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)