async def run(self):
await super().run()
config = self.session.config
key_component = await self.require_component(KeyComponent)
socks_ports = []
if not config.gui_test_mode:
socks_servers_component = await self.require_component(
SocksServersComponent)
socks_ports = socks_servers_component.socks_ports
self.download_manager = DownloadManager(
config=config.libtorrent,
state_dir=config.state_dir,
notifier=self.session.notifier,
peer_mid=key_component.primary_key.key_to_hash(),
download_defaults=config.download_defaults,
bootstrap_infohash=config.bootstrap.infohash,
socks_listen_ports=socks_ports,
dummy_mode=config.gui_test_mode)
self.download_manager.initialize()
await self.download_manager.load_checkpoints()
if config.gui_test_mode:
from tribler_core.tests.tools.common import TORRENT_WITH_DIRS # pylint: disable=import-outside-toplevel
uri = path_to_uri(TORRENT_WITH_DIRS)
await self.download_manager.start_download_from_uri(uri)
async def fake_dlmgr(tmp_path_factory):
config = LibtorrentSettings(dht_readiness_timeout=0)
dlmgr = DownloadManager(config=config,
state_dir=tmp_path_factory.mktemp('state_dir'),
notifier=MagicMock(),
peer_mid=b"0000")
dlmgr.metadata_tmpdir = tmp_path_factory.mktemp('metadata_tmpdir')
dlmgr.get_session = lambda *_, **__: MagicMock()
yield dlmgr
await dlmgr.shutdown(timeout=0)
async def download_manager(tmp_path_factory):
config = LibtorrentSettings()
config.dht = False
config.upnp = False
config.natpmp = False
config.lsd = False
download_manager = DownloadManager(
config=config,
state_dir=tmp_path_factory.mktemp('state_dir'),
notifier=MagicMock(),
peer_mid=b"0000")
download_manager.metadata_tmpdir = tmp_path_factory.mktemp('metadata_tmpdir')
download_manager.initialize()
yield download_manager
await download_manager.shutdown()
async def test_set_rate_settings(rest_api, tribler_config):
"""
Testing whether libtorrent rate limits works for large number without overflow error.
"""
extra_rate = 1024 * 1024 * 1024 # 1GB/s
post_data = {
'libtorrent': {
'max_download_rate': MAX_LIBTORRENT_RATE_LIMIT + extra_rate,
'max_upload_rate': MAX_LIBTORRENT_RATE_LIMIT + extra_rate
}
}
await do_request(rest_api, 'settings', expected_code=200, request_type='POST', post_data=post_data)
assert DownloadManager.get_libtorrent_max_download_rate(tribler_config.libtorrent) == MAX_LIBTORRENT_RATE_LIMIT
assert DownloadManager.get_libtorrent_max_upload_rate(tribler_config.libtorrent) == MAX_LIBTORRENT_RATE_LIMIT
async def create_tunnel_community(temp_path_factory,
comm_config: TunnelCommunitySettings = None,
exitnode=False,
start_lt=False) -> TriblerTunnelCommunity:
"""
Load the tunnel community in a given session. We are using our own tunnel community here instead of the one
used in Tribler.
"""
socks_servers = []
socks_ports = []
# Start the SOCKS5 servers
if start_lt:
for _ in range(NUM_SOCKS_PROXIES):
socks_server = Socks5Server()
socks_servers.append(socks_server)
await socks_server.start()
socks_ports.append(socks_server.port)
dlmgr = None
if start_lt:
# If libtorrent tries to connect to the socks5 servers before they are loaded,
# it will never recover (on Mac/Linux with Libtorrent >=1.2.0). Therefore, we start
# libtorrent afterwards.
dlmgr_settings = LibtorrentSettings()
dlmgr_settings.dht = False
dlmgr = DownloadManager(
state_dir=temp_path_factory.mktemp('state_dir'),
config=dlmgr_settings,
peer_mid=MagicMock(),
socks_listen_ports=socks_ports,
notifier=MagicMock())
dlmgr.metadata_tmpdir = temp_path_factory.mktemp('metadata_tmpdir')
comm_config = comm_config or TunnelCommunitySettings()
comm_config.exitnode_enabled = exitnode
mock_ipv8 = MockIPv8("curve25519",
TriblerTunnelCommunity,
settings={"max_circuits": 1},
config=comm_config,
socks_servers=socks_servers,
dlmgr=dlmgr)
if start_lt:
dlmgr.peer_mid = mock_ipv8.my_peer.mid
dlmgr.initialize()
dlmgr.is_shutdown_ready = lambda: True
tunnel_community = mock_ipv8.overlay
if exitnode:
mock_ipv8.overlay.settings.peer_flags.add(PEER_FLAG_EXIT_BT)
mock_ipv8.overlay.dht_provider = MockDHTProvider(
Peer(mock_ipv8.overlay.my_peer.key,
mock_ipv8.overlay.my_estimated_wan))
mock_ipv8.overlay.settings.remove_tunnel_delay = 0
return tunnel_community
async def channel_seeder(channel_tdef, loop, tmp_path_factory): # pylint: disable=unused-argument, redefined-outer-name
config = LibtorrentSettings()
config.dht = False
config.upnp = False
config.natpmp = False
config.lsd = False
seeder_dlmgr = DownloadManager(
state_dir=tmp_path_factory.mktemp('state_dir'),
config=config,
notifier=Mock(),
peer_mid=b"0000")
seeder_dlmgr.metadata_tmpdir = tmp_path_factory.mktemp('metadata_tmpdir')
seeder_dlmgr.initialize()
dscfg_seed = DownloadConfig()
dscfg_seed.set_dest_dir(TESTS_DATA_DIR / 'sample_channel')
upload = seeder_dlmgr.start_download(tdef=channel_tdef, config=dscfg_seed)
await upload.wait_for_status(DLSTATUS_SEEDING)
yield seeder_dlmgr
await seeder_dlmgr.shutdown()
async def video_seeder(tmp_path_factory, video_tdef):
config = LibtorrentSettings()
config.dht = False
config.upnp = False
config.natpmp = False
config.lsd = False
seeder_state_dir = tmp_path_factory.mktemp('video_seeder_state_dir')
dlmgr = DownloadManager(config=config,
state_dir=seeder_state_dir,
notifier=Mock(),
peer_mid=b"0000")
dlmgr.metadata_tmpdir = tmp_path_factory.mktemp('metadata_tmpdir')
dlmgr.initialize()
dscfg_seed = DownloadConfig()
dscfg_seed.set_dest_dir(TESTS_DATA_DIR)
upload = dlmgr.start_download(tdef=video_tdef, config=dscfg_seed)
await upload.wait_for_status(DLSTATUS_SEEDING)
yield dlmgr
await dlmgr.shutdown()
async def get_downloads(self, request):
get_peers = request.query.get('get_peers', '0') == '1'
get_pieces = request.query.get('get_pieces', '0') == '1'
get_files = request.query.get('get_files', '0') == '1'
downloads_json = []
downloads = self.download_manager.get_downloads()
for download in downloads:
if download.hidden and not download.config.get_channel_download():
# We still want to send channel downloads since they are displayed in the GUI
continue
state = download.get_state()
tdef = download.get_def()
# Create tracker information of the download
tracker_info = []
for url, url_info in download.get_tracker_status().items():
tracker_info.append({
"url": url,
"peers": url_info[0],
"status": url_info[1]
})
num_seeds, num_peers = state.get_num_seeds_peers()
num_connected_seeds, num_connected_peers = download.get_num_connected_seeds_peers(
)
if download.config.get_channel_download():
download_name = self.mds.ChannelMetadata.get_channel_name_cached(
tdef.get_name_utf8(), tdef.get_infohash())
elif self.mds is None:
download_name = tdef.get_name_utf8()
else:
download_name = self.mds.TorrentMetadata.get_torrent_title(tdef.get_infohash()) or \
tdef.get_name_utf8()
download_status = get_extended_status(
self.tunnel_community, download
) if self.tunnel_community else download.get_state().get_status()
download_json = {
"name":
download_name,
"progress":
state.get_progress(),
"infohash":
hexlify(tdef.get_infohash()),
"speed_down":
state.get_current_payload_speed(DOWNLOAD),
"speed_up":
state.get_current_payload_speed(UPLOAD),
"status":
dlstatus_strings[download_status],
"size":
tdef.get_length(),
"eta":
state.get_eta(),
"num_peers":
num_peers,
"num_seeds":
num_seeds,
"num_connected_peers":
num_connected_peers,
"num_connected_seeds":
num_connected_seeds,
"total_up":
state.get_total_transferred(UPLOAD),
"total_down":
state.get_total_transferred(DOWNLOAD),
"ratio":
state.get_seeding_ratio(),
"trackers":
tracker_info,
"hops":
download.config.get_hops(),
"anon_download":
download.get_anon_mode(),
"safe_seeding":
download.config.get_safe_seeding(),
# Maximum upload/download rates are set for entire sessions
"max_upload_speed":
DownloadManager.get_libtorrent_max_upload_rate(
self.download_manager.config),
"max_download_speed":
DownloadManager.get_libtorrent_max_download_rate(
self.download_manager.config),
"destination":
str(download.config.get_dest_dir()),
"availability":
state.get_availability(),
"total_pieces":
tdef.get_nr_pieces(),
"vod_mode":
download.stream and download.stream.enabled,
"error":
repr(state.get_error()) if state.get_error() else "",
"time_added":
download.config.get_time_added(),
"channel_download":
download.config.get_channel_download()
}
if download.stream:
download_json.update({
"vod_prebuffering_progress":
download.stream.prebuffprogress,
"vod_prebuffering_progress_consec":
download.stream.prebuffprogress_consec,
"vod_header_progress":
download.stream.headerprogress,
"vod_footer_progress":
download.stream.footerprogress,
})
# Add peers information if requested
if get_peers:
peer_list = state.get_peerlist()
for peer_info in peer_list: # Remove have field since it is very large to transmit.
del peer_info['have']
if 'extended_version' in peer_info:
peer_info[
'extended_version'] = _safe_extended_peer_info(
peer_info['extended_version'])
# Does this peer represent a hidden services circuit?
if peer_info.get(
'port'
) == CIRCUIT_ID_PORT and self.tunnel_community:
tc = self.tunnel_community
circuit_id = tc.ip_to_circuit_id(peer_info['ip'])
circuit = tc.circuits.get(circuit_id, None)
if circuit:
peer_info['circuit'] = circuit_id
download_json["peers"] = peer_list
# Add piece information if requested
if get_pieces:
download_json["pieces"] = download.get_pieces_base64().decode(
'utf-8')
# Add files if requested
if get_files:
download_json["files"] = self.get_files_info_json(download)
downloads_json.append(download_json)
return RESTResponse({"downloads": downloads_json})