def gen_sample_channel(mds):
my_channel = mds.ChannelMetadata.create_channel('test_channel', 'test description')
_ = my_channel.add_torrent_to_channel(TorrentDef.load(TORRENT_UBUNTU_FILE), None)
my_channel.commit_channel_torrent()
t2 = my_channel.add_torrent_to_channel(TorrentDef.load(TORRENT_VIDEO_FILE), None)
_ = mds.TorrentMetadata.from_dict(gen_random_entry())
_ = mds.TorrentMetadata.from_dict(gen_random_entry())
my_channel.commit_channel_torrent()
my_channel.delete_torrent(t2.infohash)
my_channel.commit_channel_torrent()
# Rename files to stable names
mdblob_name = os.path.join(SAMPLE_DIR, my_channel.dir_name + ".mdblob")
torrent_name = os.path.join(SAMPLE_DIR, my_channel.dir_name + ".torrent")
os.rename(mdblob_name, CHANNEL_METADATA)
os.rename(torrent_name, CHANNEL_TORRENT)
# Update channel
_ = mds.TorrentMetadata.from_dict(gen_random_entry())
my_channel.commit_channel_torrent()
# Rename updated files to stable names
os.rename(mdblob_name, CHANNEL_METADATA_UPDATED)
os.rename(torrent_name, CHANNEL_TORRENT_UPDATED)
def subtest_add_content_dir_and_file(self):
""" Add a single dir and single file to a TorrentDef """
t = TorrentDef()
dn = os.path.join(TESTS_API_DIR, "contentdir")
t.add_content(dn, "dirintorrent")
fn = os.path.join(TESTS_API_DIR, "video.avi")
t.add_content(fn, os.path.join("dirintorrent", "video.avi"))
t.set_tracker(TRACKER)
t.finalize()
# Check
exps = os.path.getsize(fn)
for f in os.listdir(dn):
if f.startswith('.'):
continue
p = os.path.join(dn, f)
exps += os.path.getsize(p)
metainfo = t.get_metainfo()
self.general_check(metainfo)
self.assert_(metainfo['info']['name'] == 'dirintorrent')
reals = 0
for file in metainfo['info']['files']:
reals += file['length']
self.assert_(exps == reals)
def _doFetch(self, filename, infohash, candidates):
if filename:
if infohash in self.requestedInfohashes:
self.requestedInfohashes.remove(infohash)
self.remote_th.notify_possible_torrent_infohash(infohash, True)
self.requests_on_disk += 1
else:
# try magnet link
magnetlink = "magnet:?xt=urn:btih:" + hexlify(infohash)
if self.remote_th.torrent_db:
# see if we know any trackers for this magnet
trackers = self.remote_th.torrent_db.getTracker(infohash)
for tracker, _ in trackers:
magnetlink += "&tr=" + urllib.quote_plus(tracker)
if DEBUG:
print >> sys.stderr, long(time()), 'rtorrent: requesting magnet', bin2str(infohash), self.prio, magnetlink, len(self.requestedInfohashes)
TorrentDef.retrieve_from_magnet(magnetlink, self.__torrentdef_retrieved, self.MAGNET_RETRIEVE_TIMEOUT, max_connections=30 if self.prio == 0 else 10)
failed_lambda = lambda infohash = infohash: self.__torrentdef_failed(infohash)
self.scheduletask(failed_lambda, t=self.MAGNET_RETRIEVE_TIMEOUT)
return True
def resume_download(self, filename, setupDelay=0):
tdef = dscfg = pstate = None
try:
pstate = self.load_download_pstate(filename)
# SWIFTPROC
metainfo = pstate.get('state', 'metainfo')
if 'infohash' in metainfo:
tdef = TorrentDefNoMetainfo(metainfo['infohash'], metainfo['name'], metainfo.get('url', None))
else:
tdef = TorrentDef.load_from_dict(metainfo)
if pstate.has_option('download_defaults', 'saveas') and \
isinstance(pstate.get('download_defaults', 'saveas'), tuple):
pstate.set('download_defaults', 'saveas', pstate.get('download_defaults', 'saveas')[-1])
dscfg = DownloadStartupConfig(pstate)
except:
# pstate is invalid or non-existing
_, file = os.path.split(filename)
infohash = binascii.unhexlify(file[:-6])
torrent_data = self.torrent_store.get(infohash)
if torrent_data:
try:
tdef = TorrentDef.load_from_memory(torrent_data)
defaultDLConfig = DefaultDownloadStartupConfig.getInstance()
dscfg = defaultDLConfig.copy()
if self.mypref_db is not None:
dest_dir = self.mypref_db.getMyPrefStatsInfohash(infohash)
if dest_dir and os.path.isdir(dest_dir):
dscfg.set_dest_dir(dest_dir)
except ValueError:
self._logger.warning("tlm: torrent data invalid")
if pstate is not None:
has_resume_data = pstate.get('state', 'engineresumedata') is not None
self._logger.debug("tlm: load_checkpoint: resumedata %s",
'len %s ' % len(pstate.get('state', 'engineresumedata')) if has_resume_data else 'None')
if tdef and dscfg:
if dscfg.get_dest_dir() != '': # removed torrent ignoring
try:
if self.download_exists(tdef.get_infohash()):
self._logger.info("tlm: not resuming checkpoint because download has already been added")
elif dscfg.get_credit_mining() and not self.session.config.get_credit_mining_enabled():
self._logger.info("tlm: not resuming checkpoint since token mining is disabled")
else:
self.add(tdef, dscfg, pstate, setupDelay=setupDelay)
except Exception as e:
self._logger.exception("tlm: load check_point: exception while adding download %s", tdef)
else:
self._logger.info("tlm: removing checkpoint %s destdir is %s", filename, dscfg.get_dest_dir())
os.remove(filename)
else:
self._logger.info("tlm: could not resume checkpoint %s %s %s", filename, tdef, dscfg)
def test_is_private(self):
privatefn = os.path.join(TESTS_DATA_DIR, "private.torrent")
publicfn = os.path.join(TESTS_DATA_DIR, "bak_single.torrent")
t1 = TorrentDef.load(privatefn)
t2 = TorrentDef.load(publicfn)
self.assert_(t1.is_private() == True)
self.assert_(t2.is_private() == False)
def test_get_name_utf8(self):
""" Add a TorrentDef with non-utf8 encoding"""
t = TorrentDef()
t.set_name('\xA1\xC0')
t.set_encoding('euc_kr')
t.set_tracker(TRACKER)
t.finalize()
self.assertEqual(t.get_name_utf8(), u'\xf7')
def setupSeeder(self):
from Tribler.Core.Session import Session
from Tribler.Core.TorrentDef import TorrentDef
from Tribler.Core.DownloadConfig import DownloadStartupConfig
self.setUpPreSession()
self.config.set_libtorrent(True)
self.config2 = self.config.copy()
self.session2 = Session(self.config2, ignore_singleton=True)
upgrader = self.session2.prestart()
while not upgrader.is_done:
time.sleep(0.1)
assert not upgrader.failed, upgrader.current_status
self.session2.start()
tdef = TorrentDef()
tdef.add_content(os.path.join(TESTS_DATA_DIR, "video.avi"))
tdef.set_tracker("http://fake.net/announce")
tdef.finalize()
torrentfn = os.path.join(self.session.get_state_dir(), "gen.torrent")
tdef.save(torrentfn)
dscfg = DownloadStartupConfig()
dscfg.set_dest_dir(TESTS_DATA_DIR) # basedir of the file we are seeding
d = self.session2.start_download(tdef, dscfg)
d.set_state_callback(self.seeder_state_callback)
return torrentfn
def setup_tunnel_seeder(self, hops):
"""
Setup the seeder.
"""
from Tribler.Core.Session import Session
self.seed_config = self.config.copy()
self.seed_config.set_state_dir(self.getStateDir(2))
self.seed_config.set_megacache_enabled(True)
self.seed_config.set_tunnel_community_socks5_listen_ports(self.get_socks5_ports())
if self.session2 is None:
self.session2 = Session(self.seed_config)
self.session2.start()
tdef = TorrentDef()
tdef.add_content(os.path.join(TESTS_DATA_DIR, "video.avi"))
tdef.set_tracker("http://localhost/announce")
tdef.finalize()
torrentfn = os.path.join(self.session2.config.get_state_dir(), "gen.torrent")
tdef.save(torrentfn)
self.seed_tdef = tdef
if hops > 0: # Safe seeding enabled
self.tunnel_community_seeder = self.load_tunnel_community_in_session(self.session2)
self.tunnel_community_seeder.build_tunnels(hops)
else:
self.sanitize_network(self.session2)
dscfg = DownloadStartupConfig()
dscfg.set_dest_dir(TESTS_DATA_DIR) # basedir of the file we are seeding
dscfg.set_hops(hops)
d = self.session2.start_download_from_tdef(tdef, dscfg)
d.set_state_callback(self.seeder_state_callback)
def subtest_add_content_piece_length(self):
""" Add a single file with piece length to a TorrentDef """
t = TorrentDef()
fn = os.path.join(TESTS_API_DIR, "video.avi")
t.add_content(fn)
t.set_piece_length(2 ** 16)
t.set_tracker(TRACKER)
t.finalize()
metainfo = t.get_metainfo()
self.general_check(metainfo)
self.assert_(metainfo['info']['piece length'] == 2 ** 16)
def test_add_content_piece_length(self):
""" Add a single file with piece length to a TorrentDef """
t = TorrentDef()
fn = os.path.join(TESTS_DATA_DIR, self.VIDEO_FILE_NAME)
t.add_content(fn)
t.set_piece_length(2 ** 16)
t.set_tracker(TRACKER)
t.finalize()
metainfo = t.get_metainfo()
self.general_check(metainfo)
self.assertEqual(metainfo['info']['piece length'], 2 ** 16)
def start_download(self, torrentfilename=None, infohash=None, tdef=None, dconfig=None):
self._logger.debug(u"starting download: filename: %s, torrent def: %s", torrentfilename, tdef)
if infohash is not None:
assert isinstance(infohash, str), "infohash type: %s" % type(infohash)
assert len(infohash) == 20, "infohash length is not 20: %s, %s" % (len(infohash), infohash)
# the priority of the parameters is: (1) tdef, (2) infohash, (3) torrent_file.
# so if we have tdef, infohash and torrent_file will be ignored, and so on.
if tdef is None:
if infohash is not None:
# try to get the torrent from torrent_store if the infohash is provided
torrent_data = self.tribler_session.get_collected_torrent(infohash)
if torrent_data is not None:
# use this torrent data for downloading
tdef = TorrentDef.load_from_memory(torrent_data)
if tdef is None:
assert torrentfilename is not None, "torrent file must be provided if tdef and infohash are not given"
# try to get the torrent from the given torrent file
torrent_data = fix_torrent(torrentfilename)
if torrent_data is None:
raise TorrentFileException("error while decoding torrent file")
tdef = TorrentDef.load_from_memory(torrent_data)
assert tdef is not None, "tdef MUST not be None after loading torrent"
default_dl_config = DefaultDownloadStartupConfig.getInstance()
dscfg = default_dl_config.copy()
if dconfig is not None:
dscfg = dconfig
d = self.tribler_session.get_download(tdef.get_infohash())
if d:
# If there is an existing credit mining download with the same infohash
# then move to the user download directory and checkpoint the download immediately.
if d.get_credit_mining():
self.tribler_session.lm.credit_mining_manager.torrents.pop(hexlify(tdef.get_infohash()), None)
d.set_credit_mining(False)
d.move_storage(dscfg.get_dest_dir())
d.checkpoint()
new_trackers = list(set(tdef.get_trackers_as_single_tuple()) - set(
d.get_def().get_trackers_as_single_tuple()))
if new_trackers:
self.tribler_session.update_trackers(tdef.get_infohash(), new_trackers)
self._logger.info('start_download: Starting in VOD mode')
result = self.tribler_session.start_download_from_tdef(tdef, dscfg)
return result
def createTorrent(self):
tdef = TorrentDef()
tdef.add_content(os.path.join(TESTS_DATA_DIR, "video.avi"))
tdef.set_tracker("http://fake.net/announce")
tdef.finalize()
torrentfn = os.path.join(self.session.get_state_dir(), "gen.torrent")
tdef.save(torrentfn)
return torrentfn
def subtest_add_content_httpseeds(self):
""" Add a single file with BitTornado httpseeds to a TorrentDef """
t = TorrentDef()
fn = os.path.join(TESTS_API_DIR, "video.avi")
t.add_content(fn)
t.set_tracker(TRACKER)
expseeds = ['http://www.cs.vu.nl/index.html', 'http://www.st.ewi.tudelft.nl/index.html']
t.set_httpseeds(expseeds)
t.finalize()
metainfo = t.get_metainfo()
self.general_check(metainfo)
realseeds = metainfo['httpseeds']
self.assert_(realseeds == expseeds)
def test_add_content_dir(self):
""" Add a single dir to a TorrentDef """
t = TorrentDef()
dn = os.path.join(TESTS_DATA_DIR, "contentdir")
t.add_content(dn, "dirintorrent")
t.set_tracker(TRACKER)
t.finalize()
exps = 0
for f in os.listdir(dn):
if f.startswith('.'):
continue
p = os.path.join(dn, f)
s = os.path.getsize(p)
exps += s
self._logger.debug("Expected size %s %d", f, s)
self._logger.debug("Expected total size of files in torrent %d", exps)
metainfo = t.get_metainfo()
self.general_check(metainfo)
self.assertEqual(metainfo['info']['name'], 'dirintorrent')
reals = 0
for file in metainfo['info']['files']:
s = file['length']
self._logger.debug("real size %s %d", file['path'], s)
reals += s
self._logger.debug("Real size of files in torrent %d", reals)
self.assertEqual(exps, reals)
def subtest_add_content_dir(self):
""" Add a single dir to a TorrentDef """
t = TorrentDef()
dn = os.path.join(TESTS_API_DIR, "contentdir")
t.add_content(dn, "dirintorrent")
t.set_tracker(TRACKER)
t.finalize()
exps = 0
for f in os.listdir(dn):
if f.startswith('.'):
continue
p = os.path.join(dn, f)
s = os.path.getsize(p)
exps += s
print "test: expected size", f, s
print "test: expected total size of files in torrent", exps
metainfo = t.get_metainfo()
self.general_check(metainfo)
self.assert_(metainfo['info']['name'] == 'dirintorrent')
reals = 0
for file in metainfo['info']['files']:
s = file['length']
print "test: real size", file['path'], s
reals += s
print "test: real size of files in torrent", reals
self.assert_(exps == reals)
def test_consolidate_channel_torrent(self):
"""
Test completely re-commit your channel
"""
channel = self.mds.ChannelMetadata.create_channel('test', 'test')
my_dir = os.path.abspath(os.path.join(self.mds.channels_dir, channel.dir_name))
tdef = TorrentDef.load(TORRENT_UBUNTU_FILE)
# 1st torrent
channel.add_torrent_to_channel(tdef, None)
channel.commit_channel_torrent()
# 2nd torrent
md = self.mds.TorrentMetadata.from_dict(
dict(self.torrent_template, public_key=channel.public_key, status=NEW))
channel.commit_channel_torrent()
# Delete entry
channel.delete_torrent(tdef.get_infohash())
channel.commit_channel_torrent()
self.assertEqual(1, len(channel.contents_list))
self.assertEqual(3, len(os.listdir(my_dir)))
channel.consolidate_channel_torrent()
self.assertEqual(1, len(os.listdir(my_dir)))
def test_create_torrent(self):
"""
Testing whether the API returns a proper base64 encoded torrent
"""
torrent_path = os.path.join(self.files_path, "video.avi.torrent")
expected_tdef = TorrentDef.load(torrent_path)
def verify_torrent(body):
response = json.loads(body)
torrent = base64.b64decode(response["torrent"])
tdef = TorrentDef.load_from_memory(torrent)
# Copy expected creation date and created by (Tribler version) from actual result
creation_date = tdef.get_creation_date()
expected_tdef.metainfo["creation date"] = creation_date
expected_tdef.metainfo["created by"] = tdef.metainfo['created by']
self.assertEqual(dir(expected_tdef), dir(tdef))
post_data = {
"files": [os.path.join(self.files_path, "video.avi"),
os.path.join(self.files_path, "video.avi.torrent")],
"description": "Video of my cat",
"trackers": "http://localhost/announce"
}
self.should_check_equality = False
return self.do_request('createtorrent?download=1', 200, None, 'POST', post_data).addCallback(verify_torrent)
def add_torrents_from_dir(self, torrents_dir, recursive=False):
# TODO: Optimize this properly!!!!
torrents_list = []
errors_list = []
if recursive:
def rec_gen():
for root, _, filenames in os.walk(torrents_dir):
for fn in filenames:
yield os.path.join(root, fn)
filename_generator = rec_gen()
else:
filename_generator = os.listdir(torrents_dir)
# Build list of .torrents to process
for f in filename_generator:
filepath = os.path.join(torrents_dir, f)
filename = str(filepath) if sys.platform == 'win32' else filepath.decode('utf-8')
if os.path.isfile(filepath) and filename.endswith(u'.torrent'):
torrents_list.append(filepath)
for chunk in chunks(torrents_list, 100): # 100 is a reasonable chunk size for commits
for f in chunk:
try:
self.add_torrent_to_channel(TorrentDef.load(f))
except DuplicateTorrentFileError:
pass
except:
errors_list.append(f)
orm.commit() # Kinda optimization to drop excess cache?
return torrents_list, errors_list
def check_watch_folder(self):
if not os.path.isdir(self.session.config.get_watch_folder_path()):
return
for root, _, files in os.walk(self.session.config.get_watch_folder_path()):
for name in files:
if not name.endswith(u".torrent"):
continue
try:
tdef = TorrentDef.load_from_memory(fix_torrent(os.path.join(root, name)))
except: # torrent appears to be corrupt
self.cleanup_torrent_file(root, name)
continue
infohash = tdef.get_infohash()
if not self.session.has_download(infohash):
self._logger.info("Starting download from torrent file %s", name)
dl_config = DefaultDownloadStartupConfig.getInstance().copy()
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.lm.ltmgr.start_download(tdef=tdef, dconfig=dl_config)
def _on_download_successful(self, address, file_name, file_data, extra_info):
self._logger.debug(u"successfully downloaded %s from %s:%s", file_name, address[0], address[1])
key = extra_info[u"key"]
info_hash = extra_info.get(u"info_hash")
thumb_hash = extra_info.get(u"thumb_hash")
assert key in self._active_request_list, u"key = %s, active_request_list = %s" % (
repr(key),
self._active_request_list,
)
self._requests_succeeded += 1
self._total_bandwidth += len(file_data)
# save data
try:
if info_hash is not None:
# save torrent
tdef = TorrentDef.load_from_memory(file_data)
self._remote_torrent_handler.save_torrent(tdef)
elif thumb_hash is not None:
# save metadata
self._remote_torrent_handler.save_metadata(thumb_hash, file_data)
finally:
# start the next request
self._clear_active_request(key)
self._start_pending_requests()
def addTorrentToDB(self, filename, torrent_hash, metadata, source='BC', extra_info={}, hack=False):
""" Arno: no need to delegate to olbridge, this is already run by OverlayThread """
# 03/02/10 Boudewijn: addExternalTorrent now requires a
# torrentdef, consequently we provide the filename through the
# extra_info dictionary
torrentdef = TorrentDef.load(filename)
if not 'filename' in extra_info:
extra_info['filename'] = filename
torrent = self.torrent_db.addExternalTorrent(torrentdef, source, extra_info)
if torrent is None:
return
# Arno, 2008-10-20: XXX torrents are filtered out in the final display stage
self.launchmany.set_activity(NTFY_ACT_GOT_METADATA,unicode('"'+torrent['name']+'"'),torrent['category'])
if self.initialized:
self.num_torrents += 1 # for free disk limitation
if not extra_info:
self.refreshTrackerStatus(torrent)
if len(self.recently_collected_torrents) < 50: # Queue of 50
self.recently_collected_torrents.append(torrent_hash)
else:
self.recently_collected_torrents.pop(0)
self.recently_collected_torrents.append(torrent_hash)
def subtest_add_content_announce_list(self):
""" Add a single file with announce-list to a TorrentDef """
t = TorrentDef()
fn = os.path.join(TESTS_API_DIR, "video.avi")
t.add_content(fn)
t.set_tracker(TRACKER)
exphier = [[TRACKER], ['http://tracker1.tribler.org:6969/announce', 'http://tracker2.tribler.org:7070/ann'],
['http://www.cs.vu.nl', 'http://www.st.ewi.tudelft.nl', 'http://www.vuze.com']]
t.set_tracker_hierarchy(exphier)
t.finalize()
metainfo = t.get_metainfo()
self.general_check(metainfo)
realhier = metainfo['announce-list']
self.assert_(realhier == exphier)
def _create_and_save_torrent(self, session, filename, createTdef=True):
if createTdef:
tdef = TorrentDef()
sourcefn = os.path.join(BASE_DIR, "API", filename)
tdef.add_content(sourcefn)
tdef.set_tracker("http://fake.net/announce")
tdef.finalize()
torrentfn = os.path.join(session.get_state_dir(), "gen.torrent")
tdef.save(torrentfn)
else:
tdef = None
torrentfn = os.path.join(BASE_DIR, "API", filename)
sdef, swiftpath = session.lm.rtorrent_handler._write_to_collected(torrentfn)
return tdef.get_id() if tdef else None, sdef.get_id()
def _rename_torrent_files(self):
"""
Renames all the torrent files to INFOHASH.torrent and delete unparseable ones.
"""
def update_status():
progress = 1.0
if self.total_torrent_file_count > 0:
progress = float(self.total_torrent_files_processed) / self.total_torrent_file_count
progress *= 100
self.status_update_func(u"Migrating torrent files %.2f%%..." % progress)
for root, _, files in os.walk(self.torrent_collecting_dir):
for name in files:
file_path = os.path.join(root, name)
try:
tdef = TorrentDef.load(file_path)
move(file_path, os.path.join(self.tmp_migration_dir, hexlify(tdef.infohash) + u".torrent"))
self.torrent_files_migrated += 1
except Exception as e:
self._logger.error(u"dropping corrupted torrent file %s: %s", file_path, str(e))
os.unlink(file_path)
self.torrent_files_dropped += 1
self.total_torrent_files_processed += 1
update_status()
# We don't want to walk through the child directories
break
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
# Let Tribler start downloading an non-functioning torrent, so
# we can talk to a normal download engine.
self.torrentfn = os.path.join('extend_hs_dir','dummydata.merkle.torrent')
tdef = TorrentDef.load(self.torrentfn)
dscfg = DownloadStartupConfig()
dscfg.set_dest_dir(self.config_path)
self.session.start_download(tdef,dscfg)
# This is the infohash of the torrent in test/extend_hs_dir
self.infohash = '\xccg\x07\xe2\x9e!]\x16\xae{\xb8\x10?\xf9\xa5\xf9\x07\xfdBk'
self.setUpMyListenSocket()
# Must be changed in test/extend_hs_dir/dummydata.merkle.torrent as well
self.mytrackerport = 4901
# Must be Tribler version <= 3.5.0. Changing this to 351 makes this test
# fail, so it's a good test.
self.myid = 'R350-----HgUyPu56789'
self.mytracker = MyTracker(self.mytrackerport,self.myid,'127.0.0.1',self.mylistenport)
self.mytracker.background_serve()
print >>sys.stderr,"test: Giving MyTracker and myself time to start"
time.sleep(5)
def test_commit_channel_torrent(self):
channel = self.mds.ChannelMetadata.create_channel('test', 'test')
tdef = TorrentDef.load(TORRENT_UBUNTU_FILE)
channel.add_torrent_to_channel(tdef, None)
# The first run should return the infohash, the second should return None, because nothing was really done
self.assertTrue(channel.commit_channel_torrent())
self.assertFalse(channel.commit_channel_torrent())
def test_restore_torrent_in_channel(self):
"""
Test if the torrent scheduled for deletion is restored/updated after the user tries to re-add it.
"""
channel_metadata = self.mds.ChannelMetadata.create_channel('test', 'test')
tdef = TorrentDef.load(TORRENT_UBUNTU_FILE)
md = channel_metadata.add_torrent_to_channel(tdef, None)
# Check correct re-add
md.status = TODELETE
md_updated = channel_metadata.add_torrent_to_channel(tdef, None)
self.assertEqual(md.status, COMMITTED)
self.assertEqual(md_updated, md)
self.assertTrue(md.has_valid_signature)
# Check update of torrent properties from a new tdef
md.status = TODELETE
new_tracker_address = u'http://tribler.org/announce'
tdef.torrent_parameters['announce'] = new_tracker_address
md_updated = channel_metadata.add_torrent_to_channel(tdef, None)
self.assertEqual(md_updated, md)
self.assertEqual(md.status, NEW)
self.assertEqual(md.tracker_info, new_tracker_address)
self.assertTrue(md.has_valid_signature)
# In addition, check that the trackers table was properly updated
self.assertEqual(len(md.health.trackers), 2)
def test_channel_update_and_download(self):
"""
Test whether we can successfully update a channel and download the new version
"""
# First we have to manually add the old version
old_payload = ChannelMetadataPayload.from_file(CHANNEL_METADATA)
with db_session:
old_channel = self.session.lm.mds.ChannelMetadata.from_payload(old_payload)
chan_dir = os.path.join(CHANNEL_DIR, old_channel.dir_name)
self.session.lm.mds.process_channel_dir(chan_dir, old_payload.public_key)
channel_tdef = TorrentDef.load(CHANNEL_TORRENT_UPDATED)
libtorrent_port = get_random_port()
yield self.setup_seeder(channel_tdef, CHANNEL_DIR, libtorrent_port)
payload = ChannelMetadataPayload.from_file(CHANNEL_METADATA_UPDATED)
# Download the channel in our session
download, finished_deferred = self.session.lm.update_channel(payload)
download.add_peer(("127.0.0.1", self.seeder_session.config.get_libtorrent_port()))
yield finished_deferred
with db_session:
# There should be 4 torrents + 1 channel torrent
channel = self.session.lm.mds.ChannelMetadata.get_channel_with_id(payload.public_key)
self.assertEqual(5, len(list(self.session.lm.mds.TorrentMetadata.select())))
self.assertEqual(4, channel.local_version)
def on_metadata_received_alert(self, alert):
torrent_info = get_info_from_handle(self.handle)
if not torrent_info:
return
metadata = {'info': lt.bdecode(torrent_info.metadata())}
trackers = [tracker['url'] for tracker in self.handle.trackers()]
if trackers:
if len(trackers) > 1:
metadata["announce-list"] = [trackers]
else:
metadata["announce"] = trackers[0]
try:
self.tdef = TorrentDef.load_from_dict(metadata)
except ValueError as ve:
self._logger.exception(ve)
return
try:
torrent_files = lt.torrent_info(metadata).files()
except RuntimeError:
self._logger.warning("Torrent contains no files!")
torrent_files = []
self.orig_files = [torrent_file.path.decode('utf-8') for torrent_file in torrent_files]
self.set_corrected_infoname()
self.set_filepieceranges()
self.set_selected_files()
self.checkpoint()
def _on_download_successful(self, address, file_name, file_data, extra_info):
self._logger.debug(u"successfully downloaded %s from %s:%s", file_name, address[0], address[1])
key = extra_info[u'key']
info_hash = extra_info.get(u"info_hash")
thumb_hash = extra_info.get(u"thumb_hash")
assert key in self._active_request_list, u"key = %s, active_request_list = %s" % (repr(key),
self._active_request_list)
self._requests_succeeded += 1
self._total_bandwidth += len(file_data)
# save data
try:
if info_hash is not None:
# save torrent
tdef = TorrentDef.load_from_memory(file_data)
self._remote_torrent_handler.save_torrent(tdef)
elif thumb_hash is not None:
# save metadata
self._remote_torrent_handler.save_metadata(thumb_hash, file_data)
except ValueError:
self._logger.warning("Remote peer sent us invalid (torrent) content over TFTP socket, ignoring it.")
finally:
# start the next request
self._clear_active_request(key)
self._start_pending_requests()
def test_set_dht_nodes_node_no_list(self):
t = TorrentDef()
t.set_dht_nodes([("127.0.0.1", 1234)])
def test_add_content_dir_and_file(self):
""" Add a single dir and single file to a TorrentDef """
t = TorrentDef()
dn = os.path.join(TESTS_DATA_DIR, "contentdir")
t.add_content(dn, "dirintorrent")
fn = os.path.join(TESTS_DATA_DIR, self.VIDEO_FILE_NAME)
t.add_content(fn, os.path.join("dirintorrent", self.VIDEO_FILE_NAME))
t.set_tracker(TRACKER)
t.finalize()
# Check
exps = os.path.getsize(fn)
for f in os.listdir(dn):
if f.startswith('.'):
continue
p = os.path.join(dn, f)
exps += os.path.getsize(p)
metainfo = t.get_metainfo()
self.general_check(metainfo)
self.assertEqual(metainfo['info']['name'], 'dirintorrent')
reals = 0
for file in metainfo['info']['files']:
reals += file['length']
self.assertEqual(exps, reals)
def startDownload(self,
torrentfilename=None,
destdir=None,
infohash=None,
tdef=None,
cmdline=False,
vodmode=False,
hops=0,
selectedFiles=None,
hidden=False):
self._logger.debug(u"startDownload: %s %s %s %s %s", torrentfilename,
destdir, tdef, vodmode, selectedFiles)
# TODO(lipu): remove the assertions after it becomes stable
if infohash is not None:
assert isinstance(infohash,
str), "infohash type: %s" % type(infohash)
assert len(infohash) == 20, "infohash length is not 20: %s, %s" % (
len(infohash), infohash)
# the priority of the parameters is: (1) tdef, (2) infohash, (3) torrent_file.
# so if we have tdef, infohash and torrent_file will be ignored, and so on.
if tdef is None:
if infohash is not None:
# try to get the torrent from torrent_store if the infohash is provided
torrent_data = self.utility.session.get_collected_torrent(
infohash)
if torrent_data is not None:
# use this torrent data for downloading
tdef = TorrentDef.load_from_memory(torrent_data)
if tdef is None:
assert torrentfilename is not None, "torrent file must be provided if tdef and infohash are not given"
# try to get the torrent from the given torrent file
torrent_data = fix_torrent(torrentfilename)
if torrent_data is None:
# show error message: could not open torrent file
dlg = wx.MessageBox(
self,
"Could not open torrent file %s" % torrentfilename,
"Error", wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return
tdef = TorrentDef.load_from_memory(torrent_data)
assert tdef is not None, "tdef MUST not be None after loading torrent"
try:
d = self.utility.session.get_download(tdef.get_infohash())
if d:
new_trackers = list(
set(tdef.get_trackers_as_single_tuple()) -
set(d.get_def().get_trackers_as_single_tuple()))
if not new_trackers:
raise DuplicateDownloadException()
else:
@forceWxThread
def do_gui():
# Show update tracker dialog
dialog = wx.MessageDialog(
None,
'This torrent is already being downloaded. Do you wish to load the trackers from it?',
'Tribler',
wx.YES_NO | wx.NO_DEFAULT | wx.ICON_QUESTION)
if dialog.ShowModal() == wx.ID_YES:
# Update trackers
self.utility.session.update_trackers(
tdef.get_infohash(), new_trackers)
dialog.Destroy()
do_gui()
return
defaultDLConfig = DefaultDownloadStartupConfig.getInstance()
dscfg = defaultDLConfig.copy()
cancelDownload = False
useDefault = not self.utility.read_config('showsaveas')
safe_seeding = self.utility.read_config(
'default_safeseeding_enabled')
if not useDefault and not destdir:
defaultname = tdef.get_name_as_unicode(
) if tdef.is_multifile_torrent() else None
if wx.Thread_IsMain():
dlg = SaveAs(None, tdef, dscfg.get_dest_dir(), defaultname,
selectedFiles)
dlg.CenterOnParent()
if isinstance(tdef, TorrentDefNoMetainfo):
# Correct for the smaller size of the dialog if there is no metainfo
center_pos = dlg.GetPosition()
center_pos[1] -= 150
dlg.SetPosition(center_pos)
if dlg.ShowModal() == wx.ID_OK:
# If the dialog has collected a torrent, use the new tdef
tdef = dlg.GetCollected() or tdef
if tdef and tdef.is_multifile_torrent():
selectedFiles = dlg.GetSelectedFiles()
destdir = dlg.GetPath()
# Anonymity over exit nodes or hidden services
safe_seeding = dlg.UseSafeSeeding()
if dlg.UseTunnels():
hops = self.utility.read_config(
'default_number_hops')
else:
cancelDownload = True
dlg.Destroy()
else:
raise Exception("cannot create dialog, not on wx thread")
# use default setup
else:
if useDefault:
if self.utility.read_config('default_anonymity_enabled'):
# only load default anonymous level if we use default settings
hops = self.utility.read_config('default_number_hops')
else:
hops = 0
if hops > 0:
if not tdef:
raise Exception(
'Currently only torrents can be downloaded in anonymous mode'
)
dscfg.set_hops(hops)
dscfg.set_safe_seeding(safe_seeding)
if not cancelDownload:
if destdir is not None:
dscfg.set_dest_dir(destdir)
if selectedFiles and len(selectedFiles) == 1:
# we should filter files to see if they are all playable
videofiles = selectedFiles
elif tdef and not selectedFiles:
videofiles = tdef.get_files(exts=videoextdefaults)
else:
videofiles = []
# disable vodmode if no videofiles, unless we still need to collect the torrent
if vodmode and len(videofiles) == 0 and (
not tdef
or not isinstance(tdef, TorrentDefNoMetainfo)):
vodmode = False
if vodmode:
self._logger.info(
'MainFrame: startDownload: Starting in VOD mode')
result = self.utility.session.start_download_from_tdef(
tdef, dscfg)
self.guiUtility.library_manager.playTorrent(
tdef.get_infohash(),
videofiles[0] if len(videofiles) == 1 else None)
else:
if selectedFiles:
dscfg.set_selected_files(selectedFiles)
self._logger.debug(
'MainFrame: startDownload: Starting in DL mode')
result = self.utility.session.start_download_from_tdef(
tdef, dscfg, hidden=hidden)
if result and not hidden:
self.show_saved(tdef)
return result
except DuplicateDownloadException as e:
# If there is something on the cmdline, all other torrents start
# in STOPPED state. Restart
if cmdline:
dlist = self.utility.session.get_downloads()
for d in dlist:
if d.get_def().get_infohash() == tdef.get_infohash():
d.restart()
break
if wx.Thread_IsMain():
# show nice warning dialog
dlg = wx.MessageDialog(
None,
"You are already downloading this torrent, see the Downloads section.",
"Duplicate download", wx.OK | wx.ICON_ERROR)
result = dlg.ShowModal()
dlg.Destroy()
else:
print_exc()
self.onWarning(e)
except Exception as e:
print_exc()
self.onWarning(e)
return None
def _on_url_fetched(data):
return TorrentDef.load_from_memory(data)
def addTorrent(self):
old_size = self.tdb.size()
old_tracker_size = self.tdb._db.size('TrackerInfo')
s_infohash = unhexlify('44865489ac16e2f34ea0cd3043cfd970cc24ec09')
m_infohash = unhexlify('ed81da94d21ad1b305133f2726cdaec5a57fed98')
single_torrent_file_path = os.path.join(self.getStateDir(),
'single.torrent')
multiple_torrent_file_path = os.path.join(self.getStateDir(),
'multiple.torrent')
copyfile(S_TORRENT_PATH_BACKUP, single_torrent_file_path)
copyfile(M_TORRENT_PATH_BACKUP, multiple_torrent_file_path)
single_tdef = TorrentDef.load(single_torrent_file_path)
self.assertEqual(s_infohash, single_tdef.get_infohash())
multiple_tdef = TorrentDef.load(multiple_torrent_file_path)
self.assertEqual(m_infohash, multiple_tdef.get_infohash())
self.tdb.addExternalTorrent(single_tdef)
self.tdb.addExternalTorrent(multiple_tdef)
single_torrent_id = self.tdb.getTorrentID(s_infohash)
multiple_torrent_id = self.tdb.getTorrentID(m_infohash)
self.assertEqual(self.tdb.getInfohash(single_torrent_id), s_infohash)
single_name = 'Tribler_4.1.7_src.zip'
multiple_name = 'Tribler_4.1.7_src'
self.assertEqual(self.tdb.size(), old_size + 2)
new_tracker_table_size = self.tdb._db.size('TrackerInfo')
self.assertLess(old_tracker_size, new_tracker_table_size)
sname = self.tdb.getOne('name', torrent_id=single_torrent_id)
self.assertEqual(sname, single_name)
mname = self.tdb.getOne('name', torrent_id=multiple_torrent_id)
self.assertEqual(mname, multiple_name)
s_size = self.tdb.getOne('length', torrent_id=single_torrent_id)
self.assertEqual(s_size, 1583233)
m_size = self.tdb.getOne('length', torrent_id=multiple_torrent_id)
self.assertEqual(m_size, 5358560)
cat = self.tdb.getOne('category', torrent_id=multiple_torrent_id)
self.assertEqual(cat, u'xxx')
s_status = self.tdb.getOne('status', torrent_id=single_torrent_id)
self.assertEqual(s_status, u'unknown')
m_comment = self.tdb.getOne('comment', torrent_id=multiple_torrent_id)
comments = 'www.tribler.org'
self.assertGreater(m_comment.find(comments), -1)
comments = 'something not inside'
self.assertEqual(m_comment.find(comments), -1)
m_trackers = self.tdb.getTrackerListByInfohash(m_infohash)
self.assertEqual(len(m_trackers), 8)
self.assertIn('http://tpb.tracker.thepiratebay.org/announce',
m_trackers)
s_torrent = self.tdb.getTorrent(s_infohash)
m_torrent = self.tdb.getTorrent(m_infohash)
self.assertEqual(s_torrent['name'], 'Tribler_4.1.7_src.zip')
self.assertEqual(m_torrent['name'], 'Tribler_4.1.7_src')
self.assertEqual(m_torrent['last_tracker_check'], 0)
def render_GET(self, request):
"""
.. http:get:: /torrentinfo
A GET request to this endpoint will return information from a torrent found at a provided URI.
This URI can either represent a file location, a magnet link or a HTTP(S) url.
- torrent: the URI of the torrent file that should be downloaded. This parameter is required.
**Example request**:
.. sourcecode:: none
curl -X PUT http://localhost:8085/torrentinfo?torrent=file:/home/me/test.torrent
**Example response**:
.. sourcecode:: javascript
{"metainfo": <torrent metainfo dictionary>}
"""
metainfo_deferred = Deferred()
def on_got_metainfo(metainfo):
if not isinstance(metainfo, dict) or 'info' not in metainfo:
self._logger.warning("Received metainfo is not a valid dictionary")
request.setResponseCode(http.INTERNAL_SERVER_ERROR)
request.write(json.dumps({"error": 'invalid response'}))
self.finish_request(request)
return
infohash = hashlib.sha1(bencode(metainfo['info'])).digest()
# Save the torrent to our store
try:
self.session.save_collected_torrent(infohash, bencode(metainfo))
except TypeError:
# Note: in libtorrent 1.1.1, bencode throws a TypeError which is a known bug
pass
request.write(json.dumps({"metainfo": metainfo}, ensure_ascii=False))
self.finish_request(request)
def on_metainfo_timeout(_):
if not request.finished:
request.setResponseCode(http.REQUEST_TIMEOUT)
request.write(json.dumps({"error": "timeout"}))
# If the above request.write failed, the request will have already been finished
if not request.finished:
self.finish_request(request)
def on_lookup_error(failure):
failure.trap(ConnectError, DNSLookupError, HttpError)
request.setResponseCode(http.INTERNAL_SERVER_ERROR)
request.write(json.dumps({"error": failure.getErrorMessage()}))
self.finish_request(request)
if 'uri' not in request.args or len(request.args['uri']) == 0:
request.setResponseCode(http.BAD_REQUEST)
return json.dumps({"error": "uri parameter missing"})
uri = unicode(request.args['uri'][0], 'utf-8')
if uri.startswith('file:'):
try:
filename = url2pathname(uri[5:])
metainfo_deferred.callback(bdecode(fix_torrent(filename)))
except TypeError:
request.setResponseCode(http.INTERNAL_SERVER_ERROR)
return json.dumps({"error": "error while decoding torrent file"})
elif uri.startswith('http'):
def _on_loaded(metadata):
metainfo_deferred.callback(bdecode(metadata))
http_get(uri.encode('utf-8')).addCallback(_on_loaded).addErrback(on_lookup_error)
elif uri.startswith('magnet'):
infohash = parse_magnetlink(uri)[1]
if infohash is None:
request.setResponseCode(http.BAD_REQUEST)
return json.dumps({"error": "missing infohash"})
if self.session.has_collected_torrent(infohash):
try:
tdef = TorrentDef.load_from_memory(self.session.get_collected_torrent(infohash))
except ValueError as exc:
request.setResponseCode(http.INTERNAL_SERVER_ERROR)
return json.dumps({"error": "invalid torrent file: %s" % str(exc)})
on_got_metainfo(tdef.get_metainfo())
return NOT_DONE_YET
self.session.lm.ltmgr.get_metainfo(uri, callback=metainfo_deferred.callback, timeout=20,
timeout_callback=on_metainfo_timeout, notify=True)
else:
request.setResponseCode(http.BAD_REQUEST)
return json.dumps({"error": "invalid uri"})
metainfo_deferred.addCallback(on_got_metainfo)
return NOT_DONE_YET
def test_set_piece_length_invalid_type(self):
t = TorrentDef()
t.set_piece_length("20")
def test_set_httpseeds(self):
t = TorrentDef()
t.set_httpseeds(["http://httpseed.com"])
self.assertEqual(t.get_httpseeds(), ["http://httpseed.com"])
def test_set_httpseeds_wrong_url(self):
t = TorrentDef()
t.set_httpseeds(["http/httpseed.com"])
def test_set_urllist_urls(self):
t = TorrentDef()
t.set_urllist(["http://url.com"])
self.assertEqual(t.get_urllist(), ["http://url.com"])
def test_set_urllist_wrong_url(self):
t = TorrentDef()
t.set_urllist(["http/url.com"])
def test_set_created_by(self):
t = TorrentDef()
t.set_created_by("dolor sit")
self.assertEqual(t.get_created_by(), "dolor sit")
def test_set_dht_nodes(self):
t = TorrentDef()
t.set_dht_nodes([["127.0.0.1", 1234]])
self.assertEqual(t.get_dht_nodes(), [["127.0.0.1", 1234]])
def test_get_piece_length(self):
t = TorrentDef()
self.assertEqual(t.get_piece_length(), 0)
def _refresh(self):
channel_url = None
try:
self.key_url_lock.acquire()
channel_url = deepcopy(self.key_url)
finally:
self.key_url_lock.release()
if channel_url:
for key, urls in channel_url.iteritems():
if key in self.key_callbacks:
for url in urls:
if DEBUG:
print >> sys.stderr, "RssParser: getting rss", url, len(
urls)
historyfile = self.gethistfilename(url, key)
urls_already_seen = URLHistory(historyfile)
urls_already_seen.read()
newItems = self.readUrl(url, urls_already_seen)
for title, new_urls, description, thumbnail in newItems:
for new_url in new_urls:
urls_already_seen.add(new_url)
urls_already_seen.write()
try:
if DEBUG:
print >> sys.stderr, "RssParser: trying", new_url
referer = urlparse(new_url)
referer = referer.scheme + "://" + referer.netloc + "/"
stream = urlOpenTimeout(new_url,
referer=referer)
bdata = stream.read()
stream.close()
bddata = bdecode(bdata, 1)
torrent = TorrentDef._create(bddata)
def processCallbacks(key):
for callback in self.key_callbacks[
key]:
try:
callback(key,
torrent,
extraInfo={
'title': title,
'description':
description,
'thumbnail':
thumbnail
})
except:
print_exc()
if self.remote_th.is_registered():
callback = lambda key=key: processCallbacks(
key)
self.remote_th.save_torrent(
torrent, callback)
else:
processCallbacks(key)
except:
if DEBUG:
print >> sys.stderr, "RssParser: could not download", new_url
pass
time.sleep(RSS_CHECK_FREQUENCY)
def test_get_infohash(self):
t = TorrentDef()
t.get_infohash()
def lineReceived(self, line):
anon_tunnel = self.anon_tunnel
if line == 'threads':
for thread in threading.enumerate():
logger.debug("%s \t %d", thread.name, thread.ident)
elif line == 'c':
logger.debug(
"========\nCircuits\n========\nid\taddress\t\t\t\t\tgoal\thops\tIN (MB)\tOUT (MB)\tinfohash\ttype"
)
for circuit_id, circuit in anon_tunnel.community.circuits.items():
info_hash = circuit.info_hash.encode(
'hex')[:10] if circuit.info_hash else '?'
logger.debug(
"%d\t%s:%d\t%d\t%d\t\t%.2f\t\t%.2f\t\t%s\t%s" % circuit_id,
circuit.first_hop[0], circuit.first_hop[1],
circuit.goal_hops, len(circuit.hops),
circuit.bytes_down / 1024.0 / 1024.0,
circuit.bytes_up / 1024.0 / 1024.0, info_hash,
circuit.ctype)
elif line.startswith('s'):
cur_path = os.getcwd()
line_split = line.split(' ')
filename = 'test_file' if len(line_split) == 1 else line_split[1]
if not os.path.exists(filename):
logger.info("Creating torrent..")
with open(filename, 'wb') as fp:
fp.write(os.urandom(50 * 1024 * 1024))
tdef = TorrentDef()
tdef.add_content(os.path.join(cur_path, filename))
tdef.set_tracker("udp://localhost/announce")
tdef.set_private()
tdef.finalize()
tdef.save(os.path.join(cur_path, filename + '.torrent'))
else:
logger.info("Loading existing torrent..")
tdef = TorrentDef.load(filename + '.torrent')
logger.info("loading torrent done, infohash of torrent: %s" %
(tdef.get_infohash().encode('hex')[:10]))
defaultDLConfig = DefaultDownloadStartupConfig.getInstance()
dscfg = defaultDLConfig.copy()
dscfg.set_hops(1)
dscfg.set_dest_dir(cur_path)
reactor.callFromThread(
anon_tunnel.session.start_download_from_tdef, tdef, dscfg)
elif line.startswith('i'):
# Introduce dispersy port from other main peer to this peer
line_split = line.split(' ')
to_introduce_ip = line_split[1]
to_introduce_port = int(line_split[2])
self.anon_tunnel.community.add_discovered_candidate(
Candidate((to_introduce_ip, to_introduce_port), tunnel=False))
elif line.startswith('d'):
line_split = line.split(' ')
filename = 'test_file' if len(line_split) == 1 else line_split[1]
logger.info("Loading torrent..")
tdef = TorrentDef.load(filename + '.torrent')
logger.info("Loading torrent done")
defaultDLConfig = DefaultDownloadStartupConfig.getInstance()
dscfg = defaultDLConfig.copy()
dscfg.set_hops(1)
dscfg.set_dest_dir(
os.path.join(
os.getcwd(),
'downloader%s' % anon_tunnel.session.get_dispersy_port()))
def start_download():
def cb(ds):
logger.info(
'Download infohash=%s, down=%s, progress=%s, status=%s, seedpeers=%s, candidates=%d'
% (tdef.get_infohash().encode('hex')[:10],
ds.get_current_speed('down'), ds.get_progress(),
dlstatus_strings[ds.get_status()],
sum(ds.get_num_seeds_peers()),
sum(1 for _ in anon_tunnel.community.
dispersy_yield_verified_candidates())))
return 1.0, False
download = anon_tunnel.session.start_download_from_tdef(
tdef, dscfg)
download.set_state_callback(cb)
reactor.callFromThread(start_download)
elif line == 'q':
anon_tunnel.should_run = False
elif line == 'r':
logger.debug("circuit\t\t\tdirection\tcircuit\t\t\tTraffic (MB)")
from_to = anon_tunnel.community.relay_from_to
for key in from_to.keys():
relay = from_to[key]
logger.info("%s-->\t%s\t\t%.2f" % (
(key[0], key[1]),
(relay.sock_addr, relay.circuit_id),
relay.bytes[1] / 1024.0 / 1024.0,
))
def test_set_name(self):
t = TorrentDef()
t.set_name("lorem ipsum")
t.get_name()
def test_add_tdef_not_finalized(self):
"""
Testing whether a ValueError is raised when a non-finalized tdef is added as download.
"""
self.lm.add(TorrentDef(), None)
def test_no_valid_metainfo(self):
t = TorrentDef()
t.get_metainfo()
def _on_magnet_fetched(meta_info):
return TorrentDef.load_from_dict(meta_info)
def test_initial_peers(self):
t = TorrentDef()
self.assertFalse(t.get_initial_peers())
class TestVideoServerSession(TestAsServer):
"""
Class for testing HTTP-based video server in a session.
Mainly HTTP range queries.
"""
@blocking_call_on_reactor_thread
@inlineCallbacks
def setUp(self, autoload_discovery=True):
""" unittest test setup code """
yield TestAsServer.setUp(self, autoload_discovery=autoload_discovery)
self.port = self.session.get_videoserver_port()
self.sourcefn = os.path.join(TESTS_DATA_DIR, "video.avi")
self.sourcesize = os.path.getsize(self.sourcefn)
self.tdef = None
self.expsize = 0
yield self.start_vod_download()
def setUpPreSession(self):
TestAsServer.setUpPreSession(self)
self.config.set_libtorrent(True)
self.config.set_videoserver_enabled(True)
#
# Tests
#
@deferred(timeout=10)
def test_specific_range(self):
return self.range_check(115, 214)
@deferred(timeout=10)
def test_last_100(self):
return self.range_check(self.sourcesize - 100, None)
@deferred(timeout=10)
def test_first_100(self):
return self.range_check(None, 100)
@deferred(timeout=10)
def test_combined(self):
return self.range_check(115, 214, setset=True)
def start_vod_download(self):
self.tdef = TorrentDef()
self.tdef.add_content(self.sourcefn)
self.tdef.set_tracker("http://127.0.0.1:12/announce")
self.tdef.finalize()
dscfg = DownloadStartupConfig()
dscfg.set_dest_dir(os.path.dirname(self.sourcefn))
download = self.session.start_download_from_tdef(self.tdef, dscfg)
return download.get_handle()
def get_std_header(self):
msg = "GET /%s/0 HTTP/1.1\r\n" % binascii.hexlify(
self.tdef.get_infohash())
msg += "Host: 127.0.0.1:" + str(self.port) + "\r\n"
return msg
@staticmethod
def create_range_str(firstbyte, lastbyte):
head = ""
if firstbyte is not None:
head += str(firstbyte)
head += "-"
if lastbyte is not None:
head += str(lastbyte)
return head
def get_header(self, firstbyte, lastbyte, setset=False):
head = self.get_std_header()
head += "Range: bytes="
head += self.create_range_str(firstbyte, lastbyte)
if setset:
# Make into set of byte ranges, VideoHTTPServer should refuse.
head += ",0-99"
head += "\r\n"
head += "Connection: close\r\n"
return head + "\r\n"
def range_check(self, firstbyte, lastbyte, setset=False):
test_deferred = Deferred()
self._logger.debug("range_test: %s %s %s setset %s", firstbyte,
lastbyte, self.sourcesize, setset)
if firstbyte is not None and lastbyte is None:
exp_byte_range = (firstbyte, self.sourcesize - 1)
elif firstbyte is None and lastbyte is not None:
exp_byte_range = (self.sourcesize - lastbyte, self.sourcesize - 1)
else:
exp_byte_range = (firstbyte, lastbyte)
# the amount of bytes actually requested. (Content-length)
self.expsize = exp_byte_range[1] - exp_byte_range[0] + 1
f = open(self.sourcefn, "rb")
f.seek(exp_byte_range[0])
expdata = f.read(self.expsize)
f.close()
def on_connected(p):
p.sendMessage(self.get_header(firstbyte, lastbyte, setset))
endpoint = TCP4ClientEndpoint(reactor, "localhost", self.port)
connectProtocol(endpoint, VideoServerProtocol(test_deferred, self.sourcesize, expdata, setset, exp_byte_range))\
.addCallback(on_connected)
return test_deferred
def test_set_initial_peers(self):
t = TorrentDef()
t.set_initial_peers([("127.0.0.1", 1234)])
self.assertEqual(t.get_initial_peers(), [("127.0.0.1", 1234)])
def test_add_content_announce_list(self):
""" Add a single file with announce-list to a TorrentDef """
t = TorrentDef()
fn = os.path.join(TESTS_DATA_DIR, self.VIDEO_FILE_NAME)
t.add_content(fn)
t.set_tracker(TRACKER)
exphier = [[TRACKER],
[
'http://tracker1.tribler.org:6969/announce',
'http://tracker2.tribler.org:7070/ann'
],
[
'http://www.cs.vu.nl', 'http://www.st.ewi.tudelft.nl',
'http://www.vuze.com'
]]
t.set_tracker_hierarchy(exphier)
t.finalize()
metainfo = t.get_metainfo()
self.general_check(metainfo)
realhier = metainfo['announce-list']
self.assertEqual(realhier, exphier)
def test_add_content_file_and_copy(self):
""" Add a single file to a TorrentDef """
t = TorrentDef()
fn = os.path.join(TESTS_DATA_DIR, self.VIDEO_FILE_NAME)
t.add_content(fn)
t.set_tracker(TRACKER)
t.finalize()
s = os.path.getsize(fn)
metainfo = t.get_metainfo()
self.general_check(metainfo)
self.assertEqual(metainfo['info']['name'], self.VIDEO_FILE_NAME)
self.assertEqual(metainfo['info']['length'], s)
self.assertTrue(t.get_pieces())
self.assertEqual(len(t.get_infohash()), INFOHASH_LENGTH)
self.assertTrue(t.get_name())
# test copy constructor
nt = TorrentDef(t.input, t.metainfo, t.infohash)
self.assertEqual(nt.input, t.input)
self.assertEqual(nt.metainfo, t.metainfo)
self.assertEqual(nt.infohash, t.infohash)
# test removing content
nt.remove_content("/test123")
self.assertEqual(len(nt.input['files']), 1)
nt.remove_content(unicode(fn))
self.assertEqual(len(nt.input['files']), 0)
nt.remove_content(unicode(fn))
def test_set_dht_nodes_node_no_string(self):
t = TorrentDef()
t.set_dht_nodes([[1234, "127.0.0.1"]])
torrent = fileargs[1]
if not os.path.exists(torrent):
print "Error: Could not find torrent file '%s'" % torrent
raise SystemExit(1)
if not config['key_file']:
config['key_file'] = torrent + ".tkey"
if not os.path.exists(config['key_file']):
print "Error: Could not find key file '%s'" % config['key_file']
raise SystemExit(1)
# Load the torrent file
try:
t = TorrentDef.load(torrent)
except Exception as e:
print "Bad torrent file:", e
raise SystemExit(1)
if not t.get_cs_keys():
print "Not a closed swarm torrent"
raise SystemExit(1)
try:
torrent_keypair = ClosedSwarm.read_cs_keypair(config['key_file'])
except Exception as e:
print "Bad torrent key file", e
raise SystemExit(1)
# Need permid of the receiving node
if not config['node_id']:
def test_set_comment(self):
t = TorrentDef()
t.set_comment("lorem ipsum")
self.assertEqual(t.get_comment(), "lorem ipsum")
self.assertEqual(t.get_comment_as_unicode(), u"lorem ipsum")
def test_set_dht_nodes_node_no_int(self):
t = TorrentDef()
t.set_dht_nodes([["127.0.0.1", "1234"]])
