async def setUp(self): await super(TestResourceMonitor, self).setUp() mock_session = MockObject() mock_session.config = MockObject() mock_session.config.get_resource_monitor_history_size = lambda: 1 mock_session.config.get_resource_monitor_poll_interval = lambda: 20 mock_session.config.get_state_dir = lambda: path_util.Path(".") mock_session.config.get_log_dir = lambda: path_util.Path("logs") mock_session.config.get_resource_monitor_enabled = lambda: False self.resource_monitor = ResourceMonitor(mock_session) self.resource_monitor.session.notifier = MockObject() self.resource_monitor.session.notifier.notify = lambda subject, changeType, obj_id, *args: None
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 check_watch_folder(self): if not self.session.config.get_watch_folder_path().is_dir(): return # Make sure that we pass a str to os.walk watch_dir = str(self.session.config.get_watch_folder_path()) for root, _, files in os.walk(watch_dir): root = path_util.Path(root) for name in files: if not name.endswith(".torrent"): continue try: tdef = TorrentDef.load(root / name) if not tdef.get_metainfo(): self.cleanup_torrent_file(root, name) continue except: # torrent appears to be corrupt self.cleanup_torrent_file(root, name) continue infohash = tdef.get_infohash() if not self.session.dlmgr.download_exists(infohash): self._logger.info("Starting download from torrent file %s", name) dl_config = DownloadConfig() anon_enabled = self.session.config.get_default_anonymity_enabled() default_num_hops = self.session.config.get_default_number_hops() dl_config.set_hops(default_num_hops if anon_enabled else 0) dl_config.set_safe_seeding(self.session.config.get_default_safeseeding_enabled()) dl_config.set_dest_dir(self.session.config.get_default_destination_dir()) self.session.dlmgr.start_download(tdef=tdef, config=dl_config)
def check_watch_folder(self): if not self.watch_folder.is_dir(): return # Make sure that we pass a str to os.walk watch_dir = str(self.watch_folder) for root, _, files in os.walk(watch_dir): root = path_util.Path(root) for name in files: if not name.endswith(".torrent"): continue try: tdef = TorrentDef.load(root / name) if not tdef.get_metainfo(): self.cleanup_torrent_file(root, name) continue except: # torrent appears to be corrupt self.cleanup_torrent_file(root, name) continue infohash = tdef.get_infohash() if not self.download_manager.download_exists(infohash): self._logger.info("Starting download from torrent file %s", name) self.download_manager.start_download(torrent_file=root / name)
def get_files_with_length(self, exts=None): """ The list of files in the torrent def. @param exts (Optional) list of filename extensions (without leading .) to search for. @return A list of filenames. """ videofiles = [] for filename, length in self._get_all_files_as_unicode_with_length(): ext = path_util.Path(filename).suffix if ext != "" and ext[0] == ".": ext = ext[1:] if exts is None or ext.lower() in exts: videofiles.append((filename, length)) return videofiles
def get_index_of_file_in_files(self, file): if not self.metainfo: raise ValueError("TorrentDef does not have metainfo") info = self.metainfo[b'info'] if file is not None and b'files' in info: for i in range(len(info[b'files'])): file_dict = info[b'files'][i] if b'path.utf-8' in file_dict: intorrentpath = maketorrent.pathlist2filename(file_dict[b'path.utf-8']) else: intorrentpath = maketorrent.pathlist2filename(file_dict[b'path']) if intorrentpath == path_util.Path(ensure_unicode(file, 'utf8')): return i raise ValueError("File not found in torrent") else: raise ValueError("File not found in single-file torrent")
def __init__(self, *args, **kwargs): self.tribler_session = kwargs.pop('tribler_session', None) num_competing_slots = kwargs.pop('competing_slots', 15) num_random_slots = kwargs.pop('random_slots', 5) self.bandwidth_community = kwargs.pop('bandwidth_community', None) socks_listen_ports = kwargs.pop('socks_listen_ports', None) state_path = self.tribler_session.config.get_state_dir( ) if self.tribler_session else path_util.Path() self.exitnode_cache = kwargs.pop('exitnode_cache', state_path / 'exitnode_cache.dat') super().__init__(*args, **kwargs) self._use_main_thread = True if self.tribler_session: if self.tribler_session.config.get_tunnel_community_exitnode_enabled( ): self.settings.peer_flags.add(PEER_FLAG_EXIT_BT) self.settings.peer_flags.add(PEER_FLAG_EXIT_IPV8) self.settings.peer_flags.add(PEER_FLAG_EXIT_HTTP) if not socks_listen_ports: socks_listen_ports = self.tribler_session.config.get_tunnel_community_socks5_listen_ports( ) elif socks_listen_ports is None: socks_listen_ports = range(1080, 1085) self.bittorrent_peers = {} self.dispatcher = TunnelDispatcher(self) self.download_states = {} self.competing_slots = [ (0, None) ] * num_competing_slots # 1st tuple item = token balance, 2nd = circuit id self.random_slots = [None] * num_random_slots self.reject_callback = None # This callback is invoked with a tuple (time, balance) when we reject a circuit self.last_forced_announce = {} # Start the SOCKS5 servers self.socks_servers = [] for port in socks_listen_ports: socks_server = Socks5Server(port, self.dispatcher) self.register_task('start_socks_%d' % port, socks_server.start) self.socks_servers.append(socks_server) self.dispatcher.set_socks_servers(self.socks_servers) self.add_message_handler(BandwidthTransactionPayload, self.on_payout) self.add_cell_handler(BalanceRequestPayload, self.on_balance_request_cell) self.add_cell_handler(RelayBalanceRequestPayload, self.on_relay_balance_request_cell) self.add_cell_handler(BalanceResponsePayload, self.on_balance_response_cell) self.add_cell_handler(RelayBalanceResponsePayload, self.on_relay_balance_response_cell) self.add_cell_handler(HTTPRequestPayload, self.on_http_request) self.add_cell_handler(HTTPResponsePayload, self.on_http_response) NO_CRYPTO_PACKETS.extend( [BalanceRequestPayload.msg_id, BalanceResponsePayload.msg_id]) if self.exitnode_cache: self.restore_exitnodes_from_disk()
def get_desktop_dir(): # http://www.mvps.org/access/api/api0054.htm # CSIDL_DESKTOPDIRECTORY = &H10 # C:\Documents and Settings\username\Desktop return path_util.Path(shell.SHGetSpecialFolderPath(0, 0x10))
def get_picture_dir(): # http://www.mvps.org/access/api/api0054.htm # CSIDL_MYPICTURES = &H27 # C:\Documents and Settings\username\My Documents\My Pictures return path_util.Path(shell.SHGetSpecialFolderPath(0, 0x27))
def get_appstate_dir(): # http://www.mvps.org/access/api/api0054.htm # CSIDL_APPDATA = &H1A # C:\Documents and Settings\username\Application Data return path_util.Path( shell.SHGetSpecialFolderPath(0, shellcon.CSIDL_APPDATA))
def get_home_dir(): # http://www.mvps.org/access/api/api0054.htm # CSIDL_PROFILE = &H28 # C:\Documents and Settings\username return path_util.Path( shell.SHGetSpecialFolderPath(0, shellcon.CSIDL_PROFILE))
def create_torrent_file(file_path_list, params, torrent_filepath=None): fs = libtorrent.file_storage() # filter all non-files file_path_list_filtered = [] for path in file_path_list: path = path_util.Path(path) if not path.exists(): raise IOError('Path does not exist: %s' % path) elif path.is_file(): file_path_list_filtered.append(path) # get the directory where these files are in. If there are multiple files, take the common directory they are in if len(file_path_list_filtered) == 1: base_path = path_util.split(file_path_list_filtered[0])[0] else: base_path = path_util.abspath(commonprefix(file_path_list_filtered)) # the base_dir directory is the parent directory of the base_path and is passed to the set_piece_hash method if len(file_path_list_filtered) == 1: filename = path_util.basename(file_path_list_filtered[0]) fs.add_file(filename, path_util.getsize(file_path_list_filtered[0])) else: for full_file_path in file_path_list_filtered: #FIXME: there should be a better, cleaner way to define this filename = path_util.join( *full_file_path.parts[len(base_path.parent.parts):]) fs.add_file(str(filename), path_util.getsize(full_file_path)) if params.get(b'piece length'): piece_size = params[b'piece length'] else: piece_size = 0 flags = libtorrent.create_torrent_flags_t.optimize # This flag doesn't exist anymore in libtorrent V1.1.0 if hasattr(libtorrent.create_torrent_flags_t, 'calculate_file_hashes'): flags |= libtorrent.create_torrent_flags_t.calculate_file_hashes params = { k: (v.decode('utf-8') if isinstance(v, bytes) else v) for k, v in params.items() } torrent = libtorrent.create_torrent(fs, piece_size=piece_size, flags=flags) # Python2 wants binary, python3 want unicode if params.get(b'comment'): torrent.set_comment(params[b'comment']) if params.get(b'created by'): torrent.set_creator(params[b'created by']) # main tracker if params.get(b'announce'): torrent.add_tracker(params[b'announce']) # tracker list if params.get(b'announce-list'): tier = 1 for tracker in params[b'announce-list']: torrent.add_tracker(tracker, tier=tier) tier += 1 # DHT nodes # http://www.bittorrent.org/beps/bep_0005.html if params.get(b'nodes'): for node in params[b'nodes']: torrent.add_node(*node) # HTTP seeding # http://www.bittorrent.org/beps/bep_0017.html if params.get(b'httpseeds'): torrent.add_http_seed(params[b'httpseeds']) # Web seeding # http://www.bittorrent.org/beps/bep_0019.html if len(file_path_list) == 1: if params.get(b'urllist', False): torrent.add_url_seed(params[b'urllist']) # read the files and calculate the hashes if len(file_path_list) == 1: libtorrent.set_piece_hashes(torrent, str(base_path)) else: libtorrent.set_piece_hashes(torrent, str(base_path.parent)) t1 = torrent.generate() torrent = libtorrent.bencode(t1) if torrent_filepath: with open(torrent_filepath, 'wb') as f: f.write(torrent) return { 'success': True, 'base_path': base_path, 'base_dir': base_path.parent, 'torrent_file_path': torrent_filepath, 'metainfo': torrent, 'infohash': sha1(bencode(t1[b'info'])).digest() }
def __init__(self, *args, **kwargs): self.tribler_session = kwargs.pop('tribler_session', None) num_competing_slots = kwargs.pop('competing_slots', 15) num_random_slots = kwargs.pop('random_slots', 5) self.bandwidth_wallet = kwargs.pop('bandwidth_wallet', None) socks_listen_ports = kwargs.pop('socks_listen_ports', None) state_path = self.tribler_session.config.get_state_dir( ) if self.tribler_session else path_util.Path() self.exitnode_cache = kwargs.pop('exitnode_cache', state_path / 'exitnode_cache.dat') super(TriblerTunnelCommunity, self).__init__(*args, **kwargs) self._use_main_thread = True if self.tribler_session: if self.tribler_session.config.get_tunnel_community_exitnode_enabled( ): self.settings.peer_flags.add(PEER_FLAG_EXIT_ANY) self.settings.peer_flags.add(PEER_FLAG_EXIT_HTTP) if not socks_listen_ports: socks_listen_ports = self.tribler_session.config.get_tunnel_community_socks5_listen_ports( ) elif socks_listen_ports is None: socks_listen_ports = range(1080, 1085) self.bittorrent_peers = {} self.dispatcher = TunnelDispatcher(self) self.download_states = {} self.competing_slots = [ (0, None) ] * num_competing_slots # 1st tuple item = token balance, 2nd = circuit id self.random_slots = [None] * num_random_slots self.reject_callback = None # This callback is invoked with a tuple (time, balance) when we reject a circuit self.last_forced_announce = {} # Start the SOCKS5 servers self.socks_servers = [] for port in socks_listen_ports: socks_server = Socks5Server(port, self.dispatcher) self.register_task('start_socks_%d' % port, socks_server.start) self.socks_servers.append(socks_server) self.dispatcher.set_socks_servers(self.socks_servers) self.decode_map.update({ chr(23): self.on_payout_block, }) self.decode_map_private.update({ chr(24): self.on_balance_request_cell, chr(25): self.on_relay_balance_request_cell, chr(26): self.on_balance_response_cell, chr(27): self.on_relay_balance_response_cell, chr(28): self.on_http_request, chr(29): self.on_http_response }) message_to_payload["balance-request"] = (24, BalanceRequestPayload) message_to_payload["relay-balance-request"] = (25, BalanceRequestPayload) message_to_payload["balance-response"] = (26, BalanceResponsePayload) message_to_payload["relay-balance-response"] = (27, BalanceResponsePayload) message_to_payload["http-request"] = (28, HTTPRequestPayload) message_to_payload["http-response"] = (29, HTTPResponsePayload) NO_CRYPTO_PACKETS.extend([24, 26]) if self.exitnode_cache: self.restore_exitnodes_from_disk()