def tribler_started_event(self, event_dict): # if public key format will be changed, don't forget to change it # at the core side as well public_key = event_dict["public_key"] if public_key: SentryReporter.set_user(public_key.encode('utf-8')) self.tribler_started.emit(event_dict["version"])
def test_set_user(): assert SentryReporter.set_user(b'some_id') == { 'id': 'db69fe66ec6b6b013c2f7d271ce17cae', 'username': '******', } assert SentryReporter.set_user(b'11111100100') == { 'id': '91f900f528d5580581197c2c6a4adbbc', 'username': '******', }
async def start(self): """ Start a Tribler session by initializing the LaunchManyCore class, opening the database and running the upgrader. Returns a deferred that fires when the Tribler session is ready for use. :param config: a TriblerConfig object """ self._logger.info("Session is using state directory: %s", self.config.get_state_dir()) self.get_ports_in_config() self.create_state_directory_structure() self.init_keypair() # we have to represent `user_id` as a string to make it equal to the # `user_id` on the GUI side user_id_str = hexlify(self.trustchain_keypair.key.pk).encode('utf-8') SentryReporter.set_user(user_id_str) # Start the REST API before the upgrader since we want to send interesting upgrader events over the socket if self.config.get_api_http_enabled() or self.config.get_api_https_enabled(): from tribler_core.restapi.rest_manager import RESTManager self.api_manager = RESTManager(self) self.readable_status = STATE_START_API await self.api_manager.start() if self.upgrader_enabled and not self.core_test_mode: from tribler_core.upgrade.upgrade import TriblerUpgrader self.upgrader = TriblerUpgrader(self) self.readable_status = STATE_UPGRADING_READABLE await self.upgrader.run() self.tracker_manager = TrackerManager(self) # Start torrent checker before Popularity community is loaded if self.config.get_torrent_checking_enabled() and not self.core_test_mode: from tribler_core.modules.torrent_checker.torrent_checker import TorrentChecker self.readable_status = STATE_START_TORRENT_CHECKER self.torrent_checker = TorrentChecker(self) await self.torrent_checker.initialize() # On Mac, we bundle the root certificate for the SSL validation since Twisted is not using the root # certificates provided by the system trust store. if sys.platform == 'darwin': os.environ['SSL_CERT_FILE'] = str(get_lib_path() / 'root_certs_mac.pem') if self.config.get_chant_enabled(): from tribler_core.modules.metadata_store.store import MetadataStore channels_dir = self.config.get_chant_channels_dir() metadata_db_name = 'metadata.db' if not self.config.get_chant_testnet() else 'metadata_testnet.db' database_path = self.config.get_state_dir() / 'sqlite' / metadata_db_name self.mds = MetadataStore(database_path, channels_dir, self.trustchain_keypair, notifier=self.notifier, disable_sync=self.core_test_mode) if self.core_test_mode: generate_test_channels(self.mds) # IPv8 if self.config.get_ipv8_enabled(): from ipv8.configuration import ConfigBuilder from ipv8.messaging.interfaces.dispatcher.endpoint import DispatcherEndpoint ipv8_config_builder = (ConfigBuilder() .set_port(self.config.get_ipv8_port()) .set_address(self.config.get_ipv8_address()) .clear_overlays() .clear_keys() # We load the keys ourselves .set_working_directory(str(self.config.get_state_dir())) .set_walker_interval(self.config.get_ipv8_walk_interval())) if self.core_test_mode: endpoint = DispatcherEndpoint([]) else: # IPv8 includes IPv6 support by default. # We only load IPv4 to not kill all Tribler overlays (currently, it would instantly crash all users). # If you want to test IPv6 in Tribler you can set ``endpoint = None`` here. endpoint = DispatcherEndpoint(["UDPIPv4"], UDPIPv4={'port': self.config.get_ipv8_port(), 'ip': self.config.get_ipv8_address()}) self.ipv8 = IPv8(ipv8_config_builder.finalize(), enable_statistics=self.config.get_ipv8_statistics() and not self.core_test_mode, endpoint_override=endpoint) await self.ipv8.start() self.config.set_anon_proxy_settings(2, ("127.0.0.1", self. config.get_tunnel_community_socks5_listen_ports())) self.ipv8_start_time = timemod.time() self.load_ipv8_overlays() if not self.core_test_mode: self.enable_ipv8_statistics() if self.api_manager: self.api_manager.set_ipv8_session(self.ipv8) if self.config.get_tunnel_community_enabled(): await self.tunnel_community.wait_for_socks_servers() if self.config.get_ipv8_walk_scaling_enabled(): from tribler_core.modules.ipv8_health_monitor import IPv8Monitor IPv8Monitor(self.ipv8, self.config.get_ipv8_walk_interval(), self.config.get_ipv8_walk_scaling_upper_limit()).start(self) # Note that currently we should only start libtorrent after the SOCKS5 servers have been started if self.config.get_libtorrent_enabled(): self.readable_status = STATE_START_LIBTORRENT from tribler_core.modules.libtorrent.download_manager import DownloadManager self.dlmgr = DownloadManager(self, dummy_mode=self.core_test_mode) self.dlmgr.initialize() self.readable_status = STATE_LOAD_CHECKPOINTS await self.dlmgr.load_checkpoints() if self.core_test_mode: await self.dlmgr.start_download_from_uri("magnet:?xt=urn:btih:0000000000000000000000000000000000000000") self.readable_status = STATE_READABLE_STARTED if self.config.get_watch_folder_enabled(): from tribler_core.modules.watch_folder import WatchFolder self.readable_status = STATE_START_WATCH_FOLDER self.watch_folder = WatchFolder(self) self.watch_folder.start() if self.config.get_resource_monitor_enabled() and not self.core_test_mode: from tribler_core.modules.resource_monitor.core import CoreResourceMonitor self.resource_monitor = CoreResourceMonitor(self) self.resource_monitor.start() if self.config.get_version_checker_enabled() and not self.core_test_mode: from tribler_core.modules.versioncheck_manager import VersionCheckManager self.version_check_manager = VersionCheckManager(self) self.version_check_manager.start() if self.config.get_ipv8_enabled(): from tribler_core.modules.payout_manager import PayoutManager self.payout_manager = PayoutManager(self.bandwidth_community, self.dht_community) if self.core_test_mode: from ipv8.messaging.interfaces.udp.endpoint import UDPv4Address from ipv8.dht.routing import RoutingTable self.dht_community.routing_tables[UDPv4Address] = RoutingTable('\x00' * 20) # GigaChannel Manager should be started *after* resuming the downloads, # because it depends on the states of torrent downloads if self.config.get_chant_enabled() and self.config.get_chant_manager_enabled() \ and self.config.get_libtorrent_enabled: from tribler_core.modules.metadata_store.gigachannel_manager import GigaChannelManager self.gigachannel_manager = GigaChannelManager(self) if not self.core_test_mode: self.gigachannel_manager.start() if self.config.get_bootstrap_enabled() and not self.core_test_mode: self.register_task('bootstrap_download', self.start_bootstrap_download) self.notifier.notify(NTFY.TRIBLER_STARTED, self.trustchain_keypair.key.pk) # If there is a config error, report to the user via GUI notifier if self.config.config_error: self.notifier.notify(NTFY.REPORT_CONFIG_ERROR, self.config.config_error)