Exemple #1
0
 def set_hostname(self):
     ''' This method is used to get the hostname of the cache,
         which is used by the cache_local mode of the NeighborSelection.
     '''
     
     own_ip = self.session.get_external_ip()
     hostname = socket.gethostbyaddr(own_ip)
     NeighborSelection.getInstance().set_cache_hostname(hostname)
Exemple #2
0
    def testFillUp(self):
        '''
        Check that the locality cut-off for a sorted list works fine!
        '''
        ns = NeighborSelection.NeighborSelection()

        ranked = range(1, 20)
        biased = ns._fillUp(ranked, -1, locality_pref=1)
        assert ranked == biased[0:len(ranked
                                      )], "locality_pref = 1, biased=" + biased

        # Now test cut-off
        biased = ns._fillUp(ranked, 6, locality_pref=1)
        assert len(
            biased) == 6, "locality_pref = 1, biased and cut to 6=" + biased
        assert ranked[0:6] == biased, "expect %s result %s" % (ranked[0:6],
                                                               biased)

        ranked = range(1, 16)
        biased = ns._fillUp(ranked, -1, locality_pref=0)
        assert set(ranked) == set(
            biased), "locality_pref = 0, biased=%s" % biased

        ranked = range(0, 20)
        biased = ns._fillUp(ranked, -1, locality_pref=0.25)
        assert len(ranked) == len(biased)
        assert set(ranked[0:5]) == set(
            biased[0:5]
        ), "locality_pref = 0.25, biased=" + biased  #first quarter -> only ranked ranks
    def __init__(self, trackerlist, interval, sched, howmany, minpeers, 
            connect, externalsched, amount_left, up, down, 
            port, ip, myid, infohash, timeout, errorfunc, excfunc, 
            maxpeers, doneflag, upratefunc, downratefunc, 
            unpauseflag = fakeflag(True), config=None):

        self.excfunc = excfunc
        newtrackerlist = []        
        for tier in trackerlist:
            if len(tier) > 1:
                shuffle(tier)
            newtrackerlist += [tier]
        self.trackerlist = newtrackerlist
        self.lastsuccessful = ''
        self.rejectedmessage = 'rejected by tracker - '
        self.port = port
        
        if DEBUG:
            print >>sys.stderr,"Rerequest tracker: infohash is",`infohash`,"port is",self.port,"myid",`myid`,"quoted id",quote(myid)

        self.url = ('?info_hash=%s&peer_id=%s&port=%s' %
            (quote(infohash), quote(myid), str(port)))
        self.ip = ip
        self.interval = interval
        self.last = None
        self.trackerid = None
        self.announce_interval = 1 * 60
        self.sched = sched
        self.howmany = howmany
        self.minpeers = minpeers
        self.connect = connect
        self.externalsched = externalsched
        self.amount_left = amount_left
        self.up = up
        self.down = down
        self.timeout = timeout
        self.errorfunc = errorfunc
        self.maxpeers = maxpeers
        self.doneflag = doneflag
        self.upratefunc = upratefunc
        self.downratefunc = downratefunc
        self.unpauseflag = unpauseflag
        self.last_failed = True
        self.never_succeeded = True
        self.errorcodes = {}
        self.lock = SuccessLock()
        self.special = None
        self.started = False
        self.stopped = False
        self.schedid = 'arno481'
        self.infohash = infohash
        self.dht = mainlineDHT.dht
        self.config = config
        
        # SmoothIT_
        self.neighborselection = NeighborSelection.getInstance()
        self.logger = logging.getLogger("Tribler.Rerequester")
Exemple #4
0
 def _init_before_session(self):
     self.ranking = RankingPolicy.selectRankingSource(self._cache_config.get_ranking_source(),
                                                 conf=self._cache_config)
     self._logger.warning("Ranking source is %s" % self.ranking)
     
     exclude_below = 1# allow only non-remote connections!
     self.filtering = NeighborSelection.createMechanism(self._cache_config.get_ns_mode(),
                                                         self.ranking,
                                                         exclude_below=exclude_below,
                                                         locality_pref=self._cache_config.get_locality_preference())
     self._logger.warning("Neighbor selection is %s" % self.filtering)
     self.max_downloads = self._cache_config.get_max_downloads()
Exemple #5
0
    def testNone(self):

        mech = NeighborSelection.NoFiltering()
        assert mech.acceptAsNeighbor(('209.34.91.45', 12345))

        iplist = [('209.34.91.45', 123), ('209.34.91.44', 123),
                  ('209.34.91.47', 123), ('81.19.23.42', 123)]
        sorted = mech.selectAsNeighbors(iplist)
        assert iplist == sorted

        sorted = mech.selectAsNeighbors(iplist, 3)
        assert iplist[0:3] == sorted, "original %s, \nselected %s" % (str(
            iplist[0:3]), str(sorted))
 def testMechanismCreation(self):
     self.assertEquals(NeighborSelection.ns_instance(), None)
     
     mech = NeighborSelection.getInstance()
     assert isinstance(NeighborSelection.ns_instance(), NeighborSelection.NoFiltering)
     
     mech2 = NeighborSelection.createMechanism("none")
     assert isinstance(mech2, NeighborSelection.NoFiltering)
     assert mech<>mech2
     assert NeighborSelection.ns_instance() is mech2
     
     local = NeighborSelection.createMechanism("enable", rankingSource = OddEvenPolicy())
     self.assertTrue(isinstance(local, NeighborSelection.SISFiltering))
     self.assertEquals(NeighborSelection.ns_instance(), local)
Exemple #7
0
    def testMechanismCreation(self):
        self.assertEquals(NeighborSelection.ns_instance(), None)

        mech = NeighborSelection.getInstance()
        assert isinstance(NeighborSelection.ns_instance(),
                          NeighborSelection.NoFiltering)

        mech2 = NeighborSelection.createMechanism("none")
        assert isinstance(mech2, NeighborSelection.NoFiltering)
        assert mech <> mech2
        assert NeighborSelection.ns_instance() is mech2

        local = NeighborSelection.createMechanism(
            "enable", rankingSource=OddEvenPolicy())
        self.assertTrue(isinstance(local, NeighborSelection.SISFiltering))
        self.assertEquals(NeighborSelection.ns_instance(), local)
    def __init__(self,
                 trackerlist,
                 interval,
                 sched,
                 howmany,
                 minpeers,
                 connect,
                 externalsched,
                 amount_left,
                 up,
                 down,
                 port,
                 ip,
                 myid,
                 infohash,
                 timeout,
                 errorfunc,
                 excfunc,
                 maxpeers,
                 doneflag,
                 upratefunc,
                 downratefunc,
                 unpauseflag=fakeflag(True),
                 config=None):

        self.excfunc = excfunc
        newtrackerlist = []
        for tier in trackerlist:
            if len(tier) > 1:
                shuffle(tier)
            newtrackerlist += [tier]
        self.trackerlist = newtrackerlist
        self.lastsuccessful = ''
        self.rejectedmessage = 'rejected by tracker - '
        self.port = port

        if DEBUG:
            print >> sys.stderr, "Rerequest tracker: infohash is", ` infohash `, "port is", self.port, "myid", ` myid `, "quoted id", quote(
                myid)

        self.url = ('?info_hash=%s&peer_id=%s&port=%s' %
                    (quote(infohash), quote(myid), str(port)))
        self.ip = ip
        self.interval = interval
        self.last = None
        self.trackerid = None
        self.announce_interval = 1 * 60
        self.sched = sched
        self.howmany = howmany
        self.minpeers = minpeers
        self.connect = connect
        self.externalsched = externalsched
        self.amount_left = amount_left
        self.up = up
        self.down = down
        self.timeout = timeout
        self.errorfunc = errorfunc
        self.maxpeers = maxpeers
        self.doneflag = doneflag
        self.upratefunc = upratefunc
        self.downratefunc = downratefunc
        self.unpauseflag = unpauseflag
        self.last_failed = True
        self.never_succeeded = True
        self.errorcodes = {}
        self.lock = SuccessLock()
        self.special = None
        self.started = False
        self.stopped = False
        self.schedid = 'arno481'
        self.infohash = infohash
        self.dht = mainlineDHT.dht
        self.config = config

        # SmoothIT_
        self.neighborselection = NeighborSelection.getInstance()
        self.logger = logging.getLogger("Tribler.Rerequester")
Exemple #9
0
    def _setup_client(self):
        def setup_directories():
            if not os.access(self._config.get_directory(), os.F_OK):
                os.mkdir(self._config.get_directory())
            if self._config.get_state_directory():
                if not os.access(self._config.get_state_directory(), os.F_OK):
                    os.mkdir(self._config.get_state_directory())
            else:
                state_dir = tempfile.mkdtemp()
                self._config.set_state_directory(state_dir)

        def setup_scfg():
            scfg = SessionStartupConfig()
            scfg.set_state_dir(self._config.get_state_directory())
            scfg.set_listen_port(self._config.get_port())
            scfg.set_overlay(False)
            scfg.set_megacache(False)
            scfg.set_upnp_mode(UPNPMODE_DISABLED)
            return scfg

        def setup_callback_handlers(session, scfg):
            self._handlers = PeerCallbackHandlers(
                self._get_name(), self._config.get_report_interval())
            self._handlers.register_handler(PeerReporter(self._get_name()))
            self._handlers.register_handler(
                ClientStatistics(self._config.get_directory(),
                                 self._config.get_id()))

            if self._config.is_hap_enabled():
                self._logger.info("HAP support enabled")
                self._handlers.register_handler(ClientHAPHandler(self._config))

            if self._config.get_sis_url() != None:
                ip_addr = net_utils.get_own_ip_addr()
                self._handlers.register_handler(
                    PeerActivityReportEmitter(
                        (ip_addr, self._config.get_port()),
                        self._config.get_activity_report_interval(),
                        sis_iop_endpoint_url=self._config.get_sis_iop_url()))

            if self._config.get_exit_on() == constants.EXIT_ON_ALL_FINISHED:
                self._handlers.register_handler(
                    ClientUptimeHandler(session,
                                        method=constants.EXIT_ON_ALL_FINISHED,
                                        callback=self._on_exit))
            elif self._config.get_exit_on() == constants.EXIT_ON_PLAYBACK_DONE:
                self._handlers.register_handler(
                    ClientUptimeHandler(session,
                                        method=constants.EXIT_ON_PLAYBACK_DONE,
                                        callback=self._on_exit))
            elif self._config.get_exit_on() == constants.EXIT_ON_SEEDING_TIME:
                self._handlers.register_handler(
                    ClientUptimeHandler(
                        session,
                        method=constants.EXIT_ON_SEEDING_TIME,
                        max_seeding_time=self._config.get_seeding_time(),
                        callback=self._on_exit))

            if self._config.get_report_to() is not None:
                if self._config.get_report_to() == 'local_report':
                    self._local_reporter = PeerLocalReporter(
                        self._get_name(), self._config.get_id(), session,
                        self._config.get_directory())
                    self._handlers.register_handler(self._local_reporter)
                else:
                    self._handlers.register_handler(
                        PeerHTTPReporter(
                            self._get_name(),
                            self._config.get_id(),
                            self._config.get_report_to(),
                            scfg,
                            self._config.get_compress_xml_reports(),
                            self._config.get_serialization_method(),
                            report_interval=self._config.get_report_interval())
                    )

        setup_directories()
        self._logger.info("Client directory is at %s" %
                          self._config.get_directory())
        self._logger.info("Client state directory is at %s" %
                          self._config.get_state_directory())
        scfg = setup_scfg()
        self._session = Session(scfg)
        self._session.set_supporter_seed(
            self._config.is_supporter_seed())  #TODO: parameterize!!!
        self._logger.error("Supporter IPs are: " +
                           self._config.get_supporter_ip())
        self._session.set_supporter_ips(self._config.get_supporter_ip())
        setup_callback_handlers(self._session, scfg)

        source = self._config.get_ranking_source()
        endpoint = self._config.get_sis_client_endpoint()
        ranking = RankingPolicy.selectRankingSource(source, conf=self._config)
        NeighborSelection.createMechanism(
            self._config.get_ns_mode(),
            ranking,
            locality_pref=self._config.get_locality_preference())
        BiasedUnchoking.BiasedUnchoking(self._config.get_peer_selection_mode(),
                                        ranking)
 def _setup_client(self):
     def setup_directories():
         if not os.access(self._config.get_directory(), os.F_OK):
             os.mkdir(self._config.get_directory())
         if self._config.get_state_directory():
             if not os.access(self._config.get_state_directory(), os.F_OK):
                 os.mkdir(self._config.get_state_directory())
         else:
             state_dir = tempfile.mkdtemp()
             self._config.set_state_directory(state_dir)
     
     def setup_scfg():
         scfg = SessionStartupConfig()
         scfg.set_state_dir(self._config.get_state_directory())
         scfg.set_listen_port(self._config.get_port())
         scfg.set_overlay(False)
         scfg.set_megacache(False)
         scfg.set_upnp_mode(UPNPMODE_DISABLED)
         return scfg
     
     def setup_callback_handlers(session, scfg):
         self._handlers = PeerCallbackHandlers(self._get_name(), self._config.get_report_interval())
         self._handlers.register_handler(PeerReporter(self._get_name()))
         self._handlers.register_handler(ClientStatistics(self._config.get_directory(),
                                                    self._config.get_id()))
         
         if self._config.is_hap_enabled():
             self._logger.info("HAP support enabled")
             self._handlers.register_handler(ClientHAPHandler(self._config))
         
         if self._config.get_sis_url() != None:
             ip_addr = net_utils.get_own_ip_addr()
             self._handlers.register_handler(PeerActivityReportEmitter(
                 (ip_addr, self._config.get_port()),
                 self._config.get_activity_report_interval(),
                 sis_iop_endpoint_url=self._config.get_sis_iop_url()))
             
         if self._config.get_exit_on() == constants.EXIT_ON_ALL_FINISHED:
             self._handlers.register_handler(ClientUptimeHandler(session,
                                                           method=constants.EXIT_ON_ALL_FINISHED,
                                                           callback=self._on_exit))
         elif self._config.get_exit_on() == constants.EXIT_ON_PLAYBACK_DONE:
             self._handlers.register_handler(ClientUptimeHandler(session,
                                                           method=constants.EXIT_ON_PLAYBACK_DONE,
                                                           callback=self._on_exit))
         elif self._config.get_exit_on() == constants.EXIT_ON_SEEDING_TIME:
             self._handlers.register_handler(ClientUptimeHandler(session,
                                                           method=constants.EXIT_ON_SEEDING_TIME,
                                                           max_seeding_time=self._config.get_seeding_time(),
                                                           callback=self._on_exit))
             
         if self._config.get_report_to() is not None:
             if self._config.get_report_to() == 'local_report':
                 self._local_reporter = PeerLocalReporter(self._get_name(),
                                                      self._config.get_id(),
                                                      session,
                                                      self._config.get_directory())
                 self._handlers.register_handler(self._local_reporter)
             else:
                 self._handlers.register_handler(PeerHTTPReporter(self._get_name(),
                                                              self._config.get_id(),
                                                              self._config.get_report_to(),
                                                              scfg,
                                                              self._config.get_compress_xml_reports(),
                                                              self._config.get_serialization_method(),
                                                              report_interval=self._config.get_report_interval()))
             
     setup_directories()
     self._logger.info("Client directory is at %s" % self._config.get_directory())
     self._logger.info("Client state directory is at %s" % self._config.get_state_directory())
     scfg = setup_scfg()
     self._session = Session(scfg)
     self._session.set_supporter_seed(self._config.is_supporter_seed())#TODO: parameterize!!!
     self._logger.error("Supporter IPs are: "+self._config.get_supporter_ip())
     self._session.set_supporter_ips(self._config.get_supporter_ip())
     setup_callback_handlers(self._session, scfg)
     
     source = self._config.get_ranking_source()
     endpoint = self._config.get_sis_client_endpoint()
     ranking = RankingPolicy.selectRankingSource(source, conf=self._config)
     NeighborSelection.createMechanism(self._config.get_ns_mode(), ranking,
                                       locality_pref=self._config.get_locality_preference())
     BiasedUnchoking.BiasedUnchoking(self._config.get_peer_selection_mode(), ranking) 
Exemple #11
0
 def testOddEvenLocally(self):
     ranking = OddEvenPolicy()
     mech = NeighborSelection.SISFiltering(1.0, ranking)
     self.tryOddEvenMech(mech)