def setUp(self): super(TestRestApiUtil, self).setUp() config = TriblerConfig() config.set_state_dir(self.getStateDir()) config.get_dispersy_enabled = lambda: False self.session = Session(config)
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 setUp(self, annotate=True): """ Create a new TriblerConfig instance """ super(TestTriblerConfig, self).setUp(annotate=annotate) self.tribler_config = TriblerConfig() self.assertIsNotNone(self.tribler_config)
class AbstractUpgrader(TriblerCoreTest): FILE_DIR = os.path.abspath(os.path.dirname(os.path.realpath(__file__))) DATABASES_DIR = os.path.abspath( os.path.join(FILE_DIR, u"../data/upgrade_databases/")) def write_data_to_file(self, file_name): with open(file_name, 'w') as file: file.write("lorem ipsum") file.close() @inlineCallbacks 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 tearDown(self): if self.torrent_store: self.torrent_store.close() if self.sqlitedb: self.sqlitedb.close() self.sqlitedb = None super(AbstractUpgrader, self).tearDown() def copy_and_initialize_upgrade_database(self, db_name): # create a file to be removed in the thumbnails os.mkdir(self.session.config.get_torrent_collecting_dir()) os.mkdir( os.path.join(self.session.config.get_torrent_collecting_dir(), 'dir1')) self.write_data_to_file( os.path.join(self.session.config.get_torrent_collecting_dir(), 'dir1', 'file1.txt')) os.mkdir(os.path.join(self.session_base_dir, 'sqlite')) shutil.copyfile( os.path.join(self.DATABASES_DIR, db_name), os.path.join(self.session.config.get_state_dir(), 'sqlite', 'tribler.sdb')) shutil.copyfile( os.path.join(self.DATABASES_DIR, 'torrent_upgrade_64_dispersy.db'), os.path.join(self.session.config.get_state_dir(), 'sqlite', 'dispersy.db')) db_path = os.path.join(self.session.config.get_state_dir(), 'sqlite', 'tribler.sdb') self.sqlitedb = SQLiteCacheDB(db_path) self.sqlitedb.initialize() self.sqlitedb.initial_begin() self.session.sqlite_db = self.sqlitedb
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 setUp(self, annotate=True): super(TestTriblerConfig, self).setUp(annotate=annotate) self.mock_session = MockObject() self.mock_session.get_state_dir = lambda: self.session_base_dir self.tribler_conf = TriblerConfig(self.mock_session) self.assertIsNotNone(self.tribler_conf) self.assertEqual(self.tribler_conf.config['user_download_states'], {})
def setUp(self): super(TestDHTSession, self).setUp() config = TriblerConfig() config.set_state_dir(self.getStateDir()) self.session = Session(config) self.dht_session = FakeDHTSession(self.session, 'a' * 20, 10)
def setUp(self): """ Create a new TriblerConfig instance """ super(TestTriblerConfig, self).setUp() self.tribler_config = TriblerConfig() self.tribler_config.get_default_state_dir = lambda **_: self.getStateDir( ) self.tribler_config.set_state_dir(self.getStateDir()) self.assertIsNotNone(self.tribler_config)
def test_init_with_config(self): """ When creating a new instance with a configobject provided, the given options must be contained in the resulting instance. """ configdict = ConfigObj({"a": 1, "b": "2"}, configspec=CONFIG_SPEC_PATH) self.tribler_config = TriblerConfig(configdict) self.tribler_config.validate() for key, value in configdict.items(): self.assertEqual(self.tribler_config.config[key], value)
class AbstractUpgrader(TriblerCoreTest): FILE_DIR = os.path.abspath(os.path.dirname(os.path.realpath(__file__))) DATABASES_DIR = os.path.abspath(os.path.join(FILE_DIR, u"../data/upgrade_databases/")) @inlineCallbacks def setUp(self): yield super(AbstractUpgrader, self).setUp() self.config = TriblerConfig(ConfigObj(configspec=CONFIG_SPEC_PATH)) self.config.set_state_dir(self.getStateDir()) self.session = Session(self.config)
def setUpPreSession(self): self.config = TriblerConfig(ConfigObj(configspec=CONFIG_SPEC_PATH)) self.config.set_state_dir(self.getStateDir()) self.config.set_torrent_checking_enabled(False) self.config.set_megacache_enabled(False) self.config.set_dispersy_enabled(False) self.config.set_mainline_dht_enabled(False) self.config.set_torrent_collecting_enabled(False) self.config.set_libtorrent_enabled(False) self.config.set_video_server_enabled(False) self.config.set_torrent_store_enabled(False)
class AbstractUpgrader(TriblerCoreTest): FILE_DIR = os.path.abspath(os.path.dirname(os.path.realpath(__file__))) DATABASES_DIR = os.path.abspath( os.path.join(FILE_DIR, u"../data/upgrade_databases/")) @inlineCallbacks def setUp(self): yield super(AbstractUpgrader, self).setUp() self.config = TriblerConfig(ConfigObj(configspec=CONFIG_SPEC_PATH)) self.config.set_state_dir(self.getStateDir()) self.session = Session(self.config)
def test_read_test_libtribler_conf(self): """ Test upgrading a libtribler configuration from 7.0 to 7.1 """ os.environ['TSTATEDIR'] = self.session_base_dir old_config = RawConfigParser() old_config.read(os.path.join(self.CONFIG_PATH, "libtribler70.conf")) new_config = TriblerConfig() result_config = add_libtribler_config(new_config, old_config) self.assertEqual(result_config.get_permid_keypair_filename(), "/anon/TriblerDir.gif") self.assertEqual( result_config.get_tunnel_community_socks5_listen_ports(), [1, 2, 3, 4, 5, 6]) self.assertTrue(result_config.get_metadata_store_dir().endswith( "/home/.Tribler/testFile")) self.assertEqual(result_config.get_anon_proxy_settings(), (2, ("127.0.0.1", [5, 4, 3, 2, 1]), '')) self.assertEqual( result_config.get_credit_mining_sources(), { 'boosting_sources': ['source1', 'source2'], 'boosting_enabled': ['testenabled'], 'boosting_disabled': ['testdisabled'], 'archive_sources': ['testarchive'] })
def test_convert_session_config(self): old_pickle_dict = { "state_dir": "/", "mainline_dht_port": 1337, "torrent_checking": "false", "torrent_collecting": "true", "libtorrent": False, "dispersy_port": 1337, "minport": 1234 } self.write_pickle_file(old_pickle_dict, "sessconfig.pickle") PickleConverter(self.mock_session).convert_session_config() self.assertTrue( os.path.exists( os.path.join(self.session_base_dir, TRIBLER_CONFIG_FILENAME))) self.assertFalse( os.path.exists( os.path.join(self.session_base_dir, "sessconfig.pickle"))) # Check the content of the config file config = TriblerConfig.load(config_path=os.path.join( self.session_base_dir, TRIBLER_CONFIG_FILENAME)) self.assertEqual(config.get_state_dir(), '/') self.assertEqual(config.get_mainline_dht_port(), 1337) self.assertEqual(config.get_torrent_checking_enabled(), False) self.assertEqual(config.get_torrent_collecting_enabled(), True) self.assertFalse(config.get_libtorrent_enabled()) self.assertEqual(config.get_dispersy_port(), 1337) self.assertEqual(config.get_libtorrent_port(), 1234)
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): super(TestPickleConverter, self).setUp() self.mock_session = MockObject() self.mock_session.get_downloads_pstate_dir = lambda: self.session_base_dir self.mock_session.config = TriblerConfig() self.mock_session.config.get_state_dir = lambda: self.session_base_dir
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 __init__(self, state_directory=None): """ Check whether a lock file exists in the Tribler directory. If not, create the file. If it exists, check the PID that is written inside the lock file. """ self.already_running = False self.state_directory = state_directory or TriblerConfig().get_state_dir() self.lock_file_path = os.path.join(self.state_directory, LOCK_FILE_NAME) if os.path.exists(self.lock_file_path): try: file_pid = int(self.get_pid_from_lock_file()) except ValueError: # Apparently, the data written inside the lock file is not an int, just remove the file and recreate it. self.remove_lock_file() self.create_lock_file() return if file_pid == os.getpid(): # Ignore when we find our own PID inside the lock file self.already_running = False elif file_pid != os.getpid() and not ProcessChecker.is_pid_running(file_pid): # The process ID written inside the lock file is old, just remove the lock file and create a new one. self.remove_lock_file() self.create_lock_file() else: self.already_running = True else: self.create_lock_file()
def setUpPreSession(self): self.config = TriblerConfig(ConfigObj(configspec=CONFIG_SPEC_PATH, encoding='latin_1')) self.config.set_default_destination_dir(self.dest_dir) self.config.set_state_dir(self.getStateDir()) self.config.set_torrent_checking_enabled(False) self.config.set_megacache_enabled(False) self.config.set_dispersy_enabled(False) self.config.set_ipv8_enabled(False) self.config.set_mainline_dht_enabled(False) self.config.set_torrent_store_enabled(False) self.config.set_torrent_search_enabled(False) self.config.set_channel_search_enabled(False) self.config.set_torrent_collecting_enabled(False) self.config.set_libtorrent_enabled(False) self.config.set_video_server_enabled(False) self.config.set_metadata_enabled(False) self.config.set_http_api_enabled(False) self.config.set_tunnel_community_enabled(False) self.config.set_credit_mining_enabled(False) self.config.set_market_community_enabled(False) self.config.set_popularity_community_enabled(False) self.config.set_dht_enabled(False) self.config.set_version_checker_enabled(False) self.config.set_libtorrent_dht_enabled(False) self.config.set_bitcoinlib_enabled(False) self.config.set_chant_enabled(False)
def setup_logging(gui=False): """ Setup logging to write logs to files inside \ .Tribler directory in each platforms """ # First check if logger.conf is present or not base_path = getattr(sys, '_MEIPASS') if hasattr( sys, '_MEIPASS') else os.path.dirname(__file__) log_config = os.path.join(base_path, "logger.conf") if not os.path.exists(log_config): print "Log configuration file not found at location '%s'" % log_config return log_directory = TriblerConfig().get_log_dir() if not os.path.exists(log_directory): os.makedirs(log_directory) info_filename = 'tribler-gui-info.log' if gui else 'tribler-core-info.log' error_filename = 'tribler-gui-error.log' if gui else 'tribler-core-error.log' logging.info_log_file = os.path.join(log_directory, info_filename) logging.error_log_file = os.path.join(log_directory, error_filename) logging.config.fileConfig(log_config, disable_existing_loggers=False)
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): """ Create a new TriblerConfig instance """ super(TestTriblerConfig, self).setUp() self.tribler_config = TriblerConfig() self.assertIsNotNone(self.tribler_config)
def test_read_test_corr_libtribler_conf(self): """ Adding corrupt values should result in the default value. Note that this test might fail if there is already an upgraded config stored in the default state directory. The code being tested here however shouldn't be ran if that config already exists. :return: """ old_config = RawConfigParser() old_config.read(os.path.join(self.CONFIG_PATH, "libtriblercorrupt70.conf")) new_config = TriblerConfig(ConfigObj(configspec=CONFIG_SPEC_PATH)) result_config = add_libtribler_config(new_config, old_config) self.assertTrue(len(result_config.get_tunnel_community_socks5_listen_ports()), 5) self.assertEqual(result_config.get_anon_proxy_settings(), (2, ('127.0.0.1', [-1, -1, -1, -1, -1]), '')) self.assertEqual(result_config.get_credit_mining_sources(), new_config.get_credit_mining_sources())
def setUp(self): super(TestDHTSession, self).setUp() config = TriblerConfig() config.set_state_dir(self.getStateDir()) self.session = Session(config) self.session.lm.ltmgr = MockObject() self.session.lm.ltmgr.dht_health_manager = MockObject() dht_health_dict = { "infohash": hexlify('a' * 20), "seeders": 1, "leechers": 2 } self.session.lm.ltmgr.dht_health_manager.get_health = lambda *_, **__: succeed({"DHT": [dht_health_dict]}) 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
class AbstractUpgrader(TriblerCoreTest): FILE_DIR = os.path.abspath(os.path.dirname(os.path.realpath(__file__))) DATABASES_DIR = os.path.abspath(os.path.join(FILE_DIR, u"../data/upgrade_databases/")) def write_data_to_file(self, file_name): with open(file_name, 'w') as file: file.write("lorem ipsum") file.close() @inlineCallbacks 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 tearDown(self): if self.torrent_store: self.torrent_store.close() if self.sqlitedb: self.sqlitedb.close() self.sqlitedb = None super(AbstractUpgrader, self).tearDown() def copy_and_initialize_upgrade_database(self, db_name): # create a file to be removed in the thumbnails os.mkdir(self.session.config.get_torrent_collecting_dir()) os.mkdir(os.path.join(self.session.config.get_torrent_collecting_dir(), 'dir1')) self.write_data_to_file(os.path.join(self.session.config.get_torrent_collecting_dir(), 'dir1', 'file1.txt')) os.mkdir(os.path.join(self.session_base_dir, 'sqlite')) shutil.copyfile(os.path.join(self.DATABASES_DIR, db_name), os.path.join(self.session.config.get_state_dir(), 'sqlite', 'tribler.sdb')) shutil.copyfile(os.path.join(self.DATABASES_DIR, 'torrent_upgrade_64_dispersy.db'), os.path.join(self.session.config.get_state_dir(), 'sqlite', 'dispersy.db')) db_path = os.path.join(self.session.config.get_state_dir(), 'sqlite', 'tribler.sdb') self.sqlitedb = SQLiteCacheDB(db_path) self.session.sqlite_db = self.sqlitedb
def test_read_test_tribler_conf(self): """ Test upgrading a Tribler configuration from 7.0 to 7.1 """ old_config = RawConfigParser() old_config.read(os.path.join(self.CONFIG_PATH, "tribler70.conf")) new_config = TriblerConfig() result_config = add_tribler_config(new_config, old_config) self.assertEqual(result_config.get_default_safeseeding_enabled(), True)
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)
class TestTriblerConfig(TriblerCoreTest): """ This class contains tests for the tribler configuration file. """ def setUp(self, annotate=True): super(TestTriblerConfig, self).setUp(annotate=annotate) self.mock_session = MockObject() self.mock_session.get_state_dir = lambda: self.session_base_dir self.tribler_conf = TriblerConfig(self.mock_session) self.assertIsNotNone(self.tribler_conf) self.assertEqual(self.tribler_conf.config['user_download_states'], {}) def test_set_family_filter(self): self.tribler_conf.set_family_filter_enabled(False) self.assertFalse(self.tribler_conf.get_family_filter_enabled())
def setUp(self): """ Create a new TriblerConfig instance """ super(TestTriblerConfig, self).setUp() self.tribler_config = TriblerConfig() self.tribler_config.get_default_state_dir = lambda **_: self.getStateDir() self.tribler_config.set_state_dir(self.getStateDir()) self.assertIsNotNone(self.tribler_config)
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_megacache_enabled(False) self.seed_config.set_dispersy_enabled(False) self.seed_config.set_ipv8_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_http_api_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_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) 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 setUpPreSession(self): self.config = TriblerConfig(ConfigObj(configspec=CONFIG_SPEC_PATH)) self.config.set_default_destination_dir(self.dest_dir) self.config.set_state_dir(self.getStateDir()) self.config.set_torrent_checking_enabled(False) self.config.set_megacache_enabled(False) self.config.set_dispersy_enabled(False) self.config.set_mainline_dht_enabled(False) self.config.set_torrent_store_enabled(False) self.config.set_torrent_search_enabled(False) self.config.set_channel_search_enabled(False) self.config.set_torrent_collecting_enabled(False) self.config.set_libtorrent_enabled(False) self.config.set_video_server_enabled(False) self.config.set_metadata_enabled(False) self.config.set_upgrader_enabled(False) self.config.set_http_api_enabled(False) self.config.set_tunnel_community_enabled(False) self.config.set_credit_mining_enabled(False) self.config.set_trustchain_enabled(False)
def setUpPreSession(self): self.config = TriblerConfig( ConfigObj(configspec=CONFIG_SPEC_PATH, default_encoding='utf-8')) self.config.set_default_destination_dir(self.dest_dir) self.config.set_state_dir(self.getStateDir()) self.config.set_torrent_checking_enabled(False) self.config.set_ipv8_enabled(False) self.config.set_libtorrent_enabled(False) self.config.set_video_server_enabled(False) self.config.set_http_api_enabled(False) self.config.set_tunnel_community_enabled(False) self.config.set_credit_mining_enabled(False) self.config.set_market_community_enabled(False) self.config.set_popularity_community_enabled(False) self.config.set_dht_enabled(False) self.config.set_version_checker_enabled(False) self.config.set_libtorrent_dht_enabled(False) self.config.set_bitcoinlib_enabled(False) self.config.set_chant_enabled(False) self.config.set_resource_monitor_enabled(False)
def test_write_load(self): """ When writing and reading a config the options should remain the same. """ port = 4444 self.tribler_config.set_anon_listen_port(port) self.tribler_config.write() path = os.path.join(self.tribler_config.get_default_state_dir(), FILENAME) read_config = TriblerConfig.load(path) read_config.validate() self.assertEqual(read_config.get_anon_listen_port(), port)
def test_write_load(self): """ When writing and reading a config the options should remain the same. """ port = 4444 self.tribler_config.set_anon_listen_port(port) self.tribler_config.write() path = os.path.join(self.tribler_config.get_state_dir(), FILENAME) read_config = TriblerConfig.load(path) read_config.validate() self.assertEqual(read_config.get_anon_listen_port(), port)
def convert_config_to_tribler71(): """ Convert the Config files libtribler.conf and tribler.conf to the newer triblerd.conf. :param: session: the Config which can be used to convert the old files to the new format :return: the newly edited Config file with the old Config data inserted. """ old_tribler_config_file_loc = os.path.join(TriblerConfig.get_default_state_dir(), "triblerd.conf") if os.path.exists(old_tribler_config_file_loc): try: new_config = TriblerConfig(ConfigObj(old_tribler_config_file_loc, configspec=CONFIG_SPEC_PATH)) except InvalidConfigException: new_config = TriblerConfig() else: new_config = TriblerConfig() libtribler_file_loc = os.path.join(TriblerConfig.get_default_state_dir(), "libtribler.conf") if os.path.exists(libtribler_file_loc): libtribler_cfg = RawConfigParser() libtribler_cfg.read(libtribler_file_loc) new_config = add_libtribler_config(new_config, libtribler_cfg) tribler_file_loc = os.path.join(TriblerConfig.get_default_state_dir(), "tribler.conf") if os.path.exists(tribler_file_loc): tribler_cfg = RawConfigParser() tribler_cfg.read(tribler_file_loc) new_config = add_tribler_config(new_config, tribler_cfg) return new_config
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 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 test_torrent_store_delete(self): config = TriblerConfig() config.set_state_dir(self.getStateDir()) config.set_torrent_store_enabled(True) session = Session(config) # 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 test_read_test_corr_tribler_conf(self): """ Adding corrupt values should result in the default value. Note that this test might fail if there is already an upgraded config stored in the default state directory. The code being tested here however shouldn't be ran if that config already exists. :return: """ old_config = RawConfigParser() old_config.read(os.path.join(self.CONFIG_PATH, "triblercorrupt70.conf")) new_config = TriblerConfig() result_config = add_tribler_config(new_config, old_config) self.assertEqual(result_config.get_default_anonymity_enabled(), True)
def test_read_test_libtribler_conf(self): """ Test upgrading a libtribler configuration from 7.0 to 7.1 """ os.environ['TSTATEDIR'] = self.session_base_dir old_config = RawConfigParser() old_config.read(os.path.join(self.CONFIG_PATH, "libtribler70.conf")) new_config = TriblerConfig() result_config = add_libtribler_config(new_config, old_config) self.assertEqual(result_config.get_tunnel_community_socks5_listen_ports(), [1, 2, 3, 4, 5, 6]) self.assertEqual(result_config.get_anon_proxy_settings(), (2, ("127.0.0.1", [5, 4, 3, 2, 1]), '')) self.assertEqual(result_config.get_credit_mining_sources(), ['source1', 'source2']) self.assertEqual(result_config.get_log_dir(), '/a/b/c')
def __init__(self, config=None, ignore_singleton=False, autoload_discovery=True): """ A Session object is created which is configured with the Tribler configuration object. Only a single session instance can exist at a time in a process. :param config: a TriblerConfig object or None, in which case we look for a saved session in the default location (state dir). If we can't find it, we create a new TriblerConfig() object to serve as startup config. Next, the config is saved in the directory indicated by its 'state_dir' attribute. :param ignore_singleton: for testing purposes only. Enables the existence of multiple Session instances. :param autoload_discovery: only false in the Tunnel community tests """ addObserver(self.unhandled_error_observer) patch_crypto_be_discovery() if not ignore_singleton: if Session.__single: raise RuntimeError("Session is singleton") Session.__single = self self._logger = logging.getLogger(self.__class__.__name__) self.ignore_singleton = ignore_singleton self.session_lock = NoDispersyRLock() self.config = config or TriblerConfig() self.get_ports_in_config() self.create_state_directory_structure() if not config.get_megacache_enabled(): config.set_torrent_checking_enabled(False) self.selected_ports = config.selected_ports self.init_keypair() self.lm = TriblerLaunchMany() self.notifier = Notifier() self.sqlite_db = None self.upgrader = None self.dispersy_member = None self.autoload_discovery = autoload_discovery
def convert_config_to_tribler71(current_config, state_dir=None): """ Convert the Config files libtribler.conf and tribler.conf to the newer triblerd.conf and cleanup the files when we are done. :param: current_config: the current config in which we merge the old config files. :return: the newly edited TriblerConfig object with the old data inserted. """ state_dir = state_dir or TriblerConfig.get_default_state_dir() libtribler_file_loc = os.path.join(state_dir, "libtribler.conf") if os.path.exists(libtribler_file_loc): libtribler_cfg = RawConfigParser() libtribler_cfg.read(libtribler_file_loc) current_config = add_libtribler_config(current_config, libtribler_cfg) os.remove(libtribler_file_loc) tribler_file_loc = os.path.join(state_dir, "tribler.conf") if os.path.exists(tribler_file_loc): tribler_cfg = RawConfigParser() tribler_cfg.read(tribler_file_loc) current_config = add_tribler_config(current_config, tribler_cfg) os.remove(tribler_file_loc) # We also have to update all existing downloads, in particular, rename the section 'downloadconfig' to # 'download_defaults'. for _, filename in enumerate(iglob( os.path.join(state_dir, STATEDIR_DLPSTATE_DIR, '*.state'))): download_cfg = RawConfigParser() try: with open(filename) as cfg_file: download_cfg.readfp(cfg_file, filename=filename) except MissingSectionHeaderError: logger.error("Removing download state file %s since it appears to be corrupt", filename) os.remove(filename) try: download_items = download_cfg.items("downloadconfig") download_cfg.add_section("download_defaults") for download_item in download_items: download_cfg.set("download_defaults", download_item[0], download_item[1]) download_cfg.remove_section("downloadconfig") with open(filename, "w") as output_config_file: download_cfg.write(output_config_file) except (NoSectionError, DuplicateSectionError): # This item has already been converted pass return current_config
def setUpPreSession(self): self.config = TriblerConfig(ConfigObj(configspec=CONFIG_SPEC_PATH, default_encoding='utf-8')) self.config.set_default_destination_dir(self.dest_dir) self.config.set_state_dir(self.getStateDir()) self.config.set_torrent_checking_enabled(False) self.config.set_ipv8_enabled(False) self.config.set_libtorrent_enabled(False) self.config.set_video_server_enabled(False) self.config.set_http_api_enabled(False) self.config.set_tunnel_community_enabled(False) self.config.set_credit_mining_enabled(False) self.config.set_market_community_enabled(False) self.config.set_popularity_community_enabled(False) self.config.set_dht_enabled(False) self.config.set_version_checker_enabled(False) self.config.set_libtorrent_dht_enabled(False) self.config.set_bitcoinlib_enabled(False) self.config.set_chant_enabled(False) self.config.set_resource_monitor_enabled(False)
def test_convert_session_config(self): old_pickle_dict = {"state_dir": "/", "mainline_dht_port": 1337, "torrent_checking": "false", "torrent_collecting": "true", "libtorrent": False, "dispersy_port": 1337, "minport": 1234} self.write_pickle_file(old_pickle_dict, "sessconfig.pickle") PickleConverter(self.mock_session).convert_session_config() self.assertTrue(os.path.exists(os.path.join(self.session_base_dir, TRIBLER_CONFIG_FILENAME))) self.assertFalse(os.path.exists(os.path.join(self.session_base_dir, "sessconfig.pickle"))) # Check the content of the config file config = TriblerConfig.load(config_path=os.path.join(self.session_base_dir, TRIBLER_CONFIG_FILENAME)) self.assertEqual(config.get_state_dir(), '/') self.assertEqual(config.get_mainline_dht_port(), 1337) self.assertEqual(config.get_torrent_checking_enabled(), False) self.assertEqual(config.get_torrent_collecting_enabled(), True) self.assertFalse(config.get_libtorrent_enabled()) self.assertEqual(config.get_dispersy_port(), 1337) self.assertEqual(config.get_libtorrent_port(), 1234)
def test_torrent_store_not_enabled(self): config = TriblerConfig() config.set_state_dir(self.getStateDir()) config.set_torrent_store_enabled(False) session = Session(config) session.delete_collected_torrent(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["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(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 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"]) elif options["dispersy"] == 0: config.set_dispersy_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") 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(self): yield super(AbstractUpgrader, self).setUp() self.config = TriblerConfig(ConfigObj(configspec=CONFIG_SPEC_PATH)) self.config.set_state_dir(self.getStateDir()) self.session = Session(self.config)
class TestAsServer(AbstractServer): """ Parent class for testing the server-side of Tribler """ @inlineCallbacks def setUp(self): yield super(TestAsServer, self).setUp() self.setUpPreSession() 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 setUpPreSession(self): self.config = TriblerConfig(ConfigObj(configspec=CONFIG_SPEC_PATH, encoding='latin_1')) self.config.set_default_destination_dir(self.dest_dir) self.config.set_state_dir(self.getStateDir()) self.config.set_torrent_checking_enabled(False) self.config.set_megacache_enabled(False) self.config.set_dispersy_enabled(False) self.config.set_ipv8_enabled(False) self.config.set_mainline_dht_enabled(False) self.config.set_torrent_store_enabled(False) self.config.set_torrent_search_enabled(False) self.config.set_channel_search_enabled(False) self.config.set_torrent_collecting_enabled(False) self.config.set_libtorrent_enabled(False) self.config.set_video_server_enabled(False) self.config.set_metadata_enabled(False) self.config.set_http_api_enabled(False) self.config.set_tunnel_community_enabled(False) self.config.set_credit_mining_enabled(False) self.config.set_market_community_enabled(False) self.config.set_popularity_community_enabled(False) self.config.set_dht_enabled(False) self.config.set_version_checker_enabled(False) self.config.set_libtorrent_dht_enabled(False) self.config.set_bitcoinlib_enabled(False) self.config.set_chant_enabled(False) @inlineCallbacks def tearDown(self): self.annotate(self._testMethodName, start=False) """ unittest test tear down code """ if self.session is not None: yield self.session.shutdown() assert self.session.has_shutdown() self.session = None yield self.stop_seeder() 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) yield super(TestAsServer, self).tearDown() def create_local_torrent(self, source_file): ''' This method creates a torrent from a local file and saves the torrent in the session state dir. Note that the source file needs to exist. ''' self.assertTrue(os.path.exists(source_file)) tdef = TorrentDef() tdef.add_content(source_file) tdef.set_tracker("http://localhost/announce") tdef.finalize() torrent_path = os.path.join(self.session.config.get_state_dir(), "seed.torrent") tdef.save(torrent_path) return tdef, torrent_path 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_megacache_enabled(False) self.seed_config.set_dispersy_enabled(False) self.seed_config.set_ipv8_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_http_api_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_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) 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 stop_seeder(self): if self.seeder_session is not None: return self.seeder_session.shutdown() return succeed(None) def seeder_state_callback(self, ds): d = ds.get_download() self._logger.debug("seeder status: %s %s %s", repr(d.get_def().get_name()), dlstatus_strings[ds.get_status()], ds.get_progress()) if ds.get_status() == DLSTATUS_SEEDING: self.seeding_deferred.callback(None) return 0.0 return 1.0
class TestTriblerConfig(TriblerCoreTest): """ This class contains tests for the tribler configuration file. """ def setUp(self): """ Create a new TriblerConfig instance """ super(TestTriblerConfig, self).setUp() self.tribler_config = TriblerConfig() self.tribler_config.get_default_state_dir = lambda **_: self.getStateDir() self.tribler_config.set_state_dir(self.getStateDir()) self.assertIsNotNone(self.tribler_config) def test_init_with_config(self): """ When creating a new instance with a configobject provided, the given options must be contained in the resulting instance. """ configdict = ConfigObj({"a": 1, "b": "2"}, configspec=CONFIG_SPEC_PATH) self.tribler_config = TriblerConfig(configdict) self.tribler_config.validate() for key, value in configdict.items(): self.assertEqual(self.tribler_config.config[key], value) def test_init_without_config(self): """ A newly created TriblerConfig is valid. """ self.tribler_config.validate() def test_write_load(self): """ When writing and reading a config the options should remain the same. """ port = 4444 self.tribler_config.set_anon_listen_port(port) self.tribler_config.write() path = os.path.join(self.tribler_config.get_default_state_dir(), FILENAME) read_config = TriblerConfig.load(path) read_config.validate() self.assertEqual(read_config.get_anon_listen_port(), port) def test_load(self): os.path.isdir(self.tribler_config.get_state_dir()) def test_libtorrent_proxy_settings(self): """ Setting and getting of libtorrent proxy settings. """ proxy_type, server, auth = 3, ['33.33.33.33', '22'], ['user', 'pass'] self.tribler_config.set_libtorrent_proxy_settings(proxy_type, ':'.join(server), ':'.join(auth)) self.assertEqual(self.tribler_config.get_libtorrent_proxy_settings()[0], proxy_type) self.assertEqual(self.tribler_config.get_libtorrent_proxy_settings()[1], server) self.assertEqual(self.tribler_config.get_libtorrent_proxy_settings()[2], auth) # if the proxy type doesn't support authentication, auth setting should be saved as None proxy_type = 1 self.tribler_config.set_libtorrent_proxy_settings(proxy_type, ':'.join(server), ':'.join(auth)) self.assertEqual(self.tribler_config.get_libtorrent_proxy_settings()[0], proxy_type) self.assertEqual(self.tribler_config.get_libtorrent_proxy_settings()[1], server) self.assertEqual(self.tribler_config.get_libtorrent_proxy_settings()[2], ['', '']) def test_anon_proxy_settings(self): proxy_type, server, auth = 3, ("33.33.33.33", [2222, 2223, 4443, 58848]), 1 self.tribler_config.set_anon_proxy_settings(proxy_type, server, auth) self.assertEqual(self.tribler_config.get_anon_proxy_settings()[0], proxy_type) self.assertEqual(self.tribler_config.get_anon_proxy_settings()[1], server) self.assertEqual(self.tribler_config.get_anon_proxy_settings()[2], auth) proxy_type = 1 self.tribler_config.set_anon_proxy_settings(proxy_type, server, auth) self.assertEqual(self.tribler_config.get_anon_proxy_settings()[0], proxy_type) self.assertEqual(self.tribler_config.get_anon_proxy_settings()[1], server) self.assertIsNone(self.tribler_config.get_anon_proxy_settings()[2]) def test_tunnel_community_socks5_listen_ports(self): ports = [5554, 9949, 9588, 35555, 84899] self.tribler_config.set_tunnel_community_socks5_listen_ports(ports) self.assertListEqual(self.tribler_config.get_tunnel_community_socks5_listen_ports(), ports) def test_credit_mining_sources(self): source_list = "listitem" self.tribler_config.set_credit_mining_sources(source_list) self.assertEqual(self.tribler_config.get_credit_mining_sources(), source_list) def test_get_set_methods_general(self): """ Check whether general get and set methods are working as expected. """ self.tribler_config.set_state_dir("TEST") self.assertEqual(self.tribler_config.get_state_dir(), "TEST") self.tribler_config.set_trustchain_keypair_filename(None) self.assertEqual(self.tribler_config.get_trustchain_keypair_filename(), os.path.join("TEST", "ec_multichain.pem")) self.tribler_config.set_trustchain_keypair_filename("TEST") self.assertEqual(self.tribler_config.get_trustchain_keypair_filename(), "TEST") self.tribler_config.set_trustchain_testnet_keypair_filename(None) self.assertEqual(self.tribler_config.get_trustchain_testnet_keypair_filename(), os.path.join("TEST", "ec_trustchain_testnet.pem")) self.tribler_config.set_trustchain_testnet_keypair_filename("TEST") self.assertEqual(self.tribler_config.get_trustchain_testnet_keypair_filename(), "TEST") self.tribler_config.set_testnet(True) self.assertTrue(self.tribler_config.get_testnet()) def test_get_set_methods_version_checker(self): """ Checks whether version checker get and set methods are working as expected. """ # Default is always true self.assertTrue(self.tribler_config.get_version_checker_enabled()) # Test disabling self.tribler_config.set_version_checker_enabled(False) self.assertFalse(self.tribler_config.get_version_checker_enabled()) # Test enabling self.tribler_config.set_version_checker_enabled(True) self.assertTrue(self.tribler_config.get_version_checker_enabled()) def test_get_set_methods_torrent_checking(self): """ Check whether torrent checking get and set methods are working as expected. """ self.tribler_config.set_torrent_checking_enabled(True) self.assertEqual(self.tribler_config.get_torrent_checking_enabled(), True) def test_get_set_methods_http_api(self): """ Check whether http api get and set methods are working as expected. """ self.tribler_config.set_http_api_enabled(True) self.assertEqual(self.tribler_config.get_http_api_enabled(), True) self.tribler_config.set_http_api_port(True) self.assertEqual(self.tribler_config.get_http_api_port(), True) self.tribler_config.set_http_api_retry_port(True) self.assertTrue(self.tribler_config.get_http_api_retry_port()) def test_get_set_methods_ipv8(self): """ Check whether IPv8 get and set methods are working as expected. """ self.tribler_config.set_ipv8_enabled(False) self.assertEqual(self.tribler_config.get_ipv8_enabled(), False) self.tribler_config.set_ipv8_port(1234) self.assertEqual(self.tribler_config.get_ipv8_port(), 1234) self.tribler_config.set_ipv8_bootstrap_override("127.0.0.1:12345") self.assertEqual(self.tribler_config.get_ipv8_bootstrap_override(), ("127.0.0.1", 12345)) self.tribler_config.set_ipv8_statistics(True) self.assertTrue(self.tribler_config.get_ipv8_statistics()) def test_get_set_methods_libtorrent(self): """ Check whether libtorrent get and set methods are working as expected. """ self.tribler_config.set_libtorrent_enabled(True) self.assertEqual(self.tribler_config.get_libtorrent_enabled(), True) self.tribler_config.set_libtorrent_utp(True) self.assertEqual(self.tribler_config.get_libtorrent_utp(), True) self.tribler_config.set_libtorrent_port(True) self.assertEqual(self.tribler_config.get_libtorrent_port(), True) self.tribler_config.set_libtorrent_port_runtime(True) self.assertEqual(self.tribler_config.get_libtorrent_port(), True) self.tribler_config.set_anon_listen_port(True) self.assertEqual(self.tribler_config.get_anon_listen_port(), True) proxy_server, proxy_auth = ["localhost", "9090"], ["user", "pass"] self.tribler_config.set_libtorrent_proxy_settings(3, ":".join(proxy_server), ":".join(proxy_auth)) self.assertEqual(self.tribler_config.get_libtorrent_proxy_settings(), (3, proxy_server, proxy_auth)) self.tribler_config.set_anon_proxy_settings(0, None, None) self.assertEqual(self.tribler_config.get_anon_proxy_settings(), (0, (None, None), None)) self.tribler_config.set_anon_proxy_settings(3, ("TEST", [5]), ("TUN", "TPW")) self.assertEqual(self.tribler_config.get_anon_proxy_settings(), (3, ("TEST", [5]), ("TUN", "TPW"))) self.tribler_config.set_libtorrent_max_conn_download(True) self.assertEqual(self.tribler_config.get_libtorrent_max_conn_download(), True) self.tribler_config.set_libtorrent_max_upload_rate(True) self.assertEqual(self.tribler_config.get_libtorrent_max_upload_rate(), True) self.tribler_config.set_libtorrent_max_download_rate(True) self.assertEqual(self.tribler_config.get_libtorrent_max_download_rate(), True) self.tribler_config.set_libtorrent_dht_enabled(False) self.assertFalse(self.tribler_config.get_libtorrent_dht_enabled()) def test_get_set_methods_video_server(self): """ Check whether video server get and set methods are working as expected. """ self.tribler_config.set_video_server_enabled(True) self.assertEqual(self.tribler_config.get_video_server_enabled(), True) self.tribler_config.set_video_server_port(True) self.assertEqual(self.tribler_config.get_video_server_port(), True) def test_get_set_methods_tunnel_community(self): """ Check whether tunnel community get and set methods are working as expected. """ self.tribler_config.set_tunnel_community_enabled(True) self.assertEqual(self.tribler_config.get_tunnel_community_enabled(), True) self.tribler_config.set_tunnel_community_socks5_listen_ports([-1]) self.assertNotEqual(self.tribler_config.get_tunnel_community_socks5_listen_ports(), [-1]) self.tribler_config.set_tunnel_community_socks5_listen_ports([5]) self.assertEqual(self.tribler_config.get_tunnel_community_socks5_listen_ports(), [5]) self.tribler_config.set_tunnel_community_exitnode_enabled(True) self.assertEqual(self.tribler_config.get_tunnel_community_exitnode_enabled(), True) self.tribler_config.set_default_number_hops(True) self.assertEqual(self.tribler_config.get_default_number_hops(), True) self.tribler_config.set_default_anonymity_enabled(True) self.assertEqual(self.tribler_config.get_default_anonymity_enabled(), True) self.tribler_config.set_default_safeseeding_enabled(True) self.assertEqual(self.tribler_config.get_default_safeseeding_enabled(), True) self.tribler_config.set_default_destination_dir(True) self.assertEqual(self.tribler_config.get_default_destination_dir(), True) self.tribler_config.set_tunnel_community_random_slots(10) self.assertEqual(self.tribler_config.get_tunnel_community_random_slots(), 10) self.tribler_config.set_tunnel_community_competing_slots(20) self.assertEqual(self.tribler_config.get_tunnel_community_competing_slots(), 20) def test_get_set_methods_wallets(self): """ Check whether wallet get and set methods are working as expected. """ self.tribler_config.set_dummy_wallets_enabled(True) self.assertTrue(self.tribler_config.get_dummy_wallets_enabled()) self.tribler_config.set_bitcoinlib_enabled(False) self.assertFalse(self.tribler_config.get_bitcoinlib_enabled()) def test_get_set_chant_methods(self): """ Check whether chant get and set methods are working as expected. """ self.tribler_config.set_chant_enabled(False) self.assertFalse(self.tribler_config.get_chant_enabled()) self.tribler_config.set_chant_channels_dir('test') self.assertEqual(self.tribler_config.get_chant_channels_dir(), os.path.join(self.tribler_config.get_state_dir(), 'test')) def test_get_set_is_matchmaker(self): """ Check whether matchmaker get and set methods are working as expected. """ self.tribler_config.set_is_matchmaker(False) self.assertFalse(self.tribler_config.get_is_matchmaker()) def test_get_set_methods_popularity_community(self): """ Check whether popularity community get and set methods are working as expected. """ self.tribler_config.set_popularity_community_enabled(True) self.assertEqual(self.tribler_config.get_popularity_community_enabled(), True) def test_get_set_methods_watch_folder(self): """ Check whether watch folder get and set methods are working as expected. """ self.tribler_config.set_watch_folder_enabled(True) self.assertEqual(self.tribler_config.get_watch_folder_enabled(), True) self.tribler_config.set_watch_folder_path(True) self.assertEqual(self.tribler_config.get_watch_folder_path(), True) def test_get_set_methods_resource_monitor(self): """ Check whether resource monitor get and set methods are working as expected. """ self.assertTrue(self.tribler_config.get_resource_monitor_enabled()) self.tribler_config.set_resource_monitor_enabled(False) self.assertFalse(self.tribler_config.get_resource_monitor_enabled()) self.tribler_config.set_resource_monitor_poll_interval(21) self.assertEqual(self.tribler_config.get_resource_monitor_poll_interval(), 21) self.tribler_config.set_resource_monitor_history_size(1234) self.assertEqual(self.tribler_config.get_resource_monitor_history_size(), 1234) self.assertEqual(self.tribler_config.get_cpu_priority_order(), 1) self.tribler_config.set_cpu_priority_order(3) self.assertEqual(self.tribler_config.get_cpu_priority_order(), 3) def test_get_set_methods_credit_mining(self): """ Check whether credit mining get and set methods are working as expected. """ self.tribler_config.set_credit_mining_enabled(True) self.assertEqual(self.tribler_config.get_credit_mining_enabled(), True) self.tribler_config.set_credit_mining_sources(True) self.assertEqual(self.tribler_config.get_credit_mining_sources(), True) self.tribler_config.set_credit_mining_disk_space(1024 ** 2) self.assertEqual(self.tribler_config.get_credit_mining_disk_space(), 1024 ** 2) def test_get_set_methods_dht(self): """ Check whether dht get and set methods are working as expected. """ self.tribler_config.set_dht_enabled(False) self.assertFalse(self.tribler_config.get_dht_enabled()) def test_get_set_methods_record_transactions(self): """ Check whether record_transactions get and set methods are working as expected. """ self.tribler_config.set_record_transactions(True) self.assertTrue(self.tribler_config.get_record_transactions())
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")
class AbstractDB(TriblerCoreTest): def setUpPreSession(self): self.config = TriblerConfig(ConfigObj(configspec=CONFIG_SPEC_PATH)) self.config.set_state_dir(self.getStateDir()) self.config.set_torrent_checking_enabled(False) self.config.set_megacache_enabled(False) self.config.set_dispersy_enabled(False) self.config.set_mainline_dht_enabled(False) self.config.set_torrent_collecting_enabled(False) self.config.set_libtorrent_enabled(False) self.config.set_video_server_enabled(False) self.config.set_torrent_store_enabled(False) @inlineCallbacks 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 @inlineCallbacks def tearDown(self): self.sqlitedb.close() self.sqlitedb = None self.session = None yield super(AbstractDB, self).tearDown()