def setup_session_config(self):
from Tribler.Core.SessionConfig import SessionStartupConfig
config = SessionStartupConfig()
config.set_install_dir(
os.path.abspath(os.path.join(BASE_DIR, "tribler")))
config.set_state_dir(
os.path.abspath(
os.path.join(BASE_DIR, "output", ".Tribler-%d") % getpid()))
config.set_torrent_checking(False)
config.set_multicast_local_peer_discovery(False)
config.set_megacache(False)
config.set_dispersy(True)
config.set_mainline_dht(False)
config.set_torrent_collecting(False)
config.set_libtorrent(False)
config.set_dht_torrent_collecting(False)
config.set_enable_torrent_search(False)
config.set_enable_channel_search(False)
config.set_videoserver_enabled(False)
config.set_http_api_enabled(False)
config.set_upgrader_enabled(False)
config.set_listen_port(20000 + self.scenario_runner._peernumber)
if self.dispersy_port is None:
self.dispersy_port = 21000 + self.scenario_runner._peernumber
config.set_dispersy_port(self.dispersy_port)
logging.error("Dispersy port set to %d" % self.dispersy_port)
return config
def start_tribler():
config = SessionStartupConfig().load()
config.set_http_api_port(API_PORT)
config.set_http_api_enabled(True)
# Check if we are already running a Tribler instance
process_checker = ProcessChecker()
if process_checker.already_running:
return
session = Session(config)
signal.signal(signal.SIGTERM, lambda signum, stack: shutdown(session, signum, stack))
session.start()
class TestAsServer(AbstractServer):
"""
Parent class for testing the server-side of Tribler
"""
@blocking_call_on_reactor_thread
@inlineCallbacks
def setUp(self, autoload_discovery=True):
yield super(TestAsServer, self).setUp(annotate=False)
self.setUpPreSession()
self.quitting = False
self.seeding_deferred = Deferred()
self.seeder_session = None
self.session = Session(self.config)
self.tribler_started_deferred = self.session.start()
yield self.tribler_started_deferred
self.assertTrue(self.session.lm.initComplete)
self.hisport = self.session.get_listen_port()
self.annotate(self._testMethodName, start=True)
def setUpPreSession(self):
""" Should set self.config_path and self.config """
self.config = SessionStartupConfig()
self.config.set_state_dir(self.getStateDir())
self.config.set_torrent_checking(False)
self.config.set_multicast_local_peer_discovery(False)
self.config.set_megacache(False)
self.config.set_dispersy(False)
self.config.set_mainline_dht(False)
self.config.set_torrent_store(False)
self.config.set_enable_torrent_search(False)
self.config.set_enable_channel_search(False)
self.config.set_torrent_collecting(False)
self.config.set_libtorrent(False)
self.config.set_dht_torrent_collecting(False)
self.config.set_videoserver_enabled(False)
self.config.set_enable_metadata(False)
self.config.set_upgrader_enabled(False)
self.config.set_http_api_enabled(False)
self.config.set_tunnel_community_enabled(False)
self.config.set_creditmining_enable(False)
self.config.set_enable_multichain(False)
@blocking_call_on_reactor_thread
@inlineCallbacks
def tearDown(self, annotate=True):
self.annotate(self._testMethodName, start=False)
""" unittest test tear down code """
if self.session is not None:
assert self.session is Session.get_instance()
yield self.session.shutdown()
assert self.session.has_shutdown()
Session.del_instance()
yield self.stop_seeder()
ts = enumerate_threads()
self._logger.debug(
"test_as_server: Number of threads still running %d", len(ts))
for t in ts:
self._logger.debug(
"Thread still running %s, daemon: %s, instance: %s",
t.getName(), t.isDaemon(), t)
yield super(TestAsServer, self).tearDown(annotate=False)
def create_local_torrent(self, source_file):
'''
This method creates a torrent from a local file and saves the torrent in the session state dir.
Note that the source file needs to exist.
'''
self.assertTrue(os.path.exists(source_file))
tdef = TorrentDef()
tdef.add_content(source_file)
tdef.set_tracker("http://localhost/announce")
tdef.finalize()
torrent_path = os.path.join(self.session.get_state_dir(),
"seed.torrent")
tdef.save(torrent_path)
return tdef, torrent_path
def setup_seeder(self, tdef, seed_dir):
self.seed_config = SessionStartupConfig()
self.seed_config.set_torrent_checking(False)
self.seed_config.set_multicast_local_peer_discovery(False)
self.seed_config.set_megacache(False)
self.seed_config.set_dispersy(False)
self.seed_config.set_mainline_dht(False)
self.seed_config.set_torrent_store(False)
self.seed_config.set_enable_torrent_search(False)
self.seed_config.set_enable_channel_search(False)
self.seed_config.set_torrent_collecting(False)
self.seed_config.set_libtorrent(True)
self.seed_config.set_dht_torrent_collecting(False)
self.seed_config.set_videoserver_enabled(False)
self.seed_config.set_enable_metadata(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 stop_seeder(self):
if self.seeder_session is not None:
return self.seeder_session.shutdown()
return succeed(None)
def seeder_state_callback(self, ds):
d = ds.get_download()
self._logger.debug("seeder status: %s %s %s",
repr(d.get_def().get_name()),
dlstatus_strings[ds.get_status()],
ds.get_progress())
if ds.get_status() == DLSTATUS_SEEDING:
self.seeding_deferred.callback(None)
return 0.0, False
return 1.0, False
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 = SessionStartupConfig().load(
) # Load the default configuration file
config.set_http_api_enabled(True)
# 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"] != -1 and options["dispersy"] > 0:
config.set_dispersy_port(options["dispersy"])
if options["libtorrent"] != -1 and options["libtorrent"] > 0:
config.set_listen_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
