]>
Commit | Line | Data |
---|---|---|
f6e6ff79 MT |
1 | #!/usr/bin/python |
2 | ||
3 | import logging | |
4 | import math | |
5 | import socket | |
f6e6ff79 MT |
6 | |
7 | import base | |
8 | import logs | |
9 | ||
10 | class GeoIP(object): | |
4585a44d | 11 | def __init__(self, pakfire): |
f6e6ff79 MT |
12 | self.pakfire = pakfire |
13 | ||
4585a44d | 14 | self.db = self.pakfire.geoip_db |
f6e6ff79 | 15 | |
f6e6ff79 MT |
16 | def __encode_ip(self, addr): |
17 | # We get a tuple if there were proxy headers. | |
18 | addr = addr.split(", ") | |
19 | if addr: | |
20 | addr = addr[-1] | |
21 | ||
ec3177e0 MT |
22 | # ip is calculated as described in http://dev.maxmind.com/geoip/csv |
23 | try: | |
24 | a1, a2, a3, a4 = addr.split(".") | |
25 | ||
26 | a1 = int(a1) | |
27 | a2 = int(a2) | |
28 | a3 = int(a3) | |
29 | a4 = int(a4) | |
30 | except: | |
31 | return 0 | |
f6e6ff79 | 32 | |
ec3177e0 | 33 | return (16777216 * a1) + (65536 * a2) + (256 * a3) + a4 |
f6e6ff79 MT |
34 | |
35 | def get_all(self, addr): | |
36 | addr = self.__encode_ip(addr) | |
37 | ||
ec3177e0 MT |
38 | ret = self.db.get("\ |
39 | SELECT * FROM locations \ | |
40 | JOIN addresses ON addresses.location = locations.id \ | |
41 | WHERE \ | |
42 | %s BETWEEN addresses.start_ip_num AND addresses.end_ip_num \ | |
43 | LIMIT 1", addr) | |
f6e6ff79 MT |
44 | |
45 | # If location was not determinable | |
ec3177e0 | 46 | if ret and ret.latitude == 0 and ret.longitude == 0: |
f6e6ff79 MT |
47 | return None |
48 | ||
49 | return ret | |
50 | ||
51 | ||
52 | class Mirrors(base.Object): | |
53 | def get_all(self): | |
54 | mirrors = [] | |
55 | ||
56 | for mirror in self.db.query("SELECT id FROM mirrors \ | |
57 | WHERE NOT status = 'deleted' ORDER BY hostname"): | |
58 | mirror = Mirror(self.pakfire, mirror.id) | |
59 | mirrors.append(mirror) | |
60 | ||
61 | return mirrors | |
62 | ||
63 | def count(self, status=None): | |
64 | query = "SELECT COUNT(*) AS count FROM mirrors" | |
65 | args = [] | |
66 | ||
67 | if status: | |
68 | query += " WHERE status = %s" | |
69 | args.append(status) | |
70 | ||
71 | query = self.db.get(query, *args) | |
72 | ||
73 | return query.count | |
74 | ||
75 | def get_random(self, limit=None): | |
76 | query = "SELECT id FROM mirrors WHERE status = 'enabled' ORDER BY RAND()" | |
77 | args = [] | |
78 | ||
79 | if limit: | |
80 | query += " LIMIT %s" | |
81 | args.append(limit) | |
82 | ||
83 | mirrors = [] | |
84 | for mirror in self.db.query(query, *args): | |
85 | mirror = Mirror(self.pakfire, mirror.id) | |
86 | mirrors.append(mirror) | |
87 | ||
88 | return mirrors | |
89 | ||
90 | def get_by_id(self, id): | |
91 | mirror = self.db.get("SELECT id FROM mirrors WHERE id = %s", id) | |
92 | if not mirror: | |
93 | return | |
94 | ||
95 | return Mirror(self.pakfire, mirror.id) | |
96 | ||
97 | def get_by_hostname(self, hostname): | |
98 | mirror = self.db.get("SELECT id FROM mirrors WHERE NOT status = 'deleted' \ | |
99 | AND hostname = %s", hostname) | |
100 | ||
101 | if not mirror: | |
102 | return | |
103 | ||
104 | return Mirror(self.pakfire, mirror.id) | |
105 | ||
106 | def get_for_location(self, addr): | |
107 | distance = 10 | |
108 | ||
109 | # Get all mirrors in here. | |
110 | _mirrors = self.get_all() | |
111 | ||
112 | mirrors = [] | |
113 | while len(mirrors) <= 2 and distance <= 270: | |
114 | for mirror in _mirrors: | |
115 | if not mirror.enabled: | |
116 | continue | |
117 | ||
118 | if mirror in mirrors: | |
119 | continue | |
120 | ||
121 | # Cannot calc the distance for mirrors when their location is unknown. | |
122 | if mirror.location is None: | |
123 | continue | |
124 | ||
125 | if mirror.distance_to(addr) <= distance: | |
126 | mirrors.append(mirror) | |
127 | ||
128 | distance *= 1.2 | |
129 | ||
130 | return mirrors | |
131 | ||
132 | def get_history(self, limit=None, offset=None, mirror=None, user=None): | |
133 | query = "SELECT * FROM mirrors_history" | |
134 | args = [] | |
135 | ||
136 | conditions = [] | |
137 | ||
138 | if mirror: | |
139 | conditions.append("mirror_id = %s") | |
140 | args.append(mirror.id) | |
141 | ||
142 | if user: | |
143 | conditions.append("user_id = %s") | |
144 | args.append(user.id) | |
145 | ||
146 | if conditions: | |
147 | query += " WHERE %s" % " AND ".join(conditions) | |
148 | ||
149 | query += " ORDER BY time DESC" | |
150 | ||
151 | if limit: | |
152 | if offset: | |
153 | query += " LIMIT %s,%s" | |
154 | args += [offset, limit,] | |
155 | else: | |
156 | query += " LIMIT %s" | |
157 | args += [limit,] | |
158 | ||
159 | entries = [] | |
160 | for entry in self.db.query(query, *args): | |
161 | entry = logs.MirrorLogEntry(self.pakfire, entry) | |
162 | entries.append(entry) | |
163 | ||
164 | return entries | |
165 | ||
166 | ||
167 | class Mirror(base.Object): | |
168 | def __init__(self, pakfire, id): | |
169 | base.Object.__init__(self, pakfire) | |
170 | ||
171 | self.id = id | |
172 | ||
173 | # Cache. | |
174 | self._data = None | |
175 | self._location = None | |
176 | ||
177 | def __cmp__(self, other): | |
178 | return cmp(self.id, other.id) | |
179 | ||
180 | @classmethod | |
181 | def create(cls, pakfire, hostname, path="", owner=None, contact=None, user=None): | |
182 | id = pakfire.db.execute("INSERT INTO mirrors(hostname, path, owner, contact) \ | |
183 | VALUES(%s, %s, %s, %s)", hostname, path, owner, contact) | |
184 | ||
185 | mirror = cls(pakfire, id) | |
186 | mirror.log("created", user=user) | |
187 | ||
188 | return mirror | |
189 | ||
190 | def log(self, action, user=None): | |
191 | user_id = None | |
192 | if user: | |
193 | user_id = user.id | |
194 | ||
195 | self.db.execute("INSERT INTO mirrors_history(mirror_id, action, user_id, time) \ | |
196 | VALUES(%s, %s, %s, NOW())", self.id, action, user_id) | |
197 | ||
198 | @property | |
199 | def data(self): | |
200 | if self._data is None: | |
201 | self._data = \ | |
202 | self.db.get("SELECT * FROM mirrors WHERE id = %s", self.id) | |
203 | ||
204 | return self._data | |
205 | ||
206 | def set_status(self, status, user=None): | |
207 | assert status in ("enabled", "disabled", "deleted") | |
208 | ||
209 | if self.status == status: | |
210 | return | |
211 | ||
212 | self.db.execute("UPDATE mirrors SET status = %s WHERE id = %s", | |
213 | status, self.id) | |
214 | ||
215 | if self._data: | |
216 | self._data["status"] = status | |
217 | ||
218 | # Log the status change. | |
219 | self.log(status, user=user) | |
220 | ||
221 | def set_hostname(self, hostname): | |
222 | if self.hostname == hostname: | |
223 | return | |
224 | ||
225 | self.db.execute("UPDATE mirrors SET hostname = %s WHERE id = %s", | |
226 | hostname, self.id) | |
227 | ||
228 | if self._data: | |
229 | self._data["hostname"] = hostname | |
230 | ||
231 | hostname = property(lambda self: self.data.hostname, set_hostname) | |
232 | ||
233 | @property | |
234 | def path(self): | |
235 | return self.data.path | |
236 | ||
237 | def set_path(self, path): | |
238 | if self.path == path: | |
239 | return | |
240 | ||
241 | self.db.execute("UPDATE mirrors SET path = %s WHERE id = %s", | |
242 | path, self.id) | |
243 | ||
244 | if self._data: | |
245 | self._data["path"] = path | |
246 | ||
247 | path = property(lambda self: self.data.path, set_path) | |
248 | ||
249 | @property | |
250 | def url(self): | |
251 | ret = "http://%s" % self.hostname | |
252 | ||
253 | if self.path: | |
254 | path = self.path | |
255 | ||
256 | if not self.path.startswith("/"): | |
257 | path = "/%s" % path | |
258 | ||
259 | if self.path.endswith("/"): | |
260 | path = path[:-1] | |
261 | ||
262 | ret += path | |
263 | ||
264 | return ret | |
265 | ||
266 | def set_owner(self, owner): | |
267 | if self.owner == owner: | |
268 | return | |
269 | ||
270 | self.db.execute("UPDATE mirrors SET owner = %s WHERE id = %s", | |
271 | owner, self.id) | |
272 | ||
273 | if self._data: | |
274 | self._data["owner"] = owner | |
275 | ||
276 | owner = property(lambda self: self.data.owner or "", set_owner) | |
277 | ||
278 | def set_contact(self, contact): | |
279 | if self.contact == contact: | |
280 | return | |
281 | ||
282 | self.db.execute("UPDATE mirrors SET contact = %s WHERE id = %s", | |
283 | contact, self.id) | |
284 | ||
285 | if self._data: | |
286 | self._data["contact"] = contact | |
287 | ||
288 | contact = property(lambda self: self.data.contact or "", set_contact) | |
289 | ||
290 | @property | |
291 | def status(self): | |
292 | return self.data.status | |
293 | ||
294 | @property | |
295 | def enabled(self): | |
296 | return self.status == "enabled" | |
297 | ||
298 | @property | |
299 | def check_status(self): | |
300 | return self.data.check_status | |
301 | ||
302 | @property | |
303 | def last_check(self): | |
304 | return self.data.last_check | |
305 | ||
306 | @property | |
307 | def address(self): | |
308 | return socket.gethostbyname(self.hostname) | |
309 | ||
310 | @property | |
311 | def location(self): | |
312 | if self._location is None: | |
313 | self._location = self.geoip.get_all(self.address) | |
314 | ||
315 | return self._location | |
316 | ||
317 | @property | |
318 | def country_code(self): | |
319 | if self.location: | |
320 | return self.location.country_code | |
321 | ||
322 | return "UNKNOWN" | |
323 | ||
324 | @property | |
325 | def latitude(self): | |
326 | if self.location: | |
327 | return self.location.latitude | |
328 | ||
329 | return 0 | |
330 | ||
331 | @property | |
332 | def longitude(self): | |
333 | if self.location: | |
334 | return self.location.longitude | |
335 | ||
336 | return 0 | |
337 | ||
338 | def distance_to(self, addr): | |
339 | location = self.geoip.get_all(addr) | |
340 | if not location: | |
341 | return 0 | |
342 | ||
343 | #if location.country_code.lower() in self.prefer_for_countries: | |
344 | # return 0 | |
345 | ||
346 | distance_vector = ( | |
347 | self.latitude - location.latitude, | |
348 | self.longitude - location.longitude | |
349 | ) | |
350 | ||
351 | distance = 0 | |
352 | for i in distance_vector: | |
353 | distance += i**2 | |
354 | ||
355 | return math.sqrt(distance) | |
356 | ||
357 | def get_history(self, *args, **kwargs): | |
358 | kwargs["mirror"] = self | |
359 | ||
360 | return self.pakfire.mirrors.get_history(*args, **kwargs) |