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 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, ignore_singleton=True) 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 start_tribler(): config = TriblerConfig() global trace_logger # Enable tracer if --trace-debug or --trace-exceptions flag is present in sys.argv trace_logger = check_and_enable_code_tracing('core') 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 setUp(self, autoload_discovery=True): yield super(TestAsServer, self).setUp(annotate=False) self.setUpPreSession() # We don't use the system keychain but a PlainText keyring for performance during tests for new_keyring in keyring.backend.get_all_keyring(): if isinstance(new_keyring, PlaintextKeyring): keyring.set_keyring(new_keyring) self.quitting = False self.seeding_deferred = Deferred() self.seeder_session = None self.seed_config = None self.session = Session(self.config) self.session.upgrader_enabled = False self.tribler_started_deferred = self.session.start() yield self.tribler_started_deferred self.assertTrue(self.session.lm.initComplete) self.hisport = self.session.config.get_libtorrent_port() self.annotate(self._testMethodName, start=True)
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(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 start_tribler(self): 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_videoserver_enabled(False) config.set_dispersy_port(self.dispersy_port) config.set_enable_torrent_search(False) config.set_enable_channel_search(False) config.set_enable_multichain(self.settings.enable_multichain) # We do not want to load the TunnelCommunity in the session but instead our own community config.set_tunnel_community_enabled(False) self.session = Session(config) self.session.start() logger.info("Using Dispersy port %d" % self.session.get_dispersy_port())
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(self): yield super(TestTrackerManager, self).setUp() self.setUpPreSession() self.session = Session(self.config) self.session.start_database() self.tracker_manager = TrackerManager(self.session)
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_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") torrentfn = os.path.join(self.session2.config.get_state_dir(), "gen.torrent") tdef.save(torrent_filepath=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 setUp(self, annotate=True): yield super(TestTrackerManager, self).setUp(annotate=annotate) self.setUpPreSession() self.session = Session(self.config, ignore_singleton=True) self.session.start_database() self.tracker_manager = TrackerManager(self.session)
def setup_seeder(self, tdef, seed_dir): self.seed_config = TriblerConfig() self.seed_config.set_torrent_checking_enabled(False) self.seed_config.set_megacache_enabled(False) self.seed_config.set_dispersy_enabled(False) self.seed_config.set_mainline_dht_enabled(False) self.seed_config.set_torrent_store_enabled(False) self.seed_config.set_torrent_search_enabled(False) self.seed_config.set_channel_search_enabled(False) self.seed_config.set_torrent_collecting_enabled(False) self.seed_config.set_libtorrent_enabled(True) self.seed_config.set_video_server_enabled(False) self.seed_config.set_metadata_enabled(False) self.seed_config.set_upgrader_enabled(False) self.seed_config.set_tunnel_community_enabled(False) self.seed_config.set_state_dir(self.getStateDir(2)) 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, ignore_singleton=True) self.seeder_session.start().addCallback(start_seed_download) return self.seeding_deferred
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, ignore_singleton=True, autoload_discovery=False) 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) from twisted.internet import reactor, task while not list(self.tunnel_community_seeder.active_data_circuits()): yield task.deferLater(reactor, .05, lambda: None) 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 test_torrent_store_delete(self): config = TriblerConfig() config.set_state_dir(self.getStateDir()) config.set_torrent_store_enabled(True) session = Session(config, ignore_singleton=True) # Manually set the torrent store as we don't want to start the session. session.lm.torrent_store = LevelDbStore( session.config.get_torrent_store_dir()) session.lm.torrent_store[hexlify("fakehash")] = "Something" self.assertEqual("Something", session.lm.torrent_store[hexlify("fakehash")]) session.delete_collected_torrent("fakehash") raised_key_error = False # This structure is needed because if we add a @raises above the test, we cannot close the DB # resulting in a dirty reactor. try: self.assertRaises(KeyError, session.lm.torrent_store[hexlify("fakehash")]) except KeyError: raised_key_error = True finally: session.lm.torrent_store.close() self.assertTrue(raised_key_error)
def start(self): # Determine socks5 ports socks5_port = self.options['socks5'] 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_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"])) if "testnet" in self.options and self.options["testnet"]: config.set_ipv8_use_testnet(True) self.session = Session(config) logger.info("Using IPv8 port %d" % self.session.config.get_dispersy_port()) return self.session.start()
def setUp(self): yield super(AbstractUpgrader, self).setUp() self.config = SessionStartupConfig() self.config.set_torrent_collecting_dir( os.path.join(self.session_base_dir, 'torrent_collecting_dir')) self.session = Session(self.config, ignore_singleton=True) self.sqlitedb = None self.torrent_store = None
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 setup_downloader(self): self.config2 = self.config.copy() self.config2.set_megacache_enabled(True) self.config2.set_torrent_collecting_enabled(True) self.config2.set_metadata_enabled(True) self.config2.set_state_dir(self.getStateDir(2)) self.session2 = Session(self.config2) return self.session2.start()
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_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"])) if self.options["restapi"] is not None: config.set_http_api_enabled(True) config.set_http_api_port(self.options["restapi"]) if self.options["ipv8_bootstrap_override"] is not None: 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 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 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 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 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["dispersy"] > 0: config.set_dispersy_port(options["dispersy"]) if options["libtorrent"] != -1 and options["libtorrent"] > 0: config.set_libtorrent_port(options["libtorrent"]) self.session = Session(config) self.session.start().addErrback(lambda failure: self.shutdown_process(failure.getErrorMessage())) msg("Tribler started") if "auto-join-channel" in options and options["auto-join-channel"]: msg("Enabling auto-joining of channels") for community in self.session.get_dispersy_instance().get_communities(): if isinstance(community, AllChannelCommunity): community.auto_join_channel = True if "log-incoming-searches" in options and options["log-incoming-searches"]: msg("Logging incoming remote searches") for community in self.session.get_dispersy_instance().get_communities(): if isinstance(community, SearchCommunity): community.log_incoming_searches = self.log_incoming_remote_search
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 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 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 setUp(self): yield super(AbstractDB, self).setUp() self.setUpPreSession() self.session = Session(self.config) 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.session.sqlite_db = self.sqlitedb
def main(define_communities): command_line_parser = optparse.OptionParser() command_line_parser.add_option("--statedir", action="store", type="string", help="Use an alternate statedir") command_line_parser.add_option("--port", action="store", type="int", help="Listen at this port") command_line_parser.add_option("--nickname", action="store", type="string", help="The moderator name") # parse command-line arguments opt, args = command_line_parser.parse_args() logger.info( "Press Q followed by <ENTER> to stop the channelcast-supporter") sscfg = SessionStartupConfig() if opt.statedir: sscfg.set_state_dir(os.path.realpath(opt.statedir)) if opt.port: sscfg.set_listen_port(opt.port) if opt.nickname: sscfg.set_nickname(opt.nickname) sscfg.set_megacache(True) sscfg.set_dispersy(True) sscfg.set_torrent_collecting(True) session = Session(sscfg) session.start() dispersy = session.get_dispersy_instance() define_communities(session) try: while True: x = sys.stdin.readline() logger.info(repr(x)) if x.strip() == 'Q': break except: print_exc() session.shutdown() logger.info("Shutting down...") time.sleep(5)