Coverage for deluge/core/core: 49%

100

101

102

103

# -*- coding: utf-8 -*-

# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with

# the additional special exception to link portions of this program with the OpenSSL library.

# See LICENSE for more details.

import base64

import glob

import logging

import os

import shutil

import tempfile

import threading

from urlparse import urljoin

import twisted.web.client

import twisted.web.error

from twisted.internet import reactor, task

import deluge.common

import deluge.component as component

from deluge import path_chooser_common

from deluge._libtorrent import lt

from deluge.configmanager import ConfigManager, get_config_dir

from deluge.core.alertmanager import AlertManager

from deluge.core.authmanager import (AUTH_LEVEL_ADMIN, AUTH_LEVEL_NONE, AUTH_LEVELS_MAPPING,

AUTH_LEVELS_MAPPING_REVERSE, AuthManager)

from deluge.core.eventmanager import EventManager

from deluge.core.filtermanager import FilterManager

from deluge.core.pluginmanager import PluginManager

from deluge.core.preferencesmanager import PreferencesManager

from deluge.core.rpcserver import export

from deluge.core.torrentmanager import TorrentManager

from deluge.error import DelugeError, InvalidPathError, InvalidTorrentError

from deluge.event import NewVersionAvailableEvent, SessionPausedEvent, SessionResumedEvent, TorrentQueueChangedEvent

from deluge.httpdownloader import download_file

log = logging.getLogger(__name__)

class Core(component.Component):

def __init__(self, listen_interface=None):

log.debug("Core init...")

component.Component.__init__(self, "Core")

# Create the client fingerprint

client_id = "DE"

client_version = deluge.common.VersionSplit(deluge.common.get_version()).version

while len(client_version) < 4:

client_version.append(0)

# Start the libtorrent session

log.info("Starting libtorrent %s (%s, %s) session...", lt.version, client_id, client_version)

self.session = lt.session(lt.fingerprint(client_id, *client_version), flags=0)

# Load the session state if available

self.__load_session_state()

# --- Set session settings ---

settings = self.session.get_settings()

settings["user_agent"] = "Deluge/%(deluge_version)s libtorrent/%(lt_version)s" % {

'deluge_version': deluge.common.get_version(),

'lt_version': self.get_libtorrent_version().rpartition(".")[0]

}

# No SSL torrent support in code so disable the listen port.

settings["ssl_listen"] = 0

# On Windows OS set the disk I/O read/write to bypass OS cache

73 if deluge.common.windows_check():

settings["disk_io_write_mode"] = lt.io_buffer_mode_t.disable_os_cache

settings["disk_io_read_mode"] = lt.io_buffer_mode_t.disable_os_cache

self.session.set_settings(settings)

# --- libtorrent plugins ---

# Allows peers to download the metadata from the swarm directly

self.session.add_extension("metadata_transfer")

self.session.add_extension("ut_metadata")

# Ban peers that sends bad data

self.session.add_extension("smart_ban")

# Create the components

self.eventmanager = EventManager()

self.preferencesmanager = PreferencesManager()

self.alertmanager = AlertManager()

self.pluginmanager = PluginManager(self)

self.torrentmanager = TorrentManager()

self.filtermanager = FilterManager(self)

self.authmanager = AuthManager()

# New release check information

self.new_release = None

# Get the core config

self.config = ConfigManager("core.conf")

self.config.save()

# If there was an interface value from the command line, use it, but

# store the one in the config so we can restore it on shutdown

self.__old_interface = None

104 if listen_interface:

if deluge.common.is_ip(listen_interface):

self.__old_interface = self.config["listen_interface"]

self.config["listen_interface"] = listen_interface

else:

log.error("Invalid listen interface (must be IP Address): %s", listen_interface)

def start(self):

"""Starts the core"""

# New release check information

self.__new_release = None

def stop(self):

log.debug("Core stopping...")

# Save the libtorrent session state

self.__save_session_state()

# We stored a copy of the old interface value

123 if self.__old_interface:

self.config["listen_interface"] = self.__old_interface

# Make sure the config file has been saved

self.config.save()

def shutdown(self):

pass

def __save_session_state(self):

"""Saves the libtorrent session state"""

filename = "session.state"

filepath = get_config_dir(filename)

filepath_bak = filepath + ".bak"

filepath_tmp = filepath + ".tmp"

try:

140 if os.path.isfile(filepath):

log.debug("Creating backup of %s at: %s", filename, filepath_bak)

shutil.copy2(filepath, filepath_bak)

except IOError as ex:

log.error("Unable to backup %s to %s: %s", filepath, filepath_bak, ex)

else:

log.info("Saving the %s at: %s", filename, filepath)

try:

with open(filepath_tmp, "wb") as _file:

_file.write(lt.bencode(self.session.save_state()))

_file.flush()

152 os.fsync(_file.fileno())

shutil.move(filepath_tmp, filepath)

except (IOError, EOFError) as ex:

log.error("Unable to save %s: %s", filename, ex)

if os.path.isfile(filepath_bak):

log.info("Restoring backup of %s from: %s", filename, filepath_bak)

shutil.move(filepath_bak, filepath)

def __load_session_state(self):

"""Loads the libtorrent session state"""

filename = "session.state"

filepath = get_config_dir(filename)

filepath_bak = filepath + ".bak"

for _filepath in (filepath, filepath_bak):

log.info("Opening %s for load: %s", filename, _filepath)

try:

with open(_filepath, "rb") as _file:

state = lt.bdecode(_file.read())

except (IOError, EOFError, RuntimeError) as ex:

log.warning("Unable to load %s: %s", _filepath, ex)

else:

log.info("Successfully loaded %s: %s", filename, _filepath)

self.session.load_state(state)

return

def get_new_release(self):

log.debug("get_new_release")

from urllib2 import urlopen, URLError

try:

self.new_release = urlopen("http://download.deluge-torrent.org/version-1.0").read().strip()

except URLError as ex:

log.debug("Unable to get release info from website: %s", ex)

return

self.check_new_release()

def check_new_release(self):

if self.new_release:

log.debug("new_release: %s", self.new_release)

if deluge.common.VersionSplit(self.new_release) > deluge.common.VersionSplit(deluge.common.get_version()):

component.get("EventManager").emit(NewVersionAvailableEvent(self.new_release))

return self.new_release

return False

# Exported Methods

@export

def add_torrent_file(self, filename, filedump, options):

"""Adds a torrent file to the session.

Args:

filename (str): the filename of the torrent

filedump (str): A base64 encoded string of the torrent file contents

options (dict): The options to apply to the torrent on add

Returns:

str: The torrent_id or None

"""

try:

filedump = base64.decodestring(filedump)

except Exception as ex:

log.error("There was an error decoding the filedump string!")

log.exception(ex)

try:

torrent_id = self.torrentmanager.add(

filedump=filedump, options=options, filename=filename

)

except Exception as ex:

log.error("There was an error adding the torrent file %s", filename)

log.exception(ex)

torrent_id = None

return torrent_id

@export

def add_torrent_url(self, url, options, headers=None):

"""

Adds a torrent from a url. Deluge will attempt to fetch the torrent

from url prior to adding it to the session.

:param url: the url pointing to the torrent file

:type url: string

:param options: the options to apply to the torrent on add

:type options: dict

:param headers: any optional headers to send

:type headers: dict

:returns: a Deferred which returns the torrent_id as a str or None

"""

log.info("Attempting to add url %s", url)

def on_download_success(filename):

# We got the file, so add it to the session

f = open(filename, "rb")

data = f.read()

f.close()

try:

os.remove(filename)

except OSError as ex:

log.warning("Couldn't remove temp file: %s", ex)

return self.add_torrent_file(filename, base64.encodestring(data), options)

def on_download_fail(failure):

if failure.check(twisted.web.error.PageRedirect):

new_url = urljoin(url, failure.getErrorMessage().split(" to ")[1])

result = download_file(

new_url, tempfile.mkstemp()[1], headers=headers,

force_filename=True

)

result.addCallbacks(on_download_success, on_download_fail)

262 elif failure.check(twisted.web.client.PartialDownloadError):

result = download_file(

url, tempfile.mkstemp()[1], headers=headers,

force_filename=True, allow_compression=False

)

result.addCallbacks(on_download_success, on_download_fail)

else:

# Log the error and pass the failure onto the client

log.error("Error occurred downloading torrent from %s", url)

log.error("Reason: %s", failure.getErrorMessage())

result = failure

return result

d = download_file(

url, tempfile.mkstemp()[1], headers=headers, force_filename=True

)

d.addCallbacks(on_download_success, on_download_fail)

return d

@export

def add_torrent_magnet(self, uri, options):

"""

Adds a torrent from a magnet link.

:param uri: the magnet link

:type uri: string

:param options: the options to apply to the torrent on add

:type options: dict

:returns: the torrent_id

:rtype: string

"""

log.debug("Attempting to add by magnet uri: %s", uri)

return self.torrentmanager.add(magnet=uri, options=options)

@export

def remove_torrent(self, torrent_id, remove_data):

"""Removes a torrent from the session.

Args:

torrent_id (str): The torrent ID to remove

remove_data (bool): If True, remove the downloaded data.

Returns:

bool: True if removed successfully

Raises:

InvalidTorrentError: if the torrent_id does not exist in the session

"""

log.debug("Removing torrent %s from the core.", torrent_id)

return self.torrentmanager.remove(torrent_id, remove_data)

@export

def remove_torrents(self, torrent_ids, remove_data):

"""Remove torrents from the session.

Args:

torrent_ids (list): The torrent IDs to remove

remove_data (bool, optional): If True, remove the downloaded data, defaults to False.

defer (bool): if True, do task.deferLater on the function that removes the torrents.

Returns:

list: a list containing all the errors, empty list if no errors occured

"""

log.info("Removing %d torrents from core.", len(torrent_ids))

def do_remove_torrents():

errors = []

for torrent_id in torrent_ids:

try:

self.torrentmanager.remove(torrent_id, remove_data=remove_data, save_state=False)

except InvalidTorrentError, ite:

errors.append((torrent_id, ite))

# Save the session state

self.torrentmanager.save_state()

return errors

return task.deferLater(reactor, 0, do_remove_torrents)

@export

def get_session_status(self, keys):

"""

Gets the session status values for 'keys', these keys are taking

from libtorrent's session status.

See: http://www.rasterbar.com/products/libtorrent/manual.html#status

:param keys: the keys for which we want values

:type keys: list

:returns: a dictionary of {key: value, ...}

:rtype: dict

"""

status = {}

session_status = self.session.status()

for key in keys:

status[key] = getattr(session_status, key)

return status

@export

def get_cache_status(self):

"""

Returns a dictionary of the session's cache status.

:returns: the cache status

:rtype: dict

"""

status = self.session.get_cache_status()

cache = {}

for attr in dir(status):

if attr.startswith("_"):

continue

cache[attr] = getattr(status, attr)

# Add in a couple ratios

try:

cache["write_hit_ratio"] = float((cache["blocks_written"] -

cache["writes"])) / float(cache["blocks_written"])

except ZeroDivisionError:

cache["write_hit_ratio"] = 0.0

try:

cache["read_hit_ratio"] = float(cache["blocks_read_hit"]) / float(cache["blocks_read"])

except ZeroDivisionError:

cache["read_hit_ratio"] = 0.0

return cache

@export

def force_reannounce(self, torrent_ids):

log.debug("Forcing reannouncment to: %s", torrent_ids)

for torrent_id in torrent_ids:

self.torrentmanager[torrent_id].force_reannounce()

@export

def pause_torrent(self, torrent_ids):

log.debug("Pausing: %s", torrent_ids)

for torrent_id in torrent_ids:

if not self.torrentmanager[torrent_id].pause():

log.warning("Error pausing torrent %s", torrent_id)

@export

def connect_peer(self, torrent_id, ip, port):

log.debug("adding peer %s to %s", ip, torrent_id)

if not self.torrentmanager[torrent_id].connect_peer(ip, port):

log.warning("Error adding peer %s:%s to %s", ip, port, torrent_id)

@export

def move_storage(self, torrent_ids, dest):

log.debug("Moving storage %s to %s", torrent_ids, dest)

for torrent_id in torrent_ids:

if not self.torrentmanager[torrent_id].move_storage(dest):

log.warning("Error moving torrent %s to %s", torrent_id, dest)

@export

def pause_session(self):

"""Pause all torrents in the session"""

if not self.session.is_paused():

self.session.pause()

component.get("EventManager").emit(SessionPausedEvent())

@export

def resume_session(self):

"""Resume all torrents in the session"""

if self.session.is_paused():

self.session.resume()

component.get("EventManager").emit(SessionResumedEvent())

@export

def resume_torrent(self, torrent_ids):

log.debug("Resuming: %s", torrent_ids)

for torrent_id in torrent_ids:

self.torrentmanager[torrent_id].resume()

def create_torrent_status(self, torrent_id, torrent_keys, plugin_keys, diff=False, update=False, all_keys=False):

try:

status = self.torrentmanager[torrent_id].get_status(torrent_keys, diff, update=update, all_keys=all_keys)

except KeyError:

import traceback

traceback.print_exc()

# Torrent was probaly removed meanwhile

return {}

# Ask the plugin manager to fill in the plugin keys

if len(plugin_keys) > 0:

status.update(self.pluginmanager.get_status(torrent_id, plugin_keys))

return status

@export

def get_torrent_status(self, torrent_id, keys, diff=False):

torrent_keys, plugin_keys = self.torrentmanager.separate_keys(keys, [torrent_id])

return self.create_torrent_status(torrent_id, torrent_keys, plugin_keys, diff=diff, update=True,

all_keys=not keys)

@export

def get_torrents_status(self, filter_dict, keys, diff=False):

"""

returns all torrents , optionally filtered by filter_dict.

"""

torrent_ids = self.filtermanager.filter_torrent_ids(filter_dict)

d = self.torrentmanager.torrents_status_update(torrent_ids, keys, diff=diff)

def add_plugin_fields(args):

status_dict, plugin_keys = args

# Ask the plugin manager to fill in the plugin keys

if len(plugin_keys) > 0:

for key in status_dict.keys():

status_dict[key].update(self.pluginmanager.get_status(key, plugin_keys))

return status_dict

d.addCallback(add_plugin_fields)

return d

@export

def get_filter_tree(self, show_zero_hits=True, hide_cat=None):

"""

returns {field: [(value,count)] }

for use in sidebar(s)

"""

return self.filtermanager.get_filter_tree(show_zero_hits, hide_cat)

@export

def get_session_state(self):

"""Returns a list of torrent_ids in the session."""

# Get the torrent list from the TorrentManager

return self.torrentmanager.get_torrent_list()

@export

def get_config(self):

"""Get all the preferences as a dictionary"""

return self.config.config

@export

def get_config_value(self, key):

"""Get the config value for key"""

return self.config.get(key)

@export

def get_config_values(self, keys):

"""Get the config values for the entered keys"""

return dict((key, self.config.get(key)) for key in keys)

@export

def set_config(self, config):

"""Set the config with values from dictionary"""

# Load all the values into the configuration

for key in config.keys():

if isinstance(config[key], basestring):

config[key] = config[key].encode("utf8")

self.config[key] = config[key]

@export

def get_listen_port(self):

"""Returns the active listen port"""

return self.session.listen_port()

@export

def get_i2p_proxy(self):

"""Returns the active listen port"""

i2p_settings = self.session.i2p_proxy()

i2p_dict = {"hostname": i2p_settings.hostname, "port": i2p_settings.port}

return i2p_dict

@export

def get_proxy(self):

"""Returns the active listen port"""

proxy_settings = self.session.proxy()

proxy_dict = {

"type": int(proxy_settings.type),

"hostname": proxy_settings.hostname,

"username": proxy_settings.username,

"password": proxy_settings.password,

"port": proxy_settings.port,

"proxy_hostnames": proxy_settings.proxy_hostnames,

"proxy_peer_connections": proxy_settings.proxy_peer_connections

}

return proxy_dict

@export

def get_available_plugins(self):

"""Returns a list of plugins available in the core"""

return self.pluginmanager.get_available_plugins()

@export

def get_enabled_plugins(self):

"""Returns a list of enabled plugins in the core"""

return self.pluginmanager.get_enabled_plugins()

@export

def enable_plugin(self, plugin):

self.pluginmanager.enable_plugin(plugin)

return None

@export

def disable_plugin(self, plugin):

self.pluginmanager.disable_plugin(plugin)

return None

@export

def force_recheck(self, torrent_ids):

"""Forces a data recheck on torrent_ids"""

for torrent_id in torrent_ids:

self.torrentmanager[torrent_id].force_recheck()

@export

def set_torrent_options(self, torrent_ids, options):

"""Sets the torrent options for torrent_ids"""

for torrent_id in torrent_ids:

self.torrentmanager[torrent_id].set_options(options)

@export

def set_torrent_trackers(self, torrent_id, trackers):

"""Sets a torrents tracker list. trackers will be [{"url", "tier"}]"""

return self.torrentmanager[torrent_id].set_trackers(trackers)

@export

def set_torrent_max_connections(self, torrent_id, value):