Add my name to author list

Adds `sanitize_filepath` for use before passing to libtorrent rename_file

.gitignore

@@ -7,3 +7,5 @@ dist
 *.pyc
 *.tar.*
 _trial_temp
+deluge/i18n/*
+*.desktop

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "libtorrent"]
-	path = libtorrent
-	url = git://deluge-torrent.org/libtorrent

ChangeLog

@@ -1,4 +1,161 @@
-=== Deluge 1.3.0 (In Development) ===
+=== Deluge 1.3.3 (22 July 2011) ===
+==== Core ====
+	* Properly show the 'Checking Resume Data' state instead of just 7
+	* #1788: Added ability to use XDG_DOWNLOAD_DIR as default download folder
+	* Fix path error with torrent files prefixed with 'file://' from Firefox
+	* #1869: Fix setting the disk io read/write to bypass OS cache in Windows
+	* #1504: Fix win32 running deluged as not logged in user via runas or service
+	* #890: If added torrent already exists, append extra trackers to it
+	* #1338: Fix Seeds and Peers totals not updating
+	* #1239: Fix translated Tracker Error text not counted in sidebar Error status
+	* Fix httpdownloader error with existing filename
+	* #1505: Add libtorrent info to version output
+	* #1637 Fix UnicodeDecodeError from 'deluge-* --help' with non-english languages
+	* #1714 Fix handling of backslashes when renaming files/folders
+
+==== GtkUI ====
+	* Show the checking icon for torrents in the 'Checking Resume Data' state
+	* #1195: Fix right-click selecting issue when switching between folders and files
+	* Add F2 key shortcut for renaming filenames in the Files Tab
+	* Increase max piece size to 16 MiB in create torrent dialog
+	* #1475: Fix save and restore Preferences dialog size from config
+	* Add search as you type to the torrent view
+	* #1456: Fix no ETA showing with multiple files
+	* #1560: Fix FilesTab Progress value sorting by int instead of float
+	* #1263: Fix not remembering column widths
+	* #948: New Release Dialog now shows the server version
+	* Fix peers in PeersTab showing non-zero download rate when seeding
+
+=== AutoAdd ===
+	* #1861: Fix AutoAdd Warning (column number is a boolean)
+
+=== Label ===
+	* #1246: Fix losing Labels upon restart
+
+=== Execute ===
+	* #1477: Fix ignore Added events from state file on startup
+
+==== ConsoleUI ====
+	* #1258: Add support for urls and magnet uris in add command
+	* #1801: Fix unhandled defered error and missing error message upon failed connect
+
+=== Deluge 1.3.2 (24 May 2011) ===
+==== Core ====
+	* #1527: Fix Converting unicode to unicode error in move_storage
+	* #1373: Fix creating and moving non-ascii folder names in MS Windows
+	* #1507: Fix temporary file race condition in core/core.py:add_torrent_url
+	* Fix a bug that can occur when upgrading 1.1 config files
+	* #1517: Fix isohunt urls not loading
+	* Handle redirection when adding a torrent by url
+	* #1614: Fix autoadd matching a directory called "torrent"
+	* #1742: Fix failure in Event handler prevents further emissions
+
+==== GtkUI ====
+	* #1514: Added Indicator Applet
+	* #1494: Add torrent columns Downloaded and Uploaded
+	* #1308: Add torrent column Seeds/Peers ratio
+	* #1646: Add torrent columns for per torrent upload and download speed limits
+	* Add missing icons for Trackers filter
+	* Fix inconsistancies in the text for translation
+	* #1510: Fix cannot create a torrent with only non-zero tier trackers
+	* #1513: Fix unhandled Twisted Error in test_listen_port
+	* #690:  Fix renaming folders does not remove old empty folders
+	* #1336: Fix uneeded horizontal scrollbar showing in Files & Peers Tab
+	* #1508: Fix TypeError in cell_data_queue() could not convert argument to correct param type
+	* #1498: Fix double slashes appearing when renaming
+	* #1283: Fix consistent icons for Files tab
+	* #1282: Text for AutoManaged changed to 'On/Off' and localized
+	* Fix Up/Down buttons in Edit Trackers Dialog
+	* Add Key Shortcuts for main menu functions
+
+==== WebUI ====
+	* #1194: Fix infinite login prompt in web ui through reverse proxy
+	* #1355: Fix slow changing states in webUI
+	* #1536: Fix Edit Trackers window not scrolling and not being resizable
+	* #1799: Fix Missing textbox for "Move completed" in torrent options
+	* #1562: Fix Javascript error in Web UI when re-opening preferences
+	* #1567: Fix js from plugins does not work with different 'base' setting
+	* #1268: Fix torrent errors not displayed in webui
+	* #1323: Fix filter panels not scrollable
+	* Fix file uploads from behind a reverse proxy.
+	* #1333: Fix peer list doesn't update automatically
+	* #1537: Fix editing trackers list, trackers have to be reselected
+
+==== ConsoleUI ====
+	* #755:  Fix can't set listen_ports through console UI
+	* #1500: Fix Console crashes on command longer than terminal width
+	* #1248: Fix deluge-console unicode support on redirected stdout
+	* Fix for deluge-console not adding torrent files on MS Windows
+	* #1450: Fix trailing white space in paths
+	* Misc: Updated help text for deluge-console on MS Windows
+	* #1484: Fix trying to access the screen object when not using interactive mode
+	* #1548: Fix cli argument processing
+	* #1856: Add --sort option to info command
+	* #1857: Add seeding_time, active_time and tracker_status to info command
+
+==== Scheduler ====
+	* #1506: Fix max speed not restored on a yellow->green transition
+
+=== Deluge 1.3.1 (31 October 2010) ===
+==== Core ====
+	* #1369: Fix non-ascii config folders not working in windows
+
+==== GtkUI ====
+	* #1365: Fix sidebar not updating show/hide trackers
+	* #1247: Fix hang on quit
+
+==== WebUI ====
+	* #1364: Fix preferences not saving when the web ui plugin is enabled in classic mode
+	* #1377: Fix bug when enabling plugins
+	* #1370: Fix issues with preferences
+	* #1312: Fix deluge-web using 100% CPU
+
+=== Deluge 1.3.0 (18 September 2010) ===
+==== Core ====
+	* Fix issue where the save_timer is cancelled when it's not active
+	* Fix unhandled exception when adding a torrent to the session
+	* Moved xdg import so it is not called on Windows, where it is unused. fixes #1343
+	* Fix key error after enabling a plugin that introduces a new status key
+	* Ignore global stop ratio related settings in logic, so per torrent ones are used.
+	* Ensure preferencesmanager only changes intended libtorrent session settings.
+	* Fix issue when adding torrents without a 'session'. This can happen when a plugin adds a torrent, like how the AutoAdd plugin works. The user that adds this torrent will be an empty string.
+	* Add TorrentFileCompleted event
+
+==== GtkUI ====
+	* Increase max piece size to 8 MiB in create torrent dialog (closes #1358)
+
+==== Scheduler ====
+	* Add max active downloading and seeding options to scheduler.
+	* Fix scheduler so that it keeps current state, even after global settings change.
+
+==== AutoAdd ====
+	* AutoAdd plugin can now recover when one of the watchfolders has an unhandled exception.
+	* Fix bug in AutoAdd plugin where watchdirs would not display in gtkui when first enabled.
+	* Fix bugs with unicode torrents in AutoAdd plugin.
+
+=== Deluge 1.3.0-rc2 (20 August 2010) ===
+==== Core ====
+	* Fix tracker_icons failing on windows
+	* Fix #1302 an uncaught exception in an state_changed event handler in SessionProxy was preventing the TorrentManager's stop method from properly saving all the resume data
+	* Fix issue with SessionProxy not updating the torrent status correctly when get_torrent_status calls take place within the cache_expiry time
+
+==== ConsoleUI ====
+	* #1307: Fix not being able to add torrents
+	* #1293: Fix not being able to add paths that contain backslashes
+
+==== GtkUI ====
+	* Fix uncaught exception when closing deluge in classic mode
+
+==== Execute ====
+	* #1306: Fix always executing last event
+
+==== Label ====
+	* Fix being able to remove labels in web ui
+
+==== WebUI ====
+	* #1319: Fix shift selecting in file trees
+
+=== Deluge 1.3.0-rc1 (08 May 2010) ===
 ==== Core ====
 	* Implement #1063 option to delete torrent file copy on torrent removal - patch from Ghent
 	* Implement #457 progress bars for folders
@@ -7,15 +164,33 @@
 	* #1112: Fix renaming files in add torrent dialog
 	* #1247: Fix deluge-gtk from hanging on shutdown
 	* #995: Rewrote tracker_icons
+	* Add AutoAdd plugin
+	* Add Notifications plugin
+
+==== GtkUI ====
+	* Use new SessionProxy class for caching torrent status client-side
+	* Use torrent status diffs to reduce RPC traffic
 
 ==== Blocklist ====
 	* Implement local blocklist support
 	* #861: Pause transfers until blocklist is imported
+	* Fix redirection not working with relative paths
+
+==== Execute ====
+	* Fix running commands with the TorrentAdded event
+	* Fix the web interface
+
+==== Label ====
+	* Fix the web interface  (#733)
 
 ==== Web ====
 	* Migrate to ExtJS 3.1
 	* Add gzip compression of HTTP data to the server
-	* Improve the efficiency of the TorrentGrid
+	* Improve the efficiency of the TorrentGrid with lots of torrents (#1026)
+	* Add a base parameter to allow reverse proxying (#1076)
+	* Fix showing all the peers in the details tab (#1054)
+	* Fix uploading torrent files in Opera or IE (#1087)
+	* Complete IE support
 
 === Deluge 1.2.0 - "Bursting like an infected kidney" (10 January 2010) ===
 ==== Core ====

DEPENDS

@@ -6,7 +6,9 @@
  * simplejson (if python < 2.6)
  * setuptools
  * gettext
+ * intltool
  * pyxdg
+ * chardet
  * geoip-database (optional)
 
  * libtorrent >= 0.14, or build the included version
@@ -16,9 +18,6 @@
    * openssl
    * zlib
 
-=== UIs ===
- * chardet
-
 === Gtk ===
  * python-notify (libnotify python wrapper)
  * pygame

check_glade.sh

@@ -0,0 +1,21 @@
+#!/bin/sh
+
+# Fixes glade files which may have set gtk stock labels set to translatable
+for x in `find . -name '*.glade' |grep -v '.git\|build'` ; do \
+    for y in gtk-add gtk-apply gtk-bold gtk-cancel gtk-cdrom gtk-clear \
+        gtk-close gtk-color-picker gtk-connect gtk-convert gtk-copy gtk-cut \
+        gtk-delete gtk-dialog-error gtk-dialog-info gtk-dialog-question \
+        gtk-dialog-warning gtk-dnd gtk-dnd-multiple gtk-edit gtk-execute gtk-find \
+        gtk-find-and-replace gtk-floppy gtk-goto-bottom gtk-goto-first \
+        gtk-goto-last gtk-goto-top gtk-go-back gtk-go-down gtk-go-forward \
+        gtk-go-up gtk-help gtk-home gtk-index gtk-italic gtk-jump-to \
+        gtk-justify-center gtk-justify-fill gtk-justify-left gtk-missing-image \
+        gtk-new gtk-no gtk-ok gtk-open gtk-paste gtk-preferences gtk-print \
+        gtk-print-preview gtk-properties gtk-quit gtk-redo gtk-refresh \
+        gtk-remove gtk-revert-to-saved gtk-save gtk-save-as gtk-select-color \
+        gtk-select-font gtk-sort-descending gtk-spell-check gtk-stop \
+        gtk-strikethrough gtk-undelete gtk-underline gtk-undo gtk-yes \
+        gtk-zoom-100 gtk-zoom-fit gtk-zoom-in gtk-zoom-out; do \
+            sed -i "s/<property\ name\=\"label\"\ translatable\=\"yes\">$y<\/property>/<property\ name\=\"label\"\ translatable\=\"no\">$y<\/property>/g" $x; \
+        done;\
+    done

create_potfiles_in.py

@@ -1,17 +1,26 @@
+#!/usr/bin/env python
 import os
-
+import re
+import sys
 # Paths to exclude
 EXCLUSIONS = [
-    "deluge/scripts"
+    "deluge/scripts",
+    "deluge/i18n",
 ]
 
 POTFILE_IN = "deluge/i18n/POTFILES.in"
 
-print "Creating " + POTFILE_IN + " .."
+pattern = "deluge\/plugins\/.*\/build"
+compiled = re.compile(pattern)
+
+sys.stdout.write("Creating " + POTFILE_IN + " ... ")
+sys.stdout.flush()
 to_translate = []
 for (dirpath, dirnames, filenames) in os.walk("deluge"):
     for filename in filenames:
-        if os.path.splitext(filename)[1] in (".py", ".glade") and dirpath not in EXCLUSIONS:
+        if os.path.splitext(filename)[1] in (".py", ".glade", ".in") \
+                                            and dirpath not in EXCLUSIONS \
+                                            and not compiled.match(dirpath):
             to_translate.append(os.path.join(dirpath, filename))
 
 f = open(POTFILE_IN, "wb")

deluge/common.py

@@ -41,6 +41,7 @@ import time
 import subprocess
 import platform
 import sys
+import chardet
 
 try:
     import json
@@ -63,7 +64,6 @@ if not hasattr(json, "dumps"):
     json.load = load
 
 import pkg_resources
-import xdg, xdg.BaseDirectory
 import gettext
 import locale
 
@@ -73,9 +73,7 @@ try:
         locale.bindtextdomain("deluge", pkg_resources.resource_filename("deluge", "i18n"))
     if hasattr(locale, "textdomain"):
         locale.textdomain("deluge")
-    gettext.bindtextdomain("deluge", pkg_resources.resource_filename("deluge", "i18n"))
-    gettext.textdomain("deluge")
-    gettext.install("deluge", pkg_resources.resource_filename("deluge", "i18n"))
+    gettext.install("deluge", pkg_resources.resource_filename("deluge", "i18n"), unicode=True)
 except Exception, e:
     from deluge.log import LOG as log
     log.error("Unable to initialize gettext/locale!")
@@ -119,11 +117,12 @@ FILE_PRIORITY = {
     0: "Do Not Download",
     1: "Normal Priority",
     2: "High Priority",
-    5: "Highest Priority",
+    5: "High Priority",
+    7: "Highest Priority",
     "Do Not Download": 0,
     "Normal Priority": 1,
-    "High Priority": 2,
-    "Highest Priority": 5
+    "High Priority": 5,
+    "Highest Priority": 7
 }
 
 def get_version():
@@ -145,11 +144,19 @@ def get_default_config_dir(filename=None):
 
     """
     if windows_check():
+        appDataPath = os.environ.get("APPDATA")
+        if not appDataPath:
+            import _winreg
+            hkey = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders")
+            appDataReg = _winreg.QueryValueEx(hkey, "AppData")
+            appDataPath = appDataReg[0]
+            _winreg.CloseKey(hkey)
         if filename:
-            return os.path.join(os.environ.get("APPDATA"), "deluge", filename)
+            return os.path.join(appDataPath, "deluge", filename)
         else:
-            return os.path.join(os.environ.get("APPDATA"), "deluge")
+            return os.path.join(appDataPath, "deluge")
     else:
+        import xdg.BaseDirectory
         if filename:
             return os.path.join(xdg.BaseDirectory.save_config_path("deluge"), filename)
         else:
@@ -164,6 +171,18 @@ def get_default_download_dir():
     if windows_check():
         return os.path.expanduser("~")
     else:
+        from xdg.BaseDirectory import xdg_config_home
+        userdir_file = os.path.join(xdg_config_home, 'user-dirs.dirs')
+        try:
+            for line in open(userdir_file, 'r'):
+                if not line.startswith('#') and 'XDG_DOWNLOAD_DIR' in line:
+                        download_dir = os.path.expandvars(\
+                                        line.partition("=")[2].rstrip().strip('"'))
+                        if os.path.isdir(download_dir):
+                            return download_dir
+        except IOError:
+            pass
+
         return os.environ.get("HOME")
 
 def windows_check():
@@ -291,7 +310,14 @@ def fspeed(bps):
     '42.1 KiB/s'
 
     """
-    return '%s/s' % (fsize(bps))
+    fspeed_kb = bps / 1024.0
+    if fspeed_kb < 1024:
+        return "%.1f %s" % (fspeed_kb, _("KiB/s"))
+    fspeed_mb = fspeed_kb / 1024.0
+    if fspeed_mb < 1024:
+        return "%.1f %s" % (fspeed_mb, _("MiB/s"))
+    fspeed_gb = fspeed_mb / 1024.0
+    return "%.1f %s" % (fspeed_gb, _("GiB/s"))
 
 def fpeer(num_peers, total_peers):
     """
@@ -474,7 +500,7 @@ def free_space(path):
         sectors, bytes, free, total = map(long, win32file.GetDiskFreeSpace(path))
         return (free * sectors * bytes)
     else:
-        disk_data = os.statvfs(path)
+        disk_data = os.statvfs(path.encode("utf8"))
         block_size = disk_data.f_bsize
         return disk_data.f_bavail * block_size
 
@@ -526,7 +552,7 @@ def path_join(*parts):
             path += '/' + part
     return path
 
-XML_ESCAPES = ( 
+XML_ESCAPES = (
     ('&', '&amp;'),
     ('<', '&lt;'),
     ('>', '&gt;'),
@@ -535,9 +561,9 @@ XML_ESCAPES = (
 )
 
 def xml_decode(string):
-    """ 
+    """
     Unescape a string that was previously encoded for use within xml.
-    
+
     :param string: The string to escape
     :type string: string
     :returns: The unescaped version of the string.
@@ -548,9 +574,9 @@ def xml_decode(string):
     return string
 
 def xml_encode(string):
-    """ 
+    """
     Escape a string for use within an xml element or attribute.
-    
+
     :param string: The string to escape
     :type string: string
     :returns: An escaped version of the string.
@@ -560,6 +586,41 @@ def xml_encode(string):
         string = string.replace(char, escape)
     return string
 
+def decode_string(s, encoding="utf8"):
+    """
+    Decodes a string and re-encodes it in utf8.  If it cannot decode using
+    `:param:encoding` then it will try to detect the string encoding and
+    decode it.
+
+    :param s: string to decode
+    :type s: string
+    :keyword encoding: the encoding to use in the decoding
+    :type encoding: string
+
+    """
+
+    try:
+        s = s.decode(encoding).encode("utf8", "ignore")
+    except UnicodeDecodeError:
+        s = s.decode(chardet.detect(s)["encoding"], "ignore").encode("utf8", "ignore")
+    return s
+
+def utf8_encoded(s):
+    """
+    Returns a utf8 encoded string of s
+
+    :param s: (unicode) string to (re-)encode
+    :type s: basestring
+    :returns: a utf8 encoded string of s
+    :rtype: str
+
+    """
+    if isinstance(s, str):
+        s = decode_string(s)
+    elif isinstance(s, unicode):
+        s = s.encode("utf8", "ignore")
+    return s
+
 class VersionSplit(object):
     """
     Used for comparing version numbers.
@@ -570,13 +631,15 @@ class VersionSplit(object):
     """
     def __init__(self, ver):
         ver = ver.lower()
-        vs = ver.split("_") if "_" in ver else ver.split("-")
+        vs = ver.replace("_", "-").split("-")
         self.version = [int(x) for x in vs[0].split(".")]
         self.suffix = None
+        self.dev = False
         if len(vs) > 1:
-            for s in ("rc", "alpha", "beta", "dev"):
-                if s in vs[1][:len(s)]:
-                    self.suffix = vs[1]
+            if vs[1].startswith(("rc", "alpha", "beta")):
+                self.suffix = vs[1]
+            if vs[-1] == 'dev':
+                self.dev = True
 
     def __cmp__(self, ver):
         """
@@ -587,19 +650,8 @@ class VersionSplit(object):
 
         """
 
-        if self.version > ver.version or (self.suffix and self.suffix[:3] == "dev"):
-            return 1
-        if self.version < ver.version:
-            return -1
-
-        if self.version == ver.version:
-            if self.suffix == ver.suffix:
-                return 0
-            if self.suffix is None:
-                return 1
-            if ver.suffix is None:
-                return -1
-            if self.suffix < ver.suffix:
-                return -1
-            if self.suffix > ver.suffix:
-                return 1
+        # If there is no suffix we use z because we want final
+        # to appear after alpha, beta, and rc alphabetically.
+        v1 = [self.version, self.suffix or 'z', self.dev]
+        v2 = [ver.version, ver.suffix or 'z', ver.dev]
+        return cmp(v1, v2)

deluge/component.py

@@ -96,6 +96,10 @@ class Component(object):
         self._component_stopping_deferred = None
         _ComponentRegistry.register(self)
 
+    def __del__(self):
+        if _ComponentRegistry:
+            _ComponentRegistry.deregister(self._component_name)
+        
     def _component_start_timer(self):
         if hasattr(self, "update"):
             self._component_timer = LoopingCall(self.update)
@@ -139,11 +143,18 @@ class Component(object):
                 self._component_timer.stop()
             return True
 
+        def on_stop_fail(result):
+            self._component_state = "Started"
+            self._component_stopping_deferred = None
+            log.error(result)
+            return result
+            
         if self._component_state != "Stopped" and self._component_state != "Stopping":
             if hasattr(self, "stop"):
                 self._component_state = "Stopping"
                 d = maybeDeferred(self.stop)
                 d.addCallback(on_stop)
+                d.addErrback(on_stop_fail)
                 self._component_stopping_deferred = d
             else:
                 d = maybeDeferred(on_stop, None)

deluge/config.py

@@ -45,9 +45,9 @@ The format of the config file is two json encoded dicts:
 <version dict>
 <content dict>
 
-The version dict contains two keys: file and format.  The format version is 
-controlled by the Config class.  It should only be changed when anything below 
-it is changed directly by the Config class.  An example of this would be if we 
+The version dict contains two keys: file and format.  The format version is
+controlled by the Config class.  It should only be changed when anything below
+it is changed directly by the Config class.  An example of this would be if we
 changed the serializer for the content to something different.
 
 The config file version is changed by the 'owner' of the config file.  This is
@@ -93,13 +93,13 @@ def prop(func):
 def find_json_objects(s):
     """
     Find json objects in a string.
-    
+
     :param s: the string to find json objects in
     :type s: string
-    
+
     :returns: a list of tuples containing start and end locations of json objects in the string `s`
     :rtype: [(start, end), ...]
-    
+
     """
     objects = []
     opens = 0
@@ -119,8 +119,8 @@ def find_json_objects(s):
                 start = index + offset + 1
 
     return objects
-    
-    
+
+
 class Config(object):
     """
     This class is used to access/create/modify config files
@@ -146,7 +146,8 @@ class Config(object):
         self._save_timer = None
 
         if defaults:
-            self.__config = dict(defaults)
+            for key, value in defaults.iteritems():
+                self.set_item(key, value)
 
         # Load the config from file in the config_dir
         if config_dir:
@@ -187,6 +188,10 @@ what is currently in the config and it could not convert the value
         5
 
         """
+        if isinstance(value, basestring):
+            value = deluge.common.utf8_encoded(value)
+
+
         if not self.__config.has_key(key):
             self.__config[key] = value
             log.debug("Setting '%s' to %s of %s", key, value, type(value))
@@ -200,7 +205,10 @@ what is currently in the config and it could not convert the value
 
         if value is not None and oldtype != type(None) and oldtype != newtype:
             try:
-                value = oldtype(value)
+                if oldtype == unicode:
+                    value = oldtype(value, "utf8")
+                else:
+                    value = oldtype(value)
             except ValueError:
                 log.warning("Type '%s' invalid for '%s'", newtype, key)
                 raise
@@ -250,7 +258,13 @@ what is currently in the config and it could not convert the value
         5
 
         """
-        return self.__config[key]
+        if isinstance(self.__config[key], str):
+            try:
+                return self.__config[key].decode("utf8")
+            except UnicodeDecodeError:
+                return self.__config[key]
+        else:
+            return self.__config[key]
 
     def register_change_callback(self, callback):
         """
@@ -348,21 +362,21 @@ what is currently in the config and it could not convert the value
             return
 
         objects = find_json_objects(data)
-        
+
         if not len(objects):
             # No json objects found, try depickling it
             try:
                 self.__config.update(pickle.loads(data))
             except Exception, e:
                 log.exception(e)
-                log.warning("Unable to load config file: %s", filename)                
+                log.warning("Unable to load config file: %s", filename)
         elif len(objects) == 1:
             start, end = objects[0]
             try:
                 self.__config.update(json.loads(data[start:end]))
             except Exception, e:
                 log.exception(e)
-                log.warning("Unable to load config file: %s", filename)                
+                log.warning("Unable to load config file: %s", filename)
         elif len(objects) == 2:
             try:
                 start, end = objects[0]
@@ -371,8 +385,8 @@ what is currently in the config and it could not convert the value
                 self.__config.update(json.loads(data[start:end]))
             except Exception, e:
                 log.exception(e)
-                log.warning("Unable to load config file: %s", filename)                
-            
+                log.warning("Unable to load config file: %s", filename)
+
         log.debug("Config %s version: %s.%s loaded: %s", filename,
             self.__version["format"], self.__version["file"], self.__config)
 
@@ -396,26 +410,24 @@ what is currently in the config and it could not convert the value
             version = json.loads(data[start:end])
             start, end = objects[1]
             loaded_data = json.loads(data[start:end])
-
             if self.__config == loaded_data and self.__version == version:
                 # The config has not changed so lets just return
-                self._save_timer.cancel()
-                return
-        except Exception, e:
-            log.warning("Unable to open config file: %s", filename)
-
-        
+                if self._save_timer and self._save_timer.active():
+                    self._save_timer.cancel()
+                return True
+        except IOError, e:
+            log.warning("Unable to open config file: %s because: %s", filename, e)
 
         # Save the new config and make sure it's written to disk
         try:
             log.debug("Saving new config file %s", filename + ".new")
             f = open(filename + ".new", "wb")
-            json.dump(self.__version, f, indent=2)            
+            json.dump(self.__version, f, indent=2)
             json.dump(self.__config, f, indent=2)
             f.flush()
             os.fsync(f.fileno())
             f.close()
-        except Exception, e:
+        except IOError, e:
             log.error("Error writing new config file: %s", e)
             return False
 

deluge/core/autoadd.py

@@ -74,12 +74,12 @@ class AutoAdd(component.Component):
             return
 
         for filename in os.listdir(self.config["autoadd_location"]):
-            if filename.split(".")[-1] == "torrent":
-                try:
-                    filepath = os.path.join(self.config["autoadd_location"], filename)
-                except UnicodeDecodeError, e:
-                    log.error("Unable to auto add torrent due to inproper filename encoding: %s", e)
-                    continue
+            try:
+                filepath = os.path.join(self.config["autoadd_location"], filename)
+            except UnicodeDecodeError, e:
+                log.error("Unable to auto add torrent due to improper filename encoding: %s", e)
+                continue
+            if os.path.isfile(filepath) and filename.endswith(".torrent"):
                 try:
                     filedump = self.load_torrent(filepath)
                 except (RuntimeError, Exception), e:

deluge/core/core.py

@@ -42,11 +42,14 @@ import shutil
 import threading
 import pkg_resources
 import warnings
+import tempfile
+from urlparse import urljoin
 
 
 from twisted.internet import reactor, defer
 from twisted.internet.task import LoopingCall
 import twisted.web.client
+import twisted.web.error
 
 from deluge.httpdownloader import download_file
 from deluge.log import LOG as log
@@ -92,6 +95,11 @@ class Core(component.Component):
 
         # Set session settings
         self.settings.send_redundant_have = True
+        if deluge.common.windows_check():
+            self.settings.disk_io_write_mode = \
+                lt.io_buffer_mode_t.disable_os_cache
+            self.settings.disk_io_read_mode = \
+                lt.io_buffer_mode_t.disable_os_cache
         self.session.set_settings(self.settings)
 
         # Load metadata extension
@@ -236,20 +244,35 @@ class Core(component.Component):
         :returns: a Deferred which returns the torrent_id as a str or None
         """
         log.info("Attempting to add url %s", url)
-        def on_get_file(filename):
+        def on_download_success(filename):
             # We got the file, so add it to the session
-            data = open(filename, "rb").read()
+            f = open(filename, "rb")
+            data = f.read()
+            f.close()
+            try:
+                os.remove(filename)
+            except Exception, e:
+                log.warning("Couldn't remove temp file: %s", e)
             return self.add_torrent_file(filename, base64.encodestring(data), options)
 
-        def on_get_file_error(failure):
-            # Log the error and pass the failure onto the client
-            log.error("Error occured downloading torrent from %s", url)
-            log.error("Reason: %s", failure.getErrorMessage())
-            return failure
+        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)
+            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 occured downloading torrent from %s", url)
+                log.error("Reason: %s", failure.getErrorMessage())
+                result = failure
+            return result
 
-        d = download_file(url, url.split("/")[-1], headers=headers)
-        d.addCallback(on_get_file)
-        d.addErrback(on_get_file_error)
+        d = download_file(url, tempfile.mkstemp()[1], headers=headers, force_filename=True)
+        d.addCallbacks(on_download_success, on_download_fail)
         return d
 
     @export
@@ -747,7 +770,11 @@ class Core(component.Component):
         def on_get_page(result):
             return bool(int(result))
 
+        def logError(failure):
+            log.warning("Error testing listen port: %s", failure)
+
         d.addCallback(on_get_page)
+        d.addErrback(logError)
 
         return d
 
@@ -768,7 +795,10 @@ class Core(component.Component):
         """
         if not path:
             path = self.config["download_location"]
-        return deluge.common.free_space(path)
+        try:
+            return deluge.common.free_space(path)
+        except InvalidPathError:
+            return 0
 
     @export
     def get_libtorrent_version(self):

deluge/core/eventmanager.py

@@ -53,7 +53,10 @@ class EventManager(component.Component):
         if event.name in self.handlers:
             for handler in self.handlers[event.name]:
                 #log.debug("Running handler %s for event %s with args: %s", event.name, handler, event.args)
-                handler(*event.args)
+                try:
+                    handler(*event.args)
+                except:
+                    log.error("Event handler %s failed in %s", event.name, handler)
 
     def register_event_handler(self, event, handler):
         """

deluge/core/filtermanager.py

@@ -91,7 +91,7 @@ def tracker_error_filter(torrent_ids, values):
     # Check all the torrent's tracker_status for 'Error:' and only return torrent_ids
     # that have this substring in their tracker_status
     for torrent_id in torrent_ids:
-        if "Error:" in tm[torrent_id].get_status(["tracker_status"])["tracker_status"]:
+        if _("Error") + ":" in tm[torrent_id].get_status(["tracker_status"])["tracker_status"]:
             filtered_torrent_ids.append(torrent_id)
 
     return filtered_torrent_ids
@@ -196,9 +196,8 @@ class FilterManager(component.Component):
                 value = status[field]
                 items[field][value] = items[field].get(value, 0) + 1
 
-        items["tracker_host"]["All"] = len(torrent_ids)
-
         if "tracker_host" in items:
+            items["tracker_host"]["All"] = len(torrent_ids)
             items["tracker_host"]["Error"] = len(tracker_error_filter(torrent_ids, ("Error",)))
 
         if "state" in tree_keys and not show_zero_hits:

deluge/core/preferencesmanager.py

@@ -152,7 +152,6 @@ class PreferencesManager(component.Component):
     def start(self):
         self.core = component.get("Core")
         self.session = component.get("Core").session
-        self.settings = component.get("Core").settings
 
         # Register set functions in the Config
         self.config.register_set_function("torrentfiles_location",
@@ -229,10 +228,15 @@ class PreferencesManager(component.Component):
         self.config.register_change_callback(self._on_config_value_change)
 
     def stop(self):
-        if self.new_release_timer:
+        if self.new_release_timer and self.new_release_timer.running:
             self.new_release_timer.stop()
 
     # Config set functions
+    def session_set_setting(self, key, value):
+        settings = self.session.settings()
+        setattr(settings, key, value)
+        self.session.set_settings(settings)
+
     def _on_config_value_change(self, key, value):
         component.get("EventManager").emit(ConfigValueChangedEvent(key, value))
 
@@ -274,8 +278,7 @@ class PreferencesManager(component.Component):
     def _on_set_outgoing_ports(self, key, value):
         if not self.config["random_outgoing_ports"]:
             log.debug("outgoing port range set to %s-%s", value[0], value[1])
-            self.settings.outgoing_ports = value[0], value[1]
-            self.session.set_settings(self.settings)
+            self.session_set_setting("outgoing_ports", (value[0], value[1]))
 
     def _on_set_random_outgoing_ports(self, key, value):
         if value:
@@ -284,13 +287,11 @@ class PreferencesManager(component.Component):
     def _on_set_peer_tos(self, key, value):
         log.debug("setting peer_tos to: %s", value)
         try:
-            self.settings.peer_tos = chr(int(value, 16))
+            self.session_set_setting("peer_tos", chr(int(value, 16)))
         except ValueError, e:
             log.debug("Invalid tos byte: %s", e)
             return
 
-        self.session.set_settings(self.settings)
-
     def _on_set_dht(self, key, value):
         log.debug("dht value set to %s", value)
         state_file = deluge.configmanager.get_config_dir("dht.state")
@@ -387,51 +388,39 @@ class PreferencesManager(component.Component):
         self.session.set_max_half_open_connections(value)
 
     def _on_set_max_connections_per_second(self, key, value):
-        self.settings.connection_speed = value
-        self.session.set_settings(self.settings)
+        self.session_set_setting("connection_speed", value)
 
     def _on_ignore_limits_on_local_network(self, key, value):
-        self.settings.ignore_limits_on_local_network = value
-        self.session.set_settings(self.settings)
+        self.session_set_setting("ignore_limits_on_local_network", value)
 
     def _on_set_share_ratio_limit(self, key, value):
         log.debug("%s set to %s..", key, value)
-        self.settings.share_ratio_limit = value
-        self.session.set_settings(self.settings)
+        self.session_set_setting("share_ratio_limit", value)
 
     def _on_set_seed_time_ratio_limit(self, key, value):
         log.debug("%s set to %s..", key, value)
-        self.settings.seed_time_ratio_limit = value
-        self.session.set_settings(self.settings)
+        self.session_set_setting("seed_time_ratio_limit", value)
 
     def _on_set_seed_time_limit(self, key, value):
         log.debug("%s set to %s..", key, value)
         # This value is stored in minutes in deluge, but libtorrent wants seconds
-        self.settings.seed_time_limit = int(value * 60)
-        self.session.set_settings(self.settings)
+        self.session_set_setting("seed_time_limit", int(value * 60))
 
     def _on_set_max_active_downloading(self, key, value):
         log.debug("%s set to %s..", key, value)
-        log.debug("active_downloads: %s", self.settings.active_downloads)
-        self.settings.active_downloads = value
-        self.session.set_settings(self.settings)
+        self.session_set_setting("active_downloads", value)
 
     def _on_set_max_active_seeding(self, key, value):
         log.debug("%s set to %s..", key, value)
-        log.debug("active_seeds: %s", self.settings.active_seeds)
-        self.settings.active_seeds = value
-        self.session.set_settings(self.settings)
+        self.session_set_setting("active_seeds", value)
 
     def _on_set_max_active_limit(self, key, value):
         log.debug("%s set to %s..", key, value)
-        log.debug("active_limit: %s", self.settings.active_limit)
-        self.settings.active_limit = value
-        self.session.set_settings(self.settings)
+        self.session_set_setting("active_limit", value)
 
     def _on_set_dont_count_slow_torrents(self, key, value):
         log.debug("%s set to %s..", key, value)
-        self.settings.dont_count_slow_torrents = value
-        self.session.set_settings(self.settings)
+        self.session_set_setting("dont_count_slow_torrents", value)
 
     def _on_send_info(self, key, value):
         log.debug("Sending anonymous stats..")
@@ -467,14 +456,14 @@ class PreferencesManager(component.Component):
         if value:
             log.debug("Checking for new release..")
             threading.Thread(target=self.core.get_new_release).start()
-            if self.new_release_timer:
+            if self.new_release_timer and self.new_release_timer.running:
                 self.new_release_timer.stop()
             # Set a timer to check for a new release every 3 days
             self.new_release_timer = LoopingCall(
                 self._on_new_release_check, "new_release_check", True)
             self.new_release_timer.start(72 * 60 * 60, False)
         else:
-            if self.new_release_timer:
+            if self.new_release_timer and self.new_release_timer.running:
                 self.new_release_timer.stop()
 
     def _on_set_proxies(self, key, value):
@@ -491,8 +480,7 @@ class PreferencesManager(component.Component):
 
     def _on_rate_limit_ip_overhead(self, key, value):
         log.debug("%s: %s", key, value)
-        self.settings.rate_limit_ip_overhead = value
-        self.session.set_settings(self.settings)
+        self.session_set_setting("rate_limit_ip_overhead", value)
 
     def _on_geoip_db_location(self, key, value):
         log.debug("%s: %s", key, value)
@@ -514,10 +502,8 @@ class PreferencesManager(component.Component):
 
     def _on_cache_size(self, key, value):
         log.debug("%s: %s", key, value)
-        self.settings.cache_size = value
-        self.session.set_settings(self.settings)
+        self.session_set_setting("cache_size", value)
 
     def _on_cache_expiry(self, key, value):
         log.debug("%s: %s", key, value)
-        self.settings.cache_expiry = value
-        self.session.set_settings(self.settings)
+        self.session_set_setting("cache_expiry", value)

deluge/core/rpcserver.py

@@ -47,7 +47,11 @@ from twisted.internet import ssl, reactor, defer
 from OpenSSL import crypto, SSL
 from types import FunctionType
 
-import deluge.rencode as rencode
+try:
+    import rencode
+except ImportError:
+    import deluge.rencode as rencode
+
 from deluge.log import LOG as log
 
 import deluge.component as component
@@ -90,13 +94,13 @@ def export(auth_level=AUTH_LEVEL_DEFAULT):
 def format_request(call):
     """
     Format the RPCRequest message for debug printing
-    
+
     :param call: the request
     :type call: a RPCRequest
-    
+
     :returns: a formatted string for printing
     :rtype: str
-    
+
     """
     try:
         s = call[1] + "("
@@ -111,7 +115,7 @@ def format_request(call):
         return "UnicodeEncodeError, call: %s" % call
     else:
         return s
-        
+
 class DelugeError(Exception):
     pass
 
@@ -139,7 +143,7 @@ class DelugeRPCProtocol(Protocol):
         """
         This method is called whenever data is received from a client.  The
         only message that a client sends to the server is a RPC Request message.
-        If the RPC Request message is valid, then the method is called in 
+        If the RPC Request message is valid, then the method is called in
         :meth:`dispatch`.
 
         :param data: the data from the client. It should be a zlib compressed
@@ -187,7 +191,7 @@ class DelugeRPCProtocol(Protocol):
         :param data: the object that is to be sent to the client.  This should
             be one of the RPC message types.
         :type data: object
-        
+
         """
         self.transport.write(zlib.compress(rencode.dumps(data)))
 
@@ -254,7 +258,7 @@ class DelugeRPCProtocol(Protocol):
             try:
                 ret = component.get("AuthManager").authorize(*args, **kwargs)
                 if ret:
-                    self.factory.authorized_sessions[self.transport.sessionno] = ret
+                    self.factory.authorized_sessions[self.transport.sessionno] = (ret, args[0])
                     self.factory.session_protocols[self.transport.sessionno] = self
             except Exception, e:
                 sendError()
@@ -283,7 +287,7 @@ class DelugeRPCProtocol(Protocol):
         if method in self.factory.methods and self.transport.sessionno in self.factory.authorized_sessions:
             try:
                 method_auth_requirement = self.factory.methods[method]._rpcserver_auth_level
-                auth_level = self.factory.authorized_sessions[self.transport.sessionno]
+                auth_level = self.factory.authorized_sessions[self.transport.sessionno][0]
                 if auth_level < method_auth_requirement:
                     # This session is not allowed to call this method
                     log.debug("Session %s is trying to call a method it is not authorized to call!", self.transport.sessionno)
@@ -338,7 +342,7 @@ class RPCServer(component.Component):
         self.factory = Factory()
         self.factory.protocol = DelugeRPCProtocol
         self.factory.session_id = -1
-        
+
         # Holds the registered methods
         self.factory.methods = {}
         # Holds the session_ids and auth levels
@@ -417,26 +421,41 @@ class RPCServer(component.Component):
     def get_session_id(self):
         """
         Returns the session id of the current RPC.
-        
+
         :returns: the session id, this will be -1 if no connections have been made
         :rtype: int
 
         """
         return self.factory.session_id
-        
+
+    def get_session_user(self):
+        """
+        Returns the username calling the current RPC.
+
+        :returns: the username of the user calling the current RPC
+        :rtype: string
+
+        """
+        session_id = self.get_session_id()
+        if session_id > -1 and session_id in self.factory.authorized_sessions:
+            return self.factory.authorized_sessions[session_id][1]
+        else:
+            # No connections made yet
+            return ""
+
     def is_session_valid(self, session_id):
         """
         Checks if the session is still valid, eg, if the client is still connected.
-        
+
         :param session_id: the session id
         :type session_id: int
-        
+
         :returns: True if the session is valid
         :rtype: bool
-        
+
         """
         return session_id in self.factory.authorized_sessions
-        
+
     def emit_event(self, event):
         """
         Emits the event to interested clients.

deluge/core/torrent.py

@@ -49,6 +49,31 @@ from deluge.event import *
 
 TORRENT_STATE = deluge.common.TORRENT_STATE
 
+def sanitize_filepath(filepath, folder=False):
+    """
+    Returns a sanitized filepath to pass to libotorrent rename_file().
+    The filepath will have backslashes substituted along with whitespace
+    padding and duplicate slashes stripped. If `folder` is True a trailing
+    slash is appended to the returned filepath.
+    """
+    def clean_filename(filename):
+        filename = filename.strip()
+        if filename.replace('.', '') == '':
+            return ''
+        return filename
+
+    if '\\' in filepath or '/' in filepath:
+        folderpath = filepath.replace('\\', '/').split('/')
+        folderpath = [clean_filename(x) for x in folderpath]
+        newfilepath = '/'.join(filter(None, folderpath))
+    else:
+        newfilepath = clean_filename(filepath)
+
+    if folder is True:
+        return newfilepath + '/'
+    else:
+        return newfilepath
+
 class TorrentOptions(dict):
     def __init__(self):
         config = ConfigManager("core.conf").config
@@ -82,7 +107,7 @@ class Torrent(object):
         self.config = ConfigManager("core.conf")
 
         self.rpcserver = component.get("RPCServer")
-       
+
         # This dict holds previous status dicts returned for this torrent
         # We use this to return dicts that only contain changes from the previous
         # {session_id: status_dict, ...}
@@ -90,7 +115,7 @@ class Torrent(object):
         from twisted.internet.task import LoopingCall
         self.prev_status_cleanup_loop = LoopingCall(self.cleanup_prev_status)
         self.prev_status_cleanup_loop.start(10)
-         
+
         # Set the libtorrent handle
         self.handle = handle
         # Set the torrent_id for this torrent
@@ -179,6 +204,11 @@ class Torrent(object):
         else:
             self.time_added = time.time()
 
+        # Keep track if we're forcing a recheck of the torrent so that we can
+        # repause it after its done if necessary
+        self.forcing_recheck = False
+        self.forcing_recheck_paused = False
+
         log.debug("Torrent object created.")
 
     ## Options methods ##
@@ -341,7 +371,10 @@ class Torrent(object):
 
         # Set self.state to the ltstate right away just incase we don't hit some
         # of the logic below
-        self.state = str(ltstate)
+        if ltstate in LTSTATE:
+            self.state = LTSTATE[ltstate]
+        else:
+            self.state = str(ltstate)
 
         log.debug("set_state_based_on_ltstate: %s", deluge.common.LT_TORRENT_STATE[ltstate])
         log.debug("session.is_paused: %s", component.get("Core").session.is_paused())
@@ -393,15 +426,14 @@ class Torrent(object):
         else:
             status = self.status
 
-        if self.is_finished and (self.options["stop_at_ratio"] or self.config["stop_seed_at_ratio"]):
+        if self.is_finished and self.options["stop_at_ratio"]:
             # We're a seed, so calculate the time to the 'stop_share_ratio'
             if not status.upload_payload_rate:
                 return 0
-            stop_ratio = self.config["stop_seed_ratio"] if self.config["stop_seed_at_ratio"] else self.options["stop_ratio"]
-
+            stop_ratio = self.options["stop_ratio"]
             return ((status.all_time_download * stop_ratio) - status.all_time_upload) / status.upload_payload_rate
 
-        left = status.total_wanted - status.total_done
+        left = status.total_wanted - status.total_wanted_done
 
         if left <= 0 or status.download_payload_rate == 0:
             return 0
@@ -475,11 +507,11 @@ class Torrent(object):
             ret.append({
                 "client": client,
                 "country": country,
-                "down_speed": peer.down_speed,
+                "down_speed": peer.payload_down_speed,
                 "ip": "%s:%s" % (peer.ip[0], peer.ip[1]),
                 "progress": peer.progress,
                 "seed": peer.flags & peer.seed,
-                "up_speed": peer.up_speed,
+                "up_speed": peer.payload_up_speed,
             })
 
         return ret
@@ -543,18 +575,18 @@ class Torrent(object):
     def get_status(self, keys, diff=False):
         """
         Returns the status of the torrent based on the keys provided
-        
+
         :param keys: the keys to get the status on
         :type keys: list of str
         :param diff: if True, will return a diff of the changes since the last
         call to get_status based on the session_id
         :type diff: bool
-        
+
         :returns: a dictionary of the status keys and their values
         :rtype: dict
-        
+
         """
-     
+
         # Create the full dictionary
         self.status = self.handle.status()
         if self.handle.has_metadata():
@@ -568,6 +600,13 @@ class Torrent(object):
         if distributed_copies < 0:
             distributed_copies = 0.0
 
+        # Calculate the seeds:peers ratio
+        if self.status.num_incomplete == 0:
+            # Use -1.0 to signify infinity
+            seeds_peers_ratio = -1.0
+        else:
+            seeds_peers_ratio = self.status.num_complete / float(self.status.num_incomplete)
+
         #if you add a key here->add it to core.py STATUS_KEYS too.
         full_status = {
             "active_time": self.status.active_time,
@@ -586,6 +625,8 @@ class Torrent(object):
             "message": self.statusmsg,
             "move_on_completed_path": self.options["move_completed_path"],
             "move_on_completed": self.options["move_completed"],
+            "move_completed_path": self.options["move_completed_path"],
+            "move_completed": self.options["move_completed"],
             "next_announce": self.status.next_announce.seconds,
             "num_peers": self.status.num_peers - self.status.num_seeds,
             "num_seeds": self.status.num_seeds,
@@ -595,6 +636,7 @@ class Torrent(object):
             "remove_at_ratio": self.options["remove_at_ratio"],
             "save_path": self.options["download_location"],
             "seeding_time": self.status.seeding_time,
+            "seeds_peers_ratio": seeds_peers_ratio,
             "seed_rank": self.status.seed_rank,
             "state": self.state,
             "stop_at_ratio": self.options["stop_at_ratio"],
@@ -603,8 +645,8 @@ class Torrent(object):
             "total_done": self.status.total_done,
             "total_payload_download": self.status.total_payload_download,
             "total_payload_upload": self.status.total_payload_upload,
-            "total_peers": self.status.num_incomplete,
-            "total_seeds":  self.status.num_complete,
+            "total_peers": self.status.list_peers - self.status.list_seeds,
+            "total_seeds":  self.status.list_seeds,
             "total_uploaded": self.status.all_time_upload,
             "total_wanted": self.status.total_wanted,
             "tracker": self.status.current_tracker,
@@ -699,7 +741,7 @@ class Torrent(object):
                     status_dict[key] = full_status[key]
                 elif key in fns:
                     status_dict[key] = fns[key]()
-        
+
         session_id = self.rpcserver.get_session_id()
         if diff:
             if session_id in self.prev_status:
@@ -711,7 +753,7 @@ class Torrent(object):
                             status_diff[key] = value
                     else:
                         status_diff[key] = value
-                
+
                 self.prev_status[session_id] = status_dict
                 return status_diff
 
@@ -761,13 +803,8 @@ class Torrent(object):
 
             if self.handle.is_finished():
                 # If the torrent has already reached it's 'stop_seed_ratio' then do not do anything
-                if self.config["stop_seed_at_ratio"] or self.options["stop_at_ratio"]:
-                    if self.options["stop_at_ratio"]:
-                        ratio = self.options["stop_ratio"]
-                    else:
-                        ratio = self.config["stop_seed_ratio"]
-
-                    if self.get_ratio() >= ratio:
+                if self.options["stop_at_ratio"]:
+                    if self.get_ratio() >= self.options["stop_ratio"]:
                         #XXX: This should just be returned in the RPC Response, no event
                         #self.signals.emit_event("torrent_resume_at_stop_ratio")
                         return
@@ -794,8 +831,25 @@ class Torrent(object):
 
     def move_storage(self, dest):
         """Move a torrent's storage location"""
+
+        # Attempt to convert utf8 path to unicode
+        # Note: Inconsistent encoding for 'dest', needs future investigation
         try:
-            self.handle.move_storage(dest.encode("utf8"))
+           dest_u = unicode(dest, "utf-8")
+        except TypeError:
+           # String is already unicode
+           dest_u = dest
+
+        if not os.path.exists(dest_u):
+            try:
+                # Try to make the destination path if it doesn't exist
+                os.makedirs(dest_u)
+            except IOError, e:
+                log.exception(e)
+                log.error("Could not move storage for torrent %s since %s does not exist and could not create the directory.", self.torrent_id, dest_u)
+                return False
+        try:
+            self.handle.move_storage(dest_u)
         except:
             return False
 
@@ -857,18 +911,22 @@ class Torrent(object):
 
     def force_recheck(self):
         """Forces a recheck of the torrents pieces"""
+        paused = self.handle.is_paused()
         try:
             self.handle.force_recheck()
             self.handle.resume()
         except Exception, e:
             log.debug("Unable to force recheck: %s", e)
             return False
+        self.forcing_recheck = True
+        self.forcing_recheck_paused = paused
         return True
 
     def rename_files(self, filenames):
         """Renames files in the torrent. 'filenames' should be a list of
         (index, filename) pairs."""
         for index, filename in filenames:
+            filename = sanitize_filepath(filename)
             self.handle.rename_file(index, filename.encode("utf-8"))
 
     def rename_folder(self, folder, new_folder):
@@ -879,8 +937,7 @@ class Torrent(object):
             log.error("Attempting to rename a folder with an invalid folder name: %s", new_folder)
             return
 
-        if new_folder[-1:] != "/":
-            new_folder += "/"
+        new_folder = sanitize_filepath(new_folder, folder=True)
 
         wait_on_folder = (folder, new_folder, [])
         for f in self.get_files():
@@ -889,12 +946,12 @@ class Torrent(object):
                 wait_on_folder[2].append(f["index"])
                 self.handle.rename_file(f["index"], f["path"].replace(folder, new_folder, 1).encode("utf-8"))
         self.waiting_on_folder_rename.append(wait_on_folder)
-        
+
     def cleanup_prev_status(self):
         """
         This method gets called to check the validity of the keys in the prev_status
         dict.  If the key is no longer valid, the dict will be deleted.
-        
+
         """
         for key in self.prev_status.keys():
             if not self.rpcserver.is_session_valid(key):

deluge/core/torrentmanager.py

@@ -41,22 +41,21 @@ import os
 import time
 import shutil
 import operator
+import re
 
 from twisted.internet import reactor
 from twisted.internet.task import LoopingCall
 
 from deluge._libtorrent import lt
 
-
 from deluge.event import *
 from deluge.error import *
-import deluge.common
 import deluge.component as component
 from deluge.configmanager import ConfigManager, get_config_dir
 from deluge.core.torrent import Torrent
 from deluge.core.torrent import TorrentOptions
 import deluge.core.oldstateupgrader
-from deluge.ui.common import utf8_encoded
+from deluge.common import utf8_encoded
 
 from deluge.log import LOG as log
 
@@ -150,6 +149,9 @@ class TorrentManager(component.Component):
 
         # Keeps track of resume data that needs to be saved to disk
         self.resume_data = {}
+        
+        # Workaround to determine if TorrentAddedEvent is from state file
+        self.session_started = False
 
         # Register set functions
         self.config.register_set_function("max_connections_per_torrent",
@@ -192,6 +194,8 @@ class TorrentManager(component.Component):
             self.on_alert_metadata_received)
         self.alerts.register_handler("file_error_alert",
             self.on_alert_file_error)
+        self.alerts.register_handler("file_completed_alert",
+            self.on_alert_file_completed)
 
     def start(self):
         # Get the pluginmanager reference
@@ -256,16 +260,13 @@ class TorrentManager(component.Component):
 
     def update(self):
         for torrent_id, torrent in self.torrents.items():
-            if self.config["stop_seed_at_ratio"] or torrent.options["stop_at_ratio"] and torrent.state not in ("Checking", "Allocating", "Paused", "Queued"):
+            if torrent.options["stop_at_ratio"] and torrent.state not in ("Checking", "Allocating", "Paused", "Queued"):
                 # If the global setting is set, but the per-torrent isn't.. Just skip to the next torrent
                 # This is so that a user can turn-off the stop at ratio option on a per-torrent basis
-                if self.config["stop_seed_at_ratio"] and not torrent.options["stop_at_ratio"]:
+                if not torrent.options["stop_at_ratio"]:
                     continue
-                stop_ratio = self.config["stop_seed_ratio"]
-                if torrent.options["stop_at_ratio"]:
-                    stop_ratio = torrent.options["stop_ratio"]
-                if torrent.get_ratio() >= stop_ratio and torrent.is_finished:
-                    if self.config["remove_seed_at_ratio"] or torrent.options["remove_at_ratio"]:
+                if torrent.get_ratio() >= torrent.options["stop_ratio"] and torrent.is_finished:
+                    if torrent.options["remove_at_ratio"]:
                         self.remove(torrent_id)
                         break
                     if not torrent.handle.is_paused():
@@ -376,7 +377,35 @@ class TorrentManager(component.Component):
 
             add_torrent_params["resume_data"] = resume_data
         else:
-            # We have a torrent_info object so we're not loading from state.
+            # We have a torrent_info object or magnet uri so we're not loading from state.
+            if torrent_info:
+                add_torrent_id = str(torrent_info.info_hash())
+                if add_torrent_id in self.get_torrent_list():
+                    # Torrent already exists just append any extra trackers.
+                    log.debug("Torrent (%s) exists, checking for trackers to add...", add_torrent_id)
+                    add_torrent_trackers = []
+                    for value in torrent_info.trackers():
+                        tracker = {}
+                        tracker["url"] = value.url
+                        tracker["tier"] = value.tier
+                        add_torrent_trackers.append(tracker)
+
+                    torrent_trackers = {}
+                    tracker_list = []
+                    for tracker in  self[add_torrent_id].get_status(["trackers"])["trackers"]:
+                        torrent_trackers[(tracker["url"])] = tracker
+                        tracker_list.append(tracker)
+
+                    added_tracker = False
+                    for tracker in add_torrent_trackers:
+                        if tracker['url'] not in torrent_trackers:
+                            tracker_list.append(tracker)
+                            added_tracker = True
+
+                    if added_tracker:
+                        self[add_torrent_id].set_trackers(tracker_list)
+                    return
+
             # Check if options is None and load defaults
             if options == None:
                 options = TorrentOptions()
@@ -476,6 +505,7 @@ class TorrentManager(component.Component):
         # Emit the torrent_added signal
         component.get("EventManager").emit(TorrentAddedEvent(torrent.torrent_id))
 
+        log.info("Torrent %s added by user: %s", torrent.get_status(["name"])["name"], component.get("RPCServer").get_session_user())
         return torrent.torrent_id
 
     def load_torrent(self, torrent_id):
@@ -515,6 +545,8 @@ class TorrentManager(component.Component):
         if torrent_id not in self.torrents:
             raise InvalidTorrentError("torrent_id not in session")
 
+        torrent_name = self.torrents[torrent_id].get_status(["name"])["name"]
+
         # Emit the signal to the clients
         component.get("EventManager").emit(PreTorrentRemovedEvent(torrent_id))
 
@@ -562,7 +594,7 @@ class TorrentManager(component.Component):
 
         # Emit the signal to the clients
         component.get("EventManager").emit(TorrentRemovedEvent(torrent_id))
-
+        log.info("Torrent %s removed by user: %s", torrent_name, component.get("RPCServer").get_session_user())
         return True
 
     def load_state(self):
@@ -602,6 +634,7 @@ class TorrentManager(component.Component):
                 log.error("Torrent state file is either corrupt or incompatible! %s", e)
                 break
 
+        self.session_started = True
         component.get("EventManager").emit(SessionStartedEvent())
 
     def save_state(self):
@@ -731,6 +764,38 @@ class TorrentManager(component.Component):
         except IOError:
             log.warning("Error trying to save fastresume file")
 
+    def remove_empty_folders(self, torrent_id, folder):
+        """
+        Recursively removes folders but only if they are empty.
+        Cleans up after libtorrent folder renames.
+
+        """
+        if torrent_id not in self.torrents:
+            raise InvalidTorrentError("torrent_id is not in session")
+
+        info = self.torrents[torrent_id].get_status(['save_path'])
+        # Regex removes leading slashes that causes join function to ignore save_path
+        folder_full_path = os.path.join(info['save_path'], re.sub("^/*", "", folder))
+        folder_full_path = os.path.normpath(folder_full_path)
+
+        try:
+            if not os.listdir(folder_full_path):
+                os.removedirs(folder_full_path)
+                log.debug("Removed Empty Folder %s", folder_full_path)
+            else:
+                for root, dirs, files in os.walk(folder_full_path, topdown=False):
+                    for name in dirs:
+                        try:
+                            os.removedirs(os.path.join(root, name))
+                            log.debug("Removed Empty Folder %s", os.path.join(root, name))
+                        except OSError, (errno, strerror):
+                            if errno == 39:
+                                # Error raised if folder is not empty
+                                log.debug("%s", strerror)
+
+        except OSError, (errno, strerror):
+            log.debug("Cannot Remove Folder: %s (ErrNo %s)", strerror, errno)
+
     def queue_top(self, torrent_id):
         """Queue torrent to top"""
         if self.torrents[torrent_id].get_queue_position() == 0:
@@ -850,6 +915,13 @@ class TorrentManager(component.Component):
         except:
             return
 
+        # Check to see if we're forcing a recheck and set it back to paused
+        # if necessary
+        if torrent.forcing_recheck:
+            torrent.forcing_recheck = False
+            if torrent.forcing_recheck_paused:
+                torrent.handle.pause()
+
         # Set the torrent state
         torrent.update_state()
 
@@ -905,7 +977,7 @@ class TorrentManager(component.Component):
             torrent = self.torrents[str(alert.handle.info_hash())]
         except:
             return
-        torrent.set_save_path(alert.handle.save_path())
+        torrent.set_save_path(os.path.normpath(alert.handle.save_path()))
         torrent.set_move_completed(False)
 
     def on_alert_torrent_resumed(self, alert):
@@ -985,6 +1057,8 @@ class TorrentManager(component.Component):
                 if len(wait_on_folder[2]) == 1:
                     # This is the last alert we were waiting for, time to send signal
                     component.get("EventManager").emit(TorrentFolderRenamedEvent(torrent_id, wait_on_folder[0], wait_on_folder[1]))
+                    # Empty folders are removed after libtorrent folder renames
+                    self.remove_empty_folders(torrent_id, wait_on_folder[0])
                     del torrent.waiting_on_folder_rename[i]
                     self.save_resume_data((torrent_id,))
                     break
@@ -1012,3 +1086,9 @@ class TorrentManager(component.Component):
         except:
             return
         torrent.update_state()
+
+    def on_alert_file_completed(self, alert):
+        log.debug("file_completed_alert: %s", alert.message())
+        torrent_id = str(alert.handle.info_hash())
+        component.get("EventManager").emit(
+            TorrentFileCompletedEvent(torrent_id, alert.index))

deluge/data/share/applications/deluge.desktop

@@ -1,12 +0,0 @@
-[Desktop Entry]
-Version=1.0
-Name=Deluge BitTorrent Client
-GenericName=Bittorrent Client
-Comment=Transfer files using the Bittorrent protocol
-Exec=deluge-gtk
-Icon=deluge
-Terminal=false
-Type=Application
-Categories=Network;
-StartupNotify=true
-MimeType=application/x-bittorrent;

deluge/data/share/applications/deluge.desktop.in

@@ -0,0 +1,14 @@
+[Desktop Entry]
+Version=1.0
+_Name=Deluge
+_GenericName=BitTorrent Client
+_X-GNOME-FullName=Deluge BitTorrent Client
+_Comment=Download and share files over BitTorrent
+TryExec=deluge-gtk
+Exec=deluge-gtk %U
+Icon=deluge
+Terminal=false
+Type=Application
+Categories=Network;FileTransfer;P2P;GTK
+StartupNotify=true
+MimeType=application/x-bittorrent;x-scheme-handler/magnet;

deluge/event.py

@@ -164,6 +164,22 @@ class TorrentResumedEvent(DelugeEvent):
         """
         self._args = [torrent_id]
 
+class TorrentFileCompletedEvent(DelugeEvent):
+    """
+    Emitted when a file completes.
+
+    This will only work with libtorrent 0.15 or greater.
+
+    """
+    def __init__(self, torrent_id, index):
+        """
+        :param torrent_id: the torrent_id
+        :type torrent_id: string
+        :param index: the file index
+        :type index: int
+        """
+        self._args = [torrent_id, index]
+
 class NewVersionAvailableEvent(DelugeEvent):
     """
     Emitted when a more recent version of Deluge is available.

deluge/httpdownloader.py

@@ -51,6 +51,8 @@ class HTTPDownloader(client.HTTPDownloader):
         :type url: string
         :param filename: the filename to save the file as
         :type filename: string
+        :param force_filename: forces use of the supplied filename, regardless of header content
+        :type force_filename: bool
         :param part_callback: a function to be called when a part of data
             is received, it's signature should be: func(data, current_length, total_length)
         :type part_callback: function
@@ -84,15 +86,20 @@ class HTTPDownloader(client.HTTPDownloader):
                 self.decoder = zlib.decompressobj(zlib.MAX_WBITS + 32)
 
             if "content-disposition" in headers and not self.force_filename:
-                try:
-                    new_file_name = str(headers["content-disposition"][0]).split(";")[1].split("=")[1]
-                    new_file_name = sanitise_filename(new_file_name)
-                    new_file_name = os.path.join(os.path.split(self.fileName)[0], new_file_name)
-                except Exception, e:
-                    log.exception(e)
-                else:
-                    self.fileName = new_file_name
-                    self.value = new_file_name
+                new_file_name = str(headers["content-disposition"][0]).split(";")[1].split("=")[1]
+                new_file_name = sanitise_filename(new_file_name)
+                new_file_name = os.path.join(os.path.split(self.fileName)[0], new_file_name)
+
+                count = 1
+                fileroot = os.path.splitext(new_file_name)[0]
+                fileext = os.path.splitext(new_file_name)[1]
+                while os.path.isfile(new_file_name):
+                    # Increment filename if already exists
+                    new_file_name = "%s-%s%s" % (fileroot, count, fileext)
+                    count += 1
+
+                self.fileName = new_file_name
+                self.value = new_file_name
 
         elif self.code in (http.MOVED_PERMANENTLY, http.FOUND, http.SEE_OTHER, http.TEMPORARY_REDIRECT):
             location = headers["location"][0]
@@ -129,8 +136,6 @@ def sanitise_filename(filename):
     :type filename: string
     :returns: the sanitised filename
     :rtype: string
-
-    :raises IOError: when the filename exists
     """
 
     # Remove any quotes
@@ -147,9 +152,6 @@ def sanitise_filename(filename):
         # Dodgy server, log it
         log.warning("Potentially malicious server: trying to write to file '%s'" % filename)
 
-    if os.path.exists(filename):
-        raise IOError, "File '%s' already exists!" % filename
-
     return filename
 
 def download_file(url, filename, callback=None, headers=None, force_filename=False, allow_compression=True):

deluge/i18n/POTFILES.in

@@ -1,290 +1,182 @@
-deluge/configmanager.py
-deluge/httpdownloader.py
-deluge/error.py
-deluge/component.py
-deluge/log.py
-deluge/metafile.py
-deluge/config.py
-deluge/main.py
-deluge/__init__.py
-deluge/common.py
-deluge/bencode.py
-deluge/pluginmanagerbase.py
 deluge/event.py
-deluge/rencode.py
-deluge/decorators.py
-deluge/_libtorrent.py
+deluge/httpdownloader.py
+deluge/common.py
+deluge/main.py
+deluge/metafile.py
+deluge/log.py
+deluge/pluginmanagerbase.py
+deluge/config.py
 deluge/__rpcapi.py
+deluge/__init__.py
+deluge/component.py
 deluge/maketorrent.py
-deluge/plugins/__init__.py
-deluge/plugins/pluginbase.py
+deluge/_libtorrent.py
+deluge/decorators.py
+deluge/bencode.py
+deluge/rencode.py
+deluge/configmanager.py
+deluge/error.py
 deluge/plugins/init.py
-deluge/plugins/feeder/setup.py
-deluge/plugins/feeder/feeder/__init__.py
-deluge/plugins/feeder/feeder/core.py
-deluge/plugins/feeder/feeder/webui.py
-deluge/plugins/feeder/build/lib/feeder/__init__.py
-deluge/plugins/feeder/build/lib/feeder/core.py
-deluge/plugins/feeder/build/lib/feeder/webui.py
-deluge/plugins/label/setup.py
-deluge/plugins/label/label/test.py
-deluge/plugins/label/label/__init__.py
-deluge/plugins/label/label/core.py
-deluge/plugins/label/label/webui.py
-deluge/plugins/label/label/gtkui/__init__.py
-deluge/plugins/label/label/gtkui/label_config.py
-deluge/plugins/label/label/gtkui/submenu.py
-deluge/plugins/label/label/gtkui/sidebar_menu.py
-deluge/plugins/label/label/data/label_pref.glade
-deluge/plugins/label/label/data/label_options.glade
-deluge/plugins/label/build/lib/label/test.py
-deluge/plugins/label/build/lib/label/__init__.py
-deluge/plugins/label/build/lib/label/core.py
-deluge/plugins/label/build/lib/label/webui.py
-deluge/plugins/label/build/lib/label/gtkui/__init__.py
-deluge/plugins/label/build/lib/label/gtkui/label_config.py
-deluge/plugins/label/build/lib/label/gtkui/submenu.py
-deluge/plugins/label/build/lib/label/gtkui/sidebar_menu.py
-deluge/plugins/label/build/lib/label/data/label_pref.glade
-deluge/plugins/label/build/lib/label/data/label_options.glade
-deluge/plugins/autoadd/setup.py
-deluge/plugins/autoadd/autoadd/__init__.py
-deluge/plugins/autoadd/autoadd/common.py
-deluge/plugins/autoadd/autoadd/core.py
-deluge/plugins/autoadd/autoadd/webui.py
-deluge/plugins/autoadd/autoadd/gtkui.py
-deluge/plugins/autoadd/autoadd/data/config.glade
-deluge/plugins/autoadd/autoadd/data/autoadd_options.glade
-deluge/plugins/autoadd/build/lib/autoadd/__init__.py
-deluge/plugins/autoadd/build/lib/autoadd/common.py
-deluge/plugins/autoadd/build/lib/autoadd/core.py
-deluge/plugins/autoadd/build/lib/autoadd/webui.py
-deluge/plugins/autoadd/build/lib/autoadd/gtkui.py
-deluge/plugins/autoadd/build/lib/autoadd/data/config.glade
-deluge/plugins/autoadd/build/lib/autoadd/data/autoadd_options.glade
-deluge/plugins/scheduler/setup.py
-deluge/plugins/scheduler/scheduler/__init__.py
-deluge/plugins/scheduler/scheduler/common.py
-deluge/plugins/scheduler/scheduler/core.py
-deluge/plugins/scheduler/scheduler/webui.py
-deluge/plugins/scheduler/scheduler/gtkui.py
-deluge/plugins/scheduler/build/lib/scheduler/__init__.py
-deluge/plugins/scheduler/build/lib/scheduler/common.py
-deluge/plugins/scheduler/build/lib/scheduler/core.py
-deluge/plugins/scheduler/build/lib/scheduler/webui.py
-deluge/plugins/scheduler/build/lib/scheduler/gtkui.py
+deluge/plugins/pluginbase.py
+deluge/plugins/__init__.py
 deluge/plugins/notifications/setup.py
-deluge/plugins/notifications/notifications/test.py
-deluge/plugins/notifications/notifications/__init__.py
 deluge/plugins/notifications/notifications/common.py
-deluge/plugins/notifications/notifications/core.py
 deluge/plugins/notifications/notifications/webui.py
+deluge/plugins/notifications/notifications/__init__.py
+deluge/plugins/notifications/notifications/test.py
 deluge/plugins/notifications/notifications/gtkui.py
+deluge/plugins/notifications/notifications/core.py
 deluge/plugins/notifications/notifications/data/config.glade
-deluge/plugins/notifications/build/lib/notifications/test.py
-deluge/plugins/notifications/build/lib/notifications/__init__.py
-deluge/plugins/notifications/build/lib/notifications/common.py
-deluge/plugins/notifications/build/lib/notifications/core.py
-deluge/plugins/notifications/build/lib/notifications/webui.py
-deluge/plugins/notifications/build/lib/notifications/gtkui.py
-deluge/plugins/notifications/build/lib/notifications/data/config.glade
-deluge/plugins/stats/setup.py
-deluge/plugins/stats/stats/test_total.py
-deluge/plugins/stats/stats/test.py
-deluge/plugins/stats/stats/__init__.py
-deluge/plugins/stats/stats/graph.py
-deluge/plugins/stats/stats/common.py
-deluge/plugins/stats/stats/core.py
-deluge/plugins/stats/stats/webui.py
-deluge/plugins/stats/stats/gtkui.py
-deluge/plugins/stats/stats/data/tabs.glade
-deluge/plugins/stats/stats/data/config.glade
-deluge/plugins/stats/build/lib/stats/test_total.py
-deluge/plugins/stats/build/lib/stats/test.py
-deluge/plugins/stats/build/lib/stats/__init__.py
-deluge/plugins/stats/build/lib/stats/graph.py
-deluge/plugins/stats/build/lib/stats/common.py
-deluge/plugins/stats/build/lib/stats/core.py
-deluge/plugins/stats/build/lib/stats/webui.py
-deluge/plugins/stats/build/lib/stats/gtkui.py
-deluge/plugins/stats/build/lib/stats/data/tabs.glade
-deluge/plugins/stats/build/lib/stats/data/config.glade
-deluge/plugins/webui/setup.py
-deluge/plugins/webui/webui/__init__.py
-deluge/plugins/webui/webui/common.py
-deluge/plugins/webui/webui/core.py
-deluge/plugins/webui/webui/gtkui.py
-deluge/plugins/webui/webui/data/config.glade
-deluge/plugins/webui/build/lib/webui/__init__.py
-deluge/plugins/webui/build/lib/webui/common.py
-deluge/plugins/webui/build/lib/webui/core.py
-deluge/plugins/webui/build/lib/webui/gtkui.py
-deluge/plugins/webui/build/lib/webui/data/config.glade
+deluge/plugins/autoadd/setup.py
+deluge/plugins/autoadd/autoadd/common.py
+deluge/plugins/autoadd/autoadd/webui.py
+deluge/plugins/autoadd/autoadd/__init__.py
+deluge/plugins/autoadd/autoadd/gtkui.py
+deluge/plugins/autoadd/autoadd/core.py
+deluge/plugins/autoadd/autoadd/data/autoadd_options.glade
+deluge/plugins/autoadd/autoadd/data/config.glade
+deluge/plugins/scheduler/setup.py
+deluge/plugins/scheduler/scheduler/common.py
+deluge/plugins/scheduler/scheduler/webui.py
+deluge/plugins/scheduler/scheduler/__init__.py
+deluge/plugins/scheduler/scheduler/gtkui.py
+deluge/plugins/scheduler/scheduler/core.py
+deluge/plugins/label/setup.py
+deluge/plugins/label/label/webui.py
+deluge/plugins/label/label/__init__.py
+deluge/plugins/label/label/test.py
+deluge/plugins/label/label/core.py
+deluge/plugins/label/label/gtkui/submenu.py
+deluge/plugins/label/label/gtkui/__init__.py
+deluge/plugins/label/label/gtkui/sidebar_menu.py
+deluge/plugins/label/label/gtkui/label_config.py
+deluge/plugins/label/label/data/label_options.glade
+deluge/plugins/label/label/data/label_pref.glade
 deluge/plugins/extractor/setup.py
-deluge/plugins/extractor/build/lib/extractor/__init__.py
-deluge/plugins/extractor/build/lib/extractor/common.py
-deluge/plugins/extractor/build/lib/extractor/core.py
-deluge/plugins/extractor/build/lib/extractor/webui.py
-deluge/plugins/extractor/build/lib/extractor/gtkui.py
-deluge/plugins/extractor/build/lib/extractor/data/extractor_prefs.glade
-deluge/plugins/extractor/extractor/__init__.py
 deluge/plugins/extractor/extractor/common.py
-deluge/plugins/extractor/extractor/core.py
 deluge/plugins/extractor/extractor/webui.py
+deluge/plugins/extractor/extractor/__init__.py
 deluge/plugins/extractor/extractor/gtkui.py
+deluge/plugins/extractor/extractor/core.py
 deluge/plugins/extractor/extractor/data/extractor_prefs.glade
-deluge/plugins/execute/setup.py
-deluge/plugins/execute/build/lib/execute/__init__.py
-deluge/plugins/execute/build/lib/execute/common.py
-deluge/plugins/execute/build/lib/execute/core.py
-deluge/plugins/execute/build/lib/execute/webui.py
-deluge/plugins/execute/build/lib/execute/gtkui.py
-deluge/plugins/execute/build/lib/execute/data/execute_prefs.glade
-deluge/plugins/execute/execute/__init__.py
-deluge/plugins/execute/execute/common.py
-deluge/plugins/execute/execute/core.py
-deluge/plugins/execute/execute/webui.py
-deluge/plugins/execute/execute/gtkui.py
-deluge/plugins/execute/execute/data/execute_prefs.glade
-deluge/plugins/example/setup.py
-deluge/plugins/example/build/lib/example/__init__.py
-deluge/plugins/example/build/lib/example/common.py
-deluge/plugins/example/build/lib/example/core.py
-deluge/plugins/example/build/lib/example/webui.py
-deluge/plugins/example/build/lib/example/gtkui.py
-deluge/plugins/example/example/__init__.py
-deluge/plugins/example/example/common.py
-deluge/plugins/example/example/core.py
-deluge/plugins/example/example/webui.py
-deluge/plugins/example/example/gtkui.py
-deluge/plugins/freespace/setup.py
-deluge/plugins/freespace/build/lib/freespace/__init__.py
-deluge/plugins/freespace/build/lib/freespace/common.py
-deluge/plugins/freespace/build/lib/freespace/core.py
-deluge/plugins/freespace/build/lib/freespace/webui.py
-deluge/plugins/freespace/build/lib/freespace/gtkui.py
-deluge/plugins/freespace/build/lib/freespace/data/config.glade
-deluge/plugins/freespace/freespace/__init__.py
-deluge/plugins/freespace/freespace/common.py
-deluge/plugins/freespace/freespace/core.py
-deluge/plugins/freespace/freespace/webui.py
-deluge/plugins/freespace/freespace/gtkui.py
-deluge/plugins/freespace/freespace/data/config.glade
+deluge/plugins/webui/setup.py
+deluge/plugins/webui/webui/common.py
+deluge/plugins/webui/webui/__init__.py
+deluge/plugins/webui/webui/gtkui.py
+deluge/plugins/webui/webui/core.py
+deluge/plugins/webui/webui/data/config.glade
 deluge/plugins/blocklist/setup.py
-deluge/plugins/blocklist/build/lib/blocklist/peerguardian.py
-deluge/plugins/blocklist/build/lib/blocklist/decompressers.py
-deluge/plugins/blocklist/build/lib/blocklist/detect.py
-deluge/plugins/blocklist/build/lib/blocklist/readers.py
-deluge/plugins/blocklist/build/lib/blocklist/__init__.py
-deluge/plugins/blocklist/build/lib/blocklist/common.py
-deluge/plugins/blocklist/build/lib/blocklist/core.py
-deluge/plugins/blocklist/build/lib/blocklist/webui.py
-deluge/plugins/blocklist/build/lib/blocklist/gtkui.py
-deluge/plugins/blocklist/build/lib/blocklist/data/blocklist_pref.glade
-deluge/plugins/blocklist/blocklist/peerguardian.py
-deluge/plugins/blocklist/blocklist/decompressers.py
-deluge/plugins/blocklist/blocklist/detect.py
-deluge/plugins/blocklist/blocklist/readers.py
-deluge/plugins/blocklist/blocklist/__init__.py
 deluge/plugins/blocklist/blocklist/common.py
-deluge/plugins/blocklist/blocklist/core.py
 deluge/plugins/blocklist/blocklist/webui.py
+deluge/plugins/blocklist/blocklist/peerguardian.py
+deluge/plugins/blocklist/blocklist/__init__.py
+deluge/plugins/blocklist/blocklist/decompressers.py
+deluge/plugins/blocklist/blocklist/readers.py
+deluge/plugins/blocklist/blocklist/detect.py
 deluge/plugins/blocklist/blocklist/gtkui.py
+deluge/plugins/blocklist/blocklist/core.py
 deluge/plugins/blocklist/blocklist/data/blocklist_pref.glade
+deluge/plugins/execute/setup.py
+deluge/plugins/execute/execute/common.py
+deluge/plugins/execute/execute/webui.py
+deluge/plugins/execute/execute/__init__.py
+deluge/plugins/execute/execute/gtkui.py
+deluge/plugins/execute/execute/core.py
+deluge/plugins/execute/execute/data/execute_prefs.glade
 deluge/core/eventmanager.py
-deluge/core/autoadd.py
-deluge/core/authmanager.py
-deluge/core/rpcserver.py
-deluge/core/torrentmanager.py
-deluge/core/oldstateupgrader.py
-deluge/core/__init__.py
 deluge/core/torrent.py
-deluge/core/pluginmanager.py
-deluge/core/core.py
-deluge/core/daemon.py
+deluge/core/oldstateupgrader.py
+deluge/core/authmanager.py
+deluge/core/__init__.py
+deluge/core/torrentmanager.py
+deluge/core/autoadd.py
 deluge/core/alertmanager.py
-deluge/core/preferencesmanager.py
 deluge/core/filtermanager.py
-deluge/ui/sessionproxy.py
+deluge/core/preferencesmanager.py
+deluge/core/rpcserver.py
+deluge/core/daemon.py
+deluge/core/core.py
+deluge/core/pluginmanager.py
+deluge/data/share/applications/deluge.desktop.in
 deluge/ui/ui.py
-deluge/ui/session.py
-deluge/ui/tracker_icons.py
-deluge/ui/__init__.py
 deluge/ui/common.py
-deluge/ui/Win32IconImagePlugin.py
-deluge/ui/client.py
-deluge/ui/countries.py
 deluge/ui/coreconfig.py
-deluge/ui/web/server.py
+deluge/ui/countries.py
+deluge/ui/__init__.py
+deluge/ui/sessionproxy.py
+deluge/ui/client.py
+deluge/ui/Win32IconImagePlugin.py
+deluge/ui/tracker_icons.py
+deluge/ui/web/common.py
+deluge/ui/web/gen_gettext.py
+deluge/ui/web/json_api.py
 deluge/ui/web/web.py
 deluge/ui/web/__init__.py
-deluge/ui/web/common.py
-deluge/ui/web/pluginmanager.py
-deluge/ui/web/gen_gettext.py
+deluge/ui/web/server.py
 deluge/ui/web/auth.py
-deluge/ui/web/json_api.py
-deluge/ui/gtkui/connectionmanager.py
-deluge/ui/gtkui/torrentdetails.py
-deluge/ui/gtkui/queuedtorrents.py
-deluge/ui/gtkui/addtorrentdialog.py
-deluge/ui/gtkui/__init__.py
-deluge/ui/gtkui/status_tab.py
-deluge/ui/gtkui/preferences.py
-deluge/ui/gtkui/mainwindow.py
-deluge/ui/gtkui/notification.py
-deluge/ui/gtkui/ipcinterface.py
-deluge/ui/gtkui/createtorrentdialog.py
-deluge/ui/gtkui/torrentview.py
-deluge/ui/gtkui/listview.py
-deluge/ui/gtkui/systemtray.py
-deluge/ui/gtkui/common.py
-deluge/ui/gtkui/pluginmanager.py
-deluge/ui/gtkui/menubar.py
-deluge/ui/gtkui/sidebar.py
-deluge/ui/gtkui/statusbar.py
-deluge/ui/gtkui/filtertreeview.py
-deluge/ui/gtkui/new_release_dialog.py
-deluge/ui/gtkui/options_tab.py
+deluge/ui/web/pluginmanager.py
 deluge/ui/gtkui/peers_tab.py
-deluge/ui/gtkui/details_tab.py
-deluge/ui/gtkui/files_tab.py
-deluge/ui/gtkui/gtkui.py
-deluge/ui/gtkui/edittrackersdialog.py
+deluge/ui/gtkui/queuedtorrents.py
+deluge/ui/gtkui/common.py
+deluge/ui/gtkui/mainwindow.py
+deluge/ui/gtkui/systemtray.py
+deluge/ui/gtkui/notification.py
+deluge/ui/gtkui/options_tab.py
+deluge/ui/gtkui/new_release_dialog.py
+deluge/ui/gtkui/torrentdetails.py
+deluge/ui/gtkui/preferences.py
+deluge/ui/gtkui/addtorrentdialog.py
+deluge/ui/gtkui/createtorrentdialog.py
+deluge/ui/gtkui/statusbar.py
+deluge/ui/gtkui/__init__.py
 deluge/ui/gtkui/removetorrentdialog.py
-deluge/ui/gtkui/toolbar.py
-deluge/ui/gtkui/dialogs.py
+deluge/ui/gtkui/listview.py
+deluge/ui/gtkui/edittrackersdialog.py
+deluge/ui/gtkui/ipcinterface.py
+deluge/ui/gtkui/details_tab.py
+deluge/ui/gtkui/filtertreeview.py
 deluge/ui/gtkui/aboutdialog.py
-deluge/ui/gtkui/glade/filtertree_menu.glade
+deluge/ui/gtkui/toolbar.py
+deluge/ui/gtkui/sidebar.py
+deluge/ui/gtkui/connectionmanager.py
+deluge/ui/gtkui/gtkui.py
+deluge/ui/gtkui/status_tab.py
+deluge/ui/gtkui/menubar.py
+deluge/ui/gtkui/files_tab.py
+deluge/ui/gtkui/dialogs.py
+deluge/ui/gtkui/torrentview.py
+deluge/ui/gtkui/pluginmanager.py
 deluge/ui/gtkui/glade/main_window.glade
-deluge/ui/gtkui/glade/remove_torrent_dialog.glade
+deluge/ui/gtkui/glade/filtertree_menu.glade
+deluge/ui/gtkui/glade/add_torrent_dialog.glade
 deluge/ui/gtkui/glade/create_torrent_dialog.glade
+deluge/ui/gtkui/glade/queuedtorrents.glade
+deluge/ui/gtkui/glade/dgtkpopups.glade
 deluge/ui/gtkui/glade/connection_manager.glade
 deluge/ui/gtkui/glade/preferences_dialog.glade
-deluge/ui/gtkui/glade/torrent_menu.glade
-deluge/ui/gtkui/glade/queuedtorrents.glade
-deluge/ui/gtkui/glade/move_storage_dialog.glade
-deluge/ui/gtkui/glade/add_torrent_dialog.glade
-deluge/ui/gtkui/glade/dgtkpopups.glade
 deluge/ui/gtkui/glade/tray_menu.glade
+deluge/ui/gtkui/glade/torrent_menu.glade
 deluge/ui/gtkui/glade/edit_trackers.glade
-deluge/ui/console/colors.py
-deluge/ui/console/eventlog.py
+deluge/ui/gtkui/glade/remove_torrent_dialog.glade
+deluge/ui/gtkui/glade/move_storage_dialog.glade
 deluge/ui/console/main.py
-deluge/ui/console/__init__.py
-deluge/ui/console/statusbars.py
 deluge/ui/console/screen.py
-deluge/ui/console/commands/plugin.py
+deluge/ui/console/eventlog.py
+deluge/ui/console/__init__.py
+deluge/ui/console/colors.py
+deluge/ui/console/statusbars.py
+deluge/ui/console/commands/rm.py
+deluge/ui/console/commands/cache.py
 deluge/ui/console/commands/info.py
-deluge/ui/console/commands/recheck.py
+deluge/ui/console/commands/debug.py
 deluge/ui/console/commands/quit.py
-deluge/ui/console/commands/connect.py
-deluge/ui/console/commands/help.py
-deluge/ui/console/commands/add.py
+deluge/ui/console/commands/resume.py
 deluge/ui/console/commands/config.py
 deluge/ui/console/commands/__init__.py
-deluge/ui/console/commands/cache.py
-deluge/ui/console/commands/debug.py
-deluge/ui/console/commands/pause.py
-deluge/ui/console/commands/rm.py
 deluge/ui/console/commands/halt.py
-deluge/ui/console/commands/resume.py
+deluge/ui/console/commands/recheck.py
+deluge/ui/console/commands/connect.py
+deluge/ui/console/commands/plugin.py
+deluge/ui/console/commands/pause.py
+deluge/ui/console/commands/help.py
+deluge/ui/console/commands/add.py

deluge/main.py

@@ -48,6 +48,11 @@ import deluge.common
 import deluge.configmanager
 import deluge.error
 
+try:
+    from deluge._libtorrent import lt
+    lt_version = "\nlibtorrent: %s" % lt.version
+except ImportError:
+    lt_version = ""
 
 def start_ui():
     """Entry point for ui script"""
@@ -55,7 +60,7 @@ def start_ui():
 
     # Setup the argument parser
     parser = OptionParser(usage="%prog [options] [actions]",
-                                           version=deluge.common.get_version())
+                  version= "%prog: " + deluge.common.get_version() + lt_version)
 
     parser.add_option("-u", "--ui", dest="ui",
         help="""The UI that you wish to launch.  The UI choices are:\n
@@ -130,7 +135,7 @@ def start_daemon():
 
     # Setup the argument parser
     parser = OptionParser(usage="%prog [options] [actions]",
-                                           version=deluge.common.get_version())
+                  version= "%prog: " + deluge.common.get_version() + lt_version)
     parser.add_option("-p", "--port", dest="port",
         help="Port daemon will listen on", action="store", type="int")
     parser.add_option("-i", "--interface", dest="interface",
@@ -197,6 +202,11 @@ this should be an IP address", metavar="IFACE",
         write_pidfile()
 
     # Setup the logger
+    try:
+        # Try to make the logfile's directory if it doesn't exist
+        os.makedirs(os.path.abspath(os.path.dirname(options.logfile)))
+    except:
+        pass
     deluge.log.setupLogger(level=options.loglevel, filename=options.logfile)
     from deluge.log import LOG as log
 

deluge/pluginmanagerbase.py

@@ -102,18 +102,26 @@ class PluginManagerBase:
 
     def scan_for_plugins(self):
         """Scans for available plugins"""
-        plugin_dir = os.path.join(os.path.dirname(__file__), "plugins")
+        base_plugin_dir = os.path.join(os.path.dirname(__file__), "plugins")
+        pkg_resources.working_set.add_entry(base_plugin_dir)
         user_plugin_dir = os.path.join(deluge.configmanager.get_config_dir(), "plugins")
 
-        pkg_resources.working_set.add_entry(plugin_dir)
+        plugins_dirs = [base_plugin_dir]
+        for dirname in os.listdir(base_plugin_dir):
+            plugin_dir = os.path.join(base_plugin_dir, dirname)
+            pkg_resources.working_set.add_entry(plugin_dir)
+            plugins_dirs.append(plugin_dir)
         pkg_resources.working_set.add_entry(user_plugin_dir)
-        self.pkg_env = pkg_resources.Environment([plugin_dir, user_plugin_dir])
+        plugins_dirs.append(user_plugin_dir)
+
+        self.pkg_env = pkg_resources.Environment(plugins_dirs)
 
         self.available_plugins = []
         for name in self.pkg_env:
-            log.debug("Found plugin: %s %s",
+            log.debug("Found plugin: %s %s at %s",
                 self.pkg_env[name][0].project_name,
-                self.pkg_env[name][0].version)
+                self.pkg_env[name][0].version,
+                self.pkg_env[name][0].location)
             self.available_plugins.append(self.pkg_env[name][0].project_name)
 
     def enable_plugin(self, plugin_name):