def __init__(self, keypair=None):
""" Constructor for LIVE_AUTHMETHOD_ECDSA authentication of the
live source. If no keypair is specified, one is generated.
@param keypair (Optional) An M2Crypto.EC keypair.
"""
LiveSourceAuthConfig.__init__(self, LIVE_AUTHMETHOD_ECDSA)
if keypair is None:
self.keypair = permidmod.generate_keypair()
else:
self.keypair = keypair
def __init__(self,keypair=None):
""" Constructor for LIVE_AUTHMETHOD_ECDSA authentication of the
live source. If no keypair is specified, one is generated.
@param keypair (Optional) An M2Crypto.EC keypair.
"""
LiveSourceAuthConfig.__init__(self,LIVE_AUTHMETHOD_ECDSA)
if keypair is None:
self.keypair = generate_keypair()
else:
self.keypair = keypair
def generatePermIds(numOfPermids):
permids = list()
keypair = generate_keypair()
#two equal permids for ease of testing
permids.append((str(keypair.pub().get_der()), keypair))
permids.append((str(keypair.pub().get_der()), keypair))
# for i in range(numOfPermids):
# keypair = generate_keypair()
# permids.append((str(keypair.pub().get_der()), keypair))
return permids
def generate_cs_keypair(keypair_filename=None, pubkey_filename=None):
"""
Generate a keypair suitable for a Closed Swarm
Saves to the given files if specified, returns keypair, pubkey
"""
keypair = permid.generate_keypair()
if keypair_filename:
permid.save_keypair(keypair, keypair_filename)
pubkey = encodestring(str(keypair.pub().get_der())).replace("\n", "")
if pubkey_filename:
permid.save_pub_key(keypair, pubkey_filename)
return keypair, pubkey
def generate_cs_keypair(keypair_filename=None, pubkey_filename=None):
"""
Generate a keypair suitable for a Closed Swarm
Saves to the given files if specified, returns keypair, pubkey
"""
keypair = permid.generate_keypair()
if keypair_filename:
permid.save_keypair(keypair, keypair_filename)
pubkey = encodestring(str(keypair.pub().get_der())).replace("\n","")
if pubkey_filename:
permid.save_pub_key(keypair, pubkey_filename)
return keypair, pubkey
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 setUp(self):
self.keyfiles = [
".node_a_keypair", ".node_b_keypair", ".torrent_keypair"
]
for filename in self.keyfiles:
if not os.path.exists(filename):
keypair = permid.generate_keypair()
permid.save_keypair(keypair, filename)
self.node_a_keypair = permid.read_keypair(".node_a_keypair")
self.node_b_keypair = permid.read_keypair(".node_b_keypair")
self.torrent_keypair = permid.read_keypair(".torrent_keypair")
self.torrent_id = "1234"
# Shortcuts
self.node_a_pub_permid = str(self.node_a_keypair.pub().get_der())
self.node_b_pub_permid = str(self.node_b_keypair.pub().get_der())
self.torrent_pubkeys = [
encodestring(str(self.torrent_keypair.pub().get_der())).replace(
"\n", "")
]
# Create the certificate for this torrent ("proof of access")
self.poa_a = ClosedSwarm.create_poa(self.torrent_id,
self.torrent_keypair,
self.node_a_pub_permid)
self.poa_b = ClosedSwarm.create_poa(self.torrent_id,
self.torrent_keypair,
self.node_b_pub_permid)
self.cs_a = ClosedSwarm.ClosedSwarm(self.node_a_keypair,
self.torrent_id,
self.torrent_pubkeys, self.poa_a)
self.cs_b = ClosedSwarm.ClosedSwarm(self.node_b_keypair,
self.torrent_id,
self.torrent_pubkeys, self.poa_b)
def __init__(self, availableLangs, infohash = None):
self._keypair = generate_keypair()
self._permId = str(self._keypair.pub().get_der())
if infohash == None :
hasher = hashlib.sha1()
hasher.update(self._permId + "a")
infohash = hasher.digest()
self.channel = self._permId
self.infohash = infohash
self.description = u""
self.resetTimestamp()
self._subtitles = {}
hasher = hashlib.sha1() #fake checksums for subs
for lang in availableLangs:
hasher.update(lang + "123")
checksum = hasher.digest()
self.addSubtitle(SubtitleInfo(lang, None, checksum))
def __init__(self, availableLangs, infohash = None):
self._keypair = generate_keypair()
self._permId = str(self._keypair.pub().get_der())
if infohash == None :
hasher = hashlib.sha1()
hasher.update(self._permId + "a")
infohash = hasher.digest()
self.channel = self._permId
self.infohash = infohash
self.description = u""
self.resetTimestamp()
self._subtitles = {}
hasher = hashlib.sha1() #fake checksums for subs
for lang in availableLangs:
hasher.update(lang + "123")
checksum = hasher.digest()
self.addSubtitle(SubtitleInfo(lang, None, checksum))
def setUp(self):
self.keyfiles = [".node_a_keypair",".node_b_keypair",".torrent_keypair"]
for filename in self.keyfiles:
if not os.path.exists(filename):
keypair = permid.generate_keypair()
permid.save_keypair(keypair, filename)
self.node_a_keypair = permid.read_keypair(".node_a_keypair")
self.node_b_keypair = permid.read_keypair(".node_b_keypair")
self.torrent_keypair = permid.read_keypair(".torrent_keypair")
self.torrent_id = "1234"
# Shortcuts
self.node_a_pub_permid = str(self.node_a_keypair.pub().get_der())
self.node_b_pub_permid = str(self.node_b_keypair.pub().get_der())
self.torrent_pubkeys = [encodestring(str(self.torrent_keypair.pub().get_der())).replace("\n","")]
# Create the certificate for this torrent ("proof of access")
self.poa_a = ClosedSwarm.create_poa(self.torrent_id,
self.torrent_keypair,
self.node_a_pub_permid)
self.poa_b = ClosedSwarm.create_poa(self.torrent_id,
self.torrent_keypair,
self.node_b_pub_permid)
self.cs_a = ClosedSwarm.ClosedSwarm(self.node_a_keypair,
self.torrent_id,
self.torrent_pubkeys,
self.poa_a)
self.cs_b = ClosedSwarm.ClosedSwarm(self.node_b_keypair,
self.torrent_id,
self.torrent_pubkeys,
self.poa_b)
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 __init__(self,scfg=None,ignore_singleton=False):
"""
A Session object is created which is configured following a copy of the
SessionStartupConfig scfg. (copy constructor used internally)
@param scfg SessionStartupConfig object or None, in which case we
look for a saved session in the default location (state dir). If
we can't find it, we create a new SessionStartupConfig() object to
serve as startup config. Next, the config is saved in the directory
indicated by its 'state_dir' attribute.
In the current implementation only a single session instance can exist
at a time in a process. The ignore_singleton flag is used for testing.
"""
# ProxyService 90s Test_
# self.start_time = time.time()
# _ProxyService 90s Test
if not ignore_singleton:
if Session.__single:
raise RuntimeError, "Session is singleton"
Session.__single = self
self.sesslock = NoDispersyRLock()
# Determine startup config to use
if scfg is None: # If no override
try:
# Then try to read from default location
state_dir = Session.get_default_state_dir()
cfgfilename = Session.get_default_config_filename(state_dir)
scfg = SessionStartupConfig.load(cfgfilename)
except:
# If that fails, create a fresh config with factory defaults
print_exc()
scfg = SessionStartupConfig()
self.sessconfig = scfg.sessconfig
else: # overrides any saved config
# Work from copy
self.sessconfig = copy.copy(scfg.sessconfig)
#Niels: 11/05/2012, turning off overlay
self.sessconfig['overlay'] = 0
self.sessconfig['crawler'] = 0
# Create dir for session state, if not exist
state_dir = self.sessconfig['state_dir']
if state_dir is None:
state_dir = Session.get_default_state_dir()
self.sessconfig['state_dir'] = state_dir
if not os.path.isdir(state_dir):
os.makedirs(state_dir)
collected_torrent_dir = self.sessconfig['torrent_collecting_dir']
if not collected_torrent_dir:
collected_torrent_dir = os.path.join(self.sessconfig['state_dir'], STATEDIR_TORRENTCOLL_DIR)
self.sessconfig['torrent_collecting_dir'] = collected_torrent_dir
collected_subtitles_dir = self.sessconfig.get('subtitles_collecting_dir',None)
if not collected_subtitles_dir:
collected_subtitles_dir = os.path.join(self.sessconfig['state_dir'], STATEDIR_SUBSCOLL_DIR)
self.sessconfig['subtitles_collecting_dir'] = collected_subtitles_dir
if not os.path.exists(collected_torrent_dir):
os.makedirs(collected_torrent_dir)
if not self.sessconfig['peer_icon_path']:
self.sessconfig['peer_icon_path'] = os.path.join(self.sessconfig['state_dir'], STATEDIR_PEERICON_DIR)
# PERHAPS: load default TorrentDef and DownloadStartupConfig from state dir
# Let user handle that, he's got default_state_dir, etc.
# Core init
#print >>sys.stderr,'Session: __init__ config is', self.sessconfig
if GOTM2CRYPTO:
permidmod.init()
#
# Set params that depend on state_dir
#
# 1. keypair
#
pairfilename = os.path.join(self.sessconfig['state_dir'],'ec.pem')
if self.sessconfig['eckeypairfilename'] is None:
self.sessconfig['eckeypairfilename'] = pairfilename
if os.access(self.sessconfig['eckeypairfilename'],os.F_OK):
# May throw exceptions
self.keypair = permidmod.read_keypair(self.sessconfig['eckeypairfilename'])
else:
self.keypair = permidmod.generate_keypair()
# Save keypair
pubfilename = os.path.join(self.sessconfig['state_dir'],'ecpub.pem')
permidmod.save_keypair(self.keypair,pairfilename)
permidmod.save_pub_key(self.keypair,pubfilename)
# 2. Downloads persistent state dir
dlpstatedir = os.path.join(self.sessconfig['state_dir'],STATEDIR_DLPSTATE_DIR)
if not os.path.isdir(dlpstatedir):
os.mkdir(dlpstatedir)
# 3. tracker
trackerdir = self.get_internal_tracker_dir()
if not os.path.exists(trackerdir):
os.mkdir(trackerdir)
if self.sessconfig['tracker_dfile'] is None:
self.sessconfig['tracker_dfile'] = os.path.join(trackerdir,'tracker.db')
if self.sessconfig['tracker_allowed_dir'] is None:
self.sessconfig['tracker_allowed_dir'] = trackerdir
if self.sessconfig['tracker_logfile'] is None:
if sys.platform == "win32":
# Not "Nul:" but "nul" is /dev/null on Win32
sink = 'nul'
else:
sink = '/dev/null'
self.sessconfig['tracker_logfile'] = sink
# 4. superpeer.txt and crawler.txt
if self.sessconfig['superpeer_file'] is None:
self.sessconfig['superpeer_file'] = os.path.join(self.sessconfig['install_dir'],LIBRARYNAME,'Core','superpeer.txt')
if 'crawler_file' not in self.sessconfig or self.sessconfig['crawler_file'] is None:
self.sessconfig['crawler_file'] = os.path.join(self.sessconfig['install_dir'], LIBRARYNAME,'Core','Statistics','crawler.txt')
# 5. peer_icon_path
if self.sessconfig['peer_icon_path'] is None:
self.sessconfig['peer_icon_path'] = os.path.join(self.sessconfig['state_dir'],STATEDIR_PEERICON_DIR)
if not os.path.isdir(self.sessconfig['peer_icon_path']):
os.mkdir(self.sessconfig['peer_icon_path'])
# 6. Poor man's versioning of SessionConfig, add missing
# default values. Really should use PERSISTENTSTATE_CURRENTVERSION
# and do conversions.
for key,defvalue in sessdefaults.iteritems():
if key not in self.sessconfig:
self.sessconfig[key] = defvalue
# 7. proxyservice_dir
if self.sessconfig['overlay']: #NIELS: proxyservice_on/off is set at runtime, always make sure proxyservice_ and self.sessconfig['proxyservice_status'] == PROXYSERVICE_ON:
if self.sessconfig['proxyservice_dir'] is None:
self.sessconfig['proxyservice_dir'] = os.path.join(get_default_dest_dir(), PROXYSERVICE_DESTDIR)
# Jelle: under linux, default_dest_dir can be /tmp. Then proxyservice_dir can be deleted in between
# sessions.
if not os.path.isdir(self.sessconfig['proxyservice_dir']):
os.makedirs(self.sessconfig['proxyservice_dir'])
if not 'live_aux_seeders' in self.sessconfig:
# Poor man's versioning, really should update PERSISTENTSTATE_CURRENTVERSION
self.sessconfig['live_aux_seeders'] = sessdefaults['live_aux_seeders']
if not 'nat_detect' in self.sessconfig:
self.sessconfig['nat_detect'] = sessdefaults['nat_detect']
if not 'puncturing_internal_port' in self.sessconfig:
self.sessconfig['puncturing_internal_port'] = sessdefaults['puncturing_internal_port']
if not 'stun_servers' in self.sessconfig:
self.sessconfig['stun_servers'] = sessdefaults['stun_servers']
if not 'pingback_servers' in self.sessconfig:
self.sessconfig['pingback_servers'] = sessdefaults['pingback_servers']
if not 'mainline_dht' in self.sessconfig:
self.sessconfig['mainline_dht'] = sessdefaults['mainline_dht']
# SWIFTPROC
if self.sessconfig['swiftpath'] is None:
if sys.platform == "win32":
self.sessconfig['swiftpath'] = os.path.join(self.sessconfig['install_dir'],"swift.exe")
else:
self.sessconfig['swiftpath'] = os.path.join(self.sessconfig['install_dir'],"swift")
# Checkpoint startup config
self.save_pstate_sessconfig()
# Create handler for calling back the user via separate threads
self.uch = UserCallbackHandler(self)
# Create engine with network thread
self.lm = TriblerLaunchMany()
self.lm.register(self,self.sesslock)
self.lm.start()
def __init__(self,scfg=None,ignore_singleton=False):
"""
A Session object is created which is configured following a copy of the
SessionStartupConfig scfg. (copy constructor used internally)
@param scfg SessionStartupConfig object or None, in which case we
look for a saved session in the default location (state dir). If
we can't find it, we create a new SessionStartupConfig() object to
serve as startup config. Next, the config is saved in the directory
indicated by its 'state_dir' attribute.
In the current implementation only a single session instance can exist
at a time in a process. The ignore_singleton flag is used for testing.
"""
if not ignore_singleton:
if Session.__single:
raise RuntimeError, "Session is singleton"
Session.__single = self
self.sesslock = RLock()
# Determine startup config to use
if scfg is None: # If no override
try:
# Then try to read from default location
state_dir = Session.get_default_state_dir()
cfgfilename = Session.get_default_config_filename(state_dir)
scfg = SessionStartupConfig.load(cfgfilename)
except:
# If that fails, create a fresh config with factory defaults
print_exc()
scfg = SessionStartupConfig()
self.sessconfig = scfg.sessconfig
else: # overrides any saved config
# Work from copy
self.sessconfig = copy.copy(scfg.sessconfig)
# Create dir for session state, if not exist
state_dir = self.sessconfig['state_dir']
if state_dir is None:
state_dir = Session.get_default_state_dir()
self.sessconfig['state_dir'] = state_dir
if not os.path.isdir(state_dir):
os.makedirs(state_dir)
collected_torrent_dir = self.sessconfig['torrent_collecting_dir']
if not collected_torrent_dir:
collected_torrent_dir = os.path.join(self.sessconfig['state_dir'], STATEDIR_TORRENTCOLL_DIR)
self.sessconfig['torrent_collecting_dir'] = collected_torrent_dir
if not os.path.exists(collected_torrent_dir):
os.makedirs(collected_torrent_dir)
if not self.sessconfig['peer_icon_path']:
self.sessconfig['peer_icon_path'] = os.path.join(self.sessconfig['state_dir'], STATEDIR_PEERICON_DIR)
# PERHAPS: load default TorrentDef and DownloadStartupConfig from state dir
# Let user handle that, he's got default_state_dir, etc.
# Core init
#print >>sys.stderr,time.asctime(),'-', 'Session: __init__ config is', self.sessconfig
if GOTM2CRYPTO:
permidmod.init()
#
# Set params that depend on state_dir
#
# 1. keypair
#
pairfilename = os.path.join(self.sessconfig['state_dir'],'ec.pem')
if self.sessconfig['eckeypairfilename'] is None:
self.sessconfig['eckeypairfilename'] = pairfilename
if os.access(self.sessconfig['eckeypairfilename'],os.F_OK):
# May throw exceptions
self.keypair = permidmod.read_keypair(self.sessconfig['eckeypairfilename'])
else:
self.keypair = permidmod.generate_keypair()
# Save keypair
pubfilename = os.path.join(self.sessconfig['state_dir'],'ecpub.pem')
permidmod.save_keypair(self.keypair,pairfilename)
permidmod.save_pub_key(self.keypair,pubfilename)
# 2. Downloads persistent state dir
dlpstatedir = os.path.join(self.sessconfig['state_dir'],STATEDIR_DLPSTATE_DIR)
if not os.path.isdir(dlpstatedir):
os.mkdir(dlpstatedir)
# 3. tracker
trackerdir = self.get_internal_tracker_dir()
if not os.path.isdir(trackerdir):
os.mkdir(trackerdir)
if self.sessconfig['tracker_dfile'] is None:
self.sessconfig['tracker_dfile'] = os.path.join(trackerdir,'tracker.db')
if self.sessconfig['tracker_allowed_dir'] is None:
self.sessconfig['tracker_allowed_dir'] = trackerdir
if self.sessconfig['tracker_logfile'] is None:
if sys.platform == "win32":
# Not "Nul:" but "nul" is /dev/null on Win32
sink = 'nul'
else:
sink = '/dev/null'
self.sessconfig['tracker_logfile'] = sink
# 4. superpeer.txt and crawler.txt
if self.sessconfig['superpeer_file'] is None:
self.sessconfig['superpeer_file'] = os.path.join(self.sessconfig['install_dir'],LIBRARYNAME,'Core','superpeer.txt')
if 'crawler_file' not in self.sessconfig or self.sessconfig['crawler_file'] is None:
self.sessconfig['crawler_file'] = os.path.join(self.sessconfig['install_dir'], LIBRARYNAME,'Core','Statistics','crawler.txt')
# 5. download_help_dir
if self.sessconfig['overlay'] and self.sessconfig['download_help']:
if self.sessconfig['download_help_dir'] is None:
self.sessconfig['download_help_dir'] = os.path.join(get_default_dest_dir(),DESTDIR_COOPDOWNLOAD)
# Jelle: under linux, default_dest_dir can be /tmp. Then download_help_dir can be deleted inbetween
# sessions.
if not os.path.isdir(self.sessconfig['download_help_dir']):
os.makedirs(self.sessconfig['download_help_dir'])
# 6. peer_icon_path
if self.sessconfig['peer_icon_path'] is None:
self.sessconfig['peer_icon_path'] = os.path.join(self.sessconfig['state_dir'],STATEDIR_PEERICON_DIR)
if not os.path.isdir(self.sessconfig['peer_icon_path']):
os.mkdir(self.sessconfig['peer_icon_path'])
# 7. Poor man's versioning of SessionConfig, add missing
# default values. Really should use PERSISTENTSTATE_CURRENTVERSION
# and do conversions.
for key,defvalue in sessdefaults.iteritems():
if key not in self.sessconfig:
self.sessconfig[key] = defvalue
if not 'live_aux_seeders' in self.sessconfig:
# Poor man's versioning, really should update PERSISTENTSTATE_CURRENTVERSION
self.sessconfig['live_aux_seeders'] = sessdefaults['live_aux_seeders']
if not 'nat_detect' in self.sessconfig:
self.sessconfig['nat_detect'] = sessdefaults['nat_detect']
if not 'puncturing_internal_port' in self.sessconfig:
self.sessconfig['puncturing_internal_port'] = sessdefaults['puncturing_internal_port']
if not 'stun_servers' in self.sessconfig:
self.sessconfig['stun_servers'] = sessdefaults['stun_servers']
if not 'pingback_servers' in self.sessconfig:
self.sessconfig['pingback_servers'] = sessdefaults['pingback_servers']
if not 'mainline_dht' in self.sessconfig:
self.sessconfig['mainline_dht'] = sessdefaults['mainline_dht']
# Checkpoint startup config
self.save_pstate_sessconfig()
# Create handler for calling back the user via separate threads
self.uch = UserCallbackHandler(self)
# Create engine with network thread
self.lm = TriblerLaunchMany()
self.lm.register(self,self.sesslock)
self.lm.start()
from __future__ import with_statement
from Tribler.Core.Overlay.permid import generate_keypair
from Tribler.Test.Core.Subtitles.simple_mocks import \
MockOverlayBridge, MockSubsMsgHander, MockMetadataDBHandler, MockSession
from Tribler.Core.Utilities.Crypto import sha
from Tribler.Core.Subtitles.MetadataDomainObjects.Languages import LanguagesProvider
import logging
import os
import unittest
import codecs
from Tribler.Core.Subtitles.SubtitlesHandler import SubtitlesHandler,\
getSubtitleFileRelativeName
from Tribler.Core.Overlay.SecureOverlay import OLPROTO_VER_FOURTEENTH
logging.basicConfig(level=logging.DEBUG)
_keypairs = (generate_keypair(), generate_keypair(), generate_keypair())
testChannelId = str(_keypairs[0].pub().get_der())
testDestPermId = str(_keypairs[1].pub().get_der())
testMyPermId = str(_keypairs[2].pub().get_der())
testInfohash = sha("yoman!").digest()
RES_DIR = os.path.join('..', '..', 'subtitles_test_res')
class TestSubtitlesHandler(unittest.TestCase):
def setUp(self):
self._session = MockSession()
self.ol_bridge = MockOverlayBridge()
self.rmdDBHandler = MockMetadataDBHandler()
import unittest
import logging
import time
from struct import pack
from Tribler.Core.Subtitles.SubtitleHandler.SubsMessageHandler import SubsMessageHandler
from Tribler.Test.Core.Subtitles.simple_mocks import MockOverlayBridge, MockTokenBucket, MockMsgListener
from Tribler.Core.Overlay.permid import generate_keypair
from Tribler.Core.Utilities.Crypto import sha
from Tribler.Core.Subtitles.MetadataDomainObjects.Languages import LanguagesProvider
from Tribler.Core.MessageID import GET_SUBS, SUBS
from Tribler.Core.Utilities.bencode import bencode, bdecode
from Tribler.Core.Overlay.SecureOverlay import OLPROTO_VER_FOURTEENTH
logging.basicConfig(level=logging.DEBUG)
_keypairs = (generate_keypair(), generate_keypair(), generate_keypair())
testChannelId = str(_keypairs[0].pub().get_der())
testDestPermId = str(_keypairs[1].pub().get_der())
testMyPermId = str(_keypairs[2].pub().get_der())
testInfohash = sha("yoman!").digest()
class TestSubtitlesMsgHandlerIsolation(unittest.TestCase):
def setUp(self):
self.ol_bridge = MockOverlayBridge()
self.tokenBucket = MockTokenBucket()
self.underTest = SubsMessageHandler(self.ol_bridge,self.tokenBucket,1000000)
def test_addToRequestedSubtitles(self):
langUtil = LanguagesProvider.getLanguagesInstance()
def __init__(self, scfg=None, ignore_singleton=False):
"""
A Session object is created which is configured following a copy of the
SessionStartupConfig scfg. (copy constructor used internally)
@param scfg SessionStartupConfig object or None, in which case we
look for a saved session in the default location (state dir). If
we can't find it, we create a new SessionStartupConfig() object to
serve as startup config. Next, the config is saved in the directory
indicated by its 'state_dir' attribute.
In the current implementation only a single session instance can exist
at a time in a process. The ignore_singleton flag is used for testing.
"""
# ProxyService 90s Test_
# self.start_time = time.time()
# _ProxyService 90s Test
if not ignore_singleton:
if Session.__single:
raise RuntimeError, "Session is singleton"
Session.__single = self
self.sesslock = RLock()
# Determine startup config to use
if scfg is None: # If no override
try:
# Then try to read from default location
state_dir = Session.get_default_state_dir()
cfgfilename = Session.get_default_config_filename(state_dir)
scfg = SessionStartupConfig.load(cfgfilename)
except:
# If that fails, create a fresh config with factory defaults
print_exc()
scfg = SessionStartupConfig()
self.sessconfig = scfg.sessconfig
else: # overrides any saved config
# Work from copy
self.sessconfig = copy.copy(scfg.sessconfig)
# Create dir for session state, if not exist
state_dir = self.sessconfig["state_dir"]
if state_dir is None:
state_dir = Session.get_default_state_dir()
self.sessconfig["state_dir"] = state_dir
if not os.path.isdir(state_dir):
os.makedirs(state_dir)
collected_torrent_dir = self.sessconfig["torrent_collecting_dir"]
if not collected_torrent_dir:
collected_torrent_dir = os.path.join(self.sessconfig["state_dir"], STATEDIR_TORRENTCOLL_DIR)
self.sessconfig["torrent_collecting_dir"] = collected_torrent_dir
collected_subtitles_dir = self.sessconfig.get("subtitles_collecting_dir", None)
if not collected_subtitles_dir:
collected_subtitles_dir = os.path.join(self.sessconfig["state_dir"], STATEDIR_SUBSCOLL_DIR)
self.sessconfig["subtitles_collecting_dir"] = collected_subtitles_dir
if not os.path.exists(collected_torrent_dir):
os.makedirs(collected_torrent_dir)
if not self.sessconfig["peer_icon_path"]:
self.sessconfig["peer_icon_path"] = os.path.join(self.sessconfig["state_dir"], STATEDIR_PEERICON_DIR)
# PERHAPS: load default TorrentDef and DownloadStartupConfig from state dir
# Let user handle that, he's got default_state_dir, etc.
# Core init
# print >>sys.stderr,'Session: __init__ config is', self.sessconfig
if GOTM2CRYPTO:
permidmod.init()
#
# Set params that depend on state_dir
#
# 1. keypair
#
pairfilename = os.path.join(self.sessconfig["state_dir"], "ec.pem")
if self.sessconfig["eckeypairfilename"] is None:
self.sessconfig["eckeypairfilename"] = pairfilename
if os.access(self.sessconfig["eckeypairfilename"], os.F_OK):
# May throw exceptions
self.keypair = permidmod.read_keypair(self.sessconfig["eckeypairfilename"])
else:
self.keypair = permidmod.generate_keypair()
# Save keypair
pubfilename = os.path.join(self.sessconfig["state_dir"], "ecpub.pem")
permidmod.save_keypair(self.keypair, pairfilename)
permidmod.save_pub_key(self.keypair, pubfilename)
# 2. Downloads persistent state dir
dlpstatedir = os.path.join(self.sessconfig["state_dir"], STATEDIR_DLPSTATE_DIR)
if not os.path.isdir(dlpstatedir):
os.mkdir(dlpstatedir)
# 3. tracker
trackerdir = self.get_internal_tracker_dir()
if not os.path.isdir(trackerdir):
os.mkdir(trackerdir)
if self.sessconfig["tracker_dfile"] is None:
self.sessconfig["tracker_dfile"] = os.path.join(trackerdir, "tracker.db")
if self.sessconfig["tracker_allowed_dir"] is None:
self.sessconfig["tracker_allowed_dir"] = trackerdir
if self.sessconfig["tracker_logfile"] is None:
if sys.platform == "win32":
# Not "Nul:" but "nul" is /dev/null on Win32
sink = "nul"
else:
sink = "/dev/null"
self.sessconfig["tracker_logfile"] = sink
# 4. superpeer.txt and crawler.txt
if self.sessconfig["superpeer_file"] is None:
self.sessconfig["superpeer_file"] = os.path.join(
self.sessconfig["install_dir"], LIBRARYNAME, "Core", "superpeer.txt"
)
if "crawler_file" not in self.sessconfig or self.sessconfig["crawler_file"] is None:
self.sessconfig["crawler_file"] = os.path.join(
self.sessconfig["install_dir"], LIBRARYNAME, "Core", "Statistics", "crawler.txt"
)
# 5. peer_icon_path
if self.sessconfig["peer_icon_path"] is None:
self.sessconfig["peer_icon_path"] = os.path.join(self.sessconfig["state_dir"], STATEDIR_PEERICON_DIR)
if not os.path.isdir(self.sessconfig["peer_icon_path"]):
os.mkdir(self.sessconfig["peer_icon_path"])
# 6. Poor man's versioning of SessionConfig, add missing
# default values. Really should use PERSISTENTSTATE_CURRENTVERSION
# and do conversions.
for key, defvalue in sessdefaults.iteritems():
if key not in self.sessconfig:
self.sessconfig[key] = defvalue
# 7. proxyservice_dir
if self.sessconfig[
"overlay"
]: # NIELS: proxyservice_on/off is set at runtime, always make sure proxyservice_ and self.sessconfig['proxyservice_status'] == PROXYSERVICE_ON:
if self.sessconfig["proxyservice_dir"] is None:
self.sessconfig["proxyservice_dir"] = os.path.join(get_default_dest_dir(), PROXYSERVICE_DESTDIR)
# Jelle: under linux, default_dest_dir can be /tmp. Then proxyservice_dir can be deleted in between
# sessions.
if not os.path.isdir(self.sessconfig["proxyservice_dir"]):
os.makedirs(self.sessconfig["proxyservice_dir"])
if not "live_aux_seeders" in self.sessconfig:
# Poor man's versioning, really should update PERSISTENTSTATE_CURRENTVERSION
self.sessconfig["live_aux_seeders"] = sessdefaults["live_aux_seeders"]
if not "nat_detect" in self.sessconfig:
self.sessconfig["nat_detect"] = sessdefaults["nat_detect"]
if not "puncturing_internal_port" in self.sessconfig:
self.sessconfig["puncturing_internal_port"] = sessdefaults["puncturing_internal_port"]
if not "stun_servers" in self.sessconfig:
self.sessconfig["stun_servers"] = sessdefaults["stun_servers"]
if not "pingback_servers" in self.sessconfig:
self.sessconfig["pingback_servers"] = sessdefaults["pingback_servers"]
if not "mainline_dht" in self.sessconfig:
self.sessconfig["mainline_dht"] = sessdefaults["mainline_dht"]
# SWIFTPROC
if self.sessconfig["swiftpath"] is None:
if sys.platform == "win32":
self.sessconfig["swiftpath"] = os.path.join(self.sessconfig["install_dir"], "swift.exe")
else:
self.sessconfig["swiftpath"] = os.path.join(self.sessconfig["install_dir"], "swift")
# Checkpoint startup config
self.save_pstate_sessconfig()
# Create handler for calling back the user via separate threads
self.uch = UserCallbackHandler(self)
# Create engine with network thread
self.lm = TriblerLaunchMany()
self.lm.register(self, self.sesslock)
self.lm.start()
class TestMetadataDBHandler(unittest.TestCase):
_keypair1 = generate_keypair()
aPermId = str(_keypair1.pub().get_der())
_keypair2 = generate_keypair()
anotherPermId = str(_keypair2.pub().get_der())
def setUp(self):
#createDB = not os.path.isfile(SQL_DB)
self.db = SimpleMetadataDB(CREATE_SQL_FILE, SQL_DB)
self.underTest = MetadataDBHandler(self.db)
def tearDown(self):
self.db.close()
#if os.path.isfile(SQL_DB) :
#os.remove(SQL_DB)
def testInitHandler(self):
self.assertTrue(self.underTest is not None)
def testSingleton(self):
instance1 = MetadataDBHandler.getInstance()
instance2 = MetadataDBHandler.getInstance()
self.assertTrue(instance1 is instance2)
def testInsertNewMetadataSubs(self):
metadataDTO = MockMetadataDTO(["nld","ita"])
metadataDTO.sign(metadataDTO._keypair)
self.underTest.insertMetadata(metadataDTO)
testquery = "SELECT * FROM Metadata WHERE publisher_id=?" \
+ " AND infohash=?;"
results = self.db.fetchall(testquery, (bin2str(metadataDTO.channel),bin2str(metadataDTO.infohash)))
self.assertTrue(len(results) == 1)
tupl = results[0]
self.assertTrue(tupl[0] is not None and isinstance(tupl[0], int))
self.assertEquals(bin2str(metadataDTO.channel),tupl[1])
self.assertEquals(bin2str(metadataDTO.infohash),tupl[2])
self.assertEquals(metadataDTO.description, tupl[3])
self.assertEquals(metadataDTO.timestamp, tupl[4])
self.assertEquals(bin2str(metadataDTO.signature), tupl[5])
subtitlesQuery = "SELECT * FROM Subtitles WHERE metadata_id_fk=?;"
subtitles = self.db.fetchall(subtitlesQuery, (tupl[0],))
self.assertEquals(2,len(subtitles))
for lang in ("ita", "nld"):
found = False
foundSub = None
for subtuple in subtitles:
if subtuple[1] == lang:
found = True
foundSub = subtuple
break
self.assertTrue(found)
self.assertEquals(bin2str(metadataDTO.getSubtitle(lang).checksum), foundSub[3])
def testGetMetadataInstance(self):
metadataDTO = MockMetadataDTO(["nld","ita"])
metadataDTO.sign(metadataDTO._keypair)
self.underTest.insertMetadata(metadataDTO)
retrievedMetadata = self.underTest.getMetadata(metadataDTO.channel,
metadataDTO.infohash)
self.assertFalse(retrievedMetadata is None)
self.assertFalse(retrievedMetadata is metadataDTO)
self.assertEquals(metadataDTO,retrievedMetadata)
def testInsertNewMetadataNoSubs(self):
metadataDTO = MockMetadataDTO([])
metadataDTO.sign(metadataDTO._keypair)
self.underTest.insertMetadata(metadataDTO)
testquery = "SELECT * FROM Metadata WHERE publisher_id=?" \
+ " AND infohash=?;"
channel = bin2str(metadataDTO.channel)
infohash = bin2str(metadataDTO.infohash)
results = self.db.fetchall(testquery, (channel,infohash))
self.assertTrue(len(results) == 1)
tupl = results[0]
self.assertTrue(tupl[0] is not None and isinstance(tupl[0], int))
self.assertEquals(channel,tupl[1])
self.assertEquals(infohash,tupl[2])
self.assertEquals(metadataDTO.description, tupl[3])
self.assertEquals(metadataDTO.timestamp, tupl[4])
self.assertEquals(bin2str(metadataDTO.signature), tupl[5])
subtitlesQuery = "SELECT * FROM Subtitles WHERE metadata_id_fk=?;"
subtitles = self.db.fetchall(subtitlesQuery, (tupl[0],))
self.assertEquals(0,len(subtitles))
def testUpdateExistingWithOlder(self):
metadataDTO = MockMetadataDTO(["nld", "ita"])
metadataDTO.sign(metadataDTO._keypair)
self.underTest.insertMetadata(metadataDTO)
olderMetadataDTO = copy.copy(metadataDTO)
olderMetadataDTO.timestamp = 1 #*really* old
olderMetadataDTO.sign(olderMetadataDTO._keypair)
self.underTest.insertMetadata(olderMetadataDTO)
#assert the the older did not replace the newer
testquery = "SELECT * FROM Metadata WHERE publisher_id=?" \
+ " AND infohash=?;"
channel = bin2str(metadataDTO.channel)
infohash = bin2str(metadataDTO.infohash)
results = self.db.fetchall(testquery, (channel,infohash))
self.assertTrue(len(results) == 1)
tupl = results[0]
self.assertTrue(tupl[0] is not None and isinstance(tupl[0], int))
self.assertEquals(channel,tupl[1])
self.assertEquals(infohash,tupl[2])
self.assertEquals(metadataDTO.description, tupl[3])
self.assertEquals(metadataDTO.timestamp, tupl[4])
self.assertEquals(bin2str(metadataDTO.signature), tupl[5])
subtitlesQuery = "SELECT * FROM Subtitles WHERE metadata_id_fk=?;"
subtitles = self.db.fetchall(subtitlesQuery, (tupl[0],))
self.assertEquals(2,len(subtitles))
for lang in ("ita", "nld"):
found = False
foundSub = None
for subtuple in subtitles:
if subtuple[1] == lang:
found = True
foundSub = subtuple
break
self.assertTrue(found)
self.assertEquals(bin2str(metadataDTO.getSubtitle(lang).checksum), foundSub[3])
def testUpdateExistingWithNewerSameSub(self):
metadataDTO = MockMetadataDTO(["nld", "ita"])
metadataDTO.sign(metadataDTO._keypair)
self.underTest.insertMetadata(metadataDTO)
newerMetadataDTO = copy.copy(metadataDTO)
newerMetadataDTO.description = u"I'm newer!"
newerMetadataDTO.timestamp = newerMetadataDTO.timestamp +1 #newer
newerMetadataDTO.sign(newerMetadataDTO._keypair)
self.underTest.insertMetadata(newerMetadataDTO)
#assert the the older has been replaced
testquery = "SELECT * FROM Metadata WHERE publisher_id=?" \
+ " AND infohash=?;"
channel = bin2str(metadataDTO.channel)
infohash = bin2str(metadataDTO.infohash)
results = self.db.fetchall(testquery, (channel,infohash))
self.assertTrue(len(results) == 1)
tupl = results[0]
self.assertTrue(tupl[0] is not None and isinstance(tupl[0], int))
self.assertEquals(channel,tupl[1])
self.assertEquals(infohash,tupl[2])
self.assertEquals(newerMetadataDTO.description, tupl[3])
self.assertEquals(newerMetadataDTO.timestamp, tupl[4])
self.assertEquals(bin2str(newerMetadataDTO.signature), tupl[5])
#testing subtitles with the old once since they are not changed
subtitlesQuery = "SELECT * FROM Subtitles WHERE metadata_id_fk=?;"
subtitles = self.db.fetchall(subtitlesQuery, (tupl[0],))
self.assertEquals(2,len(subtitles))
for lang in ("ita", "nld"):
found = False
foundSub = None
for subtuple in subtitles:
if subtuple[1] == lang:
found = True
foundSub = subtuple
break
self.assertTrue(found)
self.assertEquals(bin2str(metadataDTO.getSubtitle(lang).checksum), foundSub[3])
def testUpdateExistingWithNewerNewSubs(self):
metadataDTO = MockMetadataDTO(["nld", "ita"])
metadataDTO.sign(metadataDTO._keypair)
self.underTest.insertMetadata(metadataDTO)
newerMetadataDTO = MockMetadataDTO(["nld","ita","eng"])
newerMetadataDTO.channel = metadataDTO.channel
newerMetadataDTO.infohash = metadataDTO.infohash
newerMetadataDTO._keypair = metadataDTO._keypair
newerMetadataDTO.timestamp = metadataDTO.timestamp +1 #newer
newerMetadataDTO.sign(newerMetadataDTO._keypair)
self.underTest.insertMetadata(newerMetadataDTO)
#assert the the older has been replaced
testquery = "SELECT * FROM Metadata WHERE publisher_id=?" \
+ " AND infohash=?;"
channel = bin2str(metadataDTO.channel)
infohash = bin2str(metadataDTO.infohash)
results = self.db.fetchall(testquery, (channel,infohash))
self.assertTrue(len(results) == 1)
tupl = results[0]
self.assertTrue(tupl[0] is not None and isinstance(tupl[0], int))
self.assertEquals(channel,tupl[1])
self.assertEquals(infohash,tupl[2])
self.assertEquals(newerMetadataDTO.description, tupl[3])
self.assertEquals(newerMetadataDTO.timestamp, tupl[4])
self.assertEquals(bin2str(newerMetadataDTO.signature), tupl[5])
subtitlesQuery = "SELECT * FROM Subtitles WHERE metadata_id_fk=?;"
subtitles = self.db.fetchall(subtitlesQuery, (tupl[0],))
self.assertEquals(3,len(subtitles))
for lang in ("ita", "nld","eng"):
found = False
foundSub = None
for subtuple in subtitles:
if subtuple[1] == lang:
found = True
foundSub = subtuple
break
self.assertTrue(found)
self.assertEquals(bin2str(newerMetadataDTO.getSubtitle(lang).checksum), foundSub[3])
def testUpdateExistingWithNewerSubsDeleted(self):
metadataDTO = MockMetadataDTO(["nld", "ita"])
metadataDTO.sign(metadataDTO._keypair)
self.underTest.insertMetadata(metadataDTO)
newerMetadataDTO = MockMetadataDTO(["nld","eng"])
newerMetadataDTO.channel = metadataDTO.channel
newerMetadataDTO.infohash = metadataDTO.infohash
newerMetadataDTO._keypair = metadataDTO._keypair
newerMetadataDTO.timestamp = metadataDTO.timestamp +1 #newer
newerMetadataDTO.sign(newerMetadataDTO._keypair)
self.underTest.insertMetadata(newerMetadataDTO)
#assert the the older has been replaced
testquery = "SELECT * FROM Metadata WHERE publisher_id=?" \
+ " AND infohash=?;"
channel = bin2str(metadataDTO.channel)
infohash = bin2str(metadataDTO.infohash)
results = self.db.fetchall(testquery, (channel,infohash))
self.assertTrue(len(results) == 1)
tupl = results[0]
self.assertTrue(tupl[0] is not None and isinstance(tupl[0], int))
self.assertEquals(channel,tupl[1])
self.assertEquals(infohash,tupl[2])
self.assertEquals(newerMetadataDTO.description, tupl[3])
self.assertEquals(newerMetadataDTO.timestamp, tupl[4])
self.assertEquals(bin2str(newerMetadataDTO.signature), tupl[5])
subtitlesQuery = "SELECT * FROM Subtitles WHERE metadata_id_fk=?;"
subtitles = self.db.fetchall(subtitlesQuery, (tupl[0],))
self.assertEquals(2,len(subtitles))
for lang in ("nld","eng"):
found = False
foundSub = None
for subtuple in subtitles:
if subtuple[1] == lang:
found = True
foundSub = subtuple
break
self.assertTrue(found)
self.assertEquals(bin2str(newerMetadataDTO.getSubtitle(lang).checksum), foundSub[3])
def testGetAllMetadataForInfohashEmtpy(self):
metadataDTO = MockMetadataDTO(["nld", "ita"])
metadataDTO.sign(metadataDTO._keypair)
self.underTest.insertMetadata(metadataDTO)
otherinfohash = _generateFakeInfohash()
results = self.underTest.getAllMetadataForInfohash(otherinfohash)
self.assertTrue(len(results)==0)
def testGetAllMetadataForInfohashNotEmpty(self):
infohash = _generateFakeInfohash()
metadataDTO1 = MockMetadataDTO(["nld", "ita"],infohash)
metadataDTO1.sign(metadataDTO1._keypair)
self.underTest.insertMetadata(metadataDTO1)
#different channels since the channel is automatically
#generated by MockMetadata DTO
metadataDTO2 = MockMetadataDTO(["rus", "eng"],infohash)
metadataDTO2.sign(metadataDTO2._keypair)
self.underTest.insertMetadata(metadataDTO2)
#a 3rd instance with different channel and infohash
metadataDTO3 = MockMetadataDTO(["rus", "spa", "jpn"])
metadataDTO3.sign(metadataDTO3._keypair)
self.underTest.insertMetadata(metadataDTO3)
results = self.underTest.getAllMetadataForInfohash(infohash)
self.assertTrue(len(results)==2)
#in checks for equality, not reference equality
self.assertTrue(metadataDTO1 in results)
self.assertTrue(metadataDTO2 in results)
self.assertFalse(metadataDTO3 in results)
def testDeleteSubtitle(self):
infohash = _generateFakeInfohash()
metadataDTO = MockMetadataDTO(["eng","kor"], infohash)
metadataDTO.sign(metadataDTO._keypair)
self.underTest.insertMetadata(metadataDTO)
res = self.underTest.getAllSubtitles(metadataDTO.channel, infohash)
self.assertTrue("eng" in res and "kor" in res)
#delete a subtitle that does not exist
self.underTest._deleteSubtitleByChannel(metadataDTO.channel, infohash, "ita")
res = self.underTest.getAllSubtitles(metadataDTO.channel, infohash)
self.assertTrue("eng" in res and "kor" in res)
self.underTest._deleteSubtitleByChannel(metadataDTO.channel, infohash, "eng")
res = self.underTest.getAllSubtitles(metadataDTO.channel, infohash)
self.assertTrue("kor" in res and not "eng" in res)
def testSelectLocalSubtitles(self):
infohash1 = _generateFakeInfohash()
metadataDTO1 = MockMetadataDTO(["eng","kor"], infohash1)
metadataDTO1.sign(metadataDTO1._keypair)
self.underTest.insertMetadata(metadataDTO1)
res = self.underTest.getAllLocalSubtitles()
self.assertTrue(len(res) == 0)
infohash2 = _generateFakeInfohash()
metadataDTO2 = MockMetadataDTO(["nld","spa"], infohash2)
metadataDTO2.getSubtitle("nld").path = "/bla/bla"
metadataDTO2.sign(metadataDTO2._keypair)
self.underTest.insertMetadata(metadataDTO2)
res = self.underTest.getAllLocalSubtitles()
self.assertTrue(len(res) == 1)
self.assertTrue(metadataDTO2.channel in res)
self.assertTrue(infohash2 in res[metadataDTO2.channel])
self.assertEquals(1, len(res[metadataDTO2.channel][infohash2]))
self.assertEquals(metadataDTO2.getSubtitle("nld"), res[metadataDTO2.channel][infohash2][0])
def testSelectLocalSubtitles2(self):
infohash1 = _generateFakeInfohash()
metadataDTO1 = MockMetadataDTO(["eng","kor", "nld"], infohash1)
metadataDTO1.getSubtitle("nld").path = "/bla/bla"
metadataDTO1.getSubtitle("eng").path = "/bla/bla"
metadataDTO1.sign(metadataDTO1._keypair)
self.underTest.insertMetadata(metadataDTO1)
infohash2 = _generateFakeInfohash()
metadataDTO2 = MockMetadataDTO(["ita","spa"], infohash2)
metadataDTO2.getSubtitle("ita").path = "/a/b"
metadataDTO2.getSubtitle("spa").path = "/c/d"
metadataDTO2.sign(metadataDTO2._keypair)
self.underTest.insertMetadata(metadataDTO2)
res = self.underTest.getLocalSubtitles(metadataDTO1.channel, infohash1)
self.assertEquals(2, len(res))
self.assertTrue("eng" in res)
self.assertEquals(metadataDTO1.getSubtitle("eng"), res["eng"])
self.assertTrue("nld" in res)
self.assertEquals(metadataDTO1.getSubtitle("nld"), res["nld"])
self.assertFalse("kor" in res)
def testUpdateSubtitlesWithNonePathValue(self):
infohash1 = _generateFakeInfohash()
metadataDTO1 = MockMetadataDTO(["eng","kor"], infohash1)
metadataDTO1.getSubtitle("eng").path = os.path.abspath(os.path.join("bla","bla"))
metadataDTO1.sign(metadataDTO1._keypair)
self.underTest.insertMetadata(metadataDTO1)
sub = self.underTest.getSubtitle(metadataDTO1.channel, infohash1, "eng")
self.assertEquals(os.path.abspath(os.path.join("bla","bla")), sub.path)
self.underTest.updateSubtitlePath(metadataDTO1.channel, infohash1,
"eng", None, True)
sub = self.underTest.getSubtitle(metadataDTO1.channel, infohash1, "eng")
self.assertEquals(None, sub.path)
def testUpdateSubtitles(self):
sub1path= os.path.join(RES_DIR,"fake0.srt")
sub2path=os.path.join(RES_DIR,"fake1.srt")
infohash = _generateFakeInfohash()
metadataDTO = MockMetadataDTO([], infohash)
sub1 = SubtitleInfo("ita", None, _computeSHA1(sub1path))
sub2 = SubtitleInfo("eng",None,_computeSHA1(sub2path))
metadataDTO.addSubtitle(sub1)
metadataDTO.addSubtitle(sub2)
metadataDTO.sign(metadataDTO._keypair)
self.underTest.insertMetadata(metadataDTO)
res1 = self.underTest.getSubtitle(metadataDTO.channel, infohash,"ita")
self.assertEquals(sub1,res1)
res2 = self.underTest.getSubtitle(metadataDTO.channel, infohash, "eng")
self.assertEquals(sub2,res2)
sub1bis = copy.copy(sub1)
sub1bis.path = sub1path
sub2bis = copy.copy(sub2)
sub2bis.path = sub2path
self.underTest.updateSubtitlePath(metadataDTO.channel, infohash,
sub1bis.lang, sub1bis.path, False)
self.underTest.updateSubtitlePath(metadataDTO.channel, infohash,
sub2bis.lang, sub2bis.path , False)
self.underTest.commit()
#still unchanged since I did not commit
res1 = self.underTest.getSubtitle(metadataDTO.channel, infohash,"ita")
self.assertTrue(sub1== res1 and sub1.path != res1.path)
self.assertTrue(sub1bis == res1 and sub1bis.path == res1.path)
res2 = self.underTest.getSubtitle(metadataDTO.channel, infohash, "eng")
self.assertTrue(sub2 == res2 and sub2.path != res2.path)
self.assertTrue(sub2bis == res2 and sub2bis.path == res2.path)
# 30-05-2010 Testing of the new added table (SubtitlesHave) manipulation
# methods.
def testInsertAndGetHaveMask(self):
infohash = _generateFakeInfohash()
metadataDTO1 = MockMetadataDTO(["nld","spa"], infohash)
channel = metadataDTO1.channel
metadataDTO1.sign(metadataDTO1._keypair)
self.underTest.insertMetadata(metadataDTO1)
peer_id = TestMetadataDBHandler.anotherPermId
#inserting a negative mask has to be refused
havemask = -1
funcToTest =\
lambda : self.underTest.insertHaveMask(channel, infohash,
peer_id, havemask)
self.assertRaises(MetadataDBException, funcToTest)
#also a bitmask must be smaller then 2**32
havemask = 2**32
funcToTest =\
lambda : self.underTest.insertHaveMask(channel, infohash,
peer_id, havemask)
self.assertRaises(MetadataDBException, funcToTest)
#now it's time for a correct value
havemask1=0x80000001
self.underTest.insertHaveMask(channel, infohash, peer_id, havemask1)
mask = self.underTest.getHaveMask(channel, infohash,peer_id)
self.assertEqual(mask,havemask1)
#duplicate insertions should raise an error
havemask2=0xffffffff
funcToTest = \
lambda : self.underTest.insertHaveMask(channel, infohash,
peer_id, havemask2)
self.assertRaises(MetadataDBException, funcToTest)
#insertion for another peer should go fine
self.underTest.insertHaveMask(channel, infohash, channel, havemask2)
mask1 = self.underTest.getHaveMask(channel, infohash,peer_id)
self.assertEqual(mask1,havemask1)
mask2 = self.underTest.getHaveMask(channel, infohash,channel)
self.assertEqual(mask2,havemask2)
#getting an have mask for an unexistent channel, infohash shall
#return None
mask1 = \
self.underTest.getHaveMask(channel, _generateFakeInfohash(),peer_id)
self.assertTrue(mask1 is None)
#as it should happen for asking for an unexisting peer_id
mask1 = self.underTest.getHaveMask(channel, infohash,
TestMetadataDBHandler.aPermId)
self.assertTrue(mask1 is None)
def testUpdateHaveMask(self):
infohash = _generateFakeInfohash()
metadataDTO1 = MockMetadataDTO(["nld","spa"], infohash)
channel = metadataDTO1.channel
metadataDTO1.sign(metadataDTO1._keypair)
self.underTest.insertMetadata(metadataDTO1)
peer_id = TestMetadataDBHandler.anotherPermId
#adding an have mask to the db
havemask1=0x80000001
self.underTest.insertHaveMask(channel, infohash, peer_id, havemask1)
mask = self.underTest.getHaveMask(channel, infohash,peer_id)
self.assertEqual(mask,havemask1)
#updating it to a different value
new_havemask = 0x1111ffff
self.underTest.updateHaveMask(channel, infohash, peer_id,
new_havemask)
mask = self.underTest.getHaveMask(channel, infohash,peer_id)
self.assertEqual(mask,new_havemask)
#trying to update a non existing row should cause an error
# -- currently this doesn't happen
# implementing this beahaviour would slow down the db
#funcToTest = \
# lambda: self.underTest.updateHaveMask(channel, infohash,
# channel, new_havemask)
# self.assertRaises(MetadataDBException, funcToTest)
def testDeleteHaveEntry(self):
infohash = _generateFakeInfohash()
metadataDTO1 = MockMetadataDTO(["nld","spa"], infohash)
channel = metadataDTO1.channel
metadataDTO1.sign(metadataDTO1._keypair)
self.underTest.insertMetadata(metadataDTO1)
peer_id = TestMetadataDBHandler.anotherPermId
#adding an have mask to the db
havemask1=0x80000001
self.underTest.insertHaveMask(channel, infohash, peer_id, havemask1)
havemask2=0x02324123
self.underTest.insertHaveMask(channel, infohash, channel, havemask2)
self.underTest.deleteHaveEntry(channel, infohash, peer_id)
mask = self.underTest.getHaveMask(channel, infohash, peer_id)
self.assertTrue(mask is None)
mask = self.underTest.getHaveMask(channel, infohash, channel)
self.assertEquals(havemask2,mask)
# deleting an entry that does not exist should leave
# the db unchanged
self.underTest.deleteHaveEntry(channel, infohash, peer_id)
mask = self.underTest.getHaveMask(channel, infohash, channel)
self.assertEquals(havemask2,mask)
def testGetAllHaveEntries(self):
infohash = _generateFakeInfohash()
metadataDTO1 = MockMetadataDTO(["nld","spa"], infohash)
channel = metadataDTO1.channel
metadataDTO1.sign(metadataDTO1._keypair)
self.underTest.insertMetadata(metadataDTO1)
peer_id = TestMetadataDBHandler.anotherPermId
#adding an have mask to the db
havemask1=0x80000001
self.underTest.insertHaveMask(channel, infohash, peer_id, havemask1)
time.sleep(1) # otherwise they would have the same timestamp
havemask2=0x02324123
self.underTest.insertHaveMask(channel, infohash, channel, havemask2)
d = self.underTest.getHaveEntries(channel, infohash)
#the second inserted havemask has to be returned first
# since it is newer
firstTuple = d[0]
self.assertEquals(channel, firstTuple[0])
self.assertEquals(havemask2,firstTuple[1])
self.assertTrue(firstTuple[2] is not None)
self.assertEquals(peer_id, d[1][0])
self.assertEquals(havemask1,d[1][1])
self.assertTrue(d[1][2] is not None)
def testCleanUpAllHave(self):
infohash1 = _generateFakeInfohash()
metadataDTO1 = MockMetadataDTO(["nld","spa"], infohash1)
channel1 = metadataDTO1.channel
metadataDTO1.sign(metadataDTO1._keypair)
self.underTest.insertMetadata(metadataDTO1)
infohash2 = _generateFakeInfohash()
metadataDTO2 = MockMetadataDTO(["nld","spa"], infohash2)
channel2 = metadataDTO2.channel
metadataDTO2.sign(metadataDTO2._keypair)
self.underTest.insertMetadata(metadataDTO2)
peer_id1 = TestMetadataDBHandler.anotherPermId
peer_id2 = TestMetadataDBHandler.aPermId
#inserting some data: 4 have maskes for each of the two channels with
# custom timestamps
# older then 1275295300
self.underTest.insertHaveMask(channel1, infohash1, channel1, 0x42, 1275295290)
self.underTest.insertHaveMask(channel1, infohash1, peer_id1, 0x42, 1275295291)
# newer then 1275295300
self.underTest.insertHaveMask(channel1, infohash1, peer_id2, 0x42, 1275295300)
self.underTest.insertHaveMask(channel1, infohash1, channel2, 0x42, 1275295301)
# older then 1275295300
self.underTest.insertHaveMask(channel2, infohash2, channel1, 0x42, 1275295290)
self.underTest.insertHaveMask(channel2, infohash2, peer_id1, 0x42, 1275295291)
# newer then 1275295300
self.underTest.insertHaveMask(channel2, infohash2, peer_id2, 0x42, 1275295300)
self.underTest.insertHaveMask(channel2, infohash2, channel2, 0x42, 1275295301)
self.underTest.cleanupOldHave(1275295300)
haveForEntry1 = self.underTest.getHaveEntries(channel1, infohash1)
expectedList1 = [(channel2,0x42,1275295301), (peer_id2, 0x42, 1275295300),
(channel1, 0x42, 1275295290)]
self.assertEquals(expectedList1, haveForEntry1)
haveForEntry2 = self.underTest.getHaveEntries(channel2, infohash2)
expectedList2 = [(channel2, 0x42, 1275295301),(peer_id2, 0x42, 1275295300)]
self.assertEquals(expectedList2,haveForEntry2)
import unittest
from Tribler.Core.Subtitles.MetadataDomainObjects.MetadataDTO import MetadataDTO
import Tribler.Core.Subtitles.MetadataDomainObjects.MetadataDTO as MDUtil
from Tribler.Core.Overlay.permid import generate_keypair
from Tribler.Core.CacheDB.sqlitecachedb import bin2str
import time
from Tribler.Core.Utilities.bencode import bdecode
from Tribler.Core.Subtitles.MetadataDomainObjects.SubtitleInfo import SubtitleInfo
from Tribler.Core.Subtitles.MetadataDomainObjects.Languages import LanguagesProvider
from Tribler.Core.Utilities.utilities import str2bin
import os.path
from struct import pack
RES_DIR = os.path.join('..', '..', '..', 'subtitles_test_res')
test_keypair = generate_keypair()
test_perm_id = str(test_keypair.pub().get_der())
class TestMetadataDTO(unittest.TestCase):
def setUp(self):
self._srtSubs = {
"eng": os.path.join(RES_DIR, "fake.srt"),
"ita": os.path.join(RES_DIR, "fake1.srt"),
"rus": os.path.join(RES_DIR, "fake2.srt")
}
def testMetadataDTOInit(self):
badInfohash = str2bin("GEh/o8rtTLB1wZJzFcSZSS4u9qo=")
dto = MetadataDTO(test_perm_id, badInfohash)
self.assertFalse(dto is None)
import unittest
from Tribler.Core.Subtitles.MetadataDomainObjects.MetadataDTO import MetadataDTO
import Tribler.Core.Subtitles.MetadataDomainObjects.MetadataDTO as MDUtil
from Tribler.Core.Overlay.permid import generate_keypair
from Tribler.Core.CacheDB.sqlitecachedb import bin2str
import time
from Tribler.Core.Utilities.bencode import bdecode
from Tribler.Core.Subtitles.MetadataDomainObjects.SubtitleInfo import SubtitleInfo
from Tribler.Core.Subtitles.MetadataDomainObjects.Languages import LanguagesProvider
from Tribler.Core.Utilities.utilities import str2bin
import os.path
from struct import pack
RES_DIR = os.path.join("..", "..", "..", "subtitles_test_res")
test_keypair = generate_keypair()
test_perm_id = str(test_keypair.pub().get_der())
class TestMetadataDTO(unittest.TestCase):
def setUp(self):
self._srtSubs = {
"eng": os.path.join(RES_DIR, "fake.srt"),
"ita": os.path.join(RES_DIR, "fake1.srt"),
"rus": os.path.join(RES_DIR, "fake2.srt"),
}
def testMetadataDTOInit(self):
badInfohash = str2bin("GEh/o8rtTLB1wZJzFcSZSS4u9qo=")
dto = MetadataDTO(test_perm_id, badInfohash)
self.assertFalse(dto is None)