def subtest_download(self):
""" Now download the file via another Session """
self.config2 = self.config.copy() # not really necess
self.config2.set_state_dir(self.getStateDir(2))
self.config2.set_listen_port(self.mylistenport)
self.session2 = Session(self.config2, ignore_singleton=True)
# Allow session2 to start
print >> sys.stderr, "test: downloader: Sleeping 3 secs to let Session2 start"
time.sleep(3)
tdef2 = TorrentDef.load(self.torrentfn)
dscfg2 = DownloadStartupConfig()
dscfg2.set_dest_dir(self.getDestDir(2))
dscfg2.set_video_event_callback(self.downloader_vod_ready_callback)
d = self.session2.start_download(tdef2, dscfg2)
d.set_state_callback(self.downloader_state_callback)
time.sleep(40)
# To test if BITFIELD is indeed wrapping around.
self.subtest_connect2downloader()
time.sleep(80)
class TestAsServer(unittest.TestCase):
"""
Parent class for testing the server-side of Tribler
"""
def setUp(self):
""" unittest test setup code """
self.setUpPreSession()
self.session = Session(self.config)
self.hisport = self.session.get_listen_port()
self.setUpPostSession()
def setUpPreSession(self):
""" Should set self.config_path and self.config """
self.config_path = tempfile.mkdtemp()
self.config = SessionStartupConfig()
self.config.set_state_dir(self.config_path)
self.config.set_listen_port(random.randint(10000, 60000))
self.config.set_buddycast(False)
self.config.set_start_recommender(False)
self.config.set_torrent_checking(False)
self.config.set_superpeer(False)
self.config.set_dialback(False)
self.config.set_social_networking(False)
self.config.set_remote_query(False)
self.config.set_internal_tracker(False)
self.config.set_bartercast(False)
self.config.set_multicast_local_peer_discovery(False)
self.config.set_dispersy(False)
# Assume all test scripts are run from Tribler/Test
self.config.set_install_dir(os.path.abspath(os.path.join('..','..')))
self.my_keypair = EC.gen_params(EC.NID_sect233k1)
self.my_keypair.gen_key()
def setUpPostSession(self):
""" Should set self.his_keypair """
keypair_filename = os.path.join(self.config_path,'ec.pem')
self.his_keypair = EC.load_key(keypair_filename)
def tearDown(self):
""" unittest test tear down code """
if self.session is not None:
self.session.shutdown()
print >>sys.stderr,"test_as_server: sleeping after session shutdown"
time.sleep(2)
try:
shutil.rmtree(self.config_path)
except:
# Not fatal if something goes wrong here, and Win32 often gives
# spurious Permission Denied errors.
print_exc()
class TestAsServer(unittest.TestCase):
"""
Parent class for testing the server-side of Tribler
"""
def setUp(self):
""" unittest test setup code """
self.setUpPreSession()
self.session = Session(self.config)
self.hisport = self.session.get_listen_port()
self.setUpPostSession()
def setUpPreSession(self):
""" Should set self.config_path and self.config """
self.config_path = tempfile.mkdtemp()
self.config = SessionStartupConfig()
self.config.set_state_dir(self.config_path)
self.config.set_listen_port(random.randint(10000, 60000))
self.config.set_buddycast(False)
self.config.set_start_recommender(False)
self.config.set_torrent_checking(False)
self.config.set_superpeer(False)
self.config.set_dialback(False)
self.config.set_social_networking(False)
self.config.set_remote_query(False)
self.config.set_internal_tracker(False)
self.config.set_bartercast(False)
self.config.set_multicast_local_peer_discovery(False)
self.config.set_dispersy(False)
# Assume all test scripts are run from Tribler/Test
self.config.set_install_dir(os.path.abspath(os.path.join('..', '..')))
self.my_keypair = EC.gen_params(EC.NID_sect233k1)
self.my_keypair.gen_key()
def setUpPostSession(self):
""" Should set self.his_keypair """
keypair_filename = os.path.join(self.config_path, 'ec.pem')
self.his_keypair = EC.load_key(keypair_filename)
def tearDown(self):
""" unittest test tear down code """
if self.session is not None:
self.session.shutdown()
print >> sys.stderr, "test_as_server: sleeping after session shutdown"
time.sleep(2)
try:
shutil.rmtree(self.config_path)
except:
# Not fatal if something goes wrong here, and Win32 often gives
# spurious Permission Denied errors.
print_exc()
def subtest_download(self):
""" Now download the file via another Session """
self.session2 = Session(self.config2, ignore_singleton=True)
self.session2.start()
time.sleep(5)
tdef2 = TorrentDef.load(self.torrentfn)
d = self.session2.start_download(tdef2, self.dscfg2)
d.set_state_callback(self.downloader_state_callback)
time.sleep(5)
d.add_peer(("127.0.0.1", self.hisport))
assert self.downloading_event.wait(60)
def subtest_download(self):
""" Now download the file via another Session """
self.config2 = self.config.copy() # not really necess
self.config2.set_state_dir(self.getStateDir(2))
self.config2.set_listen_port(self.mylistenport)
self.session2 = Session(self.config2, ignore_singleton=True)
# Allow session2 to start
print >> sys.stderr, "test: downloader: Sleeping 3 secs to let Session2 start"
time.sleep(3)
tdef2 = TorrentDef.load(self.torrentfn)
dscfg2 = DownloadStartupConfig()
dscfg2.set_dest_dir(self.getDestDir(2))
dscfg2.set_video_event_callback(self.downloader_vod_ready_callback)
d = self.session2.start_download(tdef2, dscfg2)
d.set_state_callback(self.downloader_state_callback)
time.sleep(40)
# To test if BITFIELD is indeed wrapping around.
self.subtest_connect2downloader()
time.sleep(80)
def subtest_download(self):
""" Now download the file via another Session """
self.config2 = self.config.copy() # not really necess
self.config_path2 = tempfile.mkdtemp()
self.config2.set_state_dir(self.config_path2)
self.config2.set_listen_port(self.mylistenport)
self.session2 = Session(self.config2, ignore_singleton=True)
# Allow session2 to start
print >> sys.stderr, "test: Sleeping 3 secs to let Session2 start"
time.sleep(3)
tdef2 = TorrentDef.load(self.torrentfn)
dscfg2 = DownloadStartupConfig()
dscfg2.set_dest_dir(self.config_path2)
d = self.session2.start_download(tdef2, dscfg2)
d.set_state_callback(self.downloader_state_callback)
time.sleep(20)
def setUp(self):
self.setUpCleanup()
self.setUpPreSession()
self.quitting = False
self.session = Session(self.config)
self.session.start()
self.hisport = self.session.get_listen_port()
while not self.session.lm.initComplete:
time.sleep(1)
self.annotate(self._testMethodName, start=True)
def subtest_download(self):
""" Now download the file via another Session """
self.session2 = Session(self.config2, ignore_singleton=True)
self.session2.start()
time.sleep(5)
tdef2 = TorrentDef.load(self.torrentfn)
d = self.session2.start_download(tdef2, self.dscfg2)
d.set_state_callback(self.downloader_state_callback)
time.sleep(5)
d.add_peer(("127.0.0.1", self.hisport))
assert self.downloading_event.wait(60)
def subtest_download(self):
""" Now download the file via another Session """
self.config2 = self.config.copy() # not really necess
self.config_path2 = tempfile.mkdtemp()
self.config2.set_state_dir(self.config_path2)
self.config2.set_listen_port(self.mylistenport)
self.session2 = Session(self.config2,ignore_singleton=True)
# Allow session2 to start
print >>sys.stderr,"test: Sleeping 3 secs to let Session2 start"
time.sleep(3)
tdef2 = TorrentDef.load(self.torrentfn)
dscfg2 = DownloadStartupConfig()
dscfg2.set_dest_dir(self.config_path2)
d = self.session2.start_download(tdef2,dscfg2)
d.set_state_callback(self.downloader_state_callback)
time.sleep(20)
class TestSeeding(TestAsServer):
"""
Testing seeding via new tribler API:
"""
def setUp(self):
""" override TestAsServer """
TestAsServer.setUp(self)
print >> sys.stderr, "test: Giving Session time to startup"
time.sleep(5)
print >> sys.stderr, "test: Session should have started up"
def setUpPreSession(self):
""" override TestAsServer """
TestAsServer.setUpPreSession(self)
self.config.set_overlay(False)
self.config.set_internal_tracker(True)
self.mylistenport = 4810
def setUpPostSession(self):
pass
@skip("We need to migrate this to swift")
def test_live_torrent(self):
"""
I want to start a Tribler client once and then connect to
it many times. So there must be only one test method
to prevent setUp() from creating a new client every time.
The code is constructed so unittest will show the name of the
(sub)test where the error occured in the traceback it prints.
"""
self.setup_seeder()
time.sleep(10)
# self.subtest_connect2downloader()
self.subtest_download()
def setup_seeder(self):
self.tdef = TorrentDef()
# semi automatic
self.bitrate = 6144
piecesize = 32768
self.npieces = 12
playtime = ((self.npieces - 1) * piecesize) / self.bitrate
playtimestr = '0:' + str(playtime) # DON'T WORK IF > 60 secs
self.tdef.create_live("Test Live", self.bitrate, playtimestr)
self.tdef.set_tracker(self.session.get_internal_tracker_url())
self.tdef.set_piece_length(piecesize)
self.tdef.finalize()
print >> sys.stderr, "test: setup_seeder: name is", self.tdef.metainfo[
'info']['name']
self.dscfg = DownloadStartupConfig()
self.dscfg.set_dest_dir(self.getDestDir())
# File source
source = InfiniteSource(piecesize)
self.dscfg.set_video_ratelimit(self.bitrate)
self.dscfg.set_video_source(source)
d = self.session.start_download(self.tdef, self.dscfg)
d.set_state_callback(self.seeder_state_callback)
def seeder_state_callback(self, ds):
d = ds.get_download()
print >> sys.stderr, "test: seeder:", dlstatus_strings[
ds.get_status()], ds.get_progress()
return (1.0, False)
def subtest_download(self):
""" Now download the file via another Session """
self.config2 = self.config.copy() # not really necess
self.config2.set_state_dir(self.getStateDir(2))
self.config2.set_listen_port(self.mylistenport)
self.session2 = Session(self.config2, ignore_singleton=True)
# Allow session2 to start
print >> sys.stderr, "test: downloader: Sleeping 3 secs to let Session2 start"
time.sleep(3)
tdef2 = TorrentDef.load(self.torrentfn)
dscfg2 = DownloadStartupConfig()
dscfg2.set_dest_dir(self.getDestDir(2))
dscfg2.set_video_event_callback(self.downloader_vod_ready_callback)
d = self.session2.start_download(tdef2, dscfg2)
d.set_state_callback(self.downloader_state_callback)
time.sleep(40)
# To test if BITFIELD is indeed wrapping around.
self.subtest_connect2downloader()
time.sleep(80)
def downloader_state_callback(self, ds):
d = ds.get_download()
print >> sys.stderr, "test: download:", dlstatus_strings[
ds.get_status()], ds.get_progress()
return (1.0, False)
def downloader_vod_ready_callback(self, d, event, params):
""" Called by SessionThread """
if event == VODEVENT_START:
stream = params["stream"]
while True:
# Fake video playback
data = stream.read(self.bitrate)
if len(data) == 0:
break
time.sleep(1)
def subtest_connect2downloader(self):
print >> sys.stderr, "test: verifier: Connecting to seeder to check bitfield"
infohash = self.tdef.get_infohash()
s = BTConnection('localhost',
self.mylistenport,
user_infohash=infohash)
s.read_handshake_medium_rare()
try:
s.s.settimeout(10.0)
resp = s.recv()
self.assert_(len(resp) > 0)
print >> sys.stderr, "test: verifier: Got message", getMessageName(
resp[0])
self.assert_(resp[0] == EXTEND)
resp = s.recv()
self.assert_(len(resp) > 0)
print >> sys.stderr, "test: verifier: Got 2nd message", getMessageName(
resp[0])
self.assert_(resp[0] == BITFIELD)
b = Bitfield(self.npieces, resp[1:])
print >> sys.stderr, "test: verifier: Bitfield is", repr(
b.toboollist())
b2 = Bitfield(self.npieces)
b2[0] = True
msg = BITFIELD + b2.tostring()
s.send(msg)
time.sleep(5)
except socket.timeout:
print >> sys.stderr, "test: verifier: Timeout, peer didn't reply"
self.assert_(False)
s.close()
import sys
import time
from Tribler.Core.Session import *
from Tribler.Core.TorrentDef import *
def states_callback(dslist):
for ds in dslist:
d = ds.get_download()
print >>sys.stderr,"bctest 1: Stats",`d.get_def().get_name()`,dlstatus_strings[ds.get_status()],ds.get_progress(),"%",ds.get_error(),"up",ds.get_current_speed(UPLOAD),"down",ds.get_current_speed(DOWNLOAD),currentThread().getName()
return (10.0,False)
if __name__ == "__main__":
sscfg = SessionStartupConfig()
sscfg.set_state_dir('Session1')
sscfg.set_overlay(1)
sscfg.set_overlay_log('test.log')
sscfg.set_superpeer_file('superpeer1.txt')
sscfg.set_listen_port(7011)
s = Session(sscfg)
s.set_download_states_callback(states_callback,getpeerlist=False)
tdef = TorrentDef.load('bla.torrent')
d = s.start_download(tdef)
time.sleep(3600*24*7)
class TestSeeding(TestAsServer):
"""
Testing seeding via new tribler API:
"""
def setUp(self):
""" override TestAsServer """
TestAsServer.setUp(self)
print >> sys.stderr, "test: Giving Session time to startup"
time.sleep(5)
print >> sys.stderr, "test: Session should have started up"
def setUpPreSession(self):
""" override TestAsServer """
TestAsServer.setUpPreSession(self)
self.config.set_overlay(False)
self.config.set_internal_tracker(True)
self.mylistenport = 4810
def setUpPostSession(self):
pass
@skip("We need to migrate this to swift")
def test_live_torrent(self):
"""
I want to start a Tribler client once and then connect to
it many times. So there must be only one test method
to prevent setUp() from creating a new client every time.
The code is constructed so unittest will show the name of the
(sub)test where the error occured in the traceback it prints.
"""
self.setup_seeder()
time.sleep(10)
# self.subtest_connect2downloader()
self.subtest_download()
def setup_seeder(self):
self.tdef = TorrentDef()
# semi automatic
self.bitrate = 6144
piecesize = 32768
self.npieces = 12
playtime = ((self.npieces - 1) * piecesize) / self.bitrate
playtimestr = '0:' + str(playtime) # DON'T WORK IF > 60 secs
self.tdef.create_live("Test Live", self.bitrate, playtimestr)
self.tdef.set_tracker(self.session.get_internal_tracker_url())
self.tdef.set_piece_length(piecesize)
self.tdef.finalize()
print >> sys.stderr, "test: setup_seeder: name is", self.tdef.metainfo['info']['name']
self.dscfg = DownloadStartupConfig()
self.dscfg.set_dest_dir(self.getDestDir())
# File source
source = InfiniteSource(piecesize)
self.dscfg.set_video_ratelimit(self.bitrate)
self.dscfg.set_video_source(source)
d = self.session.start_download(self.tdef, self.dscfg)
d.set_state_callback(self.seeder_state_callback)
def seeder_state_callback(self, ds):
d = ds.get_download()
print >> sys.stderr, "test: seeder:", dlstatus_strings[ds.get_status()], ds.get_progress()
return (1.0, False)
def subtest_download(self):
""" Now download the file via another Session """
self.config2 = self.config.copy() # not really necess
self.config2.set_state_dir(self.getStateDir(2))
self.config2.set_listen_port(self.mylistenport)
self.session2 = Session(self.config2, ignore_singleton=True)
# Allow session2 to start
print >> sys.stderr, "test: downloader: Sleeping 3 secs to let Session2 start"
time.sleep(3)
tdef2 = TorrentDef.load(self.torrentfn)
dscfg2 = DownloadStartupConfig()
dscfg2.set_dest_dir(self.getDestDir(2))
dscfg2.set_video_event_callback(self.downloader_vod_ready_callback)
d = self.session2.start_download(tdef2, dscfg2)
d.set_state_callback(self.downloader_state_callback)
time.sleep(40)
# To test if BITFIELD is indeed wrapping around.
self.subtest_connect2downloader()
time.sleep(80)
def downloader_state_callback(self, ds):
d = ds.get_download()
print >> sys.stderr, "test: download:", dlstatus_strings[ds.get_status()], ds.get_progress()
return (1.0, False)
def downloader_vod_ready_callback(self, d, event, params):
""" Called by SessionThread """
if event == VODEVENT_START:
stream = params["stream"]
while True:
# Fake video playback
data = stream.read(self.bitrate)
if len(data) == 0:
break
time.sleep(1)
def subtest_connect2downloader(self):
print >> sys.stderr, "test: verifier: Connecting to seeder to check bitfield"
infohash = self.tdef.get_infohash()
s = BTConnection('localhost', self.mylistenport, user_infohash=infohash)
s.read_handshake_medium_rare()
try:
s.s.settimeout(10.0)
resp = s.recv()
self.assert_(len(resp) > 0)
print >> sys.stderr, "test: verifier: Got message", getMessageName(resp[0])
self.assert_(resp[0] == EXTEND)
resp = s.recv()
self.assert_(len(resp) > 0)
print >> sys.stderr, "test: verifier: Got 2nd message", getMessageName(resp[0])
self.assert_(resp[0] == BITFIELD)
b = Bitfield(self.npieces, resp[1:])
print >> sys.stderr, "test: verifier: Bitfield is", repr(b.toboollist())
b2 = Bitfield(self.npieces)
b2[0] = True
msg = BITFIELD + b2.tostring()
s.send(msg)
time.sleep(5)
except socket.timeout:
print >> sys.stderr, "test: verifier: Timeout, peer didn't reply"
self.assert_(False)
s.close()
def setUp(self):
""" unittest test setup code """
self.setUpPreSession()
self.session = Session(self.config)
self.hisport = self.session.get_listen_port()
self.setUpPostSession()
class TestSeeding(TestAsServer):
"""
Testing seeding via new tribler API:
"""
def setUp(self):
""" override TestAsServer """
TestAsServer.setUp(self)
self.session2 = None
self.seeding_event = threading.Event()
self.downloading_event = threading.Event()
def setUpPreSession(self):
""" override TestAsServer """
TestAsServer.setUpPreSession(self)
self.config.set_libtorrent(True)
self.config2 = self.config.copy() # not really necess
self.config2.set_state_dir(self.getStateDir(2))
self.config2.set_listen_port(4810)
self.dscfg2 = DownloadStartupConfig()
self.dscfg2.set_dest_dir(self.getDestDir(2))
def setUpPostSession(self):
pass
def tearDown(self):
if self.session2:
self._shutdown_session(self.session2)
time.sleep(10)
TestAsServer.tearDown(self)
def setup_seeder(self, merkle, filename='file.wmv'):
self.tdef = TorrentDef()
self.sourcefn = os.path.join(BASE_DIR, "API", filename)
self.tdef.add_content(self.sourcefn)
self.tdef.set_tracker("http://fake.net/announce")
self.tdef.set_create_merkle_torrent(merkle)
self.tdef.finalize()
self.torrentfn = os.path.join(self.session.get_state_dir(), "gen.torrent")
self.tdef.save(self.torrentfn)
print >> sys.stderr, "test: setup_seeder: name is", self.tdef.metainfo['info']['name']
self.dscfg = DownloadStartupConfig()
self.dscfg.set_dest_dir(os.path.join(BASE_DIR, "API")) # basedir of the file we are seeding
d = self.session.start_download(self.tdef, self.dscfg)
d.set_state_callback(self.seeder_state_callback)
print >> sys.stderr, "test: setup_seeder: starting to wait for download to reach seeding state"
assert self.seeding_event.wait(60)
def seeder_state_callback(self, ds):
d = ds.get_download()
print >> sys.stderr, "test: seeder:", repr(d.get_def().get_name()), dlstatus_strings[ds.get_status()], ds.get_progress()
if ds.get_status() == DLSTATUS_SEEDING:
self.seeding_event.set()
return (1.0, False)
def test_normal_torrent(self):
self.setup_seeder(False)
self.subtest_is_seeding()
self.subtest_download()
# def test_merkle_torrent(self):
# self.setup_seeder(True)
# self.subtest_is_seeding()
# self.subtest_download()
def subtest_is_seeding(self):
infohash = self.tdef.get_infohash()
s = BTConnection('localhost', self.hisport, user_infohash=infohash)
s.read_handshake_medium_rare()
s.send(CHOKE)
try:
s.s.settimeout(10.0)
resp = s.recv()
self.assert_(len(resp) > 0)
self.assert_(resp[0] == EXTEND)
except socket.timeout:
print >> sys.stderr, "test: Timeout, peer didn't reply"
self.assert_(False)
s.close()
def subtest_download(self):
""" Now download the file via another Session """
self.session2 = Session(self.config2, ignore_singleton=True)
self.session2.start()
time.sleep(5)
tdef2 = TorrentDef.load(self.torrentfn)
d = self.session2.start_download(tdef2, self.dscfg2)
d.set_state_callback(self.downloader_state_callback)
time.sleep(5)
d.add_peer(("127.0.0.1", self.hisport))
assert self.downloading_event.wait(60)
def downloader_state_callback(self, ds):
d = ds.get_download()
print >> sys.stderr, "test: download:", repr(d.get_def().get_name()), dlstatus_strings[ds.get_status()], ds.get_progress()
if ds.get_status() == DLSTATUS_SEEDING:
# File is in
destfn = os.path.join(self.getDestDir(2), "file.wmv")
f = open(destfn, "rb")
realdata = f.read()
f.close()
f = open(self.sourcefn, "rb")
expdata = f.read()
f.close()
self.assert_(realdata == expdata)
self.downloading_event.set()
return (1.0, True)
return (1.0, False)
class TestSeeding(TestAsServer):
"""
Testing seeding via new tribler API:
"""
def setUp(self):
""" override TestAsServer """
TestAsServer.setUp(self)
self.session2 = None
self.seeding_event = threading.Event()
self.downloading_event = threading.Event()
def setUpPreSession(self):
""" override TestAsServer """
TestAsServer.setUpPreSession(self)
self.config.set_libtorrent(True)
self.config2 = self.config.copy() # not really necess
self.config2.set_state_dir(self.getStateDir(2))
self.config2.set_listen_port(4810)
self.dscfg2 = DownloadStartupConfig()
self.dscfg2.set_dest_dir(self.getDestDir(2))
def setUpPostSession(self):
pass
def tearDown(self):
if self.session2:
self._shutdown_session(self.session2)
time.sleep(10)
TestAsServer.tearDown(self)
def setup_seeder(self, merkle, filename='file.wmv'):
self.tdef = TorrentDef()
self.sourcefn = os.path.join(BASE_DIR, "API", filename)
self.tdef.add_content(self.sourcefn)
self.tdef.set_tracker("http://fake.net/announce")
self.tdef.set_create_merkle_torrent(merkle)
self.tdef.finalize()
self.torrentfn = os.path.join(self.session.get_state_dir(),
"gen.torrent")
self.tdef.save(self.torrentfn)
print >> sys.stderr, "test: setup_seeder: name is", self.tdef.metainfo[
'info']['name']
self.dscfg = DownloadStartupConfig()
self.dscfg.set_dest_dir(os.path.join(
BASE_DIR, "API")) # basedir of the file we are seeding
d = self.session.start_download(self.tdef, self.dscfg)
d.set_state_callback(self.seeder_state_callback)
print >> sys.stderr, "test: setup_seeder: starting to wait for download to reach seeding state"
assert self.seeding_event.wait(60)
def seeder_state_callback(self, ds):
d = ds.get_download()
print >> sys.stderr, "test: seeder:", repr(
d.get_def().get_name()), dlstatus_strings[
ds.get_status()], ds.get_progress()
if ds.get_status() == DLSTATUS_SEEDING:
self.seeding_event.set()
return (1.0, False)
def test_normal_torrent(self):
self.setup_seeder(False)
self.subtest_is_seeding()
self.subtest_download()
# def test_merkle_torrent(self):
# self.setup_seeder(True)
# self.subtest_is_seeding()
# self.subtest_download()
def subtest_is_seeding(self):
infohash = self.tdef.get_infohash()
s = BTConnection('localhost', self.hisport, user_infohash=infohash)
s.read_handshake_medium_rare()
s.send(CHOKE)
try:
s.s.settimeout(10.0)
resp = s.recv()
self.assert_(len(resp) > 0)
self.assert_(resp[0] == EXTEND)
except socket.timeout:
print >> sys.stderr, "test: Timeout, peer didn't reply"
self.assert_(False)
s.close()
def subtest_download(self):
""" Now download the file via another Session """
self.session2 = Session(self.config2, ignore_singleton=True)
self.session2.start()
time.sleep(5)
tdef2 = TorrentDef.load(self.torrentfn)
d = self.session2.start_download(tdef2, self.dscfg2)
d.set_state_callback(self.downloader_state_callback)
time.sleep(5)
d.add_peer(("127.0.0.1", self.hisport))
assert self.downloading_event.wait(60)
def downloader_state_callback(self, ds):
d = ds.get_download()
print >> sys.stderr, "test: download:", repr(
d.get_def().get_name()), dlstatus_strings[
ds.get_status()], ds.get_progress()
if ds.get_status() == DLSTATUS_SEEDING:
# File is in
destfn = os.path.join(self.getDestDir(2), "file.wmv")
f = open(destfn, "rb")
realdata = f.read()
f.close()
f = open(self.sourcefn, "rb")
expdata = f.read()
f.close()
self.assert_(realdata == expdata)
self.downloading_event.set()
return (1.0, True)
return (1.0, False)
class TestSeeding(TestAsServer):
"""
Testing seeding via new tribler API:
"""
def setUp(self):
""" override TestAsServer """
TestAsServer.setUp(self)
print >>sys.stderr,"test: Giving Session time to startup"
time.sleep(5)
print >>sys.stderr,"test: Session should have started up"
def setUpPreSession(self):
""" override TestAsServer """
TestAsServer.setUpPreSession(self)
self.config.set_megacache(False)
self.config.set_internal_tracker(True)
#self.config.set_tracker_nat_check(0)
self.mylistenport = 4810
def setUpPostSession(self):
pass
def setup_seeder(self,merkle):
self.tdef = TorrentDef()
self.sourcefn = os.path.join(os.getcwd(),"file.wmv")
self.tdef.add_content(self.sourcefn)
self.tdef.set_create_merkle_torrent(merkle)
self.tdef.set_tracker(self.session.get_internal_tracker_url())
self.tdef.finalize()
self.torrentfn = os.path.join(self.session.get_state_dir(),"gen.torrent")
self.tdef.save(self.torrentfn)
print >>sys.stderr,"test: setup_seeder: name is",self.tdef.metainfo['info']['name']
self.dscfg = DownloadStartupConfig()
self.dscfg.set_dest_dir(os.getcwd())
d = self.session.start_download(self.tdef,self.dscfg)
d.set_state_callback(self.seeder_state_callback)
print >>sys.stderr,"test: Giving Download time to startup"
time.sleep(5)
def seeder_state_callback(self,ds):
d = ds.get_download()
print >>sys.stderr,"test: seeder:",`d.get_def().get_name()`,dlstatus_strings[ds.get_status()],ds.get_progress()
return (1.0,False)
def test_normal_torrent(self):
"""
I want to start a Tribler client once and then connect to
it many times. So there must be only one test method
to prevent setUp() from creating a new client every time.
The code is constructed so unittest will show the name of the
(sub)test where the error occured in the traceback it prints.
"""
self.setup_seeder(False)
self.subtest_is_seeding()
self.subtest_download()
def test_merkle_torrent(self):
self.setup_seeder(True)
self.subtest_is_seeding()
self.subtest_download()
def subtest_is_seeding(self):
infohash = self.tdef.get_infohash()
print >> sys.stderr,"test: Connect to see if seeding this infohash"
myid = '*' * 20
s = BTConnection('localhost',self.hisport,myid=myid,user_infohash=infohash)
s.read_handshake_medium_rare()
s.send(CHOKE)
try:
s.s.settimeout(10.0)
print >> sys.stderr,"test: Receive to see if seeding this infohash"
resp = s.recv()
self.assert_(len(resp) > 0)
self.assert_(resp[0] == EXTEND)
except socket.timeout:
print >> sys.stderr,"test: Timeout, peer didn't reply"
self.assert_(False)
s.close()
def subtest_download(self):
""" Now download the file via another Session """
self.config2 = self.config.copy() # not really necess
self.config_path2 = tempfile.mkdtemp()
self.config2.set_state_dir(self.config_path2)
self.config2.set_listen_port(self.mylistenport)
self.session2 = Session(self.config2,ignore_singleton=True)
# Allow session2 to start
print >>sys.stderr,"test: Sleeping 3 secs to let Session2 start"
time.sleep(3)
tdef2 = TorrentDef.load(self.torrentfn)
dscfg2 = DownloadStartupConfig()
dscfg2.set_dest_dir(self.config_path2)
d = self.session2.start_download(tdef2,dscfg2)
d.set_state_callback(self.downloader_state_callback)
time.sleep(20)
def downloader_state_callback(self,ds):
d = ds.get_download()
print >>sys.stderr,"test: download:",`d.get_def().get_name()`,dlstatus_strings[ds.get_status()],ds.get_progress()
if ds.get_status() == DLSTATUS_SEEDING:
# File is in
destfn = os.path.join(self.config_path2,"file.wmv")
f = open(destfn,"rb")
realdata = f.read()
f.close()
f = open(self.sourcefn,"rb")
expdata = f.read()
f.close()
self.assert_(realdata == expdata)
return (1.0,True)
return (1.0,False)
def setUp(self):
""" unittest test setup code """
self.setUpPreSession()
self.session = Session(self.config)
self.hisport = self.session.get_listen_port()
self.setUpPostSession()
from Tribler.Core.TorrentDef import *
def states_callback(dslist):
for ds in dslist:
d = ds.get_download()
print >> sys.stderr, "bctest 1: Stats", ` d.get_def().get_name(
) `, dlstatus_strings[ds.get_status()], ds.get_progress(
), "%", ds.get_error(), "up", ds.get_current_speed(
UPLOAD), "down", ds.get_current_speed(
DOWNLOAD), currentThread().getName()
return (10.0, False)
if __name__ == "__main__":
sscfg = SessionStartupConfig()
sscfg.set_state_dir('Session1')
sscfg.set_overlay(1)
sscfg.set_overlay_log('test.log')
sscfg.set_superpeer_file('superpeer1.txt')
sscfg.set_listen_port(7011)
s = Session(sscfg)
s.set_download_states_callback(states_callback, getpeerlist=False)
tdef = TorrentDef.load('bla.torrent')
d = s.start_download(tdef)
time.sleep(3600 * 24 * 7)
class TestSeeding(TestAsServer):
"""
Testing seeding via new tribler API:
"""
def setUp(self):
""" override TestAsServer """
TestAsServer.setUp(self)
print >> sys.stderr, "test: Giving Session time to startup"
time.sleep(5)
print >> sys.stderr, "test: Session should have started up"
def setUpPreSession(self):
""" override TestAsServer """
TestAsServer.setUpPreSession(self)
self.config.set_megacache(False)
self.config.set_internal_tracker(True)
#self.config.set_tracker_nat_check(0)
self.mylistenport = 4810
def setUpPostSession(self):
pass
def setup_seeder(self, merkle):
self.tdef = TorrentDef()
self.sourcefn = os.path.join(os.getcwd(), "file.wmv")
self.tdef.add_content(self.sourcefn)
self.tdef.set_create_merkle_torrent(merkle)
self.tdef.set_tracker(self.session.get_internal_tracker_url())
self.tdef.finalize()
self.torrentfn = os.path.join(self.session.get_state_dir(),
"gen.torrent")
self.tdef.save(self.torrentfn)
print >> sys.stderr, "test: setup_seeder: name is", self.tdef.metainfo[
'info']['name']
self.dscfg = DownloadStartupConfig()
self.dscfg.set_dest_dir(os.getcwd())
d = self.session.start_download(self.tdef, self.dscfg)
d.set_state_callback(self.seeder_state_callback)
print >> sys.stderr, "test: Giving Download time to startup"
time.sleep(5)
def seeder_state_callback(self, ds):
d = ds.get_download()
print >> sys.stderr, "test: seeder:", ` d.get_def().get_name(
) `, dlstatus_strings[ds.get_status()], ds.get_progress()
return (1.0, False)
def test_normal_torrent(self):
"""
I want to start a Tribler client once and then connect to
it many times. So there must be only one test method
to prevent setUp() from creating a new client every time.
The code is constructed so unittest will show the name of the
(sub)test where the error occured in the traceback it prints.
"""
self.setup_seeder(False)
self.subtest_is_seeding()
self.subtest_download()
def test_merkle_torrent(self):
self.setup_seeder(True)
self.subtest_is_seeding()
self.subtest_download()
def subtest_is_seeding(self):
infohash = self.tdef.get_infohash()
print >> sys.stderr, "test: Connect to see if seeding this infohash"
myid = '*' * 20
s = BTConnection('localhost',
self.hisport,
myid=myid,
user_infohash=infohash)
s.read_handshake_medium_rare()
s.send(CHOKE)
try:
s.s.settimeout(10.0)
print >> sys.stderr, "test: Receive to see if seeding this infohash"
resp = s.recv()
self.assert_(len(resp) > 0)
self.assert_(resp[0] == EXTEND)
except socket.timeout:
print >> sys.stderr, "test: Timeout, peer didn't reply"
self.assert_(False)
s.close()
def subtest_download(self):
""" Now download the file via another Session """
self.config2 = self.config.copy() # not really necess
self.config_path2 = tempfile.mkdtemp()
self.config2.set_state_dir(self.config_path2)
self.config2.set_listen_port(self.mylistenport)
self.session2 = Session(self.config2, ignore_singleton=True)
# Allow session2 to start
print >> sys.stderr, "test: Sleeping 3 secs to let Session2 start"
time.sleep(3)
tdef2 = TorrentDef.load(self.torrentfn)
dscfg2 = DownloadStartupConfig()
dscfg2.set_dest_dir(self.config_path2)
d = self.session2.start_download(tdef2, dscfg2)
d.set_state_callback(self.downloader_state_callback)
time.sleep(20)
def downloader_state_callback(self, ds):
d = ds.get_download()
print >> sys.stderr, "test: download:", ` d.get_def().get_name(
) `, dlstatus_strings[ds.get_status()], ds.get_progress()
if ds.get_status() == DLSTATUS_SEEDING:
# File is in
destfn = os.path.join(self.config_path2, "file.wmv")
f = open(destfn, "rb")
realdata = f.read()
f.close()
f = open(self.sourcefn, "rb")
expdata = f.read()
f.close()
self.assert_(realdata == expdata)
return (1.0, True)
return (1.0, False)
class TestAsServer(AbstractServer):
"""
Parent class for testing the server-side of Tribler
"""
def setUp(self):
self.setUpCleanup()
self.setUpPreSession()
self.quitting = False
self.session = Session(self.config)
self.session.start()
self.hisport = self.session.get_listen_port()
while not self.session.lm.initComplete:
time.sleep(1)
self.annotate(self._testMethodName, start=True)
def setUpPreSession(self):
""" Should set self.config_path and self.config """
self.config = SessionStartupConfig()
self.config.set_state_dir(self.getStateDir())
self.config.set_listen_port(random.randint(10000, 60000))
self.config.set_torrent_checking(False)
self.config.set_multicast_local_peer_discovery(False)
self.config.set_megacache(False)
self.config.set_dispersy(False)
self.config.set_swift_proc(False)
self.config.set_mainline_dht(False)
self.config.set_torrent_collecting(False)
self.config.set_libtorrent(False)
self.config.set_dht_torrent_collecting(False)
def tearDown(self):
self.annotate(self._testMethodName, start=False)
""" unittest test tear down code """
if self.session is not None:
self._shutdown_session(self.session)
Session.del_instance()
time.sleep(10)
gc.collect()
ts = enumerate_threads()
print >> sys.stderr, "test_as_server: Number of threads still running", len(ts)
for t in ts:
print >> sys.stderr, "test_as_server: Thread still running", t.getName(), "daemon", t.isDaemon(), "instance:", t
if SQLiteCacheDB.hasInstance():
SQLiteCacheDB.getInstance().close_all()
SQLiteCacheDB.delInstance()
self.tearDownCleanup()
def _shutdown_session(self, session):
session_shutdown_start = time.time()
waittime = 60
session.shutdown()
while not session.has_shutdown():
diff = time.time() - session_shutdown_start
assert diff < waittime, "test_as_server: took too long for Session to shutdown"
print >> sys.stderr, "test_as_server: ONEXIT Waiting for Session to shutdown, will wait for an additional %d seconds" % (waittime - diff)
time.sleep(1)
print >> sys.stderr, "test_as_server: Session is shutdown"
def assert_(self, boolean, reason=None, do_assert = True):
if not boolean:
self.quit()
assert boolean, reason
def startTest(self, callback):
self.quitting = False
callback()
def Call(self, seconds, callback):
if not self.quitting:
if seconds:
time.sleep(seconds)
callback()
def CallConditional(self, timeout, condition, callback, assertMsg=None):
t = time.time()
def DoCheck():
if not self.quitting:
if time.time() - t < timeout:
if condition():
print >> sys.stderr, "test_as_server: condition satisfied after %d seconds, calling callback" % (time.time() - t)
callback()
else:
self.Call(0.5, DoCheck)
else:
print >> sys.stderr, "test_as_server: quitting, condition was not satisfied in %d seconds (%s)" % (timeout, assertMsg or "no-assert-msg")
self.assert_(False, assertMsg if assertMsg else "Condition was not satisfied in %d seconds" % timeout, do_assert=False)
self.Call(0, DoCheck)
def quit(self):
self.quitting = True
