def test_check_torrent_health(self):
"""
Test the endpoint to fetch the health of a chant-managed, infohash-only torrent
"""
infohash = 'a' * 20
tracker_url = 'udp://localhost:%s/announce' % self.udp_port
self.udp_tracker.tracker_info.add_info_about_infohash(
infohash, 12, 11, 1)
with db_session:
tracker_state = self.session.lm.mds.TrackerState(url=tracker_url)
torrent_state = self.session.lm.mds.TorrentState(
trackers=tracker_state, infohash=infohash)
self.session.lm.mds.TorrentMetadata(infohash=infohash,
title='ubuntu-torrent.iso',
size=42,
tracker_info=tracker_url,
health=torrent_state)
url = 'metadata/torrents/%s/health?timeout=10&refresh=1' % hexlify(
infohash)
self.should_check_equality = False
# Initialize the torrent checker
self.session.lm.torrent_checker = TorrentChecker(self.session)
self.session.lm.torrent_checker.initialize()
def verify_response_no_trackers(response):
json_response = json.loads(response)
self.assertIn("health", json_response)
self.assertIn("udp://localhost:%s" % self.udp_port,
json_response['health'])
if has_bep33_support():
self.assertIn("DHT", json_response['health'])
# Add mock DHT response
self.session.lm.ltmgr = MockObject()
self.session.lm.ltmgr.dht_health_manager = MockObject()
dht_health_dict = {
"infohash": hexlify(infohash),
"seeders": 1,
"leechers": 2
}
self.session.lm.ltmgr.dht_health_manager.get_health = lambda *_, **__: succeed(
{"DHT": [dht_health_dict]})
# Left for compatibility with other tests in this object
self.udp_tracker.start()
self.http_tracker.start()
yield self.do_request(
url, expected_code=200,
request_type='GET').addCallback(verify_response_no_trackers)
def verify_response_nowait(response):
json_response = json.loads(response)
self.assertDictEqual(json_response, {u'checking': u'1'})
yield self.do_request(
url + '&nowait=1', expected_code=200,
request_type='GET').addCallback(verify_response_nowait)
def setUp(self):
yield super(TestTorrentChecker, self).setUp()
self.session.lm.torrent_db = TorrentDBHandler(self.session)
self.session.lm.torrent_checker = TorrentChecker(self.session)
self.session.lm.tracker_manager = TrackerManager(self.session)
self.session.lm.popularity_community = MockObject()
self.torrent_checker = self.session.lm.torrent_checker
self.torrent_checker._torrent_db = self.session.open_dbhandler(
NTFY_TORRENTS)
self.torrent_checker._torrent_db.category = Category()
self.torrent_checker.listen_on_udp = lambda: None
def setUp(self):
yield super(TestTorrentChecker, self).setUp()
self.session.lm.torrent_checker = TorrentChecker(self.session)
self.session.lm.tracker_manager = TrackerManager(self.session)
self.session.lm.popularity_community = MockObject()
self.torrent_checker = self.session.lm.torrent_checker
self.torrent_checker.listen_on_udp = lambda: None
def get_metainfo(_, callback, **__):
callback({"seeders": 1, "leechers": 2})
self.session.lm.ltmgr = MockObject()
self.session.lm.ltmgr.get_metainfo = get_metainfo
self.session.lm.ltmgr.shutdown = lambda: None
def setUp(self, annotate=True):
super(TestTorrentChecker, self).setUp(annotate=annotate)
config = SessionStartupConfig()
config.set_state_dir(self.getStateDir())
config.set_megacache(True)
self.session = Session(config, ignore_singleton=True)
self.session.start_database()
self.session.lm.torrent_db = TorrentDBHandler(self.session)
self.session.lm.torrent_checker = TorrentChecker(self.session)
self.session.lm.tracker_manager = TrackerManager(self.session)
self.torrent_checker = self.session.lm.torrent_checker
self.torrent_checker._torrent_db = self.session.open_dbhandler(NTFY_TORRENTS)
self.torrent_checker._torrent_db.category = Category()
def setUp(self, annotate=True):
super(TestTorrentChecker, self).setUp(annotate=annotate)
config = TriblerConfig()
config.set_state_dir(self.getStateDir())
config.set_megacache_enabled(True)
self.session = Session(config)
self.session.start_database()
self.session.lm.torrent_db = TorrentDBHandler(self.session)
self.session.lm.torrent_checker = TorrentChecker(self.session)
self.session.lm.tracker_manager = TrackerManager(self.session)
self.session.lm.popularity_community = MockObject()
self.torrent_checker = self.session.lm.torrent_checker
self.torrent_checker._torrent_db = self.session.open_dbhandler(NTFY_TORRENTS)
self.torrent_checker._torrent_db.category = Category()
self.torrent_checker.listen_on_udp = lambda: None
def init(self):
if self.dispersy:
from Tribler.dispersy.community import HardKilledCommunity
self._logger.info("lmc: Starting Dispersy...")
self.session.readable_status = STATE_STARTING_DISPERSY
now = timemod.time()
success = self.dispersy.start(self.session.autoload_discovery)
diff = timemod.time() - now
if success:
self._logger.info(
"lmc: Dispersy started successfully in %.2f seconds [port: %d]",
diff, self.dispersy.wan_address[1])
else:
self._logger.info(
"lmc: Dispersy failed to start in %.2f seconds", diff)
self.upnp_ports.append((self.dispersy.wan_address[1], 'UDP'))
from Tribler.dispersy.crypto import M2CryptoSK
private_key = self.dispersy.crypto.key_to_bin(
M2CryptoSK(filename=self.session.config.
get_permid_keypair_filename()))
self.session.dispersy_member = blockingCallFromThread(
reactor, self.dispersy.get_member, private_key=private_key)
blockingCallFromThread(reactor,
self.dispersy.define_auto_load,
HardKilledCommunity,
self.session.dispersy_member,
load=True)
if self.session.config.get_megacache_enabled():
self.dispersy.database.attach_commit_callback(
self.session.sqlite_db.commit_now)
# notify dispersy finished loading
self.session.notifier.notify(NTFY_DISPERSY, NTFY_STARTED, None)
self.session.readable_status = STATE_LOADING_COMMUNITIES
# We should load the mainline DHT before loading the IPv8 overlays since the DHT is used for the tunnel overlay.
if self.session.config.get_mainline_dht_enabled():
self.session.readable_status = STATE_START_MAINLINE_DHT
from Tribler.Core.DecentralizedTracking import mainlineDHT
self.mainline_dht = mainlineDHT.init(
('127.0.0.1', self.session.config.get_mainline_dht_port()),
self.session.config.get_state_dir())
self.upnp_ports.append(
(self.session.config.get_mainline_dht_port(), 'UDP'))
if self.ipv8:
self.load_ipv8_overlays()
if self.dispersy:
self.load_dispersy_communities()
tunnel_community_ports = self.session.config.get_tunnel_community_socks5_listen_ports(
)
self.session.config.set_anon_proxy_settings(
2, ("127.0.0.1", tunnel_community_ports))
if self.session.config.get_channel_search_enabled(
) and self.session.config.get_dispersy_enabled():
self.session.readable_status = STATE_INITIALIZE_CHANNEL_MGR
from Tribler.Core.Modules.channel.channel_manager import ChannelManager
self.channel_manager = ChannelManager(self.session)
self.channel_manager.initialize()
if self.session.config.get_libtorrent_enabled():
self.session.readable_status = STATE_START_LIBTORRENT
from Tribler.Core.Libtorrent.LibtorrentMgr import LibtorrentMgr
self.ltmgr = LibtorrentMgr(self.session)
self.ltmgr.initialize()
for port, protocol in self.upnp_ports:
self.ltmgr.add_upnp_mapping(port, protocol)
# add task for tracker checking
if self.session.config.get_torrent_checking_enabled():
self.session.readable_status = STATE_START_TORRENT_CHECKER
self.torrent_checker = TorrentChecker(self.session)
self.torrent_checker.initialize()
if self.rtorrent_handler and self.session.config.get_dispersy_enabled(
):
self.session.readable_status = STATE_START_REMOTE_TORRENT_HANDLER
self.rtorrent_handler.initialize()
if self.api_manager:
self.session.readable_status = STATE_START_API_ENDPOINTS
self.api_manager.root_endpoint.start_endpoints()
if self.session.config.get_watch_folder_enabled():
self.session.readable_status = STATE_START_WATCH_FOLDER
self.watch_folder = WatchFolder(self.session)
self.watch_folder.start()
if self.session.config.get_credit_mining_enabled():
self.session.readable_status = STATE_START_CREDIT_MINING
from Tribler.Core.CreditMining.CreditMiningManager import CreditMiningManager
self.credit_mining_manager = CreditMiningManager(self.session)
if self.session.config.get_resource_monitor_enabled():
self.resource_monitor = ResourceMonitor(self.session)
self.resource_monitor.start()
self.version_check_manager = VersionCheckManager(self.session)
self.session.set_download_states_callback(self.sesscb_states_callback)
self.initComplete = True
def init(self):
if self.dispersy:
from Tribler.dispersy.community import HardKilledCommunity
self._logger.info("lmc: Starting Dispersy...")
now = timemod.time()
success = self.dispersy.start(self.session.autoload_discovery)
diff = timemod.time() - now
if success:
self._logger.info(
"lmc: Dispersy started successfully in %.2f seconds [port: %d]",
diff, self.dispersy.wan_address[1])
else:
self._logger.info(
"lmc: Dispersy failed to start in %.2f seconds", diff)
self.upnp_ports.append((self.dispersy.wan_address[1], 'UDP'))
from Tribler.dispersy.crypto import M2CryptoSK
private_key = self.dispersy.crypto.key_to_bin(
M2CryptoSK(filename=self.session.config.
get_permid_keypair_filename()))
self.session.dispersy_member = blockingCallFromThread(
reactor, self.dispersy.get_member, private_key=private_key)
blockingCallFromThread(reactor,
self.dispersy.define_auto_load,
HardKilledCommunity,
self.session.dispersy_member,
load=True)
if self.session.config.get_megacache_enabled():
self.dispersy.database.attach_commit_callback(
self.session.sqlite_db.commit_now)
# notify dispersy finished loading
self.session.notifier.notify(NTFY_DISPERSY, NTFY_STARTED, None)
self.load_communities()
tunnel_community_ports = self.session.config.get_tunnel_community_socks5_listen_ports(
)
self.session.config.set_anon_proxy_settings(
2, ("127.0.0.1", tunnel_community_ports))
if self.session.config.get_channel_search_enabled():
from Tribler.Core.Modules.channel.channel_manager import ChannelManager
self.channel_manager = ChannelManager(self.session)
self.channel_manager.initialize()
if self.session.config.get_mainline_dht_enabled():
from Tribler.Core.DecentralizedTracking import mainlineDHT
self.mainline_dht = mainlineDHT.init(
('127.0.0.1', self.session.config.get_mainline_dht_port()),
self.session.config.get_state_dir())
self.upnp_ports.append(
(self.session.config.get_mainline_dht_port(), 'UDP'))
if self.session.config.get_libtorrent_enabled():
from Tribler.Core.Libtorrent.LibtorrentMgr import LibtorrentMgr
self.ltmgr = LibtorrentMgr(self.session)
self.ltmgr.initialize()
for port, protocol in self.upnp_ports:
self.ltmgr.add_upnp_mapping(port, protocol)
# add task for tracker checking
if self.session.config.get_torrent_checking_enabled():
self.torrent_checker = TorrentChecker(self.session)
self.torrent_checker.initialize()
if self.rtorrent_handler:
self.rtorrent_handler.initialize()
if self.api_manager:
self.api_manager.root_endpoint.start_endpoints()
if self.session.config.get_watch_folder_enabled():
self.watch_folder = WatchFolder(self.session)
self.watch_folder.start()
if self.session.config.get_credit_mining_enabled():
from Tribler.Core.CreditMining.BoostingManager import BoostingManager
self.boosting_manager = BoostingManager(self.session)
if self.session.config.get_resource_monitor_enabled():
self.resource_monitor = ResourceMonitor(self.session)
self.resource_monitor.start()
self.version_check_manager = VersionCheckManager(self.session)
self.session.set_download_states_callback(self.sesscb_states_callback)
self.initComplete = True
def test_check_torrent_health(self):
"""
Test the endpoint to fetch the health of a torrent
"""
torrent_db = self.session.open_dbhandler(NTFY_TORRENTS)
torrent_db.addExternalTorrentNoDef(
'a' * 20, 'ubuntu-torrent.iso', [['file1.txt', 42]],
('udp://localhost:%s/announce' % self.udp_port,
'http://localhost:%s/announce' % self.http_port), time.time())
url = 'torrents/%s/health?timeout=10&refresh=1' % ('a' *
20).encode('hex')
self.should_check_equality = False
yield self.do_request(url, expected_code=400,
request_type='GET') # No torrent checker
def call_cb(infohash, callback, **_):
callback({"seeders": 1, "leechers": 2})
# Initialize the torrent checker
self.session.lm.torrent_checker = TorrentChecker(self.session)
self.session.lm.torrent_checker.initialize()
self.session.lm.ltmgr = MockObject()
self.session.lm.ltmgr.get_metainfo = call_cb
yield self.do_request('torrents/%s/health' % ('f' * 40),
expected_code=404,
request_type='GET')
def verify_response_no_trackers(response):
json_response = json.loads(response)
self.assertTrue('DHT' in json_response['health'])
def verify_response_with_trackers(response):
json_response = json.loads(response)
expected_dict = {
u"health": {
u"DHT": {
u"leechers": 2,
u"seeders": 1,
u"infohash": (u'a' * 20).encode('hex')
},
u"udp://localhost:%s" % self.udp_port: {
u"leechers": 20,
u"seeders": 10,
u"infohash": (u'a' * 20).encode('hex')
},
u"http://localhost:%s/announce" % self.http_port: {
u"leechers": 30,
u"seeders": 20,
u"infohash": (u'a' * 20).encode('hex')
}
}
}
self.assertDictEqual(json_response, expected_dict)
yield self.do_request(
url, expected_code=200,
request_type='GET').addCallback(verify_response_no_trackers)
self.udp_tracker.start()
self.udp_tracker.tracker_info.add_info_about_infohash('a' * 20, 10, 20)
self.http_tracker.start()
self.http_tracker.tracker_info.add_info_about_infohash(
'a' * 20, 20, 30)
yield self.do_request(
url, expected_code=200,
request_type='GET').addCallback(verify_response_with_trackers)
def init(self):
if self.dispersy:
from Tribler.dispersy.community import HardKilledCommunity
self._logger.info("lmc: Starting Dispersy...")
now = timemod.time()
success = self.dispersy.start(self.session.autoload_discovery)
diff = timemod.time() - now
if success:
self._logger.info("lmc: Dispersy started successfully in %.2f seconds [port: %d]",
diff, self.dispersy.wan_address[1])
else:
self._logger.info("lmc: Dispersy failed to start in %.2f seconds", diff)
self.upnp_ports.append((self.dispersy.wan_address[1], 'UDP'))
from Tribler.dispersy.crypto import M2CryptoSK
self.session.dispersy_member = blockingCallFromThread(reactor, self.dispersy.get_member,
private_key=self.dispersy.crypto.key_to_bin(M2CryptoSK(filename=self.session.get_permid_keypair_filename())))
blockingCallFromThread(reactor, self.dispersy.define_auto_load, HardKilledCommunity,
self.session.dispersy_member, load=True)
if self.session.get_megacache():
self.dispersy.database.attach_commit_callback(self.session.sqlite_db.commit_now)
# notify dispersy finished loading
self.session.notifier.notify(NTFY_DISPERSY, NTFY_STARTED, None)
@blocking_call_on_reactor_thread
def load_communities():
self._logger.info("tribler: Preparing communities...")
now_time = timemod.time()
default_kwargs = {'tribler_session': self.session}
# Search Community
if self.session.get_enable_torrent_search():
from Tribler.community.search.community import SearchCommunity
self.dispersy.define_auto_load(SearchCommunity, self.session.dispersy_member, load=True,
kargs=default_kwargs)
# AllChannel Community
if self.session.get_enable_channel_search():
from Tribler.community.allchannel.community import AllChannelCommunity
self.dispersy.define_auto_load(AllChannelCommunity, self.session.dispersy_member, load=True,
kargs=default_kwargs)
# Bartercast Community
if self.session.get_barter_community_enabled():
from Tribler.community.bartercast4.community import BarterCommunity
self.dispersy.define_auto_load(BarterCommunity, self.session.dispersy_member, load=True)
# Channel Community
if self.session.get_channel_community_enabled():
from Tribler.community.channel.community import ChannelCommunity
self.dispersy.define_auto_load(ChannelCommunity,
self.session.dispersy_member, load=True, kargs=default_kwargs)
# PreviewChannel Community
if self.session.get_preview_channel_community_enabled():
from Tribler.community.channel.preview import PreviewChannelCommunity
self.dispersy.define_auto_load(PreviewChannelCommunity,
self.session.dispersy_member, kargs=default_kwargs)
if self.session.get_tunnel_community_enabled():
tunnel_settings = TunnelSettings(tribler_session=self.session)
tunnel_kwargs = {'tribler_session': self.session, 'settings': tunnel_settings}
if self.session.get_enable_multichain():
multichain_kwargs = {'tribler_session': self.session}
# If the multichain is enabled, we use the permanent multichain keypair
# for both the multichain and the tunnel community
keypair = self.session.multichain_keypair
dispersy_member = self.dispersy.get_member(private_key=keypair.key_to_bin())
from Tribler.community.multichain.community import MultiChainCommunity
self.dispersy.define_auto_load(MultiChainCommunity,
dispersy_member,
load=True,
kargs=multichain_kwargs)
from Tribler.community.tunnel.hidden_community_multichain import HiddenTunnelCommunityMultichain
self.tunnel_community = self.dispersy.define_auto_load(
HiddenTunnelCommunityMultichain, dispersy_member, load=True, kargs=tunnel_kwargs)[0]
else:
keypair = self.dispersy.crypto.generate_key(u"curve25519")
dispersy_member = self.dispersy.get_member(private_key=self.dispersy.crypto.key_to_bin(keypair))
from Tribler.community.tunnel.hidden_community import HiddenTunnelCommunity
self.tunnel_community = self.dispersy.define_auto_load(
HiddenTunnelCommunity, dispersy_member, load=True, kargs=tunnel_kwargs)[0]
self.session.set_anon_proxy_settings(2, ("127.0.0.1",
self.session.get_tunnel_community_socks5_listen_ports()))
self._logger.info("tribler: communities are ready in %.2f seconds", timemod.time() - now_time)
load_communities()
if self.session.get_enable_channel_search():
from Tribler.Core.Modules.channel.channel_manager import ChannelManager
self.channel_manager = ChannelManager(self.session)
self.channel_manager.initialize()
if self.session.get_mainline_dht():
from Tribler.Core.DecentralizedTracking import mainlineDHT
self.mainline_dht = mainlineDHT.init(('127.0.0.1', self.session.get_mainline_dht_listen_port()),
self.session.get_state_dir())
self.upnp_ports.append((self.session.get_mainline_dht_listen_port(), 'UDP'))
if self.session.get_libtorrent():
from Tribler.Core.Libtorrent.LibtorrentMgr import LibtorrentMgr
self.ltmgr = LibtorrentMgr(self.session)
self.ltmgr.initialize()
for port, protocol in self.upnp_ports:
self.ltmgr.add_upnp_mapping(port, protocol)
# add task for tracker checking
if self.session.get_torrent_checking():
self.torrent_checker = TorrentChecker(self.session)
self.torrent_checker.initialize()
if self.rtorrent_handler:
self.rtorrent_handler.initialize()
if self.api_manager:
self.api_manager.root_endpoint.start_endpoints()
if self.session.get_watch_folder_enabled():
self.watch_folder = WatchFolder(self.session)
self.watch_folder.start()
if self.session.get_creditmining_enable():
from Tribler.Policies.BoostingManager import BoostingManager
self.boosting_manager = BoostingManager(self.session)
self.version_check_manager = VersionCheckManager(self.session)
self.session.set_download_states_callback(self.sesscb_states_callback)
self.initComplete = True
def test_check_torrent_health_chant(self):
"""
Test the endpoint to fetch the health of a chant-managed, infohash-only torrent
"""
infohash = 'a' * 20
tracker_url = 'udp://localhost:%s/announce' % self.udp_port
meta_info = {
"info": {
"name": "my_torrent",
"piece length": 42,
"root hash": infohash,
"files": [],
"url-list": tracker_url
}
}
tdef = TorrentDef.load_from_dict(meta_info)
with db_session:
self.session.lm.mds.TorrentMetadata(infohash=tdef.infohash,
title='ubuntu-torrent.iso',
size=42,
tracker_info=tracker_url)
url = 'torrents/%s/health?timeout=10&refresh=1' % tdef.infohash.encode(
'hex')
self.should_check_equality = False
def fake_get_metainfo(_,
callback,
timeout=10,
timeout_callback=None,
notify=True):
meta_info_extended = meta_info.copy()
meta_info_extended['seeders'] = 12
meta_info_extended['leechers'] = 11
callback(meta_info_extended)
# Initialize the torrent checker
self.session.lm.torrent_checker = TorrentChecker(self.session)
self.session.lm.torrent_checker.initialize()
self.session.lm.ltmgr = MockObject()
self.session.lm.ltmgr.get_metainfo = fake_get_metainfo
def verify_response_no_trackers(response):
json_response = json.loads(response)
expected_dict = {
u"health": {
u"DHT": {
u"leechers": 11,
u"seeders": 12,
u"infohash": unicode(tdef.infohash.encode('hex'))
}
}
}
self.assertDictEqual(json_response, expected_dict)
# Left for compatibility with other tests in this object
self.udp_tracker.start()
self.http_tracker.start()
# TODO: add test for DHT timeout
yield self.do_request(
url, expected_code=200,
request_type='GET').addCallback(verify_response_no_trackers)
def init(self, autoload_discovery):
if self.dispersy:
from Tribler.dispersy.community import HardKilledCommunity
self._logger.info("lmc: Starting Dispersy...")
now = timemod.time()
success = self.dispersy.start(autoload_discovery)
diff = timemod.time() - now
if success:
self._logger.info(
"lmc: Dispersy started successfully in %.2f seconds [port: %d]",
diff, self.dispersy.wan_address[1])
else:
self._logger.info(
"lmc: Dispersy failed to start in %.2f seconds", diff)
self.upnp_ports.append((self.dispersy.wan_address[1], 'UDP'))
from Tribler.dispersy.crypto import M2CryptoSK
self.session.dispersy_member = blockingCallFromThread(
reactor,
self.dispersy.get_member,
private_key=self.dispersy.crypto.key_to_bin(
M2CryptoSK(
filename=self.session.get_permid_keypair_filename())))
blockingCallFromThread(reactor,
self.dispersy.define_auto_load,
HardKilledCommunity,
self.session.dispersy_member,
load=True)
if self.session.get_megacache():
self.dispersy.database.attach_commit_callback(
self.session.sqlite_db.commit_now)
# notify dispersy finished loading
self.session.notifier.notify(NTFY_DISPERSY, NTFY_STARTED, None)
@blocking_call_on_reactor_thread
def load_communities():
# load communities
# Search Community
if self.session.get_enable_torrent_search():
from Tribler.community.search.community import SearchCommunity
self.dispersy.define_auto_load(
SearchCommunity,
self.session.dispersy_member,
load=True,
kargs={'tribler_session': self.session})
# AllChannel Community
if self.session.get_enable_channel_search():
from Tribler.community.allchannel.community import AllChannelCommunity
self.dispersy.define_auto_load(
AllChannelCommunity,
self.session.dispersy_member,
load=True,
kargs={'tribler_session': self.session})
load_communities()
from Tribler.Core.DecentralizedTracking import mainlineDHT
try:
self.mainline_dht = mainlineDHT.init(
('127.0.0.1', self.session.get_mainline_dht_listen_port()),
self.session.get_state_dir())
self.upnp_ports.append(
(self.session.get_mainline_dht_listen_port(), 'UDP'))
except:
print_exc()
if self.session.get_libtorrent():
from Tribler.Core.Libtorrent.LibtorrentMgr import LibtorrentMgr
self.ltmgr = LibtorrentMgr(self.session)
self.ltmgr.initialize()
# FIXME(lipu): upnp APIs are not exported in libtorrent python-binding.
#for port, protocol in self.upnp_ports:
# self.ltmgr.add_upnp_mapping(port, protocol)
# add task for tracker checking
if self.session.get_torrent_checking():
try:
from Tribler.Core.TorrentChecker.torrent_checker import TorrentChecker
self.torrent_checker = TorrentChecker(self.session)
self.torrent_checker.initialize()
except:
print_exc()
if self.rtorrent_handler:
self.rtorrent_handler.initialize()
self.initComplete = True
def init(self):
# Wallets
if self.session.config.get_bitcoinlib_enabled():
try:
from Tribler.Core.Modules.wallet.btc_wallet import BitcoinWallet, BitcoinTestnetWallet
wallet_path = os.path.join(self.session.config.get_state_dir(),
'wallet')
btc_wallet = BitcoinWallet(wallet_path)
btc_testnet_wallet = BitcoinTestnetWallet(wallet_path)
self.wallets[btc_wallet.get_identifier()] = btc_wallet
self.wallets[
btc_testnet_wallet.get_identifier()] = btc_testnet_wallet
except Exception as exc:
self._logger.error("bitcoinlib library cannot be loaded: %s",
exc)
if self.session.config.get_chant_enabled():
channels_dir = os.path.join(
self.session.config.get_chant_channels_dir())
database_path = os.path.join(self.session.config.get_state_dir(),
'sqlite', 'metadata.db')
self.mds = MetadataStore(database_path, channels_dir,
self.session.trustchain_keypair)
if self.session.config.get_dummy_wallets_enabled():
# For debugging purposes, we create dummy wallets
dummy_wallet1 = DummyWallet1()
self.wallets[dummy_wallet1.get_identifier()] = dummy_wallet1
dummy_wallet2 = DummyWallet2()
self.wallets[dummy_wallet2.get_identifier()] = dummy_wallet2
if self.ipv8:
self.ipv8_start_time = time.time()
self.load_ipv8_overlays()
self.enable_ipv8_statistics()
tunnel_community_ports = self.session.config.get_tunnel_community_socks5_listen_ports(
)
self.session.config.set_anon_proxy_settings(
2, ("127.0.0.1", tunnel_community_ports))
if self.session.config.get_libtorrent_enabled():
self.session.readable_status = STATE_START_LIBTORRENT
from Tribler.Core.Libtorrent.LibtorrentMgr import LibtorrentMgr
self.ltmgr = LibtorrentMgr(self.session)
self.ltmgr.initialize()
for port, protocol in self.upnp_ports:
self.ltmgr.add_upnp_mapping(port, protocol)
if self.session.config.get_chant_enabled():
self.gigachannel_manager = GigaChannelManager(self.session)
self.gigachannel_manager.start()
# add task for tracker checking
if self.session.config.get_torrent_checking_enabled():
self.session.readable_status = STATE_START_TORRENT_CHECKER
self.torrent_checker = TorrentChecker(self.session)
self.torrent_checker.initialize()
if self.api_manager:
self.session.readable_status = STATE_START_API_ENDPOINTS
self.api_manager.root_endpoint.start_endpoints()
if self.session.config.get_watch_folder_enabled():
self.session.readable_status = STATE_START_WATCH_FOLDER
self.watch_folder = WatchFolder(self.session)
self.watch_folder.start()
if self.session.config.get_credit_mining_enabled():
self.session.readable_status = STATE_START_CREDIT_MINING
from Tribler.Core.CreditMining.CreditMiningManager import CreditMiningManager
self.credit_mining_manager = CreditMiningManager(self.session)
if self.session.config.get_resource_monitor_enabled():
self.resource_monitor = ResourceMonitor(self.session)
self.resource_monitor.start()
if self.session.config.get_version_checker_enabled():
self.version_check_manager = VersionCheckManager(self.session)
self.version_check_manager.start()
self.session.set_download_states_callback(self.sesscb_states_callback)
if self.session.config.get_ipv8_enabled(
) and self.session.config.get_trustchain_enabled():
self.payout_manager = PayoutManager(self.trustchain_community,
self.dht_community)
self.initComplete = True
