Release 2.0.3

Include the correct usage for other display servers.

Still not sure how to get the proper timestamp for Wayland or Quartz but
I read that using 0 equals the GDK_CURRENT_TIME which suffices for now.

.gitattributes

@@ -1,25 +1,5 @@
-/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
 *.py diff=python
+ext-all.js diff=minjs

.gitignore

@@ -1,14 +1,24 @@
 *~
 build
+.cache
 dist
-*egg-info
+docs/source/modules/deluge*.rst
+*.egg-info/
+*.dist-info/
 *.egg
 *.log
-*.pyc
+__pycache__/
+*.py[cod]
 *.tar.*
 _trial_temp
+.tox/
 deluge/i18n/*/
+deluge.pot
+deluge/ui/web/js/*.js
+deluge/ui/web/js/extjs/ext-extensions*.js
 *.desktop
+*.appdata.xml
 .build_data*
 osx/app
 RELEASE-VERSION
+.venv*

.pre-commit-config.yaml

@@ -0,0 +1,41 @@
+default_language_version:
+  python: python3
+exclude: >
+  (?x)^(
+      deluge/ui/web/docs/template/.*|
+  )$
+repos:
+  - repo: https://github.com/ambv/black
+    rev: 19.3b0
+    hooks:
+      - id: black
+        name: Fmt Black
+        language_version: python3.6
+  - repo: https://github.com/prettier/prettier
+    rev: 1.17.0
+    hooks:
+      - id: prettier
+        name: Fmt Prettier
+        # Workaround to list modified files only.
+        args: [--list-different]
+  - repo: https://gitlab.com/pycqa/flake8
+    rev: 3.7.7
+    hooks:
+      - id: flake8
+        name: Chk Flake8
+        additional_dependencies:
+          - flake8-isort==2.7
+          - pep8-naming==0.8.2
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v2.2.1
+    hooks:
+      - id: double-quote-string-fixer
+        name: Fix Double-quotes
+      - id: end-of-file-fixer
+        name: Fix End-of-files
+        exclude_types: [javascript, css]
+      - id: mixed-line-ending
+        name: Fix Line endings
+        args: [--fix=auto]
+      - id: trailing-whitespace
+        name: Fix Trailing whitespace

.prettierignore

@@ -0,0 +1,6 @@
+deluge/ui/web/css/ext-*.css
+deluge/ui/web/js/extjs/ext-*.js
+deluge/ui/web/docs/
+deluge/ui/web/themes/images/
+*.py*
+*.html

.prettierrc.yaml

@@ -0,0 +1,13 @@
+trailingComma: "es5"
+tabWidth: 4
+singleQuote: true
+overrides:
+  - files:
+      - "*.yaml"
+      - ".*.yaml"
+      - "*.yml"
+      - ".*.yml"
+      - "*.md"
+    options:
+      tabWidth: 2
+      singleQuote: false

.pylintrc

@@ -0,0 +1,425 @@
+[MASTER]
+
+# Specify a configuration file.
+#rcfile=
+
+# Python code to execute, usually for sys.path manipulation such as
+# pygtk.require().
+#init-hook=
+
+# Add files or directories to the blacklist. They should be base names, not
+# paths.
+ignore=CVS
+
+# Add files or directories matching the regex patterns to the blacklist. The
+# regex matches against base names, not paths.
+ignore-patterns=
+
+# Pickle collected data for later comparisons.
+persistent=yes
+
+# List of plugins (as comma separated values of python modules names) to load,
+# usually to register additional checkers.
+load-plugins=
+
+# Use multiple processes to speed up Pylint.
+jobs=2
+
+# Allow loading of arbitrary C extensions. Extensions are imported into the
+# active Python interpreter and may run arbitrary code.
+unsafe-load-any-extension=no
+
+# A comma-separated list of package or module names from where C extensions may
+# be loaded. Extensions are loading into the active Python interpreter and may
+# run arbitrary code
+extension-pkg-whitelist=
+
+# Allow optimization of some AST trees. This will activate a peephole AST
+# optimizer, which will apply various small optimizations. For instance, it can
+# be used to obtain the result of joining multiple strings with the addition
+# operator. Joining a lot of strings can lead to a maximum recursion error in
+# Pylint and this flag can prevent that. It has one side effect, the resulting
+# AST will be different than the one from reality. This option is deprecated
+# and it will be removed in Pylint 2.0.
+optimize-ast=no
+
+
+[MESSAGES CONTROL]
+
+# Only show warnings with the listed confidence levels. Leave empty to show
+# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED
+confidence=
+
+# Enable the message, report, category or checker with the given id(s). You can
+# either give multiple identifier separated by comma (,) or put this option
+# multiple time (only on the command line, not in the configuration file where
+# it should appear only once). See also the "--disable" option for examples.
+#enable=
+
+# Disable the message, report, category or checker with the given id(s). You
+# can either give multiple identifiers separated by comma (,) or put this
+# option multiple times (only on the command line, not in the configuration
+# file where it should appear only once).You can also use "--disable=all" to
+# disable everything first and then reenable specific checks. For example, if
+# you want to run only the similarities checker, you can use "--disable=all
+# --enable=similarities". If you want to run only the classes checker, but have
+# no Warning level messages displayed, use"--disable=all --enable=classes
+# --disable=W"
+#
+# Arranged by category and use symbolic names instead of ids.
+disable=
+# Convention
+    missing-docstring, invalid-name, bad-continuation,
+# Error
+    no-member, no-name-in-module,
+# Information
+    locally-disabled,
+# Refactor
+    no-self-use, too-many-arguments, too-many-branches, too-many-instance-attributes,
+    too-many-locals, too-few-public-methods, too-many-public-methods, too-many-statements,
+# Refactor msgs that should eventually be enabled:
+    redefined-variable-type, too-many-ancestors,
+    too-many-nested-blocks, too-many-return-statements,
+# Warning
+    unused-argument, protected-access, import-error, unused-variable,
+    attribute-defined-outside-init,
+# Warning msgs that should eventually be enabled:
+    arguments-differ, global-statement, fixme, broad-except
+
+[REPORTS]
+
+# Set the output format. Available formats are text, parseable, colorized, msvs
+# (visual studio) and html. You can also give a reporter class, eg
+# mypackage.mymodule.MyReporterClass.
+output-format=parseable
+
+# Put messages in a separate file for each module / package specified on the
+# command line instead of printing them on stdout. Reports (if any) will be
+# written in a file name "pylint_global.[txt|html]". This option is deprecated
+# and it will be removed in Pylint 2.0.
+files-output=no
+
+# Tells whether to display a full report or only the messages
+reports=no
+
+# Python expression which should return a note less than 10 (10 is the highest
+# note). You have access to the variables errors warning, statement which
+# respectively contain the number of errors / warnings messages and the total
+# number of statements analyzed. This is used by the global evaluation report
+# (RP0004).
+evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
+
+# Template used to display messages. This is a python new-style format string
+# used to format the message information. See doc for all details
+#msg-template=
+
+
+[SPELLING]
+
+# Spelling dictionary name. Available dictionaries: none. To make it working
+# install python-enchant package.
+spelling-dict=
+
+# List of comma separated words that should not be checked.
+spelling-ignore-words=
+
+# A path to a file that contains private dictionary; one word per line.
+spelling-private-dict-file=
+
+# Tells whether to store unknown words to indicated private dictionary in
+# --spelling-private-dict-file option instead of raising a message.
+spelling-store-unknown-words=no
+
+
+[BASIC]
+
+# Good variable names which should always be accepted, separated by a comma
+good-names=d,i,j,k,ex,Run,_,log
+
+# Bad variable names which should always be refused, separated by a comma
+bad-names=foo,bar,baz,toto,tutu,tata
+
+# Colon-delimited sets of names that determine each other's naming style when
+# the name regexes allow several styles.
+name-group=
+
+# Include a hint for the correct naming format with invalid-name
+include-naming-hint=no
+
+# List of decorators that produce properties, such as abc.abstractproperty. Add
+# to this list to register other decorators that produce valid properties.
+property-classes=abc.abstractproperty
+
+# Regular expression matching correct function names
+function-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Naming hint for function names
+function-name-hint=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression matching correct variable names
+variable-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Naming hint for variable names
+variable-name-hint=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression matching correct constant names
+const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$
+
+# Naming hint for constant names
+const-name-hint=(([A-Z_][A-Z0-9_]*)|(__.*__))$
+
+# Regular expression matching correct attribute names
+attr-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Naming hint for attribute names
+attr-name-hint=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression matching correct argument names
+argument-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Naming hint for argument names
+argument-name-hint=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression matching correct class attribute names
+class-attribute-rgx=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$
+
+# Naming hint for class attribute names
+class-attribute-name-hint=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$
+
+# Regular expression matching correct inline iteration names
+inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$
+
+# Naming hint for inline iteration names
+inlinevar-name-hint=[A-Za-z_][A-Za-z0-9_]*$
+
+# Regular expression matching correct class names
+class-rgx=[A-Z_][a-zA-Z0-9]+$
+
+# Naming hint for class names
+class-name-hint=[A-Z_][a-zA-Z0-9]+$
+
+# Regular expression matching correct module names
+module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
+
+# Naming hint for module names
+module-name-hint=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
+
+# Regular expression matching correct method names
+method-rgx=[a-z_][a-z0-9_]{2,40}$
+
+# Naming hint for method names
+method-name-hint=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression which should only match function or class names that do
+# not require a docstring.
+no-docstring-rgx=__.*__
+
+# Minimum line length for functions/classes that require docstrings, shorter
+# ones are exempt.
+docstring-min-length=-1
+
+
+[ELIF]
+
+# Maximum number of nested blocks for function / method body
+max-nested-blocks=5
+
+
+[LOGGING]
+
+# Logging modules to check that the string format arguments are in logging
+# function parameter format
+logging-modules=logging
+
+
+[FORMAT]
+
+# Maximum number of characters on a single line.
+max-line-length=120
+
+# Regexp for a line that is allowed to be longer than the limit.
+ignore-long-lines=^\s*(# )?<?https?://\S+>?$
+
+# Allow the body of an if to be on the same line as the test if there is no
+# else.
+single-line-if-stmt=no
+
+# List of optional constructs for which whitespace checking is disabled. `dict-
+# separator` is used to allow tabulation in dicts, etc.: {1  : 1,\n222: 2}.
+# `trailing-comma` allows a space between comma and closing bracket: (a, ).
+# `empty-line` allows space-only lines.
+no-space-check=trailing-comma,dict-separator
+
+# Maximum number of lines in a module
+max-module-lines=1550
+
+# String used as indentation unit. This is usually "    " (4 spaces) or "\t" (1
+# tab).
+indent-string='    '
+
+# Number of spaces of indent required inside a hanging or continued line.
+indent-after-paren=4
+
+# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
+expected-line-ending-format=LF
+
+
+[MISCELLANEOUS]
+
+# List of note tags to take in consideration, separated by a comma.
+notes=FIXME,XXX,TODO
+
+
+[VARIABLES]
+
+# Tells whether we should check for unused import in __init__ files.
+init-import=no
+
+# A regular expression matching the name of dummy variables (i.e. expectedly
+# not used).
+dummy-variables-rgx=_$|dummy
+
+# List of additional names supposed to be defined in builtins. Remember that
+# you should avoid to define new builtins when possible.
+additional-builtins=_,_n,__request__,WindowsError
+
+# List of strings which can identify a callback function by name. A callback
+# name must start or end with one of those strings.
+callbacks=cb_,_cb
+
+# List of qualified module names which can have objects that can redefine
+# builtins.
+redefining-builtins-modules=six.moves,future.builtins,future_builtins
+
+
+[TYPECHECK]
+
+# Tells whether missing members accessed in mixin class should be ignored. A
+# mixin class is detected if its name ends with "mixin" (case insensitive).
+ignore-mixin-members=yes
+
+# List of module names for which member attributes should not be checked
+# (useful for modules/projects where namespaces are manipulated during runtime
+# and thus existing member attributes cannot be deduced by static analysis. It
+# supports qualified module names, as well as Unix pattern matching.
+ignored-modules=
+
+# List of class names for which member attributes should not be checked (useful
+# for classes with dynamically set attributes). This supports the use of
+# qualified names.
+ignored-classes=SQLObject,twisted.internet.reactor
+
+# List of members which are set dynamically and missed by pylint inference
+# system, and so shouldn't trigger E1101 when accessed. Python regular
+# expressions are accepted.
+generated-members=REQUEST,acl_users,aq_parent
+
+# List of decorators that produce context managers, such as
+# contextlib.contextmanager. Add to this list to register other decorators that
+# produce valid context managers.
+contextmanager-decorators=contextlib.contextmanager
+
+
+[SIMILARITIES]
+
+# Minimum lines number of a similarity.
+min-similarity-lines=4
+
+# Ignore comments when computing similarities.
+ignore-comments=yes
+
+# Ignore docstrings when computing similarities.
+ignore-docstrings=yes
+
+# Ignore imports when computing similarities.
+ignore-imports=no
+
+
+[IMPORTS]
+
+# Deprecated modules which should not be used, separated by a comma
+deprecated-modules=regsub,TERMIOS,Bastion,rexec
+
+# Create a graph of every (i.e. internal and external) dependencies in the
+# given file (report RP0402 must not be disabled)
+import-graph=
+
+# Create a graph of external dependencies in the given file (report RP0402 must
+# not be disabled)
+ext-import-graph=
+
+# Create a graph of internal dependencies in the given file (report RP0402 must
+# not be disabled)
+int-import-graph=
+
+# Force import order to recognize a module as part of the standard
+# compatibility libraries.
+known-standard-library=
+
+# Force import order to recognize a module as part of a third party library.
+known-third-party=enchant
+
+# Analyse import fallback blocks. This can be used to support both Python 2 and
+# 3 compatible code, which means that the block might have code that exists
+# only in one or another interpreter, leading to false positives when analysed.
+analyse-fallback-blocks=no
+
+
+[DESIGN]
+
+# Maximum number of arguments for function / method
+max-args=7
+
+# Argument names that match this expression will be ignored. Default to name
+# with leading underscore
+ignored-argument-names=_.*
+
+# Maximum number of locals for function / method body
+max-locals=15
+
+# Maximum number of return / yield for function / method body
+max-returns=6
+
+# Maximum number of branch for function / method body
+max-branches=12
+
+# Maximum number of statements in function / method body
+max-statements=50
+
+# Maximum number of parents for a class (see R0901).
+max-parents=7
+
+# Maximum number of attributes for a class (see R0902).
+max-attributes=7
+
+# Minimum number of public methods for a class (see R0903).
+min-public-methods=2
+
+# Maximum number of public methods for a class (see R0904).
+max-public-methods=20
+
+# Maximum number of boolean expressions in a if statement
+max-bool-expr=5
+
+
+[CLASSES]
+
+# List of method names used to declare (i.e. assign) instance attributes.
+defining-attr-methods=__init__,__new__,setUp
+
+# List of valid names for the first argument in a class method.
+valid-classmethod-first-arg=cls
+
+# List of valid names for the first argument in a metaclass class method.
+valid-metaclass-classmethod-first-arg=mcs
+
+# List of member names, which should be excluded from the protected access
+# warning.
+exclude-protected=_asdict,_fields,_replace,_source,_make
+
+
+[EXCEPTIONS]
+
+# Exceptions that will emit a warning when being caught. Defaults to
+# "Exception"
+overgeneral-exceptions=Exception

.readthedocs.yml

@@ -0,0 +1,22 @@
+# .readthedocs.yml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Build documentation in the docs/ directory with Sphinx
+sphinx:
+  configuration: docs/source/conf.py
+
+# Optionally build your docs in additional formats such as PDF and ePub
+formats: all
+
+# Optionally set the version of Python and requirements required to build your docs
+python:
+  version: 3.7
+  install:
+    - requirements: requirements.txt
+    - requirements: docs/requirements.txt
+    - method: setuptools
+      path: .

.travis.yml

@@ -0,0 +1,83 @@
+dist: xenial
+sudo: required
+
+language: python
+python:
+  # Travis Xenial Python to support system_site_packages
+  - 3.5
+cache: pip
+virtualenv:
+  system_site_packages: true
+
+env:
+  global:
+    - DISPLAY=:99.0
+
+git:
+  # Set greater depth to get version from tags.
+  depth: 1000
+
+matrix:
+  include:
+    - name: Unit tests
+      env: TOX_ENV=py3
+    - name: Unit tests - libtorrent 1.2
+      env: TOX_ENV=py3
+      addons:
+        apt:
+          sources: [sourceline: "ppa:libtorrent.org/1.2-daily"]
+          packages: [python3-libtorrent, python3-venv]
+    - name: Unit tests - Python 2
+      env: TOX_ENV=py27
+      python: 2.7
+    - if: commit_message =~ SECURITY_TEST
+      env: TOX_ENV=security
+    - name: Code linting
+      env: TOX_ENV=lint
+    - name: Docs build
+      env: TOX_ENV=docs
+    - name: GTK unit tests
+      env: TOX_ENV=gtkui
+    - name: Plugins unit tests
+      env: TOX_ENV=plugins
+
+addons:
+  apt:
+    sources:
+      - sourceline: "ppa:libtorrent.org/rc-1.1-daily"
+      - deadsnakes
+    packages:
+      - python-libtorrent
+      - python3-libtorrent
+      # Install py36 specifically for pre-commit to run black formatter.
+      - python3.6
+      # Intall python3-venv to provide ensurepip module for tox.
+      - python3-venv
+
+# Install dependencies
+install:
+  - pip install tox tox-venv
+  # GTKUI tests
+  - "if [ $TOX_ENV == 'gtkui' ]; then
+    sudo apt install python3-gi python3-gi-cairo gir1.2-gtk-3.0;
+    fi"
+  # Security tests
+  - "if [ $TOX_ENV == 'security' ]; then
+    testssl_url=https://github.com/drwetter/testssl.sh/archive/v2.9.5-5.tar.gz;
+    wget -O- $testssl_url | tar xz
+    && mv -t deluge/tests/data testssl.sh-2.9.5-5/testssl.sh testssl.sh-2.9.5-5/etc/;
+    fi"
+
+before_script:
+  - export PYTHONPATH=$PYTHONPATH:$PWD
+  # Verify libtorrent installed and version
+  - python -c "import libtorrent as lt; print(lt.__version__)"
+  # Start xvfb for the GTKUI tests
+  - "if [ $TOX_ENV == 'gtkui' ]; then
+    /sbin/start-stop-daemon --start --quiet --background \
+    --make-pidfile --pidfile /tmp/custom_xvfb_99.pid \
+    --exec /usr/bin/Xvfb -- :99 -ac -screen 0 1280x1024x16;
+    fi"
+
+script:
+  - tox -e $TOX_ENV

AUTHORS

@@ -14,7 +14,7 @@ libtorrent (http://www.libtorrent.org):
 Contributors (and Past Developers):
     * Zach Tibbitts <zach@collegegeek.org>
     * Alon Zakai ('Kripken') <kripkensteiner@gmail.com>
-    * Marcos Pinto ('markybob') <markybob@gmail.com>
+    * Marcos Mobley ('markybob') <markybob@gmail.com>
     * Alex Dedul
     * Sadrul Habib Chowdhury
     * Ido Abramovich <ido.deluge@gmail.com>
@@ -457,7 +457,7 @@ Translation Contributors:
     Marco Rodrigues
     Marcos
     Marcos Escalier
-    Marcos Pinto
+    Marcos Mobley
     Marcus Ekstrom
     Marek Dębowski
     Mário Buči

CHANGELOG.md

@@ -0,0 +1,100 @@
+# Changelog
+
+## 2.0.3 (2019-06-12)
+
+### Gtk UI
+
+- Fix errors running on Wayland (#3265).
+- Fix Peers Tab tooltip and context menu errors (#3266).
+
+### Web UI
+
+- Fix TypeError in Peers Tab setting country flag.
+- Fix reverse proxy header TypeError (#3260).
+- Fix request.base 'idna' codec error (#3261).
+- Fix unable to change password (#3262).
+
+### Extractor plugin
+
+- Fix potential error starting plugin.
+
+### Documentation
+
+- Fix macOS install typo.
+- Fix Windows install instructions.
+
+## 2.0.2 (2019-06-08)
+
+### Packaging
+
+- Add systemd deluged and deluge-web service files to package tarball (#2034)
+
+### Core
+
+- Fix Python 2 compatiblity issue with SimpleNamespace.
+
+## 2.0.1 (2019-06-07)
+
+### Packaging
+
+- Fix setup.py build error without git installed.
+
+## 2.0.0 (2019-06-06)
+
+### Codebase
+
+- Ported to Python 3
+
+### Core
+
+- Improved Logging
+- Removed the AutoAdd feature on the core. It's now handled with the AutoAdd
+  plugin, which is also shipped with Deluge, and it does a better job and
+  now, it even supports multiple users perfectly.
+- Authentication/Permission exceptions are now sent to clients and recreated
+  there to allow acting upon them.
+- Updated SSL/TLS Protocol parameters for better security.
+- Make the distinction between adding to the session new unmanaged torrents
+  and torrents loaded from state. This will break backwards compatability.
+- Pass a copy of an event instead of passing the event arguments to the
+  event handlers. This will break backwards compatability.
+- Allow changing ownership of torrents.
+- File modifications on the auth file are now detected and when they happen,
+  the file is reloaded. Upon finding an old auth file with an old format, an
+  upgrade to the new format is made, file saved, and reloaded.
+- Authentication no longer requires a username/password. If one or both of
+  these is missing, an authentication error will be sent to the client
+  which sould then ask the username/password to the user.
+- Implemented sequential downloads.
+- Provide information about a torrent's pieces states
+- Add Option To Specify Outgoing Connection Interface.
+- Fix potential for host_id collision when creating hostlist entries.
+
+### Gtk UI
+
+- Ported to GTK3 (3rd-party plugins will need updated).
+- Allow changing ownership of torrents.
+- Host entries in the Connection Manager UI are now editable.
+- Implemented sequential downloads UI handling.
+- Add optional pieces bar instead of a regular progress bar in torrent status tab.
+- Make torrent opening compatible with all unicode paths.
+- Fix magnet association button on Windows.
+- Add keyboard shortcuts for changing queue position:
+  - Up: Ctrl+Alt+Up
+  - Down: Ctrl+Alt+Down
+  - Top: Ctrl+Alt+Shift+Up
+  - Bottom: Ctrl+Alt+Shift+Down
+
+### Web UI
+
+- Server (deluge-web) now daemonizes by default, use '-d' or '--do-not-daemonize' to disable.
+- Fixed the '--base' option to work for regular use, not just with reverse proxies.
+
+### Blocklist Plugin
+
+- Implemented whitelist support to both core and GTK UI.
+- Implemented ip filter cleaning before each update. Restarting the deluge
+  daemon is no longer needed.
+- If "check_after_days" is 0(zero), the timer is not started anymore. It
+  would keep updating one call after the other. If the value changed, the
+  timer is now stopped and restarted using the new value.

ChangeLog

@@ -1,521 +0,0 @@
-=== Deluge 1.4.0 (In Development) ===
-	* Improved Logging
-	* Removed the AutoAdd feature on the core. It's now handled with the AutoAdd
-	plugin, which is also shipped with Deluge, and it does a better job and
-	now, it even supports multiple users perfectly.
-	* Authentication/Permission exceptions are now sent to clients and recreated
-	there to allow acting upon them.
-	* Enforced the use of the "deluge.plugins" namespace to reduce package
-	names clashing beetween regular packages and deluge plugins.
-
-==== Core ====
-	* Make the distinction between adding to the session new unmanaged torrents
-	and torrents loaded from state. This will break backwards compatability.
-	* Pass a copy of an event instead of passing the event arguments to the
-	event handlers. This will break backwards compatability.
-	* Allow changing ownership of torrents.
-	* File modifications on the auth file are now detected and when they happen,
-	the file is reloaded. Upon finding an old auth file with an old format, an
-	upgrade to the new format is made, file saved, and reloaded.
-	* Authentication no longer requires a username/password. If one or both of
-	these is missing, an authentication error will be sent to the client
-	which sould then ask the username/password to the user.
-	* Implemented sequential downloads.
-	* #378: Provide information about a torrent's pieces states
-
-==== GtkUI ====
-	* Fix uncaught exception when closing deluge in classic mode
-	* Allow changing ownership of torrents
-	* Host entries in the Connection Manager UI are now editable. They're
-	now also migrated from the old format were automatic localhost logins were
-	possible, which no longer is, this fixes #1814.
-	* Implemented sequential downloads UI handling.
-	* #378: Allow showing a pieces bar instead of a regular progress bar in a
-	torrent's status tab.
-	* #2093: Make torrent opening compatible with all unicode paths.
-
-==== Blocklist Plugin ====
-	* #1382: Implemented whitelist support to both core and GTK UI.
-	* Implemented ip filter cleaning before each update. Restarting the deluge
-	daemon is no longer needed.
-	* If "check_after_days" is 0(zero), the timer is not started anymore. It
-	would keep updating one call after the other. If the value changed, the
-	timer is now stopped and restarted using the new value.
-
-=== Deluge 1.3.7 (In Development) ===
-==== GtkUI ====
-	* Fix issue with Plugins that add Tab to torrentdetails
-	* Fix the scalable icon install directory
-
-==== 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
-
-==== 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) ===
-==== 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
-	* #1964: Fix unhandled UnpicklingErrors
-	* #1967: Fix unhandled IndexError when trying to open a non-json conf file
-	* Fix setting daemon listen interface from command line
-	* #2021: Fix share ratio limit not obeyed for seeded torrents added to session
-	* Add optparse custom version to prevent unnecessary loading of libtorrent
-	* #1554: Fix seeding on share ratio failing for partially selected torrents
-	* Add proper process title naming in ps, top etc. (Depends: setproctitle)
-
-==== GtkUI ====
-	* #1918: Fix Drag'n'Drop not working in Windows
-	* #1941: Increase maximum Cache Size to 999999 (15GiB)
-	* #1940: File & folder renaming issue when using Add Torrent dialog in Windows
-	* LP#821577: Fix UnpicklingError when external selection dragged onto Files Tab
-	* #1934: Fix Unicode error in AddTorrent Dialog
-	* #1957: Fix keyerror when adding columns for non-latin languages
-	* #1969: Fix menu item 'Quit & Shutdown' still available when not connected to daemon
-	* #1895: Fix Files Tab showing wrong files due to torrent_info race condition
-	* #2010: Move speed text in titlebar to the beginning
-	* #2032: Wait for client to shutdown/disconnect before stopping reactor
-	* Fix compatibility with Python 2.5
-	* Fix collapsed treeview in Create Torrent dialog
-	* Ignore unmaximise event when window isn't visible
-	* #1976: Fixed text entry with trailing newline characters causing issues for Move Storage
-
-==== WebUI ====
-	* Fix Webui files-tab menu setting wrong priority
-	* Update to ExtJS 3.4.0
-	* #1960: Fix statustab showing total_payload_download for upload as well
-	* Remove uneeded Titlebar to save space
-	* Fix clipped Browse button in WebUI
-	* #1915: Fix being unable to stop the status bar from autohiding
-	* Fix password box focus issue in Firefox
-	* Fix plugin uploads from behind a reverse proxy
-	* #2010: Move speed text in titlebar to the beginning
-	* #1936: Fix Referenced before assignment error in json_api
-	* Changes are now applied when clicking OK in Preferences
-	* Added Download,Uploaded,Down Limit, Up Limit & Seeder/Peeds columns
-	* Add magnet uri support to Add Url
-	* Add keymaps for torrents - Ctrl-A (select all) and Delete
-	* #2037: Fix 'Add Torrents' torrents list not scrolling
-	* #2038: Fix Chrome 17 disconnecting from webui
-
-==== Console ====
-	* #1953: Fix flickering on every update
-	* #1954: Fix 'invalid literal for float' when setting listen interface
-	* #1945: Fix UnicodeDecodeError when using non-ascii chars in info
-
-==== Label ====
-	* #1961: Add missing 'All' filter option
-	* #2035: Fix label options dialog in webui
-	* #2036: Fix newly added labels not being sorted in torrent right click menu
-
-==== Notification ====
-	* #1905: Fix no email sent to second email address
-	* #1898: Fix email notifications not including date/time they were sent
-
-==== Scheduler ====
-	* Add plugin page for WebUi
-
-==== Execute ====
-	* Commands now run scripts asynchronous to prevent Deluge from hanging
-
-==== AutoAdd ====
-	* Added watch folder support for '.magnet' text file containing single or multiple magnet uris
-	* Fix glade object issue when re-enabling plugin in same session
-	* Fix plugin not showing as enabled in webui
-
-=== 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
-	* Implement #1012 httpdownloader supports gzip decoding
-	* #496: Remove deprecated functions in favour of get_session_status()
-	* #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 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 ====
-	* Implement new RPC protocol DelugeRPC replacing XMLRPC
-	* Move to a twisted framework
-	* Add an 'Error' filter for Trackers to show trackers that currently have a tracker error
-	* Use system GeoIP database if available, this is now an optional dependency
-
-==== GtkUI ====
-	* Remove SignalReceiver
-	* Implemented a cross-platform IPC method thus removing the DBUS dependency
-	* Implement a "True" Classic Mode where there is no longer a separate daemon process
-	* Add preferences option "Add torrent in paused state"
-	* Add tracker icons to the Tracker column
-	* Implement #259 show tooltip with country name in the peers tab
-	* Add an error category to the tracker sidebar list
-	* Add Find More Plugins button to Plugins preference page
-	* Fix #518 remove header in add torrent dialog to save vertical space
-	* Add a Cache preferences page to adjust cache settings and examine cache status
-	* Add ability to rename files prior to adding them
-	* Fix shutdown handler with GNOME session manager
-	* Allow 4 MiB piece sizes when creating a torrent
-
-==== ConsoleUI ====
-	* Changed to use curses for a more interactive client
-
-==== WebUI ====
-	* Move over to using Twisted-Web for the webserver.
-	* Move to only AJAX interface built upon Ext-JS.
-
-==== Plugins ====
-	* Add Scheduler plugin
-	* Add Extractor plugin
-
-==== Misc ====
-	* PyGTK dependency bumped to => 2.12 to use new tooltip system
-	* Add new scripts for invoking UIs: deluge-gtk, deluge-web, deluge-console
-	* Remove GeoIP database from the source tree
-
-=== Deluge 1.1.0 - "Time gas!" (10 January 2009) ===
-==== Core ====
-	* Implement #79 ability to change outgoing port range
-	* Implement #296 ability to change peer TOS byte
-	* Add per-torrent move on completed settings
-	* Implement #414 use async save_resume_data method
-	* Filter Manager with torrent filtering in get_torrents_status , for sidebar and plugins.
-	* Implement #368 add torrents by infohash/magnet uri (trackerless torrents)
-	* Remove remaining gtk functions in common
-	* Tracker icons.
-	* Add ETA for torrents with stop at seed ratio set
-	* Fix #47 the state and config files are no longer invalidated when there is no diskspace
-	* Fix #619 return "" instead of "Infinity" if seconds == 0 in ftime
-	* Add -P, --pidfile option to deluged
-
-==== GtkUI ====
-	* Add peer progress to the peers tab
-	* Add ability to manually add peers
-	* Sorting # column will place downloaders above seeds
-	* Remove dependency on libtorrent for add torrent dialog
-	* Allow adding multiple trackers at once in the edit tracker dialog
-	* Implement #28 Create Torrent Dialog
-	* Redesiged sidebar with filters for Active and Tracker (see Filter Manager)
-	* Implement #428 the ability to rename files and directories
-	* Implement #229 add date added column
-	* Implement #596 show speeds in title
-	* Fix #636 not setting the daemon's config directory when using --config= with the UI in classic mode.
-	* Fix #624 do not allow changing file priorities when using compact allocation
-	* Fix #602 re-did files/peers tab state saving/loading
-	* Fix gtk warnings
-	* Add protocol traffic statusbar item
-	* Rework the Remove Torrent Dialog to only have 2 options, remove data and remove from session.
-	* Add "Install Plugin" and "Rescan Plugins" buttons to the Plugins preferences
-	* Make active port test use internal graphic instead of launching browser
-
-==== WebUI ====
-	* Lots of smaller tweaks.
-	* All details tabs have the same features as in gtk-ui 1.0.x
-	* Persistent sessions #486
-	* Plugin improvements for easy use of templates and images in eggs. #497
-	* Classic template takes over some style elements from white template.
-	* https (for users that know how to create certificates)
-	* Easier apache mod_proxy use.
-	* Redesigned sidebar
-
-==== AjaxUI ====
-	* Hosted in a webui template.
-
-==== ConsoleUI ====
-	* New ConsoleUI written by Idoa01
-	* Callable from command-line for scripts.
-
-==== Plugins ====
-	* Stats plugin for graphs.
-	* Label plugin for grouping torrents and per torrent settings.
-
-==== Misc ====
-	* Implement #478 display UI options in usage help
-	* Fix #547 add description to name field per HIG entry 2.1.1.1
-	* Fix #531 set default log level to ERROR and add 2 command-line options, "-L, --loglevel" and "-q, --quiet".

DEPENDS

@@ -1,30 +0,0 @@
-=== Core ===
- * python >= 2.6
- * twisted >= 8.1
- * twisted-web >= 8.1
- * pyopenssl
- * setuptools
- * gettext
- * intltool
- * pyxdg
- * chardet
- * geoip-database (optional)
- * setproctitle (optional)
- * rencode >= 1.0.2 (optional), a Python port is already included
-
- * libtorrent (rasterbar) >= 0.16.7
-
- * If building libtorrent:
-   * boost >= 1.40
-   * openssl
-   * zlib
-
-=== Gtk ===
- * pygtk >= 2.16
- * librsvg
- * xdg-utils
- * python-notify (optional)
- * pygame (optional)
-
-=== Web ===
- * mako

DEPENDS.md

@@ -0,0 +1,101 @@
+# Deluge dependencies
+
+The following are required to install and run Deluge. They are separated into
+sections to distinguish the precise requirements for each module.
+
+All modules will require the [common](#common) section dependencies.
+
+## Prerequisite
+
+- [Python] _>= 3.5_
+
+## Build
+
+- [setuptools]
+- [intltool] - Optional: Desktop file translation for \*nix.
+- [closure-compiler] - Minify javascript (alternative is [slimit])
+
+## Common
+
+- [Twisted] _>= 17.1_ - Use `TLS` extras for `service_identity` and `idna`.
+- [OpenSSL] _>= 1.0.1_
+- [pyOpenSSL]
+- [rencode] _>= 1.0.2_ - Encoding library.
+- [PyXDG] - Access freedesktop.org standards for \*nix.
+- [xdg-utils] - Provides xdg-open for \*nix.
+- [six]
+- [zope.interface]
+- [chardet] - Optional: Encoding detection.
+- [setproctitle] - Optional: Renaming processes.
+- [Pillow] - Optional: Support for resizing tracker icons.
+- [dbus-python] - Optional: Show item location in filemanager.
+
+#### Linux and BSD
+
+- [distro] - Optional: OS platform information.
+
+#### Windows OS
+
+- [pywin32]
+- [certifi]
+
+## Core (deluged daemon)
+
+- [libtorrent] _>= 1.1.1_
+- [GeoIP] - Optional: IP address location lookup. (_Debian: `python-geoip`_)
+
+## GTK UI
+
+- [GTK+] >= 3.10
+- [PyGObject]
+- [Pycairo]
+- [librsvg] _>= 2_
+- [libappindicator3] w/GIR - Optional: Ubuntu system tray icon.
+
+#### MacOS
+
+- [GtkOSXApplication]
+
+## Web UI
+
+- [mako]
+
+## Plugins
+
+### Notifications
+
+- [pygame] - Optional: Play sounds
+- [libnotify] w/GIR - Optional: Desktop popups.
+
+[python]: https://www.python.org/
+[setuptools]: https://setuptools.readthedocs.io/en/latest/
+[intltool]: https://freedesktop.org/wiki/Software/intltool/
+[closure-compiler]: https://developers.google.com/closure/compiler/
+[slimit]: https://slimit.readthedocs.io/en/latest/
+[openssl]: https://www.openssl.org/
+[pyopenssl]: https://pyopenssl.org
+[twisted]: https://twistedmatrix.com
+[pillow]: https://pypi.org/project/Pillow/
+[libtorrent]: https://libtorrent.org/
+[zope.interface]: https://pypi.org/project/zope.interface/
+[distro]: https://github.com/nir0s/distro
+[pywin32]: https://github.com/mhammond/pywin32
+[certifi]: https://pypi.org/project/certifi/
+[py2-ipaddress]: https://pypi.org/project/py2-ipaddress/
+[dbus-python]: https://pypi.org/project/dbus-python/
+[setproctitle]: https://pypi.org/project/setproctitle/
+[gtkosxapplication]: https://github.com/jralls/gtk-mac-integration
+[chardet]: https://chardet.github.io/
+[rencode]: https://github.com/aresch/rencode
+[pyxdg]: https://www.freedesktop.org/wiki/Software/pyxdg/
+[six]: https://pythonhosted.org/six/
+[xdg-utils]: https://www.freedesktop.org/wiki/Software/xdg-utils/
+[gtk+]: https://www.gtk.org/
+[pycairo]: https://cairographics.org/pycairo/
+[pygobject]: https://pygobject.readthedocs.io/en/latest/
+[geoip]: https://pypi.org/project/GeoIP/
+[mako]: https://www.makotemplates.org/
+[pygame]: https://www.pygame.org/
+[libnotify]: https://developer.gnome.org/libnotify/
+[python-appindicator]: https://packages.ubuntu.com/xenial/python-appindicator
+[librsvg]: https://wiki.gnome.org/action/show/Projects/LibRsvg

MANIFEST.in

@@ -1,22 +1,35 @@
-include AUTHORS ChangeLog DEPENDS ez_setup.py LICENSE  msgfmt.py RELEASE-VERSION version.py
+include *.md
+include AUTHORS
+include LICENSE
+include RELEASE-VERSION
+include msgfmt.py
+include minify_web_js.py
+include version.py
+include gen_web_gettext.py
+
 graft docs/man
+graft packaging/systemd
 
 include deluge/i18n/*.po
+recursive-exclude deluge/i18n *.mo
 
 graft deluge/plugins
-recursive-exclude deluge/plugins create_dev_link.sh *.pyc
+recursive-exclude deluge/plugins create_dev_link.sh *.pyc *.egg
+prune deluge/plugins/*/build
+prune deluge/plugins/*/*.egg-info
+
+graft deluge/tests/
+recursive-exclude deluge/tests *.pyc
 
-prune deluge/tests
 graft deluge/ui/data
+recursive-exclude deluge/ui/data *.desktop *.xml
 graft deluge/ui/gtkui/glade
 
 include deluge/ui/web/index.html
-include deluge/ui/web/gettext.js
 include deluge/ui/web/css/*.css
-exclude deluge/ui/web/css/*-debug.css
 include deluge/ui/web/js/*.js
-exclude deluge/ui/web/js/*-debug.js
-exclude deluge/ui/web/gen_gettext.py
+graft deluge/ui/web/js/deluge-all/
+graft deluge/ui/web/js/extjs/
 graft deluge/ui/web/themes
 graft deluge/ui/web/render
 graft deluge/ui/web/icons

README

@@ -1,57 +0,0 @@
-==========================
- Deluge BitTorrent Client
-==========================
-
-Homepage: http://deluge-torrent.org
-
-Authors:
-    Andrew Resch
-    Damien Churchill
-
-For contributors and past developers see: 
-    AUTHORS
-
-==========================
-Installation Instructions:
-==========================
-
-For detailed instructions see: http://dev.deluge-torrent.org/wiki/Installing/Source
-
-Ensure build dependencies are installed, see DEPENDS for a full listing.
-
-Build and install by running:
-
-    $ python setup.py build
-    $ sudo python setup.py install
-
-==========================
-Contact/Support:
-==========================
-
-   Forum: http://forum.deluge-torrent.org
-   IRC Channel: #deluge on irc.freenode.net
-
-==========================
-FAQ
-==========================
-
-For the full FAQ see: http://dev.deluge-torrent.org/wiki/Faq
-
-How to start the various user-interfaces
-
-    Gtk:
-        deluge or deluge-gtk
-    Console:
-        deluge-console
-    Web:
-        deluge-web
-        Go to http://localhost:8112/ default-password = "deluge"
-    
-How do I start the daemon?
-
-    deluged
-
-I can't connect to the daemon from another machine
-
-    See: http://dev.deluge-torrent.org/wiki/UserGuide/ThinClient
-

README.md

@@ -0,0 +1,63 @@
+# Deluge BitTorrent Client
+
+[![build-status]][travis-deluge] [![docs-status]][rtd-deluge]
+
+Deluge is a BitTorrent client that utilizes a daemon/client model.
+It has various user interfaces available such as the GTK-UI, Web-UI and
+a Console-UI. It uses [libtorrent][lt] at it's core to handle the BitTorrent
+protocol.
+
+## Install
+
+From [PyPi](https://pypi.org/project/deluge):
+
+    pip install deluge
+
+From source code:
+
+    python setup.py build
+    python setup.py install
+
+See [DEPENDS](DEPENDS.md) and [Installing/Source] for dependency details.
+
+## Usage
+
+The various user-interfaces and Deluge daemon can be started with the following commands.
+
+Use the `--help` option for further command options.
+
+### Gtk UI
+
+`deluge` or `deluge-gtk`
+
+### Console UI
+
+`deluge-console`
+
+### Web UI
+
+`deluge-web`
+
+Open http://localhost:8112 with default password `deluge`.
+
+### Daemon
+
+`deluged`
+
+See the [Thinclient guide] to connect to the daemon from another computer.
+
+## Contact
+
+- [Homepage](https://deluge-torrent.org)
+- [User guide][user guide]
+- [Forum](https://forum.deluge-torrent.org)
+- [IRC Freenode #deluge](irc://irc.freenode.net/deluge)
+
+[user guide]: https://dev.deluge-torrent.org/wiki/UserGuide
+[thinclient guide]: https://dev.deluge-torrent.org/wiki/UserGuide/ThinClient
+[installing/source]: https://dev.deluge-torrent.org/wiki/Installing/Source
+[build-status]: https://travis-ci.org/deluge-torrent/deluge.svg "Travis Status"
+[travis-deluge]: https://travis-ci.org/deluge-torrent/deluge
+[docs-status]: https://readthedocs.org/projects/deluge/badge/?version=develop
+[rtd-deluge]: https://deluge.readthedocs.io/en/develop/?badge=develop "Documentation Status"
+[lt]: https://libtorrent.org

appveyor.yml

@@ -0,0 +1,53 @@
+environment:
+  PYTHON_VERSION: 3.6
+  PYTHON_ARCH: 64
+  PYTHON: "C:\\Python36-x64"
+  APPVEYOR_SAVE_CACHE_ON_ERROR: true
+
+  matrix:
+    - TOXENV: py36
+
+pull_requests:
+  do_not_increment_build_number: true
+
+install:
+  # If there is a newer build queued for same PR, cancel this one. Credit: JuliaLang devs
+  - ps:
+      if ($env:APPVEYOR_PULL_REQUEST_NUMBER -and $env:APPVEYOR_BUILD_NUMBER -ne ((Invoke-RestMethod `
+      https://ci.appveyor.com/api/projects/$env:APPVEYOR_ACCOUNT_NAME/$env:APPVEYOR_PROJECT_SLUG/history?recordsNumber=50).builds | `
+      Where-Object pullRequestId -eq $env:APPVEYOR_PULL_REQUEST_NUMBER)[0].buildNumber) { `
+      throw "There are newer queued builds for this pull request, failing early." }
+  - "SET PATH=%PYTHON%;%PYTHON%\\Scripts;%PATH%"
+  - "python -VV"
+  - if defined TOXENV (
+    python -m pip install tox tox_venv
+    ) else (
+    python -m pip install -rrequirements.txt pygame bbfreeze pefile
+    )
+  - "SET PATH=C:\\OpenSSL-v11-Win64\\bin;%PATH%"
+  - openssl version -v
+  - python -m pip install deluge-libtorrent
+  - 'python -c "import libtorrent; print(libtorrent.__version__)"'
+
+cache:
+  - '%LOCALAPPDATA%\pip\cache'
+
+build: false
+
+test_script:
+  - if defined TOXENV tox
+# Commented out as require GTK3 to create package.
+# after_test:
+# - if not defined TOXENV python setup.py build && python setup.py install
+# - cd %APPVEYOR_BUILD_FOLDER%\\packaging\\win32
+# - if not defined TOXENV deluge-bbfreeze.py debug
+# - "SET PATH=C:\\Program Files (x86)\\NSIS;%PATH%"
+# - if not defined TOXENV makensis deluge-win32-installer.nsi
+# - if not defined TOXENV 7z a deluge-win32.zip build-win32 "-x!*.exe"
+
+# artifacts:
+# - path: packaging\win32\deluge-win32.zip
+# - path: packaging\win32\build-win32\*.exe
+
+#on_success:
+#

check_glade.sh

@@ -1,21 +0,0 @@
-#!/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,32 +0,0 @@
-#!/usr/bin/env python
-import os
-import re
-import sys
-# Paths to exclude
-EXCLUSIONS = [
-    "deluge/scripts",
-    "deluge/i18n",
-]
-
-POTFILE_IN = "deluge/i18n/POTFILES.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", ".in") \
-                                            and dirpath not in EXCLUSIONS \
-                                            and not compiled.match(dirpath):
-            to_translate.append(os.path.join(dirpath, filename))
-
-f = open(POTFILE_IN, "wb")
-for line in to_translate:
-    f.write(line + "\n")
-
-f.close()
-
-print "Done"

createicons.sh

@@ -1,6 +0,0 @@
-#!/bin/bash
-for size in 16 22 24 32 36 48 64 72 96 128 192 256; do mkdir -p deluge/ui/data/\
-icons/hicolor/${size}x${size}/apps; rsvg-convert -w ${size} -h ${size} \
--o deluge/ui/data/icons/hicolor/${size}x${size}/apps/deluge.png deluge/ui/data/pixmaps\
-/deluge.svg; mkdir -p deluge/ui/data/icons/scalable/apps/; cp deluge/ui/data/pixmaps/\
-deluge.svg deluge/ui/data/icons/scalable/apps/deluge.svg; done

deluge/__init__.py

@@ -1,4 +1 @@
 """Deluge"""
-# this is a namespace package
-import pkg_resources
-pkg_resources.declare_namespace(__name__)

deluge/__rpcapi.py

@@ -1,20 +0,0 @@
-from new import classobj
-from deluge.core.core import Core
-from deluge.core.daemon import Daemon
-
-class RpcApi:
-    pass
-
-def scan_for_methods(obj):
-    methods = {
-        '__doc__': 'Methods available in %s' % obj.__name__.lower()
-    }
-    for d in dir(obj):
-        if not hasattr(getattr(obj,d), '_rpcserver_export'):
-            continue
-        methods[d] = getattr(obj, d)
-    cobj = classobj(obj.__name__.lower(), (object,), methods)
-    setattr(RpcApi, obj.__name__.lower(), cobj)
-
-scan_for_methods(Core)
-scan_for_methods(Daemon)

deluge/_libtorrent.py

@@ -1,60 +1,33 @@
-#
-# _libtorrent.py
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2009 Andrew Resch <andrewresch@gmail.com>
 #
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
 
 """
-This module is used to handle the importing of libtorrent.
+This module is used to handle the importing of libtorrent and also controls
+the minimum versions of libtorrent that this version of Deluge supports.
 
-We use this module to control what versions of libtorrent this version of Deluge
-supports.
-
-** Usage **
-
->>> from deluge._libtorrent import lt
+Example:
+    >>> from deluge._libtorrent import lt
 
 """
+from __future__ import unicode_literals
 
-REQUIRED_VERSION = "0.16.7.0"
-
-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)
+from deluge.common import VersionSplit, get_version
 
 try:
     import deluge.libtorrent as lt
-    check_version(lt)
 except ImportError:
     import libtorrent as lt
-    check_version(lt)
+
+REQUIRED_VERSION = '1.1.2.0'
+LT_VERSION = lt.__version__
+
+if VersionSplit(LT_VERSION) < VersionSplit(REQUIRED_VERSION):
+    raise ImportError(
+        'Deluge %s requires libtorrent >= %s' % (get_version(), REQUIRED_VERSION)
+    )

deluge/argparserbase.py

@@ -0,0 +1,387 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2007 Andrew Resch <andrewresch@gmail.com>
+#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
+#
+
+from __future__ import unicode_literals
+
+import argparse
+import logging
+import os
+import platform
+import sys
+import textwrap
+
+import deluge.log
+from deluge import common
+from deluge.configmanager import get_config_dir, set_config_dir
+
+
+def find_subcommand(self, args=None, sys_argv=True):
+    """Find if a subcommand has been supplied.
+
+    Args:
+        args (list, optional): The argument list to search through.
+        sys_argv (bool): Use sys.argv[1:] if args is None.
+
+    Returns:
+        int: Index of the subcommand or '-1' if none found.
+
+    """
+    subcommand_found = -1
+    if args is None:
+        args = sys.argv[1:] if sys_argv is None else []
+
+    for x in self._subparsers._actions:
+        if not isinstance(x, argparse._SubParsersAction):
+            continue
+        for sp_name in x._name_parser_map:
+            if sp_name in args:
+                subcommand_found = args.index(sp_name)
+
+    return subcommand_found
+
+
+def set_default_subparser(self, name, abort_opts=None):
+    """Sets the default argparse subparser.
+
+    Args:
+        name (str): The name of the default subparser.
+        abort_opts (list): The arguments to test for in case no subcommand is found.
+                           If any of the values are found, the default subparser will
+                           not be inserted into sys.argv.
+
+    Returns:
+        list: The arguments found in sys.argv if no subcommand found, else None
+
+    """
+    found_abort_opts = []
+    abort_opts = [] if abort_opts is None else abort_opts
+    test_args = sys.argv[1:]
+    subparser_found = self.find_subcommand(args=test_args)
+
+    for i, arg in enumerate(test_args):
+        if subparser_found == i:
+            break
+        if arg in abort_opts:
+            found_abort_opts.append(arg)
+
+    if subparser_found == -1:
+        if found_abort_opts:
+            # Found one or more of arguments in abort_opts
+            return found_abort_opts
+
+        # insert default in first position, this implies no
+        # global options without a sub_parsers specified
+        sys.argv.insert(1, name)
+
+    return None
+
+
+argparse.ArgumentParser.find_subcommand = find_subcommand
+argparse.ArgumentParser.set_default_subparser = set_default_subparser
+
+
+def _get_version_detail():
+    version_str = '%s\n' % (common.get_version())
+    try:
+        from deluge._libtorrent import LT_VERSION
+
+        version_str += 'libtorrent: %s\n' % LT_VERSION
+    except ImportError:
+        pass
+    version_str += 'Python: %s\n' % platform.python_version()
+    version_str += 'OS: %s %s\n' % (platform.system(), common.get_os_version())
+    return version_str
+
+
+class DelugeTextHelpFormatter(argparse.RawDescriptionHelpFormatter):
+    """Help message formatter which retains formatting of all help text."""
+
+    def _split_lines(self, text, width):
+        """
+        Do not remove whitespaces in string but still wrap text to max width.
+        Instead of passing the entire text to textwrap.wrap, split and pass each
+        line instead. This way list formatting is not mangled by textwrap.wrap.
+        """
+        wrapped_lines = []
+        for l in text.splitlines():
+            wrapped_lines.extend(textwrap.wrap(l, width, subsequent_indent='  '))
+        return wrapped_lines
+
+    def _format_action_invocation(self, action):
+        """
+        Combines the options with comma and displays the argument
+        value only once instead of after both options.
+        Instead of: -s <arg>, --long-opt <arg>
+        Show      : -s, --long-opt <arg>
+
+        """
+        if not action.option_strings:
+            metavar, = self._metavar_formatter(action, action.dest)(1)
+            return metavar
+        else:
+            parts = []
+            # if the Optional doesn't take a value, format is:
+            #    -s, --long
+            if action.nargs == 0:
+                parts.extend(action.option_strings)
+
+            # if the Optional takes a value, format is:
+            #    -s, --long ARGS
+            else:
+                default = action.dest.upper()
+                args_string = self._format_args(action, default)
+                opt = ', '.join(action.option_strings)
+                parts.append('%s %s' % (opt, args_string))
+            return ', '.join(parts)
+
+
+class HelpAction(argparse._HelpAction):
+    def __call__(self, parser, namespace, values, option_string=None):
+        if hasattr(parser, 'subparser'):
+            subparser = getattr(parser, 'subparser')
+            subparser.print_help()
+        else:
+            parser.print_help()
+        parser.exit()
+
+
+class ArgParserBase(argparse.ArgumentParser):
+    def __init__(self, *args, **kwargs):
+        if 'formatter_class' not in kwargs:
+            kwargs['formatter_class'] = lambda prog: DelugeTextHelpFormatter(
+                prog, max_help_position=33, width=90
+            )
+
+        kwargs['add_help'] = kwargs.get('add_help', False)
+        common_help = kwargs.pop('common_help', True)
+        self.log_stream = sys.stdout
+        if 'log_stream' in kwargs:
+            self.log_stream = kwargs['log_stream']
+            del kwargs['log_stream']
+
+        super(ArgParserBase, self).__init__(*args, **kwargs)
+
+        self.common_setup = False
+        self.process_arg_group = False
+        self.group = self.add_argument_group(_('Common Options'))
+        if common_help:
+            self.group.add_argument(
+                '-h', '--help', action=HelpAction, help=_('Print this help message')
+            )
+        self.group.add_argument(
+            '-V',
+            '--version',
+            action='version',
+            version='%(prog)s ' + _get_version_detail(),
+            help=_('Print version information'),
+        )
+        self.group.add_argument(
+            '-v',
+            action='version',
+            version='%(prog)s ' + _get_version_detail(),
+            help=argparse.SUPPRESS,
+        )  # Deprecated arg
+        self.group.add_argument(
+            '-c',
+            '--config',
+            metavar='<config>',
+            help=_('Set the config directory path'),
+        )
+        self.group.add_argument(
+            '-l',
+            '--logfile',
+            metavar='<logfile>',
+            help=_('Output to specified logfile instead of stdout'),
+        )
+        self.group.add_argument(
+            '-L',
+            '--loglevel',
+            choices=[l for k in deluge.log.levels for l in (k, k.upper())],
+            help=_('Set the log level (none, error, warning, info, debug)'),
+            metavar='<level>',
+        )
+        self.group.add_argument(
+            '--logrotate',
+            nargs='?',
+            const='2M',
+            metavar='<max-size>',
+            help=_(
+                'Enable logfile rotation, with optional maximum logfile size, '
+                'default: %(const)s (Logfile rotation count is 5)'
+            ),
+        )
+        self.group.add_argument(
+            '-q',
+            '--quiet',
+            action='store_true',
+            help=_('Quieten logging output (Same as `--loglevel none`)'),
+        )
+        self.group.add_argument(
+            '--profile',
+            metavar='<profile-file>',
+            nargs='?',
+            default=False,
+            help=_(
+                'Profile %(prog)s with cProfile. Outputs to stdout '
+                'unless a filename is specified'
+            ),
+        )
+
+    def parse_args(self, args=None):
+        """Parse UI arguments and handle common and process group options.
+
+        Notes:
+            Unknown arguments results in usage text printed and system exit.
+
+        Args:
+            args (list, optional): The arguments to parse.
+
+        Returns:
+            argparse.Namespace: The parsed arguments.
+
+        """
+        options = super(ArgParserBase, self).parse_args(args=args)
+        return self._handle_ui_options(options)
+
+    def parse_known_ui_args(self, args, withhold=None):
+        """Parse UI arguments and handle common and process group options without error.
+
+        Args:
+            args (list): The arguments to parse.
+            withhold (list): Values to ignore in the args list.
+
+        Returns:
+            argparse.Namespace: The parsed arguments.
+
+        """
+        if withhold:
+            args = [a for a in args if a not in withhold]
+        options, remaining = super(ArgParserBase, self).parse_known_args(args=args)
+        options.remaining = remaining
+        # Hanlde common and process group options
+        return self._handle_ui_options(options)
+
+    def _handle_ui_options(self, options):
+        """Handle UI common and process group options.
+
+        Args:
+            options (argparse.Namespace): The parsed options.
+
+        Returns:
+            argparse.Namespace: The parsed options.
+
+        """
+        if not self.common_setup:
+            self.common_setup = True
+
+            # Setup the logger
+            if options.quiet:
+                options.loglevel = 'none'
+            if options.loglevel:
+                options.loglevel = options.loglevel.lower()
+
+            logfile_mode = 'w'
+            logrotate = options.logrotate
+            if options.logrotate:
+                logfile_mode = 'a'
+                logrotate = common.parse_human_size(options.logrotate)
+
+            # Setup the logger
+            deluge.log.setup_logger(
+                level=options.loglevel,
+                filename=options.logfile,
+                filemode=logfile_mode,
+                logrotate=logrotate,
+                output_stream=self.log_stream,
+            )
+
+            if options.config:
+                if not set_config_dir(options.config):
+                    log = logging.getLogger(__name__)
+                    log.error('There was an error setting the config dir! Exiting..')
+                    sys.exit(1)
+            else:
+                if not os.path.exists(common.get_default_config_dir()):
+                    os.makedirs(common.get_default_config_dir())
+
+        if self.process_arg_group:
+            self.process_arg_group = False
+            # If donotdaemonize is set, skip process forking.
+            if not (common.windows_check() or options.donotdaemonize):
+                if os.fork():
+                    os._exit(0)
+                os.setsid()
+                # Do second fork
+                if os.fork():
+                    os._exit(0)
+                # Ensure process doesn't keep any directory in use that may prevent a filesystem unmount.
+                os.chdir(get_config_dir())
+
+            # Write pid file before chuid
+            if options.pidfile:
+                with open(options.pidfile, 'wb') as _file:
+                    _file.write('%d\n' % os.getpid())
+
+            if not common.windows_check():
+                if options.user:
+                    if not options.user.isdigit():
+                        import pwd
+
+                        options.user = pwd.getpwnam(options.user)[2]
+                    os.setuid(options.user)
+                if options.group:
+                    if not options.group.isdigit():
+                        import grp
+
+                        options.group = grp.getgrnam(options.group)[2]
+                    os.setuid(options.group)
+
+        return options
+
+    def add_process_arg_group(self):
+        """Adds a grouping of common process args to control a daemon to the parser"""
+
+        self.process_arg_group = True
+        self.group = self.add_argument_group(_('Process Control Options'))
+        self.group.add_argument(
+            '-P',
+            '--pidfile',
+            metavar='<pidfile>',
+            action='store',
+            help=_('Pidfile to store the process id'),
+        )
+        if not common.windows_check():
+            self.group.add_argument(
+                '-d',
+                '--do-not-daemonize',
+                dest='donotdaemonize',
+                action='store_true',
+                help=_('Do not daemonize (fork) this process'),
+            )
+            self.group.add_argument(
+                '-f',
+                '--fork',
+                dest='donotdaemonize',
+                action='store_false',
+                help=argparse.SUPPRESS,
+            )  # Deprecated arg
+            self.group.add_argument(
+                '-U',
+                '--user',
+                metavar='<user>',
+                action='store',
+                help=_('Change to this user on startup (Requires root)'),
+            )
+            self.group.add_argument(
+                '-g',
+                '--group',
+                metavar='<group>',
+                action='store',
+                help=_('Change to this group on startup (Requires root)'),
+            )

deluge/bencode.py

@@ -9,66 +9,85 @@
 # License.
 
 # Written by Petru Paler
+# Updated by Calum Lind to support both Python 2 and Python 3.
+
+from __future__ import unicode_literals
+
+from sys import version_info
+
+PY2 = version_info.major == 2
+
+
+class BTFailure(Exception):
+    pass
+
+
+DICT_DELIM = b'd'
+END_DELIM = b'e'
+INT_DELIM = b'i'
+LIST_DELIM = b'l'
+BYTE_SEP = b':'
 
-# Minor modifications made by Andrew Resch to replace the BTFailure errors with Exceptions
 
 def decode_int(x, f):
     f += 1
-    newf = x.index('e', f)
+    newf = x.index(END_DELIM, f)
     n = int(x[f:newf])
-    if x[f] == '-':
-        if x[f + 1] == '0':
-            raise ValueError
-    elif x[f] == '0' and newf != f+1:
+    if x[f : f + 1] == b'-' and x[f + 1 : f + 2] == b'0':
         raise ValueError
-    return (n, newf+1)
+    elif x[f : f + 1] == b'0' and newf != f + 1:
+        raise ValueError
+    return (n, newf + 1)
+
 
 def decode_string(x, f):
-    colon = x.index(':', f)
+    colon = x.index(BYTE_SEP, f)
     n = int(x[f:colon])
-    if x[f] == '0' and colon != f+1:
+    if x[f : f + 1] == b'0' and colon != f + 1:
         raise ValueError
     colon += 1
-    return (x[colon:colon+n], colon+n)
+    return (x[colon : colon + n], colon + n)
+
 
 def decode_list(x, f):
-    r, f = [], f+1
-    while x[f] != 'e':
-        v, f = decode_func[x[f]](x, f)
+    r, f = [], f + 1
+    while x[f : f + 1] != END_DELIM:
+        v, f = decode_func[x[f : f + 1]](x, f)
         r.append(v)
     return (r, f + 1)
 
+
 def decode_dict(x, f):
-    r, f = {}, f+1
-    while x[f] != 'e':
+    r, f = {}, f + 1
+    while x[f : f + 1] != END_DELIM:
         k, f = decode_string(x, f)
-        r[k], f = decode_func[x[f]](x, f)
+        r[k], f = decode_func[x[f : f + 1]](x, f)
     return (r, f + 1)
 
+
 decode_func = {}
-decode_func['l'] = decode_list
-decode_func['d'] = decode_dict
-decode_func['i'] = decode_int
-decode_func['0'] = decode_string
-decode_func['1'] = decode_string
-decode_func['2'] = decode_string
-decode_func['3'] = decode_string
-decode_func['4'] = decode_string
-decode_func['5'] = decode_string
-decode_func['6'] = decode_string
-decode_func['7'] = decode_string
-decode_func['8'] = decode_string
-decode_func['9'] = decode_string
+decode_func[LIST_DELIM] = decode_list
+decode_func[DICT_DELIM] = decode_dict
+decode_func[INT_DELIM] = decode_int
+decode_func[b'0'] = decode_string
+decode_func[b'1'] = decode_string
+decode_func[b'2'] = decode_string
+decode_func[b'3'] = decode_string
+decode_func[b'4'] = decode_string
+decode_func[b'5'] = decode_string
+decode_func[b'6'] = decode_string
+decode_func[b'7'] = decode_string
+decode_func[b'8'] = decode_string
+decode_func[b'9'] = decode_string
+
 
 def bdecode(x):
     try:
-        r, l = decode_func[x[0]](x, 0)
-    except (IndexError, KeyError, ValueError):
-        raise Exception("not a valid bencoded string")
-
-    return r
-
-from types import StringType, IntType, LongType, DictType, ListType, TupleType
+        r, __ = decode_func[x[0:1]](x, 0)
+    except (LookupError, TypeError, ValueError):
+        raise BTFailure('Not a valid bencoded string')
+    else:
+        return r
 
 
 class Bencached(object):
@@ -78,52 +97,62 @@ class Bencached(object):
     def __init__(self, s):
         self.bencoded = s
 
-def encode_bencached(x,r):
+
+def encode_bencached(x, r):
     r.append(x.bencoded)
 
+
 def encode_int(x, r):
-    r.extend(('i', str(x), 'e'))
+    r.extend((INT_DELIM, str(x).encode('utf8'), END_DELIM))
+
 
 def encode_bool(x, r):
-    if x:
-        encode_int(1, r)
-    else:
-        encode_int(0, r)
+    encode_int(1 if x else 0, r)
+
 
 def encode_string(x, r):
-    r.extend((str(len(x)), ':', x))
+    encode_bytes(x.encode('utf8'), r)
+
+
+def encode_bytes(x, r):
+    r.extend((str(len(x)).encode('utf8'), BYTE_SEP, x))
+
 
 def encode_list(x, r):
-    r.append('l')
+    r.append(LIST_DELIM)
     for i in x:
         encode_func[type(i)](i, r)
-    r.append('e')
+    r.append(END_DELIM)
 
-def encode_dict(x,r):
-    r.append('d')
-    ilist = x.items()
-    ilist.sort()
-    for k, v in ilist:
-        r.extend((str(len(k)), ':', k))
+
+def encode_dict(x, r):
+    r.append(DICT_DELIM)
+    for k, v in sorted(x.items()):
+        try:
+            k = k.encode('utf8')
+        except AttributeError:
+            pass
+        r.extend((str(len(k)).encode('utf8'), BYTE_SEP, k))
         encode_func[type(v)](v, r)
-    r.append('e')
+    r.append(END_DELIM)
+
 
 encode_func = {}
 encode_func[Bencached] = encode_bencached
-encode_func[IntType] = encode_int
-encode_func[LongType] = encode_int
-encode_func[StringType] = encode_string
-encode_func[ListType] = encode_list
-encode_func[TupleType] = encode_list
-encode_func[DictType] = encode_dict
+encode_func[int] = encode_int
+encode_func[list] = encode_list
+encode_func[tuple] = encode_list
+encode_func[dict] = encode_dict
+encode_func[bool] = encode_bool
+encode_func[str] = encode_string
+encode_func[bytes] = encode_bytes
+if PY2:
+    encode_func[long] = encode_int  # noqa: F821
+    encode_func[str] = encode_bytes
+    encode_func[unicode] = encode_string  # noqa: F821
 
-try:
-    from types import BooleanType
-    encode_func[BooleanType] = encode_bool
-except ImportError:
-    pass
 
 def bencode(x):
     r = []
     encode_func[type(x)](x, r)
-    return ''.join(r)
+    return b''.join(r)

deluge/component.py

@@ -1,51 +1,53 @@
-#
-# component.py
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2007-2010 Andrew Resch <andrewresch@gmail.com>
 #
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
 
+from __future__ import unicode_literals
+
 import logging
+import traceback
 from collections import defaultdict
-from twisted.internet.defer import maybeDeferred, succeed, DeferredList, fail
-from twisted.internet.task import LoopingCall
+
+from six import string_types
+from twisted.internet import reactor
+from twisted.internet.defer import DeferredList, fail, maybeDeferred, succeed
+from twisted.internet.task import LoopingCall, deferLater
 
 log = logging.getLogger(__name__)
 
+
 class ComponentAlreadyRegistered(Exception):
     pass
 
+
+class ComponentException(Exception):
+    def __init__(self, message, tb):
+        super(ComponentException, self).__init__(message)
+        self.message = message
+        self.tb = tb
+
+    def __str__(self):
+        s = super(ComponentException, self).__str__()
+        return '%s\n%s' % (s, ''.join(self.tb))
+
+    def __eq__(self, other):
+        if isinstance(other, self.__class__):
+            return self.message == other.message
+        else:
+            return False
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+
 class Component(object):
-    """
-    Component objects are singletons managed by the :class:`ComponentRegistry`.
+    """Component objects are singletons managed by the :class:`ComponentRegistry`.
+
     When a new Component object is instantiated, it will be automatically
     registered with the :class:`ComponentRegistry`.
 
@@ -89,11 +91,20 @@ class Component(object):
                     still be considered in a Started state.
 
     """
+
     def __init__(self, name, interval=1, depend=None):
+        """Initialize component.
+
+        Args:
+            name (str): Name of component.
+            interval (int, optional): The interval in seconds to call the update function.
+            depend (list, optional): The names of components this component depends on.
+
+        """
         self._component_name = name
         self._component_interval = interval
         self._component_depend = depend
-        self._component_state = "Stopped"
+        self._component_state = 'Stopped'
         self._component_timer = None
         self._component_starting_deferred = None
         self._component_stopping_deferred = None
@@ -104,57 +115,62 @@ class Component(object):
             _ComponentRegistry.deregister(self)
 
     def _component_start_timer(self):
-        if hasattr(self, "update"):
+        if hasattr(self, 'update'):
             self._component_timer = LoopingCall(self.update)
             self._component_timer.start(self._component_interval)
 
     def _component_start(self):
         def on_start(result):
-            self._component_state = "Started"
+            self._component_state = 'Started'
             self._component_starting_deferred = None
             self._component_start_timer()
             return True
 
         def on_start_fail(result):
-            self._component_state = "Stopped"
+            self._component_state = 'Stopped'
             self._component_starting_deferred = None
             log.error(result)
-            return result
+            return fail(result)
 
-        if self._component_state == "Stopped":
-            if hasattr(self, "start"):
-                self._component_state = "Starting"
-                d = maybeDeferred(self.start)
-                d.addCallback(on_start)
-                d.addErrback(on_start_fail)
+        if self._component_state == 'Stopped':
+            if hasattr(self, 'start'):
+                self._component_state = 'Starting'
+                d = deferLater(reactor, 0, self.start)
+                d.addCallbacks(on_start, on_start_fail)
                 self._component_starting_deferred = d
             else:
                 d = maybeDeferred(on_start, None)
-        elif self._component_state == "Starting":
+        elif self._component_state == 'Starting':
             return self._component_starting_deferred
-        elif self._component_state == "Started":
+        elif self._component_state == 'Started':
             d = succeed(True)
         else:
-            d = fail("Cannot start a component not in a Stopped state!")
-
+            d = fail(
+                ComponentException(
+                    'Trying to start component "%s" but it is '
+                    'not in a stopped state. Current state: %s'
+                    % (self._component_name, self._component_state),
+                    traceback.format_stack(limit=4),
+                )
+            )
         return d
 
     def _component_stop(self):
         def on_stop(result):
-            self._component_state = "Stopped"
+            self._component_state = 'Stopped'
             if self._component_timer and self._component_timer.running:
                 self._component_timer.stop()
             return True
 
         def on_stop_fail(result):
-            self._component_state = "Started"
+            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"
+        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)
@@ -162,43 +178,55 @@ class Component(object):
             else:
                 d = maybeDeferred(on_stop, None)
 
-        if self._component_state == "Stopping":
+        if self._component_state == 'Stopping':
             return self._component_stopping_deferred
 
         return succeed(None)
 
     def _component_pause(self):
         def on_pause(result):
-            self._component_state = "Paused"
+            self._component_state = 'Paused'
 
-        if self._component_state == "Started":
+        if self._component_state == 'Started':
             if self._component_timer and self._component_timer.running:
                 d = maybeDeferred(self._component_timer.stop)
                 d.addCallback(on_pause)
             else:
                 d = succeed(None)
-        elif self._component_state == "Paused":
+        elif self._component_state == 'Paused':
             d = succeed(None)
         else:
-            d = fail("Cannot pause a component in a non-Started state!")
-
+            d = fail(
+                ComponentException(
+                    'Trying to pause component "%s" but it is '
+                    'not in a started state. Current state: %s'
+                    % (self._component_name, self._component_state),
+                    traceback.format_stack(limit=4),
+                )
+            )
         return d
 
     def _component_resume(self):
         def on_resume(result):
-            self._component_state = "Started"
+            self._component_state = 'Started'
 
-        if self._component_state == "Paused":
+        if self._component_state == 'Paused':
             d = maybeDeferred(self._component_start_timer)
             d.addCallback(on_resume)
         else:
-            d = fail("Component cannot be resumed from a non-Paused state!")
-
+            d = fail(
+                ComponentException(
+                    'Trying to resume component "%s" but it is '
+                    'not in a paused state. Current state: %s'
+                    % (self._component_name, self._component_state),
+                    traceback.format_stack(limit=4),
+                )
+            )
         return d
 
     def _component_shutdown(self):
         def on_stop(result):
-            if hasattr(self, "shutdown"):
+            if hasattr(self, 'shutdown'):
                 return maybeDeferred(self.shutdown)
             return succeed(None)
 
@@ -206,6 +234,9 @@ class Component(object):
         d.addCallback(on_stop)
         return d
 
+    def get_state(self):
+        return self._component_state
+
     def start(self):
         pass
 
@@ -218,32 +249,36 @@ class Component(object):
     def shutdown(self):
         pass
 
+
 class ComponentRegistry(object):
+    """The ComponentRegistry holds a list of currently registered :class:`Component` objects.
+
+    It is used to manage the Components by starting, stopping, pausing and shutting them down.
     """
-    The ComponentRegistry holds a list of currently registered
-    :class:`Component` objects.  It is used to manage the Components by
-    starting, stopping, pausing and shutting them down.
-    """
+
     def __init__(self):
         self.components = {}
         # Stores all of the components that are dependent on a particular component
         self.dependents = defaultdict(list)
 
     def register(self, obj):
-        """
-        Registers a component object with the registry.  This is done
-        automatically when a Component object is instantiated.
+        """Register a component object with the registry.
 
-        :param obj: the Component object
-        :type obj: object
+        Note:
+            This is done automatically when a Component object is instantiated.
 
-        :raises ComponentAlreadyRegistered: if a component with the same name is already registered.
+        Args:
+            obj (Component): A component object to register.
+
+        Raises:
+            ComponentAlreadyRegistered: If a component with the same name is already registered.
 
         """
         name = obj._component_name
         if name in self.components:
             raise ComponentAlreadyRegistered(
-                "Component already registered with name %s" % name)
+                'Component already registered with name %s' % name
+            )
 
         self.components[obj._component_name] = obj
         if obj._component_depend:
@@ -251,42 +286,45 @@ class ComponentRegistry(object):
                 self.dependents[depend].append(name)
 
     def deregister(self, obj):
-        """
-        Deregisters a component from the registry.  A stop will be
+        """Deregister a component from the registry.  A stop will be
         issued to the component prior to deregistering it.
 
-        :param obj: the Component object
-        :type obj: object
+        Args:
+            obj (Component): a component object to deregister
+
+        Returns:
+            Deferred: a deferred object that will fire once the Component has been sucessfully deregistered
 
         """
-
         if obj in self.components.values():
-            log.debug("Deregistering Component: %s", obj._component_name)
+            log.debug('Deregistering Component: %s', obj._component_name)
             d = self.stop([obj._component_name])
+
             def on_stop(result, name):
-                del self.components[name]
+                # Component may have been removed, so pop to ensure it doesn't fail
+                self.components.pop(name, None)
+
             return d.addCallback(on_stop, obj._component_name)
         else:
             return succeed(None)
 
-    def start(self, names=[]):
-        """
-        Starts Components that are currently in a Stopped state and their
-        dependencies.  If *names* is specified, will only start those
-        Components and their dependencies and if not it will start all
-        registered components.
+    def start(self, names=None):
+        """Start Components, and their dependencies, that are currently in a Stopped state.
 
-        :param names: a list of Components to start
-        :type names: list
+        Note:
+            If no names are specified then all registered components will be started.
 
-        :returns: a Deferred object that will fire once all Components have been sucessfully started
-        :rtype: twisted.internet.defer.Deferred
+        Args:
+            names (list): A list of Components to start and their dependencies.
+
+        Returns:
+            Deferred: Fired once all Components have been successfully started.
 
         """
         # Start all the components if names is empty
         if not names:
-            names = self.components.keys()
-        elif isinstance(names, str):
+            names = list(self.components)
+        elif isinstance(names, string_types):
             names = [names]
 
         def on_depends_started(result, name):
@@ -305,22 +343,22 @@ class ComponentRegistry(object):
 
         return DeferredList(deferreds)
 
-    def stop(self, names=[]):
-        """
-        Stops Components that are currently not in a Stopped state.  If
-        *names* is specified, then it will only stop those Components,
-        and if not it will stop all the registered Components.
+    def stop(self, names=None):
+        """Stop Components that are currently not in a Stopped state.
 
-        :param names: a list of Components to start
-        :type names: list
+        Note:
+            If no names are specified then all registered components will be stopped.
 
-        :returns: a Deferred object that will fire once all Components have been sucessfully stopped
-        :rtype: twisted.internet.defer.Deferred
+        Args:
+            names (list): A list of Components to stop.
+
+        Returns:
+            Deferred: Fired once all Components have been successfully stopped.
 
         """
         if not names:
-            names = self.components.keys()
-        elif isinstance(names, str):
+            names = list(self.components)
+        elif isinstance(names, string_types):
             names = [names]
 
         def on_dependents_stopped(result, name):
@@ -335,7 +373,9 @@ class ComponentRegistry(object):
             if name in self.components:
                 if name in self.dependents:
                     # If other components depend on this component, stop them first
-                    d = self.stop(self.dependents[name]).addCallback(on_dependents_stopped, name)
+                    d = self.stop(self.dependents[name]).addCallback(
+                        on_dependents_stopped, name
+                    )
                     deferreds.append(d)
                     stopped_in_deferred.update(self.dependents[name])
                 else:
@@ -343,81 +383,84 @@ class ComponentRegistry(object):
 
         return DeferredList(deferreds)
 
-    def pause(self, names=[]):
-        """
-        Pauses Components that are currently in a Started state.  If
-        *names* is specified, then it will only pause those Components,
-        and if not it will pause all the registered Components.
+    def pause(self, names=None):
+        """Pause Components that are currently in a Started state.
 
-        :param names: a list of Components to pause
-        :type names: list
+        Note:
+            If no names are specified then all registered components will be paused.
 
-        :returns: a Deferred object that will fire once all Components have been sucessfully paused
-        :rtype: twisted.internet.defer.Deferred
+        Args:
+            names (list): A list of Components to pause.
+
+        Returns:
+            Deferred: Fired once all Components have been successfully paused.
 
         """
         if not names:
-            names = self.components.keys()
-        elif isinstance(names, str):
+            names = list(self.components)
+        elif isinstance(names, string_types):
             names = [names]
 
         deferreds = []
 
         for name in names:
-            if self.components[name]._component_state == "Started":
+            if self.components[name]._component_state == 'Started':
                 deferreds.append(self.components[name]._component_pause())
 
         return DeferredList(deferreds)
 
-    def resume(self, names=[]):
-        """
-        Resumes Components that are currently in a Paused state.  If
-        *names* is specified, then it will only resume those Components,
-        and if not it will resume all the registered Components.
+    def resume(self, names=None):
+        """Resume Components that are currently in a Paused state.
 
-        :param names: a list of Components to resume
-        :type names: list
+        Note:
+            If no names are specified then all registered components will be resumed.
 
-        :returns: a Deferred object that will fire once all Components have been successfully resumed
-        :rtype: twisted.internet.defer.Deferred
+        Args:
+            names (list): A list of Components to to resume.
+
+        Returns:
+            Deferred: Fired once all Components have been successfully resumed.
 
         """
         if not names:
-            names = self.components.keys()
-        elif isinstance(names, str):
+            names = list(self.components)
+        elif isinstance(names, string_types):
             names = [names]
 
         deferreds = []
 
         for name in names:
-            if self.components[name]._component_state == "Paused":
+            if self.components[name]._component_state == 'Paused':
                 deferreds.append(self.components[name]._component_resume())
 
         return DeferredList(deferreds)
 
     def shutdown(self):
-        """
-        Shutdowns all Components regardless of state.  This will call
-        :meth:`stop` on call the components prior to shutting down.  This should
-        be called when the program is exiting to ensure all Components have a
-        chance to properly shutdown.
+        """Shutdown all Components regardless of state.
 
-        :returns: a Deferred object that will fire once all Components have been successfully shut down
-        :rtype: twisted.internet.defer.Deferred
+        This will call stop() on all the components prior to shutting down. This should be called
+        when the program is exiting to ensure all Components have a chance to properly shutdown.
+
+        Returns:
+            Deferred: Fired once all Components have been successfully shut down.
 
         """
+
         def on_stopped(result):
-            return DeferredList(map(lambda c: c._component_shutdown(), self.components.values()))
+            return DeferredList(
+                [comp._component_shutdown() for comp in self.components.values()]
+            )
 
-        return self.stop(self.components.keys()).addCallback(on_stopped)
+        return self.stop(list(self.components)).addCallback(on_stopped)
 
     def update(self):
-        """
-        Updates all Components that are in a Started state.
-
-        """
+        """Update all Components that are in a Started state."""
         for component in self.components.items():
-            component.update()
+            try:
+                component.update()
+            except BaseException as ex:
+                log.exception(ex)
+
 
 _ComponentRegistry = ComponentRegistry()
 
@@ -429,17 +472,18 @@ resume = _ComponentRegistry.resume
 update = _ComponentRegistry.update
 shutdown = _ComponentRegistry.shutdown
 
+
 def get(name):
-    """
-    Return a reference to a component.
+    """Return a reference to a component.
 
-    :param name: the Component name to get
-    :type name: string
+    Args:
+        name (str): The Component name to get.
 
-    :returns: the Component object
-    :rtype: object
+    Returns:
+        Component: The Component object.
 
-    :raises KeyError: if the Component does not exist
+    Raises:
+        KeyError: If the Component does not exist.
 
     """
     return _ComponentRegistry.components[name]

deluge/config.py

@@ -1,38 +1,11 @@
-#
-# config.py
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2008 Andrew Resch <andrewresch@gmail.com>
 #
-# Deluge is free software.
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
-#
-
 
 """
 Deluge Config Module
@@ -66,96 +39,111 @@ this can only be done for the 'config file version' and not for the 'format'
 version as this will be done internally.
 
 """
+from __future__ import unicode_literals
 
-import cPickle as pickle
+import json
 import logging
-import shutil
 import os
+import shutil
+from codecs import getwriter
+from io import open
+from tempfile import NamedTemporaryFile
 
-import deluge.common
+import six.moves.cPickle as pickle  # noqa: N813
 
-json = deluge.common.json
+from deluge.common import JSON_FORMAT, get_default_config_dir
 
 log = logging.getLogger(__name__)
+callLater = None  # noqa: N816 Necessary for the config tests
+
 
 def prop(func):
     """Function decorator for defining property attributes
 
     The decorated function is expected to return a dictionary
     containing one or more of the following pairs:
+
         fget - function for getting attribute value
         fset - function for setting attribute value
         fdel - function for deleting attribute
+
     This can be conveniently constructed by the locals() builtin
     function; see:
     http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/205183
     """
     return property(doc=func.__doc__, **func())
 
+
 def find_json_objects(s):
-    """
-    Find json objects in a string.
+    """Find json objects in a string.
 
-    :param s: the string to find json objects in
-    :type s: string
+    Args:
+        s (str): the string to find json objects in
 
-    :returns: a list of tuples containing start and end locations of json objects in the string `s`
-    :rtype: [(start, end), ...]
+    Returns:
+        list: A list of tuples containing start and end locations of json
+            objects in string `s`. e.g. [(start, end), ...]
 
     """
     objects = []
     opens = 0
-    start = s.find("{")
+    start = s.find('{')
     offset = start
 
     if start < 0:
         return []
 
+    quoted = False
     for index, c in enumerate(s[offset:]):
-        if c == "{":
+        if c == '"':
+            quoted = not quoted
+        elif quoted:
+            continue
+        elif c == '{':
             opens += 1
-        elif c == "}":
+        elif c == '}':
             opens -= 1
             if opens == 0:
-                objects.append((start, index+offset+1))
+                objects.append((start, index + offset + 1))
                 start = index + offset + 1
 
     return objects
 
 
 class Config(object):
-    """
-    This class is used to access/create/modify config files
+    """This class is used to access/create/modify config files.
 
-    :param filename: the name of the config file
-    :param defaults: dictionary of default values
-    :param config_dir: the path to the config directory
+    Args:
+        filename (str): The config filename.
+        defaults (dict): The default config values to insert before loading the config file.
+        config_dir (str): the path to the config directory.
+        file_version (int): The file format for the default config values when creating
+            a fresh config. This value should be increased whenever a new migration function is
+            setup to convert old config files. (default: 1)
 
     """
-    def __init__(self, filename, defaults=None, config_dir=None):
+
+    def __init__(self, filename, defaults=None, config_dir=None, file_version=1):
         self.__config = {}
         self.__set_functions = {}
         self.__change_callbacks = []
 
         # These hold the version numbers and they will be set when loaded
-        self.__version = {
-            "format": 1,
-            "file": 1
-        }
+        self.__version = {'format': 1, 'file': file_version}
 
         # This will get set with a reactor.callLater whenever a config option
         # is set.
         self._save_timer = None
 
         if defaults:
-            for key, value in defaults.iteritems():
+            for key, value in defaults.items():
                 self.set_item(key, value)
 
         # Load the config from file in the config_dir
         if config_dir:
             self.__config_file = os.path.join(config_dir, filename)
         else:
-            self.__config_file = deluge.common.get_default_config_dir(filename)
+            self.__config_file = get_default_config_dir(filename)
 
         self.load()
 
@@ -163,110 +151,136 @@ class Config(object):
         return item in self.__config
 
     def __setitem__(self, key, value):
-        """
-        See
-        :meth:`set_item`
-        """
+        """See set_item"""
 
         return self.set_item(key, value)
 
     def set_item(self, key, value):
-        """
-        Sets item 'key' to 'value' in the config dictionary, but does not allow
-        changing the item's type unless it is None.  If the types do not match,
-        it will attempt to convert it to the set type before raising a ValueError.
+        """Sets item 'key' to 'value' in the config dictionary.
 
-        :param key: string, item to change to change
-        :param value: the value to change item to, must be same type as what is currently in the config
+        Does not allow changing the item's type unless it is None.
 
-        :raises ValueError: raised when the type of value is not the same as\
-what is currently in the config and it could not convert the value
+        If the types do not match, it will attempt to convert it to the
+        set type before raising a ValueError.
 
-        **Usage**
+        Args:
+            key (str): Item to change to change.
+            value (any): The value to change item to, must be same type as what is
+                currently in the config.
 
-        >>> config = Config("test.conf")
-        >>> config["test"] = 5
-        >>> config["test"]
-        5
+        Raises:
+            ValueError: Raised when the type of value is not the same as what is
+                currently in the config and it could not convert the value.
+
+        Examples:
+            >>> config = Config('test.conf')
+            >>> config['test'] = 5
+            >>> config['test']
+            5
 
         """
-        if isinstance(value, basestring):
-            value = deluge.common.utf8_encoded(value)
-
-
-        if not self.__config.has_key(key):
+        if key not in self.__config:
             self.__config[key] = value
-            log.debug("Setting '%s' to %s of %s", key, value, type(value))
+            log.debug('Setting key "%s" to: %s (of type: %s)', key, value, type(value))
             return
 
         if self.__config[key] == value:
             return
 
-        # Do not allow the type to change unless it is None
-        oldtype, newtype = type(self.__config[key]), type(value)
-
-        if value is not None and oldtype != type(None) and oldtype != newtype:
+        # Change the value type if it is not None and does not match.
+        type_match = isinstance(self.__config[key], (type(None), type(value)))
+        if value is not None and not type_match:
             try:
-                if oldtype == unicode:
-                    value = oldtype(value, "utf8")
-                else:
+                oldtype = type(self.__config[key])
+                # Don't convert to bytes as requires encoding and value will
+                # be decoded anyway.
+                if oldtype is not bytes:
                     value = oldtype(value)
             except ValueError:
-                log.warning("Type '%s' invalid for '%s'", newtype, key)
+                log.warning('Value Type "%s" invalid for key: %s', type(value), key)
                 raise
 
-        log.debug("Setting '%s' to %s of %s", key, value, type(value))
+        if isinstance(value, bytes):
+            value = value.decode('utf8')
 
+        log.debug('Setting key "%s" to: %s (of type: %s)', key, value, type(value))
         self.__config[key] = value
+
+        global callLater
+        if callLater is None:
+            # Must import here and not at the top or it will throw ReactorAlreadyInstalledError
+            from twisted.internet.reactor import (
+                callLater,
+            )  # pylint: disable=redefined-outer-name
         # Run the set_function for this key if any
-        from twisted.internet import reactor
         try:
             for func in self.__set_functions[key]:
-                reactor.callLater(0, func, key, value)
+                callLater(0, func, key, value)
         except KeyError:
             pass
         try:
+
             def do_change_callbacks(key, value):
                 for func in self.__change_callbacks:
                     func(key, value)
-            reactor.callLater(0, do_change_callbacks, key, value)
-        except:
+
+            callLater(0, do_change_callbacks, key, value)
+        except Exception:
             pass
 
         # We set the save_timer for 5 seconds if not already set
         if not self._save_timer or not self._save_timer.active():
-            self._save_timer = reactor.callLater(5, self.save)
+            self._save_timer = callLater(5, self.save)
 
     def __getitem__(self, key):
-        """
-        See
-        :meth:`get_item`
-        """
+        """See get_item """
         return self.get_item(key)
 
     def get_item(self, key):
-        """
-        Gets the value of item 'key'
+        """Gets the value of item 'key'.
 
-        :param key: the item for which you want it's value
-        :return: the value of item 'key'
+        Args:
+            key (str): The item for which you want it's value.
 
-        :raises KeyError: if 'key' is not in the config dictionary
+        Returns:
+            any: The value of item 'key'.
 
-        **Usage**
+        Raises:
+            ValueError: If 'key' is not in the config dictionary.
 
-        >>> config = Config("test.conf", defaults={"test": 5})
-        >>> config["test"]
-        5
+        Examples:
+            >>> config = Config('test.conf', defaults={'test': 5})
+            >>> config['test']
+            5
 
         """
-        if isinstance(self.__config[key], str):
-            try:
-                return self.__config[key].decode("utf8")
-            except UnicodeDecodeError:
-                return self.__config[key]
-        else:
-            return self.__config[key]
+        return self.__config[key]
+
+    def get(self, key, default=None):
+        """Gets the value of item 'key' if key is in the config, else default.
+
+        If default is not given, it defaults to None, so that this method
+        never raises a KeyError.
+
+        Args:
+            key (str): the item for which you want it's value
+            default (any): the default value if key is missing
+
+        Returns:
+            any: The value of item 'key' or default.
+
+        Examples:
+            >>> config = Config('test.conf', defaults={'test': 5})
+            >>> config.get('test', 10)
+            5
+            >>> config.get('bad_key', 10)
+            10
+
+        """
+        try:
+            return self.get_item(key)
+        except KeyError:
+            return default
 
     def __delitem__(self, key):
         """
@@ -276,59 +290,69 @@ what is currently in the config and it could not convert the value
         self.del_item(key)
 
     def del_item(self, key):
-        """
-        Deletes item with a specific key from the configuration.
+        """Deletes item with a specific key from the configuration.
 
-        :param key: the item which you wish to delete.
-        :raises KeyError: if 'key' is not in the config dictionary
+        Args:
+            key (str): The item which you wish to delete.
+
+        Raises:
+            ValueError: If 'key' is not in the config dictionary.
+
+        Examples:
+            >>> config = Config('test.conf', defaults={'test': 5})
+            >>> del config['test']
 
-        **Usage**
-        >>> config = Config("test.conf", defaults={"test": 5})
-        >>> del config["test"]
         """
+
         del self.__config[key]
-        # We set the save_timer for 5 seconds if not already set
-        from twisted.internet import reactor
-        if not self._save_timer or not self._save_timer.active():
-            self._save_timer = reactor.callLater(5, self.save)
 
+        global callLater
+        if callLater is None:
+            # Must import here and not at the top or it will throw ReactorAlreadyInstalledError
+            from twisted.internet.reactor import (
+                callLater,
+            )  # pylint: disable=redefined-outer-name
+
+        # We set the save_timer for 5 seconds if not already set
+        if not self._save_timer or not self._save_timer.active():
+            self._save_timer = callLater(5, self.save)
 
     def register_change_callback(self, callback):
-        """
-        Registers a callback function that will be called when a value is changed in the config dictionary
+        """Registers a callback function for any changed value.
 
-        :param callback: the function, callback(key, value)
+        Will be called when any value is changed in the config dictionary.
 
-        **Usage**
+        Args:
+            callback (func): The function to call with parameters: f(key, value).
 
-        >>> config = Config("test.conf", defaults={"test": 5})
-        >>> def cb(key, value):
-        ...     print key, value
-        ...
-        >>> config.register_change_callback(cb)
+        Examples:
+            >>> config = Config('test.conf', defaults={'test': 5})
+            >>> def cb(key, value):
+            ...     print key, value
+            ...
+            >>> config.register_change_callback(cb)
 
         """
         self.__change_callbacks.append(callback)
 
     def register_set_function(self, key, function, apply_now=True):
-        """
-        Register a function to be called when a config value changes
+        """Register a function to be called when a config value changes.
 
-        :param key: the item to monitor for change
-        :param function: the function to call when the value changes, f(key, value)
-        :keyword apply_now: if True, the function will be called after it's registered
+        Args:
+            key (str): The item to monitor for change.
+            function (func): The function to call when the value changes, f(key, value).
+            apply_now (bool): If True, the function will be called immediately after it's registered.
 
-        **Usage**
-
-        >>> config = Config("test.conf", defaults={"test": 5})
-        >>> def cb(key, value):
-        ...     print key, value
-        ...
-        >>> config.register_set_function("test", cb, apply_now=True)
-        test 5
+        Examples:
+            >>> config = Config('test.conf', defaults={'test': 5})
+            >>> def cb(key, value):
+            ...     print key, value
+            ...
+            >>> config.register_set_function('test', cb, apply_now=True)
+            test 5
 
         """
-        log.debug("Registering function for %s key..", key)
+        log.debug('Registering function for %s key..', key)
         if key not in self.__set_functions:
             self.__set_functions[key] = []
 
@@ -340,52 +364,50 @@ what is currently in the config and it could not convert the value
         return
 
     def apply_all(self):
-        """
-        Calls all set functions
+        """Calls all set functions.
 
-        **Usage**
-
-        >>> config = Config("test.conf", defaults={"test": 5})
-        >>> def cb(key, value):
-        ...     print key, value
-        ...
-        >>> config.register_set_function("test", cb, apply_now=False)
-        >>> config.apply_all()
-        test 5
+        Examples:
+            >>> config = Config('test.conf', defaults={'test': 5})
+            >>> def cb(key, value):
+            ...     print key, value
+            ...
+            >>> config.register_set_function('test', cb, apply_now=False)
+            >>> config.apply_all()
+            test 5
 
         """
-        log.debug("Calling all set functions..")
-        for key, value in self.__set_functions.iteritems():
+        log.debug('Calling all set functions..')
+        for key, value in self.__set_functions.items():
             for func in value:
                 func(key, self.__config[key])
 
     def apply_set_functions(self, key):
-        """
-        Calls set functions for `:param:key`.
+        """Calls set functions for `:param:key`.
 
-        :param key: str, the config key
+        Args:
+            key (str): the config key
 
         """
-        log.debug("Calling set functions for key %s..", key)
+        log.debug('Calling set functions for key %s..', key)
         if key in self.__set_functions:
             for func in self.__set_functions[key]:
                 func(key, self.__config[key])
 
     def load(self, filename=None):
-        """
-        Load a config file
-
-        :param filename: if None, uses filename set in object initialization
+        """Load a config file.
 
+        Args:
+            filename (str): If None, uses filename set in object initialization
 
         """
         if not filename:
             filename = self.__config_file
 
         try:
-            data = open(filename, "rb").read()
-        except IOError, e:
-            log.warning("Unable to open config file %s: %s", filename, e)
+            with open(filename, 'r', encoding='utf8') as _file:
+                data = _file.read()
+        except IOError as ex:
+            log.warning('Unable to open config file %s: %s', filename, ex)
             return
 
         objects = find_json_objects(data)
@@ -394,36 +416,42 @@ what is currently in the config and it could not convert the value
             # 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)
+            except Exception as ex:
+                log.exception(ex)
+                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)
+            except Exception as ex:
+                log.exception(ex)
+                log.warning('Unable to load config file: %s', filename)
         elif len(objects) == 2:
             try:
                 start, end = objects[0]
                 self.__version.update(json.loads(data[start:end]))
                 start, end = objects[1]
                 self.__config.update(json.loads(data[start:end]))
-            except Exception, e:
-                log.exception(e)
-                log.warning("Unable to load config file: %s", filename)
+            except Exception as ex:
+                log.exception(ex)
+                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)
+        log.debug(
+            'Config %s version: %s.%s loaded: %s',
+            filename,
+            self.__version['format'],
+            self.__version['file'],
+            self.__config,
+        )
 
     def save(self, filename=None):
-        """
-        Save configuration to disk
+        """Save configuration to disk.
 
-        :param filename: if None, uses filename set in object initiliazation
-        :rtype bool:
-        :return: whether or not the save succeeded.
+        Args:
+            filename (str): If None, uses filename set in object initialization
+
+        Returns:
+            bool: Whether or not the save succeeded.
 
         """
         if not filename:
@@ -431,7 +459,8 @@ what is currently in the config and it could not convert the value
         # Check to see if the current config differs from the one on disk
         # We will only write a new config file if there is a difference
         try:
-            data = open(filename, "rb").read()
+            with open(filename, 'r', encoding='utf8') as _file:
+                data = _file.read()
             objects = find_json_objects(data)
             start, end = objects[0]
             version = json.loads(data[start:end])
@@ -442,36 +471,41 @@ what is currently in the config and it could not convert the value
                 if self._save_timer and self._save_timer.active():
                     self._save_timer.cancel()
                 return True
-        except (IOError, IndexError), e:
-            log.warning("Unable to open config file: %s because: %s", filename, e)
+        except (IOError, IndexError) as ex:
+            log.warning('Unable to open config file: %s because: %s', filename, ex)
 
         # 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.__config, f, indent=2)
-            f.flush()
-            os.fsync(f.fileno())
-            f.close()
-        except IOError, e:
-            log.error("Error writing new config file: %s", e)
+            with NamedTemporaryFile(
+                prefix=os.path.basename(filename) + '.', delete=False
+            ) as _file:
+                filename_tmp = _file.name
+                log.debug('Saving new config file %s', filename_tmp)
+                json.dump(self.__version, getwriter('utf8')(_file), **JSON_FORMAT)
+                json.dump(self.__config, getwriter('utf8')(_file), **JSON_FORMAT)
+                _file.flush()
+                os.fsync(_file.fileno())
+        except IOError as ex:
+            log.error('Error writing new config file: %s', ex)
             return False
 
+        # Resolve symlinked config files before backing up and saving.
+        filename = os.path.realpath(filename)
+
         # Make a backup of the old config
         try:
-            log.debug("Backing up old config file to %s~", filename)
-            shutil.move(filename, filename + "~")
-        except Exception, e:
-            log.warning("Unable to backup old config...")
+            log.debug('Backing up old config file to %s.bak', filename)
+            shutil.move(filename, filename + '.bak')
+        except IOError as ex:
+            log.warning('Unable to backup old config: %s', ex)
 
         # The new config file has been written successfully, so let's move it over
         # the existing one.
         try:
-            log.debug("Moving new config file %s to %s..", filename + ".new", filename)
-            shutil.move(filename + ".new", filename)
-        except Exception, e:
-            log.error("Error moving new config file: %s", e)
+            log.debug('Moving new config file %s to %s', filename_tmp, filename)
+            shutil.move(filename_tmp, filename)
+        except IOError as ex:
+            log.error('Error moving new config file: %s', ex)
             return False
         else:
             return True
@@ -480,36 +514,42 @@ what is currently in the config and it could not convert the value
                 self._save_timer.cancel()
 
     def run_converter(self, input_range, output_version, func):
-        """
-        Runs a function that will convert file versions in the `:param:input_range`
-        to the `:param:output_version`.
+        """Runs a function that will convert file versions.
 
-        :param input_range: tuple, (int, int) the range of input versions this
-            function will accept
-        :param output_version: int, the version this function will return
-        :param func: func, the function that will do the conversion, it will take
-            the config dict as an argument and return the augmented dict
+        Args:
+            input_range (tuple): (int, int) The range of input versions this function will accept.
+            output_version (int): The version this function will convert to.
+            func (func): The function that will do the conversion, it will take the config
+                dict as an argument and return the augmented dict.
 
-        :raises ValueError: if the output_version is less than the input_range
+        Raises:
+            ValueError: If output_version is less than the input_range.
 
         """
         if output_version in input_range or output_version <= max(input_range):
-            raise ValueError("output_version needs to be greater than input_range")
+            raise ValueError('output_version needs to be greater than input_range')
 
-        if self.__version["file"] not in input_range:
-            log.debug("File version %s is not in input_range %s, ignoring converter function..",
-                self.__version["file"], input_range)
+        if self.__version['file'] not in input_range:
+            log.debug(
+                'File version %s is not in input_range %s, ignoring converter function..',
+                self.__version['file'],
+                input_range,
+            )
             return
 
         try:
             self.__config = func(self.__config)
-        except Exception, e:
-            log.exception(e)
-            log.error("There was an exception try to convert config file %s %s to %s",
-                self.__config_file, self.__version["file"], output_version)
-            raise e
+        except Exception as ex:
+            log.exception(ex)
+            log.error(
+                'There was an exception try to convert config file %s %s to %s',
+                self.__config_file,
+                self.__version['file'],
+                output_version,
+            )
+            raise ex
         else:
-            self.__version["file"] = output_version
+            self.__version['file'] = output_version
             self.save()
 
     @property
@@ -517,10 +557,13 @@ what is currently in the config and it could not convert the value
         return self.__config_file
 
     @prop
-    def config():
+    def config():  # pylint: disable=no-method-argument
         """The config dictionary"""
+
         def fget(self):
             return self.__config
+
         def fdel(self):
             return self.save()
+
         return locals()

deluge/configmanager.py

@@ -1,40 +1,16 @@
-#
-# configmanager.py
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2007 Andrew Resch <andrewresch@gmail.com>
 #
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
 
-import os
+from __future__ import unicode_literals
+
 import logging
+import os
 
 import deluge.common
 import deluge.log
@@ -42,9 +18,10 @@ from deluge.config import Config
 
 log = logging.getLogger(__name__)
 
-class _ConfigManager:
+
+class _ConfigManager(object):
     def __init__(self):
-        log.debug("ConfigManager started..")
+        log.debug('ConfigManager started..')
         self.config_files = {}
         self.__config_directory = None
 
@@ -69,16 +46,19 @@ class _ConfigManager:
         if not directory:
             return False
 
-        log.info("Setting config directory to: %s", directory)
+        # Ensure absolute dirpath
+        directory = os.path.abspath(directory)
+
+        log.info('Setting config directory to: %s', directory)
         if not os.path.exists(directory):
             # Try to create the config folder if it doesn't exist
             try:
                 os.makedirs(directory)
-            except Exception, e:
-                log.error("Unable to make config directory: %s", e)
+            except OSError as ex:
+                log.error('Unable to make config directory: %s', ex)
                 return False
         elif not os.path.isdir(directory):
-            log.error("Config directory needs to be a directory!")
+            log.error('Config directory needs to be a directory!')
             return False
 
         self.__config_directory = directory
@@ -109,30 +89,42 @@ class _ConfigManager:
         # We need to return True to keep the timer active
         return True
 
-    def get_config(self, config_file, defaults=None):
+    def get_config(self, config_file, defaults=None, file_version=1):
         """Get a reference to the Config object for this filename"""
-        log.debug("Getting config '%s'", config_file)
+        log.debug('Getting config: %s', config_file)
         # Create the config object if not already created
-        if config_file not in self.config_files.keys():
-            self.config_files[config_file] = Config(config_file, defaults, self.config_directory)
+        if config_file not in self.config_files:
+            self.config_files[config_file] = Config(
+                config_file,
+                defaults,
+                config_dir=self.config_directory,
+                file_version=file_version,
+            )
 
         return self.config_files[config_file]
 
+
 # Singleton functions
 _configmanager = _ConfigManager()
 
-def ConfigManager(config, defaults=None):
-    return _configmanager.get_config(config, defaults)
+
+def ConfigManager(config, defaults=None, file_version=1):  # NOQA: N802
+    return _configmanager.get_config(
+        config, defaults=defaults, file_version=file_version
+    )
+
 
 def set_config_dir(directory):
     """Sets the config directory, else just uses default"""
-    return _configmanager.set_config_dir(directory)
+    return _configmanager.set_config_dir(deluge.common.decode_bytes(directory))
+
 
 def get_config_dir(filename=None):
-    if filename != None:
+    if filename is not None:
         return os.path.join(_configmanager.get_config_dir(), filename)
     else:
         return _configmanager.get_config_dir()
 
+
 def close(config):
     return _configmanager.close(config)

deluge/core/alertmanager.py

@@ -1,83 +1,78 @@
-#
-# alertmanager.py
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2007-2009 Andrew Resch <andrewresch@gmail.com>
 #
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
 
 """
 
 The AlertManager handles all the libtorrent alerts.
 
-This should typically only be used by the Core.  Plugins should utilize the
+This should typically only be used by the Core. Plugins should utilize the
 `:mod:EventManager` for similar functionality.
 
 """
+from __future__ import unicode_literals
 
 import logging
+import types
+
 from twisted.internet import reactor
 
 import deluge.component as component
 from deluge._libtorrent import lt
-from deluge.common import decode_string
+from deluge.common import decode_bytes
 
 log = logging.getLogger(__name__)
 
-class AlertManager(component.Component):
-    def __init__(self):
-        log.debug("AlertManager initialized..")
-        component.Component.__init__(self, "AlertManager", interval=0.05)
-        self.session = component.get("Core").session
+try:
+    SimpleNamespace = types.SimpleNamespace  # Python 3.3+
+except AttributeError:
 
-        self.session.set_alert_mask(
-            lt.alert.category_t.error_notification |
-            lt.alert.category_t.port_mapping_notification |
-            lt.alert.category_t.storage_notification |
-            lt.alert.category_t.tracker_notification |
-            lt.alert.category_t.status_notification |
-            lt.alert.category_t.ip_block_notification |
-            lt.alert.category_t.performance_warning)
+    class SimpleNamespace(object):  # Python 2.7
+        def __init__(self, **attr):
+            self.__dict__.update(attr)
+
+
+class AlertManager(component.Component):
+    """AlertManager fetches and processes libtorrent alerts"""
+
+    def __init__(self):
+        log.debug('AlertManager init...')
+        component.Component.__init__(self, 'AlertManager', interval=0.3)
+        self.session = component.get('Core').session
+
+        # Increase the alert queue size so that alerts don't get lost.
+        self.alert_queue_size = 10000
+        self.set_alert_queue_size(self.alert_queue_size)
+
+        alert_mask = (
+            lt.alert.category_t.error_notification
+            | lt.alert.category_t.port_mapping_notification
+            | lt.alert.category_t.storage_notification
+            | lt.alert.category_t.tracker_notification
+            | lt.alert.category_t.status_notification
+            | lt.alert.category_t.ip_block_notification
+            | lt.alert.category_t.performance_warning
+        )
+
+        self.session.apply_settings({'alert_mask': alert_mask})
 
         # handlers is a dictionary of lists {"alert_type": [handler1,h2,..]}
         self.handlers = {}
         self.delayed_calls = []
-        self.wait_on_handler = False
 
     def update(self):
         self.delayed_calls = [dc for dc in self.delayed_calls if dc.active()]
-        self.handle_alerts(wait=self.wait_on_handler)
+        self.handle_alerts()
 
     def stop(self):
-        for dc in self.delayed_calls:
-            if dc.active():
-                dc.cancel()
+        for delayed_call in self.delayed_calls:
+            if delayed_call.active():
+                delayed_call.cancel()
         self.delayed_calls = []
 
     def register_handler(self, alert_type, handler):
@@ -96,7 +91,7 @@ class AlertManager(component.Component):
 
         # Append the handler to the list in the handlers dictionary
         self.handlers[alert_type].append(handler)
-        log.debug("Registered handler for alert %s", alert_type)
+        log.debug('Registered handler for alert %s', alert_type)
 
     def deregister_handler(self, handler):
         """
@@ -105,30 +100,53 @@ class AlertManager(component.Component):
         :param handler: func, the handler function to deregister
         """
         # Iterate through all handlers and remove 'handler' where found
-        for (key, value) in self.handlers.items():
+        for (dummy_key, value) in self.handlers.items():
             if handler in value:
                 # Handler is in this alert type list
                 value.remove(handler)
 
-    def handle_alerts(self, wait=False):
+    def handle_alerts(self):
         """
-        Pops all libtorrent alerts in the session queue and handles them
-        appropriately.
-
-        :param wait: bool, if True then the handler functions will be run right
-            away and waited to return before processing the next alert
+        Pops all libtorrent alerts in the session queue and handles them appropriately.
         """
         alerts = self.session.pop_alerts()
+        if not alerts:
+            return
+
+        num_alerts = len(alerts)
+        if log.isEnabledFor(logging.DEBUG):
+            log.debug('Alerts queued: %s', num_alerts)
+        if num_alerts > 0.9 * self.alert_queue_size:
+            log.warning(
+                'Warning total alerts queued, %s, passes 90%% of queue size.',
+                num_alerts,
+            )
+
         # Loop through all alerts in the queue
         for alert in alerts:
             alert_type = type(alert).__name__
             # Display the alert message
             if log.isEnabledFor(logging.DEBUG):
-                log.debug("%s: %s", alert_type, decode_string(alert.message()))
+                log.debug('%s: %s', alert_type, decode_bytes(alert.message()))
             # Call any handlers for this alert type
             if alert_type in self.handlers:
                 for handler in self.handlers[alert_type]:
-                    if not wait:
-                        self.delayed_calls.append(reactor.callLater(0, handler, alert))
-                    else:
-                        handler(alert)
+                    if log.isEnabledFor(logging.DEBUG):
+                        log.debug('Handling alert: %s', alert_type)
+                    # Copy alert attributes
+                    alert_copy = SimpleNamespace(
+                        **{
+                            attr: getattr(alert, attr)
+                            for attr in dir(alert)
+                            if not attr.startswith('__')
+                        }
+                    )
+                    self.delayed_calls.append(reactor.callLater(0, handler, alert_copy))
+
+    def set_alert_queue_size(self, queue_size):
+        """Sets the maximum size of the libtorrent alert queue"""
+        log.info('Alert Queue Size set to %s', queue_size)
+        self.alert_queue_size = queue_size
+        component.get('Core').apply_session_setting(
+            'alert_queue_size', self.alert_queue_size
+        )

deluge/core/authmanager.py

@@ -1,52 +1,31 @@
-#
-# authmanager.py
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2009 Andrew Resch <andrewresch@gmail.com>
 # Copyright (C) 2011 Pedro Algarvio <pedro@algarvio.me>
 #
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
 
-import os
-import random
-import stat
-import shutil
+from __future__ import unicode_literals
+
 import logging
+import os
+import shutil
+from io import open
 
 import deluge.component as component
 import deluge.configmanager as configmanager
-from deluge.common import (AUTH_LEVEL_ADMIN, AUTH_LEVEL_NONE, AUTH_LEVEL_NORMAL,
-                           AUTH_LEVEL_READONLY, AUTH_LEVEL_DEFAULT,
-                           create_localclient_account)
-
-from deluge.error import AuthManagerError, AuthenticationRequired, BadLoginError
+from deluge.common import (
+    AUTH_LEVEL_ADMIN,
+    AUTH_LEVEL_DEFAULT,
+    AUTH_LEVEL_NONE,
+    AUTH_LEVEL_NORMAL,
+    AUTH_LEVEL_READONLY,
+    create_localclient_account,
+)
+from deluge.error import AuthenticationRequired, AuthManagerError, BadLoginError
 
 log = logging.getLogger(__name__)
 
@@ -55,15 +34,14 @@ AUTH_LEVELS_MAPPING = {
     'READONLY': AUTH_LEVEL_READONLY,
     'DEFAULT': AUTH_LEVEL_NORMAL,
     'NORMAL': AUTH_LEVEL_DEFAULT,
-    'ADMIN': AUTH_LEVEL_ADMIN
+    'ADMIN': AUTH_LEVEL_ADMIN,
 }
+AUTH_LEVELS_MAPPING_REVERSE = {v: k for k, v in AUTH_LEVELS_MAPPING.items()}
 
-AUTH_LEVELS_MAPPING_REVERSE = {}
-for key, value in AUTH_LEVELS_MAPPING.iteritems():
-    AUTH_LEVELS_MAPPING_REVERSE[value] = key
 
 class Account(object):
     __slots__ = ('username', 'password', 'authlevel')
+
     def __init__(self, username, password, authlevel):
         self.username = username
         self.password = password
@@ -74,17 +52,19 @@ class Account(object):
             'username': self.username,
             'password': self.password,
             'authlevel': AUTH_LEVELS_MAPPING_REVERSE[self.authlevel],
-            'authlevel_int': self.authlevel
+            'authlevel_int': self.authlevel,
         }
 
     def __repr__(self):
-        return ('<Account username="%(username)s" authlevel=%(authlevel)s>' %
-                self.__dict__)
+        return '<Account username="%(username)s" authlevel=%(authlevel)s>' % {
+            'username': self.username,
+            'authlevel': self.authlevel,
+        }
 
 
 class AuthManager(component.Component):
     def __init__(self):
-        component.Component.__init__(self, "AuthManager", interval=10)
+        component.Component.__init__(self, 'AuthManager', interval=10)
         self.__auth = {}
         self.__auth_modification_time = None
 
@@ -98,93 +78,96 @@ class AuthManager(component.Component):
         pass
 
     def update(self):
-        auth_file = configmanager.get_config_dir("auth")
+        auth_file = configmanager.get_config_dir('auth')
         # Check for auth file and create if necessary
-        if not os.path.exists(auth_file):
-            log.info("Authfile not found, recreating it.")
+        if not os.path.isfile(auth_file):
+            log.info('Authfile not found, recreating it.')
             self.__load_auth_file()
             return
 
         auth_file_modification_time = os.stat(auth_file).st_mtime
         if self.__auth_modification_time != auth_file_modification_time:
-            log.info("Auth file changed, reloading it!")
+            log.info('Auth file changed, reloading it!')
             self.__load_auth_file()
 
     def authorize(self, username, password):
-        """
-        Authorizes users based on username and password
+        """Authorizes users based on username and password.
 
-        :param username: str, username
-        :param password: str, password
-        :returns: int, the auth level for this user
-        :rtype: int
+        Args:
+            username (str): Username
+            password (str): Password
 
-        :raises AuthenticationRequired: if aditional details are required to
-                                        authenticate.
-        :raises BadLoginError: if the username does not exist or password does
-                               not match.
+        Returns:
+            int: The auth level for this user.
+
+        Raises:
+            AuthenticationRequired: If aditional details are required to authenticate.
+            BadLoginError: If the username does not exist or password does not match.
 
         """
         if not username:
             raise AuthenticationRequired(
-                "Username and Password are required.", username
+                'Username and Password are required.', username
             )
 
         if username not in self.__auth:
             # Let's try to re-load the file.. Maybe it's been updated
             self.__load_auth_file()
             if username not in self.__auth:
-                raise BadLoginError("Username does not exist", username)
+                raise BadLoginError('Username does not exist', username)
 
         if self.__auth[username].password == password:
             # Return the users auth level
             return self.__auth[username].authlevel
         elif not password and self.__auth[username].password:
-            raise AuthenticationRequired("Password is required", username)
+            raise AuthenticationRequired('Password is required', username)
         else:
-            raise BadLoginError("Password does not match", username)
+            raise BadLoginError('Password does not match', username)
 
     def has_account(self, username):
         return username in self.__auth
 
     def get_known_accounts(self):
-        """
-        Returns a list of known deluge usernames.
-        """
+        """Returns a list of known deluge usernames."""
         self.__load_auth_file()
         return [account.data() for account in self.__auth.values()]
 
     def create_account(self, username, password, authlevel):
         if username in self.__auth:
-            raise AuthManagerError("Username in use.", username)
+            raise AuthManagerError('Username in use.', username)
+        if authlevel not in AUTH_LEVELS_MAPPING:
+            raise AuthManagerError('Invalid auth level: %s' % authlevel)
         try:
-            self.__auth[username] = Account(username, password,
-                                            AUTH_LEVELS_MAPPING[authlevel])
+            self.__auth[username] = Account(
+                username, password, AUTH_LEVELS_MAPPING[authlevel]
+            )
             self.write_auth_file()
             return True
-        except Exception, err:
-            log.exception(err)
-            raise err
+        except Exception as ex:
+            log.exception(ex)
+            raise ex
 
     def update_account(self, username, password, authlevel):
         if username not in self.__auth:
-            raise AuthManagerError("Username not known", username)
+            raise AuthManagerError('Username not known', username)
+        if authlevel not in AUTH_LEVELS_MAPPING:
+            raise AuthManagerError('Invalid auth level: %s' % authlevel)
         try:
             self.__auth[username].username = username
             self.__auth[username].password = password
             self.__auth[username].authlevel = AUTH_LEVELS_MAPPING[authlevel]
             self.write_auth_file()
             return True
-        except Exception, err:
-            log.exception(err)
-            raise err
+        except Exception as ex:
+            log.exception(ex)
+            raise ex
 
     def remove_account(self, username):
         if username not in self.__auth:
-            raise AuthManagerError("Username not known", username)
-        elif username == component.get("RPCServer").get_session_user():
+            raise AuthManagerError('Username not known', username)
+        elif username == component.get('RPCServer').get_session_user():
             raise AuthManagerError(
-                "You cannot delete your own account while logged in!", username
+                'You cannot delete your own account while logged in!', username
             )
 
         del self.__auth[username]
@@ -192,36 +175,45 @@ class AuthManager(component.Component):
         return True
 
     def write_auth_file(self):
-        old_auth_file = configmanager.get_config_dir("auth")
-        new_auth_file = old_auth_file + '.new'
-        bak_auth_file = old_auth_file + '.bak'
-        # Let's first create a backup
-        if os.path.exists(old_auth_file):
-            shutil.copy2(old_auth_file, bak_auth_file)
+        filename = 'auth'
+        filepath = os.path.join(configmanager.get_config_dir(), filename)
+        filepath_bak = filepath + '.bak'
+        filepath_tmp = filepath + '.tmp'
 
         try:
-            fd = open(new_auth_file, "w")
-            for account in self.__auth.values():
-                fd.write(
-                    "%(username)s:%(password)s:%(authlevel_int)s\n" %
-                    account.data()
-                )
-            fd.flush()
-            os.fsync(fd.fileno())
-            fd.close()
-            os.rename(new_auth_file, old_auth_file)
-        except:
-            # Something failed, let's restore the previous file
-            if os.path.exists(bak_auth_file):
-                os.rename(bak_auth_file, old_auth_file)
+            if os.path.isfile(filepath):
+                log.debug('Creating backup of %s at: %s', filename, filepath_bak)
+                shutil.copy2(filepath, filepath_bak)
+        except IOError as ex:
+            log.error('Unable to backup %s to %s: %s', filepath, filepath_bak, ex)
+        else:
+            log.info('Saving the %s at: %s', filename, filepath)
+            try:
+                with open(filepath_tmp, 'w', encoding='utf8') as _file:
+                    for account in self.__auth.values():
+                        _file.write(
+                            '%(username)s:%(password)s:%(authlevel_int)s\n'
+                            % account.data()
+                        )
+                    _file.flush()
+                    os.fsync(_file.fileno())
+                shutil.move(filepath_tmp, filepath)
+            except IOError as ex:
+                log.error('Unable to save %s: %s', filename, ex)
+                if os.path.isfile(filepath_bak):
+                    log.info('Restoring backup of %s from: %s', filename, filepath_bak)
+                    shutil.move(filepath_bak, filepath)
 
         self.__load_auth_file()
 
     def __load_auth_file(self):
         save_and_reload = False
-        auth_file = configmanager.get_config_dir("auth")
+        filename = 'auth'
+        auth_file = configmanager.get_config_dir(filename)
+        auth_file_bak = auth_file + '.bak'
+
         # Check for auth file and create if necessary
-        if not os.path.exists(auth_file):
+        if not os.path.isfile(auth_file):
             create_localclient_account()
             return self.__load_auth_file()
 
@@ -232,24 +224,33 @@ class AuthManager(component.Component):
             # File didn't change, no need for re-parsing's
             return
 
-        # Load the auth file into a dictionary: {username: Account(...)}
-        f = open(auth_file, "r").readlines()
+        for _filepath in (auth_file, auth_file_bak):
+            log.info('Opening %s for load: %s', filename, _filepath)
+            try:
+                with open(_filepath, 'r', encoding='utf8') as _file:
+                    file_data = _file.readlines()
+            except IOError as ex:
+                log.warning('Unable to load %s: %s', _filepath, ex)
+                file_data = []
+            else:
+                log.info('Successfully loaded %s: %s', filename, _filepath)
+                break
 
-        for line in f:
+        # Load the auth file into a dictionary: {username: Account(...)}
+        for line in file_data:
             line = line.strip()
-            if line.startswith("#") or not line:
+            if line.startswith('#') or not line:
                 # This line is a comment or empty
                 continue
-            try:
-                lsplit = line.split(":")
-            except Exception, e:
-                log.error("Your auth file is malformed: %s", e)
-                continue
+            lsplit = line.split(':')
             if len(lsplit) == 2:
                 username, password = lsplit
-                log.warning("Your auth entry for %s contains no auth level, "
-                            "using AUTH_LEVEL_DEFAULT(%s)..", username,
-                            AUTH_LEVEL_DEFAULT)
+                log.warning(
+                    'Your auth entry for %s contains no auth level, '
+                    'using AUTH_LEVEL_DEFAULT(%s)..',
+                    username,
+                    AUTH_LEVEL_DEFAULT,
+                )
                 if username == 'localclient':
                     authlevel = AUTH_LEVEL_ADMIN
                 else:
@@ -259,8 +260,7 @@ class AuthManager(component.Component):
             elif len(lsplit) == 3:
                 username, password, authlevel = lsplit
             else:
-                log.error("Your auth file is malformed: "
-                          "Incorrect number of fields!")
+                log.error('Your auth file is malformed: Incorrect number of fields!')
                 continue
 
             username = username.strip()
@@ -271,19 +271,19 @@ class AuthManager(component.Component):
                 try:
                     authlevel = AUTH_LEVELS_MAPPING[authlevel]
                 except KeyError:
-                    log.error("Your auth file is malformed: %r is not a valid auth "
-                              "level" % authlevel)
+                    log.error(
+                        'Your auth file is malformed: %r is not a valid auth level',
+                        authlevel,
+                    )
                 continue
 
             self.__auth[username] = Account(username, password, authlevel)
 
-        if "localclient" not in self.__auth:
+        if 'localclient' not in self.__auth:
             create_localclient_account(True)
             return self.__load_auth_file()
 
-
         if save_and_reload:
-            log.info("Re-writing auth file (upgrade)")
+            log.info('Re-writing auth file (upgrade)')
             self.write_auth_file()
         self.__auth_modification_time = auth_file_modification_time
-

deluge/core/daemon.py

@@ -1,200 +1,205 @@
-#
-# daemon.py
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2007-2009 Andrew Resch <andrewresch@gmail.com>
 #
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
 
-import os
+"""The Deluge daemon"""
+from __future__ import unicode_literals
+
 import logging
+import os
+import socket
+
 from twisted.internet import reactor
-import twisted.internet.error
 
 import deluge.component as component
-import deluge.configmanager
-import deluge.common
+from deluge.common import get_version, is_ip, is_process_running, windows_check
+from deluge.configmanager import get_config_dir
+from deluge.core.core import Core
 from deluge.core.rpcserver import RPCServer, export
-import deluge.error
+from deluge.error import DaemonRunningError
+
+if windows_check():
+    from win32api import SetConsoleCtrlHandler
+    from win32con import CTRL_CLOSE_EVENT, CTRL_SHUTDOWN_EVENT
 
 log = logging.getLogger(__name__)
 
+
+def is_daemon_running(pid_file):
+    """
+    Check for another running instance of the daemon using the same pid file.
+
+    Args:
+        pid_file: The location of the file with pid, port values.
+
+    Returns:
+        bool: True is daemon is running, False otherwise.
+
+    """
+
+    try:
+        with open(pid_file) as _file:
+            pid, port = [int(x) for x in _file.readline().strip().split(';')]
+    except (EnvironmentError, ValueError):
+        return False
+
+    if is_process_running(pid):
+        # Ensure it's a deluged process by trying to open a socket to it's port.
+        _socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        try:
+            _socket.connect(('127.0.0.1', port))
+        except socket.error:
+            # Can't connect, so pid is not a deluged process.
+            return False
+        else:
+            # This is a deluged process!
+            _socket.close()
+            return True
+
+
 class Daemon(object):
-    def __init__(self, options=None, args=None, classic=False):
-        # Check for another running instance of the daemon
-        if os.path.isfile(deluge.configmanager.get_config_dir("deluged.pid")):
-            # Get the PID and the port of the supposedly running daemon
-            try:
-                (pid, port) = open(
-                    deluge.configmanager.get_config_dir("deluged.pid")
-                ).read().strip().split(";")
-                pid = int(pid)
-                port = int(port)
-            except ValueError:
-                pid = None
-                port = None
+    """The Deluge Daemon class"""
 
+    def __init__(
+        self,
+        listen_interface=None,
+        outgoing_interface=None,
+        interface=None,
+        port=None,
+        standalone=False,
+        read_only_config_keys=None,
+    ):
+        """
+        Args:
+            listen_interface (str, optional): The IP address to listen to
+                BitTorrent connections on.
+            outgoing_interface (str, optional): The network interface name or
+                IP address to open outgoing BitTorrent connections on.
+            interface (str, optional): The IP address the daemon will
+                listen for UI connections on.
+            port (int, optional): The port the daemon will listen for UI
+                connections on.
+            standalone (bool, optional): If True the client is in Standalone
+                mode otherwise, if False, start the daemon as separate process.
+            read_only_config_keys (list of str, optional): A list of config
+                keys that will not be altered by core.set_config() RPC method.
+        """
+        self.standalone = standalone
+        self.pid_file = get_config_dir('deluged.pid')
+        log.info('Deluge daemon %s', get_version())
+        if is_daemon_running(self.pid_file):
+            raise DaemonRunningError(
+                'Deluge daemon already running with this config directory!'
+            )
 
-            def process_running(pid):
-                if deluge.common.windows_check():
-                    import win32process
-                    return pid in win32process.EnumProcesses()
-                else:
-                    # We can just use os.kill on UNIX to test if the process is running
-                    try:
-                        os.kill(pid, 0)
-                    except OSError:
-                        return False
-                    else:
-                        return True
-
-            if pid is not None and process_running(pid):
-                # Ok, so a process is running with this PID, let's make doubly-sure
-                # it's a deluged process by trying to open a socket to it's port.
-                import socket
-                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                try:
-                    s.connect(("127.0.0.1", port))
-                except socket.error:
-                    # Can't connect, so it must not be a deluged process..
-                    pass
-                else:
-                    # This is a deluged!
-                    s.close()
-                    raise deluge.error.DaemonRunningError(
-                        "There is a deluge daemon running with this config "
-                        "directory!"
-                    )
-
-        # Twisted catches signals to terminate, so just have it call the shutdown
-        # method.
-        reactor.addSystemEventTrigger("before", "shutdown", self._shutdown)
+        # Twisted catches signals to terminate, so just have it call the shutdown method.
+        reactor.addSystemEventTrigger('before', 'shutdown', self._shutdown)
 
         # Catch some Windows specific signals
-        if deluge.common.windows_check():
-            from win32api import SetConsoleCtrlHandler
-            from win32con import CTRL_CLOSE_EVENT
-            from win32con import CTRL_SHUTDOWN_EVENT
+        if windows_check():
+
             def win_handler(ctrl_type):
-                log.debug("ctrl_type: %s", ctrl_type)
+                """Handle the Windows shutdown or close events."""
+                log.debug('windows handler ctrl_type: %s', ctrl_type)
                 if ctrl_type == CTRL_CLOSE_EVENT or ctrl_type == CTRL_SHUTDOWN_EVENT:
                     self._shutdown()
                     return 1
+
             SetConsoleCtrlHandler(win_handler)
 
-        version = deluge.common.get_version()
-
-        log.info("Deluge daemon %s", version)
-        log.debug("options: %s", options)
-        log.debug("args: %s", args)
-        # Set the config directory
-        if options and options.config:
-            deluge.configmanager.set_config_dir(options.config)
-
-        if options and options.listen_interface:
-            listen_interface = options.listen_interface
-        else:
-            listen_interface = ""
-
-        from deluge.core.core import Core
         # Start the core as a thread and join it until it's done
-        self.core = Core(listen_interface=listen_interface)
+        self.core = Core(
+            listen_interface=listen_interface,
+            outgoing_interface=outgoing_interface,
+            read_only_config_keys=read_only_config_keys,
+        )
 
-        port = self.core.config["daemon_port"]
-        if options and options.port:
-            port = options.port
-        if options and options.ui_interface:
-            interface = options.ui_interface
-        else:
-            interface = ""
+        if port is None:
+            port = self.core.config['daemon_port']
+        self.port = port
+
+        if interface and not is_ip(interface):
+            log.error('Invalid UI interface (must be IP Address): %s', interface)
+            interface = None
 
         self.rpcserver = RPCServer(
             port=port,
-            allow_remote=self.core.config["allow_remote"],
-            listen=not classic,
-            interface=interface
+            allow_remote=self.core.config['allow_remote'],
+            listen=not standalone,
+            interface=interface,
         )
 
+        log.debug(
+            'Listening to UI on: %s:%s and bittorrent on: %s Making connections out on: %s',
+            interface,
+            port,
+            listen_interface,
+            outgoing_interface,
+        )
+
+    def start(self):
         # Register the daemon and the core RPCs
         self.rpcserver.register_object(self.core)
         self.rpcserver.register_object(self)
 
-
         # Make sure we start the PreferencesManager first
-        component.start("PreferencesManager")
+        component.start('PreferencesManager')
 
-        if not classic:
-            # Write out a pid file all the time, we use this to see if a deluged is running
-            # We also include the running port number to do an additional test
-            open(deluge.configmanager.get_config_dir("deluged.pid"), "wb").write(
-                "%s;%s\n" % (os.getpid(), port))
+        if not self.standalone:
+            log.info('Deluge daemon starting...')
+            # Create pid file to track if deluged is running, also includes the port number.
+            pid = os.getpid()
+            log.debug('Storing pid %s & port %s in: %s', pid, self.port, self.pid_file)
+            with open(self.pid_file, 'w') as _file:
+                _file.write('%s;%s\n' % (pid, self.port))
 
             component.start()
+
             try:
                 reactor.run()
             finally:
-                self._shutdown()
+                log.debug('Remove pid file: %s', self.pid_file)
+                os.remove(self.pid_file)
+                log.info('Deluge daemon shutdown successfully')
 
     @export()
     def shutdown(self, *args, **kwargs):
+        log.debug('Deluge daemon shutdown requested...')
         reactor.callLater(0, reactor.stop)
 
     def _shutdown(self, *args, **kwargs):
-        if os.path.exists(deluge.configmanager.get_config_dir("deluged.pid")):
-            try:
-                os.remove(deluge.configmanager.get_config_dir("deluged.pid"))
-            except Exception, e:
-                log.exception(e)
-                log.error("Error removing deluged.pid!")
-
-        log.info("Waiting for components to shutdown..")
-        d = component.shutdown()
-        return d
+        log.info('Deluge daemon shutting down, waiting for components to shutdown...')
+        if not self.standalone:
+            return component.shutdown()
 
     @export()
     def get_method_list(self):
-        """
-        Returns a list of the exported methods.
-        """
+        """Returns a list of the exported methods."""
         return self.rpcserver.get_method_list()
 
+    @export()
+    def get_version(self):
+        """Returns the daemon version"""
+        return get_version()
+
     @export(1)
     def authorized_call(self, rpc):
-        """
-        Returns True if authorized to call rpc.
+        """Determines if session auth_level is authorized to call RPC.
 
-        :param rpc: a rpc, eg, "core.get_torrents_status"
-        :type rpc: string
+        Args:
+            rpc (str): A RPC, e.g. core.get_torrents_status
 
+        Returns:
+            bool: True if authorized to call RPC, otherwise False.
         """
-        if not rpc in self.get_method_list():
+        if rpc not in self.get_method_list():
             return False
 
-        auth_level = self.rpcserver.get_session_auth_level()
-        return auth_level >= self.rpcserver.get_rpc_auth_level()
+        return self.rpcserver.get_session_auth_level() >= self.rpcserver.get_rpc_auth_level(
+            rpc
+        )

deluge/core/daemon_entry.py

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2007 Andrew Resch <andrewresch@gmail.com>
+# Copyright (C) 2010 Pedro Algarvio <pedro@algarvio.me>
+#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
+#
+from __future__ import print_function, unicode_literals
+
+import os
+import sys
+from logging import DEBUG, FileHandler, getLogger
+
+from twisted.internet.error import CannotListenError
+
+from deluge.argparserbase import ArgParserBase
+from deluge.common import run_profiled
+from deluge.configmanager import get_config_dir
+from deluge.i18n import setup_mock_translation
+
+
+def add_daemon_options(parser):
+    group = parser.add_argument_group(_('Daemon Options'))
+    group.add_argument(
+        '-u',
+        '--ui-interface',
+        metavar='<ip-addr>',
+        action='store',
+        help=_('IP address to listen for UI connections'),
+    )
+    group.add_argument(
+        '-p',
+        '--port',
+        metavar='<port>',
+        action='store',
+        type=int,
+        help=_('Port to listen for UI connections on'),
+    )
+    group.add_argument(
+        '-i',
+        '--interface',
+        metavar='<ip-addr>',
+        dest='listen_interface',
+        action='store',
+        help=_('IP address to listen for BitTorrent connections'),
+    )
+    group.add_argument(
+        '-o',
+        '--outgoing-interface',
+        metavar='<interface>',
+        dest='outgoing_interface',
+        action='store',
+        help=_(
+            'The network interface name or IP address for outgoing BitTorrent connections.'
+        ),
+    )
+    group.add_argument(
+        '--read-only-config-keys',
+        metavar='<comma-separated-keys>',
+        action='store',
+        help=_('Config keys to be unmodified by `set_config` RPC'),
+        type=str,
+        default='',
+    )
+    parser.add_process_arg_group()
+
+
+def start_daemon(skip_start=False):
+    """
+    Entry point for daemon script
+
+    Args:
+        skip_start (bool): If starting daemon should be skipped.
+
+    Returns:
+        deluge.core.daemon.Daemon: A new daemon object
+
+    """
+    setup_mock_translation()
+
+    # Setup the argument parser
+    parser = ArgParserBase()
+    add_daemon_options(parser)
+
+    options = parser.parse_args()
+
+    # Check for any daemons running with this same config
+    from deluge.core.daemon import is_daemon_running
+
+    pid_file = get_config_dir('deluged.pid')
+    if is_daemon_running(pid_file):
+        print(
+            'Cannot run multiple daemons with same config directory.\n'
+            'If you believe this is an error, force starting by deleting: %s' % pid_file
+        )
+        sys.exit(1)
+
+    log = getLogger(__name__)
+
+    # If no logfile specified add logging to default location (as well as stdout)
+    if not options.logfile:
+        options.logfile = get_config_dir('deluged.log')
+        file_handler = FileHandler(options.logfile)
+        log.addHandler(file_handler)
+
+    def run_daemon(options):
+        try:
+            from deluge.core.daemon import Daemon
+
+            daemon = Daemon(
+                listen_interface=options.listen_interface,
+                outgoing_interface=options.outgoing_interface,
+                interface=options.ui_interface,
+                port=options.port,
+                read_only_config_keys=options.read_only_config_keys.split(','),
+            )
+            if skip_start:
+                return daemon
+            else:
+                daemon.start()
+        except CannotListenError as ex:
+            log.error(
+                'Cannot start deluged, listen port in use.\n'
+                ' Check for other running daemons or services using this port: %s:%s',
+                ex.interface,
+                ex.port,
+            )
+            sys.exit(1)
+        except Exception as ex:
+            log.error('Unable to start deluged: %s', ex)
+            if log.isEnabledFor(DEBUG):
+                log.exception(ex)
+            sys.exit(1)
+        finally:
+            log.info('Exiting...')
+            if options.pidfile:
+                os.remove(options.pidfile)
+
+    return run_profiled(
+        run_daemon, options, output_file=options.profile, do_profile=options.profile
+    )

deluge/core/eventmanager.py

@@ -1,46 +1,24 @@
-#
-# eventmanager.py
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2009 Andrew Resch <andrewresch@gmail.com>
 #
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
 
+from __future__ import unicode_literals
+
 import logging
+
 import deluge.component as component
 
 log = logging.getLogger(__name__)
 
+
 class EventManager(component.Component):
     def __init__(self):
-        component.Component.__init__(self, "EventManager")
+        component.Component.__init__(self, 'EventManager')
         self.handlers = {}
 
     def emit(self, event):
@@ -50,15 +28,20 @@ class EventManager(component.Component):
         :param event: DelugeEvent
         """
         # Emit the event to the interested clients
-        component.get("RPCServer").emit_event(event)
+        component.get('RPCServer').emit_event(event)
         # Call any handlers for the event
         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)
+                # log.debug('Running handler %s for event %s with args: %s', event.name, handler, event.args)
                 try:
                     handler(*event.args)
-                except Exception, e:
-                    log.error("Event handler %s failed in %s with exception %s", event.name, handler, e)
+                except Exception as ex:
+                    log.error(
+                        'Event handler %s failed in %s with exception %s',
+                        event.name,
+                        handler,
+                        ex,
+                    )
 
     def register_event_handler(self, event, handler):
         """

deluge/core/filtermanager.py

@@ -1,85 +1,66 @@
-#
-# core.py
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2008 Martijn Voncken <mvoncken@gmail.com>
 #
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
 
+from __future__ import unicode_literals
+
 import logging
-import deluge.component as component
 
-STATE_SORT = ["All", "Downloading", "Seeding", "Active", "Paused", "Queued"]
+from six import string_types
+
+import deluge.component as component
+from deluge.common import TORRENT_STATE
 
 log = logging.getLogger(__name__)
 
-#special purpose filters:
-def filter_keywords(torrent_ids, values):
-    #cleanup.
-    keywords = ",".join([v.lower() for v in values])
-    keywords = keywords.split(",")
+STATE_SORT = ['All', 'Active'] + TORRENT_STATE
 
 
+# Special purpose filters:
+def filter_keywords(torrent_ids, values):
+    # Cleanup
+    keywords = ','.join([v.lower() for v in values])
+    keywords = keywords.split(',')
+
     for keyword in keywords:
         torrent_ids = filter_one_keyword(torrent_ids, keyword)
     return torrent_ids
 
+
 def filter_one_keyword(torrent_ids, keyword):
     """
     search torrent on keyword.
     searches title,state,tracker-status,tracker,files
     """
-    all_torrents = component.get("TorrentManager").torrents
-    #filter:
-    found = False
+    all_torrents = component.get('TorrentManager').torrents
+
     for torrent_id in torrent_ids:
         torrent = all_torrents[torrent_id]
         if keyword in torrent.filename.lower():
             yield torrent_id
         elif keyword in torrent.state.lower():
             yield torrent_id
-        elif torrent.trackers and keyword in torrent.trackers[0]["url"]:
+        elif torrent.trackers and keyword in torrent.trackers[0]['url']:
             yield torrent_id
         elif keyword in torrent_id:
             yield torrent_id
-        #i want to find broken torrents (search on "error", or "unregistered")
+        # Want to find broken torrents (search on "error", or "unregistered")
         elif keyword in torrent.tracker_status.lower():
             yield torrent_id
         else:
             for t_file in torrent.get_files():
-                if keyword in t_file["path"].lower():
+                if keyword in t_file['path'].lower():
                     yield torrent_id
                     break
 
+
 def filter_by_name(torrent_ids, search_string):
-    all_torrents = component.get("TorrentManager").torrents
+    all_torrents = component.get('TorrentManager').torrents
     try:
         search_string, match_case = search_string[0].split('::match')
     except ValueError:
@@ -99,48 +80,53 @@ def filter_by_name(torrent_ids, search_string):
         if search_string in torrent_name:
             yield torrent_id
 
+
 def tracker_error_filter(torrent_ids, values):
     filtered_torrent_ids = []
-    tm = component.get("TorrentManager")
+    tm = component.get('TorrentManager')
 
     # If this is a tracker_host, then we need to filter on it
-    if values[0] != "Error":
+    if values[0] != 'Error':
         for torrent_id in torrent_ids:
-            if values[0] == tm[torrent_id].get_status(["tracker_host"])["tracker_host"]:
+            if values[0] == tm[torrent_id].get_status(['tracker_host'])['tracker_host']:
                 filtered_torrent_ids.append(torrent_id)
         return filtered_torrent_ids
 
-    # Check all the torrent's tracker_status for 'Error:' and only return torrent_ids
-    # that have this substring in their tracker_status
+    # Check torrent's tracker_status for 'Error:' and return those torrent_ids
     for torrent_id in torrent_ids:
-        if _("Error") + ":" in tm[torrent_id].get_status(["tracker_host"])["tracker_host"]:
+        if 'Error:' in tm[torrent_id].get_status(['tracker_status'])['tracker_status']:
             filtered_torrent_ids.append(torrent_id)
     return filtered_torrent_ids
 
+
 class FilterManager(component.Component):
     """FilterManager
 
     """
+
     def __init__(self, core):
-        component.Component.__init__(self, "FilterManager")
-        log.debug("FilterManager init..")
+        component.Component.__init__(self, 'FilterManager')
+        log.debug('FilterManager init..')
         self.core = core
         self.torrents = core.torrentmanager
         self.registered_filters = {}
-        self.register_filter("keyword", filter_keywords)
-        self.register_filter("name", filter_by_name)
+        self.register_filter('keyword', filter_keywords)
+        self.register_filter('name', filter_by_name)
         self.tree_fields = {}
 
-        self.register_tree_field("state", self._init_state_tree)
-        def _init_tracker_tree():
-            return {"Error": 0}
-        self.register_tree_field("tracker_host", _init_tracker_tree)
+        self.register_tree_field('state', self._init_state_tree)
 
-        self.register_filter("tracker_host", tracker_error_filter)
+        def _init_tracker_tree():
+            return {'Error': 0}
+
+        self.register_tree_field('tracker_host', _init_tracker_tree)
+
+        self.register_filter('tracker_host', tracker_error_filter)
 
         def _init_users_tree():
-            return {"": 0}
-        self.register_tree_field("owner", _init_users_tree)
+            return {'': 0}
+
+        self.register_tree_field('owner', _init_users_tree)
 
     def filter_torrent_ids(self, filter_dict):
         """
@@ -150,51 +136,60 @@ class FilterManager(component.Component):
         if not filter_dict:
             return self.torrents.get_torrent_list()
 
-        #sanitize input: filter-value must be a list of strings
+        # Sanitize input: filter-value must be a list of strings
         for key, value in filter_dict.items():
-            if isinstance(value, basestring):
+            if isinstance(value, string_types):
                 filter_dict[key] = [value]
 
-        if "id"in filter_dict: #optimized filter for id:
-            torrent_ids = list(filter_dict["id"])
-            del filter_dict["id"]
+        # Optimized filter for id
+        if 'id' in filter_dict:
+            torrent_ids = list(filter_dict['id'])
+            del filter_dict['id']
         else:
             torrent_ids = self.torrents.get_torrent_list()
 
-        if not filter_dict: #return if there's  nothing more to filter
+        # Return if there's nothing more to filter
+        if not filter_dict:
             return torrent_ids
 
-        #special purpose: state=Active.
-        if "state" in filter_dict:
+        # Special purpose, state=Active.
+        if 'state' in filter_dict:
             # We need to make sure this is a list for the logic below
-            filter_dict["state"] = list(filter_dict["state"])
+            filter_dict['state'] = list(filter_dict['state'])
 
-        if "state" in filter_dict and "Active" in filter_dict["state"]:
-            filter_dict["state"].remove("Active")
-            if not filter_dict["state"]:
-                del filter_dict["state"]
+        if 'state' in filter_dict and 'Active' in filter_dict['state']:
+            filter_dict['state'].remove('Active')
+            if not filter_dict['state']:
+                del filter_dict['state']
             torrent_ids = self.filter_state_active(torrent_ids)
 
-        if not filter_dict: #return if there's  nothing more to filter
+        if not filter_dict:
             return torrent_ids
 
-        #Registered filters:
-        for field, values in filter_dict.items():
+        # Registered filters
+        for field, values in list(filter_dict.items()):
             if field in self.registered_filters:
-                # a set filters out the doubles.
-                torrent_ids = list(set(self.registered_filters[field](torrent_ids, values)))
+                # Filters out doubles
+                torrent_ids = list(
+                    set(self.registered_filters[field](torrent_ids, values))
+                )
                 del filter_dict[field]
 
-
-        if not filter_dict: #return if there's  nothing more to filter
+        if not filter_dict:
             return torrent_ids
 
-        #leftover filter arguments:
-        #default filter on status fields.
+        torrent_keys, plugin_keys = self.torrents.separate_keys(
+            list(filter_dict), torrent_ids
+        )
+        # Leftover filter arguments, default filter on status fields.
         for torrent_id in list(torrent_ids):
-            status = self.torrents[torrent_id].get_status(filter_dict.keys()) #status={key:value}
-            for field, values in filter_dict.iteritems():
-                if (not status[field] in values) and torrent_id in torrent_ids:
+            status = self.core.create_torrent_status(
+                torrent_id, torrent_keys, plugin_keys
+            )
+            for field, values in filter_dict.items():
+                if field in status and status[field] in values:
+                    continue
+                elif torrent_id in torrent_ids:
                     torrent_ids.remove(torrent_id)
         return torrent_ids
 
@@ -204,55 +199,58 @@ class FilterManager(component.Component):
         for use in sidebar.
         """
         torrent_ids = self.torrents.get_torrent_list()
-        tree_keys = list(self.tree_fields.keys())
+        tree_keys = list(self.tree_fields)
         if hide_cat:
             for cat in hide_cat:
                 tree_keys.remove(cat)
 
         torrent_keys, plugin_keys = self.torrents.separate_keys(tree_keys, torrent_ids)
-        items = dict((field, self.tree_fields[field]()) for field in tree_keys)
+        items = {field: self.tree_fields[field]() for field in tree_keys}
 
         for torrent_id in list(torrent_ids):
-            status = self.core.create_torrent_status(torrent_id, torrent_keys, plugin_keys) #status={key:value}
+            status = self.core.create_torrent_status(
+                torrent_id, torrent_keys, plugin_keys
+            )  # status={key:value}
             for field in tree_keys:
                 value = status[field]
                 items[field][value] = items[field].get(value, 0) + 1
 
-        if "tracker_host" in items:
-            items["tracker_host"]["All"] = len(torrent_ids)
-            items["tracker_host"]["Error"] = len(tracker_error_filter(torrent_ids, ("Error",)))
+        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:
-            self._hide_state_items(items["state"])
+        if not show_zero_hits:
+            for cat in ['state', 'owner', 'tracker_host']:
+                if cat in tree_keys:
+                    self._hide_state_items(items[cat])
 
-        #return a dict of tuples:
-        sorted_items = {}
-        for field in tree_keys:
-            sorted_items[field] = sorted(items[field].iteritems())
+        # Return a dict of tuples:
+        sorted_items = {field: sorted(items[field].items()) for field in tree_keys}
 
-        if "state" in tree_keys:
-            sorted_items["state"].sort(self._sort_state_items)
+        if 'state' in tree_keys:
+            sorted_items['state'].sort(key=self._sort_state_item)
 
         return sorted_items
 
     def _init_state_tree(self):
-        return {"All":len(self.torrents.get_torrent_list()),
-            "Downloading":0,
-            "Seeding":0,
-            "Paused":0,
-            "Checking":0,
-            "Queued":0,
-            "Error":0,
-            "Active":len(self.filter_state_active(self.torrents.get_torrent_list()))
-            }
+        init_state = {}
+        init_state['All'] = len(self.torrents.get_torrent_list())
+        for state in TORRENT_STATE:
+            init_state[state] = 0
+        init_state['Active'] = len(
+            self.filter_state_active(self.torrents.get_torrent_list())
+        )
+        return init_state
 
-    def register_filter(self, id, filter_func, filter_value = None):
-        self.registered_filters[id] = filter_func
+    def register_filter(self, filter_id, filter_func, filter_value=None):
+        self.registered_filters[filter_id] = filter_func
 
-    def deregister_filter(self, id):
-        del self.registered_filters[id]
+    def deregister_filter(self, filter_id):
+        del self.registered_filters[filter_id]
 
-    def register_tree_field(self, field, init_func = lambda : {}):
+    def register_tree_field(self, field, init_func=lambda: {}):
         self.tree_fields[field] = init_func
 
     def deregister_tree_field(self, field):
@@ -261,28 +259,23 @@ class FilterManager(component.Component):
 
     def filter_state_active(self, torrent_ids):
         for torrent_id in list(torrent_ids):
-            status = self.torrents[torrent_id].get_status(["download_payload_rate", "upload_payload_rate"])
-            if status["download_payload_rate"] or status["upload_payload_rate"]:
-                pass #ok
+            status = self.torrents[torrent_id].get_status(
+                ['download_payload_rate', 'upload_payload_rate']
+            )
+            if status['download_payload_rate'] or status['upload_payload_rate']:
+                pass
             else:
                 torrent_ids.remove(torrent_id)
         return torrent_ids
 
     def _hide_state_items(self, state_items):
-        "for hide(show)-zero hits"
-        for (value, count)  in state_items.items():
-            if value != "All" and count == 0:
+        """For hide(show)-zero hits"""
+        for value, count in list(state_items.items()):
+            if value != 'All' and count == 0:
                 del state_items[value]
 
-    def _sort_state_items(self, x, y):
-        ""
-        if x[0] in STATE_SORT:
-            ix = STATE_SORT.index(x[0])
-        else:
-            ix = 99
-        if y[0] in STATE_SORT:
-            iy = STATE_SORT.index(y[0])
-        else:
-            iy = 99
-
-        return ix - iy
+    def _sort_state_item(self, item):
+        try:
+            return STATE_SORT.index(item[0])
+        except ValueError:
+            return 99

deluge/core/oldstateupgrader.py

@@ -1,143 +0,0 @@
-#
-# oldstateupgrader.py
-#
-# Copyright (C) 2008 Andrew Resch <andrewresch@gmail.com>
-#
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
-#
-
-
-import os
-import os.path
-import pickle
-import cPickle
-import shutil
-import logging
-
-from deluge._libtorrent import lt
-
-from deluge.configmanager import ConfigManager, get_config_dir
-import deluge.core.torrentmanager
-
-log = logging.getLogger(__name__)
-
-#start : http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/286203
-def makeFakeClass(module, name):
-    class FakeThing(object):
-        pass
-    FakeThing.__name__ = name
-    FakeThing.__module__ = '(fake)' + module
-    return FakeThing
-
-class PickleUpgrader(pickle.Unpickler):
-    def find_class(self, module, cname):
-        # Pickle tries to load a couple things like copy_reg and
-        # __builtin__.object even though a pickle file doesn't
-        # explicitly reference them (afaict): allow them to be loaded
-        # normally.
-        if module in ('copy_reg', '__builtin__'):
-            thing = pickle.Unpickler.find_class(self, module, cname)
-            return thing
-        return makeFakeClass(module, cname)
-# end: http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/286203
-
-class OldStateUpgrader:
-    def __init__(self):
-        self.config = ConfigManager("core.conf")
-        self.state05_location = os.path.join(get_config_dir(), "persistent.state")
-        self.state10_location = os.path.join(get_config_dir(), "state", "torrents.state")
-        if os.path.exists(self.state05_location) and not os.path.exists(self.state10_location):
-            # If the 0.5 state file exists and the 1.0 doesn't, then let's upgrade it
-            self.upgrade05()
-
-    def upgrade05(self):
-        try:
-            state = PickleUpgrader(open(self.state05_location, "rb")).load()
-        except Exception, e:
-            log.debug("Unable to open 0.5 state file: %s", e)
-            return
-
-        # Check to see if we can upgrade this file
-        if type(state).__name__ == 'list':
-            log.warning("0.5 state file is too old to upgrade")
-            return
-
-        new_state = deluge.core.torrentmanager.TorrentManagerState()
-        for ti, uid in state.torrents.items():
-            torrent_path = os.path.join(get_config_dir(), "torrentfiles", ti.filename)
-            try:
-                torrent_info = None
-                log.debug("Attempting to create torrent_info from %s", torrent_path)
-                _file = open(torrent_path, "rb")
-                torrent_info = lt.torrent_info(lt.bdecode(_file.read()))
-                _file.close()
-            except (IOError, RuntimeError), e:
-                log.warning("Unable to open %s: %s", torrent_path, e)
-
-            # Copy the torrent file to the new location
-            import shutil
-            shutil.copyfile(torrent_path, os.path.join(get_config_dir(), "state", str(torrent_info.info_hash()) + ".torrent"))
-
-            # Set the file prioritiy property if not already there
-            if not hasattr(ti, "priorities"):
-                ti.priorities = [1] * torrent_info.num_files()
-
-            # Create the new TorrentState object
-            new_torrent = deluge.core.torrentmanager.TorrentState(
-                torrent_id=str(torrent_info.info_hash()),
-                filename=ti.filename,
-                save_path=ti.save_dir,
-                compact=ti.compact,
-                paused=ti.user_paused,
-                total_uploaded=ti.uploaded_memory,
-                max_upload_speed=ti.upload_rate_limit,
-                max_download_speed=ti.download_rate_limit,
-                file_priorities=ti.priorities,
-                queue=state.queue.index(ti)
-            )
-            # Append the object to the state list
-            new_state.torrents.append(new_torrent)
-
-        # Now we need to write out the new state file
-        try:
-            log.debug("Saving torrent state file.")
-            state_file = open(
-                os.path.join(get_config_dir(), "state", "torrents.state"), "wb")
-            cPickle.dump(new_state, state_file)
-            state_file.close()
-        except IOError, e:
-            log.warning("Unable to save state file: %s", e)
-            return
-
-        # Rename the persistent.state file
-        try:
-            os.rename(self.state05_location, self.state05_location + ".old")
-        except Exception, e:
-            log.debug("Unable to rename old persistent.state file! %s", e)

deluge/core/pluginmanager.py

@@ -1,62 +1,40 @@
-#
-# pluginmanager.py
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2007 Andrew Resch <andrewresch@gmail.com>
 #
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
 
 
 """PluginManager for Core"""
+from __future__ import unicode_literals
 
 import logging
 
-from deluge.event import PluginEnabledEvent, PluginDisabledEvent
-import deluge.pluginmanagerbase
+from twisted.internet import defer
+
 import deluge.component as component
+import deluge.pluginmanagerbase
+from deluge.event import PluginDisabledEvent, PluginEnabledEvent
 
 log = logging.getLogger(__name__)
 
-class PluginManager(deluge.pluginmanagerbase.PluginManagerBase,
-    component.Component):
+
+class PluginManager(deluge.pluginmanagerbase.PluginManagerBase, component.Component):
     """PluginManager handles the loading of plugins and provides plugins with
     functions to access parts of the core."""
 
     def __init__(self, core):
-        component.Component.__init__(self, "CorePluginManager")
+        component.Component.__init__(self, 'CorePluginManager')
 
         self.status_fields = {}
 
         # Call the PluginManagerBase constructor
         deluge.pluginmanagerbase.PluginManagerBase.__init__(
-            self, "core.conf", "deluge.plugin.core")
+            self, 'core.conf', 'deluge.plugin.core'
+        )
 
     def start(self):
         # Enable plugins that are enabled in the config
@@ -70,28 +48,44 @@ class PluginManager(deluge.pluginmanagerbase.PluginManagerBase,
         self.stop()
 
     def update_plugins(self):
-        for plugin in self.plugins.keys():
-            if hasattr(self.plugins[plugin], "update"):
+        for plugin in self.plugins:
+            if hasattr(self.plugins[plugin], 'update'):
                 try:
                     self.plugins[plugin].update()
-                except Exception, e:
-                    log.exception(e)
+                except Exception as ex:
+                    log.exception(ex)
 
     def enable_plugin(self, name):
+        d = defer.succeed(True)
         if name not in self.plugins:
-            super(PluginManager, self).enable_plugin(name)
-            if name in self.plugins:
-                component.get("EventManager").emit(PluginEnabledEvent(name))
+            d = deluge.pluginmanagerbase.PluginManagerBase.enable_plugin(self, name)
+
+            def on_enable_plugin(result):
+                if result is True and name in self.plugins:
+                    component.get('EventManager').emit(PluginEnabledEvent(name))
+                return result
+
+            d.addBoth(on_enable_plugin)
+        return d
 
     def disable_plugin(self, name):
+        d = defer.succeed(True)
         if name in self.plugins:
-            super(PluginManager, self).disable_plugin(name)
-            if name not in self.plugins:
-                component.get("EventManager").emit(PluginDisabledEvent(name))
+            d = deluge.pluginmanagerbase.PluginManagerBase.disable_plugin(self, name)
+
+            def on_disable_plugin(result):
+                if name not in self.plugins:
+                    component.get('EventManager').emit(PluginDisabledEvent(name))
+                return result
+
+            d.addBoth(on_disable_plugin)
+        return d
 
     def get_status(self, torrent_id, fields):
         """Return the value of status fields for the selected torrent_id."""
         status = {}
+        if len(fields) == 0:
+            fields = list(self.status_fields)
         for field in fields:
             try:
                 status[field] = self.status_fields[field](torrent_id)
@@ -102,13 +96,13 @@ class PluginManager(deluge.pluginmanagerbase.PluginManagerBase,
     def register_status_field(self, field, function):
         """Register a new status field.  This can be used in the same way the
         client requests other status information from core."""
-        log.debug("Registering status field %s with PluginManager", field)
+        log.debug('Registering status field %s with PluginManager', field)
         self.status_fields[field] = function
 
     def deregister_status_field(self, field):
         """Deregisters a status field"""
-        log.debug("Deregistering status field %s with PluginManager", field)
+        log.debug('Deregistering status field %s with PluginManager', field)
         try:
             del self.status_fields[field]
-        except:
-            log.warning("Unable to deregister status field %s", field)
+        except Exception:
+            log.warning('Unable to deregister status field %s', field)

deluge/core/preferencesmanager.py

@@ -1,165 +1,162 @@
-#
-# preferencesmanager.py
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2008-2010 Andrew Resch <andrewresch@gmail.com>
 #
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
 
 
-import os
+from __future__ import unicode_literals
+
 import logging
+import os
+import platform
+import random
 import threading
+
 from twisted.internet.task import LoopingCall
 
-from deluge._libtorrent import lt
-
-from deluge.event import *
-import deluge.configmanager
 import deluge.common
 import deluge.component as component
+import deluge.configmanager
+from deluge._libtorrent import lt
+from deluge.event import ConfigValueChangedEvent
+
+try:
+    import GeoIP
+except ImportError:
+    GeoIP = None
+
+try:
+    from urllib.parse import quote_plus
+    from urllib.request import urlopen
+except ImportError:
+    from urllib import quote_plus
+    from urllib2 import urlopen
 
 log = logging.getLogger(__name__)
 
 DEFAULT_PREFS = {
-    "send_info": False,
-    "info_sent": 0.0,
-    "daemon_port": 58846,
-    "allow_remote": False,
-    "compact_allocation": False,
-    "download_location": deluge.common.get_default_download_dir(),
-    "listen_ports": [6881, 6891],
-    "listen_interface": "",
-    "copy_torrent_file": False,
-    "del_copy_torrent_file": False,
-    "torrentfiles_location": deluge.common.get_default_download_dir(),
-    "plugins_location": os.path.join(deluge.configmanager.get_config_dir(), "plugins"),
-    "prioritize_first_last_pieces": False,
-    "sequential_download": False,
-    "random_port": True,
-    "dht": True,
-    "upnp": True,
-    "natpmp": True,
-    "utpex": True,
-    "lsd": True,
-    "enc_in_policy": 1,
-    "enc_out_policy": 1,
-    "enc_level": 2,
-    "enc_prefer_rc4": True,
-    "max_connections_global": 200,
-    "max_upload_speed": -1.0,
-    "max_download_speed": -1.0,
-    "max_upload_slots_global": 4,
-    "max_half_open_connections": (lambda: deluge.common.windows_check() and
-        (lambda: deluge.common.vista_check() and 4 or 8)() or 50)(),
-    "max_connections_per_second": 20,
-    "ignore_limits_on_local_network": True,
-    "max_connections_per_torrent": -1,
-    "max_upload_slots_per_torrent": -1,
-    "max_upload_speed_per_torrent": -1,
-    "max_download_speed_per_torrent": -1,
-    "enabled_plugins": [],
-    "add_paused": False,
-    "max_active_seeding": 5,
-    "max_active_downloading": 3,
-    "max_active_limit": 8,
-    "dont_count_slow_torrents": False,
-    "queue_new_to_top": False,
-    "stop_seed_at_ratio": False,
-    "remove_seed_at_ratio": False,
-    "stop_seed_ratio": 2.00,
-    "share_ratio_limit": 2.00,
-    "seed_time_ratio_limit": 7.00,
-    "seed_time_limit": 180,
-    "auto_managed": True,
-    "move_completed": False,
-    "move_completed_path": deluge.common.get_default_download_dir(),
-    "new_release_check": True,
-    "proxies": {
-        "peer": {
-            "type": 0,
-            "hostname": "",
-            "username": "",
-            "password": "",
-            "port": 8080
-        },
-        "web_seed": {
-            "type": 0,
-            "hostname": "",
-            "username": "",
-            "password": "",
-            "port": 8080
-        },
-        "tracker": {
-            "type": 0,
-            "hostname": "",
-            "username": "",
-            "password": "",
-            "port": 8080
-        },
-        "dht": {
-            "type": 0,
-            "hostname": "",
-            "username": "",
-            "password": "",
-            "port": 8080
-        },
-
+    'send_info': False,
+    'info_sent': 0.0,
+    'daemon_port': 58846,
+    'allow_remote': False,
+    'pre_allocate_storage': False,
+    'download_location': deluge.common.get_default_download_dir(),
+    'listen_ports': [6881, 6891],
+    'listen_interface': '',
+    'outgoing_interface': '',
+    'random_port': True,
+    'listen_random_port': None,
+    'listen_use_sys_port': False,
+    'listen_reuse_port': True,
+    'outgoing_ports': [0, 0],
+    'random_outgoing_ports': True,
+    'copy_torrent_file': False,
+    'del_copy_torrent_file': False,
+    'torrentfiles_location': deluge.common.get_default_download_dir(),
+    'plugins_location': os.path.join(deluge.configmanager.get_config_dir(), 'plugins'),
+    'prioritize_first_last_pieces': False,
+    'sequential_download': False,
+    'dht': True,
+    'upnp': True,
+    'natpmp': True,
+    'utpex': True,
+    'lsd': True,
+    'enc_in_policy': 1,
+    'enc_out_policy': 1,
+    'enc_level': 2,
+    'max_connections_global': 200,
+    'max_upload_speed': -1.0,
+    'max_download_speed': -1.0,
+    'max_upload_slots_global': 4,
+    'max_half_open_connections': (
+        lambda: deluge.common.windows_check()
+        and (lambda: deluge.common.vista_check() and 4 or 8)()
+        or 50
+    )(),
+    'max_connections_per_second': 20,
+    'ignore_limits_on_local_network': True,
+    'max_connections_per_torrent': -1,
+    'max_upload_slots_per_torrent': -1,
+    'max_upload_speed_per_torrent': -1,
+    'max_download_speed_per_torrent': -1,
+    'enabled_plugins': [],
+    'add_paused': False,
+    'max_active_seeding': 5,
+    'max_active_downloading': 3,
+    'max_active_limit': 8,
+    'dont_count_slow_torrents': False,
+    'queue_new_to_top': False,
+    'stop_seed_at_ratio': False,
+    'remove_seed_at_ratio': False,
+    'stop_seed_ratio': 2.00,
+    'share_ratio_limit': 2.00,
+    'seed_time_ratio_limit': 7.00,
+    'seed_time_limit': 180,
+    'auto_managed': True,
+    'move_completed': False,
+    'move_completed_path': deluge.common.get_default_download_dir(),
+    'move_completed_paths_list': [],
+    'download_location_paths_list': [],
+    'path_chooser_show_chooser_button_on_localhost': True,
+    'path_chooser_auto_complete_enabled': True,
+    'path_chooser_accelerator_string': 'Tab',
+    'path_chooser_max_popup_rows': 20,
+    'path_chooser_show_hidden_files': False,
+    'new_release_check': True,
+    'proxy': {
+        'type': 0,
+        'hostname': '',
+        'username': '',
+        'password': '',
+        'port': 8080,
+        'proxy_hostnames': True,
+        'proxy_peer_connections': True,
+        'proxy_tracker_connections': True,
+        'force_proxy': False,
+        'anonymous_mode': False,
     },
-    "outgoing_ports": [0, 0],
-    "random_outgoing_ports": True,
-    "peer_tos": "0x00",
-    "rate_limit_ip_overhead": True,
-    "geoip_db_location": "/usr/share/GeoIP/GeoIP.dat",
-    "cache_size": 512,
-    "cache_expiry": 60,
-    "auto_manage_prefer_seeds": False,
-    "shared": False
+    'peer_tos': '0x00',
+    'rate_limit_ip_overhead': True,
+    'geoip_db_location': '/usr/share/GeoIP/GeoIP.dat',
+    'cache_size': 512,
+    'cache_expiry': 60,
+    'auto_manage_prefer_seeds': False,
+    'shared': False,
+    'super_seeding': False,
 }
 
+
 class PreferencesManager(component.Component):
     def __init__(self):
-        component.Component.__init__(self, "PreferencesManager")
+        component.Component.__init__(self, 'PreferencesManager')
+        self.config = deluge.configmanager.ConfigManager('core.conf', DEFAULT_PREFS)
+        if 'proxies' in self.config:
+            log.warning(
+                'Updating config file for proxy, using "peer" values to fill new "proxy" setting'
+            )
+            self.config['proxy'].update(self.config['proxies']['peer'])
+            log.warning('New proxy config is: %s', self.config['proxy'])
+            del self.config['proxies']
+        if 'i2p_proxy' in self.config and self.config['i2p_proxy']['hostname']:
+            self.config['proxy'].update(self.config['i2p_proxy'])
+            self.config['proxy']['type'] = 6
+            del self.config['i2p_proxy']
+        if 'anonymous_mode' in self.config:
+            self.config['proxy']['anonymous_mode'] = self.config['anonymous_mode']
+            del self.config['anonymous_mode']
+        if 'proxy' in self.config:
+            for key in DEFAULT_PREFS['proxy']:
+                if key not in self.config['proxy']:
+                    self.config['proxy'][key] = DEFAULT_PREFS['proxy'][key]
 
-        self.config = deluge.configmanager.ConfigManager("core.conf", DEFAULT_PREFS)
-        if 'public' in self.config:
-            log.debug("Updating configuration file: Renamed torrent's public "
-                      "attribute to shared.")
-            self.config["shared"] = self.config["public"]
-            del self.config["public"]
-
-    def start(self):
-        self.core = component.get("Core")
-        self.session = component.get("Core").session
+        self.core = component.get('Core')
         self.new_release_timer = None
 
+    def start(self):
         # Set the initial preferences on start-up
         for key in DEFAULT_PREFS:
             self.do_config_set_func(key, self.config[key])
@@ -172,126 +169,131 @@ class PreferencesManager(component.Component):
 
     # Config set functions
     def do_config_set_func(self, key, value):
-        on_set_func = getattr(self, "_on_set_" + key, None)
+        on_set_func = getattr(self, '_on_set_' + key, None)
         if on_set_func:
+            if log.isEnabledFor(logging.DEBUG):
+                log.debug('Config key: %s set to %s..', key, value)
             on_set_func(key, value)
 
-    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):
-        self.do_config_set_func(key, value)
-        component.get("EventManager").emit(ConfigValueChangedEvent(key, value))
+        if self.get_state() == 'Started':
+            self.do_config_set_func(key, value)
+            component.get('EventManager').emit(ConfigValueChangedEvent(key, value))
 
     def _on_set_torrentfiles_location(self, key, value):
-        if self.config["copy_torrent_file"]:
+        if self.config['copy_torrent_file']:
             try:
                 os.makedirs(value)
-            except Exception, e:
-                log.debug("Unable to make directory: %s", e)
+            except OSError as ex:
+                log.debug('Unable to make directory: %s', ex)
 
     def _on_set_listen_ports(self, key, value):
-        # 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.__set_listen_on()
 
     def _on_set_listen_interface(self, key, value):
-        # Call the random_port callback since it'll do what we need
-        self._on_set_random_port("random_port", self.config["random_port"])
+        self.__set_listen_on()
+
+    def _on_set_outgoing_interface(self, key, value):
+        """Set interface name or IP address for outgoing BitTorrent connections."""
+        value = value.strip() if value else ''
+        self.core.apply_session_settings({'outgoing_interfaces': value})
 
     def _on_set_random_port(self, key, value):
-        log.debug("random port value set to %s", value)
-        # We need to check if the value has been changed to true and false
-        # and then handle accordingly.
-        if value:
-            import random
-            listen_ports = []
-            randrange = lambda: random.randrange(49152, 65525)
-            listen_ports.append(randrange())
-            listen_ports.append(listen_ports[0]+10)
-        else:
-            listen_ports = self.config["listen_ports"]
+        self.__set_listen_on()
 
-        # 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"])
+    def __set_listen_on(self):
+        """ Set the ports and interface address to listen for incoming connections on."""
+        if self.config['random_port']:
+            if not self.config['listen_random_port']:
+                self.config['listen_random_port'] = random.randrange(49152, 65525)
+            listen_ports = [
+                self.config['listen_random_port']
+            ] * 2  # use single port range
+        else:
+            self.config['listen_random_port'] = None
+            listen_ports = self.config['listen_ports']
+
+        if self.config['listen_interface']:
+            interface = self.config['listen_interface'].strip()
+        else:
+            interface = '0.0.0.0'
+
+        log.debug(
+            'Listen Interface: %s, Ports: %s with use_sys_port: %s',
+            interface,
+            listen_ports,
+            self.config['listen_use_sys_port'],
+        )
+        interfaces = [
+            '%s:%s' % (interface, port)
+            for port in range(listen_ports[0], listen_ports[1] + 1)
+        ]
+        self.core.apply_session_settings(
+            {
+                'listen_system_port_fallback': self.config['listen_use_sys_port'],
+                'listen_interfaces': ''.join(interfaces),
+            }
         )
 
     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.session_set_setting("outgoing_ports", (value[0], value[1]))
+        self.__set_outgoing_ports()
 
     def _on_set_random_outgoing_ports(self, key, value):
-        if value:
-            self.session.outgoing_ports(0, 0)
+        self.__set_outgoing_ports()
+
+    def __set_outgoing_ports(self):
+        port = (
+            0
+            if self.config['random_outgoing_ports']
+            else self.config['outgoing_ports'][0]
+        )
+        if port:
+            num_ports = (
+                self.config['outgoing_ports'][1] - self.config['outgoing_ports'][0]
+            )
+            num_ports = num_ports if num_ports > 1 else 5
+        else:
+            num_ports = 0
+        log.debug('Outgoing port set to %s with range: %s', port, num_ports)
+        self.core.apply_session_settings(
+            {'outgoing_port': port, 'num_outgoing_ports': num_ports}
+        )
 
     def _on_set_peer_tos(self, key, value):
-        log.debug("setting peer_tos to: %s", value)
         try:
-            self.session_set_setting("peer_tos", chr(int(value, 16)))
-        except ValueError, e:
-            log.debug("Invalid tos byte: %s", e)
-            return
+            self.core.apply_session_setting('peer_tos', int(value, 16))
+        except ValueError as ex:
+            log.error('Invalid tos byte: %s', ex)
 
     def _on_set_dht(self, key, value):
-        log.debug("dht value set to %s", value)
-        state_file = deluge.configmanager.get_config_dir("dht.state")
-        if value:
-            state = None
-            try:
-                state = lt.bdecode(open(state_file, "rb").read())
-            except Exception, e:
-                log.warning("Unable to read DHT state file: %s", e)
-
-            try:
-                self.session.start_dht(state)
-            except Exception, e:
-                log.warning("Restoring old DHT state failed: %s", e)
-                self.session.start_dht(None)
-            self.session.add_dht_router("router.bittorrent.com", 6881)
-            self.session.add_dht_router("router.utorrent.com", 6881)
-            self.session.add_dht_router("router.bitcomet.com", 6881)
-        else:
-            self.core.save_dht_state()
-            self.session.stop_dht()
+        lt_bootstraps = self.core.session.get_settings()['dht_bootstrap_nodes']
+        # Update list of lt bootstraps, using set to remove duplicates.
+        dht_bootstraps = set(
+            lt_bootstraps.split(',')
+            + [
+                'router.bittorrent.com:6881',
+                'router.utorrent.com:6881',
+                'router.bitcomet.com:6881',
+                'dht.transmissionbt.com:6881',
+                'dht.aelitis.com:6881',
+            ]
+        )
+        self.core.apply_session_settings(
+            {'dht_bootstrap_nodes': ','.join(dht_bootstraps), 'enable_dht': value}
+        )
 
     def _on_set_upnp(self, key, value):
-        log.debug("upnp value set to %s", value)
-        if value:
-            self.session.start_upnp()
-        else:
-            self.session.stop_upnp()
+        self.core.apply_session_setting('enable_upnp', value)
 
     def _on_set_natpmp(self, key, value):
-        log.debug("natpmp value set to %s", value)
-        if value:
-            self.session.start_natpmp()
-        else:
-            self.session.stop_natpmp()
+        self.core.apply_session_setting('enable_natpmp', value)
 
     def _on_set_lsd(self, key, value):
-        log.debug("lsd value set to %s", value)
-        if value:
-            self.session.start_lsd()
-        else:
-            self.session.stop_lsd()
+        self.core.apply_session_setting('enable_lsd', value)
 
     def _on_set_utpex(self, key, value):
-        log.debug("utpex value set to %s", value)
         if value:
-            # 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
+            self.core.session.add_extension('ut_pex')
 
     def _on_set_enc_in_policy(self, key, value):
         self._on_set_encryption(key, value)
@@ -302,179 +304,179 @@ class PreferencesManager(component.Component):
     def _on_set_enc_level(self, key, value):
         self._on_set_encryption(key, value)
 
-    def _on_set_enc_prefer_rc4(self, key, value):
-        self._on_set_encryption(key, value)
-
     def _on_set_encryption(self, key, value):
-        log.debug("encryption value %s set to %s..", key, value)
-        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.prefer_rc4 = self.config["enc_prefer_rc4"]
-        self.session.set_pe_settings(pe_settings)
-        set = self.session.get_pe_settings()
-        log.debug("encryption settings:\n\t\t\tout_policy: %s\n\t\t\
-        in_policy: %s\n\t\t\tlevel: %s\n\t\t\tprefer_rc4: %s",
-            set.out_enc_policy,
-            set.in_enc_policy,
-            set.allowed_enc_level,
-            set.prefer_rc4)
+        # Convert Deluge enc_level values to libtorrent enc_level values.
+        pe_enc_level = {
+            0: lt.enc_level.plaintext,
+            1: lt.enc_level.rc4,
+            2: lt.enc_level.both,
+        }
+        self.core.apply_session_settings(
+            {
+                'out_enc_policy': lt.enc_policy(self.config['enc_out_policy']),
+                'in_enc_policy': lt.enc_policy(self.config['enc_in_policy']),
+                'allowed_enc_level': lt.enc_level(
+                    pe_enc_level[self.config['enc_level']]
+                ),
+                'prefer_rc4': True,
+            }
+        )
 
     def _on_set_max_connections_global(self, key, value):
-        log.debug("max_connections_global set to %s..", value)
-        self.session.set_max_connections(value)
+        self.core.apply_session_setting('connections_limit', value)
 
     def _on_set_max_upload_speed(self, key, value):
-        log.debug("max_upload_speed set to %s..", value)
         # We need to convert Kb/s to B/s
-        if value < 0:
-            v = -1
-        else:
-            v = int(value * 1024)
-
-        self.session.set_upload_rate_limit(v)
+        value = -1 if value < 0 else int(value * 1024)
+        self.core.apply_session_setting('upload_rate_limit', value)
 
     def _on_set_max_download_speed(self, key, value):
-        log.debug("max_download_speed set to %s..", value)
         # We need to convert Kb/s to B/s
-        if value < 0:
-            v = -1
-        else:
-            v = int(value * 1024)
-        self.session.set_download_rate_limit(v)
+        value = -1 if value < 0 else int(value * 1024)
+        self.core.apply_session_setting('download_rate_limit', value)
 
     def _on_set_max_upload_slots_global(self, key, value):
-        log.debug("max_upload_slots_global set to %s..", value)
-        self.session.set_max_uploads(value)
+        self.core.apply_session_setting('unchoke_slots_limit', value)
 
     def _on_set_max_half_open_connections(self, key, value):
-        self.session.set_max_half_open_connections(value)
+        self.core.apply_session_setting('half_open_limit', value)
 
     def _on_set_max_connections_per_second(self, key, value):
-        self.session_set_setting("connection_speed", value)
+        self.core.apply_session_setting('connection_speed', value)
 
     def _on_set_ignore_limits_on_local_network(self, key, value):
-        self.session_set_setting("ignore_limits_on_local_network", value)
+        self.core.apply_session_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.session_set_setting("share_ratio_limit", value)
+        # This value is a float percentage in deluge, but libtorrent needs int percentage.
+        self.core.apply_session_setting('share_ratio_limit', int(value * 100))
 
     def _on_set_seed_time_ratio_limit(self, key, value):
-        log.debug("%s set to %s..", key, value)
-        self.session_set_setting("seed_time_ratio_limit", value)
+        # This value is a float percentage in deluge, but libtorrent needs int percentage.
+        self.core.apply_session_setting('seed_time_ratio_limit', int(value * 100))
 
     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.session_set_setting("seed_time_limit", int(value * 60))
+        self.core.apply_session_setting('seed_time_limit', int(value * 60))
 
     def _on_set_max_active_downloading(self, key, value):
-        log.debug("%s set to %s..", key, value)
-        self.session_set_setting("active_downloads", value)
+        self.core.apply_session_setting('active_downloads', value)
 
     def _on_set_max_active_seeding(self, key, value):
-        log.debug("%s set to %s..", key, value)
-        self.session_set_setting("active_seeds", value)
+        self.core.apply_session_setting('active_seeds', value)
 
     def _on_set_max_active_limit(self, key, value):
-        log.debug("%s set to %s..", key, value)
-        self.session_set_setting("active_limit", value)
+        self.core.apply_session_setting('active_limit', value)
 
     def _on_set_dont_count_slow_torrents(self, key, value):
-        log.debug("%s set to %s..", key, value)
-        self.session_set_setting("dont_count_slow_torrents", value)
+        self.core.apply_session_setting('dont_count_slow_torrents', value)
 
     def _on_set_send_info(self, key, value):
-        log.debug("Sending anonymous stats..")
         """sends anonymous stats home"""
-        class Send_Info_Thread(threading.Thread):
+        log.debug('Sending anonymous stats..')
+
+        class SendInfoThread(threading.Thread):
             def __init__(self, config):
                 self.config = config
                 threading.Thread.__init__(self)
+
             def run(self):
                 import time
+
                 now = time.time()
                 # check if we've done this within the last week or never
-                if (now - self.config["info_sent"]) >= (60 * 60 * 24 * 7):
-                    import deluge.common
-                    from urllib import quote_plus
-                    from urllib2 import urlopen
-                    import platform
+                if (now - self.config['info_sent']) >= (60 * 60 * 24 * 7):
                     try:
-                        url = "http://deluge-torrent.org/stats_get.php?processor=" + \
-                            platform.machine() + "&python=" + platform.python_version() \
-                            + "&deluge=" + deluge.common.get_version() \
-                            + "&os=" + platform.system() \
-                            + "&plugins=" + quote_plus(":".join(self.config["enabled_plugins"]))
+                        url = (
+                            'http://deluge-torrent.org/stats_get.php?processor='
+                            + platform.machine()
+                            + '&python='
+                            + platform.python_version()
+                            + '&deluge='
+                            + deluge.common.get_version()
+                            + '&os='
+                            + platform.system()
+                            + '&plugins='
+                            + quote_plus(':'.join(self.config['enabled_plugins']))
+                        )
                         urlopen(url)
-                    except IOError, e:
-                        log.debug("Network error while trying to send info: %s", e)
+                    except IOError as ex:
+                        log.debug('Network error while trying to send info: %s', ex)
                     else:
-                        self.config["info_sent"] = now
+                        self.config['info_sent'] = now
+
         if value:
-            Send_Info_Thread(self.config).start()
+            SendInfoThread(self.config).start()
 
     def _on_set_new_release_check(self, key, value):
         if value:
-            log.debug("Checking for new release..")
+            log.debug('Checking for new release..')
             threading.Thread(target=self.core.get_new_release).start()
             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_set_new_release_check, "new_release_check", True)
+                self._on_set_new_release_check, 'new_release_check', True
+            )
             self.new_release_timer.start(72 * 60 * 60, False)
         else:
             if self.new_release_timer and self.new_release_timer.running:
                 self.new_release_timer.stop()
 
-    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)
+    def _on_set_proxy(self, key, value):
+        # Initialise with type none and blank hostnames.
+        proxy_settings = {
+            'proxy_type': lt.proxy_type_t.none,
+            'i2p_hostname': '',
+            'proxy_hostname': '',
+            'proxy_hostnames': value['proxy_hostnames'],
+            'proxy_peer_connections': value['proxy_peer_connections'],
+            'proxy_tracker_connections': value['proxy_tracker_connections'],
+            'force_proxy': value['force_proxy'],
+            'anonymous_mode': value['anonymous_mode'],
+        }
+
+        if value['type'] == lt.proxy_type_t.i2p_proxy:
+            proxy_settings.update(
+                {
+                    'proxy_type': lt.proxy_type_t.i2p_proxy,
+                    'i2p_hostname': value['hostname'],
+                    'i2p_port': value['port'],
+                }
+            )
+        elif value['type'] != lt.proxy_type_t.none:
+            proxy_settings.update(
+                {
+                    'proxy_type': value['type'],
+                    'proxy_hostname': value['hostname'],
+                    'proxy_port': value['port'],
+                    'proxy_username': value['username'],
+                    'proxy_password': value['password'],
+                }
+            )
+
+        self.core.apply_session_settings(proxy_settings)
 
     def _on_set_rate_limit_ip_overhead(self, key, value):
-        log.debug("%s: %s", key, value)
-        self.session_set_setting("rate_limit_ip_overhead", value)
+        self.core.apply_session_setting('rate_limit_ip_overhead', value)
 
-    def _on_set_geoip_db_location(self, key, value):
-        log.debug("%s: %s", key, value)
+    def _on_set_geoip_db_location(self, key, geoipdb_path):
         # Load the GeoIP DB for country look-ups if available
-        geoip_db = ""
-        if os.path.exists(value):
-            geoip_db = value
-        elif os.path.exists(deluge.common.resource_filename("deluge", os.path.join("data", "GeoIP.dat"))):
-            geoip_db = deluge.common.resource_filename(
-                "deluge", os.path.join("data", "GeoIP.dat")
-            )
-        else:
-            log.warning("Unable to find GeoIP database file!")
-
-        if geoip_db:
+        if os.path.exists(geoipdb_path):
             try:
-                self.session.load_country_db(str(geoip_db))
-            except Exception, e:
-                log.error("Unable to load geoip database!")
-                log.exception(e)
+                self.core.geoip_instance = GeoIP.open(
+                    geoipdb_path, GeoIP.GEOIP_STANDARD
+                )
+            except AttributeError:
+                log.warning('GeoIP Unavailable')
+        else:
+            log.warning('Unable to find GeoIP database file: %s', geoipdb_path)
 
     def _on_set_cache_size(self, key, value):
-        log.debug("%s: %s", key, value)
-        self.session_set_setting("cache_size", value)
+        self.core.apply_session_setting('cache_size', value)
 
     def _on_set_cache_expiry(self, key, value):
-        log.debug("%s: %s", key, value)
-        self.session_set_setting("cache_expiry", value)
+        self.core.apply_session_setting('cache_expiry', value)
 
     def _on_auto_manage_prefer_seeds(self, key, value):
-        log.debug("%s set to %s..", key, value)
-        self.session_set_setting("auto_manage_prefer_seeds", value)
+        self.core.apply_session_setting('auto_manage_prefer_seeds', value)

deluge/core/rpcserver.py

@@ -1,65 +1,43 @@
-#
-# rpcserver.py
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2008,2009 Andrew Resch <andrewresch@gmail.com>
 #
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
 
 """RPCServer Module"""
+from __future__ import unicode_literals
 
-import sys
-import zlib
+import logging
 import os
 import stat
-import logging
+import sys
 import traceback
-
-from twisted.internet.protocol import Factory, Protocol
-from twisted.internet import reactor, defer
-
-from OpenSSL import crypto, SSL
+from collections import namedtuple
 from types import FunctionType
 
-try:
-    import rencode
-except ImportError:
-    import deluge.rencode as rencode
+from OpenSSL import crypto
+from twisted.internet import defer, reactor
+from twisted.internet.protocol import Factory, connectionDone
 
 import deluge.component as component
 import deluge.configmanager
-from deluge.core.authmanager import (AUTH_LEVEL_NONE, AUTH_LEVEL_DEFAULT,
-                                     AUTH_LEVEL_ADMIN)
-from deluge.error import (DelugeError, NotAuthorizedError, WrappedException,
-                          _ClientSideRecreateError, IncompatibleClient)
-
+from deluge.core.authmanager import (
+    AUTH_LEVEL_ADMIN,
+    AUTH_LEVEL_DEFAULT,
+    AUTH_LEVEL_NONE,
+)
+from deluge.crypto_utils import get_context_factory
+from deluge.error import (
+    DelugeError,
+    IncompatibleClient,
+    NotAuthorizedError,
+    WrappedException,
+    _ClientSideRecreateError,
+)
+from deluge.event import ClientDisconnectedEvent
 from deluge.transfer import DelugeTransferProtocol
 
 RPC_RESPONSE = 1
@@ -68,6 +46,7 @@ RPC_EVENT = 3
 
 log = logging.getLogger(__name__)
 
+
 def export(auth_level=AUTH_LEVEL_DEFAULT):
     """
     Decorator function to register an object's method as an RPC.  The object
@@ -79,17 +58,27 @@ def export(auth_level=AUTH_LEVEL_DEFAULT):
     :type auth_level: int
 
     """
+
     def wrap(func, *args, **kwargs):
         func._rpcserver_export = True
         func._rpcserver_auth_level = auth_level
-        doc = func.__doc__
-        func.__doc__ = "**RPC Exported Function** (*Auth Level: %s*)\n\n" % auth_level
-        if doc:
-            func.__doc__ += doc
+
+        rpc_text = '**RPC exported method** (*Auth level: %s*)' % auth_level
+
+        # Append the RPC text while ensuring correct docstring formatting.
+        if func.__doc__:
+            if func.__doc__.endswith('    '):
+                indent = func.__doc__.split('\n')[-1]
+                func.__doc__ += '\n{}'.format(indent)
+            else:
+                func.__doc__ += '\n\n'
+            func.__doc__ += rpc_text
+        else:
+            func.__doc__ = rpc_text
 
         return func
 
-    if type(auth_level) is FunctionType:
+    if isinstance(auth_level, FunctionType):
         func = auth_level
         auth_level = AUTH_LEVEL_DEFAULT
         return wrap(func)
@@ -109,34 +98,25 @@ def format_request(call):
 
     """
     try:
-        s = call[1] + "("
+        s = call[1] + '('
         if call[2]:
-            s += ", ".join([str(x) for x in call[2]])
+            s += ', '.join([str(x) for x in call[2]])
         if call[3]:
             if call[2]:
-                s += ", "
-            s += ", ".join([key + "=" + str(value) for key, value in call[3].items()])
-        s += ")"
+                s += ', '
+            s += ', '.join([key + '=' + str(value) for key, value in call[3].items()])
+        s += ')'
     except UnicodeEncodeError:
-        return "UnicodeEncodeError, call: %s" % call
+        return 'UnicodeEncodeError, call: %s' % call
     else:
         return s
 
-class ServerContextFactory(object):
-    def getContext(self):
-        """
-        Create an SSL context.
-
-        This loads the servers cert/private key SSL files for use with the
-        SSL transport.
-        """
-        ssl_dir = deluge.configmanager.get_config_dir("ssl")
-        ctx = SSL.Context(SSL.SSLv3_METHOD)
-        ctx.use_certificate_file(os.path.join(ssl_dir, "daemon.cert"))
-        ctx.use_privatekey_file(os.path.join(ssl_dir, "daemon.pkey"))
-        return ctx
 
 class DelugeRPCProtocol(DelugeTransferProtocol):
+    def __init__(self):
+        super(DelugeRPCProtocol, self).__init__()
+        # namedtuple subclass with auth_level, username for the connected session.
+        self.AuthLevel = namedtuple('SessionAuthlevel', 'auth_level, username')
 
     def message_received(self, request):
         """
@@ -144,28 +124,30 @@ class DelugeRPCProtocol(DelugeTransferProtocol):
         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
         :meth:`dispatch`.
-        
+
         :param request: the request from the client.
         :type data: tuple
 
         """
-        if type(request) is not tuple:
-            log.debug("Received invalid message: type is not tuple")
+        if not isinstance(request, tuple):
+            log.debug('Received invalid message: type is not tuple')
             return
 
         if len(request) < 1:
-            log.debug("Received invalid message: there are no items")
+            log.debug('Received invalid message: there are no items')
             return
 
         for call in request:
             if len(call) != 4:
-                log.debug("Received invalid rpc request: number of items "
-                          "in request is %s", len(call))
+                log.debug(
+                    'Received invalid rpc request: number of items ' 'in request is %s',
+                    len(call),
+                )
                 continue
-            #log.debug("RPCRequest: %s", format_request(call))
+            # log.debug('RPCRequest: %s', format_request(call))
             reactor.callLater(0, self.dispatch, *call)
 
-    def sendData(self, data):
+    def sendData(self, data):  # NOQA: N802
         """
         Sends the data to the client.
 
@@ -174,19 +156,25 @@ class DelugeRPCProtocol(DelugeTransferProtocol):
         :type data: object
 
         """
-        self.transfer_message(data)
+        try:
+            self.transfer_message(data)
+        except Exception as ex:
+            log.warning('Error occurred when sending message: %s.', ex)
+            log.exception(ex)
+            raise
 
-    def connectionMade(self):
+    def connectionMade(self):  # NOQA: N802
         """
         This method is called when a new client connects.
         """
         peer = self.transport.getPeer()
-        log.info("Deluge Client connection made from: %s:%s",
-                 peer.host, peer.port)
+        log.info('Deluge Client connection made from: %s:%s', peer.host, peer.port)
         # Set the initial auth level of this session to AUTH_LEVEL_NONE
-        self.factory.authorized_sessions[self.transport.sessionno] = AUTH_LEVEL_NONE
+        self.factory.authorized_sessions[self.transport.sessionno] = self.AuthLevel(
+            AUTH_LEVEL_NONE, ''
+        )
 
-    def connectionLost(self, reason):
+    def connectionLost(self, reason=connectionDone):  # NOQA: N802
         """
         This method is called when the client is disconnected.
 
@@ -202,7 +190,11 @@ class DelugeRPCProtocol(DelugeTransferProtocol):
         if self.transport.sessionno in self.factory.interested_events:
             del self.factory.interested_events[self.transport.sessionno]
 
-        log.info("Deluge client disconnected: %s", reason.value)
+        if self.factory.state == 'running':
+            component.get('EventManager').emit(
+                ClientDisconnectedEvent(self.factory.session_id)
+            )
+        log.info('Deluge client disconnected: %s', reason.value)
 
     def valid_session(self):
         return self.transport.sessionno in self.factory.authorized_sessions
@@ -223,60 +215,77 @@ class DelugeRPCProtocol(DelugeTransferProtocol):
         :type kwargs: dict
 
         """
-        def sendError():
+
+        def send_error():
             """
             Sends an error response with the contents of the exception that was raised.
             """
-            exceptionType, exceptionValue, exceptionTraceback = sys.exc_info()
-            formated_tb = "".join(traceback.format_tb(exceptionTraceback))
+            exc_type, exc_value, dummy_exc_trace = sys.exc_info()
+            formated_tb = traceback.format_exc()
             try:
-                self.sendData((
-                    RPC_ERROR,
-                    request_id,
-                    exceptionType.__name__,
-                    exceptionValue._args,
-                    exceptionValue._kwargs,
-                    formated_tb
-                ))
-            except Exception, err:
-                # This most likely not a deluge exception, let's wrap it
-                log.error("An exception occurred while sending RPC_ERROR to "
-                          "client. Wrapping it and resending. Error to "
-                          "send(causing exception goes next):\n%s", formated_tb)
-                log.exception(err)
+                self.sendData(
+                    (
+                        RPC_ERROR,
+                        request_id,
+                        exc_type.__name__,
+                        exc_value._args,
+                        exc_value._kwargs,
+                        formated_tb,
+                    )
+                )
+            except AttributeError:
+                # This is not a deluge exception (object has no attribute '_args), let's wrap it
+                log.warning(
+                    'An exception occurred while sending RPC_ERROR to '
+                    'client. Wrapping it and resending. Error to '
+                    'send(causing exception goes next):\n%s',
+                    formated_tb,
+                )
                 try:
-                    raise WrappedException(str(exceptionValue), exceptionType.__name__, formated_tb)
-                except:
-                    sendError()
+                    raise WrappedException(
+                        str(exc_value), exc_type.__name__, formated_tb
+                    )
+                except WrappedException:
+                    send_error()
+            except Exception as ex:
+                log.error(
+                    'An exception occurred while sending RPC_ERROR to client: %s', ex
+                )
 
-        if method == "daemon.info":
+        if method == 'daemon.info':
             # This is a special case and used in the initial connection process
             self.sendData((RPC_RESPONSE, request_id, deluge.common.get_version()))
             return
-        elif method == "daemon.login":
+        elif method == 'daemon.login':
             # This is a special case and used in the initial connection process
             # We need to authenticate the user here
-            log.debug("RPC dispatch daemon.login")
+            log.debug('RPC dispatch daemon.login')
             try:
                 client_version = kwargs.pop('client_version', None)
                 if client_version is None:
                     raise IncompatibleClient(deluge.common.get_version())
-                ret = component.get("AuthManager").authorize(*args, **kwargs)
+                ret = component.get('AuthManager').authorize(*args, **kwargs)
                 if ret:
-                    self.factory.authorized_sessions[self.transport.sessionno] = (ret, args[0])
+                    self.factory.authorized_sessions[
+                        self.transport.sessionno
+                    ] = self.AuthLevel(ret, args[0])
                     self.factory.session_protocols[self.transport.sessionno] = self
-            except Exception, e:
-                sendError()
-                if not isinstance(e, _ClientSideRecreateError):
-                    log.exception(e)
+            except Exception as ex:
+                send_error()
+                if not isinstance(ex, _ClientSideRecreateError):
+                    log.exception(ex)
             else:
                 self.sendData((RPC_RESPONSE, request_id, (ret)))
                 if not ret:
                     self.transport.loseConnection()
-            finally:
-                return
-        elif method == "daemon.set_event_interest" and self.valid_session():
-            log.debug("RPC dispatch daemon.set_event_interest")
+            return
+
+        # Anything below requires a valid session
+        if not self.valid_session():
+            return
+
+        if method == 'daemon.set_event_interest':
+            log.debug('RPC dispatch daemon.set_event_interest')
             # This special case is to allow clients to set which events they are
             # interested in receiving.
             # We are expecting a sequence from the client.
@@ -284,51 +293,66 @@ class DelugeRPCProtocol(DelugeTransferProtocol):
                 if self.transport.sessionno not in self.factory.interested_events:
                     self.factory.interested_events[self.transport.sessionno] = []
                 self.factory.interested_events[self.transport.sessionno].extend(args[0])
-            except Exception, e:
-                sendError()
+            except Exception:
+                send_error()
             else:
                 self.sendData((RPC_RESPONSE, request_id, (True)))
-            finally:
+            return
+
+        if method not in self.factory.methods:
+            try:
+                # Raise exception to be sent back to client
+                raise AttributeError('RPC call on invalid function: %s' % method)
+            except AttributeError:
+                send_error()
                 return
 
-        if method in self.factory.methods and self.valid_session():
-            log.debug("RPC dispatch %s", method)
-            try:
-                method_auth_requirement = self.factory.methods[method]._rpcserver_auth_level
-                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)
-                    raise NotAuthorizedError(auth_level, method_auth_requirement)
-                # Set the session_id in the factory so that methods can know
-                # which session is calling it.
-                self.factory.session_id = self.transport.sessionno
-                ret = self.factory.methods[method](*args, **kwargs)
-            except Exception, e:
-                sendError()
-                # Don't bother printing out DelugeErrors, because they are just
-                # for the client
-                if not isinstance(e, DelugeError):
-                    log.exception("Exception calling RPC request: %s", e)
-            else:
-                # Check if the return value is a deferred, since we'll need to
-                # wait for it to fire before sending the RPC_RESPONSE
-                if isinstance(ret, defer.Deferred):
-                    def on_success(result):
+        log.debug('RPC dispatch %s', method)
+        try:
+            method_auth_requirement = self.factory.methods[method]._rpcserver_auth_level
+            auth_level = self.factory.authorized_sessions[
+                self.transport.sessionno
+            ].auth_level
+            if auth_level < method_auth_requirement:
+                # This session is not allowed to call this method
+                log.debug(
+                    'Session %s is attempting an unauthorized method call!',
+                    self.transport.sessionno,
+                )
+                raise NotAuthorizedError(auth_level, method_auth_requirement)
+            # Set the session_id in the factory so that methods can know
+            # which session is calling it.
+            self.factory.session_id = self.transport.sessionno
+            ret = self.factory.methods[method](*args, **kwargs)
+        except Exception as ex:
+            send_error()
+            # Don't bother printing out DelugeErrors, because they are just
+            # for the client
+            if not isinstance(ex, DelugeError):
+                log.exception('Exception calling RPC request: %s', ex)
+        else:
+            # Check if the return value is a deferred, since we'll need to
+            # wait for it to fire before sending the RPC_RESPONSE
+            if isinstance(ret, defer.Deferred):
+
+                def on_success(result):
+                    try:
                         self.sendData((RPC_RESPONSE, request_id, result))
-                        return result
+                    except Exception:
+                        send_error()
+                    return result
 
-                    def on_fail(failure):
-                        try:
-                            failure.raiseException()
-                        except Exception, e:
-                            sendError()
-                        return failure
+                def on_fail(failure):
+                    try:
+                        failure.raiseException()
+                    except Exception:
+                        send_error()
+                    return failure
+
+                ret.addCallbacks(on_success, on_fail)
+            else:
+                self.sendData((RPC_RESPONSE, request_id, ret))
 
-                    ret.addCallbacks(on_success, on_fail)
-                else:
-                    self.sendData((RPC_RESPONSE, request_id, ret))
 
 class RPCServer(component.Component):
     """
@@ -346,12 +370,13 @@ class RPCServer(component.Component):
     :type listen: bool
     """
 
-    def __init__(self, port=58846, interface="", allow_remote=False, listen=True):
-        component.Component.__init__(self, "RPCServer")
+    def __init__(self, port=58846, interface='', allow_remote=False, listen=True):
+        component.Component.__init__(self, 'RPCServer')
 
         self.factory = Factory()
         self.factory.protocol = DelugeRPCProtocol
         self.factory.session_id = -1
+        self.factory.state = 'running'
 
         # Holds the registered methods
         self.factory.methods = {}
@@ -367,24 +392,28 @@ class RPCServer(component.Component):
             return
 
         if allow_remote:
-            hostname = ""
+            hostname = ''
         else:
-            hostname = "localhost"
+            hostname = 'localhost'
 
         if interface:
             hostname = interface
 
-        log.info("Starting DelugeRPC server %s:%s", hostname, port)
+        log.info('Starting DelugeRPC server %s:%s', hostname, port)
 
         # Check for SSL keys and generate some if needed
         check_ssl_keys()
 
+        cert = os.path.join(deluge.configmanager.get_config_dir('ssl'), 'daemon.cert')
+        pkey = os.path.join(deluge.configmanager.get_config_dir('ssl'), 'daemon.pkey')
+
         try:
-            reactor.listenSSL(port, self.factory, ServerContextFactory(), interface=hostname)
-        except Exception, e:
-            log.info("Daemon already running or port not available..")
-            log.error(e)
-            sys.exit(0)
+            reactor.listenSSL(
+                port, self.factory, get_context_factory(cert, pkey), interface=hostname
+            )
+        except Exception as ex:
+            log.debug('Daemon already running or port not available.: %s', ex)
+            raise
 
     def register_object(self, obj, name=None):
         """
@@ -400,11 +429,11 @@ class RPCServer(component.Component):
             name = obj.__class__.__name__.lower()
 
         for d in dir(obj):
-            if d[0] == "_":
+            if d[0] == '_':
                 continue
             if getattr(getattr(obj, d), '_rpcserver_export', False):
-                log.debug("Registering method: %s", name + "." + d)
-                self.factory.methods[name + "." + d] = getattr(obj, d)
+                log.debug('Registering method: %s', name + '.' + d)
+                self.factory.methods[name + '.' + d] = getattr(obj, d)
 
     def deregister_object(self, obj):
         """
@@ -414,7 +443,7 @@ class RPCServer(component.Component):
 
         """
         for key, value in self.factory.methods.items():
-            if value.im_self == obj:
+            if value.__self__ == obj:
                 del self.factory.methods[key]
 
     def get_object_method(self, name):
@@ -438,7 +467,7 @@ class RPCServer(component.Component):
         :returns: the exported methods
         :rtype: list
         """
-        return self.factory.methods.keys()
+        return list(self.factory.methods)
 
     def get_session_id(self):
         """
@@ -459,13 +488,13 @@ class RPCServer(component.Component):
 
         """
         if not self.listen:
-            return "localclient"
+            return 'localclient'
         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]
+            return self.factory.authorized_sessions[session_id].username
         else:
             # No connections made yet
-            return ""
+            return ''
 
     def get_session_auth_level(self):
         """
@@ -476,7 +505,7 @@ class RPCServer(component.Component):
         """
         if not self.listen or not self.is_session_valid(self.get_session_id()):
             return AUTH_LEVEL_ADMIN
-        return self.factory.authorized_sessions[self.get_session_id()][0]
+        return self.factory.authorized_sessions[self.get_session_id()].auth_level
 
     def get_rpc_auth_level(self, rpc):
         """
@@ -485,7 +514,7 @@ class RPCServer(component.Component):
         :returns: the auth level
         :rtype: int
         """
-        self.factory.methods[rpc]._rpcserver_auth_level
+        return self.factory.methods[rpc]._rpcserver_auth_level
 
     def is_session_valid(self, session_id):
         """
@@ -507,11 +536,11 @@ class RPCServer(component.Component):
         :param event: the event to emit
         :type event: :class:`deluge.event.DelugeEvent`
         """
-        log.debug("intevents: %s", self.factory.interested_events)
+        log.debug('intevents: %s', self.factory.interested_events)
         # Find sessions interested in this event
         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)
+                log.debug('Emit Event: %s %s', event.name, event.args)
                 # This session is interested so send a RPC_EVENT
                 self.factory.session_protocols[session_id].sendData(
                     (RPC_EVENT, event.name, event.args)
@@ -527,47 +556,72 @@ class RPCServer(component.Component):
         :type event: :class:`deluge.event.DelugeEvent`
         """
         if not self.is_session_valid(session_id):
-            log.debug("Session ID %s is not valid. Not sending event \"%s\".", session_id, event.name)
+            log.debug(
+                'Session ID %s is not valid. Not sending event "%s".',
+                session_id,
+                event.name,
+            )
             return
         if session_id not in self.factory.interested_events:
-            log.debug("Session ID %s is not interested in any events. Not sending event \"%s\".", session_id, event.name)
+            log.debug(
+                'Session ID %s is not interested in any events. Not sending event "%s".',
+                session_id,
+                event.name,
+            )
             return
         if event.name not in self.factory.interested_events[session_id]:
-            log.debug("Session ID %s is not interested in event \"%s\". Not sending it.", session_id, event.name)
+            log.debug(
+                'Session ID %s is not interested in event "%s". Not sending it.',
+                session_id,
+                event.name,
+            )
             return
-        log.debug("Sending event \"%s\" with args \"%s\" to session id \"%s\".",
-                  event.name, event.args, session_id)
-        self.factory.session_protocols[session_id].sendData((RPC_EVENT, event.name, event.args))
+        log.debug(
+            'Sending event "%s" with args "%s" to session id "%s".',
+            event.name,
+            event.args,
+            session_id,
+        )
+        self.factory.session_protocols[session_id].sendData(
+            (RPC_EVENT, event.name, event.args)
+        )
+
+    def stop(self):
+        self.factory.state = 'stopping'
 
 
 def check_ssl_keys():
     """
     Check for SSL cert/key and create them if necessary
     """
-    ssl_dir = deluge.configmanager.get_config_dir("ssl")
+    ssl_dir = deluge.configmanager.get_config_dir('ssl')
     if not os.path.exists(ssl_dir):
         # The ssl folder doesn't exist so we need to create it
         os.makedirs(ssl_dir)
         generate_ssl_keys()
     else:
-        for f in ("daemon.pkey", "daemon.cert"):
+        for f in ('daemon.pkey', 'daemon.cert'):
             if not os.path.exists(os.path.join(ssl_dir, f)):
                 generate_ssl_keys()
                 break
 
+
 def generate_ssl_keys():
     """
     This method generates a new SSL key/cert.
     """
-    digest = "md5"
+    from deluge.common import PY2
+
+    digest = 'sha256' if not PY2 else b'sha256'
+
     # Generate key pair
     pkey = crypto.PKey()
-    pkey.generate_key(crypto.TYPE_RSA, 1024)
+    pkey.generate_key(crypto.TYPE_RSA, 2048)
 
     # Generate cert request
     req = crypto.X509Req()
     subj = req.get_subject()
-    setattr(subj, "CN", "Deluge Daemon")
+    setattr(subj, 'CN', 'Deluge Daemon')
     req.set_pubkey(pkey)
     req.sign(pkey, digest)
 
@@ -575,20 +629,18 @@ def generate_ssl_keys():
     cert = crypto.X509()
     cert.set_serial_number(0)
     cert.gmtime_adj_notBefore(0)
-    cert.gmtime_adj_notAfter(60*60*24*365*5) # Five Years
+    cert.gmtime_adj_notAfter(60 * 60 * 24 * 365 * 3)  # Three Years
     cert.set_issuer(req.get_subject())
     cert.set_subject(req.get_subject())
     cert.set_pubkey(req.get_pubkey())
     cert.sign(pkey, digest)
 
     # Write out files
-    ssl_dir = deluge.configmanager.get_config_dir("ssl")
-    open(os.path.join(ssl_dir, "daemon.pkey"), "w").write(
-        crypto.dump_privatekey(crypto.FILETYPE_PEM, pkey)
-    )
-    open(os.path.join(ssl_dir, "daemon.cert"), "w").write(
-        crypto.dump_certificate(crypto.FILETYPE_PEM, cert)
-    )
+    ssl_dir = deluge.configmanager.get_config_dir('ssl')
+    with open(os.path.join(ssl_dir, 'daemon.pkey'), 'wb') as _file:
+        _file.write(crypto.dump_privatekey(crypto.FILETYPE_PEM, pkey))
+    with open(os.path.join(ssl_dir, 'daemon.cert'), 'wb') as _file:
+        _file.write(crypto.dump_certificate(crypto.FILETYPE_PEM, cert))
     # Make the files only readable by this user
-    for f in ("daemon.pkey", "daemon.cert"):
+    for f in ('daemon.pkey', 'daemon.cert'):
         os.chmod(os.path.join(ssl_dir, f), stat.S_IREAD | stat.S_IWRITE)

deluge/crypto_utils.py

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2007,2008 Andrew Resch <andrewresch@gmail.com>
+#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
+#
+
+from __future__ import division, print_function, unicode_literals
+
+from OpenSSL.crypto import FILETYPE_PEM
+from twisted.internet.ssl import (
+    AcceptableCiphers,
+    Certificate,
+    CertificateOptions,
+    KeyPair,
+    TLSVersion,
+)
+
+# A TLS ciphers list.
+# Sources for more information on TLS ciphers:
+# - https://wiki.mozilla.org/Security/Server_Side_TLS
+# - https://www.ssllabs.com/projects/best-practices/index.html
+# - https://hynek.me/articles/hardening-your-web-servers-ssl-ciphers/
+#
+# This list was inspired by the `urllib3` library
+# - https://github.com/urllib3/urllib3/blob/master/urllib3/util/ssl_.py#L79
+#
+# The general intent is:
+# - prefer cipher suites that offer perfect forward secrecy (ECDHE),
+# - prefer AES-GCM over ChaCha20 because hardware-accelerated AES is common,
+# - disable NULL authentication, MD5 MACs and DSS for security reasons.
+TLS_CIPHERS = ':'.join(
+    [
+        'ECDH+AESGCM',
+        'ECDH+CHACHA20',
+        'AES256-GCM-SHA384',
+        'AES128-GCM-SHA256',
+        '!DSS' '!aNULL',
+        '!eNULL',
+        '!MD5',
+    ]
+)
+
+# This value tells OpenSSL to disable all SSL/TLS renegotiation.
+SSL_OP_NO_RENEGOTIATION = 0x40000000
+
+
+def get_context_factory(cert_path, pkey_path):
+    """OpenSSL context factory.
+
+    Generates an OpenSSL context factory using Twisted's CertificateOptions class.
+    This will keep a server cipher order.
+
+    Args:
+        cert_path (string): The path to the certificate file
+        pkey_path (string): The path to the private key file
+
+    Returns:
+        twisted.internet.ssl.CertificateOptions: An OpenSSL context factory
+    """
+
+    with open(cert_path) as cert:
+        certificate = Certificate.loadPEM(cert.read()).original
+    with open(pkey_path) as pkey:
+        private_key = KeyPair.load(pkey.read(), FILETYPE_PEM).original
+    ciphers = AcceptableCiphers.fromOpenSSLCipherString(TLS_CIPHERS)
+    cert_options = CertificateOptions(
+        privateKey=private_key,
+        certificate=certificate,
+        raiseMinimumTo=TLSVersion.TLSv1_2,
+        acceptableCiphers=ciphers,
+    )
+    ctx = cert_options.getContext()
+    ctx.use_certificate_chain_file(cert_path)
+    ctx.set_options(SSL_OP_NO_RENEGOTIATION)
+
+    return cert_options

deluge/decorators.py

@@ -1,40 +1,20 @@
-#
-# decorators.py
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2010 John Garland <johnnybg+deluge@gmail.com>
 #
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
 
+from __future__ import unicode_literals
+
+import inspect
+import re
+import warnings
 from functools import wraps
 
+
 def proxy(proxy_func):
     """
     Factory class which returns a decorator that passes
@@ -43,9 +23,142 @@ def proxy(proxy_func):
     :param proxy_func: the proxy function
     :type proxy_func: function
     """
+
     def decorator(func):
         @wraps(func)
         def wrapper(*args, **kwargs):
             return proxy_func(func, *args, **kwargs)
+
         return wrapper
+
     return decorator
+
+
+def overrides(*args):
+    """
+    Decorater function to specify when class methods override
+    super class methods.
+
+    When used as
+    @overrides
+    def funcname
+
+    the argument will be the funcname function.
+
+    When used as
+    @overrides(BaseClass)
+    def funcname
+
+    the argument will be the BaseClass
+
+    """
+    stack = inspect.stack()
+    if inspect.isfunction(args[0]):
+        return _overrides(stack, args[0])
+    else:
+        # One or more classes are specifed, so return a function that will be
+        # called with the real function as argument
+        def ret_func(func, **kwargs):
+            return _overrides(stack, func, explicit_base_classes=args)
+
+        return ret_func
+
+
+def _overrides(stack, method, explicit_base_classes=None):
+    # stack[0]=overrides, stack[1]=inside class def'n, stack[2]=outside class def'n
+    classes = {}
+    derived_class_locals = stack[2][0].f_locals
+
+    # Find all super classes
+    m = re.search(r'class\s(.+)\((.+)\)\s*\:', stack[2][4][0])
+    class_name = m.group(1)
+    base_classes = m.group(2)
+
+    # Handle multiple inheritance
+    base_classes = [s.strip() for s in base_classes.split(',')]
+    check_classes = base_classes
+
+    if not base_classes:
+        raise ValueError(
+            'overrides decorator: unable to determine base class of class "%s"'
+            % class_name
+        )
+
+    def get_class(cls_name):
+        if '.' not in cls_name:
+            return derived_class_locals[cls_name]
+        else:
+            components = cls_name.split('.')
+            # obj is either a module or a class
+            obj = derived_class_locals[components[0]]
+            for c in components[1:]:
+                assert inspect.ismodule(obj) or inspect.isclass(obj)
+                obj = getattr(obj, c)
+            return obj
+
+    if explicit_base_classes:
+        # One or more base classes are explicitly given, check only those classes
+        override_classes = re.search(r'\s*@overrides\((.+)\)\s*', stack[1][4][0]).group(
+            1
+        )
+        override_classes = [c.strip() for c in override_classes.split(',')]
+        check_classes = override_classes
+
+    for c in base_classes + check_classes:
+        classes[c] = get_class(c)
+
+    # Verify that the excplicit override class is one of base classes
+    if explicit_base_classes:
+        from itertools import product
+
+        for bc, cc in product(base_classes, check_classes):
+            if issubclass(classes[bc], classes[cc]):
+                break
+        else:
+            raise Exception(
+                'Excplicit override class "%s" is not a super class of: %s'
+                % (explicit_base_classes, class_name)
+            )
+        if not all(hasattr(classes[cls], method.__name__) for cls in check_classes):
+            for cls in check_classes:
+                if not hasattr(classes[cls], method.__name__):
+                    raise Exception(
+                        'Function override "%s" not found in superclass: %s\n%s'
+                        % (
+                            method.__name__,
+                            cls,
+                            'File: %s:%s' % (stack[1][1], stack[1][2]),
+                        )
+                    )
+
+    if not any(hasattr(classes[cls], method.__name__) for cls in check_classes):
+        raise Exception(
+            'Function override "%s" not found in any superclass: %s\n%s'
+            % (
+                method.__name__,
+                check_classes,
+                'File: %s:%s' % (stack[1][1], stack[1][2]),
+            )
+        )
+    return method
+
+
+def deprecated(func):
+    """This is a decorator which can be used to mark function as deprecated.
+
+    It will result in a warning being emmitted when the function is used.
+
+    """
+
+    @wraps(func)
+    def depr_func(*args, **kwargs):
+        warnings.simplefilter('always', DeprecationWarning)  # Turn off filter
+        warnings.warn(
+            'Call to deprecated function {}.'.format(func.__name__),
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+        warnings.simplefilter('default', DeprecationWarning)  # Reset filter
+        return func(*args, **kwargs)
+
+    return depr_func

deluge/error.py

@@ -1,131 +1,96 @@
-#
-# error.py
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2008 Andrew Resch <andrewresch@gmail.com>
 # Copyright (C) 2011 Pedro Algarvio <pedro@algarvio.me>
 #
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
 
 
+from __future__ import unicode_literals
+
+
 class DelugeError(Exception):
-    def _get_message(self):
-        return self._message
-    def _set_message(self, message):
-        self._message = message
-    message = property(_get_message, _set_message)
-    del _get_message, _set_message
-
-    def __str__(self):
-        return self.message
-
     def __new__(cls, *args, **kwargs):
         inst = super(DelugeError, cls).__new__(cls, *args, **kwargs)
         inst._args = args
         inst._kwargs = kwargs
         return inst
 
-class NoCoreError(DelugeError):
-    pass
+    def __init__(self, message=None):
+        super(DelugeError, self).__init__(message)
+        self.message = message
+
+    def __str__(self):
+        return self.message
+
 
 class DaemonRunningError(DelugeError):
     pass
 
+
 class InvalidTorrentError(DelugeError):
     pass
 
+
+class AddTorrentError(DelugeError):
+    pass
+
+
 class InvalidPathError(DelugeError):
     pass
 
+
 class WrappedException(DelugeError):
-    def _get_traceback(self):
-        return self._traceback
-    def _set_traceback(self, traceback):
-        self._traceback = traceback
-    traceback = property(_get_traceback, _set_traceback)
-    del _get_traceback, _set_traceback
-
-    def _get_type(self):
-        return self._type
-    def _set_type(self, type):
-        self._type = type
-    type = property(_get_type, _set_type)
-    del _get_type, _set_type
-
     def __init__(self, message, exception_type, traceback):
-        self.message = message
+        super(WrappedException, self).__init__(message)
         self.type = exception_type
         self.traceback = traceback
 
+    def __str__(self):
+        return '%s\n%s' % (self.message, self.traceback)
+
+
 class _ClientSideRecreateError(DelugeError):
     pass
 
+
 class IncompatibleClient(_ClientSideRecreateError):
     def __init__(self, daemon_version):
         self.daemon_version = daemon_version
-        self.message = _(
-            "Your deluge client is not compatible with the daemon. "
-            "Please upgrade your client to %(daemon_version)s"
-        ) % dict(daemon_version=self.daemon_version)
+        msg = (
+            'Your deluge client is not compatible with the daemon. '
+            'Please upgrade your client to %(daemon_version)s'
+        ) % {'daemon_version': self.daemon_version}
+        super(IncompatibleClient, self).__init__(message=msg)
+
 
 class NotAuthorizedError(_ClientSideRecreateError):
-
     def __init__(self, current_level, required_level):
-        self.message = _(
-            "Auth level too low: %(current_level)s < %(required_level)s" %
-            dict(current_level=current_level, required_level=required_level)
-        )
+        msg = ('Auth level too low: %(current_level)s < %(required_level)s') % {
+            'current_level': current_level,
+            'required_level': required_level,
+        }
+        super(NotAuthorizedError, self).__init__(message=msg)
         self.current_level = current_level
         self.required_level = required_level
 
 
 class _UsernameBasedPasstroughError(_ClientSideRecreateError):
-
-    def _get_username(self):
-        return self._username
-    def _set_username(self, username):
-        self._username = username
-    username = property(_get_username, _set_username)
-    del _get_username, _set_username
-
     def __init__(self, message, username):
         super(_UsernameBasedPasstroughError, self).__init__(message)
-        self.message = message
         self.username = username
 
 
 class BadLoginError(_UsernameBasedPasstroughError):
     pass
 
+
 class AuthenticationRequired(_UsernameBasedPasstroughError):
     pass
 
+
 class AuthManagerError(_UsernameBasedPasstroughError):
     pass

deluge/event.py

@@ -1,36 +1,10 @@
-#
-# event.py
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2009 Andrew Resch <andrewresch@gmail.com>
 #
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-#   The Free Software Foundation, Inc.,
-#   51 Franklin Street, Fifth Floor
-#   Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
 
 """
@@ -40,19 +14,25 @@ This module describes the types of events that can be generated by the daemon
 and subsequently emitted to the clients.
 
 """
+from __future__ import unicode_literals
+
+import six
 
 known_events = {}
 
+
 class DelugeEventMetaClass(type):
     """
     This metaclass simply keeps a list of all events classes created.
     """
-    def __init__(cls, name, bases, dct):
+
+    def __init__(cls, name, bases, dct):  # pylint: disable=bad-mcs-method-argument
         super(DelugeEventMetaClass, cls).__init__(name, bases, dct)
-        if name != "DelugeEvent":
+        if name != 'DelugeEvent':
             known_events[name] = cls
 
-class DelugeEvent(object):
+
+class DelugeEvent(six.with_metaclass(DelugeEventMetaClass, object)):
     """
     The base class for all events.
 
@@ -62,23 +42,24 @@ class DelugeEvent(object):
     :type args: list
 
     """
-    __metaclass__ = DelugeEventMetaClass
 
     def _get_name(self):
         return self.__class__.__name__
 
     def _get_args(self):
-        if not hasattr(self, "_args"):
+        if not hasattr(self, '_args'):
             return []
         return self._args
 
     name = property(fget=_get_name)
     args = property(fget=_get_args)
 
+
 class TorrentAddedEvent(DelugeEvent):
     """
     Emitted when a new torrent is successfully added to the session.
     """
+
     def __init__(self, torrent_id, from_state):
         """
         :param torrent_id: the torrent_id of the torrent that was added
@@ -88,10 +69,12 @@ class TorrentAddedEvent(DelugeEvent):
         """
         self._args = [torrent_id, from_state]
 
+
 class TorrentRemovedEvent(DelugeEvent):
     """
     Emitted when a torrent has been removed from the session.
     """
+
     def __init__(self, torrent_id):
         """
         :param torrent_id: the torrent_id
@@ -99,10 +82,12 @@ class TorrentRemovedEvent(DelugeEvent):
         """
         self._args = [torrent_id]
 
+
 class PreTorrentRemovedEvent(DelugeEvent):
     """
     Emitted when a torrent is about to be removed from the session.
     """
+
     def __init__(self, torrent_id):
         """
         :param torrent_id: the torrent_id
@@ -110,10 +95,12 @@ class PreTorrentRemovedEvent(DelugeEvent):
         """
         self._args = [torrent_id]
 
+
 class TorrentStateChangedEvent(DelugeEvent):
     """
     Emitted when a torrent changes state.
     """
+
     def __init__(self, torrent_id, state):
         """
         :param torrent_id: the torrent_id
@@ -123,16 +110,34 @@ class TorrentStateChangedEvent(DelugeEvent):
         """
         self._args = [torrent_id, state]
 
+
+class TorrentTrackerStatusEvent(DelugeEvent):
+    """
+    Emitted when a torrents tracker status changes.
+    """
+
+    def __init__(self, torrent_id, status):
+        """
+        Args:
+            torrent_id (str): the torrent_id
+            status (str): the new status
+        """
+        self._args = [torrent_id, status]
+
+
 class TorrentQueueChangedEvent(DelugeEvent):
     """
     Emitted when the queue order has changed.
     """
+
     pass
 
+
 class TorrentFolderRenamedEvent(DelugeEvent):
     """
     Emitted when a folder within a torrent has been renamed.
     """
+
     def __init__(self, torrent_id, old, new):
         """
         :param torrent_id: the torrent_id
@@ -144,10 +149,12 @@ class TorrentFolderRenamedEvent(DelugeEvent):
         """
         self._args = [torrent_id, old, new]
 
+
 class TorrentFileRenamedEvent(DelugeEvent):
     """
     Emitted when a file within a torrent has been renamed.
     """
+
     def __init__(self, torrent_id, index, name):
         """
         :param torrent_id: the torrent_id
@@ -159,10 +166,12 @@ class TorrentFileRenamedEvent(DelugeEvent):
         """
         self._args = [torrent_id, index, name]
 
+
 class TorrentFinishedEvent(DelugeEvent):
     """
     Emitted when a torrent finishes downloading.
     """
+
     def __init__(self, torrent_id):
         """
         :param torrent_id: the torrent_id
@@ -170,10 +179,12 @@ class TorrentFinishedEvent(DelugeEvent):
         """
         self._args = [torrent_id]
 
+
 class TorrentResumedEvent(DelugeEvent):
     """
     Emitted when a torrent resumes from a paused state.
     """
+
     def __init__(self, torrent_id):
         """
         :param torrent_id: the torrent_id
@@ -181,13 +192,12 @@ 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
@@ -197,17 +207,36 @@ class TorrentFileCompletedEvent(DelugeEvent):
         """
         self._args = [torrent_id, index]
 
+
+class TorrentStorageMovedEvent(DelugeEvent):
+    """
+    Emitted when the storage location for a torrent has been moved.
+    """
+
+    def __init__(self, torrent_id, path):
+        """
+        :param torrent_id: the torrent_id
+        :type torrent_id: string
+        :param path: the new location
+        :type path: string
+        """
+        self._args = [torrent_id, path]
+
+
 class CreateTorrentProgressEvent(DelugeEvent):
     """
     Emitted when creating a torrent file remotely.
     """
+
     def __init__(self, piece_count, num_pieces):
         self._args = [piece_count, num_pieces]
 
+
 class NewVersionAvailableEvent(DelugeEvent):
     """
     Emitted when a more recent version of Deluge is available.
     """
+
     def __init__(self, new_release):
         """
         :param new_release: the new version that is available
@@ -215,29 +244,37 @@ class NewVersionAvailableEvent(DelugeEvent):
         """
         self._args = [new_release]
 
+
 class SessionStartedEvent(DelugeEvent):
     """
     Emitted when a session has started.  This typically only happens once when
     the daemon is initially started.
     """
+
     pass
 
+
 class SessionPausedEvent(DelugeEvent):
     """
     Emitted when the session has been paused.
     """
+
     pass
 
+
 class SessionResumedEvent(DelugeEvent):
     """
     Emitted when the session has been resumed.
     """
+
     pass
 
+
 class ConfigValueChangedEvent(DelugeEvent):
     """
     Emitted when a config value changes in the Core.
     """
+
     def __init__(self, key, value):
         """
         :param key: the key that changed
@@ -246,17 +283,42 @@ class ConfigValueChangedEvent(DelugeEvent):
         """
         self._args = [key, value]
 
+
 class PluginEnabledEvent(DelugeEvent):
     """
     Emitted when a plugin is enabled in the Core.
     """
+
     def __init__(self, plugin_name):
         self._args = [plugin_name]
 
+
 class PluginDisabledEvent(DelugeEvent):
     """
     Emitted when a plugin is disabled in the Core.
     """
+
     def __init__(self, plugin_name):
         self._args = [plugin_name]
 
+
+class ClientDisconnectedEvent(DelugeEvent):
+    """
+    Emitted when a client disconnects.
+    """
+
+    def __init__(self, session_id):
+        self._args = [session_id]
+
+
+class ExternalIPEvent(DelugeEvent):
+    """
+    Emitted when the external ip address is received from libtorrent.
+    """
+
+    def __init__(self, external_ip):
+        """
+        Args:
+            external_ip (str): The IP address.
+        """
+        self._args = [external_ip]

deluge/httpdownloader.py

@@ -1,207 +1,330 @@
-#
-# httpdownloader.py
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2009 Andrew Resch <andrewresch@gmail.com>
 #
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
 
-from twisted.web import client, http
-from twisted.web.error import PageRedirect
-from twisted.python.failure import Failure
-from twisted.internet import reactor
-from common import get_version
+from __future__ import unicode_literals
+
+import cgi
 import logging
 import os.path
 import zlib
 
+from twisted.internet import reactor
+from twisted.internet.defer import Deferred
+from twisted.python.failure import Failure
+from twisted.web import client, http
+from twisted.web._newclient import HTTPClientParser
+from twisted.web.error import PageRedirect
+from twisted.web.http_headers import Headers
+from twisted.web.iweb import IAgent
+from zope.interface import implementer
+
+from deluge.common import get_version
+
 log = logging.getLogger(__name__)
 
-class HTTPDownloader(client.HTTPDownloader):
-    """
-    Factory class for downloading files and keeping track of progress.
-    """
-    def __init__(self, url, filename, part_callback=None, headers=None,
-                 force_filename=False, allow_compression=True):
+
+class CompressionDecoder(client.GzipDecoder):
+    """A compression decoder for gzip, x-gzip and deflate."""
+
+    def deliverBody(self, protocol):  # NOQA: N802
+        self.original.deliverBody(CompressionDecoderProtocol(protocol, self.original))
+
+
+class CompressionDecoderProtocol(client._GzipProtocol):
+    """A compression decoder protocol for CompressionDecoder."""
+
+    def __init__(self, protocol, response):
+        super(CompressionDecoderProtocol, self).__init__(protocol, response)
+        self._zlibDecompress = zlib.decompressobj(32 + zlib.MAX_WBITS)
+
+
+class BodyHandler(HTTPClientParser, object):
+    """An HTTP parser that saves the response to a file."""
+
+    def __init__(self, request, finished, length, agent, encoding=None):
+        """BodyHandler init.
+
+        Args:
+            request (t.w.i.IClientRequest): The parser request.
+            finished (Deferred): A Deferred to handle the finished response.
+            length (int): The length of the response.
+            agent (t.w.i.IAgent): The agent from which the request was sent.
         """
-        :param url: the url to download from
-        :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
-        :param headers: any optional headers to send
-        :type headers: dictionary
-        """
-        self.part_callback = part_callback
+        super(BodyHandler, self).__init__(request, finished)
+        self.agent = agent
+        self.finished = finished
+        self.total_length = length
         self.current_length = 0
-        self.decoder = None
-        self.value = filename
+        self.data = b''
+        self.encoding = encoding
+
+    def dataReceived(self, data):  # NOQA: N802
+        self.current_length += len(data)
+        self.data += data
+        if self.agent.part_callback:
+            self.agent.part_callback(data, self.current_length, self.total_length)
+
+    def connectionLost(self, reason):  # NOQA: N802
+        if self.encoding:
+            self.data = self.data.decode(self.encoding).encode('utf8')
+        with open(self.agent.filename, 'wb') as _file:
+            _file.write(self.data)
+        self.finished.callback(self.agent.filename)
+        self.state = u'DONE'
+        HTTPClientParser.connectionLost(self, reason)
+
+
+@implementer(IAgent)
+class HTTPDownloaderAgent(object):
+    """A File Downloader Agent."""
+
+    def __init__(
+        self,
+        agent,
+        filename,
+        part_callback=None,
+        force_filename=False,
+        allow_compression=True,
+        handle_redirect=True,
+    ):
+        """HTTPDownloaderAgent init.
+
+        Args:
+            agent (t.w.c.Agent): The agent which will send the requests.
+            filename (str): The filename to save the file as.
+            force_filename (bool): Forces use of the supplied filename,
+                regardless of header content.
+            part_callback (func): A function to be called when a part of data
+                is received, it's signature should be:
+                    func(data, current_length, total_length)
+        """
+
+        self.handle_redirect = handle_redirect
+        self.agent = agent
+        self.filename = filename
+        self.part_callback = part_callback
         self.force_filename = force_filename
         self.allow_compression = allow_compression
-        agent = "Deluge/%s (http://deluge-torrent.org)" % get_version()
-        client.HTTPDownloader.__init__(self, url, filename, headers=headers, agent=agent)
+        self.decoder = None
 
-    def gotStatus(self, version, status, message):
-        self.code = int(status)
-        client.HTTPDownloader.gotStatus(self, version, status, message)
+    def request_callback(self, response):
+        finished = Deferred()
 
-    def gotHeaders(self, headers):
-        if self.code == http.OK:
-            if "content-length" in headers:
-                self.total_length = int(headers["content-length"][0])
-            else:
-                self.total_length = 0
+        if not self.handle_redirect and response.code in (
+            http.MOVED_PERMANENTLY,
+            http.FOUND,
+            http.SEE_OTHER,
+            http.TEMPORARY_REDIRECT,
+        ):
+            location = response.headers.getRawHeaders(b'location')[0]
+            error = PageRedirect(response.code, location=location)
+            finished.errback(Failure(error))
+        else:
+            headers = response.headers
+            body_length = int(headers.getRawHeaders(b'content-length', default=[0])[0])
 
-            if self.allow_compression and "content-encoding" in headers and \
-               headers["content-encoding"][0] in ("gzip", "x-gzip", "deflate"):
-                # Adding 32 to the wbits enables gzip & zlib decoding (with automatic header detection)
-                # Adding 16 just enables gzip decoding (no zlib)
-                self.decoder = zlib.decompressobj(zlib.MAX_WBITS + 32)
+            if headers.hasHeader(b'content-disposition') and not self.force_filename:
+                content_disp = headers.getRawHeaders(b'content-disposition')[0].decode(
+                    'utf-8'
+                )
+                content_disp_params = cgi.parse_header(content_disp)[1]
+                if 'filename' in content_disp_params:
+                    new_file_name = content_disp_params['filename']
+                    new_file_name = sanitise_filename(new_file_name)
+                    new_file_name = os.path.join(
+                        os.path.split(self.filename)[0], new_file_name
+                    )
 
-            if "content-disposition" in headers and not self.force_filename:
-                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
 
-                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.fileName = new_file_name
-                self.value = new_file_name
+            cont_type = headers.getRawHeaders(b'content-type')[0].decode()
+            params = cgi.parse_header(cont_type)[1]
+            encoding = params.get('charset', None)
+            response.deliverBody(
+                BodyHandler(response.request, finished, body_length, self, encoding)
+            )
 
-        elif self.code in (http.MOVED_PERMANENTLY, http.FOUND, http.SEE_OTHER, http.TEMPORARY_REDIRECT):
-            location = headers["location"][0]
-            error = PageRedirect(self.code, location=location)
-            self.noPage(Failure(error))
+        return finished
 
-        return client.HTTPDownloader.gotHeaders(self, headers)
+    def request(self, method, uri, headers=None, body_producer=None):
+        """Issue a new request to the wrapped agent.
 
-    def pagePart(self, data):
-        if self.code == http.OK:
-            self.current_length += len(data)
-            if self.decoder:
-                data = self.decoder.decompress(data)
-            if self.part_callback:
-                self.part_callback(data, self.current_length, self.total_length)
+        Args:
+            method (bytes): The HTTP method to use.
+            uri (bytes): The url to download from.
+            headers (t.w.h.Headers, optional): Any extra headers to send.
+            body_producer (t.w.i.IBodyProducer, optional): Request body data.
 
-        return client.HTTPDownloader.pagePart(self, data)
+        Returns:
+            Deferred: The filename of the of the downloaded file.
+        """
+        if headers is None:
+            headers = Headers()
 
-    def pageEnd(self):
-        if self.decoder:
-            data = self.decoder.flush()
-            self.current_length -= len(data)
-            self.decoder = None
-            self.pagePart(data)
+        if not headers.hasHeader(b'User-Agent'):
+            version = get_version()
+            user_agent = 'Deluge/%s (https://deluge-torrent.org)' % version
+            headers.addRawHeader('User-Agent', user_agent)
+
+        d = self.agent.request(
+            method=method, uri=uri, headers=headers, bodyProducer=body_producer
+        )
+        d.addCallback(self.request_callback)
+        return d
 
-        return client.HTTPDownloader.pageEnd(self)
 
 def sanitise_filename(filename):
-    """
-    Sanitises a filename to use as a download destination file.
+    """Sanitises a filename to use as a download destination file.
+
     Logs any filenames that could be considered malicious.
 
-    :param filename: the filename to sanitise
-    :type filename: string
-    :returns: the sanitised filename
-    :rtype: string
+    filename (str): The filename to sanitise.
+
+    Returns:
+        str: The sanitised filename.
     """
 
     # Remove any quotes
-    filename = filename.strip("'\"")
+    filename = filename.strip('\'"')
 
     if os.path.basename(filename) != filename:
         # Dodgy server, log it
-        log.warning("Potentially malicious server: trying to write to file '%s'" % filename)
+        log.warning(
+            'Potentially malicious server: trying to write to file: %s', filename
+        )
         # Only use the basename
         filename = os.path.basename(filename)
 
     filename = filename.strip()
-    if filename.startswith(".") or ";" in filename or "|" in filename:
+    if filename.startswith('.') or ';' in filename or '|' in filename:
         # Dodgy server, log it
-        log.warning("Potentially malicious server: trying to write to file '%s'" % filename)
+        log.warning(
+            'Potentially malicious server: trying to write to file: %s', filename
+        )
 
     return filename
 
-def download_file(url, filename, callback=None, headers=None,
-                  force_filename=False, allow_compression=True):
+
+def _download_file(
+    url,
+    filename,
+    callback=None,
+    headers=None,
+    force_filename=False,
+    allow_compression=True,
+    handle_redirects=True,
+):
+    """Downloads a file from a specific URL and returns a Deferred.
+
+    A callback function can be specified to be called as parts are received.
+
+    Args:
+        url (str): The url to download from.
+        filename (str): The filename to save the file as.
+        callback (func): A function to be called when partial data is received,
+            it's signature should be: func(data, current_length, total_length)
+        headers (dict): Any optional headers to send.
+        force_filename (bool): Force using the filename specified rather than
+            one the server may suggest.
+        allow_compression (bool): Allows gzip & deflate decoding.
+
+    Returns:
+        Deferred: The filename of the downloaded file.
+
+    Raises:
+        t.w.e.PageRedirect
+        t.w.e.Error: for all other HTTP response errors
     """
-    Downloads a file from a specific URL and returns a Deferred.  You can also
-    specify a callback function to be called as parts are received.
 
-    :param url: the url to download from
-    :type url: string
-    :param filename: the filename to save the file as
-    :type filename: string
-    :param 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 callback: function
-    :param headers: any optional headers to send
-    :type headers: dictionary
-    :param force_filename: force us to use the filename specified rather than
-                           one the server may suggest
-    :type force_filename: boolean
-    :param allow_compression: allows gzip & deflate decoding
-    :type allow_compression: boolean
-
-    :returns: the filename of the downloaded file
-    :rtype: Deferred
-
-    :raises t.w.e.PageRedirect: when server responds with a temporary redirect
-         or permanently moved.
-    :raises t.w.e.Error: for all other HTTP response errors (besides OK)
-    """
-    url = str(url)
-    filename = str(filename)
-    if headers:
-        for key, value in headers.items():
-            headers[str(key)] = str(value)
+    agent = client.Agent(reactor)
 
     if allow_compression:
-        if not headers:
-            headers = {}
-        headers["accept-encoding"] = "deflate, gzip, x-gzip"
+        enc_accepted = ['gzip', 'x-gzip', 'deflate']
+        decoders = [(enc.encode(), CompressionDecoder) for enc in enc_accepted]
+        agent = client.ContentDecoderAgent(agent, decoders)
+    if handle_redirects:
+        agent = client.RedirectAgent(agent)
 
-    scheme, host, port, path = client._parse(url)
-    factory = HTTPDownloader(url, filename, callback, headers, force_filename, allow_compression)
-    if scheme == "https":
-        from twisted.internet import ssl
-        reactor.connectSSL(host, port, factory, ssl.ClientContextFactory())
-    else:
-        reactor.connectTCP(host, port, factory)
+    agent = HTTPDownloaderAgent(
+        agent, filename, callback, force_filename, allow_compression, handle_redirects
+    )
 
-    return factory.deferred
+    # The Headers init expects dict values to be a list.
+    if headers:
+        for name, value in list(headers.items()):
+            if not isinstance(value, list):
+                headers[name] = [value]
+
+    return agent.request(b'GET', url.encode(), Headers(headers))
+
+
+def download_file(
+    url,
+    filename,
+    callback=None,
+    headers=None,
+    force_filename=False,
+    allow_compression=True,
+    handle_redirects=True,
+):
+    """Downloads a file from a specific URL and returns a Deferred.
+
+    A callback function can be specified to be called as parts are received.
+
+    Args:
+        url (str): The url to download from.
+        filename (str): The filename to save the file as.
+        callback (func): A function to be called when partial data is received,
+            it's signature should be: func(data, current_length, total_length).
+        headers (dict): Any optional headers to send.
+        force_filename (bool): Force the filename specified rather than one the
+            server may suggest.
+        allow_compression (bool): Allows gzip & deflate decoding.
+        handle_redirects (bool): HTTP redirects handled automatically or not.
+
+    Returns:
+        Deferred: The filename of the downloaded file.
+
+    Raises:
+        t.w.e.PageRedirect: If handle_redirects is False.
+        t.w.e.Error: For all other HTTP response errors.
+    """
+
+    def on_download_success(result):
+        log.debug('Download success!')
+        return result
+
+    def on_download_fail(failure):
+        log.warning(
+            'Error occurred downloading file from "%s": %s',
+            url,
+            failure.getErrorMessage(),
+        )
+        result = failure
+        return result
+
+    d = _download_file(
+        url,
+        filename,
+        callback=callback,
+        headers=headers,
+        force_filename=force_filename,
+        allow_compression=allow_compression,
+        handle_redirects=handle_redirects,
+    )
+    d.addCallbacks(on_download_success, on_download_fail)
+    return d

deluge/i18n/__init__.py

@@ -0,0 +1,15 @@
+from .util import (
+    I18N_DOMAIN,
+    get_languages,
+    set_language,
+    setup_mock_translation,
+    setup_translation,
+)
+
+__all__ = [
+    'I18N_DOMAIN',
+    'set_language',
+    'get_languages',
+    'setup_translation',
+    'setup_mock_translation',
+]

deluge/i18n/languages.py

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+#
+# This file is public domain.
+#
+
+from __future__ import unicode_literals
+
+# Language code for this installation. All choices can be found here:
+# http://www.i18nguy.com/unicode/language-identifiers.html
+LANGUAGE_CODE = 'en-us'
+
+
+# Deferred translation
+def _(message):
+    return message
+
+
+# Languages we provide translations for, out of the box.
+LANGUAGES = {
+    'af': _('Afrikaans'),
+    'ar': _('Arabic'),
+    'ast': _('Asturian'),
+    'az': _('Azerbaijani'),
+    'bg': _('Bulgarian'),
+    'be': _('Belarusian'),
+    'bn': _('Bengali'),
+    'br': _('Breton'),
+    'bs': _('Bosnian'),
+    'ca': _('Catalan'),
+    'cs': _('Czech'),
+    'cy': _('Welsh'),
+    'da': _('Danish'),
+    'de': _('German'),
+    'el': _('Greek'),
+    'en': _('English'),
+    'en_AU': _('English (Australia)'),
+    'en_CA': _('English (Canada)'),
+    'en_GB': _('English (United Kingdom)'),
+    'eo': _('Esperanto'),
+    'es': _('Spanish'),
+    'es-ar': _('Argentinian Spanish'),
+    'es-mx': _('Mexican Spanish'),
+    'es-ni': _('Nicaraguan Spanish'),
+    'es-ve': _('Venezuelan Spanish'),
+    'et': _('Estonian'),
+    'eu': _('Basque'),
+    'fa': _('Persian'),
+    'fi': _('Finnish'),
+    'fr': _('French'),
+    'fy': _('Frisian'),
+    'ga': _('Irish'),
+    'gl': _('Galician'),
+    'he': _('Hebrew'),
+    'hi': _('Hindi'),
+    'hr': _('Croatian'),
+    'hu': _('Hungarian'),
+    'ia': _('Interlingua'),
+    'id': _('Indonesian'),
+    'is': _('Icelandic'),
+    'it': _('Italian'),
+    'iu': _('Inuktitut'),
+    'ja': _('Japanese'),
+    'ka': _('Georgian'),
+    'kk': _('Kazakh'),
+    'km': _('Khmer'),
+    'kn': _('Kannada'),
+    'ko': _('Korean'),
+    'ku': _('Kurdish'),
+    'la': _('Latin'),
+    'lb': _('Luxembourgish'),
+    'lt': _('Lithuanian'),
+    'lv': _('Latvian'),
+    'mk': _('Macedonian'),
+    'ml': _('Malayalam'),
+    'mn': _('Mongolian'),
+    'ms': _('Mayaly'),
+    'my': _('Burmese'),
+    'nb': _('Norwegian Bokmal'),
+    'ne': _('Nepali'),
+    'nds': _('Low German'),
+    'nl': _('Dutch'),
+    'nn': _('Norwegian Nynorsk'),
+    'os': _('Ossetic'),
+    'pa': _('Punjabi'),
+    'pl': _('Polish'),
+    'pms': _('Piedmontese'),
+    'pt': _('Portuguese'),
+    'pt_BR': _('Brazilian Portuguese'),
+    'ro': _('Romanian'),
+    'ru': _('Russian'),
+    'sk': _('Slovak'),
+    'sl': _('Slovenian'),
+    'si': _('Sinhalese'),
+    'sq': _('Albanian'),
+    'sr': _('Serbian'),
+    'sr-latn': _('Serbian Latin'),
+    'sv': _('Swedish'),
+    'sw': _('Swahili'),
+    'ta': _('Tamil'),
+    'te': _('Telugu'),
+    'th': _('Thai'),
+    'tl': _('Tagalog'),
+    'tlh': _('Klingon'),
+    'tr': _('Turkish'),
+    'tt': _('Tatar'),
+    'udm': _('Udmurt'),
+    'uk': _('Ukrainian'),
+    'ur': _('Urdu'),
+    'vi': _('Vietnamese'),
+    'zh_CN': _('Chinese (Simplified)'),
+    'zh_HK': _('Chinese (Hong Kong)'),
+    'zh-hans': _('Simplified Chinese'),
+    'zh-hant': _('Traditional Chinese'),
+    'zh_TW': _('Chinese (Taiwan)'),
+}
+
+del _

deluge/i18n/util.py

@@ -0,0 +1,150 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2007,2008 Andrew Resch <andrewresch@gmail.com>
+#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
+#
+
+from __future__ import unicode_literals
+
+import ctypes
+import gettext
+import locale
+import logging
+import os
+import sys
+from glob import glob
+
+from six.moves import builtins
+
+import deluge.common
+
+from .languages import LANGUAGES
+
+log = logging.getLogger(__name__)
+
+I18N_DOMAIN = 'deluge'
+
+
+def get_translations_path():
+    """Get the absolute path to the directory containing translation files"""
+    return deluge.common.resource_filename('deluge', 'i18n')
+
+
+def get_languages():
+    lang = []
+
+    translations_path = get_translations_path()
+    lc_messages_path = os.path.join('LC_MESSAGES', I18N_DOMAIN + '.mo')
+    for root, dirs, files in os.walk(translations_path):
+        # Get the dirs
+        lang_dirs = [
+            lang_dir
+            for lang_dir in dirs
+            if glob(os.path.join(translations_path, lang_dir, lc_messages_path))
+        ]
+        break
+    else:
+        return lang
+
+    for i, lang_code in enumerate(lang_dirs):
+        name = '%s (Language name missing)' % lang_code
+        if lang_code in LANGUAGES:
+            name = LANGUAGES[lang_code]
+        lang.append([lang_code, _(name)])
+
+    lang = sorted(lang, key=lambda l: l[1])
+    return lang
+
+
+def set_language(lang):
+    """
+    Set the language to use.
+
+    gettext and GtkBuilder will load the translations from the specified
+    language.
+
+    :param lang: the language, e.g. "en", "de" or "en_GB"
+    :type lang: str
+    """
+    # Necessary to set these environment variables for GtkBuilder
+    deluge.common.set_env_variable('LANGUAGE', lang)  # Windows/Linux
+    deluge.common.set_env_variable('LANG', lang)  # For OSX
+
+    translations_path = get_translations_path()
+    try:
+        ro = gettext.translation(
+            'deluge', localedir=translations_path, languages=[lang]
+        )
+        ro.install()
+    except IOError as ex:
+        log.warning('IOError when loading translations: %s', ex)
+
+
+def setup_mock_translation(warn_msg=None):
+    def _func(*txt):
+        if warn_msg:
+            log.warning(
+                '"%s" has been marked for translation, but translation is unavailable.',
+                txt[0],
+            )
+        return txt[0]
+
+    builtins.__dict__['_'] = _func
+    builtins.__dict__['ngettext'] = builtins.__dict__['_n'] = _func
+
+
+# Initialize gettext
+def setup_translation():
+    translations_path = get_translations_path()
+    log.info('Setting up translations from %s', translations_path)
+
+    try:
+        if hasattr(locale, 'bindtextdomain'):
+            locale.bindtextdomain(I18N_DOMAIN, translations_path)
+        if hasattr(locale, 'textdomain'):
+            locale.textdomain(I18N_DOMAIN)
+
+        gettext.bindtextdomain(I18N_DOMAIN, translations_path)
+        gettext.bind_textdomain_codeset(I18N_DOMAIN, 'UTF-8')
+        gettext.textdomain(I18N_DOMAIN)
+
+        # Workaround for Python 2 unicode gettext (keyword removed in Py3).
+        kwargs = {} if not deluge.common.PY2 else {'unicode': True}
+
+        gettext.install(I18N_DOMAIN, translations_path, names='ngettext', **kwargs)
+        builtins.__dict__['_n'] = builtins.__dict__['ngettext']
+
+        libintl = None
+        if deluge.common.windows_check():
+            for intl in ('libintl-8.dll', 'intl.dll'):
+                try:
+                    libintl = ctypes.cdll.LoadLibrary(intl)
+                except OSError as ex:
+                    exception = ex
+                else:
+                    break
+                finally:
+                    if not libintl:
+                        log.error('Unable to initialize gettext/locale!')
+                        log.error(exception)
+                        setup_mock_translation()
+        elif deluge.common.osx_check():
+            libintl = ctypes.cdll.LoadLibrary('libintl.dylib')
+
+        if libintl:
+            libintl.bindtextdomain(
+                I18N_DOMAIN, translations_path.encode(sys.getfilesystemencoding())
+            )
+            libintl.textdomain(I18N_DOMAIN)
+            libintl.bind_textdomain_codeset(I18N_DOMAIN, 'UTF-8')
+            libintl.gettext.restype = ctypes.c_char_p
+
+    except Exception as ex:
+        log.error('Unable to initialize gettext/locale!')
+        log.exception(ex)
+        setup_mock_translation()
+
+    deluge.common.translate_size_units()

deluge/log.py

@@ -1,61 +1,43 @@
-#
-# log.py
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2007 Andrew Resch <andrewresch@gmail.com>
 # Copyright (C) 2010 Pedro Algarvio <pedro@algarvio.me>
 #
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
 
 """Logging functions"""
+from __future__ import unicode_literals
 
-import os
 import inspect
 import logging
-from deluge import common
+import logging.handlers
+import os
+import sys
+
 from twisted.internet import defer
 from twisted.python.log import PythonLoggingObserver
 
-__all__ = ["setupLogger", "setLoggerLevel", "getPluginLogger", "LOG"]
+from deluge import common
+
+__all__ = ('setup_logger', 'set_logger_level', 'get_plugin_logger', 'LOG')
 
 LoggingLoggerClass = logging.getLoggerClass()
 
 if 'dev' in common.get_version():
-    DEFAULT_LOGGING_FORMAT = "%%(asctime)s.%%(msecs)03.0f [%%(levelname)-8s][%%(name)-%ds:%%(lineno)-4d] %%(message)s"
+    DEFAULT_LOGGING_FORMAT = '%%(asctime)s.%%(msecs)03.0f [%%(levelname)-8s][%%(name)-%ds:%%(lineno)-4d] %%(message)s'
 else:
-    DEFAULT_LOGGING_FORMAT = "%%(asctime)s [%%(levelname)-8s][%%(name)-%ds] %%(message)s"
+    DEFAULT_LOGGING_FORMAT = (
+        '%%(asctime)s [%%(levelname)-8s][%%(name)-%ds:%%(lineno)-4d] %%(message)s'
+    )
 MAX_LOGGER_NAME_LENGTH = 10
 
+
 class Logging(LoggingLoggerClass):
     def __init__(self, logger_name):
-        LoggingLoggerClass.__init__(self, logger_name)
+        super(Logging, self).__init__(logger_name)
 
         # This makes module name padding increase to the biggest module name
         # so that logs keep readability.
@@ -63,10 +45,12 @@ class Logging(LoggingLoggerClass):
         if len(logger_name) > MAX_LOGGER_NAME_LENGTH:
             MAX_LOGGER_NAME_LENGTH = len(logger_name)
             for handler in logging.getLogger().handlers:
-                handler.setFormatter(logging.Formatter(
-                    DEFAULT_LOGGING_FORMAT % MAX_LOGGER_NAME_LENGTH,
-                    datefmt="%H:%M:%S"
-                ))
+                handler.setFormatter(
+                    logging.Formatter(
+                        DEFAULT_LOGGING_FORMAT % MAX_LOGGER_NAME_LENGTH,
+                        datefmt='%H:%M:%S',
+                    )
+                )
 
     @defer.inlineCallbacks
     def garbage(self, msg, *args, **kwargs):
@@ -102,84 +86,127 @@ class Logging(LoggingLoggerClass):
     def exception(self, msg, *args, **kwargs):
         yield LoggingLoggerClass.exception(self, msg, *args, **kwargs)
 
-    def findCaller(self):
+    def findCaller(self, stack_info=False):  # NOQA: N802
         f = logging.currentframe().f_back
-        rv = "(unknown file)", 0, "(unknown function)"
-        while hasattr(f, "f_code"):
+        rv = '(unknown file)', 0, '(unknown function)'
+        while hasattr(f, 'f_code'):
             co = f.f_code
             filename = os.path.normcase(co.co_filename)
-            if filename in (__file__.replace('.pyc', '.py'),
-                            defer.__file__.replace('.pyc', '.py')):
+            if filename in (
+                __file__.replace('.pyc', '.py'),
+                defer.__file__.replace('.pyc', '.py'),
+            ):
                 f = f.f_back
                 continue
-            rv = (filename, f.f_lineno, co.co_name)
+            if common.PY2:
+                rv = (filename, f.f_lineno, co.co_name)
+            else:
+                rv = (filename, f.f_lineno, co.co_name, None)
             break
         return rv
 
+
 levels = {
-    "none": logging.NOTSET,
-    "info": logging.INFO,
-    "warn": logging.WARNING,
-    "warning": logging.WARNING,
-    "error": logging.ERROR,
-    "none": logging.CRITICAL,
-    "debug": logging.DEBUG,
-    "trace": 5,
-    "garbage": 1
+    'info': logging.INFO,
+    'warn': logging.WARNING,
+    'warning': logging.WARNING,
+    'error': logging.ERROR,
+    'none': logging.CRITICAL,
+    'debug': logging.DEBUG,
+    'trace': 5,
+    'garbage': 1,
 }
 
 
-def setupLogger(level="error", filename=None, filemode="w"):
+def setup_logger(
+    level='error',
+    filename=None,
+    filemode='w',
+    logrotate=None,
+    output_stream=sys.stdout,
+    twisted_observer=True,
+):
     """
     Sets up the basic logger and if `:param:filename` is set, then it will log
     to that file instead of stdout.
 
-    :param level: str, the level to log
-    :param filename: str, the file to log to
+    Args:
+        level (str): The log level to use (Default: 'error')
+        filename (str, optional): The log filename. Default is None meaning log
+                                  to terminal
+        filemode (str): The filemode to use when opening the log file
+        logrotate (int, optional): The size of the logfile in bytes when enabling
+                                   log rotation (Default is None meaning disabled)
+        output_stream (file descriptor): File descriptor to log to if not logging to file
+        twisted_observer (bool): Whether to setup the custom twisted logging observer.
     """
-    import logging
-
     if logging.getLoggerClass() is not Logging:
         logging.setLoggerClass(Logging)
-        logging.addLevelName(5, 'TRACE')
-        logging.addLevelName(1, 'GARBAGE')
+        logging.addLevelName(levels['trace'], 'TRACE')
+        logging.addLevelName(levels['garbage'], 'GARBAGE')
 
     level = levels.get(level, logging.ERROR)
 
-    rootLogger = logging.getLogger()
+    root_logger = logging.getLogger()
 
-    if filename and filemode=='a':
-        import logging.handlers
+    if filename and logrotate:
         handler = logging.handlers.RotatingFileHandler(
-            filename, filemode,
-            maxBytes=50*1024*1024,   # 50 Mb
-            backupCount=3,
-            encoding='utf-8',
-            delay=0
-        )
-    elif filename and filemode=='w':
-        import logging.handlers
-        handler = getattr(
-            logging.handlers, 'WatchedFileHandler', logging.FileHandler)(
-                filename, filemode, 'utf-8', delay=0
+            filename, maxBytes=logrotate, backupCount=5, encoding='utf-8'
         )
+    elif filename and filemode == 'w':
+        handler_cls = logging.FileHandler
+        if not common.windows_check():
+            handler_cls = getattr(
+                logging.handlers, 'WatchedFileHandler', logging.FileHandler
+            )
+        handler = handler_cls(filename, mode=filemode, encoding='utf-8')
     else:
-        handler = logging.StreamHandler()
+        handler = logging.StreamHandler(stream=output_stream)
 
     handler.setLevel(level)
 
     formatter = logging.Formatter(
-        DEFAULT_LOGGING_FORMAT % MAX_LOGGER_NAME_LENGTH,
-        datefmt="%H:%M:%S"
+        DEFAULT_LOGGING_FORMAT % MAX_LOGGER_NAME_LENGTH, datefmt='%H:%M:%S'
     )
 
     handler.setFormatter(formatter)
-    rootLogger.addHandler(handler)
-    rootLogger.setLevel(level)
 
-    twisted_logging = PythonLoggingObserver('twisted')
-    twisted_logging.start()
-    logging.getLogger("twisted").setLevel(level)
+    # Check for existing handler to prevent duplicate logging.
+    if root_logger.handlers:
+        for handle in root_logger.handlers:
+            if not isinstance(handle, type(handler)):
+                root_logger.addHandler(handler)
+    else:
+        root_logger.addHandler(handler)
+    root_logger.setLevel(level)
+
+    if twisted_observer:
+        twisted_logging = TwistedLoggingObserver()
+        twisted_logging.start()
+
+
+class TwistedLoggingObserver(PythonLoggingObserver):
+    """
+    Custom logging class to fix missing exception tracebacks in log output with new
+    twisted.logger module in twisted version >= 15.2.
+
+    Related twisted bug ticket: https://twistedmatrix.com/trac/ticket/7927
+
+    """
+
+    def __init__(self):
+        PythonLoggingObserver.__init__(self, loggerName='twisted')
+
+    def emit(self, event_dict):
+        log = logging.getLogger(__name__)
+        if 'log_failure' in event_dict:
+            fmt = '%(log_namespace)s \n%(log_failure)s'
+            getattr(LoggingLoggerClass, event_dict['log_level'].name)(
+                log, fmt % (event_dict)
+            )
+        else:
+            PythonLoggingObserver.emit(self, event_dict)
+
 
 def tweak_logging_levels():
     """This function allows tweaking the logging levels for all or some loggers.
@@ -200,62 +227,69 @@ def tweak_logging_levels():
     the command line.
     """
     from deluge import configmanager
-    logging_config_file = os.path.join(configmanager.get_config_dir(),
-                                       'logging.conf')
+
+    logging_config_file = os.path.join(configmanager.get_config_dir(), 'logging.conf')
     if not os.path.isfile(logging_config_file):
         return
     log = logging.getLogger(__name__)
-    log.warn("logging.conf found! tweaking logging levels from %s",
-             logging_config_file)
-    for line in open(logging_config_file, 'r').readlines():
-        if line.strip().startswith("#"):
-            continue
-        name, level = line.strip().split(':')
-        if level not in levels:
-            continue
+    log.warning(
+        'logging.conf found! tweaking logging levels from %s', logging_config_file
+    )
+    with open(logging_config_file, 'r') as _file:
+        for line in _file:
+            if line.strip().startswith('#'):
+                continue
+            name, level = line.strip().split(':')
+            if level not in levels:
+                continue
 
-        log.warn("Setting logger \"%s\" to logging level \"%s\"", name, level)
-        setLoggerLevel(level, name)
+            log.warning('Setting logger "%s" to logging level "%s"', name, level)
+            set_logger_level(level, name)
 
 
-def setLoggerLevel(level, logger_name=None):
+def set_logger_level(level, logger_name=None):
     """
     Sets the logger level.
 
     :param level: str, a string representing the desired level
     :param logger_name: str, a string representing desired logger name for which
-                        the level should change. The default is "None" will will
-                        tweak the root logger level.
+                        the level should change. The default is "None" will tweak
+                        the root logger level.
 
     """
-    logging.getLogger(logger_name).setLevel(levels.get(level, "error"))
+    logging.getLogger(logger_name).setLevel(levels.get(level, 'error'))
 
 
-def getPluginLogger(logger_name):
+def get_plugin_logger(logger_name):
     import warnings
+
     stack = inspect.stack()
-    stack.pop(0)                # The logging call from this module
-    module_stack = stack.pop(0) # The module that called the log function
+    stack.pop(0)  # The logging call from this module
+    module_stack = stack.pop(0)  # The module that called the log function
     caller_module = inspect.getmodule(module_stack[0])
     # In some weird cases caller_module might be None, try to continue
     caller_module_name = getattr(caller_module, '__name__', '')
-    warnings.warn_explicit(DEPRECATION_WARNING, DeprecationWarning,
-                           module_stack[1], module_stack[2],
-                            caller_module_name)
+    warnings.warn_explicit(
+        DEPRECATION_WARNING,
+        DeprecationWarning,
+        module_stack[1],
+        module_stack[2],
+        caller_module_name,
+    )
 
     if 'deluge.plugins.' in logger_name:
         return logging.getLogger(logger_name)
-    return logging.getLogger("deluge.plugin.%s" % logger_name)
+    return logging.getLogger('deluge.plugin.%s' % logger_name)
 
 
 DEPRECATION_WARNING = """You seem to be using old style logging on your code, ie:
     from deluge.log import LOG as log
 
 or:
-    from deluge.log import getPluginLogger
+    from deluge.log import get_plugin_logger
 
 This has been deprecated in favour of an enhanced logging system and both "LOG"
-and "getPluginLogger" will be removed on the next major version release of Deluge,
+and "get_plugin_logger" will be removed on the next major version release of Deluge,
 meaning, code will break, specially plugins.
 If you're seeing this message and you're not the developer of the plugin which
 triggered this warning, please report to it's author.
@@ -268,28 +302,37 @@ If you're the developer, please stop using the above code and instead use:
 The above will result in, regarding the "Label" plugin for example a log message similar to:
    15:33:54 [deluge.plugins.label.core:78  ][INFO    ] *** Start Label plugin ***
 
-Triggering code:"""
+Triggering code:
+"""
 
-class __BackwardsCompatibleLOG(object):
+
+class _BackwardsCompatibleLOG(object):
     def __getattribute__(self, name):
         import warnings
+
         logger_name = 'deluge'
         stack = inspect.stack()
-        stack.pop(0)                # The logging call from this module
-        module_stack = stack.pop(0) # The module that called the log function
+        stack.pop(0)  # The logging call from this module
+        module_stack = stack.pop(0)  # The module that called the log function
         caller_module = inspect.getmodule(module_stack[0])
         # In some weird cases caller_module might be None, try to continue
         caller_module_name = getattr(caller_module, '__name__', '')
-        warnings.warn_explicit(DEPRECATION_WARNING, DeprecationWarning,
-                               module_stack[1], module_stack[2],
-                               caller_module_name)
+        warnings.warn_explicit(
+            DEPRECATION_WARNING,
+            DeprecationWarning,
+            module_stack[1],
+            module_stack[2],
+            caller_module_name,
+        )
         if caller_module:
             for member in stack:
                 module = inspect.getmodule(member[0])
                 if not module:
                     continue
-                if module.__name__ in ('deluge.plugins.pluginbase',
-                                       'deluge.plugins.init'):
+                if module.__name__ in (
+                    'deluge.plugins.pluginbase',
+                    'deluge.plugins.init',
+                ):
                     logger_name += '.plugin.%s' % caller_module_name
                     # Monkey Patch The Plugin Module
                     caller_module.log = logging.getLogger(logger_name)
@@ -297,8 +340,9 @@ class __BackwardsCompatibleLOG(object):
         else:
             logging.getLogger(logger_name).warning(
                 "Unable to monkey-patch the calling module's `log` attribute! "
-                "You should really update and rebuild your plugins..."
+                'You should really update and rebuild your plugins...'
             )
         return getattr(logging.getLogger(logger_name), name)
 
-LOG = __BackwardsCompatibleLOG()
+
+LOG = _BackwardsCompatibleLOG()

deluge/main.py

@@ -1,278 +0,0 @@
-#
-# main.py
-#
-# Copyright (C) 2007 Andrew Resch <andrewresch@gmail.com>
-# Copyright (C) 2010 Pedro Algarvio <pedro@algarvio.me>
-#
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
-#
-
-
-# The main starting point for the program.    This function is called when the
-# user runs the command 'deluge'.
-
-"""Main starting point for Deluge.  Contains the main() entry point."""
-
-import os
-import sys
-from optparse import OptionParser
-from logging import FileHandler, getLogger
-from errno import EEXIST
-
-from deluge.log import setupLogger
-import deluge.error
-
-def version_callback(option, opt_str, value, parser):
-    print os.path.basename(sys.argv[0]) + ": " + deluge.common.get_version()
-    try:
-        from deluge._libtorrent import lt
-        print "libtorrent: %s" % lt.version
-    except ImportError:
-        pass
-    raise SystemExit
-
-def start_ui():
-    """Entry point for ui script"""
-    import deluge.common
-    deluge.common.setup_translations()
-
-    # Setup the argument parser
-    parser = OptionParser(usage="%prog [options] [actions]")
-    parser.add_option("-v", "--version", action="callback", callback=version_callback,
-        help="Show program's version number and exit")
-    parser.add_option("-u", "--ui", dest="ui",
-        help="""The UI that you wish to launch.  The UI choices are:\n
-        \t gtk -- A GTK-based graphical user interface (default)\n
-        \t web -- A web-based interface (http://localhost:8112)\n
-        \t console -- A console or command-line interface""", action="store", type="str")
-    parser.add_option("-s", "--set-default-ui", dest="default_ui",
-        help="Sets the default UI to be run when no UI is specified", action="store", type="str")
-    parser.add_option("-a", "--args", dest="args",
-        help="Arguments to pass to UI, -a '--option args'", action="store", type="str")
-    parser.add_option("-c", "--config", dest="config",
-        help="Set the config folder location", action="store", type="str")
-    parser.add_option("-l", "--logfile", dest="logfile",
-        help="Output to designated logfile instead of stdout", action="store", type="str")
-    parser.add_option("-L", "--loglevel", dest="loglevel",
-        help="Set the log level: none, info, warning, error, critical, debug", action="store", type="str")
-    parser.add_option("-q", "--quiet", dest="quiet",
-        help="Sets the log level to 'none', this is the same as `-L none`", action="store_true", default=False)
-    parser.add_option("-r", "--rotate-logs",
-        help="Rotate logfiles.", action="store_true", default=False)
-
-    # Get the options and args from the OptionParser
-    (options, args) = parser.parse_args(deluge.common.unicode_argv()[1:])
-
-    # Setup the logger
-    if options.quiet:
-        options.loglevel = "none"
-    if options.loglevel:
-        options.loglevel = options.loglevel.lower()
-    logfile_mode = 'w'
-    if options.rotate_logs:
-        logfile_mode = 'a'
-    setupLogger(level=options.loglevel, filename=options.logfile, filemode=logfile_mode)
-    log = getLogger(__name__)
-
-    if options.config:
-        if not os.path.exists(options.config):
-            # Try to create the config folder if it doesn't exist
-            try:
-                os.makedirs(options.config)
-            except Exception, e:
-                pass
-        elif not os.path.isdir(options.config):
-            log.error("Config option needs to be a directory!")
-            sys.exit(1)
-    else:
-        if not os.path.exists(deluge.common.get_default_config_dir()):
-            os.makedirs(deluge.common.get_default_config_dir())
-
-    if options.default_ui:
-        import deluge.configmanager
-        if options.config:
-            deluge.configmanager.set_config_dir(options.config)
-
-        config = deluge.configmanager.ConfigManager("ui.conf")
-        config["default_ui"] = options.default_ui
-        config.save()
-        print "The default UI has been changed to", options.default_ui
-        sys.exit(0)
-
-    version = deluge.common.get_version()
-
-    log.info("Deluge ui %s", version)
-    log.debug("options: %s", options)
-    log.debug("args: %s", args)
-    log.debug("ui_args: %s", args)
-
-    from deluge.ui.ui import UI
-    log.info("Starting ui..")
-    UI(options, args, options.args)
-
-def start_daemon():
-    """Entry point for daemon script"""
-    import deluge.common
-    deluge.common.setup_translations()
-
-    if 'dev' not in deluge.common.get_version():
-        import warnings
-        warnings.filterwarnings('ignore', category=DeprecationWarning, module='twisted')
-
-    # Setup the argument parser
-    parser = OptionParser(usage="%prog [options] [actions]")
-    parser.add_option("-v", "--version", action="callback", callback=version_callback,
-            help="Show program's version number and exit")
-    parser.add_option("-p", "--port", dest="port",
-        help="Port daemon will listen on", action="store", type="int")
-    parser.add_option("-i", "--interface", dest="listen_interface",
-        help="Interface daemon will listen for bittorrent connections on, \
-this should be an IP address", metavar="IFACE",
-        action="store", type="str")
-    parser.add_option("-u", "--ui-interface", dest="ui_interface",
-        help="Interface daemon will listen for UI connections on, this should be\
- an IP address", metavar="IFACE", action="store", type="str")
-    if not (deluge.common.windows_check() or deluge.common.osx_check()):
-        parser.add_option("-d", "--do-not-daemonize", dest="donot",
-            help="Do not daemonize", action="store_true", default=False)
-    parser.add_option("-c", "--config", dest="config",
-        help="Set the config location", action="store", type="str")
-    parser.add_option("-P", "--pidfile", dest="pidfile",
-        help="Use pidfile to store process id", action="store", type="str")
-    if not deluge.common.windows_check():
-        parser.add_option("-U", "--user", dest="user",
-            help="User to switch to. Only use it when starting as root", action="store", type="str")
-        parser.add_option("-g", "--group", dest="group",
-            help="Group to switch to. Only use it when starting as root", action="store", type="str")
-    parser.add_option("-l", "--logfile", dest="logfile",
-        help="Set the logfile location", action="store", type="str")
-    parser.add_option("-L", "--loglevel", dest="loglevel",
-        help="Set the log level: none, info, warning, error, critical, debug", action="store", type="str")
-    parser.add_option("-q", "--quiet", dest="quiet",
-        help="Sets the log level to 'none', this is the same as `-L none`", action="store_true", default=False)
-    parser.add_option("-r", "--rotate-logs",
-        help="Rotate logfiles.", action="store_true", default=False)
-    parser.add_option("--profile", dest="profile", action="store_true", default=False,
-        help="Profiles the daemon")
-
-    # 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)
-    logfile_mode = 'w'
-    if options.rotate_logs:
-        logfile_mode = 'a'
-    setupLogger(level=options.loglevel, filename=options.logfile, filemode=logfile_mode)
-    log = getLogger(__name__)
-
-    import deluge.configmanager
-    if options.config:
-        if not deluge.configmanager.set_config_dir(options.config):
-            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():
-        if options.pidfile:
-            open(options.pidfile, "wb").write("%s\n" % os.getpid())
-
-    # If the donot daemonize is set, then we just skip the forking
-    if not (deluge.common.windows_check() or deluge.common.osx_check() or options.donot):
-        if os.fork():
-            # We've forked and this is now the parent process, so die!
-            os._exit(0)
-        os.setsid()
-        # Do second fork
-        if os.fork():
-            os._exit(0)
-
-    # Write pid file before chuid
-    write_pidfile()
-
-    if not deluge.common.windows_check():
-        if options.user:
-            if not options.user.isdigit():
-                import pwd
-                options.user = pwd.getpwnam(options.user)[2]
-            os.setuid(options.user)
-        if options.group:
-            if not options.group.isdigit():
-                import grp
-                options.group = grp.getgrnam(options.group)[2]
-            os.setuid(options.group)
-
-    open_logfile()
-
-    def run_daemon(options, args):
-        try:
-            from deluge.core.daemon import Daemon
-            Daemon(options, args)
-        except deluge.error.DaemonRunningError, e:
-            log.error(e)
-            log.error("You cannot run multiple daemons with the same config directory set.")
-            log.error("If you believe this is an error, you can force a start by deleting %s.", deluge.configmanager.get_config_dir("deluged.pid"))
-            sys.exit(1)
-        except Exception, e:
-            log.exception(e)
-            sys.exit(1)
-
-    if options.profile:
-        import cProfile
-        profiler = cProfile.Profile()
-        profile_output = deluge.configmanager.get_config_dir("deluged.profile")
-
-        # Twisted catches signals to terminate
-        def save_profile_stats():
-            profiler.dump_stats(profile_output)
-            print "Profile stats saved to %s" % profile_output
-
-        from twisted.internet import reactor
-        reactor.addSystemEventTrigger("before", "shutdown", save_profile_stats)
-        print "Running with profiler..."
-        profiler.runcall(run_daemon, options, args)
-    else:
-        run_daemon(options, args)

deluge/maketorrent.py

@@ -1,155 +1,133 @@
-#
-# maketorrent.py
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2009 Andrew Resch <andrewresch@gmail.com>
 #
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
 
-import sys
+from __future__ import division, unicode_literals
+
 import os
 from hashlib import sha1 as sha
 
-from deluge.common import get_path_size
 from deluge.bencode import bencode
+from deluge.common import get_path_size, utf8_encode_structure
+
 
 class InvalidPath(Exception):
-    """
-    Raised when an invalid path is supplied
-    """
+    """Raised when an invalid path is supplied."""
+
     pass
 
+
 class InvalidPieceSize(Exception):
+    """Raised when an invalid piece size is set.
+
+    Note:
+        Piece sizes must be multiples of 16KiB.
     """
-    Raised when an invalid piece size is set.  Piece sizes must be multiples of
-    16KiB.
-    """
+
     pass
 
+
 class TorrentMetadata(object):
-    """
-    This class is used to create .torrent files.
+    """This class is used to create .torrent files.
 
-    ** Usage **
+    Examples:
 
-    >>> t = TorrentMetadata()
-    >>> t.data_path = "/tmp/torrent"
-    >>> t.comment = "My Test Torrent"
-    >>> t.trackers = [["http://tracker.openbittorent.com"]]
-    >>> t.save("/tmp/test.torrent")
+        >>> t = TorrentMetadata()
+        >>> t.data_path = '/tmp/torrent'
+        >>> t.comment = 'My Test Torrent'
+        >>> t.trackers = [['http://tracker.openbittorent.com']]
+        >>> t.save('/tmp/test.torrent')
 
     """
+
     def __init__(self):
         self.__data_path = None
         self.__piece_size = 0
-        self.__comment = ""
+        self.__comment = ''
         self.__private = False
         self.__trackers = []
         self.__webseeds = []
         self.__pad_files = False
 
     def save(self, torrent_path, progress=None):
-        """
-        Creates and saves the torrent file to `path`.
+        """Creates and saves the torrent file to `path`.
 
-        :param torrent_path: where to save the torrent file
-        :type torrent_path: string
+        Args:
+            torrent_path (str): Location to save the torrent file.
+            progress(func, optional): The function to be called when a piece is hashed. The
+                provided function should be in the format `func(num_completed, num_pieces)`.
 
-        :param progress: a function to be called when a piece is hashed
-        :type progress: function(num_completed, num_pieces)
-
-        :raises InvalidPath: if the data_path has not been set
+        Raises:
+            InvalidPath: If the data_path has not been set.
 
         """
         if not self.data_path:
-            raise InvalidPath("Need to set a data_path!")
+            raise InvalidPath('Need to set a data_path!')
 
-        torrent = {
-            "info": {}
-            }
+        torrent = {'info': {}}
 
         if self.comment:
-            torrent["comment"] = self.comment.encode("UTF-8")
+            torrent['comment'] = self.comment
 
         if self.private:
-            torrent["info"]["private"] = True
+            torrent['info']['private'] = True
 
         if self.trackers:
-            torrent["announce"] = self.trackers[0][0]
-            torrent["announce-list"] = self.trackers
+            torrent['announce'] = self.trackers[0][0]
+            torrent['announce-list'] = self.trackers
         else:
-            torrent["announce"] = ""
+            torrent['announce'] = ''
 
         if self.webseeds:
             httpseeds = []
             webseeds = []
             for w in self.webseeds:
-                if w.endswith(".php"):
+                if w.endswith('.php'):
                     httpseeds.append(w)
                 else:
                     webseeds.append(w)
 
             if httpseeds:
-                torrent["httpseeds"] = httpseeds
+                torrent['httpseeds'] = httpseeds
             if webseeds:
-                torrent["url-list"] = webseeds
+                torrent['url-list'] = webseeds
 
         datasize = get_path_size(self.data_path)
 
         if self.piece_size:
-            piece_size = piece_size * 1024
+            piece_size = self.piece_size * 1024
         else:
             # We need to calculate a piece size
             piece_size = 16384
-            while (datasize / piece_size) > 1024 and piece_size < (8192 * 1024):
+            while (datasize // piece_size) > 1024 and piece_size < (8192 * 1024):
                 piece_size *= 2
 
         # Calculate the number of pieces we will require for the data
-        num_pieces = datasize / piece_size
+        num_pieces = datasize // piece_size
         if datasize % piece_size:
             num_pieces += 1
 
-        torrent["info"]["piece length"] = piece_size
+        torrent['info']['piece length'] = piece_size
+        torrent['info']['name'] = os.path.split(self.data_path)[1]
 
         # Create the info
         if os.path.isdir(self.data_path):
-            torrent["info"]["name"] = os.path.split(self.data_path)[1]
             files = []
             padding_count = 0
             # Collect a list of file paths and add padding files if necessary
             for (dirpath, dirnames, filenames) in os.walk(self.data_path):
                 for index, filename in enumerate(filenames):
-                    size = get_path_size(os.path.join(self.data_path, dirpath, filename))
-                    p = dirpath[len(self.data_path):]
-                    p = p.lstrip("/")
-                    p = p.split("/")
+                    size = get_path_size(
+                        os.path.join(self.data_path, dirpath, filename)
+                    )
+                    p = dirpath[len(self.data_path) :]
+                    p = p.lstrip('/')
+                    p = p.split('/')
                     if p[0]:
                         p += [filename]
                     else:
@@ -160,7 +138,7 @@ class TorrentMetadata(object):
                         left = size % piece_size
                         if left:
                             p = list(p)
-                            p[-1] = "_____padding_file_" + str(padding_count)
+                            p[-1] = '_____padding_file_' + str(padding_count)
                             files.append((piece_size - left, p))
                             padding_count += 1
 
@@ -171,179 +149,224 @@ class TorrentMetadata(object):
             fs = []
             pieces = []
             # Create the piece hashes
-            buf = ""
+            buf = b''
             for size, path in files:
-                path = [s.decode(sys.getfilesystemencoding()).encode("UTF-8") for s in path]
-                fs.append({"length": size, "path": path})
-                if path[-1].startswith("_____padding_file_"):
-                    buf += "\0" * size
+                path = [s.encode('UTF-8') for s in path]
+                fs.append({b'length': size, b'path': path})
+                if path[-1].startswith(b'_____padding_file_'):
+                    buf += b'\0' * size
                     pieces.append(sha(buf).digest())
-                    buf = ""
-                    fs[-1]["attr"] = "p"
+                    buf = b''
+                    fs[-1][b'attr'] = b'p'
                 else:
-                    fd = open(os.path.join(self.data_path, *path), "rb")
-                    r = fd.read(piece_size - len(buf))
-                    while r:
-                        buf += r
-                        if len(buf) == piece_size:
-                            pieces.append(sha(buf).digest())
-                            # Run the progress function if necessary
-                            if progress:
-                                progress(len(pieces), num_pieces)
-                            buf = ""
-                        else:
-                            break
-                        r = fd.read(piece_size - len(buf))
-                    fd.close()
-
+                    with open(
+                        os.path.join(self.data_path.encode('utf8'), *path), 'rb'
+                    ) as _file:
+                        r = _file.read(piece_size - len(buf))
+                        while r:
+                            buf += r
+                            if len(buf) == piece_size:
+                                pieces.append(sha(buf).digest())
+                                # Run the progress function if necessary
+                                if progress:
+                                    progress(len(pieces), num_pieces)
+                                buf = b''
+                            else:
+                                break
+                            r = _file.read(piece_size - len(buf))
+            torrent['info']['files'] = fs
             if buf:
                 pieces.append(sha(buf).digest())
                 if progress:
                     progress(len(pieces), num_pieces)
-                buf = ""
-
-            torrent["info"]["pieces"] = "".join(pieces)
-            torrent["info"]["files"] = fs
+                buf = ''
 
         elif os.path.isfile(self.data_path):
-            torrent["info"]["name"] = os.path.split(self.data_path)[1]
-            torrent["info"]["length"] = get_path_size(self.data_path)
+            torrent['info']['length'] = get_path_size(self.data_path)
             pieces = []
 
-            fd = open(self.data_path, "rb")
-            r = fd.read(piece_size)
-            while r:
-                pieces.append(sha(r).digest())
-                if progress:
-                    progress(len(pieces), num_pieces)
+            with open(self.data_path, 'rb') as _file:
+                r = _file.read(piece_size)
+                while r:
+                    pieces.append(sha(r).digest())
+                    if progress:
+                        progress(len(pieces), num_pieces)
 
-                r = fd.read(piece_size)
+                    r = _file.read(piece_size)
 
-            torrent["info"]["pieces"] = "".join(pieces)
+        torrent['info']['pieces'] = b''.join(pieces)
 
         # Write out the torrent file
-        open(torrent_path, "wb").write(bencode(torrent))
+        with open(torrent_path, 'wb') as _file:
+            _file.write(bencode(utf8_encode_structure(torrent)))
 
     def get_data_path(self):
-        """
-        The path to the files that the torrent will contain.  It can be either
-        a file or a folder.  This property needs to be set before the torrent
-        file can be created and saved.
+        """Get the path to the files that the torrent will contain.
+
+        Note:
+            It can be either a file or a folder.
+
+        Returns:
+            str: The torrent data path, either a file or a folder.
+
         """
         return self.__data_path
 
     def set_data_path(self, path):
-        """
-        :param path: the path to the data
-        :type path: string
+        """Set the path to the files (data) that the torrent will contain.
 
-        :raises InvalidPath: if the path is not found
+        Note:
+            This property needs to be set before the torrent file can be created and saved.
+
+        Args:
+            path (str): The path to the torrent data and can be either a file or a folder.
+
+        Raises:
+            InvalidPath: If the path is not found.
 
         """
         if os.path.exists(path) and (os.path.isdir(path) or os.path.isfile(path)):
             self.__data_path = os.path.abspath(path)
         else:
-            raise InvalidPath("No such file or directory: %s" % path)
+            raise InvalidPath('No such file or directory: %s' % path)
 
     def get_piece_size(self):
-        """
-        The size of pieces in bytes.  The size must be a multiple of 16KiB.
-        If you don't set a piece size, one will be automatically selected to
-        produce a torrent with less than 1024 pieces or the smallest possible
-        with a 8192KiB piece size.
+        """The size of the pieces.
 
+        Returns:
+            int: The piece size in multiples of 16 KiBs.
         """
         return self.__piece_size
 
     def set_piece_size(self, size):
-        """
-        :param size: the desired piece size in KiBs
-        :type size: int
+        """Set piece size.
 
-        :raises InvalidPieceSize: if the piece size is not a multiple of 16 KiB
+        Note:
+            If no piece size is set, one will be automatically selected to
+            produce a torrent with less than 1024 pieces or the smallest possible
+            with a 8192KiB piece size.
+
+        Args:
+            size (int): The desired piece size in multiples of 16 KiBs.
+
+        Raises:
+            InvalidPieceSize: If the piece size is not a valid multiple of 16 KiB.
 
         """
         if size % 16 and size:
-            raise InvalidPieceSize("Piece size must be a multiple of 16 KiB")
+            raise InvalidPieceSize('Piece size must be a multiple of 16 KiB')
         self.__piece_size = size
 
     def get_comment(self):
-        """
-        Comment is some extra info to be stored in the torrent.  This is
-        typically an informational string.
+        """Get the torrent comment.
+
+        Returns:
+            str: An informational string about the torrent.
+
         """
         return self.__comment
 
     def set_comment(self, comment):
-        """
-        :param comment: an informational string
-        :type comment: string
+        """Set the comment for the torrent.
+
+        Args:
+            comment (str): An informational string about the torrent.
+
         """
         self.__comment = comment
 
     def get_private(self):
-        """
-        Private torrents only announce to the tracker and will not use DHT or
-        Peer Exchange.
+        """Get the private flag of the torrent.
 
-        See: http://bittorrent.org/beps/bep_0027.html
+        Returns:
+            bool: True if private flag has been set, else False.
 
         """
         return self.__private
 
     def set_private(self, private):
-        """
-        :param private: True if the torrent is to be private
-        :type private: bool
+        """Set the torrent private flag.
+
+        Note:
+            Private torrents only announce to trackers and will not use DHT or
+            Peer Exchange. See http://bittorrent.org/beps/bep_0027.html
+
+        Args:
+            private (bool): True if the torrent is to be private.
+
         """
         self.__private = private
 
     def get_trackers(self):
-        """
-        The announce trackers is a list of lists.
+        """Get the announce trackers.
 
-        See: http://bittorrent.org/beps/bep_0012.html
+        Note:
+            See http://bittorrent.org/beps/bep_0012.html
+
+        Returns:
+            list of lists: A list containing a list of trackers.
 
         """
         return self.__trackers
 
     def set_trackers(self, trackers):
-        """
-        :param trackers: a list of lists of trackers, each list is a tier
-        :type trackers: list of list of strings
+        """Set the announce trackers.
+
+        Args:
+            private (list of lists): A list containing lists of trackers as strings, each list is a tier.
+
         """
         self.__trackers = trackers
 
     def get_webseeds(self):
-        """
-        The web seeds can either be:
-        Hoffman-style: http://bittorrent.org/beps/bep_0017.html
-        or,
-        GetRight-style: http://bittorrent.org/beps/bep_0019.html
+        """Get the webseeds.
+
+        Note:
+            The web seeds can either be:
+                Hoffman-style: http://bittorrent.org/beps/bep_0017.html
+                GetRight-style: http://bittorrent.org/beps/bep_0019.html
+
+            If the url ends in '.php' then it will be considered Hoffman-style, if
+            not it will be considered GetRight-style.
+
+        Returns:
+            list: The webseeds.
 
-        If the url ends in '.php' then it will be considered Hoffman-style, if
-        not it will be considered GetRight-style.
         """
         return self.__webseeds
 
     def set_webseeds(self, webseeds):
-        """
-        :param webseeds: the webseeds which can be either Hoffman or GetRight style
-        :type webseeds: list of urls
+        """Set webseeds.
+
+        Note:
+            The web seeds can either be:
+                Hoffman-style: http://bittorrent.org/beps/bep_0017.html
+                GetRight-style: http://bittorrent.org/beps/bep_0019.html
+
+            If the url ends in '.php' then it will be considered Hoffman-style, if
+            not it will be considered GetRight-style.
+
+        Args:
+            private (list): The webseeds URLs which can be either Hoffman or GetRight style.
+
         """
         self.__webseeds = webseeds
 
     def get_pad_files(self):
-        """
-        If this is True, padding files will be added to align files on piece
-        boundaries.
+        """Get status of padding files for the torrent.
+
+        Returns:
+            bool: True if padding files have been enabled to align files on piece boundaries.
+
         """
         return self.__pad_files
 
     def set_pad_files(self, pad):
-        """
-        :param pad: set True to align files on piece boundaries
-        :type pad: bool
+        """Enable padding files for the torrent.
+
+        Args:
+            private (bool): True adds padding files to align files on piece boundaries.
+
         """
         self.__pad_files = pad
 

deluge/metafile.py

@@ -1,29 +1,26 @@
-# Taken from http://download.bittorrent.com/dl/BitTorrent-5.3-GPL.tar.gz
+# -*- coding: utf-8 -*-
 #
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
+# Original file from BitTorrent-5.3-GPL.tar.gz
+# Copyright (C) Bram Cohen
 #
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
+# Modifications for use in Deluge:
+# Copyright (C) 2007 Andrew Resch <andrewresch@gmail.com>
+#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-# Written by Bram Cohen
-# Modifications for use in Deluge by Andrew Resch 2008
+from __future__ import division, unicode_literals
 
-import os.path
-import sys
-import time
 import logging
+import os.path
+import time
 from hashlib import sha1 as sha
 
 import deluge.component as component
 from deluge.bencode import bencode
+from deluge.common import utf8_encode_structure
 from deluge.event import CreateTorrentProgressEvent
 
 log = logging.getLogger(__name__)
@@ -31,45 +28,48 @@ log = logging.getLogger(__name__)
 ignore = ['core', 'CVS', 'Thumbs.db', 'desktop.ini']
 
 noncharacter_translate = {}
-for i in xrange(0xD800, 0xE000):
+for i in range(0xD800, 0xE000):
     noncharacter_translate[i] = ord('-')
-for i in xrange(0xFDD0, 0xFDF0):
+for i in range(0xFDD0, 0xFDF0):
     noncharacter_translate[i] = ord('-')
 for i in (0xFFFE, 0xFFFF):
     noncharacter_translate[i] = ord('-')
 
+
 def gmtime():
     return time.mktime(time.gmtime())
 
-def get_filesystem_encoding():
-    return sys.getfilesystemencoding()
-
-def decode_from_filesystem(path):
-    encoding = get_filesystem_encoding()
-    if encoding == None:
-        assert isinstance(path, unicode), "Path should be unicode not %s" % type(path)
-        decoded_path = path
-    else:
-        assert isinstance(path, str), "Path should be str not %s" % type(path)
-        decoded_path = path.decode(encoding)
-
-    return decoded_path
 
 def dummy(*v):
     pass
 
+
 class RemoteFileProgress(object):
     def __init__(self, session_id):
         self.session_id = session_id
 
     def __call__(self, piece_count, num_pieces):
-        component.get("RPCServer").emit_event_for_session_id(
+        component.get('RPCServer').emit_event_for_session_id(
             self.session_id, CreateTorrentProgressEvent(piece_count, num_pieces)
         )
 
-def make_meta_file(path, url, piece_length, progress=None, title=None, comment=None,
-                   safe=None, content_type=None, target=None, webseeds=None, name=None,
-                   private=False, created_by=None, trackers=None):
+
+def make_meta_file(
+    path,
+    url,
+    piece_length,
+    progress=None,
+    title=None,
+    comment=None,
+    safe=None,
+    content_type=None,
+    target=None,
+    webseeds=None,
+    name=None,
+    private=False,
+    created_by=None,
+    trackers=None,
+):
     data = {'creation date': int(gmtime())}
     if url:
         data['announce'] = url.strip()
@@ -83,31 +83,32 @@ def make_meta_file(path, url, piece_length, progress=None, title=None, comment=N
         f = target
 
     if progress is None:
-        session_id = component.get("RPCServer").get_session_id()
-        if not session_id:
-            progress = dummy
+        progress = dummy
+        try:
+            session_id = component.get('RPCServer').get_session_id()
+        except KeyError:
+            pass
         else:
-            progress = RemoteFileProgress(component.get("RPCServer").get_session_id())
+            if session_id:
+                progress = RemoteFileProgress(session_id)
 
     info = makeinfo(path, piece_length, progress, name, content_type, private)
 
-    #check_info(info)
-    h = file(f, 'wb')
-
+    # check_info(info)
     data['info'] = info
     if title:
-        data['title'] = title.encode("utf8")
+        data['title'] = title.encode('utf8')
     if comment:
-        data['comment'] = comment.encode("utf8")
+        data['comment'] = comment.encode('utf8')
     if safe:
-        data['safe'] = safe.encode("utf8")
+        data['safe'] = safe.encode('utf8')
 
     httpseeds = []
     url_list = []
 
     if webseeds:
         for webseed in webseeds:
-            if webseed.endswith(".php"):
+            if webseed.endswith('.php'):
                 httpseeds.append(webseed)
             else:
                 url_list.append(webseed)
@@ -117,15 +118,15 @@ def make_meta_file(path, url, piece_length, progress=None, title=None, comment=N
     if httpseeds:
         data['httpseeds'] = httpseeds
     if created_by:
-        data['created by'] = created_by.encode("utf8")
+        data['created by'] = created_by.encode('utf8')
 
     if trackers and (len(trackers[0]) > 1 or len(trackers) > 1):
         data['announce-list'] = trackers
 
-    data["encoding"] = "UTF-8"
+    data['encoding'] = 'UTF-8'
+    with open(f, 'wb') as file_:
+        file_.write(bencode(utf8_encode_structure(data)))
 
-    h.write(bencode(data))
-    h.close()
 
 def calcsize(path):
     total = 0
@@ -133,31 +134,13 @@ def calcsize(path):
         total += os.path.getsize(s[1])
     return total
 
-def makeinfo(path, piece_length, progress, name = None,
-             content_type = None, private=False):  # HEREDAVE. If path is directory,
-                                                   # how do we assign content type?
-    def to_utf8(name):
-        if isinstance(name, unicode):
-            u = name
-        else:
-            try:
-                u = decode_from_filesystem(name)
-            except Exception:
-                raise Exception('Could not convert file/directory name %r to '
-                                'Unicode. Either the assumed filesystem '
-                                'encoding "%s" is wrong or the filename contains '
-                                'illegal bytes.' % (name, get_filesystem_encoding()))
 
-        if u.translate(noncharacter_translate) != u:
-            raise Exception('File/directory name "%s" contains reserved '
-                              'unicode values that do not correspond to '
-                              'characters.' % name)
-        return u.encode('utf-8')
+def makeinfo(path, piece_length, progress, name=None, content_type=None, private=False):
+    # HEREDAVE. If path is directory, how do we assign content type?
     path = os.path.abspath(path)
     piece_count = 0
     if os.path.isdir(path):
-        subs = subfiles(path)
-        subs.sort()
+        subs = sorted(subfiles(path))
         pieces = []
         sh = sha()
         done = 0
@@ -168,78 +151,86 @@ def makeinfo(path, piece_length, progress, name = None,
             totalsize += os.path.getsize(f)
         if totalsize >= piece_length:
             import math
-            num_pieces = math.ceil(float(totalsize) / float(piece_length))
+
+            num_pieces = math.ceil(totalsize / piece_length)
         else:
             num_pieces = 1
 
         for p, f in subs:
             pos = 0
             size = os.path.getsize(f)
-            p2 = [to_utf8(n) for n in p]
+            p2 = [n.encode('utf8') for n in p]
             if content_type:
-                fs.append({'length': size, 'path': p2,
-                           'content_type' : content_type}) # HEREDAVE. bad for batch!
+                fs.append(
+                    {'length': size, 'path': p2, 'content_type': content_type}
+                )  # HEREDAVE. bad for batch!
             else:
                 fs.append({'length': size, 'path': p2})
-            h = file(f, 'rb')
-            while pos < size:
-                a = min(size - pos, piece_length - done)
-                sh.update(h.read(a))
-                done += a
-                pos += a
-                totalhashed += a
+            with open(f, 'rb') as file_:
+                while pos < size:
+                    a = min(size - pos, piece_length - done)
+                    sh.update(file_.read(a))
+                    done += a
+                    pos += a
+                    totalhashed += a
 
-                if done == piece_length:
-                    pieces.append(sh.digest())
-                    piece_count += 1
-                    done = 0
-                    sh = sha()
-                    progress(piece_count, num_pieces)
-            h.close()
+                    if done == piece_length:
+                        pieces.append(sh.digest())
+                        piece_count += 1
+                        done = 0
+                        sh = sha()
+                        progress(piece_count, num_pieces)
         if done > 0:
             pieces.append(sh.digest())
             piece_count += 1
             progress(piece_count, num_pieces)
 
-        if name is not None:
-            assert isinstance(name, unicode)
-            name = to_utf8(name)
-        else:
-            name = to_utf8(os.path.split(path)[1])
+        if not name:
+            name = os.path.split(path)[1]
 
-        return {'pieces': ''.join(pieces),
-            'piece length': piece_length, 'files': fs,
-            'name': name,
-            'private': private}
+        return {
+            'pieces': b''.join(pieces),
+            'piece length': piece_length,
+            'files': fs,
+            'name': name.encode('utf8'),
+            'private': private,
+        }
     else:
         size = os.path.getsize(path)
         if size >= piece_length:
-            num_pieces = size / piece_length
+            num_pieces = size // piece_length
         else:
             num_pieces = 1
 
         pieces = []
         p = 0
-        h = file(path, 'rb')
-        while p < size:
-            x = h.read(min(piece_length, size - p))
-            pieces.append(sha(x).digest())
-            piece_count += 1
-            p += piece_length
-            if p > size:
-                p = size
-            progress(piece_count, num_pieces)
-        h.close()
+        with open(path, 'rb') as _file:
+            while p < size:
+                x = _file.read(min(piece_length, size - p))
+                pieces.append(sha(x).digest())
+                piece_count += 1
+                p += piece_length
+                if p > size:
+                    p = size
+                progress(piece_count, num_pieces)
+        name = os.path.split(path)[1].encode('utf8')
         if content_type is not None:
-            return {'pieces': ''.join(pieces),
-                'piece length': piece_length, 'length': size,
-                'name': to_utf8(os.path.split(path)[1]),
-                'content_type' : content_type,
-                'private': private }
-        return {'pieces': ''.join(pieces),
-            'piece length': piece_length, 'length': size,
-            'name': to_utf8(os.path.split(path)[1]),
-            'private': private}
+            return {
+                'pieces': b''.join(pieces),
+                'piece length': piece_length,
+                'length': size,
+                'name': name,
+                'content_type': content_type,
+                'private': private,
+            }
+        return {
+            'pieces': b''.join(pieces),
+            'piece length': piece_length,
+            'length': size,
+            'name': name,
+            'private': private,
+        }
+
 
 def subfiles(d):
     r = []

deluge/path_chooser_common.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013 Bro <bro.development@gmail.com>
+#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
+#
+
+from __future__ import unicode_literals
+
+import os
+
+from deluge.common import PY2
+
+
+def is_hidden(filepath):
+    def has_hidden_attribute(filepath):
+        import win32api
+        import win32con
+
+        try:
+            attribute = win32api.GetFileAttributes(filepath)
+            return attribute & (
+                win32con.FILE_ATTRIBUTE_HIDDEN | win32con.FILE_ATTRIBUTE_SYSTEM
+            )
+        except (AttributeError, AssertionError):
+            return False
+
+    name = os.path.basename(os.path.abspath(filepath))
+    # Windows
+    if os.name == 'nt':
+        return has_hidden_attribute(filepath)
+    return name.startswith('.')
+
+
+def get_completion_paths(args):
+    """
+    Takes a path value and returns the available completions.
+    If the path_value is a valid path, return all sub-directories.
+    If the path_value is not a valid path, remove the basename from the
+    path and return all sub-directories of path that start with basename.
+
+    :param args: options
+    :type args: dict
+    :returns: the args argument containing the available completions for the completion_text
+    :rtype: list
+
+    """
+    args['paths'] = []
+    path_value = args['completion_text']
+    hidden_files = args['show_hidden_files']
+
+    def get_subdirs(dirname):
+        try:
+            if PY2:
+                return os.walk(dirname).__next__[1]
+            else:
+                return next(os.walk(dirname))[1]
+        except StopIteration:
+            # Invalid dirname
+            return []
+
+    dirname = os.path.dirname(path_value)
+    basename = os.path.basename(path_value)
+
+    dirs = get_subdirs(dirname)
+    # No completions available
+    if not dirs:
+        return args
+
+    # path_value ends with path separator so
+    # we only want all the subdirectories
+    if not basename:
+        # Lets remove hidden files
+        if not hidden_files:
+            old_dirs = dirs
+            dirs = []
+            for d in old_dirs:
+                if not is_hidden(os.path.join(dirname, d)):
+                    dirs.append(d)
+    matching_dirs = []
+    for s in dirs:
+        if s.startswith(basename):
+            p = os.path.join(dirname, s)
+            if not p.endswith(os.path.sep):
+                p += os.path.sep
+            matching_dirs.append(p)
+
+    args['paths'] = sorted(matching_dirs)
+    return args

deluge/pluginmanagerbase.py

@@ -1,62 +1,39 @@
-#
-# pluginmanagerbase.py
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2007 Andrew Resch <andrewresch@gmail.com>
 #
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
 
 
 """PluginManagerBase"""
+from __future__ import unicode_literals
 
-import os.path
 import logging
+import os.path
+
 import pkg_resources
+from twisted.internet import defer
+from twisted.python.failure import Failure
 
 import deluge.common
-import deluge.configmanager
-
 import deluge.component as component
+import deluge.configmanager
 
 log = logging.getLogger(__name__)
 
 METADATA_KEYS = [
-    "Name",
-    "License",
-    "Author",
-    "Home-page",
-    "Summary",
-    "Platform",
-    "Version",
-    "Author-email",
-    "Description",
+    'Name',
+    'License',
+    'Author',
+    'Home-page',
+    'Summary',
+    'Platform',
+    'Version',
+    'Author-email',
+    'Description',
 ]
 
 DEPRECATION_WARNING = """
@@ -69,17 +46,20 @@ If you're the developer, please take a look at the plugins hosted on deluge's
 git repository to have an idea of what needs to be changed.
 """
 
-class PluginManagerBase:
+
+class PluginManagerBase(object):
     """PluginManagerBase is a base class for PluginManagers to inherit"""
 
     def __init__(self, config_file, entry_name):
-        log.debug("Plugin manager init..")
+        log.debug('Plugin manager init..')
 
         self.config = deluge.configmanager.ConfigManager(config_file)
 
         # Create the plugins folder if it doesn't exist
-        if not os.path.exists(os.path.join(deluge.configmanager.get_config_dir(), "plugins")):
-            os.mkdir(os.path.join(deluge.configmanager.get_config_dir(), "plugins"))
+        if not os.path.exists(
+            os.path.join(deluge.configmanager.get_config_dir(), 'plugins')
+        ):
+            os.mkdir(os.path.join(deluge.configmanager.get_config_dir(), 'plugins'))
 
         # This is the entry we want to load..
         self.entry_name = entry_name
@@ -92,12 +72,13 @@ class PluginManagerBase:
 
     def enable_plugins(self):
         # Load plugins that are enabled in the config.
-        for name in self.config["enabled_plugins"]:
+        for name in self.config['enabled_plugins']:
             self.enable_plugin(name)
 
     def disable_plugins(self):
-        # Disable all plugins that are enabled
-        for key in self.plugins.keys():
+        """Disable all plugins that are enabled"""
+        # Dict will be modified so iterate over generated list
+        for key in list(self.plugins):
             self.disable_plugin(key)
 
     def __getitem__(self, key):
@@ -109,102 +90,193 @@ class PluginManagerBase:
 
     def get_enabled_plugins(self):
         """Returns a list of enabled plugins"""
-        return self.plugins.keys()
+        return list(self.plugins)
 
     def scan_for_plugins(self):
         """Scans for available plugins"""
-        base_plugin_dir = deluge.common.resource_filename("deluge", "plugins")
-        pkg_resources.working_set.add_entry(base_plugin_dir)
-        user_plugin_dir = os.path.join(deluge.configmanager.get_config_dir(), "plugins")
+        base_dir = deluge.common.resource_filename('deluge', 'plugins')
+        user_dir = os.path.join(deluge.configmanager.get_config_dir(), 'plugins')
+        base_subdir = [
+            os.path.join(base_dir, f)
+            for f in os.listdir(base_dir)
+            if os.path.isdir(os.path.join(base_dir, f))
+        ]
+        plugin_dirs = [base_dir, user_dir] + base_subdir
 
-        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)
-        plugins_dirs.append(user_plugin_dir)
-
-        self.pkg_env = pkg_resources.Environment(plugins_dirs)
+        for dirname in plugin_dirs:
+            pkg_resources.working_set.add_entry(dirname)
+        self.pkg_env = pkg_resources.Environment(plugin_dirs, None)
 
         self.available_plugins = []
         for name in self.pkg_env:
-            log.debug("Found plugin: %s %s at %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].location)
+                self.pkg_env[name][0].location,
+            )
             self.available_plugins.append(self.pkg_env[name][0].project_name)
 
     def enable_plugin(self, plugin_name):
-        """Enables a plugin"""
+        """Enable a plugin.
+
+        Args:
+            plugin_name (str): The plugin name.
+
+        Returns:
+            Deferred: A deferred with callback value True or False indicating
+                whether the plugin is enabled or not.
+
+        """
         if plugin_name not in self.available_plugins:
-            log.warning("Cannot enable non-existant plugin %s", plugin_name)
-            return
+            log.warning('Cannot enable non-existant plugin %s', plugin_name)
+            return defer.succeed(False)
 
         if plugin_name in self.plugins:
-            log.warning("Cannot enable already enabled plugin %s", plugin_name)
-            return
+            log.warning('Cannot enable already enabled plugin %s', plugin_name)
+            return defer.succeed(True)
 
-        plugin_name = plugin_name.replace(" ", "-")
+        plugin_name = plugin_name.replace(' ', '-')
         egg = self.pkg_env[plugin_name][0]
+        # Activate is required by non-namespace plugins.
         egg.activate()
+        return_d = defer.succeed(True)
+
         for name in egg.get_entry_map(self.entry_name):
-            entry_point = egg.get_entry_info(self.entry_name, name)
             try:
-                cls = entry_point.load()
-                instance = cls(plugin_name.replace("-", "_"))
-            except Exception, e:
-                log.error("Unable to instantiate plugin %r from %r!",
-                          name, egg.location)
-                log.exception(e)
+                cls = egg.load_entry_point(self.entry_name, name)
+                instance = cls(plugin_name.replace('-', '_'))
+            except component.ComponentAlreadyRegistered as ex:
+                log.error(ex)
+                return defer.succeed(False)
+            except Exception as ex:
+                log.error(
+                    'Unable to instantiate plugin %r from %r!', name, egg.location
+                )
+                log.exception(ex)
                 continue
-            instance.enable()
-            if not instance.__module__.startswith("deluge.plugins."):
+            try:
+                return_d = defer.maybeDeferred(instance.enable)
+            except Exception as ex:
+                log.error('Unable to enable plugin: %s', name)
+                log.exception(ex)
+                return_d = defer.fail(False)
+
+            if not instance.__module__.startswith('deluge.plugins.'):
                 import warnings
+
                 warnings.warn_explicit(
                     DEPRECATION_WARNING % name,
                     DeprecationWarning,
-                    instance.__module__, 0
+                    instance.__module__,
+                    0,
                 )
-            if self._component_state == "Started":
-                component.start([instance.plugin._component_name])
-            plugin_name = plugin_name.replace("-", " ")
-            self.plugins[plugin_name] = instance
-            if plugin_name not in self.config["enabled_plugins"]:
-                log.debug("Adding %s to enabled_plugins list in config",
-                    plugin_name)
-                self.config["enabled_plugins"].append(plugin_name)
-            log.info("Plugin %s enabled..", plugin_name)
+            if self._component_state == 'Started':
+
+                def on_enabled(result, instance):
+                    return component.start([instance.plugin._component_name])
+
+                return_d.addCallback(on_enabled, instance)
+
+            def on_started(result, instance):
+                plugin_name_space = plugin_name.replace('-', ' ')
+                self.plugins[plugin_name_space] = instance
+                if plugin_name_space not in self.config['enabled_plugins']:
+                    log.debug(
+                        'Adding %s to enabled_plugins list in config', plugin_name_space
+                    )
+                    self.config['enabled_plugins'].append(plugin_name_space)
+                log.info('Plugin %s enabled...', plugin_name_space)
+                return True
+
+            def on_started_error(result, instance):
+                log.error(
+                    'Failed to start plugin: %s\n%s',
+                    plugin_name,
+                    result.getTraceback(elideFrameworkCode=1, detail='brief'),
+                )
+                self.plugins[plugin_name.replace('-', ' ')] = instance
+                self.disable_plugin(plugin_name)
+                return False
+
+            return_d.addCallbacks(
+                on_started,
+                on_started_error,
+                callbackArgs=[instance],
+                errbackArgs=[instance],
+            )
+            return return_d
+
+        return defer.succeed(False)
 
     def disable_plugin(self, name):
-        """Disables a plugin"""
-        try:
-            self.plugins[name].disable()
-            component.deregister(self.plugins[name].plugin)
-            del self.plugins[name]
-            self.config["enabled_plugins"].remove(name)
-        except KeyError:
-            log.warning("Plugin %s is not enabled..", name)
+        """Disable a plugin.
 
-        log.info("Plugin %s disabled..", name)
+        Args:
+            plugin_name (str): The plugin name.
+
+        Returns:
+            Deferred: A deferred with callback value True or False indicating
+                whether the plugin is disabled or not.
+
+        """
+        if name not in self.plugins:
+            log.warning('Plugin "%s" is not enabled...', name)
+            return defer.succeed(True)
+
+        try:
+            d = defer.maybeDeferred(self.plugins[name].disable)
+        except Exception as ex:
+            log.error('Error when disabling plugin: %s', self.plugin._component_name)
+            log.debug(ex)
+            d = defer.succeed(False)
+
+        def on_disabled(result):
+            ret = True
+            if isinstance(result, Failure):
+                log.debug(
+                    'Error when disabling plugin %s: %s', name, result.getTraceback()
+                )
+                ret = False
+            try:
+                component.deregister(self.plugins[name].plugin)
+                del self.plugins[name]
+                self.config['enabled_plugins'].remove(name)
+            except Exception as ex:
+                log.warning('Problems occured disabling plugin: %s', name)
+                log.debug(ex)
+                ret = False
+            else:
+                log.info('Plugin %s disabled...', name)
+            return ret
+
+        d.addBoth(on_disabled)
+        return d
 
     def get_plugin_info(self, name):
         """Returns a dictionary of plugin info from the metadata"""
         info = {}.fromkeys(METADATA_KEYS)
-        last_header = ""
+        last_header = ''
         cont_lines = []
-        for line in self.pkg_env[name][0].get_metadata("PKG-INFO").splitlines():
+        # Missing plugin info
+        if not self.pkg_env[name]:
+            log.warning('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
-            if line[0] in ' \t' and (len(line.split(":", 1)) == 1 or line.split(":", 1)[0] not in info.keys()):
+            if line[0] in ' \t' and (
+                len(line.split(':', 1)) == 1 or line.split(':', 1)[0] not in info
+            ):
                 # This is a continuation
                 cont_lines.append(line.strip())
             else:
                 if cont_lines:
-                    info[last_header] = "\n".join(cont_lines).strip()
+                    info[last_header] = '\n'.join(cont_lines).strip()
                     cont_lines = []
-                if line.split(":", 1)[0] in info.keys():
-                    last_header = line.split(":", 1)[0]
-                    info[last_header] = line.split(":", 1)[1].strip()
-
+                if line.split(':', 1)[0] in info:
+                    last_header = line.split(':', 1)[0]
+                    info[last_header] = line.split(':', 1)[1].strip()
         return info

deluge/plugins/AutoAdd/deluge/__init__.py

@@ -1,3 +0,0 @@
-# this is a namespace package
-import pkg_resources
-pkg_resources.declare_namespace(__name__)

deluge/plugins/AutoAdd/deluge/plugins/__init__.py

@@ -1,3 +0,0 @@
-# this is a namespace package
-import pkg_resources
-pkg_resources.declare_namespace(__name__)

deluge/plugins/AutoAdd/deluge/plugins/autoadd/__init__.py

@@ -1,58 +0,0 @@
-#
-# __init__.py
-#
-# Copyright (C) 2009 GazpachoKing <chase.sterling@gmail.com>
-#
-# Basic plugin template created by:
-# Copyright (C) 2008 Martijn Voncken <mvoncken@gmail.com>
-# Copyright (C) 2007-2009 Andrew Resch <andrewresch@gmail.com>
-# Copyright (C) 2009 Damien Churchill <damoxc@gmail.com>
-#
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
-
-from deluge.plugins.init import PluginInitBase
-
-class CorePlugin(PluginInitBase):
-    def __init__(self, plugin_name):
-        from core import Core as _plugin_cls
-        self._plugin_cls = _plugin_cls
-        super(CorePlugin, self).__init__(plugin_name)
-
-class GtkUIPlugin(PluginInitBase):
-    def __init__(self, plugin_name):
-        from gtkui import GtkUI as _plugin_cls
-        self._plugin_cls = _plugin_cls
-        super(GtkUIPlugin, self).__init__(plugin_name)
-
-class WebUIPlugin(PluginInitBase):
-    def __init__(self, plugin_name):
-        from webui import WebUI as _plugin_cls
-        self._plugin_cls = _plugin_cls
-        super(WebUIPlugin, self).__init__(plugin_name)

deluge/plugins/AutoAdd/deluge/plugins/autoadd/common.py

@@ -1,43 +0,0 @@
-#
-# common.py
-#
-# Copyright (C) 2009 GazpachoKing <chase.sterling@gmail.com>
-#
-# Basic plugin template created by:
-# Copyright (C) 2008 Martijn Voncken <mvoncken@gmail.com>
-# Copyright (C) 2007-2009 Andrew Resch <andrewresch@gmail.com>
-# Copyright (C) 2009 Damien Churchill <damoxc@gmail.com>
-#
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
-
-def get_resource(filename):
-    import pkg_resources, os
-    return pkg_resources.resource_filename("deluge.plugins.autoadd",
-                                           os.path.join("data", filename))

deluge/plugins/AutoAdd/deluge/plugins/autoadd/core.py

@@ -1,505 +0,0 @@
-#
-# core.py
-#
-# Copyright (C) 2009 GazpachoKing <chase.sterling@gmail.com>
-# Copyright (C) 2011 Pedro Algarvio <pedro@algarvio.me>
-#
-# Basic plugin template created by:
-# Copyright (C) 2008 Martijn Voncken <mvoncken@gmail.com>
-# Copyright (C) 2007-2009 Andrew Resch <andrewresch@gmail.com>
-# Copyright (C) 2009 Damien Churchill <damoxc@gmail.com>
-#
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
-
-from deluge._libtorrent import lt
-import os
-import logging
-from deluge.plugins.pluginbase import CorePluginBase
-import deluge.component as component
-import deluge.configmanager
-from deluge.common import AUTH_LEVEL_ADMIN
-from deluge.core.rpcserver import export
-from twisted.internet.task import LoopingCall, deferLater
-from twisted.internet import reactor
-from deluge.event import DelugeEvent
-
-log = logging.getLogger(__name__)
-
-DEFAULT_PREFS = {
-    "watchdirs":{},
-    "next_id":1
-}
-
-OPTIONS_AVAILABLE = { #option: builtin
-    "enabled":False,
-    "path":False,
-    "append_extension":False,
-    "copy_torrent": False,
-    "delete_copy_torrent_toggle": False,
-    "abspath":False,
-    "download_location":True,
-    "max_download_speed":True,
-    "max_upload_speed":True,
-    "max_connections":True,
-    "max_upload_slots":True,
-    "prioritize_first_last":True,
-    "auto_managed":True,
-    "stop_at_ratio":True,
-    "stop_ratio":True,
-    "remove_at_ratio":True,
-    "move_completed":True,
-    "move_completed_path":True,
-    "label":False,
-    "add_paused":True,
-    "queue_to_top":False,
-    "owner": "localclient"
-}
-
-MAX_NUM_ATTEMPTS = 10
-
-class AutoaddOptionsChangedEvent(DelugeEvent):
-    """Emitted when the options for the plugin are changed."""
-    def __init__(self):
-        pass
-
-def CheckInput(cond, message):
-    if not cond:
-        raise Exception(message)
-
-class Core(CorePluginBase):
-    def enable(self):
-
-        #reduce typing, assigning some values to self...
-        self.config = deluge.configmanager.ConfigManager("autoadd.conf", DEFAULT_PREFS)
-        self.config.run_converter((0, 1), 2, self.__migrate_config_1_to_2)
-        self.config.save()
-        self.watchdirs = self.config["watchdirs"]
-
-        component.get("EventManager").register_event_handler(
-            "PreTorrentRemovedEvent", self.__on_pre_torrent_removed
-        )
-
-        # Dict of Filename:Attempts
-        self.invalid_torrents = {}
-        # Loopingcall timers for each enabled watchdir
-        self.update_timers = {}
-        deferLater(reactor, 5, self.enable_looping)
-
-    def enable_looping(self):
-        # Enable all looping calls for enabled watchdirs here
-        for watchdir_id, watchdir in self.watchdirs.iteritems():
-            if watchdir['enabled']:
-                self.enable_watchdir(watchdir_id)
-
-    def disable(self):
-        #disable all running looping calls
-        component.get("EventManager").deregister_event_handler(
-            "PreTorrentRemovedEvent", self.__on_pre_torrent_removed
-        )
-        for loopingcall in self.update_timers.itervalues():
-            loopingcall.stop()
-        self.config.save()
-
-    def update(self):
-        pass
-
-    @export
-    def set_options(self, watchdir_id, options):
-        """Update the options for a watch folder."""
-        watchdir_id = str(watchdir_id)
-        options = self._make_unicode(options)
-        CheckInput(
-            watchdir_id in self.watchdirs, _("Watch folder does not exist.")
-        )
-        if options.has_key('path'):
-            options['abspath'] = os.path.abspath(options['path'])
-            CheckInput(
-                os.path.isdir(options['abspath']), _("Path does not exist.")
-            )
-            for w_id, w in self.watchdirs.iteritems():
-                if options['abspath'] == w['abspath'] and watchdir_id != w_id:
-                    raise Exception("Path is already being watched.")
-        for key in options.keys():
-            if key not in OPTIONS_AVAILABLE:
-                if key not in [key2+'_toggle' for key2 in OPTIONS_AVAILABLE.iterkeys()]:
-                    raise Exception("autoadd: Invalid options key:%s" % key)
-        #disable the watch loop if it was active
-        if watchdir_id in self.update_timers:
-            self.disable_watchdir(watchdir_id)
-
-        self.watchdirs[watchdir_id].update(options)
-        #re-enable watch loop if appropriate
-        if self.watchdirs[watchdir_id]['enabled']:
-            self.enable_watchdir(watchdir_id)
-        self.config.save()
-        component.get("EventManager").emit(AutoaddOptionsChangedEvent())
-
-    def load_torrent(self, filename, magnet):
-        try:
-            log.debug("Attempting to open %s for add.", filename)
-            if magnet == False:
-                _file = open(filename, "rb")
-            elif magnet == True:
-                _file = open(filename, "r")
-            filedump = _file.read()
-            if not filedump:
-                raise RuntimeError, "Torrent is 0 bytes!"
-            _file.close()
-        except IOError, e:
-            log.warning("Unable to open %s: %s", filename, e)
-            raise e
-
-        # Get the info to see if any exceptions are raised
-        if magnet == False:
-            lt.torrent_info(lt.bdecode(filedump))
-
-        return filedump
-
-    def split_magnets(self, filename):
-        log.debug("Attempting to open %s for splitting magnets.", filename)
-        try:
-            _file = open(filename, "r")
-        except IOError, e:
-            log.warning("Unable to open %s: %s", filename, e)
-            raise e
-        else:
-            magnets = list(filter(len, _file.readlines()))
-            _file.close()
-            if len(magnets) < 2:
-                return
-            n = 0
-            path = filename.rsplit(os.sep, 1)[0]
-            for magnet in magnets:
-                for part in magnet.split('&'):
-                    if part.startswith("dn="):
-                        mname = os.sep.join([path, part[3:] + ".magnet"])
-                        break
-                else:
-                    mname = '.'.join([filename, str(n), "magnet"])
-                    n += 1
-                try:
-                    _mfile = open(mname, "w")
-                except IOError, e:
-                    log.warning("Unable to open %s: %s", mname, e)
-                else:
-                    _mfile.write(magnet)
-                    _mfile.close()
-            return magnets
-
-    def update_watchdir(self, watchdir_id):
-        """Check the watch folder for new torrents to add."""
-        log.trace("Updating watchdir id: %s", watchdir_id)
-        watchdir_id = str(watchdir_id)
-        watchdir = self.watchdirs[watchdir_id]
-        if not watchdir['enabled']:
-            # We shouldn't be updating because this watchdir is not enabled
-            log.debug("Watchdir id %s is not enabled. Disabling it.",
-                      watchdir_id)
-            self.disable_watchdir(watchdir_id)
-            return
-
-        if not os.path.isdir(watchdir["abspath"]):
-            log.warning("Invalid AutoAdd folder: %s", watchdir["abspath"])
-            self.disable_watchdir(watchdir_id)
-            return
-
-        # Generate options dict for watchdir
-        opts = {}
-        if 'stop_at_ratio_toggle' in watchdir:
-            watchdir['stop_ratio_toggle'] = watchdir['stop_at_ratio_toggle']
-        # We default to True when reading _toggle values, so a config
-        # without them is valid, and applies all its settings.
-        for option, value in watchdir.iteritems():
-            if OPTIONS_AVAILABLE.get(option):
-                if watchdir.get(option+'_toggle', True):
-                    opts[option] = value
-
-        # Check for .magnet files containing multiple magnet links and
-        # create a new .magnet file for each of them.
-        for filename in os.listdir(watchdir["abspath"]):
-            try:
-                filepath = os.path.join(watchdir["abspath"], filename)
-            except UnicodeDecodeError, e:
-                log.error("Unable to auto add torrent due to improper "
-                          "filename encoding: %s", e)
-                continue
-            if os.path.isdir(filepath):
-                # Skip directories
-                continue
-            elif os.path.splitext(filename)[1] == ".magnet" and \
-                    self.split_magnets(filepath):
-                os.remove(filepath)
-
-        for filename in os.listdir(watchdir["abspath"]):
-            try:
-                filepath = os.path.join(watchdir["abspath"], filename)
-            except UnicodeDecodeError, e:
-                log.error("Unable to auto add torrent due to improper "
-                          "filename encoding: %s", e)
-                continue
-            if os.path.isdir(filepath):
-                # Skip directories
-                continue
-            else:
-                ext = os.path.splitext(filename)[1]
-                if ext == ".torrent":
-                    magnet = False
-                elif ext == ".magnet":
-                    magnet = True
-                else:
-                    continue
-                try:
-                    filedump = self.load_torrent(filepath, magnet)
-                except (RuntimeError, Exception), e:
-                    # If the torrent is invalid, we keep track of it so that we
-                    # can try again on the next pass.  This is because some
-                    # torrents may not be fully saved during the pass.
-                    log.debug("Torrent is invalid: %s", e)
-                    if filename in self.invalid_torrents:
-                        self.invalid_torrents[filename] += 1
-                        if self.invalid_torrents[filename] >= MAX_NUM_ATTEMPTS:
-                            log.warning(
-                                "Maximum attempts reached while trying to add the "
-                                "torrent file with the path %s", filepath
-                            )
-                            os.rename(filepath, filepath + ".invalid")
-                            del self.invalid_torrents[filename]
-                    else:
-                        self.invalid_torrents[filename] = 1
-                    continue
-
-                # The torrent looks good, so lets add it to the session.
-                if magnet == False:
-                    torrent_id = component.get("TorrentManager").add(
-                        filedump=filedump, filename=filename, options=opts,
-                        owner=watchdir.get("owner", "localclient")
-                    )
-                elif magnet == True:
-                    torrent_id = component.get("TorrentManager").add(
-                        magnet=filedump, options=opts,
-                        owner=watchdir.get("owner", "localclient")
-                    )
-                # If the torrent added successfully, set the extra options.
-                if torrent_id:
-                    if 'Label' in component.get("CorePluginManager").get_enabled_plugins():
-                        if watchdir.get('label_toggle', True) and watchdir.get('label'):
-                            label = component.get("CorePlugin.Label")
-                            if not watchdir['label'] in label.get_labels():
-                                label.add(watchdir['label'])
-                            label.set_torrent(torrent_id, watchdir['label'])
-                    if watchdir.get('queue_to_top_toggle', True) and 'queue_to_top' in watchdir:
-                        if watchdir['queue_to_top']:
-                            component.get("TorrentManager").queue_top(torrent_id)
-                        else:
-                            component.get("TorrentManager").queue_bottom(torrent_id)
-                else:
-                    # torrent handle is invalid and so is the magnet link
-                    if magnet == True:
-                        log.debug("invalid magnet link")
-                        os.rename(filepath, filepath + ".invalid")
-                        continue
-
-                # Rename, copy or delete the torrent once added to deluge.
-                if watchdir.get('append_extension_toggle'):
-                    if not watchdir.get('append_extension'):
-                        watchdir['append_extension'] = ".added"
-                    os.rename(filepath, filepath + watchdir['append_extension'])
-                elif watchdir.get('copy_torrent_toggle'):
-                    copy_torrent_path = watchdir['copy_torrent']
-                    copy_torrent_file = os.path.join(copy_torrent_path, filename)
-                    log.debug("Moving added torrent file \"%s\" to \"%s\"",
-                              os.path.basename(filepath), copy_torrent_path)
-                    try:
-                        os.rename(filepath, copy_torrent_file)
-                    except OSError, why:
-                        from errno import EXDEV
-                        if why.errno == errno.EXDEV:
-                            # This can happen for different mount points
-                            from shutil import copyfile
-                            try:
-                                copyfile(filepath, copy_torrent_file)
-                                os.remove(filepath)
-                            except OSError:
-                                # Last Resort!
-                                try:
-                                    open(copy_torrent_file, 'wb').write(
-                                        open(filepath, 'rb').read()
-                                    )
-                                    os.remove(filepath)
-                                except OSError, why:
-                                    raise why
-                        else:
-                            raise why
-                else:
-                    os.remove(filepath)
-
-    def on_update_watchdir_error(self, failure, watchdir_id):
-        """Disables any watch folders with un-handled exceptions."""
-        self.disable_watchdir(watchdir_id)
-        log.error("Disabling '%s', error during update: %s",
-                  self.watchdirs[watchdir_id]["path"], failure)
-
-    @export
-    def enable_watchdir(self, watchdir_id):
-        w_id = str(watchdir_id)
-        # Enable the looping call
-        if w_id not in self.update_timers or not self.update_timers[w_id].running:
-            self.update_timers[w_id] = LoopingCall(self.update_watchdir, w_id)
-            self.update_timers[w_id].start(5).addErrback(
-                self.on_update_watchdir_error, w_id
-            )
-        # Update the config
-        if not self.watchdirs[w_id]['enabled']:
-            self.watchdirs[w_id]['enabled'] = True
-            self.config.save()
-            component.get("EventManager").emit(AutoaddOptionsChangedEvent())
-
-    @export
-    def disable_watchdir(self, watchdir_id):
-        w_id = str(watchdir_id)
-        # Disable the looping call
-        if w_id in self.update_timers:
-            if self.update_timers[w_id].running:
-                self.update_timers[w_id].stop()
-            del self.update_timers[w_id]
-        # Update the config
-        if self.watchdirs[w_id]['enabled']:
-            self.watchdirs[w_id]['enabled'] = False
-            self.config.save()
-            component.get("EventManager").emit(AutoaddOptionsChangedEvent())
-
-    @export
-    def set_config(self, config):
-        """Sets the config dictionary."""
-        config = self._make_unicode(config)
-        for key in config.keys():
-            self.config[key] = config[key]
-        self.config.save()
-        component.get("EventManager").emit(AutoaddOptionsChangedEvent())
-
-    @export
-    def get_config(self):
-        """Returns the config dictionary."""
-        return self.config.config
-
-    @export
-    def get_watchdirs(self):
-        rpcserver = component.get("RPCServer")
-        session_user = rpcserver.get_session_user()
-        session_auth_level = rpcserver.get_session_auth_level()
-        if session_auth_level == AUTH_LEVEL_ADMIN:
-            log.debug("Current logged in user %s is an ADMIN, send all "
-                      "watchdirs", session_user)
-            return self.watchdirs
-
-        watchdirs = {}
-        for watchdir_id, watchdir in self.watchdirs.iteritems():
-            if watchdir.get("owner", "localclient") == session_user:
-                watchdirs[watchdir_id] = watchdir
-
-        log.debug("Current logged in user %s is not an ADMIN, send only "
-                  "his watchdirs: %s", session_user, watchdirs.keys())
-        return watchdirs
-
-    def _make_unicode(self, options):
-        opts = {}
-        for key in options:
-            if isinstance(options[key], str):
-                options[key] = unicode(options[key], "utf8")
-            opts[key] = options[key]
-        return opts
-
-    @export
-    def add(self, options={}):
-        """Add a watch folder."""
-        options = self._make_unicode(options)
-        abswatchdir = os.path.abspath(options['path'])
-        CheckInput(os.path.isdir(abswatchdir) , _("Path does not exist."))
-        CheckInput(
-            os.access(abswatchdir, os.R_OK|os.W_OK),
-            "You must have read and write access to watch folder."
-        )
-        if abswatchdir in [wd['abspath'] for wd in self.watchdirs.itervalues()]:
-            raise Exception("Path is already being watched.")
-        options.setdefault('enabled', False)
-        options['abspath'] = abswatchdir
-        watchdir_id = self.config['next_id']
-        self.watchdirs[str(watchdir_id)] = options
-        if options.get('enabled'):
-            self.enable_watchdir(watchdir_id)
-        self.config['next_id'] = watchdir_id + 1
-        self.config.save()
-        component.get("EventManager").emit(AutoaddOptionsChangedEvent())
-        return watchdir_id
-
-    @export
-    def remove(self, watchdir_id):
-        """Remove a watch folder."""
-        watchdir_id = str(watchdir_id)
-        CheckInput(watchdir_id in self.watchdirs,
-                   "Unknown Watchdir: %s" % self.watchdirs)
-        if self.watchdirs[watchdir_id]['enabled']:
-            self.disable_watchdir(watchdir_id)
-        del self.watchdirs[watchdir_id]
-        self.config.save()
-        component.get("EventManager").emit(AutoaddOptionsChangedEvent())
-
-    def __migrate_config_1_to_2(self, config):
-        for watchdir_id in config['watchdirs'].iterkeys():
-            config['watchdirs'][watchdir_id]['owner'] = 'localclient'
-        return config
-
-    def __on_pre_torrent_removed(self, torrent_id):
-        try:
-            torrent = component.get("TorrentManager")[torrent_id]
-        except KeyError:
-            log.warning("Unable to remove torrent file for torrent id %s. It"
-                        "was already deleted from the TorrentManager",
-                        torrent_id)
-            return
-        torrent_fname = torrent.filename
-        for watchdir in self.watchdirs.itervalues():
-            if not watchdir.get('copy_torrent_toggle', False):
-                # This watchlist does copy torrents
-                continue
-            elif not watchdir.get('delete_copy_torrent_toggle', False):
-                # This watchlist is not set to delete finished torrents
-                continue
-            copy_torrent_path = watchdir['copy_torrent']
-            torrent_fname_path = os.path.join(copy_torrent_path, torrent_fname)
-            if os.path.isfile(torrent_fname_path):
-                try:
-                    os.remove(torrent_fname_path)
-                    log.info("Removed torrent file \"%s\" from \"%s\"",
-                             torrent_fname, copy_torrent_path)
-                    break
-                except OSError, e:
-                    log.info("Failed to removed torrent file \"%s\" from "
-                             "\"%s\": %s", torrent_fname, copy_torrent_path, e)

deluge/plugins/AutoAdd/deluge/plugins/autoadd/data/autoadd.js

@@ -1,50 +0,0 @@
-/*
-Script: autoadd.js
-    The client-side javascript code for the AutoAdd plugin.
-
-Copyright:
-    (C) GazpachoKing 2009 <damoxc@gmail.com>
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 3, or (at your option)
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, write to:
-        The Free Software Foundation, Inc.,
-        51 Franklin Street, Fifth Floor
-        Boston, MA  02110-1301, USA.
-
-    In addition, as a special exception, the copyright holders give
-    permission to link the code of portions of this program with the OpenSSL
-    library.
-    You must obey the GNU General Public License in all respects for all of
-    the code used other than OpenSSL. If you modify file(s) with this
-    exception, you may extend this exception to your version of the file(s),
-    but you are not obligated to do so. If you do not wish to do so, delete
-    this exception statement from your version. If you delete this exception
-    statement from all source files in the program, then also delete it here.
-*/
-
-AutoAddPlugin = Ext.extend(Deluge.Plugin, {
-	constructor: function(config) {
-		config = Ext.apply({
-			name: "AutoAdd"
-		}, config);
-		AutoAddPlugin.superclass.constructor.call(this, config);
-	},
-	
-	onDisable: function() {
-		
-	},
-	
-	onEnable: function() {
-		
-	}
-});
-new AutoAddPlugin();

deluge/plugins/AutoAdd/deluge/plugins/autoadd/gtkui.py

@@ -1,516 +0,0 @@
-#
-# gtkui.py
-#
-# Copyright (C) 2009 GazpachoKing <chase.sterling@gmail.com>
-#
-# Basic plugin template created by:
-# Copyright (C) 2008 Martijn Voncken <mvoncken@gmail.com>
-# Copyright (C) 2007-2009 Andrew Resch <andrewresch@gmail.com>
-# Copyright (C) 2009 Damien Churchill <damoxc@gmail.com>
-#
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
-
-import gtk
-import gtk.glade
-import logging
-from deluge.ui.client import client
-from deluge.ui.gtkui import dialogs
-from deluge.plugins.pluginbase import GtkPluginBase
-import deluge.component as component
-import deluge.common
-import os
-
-from common import get_resource
-
-log = logging.getLogger(__name__)
-
-class IncompatibleOption(Exception):
-    pass
-
-class OptionsDialog():
-    spin_ids = ["max_download_speed", "max_upload_speed", "stop_ratio"]
-    spin_int_ids = ["max_upload_slots", "max_connections"]
-    chk_ids = ["stop_at_ratio", "remove_at_ratio", "move_completed",
-               "add_paused", "auto_managed", "queue_to_top"]
-
-    def __init__(self):
-        self.accounts = gtk.ListStore(str)
-        self.labels = gtk.ListStore(str)
-        self.core_config = {}
-
-    def show(self, options={}, watchdir_id=None):
-        self.glade = gtk.glade.XML(get_resource("autoadd_options.glade"))
-        self.glade.signal_autoconnect({
-            "on_opts_add":self.on_add,
-            "on_opts_apply":self.on_apply,
-            "on_opts_cancel":self.on_cancel,
-            "on_options_dialog_close":self.on_cancel,
-            "on_toggle_toggled":self.on_toggle_toggled
-        })
-        self.dialog = self.glade.get_widget("options_dialog")
-        self.dialog.set_transient_for(component.get("Preferences").pref_dialog)
-
-        if watchdir_id:
-            #We have an existing watchdir_id, we are editing
-            self.glade.get_widget('opts_add_button').hide()
-            self.glade.get_widget('opts_apply_button').show()
-            self.watchdir_id = watchdir_id
-        else:
-            #We don't have an id, adding
-            self.glade.get_widget('opts_add_button').show()
-            self.glade.get_widget('opts_apply_button').hide()
-            self.watchdir_id = None
-
-        self.load_options(options)
-        self.dialog.run()
-
-    def load_options(self, options):
-        self.glade.get_widget('enabled').set_active(options.get('enabled', True))
-        self.glade.get_widget('append_extension_toggle').set_active(
-            options.get('append_extension_toggle', False)
-        )
-        self.glade.get_widget('append_extension').set_text(
-            options.get('append_extension', '.added')
-        )
-        self.glade.get_widget('download_location_toggle').set_active(
-            options.get('download_location_toggle', False)
-        )
-        self.glade.get_widget('copy_torrent_toggle').set_active(
-            options.get('copy_torrent_toggle', False)
-        )
-        self.glade.get_widget('delete_copy_torrent_toggle').set_active(
-            options.get('delete_copy_torrent_toggle', False)
-        )
-        self.accounts.clear()
-        self.labels.clear()
-        combobox = self.glade.get_widget('OwnerCombobox')
-        combobox_render = gtk.CellRendererText()
-        combobox.pack_start(combobox_render, True)
-        combobox.add_attribute(combobox_render, 'text', 0)
-        combobox.set_model(self.accounts)
-
-        label_widget = self.glade.get_widget('label')
-        label_widget.child.set_text(options.get('label', ''))
-        label_widget.set_model(self.labels)
-        label_widget.set_text_column(0)
-        self.glade.get_widget('label_toggle').set_active(options.get('label_toggle', False))
-
-        for id in self.spin_ids + self.spin_int_ids:
-            self.glade.get_widget(id).set_value(options.get(id, 0))
-            self.glade.get_widget(id+'_toggle').set_active(options.get(id+'_toggle', False))
-        for id in self.chk_ids:
-            self.glade.get_widget(id).set_active(bool(options.get(id, True)))
-            self.glade.get_widget(id+'_toggle').set_active(options.get(id+'_toggle', False))
-        if not options.get('add_paused', True):
-            self.glade.get_widget('isnt_add_paused').set_active(True)
-        if not options.get('queue_to_top', True):
-            self.glade.get_widget('isnt_queue_to_top').set_active(True)
-        if not options.get('auto_managed', True):
-            self.glade.get_widget('isnt_auto_managed').set_active(True)
-        for field in ['move_completed_path', 'path', 'download_location',
-                      'copy_torrent']:
-            if client.is_localhost():
-                self.glade.get_widget(field+"_chooser").set_current_folder(
-                    options.get(field, os.path.expanduser("~"))
-                )
-                self.glade.get_widget(field+"_chooser").show()
-                self.glade.get_widget(field+"_entry").hide()
-            else:
-                self.glade.get_widget(field+"_entry").set_text(
-                    options.get(field, "")
-                )
-                self.glade.get_widget(field+"_entry").show()
-                self.glade.get_widget(field+"_chooser").hide()
-        self.set_sensitive()
-
-        def on_core_config(config):
-            if client.is_localhost():
-                self.glade.get_widget('download_location_chooser').set_current_folder(
-                    options.get('download_location', config["download_location"])
-                )
-                if options.get('move_completed_toggle', config["move_completed"]):
-                    self.glade.get_widget('move_completed_toggle').set_active(True)
-                    self.glade.get_widget('move_completed_path_chooser').set_current_folder(
-                        options.get('move_completed_path', config["move_completed_path"])
-                    )
-                if options.get('copy_torrent_toggle', config["copy_torrent_file"]):
-                    self.glade.get_widget('copy_torrent_toggle').set_active(True)
-                    self.glade.get_widget('copy_torrent_chooser').set_current_folder(
-                        options.get('copy_torrent', config["torrentfiles_location"])
-                    )
-            else:
-                self.glade.get_widget('download_location_entry').set_text(
-                    options.get('download_location', config["download_location"])
-                )
-                if options.get('move_completed_toggle', config["move_completed"]):
-                    self.glade.get_widget('move_completed_toggle').set_active(
-                        options.get('move_completed_toggle', False)
-                    )
-                    self.glade.get_widget('move_completed_path_entry').set_text(
-                        options.get('move_completed_path', config["move_completed_path"])
-                    )
-                if options.get('copy_torrent_toggle', config["copy_torrent_file"]):
-                    self.glade.get_widget('copy_torrent_toggle').set_active(True)
-                    self.glade.get_widget('copy_torrent_entry').set_text(
-                        options.get('copy_torrent', config["torrentfiles_location"])
-                    )
-
-            if options.get('delete_copy_torrent_toggle', config["del_copy_torrent_file"]):
-                self.glade.get_widget('delete_copy_torrent_toggle').set_active(True)
-
-        if not options:
-            client.core.get_config().addCallback(on_core_config)
-
-        def on_accounts(accounts, owner):
-            log.debug("Got Accounts")
-            selected_iter = None
-            for account in accounts:
-                iter = self.accounts.append()
-                self.accounts.set_value(
-                    iter, 0, account['username']
-                )
-                if account['username'] == owner:
-                    selected_iter = iter
-            self.glade.get_widget('OwnerCombobox').set_active_iter(selected_iter)
-
-        def on_accounts_failure(failure):
-            log.debug("Failed to get accounts!!! %s", failure)
-            iter = self.accounts.append()
-            self.accounts.set_value(iter, 0, client.get_auth_user())
-            self.glade.get_widget('OwnerCombobox').set_active(0)
-            self.glade.get_widget('OwnerCombobox').set_sensitive(False)
-
-        def on_labels(labels):
-            log.debug("Got Labels: %s", labels)
-            for label in labels:
-                self.labels.set_value(self.labels.append(), 0, label)
-            label_widget = self.glade.get_widget('label')
-            label_widget.set_model(self.labels)
-            label_widget.set_text_column(0)
-
-        def on_failure(failure):
-            log.exception(failure)
-
-        def on_get_enabled_plugins(result):
-            if 'Label' in result:
-                self.glade.get_widget('label_frame').show()
-                client.label.get_labels().addCallback(on_labels).addErrback(on_failure)
-            else:
-                self.glade.get_widget('label_frame').hide()
-                self.glade.get_widget('label_toggle').set_active(False)
-
-        client.core.get_enabled_plugins().addCallback(on_get_enabled_plugins)
-        if client.get_auth_level() == deluge.common.AUTH_LEVEL_ADMIN:
-            client.core.get_known_accounts().addCallback(
-                on_accounts, options.get('owner', client.get_auth_user())
-            ).addErrback(on_accounts_failure)
-        else:
-            iter = self.accounts.append()
-            self.accounts.set_value(iter, 0, client.get_auth_user())
-            self.glade.get_widget('OwnerCombobox').set_active(0)
-            self.glade.get_widget('OwnerCombobox').set_sensitive(False)
-
-    def set_sensitive(self):
-        maintoggles = ['download_location', 'append_extension',
-                       'move_completed', 'label', 'max_download_speed',
-                       'max_upload_speed', 'max_connections',
-                       'max_upload_slots', 'add_paused', 'auto_managed',
-                       'stop_at_ratio', 'queue_to_top', 'copy_torrent']
-        [self.on_toggle_toggled(self.glade.get_widget(x+'_toggle')) for x in maintoggles]
-
-    def on_toggle_toggled(self, tb):
-        toggle = str(tb.name).replace("_toggle", "")
-        isactive = tb.get_active()
-        if toggle == 'download_location':
-            self.glade.get_widget('download_location_chooser').set_sensitive(isactive)
-            self.glade.get_widget('download_location_entry').set_sensitive(isactive)
-        elif toggle == 'append_extension':
-            self.glade.get_widget('append_extension').set_sensitive(isactive)
-        elif toggle == 'copy_torrent':
-            self.glade.get_widget('copy_torrent_entry').set_sensitive(isactive)
-            self.glade.get_widget('copy_torrent_chooser').set_sensitive(isactive)
-            self.glade.get_widget('delete_copy_torrent_toggle').set_sensitive(isactive)
-        elif toggle == 'move_completed':
-            self.glade.get_widget('move_completed_path_chooser').set_sensitive(isactive)
-            self.glade.get_widget('move_completed_path_entry').set_sensitive(isactive)
-            self.glade.get_widget('move_completed').set_active(isactive)
-        elif toggle == 'label':
-            self.glade.get_widget('label').set_sensitive(isactive)
-        elif toggle == 'max_download_speed':
-            self.glade.get_widget('max_download_speed').set_sensitive(isactive)
-        elif toggle == 'max_upload_speed':
-            self.glade.get_widget('max_upload_speed').set_sensitive(isactive)
-        elif toggle == 'max_connections':
-            self.glade.get_widget('max_connections').set_sensitive(isactive)
-        elif toggle == 'max_upload_slots':
-            self.glade.get_widget('max_upload_slots').set_sensitive(isactive)
-        elif toggle == 'add_paused':
-            self.glade.get_widget('add_paused').set_sensitive(isactive)
-            self.glade.get_widget('isnt_add_paused').set_sensitive(isactive)
-        elif toggle == 'queue_to_top':
-            self.glade.get_widget('queue_to_top').set_sensitive(isactive)
-            self.glade.get_widget('isnt_queue_to_top').set_sensitive(isactive)
-        elif toggle == 'auto_managed':
-            self.glade.get_widget('auto_managed').set_sensitive(isactive)
-            self.glade.get_widget('isnt_auto_managed').set_sensitive(isactive)
-        elif toggle == 'stop_at_ratio':
-            self.glade.get_widget('remove_at_ratio_toggle').set_active(isactive)
-            self.glade.get_widget('stop_ratio_toggle').set_active(isactive)
-            self.glade.get_widget('stop_at_ratio').set_active(isactive)
-            self.glade.get_widget('stop_ratio').set_sensitive(isactive)
-            self.glade.get_widget('remove_at_ratio').set_sensitive(isactive)
-
-    def on_apply(self, Event=None):
-        try:
-            options = self.generate_opts()
-            client.autoadd.set_options(
-                str(self.watchdir_id), options
-            ).addCallbacks(self.on_added, self.on_error_show)
-        except IncompatibleOption, err:
-            dialogs.ErrorDialog(_("Incompatible Option"), str(err), self.dialog).run()
-
-
-    def on_error_show(self, result):
-        d = dialogs.ErrorDialog(_("Error"), result.value.exception_msg, self.dialog)
-        result.cleanFailure()
-        d.run()
-
-    def on_added(self, result):
-        self.dialog.destroy()
-
-    def on_add(self, Event=None):
-        try:
-            options = self.generate_opts()
-            client.autoadd.add(options).addCallbacks(self.on_added, self.on_error_show)
-        except IncompatibleOption, err:
-            dialogs.ErrorDialog(_("Incompatible Option"), str(err), self.dialog).run()
-
-    def on_cancel(self, Event=None):
-        self.dialog.destroy()
-
-    def generate_opts(self):
-        # generate options dict based on gtk objects
-        options = {}
-        options['enabled'] = self.glade.get_widget('enabled').get_active()
-        if client.is_localhost():
-            options['path'] = self.glade.get_widget('path_chooser').get_filename()
-            options['download_location'] = self.glade.get_widget(
-                'download_location_chooser').get_filename()
-            options['move_completed_path'] = self.glade.get_widget(
-                'move_completed_path_chooser').get_filename()
-            options['copy_torrent'] = self.glade.get_widget(
-                'copy_torrent_chooser').get_filename()
-        else:
-            options['path'] = self.glade.get_widget('path_entry').get_text()
-            options['download_location'] = self.glade.get_widget(
-                'download_location_entry').get_text()
-            options['move_completed_path'] = self.glade.get_widget(
-                'move_completed_path_entry').get_text()
-            options['copy_torrent'] = self.glade.get_widget(
-                'copy_torrent_entry').get_text()
-
-        options['label'] = self.glade.get_widget('label').child.get_text().lower()
-        options['append_extension'] = self.glade.get_widget('append_extension').get_text()
-        options['owner'] = self.accounts[
-            self.glade.get_widget('OwnerCombobox').get_active()][0]
-
-        for key in ['append_extension_toggle', 'download_location_toggle',
-                    'label_toggle', 'copy_torrent_toggle',
-                    'delete_copy_torrent_toggle']:
-            options[key] = self.glade.get_widget(key).get_active()
-
-        for id in self.spin_ids:
-            options[id] = self.glade.get_widget(id).get_value()
-            options[id+'_toggle'] = self.glade.get_widget(id+'_toggle').get_active()
-        for id in self.spin_int_ids:
-            options[id] = self.glade.get_widget(id).get_value_as_int()
-            options[id+'_toggle'] = self.glade.get_widget(id+'_toggle').get_active()
-        for id in self.chk_ids:
-            options[id] = self.glade.get_widget(id).get_active()
-            options[id+'_toggle'] = self.glade.get_widget(id+'_toggle').get_active()
-
-        if options['copy_torrent_toggle'] and options['path'] == options['copy_torrent']:
-            raise IncompatibleOption(_("\"Watch Folder\" directory and \"Copy of .torrent"
-                                       " files to\" directory cannot be the same!"))
-        return options
-
-
-class GtkUI(GtkPluginBase):
-    def enable(self):
-
-        self.glade = gtk.glade.XML(get_resource("config.glade"))
-        self.glade.signal_autoconnect({
-            "on_add_button_clicked": self.on_add_button_clicked,
-            "on_edit_button_clicked": self.on_edit_button_clicked,
-            "on_remove_button_clicked": self.on_remove_button_clicked
-        })
-        self.opts_dialog = OptionsDialog()
-
-        component.get("PluginManager").register_hook(
-            "on_apply_prefs", self.on_apply_prefs
-        )
-        component.get("PluginManager").register_hook(
-            "on_show_prefs", self.on_show_prefs
-        )
-        client.register_event_handler(
-            "AutoaddOptionsChangedEvent", self.on_options_changed_event
-        )
-
-        self.watchdirs = {}
-
-        vbox = self.glade.get_widget("watchdirs_vbox")
-        sw = gtk.ScrolledWindow()
-        sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
-        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
-
-        vbox.pack_start(sw, True, True, 0)
-
-        self.store = self.create_model()
-
-        self.treeView = gtk.TreeView(self.store)
-        self.treeView.connect("cursor-changed", self.on_listitem_activated)
-        self.treeView.connect("row-activated", self.on_edit_button_clicked)
-        self.treeView.set_rules_hint(True)
-
-        self.create_columns(self.treeView)
-        sw.add(self.treeView)
-        sw.show_all()
-        component.get("Preferences").add_page(
-            _("AutoAdd"), self.glade.get_widget("prefs_box")
-        )
-
-    def disable(self):
-        component.get("Preferences").remove_page(_("AutoAdd"))
-        component.get("PluginManager").deregister_hook(
-            "on_apply_prefs", self.on_apply_prefs
-        )
-        component.get("PluginManager").deregister_hook(
-            "on_show_prefs", self.on_show_prefs
-        )
-
-    def create_model(self):
-        store = gtk.ListStore(str, bool, str, str)
-        for watchdir_id, watchdir in self.watchdirs.iteritems():
-            store.append([
-                watchdir_id, watchdir['enabled'],
-                watchdir.get('owner', 'localclient'), watchdir['path']
-            ])
-        return store
-
-    def create_columns(self, treeView):
-        rendererToggle = gtk.CellRendererToggle()
-        column = gtk.TreeViewColumn(
-            _("Active"), rendererToggle, activatable=1, active=1
-        )
-        column.set_sort_column_id(1)
-        treeView.append_column(column)
-        tt = gtk.Tooltip()
-        tt.set_text(_('Double-click to toggle'))
-        treeView.set_tooltip_cell(tt, None, None, rendererToggle)
-
-        rendererText = gtk.CellRendererText()
-        column = gtk.TreeViewColumn(_("Owner"), rendererText, text=2)
-        column.set_sort_column_id(2)
-        treeView.append_column(column)
-        tt2 = gtk.Tooltip()
-        tt2.set_text(_('Double-click to edit'))
-        treeView.set_has_tooltip(True)
-
-        rendererText = gtk.CellRendererText()
-        column = gtk.TreeViewColumn(_("Path"), rendererText, text=3)
-        column.set_sort_column_id(3)
-        treeView.append_column(column)
-        tt2 = gtk.Tooltip()
-        tt2.set_text(_('Double-click to edit'))
-        treeView.set_has_tooltip(True)
-
-    def load_watchdir_list(self):
-        pass
-
-    def add_watchdir_entry(self):
-        pass
-
-    def on_add_button_clicked(self, Event=None):
-        #display options_window
-        self.opts_dialog.show()
-
-    def on_remove_button_clicked(self, Event=None):
-        tree, tree_id = self.treeView.get_selection().get_selected()
-        watchdir_id = str(self.store.get_value(tree_id, 0))
-        if watchdir_id:
-            client.autoadd.remove(watchdir_id)
-
-    def on_edit_button_clicked(self, Event=None, a=None, col=None):
-        tree, tree_id = self.treeView.get_selection().get_selected()
-        watchdir_id = str(self.store.get_value(tree_id, 0))
-        if watchdir_id:
-            if col and col.get_title() == _("Active"):
-                if self.watchdirs[watchdir_id]['enabled']:
-                    client.autoadd.disable_watchdir(watchdir_id)
-                else:
-                    client.autoadd.enable_watchdir(watchdir_id)
-            else:
-                self.opts_dialog.show(self.watchdirs[watchdir_id], watchdir_id)
-
-    def on_listitem_activated(self, treeview):
-        tree, tree_id = self.treeView.get_selection().get_selected()
-        if tree_id:
-            self.glade.get_widget('edit_button').set_sensitive(True)
-            self.glade.get_widget('remove_button').set_sensitive(True)
-        else:
-            self.glade.get_widget('edit_button').set_sensitive(False)
-            self.glade.get_widget('remove_button').set_sensitive(False)
-
-    def on_apply_prefs(self):
-        log.debug("applying prefs for AutoAdd")
-        for watchdir_id, watchdir in self.watchdirs.iteritems():
-            client.autoadd.set_options(watchdir_id, watchdir)
-
-    def on_show_prefs(self):
-        client.autoadd.get_watchdirs().addCallback(self.cb_get_config)
-
-    def on_options_changed_event(self):
-        client.autoadd.get_watchdirs().addCallback(self.cb_get_config)
-
-    def cb_get_config(self, watchdirs):
-        """callback for on show_prefs"""
-        log.trace("Got whatchdirs from core: %s", watchdirs)
-        self.watchdirs = watchdirs or {}
-        self.store.clear()
-        for watchdir_id, watchdir in self.watchdirs.iteritems():
-            self.store.append([
-                watchdir_id, watchdir['enabled'],
-                watchdir.get('owner', 'localclient'), watchdir['path']
-            ])
-        # Workaround for cached glade signal appearing when re-enabling plugin in same session
-        if self.glade.get_widget('edit_button'):
-            # Disable the remove and edit buttons, because nothing in the store is selected
-            self.glade.get_widget('remove_button').set_sensitive(False)
-            self.glade.get_widget('edit_button').set_sensitive(False)

deluge/plugins/AutoAdd/deluge/plugins/autoadd/webui.py

@@ -1,57 +0,0 @@
-#
-# webui.py
-#
-# Copyright (C) 2009 GazpachoKing <chase.sterling@gmail.com>
-#
-# Basic plugin template created by:
-# Copyright (C) 2008 Martijn Voncken <mvoncken@gmail.com>
-# Copyright (C) 2007-2009 Andrew Resch <andrewresch@gmail.com>
-# Copyright (C) 2009 Damien Churchill <damoxc@gmail.com>
-#
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
-
-import logging
-from deluge.ui.client import client
-from deluge import component
-from deluge.plugins.pluginbase import WebPluginBase
-
-from common import get_resource
-
-log = logging.getLogger(__name__)
-
-class WebUI(WebPluginBase):
-
-    scripts = [get_resource("autoadd.js")]
-
-    def enable(self):
-        pass
-
-    def disable(self):
-        pass

deluge/plugins/AutoAdd/deluge_autoadd/__init__.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2009 GazpachoKing <chase.sterling@gmail.com>
+#
+# Basic plugin template created by:
+# Copyright (C) 2008 Martijn Voncken <mvoncken@gmail.com>
+# Copyright (C) 2007-2009 Andrew Resch <andrewresch@gmail.com>
+# Copyright (C) 2009 Damien Churchill <damoxc@gmail.com>
+#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
+#
+
+from __future__ import unicode_literals
+
+from deluge.plugins.init import PluginInitBase
+
+
+class CorePlugin(PluginInitBase):
+    def __init__(self, plugin_name):
+        from .core import Core as _pluginCls
+
+        self._plugin_cls = _pluginCls
+        super(CorePlugin, self).__init__(plugin_name)
+
+
+class Gtk3UIPlugin(PluginInitBase):
+    def __init__(self, plugin_name):
+        from .gtkui import GtkUI as _pluginCls
+
+        self._plugin_cls = _pluginCls
+        super(Gtk3UIPlugin, self).__init__(plugin_name)
+
+
+class WebUIPlugin(PluginInitBase):
+    def __init__(self, plugin_name):
+        from .webui import WebUI as _pluginCls
+
+        self._plugin_cls = _pluginCls
+        super(WebUIPlugin, self).__init__(plugin_name)

deluge/plugins/AutoAdd/deluge_autoadd/common.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+#
+# Basic plugin template created by:
+# Copyright (C) 2008 Martijn Voncken <mvoncken@gmail.com>
+#               2007-2009 Andrew Resch <andrewresch@gmail.com>
+#               2009 Damien Churchill <damoxc@gmail.com>
+#               2010 Pedro Algarvio <pedro@algarvio.me>
+#               2017 Calum Lind <calumlind+deluge@gmail.com>
+#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
+#
+
+from __future__ import unicode_literals
+
+import os.path
+
+from pkg_resources import resource_filename
+
+
+def get_resource(filename, subdir=False):
+    folder = os.path.join('data', 'autoadd_options') if subdir else 'data'
+    return resource_filename(__package__, os.path.join(folder, filename))

deluge/plugins/AutoAdd/deluge_autoadd/core.py

@@ -0,0 +1,522 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2009 GazpachoKing <chase.sterling@gmail.com>
+# Copyright (C) 2011 Pedro Algarvio <pedro@algarvio.me>
+#
+# Basic plugin template created by:
+# Copyright (C) 2008 Martijn Voncken <mvoncken@gmail.com>
+# Copyright (C) 2007-2009 Andrew Resch <andrewresch@gmail.com>
+# Copyright (C) 2009 Damien Churchill <damoxc@gmail.com>
+#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
+#
+
+from __future__ import unicode_literals
+
+import logging
+import os
+import shutil
+from base64 import b64encode
+
+from twisted.internet import reactor
+from twisted.internet.task import LoopingCall, deferLater
+
+import deluge.component as component
+import deluge.configmanager
+from deluge._libtorrent import lt
+from deluge.common import AUTH_LEVEL_ADMIN, is_magnet
+from deluge.core.rpcserver import export
+from deluge.error import AddTorrentError
+from deluge.event import DelugeEvent
+from deluge.plugins.pluginbase import CorePluginBase
+
+log = logging.getLogger(__name__)
+
+
+DEFAULT_PREFS = {'watchdirs': {}, 'next_id': 1}
+
+
+OPTIONS_AVAILABLE = {  # option: builtin
+    'enabled': False,
+    'path': False,
+    'append_extension': False,
+    'copy_torrent': False,
+    'delete_copy_torrent_toggle': False,
+    'abspath': False,
+    'download_location': True,
+    'max_download_speed': True,
+    'max_upload_speed': True,
+    'max_connections': True,
+    'max_upload_slots': True,
+    'prioritize_first_last': True,
+    'auto_managed': True,
+    'stop_at_ratio': True,
+    'stop_ratio': True,
+    'remove_at_ratio': True,
+    'move_completed': True,
+    'move_completed_path': True,
+    'label': False,
+    'add_paused': True,
+    'queue_to_top': False,
+    'owner': True,
+    'seed_mode': True,
+}
+
+MAX_NUM_ATTEMPTS = 10
+
+
+class AutoaddOptionsChangedEvent(DelugeEvent):
+    """Emitted when the options for the plugin are changed."""
+
+    def __init__(self):
+        pass
+
+
+def check_input(cond, message):
+    if not cond:
+        raise Exception(message)
+
+
+class Core(CorePluginBase):
+    def enable(self):
+
+        # reduce typing, assigning some values to self...
+        self.config = deluge.configmanager.ConfigManager('autoadd.conf', DEFAULT_PREFS)
+        self.config.run_converter((0, 1), 2, self.__migrate_config_1_to_2)
+        self.config.save()
+        self.watchdirs = self.config['watchdirs']
+
+        self.rpcserver = component.get('RPCServer')
+        component.get('EventManager').register_event_handler(
+            'PreTorrentRemovedEvent', self.__on_pre_torrent_removed
+        )
+
+        # Dict of Filename:Attempts
+        self.invalid_torrents = {}
+        # Loopingcall timers for each enabled watchdir
+        self.update_timers = {}
+        deferLater(reactor, 5, self.enable_looping)
+
+    def enable_looping(self):
+        # Enable all looping calls for enabled watchdirs here
+        for watchdir_id, watchdir in self.watchdirs.items():
+            if watchdir['enabled']:
+                self.enable_watchdir(watchdir_id)
+
+    def disable(self):
+        # disable all running looping calls
+        component.get('EventManager').deregister_event_handler(
+            'PreTorrentRemovedEvent', self.__on_pre_torrent_removed
+        )
+        for loopingcall in self.update_timers.values():
+            loopingcall.stop()
+        self.config.save()
+
+    def update(self):
+        pass
+
+    @export
+    def set_options(self, watchdir_id, options):
+        """Update the options for a watch folder."""
+        watchdir_id = str(watchdir_id)
+        options = self._make_unicode(options)
+        check_input(watchdir_id in self.watchdirs, _('Watch folder does not exist.'))
+        if 'path' in options:
+            options['abspath'] = os.path.abspath(options['path'])
+            check_input(os.path.isdir(options['abspath']), _('Path does not exist.'))
+            for w_id, w in self.watchdirs.items():
+                if options['abspath'] == w['abspath'] and watchdir_id != w_id:
+                    raise Exception('Path is already being watched.')
+        for key in options:
+            if key not in OPTIONS_AVAILABLE:
+                if key not in [key2 + '_toggle' for key2 in OPTIONS_AVAILABLE]:
+                    raise Exception('autoadd: Invalid options key:%s' % key)
+        # disable the watch loop if it was active
+        if watchdir_id in self.update_timers:
+            self.disable_watchdir(watchdir_id)
+
+        self.watchdirs[watchdir_id].update(options)
+        # re-enable watch loop if appropriate
+        if self.watchdirs[watchdir_id]['enabled']:
+            self.enable_watchdir(watchdir_id)
+        self.config.save()
+        component.get('EventManager').emit(AutoaddOptionsChangedEvent())
+
+    def load_torrent(self, filename, magnet):
+        log.debug('Attempting to open %s for add.', filename)
+        file_mode = 'r' if magnet else 'rb'
+        try:
+            with open(filename, file_mode) as _file:
+                filedump = _file.read()
+        except IOError as ex:
+            log.warning('Unable to open %s: %s', filename, ex)
+            raise ex
+
+        if not filedump:
+            raise EOFError('Torrent is 0 bytes!')
+
+        # Get the info to see if any exceptions are raised
+        if not magnet:
+            lt.torrent_info(lt.bdecode(filedump))
+
+        return filedump
+
+    def split_magnets(self, filename):
+        log.debug('Attempting to open %s for splitting magnets.', filename)
+        magnets = []
+        try:
+            with open(filename, 'r') as _file:
+                magnets = list(filter(len, _file.read().splitlines()))
+        except IOError as ex:
+            log.warning('Unable to open %s: %s', filename, ex)
+
+        if len(magnets) < 2:
+            return []
+
+        path = filename.rsplit(os.sep, 1)[0]
+        for magnet in magnets:
+            if not is_magnet(magnet):
+                log.warning('Found line which is not a magnet: %s', magnet)
+                continue
+
+            for part in magnet.split('&'):
+                if part.startswith('dn='):
+                    name = part[3:].strip()
+                    if name:
+                        mname = os.sep.join([path, name + '.magnet'])
+                        break
+            else:
+                short_hash = magnet.split('btih:')[1][:8]
+                mname = '.'.join([os.path.splitext(filename)[0], short_hash, 'magnet'])
+
+            try:
+                with open(mname, 'w') as _mfile:
+                    _mfile.write(magnet)
+            except IOError as ex:
+                log.warning('Unable to open %s: %s', mname, ex)
+        return magnets
+
+    def update_watchdir(self, watchdir_id):
+        """Check the watch folder for new torrents to add."""
+        log.trace('Updating watchdir id: %s', watchdir_id)
+        watchdir_id = str(watchdir_id)
+        watchdir = self.watchdirs[watchdir_id]
+        if not watchdir['enabled']:
+            # We shouldn't be updating because this watchdir is not enabled
+            log.debug('Watchdir id %s is not enabled. Disabling it.', watchdir_id)
+            self.disable_watchdir(watchdir_id)
+            return
+
+        if not os.path.isdir(watchdir['abspath']):
+            log.warning('Invalid AutoAdd folder: %s', watchdir['abspath'])
+            self.disable_watchdir(watchdir_id)
+            return
+
+        # Generate options dict for watchdir
+        options = {}
+        if 'stop_at_ratio_toggle' in watchdir:
+            watchdir['stop_ratio_toggle'] = watchdir['stop_at_ratio_toggle']
+        # We default to True when reading _toggle values, so a config
+        # without them is valid, and applies all its settings.
+        for option, value in watchdir.items():
+            if OPTIONS_AVAILABLE.get(option):
+                if watchdir.get(option + '_toggle', True) or option in [
+                    'owner',
+                    'seed_mode',
+                ]:
+                    options[option] = value
+
+        # Check for .magnet files containing multiple magnet links and
+        # create a new .magnet file for each of them.
+        for filename in os.listdir(watchdir['abspath']):
+            try:
+                filepath = os.path.join(watchdir['abspath'], filename)
+            except UnicodeDecodeError as ex:
+                log.error(
+                    'Unable to auto add torrent due to improper filename encoding: %s',
+                    ex,
+                )
+                continue
+            if os.path.isdir(filepath):
+                # Skip directories
+                continue
+            elif os.path.splitext(filename)[1] == '.magnet' and self.split_magnets(
+                filepath
+            ):
+                os.remove(filepath)
+
+        for filename in os.listdir(watchdir['abspath']):
+            try:
+                filepath = os.path.join(watchdir['abspath'], filename)
+            except UnicodeDecodeError as ex:
+                log.error(
+                    'Unable to auto add torrent due to improper filename encoding: %s',
+                    ex,
+                )
+                continue
+
+            if os.path.isdir(filepath):
+                # Skip directories
+                continue
+
+            ext = os.path.splitext(filename)[1].lower()
+            magnet = ext == '.magnet'
+            if not magnet and not ext == '.torrent':
+                log.debug('File checked for auto-loading is invalid: %s', filename)
+                continue
+
+            try:
+                filedump = self.load_torrent(filepath, magnet)
+            except (IOError, EOFError) as ex:
+                # If torrent is invalid, keep track of it so can try again on the next pass.
+                # This catches torrent files that may not be fully saved to disk at load time.
+                log.debug('Torrent is invalid: %s', ex)
+                if filename in self.invalid_torrents:
+                    self.invalid_torrents[filename] += 1
+                    if self.invalid_torrents[filename] >= MAX_NUM_ATTEMPTS:
+                        log.warning(
+                            'Maximum attempts reached while trying to add the '
+                            'torrent file with the path %s',
+                            filepath,
+                        )
+                        os.rename(filepath, filepath + '.invalid')
+                        del self.invalid_torrents[filename]
+                else:
+                    self.invalid_torrents[filename] = 1
+                continue
+
+            def on_torrent_added(torrent_id, filename, filepath):
+                if 'Label' in component.get('CorePluginManager').get_enabled_plugins():
+                    if watchdir.get('label_toggle', True) and watchdir.get('label'):
+                        label = component.get('CorePlugin.Label')
+                        if not watchdir['label'] in label.get_labels():
+                            label.add(watchdir['label'])
+                        try:
+                            label.set_torrent(torrent_id, watchdir['label'])
+                        except Exception as ex:
+                            log.error('Unable to set label: %s', ex)
+
+                if (
+                    watchdir.get('queue_to_top_toggle', True)
+                    and 'queue_to_top' in watchdir
+                ):
+                    if watchdir['queue_to_top']:
+                        component.get('TorrentManager').queue_top(torrent_id)
+                    else:
+                        component.get('TorrentManager').queue_bottom(torrent_id)
+
+                # Rename, copy or delete the torrent once added to deluge.
+                if watchdir.get('append_extension_toggle'):
+                    if not watchdir.get('append_extension'):
+                        watchdir['append_extension'] = '.added'
+                    os.rename(filepath, filepath + watchdir['append_extension'])
+                elif watchdir.get('copy_torrent_toggle'):
+                    copy_torrent_path = watchdir['copy_torrent']
+                    copy_torrent_file = os.path.join(copy_torrent_path, filename)
+                    log.debug(
+                        'Moving added torrent file "%s" to "%s"',
+                        os.path.basename(filepath),
+                        copy_torrent_path,
+                    )
+                    shutil.move(filepath, copy_torrent_file)
+                else:
+                    os.remove(filepath)
+
+            def fail_torrent_add(err_msg, filepath, magnet):
+                # torrent handle is invalid and so is the magnet link
+                log.error(
+                    'Cannot Autoadd %s: %s: %s',
+                    'magnet' if magnet else 'torrent file',
+                    filepath,
+                    err_msg,
+                )
+                os.rename(filepath, filepath + '.invalid')
+
+            try:
+                # The torrent looks good, so lets add it to the session.
+                if magnet:
+                    d = component.get('Core').add_torrent_magnet(
+                        filedump.strip(), options
+                    )
+                else:
+                    d = component.get('Core').add_torrent_file_async(
+                        filename, b64encode(filedump), options
+                    )
+                    d.addCallback(on_torrent_added, filename, filepath)
+                    d.addErrback(fail_torrent_add, filepath, magnet)
+            except AddTorrentError as ex:
+                fail_torrent_add(str(ex), filepath, magnet)
+
+    def on_update_watchdir_error(self, failure, watchdir_id):
+        """Disables any watch folders with un-handled exceptions."""
+        self.disable_watchdir(watchdir_id)
+        log.error(
+            'Disabling "%s", error during update: %s',
+            self.watchdirs[watchdir_id]['path'],
+            failure,
+        )
+
+    @export
+    def enable_watchdir(self, watchdir_id):
+        w_id = str(watchdir_id)
+        # Enable the looping call
+        if w_id not in self.update_timers or not self.update_timers[w_id].running:
+            self.update_timers[w_id] = LoopingCall(self.update_watchdir, w_id)
+            self.update_timers[w_id].start(5).addErrback(
+                self.on_update_watchdir_error, w_id
+            )
+        # Update the config
+        if not self.watchdirs[w_id]['enabled']:
+            self.watchdirs[w_id]['enabled'] = True
+            self.config.save()
+            component.get('EventManager').emit(AutoaddOptionsChangedEvent())
+
+    @export
+    def disable_watchdir(self, watchdir_id):
+        w_id = str(watchdir_id)
+        # Disable the looping call
+        if w_id in self.update_timers:
+            if self.update_timers[w_id].running:
+                self.update_timers[w_id].stop()
+            del self.update_timers[w_id]
+        # Update the config
+        if self.watchdirs[w_id]['enabled']:
+            self.watchdirs[w_id]['enabled'] = False
+            self.config.save()
+            component.get('EventManager').emit(AutoaddOptionsChangedEvent())
+
+    @export
+    def set_config(self, config):
+        """Sets the config dictionary."""
+        config = self._make_unicode(config)
+        for key in config:
+            self.config[key] = config[key]
+        self.config.save()
+        component.get('EventManager').emit(AutoaddOptionsChangedEvent())
+
+    @export
+    def get_config(self):
+        """Returns the config dictionary."""
+        return self.config.config
+
+    @export
+    def get_watchdirs(self):
+        session_user = self.rpcserver.get_session_user()
+        session_auth_level = self.rpcserver.get_session_auth_level()
+        if session_auth_level == AUTH_LEVEL_ADMIN:
+            log.debug(
+                'Current logged in user %s is an ADMIN, send all ' 'watchdirs',
+                session_user,
+            )
+            return self.watchdirs
+
+        watchdirs = {}
+        for watchdir_id, watchdir in self.watchdirs.items():
+            if watchdir.get('owner', 'localclient') == session_user:
+                watchdirs[watchdir_id] = watchdir
+
+        log.debug(
+            'Current logged in user %s is not an ADMIN, send only '
+            'their watchdirs: %s',
+            session_user,
+            list(watchdirs),
+        )
+        return watchdirs
+
+    def _make_unicode(self, options):
+        opts = {}
+        for key in options:
+            if isinstance(options[key], bytes):
+                options[key] = options[key].decode('utf8')
+            opts[key] = options[key]
+        return opts
+
+    @export
+    def add(self, options=None):
+        """Add a watch folder."""
+        if options is None:
+            options = {}
+        options = self._make_unicode(options)
+        abswatchdir = os.path.abspath(options['path'])
+        check_input(os.path.isdir(abswatchdir), _('Path does not exist.'))
+        check_input(
+            os.access(abswatchdir, os.R_OK | os.W_OK),
+            'You must have read and write access to watch folder.',
+        )
+        if abswatchdir in [wd['abspath'] for wd in self.watchdirs.values()]:
+            raise Exception('Path is already being watched.')
+        options.setdefault('enabled', False)
+        options['abspath'] = abswatchdir
+        watchdir_id = self.config['next_id']
+        self.watchdirs[str(watchdir_id)] = options
+        if options.get('enabled'):
+            self.enable_watchdir(watchdir_id)
+        self.config['next_id'] = watchdir_id + 1
+        self.config.save()
+        component.get('EventManager').emit(AutoaddOptionsChangedEvent())
+        return watchdir_id
+
+    @export
+    def remove(self, watchdir_id):
+        """Remove a watch folder."""
+        watchdir_id = str(watchdir_id)
+        check_input(
+            watchdir_id in self.watchdirs, 'Unknown Watchdir: %s' % self.watchdirs
+        )
+        if self.watchdirs[watchdir_id]['enabled']:
+            self.disable_watchdir(watchdir_id)
+        del self.watchdirs[watchdir_id]
+        self.config.save()
+        component.get('EventManager').emit(AutoaddOptionsChangedEvent())
+
+    def __migrate_config_1_to_2(self, config):
+        for watchdir_id in config['watchdirs']:
+            config['watchdirs'][watchdir_id]['owner'] = 'localclient'
+        return config
+
+    def __on_pre_torrent_removed(self, torrent_id):
+        try:
+            torrent = component.get('TorrentManager')[torrent_id]
+        except KeyError:
+            log.warning(
+                'Unable to remove torrent file for torrent id %s. It'
+                'was already deleted from the TorrentManager',
+                torrent_id,
+            )
+            return
+        torrent_fname = torrent.filename
+        for watchdir in self.watchdirs.values():
+            if not watchdir.get('copy_torrent_toggle', False):
+                # This watchlist does copy torrents
+                continue
+            elif not watchdir.get('delete_copy_torrent_toggle', False):
+                # This watchlist is not set to delete finished torrents
+                continue
+            copy_torrent_path = watchdir['copy_torrent']
+            torrent_fname_path = os.path.join(copy_torrent_path, torrent_fname)
+            if os.path.isfile(torrent_fname_path):
+                try:
+                    os.remove(torrent_fname_path)
+                    log.info(
+                        'Removed torrent file "%s" from "%s"',
+                        torrent_fname,
+                        copy_torrent_path,
+                    )
+                    break
+                except OSError as ex:
+                    log.info(
+                        'Failed to removed torrent file "%s" from "%s": %s',
+                        torrent_fname,
+                        copy_torrent_path,
+                        ex,
+                    )
+
+    @export
+    def is_admin_level(self):
+        return self.rpcserver.get_session_auth_level() == deluge.common.AUTH_LEVEL_ADMIN
+
+    @export
+    def get_auth_user(self):
+        return self.rpcserver.get_session_user()

deluge/plugins/AutoAdd/deluge_autoadd/data/autoadd.js

@@ -0,0 +1,239 @@
+/**
+ * Script: autoadd.js
+ *      The client-side javascript code for the AutoAdd plugin.
+ *
+ * Copyright (C) 2009 GazpachoKing <chase.sterling@gmail.com>
+ *
+ * This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+ * the additional special exception to link portions of this program with the OpenSSL library.
+ * See LICENSE for more details.
+ */
+
+Ext.ns('Deluge.ux.AutoAdd');
+Deluge.ux.AutoAdd.onClickFunctions = {};
+
+Ext.ns('Deluge.ux.preferences');
+
+/**
+ * @class Deluge.ux.preferences.AutoAddPage
+ * @extends Ext.Panel
+ */
+Deluge.ux.preferences.AutoAddPage = Ext.extend(Ext.Panel, {
+    title: _('AutoAdd'),
+    header: false,
+    layout: 'fit',
+    border: false,
+    watchdirs: {},
+
+    initComponent: function() {
+        Deluge.ux.preferences.AutoAddPage.superclass.initComponent.call(this);
+
+        var autoAdd = this;
+
+        this.list = new Ext.list.ListView({
+            store: new Ext.data.JsonStore({
+                fields: ['id', 'enabled', 'owner', 'path'],
+            }),
+            columns: [
+                {
+                    id: 'enabled',
+                    header: _('Active'),
+                    sortable: true,
+                    dataIndex: 'enabled',
+                    tpl: new Ext.XTemplate('{enabled:this.getCheckbox}', {
+                        getCheckbox: function(checked, selected) {
+                            Deluge.ux.AutoAdd.onClickFunctions[
+                                selected.id
+                            ] = function() {
+                                if (selected.enabled) {
+                                    deluge.client.autoadd.disable_watchdir(
+                                        selected.id
+                                    );
+                                    checked = false;
+                                } else {
+                                    deluge.client.autoadd.enable_watchdir(
+                                        selected.id
+                                    );
+                                    checked = true;
+                                }
+                                autoAdd.updateWatchDirs();
+                            };
+                            return (
+                                '<input id="enabled-' +
+                                selected.id +
+                                '" type="checkbox"' +
+                                (checked ? ' checked' : '') +
+                                ' onclick="Deluge.ux.AutoAdd.onClickFunctions[' +
+                                selected.id +
+                                ']()" />'
+                            );
+                        },
+                    }),
+                    width: 0.15,
+                },
+                {
+                    id: 'owner',
+                    header: _('Owner'),
+                    sortable: true,
+                    dataIndex: 'owner',
+                    width: 0.2,
+                },
+                {
+                    id: 'path',
+                    header: _('Path'),
+                    sortable: true,
+                    dataIndex: 'path',
+                },
+            ],
+            singleSelect: true,
+            autoExpandColumn: 'path',
+        });
+        this.list.on('selectionchange', this.onSelectionChange, this);
+
+        this.panel = this.add({
+            items: [this.list],
+            bbar: {
+                items: [
+                    {
+                        text: _('Add'),
+                        iconCls: 'icon-add',
+                        handler: this.onAddClick,
+                        scope: this,
+                    },
+                    {
+                        text: _('Edit'),
+                        iconCls: 'icon-edit',
+                        handler: this.onEditClick,
+                        scope: this,
+                        disabled: true,
+                    },
+                    '->',
+                    {
+                        text: _('Remove'),
+                        iconCls: 'icon-remove',
+                        handler: this.onRemoveClick,
+                        scope: this,
+                        disabled: true,
+                    },
+                ],
+            },
+        });
+
+        this.on('show', this.onPreferencesShow, this);
+    },
+
+    updateWatchDirs: function() {
+        deluge.client.autoadd.get_watchdirs({
+            success: function(watchdirs) {
+                this.watchdirs = watchdirs;
+                var watchdirsArray = [];
+                for (var id in watchdirs) {
+                    if (watchdirs.hasOwnProperty(id)) {
+                        var watchdir = {};
+                        watchdir['id'] = id;
+                        watchdir['enabled'] = watchdirs[id].enabled;
+                        watchdir['owner'] =
+                            watchdirs[id].owner || 'localclient';
+                        watchdir['path'] = watchdirs[id].path;
+
+                        watchdirsArray.push(watchdir);
+                    }
+                }
+                this.list.getStore().loadData(watchdirsArray);
+            },
+            scope: this,
+        });
+    },
+
+    onAddClick: function() {
+        if (!this.addWin) {
+            this.addWin = new Deluge.ux.AutoAdd.AddAutoAddCommandWindow();
+            this.addWin.on(
+                'watchdiradd',
+                function() {
+                    this.updateWatchDirs();
+                },
+                this
+            );
+        }
+        this.addWin.show();
+    },
+
+    onEditClick: function() {
+        if (!this.editWin) {
+            this.editWin = new Deluge.ux.AutoAdd.EditAutoAddCommandWindow();
+            this.editWin.on(
+                'watchdiredit',
+                function() {
+                    this.updateWatchDirs();
+                },
+                this
+            );
+        }
+        var id = this.list.getSelectedRecords()[0].id;
+        this.editWin.show(id, this.watchdirs[id]);
+    },
+
+    onPreferencesShow: function() {
+        this.updateWatchDirs();
+    },
+
+    onRemoveClick: function() {
+        var record = this.list.getSelectedRecords()[0];
+        deluge.client.autoadd.remove(record.id, {
+            success: function() {
+                this.updateWatchDirs();
+            },
+            scope: this,
+        });
+    },
+
+    onSelectionChange: function(dv, selections) {
+        if (selections.length) {
+            this.panel
+                .getBottomToolbar()
+                .items.get(1)
+                .enable();
+            this.panel
+                .getBottomToolbar()
+                .items.get(3)
+                .enable();
+        } else {
+            this.panel
+                .getBottomToolbar()
+                .items.get(1)
+                .disable();
+            this.panel
+                .getBottomToolbar()
+                .items.get(3)
+                .disable();
+        }
+    },
+});
+
+Deluge.plugins.AutoAddPlugin = Ext.extend(Deluge.Plugin, {
+    name: 'AutoAdd',
+
+    static: {
+        prefsPage: null,
+    },
+
+    onDisable: function() {
+        deluge.preferences.removePage(Deluge.plugins.AutoAddPlugin.prefsPage);
+        Deluge.plugins.AutoAddPlugin.prefsPage = null;
+    },
+
+    onEnable: function() {
+        /*
+         * Called for each of the JavaScript files.
+         * This will prevent adding unnecessary tabs to the preferences window.
+         */
+        if (!Deluge.plugins.AutoAddPlugin.prefsPage) {
+            Deluge.plugins.AutoAddPlugin.prefsPage = deluge.preferences.addPage(
+                new Deluge.ux.preferences.AutoAddPage()
+            );
+        }
+    },
+});
+
+Deluge.registerPlugin('AutoAdd', Deluge.plugins.AutoAddPlugin);

deluge/plugins/AutoAdd/deluge_autoadd/data/autoadd_options.js

@@ -0,0 +1,475 @@
+/**
+ * Script: autoadd.js
+ *      The client-side javascript code for the AutoAdd plugin.
+ *
+ * Copyright (C) 2009 GazpachoKing <chase.sterling@gmail.com>
+ *
+ * This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+ * the additional special exception to link portions of this program with the OpenSSL library.
+ * See LICENSE for more details.
+ */
+
+Ext.ns('Deluge.ux.AutoAdd');
+
+/**
+ * @class Deluge.ux.AutoAdd.AutoAddWindowBase
+ * @extends Ext.Window
+ */
+Deluge.ux.AutoAdd.AutoAddWindowBase = Ext.extend(Ext.Window, {
+    width: 350,
+    autoHeight: true,
+    closeAction: 'hide',
+
+    spin_ids: ['max_download_speed', 'max_upload_speed', 'stop_ratio'],
+    spin_int_ids: ['max_upload_slots', 'max_connections'],
+    chk_ids: [
+        'stop_at_ratio',
+        'remove_at_ratio',
+        'move_completed',
+        'add_paused',
+        'auto_managed',
+        'queue_to_top',
+    ],
+    toggle_ids: [
+        'append_extension_toggle',
+        'download_location_toggle',
+        'label_toggle',
+        'copy_torrent_toggle',
+        'delete_copy_torrent_toggle',
+        'seed_mode',
+    ],
+
+    accounts: new Ext.data.ArrayStore({
+        storeId: 'accountStore',
+        id: 0,
+        fields: [
+            {
+                name: 'displayText',
+                type: 'string',
+            },
+        ],
+    }),
+    labels: new Ext.data.ArrayStore({
+        storeId: 'labelStore',
+        id: 0,
+        fields: [
+            {
+                name: 'displayText',
+                type: 'string',
+            },
+        ],
+    }),
+
+    initComponent: function() {
+        Deluge.ux.AutoAdd.AutoAddWindowBase.superclass.initComponent.call(this);
+        this.addButton(_('Cancel'), this.onCancelClick, this);
+
+        this.MainTab = new Deluge.ux.AutoAdd.AutoAddMainPanel();
+        this.OptionsTab = new Deluge.ux.AutoAdd.AutoAddOptionsPanel();
+
+        this.form = this.add({
+            xtype: 'form',
+            baseCls: 'x-plain',
+            bodyStyle: 'padding: 5px',
+            items: [
+                {
+                    xtype: 'tabpanel',
+                    activeTab: 0,
+                    items: [this.MainTab, this.OptionsTab],
+                },
+            ],
+        });
+    },
+
+    onCancelClick: function() {
+        this.hide();
+    },
+
+    getOptions: function() {
+        var options = {};
+
+        options['enabled'] = Ext.getCmp('enabled').getValue();
+        options['path'] = Ext.getCmp('path').getValue();
+        options['download_location'] = Ext.getCmp(
+            'download_location'
+        ).getValue();
+        options['move_completed_path'] = Ext.getCmp(
+            'move_completed_path'
+        ).getValue();
+        options['copy_torrent'] = Ext.getCmp('copy_torrent').getValue();
+
+        options['label'] = Ext.getCmp('label').getValue();
+        options['append_extension'] = Ext.getCmp('append_extension').getValue();
+        options['owner'] = Ext.getCmp('owner').getValue();
+
+        this.toggle_ids.forEach(function(toggle_id) {
+            options[toggle_id] = Ext.getCmp(toggle_id).getValue();
+        });
+        this.spin_ids.forEach(function(spin_id) {
+            options[spin_id] = Ext.getCmp(spin_id).getValue();
+            options[spin_id + '_toggle'] = Ext.getCmp(
+                spin_id + '_toggle'
+            ).getValue();
+        });
+        this.spin_int_ids.forEach(function(spin_int_id) {
+            options[spin_int_id] = Ext.getCmp(spin_int_id).getValue();
+            options[spin_int_id + '_toggle'] = Ext.getCmp(
+                spin_int_id + '_toggle'
+            ).getValue();
+        });
+        this.chk_ids.forEach(function(chk_id) {
+            options[chk_id] = Ext.getCmp(chk_id).getValue();
+            options[chk_id + '_toggle'] = Ext.getCmp(
+                chk_id + '_toggle'
+            ).getValue();
+        });
+
+        if (
+            options['copy_torrent_toggle'] &&
+            options['path'] === options['copy_torrent']
+        ) {
+            throw _(
+                '"Watch Folder" directory and "Copy of .torrent' +
+                    ' files to" directory cannot be the same!'
+            );
+        }
+
+        return options;
+    },
+
+    loadOptions: function(options) {
+        /*
+         * Populate all available options data to the UI
+         */
+        var value;
+
+        if (options === undefined) {
+            options = {};
+        }
+        Ext.getCmp('enabled').setValue(
+            options['enabled'] !== undefined ? options['enabled'] : true
+        );
+        Ext.getCmp('isnt_append_extension').setValue(true);
+        Ext.getCmp('append_extension_toggle').setValue(
+            options['append_extension_toggle'] !== undefined
+                ? options['append_extension_toggle']
+                : false
+        );
+        Ext.getCmp('append_extension').setValue(
+            options['append_extension'] !== undefined
+                ? options['append_extension']
+                : '.added'
+        );
+        Ext.getCmp('download_location_toggle').setValue(
+            options['download_location_toggle'] !== undefined
+                ? options['download_location_toggle']
+                : false
+        );
+        Ext.getCmp('copy_torrent_toggle').setValue(
+            options['copy_torrent_toggle'] !== undefined
+                ? options['copy_torrent_toggle']
+                : false
+        );
+        Ext.getCmp('delete_copy_torrent_toggle').setValue(
+            options['delete_copy_torrent_toggle'] !== undefined
+                ? options['delete_copy_torrent_toggle']
+                : false
+        );
+
+        value =
+            options['seed_mode'] !== undefined ? options['seed_mode'] : false;
+        Ext.getCmp('seed_mode').setValue(value);
+
+        this.accounts.removeAll(true);
+        this.labels.removeAll(true);
+        Ext.getCmp('owner').store = this.accounts;
+        Ext.getCmp('label').store = this.labels;
+        Ext.getCmp('label').setValue(
+            options['label'] !== undefined ? options['label'] : ''
+        );
+        Ext.getCmp('label_toggle').setValue(
+            options['label_toggle'] !== undefined
+                ? options['label_toggle']
+                : false
+        );
+
+        this.spin_ids.forEach(function(spin_id) {
+            Ext.getCmp(spin_id).setValue(
+                options[spin_id] !== undefined ? options[spin_id] : 0
+            );
+            Ext.getCmp(spin_id + '_toggle').setValue(
+                options[spin_id + '_toggle'] !== undefined
+                    ? options[spin_id + '_toggle']
+                    : false
+            );
+        });
+        this.chk_ids.forEach(function(chk_id) {
+            Ext.getCmp(chk_id).setValue(
+                options[chk_id] !== undefined ? options[chk_id] : true
+            );
+            Ext.getCmp(chk_id + '_toggle').setValue(
+                options[chk_id + '_toggle'] !== undefined
+                    ? options[chk_id + '_toggle']
+                    : false
+            );
+        });
+        value =
+            options['add_paused'] !== undefined ? options['add_paused'] : true;
+        if (!value) {
+            Ext.getCmp('not_add_paused').setValue(true);
+        }
+        value =
+            options['queue_to_top'] !== undefined
+                ? options['queue_to_top']
+                : true;
+        if (!value) {
+            Ext.getCmp('not_queue_to_top').setValue(true);
+        }
+        value =
+            options['auto_managed'] !== undefined
+                ? options['auto_managed']
+                : true;
+        if (!value) {
+            Ext.getCmp('not_auto_managed').setValue(true);
+        }
+        [
+            'move_completed_path',
+            'path',
+            'download_location',
+            'copy_torrent',
+        ].forEach(function(field) {
+            value = options[field] !== undefined ? options[field] : '';
+            Ext.getCmp(field).setValue(value);
+        });
+
+        if (Object.keys(options).length === 0) {
+            deluge.client.core.get_config({
+                success: function(config) {
+                    var value;
+                    Ext.getCmp('download_location').setValue(
+                        options['download_location'] !== undefined
+                            ? options['download_location']
+                            : config['download_location']
+                    );
+                    value =
+                        options['move_completed_toggle'] !== undefined
+                            ? options['move_completed_toggle']
+                            : config['move_completed'];
+                    if (value) {
+                        Ext.getCmp('move_completed_toggle').setValue(
+                            options['move_completed_toggle'] !== undefined
+                                ? options['move_completed_toggle']
+                                : false
+                        );
+                        Ext.getCmp('move_completed_path').setValue(
+                            options['move_completed_path'] !== undefined
+                                ? options['move_completed_path']
+                                : config['move_completed_path']
+                        );
+                    }
+                    value =
+                        options['copy_torrent_toggle'] !== undefined
+                            ? options['copy_torrent_toggle']
+                            : config['copy_torrent_file'];
+                    if (value) {
+                        Ext.getCmp('copy_torrent_toggle').setValue(true);
+                        Ext.getCmp('copy_torrent').setValue(
+                            options['copy_torrent'] !== undefined
+                                ? options['copy_torrent']
+                                : config['torrentfiles_location']
+                        );
+                    }
+                    value =
+                        options['delete_copy_torrent_toggle'] !== undefined
+                            ? options['copy_torrent_toggle']
+                            : config['del_copy_torrent_file'];
+                    if (value) {
+                        Ext.getCmp('delete_copy_torrent_toggle').setValue(true);
+                    }
+                },
+            });
+        }
+
+        deluge.client.core.get_enabled_plugins({
+            success: function(plugins) {
+                if (plugins !== undefined && plugins.indexOf('Label') > -1) {
+                    this.MainTab.LabelFset.setVisible(true);
+                    deluge.client.label.get_labels({
+                        success: function(labels) {
+                            for (
+                                var index = 0;
+                                index < labels.length;
+                                index++
+                            ) {
+                                labels[index] = [labels[index]];
+                            }
+                            this.labels.loadData(labels, false);
+                        },
+                        failure: function(failure) {
+                            console.error(failure);
+                        },
+                        scope: this,
+                    });
+                } else {
+                    this.MainTab.LabelFset.setVisible(false);
+                }
+            },
+            scope: this,
+        });
+
+        var me = this;
+
+        function on_accounts(accounts, owner) {
+            for (var index = 0; index < accounts.length; index++) {
+                accounts[index] = [accounts[index]['username']];
+            }
+            me.accounts.loadData(accounts, false);
+            Ext.getCmp('owner')
+                .setValue(owner)
+                .enable();
+        }
+
+        function on_accounts_failure(failure) {
+            deluge.client.autoadd.get_auth_user({
+                success: function(user) {
+                    me.accounts.loadData([[user]], false);
+                    Ext.getCmp('owner')
+                        .setValue(user)
+                        .disable(true);
+                },
+                scope: this,
+            });
+        }
+
+        deluge.client.autoadd.is_admin_level({
+            success: function(is_admin) {
+                if (is_admin) {
+                    deluge.client.core.get_known_accounts({
+                        success: function(accounts) {
+                            deluge.client.autoadd.get_auth_user({
+                                success: function(user) {
+                                    on_accounts(
+                                        accounts,
+                                        options['owner'] !== undefined
+                                            ? options['owner']
+                                            : user
+                                    );
+                                },
+                                scope: this,
+                            });
+                        },
+                        failure: on_accounts_failure,
+                        scope: this,
+                    });
+                } else {
+                    on_accounts_failure(null);
+                }
+            },
+            scope: this,
+        });
+    },
+});
+
+/**
+ * @class Deluge.ux.AutoAdd.EditAutoAddCommandWindow
+ * @extends Deluge.ux.AutoAdd.AutoAddWindowBase
+ */
+Deluge.ux.AutoAdd.EditAutoAddCommandWindow = Ext.extend(
+    Deluge.ux.AutoAdd.AutoAddWindowBase,
+    {
+        title: _('Edit Watch Folder'),
+
+        initComponent: function() {
+            Deluge.ux.AutoAdd.EditAutoAddCommandWindow.superclass.initComponent.call(
+                this
+            );
+            this.addButton(_('Save'), this.onSaveClick, this);
+            this.addEvents({
+                watchdiredit: true,
+            });
+        },
+
+        show: function(watchdir_id, options) {
+            Deluge.ux.AutoAdd.EditAutoAddCommandWindow.superclass.show.call(
+                this
+            );
+            this.watchdir_id = watchdir_id;
+            this.loadOptions(options);
+        },
+
+        onSaveClick: function() {
+            try {
+                var options = this.getOptions();
+                deluge.client.autoadd.set_options(this.watchdir_id, options, {
+                    success: function() {
+                        this.fireEvent('watchdiredit', this, options);
+                    },
+                    scope: this,
+                });
+            } catch (err) {
+                Ext.Msg.show({
+                    title: _('Incompatible Option'),
+                    msg: err,
+                    buttons: Ext.Msg.OK,
+                    scope: this,
+                });
+            }
+
+            this.hide();
+        },
+    }
+);
+
+/**
+ * @class Deluge.ux.AutoAdd.AddAutoAddCommandWindow
+ * @extends Deluge.ux.AutoAdd.AutoAddWindowBase
+ */
+Deluge.ux.AutoAdd.AddAutoAddCommandWindow = Ext.extend(
+    Deluge.ux.AutoAdd.AutoAddWindowBase,
+    {
+        title: _('Add Watch Folder'),
+
+        initComponent: function() {
+            Deluge.ux.AutoAdd.AddAutoAddCommandWindow.superclass.initComponent.call(
+                this
+            );
+            this.addButton(_('Add'), this.onAddClick, this);
+            this.addEvents({
+                watchdiradd: true,
+            });
+        },
+
+        show: function() {
+            Deluge.ux.AutoAdd.AddAutoAddCommandWindow.superclass.show.call(
+                this
+            );
+            this.loadOptions();
+        },
+
+        onAddClick: function() {
+            var options = this.getOptions();
+            deluge.client.autoadd.add(options, {
+                success: function() {
+                    this.fireEvent('watchdiradd', this, options);
+                    this.hide();
+                },
+                failure: function(err) {
+                    const regex = /: (.*\n)\n?\]/m;
+                    var error;
+                    if ((error = regex.exec(err.error.message)) !== null) {
+                        error = error[1];
+                    } else {
+                        error = err.error.message;
+                    }
+                    Ext.Msg.show({
+                        title: _('Incompatible Option'),
+                        msg: error,
+                        buttons: Ext.Msg.OK,
+                        scope: this,
+                    });
+                },
+                scope: this,
+            });
+        },
+    }
+);

deluge/plugins/AutoAdd/deluge_autoadd/data/autoadd_options/main_tab.js

@@ -0,0 +1,304 @@
+/**
+ * Script: main_tab.js
+ *      The client-side javascript code for the AutoAdd plugin.
+ *
+ * Copyright (C) 2009 GazpachoKing <chase.sterling@gmail.com>
+ *
+ * This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+ * the additional special exception to link portions of this program with the OpenSSL library.
+ * See LICENSE for more details.
+ */
+
+Ext.ns('Deluge.ux.AutoAdd');
+
+/**
+ * @class Deluge.ux.AutoAdd.AutoAddMainPanel
+ * @extends Ext.Panel
+ */
+Deluge.ux.AutoAdd.AutoAddMainPanel = Ext.extend(Ext.Panel, {
+    id: 'main_tab_panel',
+    title: _('Main'),
+
+    initComponent: function() {
+        Deluge.ux.AutoAdd.AutoAddMainPanel.superclass.initComponent.call(this);
+        this.watchFolderFset = new Ext.form.FieldSet({
+            xtype: 'fieldset',
+            border: false,
+            title: _('Watch Folder'),
+            defaultType: 'textfield',
+            style: 'margin-top: 3px; margin-bottom: 0px; padding-bottom: 0px;',
+            width: '85%',
+            labelWidth: 1,
+            items: [
+                {
+                    xtype: 'textfield',
+                    id: 'path',
+                    hideLabel: true,
+                    width: 304,
+                },
+                {
+                    hideLabel: true,
+                    id: 'enabled',
+                    xtype: 'checkbox',
+                    boxLabel: _('Enable this watch folder'),
+                    checked: true,
+                },
+            ],
+        });
+
+        this.torrentActionFset = new Ext.form.FieldSet({
+            xtype: 'fieldset',
+            border: false,
+            title: _('Torrent File Action'),
+            style: 'margin-top: 3px; margin-bottom: 0px; padding-bottom: 0px;',
+            width: '85%',
+            labelWidth: 1,
+            defaults: {
+                style: 'margin-bottom: 2px',
+            },
+            items: [
+                {
+                    xtype: 'radiogroup',
+                    columns: 1,
+                    items: [
+                        {
+                            xtype: 'radio',
+                            name: 'torrent_action',
+                            id: 'isnt_append_extension',
+                            boxLabel: _('Delete .torrent after adding'),
+                            checked: true,
+                            hideLabel: true,
+                            listeners: {
+                                check: function(cb, newValue) {
+                                    if (newValue) {
+                                        Ext.getCmp(
+                                            'append_extension'
+                                        ).setDisabled(newValue);
+                                        Ext.getCmp('copy_torrent').setDisabled(
+                                            newValue
+                                        );
+                                        Ext.getCmp(
+                                            'delete_copy_torrent_toggle'
+                                        ).setDisabled(newValue);
+                                    }
+                                },
+                            },
+                        },
+                        {
+                            xtype: 'container',
+                            layout: 'hbox',
+                            hideLabel: true,
+                            items: [
+                                {
+                                    xtype: 'radio',
+                                    name: 'torrent_action',
+                                    id: 'append_extension_toggle',
+                                    boxLabel: _(
+                                        'Append extension after adding:'
+                                    ),
+                                    hideLabel: true,
+                                    listeners: {
+                                        check: function(cb, newValue) {
+                                            if (newValue) {
+                                                Ext.getCmp(
+                                                    'append_extension'
+                                                ).setDisabled(!newValue);
+                                                Ext.getCmp(
+                                                    'copy_torrent'
+                                                ).setDisabled(newValue);
+                                                Ext.getCmp(
+                                                    'delete_copy_torrent_toggle'
+                                                ).setDisabled(newValue);
+                                            }
+                                        },
+                                    },
+                                },
+                                {
+                                    xtype: 'textfield',
+                                    id: 'append_extension',
+                                    hideLabel: true,
+                                    disabled: true,
+                                    style: 'margin-left: 2px',
+                                    width: 112,
+                                },
+                            ],
+                        },
+                        {
+                            xtype: 'container',
+                            hideLabel: true,
+                            items: [
+                                {
+                                    xtype: 'container',
+                                    layout: 'hbox',
+                                    hideLabel: true,
+                                    items: [
+                                        {
+                                            xtype: 'radio',
+                                            name: 'torrent_action',
+                                            id: 'copy_torrent_toggle',
+                                            boxLabel: _(
+                                                'Copy of .torrent files to:'
+                                            ),
+                                            hideLabel: true,
+                                            listeners: {
+                                                check: function(cb, newValue) {
+                                                    if (newValue) {
+                                                        Ext.getCmp(
+                                                            'append_extension'
+                                                        ).setDisabled(newValue);
+                                                        Ext.getCmp(
+                                                            'copy_torrent'
+                                                        ).setDisabled(
+                                                            !newValue
+                                                        );
+                                                        Ext.getCmp(
+                                                            'delete_copy_torrent_toggle'
+                                                        ).setDisabled(
+                                                            !newValue
+                                                        );
+                                                    }
+                                                },
+                                            },
+                                        },
+                                        {
+                                            xtype: 'textfield',
+                                            id: 'copy_torrent',
+                                            hideLabel: true,
+                                            disabled: true,
+                                            style: 'margin-left: 2px',
+                                            width: 152,
+                                        },
+                                    ],
+                                },
+                                {
+                                    xtype: 'checkbox',
+                                    id: 'delete_copy_torrent_toggle',
+                                    boxLabel: _(
+                                        'Delete copy of torrent file on remove'
+                                    ),
+                                    style: 'margin-left: 10px',
+                                    disabled: true,
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        });
+
+        this.downloadFolderFset = new Ext.form.FieldSet({
+            xtype: 'fieldset',
+            border: false,
+            title: _('Download Folder'),
+            defaultType: 'textfield',
+            style: 'margin-top: 3px; margin-bottom: 0px; padding-bottom: 0px;',
+            width: '85%',
+            labelWidth: 1,
+            items: [
+                {
+                    hideLabel: true,
+                    id: 'download_location_toggle',
+                    xtype: 'checkbox',
+                    boxLabel: _('Set download folder'),
+                    listeners: {
+                        check: function(cb, checked) {
+                            Ext.getCmp('download_location').setDisabled(
+                                !checked
+                            );
+                        },
+                    },
+                },
+                {
+                    xtype: 'textfield',
+                    id: 'download_location',
+                    hideLabel: true,
+                    width: 304,
+                    disabled: true,
+                },
+            ],
+        });
+
+        this.moveCompletedFset = new Ext.form.FieldSet({
+            xtype: 'fieldset',
+            border: false,
+            title: _('Move Completed'),
+            defaultType: 'textfield',
+            style: 'margin-top: 3px; margin-bottom: 0px; padding-bottom: 0px;',
+            width: '85%',
+            labelWidth: 1,
+            items: [
+                {
+                    hideLabel: true,
+                    id: 'move_completed_toggle',
+                    xtype: 'checkbox',
+                    boxLabel: _('Set move completed folder'),
+                    listeners: {
+                        check: function(cb, checked) {
+                            Ext.getCmp('move_completed_path').setDisabled(
+                                !checked
+                            );
+                        },
+                    },
+                },
+                {
+                    xtype: 'textfield',
+                    id: 'move_completed_path',
+                    hideLabel: true,
+                    width: 304,
+                    disabled: true,
+                },
+            ],
+        });
+
+        this.LabelFset = new Ext.form.FieldSet({
+            xtype: 'fieldset',
+            border: false,
+            title: _('Label'),
+            defaultType: 'textfield',
+            style: 'margin-top: 3px; margin-bottom: 0px; padding-bottom: 3px;',
+            //width: '85%',
+            labelWidth: 1,
+            //hidden: true,
+            items: [
+                {
+                    xtype: 'container',
+                    layout: 'hbox',
+                    hideLabel: true,
+                    items: [
+                        {
+                            hashLabel: false,
+                            id: 'label_toggle',
+                            xtype: 'checkbox',
+                            boxLabel: _('Label:'),
+                            listeners: {
+                                check: function(cb, checked) {
+                                    Ext.getCmp('label').setDisabled(!checked);
+                                },
+                            },
+                        },
+                        {
+                            xtype: 'combo',
+                            id: 'label',
+                            hideLabel: true,
+                            //width: 220,
+                            width: 254,
+                            disabled: true,
+                            style: 'margin-left: 2px',
+                            mode: 'local',
+                            valueField: 'displayText',
+                            displayField: 'displayText',
+                        },
+                    ],
+                },
+            ],
+        });
+
+        this.add([
+            this.watchFolderFset,
+            this.torrentActionFset,
+            this.downloadFolderFset,
+            this.moveCompletedFset,
+            this.LabelFset,
+        ]);
+    },
+});

deluge/plugins/AutoAdd/deluge_autoadd/data/autoadd_options/options_tab.js

@@ -0,0 +1,302 @@
+/**
+ * Script: options_tab.js
+ *      The client-side javascript code for the AutoAdd plugin.
+ *
+ * Copyright (C) 2009 GazpachoKing <chase.sterling@gmail.com>
+ *
+ * This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+ * the additional special exception to link portions of this program with the OpenSSL library.
+ * See LICENSE for more details.
+ */
+
+Ext.ns('Deluge.ux.AutoAdd');
+
+/**
+ * @class Deluge.ux.AutoAdd.AutoAddOptionsPanel
+ * @extends Ext.Panel
+ */
+Deluge.ux.AutoAdd.AutoAddOptionsPanel = Ext.extend(Ext.Panel, {
+    id: 'options_tab_panel',
+    title: _('Options'),
+
+    initComponent: function() {
+        Deluge.ux.AutoAdd.AutoAddOptionsPanel.superclass.initComponent.call(
+            this
+        );
+        var maxDownload = {
+            idCheckbox: 'max_download_speed_toggle',
+            labelCheckbox: 'Max Download Speed (KiB/s):',
+            idSpinner: 'max_download_speed',
+            decimalPrecision: 1,
+        };
+        var maxUploadSpeed = {
+            idCheckbox: 'max_upload_speed_toggle',
+            labelCheckbox: 'Max upload Speed (KiB/s):',
+            idSpinner: 'max_upload_speed',
+            decimalPrecision: 1,
+        };
+        var maxConnections = {
+            idCheckbox: 'max_connections_toggle',
+            labelCheckbox: 'Max Connections::',
+            idSpinner: 'max_connections',
+            decimalPrecision: 0,
+        };
+        var maxUploadSlots = {
+            idCheckbox: 'max_upload_slots_toggle',
+            labelCheckbox: 'Max Upload Slots:',
+            idSpinner: 'max_upload_slots',
+            decimalPrecision: 0,
+        };
+        // queue data
+        var addPause = {
+            idCheckbox: 'add_paused_toggle',
+            labelCheckbox: 'Add Pause:',
+            nameRadio: 'add_paused',
+            labelRadio: {
+                yes: 'Yes',
+                no: 'No',
+            },
+        };
+        var queueTo = {
+            idCheckbox: 'queue_to_top_toggle',
+            labelCheckbox: 'Queue To:',
+            nameRadio: 'queue_to_top',
+            labelRadio: {
+                yes: 'Top',
+                no: 'Bottom',
+            },
+        };
+        var autoManaged = {
+            idCheckbox: 'auto_managed_toggle',
+            labelCheckbox: 'Auto Managed:',
+            nameRadio: 'auto_managed',
+            labelRadio: {
+                yes: 'Yes',
+                no: 'No',
+            },
+        };
+
+        this.ownerFset = new Ext.form.FieldSet({
+            xtype: 'fieldset',
+            border: false,
+            title: _('Owner'),
+            style: 'margin-top: 3px; margin-bottom: 0px; padding-bottom: 0px;',
+            //width: '85%',
+            labelWidth: 1,
+            items: [
+                {
+                    xtype: 'combo',
+                    id: 'owner',
+                    hideLabel: true,
+                    width: 312,
+                    mode: 'local',
+                    valueField: 'displayText',
+                    displayField: 'displayText',
+                },
+            ],
+        });
+
+        this.bandwidthFset = new Ext.form.FieldSet({
+            xtype: 'fieldset',
+            border: false,
+            title: _('Bandwidth'),
+            style: 'margin-top: 3px; margin-bottom: 0px; padding-bottom: 0px;',
+            //width: '85%',
+            labelWidth: 1,
+            defaults: {
+                style: 'margin-bottom: 5px',
+            },
+        });
+        this.bandwidthFset.add(this._getBandwidthContainer(maxDownload));
+        this.bandwidthFset.add(this._getBandwidthContainer(maxUploadSpeed));
+        this.bandwidthFset.add(this._getBandwidthContainer(maxConnections));
+        this.bandwidthFset.add(this._getBandwidthContainer(maxUploadSlots));
+
+        this.queueFset = new Ext.form.FieldSet({
+            xtype: 'fieldset',
+            border: false,
+            title: _('Queue'),
+            style: 'margin-top: 3px; margin-bottom: 0px; padding-bottom: 0px;',
+            //width: '85%',
+            labelWidth: 1,
+            defaults: {
+                style: 'margin-bottom: 5px',
+            },
+            items: [
+                {
+                    xtype: 'container',
+                    layout: 'hbox',
+                    hideLabel: true,
+                },
+            ],
+        });
+        this.queueFset.add(this._getQueueContainer(addPause));
+        this.queueFset.add(this._getQueueContainer(queueTo));
+        this.queueFset.add(this._getQueueContainer(autoManaged));
+        this.queueFset.add({
+            xtype: 'container',
+            hideLabel: true,
+            items: [
+                {
+                    xtype: 'container',
+                    layout: 'hbox',
+                    hideLabel: true,
+                    items: [
+                        {
+                            xtype: 'checkbox',
+                            id: 'stop_at_ratio_toggle',
+                            boxLabel: _('Stop seed at ratio:'),
+                            hideLabel: true,
+                            width: 175,
+                            listeners: {
+                                check: function(cb, checked) {
+                                    Ext.getCmp('stop_ratio').setDisabled(
+                                        !checked
+                                    );
+                                    Ext.getCmp('remove_at_ratio').setDisabled(
+                                        !checked
+                                    );
+                                },
+                            },
+                        },
+                        {
+                            xtype: 'spinnerfield',
+                            id: 'stop_ratio',
+                            hideLabel: true,
+                            disabled: true,
+                            value: 0.0,
+                            minValue: 0.0,
+                            maxValue: 100.0,
+                            decimalPrecision: 1,
+                            incrementValue: 0.1,
+                            style: 'margin-left: 2px',
+                            width: 100,
+                        },
+                    ],
+                },
+                {
+                    xtype: 'container',
+                    layout: 'hbox',
+                    hideLabel: true,
+                    style: 'margin-left: 10px',
+                    items: [
+                        {
+                            xtype: 'checkbox',
+                            id: 'remove_at_ratio',
+                            boxLabel: _('Remove at ratio'),
+                            disabled: true,
+                            checked: true,
+                        },
+                        {
+                            xtype: 'checkbox',
+                            id: 'remove_at_ratio_toggle',
+                            disabled: true,
+                            checked: true,
+                            hidden: true,
+                        },
+                        {
+                            xtype: 'checkbox',
+                            id: 'stop_ratio_toggle',
+                            disabled: true,
+                            checked: true,
+                            hidden: true,
+                        },
+                        {
+                            xtype: 'checkbox',
+                            id: 'stop_ratio_toggle',
+                            disabled: true,
+                            checked: true,
+                            hidden: true,
+                        },
+                    ],
+                },
+            ],
+        });
+        this.queueFset.add({
+            xtype: 'checkbox',
+            id: 'seed_mode',
+            boxLabel: _('Skip File Hash Check'),
+            hideLabel: true,
+            width: 175,
+        });
+
+        this.add([this.ownerFset, this.bandwidthFset, this.queueFset]);
+    },
+
+    _getBandwidthContainer: function(values) {
+        return new Ext.Container({
+            xtype: 'container',
+            layout: 'hbox',
+            hideLabel: true,
+            items: [
+                {
+                    xtype: 'checkbox',
+                    hideLabel: true,
+                    id: values.idCheckbox,
+                    boxLabel: _(values.labelCheckbox),
+                    width: 175,
+                    listeners: {
+                        check: function(cb, checked) {
+                            Ext.getCmp(values.idSpinner).setDisabled(!checked);
+                        },
+                    },
+                },
+                {
+                    xtype: 'spinnerfield',
+                    id: values.idSpinner,
+                    hideLabel: true,
+                    disabled: true,
+                    minValue: -1,
+                    maxValue: 10000,
+                    value: 0.0,
+                    decimalPrecision: values.decimalPrecision,
+                    style: 'margin-left: 2px',
+                    width: 100,
+                },
+            ],
+        });
+    },
+
+    _getQueueContainer: function(values) {
+        return new Ext.Container({
+            xtype: 'container',
+            layout: 'hbox',
+            hideLabel: true,
+            items: [
+                {
+                    xtype: 'checkbox',
+                    hideLabel: true,
+                    id: values.idCheckbox,
+                    boxLabel: _(values.labelCheckbox),
+                    width: 175,
+                    listeners: {
+                        check: function(cb, checked) {
+                            Ext.getCmp(values.nameRadio).setDisabled(!checked);
+                            Ext.getCmp('not_' + values.nameRadio).setDisabled(
+                                !checked
+                            );
+                        },
+                    },
+                },
+                {
+                    xtype: 'radio',
+                    name: values.nameRadio,
+                    id: values.nameRadio,
+                    boxLabel: _(values.labelRadio.yes),
+                    hideLabel: true,
+                    checked: true,
+                    disabled: true,
+                    width: 50,
+                },
+                {
+                    xtype: 'radio',
+                    name: values.nameRadio,
+                    id: 'not_' + values.nameRadio,
+                    boxLabel: _(values.labelRadio.no),
+                    hideLabel: true,
+                    disabled: true,
+                },
+            ],
+        });
+    },
+});

deluge/plugins/AutoAdd/deluge_autoadd/data/config.ui

@@ -1,116 +1,134 @@
-<?xml version="1.0"?>
-<glade-interface>
-  <!-- interface-requires gtk+ 2.16 -->
-  <!-- interface-naming-policy toplevel-contextual -->
-  <widget class="GtkWindow" id="prefs_window">
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.22.1 -->
+<interface>
+  <requires lib="gtk+" version="3.0"/>
+  <object class="GtkWindow" id="prefs_window">
+    <property name="can_focus">False</property>
     <child>
-      <widget class="GtkHBox" id="hbox9">
+      <placeholder/>
+    </child>
+    <child>
+      <object class="GtkBox" id="hbox9">
         <property name="visible">True</property>
+        <property name="can_focus">False</property>
         <child>
           <placeholder/>
         </child>
         <child>
-          <widget class="GtkAlignment" id="prefs_box_1">
+          <object class="GtkAlignment" id="prefs_box_1">
             <property name="visible">True</property>
+            <property name="can_focus">False</property>
             <child>
-              <widget class="GtkVBox" id="prefs_box">
+              <object class="GtkBox" id="prefs_box">
                 <property name="width_request">340</property>
                 <property name="height_request">390</property>
                 <property name="visible">True</property>
+                <property name="can_focus">False</property>
                 <property name="border_width">3</property>
                 <property name="orientation">vertical</property>
-                <signal name="parent_set" handler="on_parent_set"/>
                 <child>
-                  <widget class="GtkFrame" id="frame1">
+                  <object class="GtkFrame" id="frame1">
                     <property name="visible">True</property>
+                    <property name="can_focus">False</property>
                     <property name="label_xalign">0</property>
                     <property name="shadow_type">none</property>
                     <child>
-                      <widget class="GtkVBox" id="watchdirs_vbox">
+                      <object class="GtkBox" id="watchdirs_vbox">
                         <property name="visible">True</property>
-                        <property name="orientation">vertical</property>
+                        <property name="can_focus">False</property>
                         <property name="homogeneous">True</property>
+                        <property name="orientation">vertical</property>
                         <child>
                           <placeholder/>
                         </child>
-                      </widget>
+                      </object>
                     </child>
-                    <child>
-                      <widget class="GtkLabel" id="label1">
+                    <child type="label">
+                      <object class="GtkLabel" id="label1">
                         <property name="visible">True</property>
+                        <property name="can_focus">False</property>
                         <property name="label" translatable="yes">&lt;b&gt;Watch Folders:&lt;/b&gt;</property>
                         <property name="use_markup">True</property>
-                      </widget>
-                      <packing>
-                        <property name="type">label_item</property>
-                      </packing>
+                      </object>
                     </child>
-                  </widget>
+                  </object>
                   <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
                     <property name="position">0</property>
                   </packing>
                 </child>
                 <child>
-                  <widget class="GtkHButtonBox" id="hbuttonbox1">
+                  <object class="GtkHButtonBox" id="hbuttonbox1">
                     <property name="visible">True</property>
+                    <property name="can_focus">False</property>
                     <child>
-                      <widget class="GtkButton" id="add_button">
-                        <property name="label" translatable="no">gtk-add</property>
+                      <object class="GtkButton" id="add_button">
+                        <property name="label">gtk-add</property>
                         <property name="visible">True</property>
                         <property name="can_focus">True</property>
                         <property name="can_default">True</property>
                         <property name="receives_default">True</property>
                         <property name="use_stock">True</property>
-                        <signal name="clicked" handler="on_add_button_clicked"/>
-                      </widget>
+                        <signal name="clicked" handler="on_add_button_clicked" swapped="no"/>
+                      </object>
                       <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">False</property>
                         <property name="position">0</property>
                       </packing>
                     </child>
                     <child>
-                      <widget class="GtkButton" id="remove_button">
-                        <property name="label" translatable="no">gtk-remove</property>
+                      <object class="GtkButton" id="remove_button">
+                        <property name="label">gtk-remove</property>
                         <property name="visible">True</property>
                         <property name="sensitive">False</property>
                         <property name="can_focus">True</property>
                         <property name="can_default">True</property>
                         <property name="receives_default">True</property>
                         <property name="use_stock">True</property>
-                        <signal name="clicked" handler="on_remove_button_clicked"/>
-                      </widget>
+                        <signal name="clicked" handler="on_remove_button_clicked" swapped="no"/>
+                      </object>
                       <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">False</property>
                         <property name="position">1</property>
                       </packing>
                     </child>
                     <child>
-                      <widget class="GtkButton" id="edit_button">
-                        <property name="label" translatable="no">gtk-edit</property>
+                      <object class="GtkButton" id="edit_button">
+                        <property name="label">gtk-edit</property>
                         <property name="visible">True</property>
                         <property name="sensitive">False</property>
                         <property name="can_focus">True</property>
                         <property name="can_default">True</property>
                         <property name="receives_default">True</property>
                         <property name="use_stock">True</property>
-                        <signal name="clicked" handler="on_edit_button_clicked"/>
-                      </widget>
+                        <signal name="clicked" handler="on_edit_button_clicked" swapped="no"/>
+                      </object>
                       <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">False</property>
                         <property name="position">2</property>
                       </packing>
                     </child>
-                  </widget>
+                  </object>
                   <packing>
                     <property name="expand">False</property>
+                    <property name="fill">True</property>
                     <property name="position">1</property>
                   </packing>
                 </child>
-              </widget>
+              </object>
             </child>
-          </widget>
+          </object>
           <packing>
+            <property name="expand">True</property>
+            <property name="fill">True</property>
             <property name="position">1</property>
           </packing>
         </child>
-      </widget>
+      </object>
     </child>
-  </widget>
-</glade-interface>
+  </object>
+</interface>

deluge/plugins/AutoAdd/deluge_autoadd/gtkui.py

@@ -0,0 +1,580 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2009 GazpachoKing <chase.sterling@gmail.com>
+#
+# Basic plugin template created by:
+# Copyright (C) 2008 Martijn Voncken <mvoncken@gmail.com>
+# Copyright (C) 2007-2009 Andrew Resch <andrewresch@gmail.com>
+# Copyright (C) 2009 Damien Churchill <damoxc@gmail.com>
+#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
+#
+
+from __future__ import unicode_literals
+
+import logging
+import os
+
+import gi  # isort:skip (Required before Gtk import).
+
+gi.require_version('Gtk', '3.0')  # NOQA: E402
+
+# isort:imports-thirdparty
+from gi.repository import Gtk
+
+# isort:imports-firstparty
+import deluge.common
+import deluge.component as component
+from deluge.plugins.pluginbase import Gtk3PluginBase
+from deluge.ui.client import client
+from deluge.ui.gtk3 import dialogs
+
+# isort:imports-localfolder
+from .common import get_resource
+
+log = logging.getLogger(__name__)
+
+
+class IncompatibleOption(Exception):
+    pass
+
+
+class OptionsDialog(object):
+    spin_ids = ['max_download_speed', 'max_upload_speed', 'stop_ratio']
+    spin_int_ids = ['max_upload_slots', 'max_connections']
+    chk_ids = [
+        'stop_at_ratio',
+        'remove_at_ratio',
+        'move_completed',
+        'add_paused',
+        'auto_managed',
+        'queue_to_top',
+    ]
+
+    def __init__(self):
+        self.accounts = Gtk.ListStore(str)
+        self.labels = Gtk.ListStore(str)
+        self.core_config = {}
+
+    def show(self, options=None, watchdir_id=None):
+        if options is None:
+            options = {}
+        self.builder = Gtk.Builder()
+        self.builder.add_from_file(get_resource('autoadd_options.ui'))
+        self.builder.connect_signals(
+            {
+                'on_opts_add': self.on_add,
+                'on_opts_apply': self.on_apply,
+                'on_opts_cancel': self.on_cancel,
+                'on_options_dialog_close': self.on_cancel,
+                'on_toggle_toggled': self.on_toggle_toggled,
+            }
+        )
+        self.dialog = self.builder.get_object('options_dialog')
+        self.dialog.set_transient_for(component.get('Preferences').pref_dialog)
+
+        if watchdir_id:
+            # We have an existing watchdir_id, we are editing
+            self.builder.get_object('opts_add_button').hide()
+            self.builder.get_object('opts_apply_button').show()
+            self.watchdir_id = watchdir_id
+        else:
+            # We don't have an id, adding
+            self.builder.get_object('opts_add_button').show()
+            self.builder.get_object('opts_apply_button').hide()
+            self.watchdir_id = None
+
+        self.load_options(options)
+        self.dialog.run()
+
+    def load_options(self, options):
+        self.builder.get_object('enabled').set_active(options.get('enabled', True))
+        self.builder.get_object('append_extension_toggle').set_active(
+            options.get('append_extension_toggle', False)
+        )
+        self.builder.get_object('append_extension').set_text(
+            options.get('append_extension', '.added')
+        )
+        self.builder.get_object('download_location_toggle').set_active(
+            options.get('download_location_toggle', False)
+        )
+        self.builder.get_object('copy_torrent_toggle').set_active(
+            options.get('copy_torrent_toggle', False)
+        )
+        self.builder.get_object('delete_copy_torrent_toggle').set_active(
+            options.get('delete_copy_torrent_toggle', False)
+        )
+        self.builder.get_object('seed_mode').set_active(options.get('seed_mode', False))
+        self.accounts.clear()
+        self.labels.clear()
+        combobox = self.builder.get_object('OwnerCombobox')
+        combobox_render = Gtk.CellRendererText()
+        combobox.pack_start(combobox_render, True)
+        combobox.add_attribute(combobox_render, 'text', 0)
+        combobox.set_model(self.accounts)
+
+        label_widget = self.builder.get_object('label')
+        label_widget.get_child().set_text(options.get('label', ''))
+        label_widget.set_model(self.labels)
+        label_widget.set_entry_text_column(0)
+        self.builder.get_object('label_toggle').set_active(
+            options.get('label_toggle', False)
+        )
+
+        for spin_id in self.spin_ids + self.spin_int_ids:
+            self.builder.get_object(spin_id).set_value(options.get(spin_id, 0))
+            self.builder.get_object(spin_id + '_toggle').set_active(
+                options.get(spin_id + '_toggle', False)
+            )
+        for chk_id in self.chk_ids:
+            self.builder.get_object(chk_id).set_active(bool(options.get(chk_id, True)))
+            self.builder.get_object(chk_id + '_toggle').set_active(
+                options.get(chk_id + '_toggle', False)
+            )
+        if not options.get('add_paused', True):
+            self.builder.get_object('isnt_add_paused').set_active(True)
+        if not options.get('queue_to_top', True):
+            self.builder.get_object('isnt_queue_to_top').set_active(True)
+        if not options.get('auto_managed', True):
+            self.builder.get_object('isnt_auto_managed').set_active(True)
+        for field in [
+            'move_completed_path',
+            'path',
+            'download_location',
+            'copy_torrent',
+        ]:
+            if client.is_localhost():
+                self.builder.get_object(field + '_chooser').set_current_folder(
+                    options.get(field, os.path.expanduser('~'))
+                )
+                self.builder.get_object(field + '_chooser').show()
+                self.builder.get_object(field + '_entry').hide()
+            else:
+                self.builder.get_object(field + '_entry').set_text(
+                    options.get(field, '')
+                )
+                self.builder.get_object(field + '_entry').show()
+                self.builder.get_object(field + '_chooser').hide()
+        self.set_sensitive()
+
+        def on_core_config(config):
+            if client.is_localhost():
+                self.builder.get_object('download_location_chooser').set_current_folder(
+                    options.get('download_location', config['download_location'])
+                )
+                if options.get('move_completed_toggle', config['move_completed']):
+                    self.builder.get_object('move_completed_toggle').set_active(True)
+                    self.builder.get_object(
+                        'move_completed_path_chooser'
+                    ).set_current_folder(
+                        options.get(
+                            'move_completed_path', config['move_completed_path']
+                        )
+                    )
+                if options.get('copy_torrent_toggle', config['copy_torrent_file']):
+                    self.builder.get_object('copy_torrent_toggle').set_active(True)
+                    self.builder.get_object('copy_torrent_chooser').set_current_folder(
+                        options.get('copy_torrent', config['torrentfiles_location'])
+                    )
+            else:
+                self.builder.get_object('download_location_entry').set_text(
+                    options.get('download_location', config['download_location'])
+                )
+                if options.get('move_completed_toggle', config['move_completed']):
+                    self.builder.get_object('move_completed_toggle').set_active(
+                        options.get('move_completed_toggle', False)
+                    )
+                    self.builder.get_object('move_completed_path_entry').set_text(
+                        options.get(
+                            'move_completed_path', config['move_completed_path']
+                        )
+                    )
+                if options.get('copy_torrent_toggle', config['copy_torrent_file']):
+                    self.builder.get_object('copy_torrent_toggle').set_active(True)
+                    self.builder.get_object('copy_torrent_entry').set_text(
+                        options.get('copy_torrent', config['torrentfiles_location'])
+                    )
+
+            if options.get(
+                'delete_copy_torrent_toggle', config['del_copy_torrent_file']
+            ):
+                self.builder.get_object('delete_copy_torrent_toggle').set_active(True)
+
+        if not options:
+            client.core.get_config().addCallback(on_core_config)
+
+        def on_accounts(accounts, owner):
+            log.debug('Got Accounts')
+            selected_iter = None
+            for account in accounts:
+                acc_iter = self.accounts.append()
+                self.accounts.set_value(acc_iter, 0, account['username'])
+                if account['username'] == owner:
+                    selected_iter = acc_iter
+            self.builder.get_object('OwnerCombobox').set_active_iter(selected_iter)
+
+        def on_accounts_failure(failure):
+            log.debug('Failed to get accounts!!! %s', failure)
+            acc_iter = self.accounts.append()
+            self.accounts.set_value(acc_iter, 0, client.get_auth_user())
+            self.builder.get_object('OwnerCombobox').set_active(0)
+            self.builder.get_object('OwnerCombobox').set_sensitive(False)
+
+        def on_labels(labels):
+            log.debug('Got Labels: %s', labels)
+            for label in labels:
+                self.labels.set_value(self.labels.append(), 0, label)
+            label_widget = self.builder.get_object('label')
+            label_widget.set_model(self.labels)
+            label_widget.set_entry_text_column(0)
+
+        def on_failure(failure):
+            log.exception(failure)
+
+        def on_get_enabled_plugins(result):
+            if 'Label' in result:
+                self.builder.get_object('label_frame').show()
+                client.label.get_labels().addCallback(on_labels).addErrback(on_failure)
+            else:
+                self.builder.get_object('label_frame').hide()
+                self.builder.get_object('label_toggle').set_active(False)
+
+        client.core.get_enabled_plugins().addCallback(on_get_enabled_plugins)
+        if client.get_auth_level() == deluge.common.AUTH_LEVEL_ADMIN:
+            client.core.get_known_accounts().addCallback(
+                on_accounts, options.get('owner', client.get_auth_user())
+            ).addErrback(on_accounts_failure)
+        else:
+            acc_iter = self.accounts.append()
+            self.accounts.set_value(acc_iter, 0, client.get_auth_user())
+            self.builder.get_object('OwnerCombobox').set_active(0)
+            self.builder.get_object('OwnerCombobox').set_sensitive(False)
+
+    def set_sensitive(self):
+        maintoggles = [
+            'download_location',
+            'append_extension',
+            'move_completed',
+            'label',
+            'max_download_speed',
+            'max_upload_speed',
+            'max_connections',
+            'max_upload_slots',
+            'add_paused',
+            'auto_managed',
+            'stop_at_ratio',
+            'queue_to_top',
+            'copy_torrent',
+        ]
+        for maintoggle in maintoggles:
+            self.on_toggle_toggled(self.builder.get_object(maintoggle + '_toggle'))
+
+    def on_toggle_toggled(self, tb):
+        toggle = tb.get_name().replace('_toggle', '')
+        isactive = tb.get_active()
+        if toggle == 'download_location':
+            self.builder.get_object('download_location_chooser').set_sensitive(isactive)
+            self.builder.get_object('download_location_entry').set_sensitive(isactive)
+        elif toggle == 'append_extension':
+            self.builder.get_object('append_extension').set_sensitive(isactive)
+        elif toggle == 'copy_torrent':
+            self.builder.get_object('copy_torrent_entry').set_sensitive(isactive)
+            self.builder.get_object('copy_torrent_chooser').set_sensitive(isactive)
+            self.builder.get_object('delete_copy_torrent_toggle').set_sensitive(
+                isactive
+            )
+        elif toggle == 'move_completed':
+            self.builder.get_object('move_completed_path_chooser').set_sensitive(
+                isactive
+            )
+            self.builder.get_object('move_completed_path_entry').set_sensitive(isactive)
+            self.builder.get_object('move_completed').set_active(isactive)
+        elif toggle == 'label':
+            self.builder.get_object('label').set_sensitive(isactive)
+        elif toggle == 'max_download_speed':
+            self.builder.get_object('max_download_speed').set_sensitive(isactive)
+        elif toggle == 'max_upload_speed':
+            self.builder.get_object('max_upload_speed').set_sensitive(isactive)
+        elif toggle == 'max_connections':
+            self.builder.get_object('max_connections').set_sensitive(isactive)
+        elif toggle == 'max_upload_slots':
+            self.builder.get_object('max_upload_slots').set_sensitive(isactive)
+        elif toggle == 'add_paused':
+            self.builder.get_object('add_paused').set_sensitive(isactive)
+            self.builder.get_object('isnt_add_paused').set_sensitive(isactive)
+        elif toggle == 'queue_to_top':
+            self.builder.get_object('queue_to_top').set_sensitive(isactive)
+            self.builder.get_object('isnt_queue_to_top').set_sensitive(isactive)
+        elif toggle == 'auto_managed':
+            self.builder.get_object('auto_managed').set_sensitive(isactive)
+            self.builder.get_object('isnt_auto_managed').set_sensitive(isactive)
+        elif toggle == 'stop_at_ratio':
+            self.builder.get_object('remove_at_ratio_toggle').set_active(isactive)
+            self.builder.get_object('stop_ratio_toggle').set_active(isactive)
+            self.builder.get_object('stop_at_ratio').set_active(isactive)
+            self.builder.get_object('stop_ratio').set_sensitive(isactive)
+            self.builder.get_object('remove_at_ratio').set_sensitive(isactive)
+
+    def on_apply(self, event=None):
+        try:
+            options = self.generate_opts()
+            client.autoadd.set_options(str(self.watchdir_id), options).addCallbacks(
+                self.on_added, self.on_error_show
+            )
+        except IncompatibleOption as ex:
+            dialogs.ErrorDialog(_('Incompatible Option'), str(ex), self.dialog).run()
+
+    def on_error_show(self, result):
+        d = dialogs.ErrorDialog(_('Error'), result.value.exception_msg, self.dialog)
+        result.cleanFailure()
+        d.run()
+
+    def on_added(self, result):
+        self.dialog.destroy()
+
+    def on_add(self, event=None):
+        try:
+            options = self.generate_opts()
+            client.autoadd.add(options).addCallbacks(self.on_added, self.on_error_show)
+        except IncompatibleOption as ex:
+            dialogs.ErrorDialog(_('Incompatible Option'), str(ex), self.dialog).run()
+
+    def on_cancel(self, event=None):
+        self.dialog.destroy()
+
+    def generate_opts(self):
+        # generate options dict based on gtk objects
+        options = {}
+        options['enabled'] = self.builder.get_object('enabled').get_active()
+        if client.is_localhost():
+            options['path'] = self.builder.get_object('path_chooser').get_filename()
+            options['download_location'] = self.builder.get_object(
+                'download_location_chooser'
+            ).get_filename()
+            options['move_completed_path'] = self.builder.get_object(
+                'move_completed_path_chooser'
+            ).get_filename()
+            options['copy_torrent'] = self.builder.get_object(
+                'copy_torrent_chooser'
+            ).get_filename()
+        else:
+            options['path'] = self.builder.get_object('path_entry').get_text()
+            options['download_location'] = self.builder.get_object(
+                'download_location_entry'
+            ).get_text()
+            options['move_completed_path'] = self.builder.get_object(
+                'move_completed_path_entry'
+            ).get_text()
+            options['copy_torrent'] = self.builder.get_object(
+                'copy_torrent_entry'
+            ).get_text()
+
+        options['label'] = (
+            self.builder.get_object('label').get_child().get_text().lower()
+        )
+        options['append_extension'] = self.builder.get_object(
+            'append_extension'
+        ).get_text()
+        options['owner'] = self.accounts[
+            self.builder.get_object('OwnerCombobox').get_active()
+        ][0]
+
+        for key in [
+            'append_extension_toggle',
+            'download_location_toggle',
+            'label_toggle',
+            'copy_torrent_toggle',
+            'delete_copy_torrent_toggle',
+            'seed_mode',
+        ]:
+            options[key] = self.builder.get_object(key).get_active()
+
+        for spin_id in self.spin_ids:
+            options[spin_id] = self.builder.get_object(spin_id).get_value()
+            options[spin_id + '_toggle'] = self.builder.get_object(
+                spin_id + '_toggle'
+            ).get_active()
+        for spin_int_id in self.spin_int_ids:
+            options[spin_int_id] = self.builder.get_object(
+                spin_int_id
+            ).get_value_as_int()
+            options[spin_int_id + '_toggle'] = self.builder.get_object(
+                spin_int_id + '_toggle'
+            ).get_active()
+        for chk_id in self.chk_ids:
+            options[chk_id] = self.builder.get_object(chk_id).get_active()
+            options[chk_id + '_toggle'] = self.builder.get_object(
+                chk_id + '_toggle'
+            ).get_active()
+
+        if (
+            options['copy_torrent_toggle']
+            and options['path'] == options['copy_torrent']
+        ):
+            raise IncompatibleOption(
+                _(
+                    '"Watch Folder" directory and "Copy of .torrent'
+                    ' files to" directory cannot be the same!'
+                )
+            )
+        return options
+
+
+class GtkUI(Gtk3PluginBase):
+    def enable(self):
+        self.builder = Gtk.Builder()
+        self.builder.add_from_file(get_resource('config.ui'))
+        self.builder.connect_signals(self)
+        self.opts_dialog = OptionsDialog()
+
+        component.get('PluginManager').register_hook(
+            'on_apply_prefs', self.on_apply_prefs
+        )
+        component.get('PluginManager').register_hook(
+            'on_show_prefs', self.on_show_prefs
+        )
+        client.register_event_handler(
+            'AutoaddOptionsChangedEvent', self.on_options_changed_event
+        )
+
+        self.watchdirs = {}
+
+        vbox = self.builder.get_object('watchdirs_vbox')
+        sw = Gtk.ScrolledWindow()
+        sw.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
+        sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
+
+        vbox.pack_start(sw, True, True, 0)
+
+        self.store = self.create_model()
+
+        self.treeView = Gtk.TreeView(self.store)
+        self.treeView.connect('cursor-changed', self.on_listitem_activated)
+        self.treeView.connect('row-activated', self.on_edit_button_clicked)
+        self.treeView.set_rules_hint(True)
+
+        self.create_columns(self.treeView)
+        sw.add(self.treeView)
+        sw.show_all()
+        component.get('Preferences').add_page(
+            _('AutoAdd'), self.builder.get_object('prefs_box')
+        )
+
+    def disable(self):
+        component.get('Preferences').remove_page(_('AutoAdd'))
+        component.get('PluginManager').deregister_hook(
+            'on_apply_prefs', self.on_apply_prefs
+        )
+        component.get('PluginManager').deregister_hook(
+            'on_show_prefs', self.on_show_prefs
+        )
+
+    def create_model(self):
+        store = Gtk.ListStore(str, bool, str, str)
+        for watchdir_id, watchdir in self.watchdirs.items():
+            store.append(
+                [
+                    watchdir_id,
+                    watchdir['enabled'],
+                    watchdir.get('owner', 'localclient'),
+                    watchdir['path'],
+                ]
+            )
+        return store
+
+    def create_columns(self, treeview):
+        renderer_toggle = Gtk.CellRendererToggle()
+        column = Gtk.TreeViewColumn(
+            _('Active'), renderer_toggle, activatable=1, active=1
+        )
+        column.set_sort_column_id(1)
+        treeview.append_column(column)
+        tt = Gtk.Tooltip()
+        tt.set_text(_('Double-click to toggle'))
+        treeview.set_tooltip_cell(tt, None, None, renderer_toggle)
+
+        renderertext = Gtk.CellRendererText()
+        column = Gtk.TreeViewColumn(_('Owner'), renderertext, text=2)
+        column.set_sort_column_id(2)
+        treeview.append_column(column)
+        tt2 = Gtk.Tooltip()
+        tt2.set_text(_('Double-click to edit'))
+        treeview.set_has_tooltip(True)
+
+        renderertext = Gtk.CellRendererText()
+        column = Gtk.TreeViewColumn(_('Path'), renderertext, text=3)
+        column.set_sort_column_id(3)
+        treeview.append_column(column)
+        tt2 = Gtk.Tooltip()
+        tt2.set_text(_('Double-click to edit'))
+        treeview.set_has_tooltip(True)
+
+    def load_watchdir_list(self):
+        pass
+
+    def add_watchdir_entry(self):
+        pass
+
+    def on_add_button_clicked(self, event=None):
+        # display options_window
+        self.opts_dialog.show()
+
+    def on_remove_button_clicked(self, event=None):
+        tree, tree_id = self.treeView.get_selection().get_selected()
+        watchdir_id = str(self.store.get_value(tree_id, 0))
+        if watchdir_id:
+            client.autoadd.remove(watchdir_id)
+
+    def on_edit_button_clicked(self, event=None, a=None, col=None):
+        tree, tree_id = self.treeView.get_selection().get_selected()
+        watchdir_id = str(self.store.get_value(tree_id, 0))
+        if watchdir_id:
+            if col and col.get_title() == _('Active'):
+                if self.watchdirs[watchdir_id]['enabled']:
+                    client.autoadd.disable_watchdir(watchdir_id)
+                else:
+                    client.autoadd.enable_watchdir(watchdir_id)
+            else:
+                self.opts_dialog.show(self.watchdirs[watchdir_id], watchdir_id)
+
+    def on_listitem_activated(self, treeview):
+        tree, tree_id = self.treeView.get_selection().get_selected()
+        if tree_id:
+            self.builder.get_object('edit_button').set_sensitive(True)
+            self.builder.get_object('remove_button').set_sensitive(True)
+        else:
+            self.builder.get_object('edit_button').set_sensitive(False)
+            self.builder.get_object('remove_button').set_sensitive(False)
+
+    def on_apply_prefs(self):
+        log.debug('applying prefs for AutoAdd')
+        for watchdir_id, watchdir in self.watchdirs.items():
+            client.autoadd.set_options(watchdir_id, watchdir)
+
+    def on_show_prefs(self):
+        client.autoadd.get_watchdirs().addCallback(self.cb_get_config)
+
+    def on_options_changed_event(self):
+        client.autoadd.get_watchdirs().addCallback(self.cb_get_config)
+
+    def cb_get_config(self, watchdirs):
+        """callback for on show_prefs"""
+        log.trace('Got whatchdirs from core: %s', watchdirs)
+        self.watchdirs = watchdirs or {}
+        self.store.clear()
+        for watchdir_id, watchdir in self.watchdirs.items():
+            self.store.append(
+                [
+                    watchdir_id,
+                    watchdir['enabled'],
+                    watchdir.get('owner', 'localclient'),
+                    watchdir['path'],
+                ]
+            )
+        # Workaround for cached glade signal appearing when re-enabling plugin in same session
+        if self.builder.get_object('edit_button'):
+            # Disable the remove and edit buttons, because nothing in the store is selected
+            self.builder.get_object('remove_button').set_sensitive(False)
+            self.builder.get_object('edit_button').set_sensitive(False)

deluge/plugins/AutoAdd/deluge_autoadd/webui.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2009 GazpachoKing <chase.sterling@gmail.com>
+#
+# Basic plugin template created by:
+# Copyright (C) 2008 Martijn Voncken <mvoncken@gmail.com>
+# Copyright (C) 2007-2009 Andrew Resch <andrewresch@gmail.com>
+# Copyright (C) 2009 Damien Churchill <damoxc@gmail.com>
+#
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
+#
+
+from __future__ import unicode_literals
+
+import logging
+
+from deluge.plugins.pluginbase import WebPluginBase
+
+from .common import get_resource
+
+log = logging.getLogger(__name__)
+
+
+class WebUI(WebPluginBase):
+    scripts = [
+        get_resource('autoadd.js'),
+        get_resource('autoadd_options.js'),
+        get_resource('main_tab.js', True),
+        get_resource('options_tab.js', True),
+    ]
+
+    def enable(self):
+        pass
+
+    def disable(self):
+        pass

deluge/plugins/AutoAdd/setup.py

@@ -1,5 +1,4 @@
-#
-# setup.py
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2009 GazpachoKing <chase.sterling@gmail.com>
 # Copyright (C) 2011 Pedro Algarvio <pedro@algarvio.me>
@@ -9,46 +8,22 @@
 # Copyright (C) 2007-2009 Andrew Resch <andrewresch@gmail.com>
 # Copyright (C) 2009 Damien Churchill <damoxc@gmail.com>
 #
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
+# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
+# the additional special exception to link portions of this program with the OpenSSL library.
+# See LICENSE for more details.
 #
 
-from setuptools import setup, find_packages
+from setuptools import find_packages, setup
 
-__plugin_name__ = "AutoAdd"
-__author__ = "Chase Sterling, Pedro Algarvio"
-__author_email__ = "chase.sterling@gmail.com, pedro@algarvio.me"
-__version__ = "1.04"
-__url__ = "http://dev.deluge-torrent.org/wiki/Plugins/AutoAdd"
-__license__ = "GPLv3"
-__description__ = "Monitors folders for .torrent files."
+__plugin_name__ = 'AutoAdd'
+__author__ = 'Chase Sterling, Pedro Algarvio'
+__author_email__ = 'chase.sterling@gmail.com, pedro@algarvio.me'
+__version__ = '1.8'
+__url__ = 'http://dev.deluge-torrent.org/wiki/Plugins/AutoAdd'
+__license__ = 'GPLv3'
+__description__ = 'Monitors folders for .torrent files.'
 __long_description__ = """"""
-__pkg_data__ = {'deluge.plugins.'+__plugin_name__.lower(): ["template/*", "data/*"]}
+__pkg_data__ = {'deluge_' + __plugin_name__.lower(): ['data/*', 'data/*/*']}
 
 setup(
     name=__plugin_name__,
@@ -60,15 +35,14 @@ setup(
     license=__license__,
     long_description=__long_description__ if __long_description__ else __description__,
     packages=find_packages(),
-    namespace_packages = ["deluge", "deluge.plugins"],
-    package_data = __pkg_data__,
-
+    package_data=__pkg_data__,
     entry_points="""
     [deluge.plugin.core]
-    %s = deluge.plugins.%s:CorePlugin
-    [deluge.plugin.gtkui]
-    %s = deluge.plugins.%s:GtkUIPlugin
+    %s = deluge_%s:CorePlugin
+    [deluge.plugin.gtk3ui]
+    %s = deluge_%s:Gtk3UIPlugin
     [deluge.plugin.web]
-    %s = deluge.plugins.%s:WebUIPlugin
-    """ % ((__plugin_name__, __plugin_name__.lower())*3)
+    %s = deluge_%s:WebUIPlugin
+    """
+    % ((__plugin_name__, __plugin_name__.lower()) * 3),
 )

deluge/plugins/Blocklist/deluge/__init__.py

@@ -1,2 +0,0 @@
-# this is a namespace package
-__import__('pkg_resources').declare_namespace(__name__)

deluge/plugins/Blocklist/deluge/plugins/__init__.py

@@ -1,2 +0,0 @@
-# this is a namespace package
-__import__('pkg_resources').declare_namespace(__name__)

deluge/plugins/Blocklist/deluge/plugins/blocklist/__init__.py

@@ -1,55 +0,0 @@
-#
-# blocklist/__init__.py
-#
-# Copyright (C) 2007-2009 Andrew Resch <andrewresch@gmail.com>
-#
-#
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-#     The Free Software Foundation, Inc.,
-#     51 Franklin Street, Fifth Floor
-#     Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
-#
-
-from deluge.plugins.init import PluginInitBase
-
-class CorePlugin(PluginInitBase):
-    def __init__(self, plugin_name):
-        from core import Core as _plugin_cls
-        self._plugin_cls = _plugin_cls
-        super(CorePlugin, self).__init__(plugin_name)
-
-class GtkUIPlugin(PluginInitBase):
-    def __init__(self, plugin_name):
-        from gtkui import GtkUI as _plugin_cls
-        self._plugin_cls = _plugin_cls
-        super(GtkUIPlugin, self).__init__(plugin_name)
-
-class WebUIPlugin(PluginInitBase):
-    def __init__(self, plugin_name):
-        from webui import WebUI as _plugin_cls
-        self._plugin_cls = _plugin_cls
-        super(WebUIPlugin, self).__init__(plugin_name)

deluge/plugins/Blocklist/deluge/plugins/blocklist/common.py

@@ -1,187 +0,0 @@
-#
-# common.py
-#
-# Copyright (C) 2009 Andrew Resch <andrewresch@gmail.com>
-#
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
-#
-
-
-import pkg_resources
-import os.path
-from functools import wraps
-from sys import exc_info
-
-def get_resource(filename):
-    return pkg_resources.resource_filename("deluge.plugins.blocklist",
-                                           os.path.join("data", filename))
-
-def raisesErrorsAs(error):
-    """
-    Factory class that returns a decorator which wraps
-    the decorated function to raise all exceptions as
-    the specified error type
-    """
-    def decorator(func):
-        """
-        Returns a function which wraps the given func
-        to raise all exceptions as error
-        """
-        @wraps(func)
-        def wrapper(self, *args, **kwargs):
-            """
-            Wraps the function in a try..except block
-            and calls it with the specified args
-
-            Raises any exceptions as error preserving the
-            message and traceback
-            """
-            try:
-                return func(self, *args, **kwargs)
-            except:
-                (value, tb) = exc_info()[1:]
-                raise error, value, tb
-        return wrapper
-    return decorator
-
-def remove_zeros(ip):
-    """
-    Removes unneeded zeros from ip addresses.
-
-    Example: 000.000.000.003 -> 0.0.0.3
-
-    :param ip: the ip address
-    :type ip: string
-
-    :returns: the ip address without the unneeded zeros
-    :rtype: string
-
-    """
-    return ".".join([part.lstrip("0").zfill(1) for part in ip.split(".")])
-
-class BadIP(Exception):
-    _message = None
-    def __init__(self, message):
-        self.message = message
-
-    def __set_message(self, message):
-        self._message = message
-
-    def __get_message(self):
-        return self._message
-
-    message = property(__get_message, __set_message)
-    del __get_message, __set_message
-
-class IP(object):
-    __slots__ = ('q1', 'q2', 'q3', 'q4', '_long')
-    def __init__(self, q1, q2, q3, q4):
-        self.q1 = q1
-        self.q2 = q2
-        self.q3 = q3
-        self.q4 = q4
-        self._long = 0
-        for q in self.quadrants():
-            self._long = (self._long << 8) | int(q)
-
-    @property
-    def address(self):
-        return '.'.join([str(q) for q in [self.q1, self.q2, self.q3, self.q4]])
-
-    @property
-    def long(self):
-        return self._long
-
-    @classmethod
-    def parse(cls, ip):
-        try:
-            q1, q2, q3, q4 = [int(q) for q in ip.split('.')]
-        except ValueError:
-            raise BadIP(_("The IP address \"%s\" is badly formed" % ip))
-        if q1<0 or q2<0 or q3<0 or q4<0:
-            raise BadIP(_("The IP address \"%s\" is badly formed" % ip))
-        elif q1>255 or q2>255 or q3>255 or q4>255:
-            raise BadIP(_("The IP address \"%s\" is badly formed" % ip))
-        return cls(q1, q2, q3, q4)
-
-    def quadrants(self):
-        return (self.q1, self.q2, self.q3, self.q4)
-
-#    def next_ip(self):
-#        (q1, q2, q3, q4) = self.quadrants()
-#        if q4 >= 255:
-#            if q3 >= 255:
-#                if q2 >= 255:
-#                    if q1 >= 255:
-#                        raise BadIP(_("There ain't a next IP address"))
-#                    q1 += 1
-#                else:
-#                    q2 += 1
-#            else:
-#                q3 += 1
-#        else:
-#            q4 += 1
-#        return IP(q1, q2, q3, q4)
-#
-#    def previous_ip(self):
-#        (q1, q2, q3, q4) = self.quadrants()
-#        if q4 <= 1:
-#            if q3 <= 1:
-#                if q2 <= 1:
-#                    if q1 <= 1:
-#                        raise BadIP(_("There ain't a previous IP address"))
-#                    q1 -= 1
-#                else:
-#                    q2 -= 1
-#            else:
-#                q3 -= 1
-#        else:
-#            q4 -= 1
-#        return IP(q1, q2, q3, q4)
-
-    def __lt__(self, other):
-        if isinstance(other, basestring):
-            other = IP.parse(other)
-        return self.long < other.long
-
-    def __gt__(self, other):
-        if isinstance(other, basestring):
-            other = IP.parse(other)
-        return self.long > other.long
-
-    def __eq__(self, other):
-        if isinstance(other, basestring):
-            other = IP.parse(other)
-        return self.long == other.long
-
-    def __repr__(self):
-        return '<%s long=%s address="%s">' % (
-            self.__class__.__name__, self.long, self.address
-        )

deluge/plugins/Blocklist/deluge/plugins/blocklist/core.py

@@ -1,531 +0,0 @@
-#
-# core.py
-#
-# Copyright (C) 2008 Andrew Resch <andrewresch@gmail.com>
-# Copyright (C) 2009-2010 John Garland <johnnybg+deluge@gmail.com>
-#
-# Deluge is free software.
-#
-# You may redistribute it and/or modify it under the terms of the
-# GNU General Public License, as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# deluge is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with deluge.    If not, write to:
-# 	The Free Software Foundation, Inc.,
-# 	51 Franklin Street, Fifth Floor
-# 	Boston, MA  02110-1301, USA.
-#
-#    In addition, as a special exception, the copyright holders give
-#    permission to link the code of portions of this program with the OpenSSL
-#    library.
-#    You must obey the GNU General Public License in all respects for all of
-#    the code used other than OpenSSL. If you modify file(s) with this
-#    exception, you may extend this exception to your version of the file(s),
-#    but you are not obligated to do so. If you do not wish to do so, delete
-#    this exception statement from your version. If you delete this exception
-#    statement from all source files in the program, then also delete it here.
-#
-#
-
-import os
-import time
-import logging
-from datetime import datetime, timedelta
-from email.utils import formatdate
-from urlparse import urljoin
-import shutil
-
-from twisted.internet.task import LoopingCall
-from twisted.internet import threads, defer
-from twisted.web import error
-
-from deluge.plugins.pluginbase import CorePluginBase
-import deluge.component as component
-import deluge.configmanager
-from deluge.common import is_url
-from deluge.core.rpcserver import export
-from deluge.httpdownloader import download_file
-from common import IP, BadIP
-from detect import detect_compression, detect_format, create_reader, UnknownFormatError
-from readers import ReaderParseError
-
-# TODO: check return values for deferred callbacks
-# TODO: review class attributes for redundancy
-
-log = logging.getLogger(__name__)
-
-DEFAULT_PREFS = {
-    "url": "",
-    "load_on_start": False,
-    "check_after_days": 4,
-    "list_compression": "",
-    "list_type": "",
-    "last_update": 0.0,
-    "list_size": 0,
-    "timeout": 180,
-    "try_times": 3,
-    "whitelisted": [],
-}
-
-# Constants
-ALLOW_RANGE = 0
-BLOCK_RANGE = 1
-
-class Core(CorePluginBase):
-    def enable(self):
-        log.debug('Blocklist: Plugin enabled...')
-
-        self.is_url = True
-        self.is_downloading = False
-        self.is_importing = False
-        self.has_imported = False
-        self.up_to_date = False
-        self.need_to_resume_session = False
-        self.num_whited = 0
-        self.num_blocked = 0
-        self.file_progress = 0.0
-
-        self.core = component.get("Core")
-        self.config = deluge.configmanager.ConfigManager("blocklist.conf", DEFAULT_PREFS)
-        if "whitelisted" not in self.config:
-            self.config["whitelisted"] = []
-
-        self.reader = create_reader(self.config["list_type"], self.config["list_compression"])
-
-        if type(self.config["last_update"]) is not float:
-            self.config.config["last_update"] = 0.0
-
-        update_now = False
-        if self.config["load_on_start"]:
-            self.pause_session()
-            if self.config["last_update"]:
-                last_update = datetime.fromtimestamp(self.config["last_update"])
-                check_period = timedelta(days=self.config["check_after_days"])
-            if not self.config["last_update"] or last_update + check_period < datetime.now():
-                update_now = True
-            else:
-                d = self.import_list(deluge.configmanager.get_config_dir("blocklist.cache"))
-                d.addCallbacks(self.on_import_complete, self.on_import_error)
-                if self.need_to_resume_session:
-                    d.addBoth(self.resume_session)
-
-        # This function is called every 'check_after_days' days, to download
-        # and import a new list if needed.
-        self.update_timer = LoopingCall(self.check_import)
-        if self.config["check_after_days"] > 0:
-            self.update_timer.start(
-                self.config["check_after_days"] * 24 * 60 * 60, update_now
-            )
-
-    def disable(self):
-        self.config.save()
-        log.debug("Reset IP filter")
-        self.core.session.get_ip_filter().add_rule(
-            "0.0.0.0", "255.255.255.255", ALLOW_RANGE
-        )
-        log.debug('Blocklist: Plugin disabled')
-
-    def update(self):
-        pass
-
-    ## Exported RPC methods ###
-    @export
-    def check_import(self, force=False):
-        """
-        Imports latest blocklist specified by blocklist url
-        Only downloads/imports if necessary or forced
-
-        :param force: optional argument to force download/import
-        :type force: boolean
-        :returns: a Deferred which fires when the blocklist has been imported
-        :rtype: Deferred
-        """
-
-        # Reset variables
-        self.filename = None
-        self.force_download = force
-        self.failed_attempts = 0
-        self.auto_detected = False
-        self.up_to_date = False
-        if force:
-            self.reader = None
-        self.is_url = is_url(self.config["url"])
-
-        # Start callback chain
-        if self.is_url:
-            d = self.download_list()
-            d.addCallbacks(self.on_download_complete, self.on_download_error)
-            d.addCallback(self.import_list)
-        else:
-            d = self.import_list(self.config["url"])
-        d.addCallbacks(self.on_import_complete, self.on_import_error)
-        if self.need_to_resume_session:
-            d.addBoth(self.resume_session)
-
-        return d
-
-    @export
-    def get_config(self):
-        """
-        Returns the config dictionary
-
-        :returns: the config dictionary
-        :rtype: dict
-        """
-        return self.config.config
-
-    @export
-    def set_config(self, config):
-        """
-        Sets the config based on values in 'config'
-
-        :param config: config to set
-        :type config: dictionary
-        """
-        needs_blocklist_import = False
-        for key in config.keys():
-            if key == 'whitelisted':
-                saved = set(self.config[key])
-                update = set(config[key])
-                diff = saved.symmetric_difference(update)
-                if diff:
-                    log.debug("Whitelist changed. Updating...")
-                    added = update.intersection(diff)
-                    removed = saved.intersection(diff)
-                    if added:
-                        for ip in added:
-                            try:
-                                ip = IP.parse(ip)
-                                self.blocklist.add_rule(
-                                    ip.address, ip.address, ALLOW_RANGE
-                                )
-                                saved.add(ip.address)
-                                log.debug("Added %s to whitelisted", ip)
-                                self.num_whited += 1
-                            except BadIP, e:
-                                log.error("Bad IP: %s", e)
-                                continue
-                    if removed:
-                        needs_blocklist_import = True
-                        for ip in removed:
-                            try:
-                                ip = IP.parse(ip)
-                                saved.remove(ip.address)
-                                log.debug("Removed %s from whitelisted", ip)
-                            except BadIP, e:
-                                log.error("Bad IP: %s", e)
-                                continue
-
-                self.config[key] = list(saved)
-                continue
-            elif key == "check_after_days":
-                if self.config[key] != config[key]:
-                    self.config[key] = config[key]
-                    update_now = False
-                    if self.config["last_update"]:
-                        last_update = datetime.fromtimestamp(self.config["last_update"])
-                        check_period = timedelta(days=self.config["check_after_days"])
-                    if not self.config["last_update"] or last_update + check_period < datetime.now():
-                        update_now = True
-                    self.update_timer.running and self.update_timer.stop()
-                    if self.config["check_after_days"] > 0:
-                        self.update_timer.start(
-                            self.config["check_after_days"] * 24 * 60 * 60, update_now
-                        )
-                continue
-            self.config[key] = config[key]
-
-        if needs_blocklist_import:
-            log.debug("IP addresses were removed from the whitelist. Since we "
-                      "don't know if they were blocked before. Re-import "
-                      "current blocklist and re-add whitelisted.")
-            self.has_imported = False
-            d = self.import_list(deluge.configmanager.get_config_dir("blocklist.cache"))
-            d.addCallbacks(self.on_import_complete, self.on_import_error)
-
-    @export
-    def get_status(self):
-        """
-        Returns the status of the plugin
-
-        :returns: the status dict of the plugin
-        :rtype: dict
-        """
-        status = {}
-        if self.is_downloading:
-            status["state"] = "Downloading"
-        elif self.is_importing:
-            status["state"] = "Importing"
-        else:
-            status["state"] = "Idle"
-
-        status["up_to_date"] = self.up_to_date
-        status["num_whited"] = self.num_whited
-        status["num_blocked"] = self.num_blocked
-        status["file_progress"] = self.file_progress
-        status["file_url"] = self.config["url"]
-        status["file_size"] = self.config["list_size"]
-        status["file_date"] = self.config["last_update"]
-        status["file_type"] = self.config["list_type"]
-        status["whitelisted"] = self.config["whitelisted"]
-        if self.config["list_compression"]:
-            status["file_type"] += " (%s)" % self.config["list_compression"]
-        return status
-
-    ####
-
-    def update_info(self, blocklist):
-        """
-        Updates blocklist info
-
-        :param blocklist: path of blocklist
-        :type blocklist: string
-        :returns: path of blocklist
-        :rtype: string
-        """
-        log.debug("Updating blocklist info: %s", blocklist)
-        self.config["last_update"] = time.time()
-        self.config["list_size"] = os.path.getsize(blocklist)
-        self.filename = blocklist
-        return blocklist
-
-    def download_list(self, url=None):
-        """
-        Downloads the blocklist specified by 'url' in the config
-
-        :param url: optional url to download from, defaults to config value
-        :type url: string
-        :returns: a Deferred which fires once the blocklist has been downloaded
-        :rtype: Deferred
-        """
-        def on_retrieve_data(data, current_length, total_length):
-            if total_length:
-                fp = float(current_length) / total_length
-                if fp > 1.0:
-                    fp = 1.0
-            else:
-                fp = 0.0
-
-            self.file_progress = fp
-
-        import socket
-        socket.setdefaulttimeout(self.config["timeout"])
-
-        if not url:
-            url = self.config["url"]
-
-        headers = {}
-        if self.config["last_update"] and not self.force_download:
-            headers['If-Modified-Since'] = formatdate(self.config["last_update"], usegmt=True)
-
-        log.debug("Attempting to download blocklist %s", url)
-        log.debug("Sending headers: %s", headers)
-        self.is_downloading = True
-        return download_file(
-            url, deluge.configmanager.get_config_dir("blocklist.download"),
-            on_retrieve_data, headers
-        )
-
-    def on_download_complete(self, blocklist):
-        """
-        Runs any download clean up functions
-
-        :param blocklist: path of blocklist
-        :type blocklist: string
-        :returns: a Deferred which fires when clean up is done
-        :rtype: Deferred
-        """
-        log.debug("Blocklist download complete: %s", blocklist)
-        self.is_downloading = False
-        return threads.deferToThread(self.update_info, blocklist)
-
-    def on_download_error(self, f):
-        """
-        Recovers from download error
-
-        :param f: failure that occured
-        :type f: Failure
-        :returns: a Deferred if recovery was possible
-                  else the original failure
-        :rtype: Deferred or Failure
-        """
-        self.is_downloading = False
-        error_msg = f.getErrorMessage()
-        d = f
-        if f.check(error.PageRedirect):
-            # Handle redirect errors
-            location = urljoin(self.config["url"], error_msg.split(" to ")[1])
-            if "Moved Permanently" in error_msg:
-                log.debug("Setting blocklist url to %s", location)
-                self.config["url"] = location
-            d = self.download_list(location)
-            d.addCallbacks(self.on_download_complete, self.on_download_error)
-        else:
-            if "Not Modified" in error_msg:
-                log.debug("Blocklist is up-to-date!")
-                self.up_to_date = True
-                blocklist = deluge.configmanager.get_config_dir("blocklist.cache")
-                d = threads.deferToThread(self.update_info, blocklist)
-            else:
-                log.warning("Blocklist download failed: %s", error_msg)
-                if self.failed_attempts < self.config["try_times"]:
-                    log.debug("Let's try again")
-                    self.failed_attempts += 1
-                    d = self.download_list()
-                    d.addCallbacks(self.on_download_complete, self.on_download_error)
-        return d
-
-    def import_list(self, blocklist):
-        """
-        Imports the downloaded blocklist into the session
-
-        :param blocklist: path of blocklist
-        :type blocklist: string
-        :returns: a Deferred that fires when the blocklist has been imported
-        :rtype: Deferred
-        """
-        log.trace("on import_list")
-        def on_read_ip_range(start, end):
-            """Add ip range to blocklist"""
-#            log.trace("Adding ip range %s - %s to ipfilter as blocked", start, end)
-            self.blocklist.add_rule(start.address, end.address, BLOCK_RANGE)
-            self.num_blocked += 1
-
-        def on_finish_read(result):
-            """Add any whitelisted IP's and add the blocklist to session"""
-            # White listing happens last because the last rules added have
-            # priority
-            log.info("Added %d ranges to ipfilter as blocked", self.num_blocked)
-            for ip in self.config["whitelisted"]:
-                ip = IP.parse(ip)
-                self.blocklist.add_rule(ip.address, ip.address, ALLOW_RANGE)
-                self.num_whited += 1
-                log.trace("Added %s to the ipfiler as white-listed", ip.address)
-            log.info("Added %d ranges to ipfilter as white-listed", self.num_whited)
-            self.core.session.set_ip_filter(self.blocklist)
-            return result
-
-        # TODO: double check logic
-        if self.up_to_date and self.has_imported:
-            log.debug("Latest blocklist is already imported")
-            return defer.succeed(blocklist)
-
-        self.is_importing = True
-        self.num_blocked = 0
-        self.num_whited = 0
-        self.blocklist = self.core.session.get_ip_filter()
-
-        if not blocklist:
-            blocklist = self.filename
-
-        if not self.reader:
-            self.auto_detect(blocklist)
-            self.auto_detected = True
-
-        def on_reader_failure(failure):
-            log.error("Failed to read!!!!!!")
-            log.exception(failure)
-
-        log.debug("Importing using reader: %s", self.reader)
-        log.debug("Reader type: %s compression: %s", self.config["list_type"], self.config["list_compression"])
-        log.debug("Clearing current ip filtering")
-#        self.blocklist.add_rule("0.0.0.0", "255.255.255.255", ALLOW_RANGE)
-        d = threads.deferToThread(self.reader(blocklist).read, on_read_ip_range)
-        d.addCallback(on_finish_read).addErrback(on_reader_failure)
-
-        return d
-
-    def on_import_complete(self, blocklist):
-        """
-        Runs any import clean up functions
-
-        :param blocklist: path of blocklist
-        :type blocklist: string
-        :returns: a Deferred that fires when clean up is done
-        :rtype: Deferred
-        """
-        log.trace("on_import_list_complete")
-        d = blocklist
-        self.is_importing = False
-        self.has_imported = True
-        log.debug("Blocklist import complete!")
-        cache = deluge.configmanager.get_config_dir("blocklist.cache")
-        if blocklist != cache:
-            if self.is_url:
-                log.debug("Moving %s to %s", blocklist, cache)
-                d = threads.deferToThread(shutil.move, blocklist, cache)
-            else:
-                log.debug("Copying %s to %s", blocklist, cache)
-                d = threads.deferToThread(shutil.copy, blocklist, cache)
-        return d
-
-    def on_import_error(self, f):
-        """
-        Recovers from import error
-
-        :param f: failure that occured
-        :type f: Failure
-        :returns: a Deferred if recovery was possible
-                  else the original failure
-        :rtype: Deferred or Failure
-        """
-        log.trace("on_import_error: %s", f)
-        d = f
-        self.is_importing = False
-        try_again = False
-        cache = deluge.configmanager.get_config_dir("blocklist.cache")
-
-        if f.check(ReaderParseError) and not self.auto_detected:
-            # Invalid / corrupt list, let's detect it
-            log.warning("Invalid / corrupt blocklist")
-            self.reader = None
-            blocklist = None
-            try_again = True
-        elif self.filename != cache and os.path.exists(cache):
-            # If we have a backup and we haven't already used it
-            log.warning("Error reading blocklist: %s", f.getErrorMessage())
-            blocklist = cache
-            try_again = True
-
-        if try_again:
-            d = self.import_list(blocklist)
-            d.addCallbacks(self.on_import_complete, self.on_import_error)
-
-        return d
-
-    def auto_detect(self, blocklist):
-        """
-        Tries to auto-detect the blocklist type
-
-        :param blocklist: path of blocklist to auto-detect
-        :type blocklist: string
-        :raises UnknownFormatError: if the format cannot be detected
-        """
-        self.config["list_compression"] = detect_compression(blocklist)
-        self.config["list_type"] = detect_format(blocklist, self.config["list_compression"])
-        log.debug("Auto-detected type: %s compression: %s", self.config["list_type"], self.config["list_compression"])
-        if not self.config["list_type"]:
-            self.config["list_compression"] = ""
-            raise UnknownFormatError
-        else:
-            self.reader = create_reader(self.config["list_type"], self.config["list_compression"])
-
-
-    def pause_session(self):
-        if not self.core.session.is_paused():
-            self.core.session.pause()
-            self.need_to_resume_session = True
-        else:
-            self.need_to_resume_session = False
-
-    def resume_session(self, result):
-        self.core.session.resume()
-        self.need_to_resume_session = False
-        return result