def __init__(self, downloader, connection):
SingleDownloadHelperInterface.__init__(self)
self.downloader = downloader
self.connection = connection
self.choked = True
self.interested = False
self.active_requests = []
self.measure = Measure(downloader.max_rate_period)
self.peermeasure = Measure(downloader.max_rate_period)
self.raw_have = Bitfield(downloader.numpieces)
self.have = Bitfield(downloader.numpieces)
self.last = -1000
self.last2 = -1000
self.example_interest = None
self.backlog = 2
self.ip = connection.get_ip()
self.guard = BadDataGuard(self)
self.app_mode = globalConfig.get_mode()
self.white_list = None
self.black_list = None
self.app_mode = globalConfig.get_mode()
if self.app_mode == 'node':
source_node = globalConfig.get_value('source_node')
support_nodes = globalConfig.get_value('support_nodes')
if not globalConfig.get_value('allow_peers_download'):
self.white_list = set()
if source_node is not None and globalConfig.get_value(
'allow_source_download'):
self.white_list.add(source_node[0])
if len(support_nodes) and globalConfig.get_value(
'allow_support_download'):
self.white_list.update([addr[0] for addr in support_nodes])
else:
self.black_list = set()
if source_node is not None and not globalConfig.get_value(
'allow_source_download'):
self.black_list.add(source_node[0])
if len(support_nodes) and not globalConfig.get_value(
'allow_support_download'):
self.black_list.update([addr[0] for addr in support_nodes])
if len(self.black_list) == 0:
self.black_list = None
if DEBUG:
log('download::__init__: white_list', self.white_list,
'black_list', self.black_list)
self.helper = downloader.picker.helper
self.proxy_have = Bitfield(downloader.numpieces)
self.short_term_measure = Measure(5)
self.bad_performance_counter = 0
def __init__(self, stream, bt1download, authconfig, restartstatefilename):
self.stream = stream
self.bt1download = bt1download
self.restartstatefilename = restartstatefilename
self.exiting = False
self.ratemeasure = Measure(30)
self.storagewrapper = bt1download.storagewrapper
self.picker = bt1download.picker
self.rawserver = bt1download.rawserver
self.connecter = bt1download.connecter
self.fileselector = bt1download.fileselector
self.videostatus = bt1download.videostatus
self.buffer = []
self.buflen = 0
self.bufferlock = RLock()
self.handling_pieces = False
self.readlastseqnum = False
if authconfig.get_method() == LIVE_AUTHMETHOD_ECDSA:
self.authenticator = ECDSAAuthenticator(
self.videostatus.piecelen,
self.bt1download.len_pieces,
keypair=authconfig.get_keypair())
elif authconfig.get_method() == LIVE_AUTHMETHOD_RSA:
self.authenticator = RSAAuthenticator(
self.videostatus.piecelen,
self.bt1download.len_pieces,
keypair=authconfig.get_keypair())
else:
self.authenticator = NullAuthenticator(self.videostatus.piecelen,
self.bt1download.len_pieces)
def __init__(self,
infohash,
storage,
picker,
backlog,
max_rate_period,
numpieces,
chunksize,
measurefunc,
snub_time,
kickbans_ok,
kickfunc,
banfunc,
scheduler=None):
self.infohash = infohash
self.b64_infohash = b64encode(infohash)
self.storage = storage
self.picker = picker
self.backlog = backlog
self.max_rate_period = max_rate_period
self.measurefunc = measurefunc
self.totalmeasure = Measure(max_rate_period * storage.piece_length /
storage.request_size)
self.numpieces = numpieces
self.chunksize = chunksize
self.snub_time = snub_time
self.kickfunc = kickfunc
self.banfunc = banfunc
self.disconnectedseeds = {}
self.downloads = []
self.perip = {}
self.gotbaddata = {}
self.kicked = {}
self.banned = {}
self.kickbans_ok = kickbans_ok
self.kickbans_halted = False
self.super_seeding = False
self.endgamemode = False
self.endgame_queued_pieces = []
self.all_requests = []
self.discarded = 0L
self.download_rate = 0
self.bytes_requested = 0
self.last_time = clock()
self.queued_out = {}
self.requeueing = False
self.paused = False
self.scheduler = scheduler
self.scheduler(self.dlr_periodic_check, 1)
if self.picker is not None:
if self.picker.helper is not None:
self.picker.helper.set_downloader(self)
def __init__(self, url, dlhash, rawserver, failed_func, max_errors=10):
if DEBUG:
log('dd-downloader::__init__: url', url, 'hash',
binascii.hexlify(dlhash))
self.url = url
self.rawserver = rawserver
self.failed_func = failed_func
self.final_url = None
self.storage = None
self.lock = Lock()
self.measure = Measure(10.0)
self.errors = 0
self.max_errors = max_errors
self.seek = None
self.shutdown_flag = False
self.running = False
self.log_prefix = 'dd-downloader::' + binascii.hexlify(dlhash) + ':'
def __init__(self, downloader, url):
SingleDownloadHelperInterface.__init__(self)
self.downloader = downloader
self.baseurl = url
try:
self.scheme, self.netloc, path, pars, query, fragment = urlparse(url)
except:
self.downloader.errorfunc('cannot parse http seed address: ' + url)
return
if self.scheme != 'http':
self.downloader.errorfunc('http seed url not http: ' + url)
return
self.proxyhost = find_proxy(url)
try:
if self.proxyhost is None:
self.connection = HTTPConnection(self.netloc)
else:
self.connection = HTTPConnection(self.proxyhost)
except:
self.downloader.errorfunc('cannot connect to http seed: ' + url)
return
self.seedurl = path
if pars:
self.seedurl += ';' + pars
self.seedurl += '?'
if query:
self.seedurl += query + '&'
self.seedurl += 'info_hash=' + urllib.quote(self.downloader.infohash)
self.measure = Measure(downloader.max_rate_period)
self.index = None
self.url = ''
self.requests = []
self.request_size = 0
self.endflag = False
self.error = None
self.retry_period = 30
self._retry_period = None
self.errorcount = 0
self.goodseed = False
self.active = False
self.cancelled = False
self.resched(randint(2, 10))
def __init__(self, connection, ratelimiter, totalup, choker, storage,
picker, config):
self.connection = connection
self.ratelimiter = ratelimiter
self.totalup = totalup
self.choker = choker
self.storage = storage
self.picker = picker
self.config = config
self.max_slice_length = config['max_slice_length']
self.choked = True
self.cleared = True
self.interested = False
self.super_seeding = False
self.buffer = []
self.measure = Measure(config['max_rate_period'],
config['upload_rate_fudge'])
self.was_ever_interested = False
if storage.get_amount_left() == 0:
if choker.super_seed:
self.super_seeding = True
self.seed_have_list = []
self.skipped_count = 0
elif config['breakup_seed_bitfield']:
bitfield, msgs = storage.get_have_list_cloaked()
connection.send_bitfield(bitfield)
for have in msgs:
connection.send_have(have)
else:
connection.send_bitfield(storage.get_have_list())
elif storage.do_I_have_anything():
connection.send_bitfield(storage.get_have_list())
self.piecedl = None
self.piecebuf = None
self.hashlist = []
def __init__(self, stream):
self.stream = stream
self.ratemeasure = Measure(30)
