def run():
crypto = ECCrypto()
dispersy = Dispersy(
StandaloneEndpoint(options["port"], options["ip"]),
options["statedir"], u'dispersy.db', crypto)
if not dispersy.start():
raise RuntimeError("Unable to start Dispersy")
master_member = TriblerChainCommunityCrawler.get_master_members(
dispersy)[0]
my_member = dispersy.get_member(private_key=crypto.key_to_bin(
crypto.generate_key(u"curve25519")))
TriblerChainCommunityCrawler.init_community(
dispersy, master_member, my_member)
self._stopping = False
def signal_handler(sig, frame):
msg("Received signal '%s' in %s (shutting down)" %
(sig, frame))
if not self._stopping:
self._stopping = True
dispersy.stop().addCallback(lambda _: reactor.stop())
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)
def setUp(self, annotate=True, autoload_discovery=True):
"""
Setup some classes and files that are used by the tests in this module.
"""
yield super(BaseTestChannel,
self).setUp(autoload_discovery=autoload_discovery)
if annotate:
self.annotate(self._testMethodName, start=True)
self.fake_session = MockObject()
self.fake_session.get_state_dir = lambda: self.session_base_dir
self.fake_session.add_observer = lambda a, b, c: False
fake_notifier = MockObject()
fake_notifier.add_observer = lambda a, b, c, d: False
fake_notifier.notify = lambda a, b, c, d: False
self.fake_session.notifier = fake_notifier
self.fake_channel_community = MockObject()
self.fake_channel_community.get_channel_id = lambda: 42
self.fake_channel_community.cid = 'a' * 20
self.fake_channel_community.get_channel_name = lambda: "my fancy channel"
self.channel_db_handler = self.session.open_dbhandler(NTFY_CHANNELCAST)
self.votecast_db_handler = self.session.open_dbhandler(NTFY_VOTECAST)
self.session.get_dispersy = lambda: True
self.session.lm.dispersy = Dispersy(ManualEnpoint(0),
self.getStateDir())
def setUp(self):
super(TestBarterStatistics, self).setUp()
self.stats = BarterStatistics()
self._peer1 = "peer1"
self._peer2 = "peer2"
self._peer3 = "peer3"
self._peer4 = "peer4"
self._peer5 = "peer5"
self.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir())
def setUp(self, annotate=True, autoload_discovery=True):
yield super(TestBoostingManagerSysChannel, self).setUp()
self.channel_db_handler = self.session.open_dbhandler(NTFY_CHANNELCAST)
self.channel_db_handler._get_my_dispersy_cid = lambda: "myfakedispersyid"
self.session.config.get_dispersy_enabled = lambda: True
self.session.lm.dispersy = Dispersy(ManualEnpoint(0),
self.getStateDir())
self.dispersy_cid_hex = "abcd" * 9 + "0012"
self.dispersy_cid = binascii.unhexlify(self.dispersy_cid_hex)
def setUp(self, autoload_discovery=True):
yield super(TestCircuitDebugEndpoint, self).setUp(autoload_discovery=autoload_discovery)
self.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir())
self.dispersy._database.open()
master_member = DummyMember(self.dispersy, 1, "a" * 20)
member = self.dispersy.get_new_member(u"curve25519")
self.tunnel_community = HiddenTunnelCommunity(self.dispersy, master_member, member)
self.dispersy.get_communities = lambda: [self.tunnel_community]
self.session.get_dispersy_instance = lambda: self.dispersy
def setUp(self, autoload_discovery=True):
yield super(TestTrustchainStatsEndpoint, self).setUp(autoload_discovery=autoload_discovery)
self.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir())
self.dispersy._database.open()
master_member = DummyMember(self.dispersy, 1, "a" * 20)
self.member = self.dispersy.get_new_member(u"curve25519")
self.tc_community = TriblerChainCommunity(self.dispersy, master_member, self.member)
self.dispersy.get_communities = lambda: [self.tc_community]
self.session.get_dispersy_instance = lambda: self.dispersy
def test_chn_exist_lookup(self):
"""
testing existing channel as a source.
It also tests how boosting manager cope with unknown channel with retrying
the lookup
"""
self.session.get_dispersy = lambda: True
self.session.lm.dispersy = Dispersy(ManualEnpoint(0),
self.getStateDir())
dispersy_cid_hex = "abcd" * 9 + "0012"
dispersy_cid = binascii.unhexlify(dispersy_cid_hex)
# create channel and insert torrent
self.create_fake_allchannel_community()
self.create_torrents_in_channel(dispersy_cid_hex)
# channel is exist
community = ChannelCommunity.init_community(
self.session.lm.dispersy,
self.session.lm.dispersy.get_member(mid=dispersy_cid),
self.session.lm.dispersy._communities['allchannel']._my_member,
self.session)
# make the id unknown so boosting manager can test repeating search
id_tmp = community._channel_id
community._channel_id = 0
def _set_id_channel(channel_id):
"""
set channel id manually (emulate finding)
"""
community._channel_id = channel_id
reactor.callLater(5, _set_id_channel, id_tmp)
self.boosting_manager.add_source(dispersy_cid)
chn_obj = self.boosting_manager.get_source_object(dispersy_cid)
chn_obj._load_torrent = self._load
def clean_community(_):
"""
cleanly exit the community we are in
"""
if chn_obj.community:
chn_obj.community.cancel_all_pending_tasks()
chn_obj.kill_tasks()
d = self.check_source(dispersy_cid)
d.addCallback(clean_community)
return d
def test_chn_native_load(self):
self.session.get_dispersy = lambda: True
self.session.lm.dispersy = Dispersy(ManualEnpoint(0),
self.getStateDir())
dispersy_cid_hex = "abcd" * 9 + "0012"
dispersy_cid = binascii.unhexlify(dispersy_cid_hex)
# create channel and insert torrent
self.create_fake_allchannel_community()
self.create_torrents_in_channel(dispersy_cid_hex)
self.session.download_torrentfile = \
lambda dummy_ihash, function, _: function(binascii.hexlify(TORRENT_UBUNTU_FILE_INFOHASH))
def get_bin_torrent(_):
"""
get binary data of a torrent
"""
f = open(TORRENT_UBUNTU_FILE, "rb")
bdata = f.read()
f.close()
return bdata
self.session.get_collected_torrent = get_bin_torrent
self.boosting_manager.add_source(dispersy_cid)
def _loop_check(_):
defer_param = defer.Deferred()
def check_loaded(src):
"""
check if a torrent has been loaded
"""
src_obj = self.boosting_manager.get_source_object(src)
if src_obj.loaded_torrent[
TORRENT_UBUNTU_FILE_INFOHASH] is not None:
src_obj.community.cancel_all_pending_tasks()
src_obj.kill_tasks()
self.check_loaded_lc.stop()
self.check_loaded_lc = None
defer_param.callback(src)
self.check_loaded_lc = LoopingCall(check_loaded, dispersy_cid)
self.check_loaded_lc.start(1, now=True)
return defer_param
defer_ret = self.check_source(dispersy_cid)
defer_ret.addCallback(_loop_check)
return defer_ret
def start_dispersy(self):
msg("Starting dispersy")
# We need to import the stuff _AFTER_ configuring the logging stuff.
from Tribler.dispersy.callback import Callback
from Tribler.dispersy.dispersy import Dispersy
from Tribler.dispersy.endpoint import StandaloneEndpoint
self._dispersy = Dispersy(
Callback("Dispersy"),
StandaloneEndpoint(int(self.my_id) + 12000, '0.0.0.0'), u'.',
self._database_file)
self._dispersy.statistics.enable_debug_statistics(True)
if self._strict:
def exception_handler(exception, fatal):
msg("An exception occurred. Quitting because we are running with --strict enabled."
)
print "Exception was:"
try:
raise exception
except:
from traceback import print_exc
print_exc()
# Set Dispersy's exit status to error
self._dispersy_exit_status = 1
# Stop the experiment
reactor.callLater(1, self.stop)
return True
self._dispersy.callback.attach_exception_handler(exception_handler)
self._dispersy.start()
# low (NID_sect233k1) isn't actually that low, switching to 160bits as this is comparable to rsa 1024
# http://www.nsa.gov/business/programs/elliptic_curve.shtml
# speed difference when signing/verifying 100 items
# NID_sect233k1 signing took 0.171 verify took 0.35 totals 0.521
# NID_secp160k1 signing took 0.04 verify took 0.04 totals 0.08
self._my_member = self._dispersy.callback.call(
self._dispersy.get_new_member, (u"NID_secp160k1", ))
self._master_member = self._dispersy.callback.call(
self._dispersy.get_member, (self.master_key, ))
self._dispersy.callback.register(self._do_log)
msg("Finished starting dispersy")
def setUp(self):
"""
The startup method of this class creates a fake Dispersy instance with a fake AllChannel community. It also
inserts some random channels so we have some data to work with.
"""
yield super(TestChannelsSubscriptionEndpoint, self).setUp()
self.expected_votecast_cid = None
self.expected_votecast_vote = None
self.create_votecast_called = False
fake_community = self.create_fake_allchannel_community()
fake_community.disp_create_votecast = self.on_dispersy_create_votecast
self.session.config.get_dispersy_enabled = lambda: True
self.session.lm.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir())
self.session.lm.dispersy.attach_community(fake_community)
for i in xrange(0, 10):
self.insert_channel_in_db('rand%d' % i, 42 + i, 'Test channel %d' % i, 'Test description %d' % i)
def start_dispersy(self, autoload_discovery=True):
msg("Starting dispersy")
# We need to import the stuff _AFTER_ configuring the logging stuff.
try:
from Tribler.dispersy.dispersy import Dispersy
from Tribler.dispersy.endpoint import StandaloneEndpoint
from Tribler.dispersy.util import unhandled_error_observer
except:
from dispersy.dispersy import Dispersy
from dispersy.endpoint import StandaloneEndpoint
from dispersy.util import unhandled_error_observer
self._dispersy = Dispersy(
StandaloneEndpoint(int(self.my_id) + 12000, '0.0.0.0'), u'.',
self._database_file, self._crypto)
self._dispersy.statistics.enable_debug_statistics(True)
self.original_on_incoming_packets = self._dispersy.on_incoming_packets
if self._strict:
from twisted.python.log import addObserver
addObserver(unhandled_error_observer)
self._dispersy.start(autoload_discovery=autoload_discovery)
if self.master_private_key:
self._master_member = self._dispersy.get_member(
private_key=self.master_private_key)
else:
self._master_member = self._dispersy.get_member(
public_key=self.master_key)
self._my_member = self._dispersy.get_member(
private_key=self.my_member_private_key)
assert self._master_member
assert self._my_member
self._do_log()
self.print_on_change('community-kwargs', {}, self.community_kwargs)
self.print_on_change('community-env', {}, {'pid': getpid()})
msg("Finished starting dispersy")
def setUp(self, annotate=True):
yield super(AbstractTestCommunity, self).setUp(annotate=annotate)
self.dispersy = Dispersy(ManualEnpoint(0), self.getStateDir())
self.dispersy._database.open()
self.master_member = DummyMember(self.dispersy, 1, "a" * 20)
self.member = self.dispersy.get_new_member(u"curve25519")
def register(self, session, session_lock):
assert isInIOThread()
if not self.registered:
self.registered = True
self.session = session
self.session_lock = session_lock
# On Mac, we bundle the root certificate for the SSL validation since Twisted is not using the root
# certificates provided by the system trust store.
if sys.platform == 'darwin':
os.environ['SSL_CERT_FILE'] = os.path.join(
get_lib_path(), 'root_certs_mac.pem')
if self.session.config.get_torrent_store_enabled():
from Tribler.Core.leveldbstore import LevelDbStore
self.torrent_store = LevelDbStore(
self.session.config.get_torrent_store_dir())
if not self.torrent_store.get_db():
raise RuntimeError(
"Torrent store (leveldb) is None which should not normally happen"
)
if self.session.config.get_metadata_enabled():
from Tribler.Core.leveldbstore import LevelDbStore
self.metadata_store = LevelDbStore(
self.session.config.get_metadata_store_dir())
if not self.metadata_store.get_db():
raise RuntimeError(
"Metadata store (leveldb) is None which should not normally happen"
)
# torrent collecting: RemoteTorrentHandler
if self.session.config.get_torrent_collecting_enabled():
from Tribler.Core.RemoteTorrentHandler import RemoteTorrentHandler
self.rtorrent_handler = RemoteTorrentHandler(self.session)
# TODO(emilon): move this to a megacache component or smth
if self.session.config.get_megacache_enabled():
from Tribler.Core.CacheDB.SqliteCacheDBHandler import (
PeerDBHandler, TorrentDBHandler, MyPreferenceDBHandler,
VoteCastDBHandler, ChannelCastDBHandler)
from Tribler.Core.Category.Category import Category
self._logger.debug('tlm: Reading Session state from %s',
self.session.config.get_state_dir())
self.category = Category()
# create DBHandlers
self.peer_db = PeerDBHandler(self.session)
self.torrent_db = TorrentDBHandler(self.session)
self.mypref_db = MyPreferenceDBHandler(self.session)
self.votecast_db = VoteCastDBHandler(self.session)
self.channelcast_db = ChannelCastDBHandler(self.session)
# initializes DBHandlers
self.peer_db.initialize()
self.torrent_db.initialize()
self.mypref_db.initialize()
self.votecast_db.initialize()
self.channelcast_db.initialize()
from Tribler.Core.Modules.tracker_manager import TrackerManager
self.tracker_manager = TrackerManager(self.session)
if self.session.config.get_video_server_enabled():
self.video_server = VideoServer(
self.session.config.get_video_server_port(), self.session)
self.video_server.start()
# IPv8
if self.session.config.get_ipv8_enabled():
from Tribler.pyipv8.ipv8.configuration import get_default_configuration
ipv8_config = get_default_configuration()
ipv8_config['port'] = self.session.config.get_dispersy_port()
ipv8_config['address'] = self.session.config.get_ipv8_address()
ipv8_config['overlays'] = []
ipv8_config['keys'] = [] # We load the keys ourselves
if self.session.config.get_ipv8_bootstrap_override():
import Tribler.pyipv8.ipv8.deprecated.community as community_file
community_file._DEFAULT_ADDRESSES = [
self.session.config.get_ipv8_bootstrap_override()
]
community_file._DNS_ADDRESSES = []
self.ipv8 = IPv8(ipv8_config)
self.session.config.set_anon_proxy_settings(
2, ("127.0.0.1",
self.session.config.
get_tunnel_community_socks5_listen_ports()))
# Dispersy
self.tftp_handler = None
if self.session.config.get_dispersy_enabled():
from Tribler.dispersy.dispersy import Dispersy
from Tribler.dispersy.endpoint import MIMEndpoint
from Tribler.dispersy.endpoint import IPv8toDispersyAdapter
# set communication endpoint
if self.session.config.get_ipv8_enabled():
dispersy_endpoint = IPv8toDispersyAdapter(
self.ipv8.endpoint)
else:
dispersy_endpoint = MIMEndpoint(
self.session.config.get_dispersy_port())
working_directory = unicode(
self.session.config.get_state_dir())
self.dispersy = Dispersy(dispersy_endpoint, working_directory)
self.dispersy.statistics.enable_debug_statistics(False)
# register TFTP service
from Tribler.Core.TFTP.handler import TftpHandler
self.tftp_handler = TftpHandler(self.session,
dispersy_endpoint,
"fffffffd".decode('hex'),
block_size=1024)
self.tftp_handler.initialize()
# Torrent search
if self.session.config.get_torrent_search_enabled(
) or self.session.config.get_channel_search_enabled():
self.search_manager = SearchManager(self.session)
self.search_manager.initialize()
if not self.initComplete:
self.init()
self.session.add_observer(self.on_tribler_started, NTFY_TRIBLER,
[NTFY_STARTED])
self.session.notifier.notify(NTFY_TRIBLER, NTFY_STARTED, None)
return self.startup_deferred
def register(self, session, session_lock):
assert isInIOThread()
if not self.registered:
self.registered = True
self.session = session
self.session_lock = session_lock
# On Mac, we bundle the root certificate for the SSL validation since Twisted is not using the root
# certificates provided by the system trust store.
if sys.platform == 'darwin':
os.environ['SSL_CERT_FILE'] = os.path.join(
get_lib_path(), 'root_certs_mac.pem')
if self.session.config.get_torrent_store_enabled():
from Tribler.Core.leveldbstore import LevelDbStore
self.torrent_store = LevelDbStore(
self.session.config.get_torrent_store_dir())
if self.session.config.get_metadata_enabled():
from Tribler.Core.leveldbstore import LevelDbStore
self.metadata_store = LevelDbStore(
self.session.config.get_metadata_store_dir())
# torrent collecting: RemoteTorrentHandler
if self.session.config.get_torrent_collecting_enabled():
from Tribler.Core.RemoteTorrentHandler import RemoteTorrentHandler
self.rtorrent_handler = RemoteTorrentHandler(self.session)
# TODO(emilon): move this to a megacache component or smth
if self.session.config.get_megacache_enabled():
from Tribler.Core.CacheDB.SqliteCacheDBHandler import (
PeerDBHandler, TorrentDBHandler, MyPreferenceDBHandler,
VoteCastDBHandler, ChannelCastDBHandler)
from Tribler.Core.Category.Category import Category
self._logger.debug('tlm: Reading Session state from %s',
self.session.config.get_state_dir())
self.category = Category()
# create DBHandlers
self.peer_db = PeerDBHandler(self.session)
self.torrent_db = TorrentDBHandler(self.session)
self.mypref_db = MyPreferenceDBHandler(self.session)
self.votecast_db = VoteCastDBHandler(self.session)
self.channelcast_db = ChannelCastDBHandler(self.session)
# initializes DBHandlers
self.peer_db.initialize()
self.torrent_db.initialize()
self.mypref_db.initialize()
self.votecast_db.initialize()
self.channelcast_db.initialize()
from Tribler.Core.Modules.tracker_manager import TrackerManager
self.tracker_manager = TrackerManager(self.session)
if self.session.config.get_video_server_enabled():
self.video_server = VideoServer(
self.session.config.get_video_server_port(), self.session)
self.video_server.start()
# Dispersy
self.tftp_handler = None
if self.session.config.get_dispersy_enabled():
from Tribler.dispersy.dispersy import Dispersy
from Tribler.dispersy.endpoint import StandaloneEndpoint
# set communication endpoint
endpoint = StandaloneEndpoint(
self.session.config.get_dispersy_port())
working_directory = unicode(
self.session.config.get_state_dir())
self.dispersy = Dispersy(endpoint, working_directory)
# register TFTP service
from Tribler.Core.TFTP.handler import TftpHandler
self.tftp_handler = TftpHandler(self.session,
endpoint,
"fffffffd".decode('hex'),
block_size=1024)
self.tftp_handler.initialize()
if self.session.config.get_torrent_search_enabled(
) or self.session.config.get_channel_search_enabled():
self.search_manager = SearchManager(self.session)
self.search_manager.initialize()
if not self.initComplete:
self.init()
self.session.add_observer(self.on_tribler_started, NTFY_TRIBLER,
[NTFY_STARTED])
self.session.notifier.notify(NTFY_TRIBLER, NTFY_STARTED, None)
return self.startup_deferred
def register(self, session, sesslock):
assert isInIOThread()
if not self.registered:
self.registered = True
self.session = session
self.sesslock = sesslock
if self.session.get_torrent_store():
from Tribler.Core.leveldbstore import LevelDbStore
self.torrent_store = LevelDbStore(
self.session.get_torrent_store_dir())
if self.session.get_enable_metadata():
from Tribler.Core.leveldbstore import LevelDbStore
self.metadata_store = LevelDbStore(
self.session.get_metadata_store_dir())
# torrent collecting: RemoteTorrentHandler
if self.session.get_torrent_collecting():
from Tribler.Core.RemoteTorrentHandler import RemoteTorrentHandler
self.rtorrent_handler = RemoteTorrentHandler(self.session)
# TODO(emilon): move this to a megacache component or smth
if self.session.get_megacache():
from Tribler.Core.CacheDB.SqliteCacheDBHandler import (
PeerDBHandler, TorrentDBHandler, MyPreferenceDBHandler,
VoteCastDBHandler, ChannelCastDBHandler)
from Tribler.Core.Category.Category import Category
self._logger.debug('tlm: Reading Session state from %s',
self.session.get_state_dir())
self.category = Category()
# create DBHandlers
self.peer_db = PeerDBHandler(self.session)
self.torrent_db = TorrentDBHandler(self.session)
self.mypref_db = MyPreferenceDBHandler(self.session)
self.votecast_db = VoteCastDBHandler(self.session)
self.channelcast_db = ChannelCastDBHandler(self.session)
# initializes DBHandlers
self.peer_db.initialize()
self.torrent_db.initialize()
self.mypref_db.initialize()
self.votecast_db.initialize()
self.channelcast_db.initialize()
from Tribler.Core.Modules.tracker_manager import TrackerManager
self.tracker_manager = TrackerManager(self.session)
self.tracker_manager.initialize()
if self.session.get_videoserver_enabled():
self.video_server = VideoServer(
self.session.get_videoserver_port(), self.session)
self.video_server.start()
# Dispersy
self.tftp_handler = None
if self.session.get_dispersy():
from Tribler.dispersy.dispersy import Dispersy
from Tribler.dispersy.endpoint import StandaloneEndpoint
# set communication endpoint
endpoint = StandaloneEndpoint(self.session.get_dispersy_port(),
ip=self.session.get_ip())
working_directory = unicode(self.session.get_state_dir())
self.dispersy = Dispersy(endpoint, working_directory)
# register TFTP service
from Tribler.Core.TFTP.handler import TftpHandler
self.tftp_handler = TftpHandler(self.session,
endpoint,
"fffffffd".decode('hex'),
block_size=1024)
self.tftp_handler.initialize()
if self.session.get_enable_torrent_search(
) or self.session.get_enable_channel_search():
self.search_manager = SearchManager(self.session)
self.search_manager.initialize()
if not self.initComplete:
self.init()
self.session.add_observer(self.on_tribler_started, NTFY_TRIBLER,
[NTFY_STARTED])
self.session.notifier.notify(NTFY_TRIBLER, NTFY_STARTED, None)
return self.startup_deferred
def test_chn_max_torrents(self):
"""
Test the restriction of max_torrents in a source.
"""
self.session.get_dispersy = lambda: True
self.session.lm.dispersy = Dispersy(ManualEnpoint(0),
self.getStateDir())
dispersy_cid_hex = "abcd" * 9 + "0012"
dispersy_cid = binascii.unhexlify(dispersy_cid_hex)
# create channel and insert torrent
self.create_fake_allchannel_community()
self.create_torrents_in_channel(dispersy_cid_hex)
pioneer_file = os.path.join(
TESTS_DATA_DIR, "Pioneer.One.S01E06.720p.x264-VODO.torrent")
pioneer_tdef = TorrentDef.load(pioneer_file)
pioneer_ihash = binascii.unhexlify(
"66ED7F30E3B30FA647ABAA19A36E7503AA071535")
torrent_list = [[
self.channel_id, 1, 1, pioneer_ihash, 1460000001, pioneer_file,
pioneer_tdef.get_files_as_unicode_with_length(),
pioneer_tdef.get_trackers_as_single_tuple()
]]
self.insert_torrents_into_channel(torrent_list)
self.boosting_manager.add_source(dispersy_cid)
chn_obj = self.boosting_manager.get_source_object(dispersy_cid)
chn_obj.max_torrents = 2
chn_obj.torrent_mgr.load_torrent = lambda dummy_1, dummy_2: None
def _load(torrent, callback=None):
if not isinstance(torrent, CollectedTorrent):
torrent_id = 0
if torrent.torrent_id <= 0:
torrent_id = self.session.lm.torrent_db.getTorrentID(
torrent.infohash)
if torrent_id:
torrent.update_torrent_id(torrent_id)
infohash_str = binascii.hexlify(torrent.infohash)
torrent = CollectedTorrent(
torrent, self.tdef
if infohash_str.startswith("fc") else pioneer_tdef)
if callback is not None:
callback(torrent)
else:
return torrent
def activate_mgr():
"""
activate ltmgr and adjust max torrents to emulate overflow torrents
"""
chn_obj.max_torrents = 1
chn_obj.torrent_mgr.load_torrent = _load
reactor.callLater(5, activate_mgr)
def check_torrents_channel(src, defer_param=None):
"""
check if a torrent already in channel and ready to download
"""
if defer_param is None:
defer_param = defer.Deferred()
src_obj = self.boosting_manager.get_source_object(src)
success = True
if len(src_obj.unavail_torrent) == 0:
self.assertLessEqual(len(src_obj.torrents),
src_obj.max_torrents)
else:
success = False
reactor.callLater(1, check_torrents_channel, src, defer_param)
if success:
src_obj.community.cancel_all_pending_tasks()
src_obj.kill_tasks()
defer_param.callback(src)
return defer_param
d = self.check_source(dispersy_cid)
d.addCallback(check_torrents_channel)
return d
def test_chn_lookup(self):
"""
testing channel source.
It includes finding and downloading actual torrent
"""
self.session.get_dispersy = lambda: True
self.session.lm.dispersy = Dispersy(ManualEnpoint(0),
self.getStateDir())
dispersy_cid_hex = "abcd" * 9 + "0012"
dispersy_cid = binascii.unhexlify(dispersy_cid_hex)
# create channel and insert torrent
self.create_fake_allchannel_community()
self.create_torrents_in_channel(dispersy_cid_hex)
self.boosting_manager.add_source(dispersy_cid)
chn_obj = self.boosting_manager.get_source_object(dispersy_cid)
def _load(torrent, callback=None):
if not isinstance(torrent, CollectedTorrent):
torrent_id = 0
if torrent.torrent_id <= 0:
torrent_id = self.session.lm.torrent_db.getTorrentID(
torrent.infohash)
if torrent_id:
torrent.update_torrent_id(torrent_id)
torrent = CollectedTorrent(torrent, self.tdef)
if callback is not None:
callback(torrent)
else:
return torrent
def check_torrents_channel(src, defer_param=None, target=1):
"""
check if a torrent already in channel and ready to download
"""
if defer_param is None:
defer_param = defer.Deferred()
src_obj = self.boosting_manager.get_source_object(src)
success = True
if not src_obj or len(src_obj.torrents) < target:
success = False
reactor.callLater(1,
check_torrents_channel,
src,
defer_param,
target=target)
elif not self.boosting_manager.torrents.get(
TORRENT_FILE_INFOHASH, None):
success = False
reactor.callLater(1,
check_torrents_channel,
src,
defer_param,
target=target)
elif not self.boosting_manager.torrents[TORRENT_FILE_INFOHASH].get(
'download', None):
success = False
reactor.callLater(1,
check_torrents_channel,
src,
defer_param,
target=target)
if success:
self.boosting_manager.set_enable_mining(src,
False,
force_restart=True)
if src_obj.community:
src_obj.community.cancel_all_pending_tasks()
defer_param.callback(src)
return defer_param
chn_obj.torrent_mgr.load_torrent = _load
d = self.check_source(dispersy_cid)
d.addCallback(check_torrents_channel, target=1)
return d
def register(self, session, sesslock):
if not self.registered:
self.registered = True
self.session = session
self.sesslock = sesslock
self.downloads = {}
config = session.sessconfig # Should be safe at startup
self.upnp_ports = []
# Orig
self.sessdoneflag = Event()
self.rawserver = RawServer(
self.sessdoneflag,
config['timeout_check_interval'],
config['timeout'],
ipv6_enable=config['ipv6_enabled'],
failfunc=self.rawserver_fatalerrorfunc,
errorfunc=self.rawserver_nonfatalerrorfunc)
self.rawserver.add_task(self.rawserver_keepalive, 1)
self.listen_port = config['minport']
self.shutdownstarttime = None
self.multihandler = MultiHandler(self.rawserver, self.sessdoneflag)
# SWIFTPROC
swift_exists = config['swiftproc'] and (
os.path.exists(config['swiftpath'])
or os.path.exists(config['swiftpath'] + '.exe'))
if swift_exists:
from Tribler.Core.Swift.SwiftProcessMgr import SwiftProcessMgr
self.spm = SwiftProcessMgr(
config['swiftpath'], config['swiftcmdlistenport'],
config['swiftdlsperproc'],
self.session.get_swift_tunnel_listen_port(), self.sesslock)
try:
self.swift_process = self.spm.get_or_create_sp(
self.session.get_swift_working_dir(),
self.session.get_torrent_collecting_dir(),
self.session.get_swift_tunnel_listen_port(),
self.session.get_swift_tunnel_httpgw_listen_port(),
self.session.get_swift_tunnel_cmdgw_listen_port())
self.upnp_ports.append(
(self.session.get_swift_tunnel_listen_port(), 'UDP'))
except OSError:
# could not find/run swift
print >> sys.stderr, "lmc: could not start a swift process"
else:
self.spm = None
self.swift_process = None
# Dispersy
self.session.dispersy_member = None
if config['dispersy']:
from Tribler.dispersy.callback import Callback
from Tribler.dispersy.dispersy import Dispersy
from Tribler.dispersy.endpoint import RawserverEndpoint, TunnelEndpoint
from Tribler.dispersy.community import HardKilledCommunity
# set communication endpoint
if config['dispersy-tunnel-over-swift'] and self.swift_process:
endpoint = TunnelEndpoint(self.swift_process)
else:
endpoint = RawserverEndpoint(self.rawserver,
config['dispersy_port'])
callback = Callback("Dispersy") # WARNING NAME SIGNIFICANT
working_directory = unicode(config['state_dir'])
self.dispersy = Dispersy(callback, endpoint, working_directory)
# TODO: see if we can postpone dispersy.start to improve GUI responsiveness.
# However, for now we must start self.dispersy.callback before running
# try_register(nocachedb, self.database_thread)!
self.dispersy.start()
print >> sys.stderr, "lmc: Dispersy is listening on port", self.dispersy.wan_address[
1], "using", endpoint
self.upnp_ports.append((self.dispersy.wan_address[1], 'UDP'))
self.dispersy.callback.call(self.dispersy.define_auto_load,
args=(HardKilledCommunity, ),
kargs={'load': True})
# notify dispersy finished loading
self.session.uch.notify(NTFY_DISPERSY, NTFY_STARTED, None)
from Tribler.Core.permid import read_keypair
from Tribler.dispersy.crypto import ec_to_public_bin, ec_to_private_bin
keypair = read_keypair(
self.session.get_permid_keypair_filename())
self.session.dispersy_member = callback.call(
self.dispersy.get_member,
(ec_to_public_bin(keypair), ec_to_private_bin(keypair)))
self.database_thread = callback
else:
class FakeCallback():
def __init__(self):
from Tribler.Utilities.TimedTaskQueue import TimedTaskQueue
self.queue = TimedTaskQueue("FakeCallback")
def register(self,
call,
args=(),
kargs=None,
delay=0.0,
priority=0,
id_=u"",
callback=None,
callback_args=(),
callback_kargs=None,
include_id=False):
def do_task():
if kargs:
call(*args, **kargs)
else:
call(*args)
if callback:
if callback_kargs:
callback(*callback_args, **callback_kargs)
else:
callback(*callback_args)
self.queue.add_task(do_task, t=delay)
def shutdown(self, immediately=False):
self.queue.shutdown(immediately)
self.database_thread = FakeCallback()
if config['megacache']:
import Tribler.Core.CacheDB.cachedb as cachedb
from Tribler.Core.CacheDB.SqliteCacheDBHandler import PeerDBHandler, TorrentDBHandler, MyPreferenceDBHandler, VoteCastDBHandler, ChannelCastDBHandler, NetworkBuzzDBHandler, UserEventLogDBHandler
from Tribler.Category.Category import Category
from Tribler.Core.Tag.Extraction import TermExtraction
from Tribler.Core.CacheDB.sqlitecachedb import try_register
if DEBUG:
print >> sys.stderr, 'tlm: Reading Session state from', config[
'state_dir']
nocachedb = cachedb.init(config, self.rawserver_fatalerrorfunc)
try_register(nocachedb, self.database_thread)
self.cat = Category.getInstance(config['install_dir'])
self.term = TermExtraction.getInstance(config['install_dir'])
self.peer_db = PeerDBHandler.getInstance()
self.peer_db.registerConnectionUpdater(self.session)
self.torrent_db = TorrentDBHandler.getInstance()
self.torrent_db.register(
os.path.abspath(config['torrent_collecting_dir']))
self.mypref_db = MyPreferenceDBHandler.getInstance()
self.votecast_db = VoteCastDBHandler.getInstance()
self.votecast_db.registerSession(self.session)
self.channelcast_db = ChannelCastDBHandler.getInstance()
self.channelcast_db.registerSession(self.session)
self.nb_db = NetworkBuzzDBHandler.getInstance()
self.ue_db = UserEventLogDBHandler.getInstance()
if self.dispersy:
self.dispersy.database.attach_commit_callback(
self.channelcast_db._db.commitNow)
else:
config['torrent_checking'] = 0
self.rtorrent_handler = None
if config['torrent_collecting']:
from Tribler.Core.RemoteTorrentHandler import RemoteTorrentHandler
self.rtorrent_handler = RemoteTorrentHandler()
def test_chn_lookup(self):
"""
testing channel source.
It includes finding and downloading actual torrent
"""
self.session.get_dispersy = lambda: True
self.session.lm.dispersy = Dispersy(ManualEnpoint(0),
self.getStateDir())
dispersy_cid_hex = "abcd" * 9 + "0012"
dispersy_cid = binascii.unhexlify(dispersy_cid_hex)
# create channel and insert torrent
self.create_fake_allchannel_community()
self.create_torrents_in_channel(dispersy_cid_hex)
self.boosting_manager.add_source(dispersy_cid)
chn_obj = self.boosting_manager.get_source_object(dispersy_cid)
def check_torrents_channel(src, defer_param=None, target=1):
"""
check if a torrent already in channel and ready to download
"""
if defer_param is None:
defer_param = defer.Deferred()
src_obj = self.boosting_manager.get_source_object(src)
success = True
if not src_obj or len(src_obj.torrents) < target:
success = False
reactor.callLater(1,
check_torrents_channel,
src,
defer_param,
target=target)
elif not self.boosting_manager.torrents.get(
TORRENT_UBUNTU_FILE_INFOHASH, None):
success = False
reactor.callLater(1,
check_torrents_channel,
src,
defer_param,
target=target)
elif not self.boosting_manager.torrents[
TORRENT_UBUNTU_FILE_INFOHASH].get('download', None):
success = False
reactor.callLater(1,
check_torrents_channel,
src,
defer_param,
target=target)
if success:
self.boosting_manager.set_enable_mining(src,
False,
force_restart=True)
if src_obj.community:
src_obj.community.cancel_all_pending_tasks()
self.assertEqual(src_obj.get_source_text(), 'Simple Channel')
defer_param.callback(src)
return defer_param
chn_obj._load_torrent = self._load
d = self.check_source(dispersy_cid)
d.addCallback(check_torrents_channel, target=1)
return d
