def setupSeeder(self):
from Tribler.Core.Session import Session
from Tribler.Core.TorrentDef import TorrentDef
from Tribler.Core.DownloadConfig import DownloadStartupConfig
self.setUpPreSession()
self.config.set_libtorrent(True)
self.config2 = self.config.copy()
self.session2 = Session(self.config2, ignore_singleton=True)
upgrader = self.session2.prestart()
while not upgrader.is_done:
time.sleep(0.1)
assert not upgrader.failed, upgrader.current_status
self.session2.start()
tdef = TorrentDef()
tdef.add_content(os.path.join(TESTS_DATA_DIR, "video.avi"))
tdef.set_tracker("http://fake.net/announce")
tdef.finalize()
torrentfn = os.path.join(self.session.get_state_dir(), "gen.torrent")
tdef.save(torrentfn)
dscfg = DownloadStartupConfig()
dscfg.set_dest_dir(
TESTS_DATA_DIR) # basedir of the file we are seeding
d = self.session2.start_download(tdef, dscfg)
d.set_state_callback(self.seeder_state_callback)
return torrentfn
def test_create_channel(self):
"""
Test the pass through function of Session.create_channel to the ChannelManager.
"""
class LmMock(object):
class ChannelManager(object):
invoked_name = None
invoked_desc = None
invoked_mode = None
def create_channel(self, name, description, mode=u"closed"):
self.invoked_name = name
self.invoked_desc = description
self.invoked_mode = mode
channel_manager = ChannelManager()
config = TriblerConfig()
config.set_state_dir(self.getStateDir())
session = Session(config, ignore_singleton=True)
session.lm = LmMock()
session.lm.api_manager = None
session.create_channel("name", "description", "open")
self.assertEqual(session.lm.channel_manager.invoked_name, "name")
self.assertEqual(session.lm.channel_manager.invoked_desc,
"description")
self.assertEqual(session.lm.channel_manager.invoked_mode, "open")
def start_tribler():
config = TriblerConfig()
global trace_logger
# Enable tracer if --trace-debug or --trace-exceptions flag is present in sys.argv
trace_logger = check_and_enable_code_tracing('core')
priority_order = config.get_cpu_priority_order()
set_process_priority(pid=os.getpid(), priority_order=priority_order)
config.set_http_api_port(int(api_port))
config.set_http_api_enabled(True)
# Check if we are already running a Tribler instance
process_checker = ProcessChecker(config.get_state_dir())
if process_checker.already_running:
return
else:
process_checker.create_lock_file()
session = Session(config)
signal.signal(signal.SIGTERM,
lambda signum, stack: shutdown(session, signum, stack))
session.start()
def setUp(self, autoload_discovery=True):
yield super(TestAsServer, self).setUp(annotate=False)
self.setUpPreSession()
# We don't use the system keychain but a PlainText keyring for performance during tests
for new_keyring in keyring.backend.get_all_keyring():
if isinstance(new_keyring, PlaintextKeyring):
keyring.set_keyring(new_keyring)
self.quitting = False
self.seeding_deferred = Deferred()
self.seeder_session = None
self.seed_config = None
self.session = Session(self.config)
self.session.upgrader_enabled = False
self.tribler_started_deferred = self.session.start()
yield self.tribler_started_deferred
self.assertTrue(self.session.lm.initComplete)
self.hisport = self.session.config.get_libtorrent_port()
self.annotate(self._testMethodName, start=True)
def start_tribler(self, options):
"""
Main method to startup Tribler.
"""
def on_tribler_shutdown(_):
msg("Tribler shut down")
reactor.stop()
self.process_checker.remove_lock_file()
def signal_handler(sig, _):
msg("Received shut down signal %s" % sig)
if not self._stopping:
self._stopping = True
self.session.shutdown().addCallback(on_tribler_shutdown)
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)
config = TriblerConfig()
config.set_torrent_checking_enabled(False)
config.set_megacache_enabled(True)
config.set_dispersy_enabled(False)
config.set_mainline_dht_enabled(True)
config.set_torrent_collecting_enabled(False)
config.set_libtorrent_enabled(False)
config.set_http_api_enabled(True)
config.set_video_server_enabled(False)
config.set_torrent_search_enabled(False)
config.set_channel_search_enabled(False)
config.set_credit_mining_enabled(False)
config.set_dummy_wallets_enabled(True)
config.set_popularity_community_enabled(False)
# Check if we are already running a Tribler instance
self.process_checker = ProcessChecker()
if self.process_checker.already_running:
self.shutdown_process(
"Another Tribler instance is already using statedir %s" %
config.get_state_dir())
return
msg("Starting Tribler")
if options["statedir"]:
config.set_state_dir(options["statedir"])
if options["restapi"] > 0:
config.set_http_api_enabled(True)
config.set_http_api_port(options["restapi"])
if options["ipv8"] != -1 and options["ipv8"] > 0:
config.set_dispersy_port(options["ipv8"])
if "testnet" in options and options["testnet"]:
config.set_testnet(True)
self.session = Session(config)
self.session.start().addErrback(
lambda failure: self.shutdown_process(failure.getErrorMessage()))
msg("Tribler started")
def setUp(self, annotate=True):
super(TestRestApiUtil, self).setUp(annotate=annotate)
config = TriblerConfig()
config.set_state_dir(self.getStateDir())
config.get_dispersy_enabled = lambda: False
self.session = Session(config)
def test_create_channel_duplicate_name_error(self):
config = TriblerConfig()
config.set_state_dir(self.getStateDir())
self.session = Session(config)
class LmMock(object):
channel_manager = ChannelManager(self.session)
self.session.lm = LmMock()
class MockCommunity(object):
cid = ""
def get_channel_name(self):
return "Channel name"
channel_obj = ChannelObject(self.session,
MockCommunity(),
is_created=True)
self.session.lm.channel_manager._channel_list = [channel_obj]
with self.assertRaises(DuplicateChannelNameError) as cm:
self.session.lm.channel_manager.create_channel(
"Channel name", "description", "open")
self.assertEqual(cm.exception.message,
u"Channel name already exists: Channel name")
def start_tribler(self):
config = SessionStartupConfig()
config.set_state_dir(
os.path.join(config.get_state_dir(), "tunnel-%d") %
self.settings.socks_listen_ports[0])
config.set_torrent_checking(False)
config.set_multicast_local_peer_discovery(False)
config.set_megacache(False)
config.set_dispersy(True)
config.set_mainline_dht(True)
config.set_torrent_collecting(False)
config.set_libtorrent(True)
config.set_dht_torrent_collecting(False)
config.set_enable_torrent_search(False)
config.set_videoserver_enabled(False)
config.set_dispersy_port(self.dispersy_port)
config.set_enable_torrent_search(False)
config.set_enable_channel_search(False)
config.set_enable_multichain(self.settings.enable_multichain)
# We do not want to load the TunnelCommunity in the session but instead our own community
config.set_tunnel_community_enabled(False)
self.session = Session(config)
self.session.start()
logger.info("Using Dispersy port %d" %
self.session.get_dispersy_port())
def initialize(self):
sscfg = SessionStartupConfig()
if self._opt.statedir:
sscfg.set_state_dir(unicode(os.path.realpath(self._opt.statedir)))
if self._opt.port:
sscfg.set_dispersy_port(self._opt.port)
if self._opt.nickname:
sscfg.set_nickname(self._opt.nickname)
# pass rss config
if not self._opt.rss_config:
self._logger.error(u"rss_config unspecified")
self.rss_list = parge_rss_config_file(self._opt.rss_config)
sscfg.set_megacache(True)
sscfg.set_torrent_collecting(True)
sscfg.set_torrent_checking(True)
sscfg.set_enable_torrent_search(True)
sscfg.set_enable_channel_search(True)
self._logger.info(u"Starting session...")
self.session = Session(sscfg)
self.session.prestart()
# add dispersy start callbacks
self.session.add_observer(self.dispersy_started, NTFY_DISPERSY, [NTFY_STARTED])
self.session.start()
def setUp(self):
yield super(TestTrackerManager, self).setUp()
self.setUpPreSession()
self.session = Session(self.config)
self.session.start_database()
self.tracker_manager = TrackerManager(self.session)
def setup_tunnel_seeder(self, hops):
"""
Setup the seeder.
"""
from Tribler.Core.Session import Session
self.seed_config = self.config.copy()
self.seed_config.set_state_dir(self.getStateDir(2))
self.seed_config.set_tunnel_community_socks5_listen_ports(
self.get_socks5_ports())
if self.session2 is None:
self.session2 = Session(self.seed_config)
self.session2.start()
tdef = TorrentDef()
tdef.add_content(os.path.join(TESTS_DATA_DIR, "video.avi"))
tdef.set_tracker("http://localhost/announce")
torrentfn = os.path.join(self.session2.config.get_state_dir(),
"gen.torrent")
tdef.save(torrent_filepath=torrentfn)
self.seed_tdef = tdef
if hops > 0: # Safe seeding enabled
self.tunnel_community_seeder = self.load_tunnel_community_in_session(
self.session2)
self.tunnel_community_seeder.build_tunnels(hops)
else:
self.sanitize_network(self.session2)
dscfg = DownloadStartupConfig()
dscfg.set_dest_dir(
TESTS_DATA_DIR) # basedir of the file we are seeding
dscfg.set_hops(hops)
d = self.session2.start_download_from_tdef(tdef, dscfg)
d.set_state_callback(self.seeder_state_callback)
def setUp(self, annotate=True):
yield super(TestTrackerManager, self).setUp(annotate=annotate)
self.setUpPreSession()
self.session = Session(self.config, ignore_singleton=True)
self.session.start_database()
self.tracker_manager = TrackerManager(self.session)
def setup_seeder(self, tdef, seed_dir):
self.seed_config = TriblerConfig()
self.seed_config.set_torrent_checking_enabled(False)
self.seed_config.set_megacache_enabled(False)
self.seed_config.set_dispersy_enabled(False)
self.seed_config.set_mainline_dht_enabled(False)
self.seed_config.set_torrent_store_enabled(False)
self.seed_config.set_torrent_search_enabled(False)
self.seed_config.set_channel_search_enabled(False)
self.seed_config.set_torrent_collecting_enabled(False)
self.seed_config.set_libtorrent_enabled(True)
self.seed_config.set_video_server_enabled(False)
self.seed_config.set_metadata_enabled(False)
self.seed_config.set_upgrader_enabled(False)
self.seed_config.set_tunnel_community_enabled(False)
self.seed_config.set_state_dir(self.getStateDir(2))
def start_seed_download(_):
self.dscfg_seed = DownloadStartupConfig()
self.dscfg_seed.set_dest_dir(seed_dir)
d = self.seeder_session.start_download_from_tdef(
tdef, self.dscfg_seed)
d.set_state_callback(self.seeder_state_callback)
self._logger.debug(
"starting to wait for download to reach seeding state")
self.seeder_session = Session(self.seed_config, ignore_singleton=True)
self.seeder_session.start().addCallback(start_seed_download)
return self.seeding_deferred
def setup_tunnel_seeder(self, hops):
"""
Setup the seeder.
"""
from Tribler.Core.Session import Session
self.seed_config = self.config.copy()
self.seed_config.set_state_dir(self.getStateDir(2))
self.seed_config.set_megacache_enabled(True)
self.seed_config.set_tunnel_community_socks5_listen_ports(self.get_socks5_ports())
if self.session2 is None:
self.session2 = Session(self.seed_config, ignore_singleton=True, autoload_discovery=False)
self.session2.start()
tdef = TorrentDef()
tdef.add_content(os.path.join(TESTS_DATA_DIR, "video.avi"))
tdef.set_tracker("http://localhost/announce")
tdef.finalize()
torrentfn = os.path.join(self.session2.config.get_state_dir(), "gen.torrent")
tdef.save(torrentfn)
self.seed_tdef = tdef
if hops > 0: # Safe seeding enabled
self.tunnel_community_seeder = self.load_tunnel_community_in_session(self.session2)
self.tunnel_community_seeder.build_tunnels(hops)
from twisted.internet import reactor, task
while not list(self.tunnel_community_seeder.active_data_circuits()):
yield task.deferLater(reactor, .05, lambda: None)
dscfg = DownloadStartupConfig()
dscfg.set_dest_dir(TESTS_DATA_DIR) # basedir of the file we are seeding
dscfg.set_hops(hops)
d = self.session2.start_download_from_tdef(tdef, dscfg)
d.set_state_callback(self.seeder_state_callback)
def test_torrent_store_delete(self):
config = TriblerConfig()
config.set_state_dir(self.getStateDir())
config.set_torrent_store_enabled(True)
session = Session(config, ignore_singleton=True)
# Manually set the torrent store as we don't want to start the session.
session.lm.torrent_store = LevelDbStore(
session.config.get_torrent_store_dir())
session.lm.torrent_store[hexlify("fakehash")] = "Something"
self.assertEqual("Something",
session.lm.torrent_store[hexlify("fakehash")])
session.delete_collected_torrent("fakehash")
raised_key_error = False
# This structure is needed because if we add a @raises above the test, we cannot close the DB
# resulting in a dirty reactor.
try:
self.assertRaises(KeyError,
session.lm.torrent_store[hexlify("fakehash")])
except KeyError:
raised_key_error = True
finally:
session.lm.torrent_store.close()
self.assertTrue(raised_key_error)
def start(self):
# Determine socks5 ports
socks5_port = self.options['socks5']
if socks5_port is not None:
socks_listen_ports = range(socks5_port, socks5_port + 5)
else:
socks_listen_ports = [random.randint(1000, 65535) for _ in range(5)]
config = TriblerConfig()
config.set_state_dir(os.path.join(config.get_state_dir(), "tunnel-%d") % socks_listen_ports[0])
config.set_tunnel_community_socks5_listen_ports(socks_listen_ports)
config.set_torrent_checking_enabled(False)
config.set_megacache_enabled(False)
config.set_dispersy_enabled(False)
config.set_ipv8_enabled(True)
config.set_mainline_dht_enabled(True)
config.set_torrent_collecting_enabled(False)
config.set_libtorrent_enabled(False)
config.set_video_server_enabled(False)
config.set_dispersy_port(self.ipv8_port)
config.set_torrent_search_enabled(False)
config.set_channel_search_enabled(False)
config.set_trustchain_enabled(True)
config.set_credit_mining_enabled(False)
config.set_market_community_enabled(False)
config.set_mainline_dht_enabled(False)
config.set_tunnel_community_exitnode_enabled(bool(self.options["exit"]))
if "testnet" in self.options and self.options["testnet"]:
config.set_ipv8_use_testnet(True)
self.session = Session(config)
logger.info("Using IPv8 port %d" % self.session.config.get_dispersy_port())
return self.session.start()
def setUp(self):
yield super(AbstractUpgrader, self).setUp()
self.config = SessionStartupConfig()
self.config.set_torrent_collecting_dir(
os.path.join(self.session_base_dir, 'torrent_collecting_dir'))
self.session = Session(self.config, ignore_singleton=True)
self.sqlitedb = None
self.torrent_store = None
def setUp(self):
""" override TestAsServer """
TestAsServer.setUp(self)
self.session2 = Session(self.config2, ignore_singleton=True)
self.session2.start()
self.seeding_event = threading.Event()
def setup_peer(self):
"""
Setup a second peer that contains some search results.
"""
self.setUpPreSession()
self.config2 = self.config.copy()
self.config2.set_state_dir(self.getStateDir(2))
self.session2 = Session(self.config2)
yield self.session2.start()
self.dispersy2 = self.session2.get_dispersy_instance()
@inlineCallbacks
def unload_communities():
for community in self.dispersy.get_communities():
if isinstance(community, SearchCommunity) or isinstance(community, AllChannelCommunity):
yield community.unload_community()
for community in self.dispersy2.get_communities():
if isinstance(community, SearchCommunity) or isinstance(community, AllChannelCommunity):
yield community.unload_community()
def load_communities():
self.search_community = \
self.dispersy.define_auto_load(SearchCommunityTests, self.session.dispersy_member, load=True,
kargs={'tribler_session': self.session})[0]
self.dispersy2.define_auto_load(SearchCommunityTests, self.session2.dispersy_member, load=True,
kargs={'tribler_session': self.session2})
self.allchannel_community = \
self.dispersy.define_auto_load(AllChannelCommunityTests, self.session.dispersy_member, load=True,
kargs={'tribler_session': self.session})[0]
self.dispersy2.define_auto_load(AllChannelCommunityTests, self.session2.dispersy_member, load=True,
kargs={'tribler_session': self.session2})
yield unload_communities()
load_communities()
self.search_community.add_discovered_candidate(Candidate(self.dispersy2.lan_address, tunnel=False))
self.allchannel_community.add_discovered_candidate(Candidate(self.dispersy2.lan_address, tunnel=False))
# Add some content to second session
torrent_db_handler = self.session2.open_dbhandler(NTFY_TORRENTS)
torrent_db_handler.addExternalTorrentNoDef(str(unichr(97)) * 20, 'test test', [('Test.txt', 1337)], [], 1337)
torrent_db_handler.updateTorrent(str(unichr(97)) * 20, is_collected=1)
channel_db_handler = self.session2.open_dbhandler(NTFY_CHANNELCAST)
channel_db_handler.on_channel_from_dispersy('f' * 20, 42, "test", "channel for unit tests")
torrent_list = [
[1, 1, 1, ('a' * 40).decode('hex'), 1460000000, "ubuntu-torrent.iso", [['file1.txt', 42]], []]
]
channel_db_handler.on_torrents_from_dispersy(torrent_list)
# We also need to add the channel to the database of the session initiating the search
channel_db_handler = self.session.open_dbhandler(NTFY_CHANNELCAST)
channel_db_handler.on_channel_from_dispersy('f' * 20, 42, "test", "channel for unit tests")
def setup_downloader(self):
self.config2 = self.config.copy()
self.config2.set_megacache_enabled(True)
self.config2.set_torrent_collecting_enabled(True)
self.config2.set_metadata_enabled(True)
self.config2.set_state_dir(self.getStateDir(2))
self.session2 = Session(self.config2)
return self.session2.start()
def start(self):
# Determine socks5 ports
socks5_port = self.options['socks5']
if "HELPER_INDEX" in os.environ and "HELPER_BASE" in os.environ:
base_port = int(os.environ["HELPER_BASE"])
socks5_port = base_port + int(os.environ["HELPER_INDEX"]) * 5
if socks5_port is not None:
socks_listen_ports = range(socks5_port, socks5_port + 5)
else:
socks_listen_ports = [
random.randint(1000, 65535) for _ in range(5)
]
config = TriblerConfig()
config.set_state_dir(
os.path.join(config.get_state_dir(), "tunnel-%d") %
socks_listen_ports[0])
config.set_tunnel_community_socks5_listen_ports(socks_listen_ports)
config.set_torrent_checking_enabled(False)
config.set_megacache_enabled(False)
config.set_dispersy_enabled(False)
config.set_ipv8_enabled(True)
config.set_mainline_dht_enabled(True)
config.set_torrent_collecting_enabled(False)
config.set_libtorrent_enabled(False)
config.set_video_server_enabled(False)
config.set_dispersy_port(self.ipv8_port)
config.set_ipv8_address(self.ipv8_address)
config.set_torrent_search_enabled(False)
config.set_channel_search_enabled(False)
config.set_trustchain_enabled(True)
config.set_credit_mining_enabled(False)
config.set_market_community_enabled(False)
config.set_mainline_dht_enabled(False)
config.set_dht_enabled(True)
config.set_tunnel_community_exitnode_enabled(bool(
self.options["exit"]))
config.set_popularity_community_enabled(False)
config.set_testnet(bool(self.options["testnet"]))
if self.options["restapi"] is not None:
config.set_http_api_enabled(True)
config.set_http_api_port(self.options["restapi"])
if self.options["ipv8_bootstrap_override"] is not None:
config.set_ipv8_bootstrap_override(
self.options["ipv8_bootstrap_override"])
self.session = Session(config)
logger.info("Using IPv8 port %d" %
self.session.config.get_dispersy_port())
self.session.notifier.add_observer(self.circuit_removed, NTFY_TUNNEL,
[NTFY_REMOVE])
return self.session.start().addCallback(self.tribler_started)
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)
def setUp(self):
yield super(AbstractUpgrader, self).setUp()
self.config = TriblerConfig(ConfigObj(configspec=CONFIG_SPEC_PATH))
self.config.set_state_dir(self.getStateDir())
self.config.set_torrent_collecting_dir(
os.path.join(self.session_base_dir, 'torrent_collecting_dir'))
self.session = Session(self.config)
self.sqlitedb = None
self.torrent_store = None
def start_tribler(self, options):
"""
Main method to startup Tribler.
"""
def on_tribler_shutdown(_):
msg("Tribler shut down")
reactor.stop()
self.process_checker.remove_lock_file()
def signal_handler(sig, _):
msg("Received shut down signal %s" % sig)
if not self._stopping:
self._stopping = True
self.session.shutdown().addCallback(on_tribler_shutdown)
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)
config = TriblerConfig()
# Check if we are already running a Tribler instance
self.process_checker = ProcessChecker()
if self.process_checker.already_running:
self.shutdown_process("Another Tribler instance is already using statedir %s" % config.get_state_dir())
return
msg("Starting Tribler")
if options["statedir"]:
config.set_state_dir(options["statedir"])
if options["restapi"] > 0:
config.set_http_api_enabled(True)
config.set_http_api_port(options["restapi"])
if options["dispersy"] > 0:
config.set_dispersy_port(options["dispersy"])
if options["libtorrent"] != -1 and options["libtorrent"] > 0:
config.set_libtorrent_port(options["libtorrent"])
self.session = Session(config)
self.session.start().addErrback(lambda failure: self.shutdown_process(failure.getErrorMessage()))
msg("Tribler started")
if "auto-join-channel" in options and options["auto-join-channel"]:
msg("Enabling auto-joining of channels")
for community in self.session.get_dispersy_instance().get_communities():
if isinstance(community, AllChannelCommunity):
community.auto_join_channel = True
if "log-incoming-searches" in options and options["log-incoming-searches"]:
msg("Logging incoming remote searches")
for community in self.session.get_dispersy_instance().get_communities():
if isinstance(community, SearchCommunity):
community.log_incoming_searches = self.log_incoming_remote_search
def setup_downloader(self):
self.config2 = self.config.copy()
self.config2.set_megacache(True)
self.config2.set_torrent_collecting(True)
self.config2.set_torrent_store_dir(None)
self.config2.set_metadata_store_dir(None)
self.config2.set_enable_metadata(True)
self.config2.set_state_dir(self.getStateDir(2))
self.session2 = Session(self.config2, ignore_singleton=True)
return self.session2.start()
def setupPeer(self):
from Tribler.Core.Session import Session
self.config2 = self.config.copy()
self.config2.set_state_dir(self.getStateDir(2))
self.session2 = Session(self.config2, ignore_singleton=True)
yield self.session2.start()
self.load_communities(self.session2,
self.session2.get_dispersy_instance())
def start_tribler(self, options):
"""
Main method to startup Tribler.
"""
def on_tribler_shutdown(_):
msg("Tribler shut down")
reactor.stop()
self.process_checker.remove_lock_file()
def signal_handler(sig, _):
msg("Received shut down signal %s" % sig)
if not self._stopping:
self._stopping = True
self.session.shutdown().addCallback(on_tribler_shutdown)
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)
config = TriblerConfig()
# Check if we are already running a Tribler instance
self.process_checker = ProcessChecker()
if self.process_checker.already_running:
self.shutdown_process("Another Tribler instance is already using statedir %s" % config.get_state_dir())
return
msg("Starting Tribler")
if options["statedir"]:
config.set_state_dir(options["statedir"])
if options["restapi"] > 0:
config.set_http_api_enabled(True)
config.set_http_api_port(options["restapi"])
if options["ipv8"] > 0:
config.set_ipv8_port(options["ipv8"])
elif options["ipv8"] == 0:
config.set_ipv8_enabled(False)
if options["libtorrent"] != -1 and options["libtorrent"] > 0:
config.set_libtorrent_port(options["libtorrent"])
if options["ipv8_bootstrap_override"] is not None:
config.set_ipv8_bootstrap_override(options["ipv8_bootstrap_override"])
if "testnet" in options and options["testnet"]:
config.set_testnet(True)
self.session = Session(config)
self.session.start().addErrback(lambda failure: self.shutdown_process(failure.getErrorMessage()))
msg("Tribler started")
def setUp(self):
yield super(AbstractDB, self).setUp()
self.setUpPreSession()
self.session = Session(self.config)
tar = tarfile.open(os.path.join(TESTS_DATA_DIR, 'bak_new_tribler.sdb.tar.gz'), 'r|gz')
tar.extractall(self.session_base_dir)
db_path = os.path.join(self.session_base_dir, 'bak_new_tribler.sdb')
self.sqlitedb = SQLiteCacheDB(db_path, busytimeout=BUSYTIMEOUT)
self.session.sqlite_db = self.sqlitedb
def main(define_communities):
command_line_parser = optparse.OptionParser()
command_line_parser.add_option("--statedir",
action="store",
type="string",
help="Use an alternate statedir")
command_line_parser.add_option("--port",
action="store",
type="int",
help="Listen at this port")
command_line_parser.add_option("--nickname",
action="store",
type="string",
help="The moderator name")
# parse command-line arguments
opt, args = command_line_parser.parse_args()
logger.info(
"Press Q followed by <ENTER> to stop the channelcast-supporter")
sscfg = SessionStartupConfig()
if opt.statedir:
sscfg.set_state_dir(os.path.realpath(opt.statedir))
if opt.port:
sscfg.set_listen_port(opt.port)
if opt.nickname:
sscfg.set_nickname(opt.nickname)
sscfg.set_megacache(True)
sscfg.set_dispersy(True)
sscfg.set_torrent_collecting(True)
session = Session(sscfg)
session.start()
dispersy = session.get_dispersy_instance()
define_communities(session)
try:
while True:
x = sys.stdin.readline()
logger.info(repr(x))
if x.strip() == 'Q':
break
except:
print_exc()
session.shutdown()
logger.info("Shutting down...")
time.sleep(5)
