download.py

BitTorrentABC-Linux-V.2.4.3源码

                for i in x['path']:
                    n = path.join(n, i)
                files.append((n, x['length']))
                make(n)
    except OSError, e:
        failed("Couldn't allocate dir - " + str(e))
        return
    
    try:
        v,garbage = version.split(' ',1)
        garbage,v = v.split('-',1)
        v += '.'
    except:
        v = ''

    myid = 'S'
    while v != '':
        v1,v = v.split('.',1)
        try:
            v1 = int(v1)
        except:
            v1 = 0
        myid += chr(v1)
    myid += (chr(0) * (12-len(myid))) + sha(repr(time()) + ' ' + str(getpid())).digest()[-8:]
    seed(myid)
    pieces = [info['pieces'][x:x+20] for x in xrange(0, len(info['pieces']), 20)]
    rawserver = RawServer(doneflag, config['timeout_check_interval'], config['timeout'],
                          errorfunc = exchandler)
    self.rawserver = rawserver

    finflag = Event()
    self.finflag = finflag

    # PingPong : add semaphore, for allocation 1 file at a time"
    sem.acquire()
    try:
        try:
            storage = Storage(files, open, path.exists, path.getsize,
                        statusfunc, doneflag, config, failed)
            self.storage = storage
        except IOError, e:
            failed('trouble accessing files - ' + str(e))
            sem.release()   #PingPong : release semaphore
            return

        ann = [None]
        def finished(self = self, ann = ann):
            if self.config['super_seeder']:
                self._set_super_seed()
            self.finflag.set()
            self.config['round_robin_period'] = max( self.config['round_robin_period'],
                int(self.config['round_robin_period']
                    * self.response['info']['piece length']/(200000)) )
            try:
                self.storage.set_readonly()
            except (IOError, OSError), e:
                self.errorfunc('trouble setting readonly at end - ' + str(e))
            if ann[0] is not None:
                ann[0](1)
            self.finfunc()

        rm = [None]
        def data_flunked(amount, rm = rm, errorfunc = errorfunc):
            if rm[0] is not None:
                rm[0](amount)
            errorfunc('a piece failed hash check, re-downloading it')
        storagewrapper = StorageWrapper(storage, config['download_slice_size'],
            pieces, info['piece length'], finished, failed, statusfunc, doneflag,
            config['check_hashes'], data_flunked, rawserver.external_add_task,
            config, self.unpauseflag)
        self.storagewrapper = storagewrapper
    except ValueError, e:
        failed('bad data - ' + str(e))
    except IOError, e:
        failed('IOError - ' + str(e))
    if doneflag.isSet():
        sem.release()   #PingPong : release semaphore
        return

    sem.release() #PingPong : release semaphore

    e = 'maxport less than minport - no ports to check'
    for listen_port in xrange(config['minport'], config['maxport'] + 1):
        try:
            rawserver.bind(listen_port, config['bind'])
            break
        except socketerror, e:
            pass
    else:
        failed("Couldn't listen - " + str(e))
        return

    picker = PiecePicker(len(pieces), config['rarest_first_cutoff'],
                         config['rarest_first_priority_cutoff'])
    for i in xrange(len(pieces)):
        if storagewrapper.do_I_have(i):
            picker.complete(i)
    choker = Choker(config, rawserver.add_task, picker, finflag.isSet)
    self.choker = choker
    upmeasure = Measure(config['max_rate_period'],
        config['upload_rate_fudge'])
    downmeasure = Measure(config['max_rate_period'])
    def make_upload(connection, choker = choker,
            storagewrapper = storagewrapper, 
            max_slice_length = config['max_slice_length'],
            max_rate_period = config['max_rate_period'],
            fudge = config['upload_rate_fudge']):
        return Upload(connection, choker, storagewrapper, picker,
            max_slice_length, max_rate_period, fudge)
    ratemeasure = RateMeasure(storagewrapper.get_amount_left())
    rm[0] = ratemeasure.data_rejected
    downloader = Downloader(storagewrapper, picker,
        config['request_backlog'], config['max_rate_period'],
        len(pieces), downmeasure, config['snub_time'],
        ratemeasure.data_came_in)

    infohash = sha(bencode(info)).digest()
    httpdownloader = HTTPDownloader(storagewrapper, picker,
        rawserver, finflag, errorfunc, downloader, config['max_rate_period'],
        infohash, downmeasure, ratemeasure.data_came_in)
    if response.has_key('httpseeds') and not finflag.isSet():
        for u in response['httpseeds']:
            httpdownloader.make_download(u)
            
    connecter = Connecter(make_upload, downloader, choker,
        len(pieces), upmeasure, config, rawserver.add_task)
    self.connecter = connecter
    encoder = Encoder(connecter, rawserver,
        myid, config['max_message_length'], rawserver.add_task,
        config['keepalive_interval'], infohash, config)

    if response.has_key('announce-list'):
        trackerlist = response['announce-list']
    else:
        trackerlist = [[response['announce']]]

    rerequest = Rerequester(trackerlist, config['rerequest_interval'], 
        rawserver.add_task, connecter.how_many_connections, 
        config['min_peers'], encoder.start_connection, 
        rawserver.external_add_task, storagewrapper.get_amount_left, 
        upmeasure.get_total, downmeasure.get_total, listen_port, 
        config['ip'], myid, infohash, config['http_timeout'], errorfunc, 
        config['max_initiate'], doneflag)
    self.rerequest = rerequest
    ann[0] = rerequest.announce
    
    statistics = Statistics(upmeasure,downmeasure,connecter,httpdownloader,rerequest)
    if info.has_key('files'):
        statistics.set_dirstats(info['files'], len(pieces), info['piece length'])
        
    DownloaderFeedback(choker, httpdownloader, rawserver.add_task, statusfunc,
        upmeasure.get_rate, downmeasure.get_rate, ratemeasure.get_time_left, 
        ratemeasure.get_size_left, file_length, finflag,
        config['display_interval'], config['spew'], statistics)

    if not finflag.isSet():
        statusfunc(activity = 'connecting to peers')
    rerequest.d(0)
    rawserver.listen_forever(encoder)
    storage.close()
    rerequest.announce(2)

  def setUploadRate(self):
#    try:
#      def s(self = self):
#        self.connecter._uncap()
#      self.rawserver.external_add_task(s)
#    except AttributeError:
#      1
    pass

  def setConns(self, conns):
    self.config['max_uploads'] = conns
    if (conns > 30):
      self.config['max_initiate'] = conns + 10

  def setInitiate(self, initiate):
    self.config['max_initiate'] = initiate

  def getConfig(self):
    return self.config

  def getDefaults(self):
    return self.defaultargs

  def getUsageText(self):
      return self.argslistheader

  def reannounce(self, special = None):
    try:
      def r(self = self, special = special):
        if special is None:
            self.rerequest.announce()
        else:
            self.rerequest.announce(specialurl = special)
      self.rawserver.external_add_task (r)
    except AttributeError:
      1

  def getResponse(self):
   try:
    return self.response
   except:
    return None

  def Pause(self):
    try:
        self.rawserver.external_add_task(self._pausemaker, 0)
    except:
        return false
    self.whenpaused = time()
    self.unpauseflag.clear()
    return true

  def _pausemaker(self):
    self.unpauseflag.wait()   # sticks a monkey wrench in the main thread

  def Unpause(self):
    self.unpauseflag.set()
    if (time() - self.whenpaused > 60):
        def r(self = self):
            self.rerequest.announce(3)      # rerequest automatically if paused for >60 seconds
        self.rawserver.external_add_task(r)

  def set_super_seed(self):
    self.config['super_seeder'] = true
    if self.finflag.isSet() and not self.super_seeding_active:
        self.rawserver.external_add_task(self._set_super_seed)
        
  def _set_super_seed(self):
    if not self.super_seeding_active:
        self.super_seeding_active = true
        self.errorfunc('        ** SUPER-SEED OPERATION ACTIVE **\n' +
                       '  please set Max uploads so each peer gets 6-8 kB/s')
        def s(self = self):
            self.choker.set_super_seed()
        self.rawserver.external_add_task(s)
        if self.finflag.isSet():        # mode started when already finished
            def r(self = self):
                self.rerequest.announce(3)  # so after kicking everyone off, reannounce
            self.rawserver.external_add_task(r)