[ipfire.org.git] / webapp / backend / tracker.py

#!/usr/bin/python

from __future__ import division

import random

from misc import Object

def decode_hex(s):
	ret = []
	for c in s:
		for i in range(256):
			if not c == chr(i):
				continue

			ret.append("%02x" % i)

	return "".join(ret)

class Tracker(Object):
	@property
	def tracker_id(self):
		return self.settings.get("tracker_id", "TheIPFireTorrentTracker")

	def _fuzzy_interval(self, interval, fuzz=60):
		return interval + random.randint(-fuzz, fuzz)

	@property
	def interval(self):
		return self.settings.get_int("tracker_interval", 3600)

	@property
	def min_interval(self):
		interval = self.settings.get_int("tracker_min_interval", self.interval // 2)

		return self._fuzzy_interval(interval)

	@property
	def numwant(self):
		return self.settings.get_int("tracker_numwant", 50)

	def get_peers(self, info_hash, limit=None, random=True, no_peer_id=False, ipfamily=None):
		query = "SELECT * FROM tracker WHERE last_update >= NOW() - INTERVAL '%ss'"
		args = [self.interval,]

		if info_hash:
			query += " AND hash = %s"
			args.append(info_hash)

		if random:
			query += " ORDER BY RANDOM()"

		if limit:
			query += " LIMIT %s"
			args.append(limit)

		peers = []
		for row in self.db.query(query, *args):
			peer6 = None
			peer4 = None

			if row.address6 and row.port6:
				peer6 = {
					"ip" : row.address6,
					"port" : row.port6,
				}

			if row.address4 and row.port4:
				peer4 = {
					"ip" : row.address4,
					"port" : row.port4,
				}

			if not no_peer_id:
				if peer6:
					peer6["peer id"] = row.id

				if peer4:
					peer4["peer id"] = row.id

			if peer6:
				peers.append(peer6)

			if peer4:
				peers.append(peer4)

		return peers

	def cleanup_peers(self):
		"""
			Remove all peers that have timed out.
		"""
		self.db.execute("DELETE FROM tracker \
			WHERE last_update < NOW() - INTERVAL '%ss'", self.interval + 600)

	def update_peer(self, peer_id, info_hash, address6=None, port6=None,
			address4=None, port4=None, downloaded=None, uploaded=None, left_data=None):
		if address4 and address4.startswith("172.28.1."):
			address = "178.63.73.246"

		query = "UPDATE tracker SET last_update = NOW()"
		args = []

		if address6:
			query += ", address6 = %s"
			args.append(address6)

		if port6:
			query += ", port6 = %s"
			args.append(port6)

		if address4:
			query += ", address4 = %s"
			args.append(address4)

		if port4:
			query += ", port4 = %s"
			args.append(port4)

		if downloaded:
			query += ", downloaded = %s"
			args.append(downloaded)

		if uploaded:
			query += ", uploaded = %s"
			args.append(uploaded)

		if left_data:
			query += ", left_data = %s"
			args.append(left_data)

		query += " WHERE id = %s AND hash = %s"
		args += [peer_id, info_hash]

		self.db.execute(query, *args)

	def complete(self, info_hash):
		ret = self.db.get("SELECT COUNT(*) AS c FROM tracker \
			WHERE hash = %s AND left_data = 0", info_hash)

		if ret:
			return ret.c

	def incomplete(self, info_hash):
		ret = self.db.get("SELECT COUNT(*) AS c FROM tracker \
			WHERE hash = %s AND left_data > 0", info_hash)

		if ret:
			return ret.c

	def handle_event(self, event, peer_id, info_hash, **kwargs):
		# started
		if event == "started":
			self.insert_peer(peer_id, info_hash, **kwargs)

		# stopped
		elif event == "stopped":
			self.remove_peer(peer_id, info_hash)

	def peer_exists(self, peer_id, info_hash):
		ret = self.db.get("SELECT COUNT(*) AS c FROM tracker \
			WHERE id = %s AND hash = %s", peer_id, info_hash)

		if ret and ret.c > 0:
			return True

		return False

	def insert_peer(self, peer_id, info_hash, address6=None, port6=None, address4=None, port4=None):
		exists = self.peer_exists(peer_id, info_hash)
		if exists:
			return

		self.db.execute("INSERT INTO tracker(id, hash, address6, port6, address4, port4) \
			VALUES(%s, %s, %s, %s, %s, %s)", peer_id, info_hash, address6, port6, address4, port4)

	def remove_peer(self, peer_id, info_hash):
		self.db.execute("DELETE FROM tracker \
			WHERE id = %s AND hash = %s", peer_id, info_hash)

	def scrape(self, info_hashes):
		ret = {
			"files" : {},
			"flags" : {
				"min_request_interval" : self.interval,
			}
		}

		if info_hashes:
			for info_hash in info_hashes:
				ret["files"][info_hash] = {
					"complete"   : self.complete(info_hash),
					"incomplete" : self.incomplete(info_hash),
					"downloaded" : 0,
				}

		return ret


##### This is borrowed from the bittorrent client libary #####

def decode_int(x, f):
    f += 1
    newf = x.index('e', f)
    n = int(x[f:newf])
    if x[f] == '-':
        if x[f + 1] == '0':
            raise ValueError
    elif x[f] == '0' and newf != f+1:
        raise ValueError
    return (n, newf+1)

def decode_string(x, f):
    colon = x.index(':', f)
    n = int(x[f:colon])
    if x[f] == '0' and colon != f+1:
        raise ValueError
    colon += 1
    return (x[colon:colon+n], colon+n)

def decode_list(x, f):
    r, f = [], f+1
    while x[f] != 'e':
        v, f = decode_func[x[f]](x, f)
        r.append(v)
    return (r, f + 1)

def decode_dict(x, f):
    r, f = {}, f+1
    while x[f] != 'e':
        k, f = decode_string(x, f)
        r[k], f = decode_func[x[f]](x, f)
    return (r, f + 1)

decode_func = {}
decode_func['l'] = decode_list
decode_func['d'] = decode_dict
decode_func['i'] = decode_int
decode_func['0'] = decode_string
decode_func['1'] = decode_string
decode_func['2'] = decode_string
decode_func['3'] = decode_string
decode_func['4'] = decode_string
decode_func['5'] = decode_string
decode_func['6'] = decode_string
decode_func['7'] = decode_string
decode_func['8'] = decode_string
decode_func['9'] = decode_string

def bdecode(x):
    try:
        r, l = decode_func[x[0]](x, 0)
    except (IndexError, KeyError, ValueError):
        raise Exception("not a valid bencoded string")
    if l != len(x):
        raise Exception("invalid bencoded value (data after valid prefix)")
    return r

from types import StringType, IntType, LongType, DictType, ListType, TupleType


class Bencached(object):

    __slots__ = ['bencoded']

    def __init__(self, s):
        self.bencoded = s

def encode_bencached(x,r):
    r.append(x.bencoded)

def encode_int(x, r):
    r.extend(('i', str(x), 'e'))

def encode_bool(x, r):
    if x:
        encode_int(1, r)
    else:
        encode_int(0, r)

def encode_string(x, r):
    r.extend((str(len(x)), ':', x))

def encode_list(x, r):
    r.append('l')
    for i in x:
        encode_func[type(i)](i, r)
    r.append('e')

def encode_dict(x,r):
    r.append('d')
    ilist = x.items()
    ilist.sort()
    for k, v in ilist:
        r.extend((str(len(k)), ':', k))
        encode_func[type(v)](v, r)
    r.append('e')

encode_func = {}
encode_func[Bencached] = encode_bencached
encode_func[IntType] = encode_int
encode_func[LongType] = encode_int
encode_func[StringType] = encode_string
encode_func[ListType] = encode_list
encode_func[TupleType] = encode_list
encode_func[DictType] = encode_dict

try:
    from types import BooleanType
    encode_func[BooleanType] = encode_bool
except ImportError:
    pass

def bencode(x):
    r = []
    encode_func[type(x)](x, r)
    return ''.join(r)
Commit	Line	Data
43d991f6 MT	1	#!/usr/bin/python
43d991f6 MT	2
9068dba1	3	from __future__ import division
43d991f6	4
9068dba1	5	import random
938d083d	6
9068dba1	7	from misc import Object
940227cb	8
43d991f6 MT	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
940227cb	16	ret.append("%02x" % i)
43d991f6 MT	17
	18	return "".join(ret)
	19
9068dba1 MT	20	class Tracker(Object):
	21	@property
	22	def tracker_id(self):
	23	return self.settings.get("tracker_id", "TheIPFireTorrentTracker")
479f3388	24
9068dba1 MT	25	def _fuzzy_interval(self, interval, fuzz=60):
9068dba1 MT	26	return interval + random.randint(-fuzz, fuzz)
43d991f6	27
9068dba1 MT	28	@property
	29	def interval(self):
	30	return self.settings.get_int("tracker_interval", 3600)
43d991f6	31
feb02477	32	@property
9068dba1 MT	33	def min_interval(self):
9068dba1 MT	34	interval = self.settings.get_int("tracker_min_interval", self.interval // 2)
43d991f6	35
9068dba1 MT	36	return self._fuzzy_interval(interval)
	37
	38	@property
	39	def numwant(self):
	40	return self.settings.get_int("tracker_numwant", 50)
43d991f6	41
9068dba1 MT	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,]
43d991f6	45
9068dba1 MT	46	if info_hash:
	47	query += " AND hash = %s"
	48	args.append(info_hash)
43d991f6 MT	49
43d991f6 MT	50	if random:
9068dba1	51	query += " ORDER BY RANDOM()"
43d991f6 MT	52
43d991f6 MT	53	if limit:
9068dba1 MT	54	query += " LIMIT %s"
9068dba1 MT	55	args.append(limit)
43d991f6 MT	56
43d991f6 MT	57	peers = []
9068dba1 MT	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	}
e2afbd6a MT	73
e2afbd6a MT	74	if not no_peer_id:
9068dba1 MT	75	if peer6:
9068dba1 MT	76	peer6["peer id"] = row.id
e2afbd6a	77
9068dba1	78	if peer4:
ea324f48	79	peer4["peer id"] = row.id
43d991f6	80
9068dba1 MT	81	if peer6:
9068dba1 MT	82	peers.append(peer6)
43d991f6	83
9068dba1 MT	84	if peer4:
9068dba1 MT	85	peers.append(peer4)
43d991f6	86
9068dba1	87	return peers
43d991f6	88
9068dba1 MT	89	def cleanup_peers(self):
	90	"""
	91	Remove all peers that have timed out.
	92	"""
	93	self.db.execute("DELETE FROM tracker \
ea324f48	94	WHERE last_update < NOW() - INTERVAL '%ss'", self.interval + 600)
43d991f6	95
9068dba1 MT	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"
43d991f6	100
9068dba1 MT	101	query = "UPDATE tracker SET last_update = NOW()"
9068dba1 MT	102	args = []
43d991f6	103
9068dba1 MT	104	if address6:
	105	query += ", address6 = %s"
	106	args.append(address6)
43d991f6	107
9068dba1 MT	108	if port6:
	109	query += ", port6 = %s"
	110	args.append(port6)
43d991f6	111
9068dba1 MT	112	if address4:
	113	query += ", address4 = %s"
	114	args.append(address4)
43d991f6	115
9068dba1 MT	116	if port4:
	117	query += ", port4 = %s"
	118	args.append(port4)
e2afbd6a	119
9068dba1 MT	120	if downloaded:
	121	query += ", downloaded = %s"
	122	args.append(downloaded)
e2afbd6a	123
9068dba1 MT	124	if uploaded:
	125	query += ", uploaded = %s"
	126	args.append(uploaded)
e2afbd6a	127
9068dba1 MT	128	if left_data:
	129	query += ", left_data = %s"
	130	args.append(left_data)
e2afbd6a	131
9068dba1 MT	132	query += " WHERE id = %s AND hash = %s"
9068dba1 MT	133	args += [peer_id, info_hash]
43d991f6	134
9068dba1	135	self.db.execute(query, *args)
d2a80c6e	136
9068dba1 MT	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)
43d991f6	140
9068dba1 MT	141	if ret:
9068dba1 MT	142	return ret.c
43d991f6	143
9068dba1 MT	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)
43d991f6	147
9068dba1 MT	148	if ret:
9068dba1 MT	149	return ret.c
43d991f6	150
9068dba1 MT	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)
43d991f6	155
9068dba1 MT	156	# stopped
	157	elif event == "stopped":
	158	self.remove_peer(peer_id, info_hash)
43d991f6	159
9068dba1 MT	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)
43d991f6	163
9068dba1 MT	164	if ret and ret.c > 0:
9068dba1 MT	165	return True
43d991f6	166
9068dba1	167	return False
940227cb	168
9068dba1 MT	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
43d991f6	173
9068dba1 MT	174	self.db.execute("INSERT INTO tracker(id, hash, address6, port6, address4, port4) \
9068dba1 MT	175	VALUES(%s, %s, %s, %s, %s, %s)", peer_id, info_hash, address6, port6, address4, port4)
43d991f6	176
9068dba1 MT	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)
43d991f6	180
9068dba1 MT	181	def scrape(self, info_hashes):
	182	ret = {
	183	"files" : {},
	184	"flags" : {
	185	"min_request_interval" : self.interval,
	186	}
	187	}
479f3388	188
ea324f48 MT	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	}
9068dba1 MT	196
9068dba1 MT	197	return ret
479f3388	198
43d991f6	199
43d991f6 MT	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)