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 setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
self.myhash = sha(self.mypermid).digest()
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
# Calculating the infohash for proxyservice.test.torrent
self.torrentfile = os.path.join('extend_hs_dir','proxyservice.test.torrent')
# Read torrentfile to calculate the infohash
torrentfile_content = open(self.torrentfile, "rb")
# Decode all the file
metainfo = bdecode(torrentfile_content.read())
# Re-encode only the info section
self.infohash = hashlib.sha1(bencode(metainfo['info'])).digest()
# Close the torrentfile
torrentfile_content.close()
# Add us as friend, so he will accept the ASK_FOR_HELP
if False: # TEMP
friendsdb = FriendDBHandler.getInstance()
friendsdb.addFriend(self.mypermid)
else:
self.session.set_overlay_request_policy(AllowAllRequestPolicy())
self.session.set_download_states_callback(self.states_callback)
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
self.myhash = sha(self.mypermid).digest()
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
self.myhash = sha(self.mypermid).digest()
# Give Tribler some download history
print >>sys.stderr,"test: Populating MYPREFERENCES table"
self.myprefdb = self.session.open_dbhandler(NTFY_MYPREFERENCES)
data = {'destination_path':'.'}
infohashes = self.create_good_my_prefs(self,btconn.current_version)
for i in range(0,len(infohashes)):
commit = (i == len(infohashes)-1)
self.myprefdb.addMyPreference(infohashes[i], data, commit=commit)
# Give Tribler some peers
print >>sys.stderr,"test: Populating PEERS table"
self.peerdb = self.session.open_dbhandler(NTFY_PEERS)
past = int(time.time())-1000000000
peers = self.create_good_random_peers(btconn.current_version,num=200)
peers = []
for i in range(0,len(peers)):
peer = peers[i]
peer.update({'last_seen':past, 'last_connected':past})
del peer['connect_time']
peer['num_torrents'] = peer['nfiles']
del peer['nfiles']
commit = (i == len(peers)-1)
self.peerdb.addPeer(peer['permid'], peer, update_dns=True, update_connected=True, commit=commit)
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
# Calculating the infohash for proxyservice.test.torrent
self.torrentfile = os.path.join('extend_hs_dir',
'proxyservice.test.torrent')
# Read torrentfile to calculate the infohash
torrentfile_content = open(self.torrentfile, "rb")
# Decode all the file
metainfo = bdecode(torrentfile_content.read())
# Re-encode only the info section
self.infohash = hashlib.sha1(bencode(metainfo['info'])).digest()
# Close the torrentfile
torrentfile_content.close()
# Add us as friend, so he will accept the ASK_FOR_HELP
if False: # TEMP
friendsdb = FriendDBHandler.getInstance()
friendsdb.addFriend(self.mypermid)
else:
self.session.set_overlay_request_policy(AllowAllRequestPolicy())
self.session.set_download_states_callback(self.states_callback)
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
# Create URL compat torrents and save in Torrent database.
self.tdef1 = TorrentDef.load_from_url(
P2PURL_SCHEME +
'://127.2.3.42:7764/announce?SjaakCam.mpegts&k=MHowDQYJKoZIhvcNAQEBBQADaQAwZgJhAN0Khlp5ZhWC7VfLynCkKts71b8h8tZXH87PkDtJUTJaX_SS1Cddxkv63PRmKOvtAHhkTLSsWOZbSeHkOlPIq_FGg2aDLDJ05g3lQ-8mSmo05ff4SLqNUTShWO2CR2TPhQIBAw&l=HCAAAA&s=15&a=RSA&b=AAIAAA'
)
self.torrentfn1 = os.path.join(
self.session.get_torrent_collecting_dir(), "live.torrent")
self.tdef1.save(self.torrentfn1)
self.tdef2 = TorrentDef.load_from_url(
P2PURL_SCHEME +
'://127.1.0.10:6969/announce?trailer.mkv&r=TTgcifG0Ot7STCY2JL8SUOxROFo&l=AKK35A&s=15&b=AAFnGg'
)
self.torrentfn2 = os.path.join(
self.session.get_torrent_collecting_dir(), "vod.torrent")
self.tdef2.save(self.torrentfn2)
self.torrent_db = self.session.open_dbhandler(NTFY_TORRENTS)
extra_info = {'status': 'good', 'filename': self.torrentfn1}
self.torrent_db.addExternalTorrent(self.tdef1,
source='',
extra_info=extra_info)
extra_info = {'status': 'good', 'filename': self.torrentfn2}
self.torrent_db.addExternalTorrent(self.tdef2,
source='',
extra_info=extra_info)
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 setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
self.setUpMyListenSocket()
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
self.setUpMyListenSocket()
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
self.myhash = sha(self.mypermid).digest()
self.buddycast = BuddyCastFactory.getInstance(superpeer=True)
self.buddycast.olthread_register(True)
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
self.myhash = sha(self.mypermid).digest()
self.buddycast = BuddyCastFactory.getInstance(superpeer=True)
self.buddycast.olthread_register(True)
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.my_permid = str(self.my_keypair.pub().get_der())
self.my_hash = sha(self.my_permid).digest()
self.his_permid = str(self.his_keypair.pub().get_der())
# Start our server side, to with Tribler will try to connect
self.listen_port = 4123
self.listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.listen_socket.bind(("", self.listen_port))
self.listen_socket.listen(10)
self.listen_socket.settimeout(10)
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.my_permid = str(self.my_keypair.pub().get_der())
self.my_hash = sha(self.my_permid).digest()
self.his_permid = str(self.his_keypair.pub().get_der())
# Start our server side, to with Tribler will try to connect
self.listen_port = 4123
self.listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
1)
self.listen_socket.bind(("", self.listen_port))
self.listen_socket.listen(10)
self.listen_socket.settimeout(10)
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 = self.setUpDownloadConfig()
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 setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
# 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.torrentfile = os.path.join('extend_hs_dir','dummydata.merkle.torrent')
# Add us as friend, so he will accept the DOWNLOAD_HELP
if False: # TEMP
friendsdb = FriendDBHandler.getInstance()
friendsdb.addFriend(self.mypermid)
else:
self.session.set_overlay_request_policy(AllowAllRequestPolicy())
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 = self.setUpDownloadConfig()
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 setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
# 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.torrentfile = os.path.join('extend_hs_dir',
'dummydata.merkle.torrent')
# Add us as friend, so he will accept the DOWNLOAD_HELP
if False: # TEMP
friendsdb = FriendDBHandler.getInstance()
friendsdb.addFriend(self.mypermid)
else:
self.session.set_overlay_request_policy(AllowAllRequestPolicy())
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
# 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.torrentfile = os.path.join('extend_hs_dir','dummydata.merkle.torrent')
# TEMPARNO: retrieve this from Session
self.torrent_db = TorrentDBHandler.getInstance()
# Add two torrents that will match our query and one that shouldn't
torrent = self.get_default_torrent('Hallo S01E10')
ih = 'b' * 20
self.torrent_db.addTorrent(ih,torrent)
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
# 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.torrentfile = os.path.join('extend_hs_dir',
'dummydata.merkle.torrent')
# TEMPARNO: retrieve this from Session
self.torrent_db = TorrentDBHandler.getInstance()
# Add two torrents that will match our query and one that shouldn't
torrent = self.get_default_torrent('Hallo S01E10')
ih = 'b' * 20
self.torrent_db.addTorrent(ih, torrent)
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
self.another_keypair = generate_keypair()
self.anotherpermid = str(self.another_keypair.pub().get_der())
self.testInfohash = hashlib.sha1("yoman!").digest()
#copy subtitles in the collecting dir
nldName = SubUtils.getSubtitleFileRelativeName(self.anotherpermid, self.testInfohash, "nld")
engName = SubUtils.getSubtitleFileRelativeName(self.anotherpermid, self.testInfohash, "eng")
self.sub1 = os.path.join(self.collecting_dir, nldName)
self.sub2 = os.path.join(self.collecting_dir, engName)
shutil.copyfile(self.src1, self.sub1)
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
# 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.torrentfile = os.path.join('extend_hs_dir','dummydata.merkle.torrent')
# Let Tribler start downloading an non-functioning torrent, so
# we can talk to a normal download engine.
tdef = TorrentDef.load(self.torrentfile)
dscfg = DownloadStartupConfig()
dscfg.set_dest_dir(self.config_path)
self.session.start_download(tdef,dscfg)
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
# Calculating the infohash for proxyservice.test.torrent
self.torrentfile = os.path.join('extend_hs_dir',
'proxyservice.test.torrent')
# Read torrent file to calculate the infohash
torrentfile_content = open(self.torrentfile, "rb")
# Decode all the file
metainfo = bdecode(torrentfile_content.read())
# Calculate the torrent length
if "length" in metainfo["info"]:
self.length = metainfo["info"]["length"]
else:
self.length = 0
for f in metainfo["info"]["files"]:
self.length += f["length"]
# Re-encode only the info section
self.infohash = hashlib.sha1(bencode(metainfo['info'])).digest()
# Store the number of pieces
self.numpieces = int(
math.ceil((self.length / metainfo["info"]["piece length"])))
# Close the torrentfile
torrentfile_content.close()
# Add us as friend, so he will accept the ASK_FOR_HELP message
if False: # TEMP: friendsdb doesn't have an addFriend method
# friendsdb = FriendDBHandler.getInstance()
# friendsdb.addFriend(self.mypermid)
pass
else:
# Accept overlay requests from anybody
self.session.set_overlay_request_policy(AllowAllRequestPolicy())
self.session.set_download_states_callback(self.states_callback)
"""
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
#self.mypermid = str(self.my_keypair.pub().get_der())
#self.hispermid = str(self.his_keypair.pub().get_der())
self.torrent_db = self.session.open_dbhandler(NTFY_TORRENTS)
# Add two torrents that will match our query and one that shouldn't
torrent = self.get_default_torrent('Hallo S01E10')
ih = 'b' * 20
self.torrent_db.addTorrent(ih, torrent)
torrent = self.get_default_torrent('Hallo S02E01')
ih = 'c' * 20
self.torrent_db.addTorrent(ih, torrent)
torrent = self.get_default_torrent('Halo Demo')
ih = 'd' * 20
self.torrent_db.addTorrent(ih, torrent)
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
#self.mypermid = str(self.my_keypair.pub().get_der())
#self.hispermid = str(self.his_keypair.pub().get_der())
self.torrent_db = self.session.open_dbhandler(NTFY_TORRENTS)
# Add two torrents that will match our query and one that shouldn't
torrent = self.get_default_torrent('Hallo S01E10')
ih = 'b' * 20
self.torrent_db.addTorrent(ih,torrent)
torrent = self.get_default_torrent('Hallo S02E01')
ih = 'c' * 20
self.torrent_db.addTorrent(ih,torrent)
torrent = self.get_default_torrent('Halo Demo')
ih = 'd' * 20
self.torrent_db.addTorrent(ih,torrent)
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
# 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.torrentfile = os.path.join('extend_hs_dir',
'dummydata.merkle.torrent')
# Let Tribler start downloading an non-functioning torrent, so
# we can talk to a normal download engine.
tdef = TorrentDef.load(self.torrentfile)
dscfg = DownloadStartupConfig()
dscfg.set_dest_dir(self.config_path)
self.session.start_download(tdef, dscfg)
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
# Create URL compat torrents and save in Torrent database.
self.tdef1 = TorrentDef.load_from_url(P2PURL_SCHEME+'://127.2.3.42:7764/announce?SjaakCam.mpegts&k=MHowDQYJKoZIhvcNAQEBBQADaQAwZgJhAN0Khlp5ZhWC7VfLynCkKts71b8h8tZXH87PkDtJUTJaX_SS1Cddxkv63PRmKOvtAHhkTLSsWOZbSeHkOlPIq_FGg2aDLDJ05g3lQ-8mSmo05ff4SLqNUTShWO2CR2TPhQIBAw&l=HCAAAA&s=15&a=RSA&b=AAIAAA')
self.torrentfn1 = os.path.join(self.session.get_torrent_collecting_dir(),"live.torrent")
self.tdef1.save(self.torrentfn1)
self.tdef2 = TorrentDef.load_from_url(P2PURL_SCHEME+'://127.1.0.10:6969/announce?trailer.mkv&r=TTgcifG0Ot7STCY2JL8SUOxROFo&l=AKK35A&s=15&b=AAFnGg')
self.torrentfn2 = os.path.join(self.session.get_torrent_collecting_dir(),"vod.torrent")
self.tdef2.save(self.torrentfn2)
self.torrent_db = self.session.open_dbhandler(NTFY_TORRENTS)
extra_info = {'status':'good', 'filename':self.torrentfn1}
self.torrent_db.addExternalTorrent(self.tdef1, source='',extra_info=extra_info)
extra_info = {'status':'good', 'filename':self.torrentfn2}
self.torrent_db.addExternalTorrent(self.tdef2, source='',extra_info=extra_info)
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.wxs = wxServer()
self.wxs.start()
print "Sleeping to allow wxServer to start"
sleep(4)
self.mm = MugshotManager.getInstance()
self.mm.register(self.config.sessconfig)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
self.myhash = sha(self.mypermid).digest()
# Give him a usericon to send
self.mm.copy_file(self.hispermid,
self.make_filename('usericon-ok.jpg'))
self.count = 48
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
self.myhash = sha(self.mypermid).digest()
self.buddycast = BuddyCastFactory.getInstance(superpeer=True)
self.buddycast.olthread_register(True)
# arg0 = sys.argv[0].lower()
# if arg0.endswith('.exe'):
# installdir = os.path.abspath(os.path.dirname(sys.argv[0]))
# else:
# installdir = os.getcwd()
# self.utility = Utility(installdir)
# wait for buddycast to have completed on run cycle,
# seems to create problems otherwise
while not self.buddycast.ranonce:
pass
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
# Calculating the infohash for proxyservice.test.torrent
self.torrentfile = os.path.join("extend_hs_dir", "proxyservice.test.torrent")
# Read torrent file to calculate the infohash
torrentfile_content = open(self.torrentfile, "rb")
# Decode all the file
metainfo = bdecode(torrentfile_content.read())
# Calculate the torrent length
if "length" in metainfo["info"]:
self.length = metainfo["info"]["length"]
else:
self.length = 0
for f in metainfo["info"]["files"]:
self.length += f["length"]
# Re-encode only the info section
self.infohash = hashlib.sha1(bencode(metainfo["info"])).digest()
# Store the number of pieces
self.numpieces = int(math.ceil((self.length / metainfo["info"]["piece length"])))
# Close the torrentfile
torrentfile_content.close()
# Add us as friend, so he will accept the ASK_FOR_HELP message
if False: # TEMP: friendsdb doesn't have an addFriend method
# friendsdb = FriendDBHandler.getInstance()
# friendsdb.addFriend(self.mypermid)
pass
else:
# Accept overlay requests from anybody
self.session.set_overlay_request_policy(AllowAllRequestPolicy())
self.session.set_download_states_callback(self.states_callback)
"""
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
self.myhash = sha(self.mypermid).digest()
self.buddycast = BuddyCastFactory.getInstance(superpeer=True)
self.buddycast.olthread_register(True)
# arg0 = sys.argv[0].lower()
# if arg0.endswith('.exe'):
# installdir = os.path.abspath(os.path.dirname(sys.argv[0]))
# else:
# installdir = os.getcwd()
# self.utility = Utility(installdir)
# wait for buddycast to have completed on run cycle,
# seems to create problems otherwise
while not self.buddycast.ranonce:
pass
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
self.myhash = sha(self.mypermid).digest()
# Give Tribler some download history
print >> sys.stderr, "test: Populating MYPREFERENCES table"
self.myprefdb = self.session.open_dbhandler(NTFY_MYPREFERENCES)
data = {'destination_path': '.'}
infohashes = self.create_good_my_prefs(self, btconn.current_version)
for i in range(0, len(infohashes)):
commit = (i == len(infohashes) - 1)
self.myprefdb.addMyPreference(infohashes[i], data, commit=commit)
# Give Tribler some peers
print >> sys.stderr, "test: Populating PEERS table"
self.peerdb = self.session.open_dbhandler(NTFY_PEERS)
past = int(time.time()) - 1000000000
peers = self.create_good_random_peers(btconn.current_version, num=200)
peers = []
for i in range(0, len(peers)):
peer = peers[i]
peer.update({'last_seen': past, 'last_connected': past})
del peer['connect_time']
peer['num_torrents'] = peer['nfiles']
del peer['nfiles']
commit = (i == len(peers) - 1)
self.peerdb.addPeer(peer['permid'],
peer,
update_dns=True,
update_connected=True,
commit=commit)
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.mypermid = str(self.my_keypair.pub().get_der())
self.hispermid = str(self.his_keypair.pub().get_der())
self.another_keypair = generate_keypair()
self.anotherpermid = str(self.another_keypair.pub().get_der())
self.testInfohash = hashlib.sha1("yoman!").digest()
#copy subtitles in the collecting dir
nldName = SubUtils.getSubtitleFileRelativeName(self.anotherpermid,
self.testInfohash,
"nld")
engName = SubUtils.getSubtitleFileRelativeName(self.anotherpermid,
self.testInfohash,
"eng")
self.sub1 = os.path.join(self.collecting_dir, nldName)
self.sub2 = os.path.join(self.collecting_dir, engName)
shutil.copyfile(self.src1, self.sub1)
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.myoriginalip = self.session.get_external_ip()
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.tdef = TorrentDef()
self.sourcefn = os.path.join(os.getcwd(), "API", "file2.wmv")
self.tdef.add_content(self.sourcefn)
self.tdef.set_create_merkle_torrent(True)
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 = self.setUpDownloadConfig()
self.session.start_download(self.tdef, dscfg)
self.infohash = self.tdef.get_infohash()
self.mylistenport = 4810
self.numpieces = (self.tdef.get_length() + self.tdef.get_piece_length() - 1) / self.tdef.get_piece_length()
b = Bitfield(self.numpieces)
for i in range(self.numpieces):
b[i] = True
self.assert_(b.complete())
self.seederbitfieldstr = b.tostring()
# piece_hashes = ['\x01\x02\x03\x04\x05\x06\x07\x08\x07\x06\x05\x04\x03\x02\x01\x00\x01\x02\x03\x04' ] * npieces
# Construct Merkle tree
tdef2 = TorrentDef()
tdef2.add_content(self.sourcefn)
tdef2.set_create_merkle_torrent(False)
tdef2.set_tracker("http://127.0.0.1:12/announce")
tdef2.set_piece_length(self.tdef.get_piece_length())
tdef2.finalize()
metainfo = tdef2.get_metainfo()
piecesstr = metainfo['info']['pieces']
print >> sys.stderr, "test: pieces has len", len(piecesstr)
piece_hashes = []
for i in range(0, len(piecesstr), 20):
hash = piecesstr[i:i + 20]
print >> sys.stderr, "test: piece", i / 20, "hash", repr(hash)
piece_hashes.append(hash)
print >> sys.stderr, "test: Putting", len(piece_hashes), "into MerkleTree, size", self.tdef.get_piece_length(), tdef2.get_piece_length()
self.tree = MerkleTree(self.tdef.get_piece_length(), self.tdef.get_length(), None, piece_hashes)
f = open(self.sourcefn, "rb")
piece1 = f.read(2 ** 18)
piece2 = f.read(2 ** 18)
print >> sys.stderr, "read piece1", len(piece1)
print >> sys.stderr, "read piece2", len(piece2)
f.close()
hash1 = sha(piece1).digest()
hash2 = sha(piece2).digest()
print >> sys.stderr, "hash piece1", repr(hash1)
print >> sys.stderr, "hash piece2", repr(hash2)
f2 = open("piece1.bin", "wb")
f2.write(piece2)
f2.close()
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.myip = '127.0.0.1'
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
#self.mypermid = str(self.my_keypair.pub().get_der())
#self.hispermid = str(self.his_keypair.pub().get_der())
self.torrent_db = self.session.open_dbhandler(NTFY_TORRENTS)
try:
# Add two torrents that will match our query and one that shouldn't
tdef1, bmetainfo1 = self.get_default_torrent('sumfilename1','Hallo S01E10')
dbrec= self.torrent_db.addExternalTorrent(tdef1, extra_info={"filename":"sumfilename1"})
tdef2, bmetainfo2 = self.get_default_torrent('sumfilename2','Hallo S02E01')
dbrec = self.torrent_db.addExternalTorrent(tdef2, extra_info={"filename":"sumfilename2"})
tdef3, bmetainfo3 = self.get_default_torrent('sumfilename3','Halo Demo')
self.torrent_db.addExternalTorrent(tdef3, extra_info={"filename":"sumfilename3"})
self.goodtorrents_str = {}
self.goodtorrents_str[tdef1.get_infohash()] = bmetainfo1
self.goodtorrents_str[tdef2.get_infohash()] = bmetainfo2
# Unicode: Add two torrents that will match our query and one that shouldn't
tdef1, bmetainfo1 = self.get_default_torrent('usumfilename1',u'Ch\u00e8rie S01E10')
dbrec= self.torrent_db.addExternalTorrent(tdef1, extra_info={"filename":"usumfilename1"})
tdef2, bmetainfo2 = self.get_default_torrent('usumfilename2',u'Ch\u00e8rie S02E01')
dbrec = self.torrent_db.addExternalTorrent(tdef2, extra_info={"filename":"usumfilename2"})
tdef3, bmetainfo3 = self.get_default_torrent('usumfilename3',u'Cherie Demo')
self.torrent_db.addExternalTorrent(tdef3, extra_info={"filename":"usumfilename3"})
self.goodtorrents_unicode = {}
self.goodtorrents_unicode[tdef1.get_infohash()] = bmetainfo1
self.goodtorrents_unicode[tdef2.get_infohash()] = bmetainfo2
# Unicode: Add two multi-file torrents that will match our query
# because the keyword occuring in a path and one that shouldn't
paths1 = ['SomeFile.mkv',u'Besan\u00e7on.txt']
tdef1, bmetainfo1 = self.get_default_torrent('psumfilename1',u'Path S01E10',paths=paths1)
dbrec= self.torrent_db.addExternalTorrent(tdef1, extra_info={"filename":"psumfilename1"})
paths2 = ['SomeFile.mkv',u'Besan\u00e7on.doc']
tdef2, bmetainfo2 = self.get_default_torrent('psumfilename2',u'Path S02E01',paths=paths2)
dbrec = self.torrent_db.addExternalTorrent(tdef2, extra_info={"filename":"psumfilename2"})
paths3 = ['SomeFile.mkv',u'Besancon']
tdef3, bmetainfo3 = self.get_default_torrent('psumfilename3',u'Path Demo',paths=paths3)
self.torrent_db.addExternalTorrent(tdef2, extra_info={"filename":"psumfilename3"})
self.goodtorrents_path = {}
self.goodtorrents_path[tdef1.get_infohash()] = bmetainfo1
self.goodtorrents_path[tdef2.get_infohash()] = bmetainfo2
# Add two torrents that will match our two-word query and one that shouldn't
tdef1, bmetainfo1 = self.get_default_torrent('ssumfilename1','One Two S01E10')
dbrec= self.torrent_db.addExternalTorrent(tdef1, extra_info={"filename":"ssumfilename1"})
tdef2, bmetainfo2 = self.get_default_torrent('ssumfilename2','Two S02E01 One')
dbrec = self.torrent_db.addExternalTorrent(tdef2, extra_info={"filename":"ssumfilename2"})
tdef3, bmetainfo3 = self.get_default_torrent('ssumfilename3','Two Demo')
self.torrent_db.addExternalTorrent(tdef3, extra_info={"filename":"ssumfilename3"})
self.goodtorrents_two = {}
self.goodtorrents_two[tdef1.get_infohash()] = bmetainfo1
self.goodtorrents_two[tdef2.get_infohash()] = bmetainfo2
except:
print_exc()
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.myoriginalip = self.session.get_external_ip()
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.tdef = TorrentDef()
self.sourcefn = os.path.join(os.getcwd(), "API", "file2.wmv")
self.tdef.add_content(self.sourcefn)
self.tdef.set_create_merkle_torrent(True)
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 = self.setUpDownloadConfig()
self.session.start_download(self.tdef, dscfg)
self.infohash = self.tdef.get_infohash()
self.mylistenport = 4810
self.numpieces = (self.tdef.get_length() + self.tdef.get_piece_length() - 1) / self.tdef.get_piece_length()
b = Bitfield(self.numpieces)
for i in range(self.numpieces):
b[i] = True
self.assert_(b.complete())
self.seederbitfieldstr = b.tostring()
# piece_hashes = ['\x01\x02\x03\x04\x05\x06\x07\x08\x07\x06\x05\x04\x03\x02\x01\x00\x01\x02\x03\x04' ] * npieces
# Construct Merkle tree
tdef2 = TorrentDef()
tdef2.add_content(self.sourcefn)
tdef2.set_create_merkle_torrent(False)
tdef2.set_tracker("http://127.0.0.1:12/announce")
tdef2.set_piece_length(self.tdef.get_piece_length())
tdef2.finalize()
metainfo = tdef2.get_metainfo()
piecesstr = metainfo["info"]["pieces"]
print >> sys.stderr, "test: pieces has len", len(piecesstr)
piece_hashes = []
for i in range(0, len(piecesstr), 20):
hash = piecesstr[i : i + 20]
print >> sys.stderr, "test: piece", i / 20, "hash", repr(hash)
piece_hashes.append(hash)
print >> sys.stderr, "test: Putting", len(
piece_hashes
), "into MerkleTree, size", self.tdef.get_piece_length(), tdef2.get_piece_length()
self.tree = MerkleTree(self.tdef.get_piece_length(), self.tdef.get_length(), None, piece_hashes)
f = open(self.sourcefn, "rb")
piece1 = f.read(2 ** 18)
piece2 = f.read(2 ** 18)
print >> sys.stderr, "read piece1", len(piece1)
print >> sys.stderr, "read piece2", len(piece2)
f.close()
hash1 = sha(piece1).digest()
hash2 = sha(piece2).digest()
print >> sys.stderr, "hash piece1", repr(hash1)
print >> sys.stderr, "hash piece2", repr(hash2)
f2 = open("piece1.bin", "wb")
f2.write(piece2)
f2.close()
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
self.myip = '127.0.0.1'
def setUpPostSession(self):
""" override TestAsServer """
TestAsServer.setUpPostSession(self)
#self.mypermid = str(self.my_keypair.pub().get_der())
#self.hispermid = str(self.his_keypair.pub().get_der())
self.torrent_db = self.session.open_dbhandler(NTFY_TORRENTS)
try:
# Add two torrents that will match our query and one that shouldn't
tdef1, bmetainfo1 = self.get_default_torrent('sumfilename1','Hallo S01E10')
dbrec= self.torrent_db.addExternalTorrent(tdef1, extra_info={"filename":"sumfilename1"})
tdef2, bmetainfo2 = self.get_default_torrent('sumfilename2','Hallo S02E01')
dbrec = self.torrent_db.addExternalTorrent(tdef2, extra_info={"filename":"sumfilename2"})
tdef3, bmetainfo3 = self.get_default_torrent('sumfilename3','Halo Demo')
self.torrent_db.addExternalTorrent(tdef3, extra_info={"filename":"sumfilename3"})
self.goodtorrents_str = {}
self.goodtorrents_str[tdef1.get_infohash()] = bmetainfo1
self.goodtorrents_str[tdef2.get_infohash()] = bmetainfo2
# Unicode: Add two torrents that will match our query and one that shouldn't
tdef1, bmetainfo1 = self.get_default_torrent('usumfilename1',u'Ch\u00e8rie S01E10')
dbrec= self.torrent_db.addExternalTorrent(tdef1, extra_info={"filename":"usumfilename1"})
tdef2, bmetainfo2 = self.get_default_torrent('usumfilename2',u'Ch\u00e8rie S02E01')
dbrec = self.torrent_db.addExternalTorrent(tdef2, extra_info={"filename":"usumfilename2"})
tdef3, bmetainfo3 = self.get_default_torrent('usumfilename3',u'Cherie Demo')
self.torrent_db.addExternalTorrent(tdef3, extra_info={"filename":"usumfilename3"})
self.goodtorrents_unicode = {}
self.goodtorrents_unicode[tdef1.get_infohash()] = bmetainfo1
self.goodtorrents_unicode[tdef2.get_infohash()] = bmetainfo2
# Unicode: Add two multi-file torrents that will match our query
# because the keyword occuring in a path and one that shouldn't
paths1 = ['SomeFile.mkv',u'Besan\u00e7on.txt']
tdef1, bmetainfo1 = self.get_default_torrent('psumfilename1',u'Path S01E10',paths=paths1)
dbrec= self.torrent_db.addExternalTorrent(tdef1, extra_info={"filename":"psumfilename1"})
paths2 = ['SomeFile.mkv',u'Besan\u00e7on.doc']
tdef2, bmetainfo2 = self.get_default_torrent('psumfilename2',u'Path S02E01',paths=paths2)
dbrec = self.torrent_db.addExternalTorrent(tdef2, extra_info={"filename":"psumfilename2"})
paths3 = ['SomeFile.mkv',u'Besancon']
tdef3, bmetainfo3 = self.get_default_torrent('psumfilename3',u'Path Demo',paths=paths3)
self.torrent_db.addExternalTorrent(tdef2, extra_info={"filename":"psumfilename3"})
self.goodtorrents_path = {}
self.goodtorrents_path[tdef1.get_infohash()] = bmetainfo1
self.goodtorrents_path[tdef2.get_infohash()] = bmetainfo2
# Add two torrents that will match our two-word query and one that shouldn't
tdef1, bmetainfo1 = self.get_default_torrent('ssumfilename1','One Two S01E10')
dbrec= self.torrent_db.addExternalTorrent(tdef1, extra_info={"filename":"ssumfilename1"})
tdef2, bmetainfo2 = self.get_default_torrent('ssumfilename2','Two S02E01 One')
dbrec = self.torrent_db.addExternalTorrent(tdef2, extra_info={"filename":"ssumfilename2"})
tdef3, bmetainfo3 = self.get_default_torrent('ssumfilename3','Two Demo')
self.torrent_db.addExternalTorrent(tdef3, extra_info={"filename":"ssumfilename3"})
self.goodtorrents_two = {}
self.goodtorrents_two[tdef1.get_infohash()] = bmetainfo1
self.goodtorrents_two[tdef2.get_infohash()] = bmetainfo2
except:
print_exc()
