def setUp(self, annotate=True):
TriblerCoreTest.setUp(self, annotate=annotate)
self.lm = TriblerLaunchMany()
self.lm.sesslock = NoDispersyRLock()
self.lm.session = MockObject()
# Ignore notifications
mock_notifier = MockObject()
mock_notifier.notify = lambda *_: None
self.lm.session.notifier = mock_notifier
def start(self):
""" Create the LaunchManyCore instance and start it"""
# 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,
config=None,
ignore_singleton=False,
autoload_discovery=True):
"""
A Session object is created which is configured with the Tribler configuration object.
Only a single session instance can exist at a time in a process.
:param config: a TriblerConfig 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 TriblerConfig() object to
serve as startup config. Next, the config is saved in the directory
indicated by its 'state_dir' attribute.
:param ignore_singleton: for testing purposes only. Enables the existence of multiple
Session instances.
:param autoload_discovery: only false in the Tunnel community tests
"""
addObserver(self.unhandled_error_observer)
patch_crypto_be_discovery()
if not ignore_singleton:
if Session.__single:
raise RuntimeError("Session is singleton")
Session.__single = self
self._logger = logging.getLogger(self.__class__.__name__)
self.ignore_singleton = ignore_singleton
self.session_lock = NoDispersyRLock()
self.config = config or TriblerConfig()
self.get_ports_in_config()
self.create_state_directory_structure()
if not config.get_megacache_enabled():
config.set_torrent_checking_enabled(False)
self.selected_ports = config.selected_ports
self.init_keypair()
self.lm = TriblerLaunchMany()
self.notifier = Notifier()
self.sqlite_db = None
self.upgrader = None
self.dispersy_member = None
self.autoload_discovery = autoload_discovery
def setUp(self, annotate=True):
TriblerCoreTest.setUp(self, annotate=annotate)
self.lm = TriblerLaunchMany()
self.lm.session_lock = NoDispersyRLock()
self.lm.session = MockObject()
self.lm.session.config = MockObject()
self.lm.session.config.get_max_upload_rate = lambda: 100
self.lm.session.config.get_max_download_rate = lambda: 100
self.lm.session.config.get_default_number_hops = lambda: 0
# Ignore notifications
mock_notifier = MockObject()
mock_notifier.notify = lambda *_: None
self.lm.session.notifier = mock_notifier
def setUp(self):
yield super(TestTorrentDBHandler, self).setUp()
from Tribler.Core.APIImplementation.LaunchManyCore import TriblerLaunchMany
from Tribler.Core.Modules.tracker_manager import TrackerManager
self.session.lm = TriblerLaunchMany()
self.session.lm.tracker_manager = TrackerManager(self.session)
self.tdb = TorrentDBHandler(self.session)
self.tdb.torrent_dir = TESTS_DATA_DIR
self.tdb.category = Category()
self.tdb.mypref_db = MyPreferenceDBHandler(self.session)
def __init__(self, config=None, autoload_discovery=True):
"""
A Session object is created which is configured with the Tribler configuration object.
Only a single session instance can exist at a time in a process.
:param config: a TriblerConfig 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 TriblerConfig() object to
serve as startup config. Next, the config is saved in the directory
indicated by its 'state_dir' attribute.
:param autoload_discovery: only false in the Tunnel community tests
"""
addObserver(self.unhandled_error_observer)
patch_crypto_be_discovery()
self._logger = logging.getLogger(self.__class__.__name__)
self.session_lock = NoDispersyRLock()
self.config = config or TriblerConfig()
self.get_ports_in_config()
self.create_state_directory_structure()
if not self.config.get_megacache_enabled():
self.config.set_torrent_checking_enabled(False)
self.selected_ports = self.config.selected_ports
self.init_keypair()
self.lm = TriblerLaunchMany()
self.notifier = Notifier()
self.sqlite_db = None
self.upgrader_enabled = True
self.dispersy_member = None
self.readable_status = '' # Human-readable string to indicate the status during startup/shutdown of Tribler
self.autoload_discovery = autoload_discovery
def setUp(self):
TriblerCoreTest.setUp(self)
self.lm = TriblerLaunchMany()
self.lm.session_lock = NoDispersyRLock()
self.lm.session = MockObject()
self.lm.session.config = MockObject()
self.lm.session.config.get_max_upload_rate = lambda: 100
self.lm.session.config.get_max_download_rate = lambda: 100
self.lm.session.config.get_default_number_hops = lambda: 0
# Ignore notifications
mock_notifier = MockObject()
mock_notifier.notify = lambda *_: None
self.lm.session.notifier = mock_notifier
def __init__(self, config=None, autoload_discovery=True):
"""
A Session object is created which is configured with the Tribler configuration object.
Only a single session instance can exist at a time in a process.
:param config: a TriblerConfig 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 TriblerConfig() object to
serve as startup config. Next, the config is saved in the directory
indicated by its 'state_dir' attribute.
:param autoload_discovery: only false in the Tunnel community tests
"""
addObserver(self.unhandled_error_observer)
patch_crypto_be_discovery()
self._logger = logging.getLogger(self.__class__.__name__)
self.session_lock = NoDispersyRLock()
self.config = config or TriblerConfig()
self.get_ports_in_config()
self.create_state_directory_structure()
if not self.config.get_megacache_enabled():
self.config.set_torrent_checking_enabled(False)
self.selected_ports = self.config.selected_ports
self.init_keypair()
self.lm = TriblerLaunchMany()
self.notifier = Notifier()
self.sqlite_db = None
self.upgrader_enabled = True
self.dispersy_member = None
self.readable_status = '' # Human-readable string to indicate the status during startup/shutdown of Tribler
self.autoload_discovery = autoload_discovery
class Session(object):
"""
A Session is a running instance of the Tribler Core and the Core's central class.
"""
__single = None
def __init__(self, config=None, autoload_discovery=True):
"""
A Session object is created which is configured with the Tribler configuration object.
Only a single session instance can exist at a time in a process.
:param config: a TriblerConfig 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 TriblerConfig() object to
serve as startup config. Next, the config is saved in the directory
indicated by its 'state_dir' attribute.
:param autoload_discovery: only false in the Tunnel community tests
"""
addObserver(self.unhandled_error_observer)
patch_crypto_be_discovery()
self._logger = logging.getLogger(self.__class__.__name__)
self.session_lock = NoDispersyRLock()
self.config = config or TriblerConfig()
self.get_ports_in_config()
self.create_state_directory_structure()
if not self.config.get_megacache_enabled():
self.config.set_torrent_checking_enabled(False)
self.selected_ports = self.config.selected_ports
self.init_keypair()
self.lm = TriblerLaunchMany()
self.notifier = Notifier()
self.sqlite_db = None
self.upgrader_enabled = True
self.dispersy_member = None
self.readable_status = '' # Human-readable string to indicate the status during startup/shutdown of Tribler
self.autoload_discovery = autoload_discovery
def create_state_directory_structure(self):
"""Create directory structure of the state directory."""
def create_dir(path):
if not os.path.isdir(path):
os.makedirs(path)
def create_in_state_dir(path):
create_dir(os.path.join(self.config.get_state_dir(), path))
create_dir(self.config.get_state_dir())
create_dir(self.config.get_torrent_store_dir())
create_dir(self.config.get_metadata_store_dir())
create_in_state_dir(DB_DIR_NAME)
create_in_state_dir(STATEDIR_DLPSTATE_DIR)
create_in_state_dir(STATEDIR_WALLET_DIR)
def get_ports_in_config(self):
"""Claim all required random ports."""
self.config.get_libtorrent_port()
self.config.get_dispersy_port()
self.config.get_mainline_dht_port()
self.config.get_video_server_port()
self.config.get_anon_listen_port()
self.config.get_tunnel_community_socks5_listen_ports()
def init_keypair(self):
"""
Set parameters that depend on state_dir.
"""
permid_module.init()
# Set params that depend on state_dir
#
# 1. keypair
#
pair_filename = self.config.get_permid_keypair_filename()
if os.path.exists(pair_filename):
self.keypair = permid_module.read_keypair(pair_filename)
else:
self.keypair = permid_module.generate_keypair()
# Save keypair
public_key_filename = os.path.join(self.config.get_state_dir(), 'ecpub.pem')
permid_module.save_keypair(self.keypair, pair_filename)
permid_module.save_pub_key(self.keypair, public_key_filename)
trustchain_pairfilename = self.config.get_trustchain_keypair_filename()
if os.path.exists(trustchain_pairfilename):
self.trustchain_keypair = permid_module.read_keypair_trustchain(trustchain_pairfilename)
else:
self.trustchain_keypair = permid_module.generate_keypair_trustchain()
# Save keypair
trustchain_pubfilename = os.path.join(self.config.get_state_dir(), 'ecpub_multichain.pem')
permid_module.save_keypair_trustchain(self.trustchain_keypair, trustchain_pairfilename)
permid_module.save_pub_key_trustchain(self.trustchain_keypair, trustchain_pubfilename)
trustchain_testnet_pairfilename = self.config.get_trustchain_testnet_keypair_filename()
if os.path.exists(trustchain_testnet_pairfilename):
self.trustchain_testnet_keypair = permid_module.read_keypair_trustchain(trustchain_testnet_pairfilename)
else:
self.trustchain_testnet_keypair = permid_module.generate_keypair_trustchain()
# Save keypair
trustchain_testnet_pubfilename = os.path.join(self.config.get_state_dir(), 'ecpub_trustchain_testnet.pem')
permid_module.save_keypair_trustchain(self.trustchain_testnet_keypair, trustchain_testnet_pairfilename)
permid_module.save_pub_key_trustchain(self.trustchain_testnet_keypair, trustchain_testnet_pubfilename)
def unhandled_error_observer(self, event):
"""
This method is called when an unhandled error in Tribler is observed.
It broadcasts the tribler_exception event.
"""
if event['isError']:
text = ""
if 'log_legacy' in event and 'log_text' in event:
text = event['log_text']
elif 'log_failure' in event:
text = str(event['log_failure'])
# There are some errors that we are ignoring.
# No route to host: this issue is non-critical since Tribler can still function when a request fails.
if 'socket.error' in text and '[Errno 113]' in text:
self._logger.error("Observed no route to host error (but ignoring)."
"This might indicate a problem with your firewall.")
return
# Socket block: this sometimes occurres on Windows and is non-critical.
if 'socket.error' in text and '[Errno %s]' % SOCKET_BLOCK_ERRORCODE in text:
self._logger.error("Unable to send data due to socket.error %s", SOCKET_BLOCK_ERRORCODE)
return
if 'socket.error' in text and '[Errno 51]' in text:
self._logger.error("Could not send data: network is unreachable.")
return
if 'socket.error' in text and '[Errno 16]' in text:
self._logger.error("Could not send data: socket is busy.")
return
if 'socket.error' in text and '[Errno 10053]' in text:
self._logger.error("An established connection was aborted by the software in your host machine.")
return
if 'socket.error' in text and '[Errno 10054]' in text:
self._logger.error("Connection forcibly closed by the remote host.")
return
if 'exceptions.ValueError: Invalid DNS-ID' in text:
self._logger.error("Invalid DNS-ID")
return
if 'twisted.web._newclient.ResponseNeverReceived' in text:
self._logger.error("Internal Twisted response error, consider updating your Twisted version.")
return
# We already have a check for invalid infohash when adding a torrent, but if somehow we get this
# error then we simply log and ignore it.
if 'exceptions.RuntimeError: invalid info-hash' in text:
self._logger.error("Invalid info-hash found")
return
if self.lm.api_manager and len(text) > 0:
self.lm.api_manager.root_endpoint.events_endpoint.on_tribler_exception(text)
self.lm.api_manager.root_endpoint.state_endpoint.on_tribler_exception(text)
def start_download_from_uri(self, uri, download_config=None):
"""
Start a download from an argument. This argument can be of the following type:
-http: Start a download from a torrent file at the given url.
-magnet: Start a download from a torrent file by using a magnet link.
-file: Start a download from a torrent file at given location.
:param uri: specifies the location of the torrent to be downloaded
:param download_config: an optional configuration for the download
:return: a deferred that fires when a download has been added to the Tribler core
"""
if self.config.get_libtorrent_enabled():
return self.lm.ltmgr.start_download_from_uri(uri, dconfig=download_config)
raise OperationNotEnabledByConfigurationException()
def start_download_from_tdef(self, torrent_definition, download_startup_config=None, pstate=None, hidden=False):
"""
Creates a Download object and adds it to the session. The passed
ContentDef and DownloadStartupConfig are copied into the new Download
object. The Download is then started and checkpointed.
If a checkpointed version of the Download is found, that is restarted
overriding the saved DownloadStartupConfig if "download_startup_config" is not None.
Locking is done by LaunchManyCore.
:param torrent_definition: a finalized TorrentDef
:param download_startup_config: a DownloadStartupConfig or None, in which case
a new DownloadStartupConfig() is created with its default settings
and the result becomes the runtime config of this Download
:param hidden: whether this torrent should be added to the mypreference table
:return: a Download
"""
if self.config.get_libtorrent_enabled():
return self.lm.add(torrent_definition, download_startup_config, pstate=pstate, hidden=hidden)
raise OperationNotEnabledByConfigurationException()
def resume_download_from_file(self, filename):
"""
Recreates Download from resume file.
Note: this cannot be made into a method of Download, as the Download
needs to be bound to a session, it cannot exist independently.
:return: a Download object
:raises: a NotYetImplementedException
"""
raise NotYetImplementedException()
def get_downloads(self):
"""
Returns a copy of the list of Downloads.
Locking is done by LaunchManyCore.
:return: a list of Download objects
"""
return self.lm.get_downloads()
def get_download(self, infohash):
"""
Returns the Download object for this hash.
Locking is done by LaunchManyCore.
:return: a Download object
"""
return self.lm.get_download(infohash)
def has_download(self, infohash):
"""
Checks if the torrent download already exists.
:param infohash: The torrent infohash
:return: True or False indicating if the torrent download already exists
"""
return self.lm.download_exists(infohash)
def remove_download(self, download, remove_content=False, remove_state=True, hidden=False):
"""
Stops the download and removes it from the session.
Note that LaunchManyCore locks.
:param download: the Download to remove
:param remove_content: whether to delete the already downloaded content from disk
:param remove_state: whether to delete the metadata files of the downloaded content from disk
:param hidden: whether this torrent is added to the mypreference table and this entry should be removed
"""
# locking by lm
return self.lm.remove(download, removecontent=remove_content, removestate=remove_state, hidden=hidden)
def remove_download_by_id(self, infohash, remove_content=False, remove_state=True):
"""
Remove a download by it's infohash.
We can only remove content when the download object is found, otherwise only
the state is removed.
:param infohash: the download to remove
:param remove_content: whether to delete the already downloaded content from disk
:param remove_state: whether to remove the metadata files from disk
"""
download_list = self.get_downloads()
for download in download_list:
if download.get_def().get_infohash() == infohash:
return self.remove_download(download, remove_content, remove_state)
self.lm.remove_id(infohash)
def set_download_states_callback(self, user_callback, interval=1.0):
"""
See Download.set_state_callback. Calls user_callback with a list of
DownloadStates, one for each Download in the Session as first argument.
The user_callback must return a tuple (when, getpeerlist) that indicates
when to invoke the callback again (as a number of seconds from now,
or < 0.0 if not at all) and whether to also include the details of
the connected peers in the DownloadStates on that next call.
The callback will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
:param user_callback: a function adhering to the above spec
:param interval: time in between the download states callback's
"""
self.lm.set_download_states_callback(user_callback, interval)
#
# Config parameters that only exist at runtime
#
def get_permid(self):
"""
Returns the PermID of the Session, as determined by the
TriblerConfig.set_permid() parameter. A PermID is a public key.
:return: the PermID encoded in a string in DER format
"""
return str(self.keypair.pub().get_der())
#
# Notification of events in the Session
#
def add_observer(self, observer_function, subject, change_types=None, object_id=None, cache=0):
"""
Add an observer function function to the Session. The observer
function will be called when one of the specified events (changeTypes)
occurs on the specified subject.
The function will be called by a popup thread which can be used indefinitely (within reason)
by the higher level code. Note that this function is called by any thread and is thread safe.
:param observer_function: should accept as its first argument
the subject, as second argument the changeType, as third argument an
object_id (e.g. the primary key in the observed database) and an
optional list of arguments.
:param subject: the subject to observe, one of NTFY_* subjects (see simpledefs).
:param change_types: the list of events to be notified of one of NTFY_* events.
:param object_id: The specific object in the subject to monitor (e.g. a
specific primary key in a database to monitor for updates.)
:param cache: the time to bundle/cache events matching this function
"""
change_types = change_types or [NTFY_UPDATE, NTFY_INSERT, NTFY_DELETE]
self.notifier.add_observer(observer_function, subject, change_types, object_id, cache=cache)
def remove_observer(self, function):
"""
Remove observer function. No more callbacks will be made.
This function is called by any thread and is thread safe.
:param function: the observer function to remove.
"""
self.notifier.remove_observer(function)
def open_dbhandler(self, subject):
"""
Opens a connection to the specified database. Only the thread calling this method may
use this connection. The connection must be closed with close_dbhandler() when this
thread exits. This function is called by any thread.
;param subject: the database to open. Must be one of the subjects specified here.
:return: a reference to a DBHandler class for the specified subject or
None when the Session was not started with megacache enabled.
"""
if not self.config.get_megacache_enabled():
raise OperationNotEnabledByConfigurationException()
if subject == NTFY_PEERS:
return self.lm.peer_db
elif subject == NTFY_TORRENTS:
return self.lm.torrent_db
elif subject == NTFY_MYPREFERENCES:
return self.lm.mypref_db
elif subject == NTFY_VOTECAST:
return self.lm.votecast_db
elif subject == NTFY_CHANNELCAST:
return self.lm.channelcast_db
else:
raise ValueError(u"Cannot open DB subject: %s" % subject)
@staticmethod
def close_dbhandler(database_handler):
"""Closes the given database connection."""
database_handler.close()
def get_tribler_statistics(self):
"""Return a dictionary with general Tribler statistics."""
return TriblerStatistics(self).get_tribler_statistics()
def get_dispersy_statistics(self):
"""Return a dictionary with general Dispersy statistics."""
return TriblerStatistics(self).get_dispersy_statistics()
def get_dispersy_community_statistics(self):
"""Return a dictionary with Dispersy communities statistics."""
return TriblerStatistics(self).get_dispersy_community_statistics()
def get_ipv8_statistics(self):
"""Return a dictionary with IPv8 statistics."""
return TriblerStatistics(self).get_ipv8_statistics()
def get_ipv8_overlay_statistics(self):
"""Return a dictionary with IPv8 overlay statistics."""
return TriblerStatistics(self).get_ipv8_overlays_statistics()
#
# Persistence and shutdown
#
def load_checkpoint(self):
"""
Restart Downloads from a saved checkpoint, if any. Note that we fetch information from the user download
choices since it might be that a user has stopped a download. In that case, the download should not be
resumed immediately when being loaded by libtorrent.
"""
self.lm.load_checkpoint()
def checkpoint(self):
"""
Saves the internal session state to the Session's state dir.
Checkpoints the downloads via the LaunchManyCore instance. This function is called by any thread.
"""
self.lm.checkpoint_downloads()
def start_database(self):
"""
Start the SQLite database.
"""
db_path = os.path.join(self.config.get_state_dir(), DB_FILE_RELATIVE_PATH)
self.sqlite_db = SQLiteCacheDB(db_path)
self.readable_status = STATE_OPEN_DB
def start(self):
"""
Start a Tribler session by initializing the LaunchManyCore class, opening the database and running the upgrader.
Returns a deferred that fires when the Tribler session is ready for use.
"""
# Start the REST API before the upgrader since we want to send interesting upgrader events over the socket
if self.config.get_http_api_enabled():
self.lm.api_manager = RESTManager(self)
self.readable_status = STATE_START_API
self.lm.api_manager.start()
self.start_database()
if self.upgrader_enabled:
upgrader = TriblerUpgrader(self, self.sqlite_db)
self.readable_status = STATE_UPGRADING_READABLE
upgrader.run()
startup_deferred = self.lm.register(self, self.session_lock)
def load_checkpoint(_):
if self.config.get_libtorrent_enabled():
self.readable_status = STATE_LOAD_CHECKPOINTS
self.load_checkpoint()
self.readable_status = STATE_READABLE_STARTED
return startup_deferred.addCallback(load_checkpoint)
def shutdown(self):
"""
Checkpoints the session and closes it, stopping the download engine.
This method has to be called from the reactor thread.
"""
assert isInIOThread()
@inlineCallbacks
def on_early_shutdown_complete(_):
"""
Callback that gets called when the early shutdown has been completed.
Continues the shutdown procedure that is dependant on the early shutdown.
:param _: ignored parameter of the Deferred
"""
self.config.write()
yield self.checkpoint_downloads()
self.lm.shutdown_downloads()
self.lm.network_shutdown()
if self.lm.mds:
self.lm.mds.shutdown()
if self.sqlite_db:
self.sqlite_db.close()
self.sqlite_db = None
return self.lm.early_shutdown().addCallback(on_early_shutdown_complete)
def has_shutdown(self):
"""
Whether the Session has completely shutdown, i.e., its internal
threads are finished and it is safe to quit the process the Session
is running in.
:return: a boolean.
"""
return self.lm.sessdoneflag.isSet()
def get_downloads_pstate_dir(self):
"""
Returns the directory in which to checkpoint the Downloads in this
Session. This function is called by the network thread.
"""
return os.path.join(self.config.get_state_dir(), STATEDIR_DLPSTATE_DIR)
def download_torrentfile(self, infohash=None, user_callback=None, priority=0):
"""
Try to download the torrent file without a known source. A possible source could be the DHT.
If the torrent is received successfully, the user_callback method is called with the infohash as first
and the contents of the torrent file (bencoded dict) as second parameter. If the torrent could not
be obtained, the callback is not called. The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
:param infohash: the infohash of the torrent
:param user_callback: a function adhering to the above spec
:param priority: the priority of this download
"""
if not self.lm.rtorrent_handler:
raise OperationNotEnabledByConfigurationException()
self.lm.rtorrent_handler.download_torrent(None, infohash, user_callback=user_callback, priority=priority)
def download_torrentfile_from_peer(self, candidate, infohash=None, user_callback=None, priority=0):
"""
Ask the designated peer to send us the torrent file for the torrent
identified by the passed infohash. If the torrent is successfully
received, the user_callback method is called with the infohash as first
and the contents of the torrent file (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
:param candidate: the designated peer
:param infohash: the infohash of the torrent
:param user_callback: a function adhering to the above spec
:param priority: priority of this request
"""
if not self.lm.rtorrent_handler:
raise OperationNotEnabledByConfigurationException()
self.lm.rtorrent_handler.download_torrent(candidate, infohash, user_callback=user_callback, priority=priority)
def download_torrentmessage_from_peer(self, candidate, infohash, user_callback, priority=0):
"""
Ask the designated peer to send us the torrent message for the torrent
identified by the passed infohash. If the torrent message is successfully
received, the user_callback method is called with the infohash as first
and the contents of the torrent file (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
:param candidate: the designated peer
:param infohash: the infohash of the torrent
:param user_callback: a function adhering to the above spec
:param priority: priority of this request
"""
if not self.lm.rtorrent_handler:
raise OperationNotEnabledByConfigurationException()
self.lm.rtorrent_handler.download_torrentmessage(candidate, infohash, user_callback, priority)
def get_dispersy_instance(self):
if not self.config.get_dispersy_enabled():
raise OperationNotEnabledByConfigurationException()
return self.lm.dispersy
def get_ipv8_instance(self):
if not self.config.get_ipv8_enabled():
raise OperationNotEnabledByConfigurationException()
return self.lm.ipv8
def get_libtorrent_process(self):
if not self.config.get_libtorrent_enabled():
raise OperationNotEnabledByConfigurationException()
return self.lm.ltmgr
#
# Internal persistence methods
#
def checkpoint_downloads(self):
"""Checkpoints the downloads."""
return self.lm.checkpoint_downloads()
def update_trackers(self, infohash, trackers):
"""
Updates the trackers of a torrent.
:param infohash: infohash of the torrent that needs to be updated
:param trackers: A list of tracker urls
"""
return self.lm.update_trackers(infohash, trackers)
def has_collected_torrent(self, infohash):
"""
Checks if the given torrent infohash exists in the torrent_store database.
:param infohash: The given infohash binary
:return: True or False indicating if we have the torrent
"""
if not self.config.get_torrent_store_enabled():
raise OperationNotEnabledByConfigurationException("torrent_store is not enabled")
return hexlify(infohash) in self.lm.torrent_store
def get_collected_torrent(self, infohash):
"""
Gets the given torrent from the torrent_store database.
:param infohash: the given infohash binary
:return: the torrent data if exists, None otherwise
"""
if not self.config.get_torrent_store_enabled():
raise OperationNotEnabledByConfigurationException("torrent_store is not enabled")
return self.lm.torrent_store.get(hexlify(infohash))
def save_collected_torrent(self, infohash, data):
"""
Saves the given torrent into the torrent_store database.
:param infohash: the given infohash binary
:param data: the torrent file data
"""
if not self.config.get_torrent_store_enabled():
raise OperationNotEnabledByConfigurationException("torrent_store is not enabled")
self.lm.torrent_store.put(hexlify(infohash), data)
def delete_collected_torrent(self, infohash):
"""
Deletes the given torrent from the torrent_store database.
:param infohash: the given infohash binary
"""
if not self.config.get_torrent_store_enabled():
raise OperationNotEnabledByConfigurationException("torrent_store is not enabled")
del self.lm.torrent_store[hexlify(infohash)]
def search_remote_torrents(self, keywords):
"""
Searches for remote torrents through SearchCommunity with the given keywords.
:param keywords: the given keywords
:return: the number of requests made
"""
if not self.config.get_torrent_search_enabled():
raise OperationNotEnabledByConfigurationException("torrent_search is not enabled")
return self.lm.search_manager.search_for_torrents(keywords)
def search_remote_channels(self, keywords):
"""
Searches for remote channels through AllChannelCommunity with the given keywords.
:param keywords: the given keywords
"""
if not self.config.get_channel_search_enabled():
raise OperationNotEnabledByConfigurationException("channel_search is not enabled")
self.lm.search_manager.search_for_channels(keywords)
@staticmethod
def create_torrent_file(file_path_list, params=None):
"""
Creates a torrent file.
:param file_path_list: files to add in torrent file
:param params: optional parameters for torrent file
:return: a Deferred that fires when the torrent file has been created
"""
params = params or {}
return threads.deferToThread(torrent_utils.create_torrent_file, file_path_list, params)
def create_channel(self, name, description, mode=u'closed'):
"""
Creates a new Channel.
:param name: name of the Channel
:param description: description of the Channel
:param mode: mode of the Channel ('open', 'semi-open', or 'closed')
:return: a channel ID
:raises a DuplicateChannelNameError if name already exists
"""
return self.lm.channel_manager.create_channel(name, description, mode)
def add_torrent_def_to_channel(self, channel_id, torrent_def, extra_info=None, forward=True):
"""
Adds a TorrentDef to a Channel.
:param channel_id: id of the Channel to add the Torrent to
:param torrent_def: definition of the Torrent to add
:param extra_info: description of the Torrent to add
:param forward: when True the messages are forwarded (as defined by their message
destination policy) to other nodes in the community. This parameter should (almost always)
be True, its inclusion is mostly to allow certain debugging scenarios
"""
extra_info = extra_info or {}
# Make sure that this new torrent_def is also in collected torrents
self.lm.rtorrent_handler.save_torrent(torrent_def)
channelcast_db = self.open_dbhandler(NTFY_CHANNELCAST)
if channelcast_db.hasTorrent(channel_id, torrent_def.infohash):
raise DuplicateTorrentFileError("This torrent file already exists in your channel.")
dispersy_cid = str(channelcast_db.getDispersyCIDFromChannelId(channel_id))
community = self.get_dispersy_instance().get_community(dispersy_cid)
community._disp_create_torrent(
torrent_def.infohash,
long(time.time()),
torrent_def.get_name_as_unicode(),
tuple(torrent_def.get_files_with_length()),
torrent_def.get_trackers_as_single_tuple(),
forward=forward)
if 'description' in extra_info:
desc = extra_info['description'].strip()
if desc != '':
data = channelcast_db.getTorrentFromChannelId(channel_id, torrent_def.infohash, ['ChannelTorrents.id'])
community.modifyTorrent(data, {'description': desc}, forward=forward)
def check_torrent_health(self, infohash, timeout=20, scrape_now=False):
"""
Checks the given torrent's health on its trackers.
:param infohash: the given torrent infohash
:param timeout: time to wait while performing the request
:param scrape_now: flag to scrape immediately
"""
if self.lm.torrent_checker:
return self.lm.torrent_checker.add_gui_request(infohash, timeout=timeout, scrape_now=scrape_now)
return fail(Failure(RuntimeError("Torrent checker not available")))
def get_thumbnail_data(self, thumb_hash):
"""
Gets the thumbnail data.
:param thumb_hash: the thumbnail SHA1 hash
:return: the thumbnail data
"""
if not self.lm.metadata_store:
raise OperationNotEnabledByConfigurationException("libtorrent is not enabled")
return self.lm.rtorrent_handler.get_metadata(thumb_hash)
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']
# 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 = 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
# 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
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 TestLaunchManyCore(TriblerCoreTest):
"""
This class contains various small unit tests for the LaunchManyCore class.
"""
DATA_DIR = os.path.join(
os.path.abspath(os.path.dirname(os.path.realpath(__file__))), 'data')
def setUp(self, annotate=True):
TriblerCoreTest.setUp(self, annotate=annotate)
self.lm = TriblerLaunchMany()
self.lm.session_lock = NoDispersyRLock()
self.lm.session = MockObject()
self.lm.session.config = MockObject()
self.lm.session.config.get_max_upload_rate = lambda: 100
self.lm.session.config.get_max_download_rate = lambda: 100
self.lm.session.config.get_default_number_hops = lambda: 0
# Ignore notifications
mock_notifier = MockObject()
mock_notifier.notify = lambda *_: None
self.lm.session.notifier = mock_notifier
@raises(ValueError)
def test_add_tdef_not_finalized(self):
"""
Testing whether a ValueError is raised when a non-finalized tdef is added as download.
"""
self.lm.add(TorrentDef(), None)
def test_load_download_pstate(self):
"""
Testing whether a pstate is successfully loaded
"""
config_file_path = os.path.abspath(
os.path.join(self.DATA_DIR, u"config_files", u"config1.conf"))
config = self.lm.load_download_pstate(config_file_path)
self.assertIsInstance(config, CallbackConfigParser)
self.assertEqual(config.get('general', 'version'), 11)
@deferred(timeout=10)
def test_dlstates_cb_error(self):
"""
Testing whether a download is stopped on error in the download states callback in LaunchManyCore
"""
error_stop_deferred = Deferred()
def mocked_stop():
error_stop_deferred.callback(None)
error_tdef = TorrentDef()
error_tdef.get_infohash = lambda: 'aaaa'
fake_error_download = MockObject()
fake_error_download.get_def = lambda: error_tdef
fake_error_download.get_def().get_name_as_unicode = lambda: "test.iso"
fake_error_download.stop = mocked_stop
fake_error_state = MockObject()
fake_error_state.get_infohash = lambda: 'aaaa'
fake_error_state.get_error = lambda: "test error"
fake_error_state.get_status = lambda: DLSTATUS_STOPPED_ON_ERROR
fake_error_state.get_download = lambda: fake_error_download
self.lm.downloads = {'aaaa': fake_error_download}
self.lm.sesscb_states_callback([fake_error_state])
return error_stop_deferred
def test_readd_download_safe_seeding(self):
"""
Test whether a download is re-added when doing safe seeding
"""
readd_deferred = Deferred()
def mocked_update_download_hops(*_):
readd_deferred.callback(None)
self.lm.update_download_hops = mocked_update_download_hops
tdef = TorrentDef()
tdef.get_infohash = lambda: 'aaaa'
fake_download = MockObject()
fake_download.get_def = lambda: tdef
fake_download.get_def().get_name_as_unicode = lambda: "test.iso"
fake_download.get_hops = lambda: 0
fake_download.get_safe_seeding = lambda: True
dl_state = MockObject()
dl_state.get_infohash = lambda: 'aaaa'
dl_state.get_status = lambda: DLSTATUS_SEEDING
dl_state.get_download = lambda: fake_download
self.lm.downloads = {'aaaa': fake_download}
self.lm.sesscb_states_callback([dl_state])
return readd_deferred
def test_load_checkpoint(self):
"""
Test whether we are resuming downloads after loading checkpoint
"""
def mocked_resume_download(filename, setupDelay=3):
self.assertTrue(filename.endswith('abcd.state'))
self.assertEqual(setupDelay, 0)
mocked_resume_download.called = True
mocked_resume_download.called = False
self.lm.session.get_downloads_pstate_dir = lambda: self.session_base_dir
with open(
os.path.join(self.lm.session.get_downloads_pstate_dir(),
'abcd.state'), 'wb') as state_file:
state_file.write("hi")
self.lm.initComplete = True
self.lm.resume_download = mocked_resume_download
self.lm.load_checkpoint()
self.assertTrue(mocked_resume_download.called)
def test_resume_download(self):
with open(os.path.join(TESTS_DATA_DIR, "bak_single.torrent"),
mode='rb') as torrent_file:
torrent_data = torrent_file.read()
def mocked_load_download_pstate(_):
raise ValueError()
def mocked_add(tdef, dscfg, pstate, **_):
self.assertTrue(tdef)
self.assertTrue(dscfg)
self.assertIsNone(pstate)
mocked_add.called = True
mocked_add.called = False
self.lm.load_download_pstate = mocked_load_download_pstate
self.lm.torrent_store = MockObject()
self.lm.torrent_store.get = lambda _: torrent_data
self.lm.add = mocked_add
self.lm.mypref_db = MockObject()
self.lm.mypref_db.getMyPrefStatsInfohash = lambda _: TESTS_DATA_DIR
self.lm.resume_download('%s.state' % ('a' * 20))
self.assertTrue(mocked_add.called)
class TestLaunchManyCore(TriblerCoreTest):
"""
This class contains various small unit tests for the LaunchManyCore class.
"""
DATA_DIR = os.path.join(os.path.abspath(os.path.dirname(os.path.realpath(__file__))), 'data')
def setUp(self):
TriblerCoreTest.setUp(self)
self.lm = TriblerLaunchMany()
self.lm.session_lock = NoDispersyRLock()
self.lm.session = MockObject()
self.lm.session.config = MockObject()
self.lm.session.config.get_max_upload_rate = lambda: 100
self.lm.session.config.get_max_download_rate = lambda: 100
self.lm.session.config.get_default_number_hops = lambda: 0
# Ignore notifications
mock_notifier = MockObject()
mock_notifier.notify = lambda *_: None
self.lm.session.notifier = mock_notifier
@staticmethod
def create_fake_download_and_state():
"""
Create a fake download and state which can be passed to the global download callback.
"""
tdef = TorrentDef()
tdef.get_infohash = lambda: 'aaaa'
fake_peer = {'extended_version': 'Tribler', 'id': 'a' * 20, 'dtotal': 10 * 1024 * 1024}
fake_download = MockObject()
fake_download.get_def = lambda: tdef
fake_download.get_def().get_name_as_unicode = lambda: "test.iso"
fake_download.get_hops = lambda: 0
fake_download.get_safe_seeding = lambda: True
fake_download.get_peerlist = lambda: [fake_peer]
dl_state = MockObject()
dl_state.get_infohash = lambda: 'aaaa'
dl_state.get_status = lambda: DLSTATUS_SEEDING
dl_state.get_download = lambda: fake_download
return fake_download, dl_state
@raises(ValueError)
def test_add_tdef_not_finalized(self):
"""
Testing whether a ValueError is raised when a non-finalized tdef is added as download.
"""
self.lm.add(TorrentDef(), None)
def test_load_download_pstate(self):
"""
Testing whether a pstate is successfully loaded
"""
config_file_path = os.path.abspath(os.path.join(self.DATA_DIR, u"config_files", u"config1.conf"))
config = self.lm.load_download_pstate(config_file_path)
self.assertIsInstance(config, CallbackConfigParser)
self.assertEqual(config.get('general', 'version'), 11)
@trial_timeout(10)
def test_dlstates_cb_error(self):
"""
Testing whether a download is stopped on error in the download states callback in LaunchManyCore
"""
error_stop_deferred = Deferred()
def mocked_stop():
error_stop_deferred.callback(None)
fake_error_download, fake_error_state = TestLaunchManyCore.create_fake_download_and_state()
fake_error_download.stop = mocked_stop
fake_error_state.get_status = lambda: DLSTATUS_STOPPED_ON_ERROR
fake_error_state.get_error = lambda: "test error"
self.lm.downloads = {'aaaa': fake_error_download}
self.lm.sesscb_states_callback([fake_error_state])
return error_stop_deferred
def test_readd_download_safe_seeding(self):
"""
Test whether a download is re-added when doing safe seeding
"""
readd_deferred = Deferred()
def mocked_update_download_hops(*_):
readd_deferred.callback(None)
self.lm.update_download_hops = mocked_update_download_hops
fake_download, dl_state = TestLaunchManyCore.create_fake_download_and_state()
self.lm.downloads = {'aaaa': fake_download}
self.lm.sesscb_states_callback([dl_state])
return readd_deferred
def test_update_payout_balance(self):
"""
Test whether the balance of peers is correctly updated
"""
fake_download, dl_state = TestLaunchManyCore.create_fake_download_and_state()
dl_state.get_status = lambda: DLSTATUS_DOWNLOADING
fake_tc = MockObject()
fake_tc.add_listener = lambda *_: None
self.lm.payout_manager = PayoutManager(fake_tc, None)
self.lm.state_cb_count = 4
self.lm.downloads = {'aaaa': fake_download}
self.lm.sesscb_states_callback([dl_state])
self.assertTrue(self.lm.payout_manager.tribler_peers)
def test_load_checkpoint(self):
"""
Test whether we are resuming downloads after loading checkpoint
"""
def mocked_resume_download(filename, setupDelay=3):
self.assertTrue(filename.endswith('abcd.state'))
self.assertEqual(setupDelay, 0)
mocked_resume_download.called = True
mocked_resume_download.called = False
self.lm.session.get_downloads_pstate_dir = lambda: self.session_base_dir
with open(os.path.join(self.lm.session.get_downloads_pstate_dir(), 'abcd.state'), 'wb') as state_file:
state_file.write("hi")
self.lm.initComplete = True
self.lm.resume_download = mocked_resume_download
self.lm.load_checkpoint()
self.assertTrue(mocked_resume_download.called)
def test_resume_download(self):
with open(os.path.join(TESTS_DATA_DIR, "bak_single.torrent"), mode='rb') as torrent_file:
torrent_data = torrent_file.read()
def mocked_load_download_pstate(_):
raise ValueError()
def mocked_add(tdef, dscfg, pstate, **_):
self.assertTrue(tdef)
self.assertTrue(dscfg)
self.assertIsNone(pstate)
mocked_add.called = True
mocked_add.called = False
self.lm.load_download_pstate = mocked_load_download_pstate
self.lm.torrent_store = MockObject()
self.lm.torrent_store.get = lambda _: torrent_data
self.lm.add = mocked_add
self.lm.mypref_db = MockObject()
self.lm.mypref_db.getMyPrefStatsInfohash = lambda _: TESTS_DATA_DIR
self.lm.resume_download('%s.state' % ('a' * 20))
self.assertTrue(mocked_add.called)
class Session(object):
"""
A Session is a running instance of the Tribler Core and the Core's central class.
"""
__single = None
def __init__(self, config=None, autoload_discovery=True):
"""
A Session object is created which is configured with the Tribler configuration object.
Only a single session instance can exist at a time in a process.
:param config: a TriblerConfig 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 TriblerConfig() object to
serve as startup config. Next, the config is saved in the directory
indicated by its 'state_dir' attribute.
:param autoload_discovery: only false in the Tunnel community tests
"""
addObserver(self.unhandled_error_observer)
patch_crypto_be_discovery()
self._logger = logging.getLogger(self.__class__.__name__)
self.session_lock = NoDispersyRLock()
self.config = config or TriblerConfig()
self.get_ports_in_config()
self.create_state_directory_structure()
if not self.config.get_megacache_enabled():
self.config.set_torrent_checking_enabled(False)
self.selected_ports = self.config.selected_ports
self.init_keypair()
self.lm = TriblerLaunchMany()
self.notifier = Notifier()
self.sqlite_db = None
self.upgrader_enabled = True
self.dispersy_member = None
self.readable_status = '' # Human-readable string to indicate the status during startup/shutdown of Tribler
self.autoload_discovery = autoload_discovery
def create_state_directory_structure(self):
"""Create directory structure of the state directory."""
def create_dir(path):
if not os.path.isdir(path):
os.makedirs(path)
def create_in_state_dir(path):
create_dir(os.path.join(self.config.get_state_dir(), path))
create_dir(self.config.get_state_dir())
create_dir(self.config.get_torrent_store_dir())
create_dir(self.config.get_metadata_store_dir())
create_in_state_dir(DB_DIR_NAME)
create_in_state_dir(STATEDIR_DLPSTATE_DIR)
create_in_state_dir(STATEDIR_WALLET_DIR)
def get_ports_in_config(self):
"""Claim all required random ports."""
self.config.get_libtorrent_port()
self.config.get_dispersy_port()
self.config.get_mainline_dht_port()
self.config.get_video_server_port()
self.config.get_anon_listen_port()
self.config.get_tunnel_community_socks5_listen_ports()
def init_keypair(self):
"""
Set parameters that depend on state_dir.
"""
permid_module.init()
# Set params that depend on state_dir
#
# 1. keypair
#
pair_filename = self.config.get_permid_keypair_filename()
if os.path.exists(pair_filename):
self.keypair = permid_module.read_keypair(pair_filename)
else:
self.keypair = permid_module.generate_keypair()
# Save keypair
public_key_filename = os.path.join(self.config.get_state_dir(), 'ecpub.pem')
permid_module.save_keypair(self.keypair, pair_filename)
permid_module.save_pub_key(self.keypair, public_key_filename)
trustchain_pairfilename = self.config.get_trustchain_keypair_filename()
if os.path.exists(trustchain_pairfilename):
self.trustchain_keypair = permid_module.read_keypair_trustchain(trustchain_pairfilename)
else:
self.trustchain_keypair = permid_module.generate_keypair_trustchain()
# Save keypair
trustchain_pubfilename = os.path.join(self.config.get_state_dir(), 'ecpub_multichain.pem')
permid_module.save_keypair_trustchain(self.trustchain_keypair, trustchain_pairfilename)
permid_module.save_pub_key_trustchain(self.trustchain_keypair, trustchain_pubfilename)
trustchain_testnet_pairfilename = self.config.get_trustchain_testnet_keypair_filename()
if os.path.exists(trustchain_testnet_pairfilename):
self.trustchain_testnet_keypair = permid_module.read_keypair_trustchain(trustchain_testnet_pairfilename)
else:
self.trustchain_testnet_keypair = permid_module.generate_keypair_trustchain()
# Save keypair
trustchain_testnet_pubfilename = os.path.join(self.config.get_state_dir(), 'ecpub_trustchain_testnet.pem')
permid_module.save_keypair_trustchain(self.trustchain_testnet_keypair, trustchain_testnet_pairfilename)
permid_module.save_pub_key_trustchain(self.trustchain_testnet_keypair, trustchain_testnet_pubfilename)
def unhandled_error_observer(self, event):
"""
This method is called when an unhandled error in Tribler is observed.
It broadcasts the tribler_exception event.
"""
if event['isError']:
text = ""
if 'log_legacy' in event and 'log_text' in event:
text = event['log_text']
elif 'log_failure' in event:
text = str(event['log_failure'])
# There are some errors that we are ignoring.
# No route to host: this issue is non-critical since Tribler can still function when a request fails.
if 'socket.error' in text and '[Errno 113]' in text:
self._logger.error("Observed no route to host error (but ignoring)."
"This might indicate a problem with your firewall.")
return
# Socket block: this sometimes occurres on Windows and is non-critical.
if 'socket.error' in text and '[Errno %s]' % SOCKET_BLOCK_ERRORCODE in text:
self._logger.error("Unable to send data due to socket.error %s", SOCKET_BLOCK_ERRORCODE)
return
if 'socket.error' in text and '[Errno 51]' in text:
self._logger.error("Could not send data: network is unreachable.")
return
if 'socket.error' in text and '[Errno 16]' in text:
self._logger.error("Could not send data: socket is busy.")
return
if 'socket.error' in text and '[Errno 10054]' in text:
self._logger.error("Connection forcibly closed by the remote host.")
return
if 'exceptions.ValueError: Invalid DNS-ID' in text:
self._logger.error("Invalid DNS-ID")
return
if 'twisted.web._newclient.ResponseNeverReceived' in text:
self._logger.error("Internal Twisted response error, consider updating your Twisted version.")
return
# We already have a check for invalid infohash when adding a torrent, but if somehow we get this
# error then we simply log and ignore it.
if 'exceptions.RuntimeError: invalid info-hash' in text:
self._logger.error("Invalid info-hash found")
return
if self.lm.api_manager and len(text) > 0:
self.lm.api_manager.root_endpoint.events_endpoint.on_tribler_exception(text)
self.lm.api_manager.root_endpoint.state_endpoint.on_tribler_exception(text)
def start_download_from_uri(self, uri, download_config=None):
"""
Start a download from an argument. This argument can be of the following type:
-http: Start a download from a torrent file at the given url.
-magnet: Start a download from a torrent file by using a magnet link.
-file: Start a download from a torrent file at given location.
:param uri: specifies the location of the torrent to be downloaded
:param download_config: an optional configuration for the download
:return: a deferred that fires when a download has been added to the Tribler core
"""
if self.config.get_libtorrent_enabled():
return self.lm.ltmgr.start_download_from_uri(uri, dconfig=download_config)
raise OperationNotEnabledByConfigurationException()
def start_download_from_tdef(self, torrent_definition, download_startup_config=None, hidden=False):
"""
Creates a Download object and adds it to the session. The passed
ContentDef and DownloadStartupConfig are copied into the new Download
object. The Download is then started and checkpointed.
If a checkpointed version of the Download is found, that is restarted
overriding the saved DownloadStartupConfig if "download_startup_config" is not None.
Locking is done by LaunchManyCore.
:param torrent_definition: a finalized TorrentDef
:param download_startup_config: a DownloadStartupConfig or None, in which case
a new DownloadStartupConfig() is created with its default settings
and the result becomes the runtime config of this Download
:param hidden: whether this torrent should be added to the mypreference table
:return: a Download
"""
if self.config.get_libtorrent_enabled():
return self.lm.add(torrent_definition, download_startup_config, hidden=hidden)
raise OperationNotEnabledByConfigurationException()
def resume_download_from_file(self, filename):
"""
Recreates Download from resume file.
Note: this cannot be made into a method of Download, as the Download
needs to be bound to a session, it cannot exist independently.
:return: a Download object
:raises: a NotYetImplementedException
"""
raise NotYetImplementedException()
def get_downloads(self):
"""
Returns a copy of the list of Downloads.
Locking is done by LaunchManyCore.
:return: a list of Download objects
"""
return self.lm.get_downloads()
def get_download(self, infohash):
"""
Returns the Download object for this hash.
Locking is done by LaunchManyCore.
:return: a Download object
"""
return self.lm.get_download(infohash)
def has_download(self, infohash):
"""
Checks if the torrent download already exists.
:param infohash: The torrent infohash
:return: True or False indicating if the torrent download already exists
"""
return self.lm.download_exists(infohash)
def remove_download(self, download, remove_content=False, remove_state=True, hidden=False):
"""
Stops the download and removes it from the session.
Note that LaunchManyCore locks.
:param download: the Download to remove
:param remove_content: whether to delete the already downloaded content from disk
:param remove_state: whether to delete the metadata files of the downloaded content from disk
:param hidden: whether this torrent is added to the mypreference table and this entry should be removed
"""
# locking by lm
return self.lm.remove(download, removecontent=remove_content, removestate=remove_state, hidden=hidden)
def remove_download_by_id(self, infohash, remove_content=False, remove_state=True):
"""
Remove a download by it's infohash.
We can only remove content when the download object is found, otherwise only
the state is removed.
:param infohash: the download to remove
:param remove_content: whether to delete the already downloaded content from disk
:param remove_state: whether to remove the metadata files from disk
"""
download_list = self.get_downloads()
for download in download_list:
if download.get_def().get_infohash() == infohash:
return self.remove_download(download, remove_content, remove_state)
self.lm.remove_id(infohash)
def set_download_states_callback(self, user_callback, interval=1.0):
"""
See Download.set_state_callback. Calls user_callback with a list of
DownloadStates, one for each Download in the Session as first argument.
The user_callback must return a tuple (when, getpeerlist) that indicates
when to invoke the callback again (as a number of seconds from now,
or < 0.0 if not at all) and whether to also include the details of
the connected peers in the DownloadStates on that next call.
The callback will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
:param user_callback: a function adhering to the above spec
:param interval: time in between the download states callback's
"""
self.lm.set_download_states_callback(user_callback, interval)
#
# Config parameters that only exist at runtime
#
def get_permid(self):
"""
Returns the PermID of the Session, as determined by the
TriblerConfig.set_permid() parameter. A PermID is a public key.
:return: the PermID encoded in a string in DER format
"""
return str(self.keypair.pub().get_der())
#
# Notification of events in the Session
#
def add_observer(self, observer_function, subject, change_types=None, object_id=None, cache=0):
"""
Add an observer function function to the Session. The observer
function will be called when one of the specified events (changeTypes)
occurs on the specified subject.
The function will be called by a popup thread which can be used indefinitely (within reason)
by the higher level code. Note that this function is called by any thread and is thread safe.
:param observer_function: should accept as its first argument
the subject, as second argument the changeType, as third argument an
object_id (e.g. the primary key in the observed database) and an
optional list of arguments.
:param subject: the subject to observe, one of NTFY_* subjects (see simpledefs).
:param change_types: the list of events to be notified of one of NTFY_* events.
:param object_id: The specific object in the subject to monitor (e.g. a
specific primary key in a database to monitor for updates.)
:param cache: the time to bundle/cache events matching this function
"""
change_types = change_types or [NTFY_UPDATE, NTFY_INSERT, NTFY_DELETE]
self.notifier.add_observer(observer_function, subject, change_types, object_id, cache=cache)
def remove_observer(self, function):
"""
Remove observer function. No more callbacks will be made.
This function is called by any thread and is thread safe.
:param function: the observer function to remove.
"""
self.notifier.remove_observer(function)
def open_dbhandler(self, subject):
"""
Opens a connection to the specified database. Only the thread calling this method may
use this connection. The connection must be closed with close_dbhandler() when this
thread exits. This function is called by any thread.
;param subject: the database to open. Must be one of the subjects specified here.
:return: a reference to a DBHandler class for the specified subject or
None when the Session was not started with megacache enabled.
"""
if not self.config.get_megacache_enabled():
raise OperationNotEnabledByConfigurationException()
if subject == NTFY_PEERS:
return self.lm.peer_db
elif subject == NTFY_TORRENTS:
return self.lm.torrent_db
elif subject == NTFY_MYPREFERENCES:
return self.lm.mypref_db
elif subject == NTFY_VOTECAST:
return self.lm.votecast_db
elif subject == NTFY_CHANNELCAST:
return self.lm.channelcast_db
else:
raise ValueError(u"Cannot open DB subject: %s" % subject)
@staticmethod
def close_dbhandler(database_handler):
"""Closes the given database connection."""
database_handler.close()
def get_tribler_statistics(self):
"""Return a dictionary with general Tribler statistics."""
return TriblerStatistics(self).get_tribler_statistics()
def get_dispersy_statistics(self):
"""Return a dictionary with general Dispersy statistics."""
return TriblerStatistics(self).get_dispersy_statistics()
def get_dispersy_community_statistics(self):
"""Return a dictionary with Dispersy communities statistics."""
return TriblerStatistics(self).get_dispersy_community_statistics()
def get_ipv8_overlay_statistics(self):
"""Return a dictionary with IPv8 overlay statistics."""
return TriblerStatistics(self).get_ipv8_overlays_statistics()
#
# Persistence and shutdown
#
def load_checkpoint(self):
"""
Restart Downloads from a saved checkpoint, if any. Note that we fetch information from the user download
choices since it might be that a user has stopped a download. In that case, the download should not be
resumed immediately when being loaded by libtorrent.
"""
self.lm.load_checkpoint()
def checkpoint(self):
"""
Saves the internal session state to the Session's state dir.
Checkpoints the downloads via the LaunchManyCore instance. This function is called by any thread.
"""
self.lm.checkpoint_downloads()
@blocking_call_on_reactor_thread
def start_database(self):
"""
Start the SQLite database.
"""
db_path = os.path.join(self.config.get_state_dir(), DB_FILE_RELATIVE_PATH)
self.sqlite_db = SQLiteCacheDB(db_path)
self.readable_status = STATE_OPEN_DB
self.sqlite_db.initialize()
self.sqlite_db.initial_begin()
@blocking_call_on_reactor_thread
def start(self):
"""
Start a Tribler session by initializing the LaunchManyCore class, opening the database and running the upgrader.
Returns a deferred that fires when the Tribler session is ready for use.
"""
# Start the REST API before the upgrader since we want to send interesting upgrader events over the socket
if self.config.get_http_api_enabled():
self.lm.api_manager = RESTManager(self)
self.readable_status = STATE_START_API
self.lm.api_manager.start()
self.start_database()
if self.upgrader_enabled:
upgrader = TriblerUpgrader(self, self.sqlite_db)
self.readable_status = STATE_UPGRADING_READABLE
upgrader.run()
startup_deferred = self.lm.register(self, self.session_lock)
def load_checkpoint(_):
if self.config.get_libtorrent_enabled():
self.readable_status = STATE_LOAD_CHECKPOINTS
self.load_checkpoint()
self.readable_status = STATE_READABLE_STARTED
return startup_deferred.addCallback(load_checkpoint)
@blocking_call_on_reactor_thread
def shutdown(self):
"""
Checkpoints the session and closes it, stopping the download engine.
This method has to be called from the reactor thread.
"""
assert isInIOThread()
@inlineCallbacks
def on_early_shutdown_complete(_):
"""
Callback that gets called when the early shutdown has been completed.
Continues the shutdown procedure that is dependant on the early shutdown.
:param _: ignored parameter of the Deferred
"""
self.config.write()
yield self.checkpoint_downloads()
self.lm.shutdown_downloads()
self.lm.network_shutdown()
if self.sqlite_db:
self.sqlite_db.close()
self.sqlite_db = None
return self.lm.early_shutdown().addCallback(on_early_shutdown_complete)
def has_shutdown(self):
"""
Whether the Session has completely shutdown, i.e., its internal
threads are finished and it is safe to quit the process the Session
is running in.
:return: a boolean.
"""
return self.lm.sessdoneflag.isSet()
def get_downloads_pstate_dir(self):
"""
Returns the directory in which to checkpoint the Downloads in this
Session. This function is called by the network thread.
"""
return os.path.join(self.config.get_state_dir(), STATEDIR_DLPSTATE_DIR)
def download_torrentfile(self, infohash=None, user_callback=None, priority=0):
"""
Try to download the torrent file without a known source. A possible source could be the DHT.
If the torrent is received successfully, the user_callback method is called with the infohash as first
and the contents of the torrent file (bencoded dict) as second parameter. If the torrent could not
be obtained, the callback is not called. The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
:param infohash: the infohash of the torrent
:param user_callback: a function adhering to the above spec
:param priority: the priority of this download
"""
if not self.lm.rtorrent_handler:
raise OperationNotEnabledByConfigurationException()
self.lm.rtorrent_handler.download_torrent(None, infohash, user_callback=user_callback, priority=priority)
def download_torrentfile_from_peer(self, candidate, infohash=None, user_callback=None, priority=0):
"""
Ask the designated peer to send us the torrent file for the torrent
identified by the passed infohash. If the torrent is successfully
received, the user_callback method is called with the infohash as first
and the contents of the torrent file (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
:param candidate: the designated peer
:param infohash: the infohash of the torrent
:param user_callback: a function adhering to the above spec
:param priority: priority of this request
"""
if not self.lm.rtorrent_handler:
raise OperationNotEnabledByConfigurationException()
self.lm.rtorrent_handler.download_torrent(candidate, infohash, user_callback=user_callback, priority=priority)
def download_torrentmessage_from_peer(self, candidate, infohash, user_callback, priority=0):
"""
Ask the designated peer to send us the torrent message for the torrent
identified by the passed infohash. If the torrent message is successfully
received, the user_callback method is called with the infohash as first
and the contents of the torrent file (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
:param candidate: the designated peer
:param infohash: the infohash of the torrent
:param user_callback: a function adhering to the above spec
:param priority: priority of this request
"""
if not self.lm.rtorrent_handler:
raise OperationNotEnabledByConfigurationException()
self.lm.rtorrent_handler.download_torrentmessage(candidate, infohash, user_callback, priority)
def get_dispersy_instance(self):
if not self.config.get_dispersy_enabled():
raise OperationNotEnabledByConfigurationException()
return self.lm.dispersy
def get_ipv8_instance(self):
if not self.config.get_ipv8_enabled():
raise OperationNotEnabledByConfigurationException()
return self.lm.ipv8
def get_libtorrent_process(self):
if not self.config.get_libtorrent_enabled():
raise OperationNotEnabledByConfigurationException()
return self.lm.ltmgr
#
# Internal persistence methods
#
def checkpoint_downloads(self):
"""Checkpoints the downloads."""
return self.lm.checkpoint_downloads()
def update_trackers(self, infohash, trackers):
"""
Updates the trackers of a torrent.
:param infohash: infohash of the torrent that needs to be updated
:param trackers: A list of tracker urls
"""
return self.lm.update_trackers(infohash, trackers)
def has_collected_torrent(self, infohash):
"""
Checks if the given torrent infohash exists in the torrent_store database.
:param infohash: The given infohash binary
:return: True or False indicating if we have the torrent
"""
if not self.config.get_torrent_store_enabled():
raise OperationNotEnabledByConfigurationException("torrent_store is not enabled")
return hexlify(infohash) in self.lm.torrent_store
def get_collected_torrent(self, infohash):
"""
Gets the given torrent from the torrent_store database.
:param infohash: the given infohash binary
:return: the torrent data if exists, None otherwise
"""
if not self.config.get_torrent_store_enabled():
raise OperationNotEnabledByConfigurationException("torrent_store is not enabled")
return self.lm.torrent_store.get(hexlify(infohash))
def save_collected_torrent(self, infohash, data):
"""
Saves the given torrent into the torrent_store database.
:param infohash: the given infohash binary
:param data: the torrent file data
"""
if not self.config.get_torrent_store_enabled():
raise OperationNotEnabledByConfigurationException("torrent_store is not enabled")
self.lm.torrent_store.put(hexlify(infohash), data)
def delete_collected_torrent(self, infohash):
"""
Deletes the given torrent from the torrent_store database.
:param infohash: the given infohash binary
"""
if not self.config.get_torrent_store_enabled():
raise OperationNotEnabledByConfigurationException("torrent_store is not enabled")
del self.lm.torrent_store[hexlify(infohash)]
def search_remote_torrents(self, keywords):
"""
Searches for remote torrents through SearchCommunity with the given keywords.
:param keywords: the given keywords
:return: the number of requests made
"""
if not self.config.get_torrent_search_enabled():
raise OperationNotEnabledByConfigurationException("torrent_search is not enabled")
return self.lm.search_manager.search_for_torrents(keywords)
def search_remote_channels(self, keywords):
"""
Searches for remote channels through AllChannelCommunity with the given keywords.
:param keywords: the given keywords
"""
if not self.config.get_channel_search_enabled():
raise OperationNotEnabledByConfigurationException("channel_search is not enabled")
self.lm.search_manager.search_for_channels(keywords)
@staticmethod
def create_torrent_file(file_path_list, params=None):
"""
Creates a torrent file.
:param file_path_list: files to add in torrent file
:param params: optional parameters for torrent file
:return: a Deferred that fires when the torrent file has been created
"""
params = params or {}
return threads.deferToThread(torrent_utils.create_torrent_file, file_path_list, params)
def create_channel(self, name, description, mode=u'closed'):
"""
Creates a new Channel.
:param name: name of the Channel
:param description: description of the Channel
:param mode: mode of the Channel ('open', 'semi-open', or 'closed')
:return: a channel ID
:raises a DuplicateChannelNameError if name already exists
"""
return self.lm.channel_manager.create_channel(name, description, mode)
def add_torrent_def_to_channel(self, channel_id, torrent_def, extra_info={}, forward=True):
"""
Adds a TorrentDef to a Channel.
:param channel_id: id of the Channel to add the Torrent to
:param torrent_def: definition of the Torrent to add
:param extra_info: description of the Torrent to add
:param forward: when True the messages are forwarded (as defined by their message
destination policy) to other nodes in the community. This parameter should (almost always)
be True, its inclusion is mostly to allow certain debugging scenarios
"""
# Make sure that this new torrent_def is also in collected torrents
self.lm.rtorrent_handler.save_torrent(torrent_def)
channelcast_db = self.open_dbhandler(NTFY_CHANNELCAST)
if channelcast_db.hasTorrent(channel_id, torrent_def.infohash):
raise DuplicateTorrentFileError("This torrent file already exists in your channel.")
dispersy_cid = str(channelcast_db.getDispersyCIDFromChannelId(channel_id))
community = self.get_dispersy_instance().get_community(dispersy_cid)
community._disp_create_torrent(
torrent_def.infohash,
long(time.time()),
torrent_def.get_name_as_unicode(),
tuple(torrent_def.get_files_with_length()),
torrent_def.get_trackers_as_single_tuple(),
forward=forward)
if 'description' in extra_info:
desc = extra_info['description'].strip()
if desc != '':
data = channelcast_db.getTorrentFromChannelId(channel_id, torrent_def.infohash, ['ChannelTorrents.id'])
community.modifyTorrent(data, {'description': desc}, forward=forward)
def check_torrent_health(self, infohash, timeout=20, scrape_now=False):
"""
Checks the given torrent's health on its trackers.
:param infohash: the given torrent infohash
:param timeout: time to wait while performing the request
:param scrape_now: flag to scrape immediately
"""
if self.lm.torrent_checker:
return self.lm.torrent_checker.add_gui_request(infohash, timeout=timeout, scrape_now=scrape_now)
return fail(Failure(RuntimeError("Torrent checker not available")))
def get_thumbnail_data(self, thumb_hash):
"""
Gets the thumbnail data.
:param thumb_hash: the thumbnail SHA1 hash
:return: the thumbnail data
"""
if not self.lm.metadata_store:
raise OperationNotEnabledByConfigurationException("libtorrent is not enabled")
return self.lm.rtorrent_handler.get_metadata(thumb_hash)
class Session(SessionRuntimeConfig):
"""
A Session is a running instance of the Tribler Core and the Core's central
class. It implements the SessionConfigInterface which can be used to change
session parameters at runtime (for selected parameters).
cf. libtorrent session
"""
__single = None
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()
#
# Class methods
#
def get_instance(*args, **kw):
""" Returns the Session singleton if it exists or otherwise
creates it first, in which case you need to pass the constructor
params.
@return Session."""
if Session.__single is None:
Session(*args, **kw)
return Session.__single
get_instance = staticmethod(get_instance)
def get_default_state_dir(homedirpostfix='.Tribler'):
""" Returns the factory default directory for storing session state
on the current platform (Win32,Mac,Unix).
@return An absolute path name. """
# Allow override
statedirvar = '${TSTATEDIR}'
statedir = os.path.expandvars(statedirvar)
if statedir and statedir != statedirvar:
return statedir
appdir = get_appstate_dir()
statedir = os.path.join(appdir, homedirpostfix)
return statedir
get_default_state_dir = staticmethod(get_default_state_dir)
#
# Public methods
#
def start_download(self, cdef, dcfg=None, initialdlstatus=None, hidden=False):
"""
Creates a Download object and adds it to the session. The passed
ContentDef and DownloadStartupConfig are copied into the new Download
object. The Download is then started and checkpointed.
If a checkpointed version of the Download is found, that is restarted
overriding the saved DownloadStartupConfig if "dcfg" is not None.
@param cdef A finalized TorrentDef or a SwiftDef
@param dcfg DownloadStartupConfig or None, in which case
a new DownloadStartupConfig() is created with its default settings
and the result becomes the runtime config of this Download.
@param initialdlstatus The initial download status of this Download
or None. This enables the caller to create a Download in e.g.
DLSTATUS_REPEXING state instead.
@return Download
"""
# locking by lm
if cdef.get_def_type() == "torrent":
return self.lm.add(cdef,dcfg,initialdlstatus=initialdlstatus,hidden=hidden)
else:
# SWIFTPROC
return self.lm.swift_add(cdef,dcfg,initialdlstatus=initialdlstatus,hidden=hidden)
def resume_download_from_file(self,filename):
"""
Recreates Download from resume file
@return a Download object.
Note: this cannot be made into a method of Download, as the Download
needs to be bound to a session, it cannot exist independently.
"""
raise NotYetImplementedException()
def get_downloads(self):
"""
Returns a copy of the list of Downloads.
@return A list of Download objects.
"""
# locking by lm
return self.lm.get_downloads()
def get_download(self, hash):
"""
Returns the Download object for this hash.
@return A Donwload Object.
"""
# locking by lm
return self.lm.get_download(hash)
def remove_download(self,d,removecontent=False, removestate=True):
"""
Stops the download and removes it from the session.
@param d The Download to remove
@param removecontent Whether to delete the already downloaded content
from disk.
"""
# locking by lm
if d.get_def().get_def_type() == "torrent":
self.lm.remove(d,removecontent=removecontent,removestate=removestate)
else:
# SWIFTPROC
self.lm.swift_remove(d,removecontent=removecontent,removestate=removestate)
def remove_download_by_id(self, id, removecontent=False, removestate=True):
"""
@param infohash The Download to remove
@param removecontent Whether to delete the already downloaded content
from disk.
!We can only remove content when the download object is found, otherwise only
the state is removed.
"""
downloadList = self.get_downloads()
for download in downloadList:
if download.get_def().get_id() == id:
self.remove_download(download,removecontent,removestate)
return
self.lm.remove_id(id)
self.uch.perform_removestate_callback(id, [], False)
def set_download_states_callback(self,usercallback,getpeerlist=False):
"""
See Download.set_state_callback. Calls usercallback with a list of
DownloadStates, one for each Download in the Session as first argument.
The usercallback must return a tuple (when,getpeerlist) that indicates
when to reinvoke the callback again (as a number of seconds from now,
or < 0.0 if not at all) and whether to also include the details of
the connected peers in the DownloadStates on that next call.
The callback will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
@param usercallback A function adhering to the above spec.
"""
self.lm.set_download_states_callback(usercallback,getpeerlist)
#
# Config parameters that only exist at runtime
#
def get_permid(self):
""" Returns the PermID of the Session, as determined by the
SessionConfig.set_permid() parameter. A PermID is a public key
@return The PermID encoded in a string in DER format. """
self.sesslock.acquire()
try:
return str(self.keypair.pub().get_der())
finally:
self.sesslock.release()
def get_external_ip(self):
""" Returns the external IP address of this Session, i.e., by which
it is reachable from the Internet. This address is determined via
various mechanisms such as the UPnP protocol, our dialback mechanism,
and an inspection of the local network configuration.
@return A string. """
# locking done by lm
return self.lm.get_ext_ip()
def get_externally_reachable(self):
""" Returns whether the Session is externally reachable, i.e., its
listen port is not firewalled. Use add_observer() with NTFY_REACHABLE
to register to the event of detecting reachablility. Note that due to
the use of UPnP a Session may become reachable some time after
startup and due to the Dialback mechanism, this method may return
False while the Session is actually already reachable. Note that True
doesn't mean the Session is reachable from the open Internet, could just
be from the local (otherwise firewalled) LAN.
@return A boolean. """
# Arno, LICHT: make it throw exception when used in LITE versie.
from Tribler.Core.NATFirewall.DialbackMsgHandler import DialbackMsgHandler
return DialbackMsgHandler.getInstance().isConnectable()
def get_current_startup_config_copy(self):
""" Returns a SessionStartupConfig that is a copy of the current runtime
SessionConfig.
@return SessionStartupConfig
"""
# Called by any thread
self.sesslock.acquire()
try:
sessconfig = copy.copy(self.sessconfig)
return SessionStartupConfig(sessconfig=sessconfig)
finally:
self.sesslock.release()
#
# Internal tracker
#
def get_internal_tracker_url(self):
""" Returns the announce URL for the internal tracker.
@return URL """
# Called by any thread
self.sesslock.acquire()
try:
url = None
if 'tracker_url' in self.sessconfig:
url = self.sessconfig['tracker_url'] # user defined override, e.g. specific hostname
if url is None:
ip = self.lm.get_ext_ip()
port = self.get_listen_port()
url = 'http://'+ip+':'+str(port)+'/announce/'
return url
finally:
self.sesslock.release()
def get_internal_tracker_dir(self):
""" Returns the directory containing the torrents tracked by the internal
tracker (and associated databases).
@return An absolute path. """
# Called by any thread
self.sesslock.acquire()
try:
if self.sessconfig['state_dir'] is None:
return None
else:
return os.path.join(self.sessconfig['state_dir'],STATEDIR_ITRACKER_DIR)
finally:
self.sesslock.release()
def add_to_internal_tracker(self,tdef):
""" Add a torrent def to the list of torrents tracked by the internal
tracker. Use this method to use the Session as a standalone tracker.
@param tdef A finalized TorrentDef.
"""
# Called by any thread
self.sesslock.acquire()
try:
infohash = tdef.get_infohash()
filename = self.get_internal_tracker_torrentfilename(infohash)
tdef.save(filename)
print >>sys.stderr,"Session: add_to_int_tracker: saving to",filename,"url-compat",tdef.get_url_compat()
# Bring to attention of Tracker thread
self.lm.tracker_rescan_dir()
finally:
self.sesslock.release()
def remove_from_internal_tracker(self,tdef):
""" Remove a torrent def from the list of torrents tracked by the
internal tracker. Use this method to use the Session as a standalone
tracker.
@param tdef A finalized TorrentDef.
"""
infohash = tdef.get_infohash()
self.remove_from_internal_tracker_by_infohash(infohash)
def remove_from_internal_tracker_by_infohash(self,infohash):
""" Remove a torrent def from the list of torrents tracked by the
internal tracker. Use this method to use the Session as a standalone
tracker.
@param infohash Identifier of the torrent def to remove.
"""
# Called by any thread
self.sesslock.acquire()
try:
filename = self.get_internal_tracker_torrentfilename(infohash)
if DEBUG:
print >>sys.stderr,"Session: removing itracker entry",filename
if os.access(filename,os.F_OK):
os.remove(filename)
# Bring to attention of Tracker thread
self.lm.tracker_rescan_dir()
finally:
self.sesslock.release()
#
# Notification of events in the Session
#
def add_observer(self, func, subject, changeTypes = [NTFY_UPDATE, NTFY_INSERT, NTFY_DELETE], objectID = None):
""" Add an observer function function to the Session. The observer
function will be called when one of the specified events (changeTypes)
occurs on the specified subject.
The function will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
@param func The observer function. It should accept as its first argument
the subject, as second argument the changeType, as third argument an
objectID (e.g. the primary key in the observed database) and an
optional list of arguments.
@param subject The subject to observe, one of NTFY_* subjects (see
simpledefs).
@param changeTypes The list of events to be notified of one of NTFY_*
events.
@param objectID The specific object in the subject to monitor (e.g. a
specific primary key in a database to monitor for updates.)
TODO: Jelle will add per-subject/event description here ;o)
"""
#Called by any thread
self.uch.notifier.add_observer(func, subject, changeTypes, objectID) # already threadsafe
def remove_observer(self, func):
""" Remove observer function. No more callbacks will be made.
@param func The observer function to remove. """
#Called by any thread
self.uch.notifier.remove_observer(func) # already threadsafe
def open_dbhandler(self,subject):
""" Opens a connection to the specified database. Only the thread
calling this method may use this connection. The connection must be
closed with close_dbhandler() when this thread exits.
@param subject The database to open. Must be one of the subjects
specified here.
@return A reference to a DBHandler class for the specified subject or
None when the Session was not started with megacaches enabled.
<pre> NTFY_PEERS -> PeerDBHandler
NTFY_TORRENTS -> TorrentDBHandler
NTFY_PREFERENCES -> PreferenceDBHandler
NTFY_SUPERPEERS -> SuperpeerDBHandler
NTFY_FRIENDS -> FriendsDBHandler
NTFY_MYPREFERENCES -> MyPreferenceDBHandler
NTFY_BARTERCAST -> BartercastDBHandler
NTFY_SEARCH -> SearchDBHandler
NTFY_TERM -> TermDBHandler
NTFY_VOTECAST -> VotecastDBHandler
NTFY_CHANNELCAST -> ChannelCastDBHandler
NTFY_RICH_METADATA -> MetadataDBHandler
</pre>
"""
# Called by any thread
self.sesslock.acquire()
try:
if subject == NTFY_PEERS:
return self.lm.peer_db
elif subject == NTFY_TORRENTS:
return self.lm.torrent_db
elif subject == NTFY_PREFERENCES:
return self.lm.pref_db
elif subject == NTFY_SUPERPEERS:
return self.lm.superpeer_db
elif subject == NTFY_FRIENDS:
return self.lm.friend_db
elif subject == NTFY_MYPREFERENCES:
return self.lm.mypref_db
elif subject == NTFY_BARTERCAST:
return self.lm.bartercast_db
elif subject == NTFY_SEEDINGSTATS:
return self.lm.seedingstats_db
elif subject == NTFY_SEEDINGSTATSSETTINGS:
return self.lm.seedingstatssettings_db
elif subject == NTFY_VOTECAST:
return self.lm.votecast_db
elif subject == NTFY_SEARCH:
return self.lm.search_db
elif subject == NTFY_TERM:
return self.lm.term_db
elif subject == NTFY_CHANNELCAST:
return self.lm.channelcast_db
elif subject == NTFY_RICH_METADATA:
return self.lm.richmetadataDbHandler
else:
raise ValueError('Cannot open DB subject: '+subject)
finally:
self.sesslock.release()
def close_dbhandler(self,dbhandler):
""" Closes the given database connection """
dbhandler.close()
#
# Access control
#
def set_overlay_request_policy(self, reqpol):
"""
Set a function which defines which overlay requests (e.g. proxy relay request, rquery msg)
will be answered or will be denied.
The function will be called by a network thread and must return
as soon as possible to prevent performance problems.
@param reqpol is a Tribler.Core.RequestPolicy.AbstractRequestPolicy
object.
"""
# Called by any thread
# to protect self.sessconfig
self.sesslock.acquire()
try:
overlay_loaded = self.sessconfig['overlay']
finally:
self.sesslock.release()
if overlay_loaded:
self.lm.overlay_apps.setRequestPolicy(reqpol) # already threadsafe
elif DEBUG:
print >>sys.stderr,"Session: overlay is disabled, so no overlay request policy needed"
#
# Persistence and shutdown
#
def load_checkpoint(self,initialdlstatus=None):
""" Restart Downloads from checkpoint, if any.
This method allows the API user to manage restoring downloads.
E.g. a video player that wants to start the torrent the user clicked
on first, and only then restart any sleeping torrents (e.g. seeding).
The optional initialdlstatus parameter can be set to DLSTATUS_STOPPED
to restore all the Downloads in DLSTATUS_STOPPED state.
"""
self.lm.load_checkpoint(initialdlstatus)
def checkpoint(self):
""" Saves the internal session state to the Session's state dir. """
#Called by any thread
self.checkpoint_shutdown(stop=False,checkpoint=True,gracetime=None,hacksessconfcheckpoint=False)
def shutdown(self,checkpoint=True,gracetime=2.0,hacksessconfcheckpoint=True):
""" Checkpoints the session and closes it, stopping the download engine.
@param checkpoint Whether to checkpoint the Session state on shutdown.
@param gracetime Time to allow for graceful shutdown + signoff (seconds).
"""
# Called by any thread
self.lm.early_shutdown()
self.checkpoint_shutdown(stop=True,checkpoint=checkpoint,gracetime=gracetime,hacksessconfcheckpoint=hacksessconfcheckpoint)
# Arno, 2010-08-09: now shutdown after gracetime
#self.uch.shutdown()
def has_shutdown(self):
""" Whether the Session has completely shutdown, i.e., its internal
threads are finished and it is safe to quit the process the Session
is running in.
@return A Boolean.
"""
return self.lm.sessdoneflag.isSet()
def get_downloads_pstate_dir(self):
""" Returns the directory in which to checkpoint the Downloads in this
Session. """
# Called by network thread
self.sesslock.acquire()
try:
return os.path.join(self.sessconfig['state_dir'],STATEDIR_DLPSTATE_DIR)
finally:
self.sesslock.release()
#
# Tribler Core special features
#
def query_connected_peers(self,query,usercallback,max_peers_to_query=None):
""" Ask all Tribler peers we're currently connected to resolve the
specified query and return the hits. For each peer that returns
hits the usercallback method is called with first parameter the
permid of the peer, as second parameter the query string and
as third parameter a dictionary of hits. The number of times the
usercallback method will be called is undefined.
The callback will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
At the moment we support three types of query, which are all queries for
torrent files that match a set of keywords. The format of the
query string is "SIMPLE kw1 kw2 kw3" (type 1) or "SIMPLE+METADATA kw1 kw2
kw3" (type 3). In the future we plan to support full SQL queries.
For SIMPLE queries the dictionary of hits consists of
(infohash,torrentrecord) pairs. The torrentrecord is a
dictionary that contains the following keys:
<pre>
* 'content_name': The 'name' field of the torrent as Unicode string.
* 'length': The total size of the content in the torrent.
* 'leecher': The currently known number of downloaders.
* 'seeder': The currently known number of seeders.
* 'category': A list of category strings the torrent was classified into
by the remote peer.
</pre>
From Session API version 1.0.2 the following keys were added
to the torrentrecord:
<pre>
* 'torrent_size': The size of the .torrent file.
</pre>
From Session API version 1.0.4 the following keys were added
to the torrentrecord:
<pre>
* 'channel_permid': PermID of the channel this torrent belongs to (or '')
* 'channel_name': channel name as Unicode string (or '').
For SIMPLE+METADATA queries there is an extra field
<pre>
* 'torrent_file': Bencoded contents of the .torrent file.
</pre>
The torrents *not* be automatically added to the TorrentDBHandler
(if enabled) at the time of the call.
The third type of query: search for channels. It is used to query for
channels: either a particular channel matching the permid in the query,
or a list of channels whose names match the keywords in the query
by sending the query to connected peers.
The format of the query in the corresponding scenarios should be:
a. keyword-based query: "CHANNEL k bbc"
('k' stands for keyword-based and ' '{space} is a separator followed by
the keywords)
b. permid-based query: "CHANNEL p f34wrf2345wfer2345wefd3r34r54"
('p' stands for permid-based and ' '{space} is a separator followed by
the permid)
In each of the above 2 cases, the format of the hits that is returned
by the queried peer is a dictionary of hits of (signature,channelrecord).
The channelrecord is a dictionary the contains following keys:
<pre>
* 'publisher_id': a PermID
* 'publisher_name': as Unicode string
* 'infohash': 20-byte SHA1 hash
* 'torrenthash': 20-byte SHA1 hash
* 'torrentname': as Unicode string
* 'time_stamp': as integer
</pre>
@param query A Unicode query string adhering to the above spec.
@param usercallback A function adhering to the above spec.
@return currently connected peers with olversion 6 or higher
"""
self.sesslock.acquire()
try:
if self.sessconfig['overlay']:
if not (query.startswith('SIMPLE ') or query.startswith('SIMPLE+METADATA ')) and not query.startswith('CHANNEL '):
raise ValueError("Query does not start with SIMPLE or SIMPLE+METADATA or CHANNEL (%s)"%query)
from Tribler.Core.SocialNetwork.RemoteQueryMsgHandler import RemoteQueryMsgHandler
rqmh = RemoteQueryMsgHandler.getInstance()
rqmh.send_query(query,usercallback,max_peers_to_query=max_peers_to_query)
return len(rqmh.get_connected_peers(OLPROTO_VER_SIXTH))
else:
raise OperationNotEnabledByConfigurationException("Overlay not enabled")
finally:
self.sesslock.release()
return 0
def query_peers(self,query,peers,usercallback):
""" Equal to query_connected_peers only now for a limited subset of peers.
If there is no active connnection to a peer in the list, a connection
will be made.
"""
self.sesslock.acquire()
try:
if self.sessconfig['overlay']:
if not (query.startswith('SIMPLE ') or query.startswith('SIMPLE+METADATA ')) and not query.startswith('CHANNEL '):
raise ValueError('Query does not start with SIMPLE or SIMPLE+METADATA or CHANNEL')
from Tribler.Core.SocialNetwork.RemoteQueryMsgHandler import RemoteQueryMsgHandler
rqmh = RemoteQueryMsgHandler.getInstance()
rqmh.send_query_to_peers(query,peers,usercallback)
else:
raise OperationNotEnabledByConfigurationException("Overlay not enabled")
finally:
self.sesslock.release()
def download_torrentfile(self, infohash = None, roothash = None, usercallback = None, prio = 0):
""" Try to download the torrentfile without a known source.
A possible source could be the DHT.
If the torrent is succesfully
received, the usercallback method is called with the infohash as first
and the contents of the torrentfile (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
@param infohash The infohash of the torrent.
@param usercallback A function adhering to the above spec.
"""
from Tribler.Core.RemoteTorrentHandler import RemoteTorrentHandler
rtorrent_handler = RemoteTorrentHandler.getInstance()
rtorrent_handler.download_torrent(None,infohash,roothash,usercallback,prio)
def download_torrentfile_from_peer(self, candidate, infohash=None, roothash=None, usercallback=None, prio = 0):
""" Ask the designated peer to send us the torrentfile for the torrent
identified by the passed infohash. If the torrent is succesfully
received, the usercallback method is called with the infohash as first
and the contents of the torrentfile (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
@param permid The PermID of the peer to query.
@param infohash The infohash of the torrent.
@param usercallback A function adhering to the above spec.
"""
from Tribler.Core.RemoteTorrentHandler import RemoteTorrentHandler
rtorrent_handler = RemoteTorrentHandler.getInstance()
rtorrent_handler.download_torrent(candidate,infohash,roothash,usercallback,prio)
def download_torrentmessages_from_peer(self, candidate, infohashes, usercallback, prio = 0):
""" Ask the designated peer to send us the torrentfile for the torrent
identified by the passed infohash. If the torrent is succesfully
received, the usercallback method is called with the infohash as first
and the contents of the torrentfile (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
@param permid The PermID of the peer to query.
@param infohash The infohash of the torrent.
@param usercallback A function adhering to the above spec.
"""
from Tribler.Core.RemoteTorrentHandler import RemoteTorrentHandler
rtorrent_handler = RemoteTorrentHandler.getInstance()
rtorrent_handler.download_torrentmessages(candidate,infohashes,usercallback,prio)
#
# Internal persistence methods
#
def checkpoint_shutdown(self,stop,checkpoint,gracetime,hacksessconfcheckpoint):
""" Checkpoints the Session and optionally shuts down the Session.
@param stop Whether to shutdown the Session as well.
@param checkpoint Whether to checkpoint at all, or just to stop.
@param gracetime Time to allow for graceful shutdown + signoff (seconds).
"""
# Called by any thread
self.sesslock.acquire()
try:
# Arno: Make checkpoint optional on shutdown. At the moment setting
# the config at runtime is not possible (see SessionRuntimeConfig)
# so this has little use, and interferes with our way of
# changing the startup config, which is to write a new
# config to disk that will be read at start up.
if hacksessconfcheckpoint:
try:
self.save_pstate_sessconfig()
except Exception,e:
self.lm.rawserver_nonfatalerrorfunc(e)
# Checkpoint all Downloads and stop NetworkThread
if DEBUG or stop:
print >>sys.stderr,"Session: checkpoint_shutdown"
self.lm.checkpoint(stop=stop,checkpoint=checkpoint,gracetime=gracetime)
finally:
def __init__(self,
scfg=None,
ignore_singleton=False,
autoload_discovery=True):
"""
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.
"""
addObserver(self.unhandled_error_observer)
patch_crypto_be_discovery()
if not ignore_singleton:
if Session.__single:
raise RuntimeError("Session is singleton")
Session.__single = self
self._logger = logging.getLogger(self.__class__.__name__)
self.ignore_singleton = ignore_singleton
self.sesslock = NoDispersyRLock()
# Determine startup config to use
if scfg is None: # If no override
scfg = SessionStartupConfig.load()
else: # overrides any saved config
# Work from copy
scfg = SessionStartupConfig(copy.copy(scfg.sessconfig))
def create_dir(fullpath):
if not os.path.isdir(fullpath):
os.makedirs(fullpath)
def set_and_create_dir(dirname, setter, default_dir):
if dirname is None:
setter(default_dir)
create_dir(dirname or default_dir)
state_dir = scfg.get_state_dir()
set_and_create_dir(state_dir, scfg.set_state_dir, state_dir)
set_and_create_dir(
scfg.get_torrent_store_dir(), scfg.set_torrent_store_dir,
os.path.join(scfg.get_state_dir(), STATEDIR_TORRENT_STORE_DIR))
# metadata store
set_and_create_dir(
scfg.get_metadata_store_dir(), scfg.set_metadata_store_dir,
os.path.join(scfg.get_state_dir(), STATEDIR_METADATA_STORE_DIR))
set_and_create_dir(
scfg.get_peer_icon_path(), scfg.set_peer_icon_path,
os.path.join(scfg.get_state_dir(), STATEDIR_PEERICON_DIR))
create_dir(os.path.join(scfg.get_state_dir(), u"sqlite"))
create_dir(os.path.join(scfg.get_state_dir(), STATEDIR_DLPSTATE_DIR))
if GOTM2CRYPTO:
permidmod.init()
# Set params that depend on state_dir
#
# 1. keypair
#
pairfilename = scfg.get_permid_keypair_filename()
if os.path.exists(pairfilename):
self.keypair = permidmod.read_keypair(pairfilename)
else:
self.keypair = permidmod.generate_keypair()
# Save keypair
pubfilename = os.path.join(scfg.get_state_dir(), 'ecpub.pem')
permidmod.save_keypair(self.keypair, pairfilename)
permidmod.save_pub_key(self.keypair, pubfilename)
multichain_pairfilename = scfg.get_multichain_permid_keypair_filename(
)
if os.path.exists(multichain_pairfilename):
self.multichain_keypair = permidmod.read_keypair_multichain(
multichain_pairfilename)
else:
self.multichain_keypair = permidmod.generate_keypair_multichain(
)
# Save keypair
multichain_pubfilename = os.path.join(scfg.get_state_dir(),
'ecpub_multichain.pem')
permidmod.save_keypair_multichain(self.multichain_keypair,
multichain_pairfilename)
permidmod.save_pub_key_multichain(self.multichain_keypair,
multichain_pubfilename)
if not scfg.get_megacache():
scfg.set_torrent_checking(0)
self.sessconfig = scfg.sessconfig
self.sessconfig.lock = self.sesslock
self.selected_ports = scfg.selected_ports
# Claim all random ports
self.get_listen_port()
self.get_dispersy_port()
self.get_mainline_dht_listen_port()
self.get_videoserver_port()
self.get_anon_listen_port()
self.get_tunnel_community_socks5_listen_ports()
# Create handler for calling back the user via separate threads
self.lm = TriblerLaunchMany()
self.notifier = Notifier()
# Checkpoint startup config
self.save_session_config()
self.sqlite_db = None
self.upgrader_enabled = True
self.dispersy_member = None
self.readable_status = '' # Human-readable string to indicate the status during startup/shutdown of Tribler
self.autoload_discovery = autoload_discovery
self.tribler_config = TriblerConfig(self)
self.setup_tribler_gui_config()
class Session(SessionRuntimeConfig):
"""
A Session is a running instance of the Tribler Core and the Core's central
class. It implements the SessionConfigInterface which can be used to change
session parameters at runtime (for selected parameters).
cf. libtorrent session
"""
__single = None
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 = 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 and not os.path.isdir(state_dir):
try:
os.makedirs(state_dir)
except:
state_dir = None
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
# 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
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 methods
#
def get_instance(*args, **kw):
""" Returns the Session singleton if it exists or otherwise
creates it first, in which case you need to pass the constructor
params.
@return Session."""
if Session.__single is None:
Session(*args, **kw)
return Session.__single
get_instance = staticmethod(get_instance)
def has_instance():
return Session.__single != None
has_instance = staticmethod(has_instance)
def del_instance():
Session.__single = None
del_instance = staticmethod(del_instance)
def get_default_state_dir(homedirpostfix='.Tribler'):
""" Returns the factory default directory for storing session state
on the current platform (Win32,Mac,Unix).
@return An absolute path name. """
# Allow override
statedirvar = '${TSTATEDIR}'
statedir = os.path.expandvars(statedirvar)
if statedir and statedir != statedirvar:
return statedir
if os.path.isdir(homedirpostfix):
return os.path.abspath(homedirpostfix)
appdir = get_appstate_dir()
statedir = os.path.join(appdir, homedirpostfix)
return statedir
get_default_state_dir = staticmethod(get_default_state_dir)
#
# Public methods
#
def start_download(self, cdef, dcfg=None, initialdlstatus=None, hidden=False):
"""
Creates a Download object and adds it to the session. The passed
ContentDef and DownloadStartupConfig are copied into the new Download
object. The Download is then started and checkpointed.
If a checkpointed version of the Download is found, that is restarted
overriding the saved DownloadStartupConfig if "dcfg" is not None.
@param cdef A finalized TorrentDef or a SwiftDef
@param dcfg DownloadStartupConfig or None, in which case
a new DownloadStartupConfig() is created with its default settings
and the result becomes the runtime config of this Download.
@param initialdlstatus The initial download status of this Download
or None. This enables the caller to create a Download in e.g.
DLSTATUS_STOPPED state instead.
@param hidden Whether this torrent should be added to the mypreference table
@return Download
"""
# locking by lm
if cdef.get_def_type() == "torrent":
return self.lm.add(cdef, dcfg, initialdlstatus=initialdlstatus, hidden=hidden)
else:
# SWIFTPROC
return self.lm.swift_add(cdef, dcfg, initialdlstatus=initialdlstatus, hidden=hidden)
def resume_download_from_file(self, filename):
"""
Recreates Download from resume file
@return a Download object.
Note: this cannot be made into a method of Download, as the Download
needs to be bound to a session, it cannot exist independently.
"""
raise NotYetImplementedException()
def get_downloads(self):
"""
Returns a copy of the list of Downloads.
@return A list of Download objects.
"""
# locking by lm
return self.lm.get_downloads()
def get_download(self, hash):
"""
Returns the Download object for this hash.
@return A Donwload Object.
"""
# locking by lm
return self.lm.get_download(hash)
def remove_download(self, d, removecontent=False, removestate=True, hidden=False):
"""
Stops the download and removes it from the session.
@param d The Download to remove
@param removecontent Whether to delete the already downloaded content
from disk.
@param removestate Whether to delete the metadata files of the downloaded
content from disk.
@param hidden Whether this torrent is added to the mypreference table and this entry should be
removed
"""
# locking by lm
if d.get_def().get_def_type() == "torrent":
self.lm.remove(d, removecontent=removecontent, removestate=removestate, hidden=hidden)
else:
# SWIFTPROC
self.lm.swift_remove(d, removecontent=removecontent, removestate=removestate, hidden=hidden)
def remove_download_by_id(self, id, removecontent=False, removestate=True):
"""
@param infohash The Download to remove
@param removecontent Whether to delete the already downloaded content
from disk.
!We can only remove content when the download object is found, otherwise only
the state is removed.
"""
downloadList = self.get_downloads()
for download in downloadList:
if download.get_def().get_id() == id:
self.remove_download(download, removecontent, removestate)
return
self.lm.remove_id(id)
self.uch.perform_removestate_callback(id, [], False)
def set_download_states_callback(self, usercallback, getpeerlist=False):
"""
See Download.set_state_callback. Calls usercallback with a list of
DownloadStates, one for each Download in the Session as first argument.
The usercallback must return a tuple (when,getpeerlist) that indicates
when to reinvoke the callback again (as a number of seconds from now,
or < 0.0 if not at all) and whether to also include the details of
the connected peers in the DownloadStates on that next call.
The callback will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
@param usercallback A function adhering to the above spec.
"""
self.lm.set_download_states_callback(usercallback, getpeerlist)
#
# Config parameters that only exist at runtime
#
def get_permid(self):
""" Returns the PermID of the Session, as determined by the
SessionConfig.set_permid() parameter. A PermID is a public key
@return The PermID encoded in a string in DER format. """
self.sesslock.acquire()
try:
return str(self.keypair.pub().get_der())
finally:
self.sesslock.release()
def get_external_ip(self):
""" Returns the external IP address of this Session, i.e., by which
it is reachable from the Internet. This address is determined via
various mechanisms such as the UPnP protocol, our dialback mechanism,
and an inspection of the local network configuration.
@return A string. """
# locking done by lm
return self.lm.get_ext_ip()
def get_externally_reachable(self):
""" Returns whether the Session is externally reachable, i.e., its
listen port is not firewalled. Use add_observer() with NTFY_REACHABLE
to register to the event of detecting reachablility. Note that due to
the use of UPnP a Session may become reachable some time after
startup and due to the Dialback mechanism, this method may return
False while the Session is actually already reachable. Note that True
doesn't mean the Session is reachable from the open Internet, could just
be from the local (otherwise firewalled) LAN.
@return A boolean. """
# Arno, LICHT: make it throw exception when used in LITE versie.
raise NotYetImplementedException()
def get_current_startup_config_copy(self):
""" Returns a SessionStartupConfig that is a copy of the current runtime
SessionConfig.
@return SessionStartupConfig
"""
# Called by any thread
self.sesslock.acquire()
try:
sessconfig = copy.copy(self.sessconfig)
return SessionStartupConfig(sessconfig=sessconfig)
finally:
self.sesslock.release()
#
# Internal tracker
#
def get_internal_tracker_url(self):
""" Returns the announce URL for the internal tracker.
@return URL """
# Called by any thread
self.sesslock.acquire()
try:
url = None
if 'tracker_url' in self.sessconfig:
url = self.sessconfig['tracker_url'] # user defined override, e.g. specific hostname
if url is None:
ip = self.lm.get_ext_ip()
port = self.get_listen_port()
url = 'http://' + ip + ':' + str(port) + '/announce/'
return url
finally:
self.sesslock.release()
def get_internal_tracker_dir(self):
""" Returns the directory containing the torrents tracked by the internal
tracker (and associated databases).
@return An absolute path. """
# Called by any thread
self.sesslock.acquire()
try:
if self.sessconfig['state_dir'] is None:
return None
else:
return os.path.join(self.sessconfig['state_dir'], STATEDIR_ITRACKER_DIR)
finally:
self.sesslock.release()
def add_to_internal_tracker(self, tdef):
""" Add a torrent def to the list of torrents tracked by the internal
tracker. Use this method to use the Session as a standalone tracker.
@param tdef A finalized TorrentDef.
"""
# Called by any thread
self.sesslock.acquire()
try:
infohash = tdef.get_infohash()
filename = self.get_internal_tracker_torrentfilename(infohash)
tdef.save(filename)
print >> sys.stderr, "Session: add_to_int_tracker: saving to", filename, "url-compat", tdef.get_url_compat()
# Bring to attention of Tracker thread
self.lm.tracker_rescan_dir()
finally:
self.sesslock.release()
def remove_from_internal_tracker(self, tdef):
""" Remove a torrent def from the list of torrents tracked by the
internal tracker. Use this method to use the Session as a standalone
tracker.
@param tdef A finalized TorrentDef.
"""
infohash = tdef.get_infohash()
self.remove_from_internal_tracker_by_infohash(infohash)
def remove_from_internal_tracker_by_infohash(self, infohash):
""" Remove a torrent def from the list of torrents tracked by the
internal tracker. Use this method to use the Session as a standalone
tracker.
@param infohash Identifier of the torrent def to remove.
"""
# Called by any thread
self.sesslock.acquire()
try:
filename = self.get_internal_tracker_torrentfilename(infohash)
if DEBUG:
print >> sys.stderr, "Session: removing itracker entry", filename
if os.access(filename, os.F_OK):
os.remove(filename)
# Bring to attention of Tracker thread
self.lm.tracker_rescan_dir()
finally:
self.sesslock.release()
#
# Notification of events in the Session
#
def add_observer(self, func, subject, changeTypes=[NTFY_UPDATE, NTFY_INSERT, NTFY_DELETE], objectID=None, cache=0):
""" Add an observer function function to the Session. The observer
function will be called when one of the specified events (changeTypes)
occurs on the specified subject.
The function will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
@param func The observer function. It should accept as its first argument
the subject, as second argument the changeType, as third argument an
objectID (e.g. the primary key in the observed database) and an
optional list of arguments.
@param subject The subject to observe, one of NTFY_* subjects (see
simpledefs).
@param changeTypes The list of events to be notified of one of NTFY_*
events.
@param objectID The specific object in the subject to monitor (e.g. a
specific primary key in a database to monitor for updates.)
@param cache The time to bundle/cache events matching this function
TODO: Jelle will add per-subject/event description here ;o)
"""
# Called by any thread
self.uch.notifier.add_observer(func, subject, changeTypes, objectID, cache=cache) # already threadsafe
def remove_observer(self, func):
""" Remove observer function. No more callbacks will be made.
@param func The observer function to remove. """
# Called by any thread
self.uch.notifier.remove_observer(func) # already threadsafe
def open_dbhandler(self, subject):
""" Opens a connection to the specified database. Only the thread
calling this method may use this connection. The connection must be
closed with close_dbhandler() when this thread exits.
@param subject The database to open. Must be one of the subjects
specified here.
@return A reference to a DBHandler class for the specified subject or
None when the Session was not started with megacaches enabled.
<pre> NTFY_PEERS -> PeerDBHandler
NTFY_TORRENTS -> TorrentDBHandler
NTFY_MYPREFERENCES -> MyPreferenceDBHandler
NTFY_VOTECAST -> VotecastDBHandler
NTFY_CHANNELCAST -> ChannelCastDBHandler
</pre>
"""
# Called by any thread
self.sesslock.acquire()
try:
if subject == NTFY_PEERS:
return self.lm.peer_db
elif subject == NTFY_TORRENTS:
return self.lm.torrent_db
elif subject == NTFY_MYPREFERENCES:
return self.lm.mypref_db
elif subject == NTFY_SEEDINGSTATS:
return self.lm.seedingstats_db
elif subject == NTFY_SEEDINGSTATSSETTINGS:
return self.lm.seedingstatssettings_db
elif subject == NTFY_VOTECAST:
return self.lm.votecast_db
elif subject == NTFY_CHANNELCAST:
return self.lm.channelcast_db
else:
raise ValueError('Cannot open DB subject: ' + subject)
finally:
self.sesslock.release()
def close_dbhandler(self, dbhandler):
""" Closes the given database connection """
dbhandler.close()
#
# Persistence and shutdown
#
def load_checkpoint(self, initialdlstatus=None, initialdlstatus_dict={}):
""" Restart Downloads from checkpoint, if any.
This method allows the API user to manage restoring downloads.
E.g. a video player that wants to start the torrent the user clicked
on first, and only then restart any sleeping torrents (e.g. seeding).
The optional initialdlstatus parameter can be set to DLSTATUS_STOPPED
to restore all the Downloads in DLSTATUS_STOPPED state.
The options initialdlstatus_dict parameter can be used to specify a
state overriding the initaldlstatus parameter per download id.
"""
self.lm.load_checkpoint(initialdlstatus, initialdlstatus_dict)
def checkpoint(self):
""" Saves the internal session state to the Session's state dir. """
# Called by any thread
self.checkpoint_shutdown(stop=False, checkpoint=True, gracetime=None, hacksessconfcheckpoint=False)
def shutdown(self, checkpoint=True, gracetime=2.0, hacksessconfcheckpoint=True):
""" Checkpoints the session and closes it, stopping the download engine.
@param checkpoint Whether to checkpoint the Session state on shutdown.
@param gracetime Time to allow for graceful shutdown + signoff (seconds).
"""
# Called by any thread
self.lm.early_shutdown()
self.checkpoint_shutdown(stop=True, checkpoint=checkpoint, gracetime=gracetime, hacksessconfcheckpoint=hacksessconfcheckpoint)
# Arno, 2010-08-09: now shutdown after gracetime
# self.uch.shutdown()
def has_shutdown(self):
""" Whether the Session has completely shutdown, i.e., its internal
threads are finished and it is safe to quit the process the Session
is running in.
@return A Boolean.
"""
return self.lm.sessdoneflag.isSet()
def get_downloads_pstate_dir(self):
""" Returns the directory in which to checkpoint the Downloads in this
Session. """
# Called by network thread
self.sesslock.acquire()
try:
return os.path.join(self.sessconfig['state_dir'], STATEDIR_DLPSTATE_DIR)
finally:
self.sesslock.release()
def download_torrentfile(self, infohash=None, roothash=None, usercallback=None, prio=0):
""" Try to download the torrentfile without a known source.
A possible source could be the DHT.
If the torrent is succesfully
received, the usercallback method is called with the infohash as first
and the contents of the torrentfile (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
@param infohash The infohash of the torrent.
@param usercallback A function adhering to the above spec.
"""
from Tribler.Core.RemoteTorrentHandler import RemoteTorrentHandler
rtorrent_handler = RemoteTorrentHandler.getInstance()
rtorrent_handler.download_torrent(None, infohash, roothash, usercallback, prio)
def download_torrentfile_from_peer(self, candidate, infohash=None, roothash=None, usercallback=None, prio=0):
""" Ask the designated peer to send us the torrentfile for the torrent
identified by the passed infohash. If the torrent is succesfully
received, the usercallback method is called with the infohash as first
and the contents of the torrentfile (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
@param permid The PermID of the peer to query.
@param infohash The infohash of the torrent.
@param usercallback A function adhering to the above spec.
"""
from Tribler.Core.RemoteTorrentHandler import RemoteTorrentHandler
rtorrent_handler = RemoteTorrentHandler.getInstance()
rtorrent_handler.download_torrent(candidate, infohash, roothash, usercallback, prio)
def download_torrentmessages_from_peer(self, candidate, infohashes, usercallback, prio=0):
""" Ask the designated peer to send us the torrentfile for the torrent
identified by the passed infohash. If the torrent is succesfully
received, the usercallback method is called with the infohash as first
and the contents of the torrentfile (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
@param permid The PermID of the peer to query.
@param infohash The infohash of the torrent.
@param usercallback A function adhering to the above spec.
"""
from Tribler.Core.RemoteTorrentHandler import RemoteTorrentHandler
rtorrent_handler = RemoteTorrentHandler.getInstance()
rtorrent_handler.download_torrentmessages(candidate, infohashes, usercallback, prio)
#
# Internal persistence methods
#
def checkpoint_shutdown(self, stop, checkpoint, gracetime, hacksessconfcheckpoint):
""" Checkpoints the Session and optionally shuts down the Session.
@param stop Whether to shutdown the Session as well.
@param checkpoint Whether to checkpoint at all, or just to stop.
@param gracetime Time to allow for graceful shutdown + signoff (seconds).
"""
# Called by any thread
self.sesslock.acquire()
try:
# Arno: Make checkpoint optional on shutdown. At the moment setting
# the config at runtime is not possible (see SessionRuntimeConfig)
# so this has little use, and interferes with our way of
# changing the startup config, which is to write a new
# config to disk that will be read at start up.
if hacksessconfcheckpoint:
try:
self.save_pstate_sessconfig()
except Exception, e:
self.lm.rawserver_nonfatalerrorfunc(e)
# Checkpoint all Downloads and stop NetworkThread
if DEBUG or stop:
print >> sys.stderr, "Session: checkpoint_shutdown"
self.lm.checkpoint(stop=stop, checkpoint=checkpoint, gracetime=gracetime)
finally:
class Session(SessionConfigInterface):
"""
A Session is a running instance of the Tribler Core and the Core's central
class. It implements the SessionConfigInterface which can be used to change
session parameters at runtime (for selected parameters).
cf. libtorrent session
"""
__single = None
def __init__(self,
scfg=None,
ignore_singleton=False,
autoload_discovery=True):
"""
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.
"""
addObserver(self.unhandled_error_observer)
patch_crypto_be_discovery()
if not ignore_singleton:
if Session.__single:
raise RuntimeError("Session is singleton")
Session.__single = self
self._logger = logging.getLogger(self.__class__.__name__)
self.ignore_singleton = ignore_singleton
self.sesslock = NoDispersyRLock()
# Determine startup config to use
if scfg is None: # If no override
scfg = SessionStartupConfig.load()
else: # overrides any saved config
# Work from copy
scfg = SessionStartupConfig(copy.copy(scfg.sessconfig))
def create_dir(fullpath):
if not os.path.isdir(fullpath):
os.makedirs(fullpath)
def set_and_create_dir(dirname, setter, default_dir):
if dirname is None:
setter(default_dir)
create_dir(dirname or default_dir)
state_dir = scfg.get_state_dir()
set_and_create_dir(state_dir, scfg.set_state_dir, state_dir)
set_and_create_dir(
scfg.get_torrent_store_dir(), scfg.set_torrent_store_dir,
os.path.join(scfg.get_state_dir(), STATEDIR_TORRENT_STORE_DIR))
# metadata store
set_and_create_dir(
scfg.get_metadata_store_dir(), scfg.set_metadata_store_dir,
os.path.join(scfg.get_state_dir(), STATEDIR_METADATA_STORE_DIR))
set_and_create_dir(
scfg.get_peer_icon_path(), scfg.set_peer_icon_path,
os.path.join(scfg.get_state_dir(), STATEDIR_PEERICON_DIR))
create_dir(os.path.join(scfg.get_state_dir(), u"sqlite"))
create_dir(os.path.join(scfg.get_state_dir(), STATEDIR_DLPSTATE_DIR))
if GOTM2CRYPTO:
permidmod.init()
# Set params that depend on state_dir
#
# 1. keypair
#
pairfilename = scfg.get_permid_keypair_filename()
if os.path.exists(pairfilename):
self.keypair = permidmod.read_keypair(pairfilename)
else:
self.keypair = permidmod.generate_keypair()
# Save keypair
pubfilename = os.path.join(scfg.get_state_dir(), 'ecpub.pem')
permidmod.save_keypair(self.keypair, pairfilename)
permidmod.save_pub_key(self.keypair, pubfilename)
multichain_pairfilename = scfg.get_multichain_permid_keypair_filename(
)
if os.path.exists(multichain_pairfilename):
self.multichain_keypair = permidmod.read_keypair_multichain(
multichain_pairfilename)
else:
self.multichain_keypair = permidmod.generate_keypair_multichain(
)
# Save keypair
multichain_pubfilename = os.path.join(scfg.get_state_dir(),
'ecpub_multichain.pem')
permidmod.save_keypair_multichain(self.multichain_keypair,
multichain_pairfilename)
permidmod.save_pub_key_multichain(self.multichain_keypair,
multichain_pubfilename)
if not scfg.get_megacache():
scfg.set_torrent_checking(0)
self.sessconfig = scfg.sessconfig
self.sessconfig.lock = self.sesslock
self.selected_ports = scfg.selected_ports
# Claim all random ports
self.get_listen_port()
self.get_dispersy_port()
self.get_mainline_dht_listen_port()
self.get_videoserver_port()
self.get_anon_listen_port()
self.get_tunnel_community_socks5_listen_ports()
# Create handler for calling back the user via separate threads
self.lm = TriblerLaunchMany()
self.notifier = Notifier()
# Checkpoint startup config
self.save_session_config()
self.sqlite_db = None
self.upgrader_enabled = True
self.dispersy_member = None
self.readable_status = '' # Human-readable string to indicate the status during startup/shutdown of Tribler
self.autoload_discovery = autoload_discovery
self.tribler_config = TriblerConfig(self)
self.setup_tribler_gui_config()
#
# Class methods
#
@staticmethod
def get_instance(*args, **kw):
""" Returns the Session singleton if it exists or otherwise
creates it first, in which case you need to pass the constructor
params.
@return Session."""
if Session.__single is None:
Session(*args, **kw)
return Session.__single
@staticmethod
def has_instance():
return Session.__single is not None
@staticmethod
def del_instance():
Session.__single = None
def unhandled_error_observer(self, event):
"""
This method is called when an unhandled error in Tribler is observed. Broadcasts the tribler_exception event.
"""
if event['isError']:
text = ""
if 'log_legacy' in event and 'log_text' in event:
text = event['log_text']
elif 'log_failure' in event:
text = str(event['log_failure'])
# There are some errors that we are ignoring.
# No route to host: this issue is non-critical since Tribler can still function when a request fails.
if 'socket.error: [Errno 113]' in text:
self._logger.error(
"Observed no route to host error (but ignoring)."
"This might indicate a problem with your firewall.")
return
# Socket block: this sometimes occurres on Windows and is non-critical.
if 'socket.error: [Errno %s]' % SOCKET_BLOCK_ERRORCODE in text:
self._logger.error(
"Unable to send data due to socket.error %s",
SOCKET_BLOCK_ERRORCODE)
return
if 'socket.error: [Errno 51]' in text:
self._logger.error(
"Could not send data: network is unreachable.")
return
if 'exceptions.ValueError: Invalid DNS-ID' in text:
self._logger.error("Invalid DNS-ID")
return
# We already have a check for invalid infohash when adding a torrent, but if somehow we get this
# error then we simply log and ignore it.
if 'exceptions.RuntimeError: invalid info-hash' in text:
self._logger.error("Invalid info-hash found")
return
if self.lm.api_manager and len(text) > 0:
self.lm.api_manager.root_endpoint.events_endpoint.on_tribler_exception(
text)
self.lm.api_manager.root_endpoint.state_endpoint.on_tribler_exception(
text)
#
# Public methods
#
def setup_tribler_gui_config(self):
"""
Initialize the TriblerGUI configuration file and make sure that we have all required values.
"""
configfilepath = os.path.join(self.get_state_dir(), STATEDIR_GUICONFIG)
gui_config = CallbackConfigParser()
DefaultDownloadStartupConfig.getInstance().set_dest_dir(
get_default_dest_dir())
# Load the config file.
if os.path.exists(configfilepath):
gui_config.read_file(configfilepath, 'utf-8-sig')
if not gui_config.has_section('Tribler'):
gui_config.add_section('Tribler')
for k, v in tribler_defaults['Tribler'].iteritems():
if not gui_config.has_option('Tribler', k):
gui_config.set('Tribler', k, v)
if not gui_config.has_section('downloadconfig'):
gui_config.add_section('downloadconfig')
for k, v in DefaultDownloadStartupConfig.getInstance(
).dlconfig._sections['downloadconfig'].iteritems():
if not gui_config.has_option('downloadconfig', k):
gui_config.set('downloadconfig', k, v)
# Make sure we use the same ConfigParser instance for both Utility and DefaultDownloadStartupConfig.
DefaultDownloadStartupConfig.getInstance().dlconfig = gui_config
gui_config.write_file(configfilepath)
# Update all dldefaults to use the settings in gui_config
for k, v in gui_config._sections['downloadconfig'].iteritems():
dldefaults['downloadconfig'][k] = v
def start_download_from_uri(self, uri, dconfig=None):
"""
Start a download from an argument. This argument can be of the following type:
-http: Start a download from a torrent file at the given url.
-magnet: Start a download from a torrent file by using a magnet link.
-file: Start a download from a torrent file at given location.
:param uri: The argument that specifies the location of the torrent to be downloaded.
:param dconfig: An optional configuration for the download.
:return: A deferred that fires when a download has been added to the Tribler core.
"""
if self.get_libtorrent():
return self.lm.ltmgr.start_download_from_uri(uri, dconfig=dconfig)
raise OperationNotEnabledByConfigurationException()
def start_download_from_tdef(self, tdef, dcfg=None, hidden=False):
"""
Creates a Download object and adds it to the session. The passed
ContentDef and DownloadStartupConfig are copied into the new Download
object. The Download is then started and checkpointed.
If a checkpointed version of the Download is found, that is restarted
overriding the saved DownloadStartupConfig if "dcfg" is not None.
@param tdef A finalized TorrentDef
@param dcfg DownloadStartupConfig or None, in which case
a new DownloadStartupConfig() is created with its default settings
and the result becomes the runtime config of this Download.
@param hidden Whether this torrent should be added to the mypreference table
@return Download
"""
# locking by lm
if self.get_libtorrent():
return self.lm.add(tdef, dcfg, hidden=hidden)
raise OperationNotEnabledByConfigurationException()
def resume_download_from_file(self, filename):
"""
Recreates Download from resume file
@return a Download object.
Note: this cannot be made into a method of Download, as the Download
needs to be bound to a session, it cannot exist independently.
"""
raise NotYetImplementedException()
def get_downloads(self):
"""
Returns a copy of the list of Downloads.
@return A list of Download objects.
"""
# locking by lm
return self.lm.get_downloads()
def get_download(self, infohash):
"""
Returns the Download object for this hash.
@return A Donwload Object.
"""
# locking by lm
return self.lm.get_download(infohash)
def has_download(self, infohash):
"""
Checks if the torrent download already exists.
:param infohash: The torrent infohash.
:return: True or False indicating if the torrent download already exists.
"""
return self.lm.download_exists(infohash)
def remove_download(self,
d,
removecontent=False,
removestate=True,
hidden=False):
"""
Stops the download and removes it from the session.
@param d The Download to remove
@param removecontent Whether to delete the already downloaded content
from disk.
@param removestate Whether to delete the metadata files of the downloaded
content from disk.
@param hidden Whether this torrent is added to the mypreference table and this entry should be
removed
"""
# locking by lm
return self.lm.remove(d,
removecontent=removecontent,
removestate=removestate,
hidden=hidden)
def remove_download_by_id(self,
infohash,
removecontent=False,
removestate=True):
"""
@param infohash The Download to remove
@param removecontent Whether to delete the already downloaded content
from disk.
!We can only remove content when the download object is found, otherwise only
the state is removed.
"""
downloadList = self.get_downloads()
for download in downloadList:
if download.get_def().get_infohash() == infohash:
return self.remove_download(download, removecontent,
removestate)
self.lm.remove_id(infohash)
def set_download_states_callback(self, usercallback, interval=1.0):
"""
See Download.set_state_callback. Calls usercallback with a list of
DownloadStates, one for each Download in the Session as first argument.
The usercallback must return a tuple (when,getpeerlist) that indicates
when to reinvoke the callback again (as a number of seconds from now,
or < 0.0 if not at all) and whether to also include the details of
the connected peers in the DownloadStates on that next call.
The callback will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
@param usercallback A function adhering to the above spec.
"""
self.lm.set_download_states_callback(usercallback, interval)
#
# Config parameters that only exist at runtime
#
def get_permid(self):
""" Returns the PermID of the Session, as determined by the
SessionConfig.set_permid() parameter. A PermID is a public key
@return The PermID encoded in a string in DER format. """
return str(self.keypair.pub().get_der())
def get_current_startup_config_copy(self):
""" Returns a SessionStartupConfig that is a copy of the current runtime
SessionConfig.
@return SessionStartupConfig
"""
# Called by any thread
with self.sesslock:
sessconfig = copy.copy(self.sessconfig)
sessconfig.set_callback(None)
return SessionStartupConfig(sessconfig=sessconfig)
#
# Notification of events in the Session
#
def add_observer(self,
func,
subject,
changeTypes=[NTFY_UPDATE, NTFY_INSERT, NTFY_DELETE],
objectID=None,
cache=0):
""" Add an observer function function to the Session. The observer
function will be called when one of the specified events (changeTypes)
occurs on the specified subject.
The function will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
@param func The observer function. It should accept as its first argument
the subject, as second argument the changeType, as third argument an
objectID (e.g. the primary key in the observed database) and an
optional list of arguments.
@param subject The subject to observe, one of NTFY_* subjects (see
simpledefs).
@param changeTypes The list of events to be notified of one of NTFY_*
events.
@param objectID The specific object in the subject to monitor (e.g. a
specific primary key in a database to monitor for updates.)
@param cache The time to bundle/cache events matching this function
TODO: Jelle will add per-subject/event description here ;o)
"""
# Called by any thread
self.notifier.add_observer(func,
subject,
changeTypes,
objectID,
cache=cache) # already threadsafe
def remove_observer(self, func):
""" Remove observer function. No more callbacks will be made.
@param func The observer function to remove. """
# Called by any thread
self.notifier.remove_observer(func) # already threadsafe
def open_dbhandler(self, subject):
""" Opens a connection to the specified database. Only the thread
calling this method may use this connection. The connection must be
closed with close_dbhandler() when this thread exits.
@param subject The database to open. Must be one of the subjects
specified here.
@return A reference to a DBHandler class for the specified subject or
None when the Session was not started with megacaches enabled.
<pre> NTFY_PEERS -> PeerDBHandler
NTFY_TORRENTS -> TorrentDBHandler
NTFY_MYPREFERENCES -> MyPreferenceDBHandler
NTFY_VOTECAST -> VotecastDBHandler
NTFY_CHANNELCAST -> ChannelCastDBHandler
</pre>
"""
if not self.get_megacache():
raise OperationNotEnabledByConfigurationException()
# Called by any thread
if subject == NTFY_PEERS:
return self.lm.peer_db
elif subject == NTFY_TORRENTS:
return self.lm.torrent_db
elif subject == NTFY_MYPREFERENCES:
return self.lm.mypref_db
elif subject == NTFY_VOTECAST:
return self.lm.votecast_db
elif subject == NTFY_CHANNELCAST:
return self.lm.channelcast_db
else:
raise ValueError(u"Cannot open DB subject: %s" % subject)
def close_dbhandler(self, dbhandler):
""" Closes the given database connection """
dbhandler.close()
def get_tribler_statistics(self):
"""
Return a dictionary with general Tribler statistics.
"""
return TriblerStatistics(self).get_tribler_statistics()
def get_dispersy_statistics(self):
"""
Return a dictionary with general Dispersy statistics.
"""
return TriblerStatistics(self).get_dispersy_statistics()
def get_community_statistics(self):
"""
Return a dictionary with general communities statistics.
"""
return TriblerStatistics(self).get_community_statistics()
#
# Persistence and shutdown
#
def load_checkpoint(self):
"""
Restart Downloads from a saved checkpoint, if any. Note that we fetch information from the user download
choices since it might be that a user has stopped a download. In that case, the download should not be
resumed immediately when being loaded by libtorrent.
"""
self.lm.load_checkpoint()
@blocking_call_on_reactor_thread
def start_database(self):
"""
Start the SQLite database.
"""
db_path = os.path.join(self.get_state_dir(), DB_FILE_RELATIVE_PATH)
db_script_path = os.path.join(get_lib_path(), DB_SCRIPT_NAME)
self.sqlite_db = SQLiteCacheDB(db_path, db_script_path)
self.readable_status = STATE_OPEN_DB
self.sqlite_db.initialize()
self.sqlite_db.initial_begin()
@blocking_call_on_reactor_thread
def start(self):
"""
Start a Tribler session by initializing the LaunchManyCore class, opening the database and running the upgrader.
Returns a deferred that fires when the Tribler session is ready for use.
"""
# Start the REST API before the upgrader since we want to send interesting upgrader events over the socket
if self.get_http_api_enabled():
self.lm.api_manager = RESTManager(self)
self.readable_status = STATE_START_API
self.lm.api_manager.start()
self.start_database()
# We clean the mugshot since it isn't used anymore and often contains data unsuitable for sending over the API.
self.set_mugshot(None)
if self.upgrader_enabled:
upgrader = TriblerUpgrader(self, self.sqlite_db)
self.readable_status = STATE_UPGRADING_READABLE
upgrader.run()
startup_deferred = self.lm.register(self, self.sesslock)
def load_checkpoint(_):
if self.get_libtorrent():
self.readable_status = STATE_LOAD_CHECKPOINTS
self.load_checkpoint()
self.readable_status = STATE_READABLE_STARTED
self.sessconfig.set_callback(self.lm.sessconfig_changed_callback)
return startup_deferred.addCallback(load_checkpoint)
@blocking_call_on_reactor_thread
def shutdown(self):
"""
Checkpoints the session and closes it, stopping the download engine.
This method has to be called from the reactor thread.
"""
assert isInIOThread()
@inlineCallbacks
def on_early_shutdown_complete(_):
"""
Callback that gets called when the early shutdown has been completed.
Continues the shutdown procedure that is dependant on the early shutdown.
:param _: ignored parameter of the Deferred
"""
self.save_session_config()
yield self.checkpoint_downloads()
self.lm.shutdown_downloads()
self.lm.network_shutdown()
if self.sqlite_db:
self.sqlite_db.close()
self.sqlite_db = None
return self.lm.early_shutdown().addCallback(on_early_shutdown_complete)
def has_shutdown(self):
""" Whether the Session has completely shutdown, i.e., its internal
threads are finished and it is safe to quit the process the Session
is running in.
@return A Boolean.
"""
return self.lm.sessdoneflag.isSet()
def get_downloads_pstate_dir(self):
""" Returns the directory in which to checkpoint the Downloads in this
Session. """
# Called by network thread
return os.path.join(self.get_state_dir(), STATEDIR_DLPSTATE_DIR)
def download_torrentfile(self, infohash=None, usercallback=None, prio=0):
""" Try to download the torrentfile without a known source.
A possible source could be the DHT.
If the torrent is succesfully
received, the usercallback method is called with the infohash as first
and the contents of the torrentfile (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
@param infohash The infohash of the torrent.
@param usercallback A function adhering to the above spec.
"""
if not self.lm.rtorrent_handler:
raise OperationNotEnabledByConfigurationException()
self.lm.rtorrent_handler.download_torrent(None,
infohash,
user_callback=usercallback,
priority=prio)
def download_torrentfile_from_peer(self,
candidate,
infohash=None,
usercallback=None,
prio=0):
""" Ask the designated peer to send us the torrentfile for the torrent
identified by the passed infohash. If the torrent is succesfully
received, the usercallback method is called with the infohash as first
and the contents of the torrentfile (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
@param permid The PermID of the peer to query.
@param infohash The infohash of the torrent.
@param usercallback A function adhering to the above spec.
"""
if not self.lm.rtorrent_handler:
raise OperationNotEnabledByConfigurationException()
self.lm.rtorrent_handler.download_torrent(candidate,
infohash,
user_callback=usercallback,
priority=prio)
def download_torrentmessage_from_peer(self,
candidate,
infohash,
usercallback,
prio=0):
""" Ask the designated peer to send us the torrentmessage for the torrent
identified by the passed infohash. If the torrentmessage is succesfully
received, the usercallback method is called with the infohash as first
and the contents of the torrentfile (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
@param permid The PermID of the peer to query.
@param infohash The infohash of the torrent.
@param usercallback A function adhering to the above spec.
"""
if not self.lm.rtorrent_handler:
raise OperationNotEnabledByConfigurationException()
self.lm.rtorrent_handler.download_torrentmessage(
candidate, infohash, usercallback, prio)
def get_dispersy_instance(self):
if not self.get_dispersy():
raise OperationNotEnabledByConfigurationException()
return self.lm.dispersy
def get_libtorrent_process(self):
if not self.get_libtorrent():
raise OperationNotEnabledByConfigurationException()
return self.lm.ltmgr
#
# Internal persistence methods
#
def checkpoint_downloads(self):
"""
Checkpoints the downloads in Tribler.
"""
return self.lm.checkpoint_downloads()
def save_session_config(self):
""" Save the runtime SessionConfig to disk """
# Called by any thread
sscfg = self.get_current_startup_config_copy()
cfgfilename = Session.get_default_config_filename(
sscfg.get_state_dir())
sscfg.save(cfgfilename)
def update_trackers(self, infohash, trackers):
""" Updates the trackers of a torrent.
:param infohash: infohash of the torrent that needs to be updated
:param trackers: A list of tracker urls.
"""
return self.lm.update_trackers(infohash, trackers)
# New APIs
def has_collected_torrent(self, infohash):
"""
Checks if the given torrent infohash exists in the torrent_store database.
:param infohash: The given infohash binary.
:return: True or False indicating if we have the torrent.
"""
if not self.get_torrent_store():
raise OperationNotEnabledByConfigurationException(
"torrent_store is not enabled")
return hexlify(infohash) in self.lm.torrent_store
def get_collected_torrent(self, infohash):
"""
Gets the given torrent from the torrent_store database.
:param infohash: The given infohash binary.
:return: The torrent data if exists, None otherwise.
"""
if not self.get_torrent_store():
raise OperationNotEnabledByConfigurationException(
"torrent_store is not enabled")
return self.lm.torrent_store.get(hexlify(infohash))
def save_collected_torrent(self, infohash, data):
"""
Saves the given torrent into the torrent_store database.
:param infohash: The given infohash binary.
:param data: The torrent file data.
"""
if not self.get_torrent_store():
raise OperationNotEnabledByConfigurationException(
"torrent_store is not enabled")
self.lm.torrent_store.put(hexlify(infohash), data)
def delete_collected_torrent(self, infohash):
"""
Deletes the given torrent from the torrent_store database.
:param infohash: The given infohash binary.
"""
if not self.get_torrent_store():
raise OperationNotEnabledByConfigurationException(
"torrent_store is not enabled")
del self.lm.torrent_store[hexlify(infohash)]
def search_remote_torrents(self, keywords):
"""
Searches for remote torrents through SearchCommunity with the given keywords.
:param keywords: The given keywords.
:return: The number of requests made.
"""
if not self.get_enable_torrent_search():
raise OperationNotEnabledByConfigurationException(
"torrent_search is not enabled")
return self.lm.search_manager.search_for_torrents(keywords)
def search_remote_channels(self, keywords):
"""
Searches for remote channels through AllChannelCommunity with the given keywords.
:param keywords: The given keywords.
"""
if not self.get_enable_channel_search():
raise OperationNotEnabledByConfigurationException(
"channel_search is not enabled")
self.lm.search_manager.search_for_channels(keywords)
def create_torrent_file(self, file_path_list, params={}):
"""
:param file_path_list: files to add in torrent file
:param params: optional parameters for torrent file
:return: Deferred
"""
return threads.deferToThread(torrent_utils.create_torrent_file,
file_path_list, params)
def create_channel(self, name, description, mode=u'closed'):
"""
Creates a new Channel.
:param name: Name of the Channel.
:param description: Description of the Channel.
:param mode: Mode of the Channel ('open', 'semi-open', or 'closed').
:return: Channel ID
:raises DuplicateChannelNameError if name already exists
"""
return self.lm.channel_manager.create_channel(name, description, mode)
def add_torrent_def_to_channel(self,
channel_id,
torrent_def,
extra_info={},
forward=True):
"""
Adds a TorrentDef to a Channel.
:param channel_id: Id of the Channel to add the Torrent to.
:param torrent_def: Definition of the Torrent to add.
:param extra_info: Description of the Torrent to add.
:param forward: When True the messages are forwarded (as defined by their message
destination policy) to other nodes in the community. This parameter should (almost always)
be True, its inclusion is mostly to allow certain debugging scenarios.
"""
# Make sure that this new torrent_def is also in collected torrents
self.lm.rtorrent_handler.save_torrent(torrent_def)
channelcast_db = self.open_dbhandler(NTFY_CHANNELCAST)
if channelcast_db.hasTorrent(channel_id, torrent_def.infohash):
raise DuplicateTorrentFileError(
"This torrent file already exists in your channel.")
dispersy_cid = str(
channelcast_db.getDispersyCIDFromChannelId(channel_id))
community = self.get_dispersy_instance().get_community(dispersy_cid)
community._disp_create_torrent(
torrent_def.infohash,
long(time.time()),
torrent_def.get_name_as_unicode(),
tuple(torrent_def.get_files_with_length()),
torrent_def.get_trackers_as_single_tuple(),
forward=forward)
if 'description' in extra_info:
desc = extra_info['description'].strip()
if desc != '':
data = channelcast_db.getTorrentFromChannelId(
channel_id, torrent_def.infohash, ['ChannelTorrents.id'])
community.modifyTorrent(data, {'description': desc},
forward=forward)
def check_torrent_health(self, infohash, timeout=20, scrape_now=False):
"""
Checks the given torrent's health on its trackers.
:param infohash: The given torrent infohash.
"""
if self.lm.torrent_checker:
return self.lm.torrent_checker.add_gui_request(
infohash, timeout=timeout, scrape_now=scrape_now)
return fail(Failure(RuntimeError("Torrent checker not available")))
def set_max_upload_speed(self, rate):
"""
Sets the maximum upload rate (kB/s).
:param rate: The upload rate (kB/s).
"""
if not self.get_libtorrent():
raise OperationNotEnabledByConfigurationException(
"libtorrent is not enabled")
self.lm.ltmgr.set_upload_rate_limit(rate)
def set_max_download_speed(self, rate):
"""
Sets the maximum download rate (kB/s).
:param rate: The download rate (kB/s).
"""
if not self.lm.ltmgr:
raise OperationNotEnabledByConfigurationException(
"libtorrent is not enabled")
self.lm.ltmgr.set_download_rate_limit(rate)
def get_thumbnail_data(self, thumb_hash):
"""
Gets the thumbnail data.
:param thumb_hash: The thumbnail SHA1 hash.
:return: The thumbnail data.
"""
if not self.lm.metadata_store:
raise OperationNotEnabledByConfigurationException(
"libtorrent is not enabled")
return self.lm.rtorrent_handler.get_metadata(thumb_hash)
class Session(SessionConfigInterface):
"""
A Session is a running instance of the Tribler Core and the Core's central
class. It implements the SessionConfigInterface which can be used to change
session parameters at runtime (for selected parameters).
cf. libtorrent session
"""
__single = None
def __init__(self, scfg=None, ignore_singleton=False, autoload_discovery=True):
"""
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._logger = logging.getLogger(self.__class__.__name__)
self.ignore_singleton = ignore_singleton
self.sesslock = NoDispersyRLock()
# Determine startup config to use
if scfg is None: # If no override
scfg = SessionStartupConfig.load()
else: # overrides any saved config
# Work from copy
scfg = SessionStartupConfig(copy.copy(scfg.sessconfig))
def create_dir(fullpath):
if not os.path.isdir(fullpath):
os.makedirs(fullpath)
def set_and_create_dir(dirname, setter, default_dir):
if dirname is None:
setter(default_dir)
create_dir(dirname or default_dir)
state_dir = scfg.get_state_dir()
set_and_create_dir(state_dir, scfg.set_state_dir, state_dir)
set_and_create_dir(scfg.get_torrent_store_dir(),
scfg.set_torrent_store_dir,
os.path.join(scfg.get_state_dir(), STATEDIR_TORRENT_STORE_DIR))
# metadata store
set_and_create_dir(scfg.get_metadata_store_dir(),
scfg.set_metadata_store_dir,
os.path.join(scfg.get_state_dir(), STATEDIR_METADATA_STORE_DIR))
set_and_create_dir(scfg.get_peer_icon_path(), scfg.set_peer_icon_path,
os.path.join(scfg.get_state_dir(), STATEDIR_PEERICON_DIR))
create_dir(os.path.join(scfg.get_state_dir(), u"sqlite"))
create_dir(os.path.join(scfg.get_state_dir(), STATEDIR_DLPSTATE_DIR))
# Reset the nickname to something not related to the host name, it was
# really silly to have this default on the first place.
# TODO: Maybe move this to the upgrader?
if socket.gethostname() in scfg.get_nickname():
scfg.set_nickname("Tribler user")
if GOTM2CRYPTO:
permidmod.init()
# Set params that depend on state_dir
#
# 1. keypair
#
pairfilename = scfg.get_permid_keypair_filename()
if os.access(pairfilename, os.F_OK):
# May throw exceptions
self.keypair = permidmod.read_keypair(pairfilename)
else:
self.keypair = permidmod.generate_keypair()
# Save keypair
pubfilename = os.path.join(scfg.get_state_dir(), 'ecpub.pem')
permidmod.save_keypair(self.keypair, pairfilename)
permidmod.save_pub_key(self.keypair, pubfilename)
if not scfg.get_megacache():
scfg.set_torrent_checking(0)
self.sessconfig = scfg.sessconfig
self.sessconfig.lock = self.sesslock
self.selected_ports = scfg.selected_ports
# Claim all random ports
self.get_listen_port()
self.get_dispersy_port()
self.get_mainline_dht_listen_port()
self.get_videoplayer_port()
self.get_anon_listen_port()
self.get_tunnel_community_socks5_listen_ports()
# Create handler for calling back the user via separate threads
self.lm = TriblerLaunchMany()
self.notifier = Notifier(use_pool=True)
# Checkpoint startup config
self.save_pstate_sessconfig()
self.sqlite_db = None
self.autoload_discovery = autoload_discovery
def prestart(self):
"""
Pre-starts the session. We check the current version and upgrade if needed
- before we start everything else.
"""
self.sqlite_db = SQLiteCacheDB(self)
self.sqlite_db.initialize()
self.sqlite_db.initial_begin()
self.upgrader = TriblerUpgrader(self, self.sqlite_db)
self.upgrader.run()
return self.upgrader
#
# Class methods
#
@staticmethod
def get_instance(*args, **kw):
""" Returns the Session singleton if it exists or otherwise
creates it first, in which case you need to pass the constructor
params.
@return Session."""
if Session.__single is None:
Session(*args, **kw)
return Session.__single
@staticmethod
def has_instance():
return Session.__single is not None
@staticmethod
def del_instance():
Session.__single = None
#
# Public methods
#
def start_download(self, tdef, dcfg=None, initialdlstatus=None, hidden=False):
"""
Creates a Download object and adds it to the session. The passed
ContentDef and DownloadStartupConfig are copied into the new Download
object. The Download is then started and checkpointed.
If a checkpointed version of the Download is found, that is restarted
overriding the saved DownloadStartupConfig if "dcfg" is not None.
@param tdef A finalized TorrentDef
@param dcfg DownloadStartupConfig or None, in which case
a new DownloadStartupConfig() is created with its default settings
and the result becomes the runtime config of this Download.
@param initialdlstatus The initial download status of this Download
or None. This enables the caller to create a Download in e.g.
DLSTATUS_STOPPED state instead.
@param hidden Whether this torrent should be added to the mypreference table
@return Download
"""
# locking by lm
if self.get_libtorrent():
return self.lm.add(tdef, dcfg, initialdlstatus=initialdlstatus, hidden=hidden)
raise OperationNotEnabledByConfigurationException()
def resume_download_from_file(self, filename):
"""
Recreates Download from resume file
@return a Download object.
Note: this cannot be made into a method of Download, as the Download
needs to be bound to a session, it cannot exist independently.
"""
raise NotYetImplementedException()
def get_downloads(self):
"""
Returns a copy of the list of Downloads.
@return A list of Download objects.
"""
# locking by lm
return self.lm.get_downloads()
def get_download(self, infohash):
"""
Returns the Download object for this hash.
@return A Donwload Object.
"""
# locking by lm
return self.lm.get_download(infohash)
def has_download(self, infohash):
"""
Checks if the torrent download already exists.
:param infohash: The torrent infohash.
:return: True or False indicating if the torrent download already exists.
"""
return self.lm.download_exists(infohash)
def remove_download(self, d, removecontent=False, removestate=True, hidden=False):
"""
Stops the download and removes it from the session.
@param d The Download to remove
@param removecontent Whether to delete the already downloaded content
from disk.
@param removestate Whether to delete the metadata files of the downloaded
content from disk.
@param hidden Whether this torrent is added to the mypreference table and this entry should be
removed
"""
# locking by lm
self.lm.remove(d, removecontent=removecontent, removestate=removestate, hidden=hidden)
def remove_download_by_id(self, infohash, removecontent=False, removestate=True):
"""
@param infohash The Download to remove
@param removecontent Whether to delete the already downloaded content
from disk.
!We can only remove content when the download object is found, otherwise only
the state is removed.
"""
downloadList = self.get_downloads()
for download in downloadList:
if download.get_def().get_infohash() == infohash:
self.remove_download(download, removecontent, removestate)
return
self.lm.remove_id(infohash)
def set_download_states_callback(self, usercallback, getpeerlist=None):
"""
See Download.set_state_callback. Calls usercallback with a list of
DownloadStates, one for each Download in the Session as first argument.
The usercallback must return a tuple (when,getpeerlist) that indicates
when to reinvoke the callback again (as a number of seconds from now,
or < 0.0 if not at all) and whether to also include the details of
the connected peers in the DownloadStates on that next call.
The callback will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
@param usercallback A function adhering to the above spec.
"""
self.lm.set_download_states_callback(usercallback, getpeerlist or [])
#
# Config parameters that only exist at runtime
#
def get_permid(self):
""" Returns the PermID of the Session, as determined by the
SessionConfig.set_permid() parameter. A PermID is a public key
@return The PermID encoded in a string in DER format. """
return str(self.keypair.pub().get_der())
def get_current_startup_config_copy(self):
""" Returns a SessionStartupConfig that is a copy of the current runtime
SessionConfig.
@return SessionStartupConfig
"""
# Called by any thread
with self.sesslock:
sessconfig = copy.copy(self.sessconfig)
sessconfig.set_callback(None)
return SessionStartupConfig(sessconfig=sessconfig)
#
# Notification of events in the Session
#
def add_observer(self, func, subject, changeTypes=[NTFY_UPDATE, NTFY_INSERT, NTFY_DELETE], objectID=None, cache=0):
""" Add an observer function function to the Session. The observer
function will be called when one of the specified events (changeTypes)
occurs on the specified subject.
The function will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
@param func The observer function. It should accept as its first argument
the subject, as second argument the changeType, as third argument an
objectID (e.g. the primary key in the observed database) and an
optional list of arguments.
@param subject The subject to observe, one of NTFY_* subjects (see
simpledefs).
@param changeTypes The list of events to be notified of one of NTFY_*
events.
@param objectID The specific object in the subject to monitor (e.g. a
specific primary key in a database to monitor for updates.)
@param cache The time to bundle/cache events matching this function
TODO: Jelle will add per-subject/event description here ;o)
"""
# Called by any thread
self.notifier.add_observer(func, subject, changeTypes, objectID, cache=cache) # already threadsafe
def remove_observer(self, func):
""" Remove observer function. No more callbacks will be made.
@param func The observer function to remove. """
# Called by any thread
self.notifier.remove_observer(func) # already threadsafe
def open_dbhandler(self, subject):
""" Opens a connection to the specified database. Only the thread
calling this method may use this connection. The connection must be
closed with close_dbhandler() when this thread exits.
@param subject The database to open. Must be one of the subjects
specified here.
@return A reference to a DBHandler class for the specified subject or
None when the Session was not started with megacaches enabled.
<pre> NTFY_PEERS -> PeerDBHandler
NTFY_TORRENTS -> TorrentDBHandler
NTFY_MYPREFERENCES -> MyPreferenceDBHandler
NTFY_VOTECAST -> VotecastDBHandler
NTFY_CHANNELCAST -> ChannelCastDBHandler
</pre>
"""
if not self.get_megacache():
raise OperationNotEnabledByConfigurationException()
# Called by any thread
if subject == NTFY_METADATA:
return self.lm.metadata_db
elif subject == NTFY_PEERS:
return self.lm.peer_db
elif subject == NTFY_TORRENTS:
return self.lm.torrent_db
elif subject == NTFY_MYPREFERENCES:
return self.lm.mypref_db
elif subject == NTFY_VOTECAST:
return self.lm.votecast_db
elif subject == NTFY_CHANNELCAST:
return self.lm.channelcast_db
else:
raise ValueError(u"Cannot open DB subject: %s" % subject)
def close_dbhandler(self, dbhandler):
""" Closes the given database connection """
dbhandler.close()
def get_statistics(self):
from Tribler.Core.statistics import TriblerStatistics
return TriblerStatistics(self).dump_statistics()
#
# Persistence and shutdown
#
def load_checkpoint(self, initialdlstatus=None, initialdlstatus_dict={}):
""" Restart Downloads from checkpoint, if any.
This method allows the API user to manage restoring downloads.
E.g. a video player that wants to start the torrent the user clicked
on first, and only then restart any sleeping torrents (e.g. seeding).
The optional initialdlstatus parameter can be set to DLSTATUS_STOPPED
to restore all the Downloads in DLSTATUS_STOPPED state.
The options initialdlstatus_dict parameter can be used to specify a
state overriding the initaldlstatus parameter per download id.
"""
self.lm.load_checkpoint(initialdlstatus, initialdlstatus_dict)
def checkpoint(self):
""" Saves the internal session state to the Session's state dir. """
# Called by any thread
self.checkpoint_shutdown(stop=False, checkpoint=True, gracetime=None, hacksessconfcheckpoint=False)
def start(self):
""" Create the LaunchManyCore instance and start it"""
# Create engine with network thread
self.lm.register(self, self.sesslock, autoload_discovery=self.autoload_discovery)
self.sessconfig.set_callback(self.lm.sessconfig_changed_callback)
def shutdown(self, checkpoint=True, gracetime=2.0, hacksessconfcheckpoint=True):
""" Checkpoints the session and closes it, stopping the download engine.
@param checkpoint Whether to checkpoint the Session state on shutdown.
@param gracetime Time to allow for graceful shutdown + signoff (seconds).
"""
# Called by any thread
self.lm.early_shutdown()
self.checkpoint_shutdown(stop=True, checkpoint=checkpoint,
gracetime=gracetime, hacksessconfcheckpoint=hacksessconfcheckpoint)
self.sqlite_db.close()
self.sqlite_db = None
def has_shutdown(self):
""" Whether the Session has completely shutdown, i.e., its internal
threads are finished and it is safe to quit the process the Session
is running in.
@return A Boolean.
"""
return self.lm.sessdoneflag.isSet()
def get_downloads_pstate_dir(self):
""" Returns the directory in which to checkpoint the Downloads in this
Session. """
# Called by network thread
return os.path.join(self.get_state_dir(), STATEDIR_DLPSTATE_DIR)
def download_torrentfile(self, infohash=None, usercallback=None, prio=0):
""" Try to download the torrentfile without a known source.
A possible source could be the DHT.
If the torrent is succesfully
received, the usercallback method is called with the infohash as first
and the contents of the torrentfile (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
@param infohash The infohash of the torrent.
@param usercallback A function adhering to the above spec.
"""
if not self.lm.rtorrent_handler:
raise OperationNotEnabledByConfigurationException()
self.lm.rtorrent_handler.download_torrent(None, infohash, user_callback=usercallback, priority=prio)
def download_torrentfile_from_peer(self, candidate, infohash=None, usercallback=None, prio=0):
""" Ask the designated peer to send us the torrentfile for the torrent
identified by the passed infohash. If the torrent is succesfully
received, the usercallback method is called with the infohash as first
and the contents of the torrentfile (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
@param permid The PermID of the peer to query.
@param infohash The infohash of the torrent.
@param usercallback A function adhering to the above spec.
"""
if not self.lm.rtorrent_handler:
raise OperationNotEnabledByConfigurationException()
self.lm.rtorrent_handler.download_torrent(candidate, infohash, user_callback=usercallback, priority=prio)
def download_torrentmessage_from_peer(self, candidate, infohash, usercallback, prio=0):
""" Ask the designated peer to send us the torrentmessage for the torrent
identified by the passed infohash. If the torrentmessage is succesfully
received, the usercallback method is called with the infohash as first
and the contents of the torrentfile (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
@param permid The PermID of the peer to query.
@param infohash The infohash of the torrent.
@param usercallback A function adhering to the above spec.
"""
if not self.lm.rtorrent_handler:
raise OperationNotEnabledByConfigurationException()
self.lm.rtorrent_handler.download_torrentmessage(candidate, infohash, usercallback, prio)
def get_dispersy_instance(self):
if not self.get_dispersy():
raise OperationNotEnabledByConfigurationException()
return self.lm.dispersy
def get_libtorrent_process(self):
if not self.get_libtorrent():
raise OperationNotEnabledByConfigurationException()
return self.lm.ltmgr
#
# Internal persistence methods
#
def checkpoint_shutdown(self, stop, checkpoint, gracetime, hacksessconfcheckpoint):
""" Checkpoints the Session and optionally shuts down the Session.
@param stop Whether to shutdown the Session as well.
@param checkpoint Whether to checkpoint at all, or just to stop.
@param gracetime Time to allow for graceful shutdown + signoff (seconds).
"""
# Called by any thread
with self.sesslock:
# Arno: Make checkpoint optional on shutdown. At the moment setting
# the config at runtime is not possible (see SessionRuntimeConfig)
# so this has little use, and interferes with our way of
# changing the startup config, which is to write a new
# config to disk that will be read at start up.
if hacksessconfcheckpoint:
try:
self.save_pstate_sessconfig()
except Exception as e:
self._logger.error("save_pstate_sessconfig() failed with error: %s", e)
# Checkpoint all Downloads and stop NetworkThread
if stop:
self._logger.debug("Session: checkpoint_shutdown")
self.lm.checkpoint(stop=stop, checkpoint=checkpoint, gracetime=gracetime)
def save_pstate_sessconfig(self):
""" Save the runtime SessionConfig to disk """
# Called by any thread
sscfg = self.get_current_startup_config_copy()
cfgfilename = Session.get_default_config_filename(sscfg.get_state_dir())
sscfg.save(cfgfilename)
def update_trackers(self, infohash, trackers):
""" Updates the trackers of a torrent.
:param infohash: infohash of the torrent that needs to be updated
:param trackers: A list of tracker urls.
"""
return self.lm.update_trackers(infohash, trackers)
# New APIs
def has_collected_torrent(self, infohash):
"""
Checks if the given torrent infohash exists in the torrent_store database.
:param infohash: The given infohash binary.
:return: True or False indicating if we have the torrent.
"""
if not self.get_torrent_store():
raise OperationNotEnabledByConfigurationException("torrent_store is not enabled")
return hexlify(infohash) in self.lm.torrent_store
def get_collected_torrent(self, infohash):
"""
Gets the given torrent from the torrent_store database.
:param infohash: The given infohash binary.
:return: The torrent data if exists, None otherwise.
"""
if not self.get_torrent_store():
raise OperationNotEnabledByConfigurationException("torrent_store is not enabled")
return self.lm.torrent_store.get(hexlify(infohash))
def save_collected_torrent(self, infohash, data):
"""
Saves the given torrent into the torrent_store database.
:param infohash: The given infohash binary.
:param data: The torrent file data.
"""
if not self.get_torrent_store():
raise OperationNotEnabledByConfigurationException("torrent_store is not enabled")
self.lm.torrent_store.put(hexlify(infohash), data)
def search_remote_torrents(self, keywords):
"""
Searches for remote torrents through SearchCommunity with the given keywords.
:param keywords: The given keywords.
:return: The number of requests made.
"""
if not self.get_enable_torrent_search():
raise OperationNotEnabledByConfigurationException("torrent_search is not enabled")
return self.lm.search_manager.search_for_torrents(keywords)
def search_remote_channels(self, keywords):
"""
Searches for remote channels through AllChannelCommunity with the given keywords.
:param keywords: The given keywords.
"""
if not self.get_enable_channel_search():
raise OperationNotEnabledByConfigurationException("channel_search is not enabled")
self.lm.search_manager.search_for_channels(keywords)
def create_channel(self, name, description, mode=u'open'):
"""
Creates a new Channel.
:param name: Name of the Channel.
:param description: Description of the Channel.
:param mode: Mode of the Channel ('open', 'semi-open', or 'closed').
"""
if not self.get_enable_channel_search():
raise OperationNotEnabledByConfigurationException("channel_search is not enabled")
self.lm.channel_manager.create_channel(name, description, mode)
def check_torrent_health(self, infohash):
"""
Checks the given torrent's health on its trackers.
:param infohash: The given torrent infohash.
"""
self.lm.torrent_checker.add_gui_request(infohash)
def set_max_upload_speed(self, rate):
"""
Sets the maximum upload rate (kB/s).
:param rate: The upload rate (kB/s).
"""
if not self.get_libtorrent():
raise OperationNotEnabledByConfigurationException("libtorrent is not enabled")
self.lm.ltmgr.set_upload_rate_limit(rate)
def set_max_download_speed(self, rate):
"""
Sets the maximum download rate (kB/s).
:param rate: The download rate (kB/s).
"""
if not self.lm.ltmgr:
raise OperationNotEnabledByConfigurationException("libtorrent is not enabled")
self.lm.ltmgr.set_download_rate_limit(rate)
class TestLaunchManyCore(TriblerCoreTest):
"""
This class contains various small unit tests for the LaunchManyCore class.
"""
DATA_DIR = os.path.join(os.path.abspath(os.path.dirname(os.path.realpath(__file__))), 'data')
def setUp(self, annotate=True):
TriblerCoreTest.setUp(self, annotate=annotate)
self.lm = TriblerLaunchMany()
self.lm.sesslock = NoDispersyRLock()
self.lm.session = MockObject()
# Ignore notifications
mock_notifier = MockObject()
mock_notifier.notify = lambda *_: None
self.lm.session.notifier = mock_notifier
@raises(ValueError)
def test_add_tdef_not_finalized(self):
"""
Testing whether a ValueError is raised when a non-finalized tdef is added as download.
"""
self.lm.add(TorrentDef(), None)
@raises(DuplicateDownloadException)
def test_add_duplicate_download(self):
"""
Testing whether a DuplicateDownloadException is raised when a download is added twice
"""
self.lm.downloads = {"abcd": None}
tdef = TorrentDef()
tdef.metainfo_valid = True
tdef.infohash = "abcd"
self.lm.add(tdef, DefaultDownloadStartupConfig.getInstance())
def test_load_download_pstate(self):
"""
Testing whether a pstate is successfully loaded
"""
config_file_path = os.path.abspath(os.path.join(self.DATA_DIR, u"config_files", u"config1.conf"))
config = self.lm.load_download_pstate(config_file_path)
self.assertIsInstance(config, CallbackConfigParser)
self.assertEqual(config.get('general', 'version'), 11)
def test_sessconfig_changed_cb(self):
"""
Testing whether the callback works correctly when changing session config parameters
"""
self.assertFalse(self.lm.sessconfig_changed_callback('blabla', 'fancyname', '3', '4'))
self.lm.ltmgr = MockObject()
def mocked_set_utp(val):
self.assertEqual(val, '42')
mocked_set_utp.called = True
self.lm.ltmgr.set_utp = mocked_set_utp
mocked_set_utp.called = False
self.assertTrue(self.lm.sessconfig_changed_callback('libtorrent', 'utp', '42', '3'))
self.assertTrue(mocked_set_utp.called)
self.assertTrue(self.lm.sessconfig_changed_callback('libtorrent', 'anon_listen_port', '42', '43'))
@deferred(timeout=10)
def test_dlstates_cb_error(self):
"""
Testing whether a download is stopped on error in the download states callback in LaunchManyCore
"""
error_stop_deferred = Deferred()
def mocked_stop():
error_stop_deferred.callback(None)
error_tdef = TorrentDef()
error_tdef.get_infohash = lambda: 'aaaa'
fake_error_download = MockObject()
fake_error_download.get_def = lambda: error_tdef
fake_error_download.get_def().get_name_as_unicode = lambda: "test.iso"
fake_error_download.stop = mocked_stop
fake_error_state = MockObject()
fake_error_state.get_infohash = lambda: 'aaaa'
fake_error_state.get_error = lambda: "test error"
fake_error_state.get_status = lambda: DLSTATUS_STOPPED_ON_ERROR
fake_error_state.get_download = lambda: fake_error_download
self.lm.downloads = {'aaaa': fake_error_download}
self.lm.sesscb_states_callback([fake_error_state])
return error_stop_deferred
@deferred(timeout=10)
def test_dlstates_cb_seeding(self):
"""
Testing whether a download is readded when safe seeding in the download states callback in LaunchManyCore
"""
readd_deferred = Deferred()
def mocked_start_download(tdef, dscfg):
self.assertEqual(tdef, seed_tdef)
self.assertEqual(dscfg, seed_download)
readd_deferred.callback(None)
def mocked_remove_download(download):
self.assertEqual(download, seed_download)
self.lm.session.start_download_from_tdef = mocked_start_download
self.lm.session.remove_download = mocked_remove_download
seed_tdef = TorrentDef()
seed_tdef.get_infohash = lambda: 'aaaa'
seed_download = MockObject()
seed_download.get_def = lambda: seed_tdef
seed_download.get_def().get_name_as_unicode = lambda: "test.iso"
seed_download.get_hops = lambda: 0
seed_download.get_safe_seeding = lambda: True
seed_download.copy = lambda: seed_download
seed_download.set_hops = lambda _: None
fake_seed_download_state = MockObject()
fake_seed_download_state.get_infohash = lambda: 'aaaa'
fake_seed_download_state.get_status = lambda: DLSTATUS_SEEDING
fake_seed_download_state.get_download = lambda: seed_download
self.lm.sesscb_states_callback([fake_seed_download_state])
return readd_deferred
def test_load_checkpoint(self):
"""
Test whether we are resuming downloads after loading checkpoint
"""
def mocked_resume_download(filename, setupDelay=3):
self.assertTrue(filename.endswith('abcd.state'))
self.assertEqual(setupDelay, 0)
mocked_resume_download.called = True
mocked_resume_download.called = False
self.lm.session.get_downloads_pstate_dir = lambda: self.session_base_dir
with open(os.path.join(self.lm.session.get_downloads_pstate_dir(), 'abcd.state'), 'wb') as state_file:
state_file.write("hi")
self.lm.initComplete = True
self.lm.resume_download = mocked_resume_download
self.lm.load_checkpoint()
self.assertTrue(mocked_resume_download.called)
def test_resume_download(self):
with open(os.path.join(TESTS_DATA_DIR, "bak_single.torrent"), mode='rb') as torrent_file:
torrent_data = torrent_file.read()
def mocked_load_download_pstate(_):
raise ValueError()
def mocked_add(tdef, dscfg, pstate, **_):
self.assertTrue(tdef)
self.assertTrue(dscfg)
self.assertIsNone(pstate)
mocked_add.called = True
mocked_add.called = False
self.lm.load_download_pstate = mocked_load_download_pstate
self.lm.torrent_store = MockObject()
self.lm.torrent_store.get = lambda _: torrent_data
self.lm.add = mocked_add
self.lm.mypref_db = MockObject()
self.lm.mypref_db.getMyPrefStatsInfohash = lambda _: TESTS_DATA_DIR
self.lm.resume_download('%s.state' % ('a' * 20))
self.assertTrue(mocked_add.called)
class Session(SessionRuntimeConfig):
"""
A Session is a running instance of the Tribler Core and the Core's central
class. It implements the SessionConfigInterface which can be used to change
session parameters at runtime (for selected parameters).
cf. libtorrent session
"""
__single = None
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
Tribler.Core.Overlay.permid.init()
#print 'Session: __init__ config is', self.sessconfig
#
# 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 = Tribler.Core.Overlay.permid.read_keypair(self.sessconfig['eckeypairfilename'])
else:
self.keypair = Tribler.Core.Overlay.permid.generate_keypair()
# Save keypair
pubfilename = os.path.join(self.sessconfig['state_dir'],'ecpub.pem')
Tribler.Core.Overlay.permid.save_keypair(self.keypair,pairfilename)
Tribler.Core.Overlay.permid.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
if self.sessconfig['superpeer_file'] is None:
self.sessconfig['superpeer_file'] = os.path.join(self.sessconfig['install_dir'],'Tribler','Core','superpeer.txt')
# 5. download_help_dir
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. NAT type detection
if not 'nat_detect' in self.sessconfig:
# Poor man's versioning, really should update PERSISTENTSTATE_CURRENTVERSION
self.sessconfig['nat_detect'] = sessdefaults['nat_detect']
self.sessconfig['puncturing_private_port'] = sessdefaults['puncturing_private_port']
self.sessconfig['stun_servers'] = sessdefaults['stun_servers']
self.sessconfig['puncturing_coordinators'] = sessdefaults['puncturing_coordinators']
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']
# 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,self.sesslock)
self.lm.start()
#
# Class methods
#
def get_instance(*args, **kw):
""" Returns the Session singleton if it exists or otherwise
creates it first, in which case you need to pass the constructor
params.
@return Session."""
if Session.__single is None:
Session(*args, **kw)
return Session.__single
get_instance = staticmethod(get_instance)
def get_default_state_dir(homedirpostfix='.Tribler'):
""" Returns the factory default directory for storing session state
on the current platform (Win32,Mac,Unix).
@return An absolute path name. """
homedir = None
if sys.platform == 'win32':
homedirvar = '${APPDATA}'
else:
if sys.platform == 'darwin':
homedirvar = '${HOME}'
# JD wants $HOME/Libray/Preferences/something TODO
#homedirpostfix = os.path.join('Library)
else:
homedirvar = '${HOME}'
# Allow override
overridevar = '${APPDATA}'
homedir = os.path.expandvars(overridevar)
if homedir == overridevar:
# expansion failed
homedir = None
if homedir is None:
homedir = os.path.expandvars(homedirvar)
triblerdir = os.path.join(homedir,homedirpostfix)
return triblerdir
get_default_state_dir = staticmethod(get_default_state_dir)
#
# Public methods
#
def start_download(self,tdef,dcfg=None):
"""
Creates a Download object and adds it to the session. The passed
TorrentDef and DownloadStartupConfig are copied into the new Download
object. The Download is then started and checkpointed.
If a checkpointed version of the Download is found, that is restarted
overriding the saved DownloadStartupConfig is "dcfg" is not None.
@param tdef A finalized TorrentDef
@param dcfg DownloadStartupConfig or None, in which case
a new DownloadStartupConfig() is created with its default settings
and the result becomes the runtime config of this Download.
@return Download
"""
# locking by lm
return self.lm.add(tdef,dcfg)
def resume_download_from_file(self,filename):
"""
Recreates Download from resume file
@return a Download object.
Note: this cannot be made into a method of Download, as the Download
needs to be bound to a session, it cannot exist independently.
"""
raise NotYetImplementedException()
def get_downloads(self):
"""
Returns a copy of the list of Downloads.
@return A list of Download objects.
"""
# locking by lm
return self.lm.get_downloads()
def remove_download(self,d,removecontent=False):
"""
Stops the download and removes it from the session.
@param d The Download to remove
@param removecontent Whether to delete the already downloaded content
from disk.
"""
# locking by lm
self.lm.remove(d,removecontent=removecontent)
def set_download_states_callback(self,usercallback,getpeerlist=False):
"""
See Download.set_state_callback. Calls usercallback with a list of
DownloadStates, one for each Download in the Session as first argument.
The usercallback must return a tuple (when,getpeerlist) that indicates
when to reinvoke the callback again (as a number of seconds from now,
or < 0.0 if not at all) and whether to also include the details of
the connected peers in the DownloadStates on that next call.
The callback will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
@param usercallback A function adhering to the above spec.
"""
self.lm.set_download_states_callback(usercallback,getpeerlist)
#
# Config parameters that only exist at runtime
#
def get_permid(self):
""" Returns the PermID of the Session, as determined by the
SessionConfig.set_permid() parameter. A PermID is a public key
@return The PermID encoded in a string in DER format. """
self.sesslock.acquire()
try:
return str(self.keypair.pub().get_der())
finally:
self.sesslock.release()
def get_external_ip(self):
""" Returns the external IP address of this Session, i.e., by which
it is reachable from the Internet. This address is determined via
various mechanisms such as the UPnP protocol, our dialback mechanism,
and an inspection of the local network configuration.
@return A string. """
# locking done by lm
return self.lm.get_ext_ip()
def get_current_startup_config_copy(self):
""" Returns a SessionStartupConfig that is a copy of the current runtime
SessionConfig.
@return SessionStartupConfig
"""
# Called by any thread
self.sesslock.acquire()
try:
sessconfig = copy.copy(self.sessconfig)
return SessionStartupConfig(sessconfig=sessconfig)
finally:
self.sesslock.release()
#
# Internal tracker
#
def get_internal_tracker_url(self):
""" Returns the announce URL for the internal tracker.
@return URL """
# Called by any thread
self.sesslock.acquire()
try:
url = None
if 'tracker_url' in self.sessconfig:
url = self.sessconfig['tracker_url'] # user defined override, e.g. specific hostname
if url is None:
ip = self.lm.get_ext_ip()
port = self.get_listen_port()
url = 'http://'+ip+':'+str(port)+'/announce/'
return url
finally:
self.sesslock.release()
def get_internal_tracker_dir(self):
""" Returns the directory containing the torrents tracked by the internal
tracker (and associated databases).
@return An absolute path. """
# Called by any thread
self.sesslock.acquire()
try:
if self.sessconfig['state_dir'] is None:
return None
else:
return os.path.join(self.sessconfig['state_dir'],STATEDIR_ITRACKER_DIR)
finally:
self.sesslock.release()
def add_to_internal_tracker(self,tdef):
""" Add a torrent def to the list of torrents tracked by the internal
tracker. Use this method to use the Session as a standalone tracker.
@param tdef A finalized TorrentDef.
"""
# Called by any thread
self.sesslock.acquire()
try:
infohash = tdef.get_infohash()
filename = self.get_internal_tracker_torrentfilename(infohash)
tdef.save(filename)
# Bring to attention of Tracker thread
self.lm.tracker_rescan_dir()
finally:
self.sesslock.release()
def remove_from_internal_tracker(self,tdef):
""" Remove a torrent def from the list of torrents tracked by the
internal tracker. Use this method to use the Session as a standalone
tracker.
@param tdef A finalized TorrentDef.
"""
infohash = tdef.get_infohash()
self.remove_from_internal_tracker_by_infohash(infohash)
def remove_from_internal_tracker_by_infohash(self,infohash):
""" Remove a torrent def from the list of torrents tracked by the
internal tracker. Use this method to use the Session as a standalone
tracker.
@param infohash Identifier of the torrent def to remove.
"""
# Called by any thread
self.sesslock.acquire()
try:
filename = self.get_internal_tracker_torrentfilename(infohash)
if DEBUG:
print >>sys.stderr,"Session: removing itracker entry",filename
if os.access(filename,os.F_OK):
os.remove(filename)
# Bring to attention of Tracker thread
self.lm.tracker_rescan_dir()
finally:
self.sesslock.release()
#
# Notification of events in the Session
#
def add_observer(self, func, subject, changeTypes = [NTFY_UPDATE, NTFY_INSERT, NTFY_DELETE], objectID = None):
""" Add an observer function function to the Session. The observer
function will be called when one of the specified events (changeTypes)
occurs on the specified subject.
The function will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
@param func The observer function. It should accept as its first argument
the subject, as second argument the changeType, as third argument an
objectID (e.g. the primary key in the observed database) and an
optional list of arguments.
@param subject The subject to observe, one of NTFY_* subjects (see
simpledefs).
@param changeTypes The list of events to be notified of one of NTFY_*
events.
@param objectID The specific object in the subject to monitor (e.g. a
specific primary key in a database to monitor for updates.)
TODO: Jelle will add per-subject/event description here ;o)
"""
#Called by any thread
self.uch.notifier.add_observer(func, subject, changeTypes, objectID) # already threadsafe
def remove_observer(self, func):
""" Remove observer function. No more callbacks will be made.
@param func The observer function to remove. """
#Called by any thread
self.uch.notifier.remove_observer(func) # already threadsafe
def open_dbhandler(self,subject):
""" Opens a connection to the specified database. Only the thread
calling this method may use this connection. The connection must be
closed with close_dbhandler() when this thread exits.
@param subject The database to open. Must be one of the subjects
specified here.
@return A reference to a DBHandler class for the specified subject or
None when the Session was not started with megacaches enabled.
<pre> NTFY_PEERS -> PeerDBHandler
NTFY_TORRENTS -> TorrentDBHandler
NTFY_PREFERENCES -> PreferenceDBHandler
NTFY_SUPERPEERS -> SuperpeerDBHandler
NTFY_FRIENDS -> FriendsDBHandler
NTFY_MYPREFERENCES -> MyPreferenceDBHandler
NTFY_BARTERCAST -> BartercastDBHandler
</pre>
"""
# Called by any thread
self.sesslock.acquire()
try:
if subject == NTFY_PEERS:
return self.lm.peer_db
elif subject == NTFY_TORRENTS:
return self.lm.torrent_db
elif subject == NTFY_PREFERENCES:
return self.lm.pref_db
elif subject == NTFY_SUPERPEERS:
return self.lm.superpeer_db
elif subject == NTFY_FRIENDS:
return self.lm.friend_db
elif subject == NTFY_MYPREFERENCES:
return self.lm.mypref_db
elif subject == NTFY_BARTERCAST:
return self.lm.bartercast_db
else:
raise ValueError('Cannot open DB subject: '+subject)
finally:
self.sesslock.release()
def close_dbhandler(self,dbhandler):
""" Closes the given database connection """
dbhandler.close()
#
# Access control
#
def set_overlay_request_policy(self, reqpol):
"""
Set a function which defines which overlay requests (e.g. dl_helper, rquery msg)
will be answered or will be denied.
The function will be called by a network thread and must return
as soon as possible to prevent performance problems.
@param reqpol is a Tribler.Core.RequestPolicy.AbstractRequestPolicy
object.
"""
# Called by any thread
# to protect self.sessconfig
self.sesslock.acquire()
try:
overlay_loaded = self.sessconfig['overlay']
finally:
self.sesslock.release()
if overlay_loaded:
self.lm.overlay_apps.setRequestPolicy(reqpol) # already threadsafe
elif DEBUG:
print >>sys.stderr,"Session: overlay is disabled, so no overlay request policy needed"
#
# Persistence and shutdown
#
def load_checkpoint(self,initialdlstatus=None):
""" Restart Downloads from checkpoint, if any.
This method allows the API user to manage restoring downloads.
E.g. a video player that wants to start the torrent the user clicked
on first, and only then restart any sleeping torrents (e.g. seeding).
The optional initialdlstatus parameter can be set to DLSTATUS_STOPPED
to restore all the Downloads in DLSTATUS_STOPPED state.
"""
self.lm.load_checkpoint(initialdlstatus)
def checkpoint(self):
""" Saves the internal session state to the Session's state dir. """
#Called by any thread
self.checkpoint_shutdown(stop=False)
def shutdown(self,checkpoint=True,hacksessconfcheckpoint=True):
""" Checkpoints the session and closes it, stopping the download engine.
@param checkpoint Whether to checkpoint the Session state on shutdown.
"""
# Called by any thread
self.checkpoint_shutdown(stop=True,checkpoint=checkpoint,hacksessconfcheckpoint=hacksessconfcheckpoint)
self.uch.shutdown()
def get_downloads_pstate_dir(self):
""" Returns the directory in which to checkpoint the Downloads in this
Session. """
# Called by network thread
self.sesslock.acquire()
try:
return os.path.join(self.sessconfig['state_dir'],STATEDIR_DLPSTATE_DIR)
finally:
self.sesslock.release()
#
# Tribler Core special features
#
def query_connected_peers(self,query,usercallback,max_peers_to_query=None):
""" Ask all Tribler peers we're currently connected to resolve the
specified query and return the hits. For each peer that returns
hits the usercallback method is called with first parameter the
permid of the peer, as second parameter the query string and
as third parameter a dictionary of hits. The number of times the
usercallback method will be called is undefined.
At the moment we support one type of query, which is a query for
torrent files that match a set of keywords. The format of the
query string is "SIMPLE kw1 kw2 kw3". In the future we plan
to support full SQL queries.
For SIMPLE queries the dictionary of hits consists of
(infohash,torrentrecord) pairs. The torrentrecord is a
dictionary that contains the following keys:
<pre>
* 'content_name': The 'name' field of the torrent.
* 'length': The total size of the content in the torrent.
* 'leecher': The currently known number of downloaders.
* 'seeder': The currently known number of seeders.
* 'category': A list of category strings the torrent was classified into
by the remote peer.
</pre>
@param query A Unicode query string adhering to the above spec.
@param usercallback A function adhering to the above spec.
"""
self.sesslock.acquire()
try:
if self.sessconfig['overlay']:
if not query.startswith('SIMPLE '):
raise ValueError('Query does start with SIMPLE')
kws = query[len('SIMPLE '):]
rqmh = RemoteQueryMsgHandler.getInstance()
rqmh.send_query(kws,usercallback,max_nqueries=max_peers_to_query)
else:
raise OperationNotEnabledByConfigurationException("Overlay not enabled")
finally:
self.sesslock.release()
def download_torrentfile_from_peer(self,permid,infohash,usercallback):
""" Ask the designated peer to send us the torrentfile for the torrent
identified by the passed infohash. If the torrent is succesfully
received, the usercallback method is called with the infohash as first
and the contents of the torrentfile (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
@param permid The PermID of the peer to query.
@param infohash The infohash of the torrent.
@param usercallback A function adhering to the above spec.
"""
self.sesslock.acquire()
try:
if self.sessconfig['overlay']:
rtorrent_handler = RemoteTorrentHandler.getInstance()
rtorrent_handler.download_torrent(permid,infohash,usercallback)
else:
raise OperationNotEnabledByConfigurationException("Overlay not enabled")
finally:
self.sesslock.release()
#
# Internal persistence methods
#
def checkpoint_shutdown(self,stop,checkpoint,hacksessconfcheckpoint):
""" Checkpoints the Session and optionally shuts down the Session.
@param stop Whether to shutdown the Session as well.
@param checkpoint Whether to checkpoint at all, or just to stop. """
# Called by any thread
self.sesslock.acquire()
try:
# Arno: Make checkpoint optional on shutdown. At the moment setting
# the config at runtime is not possible (see SessionRuntimeConfig)
# so this has little use, and interferes with our way of
# changing the startup config, which is to write a new
# config to disk that will be read at start up.
if hacksessconfcheckpoint:
try:
self.save_pstate_sessconfig()
except Exception,e:
self.lm.rawserver_nonfatalerrorfunc(e)
# Checkpoint all Downloads and stop NetworkThread
if DEBUG:
print >>sys.stderr,"Session: checkpoint_shutdown"
self.lm.checkpoint(stop=stop,checkpoint=checkpoint)
finally:
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
Tribler.Core.Overlay.permid.init()
#print 'Session: __init__ config is', self.sessconfig
#
# 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 = Tribler.Core.Overlay.permid.read_keypair(
self.sessconfig['eckeypairfilename'])
else:
self.keypair = Tribler.Core.Overlay.permid.generate_keypair()
# Save keypair
pubfilename = os.path.join(self.sessconfig['state_dir'],
'ecpub.pem')
Tribler.Core.Overlay.permid.save_keypair(self.keypair,
pairfilename)
Tribler.Core.Overlay.permid.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
if self.sessconfig['superpeer_file'] is None:
self.sessconfig['superpeer_file'] = os.path.join(
self.sessconfig['install_dir'], 'Tribler', 'Core',
'superpeer.txt')
# 5. download_help_dir
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. NAT type detection
if not 'nat_detect' in self.sessconfig:
# Poor man's versioning, really should update PERSISTENTSTATE_CURRENTVERSION
self.sessconfig['nat_detect'] = sessdefaults['nat_detect']
self.sessconfig['puncturing_private_port'] = sessdefaults[
'puncturing_private_port']
self.sessconfig['stun_servers'] = sessdefaults['stun_servers']
self.sessconfig['puncturing_coordinators'] = sessdefaults[
'puncturing_coordinators']
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']
# 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, 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
Tribler.Core.Overlay.permid.init()
#print 'Session: __init__ config is', self.sessconfig
#
# 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 = Tribler.Core.Overlay.permid.read_keypair(self.sessconfig['eckeypairfilename'])
else:
self.keypair = Tribler.Core.Overlay.permid.generate_keypair()
# Save keypair
pubfilename = os.path.join(self.sessconfig['state_dir'],'ecpub.pem')
Tribler.Core.Overlay.permid.save_keypair(self.keypair,pairfilename)
Tribler.Core.Overlay.permid.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
if self.sessconfig['superpeer_file'] is None:
self.sessconfig['superpeer_file'] = os.path.join(self.sessconfig['install_dir'],'Tribler','Core','superpeer.txt')
# 5. download_help_dir
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. NAT type detection
if not 'nat_detect' in self.sessconfig:
# Poor man's versioning, really should update PERSISTENTSTATE_CURRENTVERSION
self.sessconfig['nat_detect'] = sessdefaults['nat_detect']
self.sessconfig['puncturing_private_port'] = sessdefaults['puncturing_private_port']
self.sessconfig['stun_servers'] = sessdefaults['stun_servers']
self.sessconfig['puncturing_coordinators'] = sessdefaults['puncturing_coordinators']
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']
# 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,self.sesslock)
self.lm.start()
class Session(SessionRuntimeConfig):
"""
A Session is a running instance of the Tribler Core and the Core's central
class. It implements the SessionConfigInterface which can be used to change
session parameters at runtime (for selected parameters).
cf. libtorrent session
"""
__single = None
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()
# ProxyService 90s Test_
# sscfg = self.get_current_startup_config_copy()
# if os.path.isfile(os.path.join(sscfg.get_state_dir(),"Proxy90secondsTestV2")):
# # The 90s test was already executed
# self.proxytest_state = False
# else:
# # The 90s test was not executed yet
# self.proxytest_state = True
# _ProxyService 90s Test
#
# Class methods
#
def get_instance(*args, **kw):
""" Returns the Session singleton if it exists or otherwise
creates it first, in which case you need to pass the constructor
params.
@return Session."""
if Session.__single is None:
Session(*args, **kw)
return Session.__single
get_instance = staticmethod(get_instance)
def get_default_state_dir(homedirpostfix=".Tribler"):
""" Returns the factory default directory for storing session state
on the current platform (Win32,Mac,Unix).
@return An absolute path name. """
# Allow override
statedirvar = "${TSTATEDIR}"
statedir = os.path.expandvars(statedirvar)
if statedir and statedir != statedirvar:
return statedir
appdir = get_appstate_dir()
statedir = os.path.join(appdir, homedirpostfix)
return statedir
get_default_state_dir = staticmethod(get_default_state_dir)
#
# Public methods
#
def start_download(self, cdef, dcfg=None, initialdlstatus=None):
"""
Creates a Download object and adds it to the session. The passed
ContentDef and DownloadStartupConfig are copied into the new Download
object. The Download is then started and checkpointed.
If a checkpointed version of the Download is found, that is restarted
overriding the saved DownloadStartupConfig if "dcfg" is not None.
@param cdef A finalized TorrentDef or a SwiftDef
@param dcfg DownloadStartupConfig or None, in which case
a new DownloadStartupConfig() is created with its default settings
and the result becomes the runtime config of this Download.
@param initialdlstatus The initial download status of this Download
or None. This enables the caller to create a Download in e.g.
DLSTATUS_REPEXING state instead.
@return Download
"""
# locking by lm
if cdef.get_def_type() == "torrent":
return self.lm.add(cdef, dcfg, initialdlstatus=initialdlstatus)
else:
# SWIFTPROC
return self.lm.swift_add(cdef, dcfg, initialdlstatus=initialdlstatus)
def resume_download_from_file(self, filename):
"""
Recreates Download from resume file
@return a Download object.
Note: this cannot be made into a method of Download, as the Download
needs to be bound to a session, it cannot exist independently.
"""
raise NotYetImplementedException()
def get_downloads(self):
"""
Returns a copy of the list of Downloads.
@return A list of Download objects.
"""
# locking by lm
return self.lm.get_downloads()
def remove_download(self, d, removecontent=False, removestate=True):
"""
Stops the download and removes it from the session.
@param d The Download to remove
@param removecontent Whether to delete the already downloaded content
from disk.
"""
# locking by lm
if d.get_def().get_def_type() == "torrent":
self.lm.remove(d, removecontent=removecontent, removestate=removestate)
else:
# SWIFTPROC
self.lm.swift_remove(d, removecontent=removecontent, removestate=removestate)
def set_download_states_callback(self, usercallback, getpeerlist=False):
"""
See Download.set_state_callback. Calls usercallback with a list of
DownloadStates, one for each Download in the Session as first argument.
The usercallback must return a tuple (when,getpeerlist) that indicates
when to reinvoke the callback again (as a number of seconds from now,
or < 0.0 if not at all) and whether to also include the details of
the connected peers in the DownloadStates on that next call.
The callback will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
@param usercallback A function adhering to the above spec.
"""
self.lm.set_download_states_callback(usercallback, getpeerlist)
#
# Config parameters that only exist at runtime
#
def get_permid(self):
""" Returns the PermID of the Session, as determined by the
SessionConfig.set_permid() parameter. A PermID is a public key
@return The PermID encoded in a string in DER format. """
self.sesslock.acquire()
try:
return str(self.keypair.pub().get_der())
finally:
self.sesslock.release()
def get_external_ip(self):
""" Returns the external IP address of this Session, i.e., by which
it is reachable from the Internet. This address is determined via
various mechanisms such as the UPnP protocol, our dialback mechanism,
and an inspection of the local network configuration.
@return A string. """
# locking done by lm
return self.lm.get_ext_ip()
def get_externally_reachable(self):
""" Returns whether the Session is externally reachable, i.e., its
listen port is not firewalled. Use add_observer() with NTFY_REACHABLE
to register to the event of detecting reachablility. Note that due to
the use of UPnP a Session may become reachable some time after
startup and due to the Dialback mechanism, this method may return
False while the Session is actually already reachable. Note that True
doesn't mean the Session is reachable from the open Internet, could just
be from the local (otherwise firewalled) LAN.
@return A boolean. """
# Arno, LICHT: make it throw exception when used in LITE versie.
from Tribler.Core.NATFirewall.DialbackMsgHandler import DialbackMsgHandler
return DialbackMsgHandler.getInstance().isConnectable()
def get_current_startup_config_copy(self):
""" Returns a SessionStartupConfig that is a copy of the current runtime
SessionConfig.
@return SessionStartupConfig
"""
# Called by any thread
self.sesslock.acquire()
try:
sessconfig = copy.copy(self.sessconfig)
return SessionStartupConfig(sessconfig=sessconfig)
finally:
self.sesslock.release()
#
# Internal tracker
#
def get_internal_tracker_url(self):
""" Returns the announce URL for the internal tracker.
@return URL """
# Called by any thread
self.sesslock.acquire()
try:
url = None
if "tracker_url" in self.sessconfig:
url = self.sessconfig["tracker_url"] # user defined override, e.g. specific hostname
if url is None:
ip = self.lm.get_ext_ip()
port = self.get_listen_port()
url = "http://" + ip + ":" + str(port) + "/announce/"
return url
finally:
self.sesslock.release()
def get_internal_tracker_dir(self):
""" Returns the directory containing the torrents tracked by the internal
tracker (and associated databases).
@return An absolute path. """
# Called by any thread
self.sesslock.acquire()
try:
if self.sessconfig["state_dir"] is None:
return None
else:
return os.path.join(self.sessconfig["state_dir"], STATEDIR_ITRACKER_DIR)
finally:
self.sesslock.release()
def add_to_internal_tracker(self, tdef):
""" Add a torrent def to the list of torrents tracked by the internal
tracker. Use this method to use the Session as a standalone tracker.
@param tdef A finalized TorrentDef.
"""
# Called by any thread
self.sesslock.acquire()
try:
infohash = tdef.get_infohash()
filename = self.get_internal_tracker_torrentfilename(infohash)
tdef.save(filename)
print >>sys.stderr, "Session: add_to_int_tracker: saving to", filename, "url-compat", tdef.get_url_compat()
# Bring to attention of Tracker thread
self.lm.tracker_rescan_dir()
finally:
self.sesslock.release()
def remove_from_internal_tracker(self, tdef):
""" Remove a torrent def from the list of torrents tracked by the
internal tracker. Use this method to use the Session as a standalone
tracker.
@param tdef A finalized TorrentDef.
"""
infohash = tdef.get_infohash()
self.remove_from_internal_tracker_by_infohash(infohash)
def remove_from_internal_tracker_by_infohash(self, infohash):
""" Remove a torrent def from the list of torrents tracked by the
internal tracker. Use this method to use the Session as a standalone
tracker.
@param infohash Identifier of the torrent def to remove.
"""
# Called by any thread
self.sesslock.acquire()
try:
filename = self.get_internal_tracker_torrentfilename(infohash)
if DEBUG:
print >>sys.stderr, "Session: removing itracker entry", filename
if os.access(filename, os.F_OK):
os.remove(filename)
# Bring to attention of Tracker thread
self.lm.tracker_rescan_dir()
finally:
self.sesslock.release()
#
# Notification of events in the Session
#
def add_observer(self, func, subject, changeTypes=[NTFY_UPDATE, NTFY_INSERT, NTFY_DELETE], objectID=None):
""" Add an observer function function to the Session. The observer
function will be called when one of the specified events (changeTypes)
occurs on the specified subject.
The function will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
@param func The observer function. It should accept as its first argument
the subject, as second argument the changeType, as third argument an
objectID (e.g. the primary key in the observed database) and an
optional list of arguments.
@param subject The subject to observe, one of NTFY_* subjects (see
simpledefs).
@param changeTypes The list of events to be notified of one of NTFY_*
events.
@param objectID The specific object in the subject to monitor (e.g. a
specific primary key in a database to monitor for updates.)
TODO: Jelle will add per-subject/event description here ;o)
"""
# Called by any thread
self.uch.notifier.add_observer(func, subject, changeTypes, objectID) # already threadsafe
def remove_observer(self, func):
""" Remove observer function. No more callbacks will be made.
@param func The observer function to remove. """
# Called by any thread
self.uch.notifier.remove_observer(func) # already threadsafe
def open_dbhandler(self, subject):
""" Opens a connection to the specified database. Only the thread
calling this method may use this connection. The connection must be
closed with close_dbhandler() when this thread exits.
@param subject The database to open. Must be one of the subjects
specified here.
@return A reference to a DBHandler class for the specified subject or
None when the Session was not started with megacaches enabled.
<pre> NTFY_PEERS -> PeerDBHandler
NTFY_TORRENTS -> TorrentDBHandler
NTFY_PREFERENCES -> PreferenceDBHandler
NTFY_SUPERPEERS -> SuperpeerDBHandler
NTFY_FRIENDS -> FriendsDBHandler
NTFY_MYPREFERENCES -> MyPreferenceDBHandler
NTFY_BARTERCAST -> BartercastDBHandler
NTFY_SEARCH -> SearchDBHandler
NTFY_TERM -> TermDBHandler
NTFY_VOTECAST -> VotecastDBHandler
NTFY_CHANNELCAST -> ChannelCastDBHandler
NTFY_RICH_METADATA -> MetadataDBHandler
</pre>
"""
# Called by any thread
self.sesslock.acquire()
try:
if subject == NTFY_PEERS:
return self.lm.peer_db
elif subject == NTFY_TORRENTS:
return self.lm.torrent_db
elif subject == NTFY_PREFERENCES:
return self.lm.pref_db
elif subject == NTFY_SUPERPEERS:
return self.lm.superpeer_db
elif subject == NTFY_FRIENDS:
return self.lm.friend_db
elif subject == NTFY_MYPREFERENCES:
return self.lm.mypref_db
elif subject == NTFY_BARTERCAST:
return self.lm.bartercast_db
elif subject == NTFY_SEEDINGSTATS:
return self.lm.seedingstats_db
elif subject == NTFY_SEEDINGSTATSSETTINGS:
return self.lm.seedingstatssettings_db
elif subject == NTFY_VOTECAST:
return self.lm.votecast_db
elif subject == NTFY_SEARCH:
return self.lm.search_db
elif subject == NTFY_TERM:
return self.lm.term_db
elif subject == NTFY_CHANNELCAST:
return self.lm.channelcast_db
elif subject == NTFY_RICH_METADATA:
return self.lm.richmetadataDbHandler
else:
raise ValueError("Cannot open DB subject: " + subject)
finally:
self.sesslock.release()
def close_dbhandler(self, dbhandler):
""" Closes the given database connection """
dbhandler.close()
#
# Access control
#
def set_overlay_request_policy(self, reqpol):
"""
Set a function which defines which overlay requests (e.g. proxy relay request, rquery msg)
will be answered or will be denied.
The function will be called by a network thread and must return
as soon as possible to prevent performance problems.
@param reqpol is a Tribler.Core.RequestPolicy.AbstractRequestPolicy
object.
"""
# Called by any thread
# to protect self.sessconfig
self.sesslock.acquire()
try:
overlay_loaded = self.sessconfig["overlay"]
finally:
self.sesslock.release()
if overlay_loaded:
self.lm.overlay_apps.setRequestPolicy(reqpol) # already threadsafe
elif DEBUG:
print >>sys.stderr, "Session: overlay is disabled, so no overlay request policy needed"
#
# Persistence and shutdown
#
def load_checkpoint(self, initialdlstatus=None):
""" Restart Downloads from checkpoint, if any.
This method allows the API user to manage restoring downloads.
E.g. a video player that wants to start the torrent the user clicked
on first, and only then restart any sleeping torrents (e.g. seeding).
The optional initialdlstatus parameter can be set to DLSTATUS_STOPPED
to restore all the Downloads in DLSTATUS_STOPPED state.
"""
self.lm.load_checkpoint(initialdlstatus)
def checkpoint(self):
""" Saves the internal session state to the Session's state dir. """
# Called by any thread
self.checkpoint_shutdown(stop=False, checkpoint=True, gracetime=None, hacksessconfcheckpoint=False)
def shutdown(self, checkpoint=True, gracetime=2.0, hacksessconfcheckpoint=True):
""" Checkpoints the session and closes it, stopping the download engine.
@param checkpoint Whether to checkpoint the Session state on shutdown.
@param gracetime Time to allow for graceful shutdown + signoff (seconds).
"""
# Called by any thread
self.lm.early_shutdown()
self.checkpoint_shutdown(
stop=True, checkpoint=checkpoint, gracetime=gracetime, hacksessconfcheckpoint=hacksessconfcheckpoint
)
# Arno, 2010-08-09: now shutdown after gracetime
# self.uch.shutdown()
def has_shutdown(self):
""" Whether the Session has completely shutdown, i.e., its internal
threads are finished and it is safe to quit the process the Session
is running in.
@return A Boolean.
"""
return self.lm.sessdoneflag.isSet()
def get_downloads_pstate_dir(self):
""" Returns the directory in which to checkpoint the Downloads in this
Session. """
# Called by network thread
self.sesslock.acquire()
try:
return os.path.join(self.sessconfig["state_dir"], STATEDIR_DLPSTATE_DIR)
finally:
self.sesslock.release()
#
# Tribler Core special features
#
def query_connected_peers(self, query, usercallback, max_peers_to_query=None):
""" Ask all Tribler peers we're currently connected to resolve the
specified query and return the hits. For each peer that returns
hits the usercallback method is called with first parameter the
permid of the peer, as second parameter the query string and
as third parameter a dictionary of hits. The number of times the
usercallback method will be called is undefined.
The callback will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
At the moment we support three types of query, which are all queries for
torrent files that match a set of keywords. The format of the
query string is "SIMPLE kw1 kw2 kw3" (type 1) or "SIMPLE+METADATA kw1 kw2
kw3" (type 3). In the future we plan to support full SQL queries.
For SIMPLE queries the dictionary of hits consists of
(infohash,torrentrecord) pairs. The torrentrecord is a
dictionary that contains the following keys:
<pre>
* 'content_name': The 'name' field of the torrent as Unicode string.
* 'length': The total size of the content in the torrent.
* 'leecher': The currently known number of downloaders.
* 'seeder': The currently known number of seeders.
* 'category': A list of category strings the torrent was classified into
by the remote peer.
</pre>
From Session API version 1.0.2 the following keys were added
to the torrentrecord:
<pre>
* 'torrent_size': The size of the .torrent file.
</pre>
From Session API version 1.0.4 the following keys were added
to the torrentrecord:
<pre>
* 'channel_permid': PermID of the channel this torrent belongs to (or '')
* 'channel_name': channel name as Unicode string (or '').
For SIMPLE+METADATA queries there is an extra field
<pre>
* 'torrent_file': Bencoded contents of the .torrent file.
</pre>
The torrents *not* be automatically added to the TorrentDBHandler
(if enabled) at the time of the call.
The third type of query: search for channels. It is used to query for
channels: either a particular channel matching the permid in the query,
or a list of channels whose names match the keywords in the query
by sending the query to connected peers.
The format of the query in the corresponding scenarios should be:
a. keyword-based query: "CHANNEL k bbc"
('k' stands for keyword-based and ' '{space} is a separator followed by
the keywords)
b. permid-based query: "CHANNEL p f34wrf2345wfer2345wefd3r34r54"
('p' stands for permid-based and ' '{space} is a separator followed by
the permid)
In each of the above 2 cases, the format of the hits that is returned
by the queried peer is a dictionary of hits of (signature,channelrecord).
The channelrecord is a dictionary the contains following keys:
<pre>
* 'publisher_id': a PermID
* 'publisher_name': as Unicode string
* 'infohash': 20-byte SHA1 hash
* 'torrenthash': 20-byte SHA1 hash
* 'torrentname': as Unicode string
* 'time_stamp': as integer
</pre>
@param query A Unicode query string adhering to the above spec.
@param usercallback A function adhering to the above spec.
@return currently connected peers with olversion 6 or higher
"""
self.sesslock.acquire()
try:
if self.sessconfig["overlay"]:
if not (query.startswith("SIMPLE ") or query.startswith("SIMPLE+METADATA ")) and not query.startswith(
"CHANNEL "
):
raise ValueError("Query does not start with SIMPLE or SIMPLE+METADATA or CHANNEL (%s)" % query)
from Tribler.Core.SocialNetwork.RemoteQueryMsgHandler import RemoteQueryMsgHandler
rqmh = RemoteQueryMsgHandler.getInstance()
rqmh.send_query(query, usercallback, max_peers_to_query=max_peers_to_query)
return len(rqmh.get_connected_peers(OLPROTO_VER_SIXTH))
else:
raise OperationNotEnabledByConfigurationException("Overlay not enabled")
finally:
self.sesslock.release()
return 0
def query_peers(self, query, peers, usercallback):
""" Equal to query_connected_peers only now for a limited subset of peers.
If there is no active connnection to a peer in the list, a connection
will be made.
"""
self.sesslock.acquire()
try:
if self.sessconfig["overlay"]:
if not (query.startswith("SIMPLE ") or query.startswith("SIMPLE+METADATA ")) and not query.startswith(
"CHANNEL "
):
raise ValueError("Query does not start with SIMPLE or SIMPLE+METADATA or CHANNEL")
from Tribler.Core.SocialNetwork.RemoteQueryMsgHandler import RemoteQueryMsgHandler
rqmh = RemoteQueryMsgHandler.getInstance()
rqmh.send_query_to_peers(query, peers, usercallback)
else:
raise OperationNotEnabledByConfigurationException("Overlay not enabled")
finally:
self.sesslock.release()
def download_torrentfile(self, infohash, usercallback, prio=0):
""" Try to download the torrentfile without a known source.
A possible source could be the DHT.
If the torrent is succesfully
received, the usercallback method is called with the infohash as first
and the contents of the torrentfile (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
@param infohash The infohash of the torrent.
@param usercallback A function adhering to the above spec.
"""
self.sesslock.acquire()
try:
if self.sessconfig["overlay"]:
from Tribler.Core.SocialNetwork.RemoteTorrentHandler import RemoteTorrentHandler
rtorrent_handler = RemoteTorrentHandler.getInstance()
rtorrent_handler.download_torrent(None, infohash, usercallback, prio)
else:
raise OperationNotEnabledByConfigurationException("Overlay not enabled")
finally:
self.sesslock.release()
def download_torrentfile_from_peer(self, permid, infohash, usercallback, prio=0):
""" Ask the designated peer to send us the torrentfile for the torrent
identified by the passed infohash. If the torrent is succesfully
received, the usercallback method is called with the infohash as first
and the contents of the torrentfile (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
@param permid The PermID of the peer to query.
@param infohash The infohash of the torrent.
@param usercallback A function adhering to the above spec.
"""
# ARNOCOMMENT: Perhaps make save to database optional.
self.sesslock.acquire()
try:
if self.sessconfig["overlay"]:
from Tribler.Core.SocialNetwork.RemoteTorrentHandler import RemoteTorrentHandler
rtorrent_handler = RemoteTorrentHandler.getInstance()
rtorrent_handler.download_torrent(permid, infohash, usercallback, prio)
else:
raise OperationNotEnabledByConfigurationException("Overlay not enabled")
finally:
self.sesslock.release()
#
# Internal persistence methods
#
def checkpoint_shutdown(self, stop, checkpoint, gracetime, hacksessconfcheckpoint):
""" Checkpoints the Session and optionally shuts down the Session.
@param stop Whether to shutdown the Session as well.
@param checkpoint Whether to checkpoint at all, or just to stop.
@param gracetime Time to allow for graceful shutdown + signoff (seconds).
"""
# Called by any thread
self.sesslock.acquire()
try:
# Arno: Make checkpoint optional on shutdown. At the moment setting
# the config at runtime is not possible (see SessionRuntimeConfig)
# so this has little use, and interferes with our way of
# changing the startup config, which is to write a new
# config to disk that will be read at start up.
if hacksessconfcheckpoint:
try:
self.save_pstate_sessconfig()
except Exception, e:
self.lm.rawserver_nonfatalerrorfunc(e)
# Checkpoint all Downloads and stop NetworkThread
if DEBUG:
print >>sys.stderr, "Session: checkpoint_shutdown"
self.lm.checkpoint(stop=stop, checkpoint=checkpoint, gracetime=gracetime)
finally:
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()
class Session(object):
"""
A Session is a running instance of the Tribler Core and the Core's central class.
"""
__single = None
def __init__(self, config=None, autoload_discovery=True):
"""
A Session object is created which is configured with the Tribler configuration object.
Only a single session instance can exist at a time in a process.
:param config: a TriblerConfig 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 TriblerConfig() object to
serve as startup config. Next, the config is saved in the directory
indicated by its 'state_dir' attribute.
:param autoload_discovery: only false in the Tunnel community tests
"""
addObserver(self.unhandled_error_observer)
patch_crypto_be_discovery()
self._logger = logging.getLogger(self.__class__.__name__)
self.session_lock = RLock()
self.config = config or TriblerConfig()
self._logger.info("Session is using state directory: %s", self.config.get_state_dir())
self.get_ports_in_config()
self.create_state_directory_structure()
self.selected_ports = self.config.selected_ports
self.init_keypair()
self.lm = TriblerLaunchMany()
self.notifier = Notifier()
self.upgrader_enabled = True
self.upgrader = None
self.readable_status = '' # Human-readable string to indicate the status during startup/shutdown of Tribler
self.autoload_discovery = autoload_discovery
def create_state_directory_structure(self):
"""Create directory structure of the state directory."""
def create_dir(path):
if not os.path.isdir(path):
os.makedirs(path)
def create_in_state_dir(path):
create_dir(os.path.join(self.config.get_state_dir(), path))
create_dir(self.config.get_state_dir())
create_in_state_dir(STATEDIR_DB_DIR)
create_in_state_dir(STATEDIR_DLPSTATE_DIR)
create_in_state_dir(STATEDIR_WALLET_DIR)
create_in_state_dir(STATEDIR_CHANNELS_DIR)
def get_ports_in_config(self):
"""Claim all required random ports."""
self.config.get_libtorrent_port()
self.config.get_video_server_port()
self.config.get_anon_listen_port()
self.config.get_tunnel_community_socks5_listen_ports()
def init_keypair(self):
"""
Set parameters that depend on state_dir.
"""
trustchain_pairfilename = self.config.get_trustchain_keypair_filename()
if os.path.exists(trustchain_pairfilename):
self.trustchain_keypair = permid_module.read_keypair_trustchain(trustchain_pairfilename)
else:
self.trustchain_keypair = permid_module.generate_keypair_trustchain()
# Save keypair
trustchain_pubfilename = os.path.join(self.config.get_state_dir(), 'ecpub_multichain.pem')
permid_module.save_keypair_trustchain(self.trustchain_keypair, trustchain_pairfilename)
permid_module.save_pub_key_trustchain(self.trustchain_keypair, trustchain_pubfilename)
trustchain_testnet_pairfilename = self.config.get_trustchain_testnet_keypair_filename()
if os.path.exists(trustchain_testnet_pairfilename):
self.trustchain_testnet_keypair = permid_module.read_keypair_trustchain(trustchain_testnet_pairfilename)
else:
self.trustchain_testnet_keypair = permid_module.generate_keypair_trustchain()
# Save keypair
trustchain_testnet_pubfilename = os.path.join(self.config.get_state_dir(), 'ecpub_trustchain_testnet.pem')
permid_module.save_keypair_trustchain(self.trustchain_testnet_keypair, trustchain_testnet_pairfilename)
permid_module.save_pub_key_trustchain(self.trustchain_testnet_keypair, trustchain_testnet_pubfilename)
def unhandled_error_observer(self, event):
"""
This method is called when an unhandled error in Tribler is observed.
It broadcasts the tribler_exception event.
"""
if event['isError']:
text = ""
if 'log_legacy' in event and 'log_text' in event:
text = event['log_text']
elif 'log_failure' in event:
text = str(event['log_failure'])
# There are some errors that we are ignoring.
# No route to host: this issue is non-critical since Tribler can still function when a request fails.
if 'socket.error' in text and '[Errno 113]' in text:
self._logger.error("Observed no route to host error (but ignoring)."
"This might indicate a problem with your firewall.")
return
# Socket block: this sometimes occurres on Windows and is non-critical.
if 'socket.error' in text and '[Errno %s]' % SOCKET_BLOCK_ERRORCODE in text:
self._logger.error("Unable to send data due to socket.error %s", SOCKET_BLOCK_ERRORCODE)
return
if 'socket.error' in text and '[Errno 51]' in text:
self._logger.error("Could not send data: network is unreachable.")
return
if 'socket.error' in text and '[Errno 16]' in text:
self._logger.error("Could not send data: socket is busy.")
return
if 'socket.error' in text and '[Errno 11001]' in text:
self._logger.error("Unable to perform DNS lookup.")
return
if 'socket.error' in text and '[Errno 10053]' in text:
self._logger.error("An established connection was aborted by the software in your host machine.")
return
if 'socket.error' in text and '[Errno 10054]' in text:
self._logger.error("Connection forcibly closed by the remote host.")
return
if 'exceptions.ValueError: Invalid DNS-ID' in text:
self._logger.error("Invalid DNS-ID")
return
if 'twisted.web._newclient.ResponseNeverReceived' in text:
self._logger.error("Internal Twisted response error, consider updating your Twisted version.")
return
if 'twisted.internet.error.AlreadyCalled' in text:
self._logger.error("Tried to cancel an already called event\n%s", text)
return
# We already have a check for invalid infohash when adding a torrent, but if somehow we get this
# error then we simply log and ignore it.
if 'exceptions.RuntimeError: invalid info-hash' in text:
self._logger.error("Invalid info-hash found")
return
if self.lm.api_manager and len(text) > 0:
self.lm.api_manager.root_endpoint.events_endpoint.on_tribler_exception(text)
self.lm.api_manager.root_endpoint.state_endpoint.on_tribler_exception(text)
def start_download_from_uri(self, uri, download_config=None):
"""
Start a download from an argument. This argument can be of the following type:
-http: Start a download from a torrent file at the given url.
-magnet: Start a download from a torrent file by using a magnet link.
-file: Start a download from a torrent file at given location.
:param uri: specifies the location of the torrent to be downloaded
:param download_config: an optional configuration for the download
:return: a deferred that fires when a download has been added to the Tribler core
"""
if self.config.get_libtorrent_enabled():
return self.lm.ltmgr.start_download_from_uri(uri, dconfig=download_config)
raise OperationNotEnabledByConfigurationException()
def start_download_from_tdef(self, torrent_definition, download_startup_config=None, pstate=None, hidden=False):
"""
Creates a Download object and adds it to the session. The passed
ContentDef and DownloadStartupConfig are copied into the new Download
object. The Download is then started and checkpointed.
If a checkpointed version of the Download is found, that is restarted
overriding the saved DownloadStartupConfig if "download_startup_config" is not None.
Locking is done by LaunchManyCore.
:param torrent_definition: a TorrentDef
:param download_startup_config: a DownloadStartupConfig or None, in which case
a new DownloadStartupConfig() is created with its default settings
and the result becomes the runtime config of this Download
:param hidden: whether this torrent should be added to the mypreference table
:return: a Download
"""
if self.config.get_libtorrent_enabled():
return self.lm.add(torrent_definition, download_startup_config, pstate=pstate, hidden=hidden)
raise OperationNotEnabledByConfigurationException()
def resume_download_from_file(self, filename):
"""
Recreates Download from resume file.
Note: this cannot be made into a method of Download, as the Download
needs to be bound to a session, it cannot exist independently.
:return: a Download object
:raises: a NotYetImplementedException
"""
raise NotYetImplementedException()
def get_downloads(self):
"""
Returns a copy of the list of Downloads.
Locking is done by LaunchManyCore.
:return: a list of Download objects
"""
return self.lm.get_downloads()
def get_download(self, infohash):
"""
Returns the Download object for this hash.
Locking is done by LaunchManyCore.
:return: a Download object
"""
return self.lm.get_download(infohash)
def has_download(self, infohash):
"""
Checks if the torrent download already exists.
:param infohash: The torrent infohash
:return: True or False indicating if the torrent download already exists
"""
return self.lm.download_exists(infohash)
def remove_download(self, download, remove_content=False, remove_state=True, hidden=False):
"""
Stops the download and removes it from the session.
Note that LaunchManyCore locks.
:param download: the Download to remove
:param remove_content: whether to delete the already downloaded content from disk
:param remove_state: whether to delete the metadata files of the downloaded content from disk
:param hidden: whether this torrent is added to the mypreference table and this entry should be removed
"""
# locking by lm
return self.lm.remove(download, removecontent=remove_content, removestate=remove_state, hidden=hidden)
def remove_download_by_id(self, infohash, remove_content=False, remove_state=True):
"""
Remove a download by it's infohash.
We can only remove content when the download object is found, otherwise only
the state is removed.
:param infohash: the download to remove
:param remove_content: whether to delete the already downloaded content from disk
:param remove_state: whether to remove the metadata files from disk
"""
download_list = self.get_downloads()
for download in download_list:
if download.get_def().get_infohash() == infohash:
return self.remove_download(download, remove_content, remove_state)
def set_download_states_callback(self, user_callback, interval=1.0):
"""
See Download.set_state_callback. Calls user_callback with a list of
DownloadStates, one for each Download in the Session as first argument.
The user_callback must return a tuple (when, getpeerlist) that indicates
when to invoke the callback again (as a number of seconds from now,
or < 0.0 if not at all) and whether to also include the details of
the connected peers in the DownloadStates on that next call.
The callback will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
:param user_callback: a function adhering to the above spec
:param interval: time in between the download states callback's
"""
self.lm.set_download_states_callback(user_callback, interval)
#
# Notification of events in the Session
#
def add_observer(self, observer_function, subject, change_types=None, object_id=None, cache=0):
"""
Add an observer function function to the Session. The observer
function will be called when one of the specified events (changeTypes)
occurs on the specified subject.
The function will be called by a popup thread which can be used indefinitely (within reason)
by the higher level code. Note that this function is called by any thread and is thread safe.
:param observer_function: should accept as its first argument
the subject, as second argument the changeType, as third argument an
object_id (e.g. the primary key in the observed database) and an
optional list of arguments.
:param subject: the subject to observe, one of NTFY_* subjects (see simpledefs).
:param change_types: the list of events to be notified of one of NTFY_* events.
:param object_id: The specific object in the subject to monitor (e.g. a
specific primary key in a database to monitor for updates.)
:param cache: the time to bundle/cache events matching this function
"""
change_types = change_types or [NTFY_UPDATE, NTFY_INSERT, NTFY_DELETE]
self.notifier.add_observer(observer_function, subject, change_types, object_id, cache=cache)
def remove_observer(self, function):
"""
Remove observer function. No more callbacks will be made.
This function is called by any thread and is thread safe.
:param function: the observer function to remove.
"""
self.notifier.remove_observer(function)
def get_tribler_statistics(self):
"""Return a dictionary with general Tribler statistics."""
return TriblerStatistics(self).get_tribler_statistics()
def get_ipv8_statistics(self):
"""Return a dictionary with IPv8 statistics."""
return TriblerStatistics(self).get_ipv8_statistics()
#
# Persistence and shutdown
#
def load_checkpoint(self):
"""
Restart Downloads from a saved checkpoint, if any. Note that we fetch information from the user download
choices since it might be that a user has stopped a download. In that case, the download should not be
resumed immediately when being loaded by libtorrent.
"""
self.lm.load_checkpoint()
def checkpoint(self):
"""
Saves the internal session state to the Session's state dir.
Checkpoints the downloads via the LaunchManyCore instance. This function is called by any thread.
"""
self.lm.checkpoint_downloads()
def start(self):
"""
Start a Tribler session by initializing the LaunchManyCore class, opening the database and running the upgrader.
Returns a deferred that fires when the Tribler session is ready for use.
"""
# Start the REST API before the upgrader since we want to send interesting upgrader events over the socket
if self.config.get_http_api_enabled():
self.lm.api_manager = RESTManager(self)
self.readable_status = STATE_START_API
self.lm.api_manager.start()
if self.upgrader_enabled:
self.upgrader = TriblerUpgrader(self)
self.readable_status = STATE_UPGRADING_READABLE
self.upgrader.run()
startup_deferred = self.lm.register(self, self.session_lock)
def load_checkpoint(_):
if self.config.get_libtorrent_enabled():
self.readable_status = STATE_LOAD_CHECKPOINTS
self.load_checkpoint()
self.readable_status = STATE_READABLE_STARTED
return startup_deferred.addCallback(load_checkpoint)
def shutdown(self):
"""
Checkpoints the session and closes it, stopping the download engine.
This method has to be called from the reactor thread.
"""
assert isInIOThread()
@inlineCallbacks
def on_early_shutdown_complete(_):
"""
Callback that gets called when the early shutdown has been completed.
Continues the shutdown procedure that is dependant on the early shutdown.
:param _: ignored parameter of the Deferred
"""
self.notify_shutdown_state("Saving configuration...")
self.config.write()
self.notify_shutdown_state("Checkpointing Downloads...")
yield self.checkpoint_downloads()
self.notify_shutdown_state("Shutting down Downloads...")
self.lm.shutdown_downloads()
self.notify_shutdown_state("Shutting down Network...")
self.lm.network_shutdown()
if self.lm.mds:
self.notify_shutdown_state("Shutting down Metadata Store...")
self.lm.mds.shutdown()
if self.upgrader:
self.upgrader.shutdown()
# We close the API manager as late as possible during shutdown.
if self.lm.api_manager is not None:
self.notify_shutdown_state("Shutting down API Manager...")
yield self.lm.api_manager.stop()
self.lm.api_manager = None
# Indicates we are shutting down core. With this environment variable set
# to 'TRUE', RESTManager will no longer accepts any new requests.
os.environ['TRIBLER_SHUTTING_DOWN'] = "TRUE"
return self.lm.early_shutdown().addCallback(on_early_shutdown_complete)
def has_shutdown(self):
"""
Whether the Session has completely shutdown, i.e., its internal
threads are finished and it is safe to quit the process the Session
is running in.
:return: a boolean.
"""
return self.lm.sessdoneflag.isSet()
def get_downloads_pstate_dir(self):
"""
Returns the directory in which to checkpoint the Downloads in this
Session. This function is called by the network thread.
"""
return os.path.join(self.config.get_state_dir(), STATEDIR_DLPSTATE_DIR)
def get_ipv8_instance(self):
if not self.config.get_ipv8_enabled():
raise OperationNotEnabledByConfigurationException()
return self.lm.ipv8
def get_libtorrent_process(self):
if not self.config.get_libtorrent_enabled():
raise OperationNotEnabledByConfigurationException()
return self.lm.ltmgr
#
# Internal persistence methods
#
def checkpoint_downloads(self):
"""Checkpoints the downloads."""
return self.lm.checkpoint_downloads()
def update_trackers(self, infohash, trackers):
"""
Updates the trackers of a torrent.
:param infohash: infohash of the torrent that needs to be updated
:param trackers: A list of tracker urls
"""
return self.lm.update_trackers(infohash, trackers)
@staticmethod
def create_torrent_file(file_path_list, params=None):
"""
Creates a torrent file.
:param file_path_list: files to add in torrent file
:param params: optional parameters for torrent file
:return: a Deferred that fires when the torrent file has been created
"""
params = params or {}
return threads.deferToThread(torrent_utils.create_torrent_file, file_path_list, params)
def create_channel(self, name, description, mode=u'closed'):
"""
Creates a new Channel.
:param name: name of the Channel
:param description: description of the Channel
:param mode: mode of the Channel ('open', 'semi-open', or 'closed')
:return: a channel ID
:raises a DuplicateChannelIdError if name already exists
"""
return self.lm.channel_manager.create_channel(name, description, mode)
def check_torrent_health(self, infohash, timeout=20, scrape_now=False):
"""
Checks the given torrent's health on its trackers.
:param infohash: the given torrent infohash
:param timeout: time to wait while performing the request
:param scrape_now: flag to scrape immediately
"""
if self.lm.torrent_checker:
return self.lm.torrent_checker.check_torrent_health(infohash, timeout=timeout, scrape_now=scrape_now)
return fail(Failure(RuntimeError("Torrent checker not available")))
def notify_shutdown_state(self, state):
self._logger.info("Tribler shutdown state notification:%s", state)
self.notifier.notify(NTFY_TRIBLER, STATE_SHUTDOWN, None, state)
class TestLaunchManyCore(TriblerCoreTest):
"""
This class contains various small unit tests for the LaunchManyCore class.
"""
DATA_DIR = os.path.join(
os.path.abspath(os.path.dirname(os.path.realpath(__file__))), 'data')
def setUp(self):
TriblerCoreTest.setUp(self)
self.lm = TriblerLaunchMany()
self.lm.session_lock = RLock()
self.lm.session = MockObject()
self.lm.session.config = MockObject()
self.lm.session.config.get_max_upload_rate = lambda: 100
self.lm.session.config.get_max_download_rate = lambda: 100
self.lm.session.config.get_default_number_hops = lambda: 0
# Ignore notifications
mock_notifier = MockObject()
mock_notifier.notify = lambda *_: None
self.lm.session.notifier = mock_notifier
@staticmethod
def create_fake_download_and_state():
"""
Create a fake download and state which can be passed to the global download callback.
"""
tdef = TorrentDef()
tdef.get_infohash = lambda: 'aaaa'
fake_peer = {
'extended_version': 'Tribler',
'id': 'a' * 20,
'dtotal': 10 * 1024 * 1024
}
fake_download = MockObject()
fake_download.get_def = lambda: tdef
fake_download.get_def().get_name_as_unicode = lambda: "test.iso"
fake_download.get_hops = lambda: 0
fake_download.get_safe_seeding = lambda: True
fake_download.get_peerlist = lambda: [fake_peer]
dl_state = MockObject()
dl_state.get_infohash = lambda: 'aaaa'
dl_state.get_status = lambda: DLSTATUS_SEEDING
dl_state.get_download = lambda: fake_download
return fake_download, dl_state
def test_load_download_pstate(self):
"""
Testing whether a pstate is successfully loaded
"""
config_file_path = os.path.abspath(
os.path.join(self.DATA_DIR, u"config_files", u"config1.conf"))
config = self.lm.load_download_pstate(config_file_path)
self.assertIsInstance(config, CallbackConfigParser)
self.assertEqual(config.get('general', 'version'), 11)
@trial_timeout(10)
def test_dlstates_cb_error(self):
"""
Testing whether a download is stopped on error in the download states callback in LaunchManyCore
"""
error_stop_deferred = Deferred()
def mocked_stop():
error_stop_deferred.callback(None)
fake_error_download, fake_error_state = TestLaunchManyCore.create_fake_download_and_state(
)
fake_error_download.stop = mocked_stop
fake_error_state.get_status = lambda: DLSTATUS_STOPPED_ON_ERROR
fake_error_state.get_error = lambda: "test error"
self.lm.downloads = {'aaaa': fake_error_download}
self.lm.sesscb_states_callback([fake_error_state])
return error_stop_deferred
def test_readd_download_safe_seeding(self):
"""
Test whether a download is re-added when doing safe seeding
"""
readd_deferred = Deferred()
def mocked_update_download_hops(*_):
readd_deferred.callback(None)
self.lm.update_download_hops = mocked_update_download_hops
fake_download, dl_state = TestLaunchManyCore.create_fake_download_and_state(
)
self.lm.downloads = {'aaaa': fake_download}
self.lm.sesscb_states_callback([dl_state])
return readd_deferred
def test_update_payout_balance(self):
"""
Test whether the balance of peers is correctly updated
"""
fake_download, dl_state = TestLaunchManyCore.create_fake_download_and_state(
)
dl_state.get_status = lambda: DLSTATUS_DOWNLOADING
fake_tc = MockObject()
fake_tc.add_listener = lambda *_: None
self.lm.payout_manager = PayoutManager(fake_tc, None)
self.lm.state_cb_count = 4
self.lm.downloads = {'aaaa': fake_download}
self.lm.sesscb_states_callback([dl_state])
self.assertTrue(self.lm.payout_manager.tribler_peers)
def test_load_checkpoint(self):
"""
Test whether we are resuming downloads after loading checkpoint
"""
def mocked_resume_download(filename, setupDelay=3):
self.assertTrue(filename.endswith('abcd.state'))
self.assertEqual(setupDelay, 0)
mocked_resume_download.called = True
mocked_resume_download.called = False
self.lm.session.get_downloads_pstate_dir = lambda: self.session_base_dir
with open(
os.path.join(self.lm.session.get_downloads_pstate_dir(),
'abcd.state'), 'wb') as state_file:
state_file.write(b"hi")
self.lm.initComplete = True
self.lm.resume_download = mocked_resume_download
self.lm.load_checkpoint()
self.assertTrue(mocked_resume_download.called)
class Session(SessionRuntimeConfig):
"""
A Session is a running instance of the Tribler Core and the Core's central
class. It implements the SessionConfigInterface which can be used to change
session parameters at runtime (for selected parameters).
cf. libtorrent session
"""
__single = None
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 = 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
# 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
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 methods
#
def get_instance(*args, **kw):
""" Returns the Session singleton if it exists or otherwise
creates it first, in which case you need to pass the constructor
params.
@return Session."""
if Session.__single is None:
Session(*args, **kw)
return Session.__single
get_instance = staticmethod(get_instance)
def has_instance():
return Session.__single != None
has_instance = staticmethod(has_instance)
def del_instance():
Session.__single = None
del_instance = staticmethod(del_instance)
def get_default_state_dir(homedirpostfix=".Tribler"):
""" Returns the factory default directory for storing session state
on the current platform (Win32,Mac,Unix).
@return An absolute path name. """
# Allow override
statedirvar = "${TSTATEDIR}"
statedir = os.path.expandvars(statedirvar)
if statedir and statedir != statedirvar:
return statedir
if os.path.isdir(homedirpostfix):
return os.path.abspath(homedirpostfix)
appdir = get_appstate_dir()
statedir = os.path.join(appdir, homedirpostfix)
return statedir
get_default_state_dir = staticmethod(get_default_state_dir)
#
# Public methods
#
def start_download(self, cdef, dcfg=None, initialdlstatus=None, hidden=False):
"""
Creates a Download object and adds it to the session. The passed
ContentDef and DownloadStartupConfig are copied into the new Download
object. The Download is then started and checkpointed.
If a checkpointed version of the Download is found, that is restarted
overriding the saved DownloadStartupConfig if "dcfg" is not None.
@param cdef A finalized TorrentDef or a SwiftDef
@param dcfg DownloadStartupConfig or None, in which case
a new DownloadStartupConfig() is created with its default settings
and the result becomes the runtime config of this Download.
@param initialdlstatus The initial download status of this Download
or None. This enables the caller to create a Download in e.g.
DLSTATUS_STOPPED state instead.
@param hidden Whether this torrent should be added to the mypreference table
@return Download
"""
# locking by lm
if cdef.get_def_type() == "torrent":
return self.lm.add(cdef, dcfg, initialdlstatus=initialdlstatus, hidden=hidden)
else:
# SWIFTPROC
return self.lm.swift_add(cdef, dcfg, initialdlstatus=initialdlstatus, hidden=hidden)
def resume_download_from_file(self, filename):
"""
Recreates Download from resume file
@return a Download object.
Note: this cannot be made into a method of Download, as the Download
needs to be bound to a session, it cannot exist independently.
"""
raise NotYetImplementedException()
def get_downloads(self):
"""
Returns a copy of the list of Downloads.
@return A list of Download objects.
"""
# locking by lm
return self.lm.get_downloads()
def get_download(self, hash):
"""
Returns the Download object for this hash.
@return A Donwload Object.
"""
# locking by lm
return self.lm.get_download(hash)
def remove_download(self, d, removecontent=False, removestate=True, hidden=False):
"""
Stops the download and removes it from the session.
@param d The Download to remove
@param removecontent Whether to delete the already downloaded content
from disk.
@param removestate Whether to delete the metadata files of the downloaded
content from disk.
@param hidden Whether this torrent is added to the mypreference table and this entry should be
removed
"""
# locking by lm
if d.get_def().get_def_type() == "torrent":
self.lm.remove(d, removecontent=removecontent, removestate=removestate, hidden=hidden)
else:
# SWIFTPROC
self.lm.swift_remove(d, removecontent=removecontent, removestate=removestate, hidden=hidden)
def remove_download_by_id(self, id, removecontent=False, removestate=True):
"""
@param infohash The Download to remove
@param removecontent Whether to delete the already downloaded content
from disk.
!We can only remove content when the download object is found, otherwise only
the state is removed.
"""
downloadList = self.get_downloads()
for download in downloadList:
if download.get_def().get_id() == id:
self.remove_download(download, removecontent, removestate)
return
self.lm.remove_id(id)
self.uch.perform_removestate_callback(id, [], False)
def set_download_states_callback(self, usercallback, getpeerlist=False):
"""
See Download.set_state_callback. Calls usercallback with a list of
DownloadStates, one for each Download in the Session as first argument.
The usercallback must return a tuple (when,getpeerlist) that indicates
when to reinvoke the callback again (as a number of seconds from now,
or < 0.0 if not at all) and whether to also include the details of
the connected peers in the DownloadStates on that next call.
The callback will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
@param usercallback A function adhering to the above spec.
"""
self.lm.set_download_states_callback(usercallback, getpeerlist)
#
# Config parameters that only exist at runtime
#
def get_permid(self):
""" Returns the PermID of the Session, as determined by the
SessionConfig.set_permid() parameter. A PermID is a public key
@return The PermID encoded in a string in DER format. """
self.sesslock.acquire()
try:
return str(self.keypair.pub().get_der())
finally:
self.sesslock.release()
def get_external_ip(self):
""" Returns the external IP address of this Session, i.e., by which
it is reachable from the Internet. This address is determined via
various mechanisms such as the UPnP protocol, our dialback mechanism,
and an inspection of the local network configuration.
@return A string. """
# locking done by lm
return self.lm.get_ext_ip()
def get_externally_reachable(self):
""" Returns whether the Session is externally reachable, i.e., its
listen port is not firewalled. Use add_observer() with NTFY_REACHABLE
to register to the event of detecting reachablility. Note that due to
the use of UPnP a Session may become reachable some time after
startup and due to the Dialback mechanism, this method may return
False while the Session is actually already reachable. Note that True
doesn't mean the Session is reachable from the open Internet, could just
be from the local (otherwise firewalled) LAN.
@return A boolean. """
# Arno, LICHT: make it throw exception when used in LITE versie.
raise NotYetImplementedException()
def get_current_startup_config_copy(self):
""" Returns a SessionStartupConfig that is a copy of the current runtime
SessionConfig.
@return SessionStartupConfig
"""
# Called by any thread
self.sesslock.acquire()
try:
sessconfig = copy.copy(self.sessconfig)
return SessionStartupConfig(sessconfig=sessconfig)
finally:
self.sesslock.release()
#
# Internal tracker
#
def get_internal_tracker_url(self):
""" Returns the announce URL for the internal tracker.
@return URL """
# Called by any thread
self.sesslock.acquire()
try:
url = None
if "tracker_url" in self.sessconfig:
url = self.sessconfig["tracker_url"] # user defined override, e.g. specific hostname
if url is None:
ip = self.lm.get_ext_ip()
port = self.get_listen_port()
url = "http://" + ip + ":" + str(port) + "/announce/"
return url
finally:
self.sesslock.release()
def get_internal_tracker_dir(self):
""" Returns the directory containing the torrents tracked by the internal
tracker (and associated databases).
@return An absolute path. """
# Called by any thread
self.sesslock.acquire()
try:
if self.sessconfig["state_dir"] is None:
return None
else:
return os.path.join(self.sessconfig["state_dir"], STATEDIR_ITRACKER_DIR)
finally:
self.sesslock.release()
def add_to_internal_tracker(self, tdef):
""" Add a torrent def to the list of torrents tracked by the internal
tracker. Use this method to use the Session as a standalone tracker.
@param tdef A finalized TorrentDef.
"""
# Called by any thread
self.sesslock.acquire()
try:
infohash = tdef.get_infohash()
filename = self.get_internal_tracker_torrentfilename(infohash)
tdef.save(filename)
print >>sys.stderr, "Session: add_to_int_tracker: saving to", filename, "url-compat", tdef.get_url_compat()
# Bring to attention of Tracker thread
self.lm.tracker_rescan_dir()
finally:
self.sesslock.release()
def remove_from_internal_tracker(self, tdef):
""" Remove a torrent def from the list of torrents tracked by the
internal tracker. Use this method to use the Session as a standalone
tracker.
@param tdef A finalized TorrentDef.
"""
infohash = tdef.get_infohash()
self.remove_from_internal_tracker_by_infohash(infohash)
def remove_from_internal_tracker_by_infohash(self, infohash):
""" Remove a torrent def from the list of torrents tracked by the
internal tracker. Use this method to use the Session as a standalone
tracker.
@param infohash Identifier of the torrent def to remove.
"""
# Called by any thread
self.sesslock.acquire()
try:
filename = self.get_internal_tracker_torrentfilename(infohash)
if DEBUG:
print >>sys.stderr, "Session: removing itracker entry", filename
if os.access(filename, os.F_OK):
os.remove(filename)
# Bring to attention of Tracker thread
self.lm.tracker_rescan_dir()
finally:
self.sesslock.release()
#
# Notification of events in the Session
#
def add_observer(self, func, subject, changeTypes=[NTFY_UPDATE, NTFY_INSERT, NTFY_DELETE], objectID=None, cache=0):
""" Add an observer function function to the Session. The observer
function will be called when one of the specified events (changeTypes)
occurs on the specified subject.
The function will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
@param func The observer function. It should accept as its first argument
the subject, as second argument the changeType, as third argument an
objectID (e.g. the primary key in the observed database) and an
optional list of arguments.
@param subject The subject to observe, one of NTFY_* subjects (see
simpledefs).
@param changeTypes The list of events to be notified of one of NTFY_*
events.
@param objectID The specific object in the subject to monitor (e.g. a
specific primary key in a database to monitor for updates.)
@param cache The time to bundle/cache events matching this function
TODO: Jelle will add per-subject/event description here ;o)
"""
# Called by any thread
self.uch.notifier.add_observer(func, subject, changeTypes, objectID, cache=cache) # already threadsafe
def remove_observer(self, func):
""" Remove observer function. No more callbacks will be made.
@param func The observer function to remove. """
# Called by any thread
self.uch.notifier.remove_observer(func) # already threadsafe
def open_dbhandler(self, subject):
""" Opens a connection to the specified database. Only the thread
calling this method may use this connection. The connection must be
closed with close_dbhandler() when this thread exits.
@param subject The database to open. Must be one of the subjects
specified here.
@return A reference to a DBHandler class for the specified subject or
None when the Session was not started with megacaches enabled.
<pre> NTFY_PEERS -> PeerDBHandler
NTFY_TORRENTS -> TorrentDBHandler
NTFY_MYPREFERENCES -> MyPreferenceDBHandler
NTFY_VOTECAST -> VotecastDBHandler
NTFY_CHANNELCAST -> ChannelCastDBHandler
</pre>
"""
# Called by any thread
self.sesslock.acquire()
try:
if subject == NTFY_PEERS:
return self.lm.peer_db
elif subject == NTFY_TORRENTS:
return self.lm.torrent_db
elif subject == NTFY_MYPREFERENCES:
return self.lm.mypref_db
elif subject == NTFY_SEEDINGSTATS:
return self.lm.seedingstats_db
elif subject == NTFY_SEEDINGSTATSSETTINGS:
return self.lm.seedingstatssettings_db
elif subject == NTFY_VOTECAST:
return self.lm.votecast_db
elif subject == NTFY_CHANNELCAST:
return self.lm.channelcast_db
else:
raise ValueError("Cannot open DB subject: " + subject)
finally:
self.sesslock.release()
def close_dbhandler(self, dbhandler):
""" Closes the given database connection """
dbhandler.close()
#
# Persistence and shutdown
#
def load_checkpoint(self, initialdlstatus=None, initialdlstatus_dict={}):
""" Restart Downloads from checkpoint, if any.
This method allows the API user to manage restoring downloads.
E.g. a video player that wants to start the torrent the user clicked
on first, and only then restart any sleeping torrents (e.g. seeding).
The optional initialdlstatus parameter can be set to DLSTATUS_STOPPED
to restore all the Downloads in DLSTATUS_STOPPED state.
The options initialdlstatus_dict parameter can be used to specify a
state overriding the initaldlstatus parameter per download id.
"""
self.lm.load_checkpoint(initialdlstatus, initialdlstatus_dict)
def checkpoint(self):
""" Saves the internal session state to the Session's state dir. """
# Called by any thread
self.checkpoint_shutdown(stop=False, checkpoint=True, gracetime=None, hacksessconfcheckpoint=False)
def shutdown(self, checkpoint=True, gracetime=2.0, hacksessconfcheckpoint=True):
""" Checkpoints the session and closes it, stopping the download engine.
@param checkpoint Whether to checkpoint the Session state on shutdown.
@param gracetime Time to allow for graceful shutdown + signoff (seconds).
"""
# Called by any thread
self.lm.early_shutdown()
self.checkpoint_shutdown(
stop=True, checkpoint=checkpoint, gracetime=gracetime, hacksessconfcheckpoint=hacksessconfcheckpoint
)
# Arno, 2010-08-09: now shutdown after gracetime
# self.uch.shutdown()
def has_shutdown(self):
""" Whether the Session has completely shutdown, i.e., its internal
threads are finished and it is safe to quit the process the Session
is running in.
@return A Boolean.
"""
return self.lm.sessdoneflag.isSet()
def get_downloads_pstate_dir(self):
""" Returns the directory in which to checkpoint the Downloads in this
Session. """
# Called by network thread
self.sesslock.acquire()
try:
return os.path.join(self.sessconfig["state_dir"], STATEDIR_DLPSTATE_DIR)
finally:
self.sesslock.release()
def download_torrentfile(self, infohash=None, roothash=None, usercallback=None, prio=0):
""" Try to download the torrentfile without a known source.
A possible source could be the DHT.
If the torrent is succesfully
received, the usercallback method is called with the infohash as first
and the contents of the torrentfile (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
@param infohash The infohash of the torrent.
@param usercallback A function adhering to the above spec.
"""
from Tribler.Core.RemoteTorrentHandler import RemoteTorrentHandler
rtorrent_handler = RemoteTorrentHandler.getInstance()
rtorrent_handler.download_torrent(None, infohash, roothash, usercallback, prio)
def download_torrentfile_from_peer(self, candidate, infohash=None, roothash=None, usercallback=None, prio=0):
""" Ask the designated peer to send us the torrentfile for the torrent
identified by the passed infohash. If the torrent is succesfully
received, the usercallback method is called with the infohash as first
and the contents of the torrentfile (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
@param permid The PermID of the peer to query.
@param infohash The infohash of the torrent.
@param usercallback A function adhering to the above spec.
"""
from Tribler.Core.RemoteTorrentHandler import RemoteTorrentHandler
rtorrent_handler = RemoteTorrentHandler.getInstance()
rtorrent_handler.download_torrent(candidate, infohash, roothash, usercallback, prio)
def download_torrentmessages_from_peer(self, candidate, infohashes, usercallback, prio=0):
""" Ask the designated peer to send us the torrentfile for the torrent
identified by the passed infohash. If the torrent is succesfully
received, the usercallback method is called with the infohash as first
and the contents of the torrentfile (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
@param permid The PermID of the peer to query.
@param infohash The infohash of the torrent.
@param usercallback A function adhering to the above spec.
"""
from Tribler.Core.RemoteTorrentHandler import RemoteTorrentHandler
rtorrent_handler = RemoteTorrentHandler.getInstance()
rtorrent_handler.download_torrentmessages(candidate, infohashes, usercallback, prio)
#
# Internal persistence methods
#
def checkpoint_shutdown(self, stop, checkpoint, gracetime, hacksessconfcheckpoint):
""" Checkpoints the Session and optionally shuts down the Session.
@param stop Whether to shutdown the Session as well.
@param checkpoint Whether to checkpoint at all, or just to stop.
@param gracetime Time to allow for graceful shutdown + signoff (seconds).
"""
# Called by any thread
self.sesslock.acquire()
try:
# Arno: Make checkpoint optional on shutdown. At the moment setting
# the config at runtime is not possible (see SessionRuntimeConfig)
# so this has little use, and interferes with our way of
# changing the startup config, which is to write a new
# config to disk that will be read at start up.
if hacksessconfcheckpoint:
try:
self.save_pstate_sessconfig()
except Exception, e:
self.lm.rawserver_nonfatalerrorfunc(e)
# Checkpoint all Downloads and stop NetworkThread
if DEBUG or stop:
print >>sys.stderr, "Session: checkpoint_shutdown"
self.lm.checkpoint(stop=stop, checkpoint=checkpoint, gracetime=gracetime)
finally:
class Session(SessionRuntimeConfig):
"""
A Session is a running instance of the Tribler Core and the Core's central
class. It implements the SessionConfigInterface which can be used to change
session parameters at runtime (for selected parameters).
cf. libtorrent session
"""
__single = None
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
Tribler.Core.Overlay.permid.init()
#print 'Session: __init__ config is', self.sessconfig
#
# 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 = Tribler.Core.Overlay.permid.read_keypair(
self.sessconfig['eckeypairfilename'])
else:
self.keypair = Tribler.Core.Overlay.permid.generate_keypair()
# Save keypair
pubfilename = os.path.join(self.sessconfig['state_dir'],
'ecpub.pem')
Tribler.Core.Overlay.permid.save_keypair(self.keypair,
pairfilename)
Tribler.Core.Overlay.permid.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
if self.sessconfig['superpeer_file'] is None:
self.sessconfig['superpeer_file'] = os.path.join(
self.sessconfig['install_dir'], 'Tribler', 'Core',
'superpeer.txt')
# 5. download_help_dir
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. NAT type detection
if not 'nat_detect' in self.sessconfig:
# Poor man's versioning, really should update PERSISTENTSTATE_CURRENTVERSION
self.sessconfig['nat_detect'] = sessdefaults['nat_detect']
self.sessconfig['puncturing_private_port'] = sessdefaults[
'puncturing_private_port']
self.sessconfig['stun_servers'] = sessdefaults['stun_servers']
self.sessconfig['puncturing_coordinators'] = sessdefaults[
'puncturing_coordinators']
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']
# 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, self.sesslock)
self.lm.start()
#
# Class methods
#
def get_instance(*args, **kw):
""" Returns the Session singleton if it exists or otherwise
creates it first, in which case you need to pass the constructor
params.
@return Session."""
if Session.__single is None:
Session(*args, **kw)
return Session.__single
get_instance = staticmethod(get_instance)
def get_default_state_dir(homedirpostfix='.Tribler'):
""" Returns the factory default directory for storing session state
on the current platform (Win32,Mac,Unix).
@return An absolute path name. """
homedir = None
if sys.platform == 'win32':
homedirvar = '${APPDATA}'
else:
if sys.platform == 'darwin':
homedirvar = '${HOME}'
# JD wants $HOME/Libray/Preferences/something TODO
#homedirpostfix = os.path.join('Library)
else:
homedirvar = '${HOME}'
# Allow override
overridevar = '${APPDATA}'
homedir = os.path.expandvars(overridevar)
if homedir == overridevar:
# expansion failed
homedir = None
if homedir is None:
homedir = os.path.expandvars(homedirvar)
triblerdir = os.path.join(homedir, homedirpostfix)
return triblerdir
get_default_state_dir = staticmethod(get_default_state_dir)
#
# Public methods
#
def start_download(self, tdef, dcfg=None):
"""
Creates a Download object and adds it to the session. The passed
TorrentDef and DownloadStartupConfig are copied into the new Download
object. The Download is then started and checkpointed.
If a checkpointed version of the Download is found, that is restarted
overriding the saved DownloadStartupConfig is "dcfg" is not None.
@param tdef A finalized TorrentDef
@param dcfg DownloadStartupConfig or None, in which case
a new DownloadStartupConfig() is created with its default settings
and the result becomes the runtime config of this Download.
@return Download
"""
# locking by lm
return self.lm.add(tdef, dcfg)
def resume_download_from_file(self, filename):
"""
Recreates Download from resume file
@return a Download object.
Note: this cannot be made into a method of Download, as the Download
needs to be bound to a session, it cannot exist independently.
"""
raise NotYetImplementedException()
def get_downloads(self):
"""
Returns a copy of the list of Downloads.
@return A list of Download objects.
"""
# locking by lm
return self.lm.get_downloads()
def remove_download(self, d, removecontent=False):
"""
Stops the download and removes it from the session.
@param d The Download to remove
@param removecontent Whether to delete the already downloaded content
from disk.
"""
# locking by lm
self.lm.remove(d, removecontent=removecontent)
def set_download_states_callback(self, usercallback, getpeerlist=False):
"""
See Download.set_state_callback. Calls usercallback with a list of
DownloadStates, one for each Download in the Session as first argument.
The usercallback must return a tuple (when,getpeerlist) that indicates
when to reinvoke the callback again (as a number of seconds from now,
or < 0.0 if not at all) and whether to also include the details of
the connected peers in the DownloadStates on that next call.
The callback will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
@param usercallback A function adhering to the above spec.
"""
self.lm.set_download_states_callback(usercallback, getpeerlist)
#
# Config parameters that only exist at runtime
#
def get_permid(self):
""" Returns the PermID of the Session, as determined by the
SessionConfig.set_permid() parameter. A PermID is a public key
@return The PermID encoded in a string in DER format. """
self.sesslock.acquire()
try:
return str(self.keypair.pub().get_der())
finally:
self.sesslock.release()
def get_external_ip(self):
""" Returns the external IP address of this Session, i.e., by which
it is reachable from the Internet. This address is determined via
various mechanisms such as the UPnP protocol, our dialback mechanism,
and an inspection of the local network configuration.
@return A string. """
# locking done by lm
return self.lm.get_ext_ip()
def get_current_startup_config_copy(self):
""" Returns a SessionStartupConfig that is a copy of the current runtime
SessionConfig.
@return SessionStartupConfig
"""
# Called by any thread
self.sesslock.acquire()
try:
sessconfig = copy.copy(self.sessconfig)
return SessionStartupConfig(sessconfig=sessconfig)
finally:
self.sesslock.release()
#
# Internal tracker
#
def get_internal_tracker_url(self):
""" Returns the announce URL for the internal tracker.
@return URL """
# Called by any thread
self.sesslock.acquire()
try:
url = None
if 'tracker_url' in self.sessconfig:
url = self.sessconfig[
'tracker_url'] # user defined override, e.g. specific hostname
if url is None:
ip = self.lm.get_ext_ip()
port = self.get_listen_port()
url = 'http://' + ip + ':' + str(port) + '/announce/'
return url
finally:
self.sesslock.release()
def get_internal_tracker_dir(self):
""" Returns the directory containing the torrents tracked by the internal
tracker (and associated databases).
@return An absolute path. """
# Called by any thread
self.sesslock.acquire()
try:
if self.sessconfig['state_dir'] is None:
return None
else:
return os.path.join(self.sessconfig['state_dir'],
STATEDIR_ITRACKER_DIR)
finally:
self.sesslock.release()
def add_to_internal_tracker(self, tdef):
""" Add a torrent def to the list of torrents tracked by the internal
tracker. Use this method to use the Session as a standalone tracker.
@param tdef A finalized TorrentDef.
"""
# Called by any thread
self.sesslock.acquire()
try:
infohash = tdef.get_infohash()
filename = self.get_internal_tracker_torrentfilename(infohash)
tdef.save(filename)
# Bring to attention of Tracker thread
self.lm.tracker_rescan_dir()
finally:
self.sesslock.release()
def remove_from_internal_tracker(self, tdef):
""" Remove a torrent def from the list of torrents tracked by the
internal tracker. Use this method to use the Session as a standalone
tracker.
@param tdef A finalized TorrentDef.
"""
infohash = tdef.get_infohash()
self.remove_from_internal_tracker_by_infohash(infohash)
def remove_from_internal_tracker_by_infohash(self, infohash):
""" Remove a torrent def from the list of torrents tracked by the
internal tracker. Use this method to use the Session as a standalone
tracker.
@param infohash Identifier of the torrent def to remove.
"""
# Called by any thread
self.sesslock.acquire()
try:
filename = self.get_internal_tracker_torrentfilename(infohash)
if DEBUG:
print >> sys.stderr, "Session: removing itracker entry", filename
if os.access(filename, os.F_OK):
os.remove(filename)
# Bring to attention of Tracker thread
self.lm.tracker_rescan_dir()
finally:
self.sesslock.release()
#
# Notification of events in the Session
#
def add_observer(self,
func,
subject,
changeTypes=[NTFY_UPDATE, NTFY_INSERT, NTFY_DELETE],
objectID=None):
""" Add an observer function function to the Session. The observer
function will be called when one of the specified events (changeTypes)
occurs on the specified subject.
The function will be called by a popup thread which can be used
indefinitely (within reason) by the higher level code.
@param func The observer function. It should accept as its first argument
the subject, as second argument the changeType, as third argument an
objectID (e.g. the primary key in the observed database) and an
optional list of arguments.
@param subject The subject to observe, one of NTFY_* subjects (see
simpledefs).
@param changeTypes The list of events to be notified of one of NTFY_*
events.
@param objectID The specific object in the subject to monitor (e.g. a
specific primary key in a database to monitor for updates.)
TODO: Jelle will add per-subject/event description here ;o)
"""
#Called by any thread
self.uch.notifier.add_observer(func, subject, changeTypes,
objectID) # already threadsafe
def remove_observer(self, func):
""" Remove observer function. No more callbacks will be made.
@param func The observer function to remove. """
#Called by any thread
self.uch.notifier.remove_observer(func) # already threadsafe
def open_dbhandler(self, subject):
""" Opens a connection to the specified database. Only the thread
calling this method may use this connection. The connection must be
closed with close_dbhandler() when this thread exits.
@param subject The database to open. Must be one of the subjects
specified here.
@return A reference to a DBHandler class for the specified subject or
None when the Session was not started with megacaches enabled.
<pre> NTFY_PEERS -> PeerDBHandler
NTFY_TORRENTS -> TorrentDBHandler
NTFY_PREFERENCES -> PreferenceDBHandler
NTFY_SUPERPEERS -> SuperpeerDBHandler
NTFY_FRIENDS -> FriendsDBHandler
NTFY_MYPREFERENCES -> MyPreferenceDBHandler
NTFY_BARTERCAST -> BartercastDBHandler
</pre>
"""
# Called by any thread
self.sesslock.acquire()
try:
if subject == NTFY_PEERS:
return self.lm.peer_db
elif subject == NTFY_TORRENTS:
return self.lm.torrent_db
elif subject == NTFY_PREFERENCES:
return self.lm.pref_db
elif subject == NTFY_SUPERPEERS:
return self.lm.superpeer_db
elif subject == NTFY_FRIENDS:
return self.lm.friend_db
elif subject == NTFY_MYPREFERENCES:
return self.lm.mypref_db
elif subject == NTFY_BARTERCAST:
return self.lm.bartercast_db
else:
raise ValueError('Cannot open DB subject: ' + subject)
finally:
self.sesslock.release()
def close_dbhandler(self, dbhandler):
""" Closes the given database connection """
dbhandler.close()
#
# Access control
#
def set_overlay_request_policy(self, reqpol):
"""
Set a function which defines which overlay requests (e.g. dl_helper, rquery msg)
will be answered or will be denied.
The function will be called by a network thread and must return
as soon as possible to prevent performance problems.
@param reqpol is a Tribler.Core.RequestPolicy.AbstractRequestPolicy
object.
"""
# Called by any thread
# to protect self.sessconfig
self.sesslock.acquire()
try:
overlay_loaded = self.sessconfig['overlay']
finally:
self.sesslock.release()
if overlay_loaded:
self.lm.overlay_apps.setRequestPolicy(reqpol) # already threadsafe
elif DEBUG:
print >> sys.stderr, "Session: overlay is disabled, so no overlay request policy needed"
#
# Persistence and shutdown
#
def load_checkpoint(self, initialdlstatus=None):
""" Restart Downloads from checkpoint, if any.
This method allows the API user to manage restoring downloads.
E.g. a video player that wants to start the torrent the user clicked
on first, and only then restart any sleeping torrents (e.g. seeding).
The optional initialdlstatus parameter can be set to DLSTATUS_STOPPED
to restore all the Downloads in DLSTATUS_STOPPED state.
"""
self.lm.load_checkpoint(initialdlstatus)
def checkpoint(self):
""" Saves the internal session state to the Session's state dir. """
#Called by any thread
self.checkpoint_shutdown(stop=False)
def shutdown(self, checkpoint=True, hacksessconfcheckpoint=True):
""" Checkpoints the session and closes it, stopping the download engine.
@param checkpoint Whether to checkpoint the Session state on shutdown.
"""
# Called by any thread
self.checkpoint_shutdown(stop=True,
checkpoint=checkpoint,
hacksessconfcheckpoint=hacksessconfcheckpoint)
self.uch.shutdown()
def get_downloads_pstate_dir(self):
""" Returns the directory in which to checkpoint the Downloads in this
Session. """
# Called by network thread
self.sesslock.acquire()
try:
return os.path.join(self.sessconfig['state_dir'],
STATEDIR_DLPSTATE_DIR)
finally:
self.sesslock.release()
#
# Tribler Core special features
#
def query_connected_peers(self,
query,
usercallback,
max_peers_to_query=None):
""" Ask all Tribler peers we're currently connected to resolve the
specified query and return the hits. For each peer that returns
hits the usercallback method is called with first parameter the
permid of the peer, as second parameter the query string and
as third parameter a dictionary of hits. The number of times the
usercallback method will be called is undefined.
At the moment we support one type of query, which is a query for
torrent files that match a set of keywords. The format of the
query string is "SIMPLE kw1 kw2 kw3". In the future we plan
to support full SQL queries.
For SIMPLE queries the dictionary of hits consists of
(infohash,torrentrecord) pairs. The torrentrecord is a
dictionary that contains the following keys:
<pre>
* 'content_name': The 'name' field of the torrent.
* 'length': The total size of the content in the torrent.
* 'leecher': The currently known number of downloaders.
* 'seeder': The currently known number of seeders.
* 'category': A list of category strings the torrent was classified into
by the remote peer.
</pre>
@param query A Unicode query string adhering to the above spec.
@param usercallback A function adhering to the above spec.
"""
self.sesslock.acquire()
try:
if self.sessconfig['overlay']:
if not query.startswith('SIMPLE '):
raise ValueError('Query does start with SIMPLE')
kws = query[len('SIMPLE '):]
rqmh = RemoteQueryMsgHandler.getInstance()
rqmh.send_query(kws,
usercallback,
max_nqueries=max_peers_to_query)
else:
raise OperationNotEnabledByConfigurationException(
"Overlay not enabled")
finally:
self.sesslock.release()
def download_torrentfile_from_peer(self, permid, infohash, usercallback):
""" Ask the designated peer to send us the torrentfile for the torrent
identified by the passed infohash. If the torrent is succesfully
received, the usercallback method is called with the infohash as first
and the contents of the torrentfile (bencoded dict) as second parameter.
If the torrent could not be obtained, the callback is not called.
The torrent will have been added to the TorrentDBHandler (if enabled)
at the time of the call.
@param permid The PermID of the peer to query.
@param infohash The infohash of the torrent.
@param usercallback A function adhering to the above spec.
"""
self.sesslock.acquire()
try:
if self.sessconfig['overlay']:
rtorrent_handler = RemoteTorrentHandler.getInstance()
rtorrent_handler.download_torrent(permid, infohash,
usercallback)
else:
raise OperationNotEnabledByConfigurationException(
"Overlay not enabled")
finally:
self.sesslock.release()
#
# Internal persistence methods
#
def checkpoint_shutdown(self, stop, checkpoint, hacksessconfcheckpoint):
""" Checkpoints the Session and optionally shuts down the Session.
@param stop Whether to shutdown the Session as well.
@param checkpoint Whether to checkpoint at all, or just to stop. """
# Called by any thread
self.sesslock.acquire()
try:
# Arno: Make checkpoint optional on shutdown. At the moment setting
# the config at runtime is not possible (see SessionRuntimeConfig)
# so this has little use, and interferes with our way of
# changing the startup config, which is to write a new
# config to disk that will be read at start up.
if hacksessconfcheckpoint:
try:
self.save_pstate_sessconfig()
except Exception, e:
self.lm.rawserver_nonfatalerrorfunc(e)
# Checkpoint all Downloads and stop NetworkThread
if DEBUG:
print >> sys.stderr, "Session: checkpoint_shutdown"
self.lm.checkpoint(stop=stop, checkpoint=checkpoint)
finally:
def __init__(self, scfg=None, ignore_singleton=False, autoload_discovery=True):
"""
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._logger = logging.getLogger(self.__class__.__name__)
self.ignore_singleton = ignore_singleton
self.sesslock = NoDispersyRLock()
# Determine startup config to use
if scfg is None: # If no override
scfg = SessionStartupConfig.load()
else: # overrides any saved config
# Work from copy
scfg = SessionStartupConfig(copy.copy(scfg.sessconfig))
def create_dir(fullpath):
if not os.path.isdir(fullpath):
os.makedirs(fullpath)
def set_and_create_dir(dirname, setter, default_dir):
if dirname is None:
setter(default_dir)
create_dir(dirname or default_dir)
state_dir = scfg.get_state_dir()
set_and_create_dir(state_dir, scfg.set_state_dir, state_dir)
set_and_create_dir(scfg.get_torrent_store_dir(),
scfg.set_torrent_store_dir,
os.path.join(scfg.get_state_dir(), STATEDIR_TORRENT_STORE_DIR))
# metadata store
set_and_create_dir(scfg.get_metadata_store_dir(),
scfg.set_metadata_store_dir,
os.path.join(scfg.get_state_dir(), STATEDIR_METADATA_STORE_DIR))
set_and_create_dir(scfg.get_peer_icon_path(), scfg.set_peer_icon_path,
os.path.join(scfg.get_state_dir(), STATEDIR_PEERICON_DIR))
create_dir(os.path.join(scfg.get_state_dir(), u"sqlite"))
create_dir(os.path.join(scfg.get_state_dir(), STATEDIR_DLPSTATE_DIR))
# Reset the nickname to something not related to the host name, it was
# really silly to have this default on the first place.
# TODO: Maybe move this to the upgrader?
if socket.gethostname() in scfg.get_nickname():
scfg.set_nickname("Tribler user")
if GOTM2CRYPTO:
permidmod.init()
# Set params that depend on state_dir
#
# 1. keypair
#
pairfilename = scfg.get_permid_keypair_filename()
if os.access(pairfilename, os.F_OK):
# May throw exceptions
self.keypair = permidmod.read_keypair(pairfilename)
else:
self.keypair = permidmod.generate_keypair()
# Save keypair
pubfilename = os.path.join(scfg.get_state_dir(), 'ecpub.pem')
permidmod.save_keypair(self.keypair, pairfilename)
permidmod.save_pub_key(self.keypair, pubfilename)
if not scfg.get_megacache():
scfg.set_torrent_checking(0)
self.sessconfig = scfg.sessconfig
self.sessconfig.lock = self.sesslock
self.selected_ports = scfg.selected_ports
# Claim all random ports
self.get_listen_port()
self.get_dispersy_port()
self.get_mainline_dht_listen_port()
self.get_videoplayer_port()
self.get_anon_listen_port()
self.get_tunnel_community_socks5_listen_ports()
# Create handler for calling back the user via separate threads
self.lm = TriblerLaunchMany()
self.notifier = Notifier(use_pool=True)
# Checkpoint startup config
self.save_pstate_sessconfig()
self.sqlite_db = None
self.autoload_discovery = autoload_discovery
