webapp/backend/tracker.py

   1 #!/usr/bin/python
   2
   3 from __future__ import division
   4
   5 import random
   6
   7 from misc import Object
   8
   9 def decode_hex(s):
  10         ret = []
  11         for c in s:
  12                 for i in range(256):
  13                         if not c == chr(i):
  14                                 continue
  15
  16                         ret.append("%02x" % i)
  17
  18         return "".join(ret)
  19
  20 class Tracker(Object):
  21         @property
  22         def tracker_id(self):
  23                 return self.settings.get("tracker_id", "TheIPFireTorrentTracker")
  24
  25         def _fuzzy_interval(self, interval, fuzz=60):
  26                 return interval + random.randint(-fuzz, fuzz)
  27
  28         @property
  29         def interval(self):
  30                 return self.settings.get_int("tracker_interval", 3600)
  31
  32         @property
  33         def min_interval(self):
  34                 interval = self.settings.get_int("tracker_min_interval", self.interval // 2)
  35
  36                 return self._fuzzy_interval(interval)
  37
  38         @property
  39         def numwant(self):
  40                 return self.settings.get_int("tracker_numwant", 50)
  41
  42         def get_peers(self, info_hash, limit=None, random=True, no_peer_id=False, ipfamily=None):
  43                 query = "SELECT * FROM tracker WHERE last_update >= NOW() - INTERVAL '%ss'"
  44                 args = [self.interval,]
  45
  46                 if info_hash:
  47                         query += " AND hash = %s"
  48                         args.append(info_hash)
  49
  50                 if random:
  51                         query += " ORDER BY RANDOM()"
  52
  53                 if limit:
  54                         query += " LIMIT %s"
  55                         args.append(limit)
  56
  57                 peers = []
  58                 for row in self.db.query(query, *args):
  59                         peer6 = None
  60                         peer4 = None
  61
  62                         if row.address6 and row.port6:
  63                                 peer6 = {
  64                                         "ip" : row.address6,
  65                                         "port" : row.port6,
  66                                 }
  67
  68                         if row.address4 and row.port4:
  69                                 peer4 = {
  70                                         "ip" : row.address4,
  71                                         "port" : row.port4,
  72                                 }
  73
  74                         if not no_peer_id:
  75                                 if peer6:
  76                                         peer6["peer id"] = row.id
  77
  78                                 if peer4:
  79                                         peer4["peer id"] = row.id
  80
  81                         if peer6:
  82                                 peers.append(peer6)
  83
  84                         if peer4:
  85                                 peers.append(peer4)
  86
  87                 return peers
  88
  89         def cleanup_peers(self):
  90                 """
  91                         Remove all peers that have timed out.
  92                 """
  93                 self.db.execute("DELETE FROM tracker \
  94                         WHERE last_update < NOW() - INTERVAL '%ss'", self.interval + 600)
  95
  96         def update_peer(self, peer_id, info_hash, address6=None, port6=None,
  97                         address4=None, port4=None, downloaded=None, uploaded=None, left_data=None):
  98                 if address4 and address4.startswith("172.28.1."):
  99                         address = "178.63.73.246"
 100
 101                 query = "UPDATE tracker SET last_update = NOW()"
 102                 args = []
 103
 104                 if address6:
 105                         query += ", address6 = %s"
 106                         args.append(address6)
 107
 108                 if port6:
 109                         query += ", port6 = %s"
 110                         args.append(port6)
 111
 112                 if address4:
 113                         query += ", address4 = %s"
 114                         args.append(address4)
 115
 116                 if port4:
 117                         query += ", port4 = %s"
 118                         args.append(port4)
 119
 120                 if downloaded:
 121                         query += ", downloaded = %s"
 122                         args.append(downloaded)
 123
 124                 if uploaded:
 125                         query += ", uploaded = %s"
 126                         args.append(uploaded)
 127
 128                 if left_data:
 129                         query += ", left_data = %s"
 130                         args.append(left_data)
 131
 132                 query += " WHERE id = %s AND hash = %s"
 133                 args += [peer_id, info_hash]
 134
 135                 self.db.execute(query, *args)
 136
 137         def complete(self, info_hash):
 138                 ret = self.db.get("SELECT COUNT(*) AS c FROM tracker \
 139                         WHERE hash = %s AND left_data = 0", info_hash)
 140
 141                 if ret:
 142                         return ret.c
 143
 144         def incomplete(self, info_hash):
 145                 ret = self.db.get("SELECT COUNT(*) AS c FROM tracker \
 146                         WHERE hash = %s AND left_data > 0", info_hash)
 147
 148                 if ret:
 149                         return ret.c
 150
 151         def handle_event(self, event, peer_id, info_hash, **kwargs):
 152                 # started
 153                 if event == "started":
 154                         self.insert_peer(peer_id, info_hash, **kwargs)
 155
 156                 # stopped
 157                 elif event == "stopped":
 158                         self.remove_peer(peer_id, info_hash)
 159
 160         def peer_exists(self, peer_id, info_hash):
 161                 ret = self.db.get("SELECT COUNT(*) AS c FROM tracker \
 162                         WHERE id = %s AND hash = %s", peer_id, info_hash)
 163
 164                 if ret and ret.c > 0:
 165                         return True
 166
 167                 return False
 168
 169         def insert_peer(self, peer_id, info_hash, address6=None, port6=None, address4=None, port4=None):
 170                 exists = self.peer_exists(peer_id, info_hash)
 171                 if exists:
 172                         return
 173
 174                 self.db.execute("INSERT INTO tracker(id, hash, address6, port6, address4, port4) \
 175                         VALUES(%s, %s, %s, %s, %s, %s)", peer_id, info_hash, address6, port6, address4, port4)
 176
 177         def remove_peer(self, peer_id, info_hash):
 178                 self.db.execute("DELETE FROM tracker \
 179                         WHERE id = %s AND hash = %s", peer_id, info_hash)
 180
 181         def scrape(self, info_hashes):
 182                 ret = {
 183                         "files" : {},
 184                         "flags" : {
 185                                 "min_request_interval" : self.interval,
 186                         }
 187                 }
 188
 189                 if info_hashes:
 190                         for info_hash in info_hashes:
 191                                 ret["files"][info_hash] = {
 192                                         "complete"   : self.complete(info_hash),
 193                                         "incomplete" : self.incomplete(info_hash),
 194                                         "downloaded" : 0,
 195                                 }
 196
 197                 return ret
 198
 199
 200 ##### This is borrowed from the bittorrent client libary #####
 201
 202 def decode_int(x, f):
 203     f += 1
 204     newf = x.index('e', f)
 205     n = int(x[f:newf])
 206     if x[f] == '-':
 207         if x[f + 1] == '0':
 208             raise ValueError
 209     elif x[f] == '0' and newf != f+1:
 210         raise ValueError
 211     return (n, newf+1)
 212
 213 def decode_string(x, f):
 214     colon = x.index(':', f)
 215     n = int(x[f:colon])
 216     if x[f] == '0' and colon != f+1:
 217         raise ValueError
 218     colon += 1
 219     return (x[colon:colon+n], colon+n)
 220
 221 def decode_list(x, f):
 222     r, f = [], f+1
 223     while x[f] != 'e':
 224         v, f = decode_func[x[f]](x, f)
 225         r.append(v)
 226     return (r, f + 1)
 227
 228 def decode_dict(x, f):
 229     r, f = {}, f+1
 230     while x[f] != 'e':
 231         k, f = decode_string(x, f)
 232         r[k], f = decode_func[x[f]](x, f)
 233     return (r, f + 1)
 234
 235 decode_func = {}
 236 decode_func['l'] = decode_list
 237 decode_func['d'] = decode_dict
 238 decode_func['i'] = decode_int
 239 decode_func['0'] = decode_string
 240 decode_func['1'] = decode_string
 241 decode_func['2'] = decode_string
 242 decode_func['3'] = decode_string
 243 decode_func['4'] = decode_string
 244 decode_func['5'] = decode_string
 245 decode_func['6'] = decode_string
 246 decode_func['7'] = decode_string
 247 decode_func['8'] = decode_string
 248 decode_func['9'] = decode_string
 249
 250 def bdecode(x):
 251     try:
 252         r, l = decode_func[x[0]](x, 0)
 253     except (IndexError, KeyError, ValueError):
 254         raise Exception("not a valid bencoded string")
 255     if l != len(x):
 256         raise Exception("invalid bencoded value (data after valid prefix)")
 257     return r
 258
 259 from types import StringType, IntType, LongType, DictType, ListType, TupleType
 260
 261
 262 class Bencached(object):
 263
 264     __slots__ = ['bencoded']
 265
 266     def __init__(self, s):
 267         self.bencoded = s
 268
 269 def encode_bencached(x,r):
 270     r.append(x.bencoded)
 271
 272 def encode_int(x, r):
 273     r.extend(('i', str(x), 'e'))
 274
 275 def encode_bool(x, r):
 276     if x:
 277         encode_int(1, r)
 278     else:
 279         encode_int(0, r)
 280
 281 def encode_string(x, r):
 282     r.extend((str(len(x)), ':', x))
 283
 284 def encode_list(x, r):
 285     r.append('l')
 286     for i in x:
 287         encode_func[type(i)](i, r)
 288     r.append('e')
 289
 290 def encode_dict(x,r):
 291     r.append('d')
 292     ilist = x.items()
 293     ilist.sort()
 294     for k, v in ilist:
 295         r.extend((str(len(k)), ':', k))
 296         encode_func[type(v)](v, r)
 297     r.append('e')
 298
 299 encode_func = {}
 300 encode_func[Bencached] = encode_bencached
 301 encode_func[IntType] = encode_int
 302 encode_func[LongType] = encode_int
 303 encode_func[StringType] = encode_string
 304 encode_func[ListType] = encode_list
 305 encode_func[TupleType] = encode_list
 306 encode_func[DictType] = encode_dict
 307
 308 try:
 309     from types import BooleanType
 310     encode_func[BooleanType] = encode_bool
 311 except ImportError:
 312     pass
 313
 314 def bencode(x):
 315     r = []
 316     encode_func[type(x)](x, r)
 317     return ''.join(r)