Bump version to 1.3.10 and update changelog

The speedup optimizations removed code that recreates the
model filter when a new column is added. This missing line
is only a problem when there plugins that add columns to the
GTKUI after initially loading the torrentlist.

.gitattributes

@@ -1,14 +1,24 @@
-/libtorrent export-ignore
-/win32 export-ignore
-docs/build export-ignore
-docs/source export-ignore
-/tests export-ignore
-deluge/scripts export-ignore
+/libtorrent/ export-ignore
+/win32/ export-ignore
+/osx/ export-ignore
+docs/build/ export-ignore
+docs/source/ export-ignore
+/tests/ export-ignore
+deluge/scripts/ export-ignore
 setup.cfg export-ignore
 check_glade.sh export-ignore
 createicons.sh export-ignore
 create_potfiles_in.py export-ignore
 gettextize.sh export-ignore
+deluge/i18n/deluge.pot export-ignore
+deluge/ui/web/css/*-debug.css export-ignore
+deluge/ui/web/js/*-debug.js export-ignore
+deluge/ui/web/js/deluge-all/ export-ignore
+deluge/ui/web/js/ext-extensions/ export-ignore
+deluge/ui/web/gen_gettext.py export-ignore
+deluge/ui/web/build export-ignore
+deluge/ui/web/docs/ export-ignore
+
 .gitattributes export-ignore
 .gitmodules export-ignore
 .gitignore export-ignore

.gitignore

@@ -9,3 +9,5 @@ dist
 _trial_temp
 deluge/i18n/*/
 *.desktop
+.build_data*
+osx/app

ChangeLog

@@ -1,3 +1,198 @@
+=== Deluge 1.3.10 (15 October 2014) ===
+==== GtkUI ====
+	* #2256: Indexes are not updated correctly when removing column
+	* Fix bug in the torrentview when Plugins added a column
+
+==== WebUI ====
+	* Security update for POODLE vulnerability
+
+=== Deluge 1.3.9 (4 October 2014) ===
+==== GtkUI ====
+	* #2514: Fix every torrent is displayed twice in classic mode
+
+=== Deluge 1.3.8 (4 October 2014) ===
+==== Core ====
+	* #1126 & #2322: Emit FinishedEvent after moving storage complete
+	* Fixes to mitigate fastresume corruption
+
+==== GtkUI ====
+	* #2335: Fix application startup failing with 'cannot acquire lock' error
+	* #2497: Fix the Queued Torrents 'Clear' button not properly clearing the list of torrent
+	* #2496: Fix updating core_config before setting default options
+	* #2493: Fix TypeError if active workspace is None
+	* LP:#1168858: Nautilus window opens behind current window
+	* Fix showing the open_folder menuitem
+	* Suppress unimportant gnome warnings
+	* Optimized the updating of the torrent view
+	* Fixed Indicator icon label issue
+	* Fix listview error with new config
+
+==== WebUI ====
+	* Ensure values are updated from config upon showing a plugin page
+
+==== Extractor ====
+	* Add WebUI plugin page
+	* Find 7-zip application path on Windows via registry
+
+==== Execute ====
+	* #1290: Add a TorrentRemoved event option
+
+==== Scheduler ====
+	* #2238: Fix an 'undefined this.scheduleCells' error in javascript console
+
+==== Notifications ====
+	* #1310: Add WebUI plugin page
+
+==== Blocklist ====
+	* #2478: Add WebUI plugin page
+
+==== Console ====
+	* #2470: Fix console parsing args
+
+=== Deluge 1.3.7 (9 July 2014) ===
+==== Core ====
+	* #2324: Encryption level set by Deluge did not match libtorrent values
+	* #2303: Torrent state was not updated until after emitting TorrentFinishedEvent
+	* Fix twisted 13.1 compatability
+	* #2343: Fix error if listen interface is whitespace
+	* #2082: Validate ip address for listen_interface entry
+	* #1490: Increase the Alertmanager interval to 0.3s
+	* Prevent private flagged torrents auto-merging trackers
+
+==== GtkUI ====
+	* Fix issue with Plugins that add Tab to torrentdetails
+	* Fix the scalable icon install directory
+	* #2335: Fix IPC lockfile issue preventing start of deluge-gtk
+	* #2365: Fix hiding Progress column generating TypeError
+	* #2371: Add StartupWMClass to desktop file
+	* #2372: Fix the Ratio column not retaining position
+	* #2369: Fix bypassing the password dialog when showing/quitting
+
+==== WebUI ====
+	* #2374: Fix right-click selection issue
+	* #2310: Fix unicode password support
+	* #2418: Fix WebUI error when adding non-ascii torrent
+
+==== Windows OS ====
+	* Allow silent uninstall for Windows package
+	* #2367: Fix DelugeStart theme not showing Private Flag as ticked/checked
+	* #2315: Potential fix for lost window issue
+
+==== Extractor ====
+	* #2290: Fix dotted filenames being rejected
+
+=== Deluge 1.3.6 (25 Feburary 2013) ===
+==== Core ====
+	* Catch & log KeyError when removing a torrent from the queued torrents set
+	* Fix moving/renaming torrents issues when using libtorrent 0.16
+	* Make sure queue order is preserved when restarting
+	* #2160: Disable use of python bindings for libtorrent extensions and replace with session flag
+	* #2163: Fix unable add torrent file with empty (0:) encoding tag
+	* #2201: Fix error in authmanager if auth file has extra newlines
+	* #2109: Fix the Proxy settings not being cleared by setting None
+	* #2110: Fix accepting magnet uris with xt param anywhere within them
+	* #2204: Fix daemon shutdown hang with large numbers of torrents
+	* Fix prioritize first/last pieces option for magnet links
+
+==== Client ====
+	* Fix keyerrors after removing torrents from UIs
+
+==== GtkUI ====
+	* Add move completed option to add torrent dialog
+	* Prevent jitter in torrent view
+	* Fix torrent creation with non-ascii characters
+	* Fix #2100 : Add option not to bring main window to front when adding torrents through ipcinterface
+	* Add Quit Dialog when toggling classic mode in preferences and only show connection manager when not in classic mode.
+	* #2169: Fix 'Download Location' in the Add Torrent Dialog not set correctly when folder typed into Other->Location field
+	* #2171: Fix the Add Peer dialog not responding if empty or invalid values entered
+	* #2104: Fix no title set for the appindicator
+	* #2086: Fix submenus and icons for appindicator
+	* #2146: Fix missing translations in View|Tabs submenu
+	* Fix torrent names on libtorrent 0.16 on windows
+	* #2147: Fix missing translations for plugin preferences page
+	* #1474: Fix the on_show_prefs hook not being executed immediatly after enabling a plugin
+	* #1946: Fix ReactorNotRestartable error when set as startup application
+	* #2130: Fix same name can be given to different files in Add Torrent dialog
+	* #2129: Fix empty filename able to be set in AddTorrent dialog
+	* #2228: Fix Apply-To-All in AddTorrent Dialog copying file renames to other torrents
+	* #2260: Fix the Add Torrent dialog also bringing the main window to active workspace
+	* Fix showing exception error to user in Classic Mode with no libtorrent installed
+
+==== Console ====
+	* LP#1004793: Enable use of connect command in non-interactive mode
+	* Ensure console commands are executed in order
+	* #2065: Fix crash with missing closing quote
+	* #1397: Add support for -s STATE in info command
+
+==== WebUI ====
+	* Add move completed option to add torrent dialog
+	* #2112: Fix world readable tmp directory in json_api
+	* #2069: Fix login window layout problem when using larger than default font size
+	* #1890: Fix columns in files and peers view could use some spacing
+	* #2103: Fix sorting by name is case-sensitive [sedulous]
+	* #2120: Fix manually entered values not being saved in spinners
+	* #2212: Fix unable to scroll in proxy preferences page
+	* Fix autoconnecting to the default host
+	* #2046: Fix plugins not enabling properly until after refreshing page
+	* #2125: Fix plugin methods not being available when enabled until restart
+	* #2085: Fix not showing torrents in sidebar for categories other than 'All' in classic mode
+	* #2232: Fix flag icon path in Peers Tab missing deluge.config.base
+	* Fix submenus closing upon mouse click
+	* Add failed login log message, including IP address, to enable use with fail2ban
+	* #2261: Fix Proxy settings not being saved in preferences
+
+==== Windows OS ====
+	* Hide the cmd windows when running deluged.exe or deluge-web.exe
+	* Add deluged-debug.exe and deluge-web-debug.exe that still show the cmd window
+	* Add gtk locale files to fix untranslated text
+	* Fix the Open Folder option not working with non-ascii paths
+	* Fix the daemon starting with config dir containing spaces
+	* Fix Windows tray submenu items requiring right-click instead of left-click
+	* Fix issue with adding some torrents with illegal characters via url in gtk client
+	* #2240: Fix freespace issue with large capacity drives
+
+==== OS X ====
+	* Fix Open File/Folder option
+	* Add OS X Menu for GTK Quartz
+
+==== Execute ====
+	* Fix execute plugin not working with unicode torrent names
+
+==== Extractor ====
+	* Add Windows support, using 7-zip
+	* Added support for more extensions
+	* Disabled extracting 'Move Completed' torrents due to race condition
+
+=== Deluge 1.3.5 (09 April 2012) ===
+==== Core ====
+	* Fix not properly detecting when torrent is at end of queue
+	* #2049: Preserve order when moving multiple torrents in the queue
+
+==== GtkUI ====
+	* Modified fix for #1957, keyerror with non-acsii columns
+	* Fix translation of items in Sidebar and Torrent Menu
+	* #2052: Fix translation of Progress bar text
+	* #2071: Fix KeyError in gtkui when file priority set to value '3'
+	* #2064: Fix files treeview height in Create Dialog
+	* Fix missing semi-colon in deluge.desktop
+	* Disable setting file priorities for seeding torrents
+	* Bring MainWindow to front when opening another instance
+
+==== WebUI ====
+	* #2050: Fix 'Up Speed' column not sorting
+	* Hide unused Infohash button in WebUI
+
+==== Label ====
+	* Disable unusable items for 'All' in sidebar menu
+	* Fix items for translation
+
+==== Console ====
+	* Fix prefixed space for tab completing commands
+	* Fix missing trailing space for command options with tab complete
+
+==== Blocklist ====
+	* Use (documented) formatdate over format_date_time
+
 === Deluge 1.3.4 (03 March 2012) ===
 ==== Core ====
 	* #1921: Free disk space reporting incorrectly in FreeBSD

DEPENDS

@@ -12,19 +12,19 @@
  * geoip-database (optional)
  * setproctitle (optional)
 
- * libtorrent >= 0.14, or build the included version
+ * libtorrent (rasterbar) >= 0.14
 
- * If building included libtorrent::
+ * If building libtorrent:
    * boost >= 1.34.1
    * openssl
    * zlib
 
 === Gtk ===
- * python-notify (libnotify python wrapper)
- * pygame
  * pygtk >= 2.12
  * librsvg
  * xdg-utils
+ * python-notify (optional)
+ * pygame (optional)
 
 === Web ===
  * mako

deluge/_libtorrent.py

@@ -47,7 +47,7 @@ supports.
 
 REQUIRED_VERSION = "0.14.9.0"
 
-def check_version(LT):
+def check_version(lt):
     from deluge.common import VersionSplit
     if VersionSplit(lt.version) < VersionSplit(REQUIRED_VERSION):
         raise ImportError("This version of Deluge requires libtorrent >=%s!" % REQUIRED_VERSION)

deluge/common.py

@@ -42,12 +42,18 @@ import subprocess
 import platform
 import sys
 import chardet
+import pkg_resources
+import gettext
+import locale
 
 try:
     import json
 except ImportError:
     import simplejson as json
 
+from deluge.error import *
+from deluge.log import LOG as log
+
 # Do a little hack here just in case the user has json-py installed since it
 # has a different api
 if not hasattr(json, "dumps"):
@@ -63,10 +69,6 @@ if not hasattr(json, "dumps"):
     json.dump = dump
     json.load = load
 
-import pkg_resources
-import gettext
-import locale
-
 # Initialize gettext
 try:
     if hasattr(locale, "bindtextdomain"):
@@ -75,14 +77,11 @@ try:
         locale.textdomain("deluge")
     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!")
     log.exception(e)
     import __builtin__
     __builtin__.__dict__["_"] = lambda x: x
 
-from deluge.error import *
-
 LT_TORRENT_STATE = {
     "Queued": 0,
     "Checking": 1,
@@ -102,7 +101,6 @@ LT_TORRENT_STATE = {
     7: "Checking Resume Data"
 }
 
-
 TORRENT_STATE = [
     "Allocating",
     "Checking",
@@ -117,7 +115,10 @@ FILE_PRIORITY = {
     0: "Do Not Download",
     1: "Normal Priority",
     2: "High Priority",
+    3: "High Priority",
+    4: "High Priority",
     5: "High Priority",
+    6: "High Priority",
     7: "Highest Priority",
     "Do Not Download": 0,
     "Normal Priority": 1,
@@ -156,11 +157,15 @@ def get_default_config_dir(filename=None):
         else:
             return os.path.join(appDataPath, "deluge")
     else:
-        import xdg.BaseDirectory
-        if filename:
-            return os.path.join(xdg.BaseDirectory.save_config_path("deluge"), filename)
-        else:
-            return xdg.BaseDirectory.save_config_path("deluge")
+        from xdg.BaseDirectory import save_config_path
+        try:
+            if filename:
+                return os.path.join(save_config_path("deluge"), filename)
+            else:
+                return save_config_path("deluge")
+        except OSError, e:
+            log.error("Unable to use default config directory, exiting... (%s)", e)
+            sys.exit(1)
 
 def get_default_download_dir():
     """
@@ -168,22 +173,20 @@ def get_default_download_dir():
     :rtype: string
 
     """
-    if windows_check():
-        return os.path.join(os.path.expanduser("~"), 'Downloads')
-    else:
+    download_dir = ""
+    if not windows_check():
         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
+            for line in open(os.path.join(xdg_config_home, 'user-dirs.dirs'), 'r'):
+                if not line.startswith('#') and line.startswith('XDG_DOWNLOAD_DIR'):
+                    download_dir = os.path.expandvars(line.partition("=")[2].rstrip().strip('"'))
+                    break
         except IOError:
             pass
 
-        return os.environ.get("HOME")
+    if not download_dir:
+        download_dir = os.path.join(os.path.expanduser("~"), 'Downloads')
+    return download_dir
 
 def windows_check():
     """
@@ -228,18 +231,27 @@ def get_pixmap(fname):
     return pkg_resources.resource_filename("deluge", os.path.join("data", \
                                            "pixmaps", fname))
 
-def open_file(path):
+def open_file(path, timestamp=None):
     """
     Opens a file or folder using the system configured program
 
     :param path: the path to the file or folder to open
     :type path: string
+    :param timestamp: the timestamp of the event that requested to open
+    :type timestamp: int
 
     """
     if windows_check():
-        os.startfile("%s" % path)
+        os.startfile(path.decode("utf8"))
+    elif osx_check():
+        subprocess.Popen(["open", "%s" % path])
     else:
-        subprocess.Popen(["xdg-open", "%s" % path])
+        if timestamp is None:
+            timestamp = int(time.time())
+        env = os.environ.copy()
+        env["DESKTOP_STARTUP_ID"] = "%s-%u-%s-xdg_open_TIME%d" % \
+            (os.path.basename(sys.argv[0]), os.getpid(), os.uname()[1], timestamp)
+        subprocess.Popen(["xdg-open", "%s" % path], env=env)
 
 def open_url_in_browser(url):
     """
@@ -452,7 +464,9 @@ def is_magnet(uri):
     True
 
     """
-    if uri[:20] == "magnet:?xt=urn:btih:":
+    magnet_scheme = 'magnet:?'
+    xt_param = 'xt=urn:btih:'
+    if uri.startswith(magnet_scheme) and xt_param in uri:
         return True
     return False
 
@@ -516,13 +530,12 @@ def free_space(path):
     :raises InvalidPathError: if the path is not valid
 
     """
-    if not os.path.exists(path):
+    if not path or not os.path.exists(path):
         raise InvalidPathError("%s is not a valid path" % path)
 
     if windows_check():
-        import win32file
-        sectors, bytes, free, total = map(long, win32file.GetDiskFreeSpace(path))
-        return (free * sectors * bytes)
+        from win32file import GetDiskFreeSpaceEx
+        return GetDiskFreeSpaceEx(path)[0]
     else:
         disk_data = os.statvfs(path.encode("utf8"))
         block_size = disk_data.f_frsize
@@ -546,15 +559,23 @@ def is_ip(ip):
     import socket
     #first we test ipv4
     try:
-        if socket.inet_pton(socket.AF_INET, "%s" % (ip)):
-            return True
+        if windows_check():
+            if socket.inet_aton("%s" % (ip)):
+                return True
+        else:
+            if socket.inet_pton(socket.AF_INET, "%s" % (ip)):
+                return True
     except socket.error:
         if not socket.has_ipv6:
             return False
     #now test ipv6
     try:
-        if socket.inet_pton(socket.AF_INET6, "%s" % (ip)):
+        if windows_check():
+            log.warning("ipv6 check unavailable on windows")
             return True
+        else:
+            if socket.inet_pton(socket.AF_INET6, "%s" % (ip)):
+                return True
     except socket.error:
         return False
 
@@ -612,37 +633,55 @@ def xml_encode(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.
+    Decodes a string and return unicode. If it cannot decode using
+    `:param:encoding` then it will try latin1, and if that fails,
+    try to detect the string encoding. If that fails, decode with
+    ignore.
 
     :param s: string to decode
     :type s: string
     :keyword encoding: the encoding to use in the decoding
     :type encoding: string
+    :returns: s converted to unicode
+    :rtype: unicode
 
     """
+    if not s:
+        return u''
+    elif isinstance(s, unicode):
+        return s
 
-    try:
-        s = s.decode(encoding).encode("utf8", "ignore")
-    except UnicodeDecodeError:
-        s = s.decode(chardet.detect(s)["encoding"], "ignore").encode("utf8", "ignore")
-    return s
+    encodings = [lambda: ("utf8", 'strict'),
+                 lambda: ("iso-8859-1", 'strict'),
+                 lambda: (chardet.detect(s)["encoding"], 'strict'),
+                 lambda: (encoding, 'ignore')]
 
-def utf8_encoded(s):
+    if not encoding is "utf8":
+        encodings.insert(0, lambda: (encoding, 'strict'))
+
+    for l in encodings:
+        try:
+            return s.decode(*l())
+        except UnicodeDecodeError:
+            pass
+    return u''
+
+def utf8_encoded(s, encoding="utf8"):
     """
     Returns a utf8 encoded string of s
 
     :param s: (unicode) string to (re-)encode
     :type s: basestring
+    :keyword encoding: the encoding to use in the decoding
+    :type encoding: string
     :returns: a utf8 encoded string of s
     :rtype: str
 
     """
     if isinstance(s, str):
-        s = decode_string(s)
+        s = decode_string(s, encoding).encode("utf8")
     elif isinstance(s, unicode):
-        s = s.encode("utf8", "ignore")
+        s = s.encode("utf8")
     return s
 
 class VersionSplit(object):

deluge/core/alertmanager.py

@@ -51,7 +51,7 @@ from deluge.log import LOG as log
 class AlertManager(component.Component):
     def __init__(self):
         log.debug("AlertManager initialized..")
-        component.Component.__init__(self, "AlertManager", interval=0.05)
+        component.Component.__init__(self, "AlertManager", interval=0.3)
         self.session = component.get("Core").session
 
         self.session.set_alert_mask(

deluge/core/authmanager.py

@@ -121,10 +121,10 @@ class AuthManager(component.Component):
             f = open(auth_file, "r").readlines()
 
         for line in f:
-            if line.startswith("#"):
-                # This is a comment line
-                continue
             line = line.strip()
+            if line.startswith("#") or not line:
+                # This line is a comment or empty
+                continue
             try:
                 lsplit = line.split(":")
             except Exception, e:

deluge/core/core.py

@@ -84,7 +84,10 @@ class Core(component.Component):
         while len(version) < 4:
             version.append(0)
 
-        self.session = lt.session(lt.fingerprint("DE", *version), flags=0)
+        # Note: All libtorrent python bindings to set plugins/extensions need to be disabled
+        # due to  GIL issue. https://code.google.com/p/libtorrent/issues/detail?id=369
+        # Setting session flags to 1 enables all libtorrent default plugins
+        self.session = lt.session(lt.fingerprint("DE", *version), flags=1)
 
         # Load the session state if available
         self.__load_session_state()
@@ -92,6 +95,8 @@ class Core(component.Component):
         # Set the user agent
         self.settings = lt.session_settings()
         self.settings.user_agent = "Deluge %s" % deluge.common.get_version()
+        # Increase the alert queue size so that alerts don't get lost
+        self.settings.alert_queue_size = 10000
 
         # Set session settings
         self.settings.send_redundant_have = True
@@ -103,9 +108,11 @@ class Core(component.Component):
         self.session.set_settings(self.settings)
 
         # Load metadata extension
-        self.session.add_extension(lt.create_metadata_plugin)
-        self.session.add_extension(lt.create_ut_metadata_plugin)
-        self.session.add_extension(lt.create_smart_ban_plugin)
+        # Note: All libtorrent python bindings to set plugins/extensions need to be disabled
+        # due to  GIL issue. https://code.google.com/p/libtorrent/issues/detail?id=369
+        # self.session.add_extension(lt.create_metadata_plugin)
+        # self.session.add_extension(lt.create_ut_metadata_plugin)
+        # self.session.add_extension(lt.create_smart_ban_plugin)
 
         # Create the components
         self.eventmanager = EventManager()
@@ -127,8 +134,11 @@ class Core(component.Component):
         # store the one in the config so we can restore it on shutdown
         self.__old_interface = None
         if listen_interface:
-            self.__old_interface = self.config["listen_interface"]
-            self.config["listen_interface"] = 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"""
@@ -270,7 +280,7 @@ class Core(component.Component):
                 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("Error occurred downloading torrent from %s", url)
                 log.error("Reason: %s", failure.getErrorMessage())
                 result = failure
             return result
@@ -414,7 +424,11 @@ class Core(component.Component):
     @export
     def get_torrent_status(self, torrent_id, keys, diff=False):
         # Build the status dictionary
-        status = self.torrentmanager[torrent_id].get_status(keys, diff)
+        try:
+            status = self.torrentmanager[torrent_id].get_status(keys, diff)
+        except KeyError:
+            # Torrent was probaly removed meanwhile
+            return {}
 
         # Get the leftover fields and ask the plugin manager to fill them
         leftover_fields = list(set(keys) - set(status.keys()))
@@ -706,7 +720,8 @@ class Core(component.Component):
     @export
     def queue_top(self, torrent_ids):
         log.debug("Attempting to queue %s to top", torrent_ids)
-        for torrent_id in torrent_ids:
+        # torrent_ids must be sorted in reverse before moving to preserve order
+        for torrent_id in sorted(torrent_ids, key=self.torrentmanager.get_queue_position, reverse=True):
             try:
                 # If the queue method returns True, then we should emit a signal
                 if self.torrentmanager.queue_top(torrent_id):
@@ -717,35 +732,48 @@ class Core(component.Component):
     @export
     def queue_up(self, torrent_ids):
         log.debug("Attempting to queue %s to up", torrent_ids)
+        torrents = ((self.torrentmanager.get_queue_position(torrent_id), torrent_id) for torrent_id in torrent_ids)
+        torrent_moved = True
+        prev_queue_position = None
         #torrent_ids must be sorted before moving.
-        torrent_ids = list(torrent_ids)
-        torrent_ids.sort(key = lambda id: self.torrentmanager.torrents[id].get_queue_position())
-        for torrent_id in torrent_ids:
-            try:
-                # If the queue method returns True, then we should emit a signal
-                if self.torrentmanager.queue_up(torrent_id):
-                    component.get("EventManager").emit(TorrentQueueChangedEvent())
-            except KeyError:
-                log.warning("torrent_id: %s does not exist in the queue", torrent_id)
+        for queue_position, torrent_id in sorted(torrents):
+            # Move the torrent if and only if there is space (by not moving it we preserve the order)
+            if torrent_moved or queue_position - prev_queue_position > 1:
+                try:
+                    torrent_moved = self.torrentmanager.queue_up(torrent_id)
+                except KeyError:
+                    log.warning("torrent_id: %s does not exist in the queue", torrent_id)
+            # If the torrent moved, then we should emit a signal
+            if torrent_moved:
+                component.get("EventManager").emit(TorrentQueueChangedEvent())
+            else:
+                prev_queue_position = queue_position
 
     @export
     def queue_down(self, torrent_ids):
         log.debug("Attempting to queue %s to down", torrent_ids)
+        torrents = ((self.torrentmanager.get_queue_position(torrent_id), torrent_id) for torrent_id in torrent_ids)
+        torrent_moved = True
+        prev_queue_position = None
         #torrent_ids must be sorted before moving.
-        torrent_ids = list(torrent_ids)
-        torrent_ids.sort(key = lambda id: -self.torrentmanager.torrents[id].get_queue_position())
-        for torrent_id in torrent_ids:
-            try:
-                # If the queue method returns True, then we should emit a signal
-                if self.torrentmanager.queue_down(torrent_id):
-                    component.get("EventManager").emit(TorrentQueueChangedEvent())
-            except KeyError:
-                log.warning("torrent_id: %s does not exist in the queue", torrent_id)
+        for queue_position, torrent_id in sorted(torrents, reverse=True):
+            # Move the torrent if and only if there is space (by not moving it we preserve the order)
+            if torrent_moved or prev_queue_position - queue_position > 1:
+                try:
+                    torrent_moved = self.torrentmanager.queue_down(torrent_id)
+                except KeyError:
+                    log.warning("torrent_id: %s does not exist in the queue", torrent_id)
+            # If the torrent moved, then we should emit a signal
+            if torrent_moved:
+                component.get("EventManager").emit(TorrentQueueChangedEvent())
+            else:
+                prev_queue_position = queue_position
 
     @export
     def queue_bottom(self, torrent_ids):
         log.debug("Attempting to queue %s to bottom", torrent_ids)
-        for torrent_id in torrent_ids:
+        # torrent_ids must be sorted before moving to preserve order
+        for torrent_id in sorted(torrent_ids, key=self.torrentmanager.get_queue_position):
             try:
                 # If the queue method returns True, then we should emit a signal
                 if self.torrentmanager.queue_bottom(torrent_id):

deluge/core/daemon.py

@@ -62,13 +62,8 @@ class Daemon(object):
 
             def process_running(pid):
                 if deluge.common.windows_check():
-                    # Do some fancy WMI junk to see if the PID exists in Windows
-                    from win32com.client import GetObject
-                    def get_proclist():
-                        WMI = GetObject('winmgmts:')
-                        processes = WMI.InstancesOf('Win32_Process')
-                        return [process.Properties_('ProcessID').Value for process in processes]
-                    return pid in get_proclist()
+                    import win32process
+                    return pid in win32process.EnumProcesses()
                 else:
                     # We can just use os.kill on UNIX to test if the process is running
                     try:

deluge/core/eventmanager.py

@@ -55,8 +55,8 @@ class EventManager(component.Component):
                 #log.debug("Running handler %s for event %s with args: %s", event.name, handler, event.args)
                 try:
                     handler(*event.args)
-                except:
-                    log.error("Event handler %s failed in %s", event.name, handler)
+                except Exception, e:
+                    log.error("Event handler %s failed in %s with exception %s", event.name, handler, e)
 
     def register_event_handler(self, event, handler):
         """

deluge/core/filtermanager.py

@@ -126,12 +126,11 @@ class FilterManager(component.Component):
 
         #sanitize input: filter-value must be a list of strings
         for key, value in filter_dict.items():
-            if isinstance(value, str):
-                filter_dict[key]  = [value]
+            if isinstance(value, basestring):
+                filter_dict[key] = [value]
 
-
-        if "id"in filter_dict: #optimized filter for id:
-            torrent_ids = filter_dict["id"]
+        if "id" in filter_dict: #optimized filter for id:
+            torrent_ids = list(filter_dict["id"])
             del filter_dict["id"]
         else:
             torrent_ids = self.torrents.get_torrent_list()

deluge/core/preferencesmanager.py

@@ -251,7 +251,7 @@ class PreferencesManager(component.Component):
         # Only set the listen ports if random_port is not true
         if self.config["random_port"] is not True:
             log.debug("listen port range set to %s-%s", value[0], value[1])
-            self.session.listen_on(value[0], value[1], str(self.config["listen_interface"]))
+            self.session.listen_on(value[0], value[1], str(self.config["listen_interface"]).strip())
 
     def _on_set_listen_interface(self, key, value):
         # Call the random_port callback since it'll do what we need
@@ -273,7 +273,7 @@ class PreferencesManager(component.Component):
         # Set the listen ports
         log.debug("listen port range set to %s-%s", listen_ports[0],
             listen_ports[1])
-        self.session.listen_on(listen_ports[0], listen_ports[1], str(self.config["listen_interface"]))
+        self.session.listen_on(listen_ports[0], listen_ports[1], str(self.config["listen_interface"]).strip())
 
     def _on_set_outgoing_ports(self, key, value):
         if not self.config["random_outgoing_ports"]:
@@ -338,15 +338,19 @@ class PreferencesManager(component.Component):
     def _on_set_utpex(self, key, value):
         log.debug("utpex value set to %s", value)
         if value:
-            self.session.add_extension(lt.create_ut_pex_plugin)
+            # Note: All libtorrent python bindings to set plugins/extensions need to be disabled
+            # due to  GIL issue. https://code.google.com/p/libtorrent/issues/detail?id=369
+            #self.session.add_extension(lt.create_ut_pex_plugin)
+            pass
 
     def _on_set_encryption(self, key, value):
         log.debug("encryption value %s set to %s..", key, value)
+        pe_enc_level = {0: lt.enc_level.plaintext, 1: lt.enc_level.rc4, 2: lt.enc_level.both}
         pe_settings = lt.pe_settings()
         pe_settings.out_enc_policy = \
             lt.enc_policy(self.config["enc_out_policy"])
         pe_settings.in_enc_policy = lt.enc_policy(self.config["enc_in_policy"])
-        pe_settings.allowed_enc_level = lt.enc_level(self.config["enc_level"])
+        pe_settings.allowed_enc_level = lt.enc_level(pe_enc_level[self.config["enc_level"]])
         pe_settings.prefer_rc4 = self.config["enc_prefer_rc4"]
         self.session.set_pe_settings(pe_settings)
         set = self.session.get_pe_settings()
@@ -468,15 +472,14 @@ class PreferencesManager(component.Component):
 
     def _on_set_proxies(self, key, value):
         for k, v in value.items():
-            if v["type"]:
-                proxy_settings = lt.proxy_settings()
-                proxy_settings.type = lt.proxy_type(v["type"])
-                proxy_settings.username = str(v["username"])
-                proxy_settings.password = str(v["password"])
-                proxy_settings.hostname = str(v["hostname"])
-                proxy_settings.port = v["port"]
-                log.debug("setting %s proxy settings", k)
-                getattr(self.session, "set_%s_proxy" % k)(proxy_settings)
+            proxy_settings = lt.proxy_settings()
+            proxy_settings.type = lt.proxy_type(v["type"])
+            proxy_settings.username = str(v["username"])
+            proxy_settings.password = str(v["password"])
+            proxy_settings.hostname = str(v["hostname"])
+            proxy_settings.port = v["port"]
+            log.debug("setting %s proxy settings", k)
+            getattr(self.session, "set_%s_proxy" % k)(proxy_settings)
 
     def _on_rate_limit_ip_overhead(self, key, value):
         log.debug("%s: %s", key, value)

deluge/core/rpcserver.py

@@ -465,7 +465,7 @@ class RPCServer(component.Component):
         """
         log.debug("intevents: %s", self.factory.interested_events)
         # Find sessions interested in this event
-        for session_id, interest in self.factory.interested_events.iteritems():
+        for session_id, interest in self.factory.interested_events.items():
             if event.name in interest:
                 log.debug("Emit Event: %s %s", event.name, event.args)
                 # This session is interested so send a RPC_EVENT

deluge/core/torrent.py

@@ -174,7 +174,7 @@ class Torrent(object):
             self.trackers = []
             # Create a list of trackers
             for value in self.handle.trackers():
-                if lt.version_minor < 15:
+                if lt.version_major == 0 and lt.version_minor < 15:
                     tracker = {}
                     tracker["url"] = value.url
                     tracker["tier"] = value.tier
@@ -260,11 +260,11 @@ class Torrent(object):
         self.handle.set_download_limit(v)
 
     def set_prioritize_first_last(self, prioritize):
-        self.options["prioritize_first_last_pieces"] = prioritize
         if prioritize:
             if self.handle.has_metadata():
                 if self.handle.get_torrent_info().num_files() == 1:
                     # We only do this if one file is in the torrent
+                    self.options["prioritize_first_last_pieces"] = prioritize
                     priorities = [1] * self.handle.get_torrent_info().num_pieces()
                     priorities[0] = 7
                     priorities[-1] = 7
@@ -478,7 +478,8 @@ class Torrent(object):
         for index, file in enumerate(files):
             ret.append({
                 'index': index,
-                'path': file.path.decode("utf8", "ignore"),
+                # Make path separators consistent across platforms
+                'path': file.path.decode("utf8").replace('\\', '/'),
                 'size': file.size,
                 'offset': file.offset
             })
@@ -667,7 +668,7 @@ class Torrent(object):
 
         def ti_name():
             if self.handle.has_metadata():
-                name = self.torrent_info.file_at(0).path.split("/", 1)[0]
+                name = self.torrent_info.file_at(0).path.replace("\\", "/", 1).split("/", 1)[0]
                 if not name:
                     name = self.torrent_info.name()
                 try:
@@ -833,26 +834,30 @@ 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:
-           dest_u = unicode(dest, "utf-8")
+           dest = unicode(dest, "utf-8")
         except TypeError:
            # String is already unicode
-           dest_u = dest
+           pass
 
-        if not os.path.exists(dest_u):
+        if not os.path.exists(dest):
             try:
                 # Try to make the destination path if it doesn't exist
-                os.makedirs(dest_u)
+                os.makedirs(dest)
             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
+
+        dest_bytes = dest.encode('utf-8')
         try:
-            self.handle.move_storage(dest_u)
-        except:
+            # libtorrent needs unicode object if wstrings are enabled, utf8 bytestring otherwise
+            try:
+                self.handle.move_storage(dest)
+            except TypeError:
+                self.handle.move_storage(dest_bytes)
+        except Exception, e:
+            log.error("Error calling libtorrent move_storage: %s" % e)
             return False
 
         return True
@@ -863,6 +868,11 @@ class Torrent(object):
         self.handle.save_resume_data()
         self.waiting_on_resume_data = True
 
+    def on_metadata_received(self):
+        if self.options["prioritize_first_last_pieces"]:
+            self.set_prioritize_first_last(True)
+        self.write_torrentfile()
+
     def write_torrentfile(self):
         """Writes the torrent file"""
         path = "%s/%s.torrent" % (
@@ -928,8 +938,17 @@ class Torrent(object):
         """Renames files in the torrent. 'filenames' should be a list of
         (index, filename) pairs."""
         for index, filename in filenames:
+            # Make sure filename is a unicode object
+            try:
+                filename = unicode(filename, "utf-8")
+            except TypeError:
+                pass
             filename = sanitize_filepath(filename)
-            self.handle.rename_file(index, filename.encode("utf-8"))
+            # libtorrent needs unicode object if wstrings are enabled, utf8 bytestring otherwise
+            try:
+                self.handle.rename_file(index, filename)
+            except TypeError:
+                self.handle.rename_file(index, filename.encode("utf-8"))
 
     def rename_folder(self, folder, new_folder):
         """Renames a folder within a torrent.  This basically does a file rename
@@ -946,7 +965,11 @@ class Torrent(object):
             if f["path"].startswith(folder):
                 # Keep a list of filerenames we're waiting on
                 wait_on_folder[2].append(f["index"])
-                self.handle.rename_file(f["index"], f["path"].replace(folder, new_folder, 1).encode("utf-8"))
+                new_path = f["path"].replace(folder, new_folder, 1)
+                try:
+                    self.handle.rename_file(f["index"], new_path)
+                except TypeError:
+                    self.handle.rename_file(f["index"], new_path.encode("utf-8"))
         self.waiting_on_folder_rename.append(wait_on_folder)
 
     def cleanup_prev_status(self):

deluge/core/torrentmanager.py

@@ -55,7 +55,7 @@ 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.common import utf8_encoded
+from deluge.common import utf8_encoded, decode_string
 
 from deluge.log import LOG as log
 
@@ -138,6 +138,7 @@ class TorrentManager(component.Component):
 
         # Create the torrents dict { torrent_id: Torrent }
         self.torrents = {}
+        self.queued_torrents = set()
 
         # This is a list of torrent_id when we shutdown the torrentmanager.
         # We use this list to determine if all active torrents have been paused
@@ -147,6 +148,9 @@ class TorrentManager(component.Component):
         # self.num_resume_data used to save resume_data in bulk
         self.num_resume_data = 0
 
+        # Keep track of torrents finished but moving storage
+        self.waiting_on_finish_moving = []
+
         # Keeps track of resume data that needs to be saved to disk
         self.resume_data = {}
 
@@ -180,6 +184,8 @@ class TorrentManager(component.Component):
             self.on_alert_tracker_error)
         self.alerts.register_handler("storage_moved_alert",
             self.on_alert_storage_moved)
+        self.alerts.register_handler("storage_moved_failed_alert",
+            self.on_alert_storage_moved_failed)
         self.alerts.register_handler("torrent_resumed_alert",
             self.on_alert_torrent_resumed)
         self.alerts.register_handler("state_changed_alert",
@@ -375,14 +381,20 @@ class TorrentManager(component.Component):
                 resume_data = self.legacy_get_resume_data_from_file(state.torrent_id)
                 self.legacy_delete_resume_data(state.torrent_id)
 
-            add_torrent_params["resume_data"] = resume_data
+            if resume_data:
+                add_torrent_params["resume_data"] = resume_data
         else:
             # 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 this torrent id is already in the session, merge any additional trackers.
                 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)
+                    log.info("Merging trackers for torrent (%s) already in session...", add_torrent_id)
+                    # Don't merge trackers if either torrent has private flag set
+                    if self[add_torrent_id].get_status(["private"])["private"]:
+                        log.info("Merging trackers abandoned: Torrent has private flag set.")
+                        return
+
                     add_torrent_trackers = []
                     for value in torrent_info.trackers():
                         tracker = {}
@@ -392,17 +404,18 @@ class TorrentManager(component.Component):
 
                     torrent_trackers = {}
                     tracker_list = []
-                    for tracker in  self[add_torrent_id].get_status(["trackers"])["trackers"]:
+                    for tracker in self[add_torrent_id].get_status(["trackers"])["trackers"]:
                         torrent_trackers[(tracker["url"])] = tracker
                         tracker_list.append(tracker)
 
-                    added_tracker = False
+                    added_tracker = 0
                     for tracker in add_torrent_trackers:
                         if tracker['url'] not in torrent_trackers:
                             tracker_list.append(tracker)
-                            added_tracker = True
+                            added_tracker += 1
 
                     if added_tracker:
+                        log.info("%s tracker(s) merged into torrent.", added_tracker)
                         self[add_torrent_id].set_trackers(tracker_list)
                     return
 
@@ -417,13 +430,19 @@ class TorrentManager(component.Component):
             # Check for renamed files and if so, rename them in the torrent_info
             # before adding to the session.
             if options["mapped_files"]:
-                for index, filename in options["mapped_files"].items():
-                    filename = deluge.core.torrent.sanitize_filepath(filename)
-                    log.debug("renaming file index %s to %s", index, filename)
-                    torrent_info.rename_file(index, utf8_encoded(filename))
+                for index, fname in options["mapped_files"].items():
+                    try:
+                        fname = unicode(fname, "utf-8")
+                    except TypeError:
+                        pass
+                    fname = deluge.core.torrent.sanitize_filepath(fname)
+                    log.debug("renaming file index %s to %s", index, fname)
+                    try:
+                        torrent_info.rename_file(index, fname)
+                    except TypeError:
+                        torrent_info.rename_file(index, fname.encode("utf-8"))
 
             add_torrent_params["ti"] = torrent_info
-            add_torrent_params["resume_data"] = ""
 
         #log.info("Adding torrent: %s", filename)
         log.debug("options: %s", options)
@@ -476,6 +495,9 @@ class TorrentManager(component.Component):
         if not options["add_paused"]:
             torrent.resume()
 
+        # Add to queued torrents set
+        self.queued_torrents.add(torrent.torrent_id)
+
         # Write the .torrent file to the state directory
         if filedump:
             try:
@@ -542,12 +564,11 @@ class TorrentManager(component.Component):
         :raises InvalidTorrentError: if the torrent_id is not in the session
 
         """
-
-        if torrent_id not in self.torrents:
+        try:
+            torrent_name = self.torrents[torrent_id].get_status(["name"])["name"]
+        except KeyError:
             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))
 
@@ -584,10 +605,17 @@ class TorrentManager(component.Component):
         # Stop the looping call
         self.torrents[torrent_id].prev_status_cleanup_loop.stop()
 
+        # Remove from set if it wasn't finished
+        if not self.torrents[torrent_id].is_finished:
+            try:
+                self.queued_torrents.remove(torrent_id)
+            except KeyError:
+                log.debug("%s isn't in queued torrents set?", torrent_id)
+
         # Remove the torrent from deluge's session
         try:
             del self.torrents[torrent_id]
-        except KeyError, ValueError:
+        except (KeyError, ValueError):
             return False
 
         # Save the session state
@@ -623,7 +651,7 @@ class TorrentManager(component.Component):
 
         # Reorder the state.torrents list to add torrents in the correct queue
         # order.
-        state.torrents.sort(key=operator.attrgetter("queue"))
+        state.torrents.sort(key=operator.attrgetter("queue"), reverse=self.config["queue_new_to_top"])
 
         resume_data = self.load_resume_data_file()
 
@@ -747,6 +775,7 @@ class TorrentManager(component.Component):
             return
 
         path = os.path.join(get_config_dir(), "state", "torrents.fastresume")
+        path_tmp = path + ".tmp"
 
         # First step is to load the existing file and update the dictionary
         if resume_data is None:
@@ -757,11 +786,12 @@ class TorrentManager(component.Component):
 
         try:
             log.debug("Saving fastresume file: %s", path)
-            fastresume_file = open(path, "wb")
+            fastresume_file = open(path_tmp, "wb")
             fastresume_file.write(lt.bencode(resume_data))
             fastresume_file.flush()
             os.fsync(fastresume_file.fileno())
             fastresume_file.close()
+            shutil.move(path_tmp, path)
         except IOError:
             log.warning("Error trying to save fastresume file")
 
@@ -771,10 +801,10 @@ class TorrentManager(component.Component):
         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'])
+        try:
+            info = self.torrents[torrent_id].get_status(['save_path'])
+        except KeyError:
+            raise InvalidTorrentError("torrent_id not in session")
         # 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)
@@ -798,6 +828,10 @@ class TorrentManager(component.Component):
         except OSError, (errno, strerror):
             log.debug("Cannot Remove Folder: %s (ErrNo %s)", strerror, errno)
 
+    def get_queue_position(self, torrent_id):
+        """Get queue position of torrent"""
+        return self.torrents[torrent_id].get_queue_position()
+
     def queue_top(self, torrent_id):
         """Queue torrent to top"""
         if self.torrents[torrent_id].get_queue_position() == 0:
@@ -816,7 +850,7 @@ class TorrentManager(component.Component):
 
     def queue_down(self, torrent_id):
         """Queue torrent down one position"""
-        if self.torrents[torrent_id].get_queue_position() == (len(self.torrents) - 1):
+        if self.torrents[torrent_id].get_queue_position() == (len(self.queued_torrents) - 1):
             return False
 
         self.torrents[torrent_id].handle.queue_position_down()
@@ -824,7 +858,7 @@ class TorrentManager(component.Component):
 
     def queue_bottom(self, torrent_id):
         """Queue torrent to bottom"""
-        if self.torrents[torrent_id].get_queue_position() == (len(self.torrents) - 1):
+        if self.torrents[torrent_id].get_queue_position() == (len(self.queued_torrents) - 1):
             return False
 
         self.torrents[torrent_id].handle.queue_position_bottom()
@@ -866,19 +900,25 @@ class TorrentManager(component.Component):
         # that the torrent wasn't downloaded, but just added.
         total_download = torrent.get_status(["total_payload_download"])["total_payload_download"]
 
-        # Move completed download to completed folder if needed
-        if not torrent.is_finished and total_download:
-            move_path = None
-
-            if torrent.options["move_completed"]:
-                move_path = torrent.options["move_completed_path"]
-                if torrent.options["download_location"] != move_path:
-                    torrent.move_storage(move_path)
-
-            component.get("EventManager").emit(TorrentFinishedEvent(torrent_id))
-
-        torrent.is_finished = True
         torrent.update_state()
+        if not torrent.is_finished and total_download:
+            # Move completed download to completed folder if needed
+            if torrent.options["move_completed"] and \
+                    torrent.options["download_location"] != torrent.options["move_completed_path"]:
+                self.waiting_on_finish_moving.append(torrent_id)
+                torrent.move_storage(torrent.options["move_completed_path"])
+            else:
+                torrent.is_finished = True
+                component.get("EventManager").emit(TorrentFinishedEvent(torrent_id))
+        else:
+            torrent.is_finished = True
+
+        # Torrent is no longer part of the queue
+        try:
+            self.queued_torrents.remove(torrent_id)
+        except KeyError:
+            # Sometimes libtorrent fires a TorrentFinishedEvent twice
+            log.debug("%s isn't in queued torrents set?", torrent_id)
 
         # Only save resume data if it was actually downloaded something. Helps
         # on startup with big queues with lots of seeding torrents. Libtorrent
@@ -928,7 +968,7 @@ class TorrentManager(component.Component):
         torrent.update_state()
 
     def on_alert_tracker_reply(self, alert):
-        log.debug("on_alert_tracker_reply: %s", alert.message().decode("utf8"))
+        log.debug("on_alert_tracker_reply: %s", decode_string(alert.message()))
         try:
             torrent = self.torrents[str(alert.handle.info_hash())]
         except:
@@ -960,7 +1000,7 @@ class TorrentManager(component.Component):
             torrent = self.torrents[str(alert.handle.info_hash())]
         except:
             return
-        tracker_status = '%s: %s' % (_("Warning"), str(alert.message()))
+        tracker_status = '%s: %s' % (_("Warning"), decode_string(alert.message()))
         # Set the tracker status for the torrent
         torrent.set_tracker_status(tracker_status)
 
@@ -976,12 +1016,32 @@ class TorrentManager(component.Component):
     def on_alert_storage_moved(self, alert):
         log.debug("on_alert_storage_moved")
         try:
-            torrent = self.torrents[str(alert.handle.info_hash())]
-        except:
+            torrent_id = str(alert.handle.info_hash())
+            torrent = self.torrents[torrent_id]
+        except (RuntimeError, KeyError):
             return
         torrent.set_save_path(os.path.normpath(alert.handle.save_path()))
         torrent.set_move_completed(False)
 
+        if torrent_id in self.waiting_on_finish_moving:
+            self.waiting_on_finish_moving.remove(torrent_id)
+            torrent.is_finished = True
+            component.get("EventManager").emit(TorrentFinishedEvent(torrent_id))
+
+    def on_alert_storage_moved_failed(self, alert):
+        """Alert handler for libtorrent storage_moved_failed_alert"""
+        log.debug("on_alert_storage_moved_failed: %s", decode_string(alert.message()))
+        try:
+            torrent_id = str(alert.handle.info_hash())
+            torrent = self.torrents[torrent_id]
+        except (RuntimeError, KeyError):
+            return
+
+        if torrent_id in self.waiting_on_finish_moving:
+            self.waiting_on_finish_moving.remove(torrent_id)
+            torrent.is_finished = True
+            component.get("EventManager").emit(TorrentFinishedEvent(torrent_id))
+
     def on_alert_torrent_resumed(self, alert):
         log.debug("on_alert_torrent_resumed")
         try:
@@ -1010,6 +1070,7 @@ class TorrentManager(component.Component):
         # Torrent may need to download data after checking.
         if torrent.state in ('Checking', 'Checking Resume Data', 'Downloading'):
             torrent.is_finished = False
+            self.queued_torrents.add(torrent_id)
 
         # Only emit a state changed event if the state has actually changed
         if torrent.state != old_state:
@@ -1032,7 +1093,7 @@ class TorrentManager(component.Component):
         self.save_resume_data_file()
 
     def on_alert_save_resume_data_failed(self, alert):
-        log.debug("on_alert_save_resume_data_failed: %s", alert.message())
+        log.debug("on_alert_save_resume_data_failed: %s", decode_string(alert.message()))
         try:
             torrent = self.torrents[str(alert.handle.info_hash())]
         except:
@@ -1046,7 +1107,7 @@ class TorrentManager(component.Component):
 
     def on_alert_file_renamed(self, alert):
         log.debug("on_alert_file_renamed")
-        log.debug("index: %s name: %s", alert.index, alert.name.decode("utf8"))
+        log.debug("index: %s name: %s", alert.index, decode_string(alert.name))
         try:
             torrent = self.torrents[str(alert.handle.info_hash())]
             torrent_id = str(alert.handle.info_hash())
@@ -1081,10 +1142,10 @@ class TorrentManager(component.Component):
             torrent = self.torrents[str(alert.handle.info_hash())]
         except:
             return
-        torrent.write_torrentfile()
+        torrent.on_metadata_received()
 
     def on_alert_file_error(self, alert):
-        log.debug("on_alert_file_error: %s", alert.message())
+        log.debug("on_alert_file_error: %s", decode_string(alert.message()))
         try:
             torrent = self.torrents[str(alert.handle.info_hash())]
         except:
@@ -1092,7 +1153,7 @@ class TorrentManager(component.Component):
         torrent.update_state()
 
     def on_alert_file_completed(self, alert):
-        log.debug("file_completed_alert: %s", alert.message())
+        log.debug("file_completed_alert: %s", decode_string(alert.message()))
         try:
             torrent_id = str(alert.handle.info_hash())
         except:

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

@@ -9,6 +9,7 @@ Exec=deluge-gtk %U
 Icon=deluge
 Terminal=false
 Type=Application
-Categories=Network;FileTransfer;P2P;GTK
+Categories=Network;FileTransfer;P2P;GTK;
+StartupWMClass=Deluge
 StartupNotify=true
 MimeType=application/x-bittorrent;x-scheme-handler/magnet;

deluge/httpdownloader.py

@@ -192,7 +192,17 @@ def download_file(url, filename, callback=None, headers=None, force_filename=Fal
             headers = {}
         headers["accept-encoding"] = "deflate, gzip, x-gzip"
 
-    scheme, host, port, path = client._parse(url)
+    # In twisted 13.1.0 the _parse() function was replaced by the _URI class 
+    if hasattr(client, '_parse'):
+        scheme, host, port, path = client._parse(url)
+    else:
+        from twisted.web.client import _URI
+        uri = _URI.fromBytes(url)
+        scheme = uri.scheme
+        host = uri.host
+        port = uri.port
+        path = uri.path
+        
     factory = HTTPDownloader(url, filename, callback, headers, force_filename, allow_compression)
     if scheme == "https":
         from twisted.internet import ssl

deluge/i18n/ast.po

@@ -2224,7 +2224,7 @@ msgid "Up:"
 msgstr "Unvíu:"
 
 #: deluge/ui/gtkui/aboutdialog.py:59
-msgid "Copyright 2007-2011 Deluge Team"
+msgid "Copyright 2007-2014 Deluge Team"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:61

deluge/i18n/cy.po

@@ -2221,7 +2221,7 @@ msgid "Up:"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:59
-msgid "Copyright 2007-2011 Deluge Team"
+msgid "Copyright 2007-2014 Deluge Team"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:61

deluge/i18n/eo.po

@@ -2221,7 +2221,7 @@ msgid "Up:"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:59
-msgid "Copyright 2007-2011 Deluge Team"
+msgid "Copyright 2007-2014 Deluge Team"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:61

deluge/i18n/fy.po

@@ -2223,7 +2223,7 @@ msgid "Up:"
 msgstr "Omheech:"
 
 #: deluge/ui/gtkui/aboutdialog.py:59
-msgid "Copyright 2007-2011 Deluge Team"
+msgid "Copyright 2007-2014 Deluge Team"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:61

deluge/i18n/iu.po

@@ -2221,7 +2221,7 @@ msgid "Up:"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:59
-msgid "Copyright 2007-2011 Deluge Team"
+msgid "Copyright 2007-2014 Deluge Team"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:61

deluge/i18n/kn.po

@@ -2221,7 +2221,7 @@ msgid "Up:"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:59
-msgid "Copyright 2007-2011 Deluge Team"
+msgid "Copyright 2007-2014 Deluge Team"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:61

deluge/i18n/ku.po

@@ -2221,7 +2221,7 @@ msgid "Up:"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:59
-msgid "Copyright 2007-2011 Deluge Team"
+msgid "Copyright 2007-2014 Deluge Team"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:61

deluge/i18n/la.po

@@ -2221,7 +2221,7 @@ msgid "Up:"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:59
-msgid "Copyright 2007-2011 Deluge Team"
+msgid "Copyright 2007-2014 Deluge Team"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:61

deluge/i18n/ml.po

@@ -2221,7 +2221,7 @@ msgid "Up:"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:59
-msgid "Copyright 2007-2011 Deluge Team"
+msgid "Copyright 2007-2014 Deluge Team"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:61

deluge/i18n/nds.po

@@ -2221,7 +2221,7 @@ msgid "Up:"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:59
-msgid "Copyright 2007-2011 Deluge Team"
+msgid "Copyright 2007-2014 Deluge Team"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:61

deluge/i18n/pms.po

@@ -2221,7 +2221,7 @@ msgid "Up:"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:59
-msgid "Copyright 2007-2011 Deluge Team"
+msgid "Copyright 2007-2014 Deluge Team"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:61

deluge/i18n/ta.po

@@ -2221,7 +2221,7 @@ msgid "Up:"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:59
-msgid "Copyright 2007-2011 Deluge Team"
+msgid "Copyright 2007-2014 Deluge Team"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:61

deluge/i18n/tl.po

@@ -2221,7 +2221,7 @@ msgid "Up:"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:59
-msgid "Copyright 2007-2011 Deluge Team"
+msgid "Copyright 2007-2014 Deluge Team"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:61

deluge/i18n/tlh.po

@@ -2221,7 +2221,7 @@ msgid "Up:"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:59
-msgid "Copyright 2007-2011 Deluge Team"
+msgid "Copyright 2007-2014 Deluge Team"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:61

deluge/i18n/zh_HK.po

@@ -2221,7 +2221,7 @@ msgid "Up:"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:59
-msgid "Copyright 2007-2011 Deluge Team"
+msgid "Copyright 2007-2014 Deluge Team"
 msgstr ""
 
 #: deluge/ui/gtkui/aboutdialog.py:61

deluge/main.py

@@ -42,6 +42,8 @@
 import os
 import sys
 from optparse import OptionParser
+from logging import FileHandler
+from errno import EEXIST
 
 import deluge.log
 import deluge.common
@@ -86,6 +88,14 @@ def start_ui():
     # Get the options and args from the OptionParser
     (options, args) = parser.parse_args()
 
+    # Setup the logger
+    if options.quiet:
+        options.loglevel = "none"
+    if options.loglevel:
+        options.loglevel = options.loglevel.lower()
+    deluge.log.setupLogger(level=options.loglevel, filename=options.logfile)
+    from deluge.log import LOG as log
+
     if options.config:
         if not os.path.exists(options.config):
             # Try to create the config folder if it doesn't exist
@@ -94,7 +104,7 @@ def start_ui():
             except Exception, e:
                 pass
         elif not os.path.isdir(options.config):
-            print "Config option needs to be a directory!"
+            log.error("Config option needs to be a directory!")
             sys.exit(1)
     else:
         if not os.path.exists(deluge.common.get_default_config_dir()):
@@ -110,18 +120,8 @@ def start_ui():
         print "The default UI has been changed to", options.default_ui
         sys.exit(0)
 
-    if options.quiet:
-        options.loglevel = "none"
-
-    if options.loglevel:
-        options.loglevel = options.loglevel.lower()
-
-    # Setup the logger
-    deluge.log.setupLogger(level=options.loglevel, filename=options.logfile)
-
     version = deluge.common.get_version()
 
-    from deluge.log import LOG as log
     log.info("Deluge ui %s", version)
     log.debug("options: %s", options)
     log.debug("args: %s", args)
@@ -170,18 +170,31 @@ this should be an IP address", metavar="IFACE",
     # Get the options and args from the OptionParser
     (options, args) = parser.parse_args()
 
+    # Setup the logger
     if options.quiet:
         options.loglevel = "none"
+    if options.logfile:
+        # Try to create the logfile's directory if it doesn't exist
+        try:
+            os.makedirs(os.path.abspath(os.path.dirname(options.logfile)))
+        except OSError, e:
+            if e.errno != EEXIST:
+                print "There was an error creating the log directory, exiting... (%s)" % e
+                sys.exit(1)
+    deluge.log.setupLogger(level=options.loglevel, filename=options.logfile)
+    from deluge.log import LOG as log
 
     if options.config:
         if not deluge.configmanager.set_config_dir(options.config):
-            print("There was an error setting the config dir! Exiting..")
+            log.error("There was an error setting the config directory! Exiting...")
             sys.exit(1)
 
     # Sets the options.logfile to point to the default location
     def open_logfile():
         if not options.logfile:
             options.logfile = deluge.configmanager.get_config_dir("deluged.log")
+            file_handler = FileHandler(options.logfile)
+            log.addHandler(file_handler)
 
     # Writes out a pidfile if necessary
     def write_pidfile():
@@ -208,15 +221,6 @@ this should be an IP address", metavar="IFACE",
         # Do not daemonize
         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
-
     if options.profile:
         import hotshot
         hsp = hotshot.Profile(deluge.configmanager.get_config_dir("deluged.profile"))

deluge/pluginmanagerbase.py

@@ -174,6 +174,12 @@ class PluginManagerBase:
         info = {}.fromkeys(METADATA_KEYS)
         last_header = ""
         cont_lines = []
+        # Missing plugin info
+        if not self.pkg_env[name]:
+            log.warn("Failed to retrive info for plugin '%s'" % name)
+            for k in info:
+                info[k] = _("Not available")
+            return info
         for line in self.pkg_env[name][0].get_metadata("PKG-INFO").splitlines():
             if not line:
                 continue
@@ -187,5 +193,4 @@ class PluginManagerBase:
                 if line.split(":", 1)[0] in info.keys():
                     last_header = line.split(":", 1)[0]
                     info[last_header] = line.split(":", 1)[1].strip()
-
         return info