def run(): crypto = ECCrypto() dispersy = Dispersy( StandaloneEndpoint(options["port"], options["ip"]), options["statedir"], u'dispersy.db', crypto) if not dispersy.start(): raise RuntimeError("Unable to start Dispersy") master_member = TriblerChainCommunityCrawler.get_master_members( dispersy)[0] my_member = dispersy.get_member(private_key=crypto.key_to_bin( crypto.generate_key(u"curve25519"))) TriblerChainCommunityCrawler.init_community( dispersy, master_member, my_member) self._stopping = False def signal_handler(sig, frame): msg("Received signal '%s' in %s (shutting down)" % (sig, frame)) if not self._stopping: self._stopping = True dispersy.stop().addCallback(lambda _: reactor.stop()) signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGTERM, signal_handler)
def setUp(self, annotate=True, autoload_discovery=True): """ Setup some classes and files that are used by the tests in this module. """ yield super(BaseTestChannel, self).setUp(autoload_discovery=autoload_discovery) if annotate: self.annotate(self._testMethodName, start=True) self.fake_session = MockObject() self.fake_session.get_state_dir = lambda: self.session_base_dir self.fake_session.add_observer = lambda a, b, c: False fake_notifier = MockObject() fake_notifier.add_observer = lambda a, b, c, d: False fake_notifier.notify = lambda a, b, c, d: False self.fake_session.notifier = fake_notifier self.fake_channel_community = MockObject() self.fake_channel_community.get_channel_id = lambda: 42 self.fake_channel_community.cid = 'a' * 20 self.fake_channel_community.get_channel_name = lambda: "my fancy channel" self.channel_db_handler = self.session.open_dbhandler(NTFY_CHANNELCAST) self.votecast_db_handler = self.session.open_dbhandler(NTFY_VOTECAST) self.session.get_dispersy = lambda: True self.session.lm.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir())
def setUp(self): super(TestBarterStatistics, self).setUp() self.stats = BarterStatistics() self._peer1 = "peer1" self._peer2 = "peer2" self._peer3 = "peer3" self._peer4 = "peer4" self._peer5 = "peer5" self.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir())
def setUp(self, annotate=True, autoload_discovery=True): yield super(TestBoostingManagerSysChannel, self).setUp() self.channel_db_handler = self.session.open_dbhandler(NTFY_CHANNELCAST) self.channel_db_handler._get_my_dispersy_cid = lambda: "myfakedispersyid" self.session.config.get_dispersy_enabled = lambda: True self.session.lm.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir()) self.dispersy_cid_hex = "abcd" * 9 + "0012" self.dispersy_cid = binascii.unhexlify(self.dispersy_cid_hex)
def setUp(self, autoload_discovery=True): yield super(TestCircuitDebugEndpoint, self).setUp(autoload_discovery=autoload_discovery) self.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir()) self.dispersy._database.open() master_member = DummyMember(self.dispersy, 1, "a" * 20) member = self.dispersy.get_new_member(u"curve25519") self.tunnel_community = HiddenTunnelCommunity(self.dispersy, master_member, member) self.dispersy.get_communities = lambda: [self.tunnel_community] self.session.get_dispersy_instance = lambda: self.dispersy
def setUp(self, autoload_discovery=True): yield super(TestTrustchainStatsEndpoint, self).setUp(autoload_discovery=autoload_discovery) self.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir()) self.dispersy._database.open() master_member = DummyMember(self.dispersy, 1, "a" * 20) self.member = self.dispersy.get_new_member(u"curve25519") self.tc_community = TriblerChainCommunity(self.dispersy, master_member, self.member) self.dispersy.get_communities = lambda: [self.tc_community] self.session.get_dispersy_instance = lambda: self.dispersy
def test_chn_exist_lookup(self): """ testing existing channel as a source. It also tests how boosting manager cope with unknown channel with retrying the lookup """ self.session.get_dispersy = lambda: True self.session.lm.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir()) dispersy_cid_hex = "abcd" * 9 + "0012" dispersy_cid = binascii.unhexlify(dispersy_cid_hex) # create channel and insert torrent self.create_fake_allchannel_community() self.create_torrents_in_channel(dispersy_cid_hex) # channel is exist community = ChannelCommunity.init_community( self.session.lm.dispersy, self.session.lm.dispersy.get_member(mid=dispersy_cid), self.session.lm.dispersy._communities['allchannel']._my_member, self.session) # make the id unknown so boosting manager can test repeating search id_tmp = community._channel_id community._channel_id = 0 def _set_id_channel(channel_id): """ set channel id manually (emulate finding) """ community._channel_id = channel_id reactor.callLater(5, _set_id_channel, id_tmp) self.boosting_manager.add_source(dispersy_cid) chn_obj = self.boosting_manager.get_source_object(dispersy_cid) chn_obj._load_torrent = self._load def clean_community(_): """ cleanly exit the community we are in """ if chn_obj.community: chn_obj.community.cancel_all_pending_tasks() chn_obj.kill_tasks() d = self.check_source(dispersy_cid) d.addCallback(clean_community) return d
def test_chn_native_load(self): self.session.get_dispersy = lambda: True self.session.lm.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir()) dispersy_cid_hex = "abcd" * 9 + "0012" dispersy_cid = binascii.unhexlify(dispersy_cid_hex) # create channel and insert torrent self.create_fake_allchannel_community() self.create_torrents_in_channel(dispersy_cid_hex) self.session.download_torrentfile = \ lambda dummy_ihash, function, _: function(binascii.hexlify(TORRENT_UBUNTU_FILE_INFOHASH)) def get_bin_torrent(_): """ get binary data of a torrent """ f = open(TORRENT_UBUNTU_FILE, "rb") bdata = f.read() f.close() return bdata self.session.get_collected_torrent = get_bin_torrent self.boosting_manager.add_source(dispersy_cid) def _loop_check(_): defer_param = defer.Deferred() def check_loaded(src): """ check if a torrent has been loaded """ src_obj = self.boosting_manager.get_source_object(src) if src_obj.loaded_torrent[ TORRENT_UBUNTU_FILE_INFOHASH] is not None: src_obj.community.cancel_all_pending_tasks() src_obj.kill_tasks() self.check_loaded_lc.stop() self.check_loaded_lc = None defer_param.callback(src) self.check_loaded_lc = LoopingCall(check_loaded, dispersy_cid) self.check_loaded_lc.start(1, now=True) return defer_param defer_ret = self.check_source(dispersy_cid) defer_ret.addCallback(_loop_check) return defer_ret
def start_dispersy(self): msg("Starting dispersy") # We need to import the stuff _AFTER_ configuring the logging stuff. from Tribler.dispersy.callback import Callback from Tribler.dispersy.dispersy import Dispersy from Tribler.dispersy.endpoint import StandaloneEndpoint self._dispersy = Dispersy( Callback("Dispersy"), StandaloneEndpoint(int(self.my_id) + 12000, '0.0.0.0'), u'.', self._database_file) self._dispersy.statistics.enable_debug_statistics(True) if self._strict: def exception_handler(exception, fatal): msg("An exception occurred. Quitting because we are running with --strict enabled." ) print "Exception was:" try: raise exception except: from traceback import print_exc print_exc() # Set Dispersy's exit status to error self._dispersy_exit_status = 1 # Stop the experiment reactor.callLater(1, self.stop) return True self._dispersy.callback.attach_exception_handler(exception_handler) self._dispersy.start() # low (NID_sect233k1) isn't actually that low, switching to 160bits as this is comparable to rsa 1024 # http://www.nsa.gov/business/programs/elliptic_curve.shtml # speed difference when signing/verifying 100 items # NID_sect233k1 signing took 0.171 verify took 0.35 totals 0.521 # NID_secp160k1 signing took 0.04 verify took 0.04 totals 0.08 self._my_member = self._dispersy.callback.call( self._dispersy.get_new_member, (u"NID_secp160k1", )) self._master_member = self._dispersy.callback.call( self._dispersy.get_member, (self.master_key, )) self._dispersy.callback.register(self._do_log) msg("Finished starting dispersy")
def setUp(self): """ The startup method of this class creates a fake Dispersy instance with a fake AllChannel community. It also inserts some random channels so we have some data to work with. """ yield super(TestChannelsSubscriptionEndpoint, self).setUp() self.expected_votecast_cid = None self.expected_votecast_vote = None self.create_votecast_called = False fake_community = self.create_fake_allchannel_community() fake_community.disp_create_votecast = self.on_dispersy_create_votecast self.session.config.get_dispersy_enabled = lambda: True self.session.lm.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir()) self.session.lm.dispersy.attach_community(fake_community) for i in xrange(0, 10): self.insert_channel_in_db('rand%d' % i, 42 + i, 'Test channel %d' % i, 'Test description %d' % i)
def start_dispersy(self, autoload_discovery=True): msg("Starting dispersy") # We need to import the stuff _AFTER_ configuring the logging stuff. try: from Tribler.dispersy.dispersy import Dispersy from Tribler.dispersy.endpoint import StandaloneEndpoint from Tribler.dispersy.util import unhandled_error_observer except: from dispersy.dispersy import Dispersy from dispersy.endpoint import StandaloneEndpoint from dispersy.util import unhandled_error_observer self._dispersy = Dispersy( StandaloneEndpoint(int(self.my_id) + 12000, '0.0.0.0'), u'.', self._database_file, self._crypto) self._dispersy.statistics.enable_debug_statistics(True) self.original_on_incoming_packets = self._dispersy.on_incoming_packets if self._strict: from twisted.python.log import addObserver addObserver(unhandled_error_observer) self._dispersy.start(autoload_discovery=autoload_discovery) if self.master_private_key: self._master_member = self._dispersy.get_member( private_key=self.master_private_key) else: self._master_member = self._dispersy.get_member( public_key=self.master_key) self._my_member = self._dispersy.get_member( private_key=self.my_member_private_key) assert self._master_member assert self._my_member self._do_log() self.print_on_change('community-kwargs', {}, self.community_kwargs) self.print_on_change('community-env', {}, {'pid': getpid()}) msg("Finished starting dispersy")
def setUp(self, annotate=True): yield super(AbstractTestCommunity, self).setUp(annotate=annotate) self.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir()) self.dispersy._database.open() self.master_member = DummyMember(self.dispersy, 1, "a" * 20) self.member = self.dispersy.get_new_member(u"curve25519")
def register(self, session, session_lock): assert isInIOThread() if not self.registered: self.registered = True self.session = session self.session_lock = session_lock # On Mac, we bundle the root certificate for the SSL validation since Twisted is not using the root # certificates provided by the system trust store. if sys.platform == 'darwin': os.environ['SSL_CERT_FILE'] = os.path.join( get_lib_path(), 'root_certs_mac.pem') if self.session.config.get_torrent_store_enabled(): from Tribler.Core.leveldbstore import LevelDbStore self.torrent_store = LevelDbStore( self.session.config.get_torrent_store_dir()) if not self.torrent_store.get_db(): raise RuntimeError( "Torrent store (leveldb) is None which should not normally happen" ) if self.session.config.get_metadata_enabled(): from Tribler.Core.leveldbstore import LevelDbStore self.metadata_store = LevelDbStore( self.session.config.get_metadata_store_dir()) if not self.metadata_store.get_db(): raise RuntimeError( "Metadata store (leveldb) is None which should not normally happen" ) # torrent collecting: RemoteTorrentHandler if self.session.config.get_torrent_collecting_enabled(): from Tribler.Core.RemoteTorrentHandler import RemoteTorrentHandler self.rtorrent_handler = RemoteTorrentHandler(self.session) # TODO(emilon): move this to a megacache component or smth if self.session.config.get_megacache_enabled(): from Tribler.Core.CacheDB.SqliteCacheDBHandler import ( PeerDBHandler, TorrentDBHandler, MyPreferenceDBHandler, VoteCastDBHandler, ChannelCastDBHandler) from Tribler.Core.Category.Category import Category self._logger.debug('tlm: Reading Session state from %s', self.session.config.get_state_dir()) self.category = Category() # create DBHandlers self.peer_db = PeerDBHandler(self.session) self.torrent_db = TorrentDBHandler(self.session) self.mypref_db = MyPreferenceDBHandler(self.session) self.votecast_db = VoteCastDBHandler(self.session) self.channelcast_db = ChannelCastDBHandler(self.session) # initializes DBHandlers self.peer_db.initialize() self.torrent_db.initialize() self.mypref_db.initialize() self.votecast_db.initialize() self.channelcast_db.initialize() from Tribler.Core.Modules.tracker_manager import TrackerManager self.tracker_manager = TrackerManager(self.session) if self.session.config.get_video_server_enabled(): self.video_server = VideoServer( self.session.config.get_video_server_port(), self.session) self.video_server.start() # IPv8 if self.session.config.get_ipv8_enabled(): from Tribler.pyipv8.ipv8.configuration import get_default_configuration ipv8_config = get_default_configuration() ipv8_config['port'] = self.session.config.get_dispersy_port() ipv8_config['address'] = self.session.config.get_ipv8_address() ipv8_config['overlays'] = [] ipv8_config['keys'] = [] # We load the keys ourselves if self.session.config.get_ipv8_bootstrap_override(): import Tribler.pyipv8.ipv8.deprecated.community as community_file community_file._DEFAULT_ADDRESSES = [ self.session.config.get_ipv8_bootstrap_override() ] community_file._DNS_ADDRESSES = [] self.ipv8 = IPv8(ipv8_config) self.session.config.set_anon_proxy_settings( 2, ("127.0.0.1", self.session.config. get_tunnel_community_socks5_listen_ports())) # Dispersy self.tftp_handler = None if self.session.config.get_dispersy_enabled(): from Tribler.dispersy.dispersy import Dispersy from Tribler.dispersy.endpoint import MIMEndpoint from Tribler.dispersy.endpoint import IPv8toDispersyAdapter # set communication endpoint if self.session.config.get_ipv8_enabled(): dispersy_endpoint = IPv8toDispersyAdapter( self.ipv8.endpoint) else: dispersy_endpoint = MIMEndpoint( self.session.config.get_dispersy_port()) working_directory = unicode( self.session.config.get_state_dir()) self.dispersy = Dispersy(dispersy_endpoint, working_directory) self.dispersy.statistics.enable_debug_statistics(False) # register TFTP service from Tribler.Core.TFTP.handler import TftpHandler self.tftp_handler = TftpHandler(self.session, dispersy_endpoint, "fffffffd".decode('hex'), block_size=1024) self.tftp_handler.initialize() # Torrent search if self.session.config.get_torrent_search_enabled( ) or self.session.config.get_channel_search_enabled(): self.search_manager = SearchManager(self.session) self.search_manager.initialize() if not self.initComplete: self.init() self.session.add_observer(self.on_tribler_started, NTFY_TRIBLER, [NTFY_STARTED]) self.session.notifier.notify(NTFY_TRIBLER, NTFY_STARTED, None) return self.startup_deferred
def register(self, session, session_lock): assert isInIOThread() if not self.registered: self.registered = True self.session = session self.session_lock = session_lock # On Mac, we bundle the root certificate for the SSL validation since Twisted is not using the root # certificates provided by the system trust store. if sys.platform == 'darwin': os.environ['SSL_CERT_FILE'] = os.path.join( get_lib_path(), 'root_certs_mac.pem') if self.session.config.get_torrent_store_enabled(): from Tribler.Core.leveldbstore import LevelDbStore self.torrent_store = LevelDbStore( self.session.config.get_torrent_store_dir()) if self.session.config.get_metadata_enabled(): from Tribler.Core.leveldbstore import LevelDbStore self.metadata_store = LevelDbStore( self.session.config.get_metadata_store_dir()) # torrent collecting: RemoteTorrentHandler if self.session.config.get_torrent_collecting_enabled(): from Tribler.Core.RemoteTorrentHandler import RemoteTorrentHandler self.rtorrent_handler = RemoteTorrentHandler(self.session) # TODO(emilon): move this to a megacache component or smth if self.session.config.get_megacache_enabled(): from Tribler.Core.CacheDB.SqliteCacheDBHandler import ( PeerDBHandler, TorrentDBHandler, MyPreferenceDBHandler, VoteCastDBHandler, ChannelCastDBHandler) from Tribler.Core.Category.Category import Category self._logger.debug('tlm: Reading Session state from %s', self.session.config.get_state_dir()) self.category = Category() # create DBHandlers self.peer_db = PeerDBHandler(self.session) self.torrent_db = TorrentDBHandler(self.session) self.mypref_db = MyPreferenceDBHandler(self.session) self.votecast_db = VoteCastDBHandler(self.session) self.channelcast_db = ChannelCastDBHandler(self.session) # initializes DBHandlers self.peer_db.initialize() self.torrent_db.initialize() self.mypref_db.initialize() self.votecast_db.initialize() self.channelcast_db.initialize() from Tribler.Core.Modules.tracker_manager import TrackerManager self.tracker_manager = TrackerManager(self.session) if self.session.config.get_video_server_enabled(): self.video_server = VideoServer( self.session.config.get_video_server_port(), self.session) self.video_server.start() # Dispersy self.tftp_handler = None if self.session.config.get_dispersy_enabled(): from Tribler.dispersy.dispersy import Dispersy from Tribler.dispersy.endpoint import StandaloneEndpoint # set communication endpoint endpoint = StandaloneEndpoint( self.session.config.get_dispersy_port()) working_directory = unicode( self.session.config.get_state_dir()) self.dispersy = Dispersy(endpoint, working_directory) # register TFTP service from Tribler.Core.TFTP.handler import TftpHandler self.tftp_handler = TftpHandler(self.session, endpoint, "fffffffd".decode('hex'), block_size=1024) self.tftp_handler.initialize() if self.session.config.get_torrent_search_enabled( ) or self.session.config.get_channel_search_enabled(): self.search_manager = SearchManager(self.session) self.search_manager.initialize() if not self.initComplete: self.init() self.session.add_observer(self.on_tribler_started, NTFY_TRIBLER, [NTFY_STARTED]) self.session.notifier.notify(NTFY_TRIBLER, NTFY_STARTED, None) return self.startup_deferred
def register(self, session, sesslock): assert isInIOThread() if not self.registered: self.registered = True self.session = session self.sesslock = sesslock if self.session.get_torrent_store(): from Tribler.Core.leveldbstore import LevelDbStore self.torrent_store = LevelDbStore( self.session.get_torrent_store_dir()) if self.session.get_enable_metadata(): from Tribler.Core.leveldbstore import LevelDbStore self.metadata_store = LevelDbStore( self.session.get_metadata_store_dir()) # torrent collecting: RemoteTorrentHandler if self.session.get_torrent_collecting(): from Tribler.Core.RemoteTorrentHandler import RemoteTorrentHandler self.rtorrent_handler = RemoteTorrentHandler(self.session) # TODO(emilon): move this to a megacache component or smth if self.session.get_megacache(): from Tribler.Core.CacheDB.SqliteCacheDBHandler import ( PeerDBHandler, TorrentDBHandler, MyPreferenceDBHandler, VoteCastDBHandler, ChannelCastDBHandler) from Tribler.Core.Category.Category import Category self._logger.debug('tlm: Reading Session state from %s', self.session.get_state_dir()) self.category = Category() # create DBHandlers self.peer_db = PeerDBHandler(self.session) self.torrent_db = TorrentDBHandler(self.session) self.mypref_db = MyPreferenceDBHandler(self.session) self.votecast_db = VoteCastDBHandler(self.session) self.channelcast_db = ChannelCastDBHandler(self.session) # initializes DBHandlers self.peer_db.initialize() self.torrent_db.initialize() self.mypref_db.initialize() self.votecast_db.initialize() self.channelcast_db.initialize() from Tribler.Core.Modules.tracker_manager import TrackerManager self.tracker_manager = TrackerManager(self.session) self.tracker_manager.initialize() if self.session.get_videoserver_enabled(): self.video_server = VideoServer( self.session.get_videoserver_port(), self.session) self.video_server.start() # Dispersy self.tftp_handler = None if self.session.get_dispersy(): from Tribler.dispersy.dispersy import Dispersy from Tribler.dispersy.endpoint import StandaloneEndpoint # set communication endpoint endpoint = StandaloneEndpoint(self.session.get_dispersy_port(), ip=self.session.get_ip()) working_directory = unicode(self.session.get_state_dir()) self.dispersy = Dispersy(endpoint, working_directory) # register TFTP service from Tribler.Core.TFTP.handler import TftpHandler self.tftp_handler = TftpHandler(self.session, endpoint, "fffffffd".decode('hex'), block_size=1024) self.tftp_handler.initialize() if self.session.get_enable_torrent_search( ) or self.session.get_enable_channel_search(): self.search_manager = SearchManager(self.session) self.search_manager.initialize() if not self.initComplete: self.init() self.session.add_observer(self.on_tribler_started, NTFY_TRIBLER, [NTFY_STARTED]) self.session.notifier.notify(NTFY_TRIBLER, NTFY_STARTED, None) return self.startup_deferred
def test_chn_max_torrents(self): """ Test the restriction of max_torrents in a source. """ self.session.get_dispersy = lambda: True self.session.lm.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir()) dispersy_cid_hex = "abcd" * 9 + "0012" dispersy_cid = binascii.unhexlify(dispersy_cid_hex) # create channel and insert torrent self.create_fake_allchannel_community() self.create_torrents_in_channel(dispersy_cid_hex) pioneer_file = os.path.join( TESTS_DATA_DIR, "Pioneer.One.S01E06.720p.x264-VODO.torrent") pioneer_tdef = TorrentDef.load(pioneer_file) pioneer_ihash = binascii.unhexlify( "66ED7F30E3B30FA647ABAA19A36E7503AA071535") torrent_list = [[ self.channel_id, 1, 1, pioneer_ihash, 1460000001, pioneer_file, pioneer_tdef.get_files_as_unicode_with_length(), pioneer_tdef.get_trackers_as_single_tuple() ]] self.insert_torrents_into_channel(torrent_list) self.boosting_manager.add_source(dispersy_cid) chn_obj = self.boosting_manager.get_source_object(dispersy_cid) chn_obj.max_torrents = 2 chn_obj.torrent_mgr.load_torrent = lambda dummy_1, dummy_2: None def _load(torrent, callback=None): if not isinstance(torrent, CollectedTorrent): torrent_id = 0 if torrent.torrent_id <= 0: torrent_id = self.session.lm.torrent_db.getTorrentID( torrent.infohash) if torrent_id: torrent.update_torrent_id(torrent_id) infohash_str = binascii.hexlify(torrent.infohash) torrent = CollectedTorrent( torrent, self.tdef if infohash_str.startswith("fc") else pioneer_tdef) if callback is not None: callback(torrent) else: return torrent def activate_mgr(): """ activate ltmgr and adjust max torrents to emulate overflow torrents """ chn_obj.max_torrents = 1 chn_obj.torrent_mgr.load_torrent = _load reactor.callLater(5, activate_mgr) def check_torrents_channel(src, defer_param=None): """ check if a torrent already in channel and ready to download """ if defer_param is None: defer_param = defer.Deferred() src_obj = self.boosting_manager.get_source_object(src) success = True if len(src_obj.unavail_torrent) == 0: self.assertLessEqual(len(src_obj.torrents), src_obj.max_torrents) else: success = False reactor.callLater(1, check_torrents_channel, src, defer_param) if success: src_obj.community.cancel_all_pending_tasks() src_obj.kill_tasks() defer_param.callback(src) return defer_param d = self.check_source(dispersy_cid) d.addCallback(check_torrents_channel) return d
def test_chn_lookup(self): """ testing channel source. It includes finding and downloading actual torrent """ self.session.get_dispersy = lambda: True self.session.lm.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir()) dispersy_cid_hex = "abcd" * 9 + "0012" dispersy_cid = binascii.unhexlify(dispersy_cid_hex) # create channel and insert torrent self.create_fake_allchannel_community() self.create_torrents_in_channel(dispersy_cid_hex) self.boosting_manager.add_source(dispersy_cid) chn_obj = self.boosting_manager.get_source_object(dispersy_cid) def _load(torrent, callback=None): if not isinstance(torrent, CollectedTorrent): torrent_id = 0 if torrent.torrent_id <= 0: torrent_id = self.session.lm.torrent_db.getTorrentID( torrent.infohash) if torrent_id: torrent.update_torrent_id(torrent_id) torrent = CollectedTorrent(torrent, self.tdef) if callback is not None: callback(torrent) else: return torrent def check_torrents_channel(src, defer_param=None, target=1): """ check if a torrent already in channel and ready to download """ if defer_param is None: defer_param = defer.Deferred() src_obj = self.boosting_manager.get_source_object(src) success = True if not src_obj or len(src_obj.torrents) < target: success = False reactor.callLater(1, check_torrents_channel, src, defer_param, target=target) elif not self.boosting_manager.torrents.get( TORRENT_FILE_INFOHASH, None): success = False reactor.callLater(1, check_torrents_channel, src, defer_param, target=target) elif not self.boosting_manager.torrents[TORRENT_FILE_INFOHASH].get( 'download', None): success = False reactor.callLater(1, check_torrents_channel, src, defer_param, target=target) if success: self.boosting_manager.set_enable_mining(src, False, force_restart=True) if src_obj.community: src_obj.community.cancel_all_pending_tasks() defer_param.callback(src) return defer_param chn_obj.torrent_mgr.load_torrent = _load d = self.check_source(dispersy_cid) d.addCallback(check_torrents_channel, target=1) return d
def register(self, session, sesslock): if not self.registered: self.registered = True self.session = session self.sesslock = sesslock self.downloads = {} config = session.sessconfig # Should be safe at startup self.upnp_ports = [] # Orig self.sessdoneflag = Event() self.rawserver = RawServer( self.sessdoneflag, config['timeout_check_interval'], config['timeout'], ipv6_enable=config['ipv6_enabled'], failfunc=self.rawserver_fatalerrorfunc, errorfunc=self.rawserver_nonfatalerrorfunc) self.rawserver.add_task(self.rawserver_keepalive, 1) self.listen_port = config['minport'] self.shutdownstarttime = None self.multihandler = MultiHandler(self.rawserver, self.sessdoneflag) # SWIFTPROC swift_exists = config['swiftproc'] and ( os.path.exists(config['swiftpath']) or os.path.exists(config['swiftpath'] + '.exe')) if swift_exists: from Tribler.Core.Swift.SwiftProcessMgr import SwiftProcessMgr self.spm = SwiftProcessMgr( config['swiftpath'], config['swiftcmdlistenport'], config['swiftdlsperproc'], self.session.get_swift_tunnel_listen_port(), self.sesslock) try: self.swift_process = self.spm.get_or_create_sp( self.session.get_swift_working_dir(), self.session.get_torrent_collecting_dir(), self.session.get_swift_tunnel_listen_port(), self.session.get_swift_tunnel_httpgw_listen_port(), self.session.get_swift_tunnel_cmdgw_listen_port()) self.upnp_ports.append( (self.session.get_swift_tunnel_listen_port(), 'UDP')) except OSError: # could not find/run swift print >> sys.stderr, "lmc: could not start a swift process" else: self.spm = None self.swift_process = None # Dispersy self.session.dispersy_member = None if config['dispersy']: from Tribler.dispersy.callback import Callback from Tribler.dispersy.dispersy import Dispersy from Tribler.dispersy.endpoint import RawserverEndpoint, TunnelEndpoint from Tribler.dispersy.community import HardKilledCommunity # set communication endpoint if config['dispersy-tunnel-over-swift'] and self.swift_process: endpoint = TunnelEndpoint(self.swift_process) else: endpoint = RawserverEndpoint(self.rawserver, config['dispersy_port']) callback = Callback("Dispersy") # WARNING NAME SIGNIFICANT working_directory = unicode(config['state_dir']) self.dispersy = Dispersy(callback, endpoint, working_directory) # TODO: see if we can postpone dispersy.start to improve GUI responsiveness. # However, for now we must start self.dispersy.callback before running # try_register(nocachedb, self.database_thread)! self.dispersy.start() print >> sys.stderr, "lmc: Dispersy is listening on port", self.dispersy.wan_address[ 1], "using", endpoint self.upnp_ports.append((self.dispersy.wan_address[1], 'UDP')) self.dispersy.callback.call(self.dispersy.define_auto_load, args=(HardKilledCommunity, ), kargs={'load': True}) # notify dispersy finished loading self.session.uch.notify(NTFY_DISPERSY, NTFY_STARTED, None) from Tribler.Core.permid import read_keypair from Tribler.dispersy.crypto import ec_to_public_bin, ec_to_private_bin keypair = read_keypair( self.session.get_permid_keypair_filename()) self.session.dispersy_member = callback.call( self.dispersy.get_member, (ec_to_public_bin(keypair), ec_to_private_bin(keypair))) self.database_thread = callback else: class FakeCallback(): def __init__(self): from Tribler.Utilities.TimedTaskQueue import TimedTaskQueue self.queue = TimedTaskQueue("FakeCallback") def register(self, call, args=(), kargs=None, delay=0.0, priority=0, id_=u"", callback=None, callback_args=(), callback_kargs=None, include_id=False): def do_task(): if kargs: call(*args, **kargs) else: call(*args) if callback: if callback_kargs: callback(*callback_args, **callback_kargs) else: callback(*callback_args) self.queue.add_task(do_task, t=delay) def shutdown(self, immediately=False): self.queue.shutdown(immediately) self.database_thread = FakeCallback() if config['megacache']: import Tribler.Core.CacheDB.cachedb as cachedb from Tribler.Core.CacheDB.SqliteCacheDBHandler import PeerDBHandler, TorrentDBHandler, MyPreferenceDBHandler, VoteCastDBHandler, ChannelCastDBHandler, NetworkBuzzDBHandler, UserEventLogDBHandler from Tribler.Category.Category import Category from Tribler.Core.Tag.Extraction import TermExtraction from Tribler.Core.CacheDB.sqlitecachedb import try_register if DEBUG: print >> sys.stderr, 'tlm: Reading Session state from', config[ 'state_dir'] nocachedb = cachedb.init(config, self.rawserver_fatalerrorfunc) try_register(nocachedb, self.database_thread) self.cat = Category.getInstance(config['install_dir']) self.term = TermExtraction.getInstance(config['install_dir']) self.peer_db = PeerDBHandler.getInstance() self.peer_db.registerConnectionUpdater(self.session) self.torrent_db = TorrentDBHandler.getInstance() self.torrent_db.register( os.path.abspath(config['torrent_collecting_dir'])) self.mypref_db = MyPreferenceDBHandler.getInstance() self.votecast_db = VoteCastDBHandler.getInstance() self.votecast_db.registerSession(self.session) self.channelcast_db = ChannelCastDBHandler.getInstance() self.channelcast_db.registerSession(self.session) self.nb_db = NetworkBuzzDBHandler.getInstance() self.ue_db = UserEventLogDBHandler.getInstance() if self.dispersy: self.dispersy.database.attach_commit_callback( self.channelcast_db._db.commitNow) else: config['torrent_checking'] = 0 self.rtorrent_handler = None if config['torrent_collecting']: from Tribler.Core.RemoteTorrentHandler import RemoteTorrentHandler self.rtorrent_handler = RemoteTorrentHandler()
def test_chn_lookup(self): """ testing channel source. It includes finding and downloading actual torrent """ self.session.get_dispersy = lambda: True self.session.lm.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir()) dispersy_cid_hex = "abcd" * 9 + "0012" dispersy_cid = binascii.unhexlify(dispersy_cid_hex) # create channel and insert torrent self.create_fake_allchannel_community() self.create_torrents_in_channel(dispersy_cid_hex) self.boosting_manager.add_source(dispersy_cid) chn_obj = self.boosting_manager.get_source_object(dispersy_cid) def check_torrents_channel(src, defer_param=None, target=1): """ check if a torrent already in channel and ready to download """ if defer_param is None: defer_param = defer.Deferred() src_obj = self.boosting_manager.get_source_object(src) success = True if not src_obj or len(src_obj.torrents) < target: success = False reactor.callLater(1, check_torrents_channel, src, defer_param, target=target) elif not self.boosting_manager.torrents.get( TORRENT_UBUNTU_FILE_INFOHASH, None): success = False reactor.callLater(1, check_torrents_channel, src, defer_param, target=target) elif not self.boosting_manager.torrents[ TORRENT_UBUNTU_FILE_INFOHASH].get('download', None): success = False reactor.callLater(1, check_torrents_channel, src, defer_param, target=target) if success: self.boosting_manager.set_enable_mining(src, False, force_restart=True) if src_obj.community: src_obj.community.cancel_all_pending_tasks() self.assertEqual(src_obj.get_source_text(), 'Simple Channel') defer_param.callback(src) return defer_param chn_obj._load_torrent = self._load d = self.check_source(dispersy_cid) d.addCallback(check_torrents_channel, target=1) return d