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))
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)
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 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()
