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 create_torrent(self):
[srchandle, sourcefn] = mkstemp()
self.content = Rand.rand_bytes(self.contentlen)
os.write(srchandle, self.content)
os.close(srchandle)
self.tdef = TorrentDef()
self.tdef.add_content(sourcefn)
self.tdef.set_piece_length(self.piecelen)
self.tdef.set_tracker("http://127.0.0.1:12/announce")
self.tdef.finalize()
torrentfn = os.path.join(self.session.config.get_state_dir(),
"gen.torrent")
self.tdef.save(torrentfn)
dscfg = DownloadStartupConfig()
destdir = os.path.dirname(sourcefn)
dscfg.set_dest_dir(destdir)
dscfg.set_mode(DLMODE_VOD)
download = self.session.start_download_from_tdef(self.tdef, dscfg)
download.set_state_callback(self.state_callback)
self.session.set_download_states_callback(self.states_callback)
def setupSeeder(self, hops=0, session=None):
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.config2.set_state_dir(self.getStateDir(2))
if session is None:
self.session2 = Session(self.config2, ignore_singleton=True, autoload_discovery=False)
upgrader = self.session2.prestart()
while not upgrader.is_done:
time.sleep(0.1)
self.session2.start()
session = self.session2
tdef = TorrentDef()
tdef.add_content(os.path.join(TESTS_DATA_DIR, "video.avi"))
tdef.set_tracker("http://fake.net/announce")
tdef.set_private() # disable dht
tdef.finalize()
torrentfn = os.path.join(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
dscfg.set_hops(hops)
d = session.start_download(tdef, dscfg)
d.set_state_callback(self.seeder_state_callback)
return torrentfn
def setUpDownloadConfig(self):
dscfg = DownloadStartupConfig()
print >> sys.stderr, "test: Downloading to", self.config_path
dscfg.set_dest_dir(self.config_path)
dscfg.set_breakup_seed_bitfield(False)
return dscfg
def _on_torrent_created(result):
"""
Success callback
:param result: from create_torrent_file
"""
metainfo_dict = bdecode(result['metainfo'])
# Download this torrent if specified
if 'download' in request.args and len(request.args['download']) > 0 \
and request.args['download'][0] == "1":
download_config = DownloadStartupConfig()
download_config.set_dest_dir(result['base_path'] if len(
file_path_list) == 1 else result['base_dir'])
try:
self.session.lm.ltmgr.start_download(
tdef=TorrentDef(metainfo=metainfo_dict),
dconfig=download_config)
except DuplicateDownloadException:
self._logger.warning(
"The created torrent is already being downloaded.")
request.write(
json.dumps({"torrent": base64.b64encode(result['metainfo'])}))
# If the above request.write failed, the request will have already been finished
if not request.finished:
request.finish()
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 do_help(self, infohash, torrent_data, permid):
basename = binascii.hexlify(
infohash) + '.torrent' # ignore .tribe stuff, not vital
torrentfilename = os.path.join(self.helpdir, basename)
tfile = open(torrentfilename, "wb")
tfile.write(torrent_data)
tfile.close()
if DEBUG:
print >> sys.stderr, "helpmsg: Got metadata required for helping", show_permid_short(
permid)
print >> sys.stderr, "helpmsg: torrent: ", torrentfilename
tdef = TorrentDef.load(torrentfilename)
if self.dlconfig is None:
dscfg = DownloadStartupConfig()
else:
dscfg = DownloadStartupConfig(self.dlconfig)
dscfg.set_coopdl_coordinator_permid(permid)
dscfg.set_dest_dir(self.helpdir)
# Start new download
self.session.start_download(tdef, dscfg)
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 download_channel(self, channel):
"""
Download a channel with a given infohash and title.
:param channel: The channel metadata ORM object.
"""
dcfg = DownloadStartupConfig()
dcfg.set_dest_dir(self.session.lm.mds.channels_dir)
dcfg.set_channel_download(True)
tdef = TorrentDefNoMetainfo(infohash=str(channel.infohash),
name=channel.dir_name)
download = self.session.start_download_from_tdef(tdef, dcfg)
def on_channel_download_finished(dl):
channel_dirname = os.path.join(self.session.lm.mds.channels_dir,
dl.get_def().get_name())
self.session.lm.mds.process_channel_dir(channel_dirname,
channel.public_key,
external_thread=True)
self.session.lm.mds._db.disconnect()
def _on_failure(failure):
self._logger.error(
"Error when processing channel dir download: %s", failure)
finished_deferred = download.finished_deferred.addCallback(
lambda dl: deferToThread(on_channel_download_finished, dl))
finished_deferred.addErrback(_on_failure)
return download, finished_deferred
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_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")
torrentfn = os.path.join(self.session2.config.get_state_dir(),
"gen.torrent")
tdef.save(torrent_filepath=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 _on_torrent_created(result):
"""
Success callback
:param result: from create_torrent_file
"""
with open(result['torrent_file_path'], 'rb') as f:
torrent_64 = base64.b64encode(f.read())
# Download this torrent if specified
if 'download' in request.args and len(request.args['download']) > 0 \
and request.args['download'][0] == "1":
download_config = DownloadStartupConfig()
download_config.set_dest_dir(result['base_path'] if len(
file_path_list) == 1 else result['base_dir'])
try:
self.session.start_download_from_uri(
'file:' + result['torrent_file_path'], download_config)
except DuplicateDownloadException:
self._logger.warning(
"The created torrent is already being downloaded.")
request.write(json.dumps({"torrent": torrent_64}))
# If the above request.write failed, the request will have already been finished
if not request.finished:
request.finish()
def setUpDownloadConfig(self):
dscfg = DownloadStartupConfig()
print >> sys.stderr, "test: Downloading to", self.config_path
dscfg.set_dest_dir(self.config_path)
dscfg.set_breakup_seed_bitfield(False)
return dscfg
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 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 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 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, ignore_singleton=True, autoload_discovery=False)
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)
from twisted.internet import reactor, task
while not list(self.tunnel_community_seeder.active_data_circuits()):
yield task.deferLater(reactor, .05, lambda: None)
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 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 not self.download_exists(tdef.get_infohash()):
self.add(tdef, dscfg, pstate, setupDelay=setupDelay)
else:
self._logger.info("tlm: not resuming checkpoint because download has already been added")
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 start_anon_download(self, hops=1):
"""
Start an anonymous download in the main Tribler session.
"""
dscfg = DownloadStartupConfig()
dscfg.set_dest_dir(self.getDestDir())
dscfg.set_hops(hops)
download = self.session.start_download_from_tdef(self.seed_tdef, dscfg)
download.add_peer(("127.0.0.1", self.session2.config.get_libtorrent_port()))
return download
def start_anon_download(self, hops=1):
"""
Start an anonymous download in the main Tribler session.
"""
dscfg = DownloadStartupConfig()
dscfg.set_dest_dir(self.getDestDir())
dscfg.set_hops(hops)
download = self.session.start_download_from_tdef(self.seed_tdef, dscfg)
download.add_peer(("127.0.0.1", self.session2.config.get_libtorrent_port()))
return download
def start_anon_download(self, hops=1):
"""
Start an anonymous download in the main Tribler session.
"""
dscfg = DownloadStartupConfig()
dscfg.set_dest_dir(self.getDestDir())
dscfg.set_hops(hops)
download = self.session.start_download_from_tdef(self.seed_tdef, dscfg)
tc = self.session.lm.tunnel_community
tc.bittorrent_peers[download] = [("127.0.0.1", self.session2.config.get_libtorrent_port())]
return download
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 updated_my_channel(self, new_torrent_path):
"""
Notify the core that we updated our channel.
:param new_torrent_path: path to the new torrent file
"""
# Start the new download
tdef = TorrentDef.load(new_torrent_path)
dcfg = DownloadStartupConfig()
dcfg.set_dest_dir(self.mds.channels_dir)
dcfg.set_channel_download(True)
self.add(tdef, dcfg)
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 updated_my_channel(self, tdef):
"""
Notify the core that we updated our channel.
"""
with db_session:
my_channel = self.session.lm.mds.ChannelMetadata.get_my_channel()
if my_channel and my_channel.status == COMMITTED and not self.session.has_download(str(my_channel.infohash)):
dcfg = DownloadStartupConfig()
dcfg.set_dest_dir(self.session.lm.mds.channels_dir)
dcfg.set_channel_download(True)
self.session.lm.add(tdef, dcfg)
def updated_my_channel(self, tdef):
"""
Notify the core that we updated our channel.
"""
with db_session:
my_channel = self.session.lm.mds.ChannelMetadata.get_my_channel()
if my_channel and my_channel.status == COMMITTED and not self.session.has_download(
str(my_channel.infohash)):
dcfg = DownloadStartupConfig()
dcfg.set_dest_dir(self.session.lm.mds.channels_dir)
dcfg.set_channel_download(True)
self.session.lm.add(tdef, dcfg)
def register_file_stream(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(self.tdef, dscfg)
while not download.handle:
time.sleep(1)
def register_file_stream(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(self.tdef, dscfg)
while not download.handle:
time.sleep(1)
def start_anon_download(self, hops=1):
"""
Start an anonymous download in the main Tribler session.
"""
dscfg = DownloadStartupConfig()
dscfg.set_dest_dir(self.getDestDir())
dscfg.set_hops(hops)
download = self.session.start_download_from_tdef(self.seed_tdef, dscfg)
tc = self.session.lm.tunnel_community
tc.bittorrent_peers[download] = [
("127.0.0.1", self.session2.config.get_libtorrent_port())
]
return download
def test_remove_torrent_id(self):
"""
Test whether removing a torrent id works.
"""
torrent_def = TorrentDef.load(TORRENT_UBUNTU_FILE)
dcfg = DownloadStartupConfig()
dcfg.set_dest_dir(self.getDestDir())
download = self.session.start_download_from_tdef(torrent_def, download_startup_config=dcfg, hidden=True)
# Create a deferred which forwards the unhexlified string version of the download's infohash
download_started = download.get_handle().addCallback(lambda handle: unhexlify(str(handle.info_hash())))
return download_started.addCallback(self.session.remove_download_by_id)
def download_channel(self, channel):
"""
Download a channel with a given infohash and title.
:param channel: The channel metadata ORM object.
"""
finished_deferred = Deferred()
dcfg = DownloadStartupConfig()
dcfg.set_dest_dir(self.mds.channels_dir)
dcfg.set_channel_download(True)
tdef = TorrentDefNoMetainfo(infohash=str(channel.infohash), name=channel.title)
download = self.session.start_download_from_tdef(tdef, dcfg)
channel_id = channel.public_key
download.finished_callback = lambda dl: self.on_channel_download_finished(dl, channel_id, finished_deferred)
return download, finished_deferred
def test_remove_torrent_id(self):
"""
Test whether removing a torrent id works.
"""
torrent_def = TorrentDef.load(TORRENT_UBUNTU_FILE)
dcfg = DownloadStartupConfig()
dcfg.set_dest_dir(self.getDestDir())
download = self.session.start_download_from_tdef(
torrent_def, download_startup_config=dcfg, hidden=True)
# Create a deferred which forwards the unhexlified string version of the download's infohash
download_started = download.get_handle().addCallback(
lambda handle: unhexlify(str(handle.info_hash())))
return download_started.addCallback(self.session.remove_download_by_id)
def on_torrent_insert(self, source_str, infohash, name):
"""
Callback function called by the source when a new torrent is discovered
"""
self._logger.debug('Received torrent %s from %s', infohash, source_str)
if source_str not in self.sources:
self._logger.debug('Skipping torrent %s (unknown source %s)',
infohash, source_str)
return
# Did we already get this torrent from another source?
if infohash in self.torrents:
self.torrents[infohash].sources.add(source_str)
self._logger.debug('Skipping torrent %s (already known)', infohash)
return
# If a download already exists or already has a checkpoint, skip this torrent
if self.session.get_download(unhexlify(infohash)) or \
os.path.exists(os.path.join(self.session.get_downloads_pstate_dir(), infohash + '.state')):
self._logger.debug(
'Skipping torrent %s (download already running or scheduled to run)',
infohash)
return
if len(self.torrents) >= self.settings.max_torrents_listed:
self._logger.debug('Skipping torrent %s (limit reached)', infohash)
return
self.torrents[infohash] = CreditMiningTorrent(infohash, name)
self.torrents[infohash].sources.add(source_str)
self._logger.info('Starting torrent %s', infohash)
magnet = u'magnet:?xt=urn:btih:%s&dn=%s' % (infohash, name)
dl_config = DownloadStartupConfig()
dl_config.set_hops(self.settings.hops)
dl_config.set_dest_dir(self.settings.save_path)
dl_config.set_credit_mining(True)
dl_config.set_user_stopped(True)
self.session.lm.add(TorrentDefNoMetainfo(unhexlify(infohash), name,
magnet),
dl_config,
hidden=True)
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.mylistenport = 4810
def new_download(self, permid, infohash, torrent_data):
""" Start a new download in order to get the pieces that will be requested by the doe.
After the download is started, find the appropriate proxy object and call it's method.
@param permid: The permid of the peer who sent the message
@param infohash: the infohash of the torrent for which relay is requested
@param torrent_data: the content of the .torrent file
"""
# Create the name for the .torrent file in the proxy cache
basename = binascii.hexlify(infohash) + '.torrent'
torrentfilename = os.path.join(self.proxydir, basename)
# Write the .torrent information in the .torrent proxy cache file
tfile = open(torrentfilename, "wb")
tfile.write(torrent_data)
tfile.close()
if DEBUG:
print >> sys.stderr, "proxy: new_download: Got metadata required for relaying"
print >> sys.stderr, "proxy: new_download: torrent: ", torrentfilename
tdef = TorrentDef.load(torrentfilename)
if self.dlconfig is None:
dscfg = DownloadStartupConfig()
else:
dscfg = DownloadStartupConfig(self.dlconfig)
dscfg.set_proxyservice_role(PROXYSERVICE_ROLE_PROXY)
dscfg.set_dest_dir(self.proxydir)
dscfg.set_doe_mode(
DOE_MODE_OFF
) # a proxy does not use other proxies for downloading data in the current stage
# Start new download
if DEBUG:
print >> sys.stderr, "proxy: new_download: Starting a new download"
self.session.add_observer(self.proxydownloader_started,
NTFY_PROXYDOWNLOADER, [NTFY_STARTED])
d = self.session.start_download(tdef, dscfg)
d.set_state_callback(self.state_callback, getpeerlist=False)
def start_download(self, torrent):
"""
Start downloading a particular torrent and add it to download list in Tribler
"""
dscfg = DownloadStartupConfig()
dscfg.set_dest_dir(self.settings.credit_mining_path)
dscfg.set_safe_seeding(False)
preload = torrent.get('preload', False)
if self.session.lm.download_exists(torrent["metainfo"].get_infohash()):
self._logger.error("Already downloading %s. Cancel start_download",
hexlify(torrent["metainfo"].get_infohash()))
return
self._logger.info("Starting %s preload %s",
hexlify(torrent["metainfo"].get_infohash()), preload)
torrent['download'] = self.session.lm.add(torrent['metainfo'], dscfg, hidden=True,
share_mode=not preload, checkpoint_disabled=True)
torrent['download'].set_priority(torrent.get('prio', 1))
def create_dconfig_from_params(parameters):
"""
Create a download configuration based on some given parameters. Possible parameters are:
- anon_hops: the number of hops for the anonymous download. 0 hops is equivalent to a plain download
- safe_seeding: whether the seeding of the download should be anonymous or not (0 = off, 1 = on)
- destination: the destination path of the torrent (where it is saved on disk)
"""
download_config = DownloadStartupConfig()
anon_hops = 0
if 'anon_hops' in parameters and len(parameters['anon_hops']) > 0:
if parameters['anon_hops'][0].isdigit():
anon_hops = int(parameters['anon_hops'][0])
safe_seeding = False
if 'safe_seeding' in parameters and len(parameters['safe_seeding']) > 0 \
and parameters['safe_seeding'][0] == "1":
safe_seeding = True
if anon_hops > 0 and not safe_seeding:
return None, "Cannot set anonymous download without safe seeding enabled"
if anon_hops > 0:
download_config.set_hops(anon_hops)
if safe_seeding:
download_config.set_safe_seeding(True)
if 'destination' in parameters and len(parameters['destination']) > 0:
if not os.path.isdir(parameters['destination'][0]):
return None, "Invalid destination directory specified"
download_config.set_dest_dir(parameters['destination'][0])
if 'selected_files[]' in parameters:
selected_files_list = [
unicode(f, 'utf-8') for f in parameters['selected_files[]']
]
download_config.set_selected_files(selected_files_list)
return download_config, None
def create_torrent(self):
[srchandle, sourcefn] = mkstemp()
self.content = '0' * self.contentlen
os.write(srchandle, self.content)
os.close(srchandle)
self.tdef = TorrentDef()
self.tdef.add_content(sourcefn)
self.tdef.set_piece_length(self.piecelen)
self.tdef.set_tracker("http://127.0.0.1:12/announce")
torrentfn = os.path.join(self.session.config.get_state_dir(), "gen.torrent")
self.tdef.save(torrentfn)
dscfg = DownloadStartupConfig()
destdir = os.path.dirname(sourcefn)
dscfg.set_dest_dir(destdir)
dscfg.set_mode(DLMODE_VOD)
download = self.session.start_download_from_tdef(self.tdef, dscfg)
download.set_state_callback(self.state_callback)
self.session.set_download_states_callback(self.states_callback)
def _on_torrent_created(result):
"""
Success callback
:param result: from create_torrent_file
"""
metainfo_dict = bdecode(result['metainfo'])
# Download this torrent if specified
if 'download' in request.args and len(request.args['download']) > 0 \
and request.args['download'][0] == "1":
download_config = DownloadStartupConfig()
download_config.set_dest_dir(result['base_path'] if len(file_path_list) == 1 else result['base_dir'])
try:
self.session.lm.ltmgr.start_download(
tdef=TorrentDef(metainfo=metainfo_dict), dconfig=download_config)
except DuplicateDownloadException:
self._logger.warning("The created torrent is already being downloaded.")
request.write(json.dumps({"torrent": base64.b64encode(result['metainfo'])}))
# If the above request.write failed, the request will have already been finished
if not request.finished:
request.finish()
def on_torrent_insert(self, source_str, infohash, name):
"""
Callback function called by the source when a new torrent is discovered
"""
self._logger.debug('Received torrent %s from %s', infohash, source_str)
if source_str not in self.sources:
self._logger.debug('Skipping torrent %s (unknown source %s)', infohash, source_str)
return
# Did we already get this torrent from another source?
if infohash in self.torrents:
self.torrents[infohash].sources.add(source_str)
self._logger.debug('Skipping torrent %s (already known)', infohash)
return
# If a download already exists or already has a checkpoint, skip this torrent
if self.session.get_download(unhexlify(infohash)) or \
os.path.exists(os.path.join(self.session.get_downloads_pstate_dir(), infohash + '.state')):
self._logger.debug('Skipping torrent %s (download already running or scheduled to run)', infohash)
return
if len(self.torrents) >= self.settings.max_torrents_listed:
self._logger.debug('Skipping torrent %s (limit reached)', infohash)
return
self.torrents[infohash] = CreditMiningTorrent(infohash, name)
self.torrents[infohash].sources.add(source_str)
self._logger.info('Starting torrent %s', infohash)
magnet = u'magnet:?xt=urn:btih:%s&dn=%s' % (infohash, name)
dl_config = DownloadStartupConfig()
dl_config.set_hops(self.settings.hops)
dl_config.set_dest_dir(self.settings.save_path)
dl_config.set_credit_mining(True)
dl_config.set_user_stopped(True)
self.session.lm.add(TorrentDefNoMetainfo(unhexlify(infohash), name, magnet), dl_config, hidden=True)
def _on_torrent_created(result):
"""
Success callback
:param result: from create_torrent_file
"""
with open(result['torrent_file_path'], 'rb') as f:
torrent_64 = base64.b64encode(f.read())
# Download this torrent if specified
if 'download' in request.args and len(request.args['download']) > 0 \
and request.args['download'][0] == "1":
download_config = DownloadStartupConfig()
download_config.set_dest_dir(result['base_path'] if len(file_path_list) == 1 else result['base_dir'])
try:
self.session.start_download_from_uri('file:' + result['torrent_file_path'], download_config)
except DuplicateDownloadException:
self._logger.warning("The created torrent is already being downloaded.")
request.write(json.dumps({"torrent": torrent_64}))
# If the above request.write failed, the request will have already been finished
if not request.finished:
request.finish()
def new_download(self, permid, infohash, torrent_data):
""" Start a new download in order to get the pieces that will be requested by the doe.
After the download is started, find the appropriate proxy object and call it's method.
@param permid: The permid of the peer who sent the message
@param infohash: the infohash of the torrent for which relay is requested
@param torrent_data: the content of the .torrent file
"""
# Create the name for the .torrent file in the proxy cache
basename = binascii.hexlify(infohash) + ".torrent"
torrentfilename = os.path.join(self.proxydir, basename)
# Write the .torrent information in the .torrent proxy cache file
tfile = open(torrentfilename, "wb")
tfile.write(torrent_data)
tfile.close()
if DEBUG:
print >>sys.stderr, "proxy: new_download: Got metadata required for relaying"
print >>sys.stderr, "proxy: new_download: torrent: ", torrentfilename
tdef = TorrentDef.load(torrentfilename)
if self.dlconfig is None:
dscfg = DownloadStartupConfig()
else:
dscfg = DownloadStartupConfig(self.dlconfig)
dscfg.set_proxyservice_role(PROXYSERVICE_ROLE_PROXY)
dscfg.set_dest_dir(self.proxydir)
dscfg.set_doe_mode(DOE_MODE_OFF) # a proxy does not use other proxies for downloading data in the current stage
# Start new download
if DEBUG:
print >>sys.stderr, "proxy: new_download: Starting a new download"
self.session.add_observer(self.proxydownloader_started, NTFY_PROXYDOWNLOADER, [NTFY_STARTED])
d = self.session.start_download(tdef, dscfg)
d.set_state_callback(self.state_callback, getpeerlist=False)
def create_torrent(self):
[srchandle, self.sourcefn] = mkstemp()
self.content = Rand.rand_bytes(self.contentlen)
os.write(srchandle, self.content)
os.close(srchandle)
self.tdef = TorrentDef()
self.tdef.add_content(self.sourcefn)
self.tdef.set_piece_length(self.piecelen)
self.tdef.set_tracker("http://127.0.0.1:12/announce")
self.tdef.finalize()
self.torrentfn = os.path.join(self.session.get_state_dir(), "gen.torrent")
self.tdef.save(self.torrentfn)
dscfg = DownloadStartupConfig()
destdir = os.path.dirname(self.sourcefn)
dscfg.set_dest_dir(destdir)
dscfg.set_video_event_callback(self.sesscb_vod_event_callback)
self.session.set_download_states_callback(self.states_callback)
self.session.start_download(self.tdef, dscfg)
def do_help(self, infohash, torrent_data, permid):
basename = binascii.hexlify(infohash)+'.torrent' # ignore .tribe stuff, not vital
torrentfilename = os.path.join(self.helpdir,basename)
tfile = open(torrentfilename, "wb")
tfile.write(torrent_data)
tfile.close()
if DEBUG:
print >> sys.stderr,"helpmsg: Got metadata required for helping",show_permid_short(permid)
print >> sys.stderr,"helpmsg: torrent: ",torrentfilename
tdef = TorrentDef.load(torrentfilename)
if self.dlconfig is None:
dscfg = DownloadStartupConfig()
else:
dscfg = DownloadStartupConfig(self.dlconfig)
dscfg.set_coopdl_coordinator_permid(permid)
dscfg.set_dest_dir(self.helpdir)
# Start new download
self.session.start_download(tdef,dscfg)
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.session2 = Session(self.config, ignore_singleton=True)
self.session2.start()
tdef = TorrentDef()
tdef.add_content(os.path.join(BASE_DIR, "data", "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(os.path.join(BASE_DIR, "data")) # basedir of the file we are seeding
self.session2.start_download(tdef, dscfg)
return torrentfn
def create_dconfig_from_params(parameters):
"""
Create a download configuration based on some given parameters. Possible parameters are:
- anon_hops: the number of hops for the anonymous download. 0 hops is equivalent to a plain download
- safe_seeding: whether the seeding of the download should be anonymous or not (0 = off, 1 = on)
- destination: the destination path of the torrent (where it is saved on disk)
"""
download_config = DownloadStartupConfig()
anon_hops = 0
if 'anon_hops' in parameters and len(parameters['anon_hops']) > 0:
if parameters['anon_hops'][0].isdigit():
anon_hops = int(parameters['anon_hops'][0])
safe_seeding = False
if 'safe_seeding' in parameters and len(parameters['safe_seeding']) > 0 \
and parameters['safe_seeding'][0] == "1":
safe_seeding = True
if anon_hops > 0 and not safe_seeding:
return None, "Cannot set anonymous download without safe seeding enabled"
if anon_hops > 0:
download_config.set_hops(anon_hops)
if safe_seeding:
download_config.set_safe_seeding(True)
if 'destination' in parameters and len(parameters['destination']) > 0:
dest_dir = cast_to_unicode_utf8(parameters['destination'][0])
download_config.set_dest_dir(dest_dir)
if 'selected_files[]' in parameters:
selected_files_list = [cast_to_unicode_utf8(f) for f in parameters['selected_files[]']]
download_config.set_selected_files(selected_files_list)
return download_config, None
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.session2 = Session(self.config, ignore_singleton=True)
self.session2.start()
tdef = TorrentDef()
tdef.add_content(os.path.join(BASE_DIR, "data", "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(os.path.join(
BASE_DIR, "data")) # basedir of the file we are seeding
self.session2.start_download(tdef, dscfg)
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(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,
ignore_singleton=True,
autoload_discovery=False)
self.session2.start()
tdef = TorrentDef()
tdef.add_content(os.path.join(TESTS_DATA_DIR, "video.avi"))
tdef.set_tracker("http://localhost/announce")
tdef.set_private() # disable dht
tdef.finalize()
torrentfn = os.path.join(self.session2.get_state_dir(), "gen.torrent")
tdef.save(torrentfn)
self.seed_tdef = tdef
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)
if hops > 0: # Safe seeding enabled
self.tunnel_community_seeder = self.load_tunnel_community_in_session(
self.session2)
def setupSeeder(self, hops=0, session=None):
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.config2.set_state_dir(self.getStateDir(2))
if session is None:
self.session2 = Session(self.config2,
ignore_singleton=True,
autoload_discovery=False)
upgrader = self.session2.prestart()
while not upgrader.is_done:
time.sleep(0.1)
self.session2.start()
session = self.session2
tdef = TorrentDef()
tdef.add_content(os.path.join(TESTS_DATA_DIR, "video.avi"))
tdef.set_tracker("http://fake.net/announce")
tdef.set_private() # disable dht
tdef.finalize()
torrentfn = os.path.join(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
dscfg.set_hops(hops)
d = session.start_download(tdef, dscfg)
d.set_state_callback(self.seeder_state_callback)
return torrentfn
def download_channel(self, channel):
"""
Download a channel with a given infohash and title.
:param channel: The channel metadata ORM object.
"""
dcfg = DownloadStartupConfig()
dcfg.set_dest_dir(self.session.lm.mds.channels_dir)
dcfg.set_channel_download(True)
tdef = TorrentDefNoMetainfo(infohash=str(channel.infohash), name=channel.dir_name)
download = self.session.start_download_from_tdef(tdef, dcfg)
def on_channel_download_finished(dl):
channel_dirname = os.path.join(self.session.lm.mds.channels_dir, dl.get_def().get_name())
self.session.lm.mds.process_channel_dir(channel_dirname, channel.public_key, external_thread=True)
self.session.lm.mds._db.disconnect()
def _on_failure(failure):
self._logger.error("Error when processing channel dir download: %s", failure)
finished_deferred = download.finished_deferred.addCallback(
lambda dl: deferToThread(on_channel_download_finished, dl))
finished_deferred.addErrback(_on_failure)
return download, finished_deferred
class TestMetadata(TestAsServer, MagnetHelpers):
"""
Once we are downloading a torrent, our client should respond to
the ut_metadata extention message. This allows other clients to
obtain the info part of the metadata from us.
"""
def setUp(self):
""" override TestAsServer """
TestAsServer.setUp(self)
print >>sys.stderr,"test: Giving MyLaunchMany time to startup"
time.sleep(5)
print >>sys.stderr,"test: MyLaunchMany should have started up"
# the metadata that we want to transfer
self.tdef = TorrentDef()
self.tdef.add_content(os.path.join(os.getcwd(), "API", "file.wmv"))
self.tdef.set_tracker(self.session.get_internal_tracker_url())
# we use a small piece length to obtain multiple pieces
self.tdef.set_piece_length(1)
self.tdef.finalize()
# self.tdef.save(os.path.join(self.session.get_state_dir(), "gen.torrent"))
MagnetHelpers.__init__(self, self.tdef)
def setup_seeder(self):
self.seeder_setup_complete = False
self.seeder_teardown_complete = False
self.seeder_teardown = False
self.dscfg = DownloadStartupConfig()
self.dscfg.set_dest_dir(os.getcwd())
self.download = self.session.start_download(self.tdef, self.dscfg)
self.download.set_state_callback(self.seeder_state_callback)
counter = 0
while not self.seeder_setup_complete:
counter += 1
time.sleep(1)
assert counter < 30, "timeout"
print >> sys.stderr, "test: setup_seeder() complete"
def teardown_seeder(self):
self.seeder_teardown_complete = False
self.session.remove_download(self.download)
counter = 0
while not self.seeder_setup_complete:
counter += 1
time.sleep(1)
assert counter < 30, "timeout"
print >> sys.stderr, "test: teardown_seeder() complete"
def seeder_state_callback(self,ds):
assert not self.seeder_teardown_complete
self.seeder_setup_complete = (ds.get_status() == DLSTATUS_DOWNLOADING)
d = ds.get_download()
print >> sys.stderr, "test: seeder:", `d.get_def().get_name()`, dlstatus_strings[ds.get_status()], ds.get_progress()
if self.seeder_teardown:
self.seeder_teardown_complete = True
else:
return (1.0, False)
def test_all(self):
self.setup_seeder()
try:
self.subtest_good_flood()
finally:
self.teardown_seeder()
self.setup_seeder()
try:
self.subtest_good_request()
self.subtest_bad_request()
finally:
self.teardown_seeder()
def subtest_good_request(self):
conn = BTConnection("localhost", self.hisport, user_infohash=self.tdef.get_infohash())
conn.send(self.create_good_extend_handshake())
conn.read_handshake_medium_rare()
metadata_id = self.read_extend_handshake(conn)
# request metadata block 0, 2, 3, and the last
conn.send(self.create_good_extend_metadata_request(metadata_id, 0))
conn.send(self.create_good_extend_metadata_request(metadata_id, 2))
conn.send(self.create_good_extend_metadata_request(metadata_id, 3))
conn.send(self.create_good_extend_metadata_request(metadata_id, len(self.metadata_list) - 1))
self.read_extend_metadata_reply(conn, 0)
self.read_extend_metadata_reply(conn, 2)
self.read_extend_metadata_reply(conn, 3)
self.read_extend_metadata_reply(conn, len(self.metadata_list) - 1)
def subtest_good_flood(self):
conn = BTConnection("localhost", self.hisport, user_infohash=self.tdef.get_infohash())
conn.send(self.create_good_extend_handshake())
conn.read_handshake_medium_rare()
metadata_id = self.read_extend_handshake(conn)
for counter in xrange(len(self.metadata_list) * 2):
piece = counter % len(self.metadata_list)
conn.send(self.create_good_extend_metadata_request(metadata_id, piece))
if counter > len(self.metadata_list):
self.read_extend_metadata_reject(conn, piece)
else:
self.read_extend_metadata_reply(conn, piece)
def subtest_bad_request(self):
self.bad_request_and_disconnect({"msg_type":0, "piece":len(self.metadata_list)})
self.bad_request_and_disconnect({"msg_type":0, "piece":-1})
self.bad_request_and_disconnect({"msg_type":0, "piece":"1"})
self.bad_request_and_disconnect({"msg_type":0, "piece":[1,2]})
self.bad_request_and_disconnect({"msg_type":0, "PIECE":1})
def bad_request_and_disconnect(self, payload):
conn = BTConnection("localhost", self.hisport, user_infohash=self.tdef.get_infohash())
conn.send(self.create_good_extend_handshake())
conn.read_handshake_medium_rare()
metadata_id = self.read_extend_handshake(conn)
conn.send(EXTEND + chr(metadata_id) + bencode(payload))
self.read_extend_metadata_close(conn)
def setUpDownloadConfig(self):
dscfg = DownloadStartupConfig()
dscfg.set_dest_dir(self.config_path)
return dscfg
class TestAsServer(AbstractServer):
"""
Parent class for testing the server-side of Tribler
"""
@inlineCallbacks
def setUp(self):
yield super(TestAsServer, self).setUp()
self.setUpPreSession()
self.quitting = False
self.seeding_deferred = Deferred()
self.seeder_session = None
self.seed_config = None
self.session = Session(self.config)
self.session.upgrader_enabled = False
self.tribler_started_deferred = self.session.start()
yield self.tribler_started_deferred
self.assertTrue(self.session.lm.initComplete)
self.hisport = self.session.config.get_libtorrent_port()
self.annotate(self._testMethodName, start=True)
def setUpPreSession(self):
self.config = TriblerConfig(ConfigObj(configspec=CONFIG_SPEC_PATH, encoding='latin_1'))
self.config.set_default_destination_dir(self.dest_dir)
self.config.set_state_dir(self.getStateDir())
self.config.set_torrent_checking_enabled(False)
self.config.set_megacache_enabled(False)
self.config.set_dispersy_enabled(False)
self.config.set_ipv8_enabled(False)
self.config.set_mainline_dht_enabled(False)
self.config.set_torrent_store_enabled(False)
self.config.set_torrent_search_enabled(False)
self.config.set_channel_search_enabled(False)
self.config.set_torrent_collecting_enabled(False)
self.config.set_libtorrent_enabled(False)
self.config.set_video_server_enabled(False)
self.config.set_metadata_enabled(False)
self.config.set_http_api_enabled(False)
self.config.set_tunnel_community_enabled(False)
self.config.set_credit_mining_enabled(False)
self.config.set_market_community_enabled(False)
self.config.set_popularity_community_enabled(False)
self.config.set_dht_enabled(False)
self.config.set_version_checker_enabled(False)
self.config.set_libtorrent_dht_enabled(False)
self.config.set_bitcoinlib_enabled(False)
self.config.set_chant_enabled(False)
@inlineCallbacks
def tearDown(self):
self.annotate(self._testMethodName, start=False)
""" unittest test tear down code """
if self.session is not None:
yield self.session.shutdown()
assert self.session.has_shutdown()
self.session = None
yield self.stop_seeder()
ts = enumerate_threads()
self._logger.debug("test_as_server: Number of threads still running %d", len(ts))
for t in ts:
self._logger.debug("Thread still running %s, daemon: %s, instance: %s", t.getName(), t.isDaemon(), t)
yield super(TestAsServer, self).tearDown()
def create_local_torrent(self, source_file):
'''
This method creates a torrent from a local file and saves the torrent in the session state dir.
Note that the source file needs to exist.
'''
self.assertTrue(os.path.exists(source_file))
tdef = TorrentDef()
tdef.add_content(source_file)
tdef.set_tracker("http://localhost/announce")
tdef.finalize()
torrent_path = os.path.join(self.session.config.get_state_dir(), "seed.torrent")
tdef.save(torrent_path)
return tdef, torrent_path
def setup_seeder(self, tdef, seed_dir, port=None):
self.seed_config = TriblerConfig()
self.seed_config.set_torrent_checking_enabled(False)
self.seed_config.set_megacache_enabled(False)
self.seed_config.set_dispersy_enabled(False)
self.seed_config.set_ipv8_enabled(False)
self.seed_config.set_mainline_dht_enabled(False)
self.seed_config.set_torrent_store_enabled(False)
self.seed_config.set_torrent_search_enabled(False)
self.seed_config.set_channel_search_enabled(False)
self.seed_config.set_http_api_enabled(False)
self.seed_config.set_torrent_collecting_enabled(False)
self.seed_config.set_libtorrent_enabled(True)
self.seed_config.set_video_server_enabled(False)
self.seed_config.set_metadata_enabled(False)
self.seed_config.set_tunnel_community_enabled(False)
self.seed_config.set_market_community_enabled(False)
self.seed_config.set_dht_enabled(False)
self.seed_config.set_state_dir(self.getStateDir(2))
self.seed_config.set_version_checker_enabled(False)
self.seed_config.set_bitcoinlib_enabled(False)
self.seed_config.set_chant_enabled(False)
if port:
self.seed_config.set_libtorrent_port(port)
def start_seed_download(_):
self.dscfg_seed = DownloadStartupConfig()
self.dscfg_seed.set_dest_dir(seed_dir)
d = self.seeder_session.start_download_from_tdef(tdef, self.dscfg_seed)
d.set_state_callback(self.seeder_state_callback)
self._logger.debug("starting to wait for download to reach seeding state")
self.seeder_session = Session(self.seed_config)
self.seeder_session.upgrader_enabled = False
self.seeder_session.start().addCallback(start_seed_download)
return self.seeding_deferred
def stop_seeder(self):
if self.seeder_session is not None:
return self.seeder_session.shutdown()
return succeed(None)
def seeder_state_callback(self, ds):
d = ds.get_download()
self._logger.debug("seeder status: %s %s %s", repr(d.get_def().get_name()), dlstatus_strings[ds.get_status()],
ds.get_progress())
if ds.get_status() == DLSTATUS_SEEDING:
self.seeding_deferred.callback(None)
return 0.0
return 1.0
def setUpDownloadConfig(self):
dscfg = DownloadStartupConfig()
dscfg.set_dest_dir(self.config_path)
return dscfg
class TestAsServer(AbstractServer):
"""
Parent class for testing the server-side of Tribler
"""
@blocking_call_on_reactor_thread
@inlineCallbacks
def setUp(self, autoload_discovery=True):
yield super(TestAsServer, self).setUp(annotate=False)
self.setUpPreSession()
# We don't use the system keychain but a PlainText keyring for performance during tests
for new_keyring in keyring.backend.get_all_keyring():
if isinstance(new_keyring, PlaintextKeyring):
keyring.set_keyring(new_keyring)
self.quitting = False
self.seeding_deferred = Deferred()
self.seeder_session = None
self.seed_config = None
self.session = Session(self.config)
self.tribler_started_deferred = self.session.start()
yield self.tribler_started_deferred
self.assertTrue(self.session.lm.initComplete)
self.hisport = self.session.config.get_libtorrent_port()
self.annotate(self._testMethodName, start=True)
def setUpPreSession(self):
self.config = TriblerConfig(
ConfigObj(configspec=CONFIG_SPEC_PATH, encoding='latin_1'))
self.config.set_default_destination_dir(self.dest_dir)
self.config.set_state_dir(self.getStateDir())
self.config.set_torrent_checking_enabled(False)
self.config.set_megacache_enabled(False)
self.config.set_dispersy_enabled(False)
self.config.set_mainline_dht_enabled(False)
self.config.set_torrent_store_enabled(False)
self.config.set_torrent_search_enabled(False)
self.config.set_channel_search_enabled(False)
self.config.set_torrent_collecting_enabled(False)
self.config.set_libtorrent_enabled(False)
self.config.set_video_server_enabled(False)
self.config.set_metadata_enabled(False)
self.config.set_upgrader_enabled(False)
self.config.set_http_api_enabled(False)
self.config.set_tunnel_community_enabled(False)
self.config.set_credit_mining_enabled(False)
self.config.set_trustchain_enabled(False)
@blocking_call_on_reactor_thread
@inlineCallbacks
def tearDown(self, annotate=True):
self.annotate(self._testMethodName, start=False)
""" unittest test tear down code """
if self.session is not None:
assert self.session is Session.get_instance()
yield self.session.shutdown()
assert self.session.has_shutdown()
Session.del_instance()
yield self.stop_seeder()
ts = enumerate_threads()
self._logger.debug(
"test_as_server: Number of threads still running %d", len(ts))
for t in ts:
self._logger.debug(
"Thread still running %s, daemon: %s, instance: %s",
t.getName(), t.isDaemon(), t)
yield super(TestAsServer, self).tearDown(annotate=False)
def create_local_torrent(self, source_file):
'''
This method creates a torrent from a local file and saves the torrent in the session state dir.
Note that the source file needs to exist.
'''
self.assertTrue(os.path.exists(source_file))
tdef = TorrentDef()
tdef.add_content(source_file)
tdef.set_tracker("http://localhost/announce")
tdef.finalize()
torrent_path = os.path.join(self.session.config.get_state_dir(),
"seed.torrent")
tdef.save(torrent_path)
return tdef, torrent_path
def setup_seeder(self, tdef, seed_dir):
self.seed_config = TriblerConfig()
self.seed_config.set_torrent_checking_enabled(False)
self.seed_config.set_megacache_enabled(False)
self.seed_config.set_dispersy_enabled(False)
self.seed_config.set_mainline_dht_enabled(False)
self.seed_config.set_torrent_store_enabled(False)
self.seed_config.set_torrent_search_enabled(False)
self.seed_config.set_channel_search_enabled(False)
self.seed_config.set_torrent_collecting_enabled(False)
self.seed_config.set_libtorrent_enabled(True)
self.seed_config.set_video_server_enabled(False)
self.seed_config.set_metadata_enabled(False)
self.seed_config.set_upgrader_enabled(False)
self.seed_config.set_tunnel_community_enabled(False)
self.seed_config.set_state_dir(self.getStateDir(2))
def start_seed_download(_):
self.dscfg_seed = DownloadStartupConfig()
self.dscfg_seed.set_dest_dir(seed_dir)
d = self.seeder_session.start_download_from_tdef(
tdef, self.dscfg_seed)
d.set_state_callback(self.seeder_state_callback)
self._logger.debug(
"starting to wait for download to reach seeding state")
self.seeder_session = Session(self.seed_config, ignore_singleton=True)
self.seeder_session.start().addCallback(start_seed_download)
return self.seeding_deferred
def stop_seeder(self):
if self.seeder_session is not None:
return self.seeder_session.shutdown()
return succeed(None)
def seeder_state_callback(self, ds):
d = ds.get_download()
self._logger.debug("seeder status: %s %s %s",
repr(d.get_def().get_name()),
dlstatus_strings[ds.get_status()],
ds.get_progress())
if ds.get_status() == DLSTATUS_SEEDING:
self.seeding_deferred.callback(None)
return 0.0, False
return 1.0, False
class TestAsServer(AbstractServer):
"""
Parent class for testing the server-side of Tribler
"""
@inlineCallbacks
def setUp(self):
yield super(TestAsServer, self).setUp()
self.setUpPreSession()
self.quitting = False
self.seeding_deferred = Deferred()
self.seeder_session = None
self.seed_config = None
self.session = Session(self.config)
self.session.upgrader_enabled = False
self.tribler_started_deferred = self.session.start()
yield self.tribler_started_deferred
self.assertTrue(self.session.lm.initComplete)
self.hisport = self.session.config.get_libtorrent_port()
self.annotate(self._testMethodName, start=True)
def setUpPreSession(self):
self.config = TriblerConfig(
ConfigObj(configspec=CONFIG_SPEC_PATH, default_encoding='utf-8'))
self.config.set_default_destination_dir(self.dest_dir)
self.config.set_state_dir(self.getStateDir())
self.config.set_torrent_checking_enabled(False)
self.config.set_ipv8_enabled(False)
self.config.set_libtorrent_enabled(False)
self.config.set_video_server_enabled(False)
self.config.set_http_api_enabled(False)
self.config.set_tunnel_community_enabled(False)
self.config.set_credit_mining_enabled(False)
self.config.set_market_community_enabled(False)
self.config.set_popularity_community_enabled(False)
self.config.set_dht_enabled(False)
self.config.set_version_checker_enabled(False)
self.config.set_libtorrent_dht_enabled(False)
self.config.set_bitcoinlib_enabled(False)
self.config.set_chant_enabled(False)
self.config.set_resource_monitor_enabled(False)
@inlineCallbacks
def tearDown(self):
self.annotate(self._testMethodName, start=False)
""" unittest test tear down code """
if self.session is not None:
if self.session.lm.ltmgr:
self.session.lm.ltmgr.is_shutdown_ready = lambda: True
yield self.session.shutdown()
assert self.session.has_shutdown()
self.session = None
yield self.stop_seeder()
ts = enumerate_threads()
self._logger.debug(
"test_as_server: Number of threads still running %d", len(ts))
for t in ts:
self._logger.debug(
"Thread still running %s, daemon: %s, instance: %s",
t.getName(), t.isDaemon(), t)
yield super(TestAsServer, self).tearDown()
def create_local_torrent(self, source_file):
"""
This method creates a torrent from a local file and saves the torrent in the session state dir.
Note that the source file needs to exist.
"""
self.assertTrue(os.path.exists(source_file))
tdef = TorrentDef()
tdef.add_content(source_file)
tdef.set_tracker("http://localhost/announce")
torrent_path = os.path.join(self.session.config.get_state_dir(),
"seed.torrent")
tdef.save(torrent_filepath=torrent_path)
return tdef, torrent_path
def setup_seeder(self, tdef, seed_dir, port=None):
self.seed_config = TriblerConfig()
self.seed_config.set_torrent_checking_enabled(False)
self.seed_config.set_ipv8_enabled(False)
self.seed_config.set_http_api_enabled(False)
self.seed_config.set_libtorrent_enabled(True)
self.seed_config.set_video_server_enabled(False)
self.seed_config.set_tunnel_community_enabled(False)
self.seed_config.set_market_community_enabled(False)
self.seed_config.set_dht_enabled(False)
self.seed_config.set_state_dir(self.getStateDir(2))
self.seed_config.set_version_checker_enabled(False)
self.seed_config.set_bitcoinlib_enabled(False)
self.seed_config.set_chant_enabled(False)
self.seed_config.set_credit_mining_enabled(False)
self.seed_config.set_resource_monitor_enabled(False)
if port:
self.seed_config.set_libtorrent_port(port)
def start_seed_download(_):
self.dscfg_seed = DownloadStartupConfig()
self.dscfg_seed.set_dest_dir(seed_dir)
d = self.seeder_session.start_download_from_tdef(
tdef, self.dscfg_seed)
d.set_state_callback(self.seeder_state_callback)
self._logger.debug(
"starting to wait for download to reach seeding state")
self.seeder_session = Session(self.seed_config)
self.seeder_session.upgrader_enabled = False
self.seeder_session.start().addCallback(start_seed_download)
return self.seeding_deferred
def stop_seeder(self):
if self.seeder_session is not None:
if self.seeder_session.lm.ltmgr:
self.seeder_session.lm.ltmgr.is_shutdown_ready = lambda: True
return self.seeder_session.shutdown()
return succeed(None)
def seeder_state_callback(self, ds):
d = ds.get_download()
self._logger.debug("seeder status: %s %s %s",
repr(d.get_def().get_name()),
dlstatus_strings[ds.get_status()],
ds.get_progress())
if ds.get_status() == DLSTATUS_SEEDING:
self.seeding_deferred.callback(None)
return 0.0
return 1.0
class TestMetadataFakePeer(TestAsServer, MagnetHelpers):
"""
Once we are downloading a torrent, our client should respond to
the ut_metadata extention message. This allows other clients to
obtain the info part of the metadata from us.
"""
def setUp(self):
TestAsServer.setUp(self)
# the metadata that we want to transfer
self.tdef = TorrentDef()
self.tdef.add_content(os.path.join(BASE_DIR, "API", "file.wmv"))
self.tdef.set_tracker("http://fake.net/announce")
# we use a small piece length to obtain multiple pieces
self.tdef.set_piece_length(1)
self.tdef.finalize()
self.setup_seeder()
MagnetHelpers.__init__(self, self.tdef)
def setUpPreSession(self):
TestAsServer.setUpPreSession(self)
self.config.set_libtorrent(True)
self.config2 = self.config.copy()
self.config2.set_state_dir(self.getStateDir(2))
self.config2.set_listen_port(4810)
def tearDown(self):
self.teardown_seeder()
TestAsServer.tearDown(self)
def setup_seeder(self):
self.seeder_setup_complete = threading.Event()
self.dscfg = DownloadStartupConfig()
self.dscfg.set_dest_dir(os.path.join(BASE_DIR, "API"))
self.download = self.session.start_download(self.tdef, self.dscfg)
self.download.set_state_callback(self.seeder_state_callback)
assert self.seeder_setup_complete.wait(30)
def teardown_seeder(self):
self.session.remove_download(self.download)
def seeder_state_callback(self, ds):
if ds.get_status() == DLSTATUS_SEEDING:
self.seeder_setup_complete.set()
d = ds.get_download()
print >> sys.stderr, "test: seeder:", repr(d.get_def().get_name()), dlstatus_strings[ds.get_status()], ds.get_progress()
return (1.0, False)
def test_good_request(self):
conn = BTConnection("localhost", self.hisport, user_infohash=self.tdef.get_infohash())
conn.send(self.create_good_extend_handshake())
conn.read_handshake_medium_rare()
metadata_id = self.read_extend_handshake(conn)
# request metadata block 0, 2, 3, and the last
conn.send(self.create_good_extend_metadata_request(metadata_id, 0))
conn.send(self.create_good_extend_metadata_request(metadata_id, 2))
conn.send(self.create_good_extend_metadata_request(metadata_id, 3))
conn.send(self.create_good_extend_metadata_request(metadata_id, len(self.metadata_list) - 1))
self.read_extend_metadata_reply(conn, 0)
self.read_extend_metadata_reply(conn, 2)
self.read_extend_metadata_reply(conn, 3)
self.read_extend_metadata_reply(conn, len(self.metadata_list) - 1)
def test_good_flood(self):
conn = BTConnection("localhost", self.hisport, user_infohash=self.tdef.get_infohash())
conn.send(self.create_good_extend_handshake())
conn.read_handshake_medium_rare()
metadata_id = self.read_extend_handshake(conn)
for counter in xrange(len(self.metadata_list) * 2):
piece = counter % len(self.metadata_list)
conn.send(self.create_good_extend_metadata_request(metadata_id, piece))
if counter > len(self.metadata_list):
self.read_extend_metadata_reject(conn, piece)
else:
self.read_extend_metadata_reply(conn, piece)
def test_bad_request(self):
self.bad_request_and_disconnect({"msg_type": 0, "piece": len(self.metadata_list)})
self.bad_request_and_disconnect({"msg_type": 0, "piece":-1})
self.bad_request_and_disconnect({"msg_type": 0, "piece": "1"})
self.bad_request_and_disconnect({"msg_type": 0, "piece": [1, 2]})
self.bad_request_and_disconnect({"msg_type": 0, "PIECE": 1})
def bad_request_and_disconnect(self, payload):
conn = BTConnection("localhost", self.hisport, user_infohash=self.tdef.get_infohash())
conn.send(self.create_good_extend_handshake())
conn.read_handshake_medium_rare()
metadata_id = self.read_extend_handshake(conn)
conn.send(EXTEND + chr(metadata_id) + bencode(payload))
self.read_extend_metadata_close(conn)
def resume_download(self,
filename,
initialdlstatus=None,
initialdlstatus_dict={},
commit=True,
setupDelay=0):
tdef = sdef = dscfg = pstate = None
try:
pstate = self.load_download_pstate(filename)
# SWIFTPROC
if SwiftDef.is_swift_url(pstate['metainfo']):
sdef = SwiftDef.load_from_url(pstate['metainfo'])
elif 'infohash' in pstate['metainfo']:
tdef = TorrentDefNoMetainfo(pstate['metainfo']['infohash'],
pstate['metainfo']['name'])
else:
tdef = TorrentDef.load_from_dict(pstate['metainfo'])
dlconfig = pstate['dlconfig']
if isinstance(dlconfig['saveas'], tuple):
dlconfig['saveas'] = dlconfig['saveas'][-1]
if sdef and 'name' in dlconfig and isinstance(
dlconfig['name'], basestring):
sdef.set_name(dlconfig['name'])
if sdef and sdef.get_tracker().startswith("127.0.0.1:"):
current_port = int(sdef.get_tracker().split(":")[1])
if current_port != self.session.get_swift_dht_listen_port():
print >> sys.stderr, "Modified SwiftDef to new tracker port"
sdef.set_tracker("127.0.0.1:%d" %
self.session.get_swift_dht_listen_port())
dscfg = DownloadStartupConfig(dlconfig)
except:
print_exc()
# pstate is invalid or non-existing
_, file = os.path.split(filename)
infohash = binascii.unhexlify(file[:-7])
torrent = self.torrent_db.getTorrent(
infohash,
keys=['name', 'torrent_file_name', 'swift_torrent_hash'],
include_mypref=False)
torrentfile = None
if torrent:
torrent_dir = self.session.get_torrent_collecting_dir()
if torrent['swift_torrent_hash']:
sdef = SwiftDef(torrent['swift_torrent_hash'])
save_name = sdef.get_roothash_as_hex()
torrentfile = os.path.join(torrent_dir, save_name)
if torrentfile and os.path.isfile(torrentfile):
# normal torrentfile is not present, see if readable torrent is there
save_name = get_readable_torrent_name(
infohash, torrent['name'])
torrentfile = os.path.join(torrent_dir, save_name)
if torrentfile and os.path.isfile(torrentfile):
tdef = TorrentDef.load(torrentfile)
defaultDLConfig = DefaultDownloadStartupConfig.getInstance()
dscfg = defaultDLConfig.copy()
if self.mypref_db != None:
preferences = self.mypref_db.getMyPrefStatsInfohash(
infohash)
if preferences:
if os.path.isdir(
preferences[2]) or preferences[2] == '':
dscfg.set_dest_dir(preferences[2])
if DEBUG:
print >> sys.stderr, "tlm: load_checkpoint: pstate is", dlstatus_strings[
pstate['dlstate']['status']], pstate['dlstate']['progress']
if pstate['engineresumedata'] is None:
print >> sys.stderr, "tlm: load_checkpoint: resumedata None"
else:
print >> sys.stderr, "tlm: load_checkpoint: resumedata len", len(
pstate['engineresumedata'])
if (tdef or sdef) and dscfg:
if dscfg.get_dest_dir() != '': # removed torrent ignoring
try:
if not self.download_exists((tdef or sdef).get_id()):
if tdef:
initialdlstatus = initialdlstatus_dict.get(
tdef.get_id(), initialdlstatus)
self.add(tdef,
dscfg,
pstate,
initialdlstatus,
commit=commit,
setupDelay=setupDelay)
else:
initialdlstatus = initialdlstatus_dict.get(
sdef.get_id(), initialdlstatus)
self.swift_add(sdef, dscfg, pstate,
initialdlstatus)
else:
print >> sys.stderr, "tlm: not resuming checkpoint because download has already been added"
except Exception as e:
self.rawserver_nonfatalerrorfunc(e)
else:
print >> sys.stderr, "tlm: removing checkpoint", filename, "destdir is", dscfg.get_dest_dir(
)
os.remove(filename)
else:
print >> sys.stderr, "tlm: could not resume checkpoint", filename, tdef, dscfg
class TestMetadataFakePeer(TestAsServer, MagnetHelpers):
"""
Once we are downloading a torrent, our client should respond to
the ut_metadata extention message. This allows other clients to
obtain the info part of the metadata from us.
"""
def setUp(self):
TestAsServer.setUp(self)
# the metadata that we want to transfer
self.tdef = TorrentDef()
self.tdef.add_content(os.path.join(TESTS_API_DIR, "file.wmv"))
self.tdef.set_tracker("http://fake.net/announce")
# we use a small piece length to obtain multiple pieces
self.tdef.set_piece_length(1)
self.tdef.finalize()
self.setup_seeder()
MagnetHelpers.__init__(self, self.tdef)
def setUpPreSession(self):
TestAsServer.setUpPreSession(self)
self.config.set_libtorrent(True)
self.config2 = self.config.copy()
self.config2.set_state_dir(self.getStateDir(2))
def tearDown(self):
self.teardown_seeder()
TestAsServer.tearDown(self)
def setup_seeder(self):
self.seeder_setup_complete = threading.Event()
self.dscfg = DownloadStartupConfig()
self.dscfg.set_dest_dir(TESTS_API_DIR)
self.download = self.session.start_download(self.tdef, self.dscfg)
self.download.set_state_callback(self.seeder_state_callback)
assert self.seeder_setup_complete.wait(30)
def teardown_seeder(self):
self.session.remove_download(self.download)
def seeder_state_callback(self, ds):
if ds.get_status() == DLSTATUS_SEEDING:
self.seeder_setup_complete.set()
d = ds.get_download()
self._logger.debug("seeder: %s %s %s", repr(d.get_def().get_name()),
dlstatus_strings[ds.get_status()],
ds.get_progress())
return 1.0, False
def test_good_request(self):
conn = BTConnection("localhost",
self.session.get_listen_port(),
user_infohash=self.tdef.get_infohash())
conn.send(self.create_good_extend_handshake())
conn.read_handshake_medium_rare()
metadata_id = self.read_extend_handshake(conn)
# request metadata block 0, 2, 3, and the last
conn.send(self.create_good_extend_metadata_request(metadata_id, 0))
conn.send(self.create_good_extend_metadata_request(metadata_id, 2))
conn.send(self.create_good_extend_metadata_request(metadata_id, 3))
conn.send(
self.create_good_extend_metadata_request(
metadata_id,
len(self.metadata_list) - 1))
self.read_extend_metadata_reply(conn, 0)
self.read_extend_metadata_reply(conn, 2)
self.read_extend_metadata_reply(conn, 3)
self.read_extend_metadata_reply(conn, len(self.metadata_list) - 1)
def test_good_flood(self):
conn = BTConnection("localhost",
self.session.get_listen_port(),
user_infohash=self.tdef.get_infohash())
conn.send(self.create_good_extend_handshake())
conn.read_handshake_medium_rare()
metadata_id = self.read_extend_handshake(conn)
for counter in xrange(len(self.metadata_list) * 2):
piece = counter % len(self.metadata_list)
conn.send(
self.create_good_extend_metadata_request(metadata_id, piece))
if counter > len(self.metadata_list):
self.read_extend_metadata_reject(conn, piece)
else:
self.read_extend_metadata_reply(conn, piece)
def test_bad_request(self):
self.bad_request_and_disconnect({
"msg_type": 0,
"piece": len(self.metadata_list)
})
self.bad_request_and_disconnect({"msg_type": 0, "piece": -1})
self.bad_request_and_disconnect({"msg_type": 0, "piece": "1"})
self.bad_request_and_disconnect({"msg_type": 0, "piece": [1, 2]})
self.bad_request_and_disconnect({"msg_type": 0, "PIECE": 1})
def bad_request_and_disconnect(self, payload):
conn = BTConnection("localhost",
self.session.get_listen_port(),
user_infohash=self.tdef.get_infohash())
conn.send(self.create_good_extend_handshake())
conn.read_handshake_medium_rare()
metadata_id = self.read_extend_handshake(conn)
conn.send(EXTEND + chr(metadata_id) + bencode(payload))
self.read_extend_metadata_close(conn)
def resume_download(self, filename, initialdlstatus=None, initialdlstatus_dict={}, commit=True, setupDelay=0):
tdef = sdef = dscfg = pstate = None
try:
pstate = self.load_download_pstate(filename)
# SWIFTPROC
if SwiftDef.is_swift_url(pstate['metainfo']):
sdef = SwiftDef.load_from_url(pstate['metainfo'])
elif 'infohash' in pstate['metainfo']:
tdef = TorrentDefNoMetainfo(pstate['metainfo']['infohash'], pstate['metainfo']['name'])
else:
tdef = TorrentDef.load_from_dict(pstate['metainfo'])
dlconfig = pstate['dlconfig']
if isinstance(dlconfig['saveas'], tuple):
dlconfig['saveas'] = dlconfig['saveas'][-1]
if sdef and 'name' in dlconfig and isinstance(dlconfig['name'], basestring):
sdef.set_name(dlconfig['name'])
if sdef and sdef.get_tracker().startswith("127.0.0.1:"):
current_port = int(sdef.get_tracker().split(":")[1])
if current_port != self.session.get_swift_dht_listen_port():
print >> sys.stderr, "Modified SwiftDef to new tracker port"
sdef.set_tracker("127.0.0.1:%d" % self.session.get_swift_dht_listen_port())
dscfg = DownloadStartupConfig(dlconfig)
except:
print_exc()
# pstate is invalid or non-existing
_, file = os.path.split(filename)
infohash = binascii.unhexlify(file[:-7])
torrent = self.torrent_db.getTorrent(infohash, keys=['name', 'torrent_file_name', 'swift_torrent_hash'], include_mypref=False)
torrentfile = None
if torrent:
torrent_dir = self.session.get_torrent_collecting_dir()
if torrent['swift_torrent_hash']:
sdef = SwiftDef(torrent['swift_torrent_hash'])
save_name = sdef.get_roothash_as_hex()
torrentfile = os.path.join(torrent_dir, save_name)
if torrentfile and os.path.isfile(torrentfile):
# normal torrentfile is not present, see if readable torrent is there
save_name = get_readable_torrent_name(infohash, torrent['name'])
torrentfile = os.path.join(torrent_dir, save_name)
if torrentfile and os.path.isfile(torrentfile):
tdef = TorrentDef.load(torrentfile)
defaultDLConfig = DefaultDownloadStartupConfig.getInstance()
dscfg = defaultDLConfig.copy()
if self.mypref_db != None:
preferences = self.mypref_db.getMyPrefStatsInfohash(infohash)
if preferences:
if os.path.isdir(preferences[2]) or preferences[2] == '':
dscfg.set_dest_dir(preferences[2])
if DEBUG:
print >> sys.stderr, "tlm: load_checkpoint: pstate is", dlstatus_strings[pstate['dlstate']['status']], pstate['dlstate']['progress']
if pstate['engineresumedata'] is None:
print >> sys.stderr, "tlm: load_checkpoint: resumedata None"
else:
print >> sys.stderr, "tlm: load_checkpoint: resumedata len", len(pstate['engineresumedata'])
if (tdef or sdef) and dscfg:
if dscfg.get_dest_dir() != '': # removed torrent ignoring
try:
if not self.download_exists((tdef or sdef).get_id()):
if tdef:
initialdlstatus = initialdlstatus_dict.get(tdef.get_id(), initialdlstatus)
self.add(tdef, dscfg, pstate, initialdlstatus, commit=commit, setupDelay=setupDelay)
else:
initialdlstatus = initialdlstatus_dict.get(sdef.get_id(), initialdlstatus)
self.swift_add(sdef, dscfg, pstate, initialdlstatus)
else:
print >> sys.stderr, "tlm: not resuming checkpoint because download has already been added"
except Exception as e:
self.rawserver_nonfatalerrorfunc(e)
else:
print >> sys.stderr, "tlm: removing checkpoint", filename, "destdir is", dscfg.get_dest_dir()
os.remove(filename)
else:
print >> sys.stderr, "tlm: could not resume checkpoint", filename, tdef, dscfg
