def setUp(self, annotate=True):
super(TestDHTSession, self).setUp(annotate=annotate)
config = SessionStartupConfig()
config.set_state_dir(self.getStateDir())
self.session = Session(config, ignore_singleton=True)
self.dht_session = FakeDHTSession(self.session, 'a' * 20, 10)
def setUp(self, annotate=True):
super(TestDHTSession, self).setUp(annotate=annotate)
config = TriblerConfig()
config.set_state_dir(self.getStateDir())
self.session = Session(config)
self.dht_session = FakeDHTSession(self.session, 'a' * 20, 10)
class TestDHTSession(TriblerCoreTest):
"""
Test the DHT session that we use to fetch the swarm status from the DHT.
"""
def setUp(self):
super(TestDHTSession, self).setUp()
config = TriblerConfig()
config.set_state_dir(self.getStateDir())
self.session = Session(config)
self.session.lm.ltmgr = MockObject()
self.session.lm.ltmgr.dht_health_manager = MockObject()
dht_health_dict = {
"infohash": hexlify('a' * 20),
"seeders": 1,
"leechers": 2
}
self.session.lm.ltmgr.dht_health_manager.get_health = lambda *_, **__: succeed({"DHT": [dht_health_dict]})
self.dht_session = FakeDHTSession(self.session, 'a' * 20, 10)
@trial_timeout(10)
def test_cleanup(self):
"""
Test the cleanup of a DHT session
"""
return self.dht_session.cleanup()
@trial_timeout(10)
def test_connect_to_tracker(self):
"""
Test the metainfo lookup of the DHT session
"""
def verify_metainfo(metainfo):
self.assertTrue('DHT' in metainfo)
self.assertEqual(metainfo['DHT'][0]['leechers'], 2)
self.assertEqual(metainfo['DHT'][0]['seeders'], 1)
return self.dht_session.connect_to_tracker().addCallback(verify_metainfo)
def test_methods(self):
"""
Test various methods in the DHT session class
"""
self.dht_session.add_infohash('b' * 20)
self.assertEqual(self.dht_session.infohash, 'b' * 20)
def check_torrent_health(self, infohash, timeout=20, scrape_now=False):
"""
Check the health of a torrent with a given infohash.
:param infohash: Torrent infohash.
:param timeout: The timeout to use in the performed requests
:param scrape_now: Flag whether we want to force scraping immediately
"""
tracker_set = []
# We first check whether the torrent is already in the database and checked before
with db_session:
result = self.tribler_session.lm.mds.TorrentState.get(infohash=database_blob(infohash))
if result:
torrent_id = str(result.infohash)
last_check = result.last_check
time_diff = time.time() - last_check
if time_diff < MIN_TORRENT_CHECK_INTERVAL and not scrape_now:
self._logger.debug("time interval too short, not doing torrent health check for %s",
hexlify(infohash))
return succeed({
"db": {
"seeders": result.seeders,
"leechers": result.leechers,
"infohash": hexlify(infohash)
}
})
# get torrent's tracker list from DB
tracker_set = self.get_valid_trackers_of_torrent(torrent_id)
deferred_list = []
for tracker_url in tracker_set:
session = self._create_session_for_request(tracker_url, timeout=timeout)
session.add_infohash(infohash)
deferred_list.append(session.connect_to_tracker().
addCallbacks(*self.get_callbacks_for_session(session)))
# Create a (fake) DHT session for the lookup if we have support for BEP33.
if has_bep33_support():
session = FakeDHTSession(self.tribler_session, infohash, timeout)
self._session_list['DHT'].append(session)
deferred_list.append(session.connect_to_tracker().
addCallbacks(*self.get_callbacks_for_session(session)))
return DeferredList(deferred_list, consumeErrors=True).addCallback(
lambda res: self.on_torrent_health_check_completed(infohash, res))
def setUp(self):
super(TestDHTSession, self).setUp()
config = TriblerConfig()
config.set_state_dir(self.getStateDir())
self.session = Session(config)
self.session.lm.ltmgr = MockObject()
self.session.lm.ltmgr.dht_health_manager = MockObject()
dht_health_dict = {
"infohash": hexlify('a' * 20),
"seeders": 1,
"leechers": 2
}
self.session.lm.ltmgr.dht_health_manager.get_health = lambda *_, **__: succeed({"DHT": [dht_health_dict]})
self.dht_session = FakeDHTSession(self.session, 'a' * 20, 10)
def setUp(self):
super(TestDHTSession, self).setUp()
config = TriblerConfig()
config.set_state_dir(self.getStateDir())
self.session = Session(config)
self.dht_session = FakeDHTSession(self.session, 'a' * 20, 10)
def add_gui_request(self, infohash, timeout=20, scrape_now=False):
"""
Public API for adding a GUI request.
:param infohash: Torrent infohash.
:param timeout: The timeout to use in the performed requests
:param scrape_now: Flag whether we want to force scraping immediately
"""
result = self._torrent_db.getTorrent(
infohash, (u'torrent_id', u'last_tracker_check', u'num_seeders',
u'num_leechers'), False)
if result is None:
self._logger.warn(u"torrent info not found, skip. infohash: %s",
hexlify(infohash))
return fail(Failure(RuntimeError("Torrent not found")))
torrent_id = result[u'torrent_id']
last_check = result[u'last_tracker_check']
time_diff = time.time() - last_check
if time_diff < self._torrent_check_interval and not scrape_now:
self._logger.debug(
u"time interval too short, skip GUI request. infohash: %s",
hexlify(infohash))
return succeed({
"db": {
"seeders": result[u'num_seeders'],
"leechers": result[u'num_leechers'],
"infohash": infohash.encode('hex')
}
})
# get torrent's tracker list from DB
tracker_set = self.get_valid_trackers_of_torrent(torrent_id)
if not tracker_set:
self._logger.warn(u"no trackers, skip GUI request. infohash: %s",
hexlify(infohash))
# TODO: add code to handle torrents with no tracker
return fail(
Failure(
RuntimeError("No trackers available for this torrent")))
deferred_list = []
for tracker_url in tracker_set:
if tracker_url == u'DHT':
# Create a (fake) DHT session for the lookup
session = FakeDHTSession(self.tribler_session, infohash,
timeout)
self._session_list['DHT'].append(session)
deferred_list.append(session.connect_to_tracker().addCallbacks(
*self.get_callbacks_for_session(session)))
elif tracker_url != u'no-DHT':
session = self._create_session_for_request(tracker_url,
timeout=timeout)
session.add_infohash(infohash)
deferred_list.append(session.connect_to_tracker().addCallbacks(
*self.get_callbacks_for_session(session)))
return DeferredList(deferred_list, consumeErrors=True).addCallback(
lambda res: self.on_gui_request_completed(infohash, res))
class TestDHTSession(TriblerCoreTest):
"""
Test the DHT session that we use to fetch the swarm status from the DHT.
"""
def setUp(self, annotate=True):
super(TestDHTSession, self).setUp(annotate=annotate)
config = SessionStartupConfig()
config.set_state_dir(self.getStateDir())
self.session = Session(config, ignore_singleton=True)
self.dht_session = FakeDHTSession(self.session, 'a' * 20, 10)
@deferred(timeout=10)
def test_cleanup(self):
"""
Test the cleanup of a DHT session
"""
return self.dht_session.cleanup()
@deferred(timeout=10)
def test_connect_to_tracker(self):
"""
Test the metainfo lookup of the DHT session
"""
def get_metainfo(infohash, callback, **_):
callback({"seeders": 1, "leechers": 2})
def verify_metainfo(metainfo):
self.assertTrue('DHT' in metainfo)
self.assertEqual(metainfo['DHT'][0]['leechers'], 2)
self.assertEqual(metainfo['DHT'][0]['seeders'], 1)
self.session.lm.ltmgr = MockObject()
self.session.lm.ltmgr.get_metainfo = get_metainfo
return self.dht_session.connect_to_tracker().addCallback(
verify_metainfo)
@deferred(timeout=10)
def test_metainfo_timeout(self):
"""
Test the metainfo timeout of the DHT session
"""
test_deferred = Deferred()
def get_metainfo_timeout(*args, **kwargs):
timeout_cb = kwargs.get('timeout_callback')
timeout_cb('a' * 20)
def on_timeout(failure):
test_deferred.callback(None)
self.session.lm.ltmgr = MockObject()
self.session.lm.ltmgr.get_metainfo = get_metainfo_timeout
self.dht_session.connect_to_tracker().addErrback(on_timeout)
return test_deferred
def test_methods(self):
"""
Test various methods in the DHT session class
"""
self.assertTrue(self.dht_session.can_add_request())
self.dht_session.add_infohash('b' * 20)
self.assertEqual(self.dht_session.infohash, 'b' * 20)
self.assertEqual(self.dht_session.max_retries, DHT_TRACKER_MAX_RETRIES)
self.assertEqual(self.dht_session.retry_interval,
DHT_TRACKER_RECHECK_INTERVAL)
self.assertGreater(self.dht_session.last_contact, 0)
class TestDHTSession(TriblerCoreTest):
"""
Test the DHT session that we use to fetch the swarm status from the DHT.
"""
def setUp(self):
super(TestDHTSession, self).setUp()
config = TriblerConfig()
config.set_state_dir(self.getStateDir())
self.session = Session(config)
self.dht_session = FakeDHTSession(self.session, 'a' * 20, 10)
@trial_timeout(10)
def test_cleanup(self):
"""
Test the cleanup of a DHT session
"""
return self.dht_session.cleanup()
@trial_timeout(10)
def test_connect_to_tracker(self):
"""
Test the metainfo lookup of the DHT session
"""
def get_metainfo(infohash, callback, **_):
callback({"seeders": 1, "leechers": 2})
def verify_metainfo(metainfo):
self.assertTrue('DHT' in metainfo)
self.assertEqual(metainfo['DHT'][0]['leechers'], 2)
self.assertEqual(metainfo['DHT'][0]['seeders'], 1)
self.session.lm.ltmgr = MockObject()
self.session.lm.ltmgr.get_metainfo = get_metainfo
return self.dht_session.connect_to_tracker().addCallback(verify_metainfo)
@trial_timeout(10)
def test_metainfo_timeout(self):
"""
Test the metainfo timeout of the DHT session
"""
test_deferred = Deferred()
def get_metainfo_timeout(*args, **kwargs):
timeout_cb = kwargs.get('timeout_callback')
timeout_cb('a' * 20)
def on_timeout(failure):
test_deferred.callback(None)
self.session.lm.ltmgr = MockObject()
self.session.lm.ltmgr.get_metainfo = get_metainfo_timeout
self.dht_session.connect_to_tracker().addErrback(on_timeout)
return test_deferred
def test_methods(self):
"""
Test various methods in the DHT session class
"""
self.assertTrue(self.dht_session.can_add_request())
self.dht_session.add_infohash('b' * 20)
self.assertEqual(self.dht_session.infohash, 'b' * 20)
self.assertEqual(self.dht_session.max_retries, DHT_TRACKER_MAX_RETRIES)
self.assertEqual(self.dht_session.retry_interval, DHT_TRACKER_RECHECK_INTERVAL)
self.assertGreater(self.dht_session.last_contact, 0)