]>
Commit | Line | Data |
---|---|---|
b45f0e98 MT |
1 | #!/usr/bin/python |
2 | ||
31a30328 | 3 | import hashlib |
b45f0e98 MT |
4 | import json |
5 | import os | |
6 | import string | |
7 | ||
8 | import cpu | |
9 | import device | |
715ba5ac | 10 | import hypervisor |
b45f0e98 MT |
11 | |
12 | class System(object): | |
13 | ||
14 | def __init__(self): | |
15 | # find all devices | |
16 | self.devices = [] | |
17 | self.scan() | |
18 | self.cpu = cpu.CPU() | |
715ba5ac MT |
19 | self.hypervisor = hypervisor.Hypervisor() |
20 | ||
b45f0e98 MT |
21 | def profile(self): |
22 | p = { | |
23 | "public_id" : self.public_id, | |
24 | "private_id" : self.private_id, | |
25 | ||
26 | "arch" : self.arch, | |
27 | "language" : self.language, | |
28 | "release" : self.release, | |
29 | "memory" : self.memory, | |
30 | "kernel" : self.kernel, | |
31 | "root_size" : self.root_size, | |
32 | "devices" : [], | |
d8614fc3 MT |
33 | |
34 | "virtual" : self.virtual, | |
b45f0e98 MT |
35 | } |
36 | ||
37 | for device in self.devices: | |
38 | p["devices"].append({ | |
39 | "subsystem" : device.subsystem.lower(), | |
40 | "vendor" : device.vendor.lower(), | |
41 | "model" : device.model.lower(), | |
42 | "deviceclass" : device.deviceclass | |
43 | }) | |
44 | ||
45 | p["cpu"] = { | |
46 | "vendor" : self.cpu.vendor, | |
47 | "model" : self.cpu.model, | |
48 | "stepping" : self.cpu.stepping, | |
49 | "flags" : self.cpu.flags, | |
50 | "bogomips" : self.cpu.bogomips, | |
51 | "speed" : self.cpu.speed, | |
b45f0e98 MT |
52 | "family" : self.cpu.family, |
53 | "count" : self.cpu.count | |
54 | } | |
715ba5ac MT |
55 | |
56 | # Only append hypervisor information if we are virtualized. | |
57 | if self.virtual: | |
58 | p["hypervisor"] = { | |
59 | "type" : self.hypervisor.type, | |
60 | "vendor" : self.hypervisor.vendor, | |
61 | } | |
62 | ||
b45f0e98 MT |
63 | return json.dumps(p) |
64 | ||
65 | ||
66 | @property | |
67 | def arch(self): | |
68 | return os.uname()[4] | |
69 | ||
70 | @property | |
71 | def public_id(self): | |
31a30328 MT |
72 | """ |
73 | This returns a globally (hopefully) ID to identify the host | |
74 | later (by request) in the database. | |
75 | """ | |
76 | return hashlib.sha1(self._unique_id).hexdigest() | |
b45f0e98 MT |
77 | |
78 | @property | |
79 | def private_id(self): | |
31a30328 MT |
80 | """ |
81 | The private ID is built out of the _unique_id and used to | |
82 | permit a host to do changes on the database. | |
83 | ||
84 | No one could ever guess this without access to the host. | |
85 | """ | |
86 | return hashlib.sha1("%s" % reversed(self._unique_id)).hexdigest() | |
87 | ||
88 | @property | |
89 | def _unique_id(self): | |
90 | """ | |
91 | This is a helper ID which is generated out of some hardware information | |
92 | that is considered to be constant over a PC's lifetime. | |
93 | ||
94 | None of the data here is ever sent to the server. | |
95 | """ | |
96 | return "123456789" # XXX just a dummy | |
97 | ||
b45f0e98 MT |
98 | @property |
99 | def language(self): | |
b3ea53a7 MT |
100 | # Return "unknown" if settings file does not exist. |
101 | filename = "/var/ipfire/main/settings" | |
102 | if not os.path.exists(filename): | |
103 | return "unknown" | |
104 | ||
105 | with open(filename, "r") as f: | |
b45f0e98 MT |
106 | for line in f.readlines(): |
107 | key, val = line.split("=", 1) | |
108 | if key=="LANGUAGE": | |
109 | return val.strip() | |
110 | ||
111 | @property | |
112 | def release(self): | |
113 | with open("/etc/system-release", "r") as f: | |
114 | return f.read().strip() | |
115 | ||
116 | @property | |
117 | def memory(self): | |
118 | with open("/proc/meminfo", "r") as f: | |
119 | firstline = f.readline().strip() | |
120 | return firstline.split()[1] | |
121 | ||
122 | @property | |
123 | def kernel(self): | |
124 | return os.uname()[2] | |
125 | ||
126 | @property | |
127 | def root_disk(self): | |
128 | with open("/etc/mtab", "r") as f: | |
129 | dev, mountpoint, rest = f.readline().split(" ",2) | |
130 | if mountpoint == "/": | |
131 | dev = dev[5:] | |
132 | # cut off all digits at end of string | |
133 | while dev[-1] in string.digits: | |
134 | dev = dev[:-1] | |
135 | return dev | |
136 | ||
137 | @property | |
138 | def root_size(self): | |
139 | path="/sys/block/%s/size" %self.root_disk | |
140 | if not os.path.exists(path): | |
141 | return | |
142 | with open(path, "r") as f: | |
143 | return int(f.readline())*512/1024 | |
144 | ||
145 | def scan(self): | |
146 | toscan = (("/sys/bus/pci/devices", device.PCIDevice), | |
147 | ("/sys/bus/usb/devices", device.USBDevice)) | |
148 | for path, cls in toscan: | |
149 | dirlist = os.listdir(path) | |
150 | for dir in dirlist: | |
151 | self.devices.append(cls(os.path.join(path, dir))) | |
d8614fc3 MT |
152 | |
153 | @property | |
154 | def virtual(self): | |
155 | """ | |
156 | Say if the host is running in a virtual environment. | |
157 | """ | |
715ba5ac | 158 | return self.hypervisor.virtual |
b45f0e98 MT |
159 | |
160 | ||
161 | ||
162 | if __name__ == "__main__": | |
163 | s=System() | |
164 | print s.arch | |
165 | print s.language | |
166 | print s.release | |
167 | print s.memory | |
168 | print s.kernel | |
169 | print s.root_disk | |
170 | print s.root_size | |
171 | print "------------\n", s.devices, "\n------------\n" | |
172 | print s.profile() | |
173 | ||
174 | import urllib2 | |
175 | import urllib | |
176 | r = urllib2.Request("http://192.168.10.101:9001/send/%s" %s.public_id, data = urllib.urlencode({"profile" : s.profile()})) | |
5b1919ae | 177 | urllib2.urlopen(r) |