class TrafficStatistics:
NODE_CLIENT = 1
NODE_SOURCE = 2
NODE_SUPPORT = 3
def __init__(self, node_type, node_id):
self.url_list = None
self.node_type = node_type
self.node_id = node_id
self.tqueue = TimedTaskQueue(nameprefix='TrafficStatTaskQueue', debug=False)
def set_url_list(self, url_list):
if DEBUG:
log('tstats::set_url_list:', url_list)
if url_list is None:
self.url_list = None
else:
self.url_list = url_list
def send_event(self, download_id, event, downloaded, uploaded, infohash, provider_key = None, provider_content_id = None):
params = {'type': str(self.node_type),
'node': self.node_id,
'd': download_id,
'e': event,
'down': str(downloaded),
'up': str(uploaded),
'infohash': infohash}
if provider_key is not None:
params['provider'] = provider_key
if provider_content_id is not None:
params['cid'] = provider_content_id
send_request_lambda = lambda : self.send_request(params)
self.tqueue.add_task(send_request_lambda)
def send_request(self, params, timeout = 5):
if self.url_list is None:
return
get_params = []
if len(params):
for k, v in params.iteritems():
get_params.append(k + '=' + urllib.quote_plus(v))
query_string = ''
if len(get_params):
query_string = '?' + '&'.join(get_params)
if DEBUG:
log('tstats::send_request: query_string', query_string)
for url in self.url_list['default']:
try:
url += query_string
if DEBUG:
log('tstats::send_request: url', url)
stream = urlOpenTimeout(url, timeout=timeout)
stream.read()
stream.close()
except:
if DEBUG:
log('tstats::send_request: failed: url', url)
def __init__(self):
if OverlayThreadingBridge.__single:
raise RuntimeError, 'OverlayThreadingBridge is Singleton'
OverlayThreadingBridge.__single = self
self.secover = None
self.olapps = None
self.olappsmsghandler = None
self.olappsconnhandler = None
self.tqueue = TimedTaskQueue(nameprefix='Overlay')
def __init__(self, node_type, node_id):
self.url_list = None
self.node_type = node_type
self.node_id = node_id
self.tqueue = TimedTaskQueue(nameprefix='TrafficStatTaskQueue', debug=False)
def __init__(self,
url_list,
options,
uid,
cookie_jar,
tdef,
player_data=None):
self.url_list = url_list
self.uid = uid
self.cookie_jar = cookie_jar
self.version = 'ts' + VERSION + '-' + VERSION_REV
self.screen_size = self.get_screen_size()
if options is None:
self.send_online_interval = TNS.DEFAULT_ONLINE_INTERVAL
self.allowed_content_types = TNS.DEFAULT_CONTENT_TYPES
self.only_license = True
else:
try:
i = int(options.get('only_license', 1))
self.only_license = i != 0
except:
self.only_license = True
try:
self.send_online_interval = int(
options.get('online_interval',
TNS.DEFAULT_ONLINE_INTERVAL))
except:
self.send_online_interval = 0
self.allowed_content_types = options.get('allowed_content_types',
TNS.DEFAULT_CONTENT_TYPES)
if not isinstance(self.allowed_content_types, list):
self.allowed_content_types = []
if tdef.get_live():
self.content_type = TNS.TYPE_LIVE
else:
self.content_type = TNS.TYPE_VOD
if self.content_type not in self.allowed_content_types:
if DEBUG:
log('tns::__init__: not allowed: content_type',
self.content_type, 'allowed', self.allowed_content_types)
raise TNSNotAllowedException
self.player_id = self.get_random()
self.session_id = self.get_random()
self.content_id = None
if tdef.get_tns_enabled():
provider_key = tdef.get_provider()
if provider_key is not None:
provider_content_id = tdef.get_content_id()
if provider_content_id is None:
provider_content_id = ''
try:
name = tdef.get_name_as_unicode()
name = name.encode('utf-8')
except:
if DEBUG:
print_exc()
name = ''
s = hashlib.sha1(provider_key + provider_key[0:4]).hexdigest()
provider_key = s[:10] + '-' + s[10:20] + '-' + s[
20:30] + '-' + s[30:]
self.content_id = 'ts:' + name + ':' + provider_key + ':' + provider_content_id
if DEBUG:
log('tns::__init__: tns enabled, content id:',
self.content_id)
elif DEBUG:
log('tns::__init__: tns enabled, but missing provider key')
if self.content_id is None:
if self.only_license:
if DEBUG:
log('tns::__init__: only licensed content allowed')
raise TNSNotAllowedException
self.content_id = 'ts:user_content'
if DEBUG:
log('tns::__init__: content id:', self.content_id)
self.video_width = None
self.video_height = None
if player_data is not None:
if player_data.has_key('width'):
self.video_width = data['width']
if player_data.has_key('height'):
self.video_height = data['height']
self.play_time = 0
self.buffer_time = 0
self.online_time = 0
self.download_stopped = False
self.stopped = False
self.playing = False
self.buffering = False
self.last_buffering = 0
self.tqueue = TimedTaskQueue(nameprefix='TNSTaskQueue', debug=False)
class TNS:
DEFAULT_ONLINE_INTERVAL = 60
DEFAULT_CONTENT_TYPES = ['d', 'o']
TYPE_VOD = 'd'
TYPE_LIVE = 'o'
TYPE_RADIO = 'r'
def __init__(self,
url_list,
options,
uid,
cookie_jar,
tdef,
player_data=None):
self.url_list = url_list
self.uid = uid
self.cookie_jar = cookie_jar
self.version = 'ts' + VERSION + '-' + VERSION_REV
self.screen_size = self.get_screen_size()
if options is None:
self.send_online_interval = TNS.DEFAULT_ONLINE_INTERVAL
self.allowed_content_types = TNS.DEFAULT_CONTENT_TYPES
self.only_license = True
else:
try:
i = int(options.get('only_license', 1))
self.only_license = i != 0
except:
self.only_license = True
try:
self.send_online_interval = int(
options.get('online_interval',
TNS.DEFAULT_ONLINE_INTERVAL))
except:
self.send_online_interval = 0
self.allowed_content_types = options.get('allowed_content_types',
TNS.DEFAULT_CONTENT_TYPES)
if not isinstance(self.allowed_content_types, list):
self.allowed_content_types = []
if tdef.get_live():
self.content_type = TNS.TYPE_LIVE
else:
self.content_type = TNS.TYPE_VOD
if self.content_type not in self.allowed_content_types:
if DEBUG:
log('tns::__init__: not allowed: content_type',
self.content_type, 'allowed', self.allowed_content_types)
raise TNSNotAllowedException
self.player_id = self.get_random()
self.session_id = self.get_random()
self.content_id = None
if tdef.get_tns_enabled():
provider_key = tdef.get_provider()
if provider_key is not None:
provider_content_id = tdef.get_content_id()
if provider_content_id is None:
provider_content_id = ''
try:
name = tdef.get_name_as_unicode()
name = name.encode('utf-8')
except:
if DEBUG:
print_exc()
name = ''
s = hashlib.sha1(provider_key + provider_key[0:4]).hexdigest()
provider_key = s[:10] + '-' + s[10:20] + '-' + s[
20:30] + '-' + s[30:]
self.content_id = 'ts:' + name + ':' + provider_key + ':' + provider_content_id
if DEBUG:
log('tns::__init__: tns enabled, content id:',
self.content_id)
elif DEBUG:
log('tns::__init__: tns enabled, but missing provider key')
if self.content_id is None:
if self.only_license:
if DEBUG:
log('tns::__init__: only licensed content allowed')
raise TNSNotAllowedException
self.content_id = 'ts:user_content'
if DEBUG:
log('tns::__init__: content id:', self.content_id)
self.video_width = None
self.video_height = None
if player_data is not None:
if player_data.has_key('width'):
self.video_width = data['width']
if player_data.has_key('height'):
self.video_height = data['height']
self.play_time = 0
self.buffer_time = 0
self.online_time = 0
self.download_stopped = False
self.stopped = False
self.playing = False
self.buffering = False
self.last_buffering = 0
self.tqueue = TimedTaskQueue(nameprefix='TNSTaskQueue', debug=False)
def start(self):
if DEBUG:
log('tns::start: ---')
self.send_event('READY')
if self.send_online_interval:
self.send_online()
self.update_counters()
self.tqueue.add_task(self.send_pixel)
def stop(self):
if DEBUG:
log('tns::stop: stopped', self.stopped)
if not self.stopped:
self.send_event('STOP')
self.tqueue.add_task('quit')
self.download_stopped = True
def send_online(self):
if self.download_stopped:
if DEBUG:
log('tns::send_online: download stopped, exit')
return
try:
if self.playing and not self.buffering:
self.send_event('ONLINE')
elif self.buffering and time.time() - self.last_buffering >= 30:
self.send_event('BUFFER')
except:
if DEBUG:
print_exc()
finally:
self.tqueue.add_task(self.send_online, self.send_online_interval)
def update_counters(self):
if self.download_stopped:
if DEBUG:
log('tns::update_counters: download stopped, exit')
return
if self.playing:
self.play_time += 1
if self.buffering:
self.buffer_time += 1
self.online_time += 1
if DEBUG:
log('tns::update_counters: playing', self.playing, 'buffering',
self.buffering, 'onlinetime', self.online_time, 'playtime',
self.play_time, 'buffer_time', self.buffer_time)
self.tqueue.add_task(self.update_counters, 1)
def send_event(self, event, event_data=None, delay=0):
if DEBUG:
log('tns::send_event: event', event, 'playing', self.playing,
'stopped', self.stopped, 'download_stopped',
self.download_stopped, 'event_data', event_data, 'delay',
delay)
if self.download_stopped:
return
event = event.upper()
if event == 'PLAY':
if self.playing:
return
self.stopped = False
self.playing = True
self.buffering = False
elif event == 'BUFFER':
self.buffering = True
self.last_buffering = time.time()
elif event == 'BUFFERFULL':
self.buffering = False
elif event == 'PAUSE':
self.playing = False
self.buffering = False
elif event in ('STOP', 'COMPLETE', 'ERROR', 'CLOSE'):
if self.stopped:
return
self.stopped = True
self.playing = False
self.buffering = False
params = {
'cookie': self.uid,
'time': str(long(time.time())),
'state': event,
'value': 'http://freestream.org/local',
'version': self.version,
'pt': self.content_type,
'player_id': str(self.player_id),
'session_id': str(self.session_id),
'file': self.content_id
}
if self.screen_size is not None:
params['sw'] = str(self.screen_size[0])
params['sh'] = str(self.screen_size[1])
if self.play_time is not None:
params['playtime'] = str(self.play_time)
if self.buffer_time is not None:
params['buffertime'] = str(self.buffer_time)
if self.online_time is not None:
params['onlinetime'] = str(self.online_time)
if self.video_width is not None:
params['vw'] = str(self.video_width)
if self.video_height is not None:
params['vh'] = str(self.video_height)
if event_data is not None:
if event_data.has_key('position'):
params['position'] = str(event_data['position'])
if event.startswith('AD'):
for p in ['ads_link', 'ads_file', 'click_url']:
if event_data.get(p, None):
params[p] = event_data[p]
send_request_lambda = lambda: self.send_request(params)
self.tqueue.add_task(send_request_lambda, delay)
def send_pixel(self, timeout=5):
for url in self.url_list['pixel']:
try:
if DEBUG:
log('tns::send_pixel: url', url)
stream = urlOpenTimeout(url,
timeout=timeout,
cookiejar=self.cookie_jar)
stream.read()
stream.close()
except:
if DEBUG:
log('tns::send_pixel: failed')
def send_request(self, params, timeout=5):
try:
get_params = []
if len(params):
for k, v in params.iteritems():
get_params.append(k + '=' + urllib.quote_plus(v))
query_string = ''
if len(get_params):
query_string = '?' + '&'.join(get_params)
if DEBUG:
log('tns::send_request: query_string', query_string)
for url in self.url_list['default']:
try:
url += query_string
if DEBUG:
log('tns::send_request: url', url)
stream = urlOpenTimeout(url,
timeout=timeout,
cookiejar=self.cookie_jar)
stream.read()
stream.close()
except:
if DEBUG:
log('tns::send_request: failed: url', url)
except:
if DEBUG:
print_exc()
def get_screen_size(self):
try:
import ctypes
user32 = ctypes.windll.user32
return (user32.GetSystemMetrics(0), user32.GetSystemMetrics(1))
except:
return
def get_random(self):
rand = random.randint(1, 1000000000)
try:
d = str(long(time.time()))
return long(d[-8:]) + rand
except:
return rand
class OverlayThreadingBridge:
__single = None
lock = threading.Lock()
def __init__(self):
if OverlayThreadingBridge.__single:
raise RuntimeError, 'OverlayThreadingBridge is Singleton'
OverlayThreadingBridge.__single = self
self.secover = None
self.olapps = None
self.olappsmsghandler = None
self.olappsconnhandler = None
self.tqueue = TimedTaskQueue(nameprefix='Overlay')
def getInstance(*args, **kw):
if OverlayThreadingBridge.__single is None:
OverlayThreadingBridge.lock.acquire()
try:
if OverlayThreadingBridge.__single is None:
OverlayThreadingBridge(*args, **kw)
finally:
OverlayThreadingBridge.lock.release()
return OverlayThreadingBridge.__single
getInstance = staticmethod(getInstance)
def resetSingleton(self):
OverlayThreadingBridge.__single = None
def register_bridge(self, secover, olapps):
self.secover = secover
self.olapps = olapps
secover.register_recv_callback(self.handleMessage)
secover.register_conns_callback(self.handleConnection)
def register(self, launchmanycore, max_len):
self.secover.register(launchmanycore, max_len)
self.iplport2oc = self.secover.iplport2oc
def get_handler(self):
return self.secover
def start_listening(self):
self.secover.start_listening()
def register_recv_callback(self, callback):
self.olappsmsghandler = callback
def register_conns_callback(self, callback):
self.olappsconnhandler = callback
def handleConnection(self, exc, permid, selversion, locally_initiated, hisdns):
if DEBUG:
print >> sys.stderr, 'olbridge: handleConnection', exc, show_permid_short(permid), selversion, locally_initiated, hisdns, currentThread().getName()
def olbridge_handle_conn_func():
if DEBUG:
print >> sys.stderr, 'olbridge: handle_conn_func', exc, show_permid_short(permid), selversion, locally_initiated, hisdns, currentThread().getName()
try:
if hisdns:
self.secover.add_peer_to_db(permid, hisdns, selversion)
if self.olappsconnhandler is not None:
self.olappsconnhandler(exc, permid, selversion, locally_initiated)
except:
print_exc()
if isinstance(exc, CloseException):
self.secover.update_peer_status(permid, exc.was_auth_done())
self.tqueue.add_task(olbridge_handle_conn_func, 0)
def handleMessage(self, permid, selversion, message):
if DEBUG:
print >> sys.stderr, 'olbridge: handleMessage', show_permid_short(permid), selversion, getMessageName(message[0]), currentThread().getName()
def olbridge_handle_msg_func():
if DEBUG:
print >> sys.stderr, 'olbridge: handle_msg_func', show_permid_short(permid), selversion, getMessageName(message[0]), currentThread().getName()
try:
if self.olappsmsghandler is None:
ret = True
else:
ret = self.olappsmsghandler(permid, selversion, message)
except:
print_exc()
ret = False
if ret == False:
if DEBUG:
print >> sys.stderr, 'olbridge: olbridge_handle_msg_func closing!', show_permid_short(permid), selversion, getMessageName(message[0]), currentThread().getName()
self.close(permid)
self.tqueue.add_task(olbridge_handle_msg_func, 0)
return True
def connect_dns(self, dns, callback):
if DEBUG:
print >> sys.stderr, 'olbridge: connect_dns', dns
def olbridge_connect_dns_callback(cexc, cdns, cpermid, cselver):
if DEBUG:
print >> sys.stderr, 'olbridge: connect_dns_callback', cexc, cdns, show_permid_short(cpermid), cselver
olbridge_connect_dns_callback_lambda = lambda : callback(cexc, cdns, cpermid, cselver)
self.add_task(olbridge_connect_dns_callback_lambda, 0)
self.secover.connect_dns(dns, olbridge_connect_dns_callback)
def connect(self, permid, callback):
if DEBUG:
print >> sys.stderr, 'olbridge: connect', show_permid_short(permid), currentThread().getName()
def olbridge_connect_callback(cexc, cdns, cpermid, cselver):
if DEBUG:
print >> sys.stderr, 'olbridge: connect_callback', cexc, cdns, show_permid_short(cpermid), cselver, callback, currentThread().getName()
olbridge_connect_callback_lambda = lambda : callback(cexc, cdns, cpermid, cselver)
self.add_task(olbridge_connect_callback_lambda, 0)
self.secover.connect(permid, olbridge_connect_callback)
def send(self, permid, msg, callback):
if DEBUG:
print >> sys.stderr, 'olbridge: send', show_permid_short(permid), len(msg)
def olbridge_send_callback(cexc, cpermid):
if DEBUG:
print >> sys.stderr, 'olbridge: send_callback', cexc, show_permid_short(cpermid)
olbridge_send_callback_lambda = lambda : callback(cexc, cpermid)
self.add_task(olbridge_send_callback_lambda, 0)
self.secover.send(permid, msg, olbridge_send_callback)
def close(self, permid):
self.secover.close(permid)
def add_task(self, task, t = 0, ident = None):
self.tqueue.add_task(task, t, ident)
def __init__(self, url_list, options, uid, cookie_jar, tdef, player_data = None):
self.url_list = url_list
self.uid = uid
self.cookie_jar = cookie_jar
self.version = 'ts' + VERSION + '-' + VERSION_REV
self.screen_size = self.get_screen_size()
if options is None:
self.send_online_interval = TNS.DEFAULT_ONLINE_INTERVAL
self.allowed_content_types = TNS.DEFAULT_CONTENT_TYPES
self.only_license = True
else:
try:
i = int(options.get('only_license', 1))
self.only_license = i != 0
except:
self.only_license = True
try:
self.send_online_interval = int(options.get('online_interval', TNS.DEFAULT_ONLINE_INTERVAL))
except:
self.send_online_interval = 0
self.allowed_content_types = options.get('allowed_content_types', TNS.DEFAULT_CONTENT_TYPES)
if not isinstance(self.allowed_content_types, list):
self.allowed_content_types = []
if tdef.get_live():
self.content_type = TNS.TYPE_LIVE
else:
self.content_type = TNS.TYPE_VOD
if self.content_type not in self.allowed_content_types:
if DEBUG:
log('tns::__init__: not allowed: content_type', self.content_type, 'allowed', self.allowed_content_types)
raise TNSNotAllowedException
self.player_id = self.get_random()
self.session_id = self.get_random()
self.content_id = None
if tdef.get_tns_enabled():
provider_key = tdef.get_provider()
if provider_key is not None:
provider_content_id = tdef.get_content_id()
if provider_content_id is None:
provider_content_id = ''
try:
name = tdef.get_name_as_unicode()
name = name.encode('utf-8')
except:
if DEBUG:
print_exc()
name = ''
s = hashlib.sha1(provider_key + provider_key[0:4]).hexdigest()
provider_key = s[:10] + '-' + s[10:20] + '-' + s[20:30] + '-' + s[30:]
self.content_id = 'ts:' + name + ':' + provider_key + ':' + provider_content_id
if DEBUG:
log('tns::__init__: tns enabled, content id:', self.content_id)
elif DEBUG:
log('tns::__init__: tns enabled, but missing provider key')
if self.content_id is None:
if self.only_license:
if DEBUG:
log('tns::__init__: only licensed content allowed')
raise TNSNotAllowedException
self.content_id = 'ts:user_content'
if DEBUG:
log('tns::__init__: content id:', self.content_id)
self.video_width = None
self.video_height = None
if player_data is not None:
if player_data.has_key('width'):
self.video_width = data['width']
if player_data.has_key('height'):
self.video_height = data['height']
self.play_time = 0
self.buffer_time = 0
self.online_time = 0
self.download_stopped = False
self.stopped = False
self.playing = False
self.buffering = False
self.last_buffering = 0
self.tqueue = TimedTaskQueue(nameprefix='TNSTaskQueue', debug=False)
class TNS:
DEFAULT_ONLINE_INTERVAL = 60
DEFAULT_CONTENT_TYPES = ['d', 'o']
TYPE_VOD = 'd'
TYPE_LIVE = 'o'
TYPE_RADIO = 'r'
def __init__(self, url_list, options, uid, cookie_jar, tdef, player_data = None):
self.url_list = url_list
self.uid = uid
self.cookie_jar = cookie_jar
self.version = 'ts' + VERSION + '-' + VERSION_REV
self.screen_size = self.get_screen_size()
if options is None:
self.send_online_interval = TNS.DEFAULT_ONLINE_INTERVAL
self.allowed_content_types = TNS.DEFAULT_CONTENT_TYPES
self.only_license = True
else:
try:
i = int(options.get('only_license', 1))
self.only_license = i != 0
except:
self.only_license = True
try:
self.send_online_interval = int(options.get('online_interval', TNS.DEFAULT_ONLINE_INTERVAL))
except:
self.send_online_interval = 0
self.allowed_content_types = options.get('allowed_content_types', TNS.DEFAULT_CONTENT_TYPES)
if not isinstance(self.allowed_content_types, list):
self.allowed_content_types = []
if tdef.get_live():
self.content_type = TNS.TYPE_LIVE
else:
self.content_type = TNS.TYPE_VOD
if self.content_type not in self.allowed_content_types:
if DEBUG:
log('tns::__init__: not allowed: content_type', self.content_type, 'allowed', self.allowed_content_types)
raise TNSNotAllowedException
self.player_id = self.get_random()
self.session_id = self.get_random()
self.content_id = None
if tdef.get_tns_enabled():
provider_key = tdef.get_provider()
if provider_key is not None:
provider_content_id = tdef.get_content_id()
if provider_content_id is None:
provider_content_id = ''
try:
name = tdef.get_name_as_unicode()
name = name.encode('utf-8')
except:
if DEBUG:
print_exc()
name = ''
s = hashlib.sha1(provider_key + provider_key[0:4]).hexdigest()
provider_key = s[:10] + '-' + s[10:20] + '-' + s[20:30] + '-' + s[30:]
self.content_id = 'ts:' + name + ':' + provider_key + ':' + provider_content_id
if DEBUG:
log('tns::__init__: tns enabled, content id:', self.content_id)
elif DEBUG:
log('tns::__init__: tns enabled, but missing provider key')
if self.content_id is None:
if self.only_license:
if DEBUG:
log('tns::__init__: only licensed content allowed')
raise TNSNotAllowedException
self.content_id = 'ts:user_content'
if DEBUG:
log('tns::__init__: content id:', self.content_id)
self.video_width = None
self.video_height = None
if player_data is not None:
if player_data.has_key('width'):
self.video_width = data['width']
if player_data.has_key('height'):
self.video_height = data['height']
self.play_time = 0
self.buffer_time = 0
self.online_time = 0
self.download_stopped = False
self.stopped = False
self.playing = False
self.buffering = False
self.last_buffering = 0
self.tqueue = TimedTaskQueue(nameprefix='TNSTaskQueue', debug=False)
def start(self):
if DEBUG:
log('tns::start: ---')
self.send_event('READY')
if self.send_online_interval:
self.send_online()
self.update_counters()
self.tqueue.add_task(self.send_pixel)
def stop(self):
if DEBUG:
log('tns::stop: stopped', self.stopped)
if not self.stopped:
self.send_event('STOP')
self.tqueue.add_task('quit')
self.download_stopped = True
def send_online(self):
if self.download_stopped:
if DEBUG:
log('tns::send_online: download stopped, exit')
return
try:
if self.playing and not self.buffering:
self.send_event('ONLINE')
elif self.buffering and time.time() - self.last_buffering >= 30:
self.send_event('BUFFER')
except:
if DEBUG:
print_exc()
finally:
self.tqueue.add_task(self.send_online, self.send_online_interval)
def update_counters(self):
if self.download_stopped:
if DEBUG:
log('tns::update_counters: download stopped, exit')
return
if self.playing:
self.play_time += 1
if self.buffering:
self.buffer_time += 1
self.online_time += 1
if DEBUG:
log('tns::update_counters: playing', self.playing, 'buffering', self.buffering, 'onlinetime', self.online_time, 'playtime', self.play_time, 'buffer_time', self.buffer_time)
self.tqueue.add_task(self.update_counters, 1)
def send_event(self, event, event_data = None, delay = 0):
if DEBUG:
log('tns::send_event: event', event, 'playing', self.playing, 'stopped', self.stopped, 'download_stopped', self.download_stopped, 'event_data', event_data, 'delay', delay)
if self.download_stopped:
return
event = event.upper()
if event == 'PLAY':
if self.playing:
return
self.stopped = False
self.playing = True
self.buffering = False
elif event == 'BUFFER':
self.buffering = True
self.last_buffering = time.time()
elif event == 'BUFFERFULL':
self.buffering = False
elif event == 'PAUSE':
self.playing = False
self.buffering = False
elif event in ('STOP', 'COMPLETE', 'ERROR', 'CLOSE'):
if self.stopped:
return
self.stopped = True
self.playing = False
self.buffering = False
params = {'cookie': self.uid,
'time': str(long(time.time())),
'state': event,
'value': 'http://freestream.org/local',
'version': self.version,
'pt': self.content_type,
'player_id': str(self.player_id),
'session_id': str(self.session_id),
'file': self.content_id}
if self.screen_size is not None:
params['sw'] = str(self.screen_size[0])
params['sh'] = str(self.screen_size[1])
if self.play_time is not None:
params['playtime'] = str(self.play_time)
if self.buffer_time is not None:
params['buffertime'] = str(self.buffer_time)
if self.online_time is not None:
params['onlinetime'] = str(self.online_time)
if self.video_width is not None:
params['vw'] = str(self.video_width)
if self.video_height is not None:
params['vh'] = str(self.video_height)
if event_data is not None:
if event_data.has_key('position'):
params['position'] = str(event_data['position'])
if event.startswith('AD'):
for p in ['ads_link', 'ads_file', 'click_url']:
if event_data.get(p, None):
params[p] = event_data[p]
send_request_lambda = lambda : self.send_request(params)
self.tqueue.add_task(send_request_lambda, delay)
def send_pixel(self, timeout = 5):
for url in self.url_list['pixel']:
try:
if DEBUG:
log('tns::send_pixel: url', url)
stream = urlOpenTimeout(url, timeout=timeout, cookiejar=self.cookie_jar)
stream.read()
stream.close()
except:
if DEBUG:
log('tns::send_pixel: failed')
def send_request(self, params, timeout = 5):
try:
get_params = []
if len(params):
for k, v in params.iteritems():
get_params.append(k + '=' + urllib.quote_plus(v))
query_string = ''
if len(get_params):
query_string = '?' + '&'.join(get_params)
if DEBUG:
log('tns::send_request: query_string', query_string)
for url in self.url_list['default']:
try:
url += query_string
if DEBUG:
log('tns::send_request: url', url)
stream = urlOpenTimeout(url, timeout=timeout, cookiejar=self.cookie_jar)
stream.read()
stream.close()
except:
if DEBUG:
log('tns::send_request: failed: url', url)
except:
if DEBUG:
print_exc()
def get_screen_size(self):
try:
import ctypes
user32 = ctypes.windll.user32
return (user32.GetSystemMetrics(0), user32.GetSystemMetrics(1))
except:
return
def get_random(self):
rand = random.randint(1, 1000000000)
try:
d = str(long(time.time()))
return long(d[-8:]) + rand
except:
return rand
def __init__(self, node_type, node_id):
self.url_list = None
self.node_type = node_type
self.node_id = node_id
self.tqueue = TimedTaskQueue(nameprefix='TrafficStatTaskQueue',
debug=False)
class TrafficStatistics:
NODE_CLIENT = 1
NODE_SOURCE = 2
NODE_SUPPORT = 3
def __init__(self, node_type, node_id):
self.url_list = None
self.node_type = node_type
self.node_id = node_id
self.tqueue = TimedTaskQueue(nameprefix='TrafficStatTaskQueue',
debug=False)
def set_url_list(self, url_list):
if DEBUG:
log('tstats::set_url_list:', url_list)
if url_list is None:
self.url_list = None
else:
self.url_list = url_list
def send_event(self,
download_id,
event,
downloaded,
uploaded,
infohash,
provider_key=None,
provider_content_id=None):
params = {
'type': str(self.node_type),
'node': self.node_id,
'd': download_id,
'e': event,
'down': str(downloaded),
'up': str(uploaded),
'infohash': infohash
}
if provider_key is not None:
params['provider'] = provider_key
if provider_content_id is not None:
params['cid'] = provider_content_id
send_request_lambda = lambda: self.send_request(params)
self.tqueue.add_task(send_request_lambda)
def send_request(self, params, timeout=5):
if self.url_list is None:
return
get_params = []
if len(params):
for k, v in params.iteritems():
get_params.append(k + '=' + urllib.quote_plus(v))
query_string = ''
if len(get_params):
query_string = '?' + '&'.join(get_params)
if DEBUG:
log('tstats::send_request: query_string', query_string)
for url in self.url_list['default']:
try:
url += query_string
if DEBUG:
log('tstats::send_request: url', url)
stream = urlOpenTimeout(url, timeout=timeout)
stream.read()
stream.close()
except:
if DEBUG:
log('tstats::send_request: failed: url', url)
