async def test_copy(tmpdir):
config = TriblerConfig(state_dir=tmpdir, file=tmpdir / '1.txt')
config.api.http_port = 42
cloned = config.copy()
assert cloned.api.http_port == 42
assert cloned.state_dir == tmpdir
assert cloned.file == tmpdir / '1.txt'
async def setUp(self):
"""
Create a new TriblerConfig instance
"""
await super(TestTriblerConfig, self).setUp()
self.tribler_config = TriblerConfig(self.getRootStateDir())
self.assertIsNotNone(self.tribler_config)
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 = self.tribler_config.get_state_dir() / CONFIG_FILENAME
read_config = TriblerConfig(self.root_state_dir, config_file=path)
self.assertEqual(read_config.get_anon_listen_port(), port)
def test_write_load(tribler_config):
"""
When writing and reading a config the options should remain the same.
"""
port = 4444
tribler_config.set_anon_listen_port(port)
tribler_config.write()
path = tribler_config.get_state_dir() / CONFIG_FILENAME
read_config = TriblerConfig(path, config_file=path)
assert read_config.get_anon_listen_port() == port
async def test_load_write_nonascii(tmpdir):
config = TriblerConfig(state_dir=tmpdir)
filename = 'test_read_write.ini'
config.download_defaults.saveas = 'ыюя'
assert not config.file
config.write(tmpdir / filename)
assert config.file == tmpdir / filename
config = TriblerConfig.load(file=tmpdir / filename, state_dir=tmpdir)
assert config.download_defaults.saveas == 'ыюя'
assert config.file == tmpdir / filename
async def extract_swagger(destination_fn):
config = TriblerConfig()
config.api.key = 'apikey'
config.api.http_enabled = False
config.api.https_enabled = False
root_endpoint = RootEndpoint(
middlewares=[ApiKeyMiddleware(config.api.key), error_middleware])
api_manager = RESTManager(config=config.api,
root_endpoint=root_endpoint,
state_dir=config.state_dir)
await api_manager.start()
fp = StringIO()
proto = aiohttp.web_protocol.RequestHandler(api_manager.runner._server,
loop=get_event_loop())
proto.connection_made(
Mock(is_closing=lambda: False, write=lambda b: fp.write(b.decode())))
proto.data_received(b'GET /docs/swagger.json HTTP/1.1\r\n'
b'Connection: close\r\n\r\n')
await proto.start()
api_spec = json.loads(fp.getvalue().split('\r\n\r\n')[1])
# All responses should have a description
for _, path in api_spec['paths'].items():
for _, spec in path.items():
for _, response in spec['responses'].items():
if 'description' not in response:
response['description'] = ''
# Convert to yaml
with open(destination_fn, 'w') as destination_fp:
destination_fp.write(yaml.dump(api_spec))
async def test_config_error_notification(tmpdir):
"""
Test if config error is notified on session startup.
"""
# 1. Setup corrupted config
shutil.copy2(CONFIG_PATH / 'corrupt-triblerd.conf',
tmpdir / 'triblerd.conf')
tribler_config = TriblerConfig(tmpdir,
config_file=tmpdir / 'triblerd.conf',
reset_config_on_error=True)
# 2. Initialize session with corrupted config, disable upgrader for simplicity.
# By mocking the notifier, we can check if the notify was called with correct parameters
session = Session(tribler_config)
session.upgrader_enabled = False
session.notifier = Mock()
# 3. Start the session which should internally call the notifier.
await session.start()
# Notifier uses asyncio loop internally, so we must wait at least a single loop cycle
await asyncio.sleep(0)
# 4. There could be multiple notify calls but we are only interested in the config error
# so using 'assert_any_call' here to check if the notify was called.
session.notifier.notify.assert_any_call(NTFY.REPORT_CONFIG_ERROR,
tribler_config.config_error)
# 5. Always shutdown the session at the end.
await session.shutdown()
def upgrade_state_dir(root_state_dir: Path,
update_status_callback=None,
interrupt_upgrade_event=None):
# Before any upgrade, prepare a separate state directory for the update version so it does not
# affect the older version state directory. This allows for safe rollback.
version_history = VersionHistory(root_state_dir)
version_history.fork_state_directory_if_necessary()
version_history.save_if_necessary()
state_dir = version_history.code_version.directory
if not state_dir.exists():
return
config = TriblerConfig.load(file=state_dir / CONFIG_FILE_NAME,
state_dir=state_dir,
reset_config_on_error=True)
channels_dir = config.chant.get_path_as_absolute('channels_dir',
config.state_dir)
primary_private_key_path = config.state_dir / KeyComponent.get_private_key_filename(
config)
primary_public_key_path = config.state_dir / config.trustchain.ec_keypair_pubfilename
primary_key = KeyComponent.load_or_create(primary_private_key_path,
primary_public_key_path)
upgrader = TriblerUpgrader(state_dir,
channels_dir,
primary_key,
update_status_callback=update_status_callback,
interrupt_upgrade_event=interrupt_upgrade_event)
upgrader.run()
def run_tribler_core_session(api_port,
api_key,
state_dir,
gui_test_mode=False):
"""
This method will start a new Tribler session.
Note that there is no direct communication between the GUI process and the core: all communication is performed
through the HTTP API.
"""
logger.info(f'Start tribler core. API port: "{api_port}". '
f'API key: "{api_key}". State dir: "{state_dir}". '
f'Core test mode: "{gui_test_mode}"')
config = TriblerConfig.load(file=state_dir / CONFIG_FILE_NAME,
state_dir=state_dir,
reset_config_on_error=True)
config.gui_test_mode = gui_test_mode
if SentryReporter.is_in_test_mode():
default_core_exception_handler.sentry_reporter.global_strategy = SentryStrategy.SEND_ALLOWED
config.api.http_port = int(api_port)
# If the API key is set to an empty string, it will remain disabled
if config.api.key not in ('', api_key):
config.api.key = api_key
config.write(
) # Immediately write the API key so other applications can use it
config.api.http_enabled = True
priority_order = config.resource_monitor.cpu_priority
set_process_priority(pid=os.getpid(), priority_order=priority_order)
# Enable tracer if --trace-debug or --trace-exceptions flag is present in sys.argv
log_dir = config.general.get_path_as_absolute('log_dir', config.state_dir)
trace_logger = check_and_enable_code_tracing('core', log_dir)
logging.getLogger('asyncio').setLevel(logging.WARNING)
if sys.platform.startswith('win'):
# TODO for the moment being, we use the SelectorEventLoop on Windows, since with the ProactorEventLoop, ipv8
# peer discovery becomes unstable. Also see issue #5485.
asyncio.set_event_loop(asyncio.SelectorEventLoop())
loop = asyncio.get_event_loop()
exception_handler = default_core_exception_handler
loop.set_exception_handler(exception_handler.unhandled_error_observer)
try:
loop.run_until_complete(
core_session(config, components=list(components_gen(config))))
finally:
if trace_logger:
trace_logger.close()
# Flush the logs to the file before exiting
for handler in logging.getLogger().handlers:
handler.flush()
async def test_load_write(tmpdir):
config = TriblerConfig(state_dir=tmpdir)
filename = 'test_read_write.ini'
config.general.log_dir = '1'
config.general.version_checker_enabled = False
config.libtorrent.port = None
config.libtorrent.proxy_type = 2
assert not config.file
config.write(tmpdir / filename)
assert config.file == tmpdir / filename
config = TriblerConfig.load(file=tmpdir / filename, state_dir=tmpdir)
assert config.general.log_dir == '1'
assert config.general.version_checker_enabled is False
assert config.libtorrent.port is None
assert config.libtorrent.proxy_type == 2
assert config.file == tmpdir / filename
async def test_invalid_config_recovers(tmpdir):
default_config_file = tmpdir / 'triblerd.conf'
shutil.copy2(CONFIG_PATH / 'corrupt-triblerd.conf', default_config_file)
# By default, recover_error set to False when loading the config file so
# if the config file is corrupted, it should raise a ParseError.
with pytest.raises(ParseError):
TriblerConfig.load(file=default_config_file, state_dir=tmpdir)
# If recover_error is set to True, the config should successfully load using
# the default config in case of corrupted config file and the error is saved.
config = TriblerConfig.load(file=default_config_file,
state_dir=tmpdir,
reset_config_on_error=True)
assert "configobj.ParseError: Invalid line" in config.error
# Since the config should be saved on previous recovery, subsequent instantiation of TriblerConfig
# should work without the reset flag.
config = TriblerConfig.load(file=default_config_file, state_dir=tmpdir)
assert not config.error
def make_config(options) -> TriblerConfig:
# Determine ipv8 port
ipv8_port = options.ipv8_port
if ipv8_port == -1:
if "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
else:
raise ValueError(
'ipv8_port option is not set, and HELPER_BASE/HELPER_INDEX env vars are not defined'
)
statedir = Path(
os.path.join(get_root_state_directory(), "tunnel-%d") % ipv8_port)
config = TriblerConfig.load(file=statedir / 'triblerd.conf',
state_dir=statedir)
config.tunnel_community.random_slots = options.random_slots
config.tunnel_community.competing_slots = options.competing_slots
config.torrent_checking.enabled = False
config.ipv8.enabled = True
config.libtorrent.enabled = False
config.ipv8.port = ipv8_port
config.ipv8.address = options.ipv8_address
config.dht.enabled = True
config.tunnel_community.exitnode_enabled = bool(options.exit)
config.popularity_community.enabled = False
config.tunnel_community.testnet = bool(options.testnet)
config.chant.enabled = False
config.bootstrap.enabled = False
if not options.no_rest_api:
https = bool(options.cert_file)
config.api.https_enabled = https
config.api.http_enabled = not https
config.api.key = options.api_key
api_port = 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"])
if https:
config.api.https_port = api_port
config.api.put_path_as_relative('https_certfile',
options.cert_file,
config.state_dir)
else:
config.api.http_port = api_port
else:
config.api.https_enabled = False
config.api.http_enabled = False
if options.ipv8_bootstrap_override is not None:
config.ipv8.bootstrap_override = options.ipv8_bootstrap_override
return config
async def test_get_path_relative(tmpdir):
config = TriblerConfig(state_dir=tmpdir)
config.general.log_dir = None
assert not config.general.log_dir
config.general.log_dir = '.'
assert config.general.get_path_as_absolute('log_dir',
tmpdir) == Path(tmpdir)
config.general.log_dir = '1'
assert config.general.get_path_as_absolute('log_dir',
tmpdir) == Path(tmpdir) / '1'
def test_convert_tribler_conf_76(tmpdir):
"""
Tests conversion of the Tribler 7.5 config
"""
shutil.copy2(CONFIG_PATH / 'triblerd75.conf', tmpdir / 'triblerd.conf')
convert_config_to_tribler76(tmpdir)
config = TriblerConfig.load(file=tmpdir / 'triblerd.conf',
state_dir=tmpdir)
assert config.api.key == '7671750ba34423c97dc3c6763041e4cb'
assert config.api.http_port == 8085
assert config.api.http_enabled
assert not config.api.https_enabled
def __init__(self, timeout_in_sec, working_dir):
super().__init__(config=TriblerConfig(state_dir=working_dir),
timeout_in_sec=timeout_in_sec,
working_dir=working_dir,
components=[
SocksServersComponent(),
LibtorrentComponent(),
TorrentCheckerComponent(),
MetadataStoreComponent(),
KeyComponent(),
RESTComponent(),
Ipv8Component(),
ObservablePopularityComponent()
])
def __init__(self, source_dir, working_dir):
super().__init__(TriblerConfig(state_dir=working_dir),
working_dir=working_dir,
components=[
RESTComponent(),
KeyComponent(),
SocksServersComponent(),
LibtorrentComponent(),
Ipv8Component(),
MetadataStoreComponent(),
GigachannelManagerComponent(),
GigaChannelComponent()
])
self.source_dir = Path(source_dir)
async def fixture_rest_manager(api_port, tmp_path, endpoint):
config = TriblerConfig()
config.api.http_enabled = True
config.api.http_port = api_port
root_endpoint = RootEndpoint(
middlewares=[ApiKeyMiddleware(config.api.key), error_middleware])
root_endpoint.add_endpoint('/events', endpoint)
rest_manager = RESTManager(config=config.api,
root_endpoint=root_endpoint,
state_dir=tmp_path)
await rest_manager.start()
yield rest_manager
await rest_manager.stop()
def test_convert_tribler_conf_76(tmpdir):
"""
Tests conversion of the Tribler 7.5 config
"""
shutil.copy2(CONFIG_PATH / 'triblerd75.conf', tmpdir / 'triblerd.conf')
convert_config_to_tribler76(tmpdir)
new_config = TriblerConfig(tmpdir, tmpdir / 'triblerd.conf')
assert new_config.get_api_key() == '7671750ba34423c97dc3c6763041e4cb'
assert new_config.get_api_http_port() == 8085
assert new_config.get_api_http_enabled()
assert not new_config.get_api_https_enabled()
def _tribler_config(tribler_state_dir, tribler_download_dir) -> TriblerConfig:
config = TriblerConfig(state_dir=tribler_state_dir)
config.download_defaults.put_path_as_relative('saveas', tribler_download_dir, state_dir=tribler_state_dir)
config.torrent_checking.enabled = False
config.ipv8.enabled = False
config.ipv8.walk_scaling_enabled = False
config.discovery_community.enabled = False
config.libtorrent.enabled = False
config.libtorrent.dht_readiness_timeout = 0
config.tunnel_community.enabled = False
config.popularity_community.enabled = False
config.dht.enabled = False
config.libtorrent.dht = False
config.chant.enabled = False
config.resource_monitor.enabled = False
config.bootstrap.enabled = False
return config
async def setUp(self):
await super(TestDHTSession, self).setUp()
self.session = Session(TriblerConfig(self.root_state_dir))
self.session.dlmgr = MockObject()
self.session.dlmgr.dht_health_manager = MockObject()
dht_health_dict = {
"infohash": hexlify(b'a' * 20),
"seeders": 1,
"leechers": 2
}
self.session.dlmgr.dht_health_manager.get_health = lambda *_, **__: succeed(
{"DHT": [dht_health_dict]})
self.dht_session = FakeDHTSession(self.session, b'a' * 20, 10)
self.bep33_dht_session = FakeBep33DHTSession(self.session, b'a' * 20,
10)
async def torrent_checker(loop, mock_dlmgr, metadata_store):
# Initialize the torrent checker
config = TriblerConfig()
config.download_defaults.number_hops = 0
tracker_manager = MagicMock()
tracker_manager.blacklist = []
notifier = MagicMock()
torrent_checker = TorrentChecker(
config=config,
download_manager=mock_dlmgr,
tracker_manager=tracker_manager,
metadata_store=metadata_store,
notifier=notifier,
socks_listen_ports=[2000, 3000],
)
await torrent_checker.initialize()
yield torrent_checker
await torrent_checker.shutdown()
async def start_tribler():
# Check if we are already running a Tribler instance
process_checker = ProcessChecker(root_state_dir)
if process_checker.already_running:
return
process_checker.create_lock_file()
# Before any upgrade, prepare a separate state directory for the update version so it does not
# affect the older version state directory. This allows for safe rollback.
version_history = VersionHistory(root_state_dir)
version_history.fork_state_directory_if_necessary()
version_history.save_if_necessary()
state_dir = version_history.code_version.directory
config = TriblerConfig(state_dir,
config_file=state_dir / CONFIG_FILENAME,
reset_config_on_error=True)
if not config.get_core_error_reporting_requires_user_consent():
SentryReporter.global_strategy = SentryStrategy.SEND_ALLOWED
config.set_api_http_port(int(api_port))
# If the API key is set to an empty string, it will remain disabled
if config.get_api_key() not in ('', api_key):
config.set_api_key(api_key)
config.write(
) # Immediately write the API key so other applications can use it
config.set_api_http_enabled(True)
priority_order = config.get_cpu_priority_order()
set_process_priority(pid=os.getpid(), priority_order=priority_order)
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',
config.get_log_dir())
session = Session(config, core_test_mode=core_test_mode)
signal.signal(signal.SIGTERM,
lambda signum, stack: shutdown(session, signum, stack))
await session.start()
def __init__(self,
config: TriblerConfig = None,
components: List[Component] = (),
shutdown_event: Event = None,
notifier: Notifier = None,
failfast: bool = True):
# deepcode ignore unguarded~next~call: not necessary to catch StopIteration on infinite iterator
self.id = next(Session._next_session_id)
self.failfast = failfast
self.logger = logging.getLogger(self.__class__.__name__)
self.config: TriblerConfig = config or TriblerConfig()
self.shutdown_event: Event = shutdown_event or Event()
self.notifier: Notifier = notifier or Notifier()
self.components: Dict[Type[Component], Component] = {}
for component in components:
self.register(component.__class__, component)
# Reserve various (possibly) fixed ports to prevent
# components from occupying those accidentally
reserve_ports([
config.libtorrent.port, config.api.http_port,
config.api.https_port, config.ipv8.port
])
class TestTriblerConfig(TriblerCoreTest):
"""
This class contains tests for the tribler configuration file.
"""
async def setUp(self):
"""
Create a new TriblerConfig instance
"""
await super(TestTriblerConfig, self).setUp()
self.tribler_config = TriblerConfig(self.getRootStateDir())
self.assertIsNotNone(self.tribler_config)
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 = self.tribler_config.get_state_dir() / CONFIG_FILENAME
read_config = TriblerConfig(self.root_state_dir, config_file=path)
self.assertEqual(read_config.get_anon_listen_port(), port)
def test_load(self):
self.tribler_config.get_state_dir().is_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_bootstrap_configs(self):
self.tribler_config.set_bootstrap_enabled(False)
self.assertFalse(self.tribler_config.get_bootstrap_enabled())
self.tribler_config.set_bootstrap_max_download_rate(20)
self.assertEqual(self.tribler_config.get_bootstrap_max_download_rate(),
20)
self.tribler_config.set_bootstrap_infohash("TestInfohash")
self.assertEqual(self.tribler_config.get_bootstrap_infohash(),
"TestInfohash")
def test_relative_paths(self):
# Default should be taken from config.spec
self.assertEqual(
self.tribler_config.get_trustchain_keypair_filename(),
path_util.abspath(self.state_dir / "ec_multichain.pem"))
local_name = Path("somedir") / "ec_multichain.pem"
global_name = self.state_dir / local_name
self.tribler_config.set_trustchain_keypair_filename(global_name)
# It should always return global path
self.assertEqual(self.tribler_config.get_trustchain_keypair_filename(),
global_name)
# But internally it should be stored as a local path string
self.assertEqual(
self.tribler_config.config['trustchain']['ec_keypair_filename'],
str(local_name))
# If it points out of the state dir, it should be saved as a global path string
out_of_dir_name_global = path_util.abspath(self.state_dir / ".." /
"filename").resolve()
self.tribler_config.set_trustchain_keypair_filename(
out_of_dir_name_global)
self.assertEqual(
self.tribler_config.config['trustchain']['ec_keypair_filename'],
str(out_of_dir_name_global))
def test_get_set_methods_general(self):
"""
Check whether general get and set methods are working as expected.
"""
self.assertEqual(
self.tribler_config.get_trustchain_testnet_keypair_filename(),
self.tribler_config.get_state_dir() / "ec_trustchain_testnet.pem")
self.tribler_config.set_trustchain_testnet_keypair_filename("bla2")
self.assertEqual(
self.tribler_config.get_trustchain_testnet_keypair_filename(),
self.tribler_config.get_state_dir() / "bla2")
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_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(get_home_dir())
self.assertEqual(self.tribler_config.get_default_destination_dir(),
path_util.Path(get_home_dir()))
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(),
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(get_home_dir())
self.assertEqual(self.tribler_config.get_watch_folder_path(),
get_home_dir())
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_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 test_get_set_default_add_download_to_channel(self):
"""
Check whether set/get methods of default add download to channel works.
"""
self.assertEqual(
self.tribler_config.get_default_add_download_to_channel(), False)
self.tribler_config.set_default_add_download_to_channel(True)
self.assertEqual(
self.tribler_config.get_default_add_download_to_channel(), True)
def _tribler_config(tribler_state_dir, tribler_download_dir):
config = TriblerConfig(tribler_state_dir)
config.set_default_destination_dir(tribler_download_dir)
config.set_torrent_checking_enabled(False)
config.set_ipv8_enabled(False)
config.set_discovery_community_enabled(False)
config.set_ipv8_walk_scaling_enabled(False)
config.set_libtorrent_enabled(False)
config.set_libtorrent_dht_readiness_timeout(0)
config.set_api_http_enabled(False)
config.set_tunnel_community_enabled(False)
config.set_popularity_community_enabled(False)
config.set_dht_enabled(False)
config.set_version_checker_enabled(False)
config.set_libtorrent_dht_enabled(False)
config.set_chant_enabled(False)
config.set_resource_monitor_enabled(False)
config.set_bootstrap_enabled(False)
return config
async def start_tribler(self, options):
"""
Main method to startup Tribler.
"""
async def signal_handler(sig):
print(f"Received shut down signal {sig}")
if not self._stopping:
self._stopping = True
await self.session.shutdown()
print("Tribler shut down")
get_event_loop().stop()
self.process_checker.remove_lock_file()
signal.signal(signal.SIGINT,
lambda sig, _: ensure_future(signal_handler(sig)))
signal.signal(signal.SIGTERM,
lambda sig, _: ensure_future(signal_handler(sig)))
statedir = Path(options.statedir
or Path(get_appstate_dir(), '.Tribler'))
config = TriblerConfig(statedir,
config_file=statedir / 'triblerd.conf')
# Check if we are already running a Tribler instance
self.process_checker = ProcessChecker()
if self.process_checker.already_running:
print(
f"Another Tribler instance is already using statedir {config.get_state_dir()}"
)
get_event_loop().stop()
return
print("Starting Tribler")
if options.restapi > 0:
config.set_api_http_enabled(True)
config.set_api_http_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 options.testnet:
config.set_tunnel_testnet(True)
config.set_chant_testnet(True)
config.set_bandwidth_testnet(True)
self.session = Session(config)
try:
await self.session.start()
except Exception as e:
print(str(e))
get_event_loop().stop()
else:
print("Tribler started")
[KeyComponent(), Ipv8Component(), BandwidthAccountingComponent(crawler_mode=True)])
signal.signal(signal.SIGTERM, lambda signum, stack: session.shutdown_event.set)
async with session.start():
await session.shutdown_event.wait()
if __name__ == "__main__":
parser = argparse.ArgumentParser(description=('Start a crawler in the bandwidth accounting community'))
parser.add_argument('--statedir', '-s', default='bw_crawler', type=str, help='Use an alternate statedir')
parser.add_argument('--restapi', '-p', default=52194, type=int, help='Use an alternate port for the REST API',
action=PortAction, metavar='{0..65535}')
args = parser.parse_args(sys.argv[1:])
logging.basicConfig(level=logging.INFO)
state_dir = Path(args.statedir).absolute()
config = TriblerConfig.load(file=state_dir / 'triblerd.conf', state_dir=state_dir)
config.tunnel_community.enabled = False
config.libtorrent.enabled = False
config.bootstrap.enabled = False
config.chant.enabled = False
config.torrent_checking.enabled = False
config.api.http_enabled = True
config.api.http_port = args.restapi
config.bandwidth_accounting.outgoing_query_interval = 5
loop = get_event_loop()
ensure_future(crawler_session(config))
loop.run_forever()
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()
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
# Enable exitnode if set in options
if "exitnode" in options and options["exitnode"]:
msg("Enabling exitnode")
config.set_tunnel_community_enabled(True)
config.set_tunnel_community_exitnode_enabled(True)
else:
config.set_tunnel_community_exitnode_enabled(False)
# Enable bitcoin testnet
if "testnet" in options and options["testnet"]:
msg("Enabling bitcoin testnet")
config.set_testnet(True)
# Enable dummy wallets
if "dummy" in options and options["dummy"]:
msg("Enabling dummy wallets")
config.set_dummy_wallets_enabled(True)
# Enable record transactions
msg("Enabling record transactions")
config.set_record_transactions(True)
# Minimize functionality enabled for plebnet
# For now, config taken from market_plugin in devos tribler repo
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_mainline_dht_enabled(True)
config.set_dht_enabled(True)
config.set_chant_enabled(False)
config.set_bitcoinlib_enabled(True)
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"] != -1 and options["dispersy"] > 0:
config.set_dispersy_port(options["dispersy"])
if options["libtorrent"] != -1 and options["libtorrent"] > 0:
config.set_libtorrent_port(options["libtorrent"])
self.session = Session(config)
self.session.start().addErrback(
lambda failure: self.shutdown_process(failure.getErrorMessage()))
msg("Tribler started")
def tribler_config(tmp_path):
config = TriblerConfig(tmp_path)
return config
async def start(self, options):
# Determine ipv8 port
ipv8_port = options.ipv8_port
if ipv8_port == -1 and "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
statedir = Path(
os.path.join(get_root_state_directory(), "tunnel-%d") % ipv8_port)
config = TriblerConfig(statedir,
config_file=statedir / 'triblerd.conf')
config.set_tunnel_community_socks5_listen_ports([])
config.set_tunnel_community_random_slots(options.random_slots)
config.set_tunnel_community_competing_slots(options.competing_slots)
config.set_torrent_checking_enabled(False)
config.set_ipv8_enabled(True)
config.set_libtorrent_enabled(False)
config.set_ipv8_port(ipv8_port)
config.set_ipv8_address(options.ipv8_address)
config.set_trustchain_enabled(True)
config.set_market_community_enabled(False)
config.set_dht_enabled(True)
config.set_tunnel_community_exitnode_enabled(bool(options.exit))
config.set_popularity_community_enabled(False)
config.set_testnet(bool(options.testnet))
config.set_chant_enabled(False)
config.set_bootstrap_enabled(False)
if not options.no_rest_api:
config.set_http_api_enabled(True)
api_port = 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 options.ipv8_bootstrap_override is not None:
config.set_ipv8_bootstrap_override(options.ipv8_bootstrap_override)
self.session = Session(config)
self.log_circuits = options.log_circuits
self.session.notifier.add_observer(NTFY.TUNNEL_REMOVE,
self.circuit_removed)
await self.session.start()
if options.log_rejects:
# We set this after Tribler has started since the tunnel_community won't be available otherwise
self.session.tunnel_community.reject_callback = self.on_circuit_reject
# Tunnel helpers store more TrustChain blocks
self.session.trustchain_community.settings.max_db_blocks = 5000000
self.tribler_started()
