def create_proxy(index, become_exit_node, crypto_enabled): from Tribler.Core.Session import Session self.setUpPreSession() config = self.config.copy() config.set_libtorrent(True) config.set_dispersy(True) config.set_state_dir(self.getStateDir(index)) session = Session(config, ignore_singleton=True, autoload_discovery=False) upgrader = session.prestart() session.start() self.sessions.append(session) while not session.lm.initComplete: time.sleep(1) dispersy = session.get_dispersy_instance() def load_community(session): keypair = dispersy.crypto.generate_key(u"curve25519") dispersy_member = dispersy.get_member(private_key=dispersy.crypto.key_to_bin(keypair)) settings = TunnelSettings(tribler_session=session) if not crypto_enabled: settings.crypto = NoCrypto() settings.become_exitnode = become_exit_node return dispersy.define_auto_load(HiddenTunnelCommunity, dispersy_member, (session, settings), load=True)[0] return blockingCallFromThread(reactor, load_community, session)
def test_create_channel(self): """ Test the pass through function of Session.create_channel to the ChannelManager. """ class LmMock(object): class ChannelManager(object): invoked_name = None invoked_desc = None invoked_mode = None def create_channel(self, name, description, mode=u"closed"): self.invoked_name = name self.invoked_desc = description self.invoked_mode = mode channel_manager = ChannelManager() config = TriblerConfig() config.set_state_dir(self.getStateDir()) session = Session(config) session.lm = LmMock() session.lm.api_manager = None session.create_channel("name", "description", "open") self.assertEqual(session.lm.channel_manager.invoked_name, "name") self.assertEqual(session.lm.channel_manager.invoked_desc, "description") self.assertEqual(session.lm.channel_manager.invoked_mode, "open")
def __init__(self): if GUIDBProducer.__single: raise RuntimeError, "GuiDBProducer is singleton" #Lets get the reference to the shared database_thread from Tribler.Core.Session import Session if Session.has_instance(): self.database_thread = Session.get_instance().lm.database_thread else: raise RuntimeError('Session not initialized') self.guitaskqueue = GUITaskQueue.getInstance() #Lets get a reference to utility from Tribler.Main.vwxGUI.GuiUtility import GUIUtility if GUIUtility.hasInstance(): self.utility = GUIUtility.getInstance().utility else: Utility = namedtuple('Utility', ['abcquitting',]) self.utility = Utility(False) self.uIds = set() self.uIdsLock = Lock() self.nrCallbacks = {}
class AbstractDB(AbstractServer): def setUp(self): super(AbstractDB, self).setUp() # dummy session self.config = SessionStartupConfig() self.config.set_state_dir(self.getStateDir()) self.config.set_torrent_checking(False) self.config.set_multicast_local_peer_discovery(False) self.config.set_megacache(False) self.config.set_dispersy(False) self.config.set_mainline_dht(False) self.config.set_torrent_collecting(False) self.config.set_libtorrent(False) self.config.set_dht_torrent_collecting(False) self.config.set_videoplayer(False) self.config.set_torrent_store(False) self.session = Session(self.config, ignore_singleton=True) dbpath = init_bak_tribler_sdb('bak_new_tribler.sdb', destination_path=self.getStateDir(), overwrite=True) self.sqlitedb = SQLiteCacheDB(self.session, busytimeout=BUSYTIMEOUT) self.sqlitedb.initialize(dbpath) self.session.sqlite_db = self.sqlitedb @blocking_call_on_reactor_thread def tearDown(self): self.sqlitedb.close() self.sqlitedb = None self.session.del_instance() self.session = None super(AbstractDB, self).tearDown(self)
def test_close_dbhandler(self): handler = MockObject() self.called = False def verify_close_called(): self.called = True handler.close = verify_close_called Session.close_dbhandler(handler) self.assertTrue(self.called)
def tearDown(self): if SQLiteCacheDB.hasInstance(): SQLiteCacheDB.getInstance().close_all() SQLiteCacheDB.delInstance() if Session.has_instance(): # Upgrading will create a session instance Session.del_instance() sqlitecachedb.INITIAL_UPGRADE_PAUSE, sqlitecachedb.SUCCESIVE_UPGRADE_PAUSE, sqlitecachedb.UPGRADE_BATCH_SIZE, sqlitecachedb.TEST_OVERRIDE = self.original_values self.tearDownCleanup()
def checkReactor(self, phase, *_): delayed_calls = reactor.getDelayedCalls() if delayed_calls: self._logger.error("The reactor was dirty during %s:", phase) for dc in delayed_calls: self._logger.error("> %s" % dc) dc.cancel() has_network_selectables = False for item in reactor.getReaders() + reactor.getWriters(): if isinstance(item, HTTPChannel) or isinstance(item, Client): has_network_selectables = True break if has_network_selectables: # TODO(Martijn): we wait a while before we continue the check since network selectables # might take some time to cleanup. I'm not sure what's causing this. yield deferLater(reactor, 0.2, lambda: None) # This is the same check as in the _cleanReactor method of Twisted's Trial selectable_strings = [] for sel in reactor.removeAll(): if interfaces.IProcessTransport.providedBy(sel): self._logger.error("Sending kill signal to %s", repr(sel)) sel.signalProcess('KILL') selectable_strings.append(repr(sel)) self.assertFalse(delayed_calls, "The reactor was dirty during %s" % phase) if Session.has_instance(): try: yield Session.get_instance().shutdown() except: pass Session.del_instance() raise RuntimeError("Found a leftover session instance during %s" % phase) self.assertFalse( selectable_strings, "The reactor has leftover readers/writers during %s: %r" % (phase, selectable_strings)) # Check whether we have closed all the sockets open_readers = reactor.getReaders() for reader in open_readers: self.assertNotIsInstance( reader, BasePort, "Listening ports left on the reactor during %s: %s" % (phase, reader)) # Check whether the threadpool is clean self.assertEqual(len(reactor.getThreadPool().working), 0, "Still items left in the threadpool")
def start(self): # Determine socks5 ports socks5_port = self.options['socks5'] if "HELPER_INDEX" in os.environ and "HELPER_BASE" in os.environ: base_port = int(os.environ["HELPER_BASE"]) socks5_port = base_port + int(os.environ["HELPER_INDEX"]) * 5 if socks5_port is not None: socks_listen_ports = range(socks5_port, socks5_port + 5) else: socks_listen_ports = [ random.randint(1000, 65535) for _ in range(5) ] config = TriblerConfig() config.set_state_dir( os.path.join(config.get_state_dir(), "tunnel-%d") % socks_listen_ports[0]) config.set_tunnel_community_socks5_listen_ports(socks_listen_ports) config.set_torrent_checking_enabled(False) config.set_megacache_enabled(False) config.set_dispersy_enabled(False) config.set_ipv8_enabled(True) config.set_mainline_dht_enabled(True) config.set_torrent_collecting_enabled(False) config.set_libtorrent_enabled(False) config.set_video_server_enabled(False) config.set_dispersy_port(self.ipv8_port) config.set_ipv8_address(self.ipv8_address) config.set_torrent_search_enabled(False) config.set_channel_search_enabled(False) config.set_trustchain_enabled(True) config.set_credit_mining_enabled(False) config.set_market_community_enabled(False) config.set_mainline_dht_enabled(False) config.set_tunnel_community_exitnode_enabled(bool( self.options["exit"])) config.set_trustchain_testnet(bool(self.options["testnet"])) if self.options["restapi"] is not None: config.set_http_api_enabled(True) config.set_http_api_port(self.options["restapi"]) if "ipv8_bootstrap_override" in self.options: config.set_ipv8_bootstrap_override( self.options["ipv8_bootstrap_override"]) self.session = Session(config) logger.info("Using IPv8 port %d" % self.session.config.get_dispersy_port()) self.session.notifier.add_observer(self.circuit_removed, NTFY_TUNNEL, [NTFY_REMOVE]) return self.session.start().addCallback(self.tribler_started)
def setupPeer(self): from Tribler.Core.Session import Session self.config2 = self.config.copy() self.config2.set_state_dir(self.getStateDir(2)) self.session2 = Session(self.config2, ignore_singleton=True) yield self.session2.start() self.load_communities(self.session2, self.session2.get_dispersy_instance())
def setup_downloader(self): self.config2 = self.config.copy() self.config2.set_megacache(True) self.config2.set_torrent_collecting(True) self.config2.set_torrent_store_dir(None) self.config2.set_metadata_store_dir(None) self.config2.set_enable_metadata(True) self.config2.set_state_dir(self.getStateDir(2)) self.session2 = Session(self.config2, ignore_singleton=True) return self.session2.start()
def start_tribler(self, options): """ Main method to startup Tribler. """ def on_tribler_shutdown(_): msg("Tribler shut down") reactor.stop() self.process_checker.remove_lock_file() def signal_handler(sig, _): msg("Received shut down signal %s" % sig) if not self._stopping: self._stopping = True self.session.shutdown().addCallback(on_tribler_shutdown) signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGTERM, signal_handler) config = TriblerConfig() # Check if we are already running a Tribler instance self.process_checker = ProcessChecker() if self.process_checker.already_running: self.shutdown_process("Another Tribler instance is already using statedir %s" % config.get_state_dir()) return msg("Starting Tribler") if options["statedir"]: config.set_state_dir(options["statedir"]) if options["restapi"] > 0: config.set_http_api_enabled(True) config.set_http_api_port(options["restapi"]) if options["ipv8"] > 0: config.set_ipv8_port(options["ipv8"]) elif options["ipv8"] == 0: config.set_ipv8_enabled(False) if options["libtorrent"] != -1 and options["libtorrent"] > 0: config.set_libtorrent_port(options["libtorrent"]) if options["ipv8_bootstrap_override"] is not None: config.set_ipv8_bootstrap_override(options["ipv8_bootstrap_override"]) if "testnet" in options and options["testnet"]: config.set_testnet(True) self.session = Session(config) self.session.start().addErrback(lambda failure: self.shutdown_process(failure.getErrorMessage())) msg("Tribler started")
def start_tribler(self, options): """ Main method to startup Tribler. """ def on_tribler_shutdown(_): msg("Tribler shut down") reactor.stop() self.process_checker.remove_lock_file() def signal_handler(sig, _): msg("Received shut down signal %s" % sig) if not self._stopping: self._stopping = True self.session.shutdown().addCallback(on_tribler_shutdown) signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGTERM, signal_handler) config = TriblerConfig() config.set_torrent_checking_enabled(False) config.set_megacache_enabled(True) config.set_dispersy_enabled(False) config.set_mainline_dht_enabled(True) config.set_torrent_collecting_enabled(False) config.set_libtorrent_enabled(False) config.set_http_api_enabled(True) config.set_video_server_enabled(False) config.set_torrent_search_enabled(False) config.set_channel_search_enabled(False) # Check if we are already running a Tribler instance self.process_checker = ProcessChecker() if self.process_checker.already_running: self.shutdown_process("Another Tribler instance is already using statedir %s" % config.get_state_dir()) return msg("Starting Tribler") if options["statedir"]: config.set_state_dir(options["statedir"]) if options["restapi"] > 0: config.set_http_api_enabled(True) config.set_http_api_port(options["restapi"]) if options["ipv8"] != -1 and options["ipv8"] > 0: config.set_dispersy_port(options["ipv8"]) self.session = Session(config) self.session.start().addErrback(lambda failure: self.shutdown_process(failure.getErrorMessage())) msg("Tribler started")
def start_tribler(): config = SessionStartupConfig().load() config.set_http_api_port(API_PORT) config.set_http_api_enabled(True) # Check if we are already running a Tribler instance process_checker = ProcessChecker() if process_checker.already_running: return session = Session(config) signal.signal(signal.SIGTERM, lambda signum, stack: shutdown(session, signum, stack)) session.start()
class TestSqliteCacheDB(AbstractServer): def setUp(self): super(TestSqliteCacheDB, self).setUp() self.config = SessionStartupConfig() self.config.set_state_dir(self.getStateDir()) self.config.set_torrent_checking(False) self.config.set_multicast_local_peer_discovery(False) self.config.set_megacache(False) self.config.set_dispersy(False) self.config.set_mainline_dht(False) self.config.set_torrent_collecting(False) self.config.set_libtorrent(False) self.config.set_dht_torrent_collecting(False) self.config.set_videoplayer(False) self.session = Session(self.config, ignore_singleton=True) self.sqlitedb = None def tearDown(self): super(TestSqliteCacheDB, self).tearDown() if self.sqlitedb: self.sqlitedb.close() self.sqlitedb = None self.session.del_instance() self.session = None def test_upgrade_from_obsolete_version(self): """We no longer support DB versions older than 17 (Tribler 6.0)""" dbpath = init_bak_tribler_sdb(u"bak_old_tribler.sdb", destination_path=self.getStateDir(), overwrite=True) self.sqlitedb = SQLiteCacheDB(self.session) self.sqlitedb.initialize(dbpath) class MockTorrentStore(object): def flush(): pass def close(): pass db_migrator = DBUpgrader(self.session, self.sqlitedb, torrent_store=MockTorrentStore()) self.assertRaises(VersionNoLongerSupportedError, db_migrator.start_migrate) def test_upgrade_from_17(self): pass
def start(self): # Determine ipv8 port ipv8_port = -1 if self.options["ipv8_port"] != -1: ipv8_port = self.options["ipv8_port"] elif "HELPER_INDEX" in os.environ and "HELPER_BASE" in os.environ: base_port = int(os.environ["HELPER_BASE"]) ipv8_port = base_port + int(os.environ["HELPER_INDEX"]) * 5 config = TriblerConfig() config.set_state_dir( os.path.join(config.get_state_dir(), "tunnel-%d") % ipv8_port) config.set_tunnel_community_socks5_listen_ports([]) config.set_tunnel_community_random_slots(self.options["random_slots"]) config.set_tunnel_community_competing_slots( self.options["competing_slots"]) config.set_torrent_checking_enabled(False) config.set_ipv8_enabled(True) config.set_libtorrent_enabled(False) config.set_video_server_enabled(False) config.set_ipv8_port(ipv8_port) config.set_ipv8_address(self.options["ipv8_address"]) config.set_trustchain_enabled(True) config.set_credit_mining_enabled(False) config.set_market_community_enabled(False) config.set_dht_enabled(True) config.set_tunnel_community_exitnode_enabled(bool( self.options["exit"])) config.set_popularity_community_enabled(False) config.set_testnet(bool(self.options["testnet"])) config.set_chant_enabled(False) if not self.options['no-rest-api']: config.set_http_api_enabled(True) api_port = self.options["restapi"] if "HELPER_INDEX" in os.environ and "HELPER_BASE" in os.environ: api_port = int(os.environ["HELPER_BASE"]) + 10000 + int( os.environ["HELPER_INDEX"]) config.set_http_api_port(api_port) if self.options["ipv8_bootstrap_override"] is not None: config.set_ipv8_bootstrap_override( self.options["ipv8_bootstrap_override"]) self.session = Session(config) self.session.notifier.add_observer(self.circuit_removed, NTFY_TUNNEL, [NTFY_REMOVE]) return self.session.start().addCallback(self.tribler_started)
def setUp(self): yield super(AbstractDB, self).setUp() self.setUpPreSession() self.session = Session(self.config, ignore_singleton=True) tar = tarfile.open( os.path.join(TESTS_DATA_DIR, 'bak_new_tribler.sdb.tar.gz'), 'r|gz') tar.extractall(self.session_base_dir) db_path = os.path.join(self.session_base_dir, 'bak_new_tribler.sdb') self.sqlitedb = SQLiteCacheDB(db_path, busytimeout=BUSYTIMEOUT) self.sqlitedb.initialize() self.session.sqlite_db = self.sqlitedb
def setUp(self): super(TestSqliteCacheDB, self).setUp() self.config = SessionStartupConfig() self.config.set_state_dir(self.getStateDir()) self.config.set_torrent_checking(False) self.config.set_multicast_local_peer_discovery(False) self.config.set_megacache(False) self.config.set_dispersy(False) self.config.set_mainline_dht(False) self.config.set_torrent_collecting(False) self.config.set_libtorrent(False) self.config.set_dht_torrent_collecting(False) self.config.set_videoplayer(False) self.session = Session(self.config, ignore_singleton=True) self.sqlitedb = None
def can_edit_channel(channel_id, channel_vote): """ This method returns whether the channel can be edited or not. """ from Tribler.Core.Session import Session if Session.get_instance().get_dispersy(): dispersy = Session.get_instance().get_dispersy_instance() try: cmty = dispersy.get_community(channel_id) channel_type, is_mod = cmty.get_channel_mode() if is_mod or channel_vote == VOTE_SUBSCRIBE and channel_type == ChannelCommunity.CHANNEL_OPEN: return True except CommunityNotFoundException: return False return False
def setup_seeder(self, tdef, seed_dir, port=None): self.seed_config = TriblerConfig() self.seed_config.set_torrent_checking_enabled(False) self.seed_config.set_ipv8_enabled(False) self.seed_config.set_http_api_enabled(False) self.seed_config.set_libtorrent_enabled(True) self.seed_config.set_video_server_enabled(False) self.seed_config.set_tunnel_community_enabled(False) self.seed_config.set_market_community_enabled(False) self.seed_config.set_dht_enabled(False) self.seed_config.set_state_dir(self.getStateDir(2)) self.seed_config.set_version_checker_enabled(False) self.seed_config.set_bitcoinlib_enabled(False) self.seed_config.set_chant_enabled(False) self.seed_config.set_credit_mining_enabled(False) self.seed_config.set_resource_monitor_enabled(False) if port: self.seed_config.set_libtorrent_port(port) def start_seed_download(_): self.dscfg_seed = DownloadStartupConfig() self.dscfg_seed.set_dest_dir(seed_dir) d = self.seeder_session.start_download_from_tdef(tdef, self.dscfg_seed) d.set_state_callback(self.seeder_state_callback) self._logger.debug("starting to wait for download to reach seeding state") self.seeder_session = Session(self.seed_config) self.seeder_session.upgrader_enabled = False self.seeder_session.start().addCallback(start_seed_download) return self.seeding_deferred
def report(self): """ Create the report in XML and send it """ # Create the report doc = xml.dom.minidom.Document() root = doc.createElement("nextsharedata") doc.appendChild(root) # Create the header header = doc.createElement("header") root.appendChild(header) header.appendChild(self.new_element(doc, "deviceid", self.device_id)) header.appendChild(self.new_element(doc, "timestamp", long(round(time.time())))) # ProxyService 90s Test_ try: from Tribler.Core.Session import Session session = Session.get_instance() if session.lm.overlay_apps.proxy_peer_manager.connectable: connectable = 1 else: connectable = 0 start_time = long(round(session.start_time)) my_permid = show_permid_short(session.get_permid()) except Exception,e: connectable = 0 start_time = 0 my_permid = 0
def setUp(self, annotate=True): super(TestTorrentChecker, self).setUp(annotate=annotate) config = SessionStartupConfig() config.set_state_dir(self.getStateDir()) config.set_megacache(True) self.session = Session(config, ignore_singleton=True) self.session.start_database() self.session.lm.torrent_db = TorrentDBHandler(self.session) self.session.lm.torrent_checker = TorrentChecker(self.session) self.session.lm.tracker_manager = TrackerManager(self.session) self.torrent_checker = self.session.lm.torrent_checker self.torrent_checker._torrent_db = self.session.open_dbhandler(NTFY_TORRENTS) self.torrent_checker._torrent_db.category = Category()
def setupSeeder(self, hops=0, session=None): from Tribler.Core.Session import Session from Tribler.Core.TorrentDef import TorrentDef from Tribler.Core.DownloadConfig import DownloadStartupConfig self.setUpPreSession() self.config.set_libtorrent(True) self.config2 = self.config.copy() self.config2.set_state_dir(self.getStateDir(2)) if session is None: self.session2 = Session(self.config2, ignore_singleton=True, autoload_discovery=False) upgrader = self.session2.prestart() while not upgrader.is_done: time.sleep(0.1) self.session2.start() session = self.session2 tdef = TorrentDef() tdef.add_content(os.path.join(TESTS_DATA_DIR, "video.avi")) tdef.set_tracker("http://fake.net/announce") tdef.set_private() # disable dht tdef.finalize() torrentfn = os.path.join(session.get_state_dir(), "gen.torrent") tdef.save(torrentfn) dscfg = DownloadStartupConfig() dscfg.set_dest_dir(TESTS_DATA_DIR) # basedir of the file we are seeding dscfg.set_hops(hops) d = session.start_download(tdef, dscfg) d.set_state_callback(self.seeder_state_callback) return torrentfn
def wait_for_instance(): print >> sys.stderr, "tgs: found instance, staring to wait for lm to be initcomplete" self.session = Session.get_instance() self.lm = self.session.lm self.CallConditional(30, lambda: self.lm.initComplete, wait_for_init)
def setup_torrentdownloader(self): self.download_event = Event() self.session1_port = self.session.get_dispersy_port() self.infohash_strs = ["41aea20908363a80d44234e8fef07fab506cd3b4", "45a647b1120ed9fe7f793e17585efb4b0efdf1a5"] for i, infohash in enumerate(self.infohash_strs): self.infohashes[i] = infohash.decode('hex') self.file_names[i] = file_name = u"%s.torrent" % infohash # Put the torrents into the uploader's store with open(os.path.join(TESTS_DATA_DIR, file_name), 'r') as torrent_file: self.session.lm.torrent_store.put(infohash, torrent_file.read()) from Tribler.Core.Session import Session self.setUpPreSession() self.config2 = self.config.copy() self.config2.set_megacache(True) self.config2.set_torrent_collecting(True) self.session2_state_dir = self.session.get_state_dir() + u"2" self.config2.set_state_dir(self.session2_state_dir) self.session2 = Session(self.config2, ignore_singleton=True) upgrader = self.session2.prestart() while not upgrader.is_done: sleep(0.1) assert not upgrader.failed, upgrader.current_status self.session2.start() sleep(1)
def relevance_score_remote_torrent(torrent_name): """ Calculate the relevance score of a remote torrent, based on the name and the matchinfo object of the last torrent from the database. The algorithm used is the same one as in search_in_local_torrents_db in SqliteCacheDBHandler.py. """ from Tribler.Core.Session import Session torrent_db = Session.get_instance().open_dbhandler(NTFY_TORRENTS) if torrent_db.latest_matchinfo_torrent is None: return 0.0 matchinfo, keywords = torrent_db.latest_matchinfo_torrent num_phrases, num_cols, num_rows = unpack_from('III', matchinfo) unpack_str = 'I' * (3 * num_cols * num_phrases) matchinfo = unpack_from('I' * 9 + unpack_str, matchinfo)[9:] score = 0.0 for phrase_ind in xrange(num_phrases): rows_with_term = matchinfo[3 * (phrase_ind * num_cols) + 2] term_freq = torrent_name.lower().count(keywords[phrase_ind]) inv_doc_freq = math.log( (num_rows - rows_with_term + 0.5) / (rows_with_term + 0.5), 2) right_side = ((term_freq * (1.2 + 1)) / (term_freq + 1.2)) score += inv_doc_freq * right_side return score
def initialize(self): sscfg = SessionStartupConfig() if self._opt.statedir: sscfg.set_state_dir(unicode(os.path.realpath(self._opt.statedir))) if self._opt.port: sscfg.set_dispersy_port(self._opt.port) if self._opt.nickname: sscfg.set_nickname(self._opt.nickname) # pass rss config if not self._opt.rss_config: self._logger.error(u"rss_config unspecified") self.rss_list = parge_rss_config_file(self._opt.rss_config) sscfg.set_megacache(True) sscfg.set_torrent_collecting(True) sscfg.set_torrent_checking(True) sscfg.set_enable_torrent_search(True) sscfg.set_enable_channel_search(True) self._logger.info(u"Starting session...") self.session = Session(sscfg) self.session.prestart() # add dispersy start callbacks self.session.add_observer(self.dispersy_started, NTFY_DISPERSY, [NTFY_STARTED]) self.session.start()
def setup_tunnel_seeder(self, hops): """ Setup the seeder. """ from Tribler.Core.Session import Session self.seed_config = self.config.copy() self.seed_config.set_state_dir(self.getStateDir(2)) self.seed_config.set_megacache_enabled(True) self.seed_config.set_tunnel_community_socks5_listen_ports(self.get_socks5_ports()) if self.session2 is None: self.session2 = Session(self.seed_config) self.session2.start() tdef = TorrentDef() tdef.add_content(os.path.join(TESTS_DATA_DIR, "video.avi")) tdef.set_tracker("http://localhost/announce") tdef.finalize() torrentfn = os.path.join(self.session2.config.get_state_dir(), "gen.torrent") tdef.save(torrentfn) self.seed_tdef = tdef if hops > 0: # Safe seeding enabled self.tunnel_community_seeder = self.load_tunnel_community_in_session(self.session2) self.tunnel_community_seeder.build_tunnels(hops) else: self.sanitize_network(self.session2) dscfg = DownloadStartupConfig() dscfg.set_dest_dir(TESTS_DATA_DIR) # basedir of the file we are seeding dscfg.set_hops(hops) d = self.session2.start_download_from_tdef(tdef, dscfg) d.set_state_callback(self.seeder_state_callback)
def __init__(self, parent): HomePanel.__init__(self, parent, 'Newest Torrents' , LIST_BLUE) self.Layout() self.torrentdb = TorrentDBHandler.getInstance() session = Session.get_instance() session.add_observer(self.OnNotify, NTFY_TORRENTS, [NTFY_INSERT])
def _showInspectionTool(self): import wx.lib.inspection itool = wx.lib.inspection.InspectionTool() itool.Show() try: frame = itool._frame import Tribler frame.locals['Tribler'] = Tribler from Tribler.Core.Overlay.SecureOverlay import SecureOverlay overlay = SecureOverlay.getInstance() frame.locals['overlay'] = overlay session = Session.get_instance() frame.locals['session'] = session from Tribler.Core.BuddyCast.buddycast import BuddyCastFactory channelcast = BuddyCastFactory.getInstance().channelcast_core frame.locals['channelcast'] = channelcast frame.locals['dispersy'] = Dispersy.get_instance() except Exception: import traceback traceback.print_exc()
def __init__(self, interval = 15): if TorrentChecking.__single: raise RuntimeError, "Torrent Checking is singleton" TorrentChecking.__single = self Thread.__init__(self) self.setName('TorrentChecking'+self.getName()) if DEBUG: print >> sys.stderr, 'TorrentChecking: Started torrentchecking from', threading.currentThread().getName() self.setDaemon(True) self.retryThreshold = 10 self.interval = interval self.shouldquit = False self.queue = deque() self.queueset = set() self.queueLock = Lock() self.announceQueue = Queue() self.mldhtchecker = mainlineDHTChecker.getInstance() self.torrentdb = TorrentDBHandler.getInstance() self.sleepEvent = threading.Event() self.torrent_collection_dir = Session.get_instance().get_torrent_collecting_dir() self.start()
def __init__(self, parent): HomePanel.__init__(self, parent, 'Newest Torrents', LIST_BLUE) self.Layout() self.torrentdb = TorrentDBHandler.getInstance() session = Session.get_instance() session.add_observer(self.OnNotify, NTFY_TORRENTS, [NTFY_INSERT])
def start_tribler(self): """ Starts the headless Tribler session with the correct configuration set """ config = SessionStartupConfig() config.set_state_dir(os.path.join(config.get_state_dir(), "tunnel-%d") % self.settings.socks_listen_ports[0]) config.set_torrent_checking(False) config.set_multicast_local_peer_discovery(False) config.set_megacache(False) config.set_dispersy(True) config.set_mainline_dht(True) config.set_torrent_collecting(False) config.set_libtorrent(True) config.set_dht_torrent_collecting(False) config.set_enable_torrent_search(False) config.set_videoplayer(False) config.set_dispersy_port(self.dispersy_port) config.set_enable_torrent_search(False) config.set_enable_channel_search(False) config.set_enable_multichain(True) self.session = Session(config) upgrader = self.session.prestart() while not upgrader.is_done: time.sleep(0.1) self.session.start() logger.info("Using port %d" % self.session.get_dispersy_port())
def setupSeeder(self): from Tribler.Core.Session import Session from Tribler.Core.TorrentDef import TorrentDef from Tribler.Core.DownloadConfig import DownloadStartupConfig self.setUpPreSession() self.config.set_libtorrent(True) self.config2 = self.config.copy() self.session2 = Session(self.config2, ignore_singleton=True) upgrader = self.session2.prestart() while not upgrader.is_done: time.sleep(0.1) assert not upgrader.failed, upgrader.current_status self.session2.start() tdef = TorrentDef() tdef.add_content(os.path.join(TESTS_DATA_DIR, "video.avi")) tdef.set_tracker("http://fake.net/announce") tdef.finalize() torrentfn = os.path.join(self.session.get_state_dir(), "gen.torrent") tdef.save(torrentfn) dscfg = DownloadStartupConfig() dscfg.set_dest_dir(TESTS_DATA_DIR) # basedir of the file we are seeding d = self.session2.start_download(tdef, dscfg) d.set_state_callback(self.seeder_state_callback) return torrentfn
def setUp(self, annotate=True): super(TestRestApiUtil, self).setUp(annotate=annotate) config = TriblerConfig() config.set_state_dir(self.getStateDir()) config.get_dispersy_enabled = lambda: False self.session = Session(config)
def test_create_channel_duplicate_name_error(self): config = TriblerConfig() config.set_state_dir(self.getStateDir()) self.session = Session(config) class LmMock(object): channel_manager = ChannelManager(self.session) self.session.lm = LmMock() class MockCommunity(object): cid = "" def get_channel_name(self): return "Channel name" channel_obj = ChannelObject(self.session, MockCommunity(), is_created=True) self.session.lm.channel_manager._channel_list = [channel_obj] with self.assertRaises(DuplicateChannelNameError) as cm: self.session.lm.channel_manager.create_channel( "Channel name", "description", "open") self.assertEqual(cm.exception.message, u"Channel name already exists: Channel name")
def readTorrent(self, torrent): try: torrent_path = torrent['torrent_path'] if not path.isfile(torrent_path): #torrent not found, try filename + current torrent collection directory torrent_collection_dir = Session.get_instance().get_torrent_collecting_dir() _, torrent_filename = path.split(torrent_path) torrent_path = path.join(torrent_collection_dir, torrent_filename) if not path.isfile(torrent_path): #torrent still not found, determine filename + current torrent collection directory torrent_path = path.join(torrent_collection_dir, get_collected_torrent_filename(torrent['infohash'])) if path.isfile(torrent_path): f = open(torrent_path,'rb') _data = f.read() f.close() data = bdecode(_data) assert 'info' in data del data['info'] torrent['info'] = data return torrent except Exception: #print_exc() return torrent
def test_rel_score_remote_torrent(self): mocked_db = MockObject() mocked_db.latest_matchinfo_torrent = struct.pack( "I" * 12, *([1] * 12)), "torrent" Session.get_instance().open_dbhandler = lambda _: mocked_db self.assertNotEqual(relevance_score_remote_torrent("my-torrent.iso"), 0.0)
def readTorrent(self, torrent): try: torrent_path = torrent['torrent_path'] if not path.isfile(torrent_path): #torrent not found, try filename + current torrent collection directory torrent_collection_dir = Session.get_instance( ).get_torrent_collecting_dir() _, torrent_filename = path.split(torrent_path) torrent_path = path.join(torrent_collection_dir, torrent_filename) if not path.isfile(torrent_path): #torrent still not found, determine filename + current torrent collection directory torrent_path = path.join( torrent_collection_dir, get_collected_torrent_filename(torrent['infohash'])) if path.isfile(torrent_path): f = open(torrent_path, 'rb') _data = f.read() f.close() data = bdecode(_data) assert 'info' in data del data['info'] torrent['info'] = data return torrent except Exception: #print_exc() return torrent
def create_session(self, index): """ Create a single session and load the tunnel community in the session of that proxy. """ from Tribler.Core.Session import Session config = self.config.copy() config.set_state_dir(self.getStateDir(index)) session = Session(config, ignore_singleton=True, autoload_discovery=False) yield session.start() self.sessions.append(session) market_member = self.generate_member(session) mc_community = self.load_triblerchain_community_in_session(session) self.load_market_community_in_session(session, market_member, mc_community) returnValue(session)
def tearDown(self): self.annotate(self._testMethodName, start=False) """ unittest test tear down code """ if self.session is not None: self._shutdown_session(self.session) Session.del_instance() time.sleep(10) gc.collect() ts = enumerate_threads() self._logger.debug("test_as_server: Number of threads still running %d", len(ts)) for t in ts: self._logger.debug("Thread still running %s, daemon: %s, instance: %s", t.getName(), t.isDaemon(), t) super(TestAsServer, self).tearDown(annotate=False)
def __init__(self, parent): HomePanel.__init__(self, parent, 'Peer Discovery' , LIST_BLUE) session = Session.get_instance() session.add_observer(self.OnNotify, NTFY_PROXYDISCOVERY, [NTFY_INSERT]) self.proxies=[] self.OnNotify(None, None, None, session.lm.overlay_apps.proxy_peer_manager.available_proxies.keys())
def start_tribler(): config = TriblerConfig() patch_wallet_methods() patch_iom_methods() config.set_http_api_port(API_PORT) config.set_http_api_enabled(True) # Check if we are already running a Tribler instance process_checker = ProcessChecker(config.get_state_dir()) if process_checker.already_running: return session = Session(config) signal.signal(signal.SIGTERM, lambda signum, stack: shutdown(session, signum, stack)) session.start()
def create_proxy(self, index, exitnode=False): """ Create a single proxy and load the tunnel community in the session of that proxy. """ from Tribler.Core.Session import Session self.setUpPreSession() config = self.config.copy() config.set_libtorrent_enabled(True) config.set_state_dir(self.getStateDir(index)) config.set_tunnel_community_socks5_listen_ports(self.get_socks5_ports()) session = Session(config) yield session.start() self.sessions.append(session) returnValue(self.load_tunnel_community_in_session(session, exitnode=exitnode))
def setUp(self): """ override TestAsServer """ TestAsServer.setUp(self) self.session2 = Session(self.config2, ignore_singleton=True) self.session2.start() self.seeding_event = threading.Event()
def setup_peer(self): """ Setup a second peer that contains some search results. """ self.setUpPreSession() self.config2 = self.config.copy() self.config2.set_state_dir(self.getStateDir(2)) self.session2 = Session(self.config2) yield self.session2.start() self.dispersy2 = self.session2.get_dispersy_instance() @inlineCallbacks def unload_communities(): for community in self.dispersy.get_communities(): if isinstance(community, SearchCommunity) or isinstance(community, AllChannelCommunity): yield community.unload_community() for community in self.dispersy2.get_communities(): if isinstance(community, SearchCommunity) or isinstance(community, AllChannelCommunity): yield community.unload_community() def load_communities(): self.search_community = \ self.dispersy.define_auto_load(SearchCommunityTests, self.session.dispersy_member, load=True, kargs={'tribler_session': self.session})[0] self.dispersy2.define_auto_load(SearchCommunityTests, self.session2.dispersy_member, load=True, kargs={'tribler_session': self.session2}) self.allchannel_community = \ self.dispersy.define_auto_load(AllChannelCommunityTests, self.session.dispersy_member, load=True, kargs={'tribler_session': self.session})[0] self.dispersy2.define_auto_load(AllChannelCommunityTests, self.session2.dispersy_member, load=True, kargs={'tribler_session': self.session2}) yield unload_communities() load_communities() self.search_community.add_discovered_candidate(Candidate(self.dispersy2.lan_address, tunnel=False)) self.allchannel_community.add_discovered_candidate(Candidate(self.dispersy2.lan_address, tunnel=False)) # Add some content to second session torrent_db_handler = self.session2.open_dbhandler(NTFY_TORRENTS) torrent_db_handler.addExternalTorrentNoDef(str(unichr(97)) * 20, 'test test', [('Test.txt', 1337)], [], 1337) torrent_db_handler.updateTorrent(str(unichr(97)) * 20, is_collected=1) channel_db_handler = self.session2.open_dbhandler(NTFY_CHANNELCAST) channel_db_handler.on_channel_from_dispersy('f' * 20, 42, "test", "channel for unit tests") torrent_list = [ [1, 1, 1, ('a' * 40).decode('hex'), 1460000000, "ubuntu-torrent.iso", [['file1.txt', 42]], []] ] channel_db_handler.on_torrents_from_dispersy(torrent_list) # We also need to add the channel to the database of the session initiating the search channel_db_handler = self.session.open_dbhandler(NTFY_CHANNELCAST) channel_db_handler.on_channel_from_dispersy('f' * 20, 42, "test", "channel for unit tests")
def start_tribler(self, options): """ Main method to startup Tribler. """ def on_tribler_shutdown(_): msg("Tribler shut down") reactor.stop() self.process_checker.remove_lock_file() def signal_handler(sig, _): msg("Received shut down signal %s" % sig) if not self._stopping: self._stopping = True self.session.shutdown().addCallback(on_tribler_shutdown) signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGTERM, signal_handler) config = TriblerConfig() config.set_torrent_checking_enabled(False) config.set_megacache_enabled(True) config.set_dispersy_enabled(False) config.set_mainline_dht_enabled(True) config.set_torrent_collecting_enabled(False) config.set_libtorrent_enabled(False) config.set_http_api_enabled(True) config.set_video_server_enabled(False) config.set_torrent_search_enabled(False) config.set_channel_search_enabled(False) config.set_credit_mining_enabled(False) config.set_dummy_wallets_enabled(True) config.set_popularity_community_enabled(False) # Check if we are already running a Tribler instance self.process_checker = ProcessChecker() if self.process_checker.already_running: self.shutdown_process("Another Tribler instance is already using statedir %s" % config.get_state_dir()) return msg("Starting Tribler") if options["statedir"]: config.set_state_dir(options["statedir"]) if options["restapi"] > 0: config.set_http_api_enabled(True) config.set_http_api_port(options["restapi"]) if options["ipv8"] != -1 and options["ipv8"] > 0: config.set_dispersy_port(options["ipv8"]) if "testnet" in options and options["testnet"]: config.set_testnet(True) self.session = Session(config) self.session.start().addErrback(lambda failure: self.shutdown_process(failure.getErrorMessage())) msg("Tribler started")
def setUp(self, annotate=True): super(TestTorrentChecker, self).setUp(annotate=annotate) config = TriblerConfig() config.set_state_dir(self.getStateDir()) config.set_megacache_enabled(True) self.session = Session(config) self.session.start_database() self.session.lm.torrent_db = TorrentDBHandler(self.session) self.session.lm.torrent_checker = TorrentChecker(self.session) self.session.lm.tracker_manager = TrackerManager(self.session) self.session.lm.popularity_community = MockObject() self.torrent_checker = self.session.lm.torrent_checker self.torrent_checker._torrent_db = self.session.open_dbhandler(NTFY_TORRENTS) self.torrent_checker._torrent_db.category = Category() self.torrent_checker.listen_on_udp = lambda: None
def setUp(self): yield super(AbstractUpgrader, self).setUp() self.config = TriblerConfig(ConfigObj(configspec=CONFIG_SPEC_PATH)) self.config.set_state_dir(self.getStateDir()) self.config.set_torrent_collecting_dir( os.path.join(self.session_base_dir, 'torrent_collecting_dir')) self.session = Session(self.config) self.sqlitedb = None self.torrent_store = None
def setUp(self, annotate=True): super(TestDHTSession, self).setUp(annotate=annotate) config = SessionStartupConfig() config.set_state_dir(self.getStateDir()) self.session = Session(config, ignore_singleton=True) self.dht_session = FakeDHTSession(self.session, 'a' * 20, 10)
def __init__(self): from Tribler.Core.Session import Session # Circular import fix self.session = Session.get_instance() self.peerdb = RePEXLogDB.getInstance() self.downloads = {} # infohash -> Download self.swarmcaches = {} # Download -> [SwarmCache] self.repexers = {} # Download -> [repexer] # register as global observer RePEXer.attach_observer(self)
def setUp(self, annotate=True): super(TestDHTSession, self).setUp(annotate=annotate) config = TriblerConfig() config.set_state_dir(self.getStateDir()) self.session = Session(config) self.dht_session = FakeDHTSession(self.session, 'a' * 20, 10)
def start_tribler(): config = TriblerConfig() priority_order = config.get_cpu_priority_order() set_process_priority(pid=os.getpid(), priority_order=priority_order) config.set_http_api_port(int(api_port)) config.set_http_api_enabled(True) # Check if we are already running a Tribler instance process_checker = ProcessChecker(config.get_state_dir()) if process_checker.already_running: return else: process_checker.create_lock_file() session = Session(config) signal.signal(signal.SIGTERM, lambda signum, stack: shutdown(session, signum, stack)) session.start()
def saveDefaultDownloadConfig(self, scfg): state_dir = self.utility.session.get_state_dir() # Save DownloadStartupConfig dlcfgfilename = get_default_dscfg_filename(state_dir) self.defaultDLConfig.save(dlcfgfilename) # Save SessionStartupConfig cfgfilename = Session.get_default_config_filename(state_dir) scfg.save(cfgfilename)
def _stop(self): if self.clean_messages_lc: self.clean_messages_lc.stop() self.clean_messages_lc = None if self.build_history_lc: self.build_history_lc.stop() self.build_history_lc = None if self.session: session_shutdown_start = time.time() waittime = 60 self.session.shutdown() while not self.session.has_shutdown(): diff = time.time() - session_shutdown_start assert diff < waittime, "Took too long for Session to shutdown" logger.info("ONEXIT Waiting for Session to shutdown, will wait for %d more seconds" % ( waittime - diff)) time.sleep(1) logger.info("Session is shut down") Session.del_instance()
def __init__(self): # always use getInstance() to create this object # ARNOCOMMENT: why isn't the lock used on this read?! if self.__single != None: raise RuntimeError, "RePEXScheduler is singleton" from Tribler.Core.Session import Session # Circular import fix self.session = Session.get_instance() self.lock = RLock() self.active = False self.current_repex = None # infohash self.downloads = {} # infohash -> Download; in order to stop Downloads that are done repexing self.last_attempts = {} # infohash -> ts; in order to prevent starvation when a certain download