Tag 1.1.2 release

Remove ui/webui/ssl from package_data since it doesn't exist

.gitattributes

@@ -1,10 +0,0 @@
-/libtorrent export-ignore
-/win32 export-ignore
-docs/build export-ignore
-docs/source export-ignore
-/tests export-ignore
-deluge/scripts export-ignore
-.gitattributes export-ignore
-.gitmodules export-ignore
-.gitignore export-ignore
-*.py diff=python

.gitignore

@@ -1,11 +0,0 @@
-*~
-build
-dist
-*egg-info
-*.egg
-*.log
-*.pyc
-*.tar.*
-_trial_temp
-deluge/i18n/*/
-*.desktop

ChangeLog

@@ -1,149 +1,393 @@
-=== Deluge 1.3.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.
+Deluge 1.1.2 - (31 January 2009)
+ Core:
+  * Fix issue where torrents get stuck Checking
 
-==== 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
-	* 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 #761 use proper theme colours in sidebar
+  * Fix saving files/peers tab state when no column is sorted
 
-==== 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.
+Deluge 1.1.1 - (24 January 2009)
+ Core:
+  * Fix oldstateupgrader for those upgrading from 0.5.x
+  * Fix setting Peer TOS byte
+  * Fix setting outgoing ports
 
-==== WebUI ====
-	* Migrate to ExtJS 3.1
-	* Add gzip compression of HTTP data to the server
-	* Improve the efficiency of the TorrentGrid
+ GtkUI:
+  * Fix opening links from Help menu and others
+  * Fix remembering sorted column in the torrent list
+  * Fix saving Files tab and Peers tab state
+  * Disable popup notification in preferences on Windows
+  * Fix crashing in AddTorrentDialog when removing torrents from the list
+  * Do not allow duplicate torrents in the AddTorrentDialog
+  * Fix translating speed units in status tab when a per-torrent limit is set
+  * Fix torrents not displaying properly after disconnecting and reconnecting to the daemon
+  * Fix when sorting # column, downloads should be on top
 
-==== Blocklist ====
-	* Implement local blocklist support
-	* #861: Pause transfers until blocklist is imported
+ Misc:
+  * Fix bdecoding some torrent files
+  * Fix the -l, --logfile option
+  * Fix #729 tracker icons not being saved in the correct location
+  * Add support for more tracker icons
+  * Fix being able to connect to a local daemon from another user account
 
-=== 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
+Deluge 1.1.0 - "Time gas!" (10 January 2009)
+ Core:
+  * Fix issue in get_tracker_host when the torrent has no tracker
+  * Fix crash while trying to convert very old 0.5 config files
 
-==== 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
+ GtkUI:
+  * Fix translation setting in remove torrent dialog
+  * Fix notification bug on startup for already finished torrents
 
-==== ConsoleUI ====
-	* Changed to use curses for a more interactive client
+ Ajaxui:
+  * Fix loading on iPods.
+  * Fix sorting on the name column.
+  * Add "Not Implemented" alerts to some functions.
+  * Improve the options tab on the Add Torrent dialog
 
-==== WebUI ====
-	* Move over to using Twisted-Web for the webserver.
-	* Move to only AJAX interface built upon Ext-JS.
+ ConsoleUI:
+  * Fix auto-complete feature for torrents.
 
-==== Plugins ====
-	* Add Scheduler plugin
-	* Add Extractor plugin
+ Misc:
+  * Added '-s', '--set-default-ui' option to deluge
 
-==== 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_RC3 (05 January 2009)
+ Core:
+  * Fix applying proxy settings
+  * Fix the display of the tracker host when it's an IP address and not a hostname
 
-=== 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:
+  * Fix folder renaming to display the change properly
+  * Fix seeding torrents from moving around when sorting the '#' column
 
-==== 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
+ Plugins:
+  * Label: Fix move on completed
+  * Add 'PeerGuardian Text (GZip)' reader to the Blocklist plugin
+  * Apply Blocklist preferences when clicking on the buttons
 
-==== 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
+Deluge 1.1.0_RC2 (29 December 2008)
+ Core:
+  * Fix new version check
+  * Fix issue that prevented torrents from being added
 
-==== AjaxUI ====
-	* Hosted in a webui template.
+ GtkUI:
+  * Fix tooltip for 'Show session speed in titlebar' option
 
-==== ConsoleUI ====
-	* New ConsoleUI written by Idoa01
-	* Callable from command-line for scripts.
+ Plugins:
+  * Remove Stats plugin since it wasn't intended to be in this release
+  * Fix never-ending import in Blocklist on Windows
 
-==== Plugins ====
-	* Stats plugin for graphs.
-	* Label plugin for grouping torrents and per torrent settings.
+ Windows:
+  * Fix double-click association on Windows
+  * Fix Pidgin icon interference
 
-==== 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".
+Deluge 1.1.0_RC1 (23 December 2008)
+ 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
+  * FilterManager 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
+  * Basic authentication for remote access to daemon, see: http://dev.deluge-torrent.org/wiki/Authentication
+
+ 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 FilterManager)
+  * 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".
+
+Deluge 1.0.7 (10 December 2008)
+ GtkUI:
+  * Fix #636 not setting the daemon's config directory when using --config= with the UI in classic mode.
+  * Fix some minor bugs in ConnectionManager
+
+ Debian:
+  * Fix #571 notification-daemon-xfce dependency circle
+
+ Misc:
+  * Fix #547 add description to name field per HIG entry 2.1.1.1
+  * libtorrent updates
+
+ Plugins:
+  * Point default blocklist url to our server and up interval to 4 days
+
+Deluge 1.0.6 (01 December 2008)
+ Core:
+  * Fix #475 catch unicode decoding errors
+  * Add an option to not include IP overhead in rate limiting (this is equivalent
+    to how 0.5.x behaves)
+  * Have default blocklist url point to our server
+
+ GtkUI:
+  * Display the proper downloaded value in the statistics tab
+
+ Windows:
+  * Fix broken graphic in new release dialog
+
+Deluge 1.0.5 (09 November 2008)
+ GtkUI:
+  * Increase the per-torrent stop share ratio max to 99999.0
+  * Fix #528 make sure gtkui config file is written before exiting
+  * Fix UDP tracker support
+
+ WebUi:
+  * Javascript auto refresh for both templates.
+
+ Windows:
+  * Fix #577 adding torrents by drag n' drop
+  * Fix association in Vista
+  * Fix WebUI launch
+
+ Debian:
+  * SID packages now requires Boost 1.36
+
+ Ubuntu:
+  * Jaunty packages are now provided
+
+Deluge 1.0.4 (31 October 2008)
+ Core:
+  * Fix #560 force an int value for global max connections
+  * Fix #545 use proper values in ratio calculation
+  * Fix UPnP again..
+
+ GtkUI:
+  * Fix #565 wait for the deluged process to start to prevent defunct processes
+
+ OS X:
+  * Fix issues with gettext
+
+ Windows:
+  * Fix starting on non-English versions of Windows
+
+Deluge 1.0.3 (18 October 2008)
+ Core:
+  * Fix upnp - it should work on more routers now too
+  * Fix issue where Deluge would send improper stats to the tracker after a
+    pause/resume.
+  * Fix issue where fastresume files would be rejected when using FAT32.  This
+    would cause the torrent to be rechecked on every startup.
+  * Fix ip filtering
+
+ GtkUI:
+  * Re-add the "Max Connections Per Second" option with a default setting of 20
+
+ WebUI:
+  * Fix White template for Opera
+
+ Misc:
+  * Deluge will now use a system libtorrent library if available.
+  * The build system will no longer build libtorrent if a system library is
+    detected.
+
+Deluge 1.0.2 (10 October 2008)
+ Core:
+  * Fix issue where torrents will not be properly added to the session
+
+Deluge 1.0.1 (10 October 2008)
+ Core:
+  * Change the default max global upload slots to 4 instead of -1 since libtorrent
+    will automatically open more slots to meet the upload speed limit.
+  * Fix display of tracker error messages
+  * Fix add_torrent_url() to download the torrent file in a thread to prevent
+    the main thread from blocking and causing the daemon to freeze.
+  * Removed the 'Maximum Connections Per Second' setting and replaced it with a
+    default setting of 20.  This should alleviate speed issues some are experiencing.
+  * Changed max half-open connections default limit to 8 on XP/2000 and 4 on Vista
+  * Prevent being able to set file priorities for compactly allocated torrents as
+    it is not intended to work.
+  * Fix freezing on start-up issues on systems that do not have a properly
+    configured localhost entry.
+  * Change max connections default setting to 200
+  * Fix issue with invalid bencoding from some trackers
+  * Plenty of libtorrent updates that should improve core stability
+
+ GtkUI:
+  * Improve performance of files tab by only updating when values change
+
+ Misc:
+  * Fix #187 set a 5 second timer to save the config file after a config value
+    has been changed.
+  * Fix #503 change the boost lib detection logic to first look for -mt and
+    if not available, fall back to regular boost lib (non-multithreaded)
+
+ WebUI:
+  * Add enable "Auto Add" checkbox
+
+Deluge 1.0.0 - "Sharks Are Bulletproof" (21 September 2008)
+ Core:
+  * Include GeoIP database for country look-ups
+  * Fix upgrading from 0.5.x state where torrents would have no trackers
+
+Deluge 0.9.09 - "1.0.0_RC9" (15 September 2008)
+ Core:
+  * Bug fixes in libtorrent including a crash when the tracker doesn't
+    have 'announce' in it's url.
+  * Fix fastresume issue causing loss of data by deleting the fastresume file
+    before writing a new one
+  * Fix #475 the use of unicode paths when adding torrents
+
+ GtkUI:
+  * Fix add torrent dialog closing preventing another dialog from being shown
+  * Fix various issues when not using English
+  * Fix setting file priorities on folders
+
+Deluge 0.9.08 - "1.0.0_RC8" (27 August 2008)
+ Core:
+  * Attempt to automatically upgrade a 0.5.x state file to new format
+  * Tracker errors now change the tracker status
+
+ Plugins:
+  * Fix bug in Blocklist that prevented downloading a new file every X days
+
+ GtkUI:
+  * Sort filenames alphabetically in add torrent dialog
+  * Fix setting file priorities on folders
+  * Fix #453 allow showing of text in the toolbar buttons
+
+Deluge 0.9.07 - "1.0.0_RC7" (18 August 2008)
+ Core:
+  * Fix loading torrents from state when fastresume file is missing
+  * Fix UPnP
+  * Fix to prevent Deluge from segfaulting when trying to autoadd an incomplete torrent file
+  * Fix #407 possible negative ETA
+
+ GtkUI:
+  * Add 'edit' to edit trackers dialog
+  * Improve performance of initial torrent list load
+  * Fix hiding the bottom pane when disabling all the tabs
+  * Fix not showing new torrents if you don't use the All label first
+  * Fix size units to be more accurate
+  * Fix torrentview sorting to be persistent
+  * Fix not displaying file list when state changes
+  * Expand root folder in files tab by default
+
+ Null:
+  * Fix #415 crash when using 'config-set' with no parameters
+
+ Windows:
+  * Fix Vista slowness issue
+  * Fix properly shutting Deluge down when system shuts down
+  * Fix opening folders/files
+
+Deluge 0.9.06 - "1.0.0_RC6" (13 August 2008)
+ Core:
+  * Fix CPU spikes
+
+ GtkUI:
+  * Fix move storage dialog when connected to a remote daemon
+
+Deluge 0.9.05 - "1.0.0_RC5" (04 August 2008)
+ Core:
+  * Fix deluged running with ssh X forwarding by removing the Gnome lib import
+  * Save resume data periodically to help prevent data loss
+  * Fix queue order shuffling on restart
+
+ GtkUI:
+  * Handle shutting down more cleanly
+  * Add translators to credits
+
+ Plugins:
+  * Improve the Blocklist plugin preferences page.
+
+ Windows:
+  * Fix drag n' drop support
+
+Deluge 0.9.04 - "1.0.0_RC4" (29 July 2008)
+ Core:
+  * Fix building with gcc 4.3
+  * Fix do not create torrentfiles folder unless 'copy_torrent_file' is True
+
+ GtkUI:
+  * Add drag n' drop support for adding .torrent files
+  * Double-clicking on host in ConnectionManager now will connect to that host
+  * Fix selecting torrents when right-clicking on them in torrentview and filestab
+  * Fix new release check
+  * Display 'total_wanted' instead of 'total_size' in Size column
+  * Fix displaying of torrents when language is not English
+  * Fix the view options to be persistent between sessions
+  * Fix signalreceiver when switching between daemons
+
+Deluge 0.9.03 - "1.0.0_RC3" (21 July 2008)
+ Core:
+  * File progress fixes from libtorrent
+  * Fix building on FreeBSD
+  * Fix #350 stop seeds when stop ratio is reached
+  * Fix #358 properly emit torrent_removed signal when remove_at_ratio happens
+
+ UI:
+  * Default to gtkui when running 'deluge' instead of defaulting to last used.
+
+ GtkUI:
+  * Fix open folder
+  * Fix #349 tab ordering when hiding/showing
+
+ Windows:
+  * Fix torrent file association and adding files from command line
+
+ Plugins:
+  * Blocklist plugin has been rewritten
+
+ Misc:
+  * Some changes for python 2.6 compatibility
+
+Deluge 0.9.02 - "1.0.0_RC2" (15 July 2008)
+ Core:
+  * Fix displaying of file progress
+  * Fix files to have proper read/write permissions
+
+ WebUI:
+  * Include missing 'classic' template
+  * Update options tab to include queue settings
+
+ Windows:
+  * Fix displaying of tray icon
+  * Fix scrolling of tray menu
+  * Fix hiding of tray icon when shutting down
+  * Fix tray icon tool tip length to show properly

DEPENDS

@@ -1,29 +0,0 @@
-=== Core ===
- * python >= 2.5
- * twisted >= 8.1
- * twisted-web >= 8.1
- * pyopenssl
- * simplejson (if python < 2.6)
- * setuptools
- * gettext
- * intltool
- * pyxdg
- * chardet
- * geoip-database (optional)
-
- * libtorrent >= 0.14, or build the included version
-
- * If building included libtorrent::
-   * boost >= 1.34.1
-   * openssl
-   * zlib
-
-=== Gtk ===
- * python-notify (libnotify python wrapper)
- * pygame
- * pygtk >= 2.12
- * librsvg
- * xdg-utils
-
-=== Web ===
- * mako

LICENSE

@@ -1,16 +1,3 @@
-Deluge is licensed under the GNU General Public License version 3 with the
-addition of the following special exception:
-
-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.
-
                     GNU GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007
 

MANIFEST.in

@@ -1,12 +0,0 @@
-recursive-include docs/man *
-recursive-include deluge *
-recursive-include win32 *
-
-recursive-exclude deluge *.egg-link
-exclude deluge/ui/web/gen_gettext.py
-exclude deluge/ui/web/css/*-debug.css
-exclude deluge/ui/web/js/build.sh
-exclude deluge/ui/web/js/Deluge*.js
-exclude deluge/ui/web/js/*-debug.js
-prune deluge/ui/web/docs
-prune deluge/scripts

README

@@ -1,23 +1,23 @@
-
 ==========================
  Deluge BitTorrent Client
 ==========================
 
-Homepage: http://deluge-torrent.org
-
 Authors:
     Andrew Resch
-    Damien Churchill
+    Marcos Pinto
+    Martijn Voncken
+    Sadrul Habib Chowdhury
+
+Homepage: http://deluge-torrent.org
 
-For past developers and contributers see: http://dev.deluge-torrent.org/wiki/About
 
 ==========================
 License
 ==========================
 Deluge is under the GNU GPLv3 license.
-Icon ui/data/pixmaps/deluge.svg and derivatives in ui/data/icons are copyright
+Icon data/pixmaps/deluge.svg and derivatives in data/icons are copyright
 Andrew Wedderburn and are under the GNU GPLv3.
-All other icons in ui/data/pixmaps are copyright Andrew Resch and are under
+All other icons in data/pixmaps are copyright Andrew Resch and are under
 the GNU GPLv3.
 
 ==========================
@@ -26,27 +26,22 @@ Contact/Support:
 
 We have two options available for support:
 
-	Our Forum, at: http://forum.deluge-torrent.org
+	Our Forum, at http://forum.deluge-torrent.org
 		or
-	Our IRC Channel, at #deluge on Freenode: http://freenode.net
+	Our IRC Channel, at #deluge on Freenode
 
 ==========================
 Installation Instructions:
 ==========================
 
-For more detailed instructions see: http://dev.deluge-torrent.org/wiki/Installing/Source
-
-See: DEPENDS for a full list of dependencies.
-
 First, make sure you have the proper build dependencies installed.  On a normal
 Debian or Ubuntu system:
 
 sudo apt-get install g++ make python-all-dev python-all python-dbus \
     python-gtk2 python-notify librsvg2-common python-xdg python-support \
-    subversion libboost-dev libboost-python-dev \
+    subversion libboost-dev libboost-python-dev libboost-iostreams-dev \
     libboost-thread-dev libboost-date-time-dev libboost-filesystem-dev \
-    libssl-dev zlib1g-dev python-setuptools \
-    python-mako python-twisted-web python-chardet python-simplejson
+    libboost-serialization-dev libssl-dev zlib1g-dev python-setuptools
 
 The names of the packages may vary depending on your OS / distro.
 
@@ -55,6 +50,7 @@ Once you have the needed libraries installed, build and install by running:
 	$ python setup.py build
 	$ sudo python setup.py install
 
+
 ==========================
 FAQ
 ==========================
@@ -62,33 +58,36 @@ FAQ
 How to start the various user-interfaces
 
     Gtk:
-        deluge-gtk
+        deluge --ui gtk
     Console:
-        deluge-console
+        deluge --ui null
     Web:
-        deluge-web
+        deluge --ui web
         Go to http://localhost:8112/ default-password = "deluge"
 
+I started "deluge" but i don't see the gtk-ui
+
+    The deluge command remembers the last interface it started. Be explicit and type one of the full "deluge -u <interface>" commands listed above.
+
 Why is deluge still listed in my system tray even after I close it ?
 
     You closed the gtk user-interface but you did not close the daemon. Choose "Quit & Shutdown Daemon" to close both Daemon and gtk-ui.
 
-How do I start the daemon?
+How do I start the daemon ?
 
     deluged
 
-How do I start the daemon with logging to console?
+How do I start the daemon with logging to console ?
 
-    deluged -d -L <log level>
+    deluged -d
 
 I can't connect to the daemon from another machine
 
     * Configure the daemon to allow remote connections
-    * Add a user to the auth file located in the config folder: ~/.config/deluge/auth
     * Restart the daemon.
 
+    Note: do not do this on a public ip , use the webui for unsecure networks.
+
 I upgraded from 0.5 and plugin x is missing
 
     1.0 is a rewrite, all old 0.5 plugins have to be rewritten.
-
-For the full FAQ see: http://dev.deluge-torrent.org/wiki/Faq

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

debian/changelog

@@ -0,0 +1,5 @@
+deluge-torrent (1.1.2-1) unstable; urgency=low
+
+  * 1.1.2 final
+
+ -- Andrew Resch (andar) <andrewresch@gmail.com>  Sat, 31 Jan 2008 16:31:14 -0800

debian/changelog.debian-lenny

@@ -0,0 +1,5 @@
+deluge-torrent (0.6.0-svn3235-1) lenny; urgency=low
+
+  * Daily Build
+
+ -- Andrew Resch (andar) <andrewresch@gmail.com>  Tue, 17 Jun 2008 16:31:14 -0800

debian/changelog.debian-sid

@@ -0,0 +1,5 @@
+deluge-torrent (0.6.0-svn3235-1) unstable; urgency=low
+
+  * Daily Build
+
+ -- Andrew Resch (andar) <andrewresch@gmail.com>  Tue, 17 Jun 2008 16:31:14 -0800

debian/changelog.ubuntu-gutsy

@@ -0,0 +1,5 @@
+deluge-torrent (0.6.0-svn3235-1) gutsy; urgency=low
+
+  * Daily Build
+
+ -- Andrew Resch (andar) <andrewresch@gmail.com>  Tue, 17 Jun 2008 16:31:14 -0800

debian/changelog.ubuntu-hardy

@@ -0,0 +1,5 @@
+deluge-torrent (0.6.0-svn3235-1) hardy; urgency=low
+
+  * Daily Build
+
+ -- Andrew Resch (andar) <andrewresch@gmail.com>  Tue, 17 Jun 2008 16:31:14 -0800

debian/compat

@@ -0,0 +1 @@
+5

debian/control

@@ -0,0 +1,21 @@
+Source: deluge-torrent
+Section: net
+Priority: optional
+Maintainer: Andrew Resch (andar) <andrewresch@gmail.com>
+Build-Depends: debhelper (>= 5.0.37.2), python-all-dev (>= 2.3.5-11), python-all, python-support (>= 0.5.3), libboost-dev (>= 1.34.1), libboost-thread-dev (>= 1.34.1), libboost-date-time-dev (>= 1.34.1), libboost-filesystem-dev (>= 1.34.1), libboost-python-dev (>= 1.34.1), libboost-iostreams-dev (>= 1.34.1), zlib1g-dev, libssl-dev, dpatch, python-setuptools
+Standards-Version: 3.7.2
+
+Package: deluge-torrent
+Architecture: any
+Depends: ${shlibs:Depends}, ${python:Depends}, python-gtk2, python-glade2, python-xdg, python-notify, notification-daemon | notification-daemon-xfce, python-dbus, librsvg2-common, python-pyopenssl, python-setuptools, python-pkg-resources
+Conflicts: deluge-torrent-common
+Replaces: deluge-torrent-common
+Description: A Bittorrent client written in Python/PyGTK
+ Deluge is a Bittorrent client, created using Python and GTK+.
+ .
+ Deluge is intended to bring a native, full-featured client to Linux GTK
+ desktop environments such as Gnome and XFCE.
+ .
+ It uses Rasterbar's version of libtorrent.
+ .
+  Homepage: http://www.deluge-torrent.org/

debian/control.debian-lenny

@@ -0,0 +1,19 @@
+Source: deluge-torrent
+Section: net
+Priority: optional
+Maintainer: Andrew Resch (andar) <andrewresch@gmail.com>
+Build-Depends: debhelper (>= 5.0.37.2), python-all-dev (>= 2.3.5-11), python-all, python-support (>= 0.5.3), libboost-dev (>= 1.33.1), libboost-thread-dev (>= 1.33.1), libboost-date-time-dev (>= 1.33.1), libboost-filesystem-dev (>= 1.33.1), libboost-serialization-dev (>= 1.33.1), libboost-program-options-dev (>= 1.33.1), libboost-regex-dev (>= 1.33.1), libboost-python-dev (>= 1.33.1), zlib1g-dev, libssl-dev, dpatch, python-setuptools
+Standards-Version: 3.7.2
+
+Package: deluge-torrent
+Architecture: any
+Depends: ${shlibs:Depends}, ${python:Depends}, python-gtk2, python-glade2, python-xdg, python-notify, notification-daemon | notification-daemon-xfce, python-dbus, librsvg2-common, python-pyopenssl, python-setuptools
+Description: A Bittorrent client written in Python/PyGTK
+ Deluge is a Bittorrent client, created using Python and GTK+.
+ .
+ Deluge is intended to bring a native, full-featured client to Linux GTK
+ desktop environments such as Gnome and XFCE.
+ .
+ It uses Rasterbar's version of libtorrent.
+ .
+  Homepage: http://www.deluge-torrent.org/

debian/control.debian-sid

@@ -0,0 +1,19 @@
+Source: deluge-torrent
+Section: net
+Priority: optional
+Maintainer: Andrew Resch (andar) <andrewresch@gmail.com>
+Build-Depends: debhelper (>= 5.0.37.2), python-all-dev (>= 2.3.5-11), python-all, python-support (>= 0.5.3), libboost1.36-dev (>= 1.36), libboost-thread1.36-dev (>= 1.36), libboost-date-time1.36-dev (>= 1.36), libboost-filesystem1.36-dev (>= 1.36), libboost-serialization1.36-dev (>= 1.36), libboost-program-options1.36-dev (>= 1.36), libboost-regex1.36-dev (>= 1.36), libboost-python1.36-dev (>= 1.36), zlib1g-dev, libssl-dev, dpatch, python-setuptools
+Standards-Version: 3.7.2
+
+Package: deluge-torrent
+Architecture: any
+Depends: ${shlibs:Depends}, ${python:Depends}, python-gtk2, python-glade2, python-xdg, python-notify, notification-daemon | notification-daemon-xfce, python-dbus, librsvg2-common, python-pyopenssl, python-setuptools
+Description: A Bittorrent client written in Python/PyGTK
+ Deluge is a Bittorrent client, created using Python and GTK+.
+ .
+ Deluge is intended to bring a native, full-featured client to Linux GTK
+ desktop environments such as Gnome and XFCE.
+ .
+ It uses Rasterbar's version of libtorrent.
+ .
+  Homepage: http://www.deluge-torrent.org/

debian/copyright

@@ -0,0 +1,99 @@
+This package was debianized by Marcos Pinto (markybob) <markybob@gmail.com> on
+Fri, 31 Jul 2008 22:03:13 +0100.
+
+It was downloaded from http://www.deluge-torrent.org/
+
+Upstream Authors & Copyright: 
+    Andrew Resch
+    Marcos Pinto
+    Sadrul Habib Chowdhury
+    Martijn Voncken
+
+License:
+
+   This package 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.
+
+   This package 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 package; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, 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.
+
+On Debian systems, the complete text of the GNU General
+Public License can be found in `/usr/share/common-licenses/GPL'.
+
+libtorrent is (C) 2003-2008 Arvid Norberg arvid@cs.umu.se and its 
+python bindings were initially written by Daniel Wallin in 2006.
+It is distributed unders terms of the BSD License below:
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+
+  * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the distribution.
+  * Neither the name of the author nor the names of its
+    contributors may be used to endorse or promote products derived
+    from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+  POSSIBILITY OF SUCH DAMAGE.
+
+  "libtorrent/include/libtorrent/asio*" are (C) 2003-2008 Christopher
+  M. Kohlhoff <chris@kohlhoff.com> and distributed under terms of the Boost
+  Software License, Version 1.0 :
+
+    Permission is hereby granted, free of charge, to any person or organization
+    obtaining a copy of the software and accompanying documentation covered by
+    this license (the "Software") to use, reproduce, display, distribute,
+    execute, and transmit the Software, and to prepare derivative works of the
+    Software, and to permit third-parties to whom the Software is furnished to
+    do so, all subject to the following:
+    The copyright notices in the Software and this entire statement, including
+    the above license grant, this restriction and the following disclaimer,
+    must be included in all copies of the Software, in whole or in part, and
+    all derivative works of the Software, unless such copies or derivative
+    works are solely in the form of machine-executable object code generated by
+    a source language processor.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+    SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+    FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+    ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS IN THE SOFTWARE.
+
+"deluge/i18n/*" are (C) 2006 Rosetta Contributors and Canonical Ltd 2006 and distributed
+under the same license as the deluge software.
+
+The Debian packaging is (C) 2006-2008, Marcos Pinto (markybob)
+<markybob@gmail.com> and  is licensed under GPL3, see above.

debian/manpages

@@ -0,0 +1,2 @@
+deluge/docs/man/deluge.1
+deluge/docs/man/deluged.1

debian/menu

@@ -0,0 +1,3 @@
+?package(deluge-torrent): needs="X11" section="Applications/Network/File Transfer" \
+  title="Deluge BitTorrent Client" longtitle="Bittorrent client written in Python/PyGTK" \
+  command="/usr/bin/deluge" icon="/usr/share/pixmaps/deluge.png"

debian/pyversions

@@ -0,0 +1 @@
+2.5

debian/pyversions.ubuntu-gutsy

@@ -0,0 +1 @@
+2.5

debian/pyversions.ubuntu-hardy

@@ -0,0 +1 @@
+2.5

debian/rules

@@ -0,0 +1,75 @@
+#!/usr/bin/make -f
+
+# Uncomment this to turn on verbose mode.
+#export DH_VERBOSE=1
+
+# Dpatch targets
+include /usr/share/dpatch/dpatch.make
+
+# Available python (using debian/pyversions) and destdir
+PYVERS      = 2.5
+DESTDIR     = $(CURDIR)/debian/deluge-torrent
+
+# We need to known the target arch to enable/disable amd64 hack
+ARCH	    = $(shell dpkg-architecture -qDEB_BUILD_ARCH_CPU)
+ARCH64	    = ia64 amd64 alpha kfreebsd-amd64 ppc64
+
+CFLAGS = -Wall -g
+ifneq (,$(findstring noopt,$(DEB_BUILD_OPTIONS)))
+	CFLAGS += -O0
+else
+	CFLAGS += -O2
+endif
+# python-libtorrent need to define AMD64 to work fine on a 64 bits system
+ifneq (,$(findstring $(ARCH),$(ARCH64)))
+	CFLAGS += -DAMD64
+endif
+
+build: patch-stamp $(PYVERS:%=build-stamp%)
+build-stamp%: patch-stamp
+	dh_testdir
+	CFLAGS="$(CFLAGS)" python$* setup.py build
+	touch $@
+
+clean: unpatch
+	dh_testdir
+	dh_testroot
+	rm -rf build/
+	find . -name \*.pyc | xargs rm -f
+	rm -rf build-stamp*
+	dh_clean
+
+install: build install-prereq $(PYVERS:%=install-%) install-finish
+install-prereq:
+	dh_testdir
+	dh_testroot
+	dh_clean -k
+	dh_installdirs
+install-%:
+	python$* setup.py install --root=$(DESTDIR) --prefix=/usr --no-compile
+install-finish:
+	# Desktop menu
+	rm -rf $(DESTDIR)/usr/share/applications
+	install -D -m644 $(CURDIR)/deluge/data/share/applications/deluge.desktop $(DESTDIR)/usr/share/applications/deluge.desktop
+
+
+binary-indep: build install
+binary-arch: build install
+	dh_testdir
+	dh_testroot
+	dh_installchangelogs
+	dh_installdocs
+	dh_installmenu
+	dh_strip
+	dh_compress
+	dh_fixperms
+	dh_pysupport
+	dh_desktop
+	dh_installdeb
+	dh_shlibdeps
+	dh_gencontrol
+	dh_md5sums
+	dh_builddeb
+
+binary: binary-indep binary-arch
+.PHONY: build clean binary-indep binary-arch binary install

deluge/SimpleXMLRPCServer.py

@@ -0,0 +1,595 @@
+"""Simple XML-RPC Server.
+
+This module can be used to create simple XML-RPC servers
+by creating a server and either installing functions, a
+class instance, or by extending the SimpleXMLRPCServer
+class.
+
+It can also be used to handle XML-RPC requests in a CGI
+environment using CGIXMLRPCRequestHandler.
+
+A list of possible usage patterns follows:
+
+1. Install functions:
+
+server = SimpleXMLRPCServer(("localhost", 8000))
+server.register_function(pow)
+server.register_function(lambda x,y: x+y, 'add')
+server.serve_forever()
+
+2. Install an instance:
+
+class MyFuncs:
+    def __init__(self):
+        # make all of the string functions available through
+        # string.func_name
+        import string
+        self.string = string
+    def _listMethods(self):
+        # implement this method so that system.listMethods
+        # knows to advertise the strings methods
+        return list_public_methods(self) + \
+                ['string.' + method for method in list_public_methods(self.string)]
+    def pow(self, x, y): return pow(x, y)
+    def add(self, x, y) : return x + y
+
+server = SimpleXMLRPCServer(("localhost", 8000))
+server.register_introspection_functions()
+server.register_instance(MyFuncs())
+server.serve_forever()
+
+3. Install an instance with custom dispatch method:
+
+class Math:
+    def _listMethods(self):
+        # this method must be present for system.listMethods
+        # to work
+        return ['add', 'pow']
+    def _methodHelp(self, method):
+        # this method must be present for system.methodHelp
+        # to work
+        if method == 'add':
+            return "add(2,3) => 5"
+        elif method == 'pow':
+            return "pow(x, y[, z]) => number"
+        else:
+            # By convention, return empty
+            # string if no help is available
+            return ""
+    def _dispatch(self, method, params):
+        if method == 'pow':
+            return pow(*params)
+        elif method == 'add':
+            return params[0] + params[1]
+        else:
+            raise 'bad method'
+
+server = SimpleXMLRPCServer(("localhost", 8000))
+server.register_introspection_functions()
+server.register_instance(Math())
+server.serve_forever()
+
+4. Subclass SimpleXMLRPCServer:
+
+class MathServer(SimpleXMLRPCServer):
+    def _dispatch(self, method, params):
+        try:
+            # We are forcing the 'export_' prefix on methods that are
+            # callable through XML-RPC to prevent potential security
+            # problems
+            func = getattr(self, 'export_' + method)
+        except AttributeError:
+            raise Exception('method "%s" is not supported' % method)
+        else:
+            return func(*params)
+
+    def export_add(self, x, y):
+        return x + y
+
+server = MathServer(("localhost", 8000))
+server.serve_forever()
+
+5. CGI script:
+
+server = CGIXMLRPCRequestHandler()
+server.register_function(pow)
+server.handle_request()
+"""
+
+# Written by Brian Quinlan (brian@sweetapp.com).
+# Based on code written by Fredrik Lundh.
+
+import xmlrpclib
+from xmlrpclib import Fault
+import SocketServer
+import BaseHTTPServer
+import sys
+import os
+try:
+    import fcntl
+except ImportError:
+    fcntl = None
+
+def resolve_dotted_attribute(obj, attr, allow_dotted_names=True):
+    """resolve_dotted_attribute(a, 'b.c.d') => a.b.c.d
+
+    Resolves a dotted attribute name to an object.  Raises
+    an AttributeError if any attribute in the chain starts with a '_'.
+
+    If the optional allow_dotted_names argument is false, dots are not
+    supported and this function operates similar to getattr(obj, attr).
+    """
+
+    if allow_dotted_names:
+        attrs = attr.split('.')
+    else:
+        attrs = [attr]
+
+    for i in attrs:
+        if i.startswith('_'):
+            raise AttributeError(
+                'attempt to access private attribute "%s"' % i
+                )
+        else:
+            obj = getattr(obj,i)
+    return obj
+
+def list_public_methods(obj):
+    """Returns a list of attribute strings, found in the specified
+    object, which represent callable attributes"""
+
+    return [member for member in dir(obj)
+                if not member.startswith('_') and
+                    callable(getattr(obj, member))]
+
+def remove_duplicates(lst):
+    """remove_duplicates([2,2,2,1,3,3]) => [3,1,2]
+
+    Returns a copy of a list without duplicates. Every list
+    item must be hashable and the order of the items in the
+    resulting list is not defined.
+    """
+    u = {}
+    for x in lst:
+        u[x] = 1
+
+    return u.keys()
+
+class SimpleXMLRPCDispatcher:
+    """Mix-in class that dispatches XML-RPC requests.
+
+    This class is used to register XML-RPC method handlers
+    and then to dispatch them. There should never be any
+    reason to instantiate this class directly.
+    """
+
+    def __init__(self, allow_none, encoding):
+        self.funcs = {}
+        self.instance = None
+        self.allow_none = allow_none
+        self.encoding = encoding
+
+    def register_instance(self, instance, allow_dotted_names=False):
+        """Registers an instance to respond to XML-RPC requests.
+
+        Only one instance can be installed at a time.
+
+        If the registered instance has a _dispatch method then that
+        method will be called with the name of the XML-RPC method and
+        its parameters as a tuple
+        e.g. instance._dispatch('add',(2,3))
+
+        If the registered instance does not have a _dispatch method
+        then the instance will be searched to find a matching method
+        and, if found, will be called. Methods beginning with an '_'
+        are considered private and will not be called by
+        SimpleXMLRPCServer.
+
+        If a registered function matches a XML-RPC request, then it
+        will be called instead of the registered instance.
+
+        If the optional allow_dotted_names argument is true and the
+        instance does not have a _dispatch method, method names
+        containing dots are supported and resolved, as long as none of
+        the name segments start with an '_'.
+
+            *** SECURITY WARNING: ***
+
+            Enabling the allow_dotted_names options allows intruders
+            to access your module's global variables and may allow
+            intruders to execute arbitrary code on your machine.  Only
+            use this option on a secure, closed network.
+
+        """
+
+        self.instance = instance
+        self.allow_dotted_names = allow_dotted_names
+
+    def register_function(self, function, name = None):
+        """Registers a function to respond to XML-RPC requests.
+
+        The optional name argument can be used to set a Unicode name
+        for the function.
+        """
+
+        if name is None:
+            name = function.__name__
+        self.funcs[name] = function
+
+    def register_introspection_functions(self):
+        """Registers the XML-RPC introspection methods in the system
+        namespace.
+
+        see http://xmlrpc.usefulinc.com/doc/reserved.html
+        """
+
+        self.funcs.update({'system.listMethods' : self.system_listMethods,
+                      'system.methodSignature' : self.system_methodSignature,
+                      'system.methodHelp' : self.system_methodHelp})
+
+    def register_multicall_functions(self):
+        """Registers the XML-RPC multicall method in the system
+        namespace.
+
+        see http://www.xmlrpc.com/discuss/msgReader$1208"""
+
+        self.funcs.update({'system.multicall' : self.system_multicall})
+
+    def _marshaled_dispatch(self, data, dispatch_method = None):
+        """Dispatches an XML-RPC method from marshalled (XML) data.
+
+        XML-RPC methods are dispatched from the marshalled (XML) data
+        using the _dispatch method and the result is returned as
+        marshalled data. For backwards compatibility, a dispatch
+        function can be provided as an argument (see comment in
+        SimpleXMLRPCRequestHandler.do_POST) but overriding the
+        existing method through subclassing is the prefered means
+        of changing method dispatch behavior.
+        """
+
+        try:
+            params, method = xmlrpclib.loads(data)
+
+            # generate response
+            if dispatch_method is not None:
+                response = dispatch_method(method, params)
+            else:
+                response = self._dispatch(method, params)
+            # wrap response in a singleton tuple
+            response = (response,)
+            response = xmlrpclib.dumps(response, methodresponse=1,
+                                       allow_none=self.allow_none, encoding=self.encoding)
+        except Fault, fault:
+            response = xmlrpclib.dumps(fault, allow_none=self.allow_none,
+                                       encoding=self.encoding)
+        except:
+            # report exception back to server
+            response = xmlrpclib.dumps(
+                xmlrpclib.Fault(1, "%s:%s" % (sys.exc_type, sys.exc_value)),
+                encoding=self.encoding, allow_none=self.allow_none,
+                )
+
+        return response
+
+    def system_listMethods(self):
+        """system.listMethods() => ['add', 'subtract', 'multiple']
+
+        Returns a list of the methods supported by the server."""
+
+        methods = self.funcs.keys()
+        if self.instance is not None:
+            # Instance can implement _listMethod to return a list of
+            # methods
+            if hasattr(self.instance, '_listMethods'):
+                methods = remove_duplicates(
+                        methods + self.instance._listMethods()
+                    )
+            # if the instance has a _dispatch method then we
+            # don't have enough information to provide a list
+            # of methods
+            elif not hasattr(self.instance, '_dispatch'):
+                methods = remove_duplicates(
+                        methods + list_public_methods(self.instance)
+                    )
+        methods.sort()
+        return methods
+
+    def system_methodSignature(self, method_name):
+        """system.methodSignature('add') => [double, int, int]
+
+        Returns a list describing the signature of the method. In the
+        above example, the add method takes two integers as arguments
+        and returns a double result.
+
+        This server does NOT support system.methodSignature."""
+
+        # See http://xmlrpc.usefulinc.com/doc/sysmethodsig.html
+
+        return 'signatures not supported'
+
+    def system_methodHelp(self, method_name):
+        """system.methodHelp('add') => "Adds two integers together"
+
+        Returns a string containing documentation for the specified method."""
+
+        method = None
+        if self.funcs.has_key(method_name):
+            method = self.funcs[method_name]
+        elif self.instance is not None:
+            # Instance can implement _methodHelp to return help for a method
+            if hasattr(self.instance, '_methodHelp'):
+                return self.instance._methodHelp(method_name)
+            # if the instance has a _dispatch method then we
+            # don't have enough information to provide help
+            elif not hasattr(self.instance, '_dispatch'):
+                try:
+                    method = resolve_dotted_attribute(
+                                self.instance,
+                                method_name,
+                                self.allow_dotted_names
+                                )
+                except AttributeError:
+                    pass
+
+        # Note that we aren't checking that the method actually
+        # be a callable object of some kind
+        if method is None:
+            return ""
+        else:
+            import pydoc
+            return pydoc.getdoc(method)
+
+    def system_multicall(self, call_list):
+        """system.multicall([{'methodName': 'add', 'params': [2, 2]}, ...]) => \
+[[4], ...]
+
+        Allows the caller to package multiple XML-RPC calls into a single
+        request.
+
+        See http://www.xmlrpc.com/discuss/msgReader$1208
+        """
+
+        results = []
+        for call in call_list:
+            method_name = call['methodName']
+            params = call['params']
+
+            try:
+                # XXX A marshalling error in any response will fail the entire
+                # multicall. If someone cares they should fix this.
+                results.append([self._dispatch(method_name, params)])
+            except Fault, fault:
+                results.append(
+                    {'faultCode' : fault.faultCode,
+                     'faultString' : fault.faultString}
+                    )
+            except:
+                results.append(
+                    {'faultCode' : 1,
+                     'faultString' : "%s:%s" % (sys.exc_type, sys.exc_value)}
+                    )
+        return results
+
+    def _dispatch(self, method, params):
+        """Dispatches the XML-RPC method.
+
+        XML-RPC calls are forwarded to a registered function that
+        matches the called XML-RPC method name. If no such function
+        exists then the call is forwarded to the registered instance,
+        if available.
+
+        If the registered instance has a _dispatch method then that
+        method will be called with the name of the XML-RPC method and
+        its parameters as a tuple
+        e.g. instance._dispatch('add',(2,3))
+
+        If the registered instance does not have a _dispatch method
+        then the instance will be searched to find a matching method
+        and, if found, will be called.
+
+        Methods beginning with an '_' are considered private and will
+        not be called.
+        """
+
+        func = None
+        try:
+            # check to see if a matching function has been registered
+            func = self.funcs[method]
+        except KeyError:
+            if self.instance is not None:
+                # check for a _dispatch method
+                if hasattr(self.instance, '_dispatch'):
+                    return self.instance._dispatch(method, params)
+                else:
+                    # call instance method directly
+                    try:
+                        func = resolve_dotted_attribute(
+                            self.instance,
+                            method,
+                            self.allow_dotted_names
+                            )
+                    except AttributeError:
+                        pass
+
+        if func is not None:
+            return func(*params)
+        else:
+            raise Exception('method "%s" is not supported' % method)
+
+class SimpleXMLRPCRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
+    """Simple XML-RPC request handler class.
+
+    Handles all HTTP POST requests and attempts to decode them as
+    XML-RPC requests.
+    """
+
+    # Class attribute listing the accessible path components;
+    # paths not on this list will result in a 404 error.
+    rpc_paths = ('/', '/RPC2')
+
+    def is_rpc_path_valid(self):
+        if self.rpc_paths:
+            return self.path in self.rpc_paths
+        else:
+            # If .rpc_paths is empty, just assume all paths are legal
+            return True
+
+    def do_POST(self):
+        """Handles the HTTP POST request.
+
+        Attempts to interpret all HTTP POST requests as XML-RPC calls,
+        which are forwarded to the server's _dispatch method for handling.
+        """
+
+        # Check that the path is legal
+        if not self.is_rpc_path_valid():
+            self.report_404()
+            return
+
+        try:
+            # Get arguments by reading body of request.
+            # We read this in chunks to avoid straining
+            # socket.read(); around the 10 or 15Mb mark, some platforms
+            # begin to have problems (bug #792570).
+            max_chunk_size = 10*1024*1024
+            size_remaining = int(self.headers["content-length"])
+            L = []
+            while size_remaining:
+                chunk_size = min(size_remaining, max_chunk_size)
+                L.append(self.rfile.read(chunk_size))
+                size_remaining -= len(L[-1])
+            data = ''.join(L)
+
+            # In previous versions of SimpleXMLRPCServer, _dispatch
+            # could be overridden in this class, instead of in
+            # SimpleXMLRPCDispatcher. To maintain backwards compatibility,
+            # check to see if a subclass implements _dispatch and dispatch
+            # using that method if present.
+            response = self.server._marshaled_dispatch(
+                    data, getattr(self, '_dispatch', None)
+                )
+        except: # This should only happen if the module is buggy
+            # internal error, report as HTTP server error
+            self.send_response(500)
+            self.end_headers()
+        else:
+            # got a valid XML RPC response
+            self.send_response(200)
+            self.send_header("Content-type", "text/xml")
+            self.send_header("Content-length", str(len(response)))
+            self.end_headers()
+            self.wfile.write(response)
+
+            # shut down the connection
+            self.wfile.flush()
+            self.connection.shutdown(1)
+
+    def report_404 (self):
+            # Report a 404 error
+        self.send_response(404)
+        response = 'No such page'
+        self.send_header("Content-type", "text/plain")
+        self.send_header("Content-length", str(len(response)))
+        self.end_headers()
+        self.wfile.write(response)
+        # shut down the connection
+        self.wfile.flush()
+        self.connection.shutdown(1)
+
+    def log_request(self, code='-', size='-'):
+        """Selectively log an accepted request."""
+
+        if self.server.logRequests:
+            BaseHTTPServer.BaseHTTPRequestHandler.log_request(self, code, size)
+
+class SimpleXMLRPCServer(SocketServer.TCPServer,
+                         SimpleXMLRPCDispatcher):
+    """Simple XML-RPC server.
+
+    Simple XML-RPC server that allows functions and a single instance
+    to be installed to handle requests. The default implementation
+    attempts to dispatch XML-RPC calls to the functions or instance
+    installed in the server. Override the _dispatch method inhereted
+    from SimpleXMLRPCDispatcher to change this behavior.
+    """
+
+    allow_reuse_address = True
+
+    def __init__(self, addr, requestHandler=SimpleXMLRPCRequestHandler,
+                 logRequests=True, allow_none=False, encoding=None):
+        self.logRequests = logRequests
+
+        SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
+        SocketServer.TCPServer.__init__(self, addr, requestHandler)
+
+        # [Bug #1222790] If possible, set close-on-exec flag; if a
+        # method spawns a subprocess, the subprocess shouldn't have
+        # the listening socket open.
+        if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
+            flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
+            flags |= fcntl.FD_CLOEXEC
+            fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
+
+class CGIXMLRPCRequestHandler(SimpleXMLRPCDispatcher):
+    """Simple handler for XML-RPC data passed through CGI."""
+
+    def __init__(self, allow_none=False, encoding=None):
+        SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
+
+    def handle_xmlrpc(self, request_text):
+        """Handle a single XML-RPC request"""
+
+        response = self._marshaled_dispatch(request_text)
+
+        print('Content-Type: text/xml')
+        print('Content-Length: %d' % len(response))
+        print(
+        sys.stdout.write(response))
+
+    def handle_get(self):
+        """Handle a single HTTP GET request.
+
+        Default implementation indicates an error because
+        XML-RPC uses the POST method.
+        """
+
+        code = 400
+        message, explain = \
+                 BaseHTTPServer.BaseHTTPRequestHandler.responses[code]
+
+        response = BaseHTTPServer.DEFAULT_ERROR_MESSAGE % \
+            {
+             'code' : code,
+             'message' : message,
+             'explain' : explain
+            }
+        print('Status: %d %s' % (code, message))
+        print('Content-Type: text/html')
+        print('Content-Length: %d' % len(response))
+        print(
+        sys.stdout.write(response))
+
+    def handle_request(self, request_text = None):
+        """Handle a single XML-RPC request passed through a CGI post method.
+
+        If no XML data is given then it is read from stdin. The resulting
+        XML-RPC response is printed to stdout along with the correct HTTP
+        headers.
+        """
+
+        if request_text is None and \
+            os.environ.get('REQUEST_METHOD', None) == 'GET':
+            self.handle_get()
+        else:
+            # POST data is normally available through stdin
+            if request_text is None:
+                request_text = sys.stdin.read()
+
+            self.handle_xmlrpc(request_text)
+
+if __name__ == '__main__':
+    print('Running XML-RPC server on port 8000')
+    server = SimpleXMLRPCServer(("localhost", 8000))
+    server.register_function(pow)
+    server.register_function(lambda x,y: x+y, 'add')
+    server.serve_forever()

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 +0,0 @@
-#
-# _libtorrent.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.
-#
-#
-
-"""
-This module is used to handle the importing of libtorrent.
-
-We use this module to control what versions of libtorrent this version of Deluge
-supports.
-
-** Usage **
-
->>> from deluge._libtorrent import lt
-
-"""
-
-REQUIRED_VERSION = "0.14.9.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)
-
-try:
-    import deluge.libtorrent as lt
-    check_version(lt)
-except ImportError:
-    import libtorrent as lt
-    check_version(lt)

deluge/common.py

@@ -19,18 +19,7 @@
 # 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.
-#
+# 	Boston, MA    02110-1301, USA.
 #
 
 
@@ -40,36 +29,9 @@ import os
 import time
 import subprocess
 import platform
-import chardet
-import logging
-
-try:
-    import json
-except ImportError:
-    import simplejson as json
-
-log = logging.getLogger(__name__)
-
-# Do a little hack here just in case the user has json-py installed since it
-# has a different api
-if not hasattr(json, "dumps"):
-    json.dumps = json.write
-    json.loads = json.read
-
-    def dump(obj, fp, **kw):
-        fp.write(json.dumps(obj))
-
-    def load(fp, **kw):
-        return json.loads(fp.read())
-
-    json.dump = dump
-    json.load = load
 
 import pkg_resources
-import gettext
-import locale
-
-from deluge.error import *
+import xdg, xdg.BaseDirectory
 
 LT_TORRENT_STATE = {
     "Queued": 0,
@@ -79,7 +41,6 @@ LT_TORRENT_STATE = {
     "Finished": 4,
     "Seeding": 5,
     "Allocating": 6,
-    "Checking Resume Data": 7,
     0: "Queued",
     1: "Checking",
     2: "Downloading Metadata",
@@ -87,10 +48,8 @@ LT_TORRENT_STATE = {
     4: "Finished",
     5: "Seeding",
     6: "Allocating",
-    7: "Checking Resume Data"
 }
 
-
 TORRENT_STATE = [
     "Allocating",
     "Checking",
@@ -105,12 +64,11 @@ FILE_PRIORITY = {
     0: "Do Not Download",
     1: "Normal Priority",
     2: "High Priority",
-    5: "High Priority",
-    7: "Highest Priority",
+    5: "Highest Priority",
     "Do Not Download": 0,
     "Normal Priority": 1,
-    "High Priority": 5,
-    "Highest Priority": 7
+    "High Priority": 2,
+    "Highest Priority": 5
 }
 
 def get_version():
@@ -123,10 +81,27 @@ def get_version():
     """
     return pkg_resources.require("Deluge")[0].version
 
+def get_revision():
+    """
+    The svn revision of the build if available
+
+    :returns: the svn revision, or ""
+    :rtype: string
+
+    """
+    revision = ""
+    try:
+        f = open(pkg_resources.resource_filename("deluge", os.path.join("data", "revision")))
+        revision = f.read()
+        f.close()
+    except IOError, e:
+        pass
+
+    return revision
+
 def get_default_config_dir(filename=None):
     """
     :param filename: if None, only the config path is returned, if provided, a path including the filename will be returned
-    :type filename: string
     :returns: a file path to the config directory and optional filename
     :rtype: string
 
@@ -137,7 +112,6 @@ def get_default_config_dir(filename=None):
         else:
             return os.path.join(os.environ.get("APPDATA"), "deluge")
     else:
-        import xdg.BaseDirectory
         if filename:
             return os.path.join(xdg.BaseDirectory.save_config_path("deluge"), filename)
         else:
@@ -152,18 +126,6 @@ def get_default_download_dir():
     if windows_check():
         return os.path.expanduser("~")
     else:
-        from xdg.BaseDirectory import xdg_config_home
-        userdir_file = os.path.join(xdg_config_home, 'user-dirs.dirs')
-        try:
-            for line in open(userdir_file, 'r'):
-                if not line.startswith('#') and 'XDG_DOWNLOAD_DIR' in line:
-                        download_dir = os.path.expandvars(\
-                                        line.partition("=")[2].rstrip().strip('"'))
-                        if os.path.isdir(download_dir):
-                            return download_dir
-        except IOError:
-            pass
-
         return os.environ.get("HOME")
 
 def windows_check():
@@ -198,33 +160,21 @@ def osx_check():
 
 def get_pixmap(fname):
     """
-    Provides easy access to files in the deluge/ui/data/pixmaps folder within the Deluge egg
+    Provides easy access to files in the deluge/data/pixmaps folder within the Deluge egg
 
     :param fname: the filename to look for
-    :type fname: string
     :returns: a path to a pixmap file included with Deluge
     :rtype: string
 
     """
-    return resource_filename("deluge", os.path.join("ui", "data", "pixmaps", fname))
-
-def resource_filename(module, path):
-    # While developing, if there's a second deluge package, installed globally
-    # and another in develop mode somewhere else, while pkg_resources.require("Deluge")
-    # returns the proper deluge instance, pkg_resources.resource_filename does
-    # not, it returns the first found on the python path, which is not good
-    # enough.
-    # This is a work-around that.
-    return pkg_resources.require("Deluge>=%s" % get_version())[0].get_resource_filename(
-        pkg_resources._manager, os.path.join(*(module.split('.')+[path]))
-    )
+    return pkg_resources.resource_filename("deluge", os.path.join("data", \
+                                           "pixmaps", fname))
 
 def open_file(path):
     """
     Opens a file or folder using the system configured program
 
     :param path: the path to the file or folder to open
-    :type path: string
 
     """
     if windows_check():
@@ -237,11 +187,16 @@ def open_url_in_browser(url):
     Opens a url in the desktop's default browser
 
     :param url: the url to open
-    :type url: string
-
     """
+    import threading
     import webbrowser
-    webbrowser.open(url)
+    class BrowserThread(threading.Thread):
+        def __init__(self, url):
+            threading.Thread.__init__(self)
+            self.url = url
+        def run(self):
+            webbrowser.open(self.url)
+    BrowserThread(url).start()
 
 ## Formatting text functions
 
@@ -249,8 +204,7 @@ def fsize(fsize_b):
     """
     Formats the bytes value into a string with KiB, MiB or GiB units
 
-    :param fsize_b: the filesize in bytes
-    :type fsize_b: int
+    :param fsize_b: int, the filesize in bytes
     :returns: formatted string in KiB, MiB or GiB units
     :rtype: string
 
@@ -262,19 +216,18 @@ def fsize(fsize_b):
     """
     fsize_kb = fsize_b / 1024.0
     if fsize_kb < 1024:
-        return "%.1f %s" % (fsize_kb, _("KiB"))
+        return "%.1f KiB" % fsize_kb
     fsize_mb = fsize_kb / 1024.0
     if fsize_mb < 1024:
-        return "%.1f %s" % (fsize_mb, _("MiB"))
+        return "%.1f MiB" % fsize_mb
     fsize_gb = fsize_mb / 1024.0
-    return "%.1f %s" % (fsize_gb, _("GiB"))
+    return "%.1f GiB" % fsize_gb
 
 def fpcnt(dec):
     """
     Formats a string to display a percentage with two decimal places
 
-    :param dec: the ratio in the range [0.0, 1.0]
-    :type dec: float
+    :param dec: float, the ratio in the range [0.0, 1.0]
     :returns: a formatted string representing a percentage
     :rtype: string
 
@@ -290,8 +243,7 @@ def fspeed(bps):
     """
     Formats a string to display a transfer speed utilizing :func:`fsize`
 
-    :param bps: bytes per second
-    :type bps: int
+    :param bps: int, bytes per second
     :returns: a formatted string representing transfer speed
     :rtype: string
 
@@ -301,23 +253,14 @@ def fspeed(bps):
     '42.1 KiB/s'
 
     """
-    fspeed_kb = bps / 1024.0
-    if fspeed_kb < 1024:
-        return "%.1f %s" % (fspeed_kb, _("KiB/s"))
-    fspeed_mb = fspeed_kb / 1024.0
-    if fspeed_mb < 1024:
-        return "%.1f %s" % (fspeed_mb, _("MiB/s"))
-    fspeed_gb = fspeed_mb / 1024.0
-    return "%.1f %s" % (fspeed_gb, _("GiB/s"))
+    return '%s/s' % (fsize(bps))
 
 def fpeer(num_peers, total_peers):
     """
     Formats a string to show 'num_peers' ('total_peers')
 
-    :param num_peers: the number of connected peers
-    :type num_peers: int
-    :param total_peers: the total number of peers
-    :type total_peers: int
+    :param num_peers: int, the number of connected peers
+    :param total_peers: int, the total number of peers
     :returns: a formatted string: num_peers (total_peers), if total_peers < 0, then it will not be shown
     :rtype: string
 
@@ -338,8 +281,7 @@ def ftime(seconds):
     """
     Formats a string to show time in a human readable form
 
-    :param seconds: the number of seconds
-    :type seconds: int
+    :param seconds: int, the number of seconds
     :returns: a formatted time string, will return '' if seconds == 0
     :rtype: string
 
@@ -375,24 +317,22 @@ def ftime(seconds):
 
 def fdate(seconds):
     """
-    Formats a date time string in the locale's date representation based on the systems timezone
+    Formats a date string in the locale's date representation based on the systems timezone
 
-    :param seconds: time in seconds since the Epoch
-    :type seconds: float
-    :returns: a string in the locale's datetime representation or "" if seconds < 0
+    :param seconds: float, time in seconds since the Epoch
+    :returns: a string in the locale's date representation or "" if seconds < 0
     :rtype: string
 
     """
     if seconds < 0:
         return ""
-    return time.strftime("%x %X", time.localtime(seconds))
+    return time.strftime("%x", time.localtime(seconds))
 
 def is_url(url):
     """
-    A simple test to check if the URL is valid
+    A simple regex test to check if the URL is valid
 
-    :param url: the url to test
-    :type url: string
+    :param url: string, the url to test
     :returns: True or False
     :rtype: bool
 
@@ -402,14 +342,14 @@ def is_url(url):
     True
 
     """
-    return url.partition('://')[0] in ("http", "https", "ftp", "udp")
+    import re
+    return bool(re.search('^(https?|ftp|udp)://', url))
 
 def is_magnet(uri):
     """
     A check to determine if a uri is a valid bittorrent magnet uri
 
-    :param uri: the uri to check
-    :type uri: string
+    :param uri: string, the uri to check
     :returns: True or False
     :rtype: bool
 
@@ -423,16 +363,36 @@ def is_magnet(uri):
         return True
     return False
 
+def fetch_url(url):
+    """
+    Downloads a torrent file from a given URL and checks the file's validity
+
+    :param url: string, the url of the .torrent file to fetch
+    :returns: the filepath to the downloaded file
+    :rtype: string
+
+    """
+    import urllib
+    from deluge.log import LOG as log
+    try:
+        filename, headers = urllib.urlretrieve(url)
+    except IOError:
+        log.debug("Network error while trying to fetch torrent from %s", url)
+    else:
+        if filename.endswith(".torrent") or headers["content-type"] ==\
+        "application/x-bittorrent":
+            return filename
+        else:
+            log.debug("URL doesn't appear to be a valid torrent file: %s", url)
+            return None
+
 def create_magnet_uri(infohash, name=None, trackers=[]):
     """
     Creates a magnet uri
 
-    :param infohash: the info-hash of the torrent
-    :type infohash: string
-    :param name: the name of the torrent (optional)
-    :type name: string
-    :param trackers: the trackers to announce to (optional)
-    :type trackers: list of strings
+    :param infohash: string, the info-hash of the torrent
+    :param name: string, the name of the torrent (optional)
+    :param trackers: list of strings, the trackers to announce to (optional)
 
     :returns: a magnet uri string
     :rtype: string
@@ -452,8 +412,7 @@ def get_path_size(path):
     """
     Gets the size in bytes of 'path'
 
-    :param path: the path to check for size
-    :type path: string
+    :param path: string, the path to check for size
     :returns: the size in bytes of the path or -1 if the path does not exist
     :rtype: int
 
@@ -475,23 +434,18 @@ def free_space(path):
     """
     Gets the free space available at 'path'
 
-    :param path: the path to check
-    :type path: string
+    :param path: string, the path to check
     :returns: the free space at path in bytes
     :rtype: int
 
-    :raises InvalidPathError: if the path is not valid
-
     """
-    if not os.path.exists(path):
-        raise InvalidPathError("%s is not a valid path" % path)
-
     if windows_check():
-        import win32file
-        sectors, bytes, free, total = map(long, win32file.GetDiskFreeSpace(path))
-        return (free * sectors * bytes)
+        import win32api
+        drive = path.split(":")[0]
+        free = win32api.GetDiskFreeSpaceEx(drive)[0]
+        return free
     else:
-        disk_data = os.statvfs(path.encode("utf8"))
+        disk_data = os.statvfs(path)
         block_size = disk_data.f_bsize
         return disk_data.f_bavail * block_size
 
@@ -499,8 +453,7 @@ def is_ip(ip):
     """
     A simple test to see if 'ip' is valid
 
-    :param ip: the ip to check
-    :type ip: string
+    :param ip: string, the ip to check
     :returns: True or False
     :rtype: bool
 
@@ -524,191 +477,3 @@ def is_ip(ip):
             return True
     except socket.error:
         return False
-
-def path_join(*parts):
-    """
-    An implementation of os.path.join that always uses / for the separator
-    to ensure that the correct paths are produced when working with internal
-    paths on Windows.
-    """
-    path = ''
-    for part in parts:
-        if not part:
-            continue
-        elif part[0] == '/':
-            path = part
-        elif not path:
-            path = part
-        else:
-            path += '/' + part
-    return path
-
-XML_ESCAPES = (
-    ('&', '&amp;'),
-    ('<', '&lt;'),
-    ('>', '&gt;'),
-    ('"', '&quot;'),
-    ("'", '&apos;')
-)
-
-def xml_decode(string):
-    """
-    Unescape a string that was previously encoded for use within xml.
-
-    :param string: The string to escape
-    :type string: string
-    :returns: The unescaped version of the string.
-    :rtype: string
-    """
-    for char, escape in XML_ESCAPES:
-        string = string.replace(escape, char)
-    return string
-
-def xml_encode(string):
-    """
-    Escape a string for use within an xml element or attribute.
-
-    :param string: The string to escape
-    :type string: string
-    :returns: An escaped version of the string.
-    :rtype: string
-    """
-    for char, escape in XML_ESCAPES:
-        string = string.replace(char, escape)
-    return string
-
-def decode_string(s, encoding="utf8"):
-    """
-    Decodes a string and re-encodes it in utf8.  If it cannot decode using
-    `:param:encoding` then it will try to detect the string encoding and
-    decode it.
-
-    :param s: string to decode
-    :type s: string
-    :keyword encoding: the encoding to use in the decoding
-    :type encoding: string
-
-    """
-
-    try:
-        s = s.decode(encoding).encode("utf8", "ignore")
-    except UnicodeDecodeError:
-        s = s.decode(chardet.detect(s)["encoding"], "ignore").encode("utf8", "ignore")
-    return s
-
-def utf8_encoded(s):
-    """
-    Returns a utf8 encoded string of s
-
-    :param s: (unicode) string to (re-)encode
-    :type s: basestring
-    :returns: a utf8 encoded string of s
-    :rtype: str
-
-    """
-    if isinstance(s, str):
-        s = decode_string(s)
-    elif isinstance(s, unicode):
-        s = s.encode("utf8", "ignore")
-    return s
-
-class VersionSplit(object):
-    """
-    Used for comparing version numbers.
-
-    :param ver: the version
-    :type ver: string
-
-    """
-    def __init__(self, ver):
-        ver = ver.lower()
-        vs = ver.replace("_", "-").split("-")
-        self.version = [int(x) for x in vs[0].split(".")]
-        self.suffix = None
-        self.dev = False
-        if len(vs) > 1:
-            if vs[1].startswith(("rc", "alpha", "beta")):
-                self.suffix = vs[1]
-            if vs[-1] == 'dev':
-                self.dev = True
-
-    def __cmp__(self, ver):
-        """
-        The comparison method.
-
-        :param ver: the version to compare with
-        :type ver: VersionSplit
-
-        """
-
-        # If there is no suffix we use z because we want final
-        # to appear after alpha, beta, and rc alphabetically.
-        v1 = [self.version, self.suffix or 'z', self.dev]
-        v2 = [ver.version, ver.suffix or 'z', ver.dev]
-        return cmp(v1, v2)
-
-
-# Common AUTH stuff
-AUTH_LEVEL_NONE = 0
-AUTH_LEVEL_READONLY = 1
-AUTH_LEVEL_NORMAL = 5
-AUTH_LEVEL_ADMIN = 10
-AUTH_LEVEL_DEFAULT = AUTH_LEVEL_NORMAL
-
-def create_auth_file():
-    import stat, configmanager
-    auth_file = configmanager.get_config_dir("auth")
-    # Check for auth file and create if necessary
-    if not os.path.exists(auth_file):
-        fd = open(auth_file, "w")
-        fd.flush()
-        os.fsync(fd.fileno())
-        fd.close()
-        # Change the permissions on the file so only this user can read/write it
-        os.chmod(auth_file, stat.S_IREAD | stat.S_IWRITE)
-
-def create_localclient_account(append=False):
-    import configmanager, random
-    auth_file = configmanager.get_config_dir("auth")
-    if not os.path.exists(auth_file):
-        create_auth_file()
-
-    try:
-        from hashlib import sha1 as sha_hash
-    except ImportError:
-        from sha import new as sha_hash
-    fd = open(auth_file, "a" if append else "w")
-    fd.write(":".join([
-        "localclient",
-        sha_hash(str(random.random())).hexdigest(),
-        str(AUTH_LEVEL_ADMIN)
-    ]) + '\n')
-    fd.flush()
-    os.fsync(fd.fileno())
-    fd.close()
-
-
-# Initialize gettext
-def setup_translations(setup_pygtk=False):
-    translations_path = resource_filename("deluge", "i18n")
-    log.info("Setting up translations from %s", translations_path)
-
-    try:
-        if hasattr(locale, "bindtextdomain"):
-            locale.bindtextdomain("deluge", translations_path)
-        if hasattr(locale, "textdomain"):
-            locale.textdomain("deluge")
-        gettext.install("deluge", translations_path, unicode=True)
-        if setup_pygtk:
-            # Even though we're not using glade anymore, let's set it up so that
-            # plugins still using it get properly translated.
-            log.info("Setting up GTK translations from %s", translations_path)
-            import gtk
-            import gtk.glade
-            gtk.glade.bindtextdomain("deluge", translations_path)
-            gtk.glade.textdomain("deluge")
-    except Exception, e:
-        log.error("Unable to initialize gettext/locale!")
-        log.exception(e)
-        import __builtin__
-        __builtin__.__dict__["_"] = lambda x: x

deluge/component.py

@@ -1,7 +1,7 @@
 #
 # component.py
 #
-# Copyright (C) 2007-2010 Andrew Resch <andrewresch@gmail.com>
+# Copyright (C) 2007, 2008 Andrew Resch <andrewresch@gmail.com>
 #
 # Deluge is free software.
 #
@@ -19,399 +19,203 @@
 # 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.
-#
+# 	Boston, MA    02110-1301, USA.
 #
 
-import logging
-from twisted.internet.defer import maybeDeferred, succeed, DeferredList, fail
-from twisted.internet.task import LoopingCall
 
-log = logging.getLogger(__name__)
-
-class ComponentAlreadyRegistered(Exception):
-    pass
-
-class Component(object):
-    """
-    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`.
-
-    The ComponentRegistry has the ability to start, stop, pause and shutdown the
-    components registered with it.
-
-    **Events:**
-
-        **start()** - This method is called when the client has connected to a
-                  Deluge core.
-
-        **stop()** - This method is called when the client has disconnected from a
-                 Deluge core.
-
-        **update()** - This method is called every 1 second by default while the
-                   Componented is in a *Started* state.  The interval can be
-                   specified during instantiation.  The update() timer can be
-                   paused by instructing the :class:`ComponentRegistry` to pause
-                   this Component.
-
-        **shutdown()** - This method is called when the client is exiting.  If the
-                     Component is in a "Started" state when this is called, a
-                     call to stop() will be issued prior to shutdown().
-
-    **States:**
-
-        A Component can be in one of these 5 states.
-
-        **Started** - The Component has been started by the :class:`ComponentRegistry`
-                    and will have it's update timer started.
-
-        **Starting** - The Component has had it's start method called, but it hasn't
-                    fully started yet.
-
-        **Stopped** - The Component has either been stopped or has yet to be started.
-
-        **Stopping** - The Component has had it's stop method called, but it hasn't
-                    fully stopped yet.
-
-        **Paused** - The Component has had it's update timer stopped, but will
-                    still be considered in a Started state.
-
-    """
-    def __init__(self, name, interval=1, depend=None):
-        self._component_name = name
-        self._component_interval = interval
-        self._component_depend = depend
-        self._component_state = "Stopped"
-        self._component_timer = None
-        self._component_starting_deferred = None
-        self._component_stopping_deferred = None
-        _ComponentRegistry.register(self)
-
-    def __del__(self):
-        if _ComponentRegistry:
-            _ComponentRegistry.deregister(self)
-        
-    def _component_start_timer(self):
-        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_starting_deferred = None
-            self._component_start_timer()
-            return True
-
-        def on_start_fail(result):
-            self._component_state = "Stopped"
-            self._component_starting_deferred = None
-            log.error(result)
-            return 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)
-                self._component_starting_deferred = d
-            else:
-                d = maybeDeferred(on_start, None)
-        elif self._component_state == "Starting":
-            return self._component_starting_deferred
-        elif self._component_state == "Started":
-            d = succeed(True)
-        else:
-            d = fail("Cannot start a component not in a Stopped state!")
-
-        return d
-
-    def _component_stop(self):
-        def on_stop(result):
-            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_stopping_deferred = None
-            log.error(result)
-            return result
-            
-        if self._component_state != "Stopped" and self._component_state != "Stopping":
-            if hasattr(self, "stop"):
-                self._component_state = "Stopping"
-                d = maybeDeferred(self.stop)
-                d.addCallback(on_stop)
-                d.addErrback(on_stop_fail)
-                self._component_stopping_deferred = d
-            else:
-                d = maybeDeferred(on_stop, None)
-
-        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"
-
-        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":
-            d = succeed(None)
-        else:
-            d = fail("Cannot pause a component in a non-Started state!")
-
-        return d
-
-    def _component_resume(self):
-        def on_resume(result):
-            self._component_state = "Started"
-
-        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!")
-
-        return d
-
-    def _component_shutdown(self):
-        def on_stop(result):
-            if hasattr(self, "shutdown"):
-                return maybeDeferred(self.shutdown)
-            return succeed(None)
-
-        d = self._component_stop()
-        d.addCallback(on_stop)
-        return d
-
-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.
-    """
-    def __init__(self):
-        self.components = {}
-
-    def register(self, obj):
-        """
-        Registers a component object with the registry.  This is done
-        automatically when a Component object is instantiated.
-
-        :param obj: the Component object
-        :type obj: object
-
-        :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)
-
-        self.components[obj._component_name] = obj
-
-    def deregister(self, obj):
-        """
-        Deregisters 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
-
-        """
-
-        if obj in self.components.values():
-            log.debug("Deregistering Component: %s", obj._component_name)
-            d = self.stop([obj._component_name])
-            def on_stop(result, name):
-                del self.components[name]
-            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.
-
-        :param names: a list of Components to start
-        :type names: list
-
-        :returns: a Deferred object that will fire once all Components have been sucessfully started
-        :rtype: twisted.internet.defer.Deferred
-
-        """
-        # Start all the components if names is empty
-        if not names:
-            names = self.components.keys()
-        elif isinstance(names, str):
-            names = [names]
-
-        def on_depends_started(result, name):
-            return self.components[name]._component_start()
-
-        deferreds = []
-
-        for name in names:
-            if self.components[name]._component_depend:
-                # This component has depends, so we need to start them first.
-                d = self.start(self.components[name]._component_depend)
-                d.addCallback(on_depends_started, name)
-                deferreds.append(d)
-            else:
-                deferreds.append(self.components[name]._component_start())
-
-        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.
-
-        :param names: a list of Components to start
-        :type names: list
-
-        :returns: a Deferred object that will fire once all Components have been sucessfully stopped
-        :rtype: twisted.internet.defer.Deferred
-
-        """
-        if not names:
-            names = self.components.keys()
-        elif isinstance(names, str):
-            names = [names]
-
-        deferreds = []
-
-        for name in names:
-            if name in self.components:
-                deferreds.append(self.components[name]._component_stop())
-
-        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.
-
-        :param names: a list of Components to pause
-        :type names: list
-
-        :returns: a Deferred object that will fire once all Components have been sucessfully paused
-        :rtype: twisted.internet.defer.Deferred
-
-        """
-        if not names:
-            names = self.components.keys()
-        elif isinstance(names, str):
-            names = [names]
-
-        deferreds = []
-
-        for name in names:
-            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.
-
-        :param names: a list of Components to resume
-        :type names: list
-
-        :returns: a Deferred object that will fire once all Components have been sucessfully resumed
-        :rtype: twisted.internet.defer.Deferred
-
-        """
-        if not names:
-            names = self.components.keys()
-        elif isinstance(names, str):
-            names = [names]
-
-        deferreds = []
-
-        for name in names:
-            if self.components[name]._component_state == "Paused":
-                deferreds.append(self.components[name]._component_resume())
-
-        return DeferredList(deferreds)
+import gobject
+from deluge.log import LOG as log
+
+COMPONENT_STATE = [
+    "Stopped",
+    "Started",
+    "Paused"
+]
+
+class Component:
+    def __init__(self, name, interval=1000, depend=None):
+        # Register with the ComponentRegistry
+        register(name, self, depend)
+        self._interval = interval
+        self._timer = None
+        self._state = COMPONENT_STATE.index("Stopped")
+
+    def get_state(self):
+        return self._state
+
+    def start(self):
+        pass
+
+    def _start(self):
+        self._state = COMPONENT_STATE.index("Started")
+        if self._update():
+            self._timer = gobject.timeout_add(self._interval, self._update)
+
+    def stop(self):
+        pass
+
+    def _stop(self):
+        self._state = COMPONENT_STATE.index("Stopped")
+        try:
+            gobject.source_remove(self._timer)
+        except:
+            pass
+
+    def _pause(self):
+        self._state = COMPONENT_STATE.index("Paused")
+        try:
+            gobject.source_remove(self._timer)
+        except:
+            pass
+
+    def _resume(self):
+        self._start()
 
     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.
+        pass
 
-        :returns: a Deferred object that will fire once all Components have been sucessfully resumed
-        :rtype: twisted.internet.defer.Deferred
+    def _update(self):
+        try:
+            self.update()
+        except AttributeError:
+            # This will stop the timer since the component doesn't have an
+            # update method.
+            return False
+        return True
 
-        """
-        deferreds = []
 
-        for component in self.components.values():
-            deferreds.append(component._component_shutdown())
+class ComponentRegistry:
+    def __init__(self):
+        self.components = {}
+        self.depend = {}
 
-        return DeferredList(deferreds)
+    def register(self, name, obj, depend):
+        """Registers a component.. depend must be list or None"""
+        log.debug("Registered %s with ComponentRegistry..", name)
+        self.components[name] = obj
+        if depend != None:
+            self.depend[name] = depend
+
+    def get(self, name):
+        """Returns a reference to the component 'name'"""
+        return self.components[name]
+
+    def start(self):
+        """Starts all components"""
+        for component in self.components.keys():
+            self.start_component(component)
+
+    def start_component(self, name):
+        """Starts a component"""
+        # Check to see if this component has any dependencies
+        if self.depend.has_key(name):
+            for depend in self.depend[name]:
+                self.start_component(depend)
+        # Only start if the component is stopped.
+        if self.components[name].get_state() == \
+            COMPONENT_STATE.index("Stopped"):
+            log.debug("Starting component %s..", name)
+            self.components[name].start()
+            self.components[name]._start()
+
+    def stop(self):
+        """Stops all components"""
+        for component in self.components.keys():
+            self.stop_component(component)
+
+    def stop_component(self, component):
+        if self.components[component].get_state() != \
+                COMPONENT_STATE.index("Stopped"):
+            log.debug("Stopping component %s..", component)
+            self.components[component].stop()
+            self.components[component]._stop()
+
+    def pause(self):
+        """Pauses all components.  Stops calling update()"""
+        for component in self.components.keys():
+            self.pause_component(component)
+
+    def pause_component(self, component):
+        if self.components[component].get_state() not in \
+            [COMPONENT_STATE.index("Paused"), COMPONENT_STATE.index("Stopped")]:
+            log.debug("Pausing component %s..", component)
+            self.components[component]._pause()
+
+    def resume(self):
+        """Resumes all components.  Starts calling update()"""
+        for component in self.components.keys():
+            self.resume_component(component)
+
+    def resume_component(self, component):
+        if self.components[component].get_state() == COMPONENT_STATE.index("Paused"):
+            log.debug("Resuming component %s..", component)
+            self.components[component]._resume()
 
     def update(self):
-        """
-        Updates all Components that are in a Started state.
+        """Updates all components"""
+        for component in self.components.keys():
+            # Only update the component if it's started
+            if self.components[component].get_state() == \
+                COMPONENT_STATE.index("Started"):
+                self.components[component].update()
+
+        return True
+
+    def shutdown(self):
+        """Shuts down all components.  This should be called when the program
+        exits so that components can do any necessary clean-up."""
+        # Stop all components first
+        self.stop()
+        for component in self.components.keys():
+            log.debug("Shutting down component %s..", component)
+            try:
+                self.components[component].shutdown()
+            except Exception, e:
+                log.debug("Unable to call shutdown(): %s", e)
 
-        """
-        for component in self.components.items():
-            component.update()
 
 _ComponentRegistry = ComponentRegistry()
 
-deregister = _ComponentRegistry.deregister
-start = _ComponentRegistry.start
-stop = _ComponentRegistry.stop
-pause = _ComponentRegistry.pause
-resume = _ComponentRegistry.resume
-update = _ComponentRegistry.update
-shutdown = _ComponentRegistry.shutdown
+def register(name, obj, depend=None):
+    """Registers a component with the registry"""
+    _ComponentRegistry.register(name, obj, depend)
 
-def get(name):
-    """
-    Return a reference to a component.
+def start(component=None):
+    """Starts all components"""
+    if component == None:
+        _ComponentRegistry.start()
+    else:
+        _ComponentRegistry.start_component(component)
 
-    :param name: the Component name to get
-    :type name: string
+def stop(component=None):
+    """Stops all or specified components"""
+    if component == None:
+        _ComponentRegistry.stop()
+    else:
+        _ComponentRegistry.stop_component(component)
 
-    :returns: the Component object
-    :rtype: object
+def pause(component=None):
+    """Pauses all or specificed components"""
+    if component == None:
+        _ComponentRegistry.pause()
+    else:
+        _ComponentRegistry.pause_component(component)
 
-    :raises KeyError: if the Component does not exist
+def resume(component=None):
+    """Resumes all or specificed components"""
+    if component == None:
+        _ComponentRegistry.resume()
+    else:
+        _ComponentRegistry.resume_component(component)
 
-    """
-    return _ComponentRegistry.components[name]
+def update():
+    """Updates all components"""
+    _ComponentRegistry.update()
+
+def shutdown():
+    """Shutdowns all components"""
+    _ComponentRegistry.shutdown()
+
+def get(component):
+    """Return a reference to the component"""
+    return _ComponentRegistry.get(component)

deluge/config.py

@@ -19,64 +19,20 @@
 # 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.
-#
+# 	Boston, MA    02110-1301, USA.
 #
 
 
 """
 Deluge Config Module
-
-This module is used for loading and saving of configuration files.. or anything
-really.
-
-The format of the config file is two json encoded dicts:
-
-<version dict>
-<content dict>
-
-The version dict contains two keys: file and format.  The format version is
-controlled by the Config class.  It should only be changed when anything below
-it is changed directly by the Config class.  An example of this would be if we
-changed the serializer for the content to something different.
-
-The config file version is changed by the 'owner' of the config file.  This is
-to signify that there is a change in the naming of some config keys or something
-similar along those lines.
-
-The content is simply the dict to be saved and will be serialized before being
-written.
-
-Converting
-
-Since the format of the config could change, there needs to be a way to have
-the Config object convert to newer formats.  To do this, you will need to
-register conversion functions for various versions of the config file. Note that
-this can only be done for the 'config file version' and not for the 'format'
-version as this will be done internally.
-
 """
 
 import cPickle as pickle
-import logging
 import shutil
 import os
-
+import gobject
 import deluge.common
-
-json = deluge.common.json
-
-log = logging.getLogger(__name__)
+from deluge.log import LOG as log
 
 def prop(func):
     """Function decorator for defining property attributes
@@ -92,37 +48,6 @@ def prop(func):
     """
     return property(doc=func.__doc__, **func())
 
-def find_json_objects(s):
-    """
-    Find json objects in a string.
-
-    :param s: the string to find json objects in
-    :type s: string
-
-    :returns: a list of tuples containing start and end locations of json objects in the string `s`
-    :rtype: [(start, end), ...]
-
-    """
-    objects = []
-    opens = 0
-    start = s.find("{")
-    offset = start
-
-    if start < 0:
-        return []
-
-    for index, c in enumerate(s[offset:]):
-        if c == "{":
-            opens += 1
-        elif c == "}":
-            opens -= 1
-            if opens == 0:
-                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
@@ -134,22 +59,15 @@ class Config(object):
     """
     def __init__(self, filename, defaults=None, config_dir=None):
         self.__config = {}
+        self.__previous_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
-        }
-
-        # This will get set with a reactor.callLater whenever a config option
+        self.__change_callback = None
+        # This will get set with a gobject.timeout_add whenever a config option
         # is set.
-        self._save_timer = None
+        self.__save_timer = None
 
         if defaults:
-            for key, value in defaults.iteritems():
-                self.set_item(key, value)
+            self.__config = defaults
 
         # Load the config from file in the config_dir
         if config_dir:
@@ -159,9 +77,6 @@ class Config(object):
 
         self.load()
 
-    def __contains__(self, item):
-        return item in self.__config
-
     def __setitem__(self, key, value):
         """
         See
@@ -173,14 +88,12 @@ class Config(object):
     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.
+        changing the item's type unless it is None
 
         :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
 
-        :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
+        :raises ValueError: raised when the type of value is not the same as what is currently in the config
 
         **Usage**
 
@@ -190,10 +103,6 @@ what is currently in the config and it could not convert the value
         5
 
         """
-        if isinstance(value, basestring):
-            value = deluge.common.utf8_encoded(value)
-
-
         if not self.__config.has_key(key):
             self.__config[key] = value
             log.debug("Setting '%s' to %s of %s", key, value, type(value))
@@ -207,35 +116,29 @@ what is currently in the config and it could not convert the value
 
         if value is not None and oldtype != type(None) and oldtype != newtype:
             try:
-                if oldtype == unicode:
-                    value = oldtype(value, "utf8")
-                else:
-                    value = oldtype(value)
+                value = oldtype(value)
             except ValueError:
                 log.warning("Type '%s' invalid for '%s'", newtype, key)
                 raise
 
         log.debug("Setting '%s' to %s of %s", key, value, type(value))
 
+        # Make a copy of the current config prior to changing it
+        self.__previous_config.update(self.__config)
         self.__config[key] = value
         # 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)
+            gobject.idle_add(self.__set_functions[key], 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)
+            gobject.idle_add(self.__change_callback, key, value)
         except:
             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)
+        if not self.__save_timer:
+            self.__save_timer = gobject.timeout_add(5000, self.save)
 
     def __getitem__(self, key):
         """
@@ -260,38 +163,7 @@ what is currently in the config and it could not convert the value
         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]
-
-    def __delitem__(self, key):
-        """
-        See
-        :meth:`del_item`
-        """
-        self.del_item(key)
-
-    def del_item(self, key):
-        """
-        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
-
-        **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)
-
+        return self.__config[key]
 
     def register_change_callback(self, callback):
         """
@@ -308,7 +180,7 @@ what is currently in the config and it could not convert the value
         >>> config.register_change_callback(cb)
 
         """
-        self.__change_callbacks.append(callback)
+        self.__change_callback = callback
 
     def register_set_function(self, key, function, apply_now=True):
         """
@@ -329,14 +201,10 @@ what is currently in the config and it could not convert the value
 
         """
         log.debug("Registering function for %s key..", key)
-        if key not in self.__set_functions:
-            self.__set_functions[key] = []
-
-        self.__set_functions[key].append(function)
-
+        self.__set_functions[key] = function
         # Run the function now if apply_now is set
         if apply_now:
-            function(key, self.__config[key])
+            self.__set_functions[key](key, self.__config[key])
         return
 
     def apply_all(self):
@@ -356,20 +224,7 @@ what is currently in the config and it could not convert the value
         """
         log.debug("Calling all set functions..")
         for key, value in self.__set_functions.iteritems():
-            for func in value:
-                func(key, self.__config[key])
-
-    def apply_set_functions(self, key):
-        """
-        Calls set functions for `:param:key`.
-
-        :param key: str, the config 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])
+            value(key, self.__config[key])
 
     def load(self, filename=None):
         """
@@ -381,49 +236,18 @@ what is currently in the config and it could not convert the value
         """
         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)
-            return
+            self.__config.update(pickle.load(open(filename, "rb")))
+        except Exception, e:
+            log.warning("Unable to load config file: %s", filename)
 
-        objects = find_json_objects(data)
-
-        if not len(objects):
-            # No json objects found, try depickling it
-            try:
-                self.__config.update(pickle.loads(data))
-            except Exception, e:
-                log.exception(e)
-                log.warning("Unable to load config file: %s", filename)
-        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)
-        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)
-
-        log.debug("Config %s version: %s.%s loaded: %s", filename,
-            self.__version["format"], self.__version["file"], self.__config)
+        log.debug("Config %s loaded: %s", filename, self.__config)
 
     def save(self, filename=None):
         """
         Save configuration to disk
 
         :param filename: if None, uses filename set in object initiliazation
-        :rtype bool:
-        :return: whether or not the save succeeded.
 
         """
         if not filename:
@@ -431,39 +255,21 @@ 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()
-            objects = find_json_objects(data)
-            start, end = objects[0]
-            version = json.loads(data[start:end])
-            start, end = objects[1]
-            loaded_data = json.loads(data[start:end])
-            if self.__config == loaded_data and self.__version == version:
+            if self.__config == pickle.load(open(filename, "rb")):
                 # The config has not changed so lets just return
-                if self._save_timer and self._save_timer.active():
-                    self._save_timer.cancel()
-                return True
-        except IOError, e:
-            log.warning("Unable to open config file: %s because: %s", filename, e)
+                self.__save_timer = None
+                return
+        except Exception, e:
+            log.warning("Unable to open config file: %s", filename)
+
+        self.__save_timer = None
 
-        # 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)
-            return False
-
-        # Make a backup of the old config
-        try:
-            log.debug("Backing up old config file to %s~", filename)
-            shutil.move(filename, filename + "~")
+            pickle.dump(self.__config, open(filename + ".new", "wb"))
         except Exception, e:
-            log.error("Error backing up old config..")
+            log.error("Error writing new config file: %s", e)
+            return
 
         # The new config file has been written successfully, so let's move it over
         # the existing one.
@@ -472,50 +278,8 @@ what is currently in the config and it could not convert the value
             shutil.move(filename + ".new", filename)
         except Exception, e:
             log.error("Error moving new config file: %s", e)
-            return False
-        else:
-            return True
-        finally:
-            if self._save_timer and self._save_timer.active():
-                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`.
-
-        :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
-
-        :raises ValueError: if the 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")
-
-        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
-        else:
-            self.__version["file"] = output_version
-            self.save()
-
-    @property
-    def config_file(self):
-        return self.__config_file
-
     @prop
     def config():
         """The config dictionary"""

deluge/configmanager.py

@@ -19,78 +19,43 @@
 # 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.
-#
+# 	Boston, MA    02110-1301, USA.
 #
 
+
+import gobject
 import os
-import logging
+import os.path
 
 import deluge.common
-import deluge.log
+from deluge.log import LOG as log
 from deluge.config import Config
 
-log = logging.getLogger(__name__)
-
 class _ConfigManager:
     def __init__(self):
         log.debug("ConfigManager started..")
         self.config_files = {}
-        self.__config_directory = None
-
-    @property
-    def config_directory(self):
-        if self.__config_directory is None:
-            self.__config_directory = deluge.common.get_default_config_dir()
-        return self.__config_directory
+        self.config_directory = deluge.common.get_default_config_dir()
+        # Set a 5 minute timer to call save()
+        gobject.timeout_add(300000, self.save)
 
     def __del__(self):
+        log.debug("ConfigManager stopping..")
         del self.config_files
 
     def set_config_dir(self, directory):
-        """
-        Sets the config directory.
-
-        :param directory: str, the directory where the config info should be
-
-        :returns bool: True if successfully changed directory, False if not
-        """
-
-        if not directory:
-            return False
-
+        """Sets the config directory"""
+        if directory == None:
+            return
         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)
-                return False
-        elif not os.path.isdir(directory):
-            log.error("Config directory needs to be a directory!")
-            return False
+                log.warning("Unable to make config directory: %s", e)
 
-        self.__config_directory = directory
-
-        # Reset the config_files so we don't get config from old config folder
-        # XXX: Probably should have it go through the config_files dict and try
-        # to reload based on the new config directory
-        self.save()
-        self.config_files = {}
-        deluge.log.tweak_logging_levels()
-
-        return True
+        self.config_directory = directory
 
     def get_config_dir(self):
         return self.config_directory
@@ -104,8 +69,8 @@ class _ConfigManager:
 
     def save(self):
         """Saves all the configs to disk."""
-        for value in self.config_files.values():
-            value.save()
+        for key in self.config_files.keys():
+            self.config_files[key].save()
         # We need to return True to keep the timer active
         return True
 

deluge/core/alertmanager.py

@@ -1,7 +1,7 @@
 #
 # alertmanager.py
 #
-# Copyright (C) 2007-2009 Andrew Resch <andrewresch@gmail.com>
+# Copyright (C) 2007 Andrew Resch <andrewresch@gmail.com>
 #
 # Deluge is free software.
 #
@@ -19,75 +19,54 @@
 # 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.
+# 	Boston, MA    02110-1301, USA.
 #
 
-"""
 
-The AlertManager handles all the libtorrent alerts.
+"""The AlertManager handles all the libtorrent alerts."""
 
-This should typically only be used by the Core.  Plugins should utilize the
-`:mod:EventManager` for similar functionality.
-
-"""
-
-import logging
-from twisted.internet import reactor
+import gobject
 
 import deluge.component as component
-from deluge._libtorrent import lt
+try:
+    import deluge.libtorrent as lt
+except ImportError:
+    import libtorrent as lt
+    if not (lt.version_major == 0 and lt.version_minor == 14):
+        raise ImportError("This version of Deluge requires libtorrent 0.14!")
 
-log = logging.getLogger(__name__)
+from deluge.log import LOG as log
 
 class AlertManager(component.Component):
-    def __init__(self):
+    def __init__(self, session):
         log.debug("AlertManager initialized..")
-        component.Component.__init__(self, "AlertManager", interval=0.05)
-        self.session = component.get("Core").session
-
+        component.Component.__init__(self, "AlertManager", interval=50)
+        self.session = session
         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)
+            lt.alert.category_t.ip_block_notification)
 
         # handlers is a dictionary of lists {"alert_type": [handler1,h2,..]}
         self.handlers = {}
 
-        self.delayed_calls = []
-
     def update(self):
-        self.delayed_calls = [dc for dc in self.delayed_calls if dc.active()]
         self.handle_alerts()
 
-    def stop(self):
-        for dc in self.delayed_calls:
-            dc.cancel()
-        self.delayed_calls = []
+    def shutdown(self):
+        del self.session
+        del self.handlers
 
     def register_handler(self, alert_type, handler):
+        """Registers a function that will be called when 'alert_type' is pop'd
+        in handle_alerts.  The handler function should look like:
+        handler(alert)
+        Where 'alert' is the actual alert object from libtorrent
         """
-        Registers a function that will be called when 'alert_type' is pop'd
-        in handle_alerts.  The handler function should look like: handler(alert)
-        Where 'alert' is the actual alert object from libtorrent.
-
-        :param alert_type: str, this is string representation of the alert name
-        :param handler: func(alert), the function to be called when the alert is raised
-        """
-        if alert_type not in self.handlers:
+        if alert_type not in self.handlers.keys():
             # There is no entry for this alert type yet, so lets make it with an
             # empty list.
             self.handlers[alert_type] = []
@@ -97,37 +76,32 @@ class AlertManager(component.Component):
         log.debug("Registered handler for alert %s", alert_type)
 
     def deregister_handler(self, handler):
-        """
-        De-registers the `:param:handler` function from all alert types.
-
-        :param handler: func, the handler function to deregister
-        """
+        """De-registers the 'handler' function from all alert types."""
         # Iterate through all handlers and remove 'handler' where found
-        for (key, value) in self.handlers.items():
+        for (key, value) in self.handlers:
             if handler in value:
                 # Handler is in this alert type list
                 value.remove(handler)
 
     def handle_alerts(self, wait=False):
-        """
-        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."""
         alert = self.session.pop_alert()
-        # Loop through all alerts in the queue
         while alert is not None:
-            alert_type = type(alert).__name__
+            # Loop through all alerts in the queue
+            # Do some magic to get the alert type as a string
+            alert_type = str(type(alert)).split("'")[1].split(".")[-1]
             # Display the alert message
             log.debug("%s: %s", alert_type, alert.message())
             # Call any handlers for this alert type
-            if alert_type in self.handlers:
+            if alert_type in self.handlers.keys():
                 for handler in self.handlers[alert_type]:
                     if not wait:
-                        self.delayed_calls.append(reactor.callLater(0, handler, alert))
+                        gobject.idle_add(handler, alert)
                     else:
                         handler(alert)
 
             alert = self.session.pop_alert()
+
+        # Return True so that the timer continues
+        return True

deluge/core/authmanager.py

@@ -1,8 +1,7 @@
 #
 # authmanager.py
 #
-# Copyright (C) 2009 Andrew Resch <andrewresch@gmail.com>
-# Copyright (C) 2011 Pedro Algarvio <pedro@algarvio.me>
+# Copyright (C) 2008 Andrew Resch <andrewresch@gmail.com>
 #
 # Deluge is free software.
 #
@@ -20,270 +19,73 @@
 # 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.
-#
+# 	Boston, MA    02110-1301, USA.
 #
 
-import os
+import os.path
 import random
 import stat
-import shutil
-import logging
 
 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
-
-log = logging.getLogger(__name__)
-
-AUTH_LEVELS_MAPPING = {
-    'NONE': AUTH_LEVEL_NONE,
-    'READONLY': AUTH_LEVEL_READONLY,
-    'DEFAULT': AUTH_LEVEL_NORMAL,
-    'NORMAL': AUTH_LEVEL_DEFAULT,
-    'ADMIN': AUTH_LEVEL_ADMIN
-}
-
-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
-        self.authlevel = authlevel
-
-    def data(self):
-        return {
-            'username': self.username,
-            'password': self.password,
-            'authlevel': AUTH_LEVELS_MAPPING_REVERSE[self.authlevel],
-            'authlevel_int': self.authlevel
-        }
-
-    def __repr__(self):
-        return ('<Account username="%(username)s" authlevel=%(authlevel)s>' %
-                self.__dict__)
-
 
 class AuthManager(component.Component):
     def __init__(self):
-        component.Component.__init__(self, "AuthManager", interval=10)
-        self.__auth = {}
-        self.__auth_modification_time = None
+        component.Component.__init__(self, "AuthManager")
+        self.auth = {}
 
     def start(self):
         self.__load_auth_file()
 
     def stop(self):
-        self.__auth = {}
+        self.auth = {}
 
     def shutdown(self):
         pass
 
-    def update(self):
-        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.")
-            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!")
-            self.__load_auth_file()
-
     def authorize(self, username, 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
-
-        :raises AuthenticationRequired: if aditional details are required to
-                                        authenticate.
-        :raises BadLoginError: if the username does not exist or password does
-                               not match.
+        :returns: True or False
+        :rtype: bool
 
         """
-        if not username:
-            raise AuthenticationRequired(
-                "Username and Password are required.", username
-            )
 
-        if username not in self.__auth:
+        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)
+            if username not in self.auth:
+                return False
 
-        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)
-        else:
-            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.
-        """
-        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)
-        try:
-            self.__auth[username] = Account(username, password,
-                                            AUTH_LEVELS_MAPPING[authlevel])
-            self.write_auth_file()
+        if self.auth[username] == password:
             return True
-        except Exception, err:
-            log.exception(err)
-            raise err
 
-    def update_account(self, username, password, authlevel):
-        if username not in self.__auth:
-            raise AuthManagerError("Username not known", username)
-        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
-
-    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(
-                "You cannot delete your own account while logged in!", username
-            )
-
-        del self.__auth[username]
-        self.write_auth_file()
-        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)
-
-        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)
-
-        self.__load_auth_file()
+        return False
 
     def __load_auth_file(self):
-        save_and_reload = False
         auth_file = configmanager.get_config_dir("auth")
         # Check for auth file and create if necessary
         if not os.path.exists(auth_file):
-            create_localclient_account()
-            return self.__load_auth_file()
-
-        auth_file_modification_time = os.stat(auth_file).st_mtime
-        if self.__auth_modification_time is None:
-            self.__auth_modification_time = auth_file_modification_time
-        elif self.__auth_modification_time == auth_file_modification_time:
-            # 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()
+            # We create a 'localclient' account with a random password
+            try:
+                from hashlib import sha1 as sha_hash
+            except ImportError:
+                from sha import new as sha_hash
+            open(auth_file, "w").write("localclient:" + sha_hash(str(random.random())).hexdigest() + "\n")
+            # Change the permissions on the file so only this user can read/write it
+            os.chmod(auth_file, stat.S_IREAD | stat.S_IWRITE)
 
+        # Load the auth file into a dictionary: {username: password, ...}
+        f = open(auth_file, "r")
         for line in f:
             if line.startswith("#"):
                 # This is a comment line
                 continue
-            line = line.strip()
             try:
-                lsplit = line.split(":")
-            except Exception, e:
-                log.error("Your auth file is malformed: %s", e)
-                continue
-            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)
-                if username == 'localclient':
-                    authlevel = AUTH_LEVEL_ADMIN
-                else:
-                    authlevel = AUTH_LEVEL_DEFAULT
-                # This is probably an old auth file
-                save_and_reload = True
-            elif len(lsplit) == 3:
-                username, password, authlevel = lsplit
-            else:
-                log.error("Your auth file is malformed: "
-                          "Incorrect number of fields!")
-                continue
-
-            username = username.strip()
-            password = password.strip()
-            try:
-                authlevel = int(authlevel)
+                username, password = line.split(":")
             except ValueError:
-                try:
-                    authlevel = AUTH_LEVELS_MAPPING[authlevel]
-                except KeyError:
-                    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:
-            create_localclient_account(True)
-            return self.__load_auth_file()
-
-
-        if save_and_reload:
-            log.info("Re-writing auth file (upgrade)")
-            self.write_auth_file()
-        self.__auth_modification_time = auth_file_modification_time
-
+            self.auth[username.strip()] = password.strip()

deluge/core/autoadd.py

@@ -0,0 +1,125 @@
+#
+# autoadd.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.
+#
+
+
+import os
+
+try:
+    import deluge.libtorrent as lt
+except ImportError:
+    import libtorrent as lt
+    if not (lt.version_major == 0 and lt.version_minor == 14):
+        raise ImportError("This version of Deluge requires libtorrent 0.14!")
+
+import deluge.component as component
+from deluge.configmanager import ConfigManager
+from deluge.log import LOG as log
+
+MAX_NUM_ATTEMPTS = 10
+
+class AutoAdd(component.Component):
+    def __init__(self):
+        component.Component.__init__(self, "AutoAdd", depend=["TorrentManager"], interval=5000)
+        # Get the core config
+        self.config = ConfigManager("core.conf")
+
+        # A list of filenames
+        self.invalid_torrents = []
+        # Filename:Attempts
+        self.attempts = {}
+
+        # Register set functions
+        self.config.register_set_function("autoadd_enable",
+            self._on_autoadd_enable, apply_now=True)
+        self.config.register_set_function("autoadd_location",
+            self._on_autoadd_location)
+
+    def update(self):
+        if not self.config["autoadd_enable"]:
+            # We shouldn't be updating because autoadd is not enabled
+            component.pause("AutoAdd")
+            return
+
+        # Check the auto add folder for new torrents to add
+        if not os.path.exists(self.config["autoadd_location"]):
+            log.warning("Invalid AutoAdd folder: %s", self.config["autoadd_location"])
+            component.pause("AutoAdd")
+            return
+
+        for filename in os.listdir(self.config["autoadd_location"]):
+            if filename.split(".")[-1] == "torrent":
+                filepath = os.path.join(self.config["autoadd_location"], filename)
+                try:
+                    filedump = self.load_torrent(filepath)
+                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.attempts[filename] += 1
+                        if self.attempts[filename] >= MAX_NUM_ATTEMPTS:
+                            os.rename(filepath, filepath + ".invalid")
+                            del self.attempts[filename]
+                            self.invalid_torrents.remove(filename)
+                    else:
+                        self.invalid_torrents.append(filename)
+                        self.attempts[filename] = 1
+                    continue
+
+                # The torrent looks good, so lets add it to the session
+                component.get("TorrentManager").add(filedump=filedump, filename=filename)
+
+                os.remove(filepath)
+
+    def load_torrent(self, filename):
+        try:
+            log.debug("Attempting to open %s for add.", filename)
+            _file = open(filename, "rb")
+            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
+        info = lt.torrent_info(lt.bdecode(filedump))
+
+        return filedump
+
+    def _on_autoadd_enable(self, key, value):
+        log.debug("_on_autoadd_enable")
+        if value:
+            component.resume("AutoAdd")
+        else:
+            component.pause("AutoAdd")
+
+    def _on_autoadd_location(self, key, value):
+        log.debug("_on_autoadd_location")
+        # We need to resume the component just incase it was paused due to
+        # an invalid autoadd location.
+        if self.config["autoadd_enable"]:
+            component.resume("AutoAdd")

deluge/core/daemon.py

@@ -1,7 +1,7 @@
 #
 # daemon.py
 #
-# Copyright (C) 2007-2009 Andrew Resch <andrewresch@gmail.com>
+# Copyright (C) 2007 Andrew Resch <andrewresch@gmail.com>
 #
 # Deluge is free software.
 #
@@ -19,183 +19,27 @@
 # 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.
+# 	Boston, MA    02110-1301, USA.
 #
 
-import os
-import logging
-from twisted.internet import reactor
-import twisted.internet.error
 
-import deluge.component as component
 import deluge.configmanager
 import deluge.common
-from deluge.core.rpcserver import RPCServer, export
-import deluge.error
-
-log = logging.getLogger(__name__)
-
-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
-
-
-            def process_running(pid):
-                if deluge.common.windows_check():
-                    # Do some fancy WMI junk to see if the PID exists in Windows
-                    from win32com.client import GetObject
-                    def get_proclist():
-                        WMI = GetObject('winmgmts:')
-                        processes = WMI.InstancesOf('Win32_Process')
-                        return [process.Properties_('ProcessID').Value for process in processes]
-                    return pid in get_proclist()
-                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("after", "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
-            def win_handler(ctrl_type):
-                log.debug("ctrl_type: %s", ctrl_type)
-                if ctrl_type == CTRL_CLOSE_EVENT or ctrl_type == CTRL_SHUTDOWN_EVENT:
-                    self._shutdown()
-                    return 1
-            SetConsoleCtrlHandler(win_handler)
+from deluge.log import LOG as log
 
+class Daemon:
+    def __init__(self, options, args):
         version = deluge.common.get_version()
+        if deluge.common.get_revision() != "":
+            version = version + "r" + deluge.common.get_revision()
 
         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)
+        deluge.configmanager.set_config_dir(options.config)
 
         from deluge.core.core import Core
         # Start the core as a thread and join it until it's done
-        self.core = Core()
+        self.core = Core(options.port).run()
 
-        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 = ""
-
-        self.rpcserver = RPCServer(
-            port=port,
-            allow_remote=self.core.config["allow_remote"],
-            listen=not classic,
-            interface=interface
-        )
-
-        # 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")
-
-        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))
-
-            component.start()
-            try:
-                reactor.run()
-            finally:
-                self._shutdown()
-
-    @export()
-    def shutdown(self, *args, **kwargs):
-        reactor.callLater(0, reactor.stop)
-
-    def _shutdown(self, *args, **kwargs):
-        try:
-            os.remove(deluge.configmanager.get_config_dir("deluged.pid"))
-        except Exception, e:
-            log.exception(e)
-            log.error("Error removing deluged.pid!")
-
-        component.shutdown()
-        try:
-            reactor.stop()
-        except twisted.internet.error.ReactorNotRunning:
-            log.debug("Tried to stop the reactor but it is not running..")
-
-    @export()
-    def get_method_list(self):
-        """
-        Returns a list of the exported methods.
-        """
-        return self.rpcserver.get_method_list()
-
-    @export(1)
-    def authorized_call(self, rpc):
-        """
-        Returns True if authorized to call rpc.
-
-        :param rpc: a rpc, eg, "core.get_torrents_status"
-        :type rpc: string
-
-        """
-        if not rpc in self.get_method_list():
-            return False
-
-        auth_level = self.rpcserver.get_session_auth_level()
-        return auth_level >= self.rpcserver.get_rpc_auth_level()

deluge/core/eventmanager.py

@@ -1,86 +0,0 @@
-#
-# eventmanager.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 logging
-import deluge.component as component
-
-log = logging.getLogger(__name__)
-
-class EventManager(component.Component):
-    def __init__(self):
-        component.Component.__init__(self, "EventManager")
-        self.handlers = {}
-
-    def emit(self, event):
-        """
-        Emits the event to interested clients.
-
-        :param event: DelugeEvent
-        """
-        # Emit the event to the interested clients
-        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)
-                try:
-                    handler(*event.args)
-                except:
-                    log.error("Event handler %s failed in %s", event.name, handler)
-
-    def register_event_handler(self, event, handler):
-        """
-        Registers a function to be called when a `:param:event` is emitted.
-
-        :param event: str, the event name
-        :param handler: function, to be called when `:param:event` is emitted
-
-        """
-        if event not in self.handlers:
-            self.handlers[event] = []
-
-        if handler not in self.handlers[event]:
-            self.handlers[event].append(handler)
-
-    def deregister_event_handler(self, event, handler):
-        """
-        Deregisters an event handler function.
-
-        :param event: str, the event name
-        :param handler: function, currently registered to handle `:param:event`
-
-        """
-        if event in self.handlers and handler in self.handlers[event]:
-            self.handlers[event].remove(handler)

deluge/core/filtermanager.py

@@ -19,27 +19,15 @@
 # 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.
-#
+# 	Boston, MA    02110-1301, USA.
 #
 
-import logging
+
 import deluge.component as component
+from deluge.log import LOG as log
 
 STATE_SORT = ["All", "Downloading", "Seeding", "Active", "Paused", "Queued"]
 
-log = logging.getLogger(__name__)
-
 #special purpose filters:
 def filter_keywords(torrent_ids, values):
     #cleanup.
@@ -78,45 +66,6 @@ def filter_one_keyword(torrent_ids, keyword):
                     yield torrent_id
                     break
 
-def filter_by_name(torrent_ids, search_string):
-    all_torrents = component.get("TorrentManager").torrents
-    try:
-        search_string, match_case = search_string[0].split('::match')
-    except ValueError:
-        search_string = search_string[0]
-        match_case = False
-
-    if match_case is False:
-        search_string = search_string.lower()
-
-    for torrent_id in torrent_ids:
-        torrent_name = all_torrents[torrent_id].get_name()
-        if match_case is False:
-            torrent_name = all_torrents[torrent_id].get_name().lower()
-        else:
-            torrent_name = all_torrents[torrent_id].get_name()
-
-        if search_string in torrent_name:
-            yield torrent_id
-
-def tracker_error_filter(torrent_ids, values):
-    filtered_torrent_ids = []
-    tm = component.get("TorrentManager")
-
-    # If this is a tracker_host, then we need to filter on it
-    if values[0] != "Error":
-        for torrent_id in torrent_ids:
-            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
-    for torrent_id in torrent_ids:
-        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
@@ -126,22 +75,13 @@ class FilterManager(component.Component):
         component.Component.__init__(self, "FilterManager")
         log.debug("FilterManager init..")
         self.core = core
-        self.torrents = core.torrentmanager
+        self.torrents = core.torrents
         self.registered_filters = {}
         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_filter("tracker_host", tracker_error_filter)
-
-        def _init_users_tree():
-            return {"": 0}
-        self.register_tree_field("owner", _init_users_tree)
+        self.register_tree_field("tracker_host")
 
     def filter_torrent_ids(self, filter_dict):
         """
@@ -158,7 +98,7 @@ class FilterManager(component.Component):
 
 
         if "id"in filter_dict: #optimized filter for id:
-            torrent_ids = list(filter_dict["id"])
+            torrent_ids = filter_dict["id"]
             del filter_dict["id"]
         else:
             torrent_ids = self.torrents.get_torrent_list()
@@ -167,10 +107,6 @@ class FilterManager(component.Component):
             return torrent_ids
 
         #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"])
-
         if "state" in filter_dict and "Active" in filter_dict["state"]:
             filter_dict["state"].remove("Active")
             if not filter_dict["state"]:
@@ -193,7 +129,7 @@ class FilterManager(component.Component):
 
         #leftover filter arguments:
         #default filter on status fields.
-        status_func = self.core.get_torrent_status #premature optimalisation..
+        status_func = self.core.export_get_torrent_status #premature optimalisation..
         for torrent_id in list(torrent_ids):
             status = status_func(torrent_id, filter_dict.keys()) #status={key:value}
             for field, values in filter_dict.iteritems():
@@ -208,7 +144,7 @@ class FilterManager(component.Component):
         for use in sidebar.
         """
         torrent_ids = self.torrents.get_torrent_list()
-        status_func = self.core.get_torrent_status #premature optimalisation..
+        status_func = self.core.export_get_torrent_status #premature optimalisation..
         tree_keys = list(self.tree_fields.keys())
         if hide_cat:
             for cat in hide_cat:
@@ -223,10 +159,6 @@ class FilterManager(component.Component):
                 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 "state" in tree_keys and not show_zero_hits:
             self._hide_state_items(items["state"])
 
@@ -261,11 +193,10 @@ class FilterManager(component.Component):
         self.tree_fields[field] = init_func
 
     def deregister_tree_field(self, field):
-        if field in self.tree_fields:
-            del self.tree_fields[field]
+        del self.tree_fields[field]
 
     def filter_state_active(self, torrent_ids):
-        get_status = self.core.get_torrent_status
+        get_status = self.core.export_get_torrent_status
         for torrent_id in list(torrent_ids):
             status = get_status(torrent_id, ["download_payload_rate", "upload_payload_rate"])
             if status["download_payload_rate"] or status["upload_payload_rate"]:
@@ -292,3 +223,6 @@ class FilterManager(component.Component):
             iy = 99
 
         return ix - iy
+
+
+

deluge/core/oldstateupgrader.py

@@ -19,18 +19,7 @@
 # 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.
-#
+# 	Boston, MA    02110-1301, USA.
 #
 
 
@@ -39,14 +28,17 @@ import os.path
 import pickle
 import cPickle
 import shutil
-import logging
 
-from deluge._libtorrent import lt
+try:
+    import deluge.libtorrent as lt
+except ImportError:
+    import libtorrent as lt
+    if not (lt.version_major == 0 and lt.version_minor == 14):
+        raise ImportError("This version of Deluge requires libtorrent 0.14!")
 
-from deluge.configmanager import ConfigManager, get_config_dir
+from deluge.configmanager import ConfigManager
 import deluge.core.torrentmanager
-
-log = logging.getLogger(__name__)
+from deluge.log import LOG as log
 
 #start : http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/286203
 def makeFakeClass(module, name):
@@ -71,8 +63,8 @@ class PickleUpgrader(pickle.Unpickler):
 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")
+        self.state05_location = os.path.join(self.config["config_location"], "persistent.state")
+        self.state10_location = os.path.join(self.config["state_location"], "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()
@@ -91,7 +83,7 @@ class OldStateUpgrader:
 
         new_state = deluge.core.torrentmanager.TorrentManagerState()
         for ti, uid in state.torrents.items():
-            torrent_path = os.path.join(get_config_dir(), "torrentfiles", ti.filename)
+            torrent_path = os.path.join(self.config["config_location"], "torrentfiles", ti.filename)
             try:
                 torrent_info = None
                 log.debug("Attempting to create torrent_info from %s", torrent_path)
@@ -99,11 +91,11 @@ class OldStateUpgrader:
                 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)
+                log.warning("Unable to open %s: %s", filepath, 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"))
+            shutil.copyfile(torrent_path, os.path.join(self.config["state_location"], str(torrent_info.info_hash()) + ".torrent"))
 
             # Set the file prioritiy property if not already there
             if not hasattr(ti, "priorities"):
@@ -129,7 +121,7 @@ class OldStateUpgrader:
         try:
             log.debug("Saving torrent state file.")
             state_file = open(
-                os.path.join(get_config_dir(), "state", "torrents.state"), "wb")
+                os.path.join(self.config["state_location"], "torrents.state"), "wb")
             cPickle.dump(new_state, state_file)
             state_file.close()
         except IOError, e:

deluge/core/pluginmanager.py

@@ -19,30 +19,17 @@
 # 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.
-#
+# 	Boston, MA    02110-1301, USA.
 #
 
 
 """PluginManager for Core"""
 
-import logging
+import gobject
 
-from deluge.event import PluginEnabledEvent, PluginDisabledEvent
 import deluge.pluginmanagerbase
 import deluge.component as component
-
-log = logging.getLogger(__name__)
+from deluge.log import LOG as log
 
 class PluginManager(deluge.pluginmanagerbase.PluginManagerBase,
     component.Component):
@@ -50,7 +37,14 @@ class PluginManager(deluge.pluginmanagerbase.PluginManagerBase,
     functions to access parts of the core."""
 
     def __init__(self, core):
-        component.Component.__init__(self, "CorePluginManager")
+        component.Component.__init__(self, "PluginManager")
+        self.core = core
+        # Set up the hooks dictionary
+        self.hooks = {
+            "post_torrent_add": [],
+            "post_torrent_remove": [],
+            "post_session_load": []
+        }
 
         self.status_fields = {}
 
@@ -62,42 +56,29 @@ class PluginManager(deluge.pluginmanagerbase.PluginManagerBase,
         # Enable plugins that are enabled in the config
         self.enable_plugins()
 
+        # Set update timer to call update() in plugins every second
+        self.update_timer = gobject.timeout_add(1000, self.update_plugins)
+
     def stop(self):
         # Disable all enabled plugins
         self.disable_plugins()
+        # Stop the update timer
+        gobject.source_remove(self.update_timer)
 
     def shutdown(self):
         self.stop()
 
     def update_plugins(self):
         for plugin in self.plugins.keys():
-            if hasattr(self.plugins[plugin], "update"):
-                try:
-                    self.plugins[plugin].update()
-                except Exception, e:
-                    log.exception(e)
-
-    def enable_plugin(self, name):
-        if name not in self.plugins:
-            super(PluginManager, self).enable_plugin(name)
-            if name in self.plugins:
-                component.get("EventManager").emit(PluginEnabledEvent(name))
-
-    def disable_plugin(self, name):
-        if name in self.plugins:
-            super(PluginManager, self).disable_plugin(name)
-            if name not in self.plugins:
-                component.get("EventManager").emit(PluginDisabledEvent(name))
-
-    def get_status(self, torrent_id, fields):
-        """Return the value of status fields for the selected torrent_id."""
-        status = {}
-        for field in fields:
             try:
-                status[field] = self.status_fields[field](torrent_id)
-            except KeyError:
+                self.plugins[plugin].update()
+            except AttributeError:
+                # We don't care if this doesn't work
                 pass
-        return status
+
+    def get_core(self):
+        """Returns a reference to the core"""
+        return self.core
 
     def register_status_field(self, field, function):
         """Register a new status field.  This can be used in the same way the
@@ -112,3 +93,62 @@ class PluginManager(deluge.pluginmanagerbase.PluginManagerBase,
             del self.status_fields[field]
         except:
             log.warning("Unable to deregister status field %s", field)
+
+    def get_status(self, torrent_id, fields):
+        """Return the value of status fields for the selected torrent_id."""
+        status = {}
+        for field in fields:
+            try:
+                status[field] = self.status_fields[field](torrent_id)
+            except KeyError:
+                log.warning("Status field %s is not registered with the\
+                    PluginManager.", field)
+        return status
+
+    def register_hook(self, hook, function):
+        """Register a hook function with the plugin manager"""
+        try:
+            self.hooks[hook].append(function)
+        except KeyError:
+            log.warning("Plugin attempting to register invalid hook.")
+
+    def deregister_hook(self, hook, function):
+        """Deregisters a hook function"""
+        try:
+            self.hooks[hook].remove(function)
+        except:
+            log.warning("Unable to deregister hook %s", hook)
+
+    def run_post_torrent_add(self, torrent_id):
+        """This hook is run after a torrent has been added to the session."""
+        log.debug("run_post_torrent_add")
+        for function in self.hooks["post_torrent_add"]:
+            function(torrent_id)
+
+    def run_post_torrent_remove(self, torrent_id):
+        """This hook is run after a torrent has been removed from the session.
+        """
+        log.debug("run_post_torrent_remove")
+        for function in self.hooks["post_torrent_remove"]:
+            function(torrent_id)
+
+    def run_post_session_load(self):
+        """This hook is run after all the torrents have been loaded into the
+        session from the saved state.  It is called prior to resuming the
+        torrents and they all will have a 'Paused' state."""
+        log.debug("run_post_session_load")
+        for function in self.hooks["post_session_load"]:
+            function()
+
+    def get_torrent_list(self):
+        """Returns a list of torrent_id's in the current session."""
+        return component.get("TorrentManager").get_torrent_list()
+
+    def block_ip_range(self, range):
+        """Blocks the ip range in the core"""
+        return self.core.export_block_ip_range(range)
+
+    def reset_ip_filter(self):
+        """Resets the ip filter"""
+        return self.core.export_reset_ip_filter()
+

deluge/core/preferencesmanager.py

@@ -1,7 +1,7 @@
 #
 # preferencesmanager.py
 #
-# Copyright (C) 2008-2010 Andrew Resch <andrewresch@gmail.com>
+# Copyright (C) 2008 Andrew Resch <andrewresch@gmail.com>
 #
 # Deluge is free software.
 #
@@ -19,36 +19,28 @@
 # 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.
-#
+# 	Boston, MA    02110-1301, USA.
 #
 
 
-import os
-import logging
+import os.path
 import threading
-from twisted.internet.task import LoopingCall
+import gobject
 
-from deluge._libtorrent import lt
+try:
+    import deluge.libtorrent as lt
+except ImportError:
+    import libtorrent as lt
+    if not (lt.version_major == 0 and lt.version_minor == 14):
+        raise ImportError("This version of Deluge requires libtorrent 0.14!")
 
-from deluge.event import *
 import deluge.configmanager
 import deluge.common
 import deluge.component as component
-
-log = logging.getLogger(__name__)
+from deluge.log import LOG as log
 
 DEFAULT_PREFS = {
+    "config_location": deluge.configmanager.get_config_dir(),
     "send_info": False,
     "info_sent": 0.0,
     "daemon_port": 58846,
@@ -56,13 +48,11 @@ DEFAULT_PREFS = {
     "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"),
+    "state_location": os.path.join(deluge.configmanager.get_config_dir(), "state"),
     "prioritize_first_last_pieces": False,
-    "sequential_download": False,
     "random_port": True,
     "dht": True,
     "upnp": True,
@@ -86,6 +76,8 @@ DEFAULT_PREFS = {
     "max_upload_speed_per_torrent": -1,
     "max_download_speed_per_torrent": -1,
     "enabled_plugins": [],
+    "autoadd_location": deluge.common.get_default_download_dir(),
+    "autoadd_enable": False,
     "add_paused": False,
     "max_active_seeding": 5,
     "max_active_downloading": 3,
@@ -136,12 +128,7 @@ DEFAULT_PREFS = {
     "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
+    "rate_limit_ip_overhead": True
 }
 
 class PreferencesManager(component.Component):
@@ -149,41 +136,84 @@ class PreferencesManager(component.Component):
         component.Component.__init__(self, "PreferencesManager")
 
         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.new_release_timer = None
+        self.settings = component.get("Core").settings
+        self.signals = component.get("SignalManager")
 
-        # Set the initial preferences on start-up
-        for key in DEFAULT_PREFS:
-            self.do_config_set_func(key, self.config[key])
+        # Register set functions in the Config
+        self.config.register_set_function("torrentfiles_location",
+            self._on_set_torrentfiles_location)
+        self.config.register_set_function("state_location",
+            self._on_set_state_location)
+        self.config.register_set_function("listen_ports",
+            self._on_set_listen_ports)
+        self.config.register_set_function("random_port",
+            self._on_set_random_port)
+        self.config.register_set_function("outgoing_ports",
+            self._on_set_outgoing_ports)
+        self.config.register_set_function("random_outgoing_ports",
+            self._on_set_random_outgoing_ports)
+        self.config.register_set_function("peer_tos",
+            self._on_set_peer_tos)
+        self.config.register_set_function("dht", self._on_set_dht)
+        self.config.register_set_function("upnp", self._on_set_upnp)
+        self.config.register_set_function("natpmp", self._on_set_natpmp)
+        self.config.register_set_function("utpex", self._on_set_utpex)
+        self.config.register_set_function("lsd", self._on_set_lsd)
+        self.config.register_set_function("enc_in_policy",
+            self._on_set_encryption)
+        self.config.register_set_function("enc_out_policy",
+            self._on_set_encryption)
+        self.config.register_set_function("enc_level",
+            self._on_set_encryption)
+        self.config.register_set_function("enc_prefer_rc4",
+            self._on_set_encryption)
+        self.config.register_set_function("max_connections_global",
+            self._on_set_max_connections_global)
+        self.config.register_set_function("max_upload_speed",
+            self._on_set_max_upload_speed)
+        self.config.register_set_function("max_download_speed",
+            self._on_set_max_download_speed)
+        self.config.register_set_function("max_upload_slots_global",
+            self._on_set_max_upload_slots_global)
+        self.config.register_set_function("max_half_open_connections",
+            self._on_set_max_half_open_connections)
+        self.config.register_set_function("max_connections_per_second",
+            self._on_set_max_connections_per_second)
+        self.config.register_set_function("ignore_limits_on_local_network",
+            self._on_ignore_limits_on_local_network)
+        self.config.register_set_function("share_ratio_limit",
+            self._on_set_share_ratio_limit)
+        self.config.register_set_function("seed_time_ratio_limit",
+            self._on_set_seed_time_ratio_limit)
+        self.config.register_set_function("seed_time_limit",
+            self._on_set_seed_time_limit)
+        self.config.register_set_function("max_active_downloading",
+            self._on_set_max_active_downloading)
+        self.config.register_set_function("max_active_seeding",
+            self._on_set_max_active_seeding)
+        self.config.register_set_function("max_active_limit",
+            self._on_set_max_active_limit)
+        self.config.register_set_function("dont_count_slow_torrents",
+            self._on_set_dont_count_slow_torrents)
+        self.config.register_set_function("send_info",
+            self._on_send_info)
+        self.config.register_set_function("proxies",
+            self._on_set_proxies)
+        self.new_release_timer = None
+        self.config.register_set_function("new_release_check",
+            self._on_new_release_check)
+        self.config.register_set_function("rate_limit_ip_overhead",
+            self._on_rate_limit_ip_overhead)
 
         self.config.register_change_callback(self._on_config_value_change)
 
-    def stop(self):
-        if self.new_release_timer and self.new_release_timer.running:
-            self.new_release_timer.stop()
-
     # Config set functions
-    def do_config_set_func(self, key, value):
-        on_set_func = getattr(self, "_on_set_" + key, None)
-        if on_set_func:
-            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))
+        self.signals.emit("config_value_changed", key, value)
 
     def _on_set_torrentfiles_location(self, key, value):
         if self.config["copy_torrent_file"]:
@@ -192,17 +222,18 @@ class PreferencesManager(component.Component):
             except Exception, e:
                 log.debug("Unable to make directory: %s", e)
 
+    def _on_set_state_location(self, key, value):
+        if not os.access(value, os.F_OK):
+            try:
+                os.makedirs(value)
+            except Exception, e:
+                log.debug("Unable to make directory: %s", e)
+
     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"])
-            )
-
-    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.session.listen_on(value[0], value[1])
 
     def _on_set_random_port(self, key, value):
         log.debug("random port value set to %s", value)
@@ -220,15 +251,13 @@ class PreferencesManager(component.Component):
         # Set the listen ports
         log.debug("listen port range set to %s-%s", listen_ports[0],
             listen_ports[1])
-        self.session.listen_on(
-            listen_ports[0], listen_ports[1],
-            str(self.config["listen_interface"])
-        )
+        self.session.listen_on(listen_ports[0], listen_ports[1])
 
     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.settings.outgoing_ports = value[0], value[1]
+            self.session.set_settings(self.settings)
 
     def _on_set_random_outgoing_ports(self, key, value):
         if value:
@@ -237,14 +266,16 @@ class PreferencesManager(component.Component):
     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)))
+            self.settings.peer_tos = chr(int(value, 16))
         except ValueError, e:
             log.debug("Invalid tos byte: %s", e)
             return
 
+        self.session.set_settings(self.settings)
+
     def _on_set_dht(self, key, value):
         log.debug("dht value set to %s", value)
-        state_file = deluge.configmanager.get_config_dir("dht.state")
+        state_file = deluge.common.get_default_config_dir("dht.state")
         if value:
             state = None
             try:
@@ -290,18 +321,6 @@ class PreferencesManager(component.Component):
         if value:
             self.session.add_extension(lt.create_ut_pex_plugin)
 
-    def _on_set_enc_in_policy(self, key, value):
-        self._on_set_encryption(key, value)
-
-    def _on_set_enc_out_policy(self, key, value):
-        self._on_set_encryption(key, value)
-
-    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()
@@ -350,41 +369,53 @@ class PreferencesManager(component.Component):
         self.session.set_max_half_open_connections(value)
 
     def _on_set_max_connections_per_second(self, key, value):
-        self.session_set_setting("connection_speed", value)
+        self.settings.connection_speed = value
+        self.session.set_settings(self.settings)
 
-    def _on_set_ignore_limits_on_local_network(self, key, value):
-        self.session_set_setting("ignore_limits_on_local_network", value)
+    def _on_ignore_limits_on_local_network(self, key, value):
+        self.settings.ignore_limits_on_local_network = value
+        self.session.set_settings(self.settings)
 
     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)
+        self.settings.share_ratio_limit = value
+        self.session.set_settings(self.settings)
 
     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)
+        self.settings.seed_time_ratio_limit = value
+        self.session.set_settings(self.settings)
 
     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.settings.seed_time_limit = int(value * 60)
+        self.session.set_settings(self.settings)
 
     def _on_set_max_active_downloading(self, key, value):
         log.debug("%s set to %s..", key, value)
-        self.session_set_setting("active_downloads", value)
+        log.debug("active_downloads: %s", self.settings.active_downloads)
+        self.settings.active_downloads = value
+        self.session.set_settings(self.settings)
 
     def _on_set_max_active_seeding(self, key, value):
         log.debug("%s set to %s..", key, value)
-        self.session_set_setting("active_seeds", value)
+        log.debug("active_seeds: %s", self.settings.active_seeds)
+        self.settings.active_seeds = value
+        self.session.set_settings(self.settings)
 
     def _on_set_max_active_limit(self, key, value):
         log.debug("%s set to %s..", key, value)
-        self.session_set_setting("active_limit", value)
+        log.debug("active_limit: %s", self.settings.active_limit)
+        self.settings.active_limit = value
+        self.session.set_settings(self.settings)
 
     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.settings.dont_count_slow_torrents = value
+        self.session.set_settings(self.settings)
 
-    def _on_set_send_info(self, key, value):
+    def _on_send_info(self, key, value):
         log.debug("Sending anonymous stats..")
         """sends anonymous stats home"""
         class Send_Info_Thread(threading.Thread):
@@ -405,7 +436,7 @@ class PreferencesManager(component.Component):
                             platform.machine() + "&python=" + platform.python_version() \
                             + "&deluge=" + deluge.common.get_version() \
                             + "&os=" + platform.system() \
-                            + "&plugins=" + quote_plus(":".join(self.config["enabled_plugins"]))
+                            + "&plugins=" + quote_plus(self.config["enabled_plugins"])
                         urlopen(url)
                     except IOError, e:
                         log.debug("Network error while trying to send info: %s", e)
@@ -414,64 +445,32 @@ class PreferencesManager(component.Component):
         if value:
             Send_Info_Thread(self.config).start()
 
-    def _on_set_new_release_check(self, key, value):
+    def _on_new_release_check(self, key, value):
         if value:
             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()
+            if self.new_release_timer:
+                gobject.source_remove(self.new_release_timer)
             # 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.new_release_timer.start(72 * 60 * 60, False)
+            self.new_release_timer = gobject.timeout_add(
+                72 * 60 * 60 * 1000, self._on_new_release_check, "new_release_check", True)
         else:
-            if self.new_release_timer and self.new_release_timer.running:
-                self.new_release_timer.stop()
+            if self.new_release_timer:
+                gobject.source.remove(self.new_release_timer)
 
     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.username = v["username"]
+                proxy_settings.password = v["password"]
+                proxy_settings.hostname = 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_rate_limit_ip_overhead(self, key, value):
+    def _on_rate_limit_ip_overhead(self, key, value):
         log.debug("%s: %s", key, value)
-        self.session_set_setting("rate_limit_ip_overhead", value)
-
-    def _on_set_geoip_db_location(self, key, value):
-        log.debug("%s: %s", key, value)
-        # 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:
-            try:
-                self.session.load_country_db(str(geoip_db))
-            except Exception, e:
-                log.error("Unable to load geoip database!")
-                log.exception(e)
-
-    def _on_set_cache_size(self, key, value):
-        log.debug("%s: %s", key, value)
-        self.session_set_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)
-
-    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.settings.rate_limit_ip_overhead = value
+        self.session.set_settings(self.settings)

deluge/core/rpcserver.py

@@ -1,7 +1,7 @@
 #
 # rpcserver.py
 #
-# Copyright (C) 2008,2009 Andrew Resch <andrewresch@gmail.com>
+# Copyright (C) 2008 Andrew Resch <andrewresch@gmail.com>
 #
 # Deluge is free software.
 #
@@ -19,594 +19,96 @@
 # 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.
-#
+# 	Boston, MA    02110-1301, USA.
 #
 
-"""RPCServer Module"""
 
-import sys
-import zlib
-import os
-import stat
-import logging
-import traceback
+import gobject
 
-from twisted.internet.protocol import Factory, Protocol
-from twisted.internet import reactor, defer
-
-from OpenSSL import crypto, SSL
-from types import FunctionType
-
-try:
-    import rencode
-except ImportError:
-    import deluge.rencode as rencode
+from deluge.SimpleXMLRPCServer import SimpleXMLRPCServer
+from deluge.SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
+from SocketServer import ThreadingMixIn
+from base64 import decodestring, encodestring
 
+from deluge.log import LOG as log
 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)
 
-RPC_RESPONSE = 1
-RPC_ERROR = 2
-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
-    will need to be registered with an :class:`RPCServer` to be effective.
-
-    :param func: the function to export
-    :type func: function
-    :param auth_level: the auth level required to call this method
-    :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
-
-        return func
-
-    if type(auth_level) is FunctionType:
-        func = auth_level
-        auth_level = AUTH_LEVEL_DEFAULT
-        return wrap(func)
-    else:
-        return wrap
-
-
-def format_request(call):
-    """
-    Format the RPCRequest message for debug printing
-
-    :param call: the request
-    :type call: a RPCRequest
-
-    :returns: a formatted string for printing
-    :rtype: str
-
-    """
-    try:
-        s = call[1] + "("
-        if 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 += ")"
-    except UnicodeEncodeError:
-        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(Protocol):
-    __buffer = None
-
-    def dataReceived(self, data):
-        """
-        This method is called whenever data is received from a client.  The
-        only message that a client sends to the server is a RPC Request message.
-        If the RPC Request message is valid, then the method is called in
-        :meth:`dispatch`.
-
-        :param data: the data from the client. It should be a zlib compressed
-            rencoded string.
-        :type data: str
-
-        """
-        if self.__buffer:
-            # We have some data from the last dataReceived() so lets prepend it
-            data = self.__buffer + data
-            self.__buffer = None
-
-        while data:
-            dobj = zlib.decompressobj()
-            try:
-                request = rencode.loads(dobj.decompress(data))
-            except Exception, e:
-                #log.debug("Received possible invalid message (%r): %s", data, e)
-                # This could be cut-off data, so we'll save this in the buffer
-                # and try to prepend it on the next dataReceived()
-                self.__buffer = data
-                return
-            else:
-                data = dobj.unused_data
-
-            if type(request) is not tuple:
-                log.debug("Received invalid message: type is not tuple")
-                return
-
-            if len(request) < 1:
-                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))
-                    continue
-                #log.debug("RPCRequest: %s", format_request(call))
-                reactor.callLater(0, self.dispatch, *call)
-
-    def sendData(self, data):
-        """
-        Sends the data to the client.
-
-        :param data: the object that is to be sent to the client.  This should
-            be one of the RPC message types.
-        :type data: object
-
-        """
-        self.transport.write(zlib.compress(rencode.dumps(data)))
-
-    def connectionMade(self):
-        """
-        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)
-        # Set the initial auth level of this session to AUTH_LEVEL_NONE
-        self.factory.authorized_sessions[self.transport.sessionno] = AUTH_LEVEL_NONE
-
-    def connectionLost(self, reason):
-        """
-        This method is called when the client is disconnected.
-
-        :param reason: the reason the client disconnected.
-        :type reason: str
-
-        """
-
-        # We need to remove this session from various dicts
-        del self.factory.authorized_sessions[self.transport.sessionno]
-        if self.transport.sessionno in self.factory.session_protocols:
-            del self.factory.session_protocols[self.transport.sessionno]
-        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)
-
-    def valid_session(self):
-        return self.transport.sessionno in self.factory.authorized_sessions
-
-    def dispatch(self, request_id, method, args, kwargs):
-        """
-        This method is run when a RPC Request is made.  It will run the local method
-        and will send either a RPC Response or RPC Error back to the client.
-
-        :param request_id: the request_id from the client (sent in the RPC Request)
-        :type request_id: int
-        :param method: the local method to call. It must be registered with
-            the :class:`RPCServer`.
-        :type method: str
-        :param args: the arguments to pass to `method`
-        :type args: list
-        :param kwargs: the keyword-arguments to pass to `method`
-        :type kwargs: dict
-
-        """
-        def sendError():
-            """
-            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))
-            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)
-                try:
-                    raise WrappedException(str(exceptionValue), exceptionType.__name__, formated_tb)
-                except:
-                    sendError()
-
-        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":
-            # 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")
-            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)
-                if ret:
-                    self.factory.authorized_sessions[self.transport.sessionno] = (ret, args[0])
-                    self.factory.session_protocols[self.transport.sessionno] = self
-            except Exception, e:
-                sendError()
-                if not isinstance(e, _ClientSideRecreateError):
-                    log.exception(e)
-            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")
-            # This special case is to allow clients to set which events they are
-            # interested in receiving.
-            # We are expecting a sequence from the client.
-            try:
-                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()
-            else:
-                self.sendData((RPC_RESPONSE, request_id, (True)))
-            finally:
-                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):
-                        self.sendData((RPC_RESPONSE, request_id, result))
-                        return result
-
-                    def on_fail(failure):
-                        try:
-                            failure.raiseException()
-                        except Exception, e:
-                            sendError()
-                        return failure
-
-                    ret.addCallbacks(on_success, on_fail)
-                else:
-                    self.sendData((RPC_RESPONSE, request_id, ret))
+def export(func):
+    func._rpcserver_export = True
+    return func
 
 class RPCServer(component.Component):
-    """
-    This class is used to handle rpc requests from the client.  Objects are
-    registered with this class and their methods are exported using the export
-    decorator.
-
-    :param port: the port the RPCServer will listen on
-    :type port: int
-    :param interface: the interface to listen on, this may override the `allow_remote` setting
-    :type interface: str
-    :param allow_remote: set True if the server should allow remote connections
-    :type allow_remote: bool
-    :param listen: if False, will not start listening.. This is only useful in Classic Mode
-    :type listen: bool
-    """
-
-    def __init__(self, port=58846, interface="", allow_remote=False, listen=True):
+    def __init__(self, port):
         component.Component.__init__(self, "RPCServer")
 
-        self.factory = Factory()
-        self.factory.protocol = DelugeRPCProtocol
-        self.factory.session_id = -1
+        # Get config
+        self.config = deluge.configmanager.ConfigManager("core.conf")
 
-        # Holds the registered methods
-        self.factory.methods = {}
-        # Holds the session_ids and auth levels
-        self.factory.authorized_sessions = {}
-        # Holds the protocol objects with the session_id as key
-        self.factory.session_protocols = {}
-        # Holds the interested event list for the sessions
-        self.factory.interested_events = {}
+        if port == None:
+            port = self.config["daemon_port"]
 
-        self.listen = listen
-        if not listen:
-            return
-
-        if allow_remote:
+        if self.config["allow_remote"]:
             hostname = ""
         else:
             hostname = "localhost"
 
-        if interface:
-            hostname = interface
-
-        log.info("Starting DelugeRPC server %s:%s", hostname, port)
-
-        # Check for SSL keys and generate some if needed
-        check_ssl_keys()
-
+        # Setup the xmlrpc server
         try:
-            reactor.listenSSL(port, self.factory, ServerContextFactory(), interface=hostname)
+            log.info("Starting XMLRPC server %s:%s", hostname, port)
+            self.server = XMLRPCServer((hostname, port),
+                requestHandler=BasicAuthXMLRPCRequestHandler,
+                logRequests=False,
+                allow_none=True)
         except Exception, e:
             log.info("Daemon already running or port not available..")
             log.error(e)
             sys.exit(0)
 
-    def register_object(self, obj, name=None):
-        """
-        Registers an object to export it's rpc methods.  These methods should
-        be exported with the export decorator prior to registering the object.
+        self.server.register_multicall_functions()
+        self.server.register_introspection_functions()
 
-        :param obj: the object that we want to export
-        :type obj: object
-        :param name: the name to use, if None, it will be the class name of the object
-        :type name: str
-        """
+        self.server.socket.setblocking(False)
+
+        gobject.io_add_watch(self.server.socket.fileno(), gobject.IO_IN | gobject.IO_OUT | gobject.IO_PRI | gobject.IO_ERR | gobject.IO_HUP, self._on_socket_activity)
+
+    def _on_socket_activity(self, source, condition):
+        """This gets called when there is activity on the socket, ie, data to read
+        or to write."""
+        self.server.handle_request()
+        return True
+
+    def register_object(self, obj, name=None):
         if not name:
-            name = obj.__class__.__name__.lower()
+            name = obj.__class__.__name__
 
         for d in dir(obj):
             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)
+                self.server.register_function(getattr(obj, d), name + "." + d)
 
-    def deregister_object(self, obj):
+class XMLRPCServer(ThreadingMixIn, SimpleXMLRPCServer):
+    def get_request(self):
+        """Get the request and client address from the socket.
+            We override this so that we can get the ip address of the client.
         """
-        Deregisters an objects exported rpc methods.
+        request, client_address = self.socket.accept()
+        self.client_address = client_address[0]
+        return (request, client_address)
+
+class BasicAuthXMLRPCRequestHandler(SimpleXMLRPCRequestHandler):
+    def do_POST(self):
+        if "authorization" in self.headers:
+            auth = self.headers['authorization']
+            auth = auth.replace("Basic ","")
+            decoded_auth = decodestring(auth)
+            # Check authentication here
+            if component.get("AuthManager").authorize(*decoded_auth.split(":")):
+                # User authorized, call the real do_POST now
+                return SimpleXMLRPCRequestHandler.do_POST(self)
 
-        :param obj: the object that was previously registered
-
-        """
-        for key, value in self.factory.methods.items():
-            if value.im_self == obj:
-                del self.factory.methods[key]
-
-    def get_object_method(self, name):
-        """
-        Returns a registered method.
-
-        :param name: the name of the method, usually in the form of 'object.method'
-        :type name: str
-
-        :returns: method
-
-        :raises KeyError: if `name` is not registered
-
-        """
-        return self.factory.methods[name]
-
-    def get_method_list(self):
-        """
-        Returns a list of the exported methods.
-
-        :returns: the exported methods
-        :rtype: list
-        """
-        return self.factory.methods.keys()
-
-    def get_session_id(self):
-        """
-        Returns the session id of the current RPC.
-
-        :returns: the session id, this will be -1 if no connections have been made
-        :rtype: int
-
-        """
-        return self.factory.session_id
-
-    def get_session_user(self):
-        """
-        Returns the username calling the current RPC.
-
-        :returns: the username of the user calling the current RPC
-        :rtype: string
-
-        """
-        if not self.listen:
-            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]
-        else:
-            # No connections made yet
-            return ""
-
-    def get_session_auth_level(self):
-        """
-        Returns the auth level of the user calling the current RPC.
-
-        :returns: the auth level
-        :rtype: int
-        """
-        if not self.listen:
-            return AUTH_LEVEL_ADMIN
-        return self.factory.authorized_sessions[self.get_session_id()][0]
-
-    def get_rpc_auth_level(self, rpc):
-        """
-        Returns the auth level requirement for an exported rpc.
-
-        :returns: the auth level
-        :rtype: int
-        """
-        self.factory.methods[rpc]._rpcserver_auth_level
-
-    def is_session_valid(self, session_id):
-        """
-        Checks if the session is still valid, eg, if the client is still connected.
-
-        :param session_id: the session id
-        :type session_id: int
-
-        :returns: True if the session is valid
-        :rtype: bool
-
-        """
-        return session_id in self.factory.authorized_sessions
-
-    def emit_event(self, event):
-        """
-        Emits the event to interested clients.
-
-        :param event: the event to emit
-        :type event: :class:`deluge.event.DelugeEvent`
-        """
-        log.debug("intevents: %s", self.factory.interested_events)
-        # Find sessions interested in this event
-        for session_id, interest in self.factory.interested_events.iteritems():
-            if event.name in interest:
-                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)
-                )
-
-    def emit_event_for_session_id(self, session_id, event):
-        """
-        Emits the event to specified session_id.
-
-        :param session_id: the event to emit
-        :type session_id: int
-        :param event: the event to emit
-        :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)
-            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)
-            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)
-            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))
-
-
-def check_ssl_keys():
-    """
-    Check for SSL cert/key and create them if necessary
-    """
-    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"):
-            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"
-    # Generate key pair
-    pkey = crypto.PKey()
-    pkey.generate_key(crypto.TYPE_RSA, 1024)
-
-    # Generate cert request
-    req = crypto.X509Req()
-    subj = req.get_subject()
-    setattr(subj, "CN", "Deluge Daemon")
-    req.set_pubkey(pkey)
-    req.sign(pkey, digest)
-
-    # Generate certificate
-    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.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)
-    )
-    # Make the files only readable by this user
-    for f in ("daemon.pkey", "daemon.cert"):
-        os.chmod(os.path.join(ssl_dir, f), stat.S_IREAD | stat.S_IWRITE)
+        # if cannot authenticate, end the connection
+        self.send_response(401)
+        self.end_headers()

deluge/core/signalmanager.py

@@ -0,0 +1,108 @@
+#
+# signalmanager.py
+#
+# Copyright (C) 2007, 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.
+#
+
+
+import deluge.xmlrpclib as xmlrpclib
+import socket
+import struct
+
+import gobject
+
+import deluge.component as component
+from deluge.log import LOG as log
+
+class Transport(xmlrpclib.Transport):
+    def make_connection(self, host):
+        # create a HTTP connection object from a host descriptor
+        import httplib
+        host, extra_headers, x509 = self.get_host_info(host)
+        h = httplib.HTTP(host)
+        h._conn.connect()
+        h._conn.sock.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER,
+                      struct.pack('ii', 1, 0))
+        return h
+
+class SignalManager(component.Component):
+    def __init__(self):
+        component.Component.__init__(self, "SignalManager")
+        self.clients = {}
+        self.handlers = {}
+
+    def shutdown(self):
+        self.clients = {}
+        self.handlers = {}
+
+    def register_handler(self, signal, handler):
+        """Registers a handler for signals"""
+        if signal not in self.handler.keys():
+            self.handler[signal] = []
+
+        self.handler[signal].append(handler)
+        log.debug("Registered signal handler for %s", signal)
+
+    def deregister_handler(self, handler):
+        """De-registers the 'handler' function from all signal types."""
+        # Iterate through all handlers and remove 'handler' where found
+        for (key, value) in self.handlers:
+            if handler in value:
+                value.remove(handler)
+
+    def deregister_client(self, address):
+        """Deregisters a client"""
+        log.debug("Deregistering %s as a signal reciever..", address)
+        for client in self.clients.keys():
+            if client.split("//")[1].split(":")[0] == address:
+                del self.clients[client]
+                break
+
+    def register_client(self, address, port):
+        """Registers a client to emit signals to."""
+        uri = "http://" + str(address) + ":" + str(port)
+        log.debug("Registering %s as a signal reciever..", uri)
+        self.clients[uri] = xmlrpclib.ServerProxy(uri, transport=Transport())
+        #self.clients[uri].socket.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER,
+                    #  struct.pack('ii', 1, 0))
+
+    def emit(self, signal, *data):
+        # Run the handlers
+        if signal in self.handlers.keys():
+            for handler in self.handlers[signal]:
+                handler(*data)
+
+        for uri in self.clients:
+            gobject.idle_add(self._emit, uri, signal, 1, *data)
+
+    def _emit(self, uri, signal, count, *data):
+        if uri not in self.clients:
+            return
+        client = self.clients[uri]
+        try:
+            client.emit_signal(signal, *data)
+        except (socket.error, Exception), e:
+            log.warning("Unable to emit signal to client %s: %s (%d)", client, e, count)
+            if count < 30:
+                gobject.timeout_add(1000, self._emit, uri, signal, count + 1, *data)
+            else:
+                log.info("Removing %s because it couldn't be reached..", uri)
+                del self.clients[uri]

deluge/core/torrent.py

@@ -1,7 +1,7 @@
 #
 # torrent.py
 #
-# Copyright (C) 2007-2009 Andrew Resch <andrewresch@gmail.com>
+# Copyright (C) 2007, 2008 Andrew Resch <andrewresch@gmail.com>
 #
 # Deluge is free software.
 #
@@ -19,106 +19,98 @@
 # 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.
+# 	Boston, MA    02110-1301, USA.
 #
 
+
 """Internal Torrent class"""
 
 import os
 import time
-import logging
-from urllib import unquote
 from urlparse import urlparse
 
-from deluge._libtorrent import lt
+try:
+    import deluge.libtorrent as lt
+except ImportError:
+    import libtorrent as lt
+    if not (lt.version_major == 0 and lt.version_minor == 14):
+        raise ImportError("This version of Deluge requires libtorrent 0.14!")
 
 import deluge.common
 import deluge.component as component
-from deluge.configmanager import ConfigManager, get_config_dir
-from deluge.event import *
+from deluge.configmanager import ConfigManager
+from deluge.log import LOG as log
+
+import deluge.xmlrpclib
 
 TORRENT_STATE = deluge.common.TORRENT_STATE
 
-log = logging.getLogger(__name__)
-
-def sanitize_filepath(filepath, folder=False):
-    """
-    Returns a sanitized filepath to pass to libotorrent rename_file().
-    The filepath will have backslashes substituted along with whitespace
-    padding and duplicate slashes stripped. If `folder` is True a trailing
-    slash is appended to the returned filepath.
-    """
-    def clean_filename(filename):
-        filename = filename.strip()
-        if filename.replace('.', '') == '':
-            return ''
-        return filename
-
-    if '\\' in filepath or '/' in filepath:
-        folderpath = filepath.replace('\\', '/').split('/')
-        folderpath = [clean_filename(x) for x in folderpath]
-        newfilepath = '/'.join(filter(None, folderpath))
-    else:
-        newfilepath = clean_filename(filepath)
-
-    if folder is True:
-        return newfilepath + '/'
-    else:
-        return newfilepath
-
 class TorrentOptions(dict):
     def __init__(self):
-        config = ConfigManager("core.conf").config
-        options_conf_map = {
+        self.config = ConfigManager("core.conf")
+        self.default_keys = {
+            "max_download_speed": "max_download_speed_per_torrent",
+            "max_upload_speed": "max_upload_speed_per_torrent",
             "max_connections": "max_connections_per_torrent",
             "max_upload_slots": "max_upload_slots_per_torrent",
-            "max_upload_speed": "max_upload_speed_per_torrent",
-            "max_download_speed": "max_download_speed_per_torrent",
             "prioritize_first_last_pieces": "prioritize_first_last_pieces",
-            "sequential_download": "sequential_download",
-            "compact_allocation": "compact_allocation",
-            "download_location": "download_location",
             "auto_managed": "auto_managed",
-            "stop_at_ratio": "stop_seed_at_ratio",
-            "stop_ratio": "stop_seed_ratio",
-            "remove_at_ratio": "remove_seed_at_ratio",
             "move_completed": "move_completed",
             "move_completed_path": "move_completed_path",
-            "add_paused": "add_paused",
-            "shared": "shared"
+            "file_priorities": [],
+            "compact_allocation": "compact_allocation",
+            "download_location": "download_location",
+            "add_paused": "add_paused"
         }
-        for opt_k, conf_k in options_conf_map.iteritems():
-            self[opt_k] = config[conf_k]
-        self["file_priorities"] = []
-        self["mapped_files"] = {}
+        super(TorrentOptions, self).__setitem__("stop_at_ratio", False)
+        super(TorrentOptions, self).__setitem__("stop_ratio", 2.0)
+        super(TorrentOptions, self).__setitem__("remove_at_ratio", False)
 
-class Torrent(object):
+    def items(self):
+        i = super(TorrentOptions, self).items()
+        for k in self.default_keys:
+            if k not in super(TorrentOptions, self).keys():
+                i.append((k, self.__getitem__(k)))
+
+        return i
+
+    def keys(self):
+        k = super(TorrentOptions, self).keys()
+        for key in self.default_keys.keys():
+            if key not in k:
+                k.append(key)
+        return k
+
+    def iteritems(self):
+        return self.items().iteritems()
+
+    def has_key(self, key):
+        return super(TorrentOptions, self).has_key(key) or key in self.default_keys
+
+    def __setitem__(self, key, value):
+        super(TorrentOptions, self).__setitem__(key, value)
+
+    def __getitem__(self, key):
+        if super(TorrentOptions, self).has_key(key):
+            return super(TorrentOptions, self).__getitem__(key)
+        elif key in self.default_keys:
+            if self.default_keys[key] and self.default_keys[key] in self.config.config:
+                return self.config[self.default_keys[key]]
+            else:
+                return self.default_keys[key]
+        else:
+            raise KeyError
+
+
+class Torrent:
     """Torrent holds information about torrents added to the libtorrent session.
     """
-    def __init__(self, handle, options, state=None, filename=None, magnet=None, owner=None):
+    def __init__(self, handle, options, state=None, filename=None, magnet=None):
         log.debug("Creating torrent object %s", str(handle.info_hash()))
         # Get the core config
         self.config = ConfigManager("core.conf")
 
-        self.rpcserver = component.get("RPCServer")
-
-        # This dict holds previous status dicts returned for this torrent
-        # We use this to return dicts that only contain changes from the previous
-        # {session_id: status_dict, ...}
-        self.prev_status = {}
-        from twisted.internet.task import LoopingCall
-        self.prev_status_cleanup_loop = LoopingCall(self.cleanup_prev_status)
-        self.prev_status_cleanup_loop.start(10)
+        self.signals = component.get("SignalManager")
 
         # Set the libtorrent handle
         self.handle = handle
@@ -153,6 +145,9 @@ class Torrent(object):
         except RuntimeError:
             self.torrent_info = None
 
+        # Files dictionary
+        self.files = self.get_files()
+
         # Default total_uploaded to 0, this may be changed by the state
         self.total_uploaded = 0
 
@@ -173,22 +168,22 @@ class Torrent(object):
             # Set the filename
             self.filename = state.filename
             self.is_finished = state.is_finished
+            # Set the per-torrent queue options
+            self.options["stop_at_ratio"] = state.stop_at_ratio
+            self.options["stop_ratio"] = state.stop_ratio
+            self.options["remove_at_ratio"] = state.remove_at_ratio
         else:
             # Tracker list
             self.trackers = []
             # Create a list of trackers
             for value in self.handle.trackers():
-                if lt.version_minor < 15:
-                    tracker = {}
-                    tracker["url"] = value.url
-                    tracker["tier"] = value.tier
-                else:
-                    tracker = value
+                tracker = {}
+                tracker["url"] = value.url
+                tracker["tier"] = value.tier
                 self.trackers.append(tracker)
 
         # Various torrent options
         self.handle.resolve_countries(True)
-
         self.set_options(self.options)
 
         # Status message holds error info about the torrent
@@ -200,82 +195,35 @@ class Torrent(object):
         # The tracker status
         self.tracker_status = ""
 
-        # This gets updated when get_tracker_host is called
-        self.tracker_host = None
-
         if state:
             self.time_added = state.time_added
         else:
             self.time_added = time.time()
 
-        # Keep track of the owner
-        if state:
-            self.owner = state.owner
-        else:
-            self.owner = owner
-
-        # Keep track of last seen complete
-        if state:
-            self._last_seen_complete = state.last_seen_complete or 0.0
-        else:
-            self._last_seen_complete = 0.0
-
-        # Keep track if we're forcing a recheck of the torrent so that we can
-        # re-pause it after its done if necessary
-        self.forcing_recheck = False
-        self.forcing_recheck_paused = False
-
         log.debug("Torrent object created.")
 
     ## Options methods ##
     def set_options(self, options):
         OPTIONS_FUNCS = {
             # Functions used for setting options
-            "auto_managed": self.set_auto_managed,
-            "download_location": self.set_save_path,
-            "file_priorities": self.set_file_priorities,
-            "max_connections": self.handle.set_max_connections,
             "max_download_speed": self.set_max_download_speed,
-            "max_upload_slots": self.handle.set_max_uploads,
             "max_upload_speed": self.set_max_upload_speed,
+            "max_connections": self.handle.set_max_connections,
+            "max_upload_slots": self.handle.set_max_uploads,
             "prioritize_first_last_pieces": self.set_prioritize_first_last,
-            "sequential_download": self.set_sequential_download
-
+            "auto_managed": self.set_auto_managed,
+            "file_priorities": self.set_file_priorities,
+            "download_location": self.set_save_path,
         }
         for (key, value) in options.items():
             if OPTIONS_FUNCS.has_key(key):
                 OPTIONS_FUNCS[key](value)
+
         self.options.update(options)
 
     def get_options(self):
         return self.options
 
-    def get_name(self):
-        if self.handle.has_metadata():
-            name = self.torrent_info.file_at(0).path.split("/", 1)[0]
-            if not name:
-                name = self.torrent_info.name()
-            try:
-                return name.decode("utf8", "ignore")
-            except UnicodeDecodeError:
-                return name
-        elif self.magnet:
-            try:
-                keys = dict([k.split('=') for k in self.magnet.split('?')[-1].split('&')])
-                name = keys.get('dn')
-                if not name:
-                    return self.torrent_id
-                name = unquote(name).replace('+', ' ')
-                try:
-                    return name.decode("utf8", "ignore")
-                except UnicodeDecodeError:
-                    return name
-            except:
-                pass
-        return self.torrent_id
-
-    def set_owner(self, account):
-        self.owner = account
 
     def set_max_connections(self, max_connections):
         self.options["max_connections"] = int(max_connections)
@@ -304,30 +252,14 @@ class Torrent(object):
 
     def set_prioritize_first_last(self, prioritize):
         self.options["prioritize_first_last_pieces"] = prioritize
-        if self.handle.has_metadata():
-            if self.options["compact_allocation"]:
-                log.debug("Setting first/last priority with compact "
-                          "allocation does not work!")
-                return
-
-            paths = {}
-            ti = self.handle.get_torrent_info()
-            for n in range(ti.num_pieces()):
-                slices = ti.map_block(n, 0, ti.piece_size(n))
-                for slice in slices:
-                    fe = ti.file_at(slice.file_index)
-                    paths.setdefault(fe.path, []).append(n)
-
-            priorities = self.handle.piece_priorities()
-            for pieces in paths.itervalues():
-                two_percent = 2*100/len(pieces)
-                for piece in pieces[:two_percent]+pieces[-two_percent:]:
-                    priorities[piece] = prioritize and 7 or 1
-            self.handle.prioritize_pieces(priorities)
-
-    def set_sequential_download(self, set_sequencial):
-        self.options["sequential_download"] = set_sequencial
-        self.handle.set_sequential_download(set_sequencial)
+        if prioritize:
+            if self.handle.has_metadata():
+                if self.handle.get_torrent_info().num_files() == 1:
+                    # We only do this if one file is in the torrent
+                    priorities = [1] * self.handle.get_torrent_info().num_pieces()
+                    priorities[0] = 7
+                    priorities[-1] = 7
+                    self.handle.prioritize_pieces(priorities)
 
     def set_auto_managed(self, auto_managed):
         self.options["auto_managed"] = auto_managed
@@ -344,14 +276,8 @@ class Torrent(object):
     def set_remove_at_ratio(self, remove_at_ratio):
         self.options["remove_at_ratio"] = remove_at_ratio
 
-    def set_move_completed(self, move_completed):
-        self.options["move_completed"] = move_completed
-
-    def set_move_completed_path(self, move_completed_path):
-        self.options["move_completed_path"] = move_completed_path
-
     def set_file_priorities(self, file_priorities):
-        if len(file_priorities) != len(self.get_files()):
+        if len(file_priorities) != len(self.files):
             log.debug("file_priorities len != num_files")
             self.options["file_priorities"] = self.handle.file_priorities()
             return
@@ -390,29 +316,27 @@ class Torrent(object):
                 tracker["tier"] = value.tier
                 trackers.append(tracker)
             self.trackers = trackers
-            self.tracker_host = None
             return
 
         log.debug("Setting trackers for %s: %s", self.torrent_id, trackers)
         tracker_list = []
 
         for tracker in trackers:
-            new_entry = lt.announce_entry(str(tracker["url"]))
+            new_entry = lt.announce_entry(tracker["url"])
             new_entry.tier = tracker["tier"]
             tracker_list.append(new_entry)
+
         self.handle.replace_trackers(tracker_list)
 
         # Print out the trackers
-        #for t in self.handle.trackers():
-        #    log.debug("tier: %s tracker: %s", t["tier"], t["url"])
+        for t in self.handle.trackers():
+            log.debug("tier: %s tracker: %s", t.tier, t.url)
         # Set the tracker list in the torrent object
         self.trackers = trackers
         if len(trackers) > 0:
-            # Force a re-announce if there is at least 1 tracker
+            # Force a reannounce if there is at least 1 tracker
             self.force_reannounce()
 
-        self.tracker_host = None
-
     ### End Options methods ###
 
     def set_save_path(self, save_path):
@@ -428,31 +352,10 @@ class Torrent(object):
         LTSTATE = deluge.common.LT_TORRENT_STATE
         ltstate = int(self.handle.status().state)
 
-        # Set self.state to the ltstate right away just incase we don't hit some
-        # of the logic below
-        if ltstate in LTSTATE:
-            self.state = LTSTATE[ltstate]
-        else:
-            self.state = str(ltstate)
-
         log.debug("set_state_based_on_ltstate: %s", deluge.common.LT_TORRENT_STATE[ltstate])
         log.debug("session.is_paused: %s", component.get("Core").session.is_paused())
-
-        # First we check for an error from libtorrent, and set the state to that
-        # if any occurred.
-        if len(self.handle.status().error) > 0:
-            # This is an error'd torrent
-            self.state = "Error"
-            self.set_status_message(self.handle.status().error)
-            if self.handle.is_paused():
-                self.handle.auto_managed(False)
-            return
-
         if ltstate == LTSTATE["Queued"] or ltstate == LTSTATE["Checking"]:
-            if self.handle.is_paused():
-                self.state = "Paused"
-            else:
-                self.state = "Checking"
+            self.state = "Checking"
             return
         elif ltstate == LTSTATE["Downloading"] or ltstate == LTSTATE["Downloading Metadata"]:
             self.state = "Downloading"
@@ -461,7 +364,12 @@ class Torrent(object):
         elif ltstate == LTSTATE["Allocating"]:
             self.state = "Allocating"
 
-        if self.handle.is_paused() and self.handle.is_auto_managed() and not component.get("Core").session.is_paused():
+        if self.handle.is_paused() and len(self.handle.status().error) > 0:
+            # This is an error'd torrent
+            self.state = "Error"
+            self.set_status_message(self.handle.status().error)
+            self.handle.auto_managed(False)
+        elif self.handle.is_paused() and self.handle.is_auto_managed() and not component.get("Core").session.is_paused():
             self.state = "Queued"
         elif component.get("Core").session.is_paused() or (self.handle.is_paused() and not self.handle.is_auto_managed()):
             self.state = "Paused"
@@ -485,14 +393,15 @@ class Torrent(object):
         else:
             status = self.status
 
-        if self.is_finished and self.options["stop_at_ratio"]:
+        if self.is_finished and (self.options["stop_at_ratio"] or self.config["stop_seed_at_ratio"]):
             # We're a seed, so calculate the time to the 'stop_share_ratio'
             if not status.upload_payload_rate:
                 return 0
-            stop_ratio = self.options["stop_ratio"]
+            stop_ratio = self.config["stop_seed_ratio"] if self.config["stop_seed_at_ratio"] else self.options["stop_ratio"]
+
             return ((status.all_time_download * stop_ratio) - status.all_time_upload) / status.upload_payload_rate
 
-        left = status.total_wanted - status.total_wanted_done
+        left = status.total_wanted - status.total_done
 
         if left <= 0 or status.download_payload_rate == 0:
             return 0
@@ -511,7 +420,9 @@ class Torrent(object):
         else:
             status = self.status
 
-        if status.total_done > 0:
+        if status.all_time_download > 0:
+            downloaded = status.all_time_download
+        elif status.total_done > 0:
             # We use 'total_done' if the downloaded value is 0
             downloaded = status.total_done
         else:
@@ -564,13 +475,13 @@ class Torrent(object):
                     country += c
 
             ret.append({
-                "client": client,
-                "country": country,
-                "down_speed": peer.payload_down_speed,
                 "ip": "%s:%s" % (peer.ip[0], peer.ip[1]),
-                "progress": peer.progress,
+                "up_speed": peer.up_speed,
+                "down_speed": peer.down_speed,
+                "country": country,
+                "client": client,
                 "seed": peer.flags & peer.seed,
-                "up_speed": peer.payload_up_speed,
+                "progress": peer.progress
             })
 
         return ret
@@ -586,7 +497,7 @@ class Torrent(object):
 
         file_progress = self.handle.file_progress()
         ret = []
-        for i,f in enumerate(self.get_files()):
+        for i,f in enumerate(self.files):
             try:
                 ret.append(float(file_progress[i]) / float(f["size"]))
             except ZeroDivisionError:
@@ -597,9 +508,6 @@ class Torrent(object):
     def get_tracker_host(self):
         """Returns just the hostname of the currently connected tracker
         if no tracker is connected, it uses the 1st tracker."""
-        if self.tracker_host:
-            return self.tracker_host
-
         if not self.status:
             self.status = self.handle.status()
 
@@ -608,7 +516,7 @@ class Torrent(object):
             tracker = self.trackers[0]["url"]
 
         if tracker:
-            url = urlparse(tracker.replace("udp://", "http://"))
+            url = urlparse(tracker)
             if hasattr(url, "hostname"):
                 host = (url.hostname or 'DHT')
                 # Check if hostname is an IP address and just return it if that's the case
@@ -623,39 +531,15 @@ class Torrent(object):
 
                 parts = host.split(".")
                 if len(parts) > 2:
-                    if parts[-2] in ("co", "com", "net", "org") or parts[-1] in ("uk"):
+                    if parts[-2] in ("co", "com"):
                         host = ".".join(parts[-3:])
                     else:
                         host = ".".join(parts[-2:])
-                self.tracker_host = host
                 return host
         return ""
 
-    def get_last_seen_complete(self):
-        """
-        Returns the time a torrent was last seen complete, ie, with all pieces
-        available.
-        """
-        if lt.version_minor > 15:
-            return self.status.last_seen_complete
-        self.calculate_last_seen_complete()
-        return self._last_seen_complete
-
-    def get_status(self, keys, diff=False):
-        """
-        Returns the status of the torrent based on the keys provided
-
-        :param keys: the keys to get the status on
-        :type keys: list of str
-        :param diff: if True, will return a diff of the changes since the last
-        call to get_status based on the session_id
-        :type diff: bool
-
-        :returns: a dictionary of the status keys and their values
-        :rtype: dict
-
-        """
-
+    def get_status(self, keys):
+        """Returns the status of the torrent based on the keys provided"""
         # Create the full dictionary
         self.status = self.handle.status()
         if self.handle.has_metadata():
@@ -669,71 +553,59 @@ class Torrent(object):
         if distributed_copies < 0:
             distributed_copies = 0.0
 
-        # Calculate the seeds:peers ratio
-        if self.status.num_incomplete == 0:
-            # Use -1.0 to signify infinity
-            seeds_peers_ratio = -1.0
-        else:
-            seeds_peers_ratio = self.status.num_complete / float(self.status.num_incomplete)
-
+        #if you add a key here->add it to core.py STATUS_KEYS too.
         full_status = {
-            "active_time": self.status.active_time,
-            "all_time_download": self.status.all_time_download,
-            "compact": self.options["compact_allocation"],
             "distributed_copies": distributed_copies,
-            "download_payload_rate": self.status.download_payload_rate,
-            "file_priorities": self.options["file_priorities"],
-            "hash": self.torrent_id,
-            "is_auto_managed": self.options["auto_managed"],
-            "is_finished": self.is_finished,
-            "max_connections": self.options["max_connections"],
-            "max_download_speed": self.options["max_download_speed"],
-            "max_upload_slots": self.options["max_upload_slots"],
-            "max_upload_speed": self.options["max_upload_speed"],
-            "message": self.statusmsg,
-            "move_on_completed_path": self.options["move_completed_path"],
-            "move_on_completed": self.options["move_completed"],
-            "move_completed_path": self.options["move_completed_path"],
-            "move_completed": self.options["move_completed"],
-            "next_announce": self.status.next_announce.seconds,
-            "num_peers": self.status.num_peers - self.status.num_seeds,
-            "num_seeds": self.status.num_seeds,
-            "owner": self.owner,
-            "paused": self.status.paused,
-            "prioritize_first_last": self.options["prioritize_first_last_pieces"],
-            "sequential_download": self.options["sequential_download"],
-            "progress": progress,
-            "shared": self.options["shared"],
-            "remove_at_ratio": self.options["remove_at_ratio"],
-            "save_path": self.options["download_location"],
-            "seeding_time": self.status.seeding_time,
-            "seeds_peers_ratio": seeds_peers_ratio,
-            "seed_rank": self.status.seed_rank,
-            "state": self.state,
-            "stop_at_ratio": self.options["stop_at_ratio"],
-            "stop_ratio": self.options["stop_ratio"],
-            "time_added": self.time_added,
             "total_done": self.status.total_done,
+            "total_uploaded": self.status.all_time_upload,
+            "all_time_download": self.status.all_time_download,
+            "state": self.state,
+            "paused": self.status.paused,
+            "progress": progress,
+            "next_announce": self.status.next_announce.seconds,
             "total_payload_download": self.status.total_payload_download,
             "total_payload_upload": self.status.total_payload_upload,
-            "total_peers": self.status.list_peers - self.status.list_seeds,
-            "total_seeds":  self.status.list_seeds,
-            "total_uploaded": self.status.all_time_upload,
+            "download_payload_rate": self.status.download_payload_rate,
+            "upload_payload_rate": self.status.upload_payload_rate,
+            "num_peers": self.status.num_peers - self.status.num_seeds,
+            "num_seeds": self.status.num_seeds,
+            "total_peers": self.status.num_incomplete,
+            "total_seeds":  self.status.num_complete,
             "total_wanted": self.status.total_wanted,
             "tracker": self.status.current_tracker,
             "trackers": self.trackers,
             "tracker_status": self.tracker_status,
-            "upload_payload_rate": self.status.upload_payload_rate
+            "save_path": self.options["download_location"],
+            "files": self.files,
+            "file_priorities": self.options["file_priorities"],
+            "compact": self.options["compact_allocation"],
+            "max_connections": self.options["max_connections"],
+            "max_upload_slots": self.options["max_upload_slots"],
+            "max_upload_speed": self.options["max_upload_speed"],
+            "max_download_speed": self.options["max_download_speed"],
+            "prioritize_first_last": self.options["prioritize_first_last_pieces"],
+            "message": self.statusmsg,
+            "hash": self.torrent_id,
+            "active_time": self.status.active_time,
+            "seeding_time": self.status.seeding_time,
+            "seed_rank": self.status.seed_rank,
+            "is_auto_managed": self.options["auto_managed"],
+            "stop_ratio": self.options["stop_ratio"],
+            "stop_at_ratio": self.options["stop_at_ratio"],
+            "remove_at_ratio": self.options["remove_at_ratio"],
+            "move_on_completed": self.options["move_completed"],
+            "move_on_completed_path": self.options["move_completed_path"],
+            "time_added": self.time_added
         }
 
-        def ti_comment():
+        def ti_name():
             if self.handle.has_metadata():
                 try:
-                    return self.torrent_info.comment().decode("utf8", "ignore")
+                    return self.torrent_info.name().decode("utf8", "ignore")
                 except UnicodeDecodeError:
-                    return self.torrent_info.comment()
-            return ""
+                    return self.torrent_info.name()
 
+            return self.torrent_id
         def ti_priv():
             if self.handle.has_metadata():
                 return self.torrent_info.priv()
@@ -754,29 +626,21 @@ class Torrent(object):
             if self.handle.has_metadata():
                 return self.torrent_info.piece_length()
             return 0
-        def ti_pieces_info():
-            if self.handle.has_metadata():
-                return self.get_pieces_info()
-            return None
 
         fns = {
-            "comment": ti_comment,
-            "eta": self.get_eta,
-            "file_progress": self.get_file_progress,
-            "files": self.get_files,
-            "is_seed": self.handle.is_seed,
-            "name": self.get_name,
+            "name": ti_name,
+            "private": ti_priv,
+            "total_size": ti_total_size,
             "num_files": ti_num_files,
             "num_pieces": ti_num_pieces,
-            "pieces": ti_pieces_info,
-            "peers": self.get_peers,
             "piece_length": ti_piece_length,
-            "private": ti_priv,
-            "queue": self.handle.queue_position,
+            "eta": self.get_eta,
             "ratio": self.get_ratio,
-            "total_size": ti_total_size,
-            "tracker_host": self.get_tracker_host,
-            "last_seen_complete": self.get_last_seen_complete
+            "file_progress": self.get_file_progress,
+            "queue": self.handle.queue_position,
+            "is_seed": self.handle.is_seed,
+            "peers": self.get_peers,
+            "tracker_host": self.get_tracker_host
         }
 
         # Create the desired status dictionary and return it
@@ -793,24 +657,6 @@ class Torrent(object):
                 elif key in fns:
                     status_dict[key] = fns[key]()
 
-        session_id = self.rpcserver.get_session_id()
-        if diff:
-            if session_id in self.prev_status:
-                # We have a previous status dict, so lets make a diff
-                status_diff = {}
-                for key, value in status_dict.items():
-                    if key in self.prev_status[session_id]:
-                        if value != self.prev_status[session_id][key]:
-                            status_diff[key] = value
-                    else:
-                        status_diff[key] = value
-
-                self.prev_status[session_id] = status_dict
-                return status_diff
-
-            self.prev_status[session_id] = status_dict
-            return status_dict
-
         return status_dict
 
     def apply_options(self):
@@ -820,7 +666,6 @@ class Torrent(object):
         self.handle.set_upload_limit(int(self.max_upload_speed * 1024))
         self.handle.set_download_limit(int(self.max_download_speed * 1024))
         self.handle.prioritize_files(self.file_priorities)
-        self.handle.set_sequential_download(self.options["sequential_download"])
         self.handle.resolve_countries(True)
 
     def pause(self):
@@ -833,7 +678,7 @@ class Torrent(object):
             # show it as 'Paused'.  We need to emit a torrent_paused signal because
             # the torrent_paused alert from libtorrent will not be generated.
             self.update_state()
-            component.get("EventManager").emit(TorrentStateChangedEvent(self.torrent_id, "Paused"))
+            self.signals.emit("torrent_paused", self.torrent_id)
         else:
             try:
                 self.handle.pause()
@@ -855,10 +700,14 @@ class Torrent(object):
 
             if self.handle.is_finished():
                 # If the torrent has already reached it's 'stop_seed_ratio' then do not do anything
-                if self.options["stop_at_ratio"]:
-                    if self.get_ratio() >= self.options["stop_ratio"]:
-                        #XXX: This should just be returned in the RPC Response, no event
-                        #self.signals.emit_event("torrent_resume_at_stop_ratio")
+                if self.config["stop_seed_at_ratio"] or self.options["stop_at_ratio"]:
+                    if self.options["stop_at_ratio"]:
+                        ratio = self.options["stop_ratio"]
+                    else:
+                        ratio = self.config["stop_seed_ratio"]
+
+                    if self.get_ratio() >= ratio:
+                        self.signals.emit("torrent_resume_at_stop_ratio")
                         return
 
             if self.options["auto_managed"]:
@@ -883,27 +732,8 @@ class Torrent(object):
 
     def move_storage(self, dest):
         """Move a torrent's storage location"""
-
-        # Attempt to convert utf8 path to unicode
-        # Note: Inconsistent encoding for 'dest', needs future investigation
         try:
-            dest_u = unicode(dest, "utf-8")
-        except TypeError:
-            # String is already unicode
-            dest_u = dest
-
-        if not os.path.exists(dest_u):
-            try:
-                # Try to make the destination path if it doesn't exist
-                os.makedirs(dest_u)
-            except IOError, e:
-                log.exception(e)
-                log.error("Could not move storage for torrent %s since %s does "
-                          "not exist and could not create the directory.",
-                          self.torrent_id, dest_u)
-                return False
-        try:
-            self.handle.move_storage(dest_u)
+            self.handle.move_storage(dest.encode("utf8"))
         except:
             return False
 
@@ -915,17 +745,44 @@ class Torrent(object):
         self.handle.save_resume_data()
         self.waiting_on_resume_data = True
 
+    def write_resume_data(self, resume_data):
+        """Writes the .fastresume file for the torrent"""
+        resume_data = lt.bencode(resume_data)
+        path = "%s/%s.fastresume" % (
+            self.config["state_location"],
+            self.torrent_id)
+        try:
+            self.delete_fastresume()
+            log.debug("Saving fastresume file: %s", path)
+            fastresume = open(path, "wb")
+            fastresume.write(resume_data)
+            fastresume.close()
+        except IOError:
+            log.warning("Error trying to save fastresume file")
+
+        self.waiting_on_resume_data = False
+
+    def delete_fastresume(self):
+        """Deletes the .fastresume file"""
+        path = "%s/%s.fastresume" % (
+            self.config["state_location"],
+            self.torrent_id)
+        log.debug("Deleting fastresume file: %s", path)
+        try:
+            os.remove(path)
+        except Exception, e:
+            log.warning("Unable to delete the fastresume file: %s", e)
+
     def write_torrentfile(self):
         """Writes the torrent file"""
         path = "%s/%s.torrent" % (
-            os.path.join(get_config_dir(), "state"),
+            self.config["state_location"],
             self.torrent_id)
         log.debug("Writing torrent file: %s", path)
         try:
-            self.torrent_info = self.handle.get_torrent_info()
-            # Regenerate the file priorities
-            self.set_file_priorities([])
-            md = lt.bdecode(self.torrent_info.metadata())
+            ti = self.handle.get_torrent_info()
+            md = lt.bdecode(ti.metadata())
+            log.debug("md: %s", md)
             torrent_file = {}
             torrent_file["info"] = md
             open(path, "wb").write(lt.bencode(torrent_file))
@@ -935,7 +792,7 @@ class Torrent(object):
     def delete_torrentfile(self):
         """Deletes the .torrent file in the state"""
         path = "%s/%s.torrent" % (
-            os.path.join(get_config_dir(), "state"),
+            self.config["state_location"],
             self.torrent_id)
         log.debug("Deleting torrent file: %s", path)
         try:
@@ -965,23 +822,18 @@ class Torrent(object):
 
     def force_recheck(self):
         """Forces a recheck of the torrents pieces"""
-        paused = self.handle.is_paused()
         try:
             self.handle.force_recheck()
-            self.handle.resume()
         except Exception, e:
             log.debug("Unable to force recheck: %s", e)
             return False
-        self.forcing_recheck = True
-        self.forcing_recheck_paused = paused
         return True
 
     def rename_files(self, filenames):
         """Renames files in the torrent. 'filenames' should be a list of
         (index, filename) pairs."""
         for index, filename in filenames:
-            filename = sanitize_filepath(filename)
-            self.handle.rename_file(index, filename.encode("utf-8"))
+            self.handle.rename_file(index, filename)
 
     def rename_folder(self, folder, new_folder):
         """Renames a folder within a torrent.  This basically does a file rename
@@ -991,71 +843,13 @@ class Torrent(object):
             log.error("Attempting to rename a folder with an invalid folder name: %s", new_folder)
             return
 
-        new_folder = sanitize_filepath(new_folder, folder=True)
+        if new_folder[-1:] != "/":
+            new_folder += "/"
 
         wait_on_folder = (folder, new_folder, [])
         for f in self.get_files():
             if f["path"].startswith(folder):
                 # Keep a list of filerenames we're waiting on
                 wait_on_folder[2].append(f["index"])
-                self.handle.rename_file(f["index"], f["path"].replace(folder, new_folder, 1).encode("utf-8"))
+                self.handle.rename_file(f["index"], f["path"].replace(folder, new_folder, 1))
         self.waiting_on_folder_rename.append(wait_on_folder)
-
-    def cleanup_prev_status(self):
-        """
-        This method gets called to check the validity of the keys in the prev_status
-        dict.  If the key is no longer valid, the dict will be deleted.
-
-        """
-        for key in self.prev_status.keys():
-            if not self.rpcserver.is_session_valid(key):
-                del self.prev_status[key]
-
-    def calculate_last_seen_complete(self):
-        if self._last_seen_complete+60 > time.time():
-            # Simple caching. Only calculate every 1 min at minimum
-            return self._last_seen_complete
-
-        availability = self.handle.piece_availability()
-        if filter(lambda x: x<1, availability):
-            # Torrent does not have all the pieces
-            return
-        log.trace("Torrent %s has all the pieces. Setting last seen complete.",
-                  self.torrent_id)
-        self._last_seen_complete = time.time()
-
-    def get_pieces_info(self):
-        pieces = {}
-        # First get the pieces availability.
-        availability = self.handle.piece_availability()
-        # Pieces from connected peers
-        for peer_info in self.handle.get_peer_info():
-            if peer_info.downloading_piece_index < 0:
-                # No piece index, then we're not downloading anything from
-                # this peer
-                continue
-            pieces[peer_info.downloading_piece_index] = 2
-
-        # Now, the rest of the pieces
-        for idx, piece in enumerate(self.handle.status().pieces):
-            if idx in pieces:
-                # Piece beeing downloaded, handled above
-                continue
-            elif piece:
-                # Completed Piece
-                pieces[idx] = 3
-                continue
-            elif availability[idx] > 0:
-                # Piece not downloaded nor beeing downloaded but available
-                pieces[idx] = 1
-                continue
-            # If we reached here, it means the piece is missing, ie, there's
-            # no known peer with this piece, or this piece has not been asked
-            # for so far.
-            pieces[idx] = 0
-
-        sorted_indexes = pieces.keys()
-        sorted_indexes.sort()
-        # Return only the piece states, no need for the piece index
-        # Keep the order
-        return [pieces[idx] for idx in sorted_indexes]

deluge/data/GEOIP_LICENSE.txt

@@ -0,0 +1,39 @@
+There are two licenses, one for the C library software, and one for
+the database.
+
+SOFTWARE LICENSE (C library)
+
+The GeoIP C Library is licensed under the LGPL.  For details see
+the COPYING file.
+
+OPEN DATA LICENSE (GeoLite Country and GeoLite City databases)
+
+Copyright (c) 2008 MaxMind, Inc.  All Rights Reserved.
+
+All advertising materials and documentation mentioning features or use of
+this database must display the following acknowledgment:
+"This product includes GeoLite data created by MaxMind, available from
+http://maxmind.com/"
+
+Redistribution and use with or without modification, are permitted provided
+that the following conditions are met:
+1. Redistributions must retain the above copyright notice, this list of
+conditions and the following disclaimer in the documentation and/or other
+materials provided with the distribution. 
+2. All advertising materials and documentation mentioning features or use of
+this database must display the following acknowledgement:
+"This product includes GeoLite data created by MaxMind, available from
+http://maxmind.com/"
+3. "MaxMind" may not be used to endorse or promote products derived from this
+database without specific prior written permission.
+
+THIS DATABASE IS PROVIDED BY MAXMIND, INC ``AS IS'' AND ANY 
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
+DISCLAIMED. IN NO EVENT SHALL MAXMIND BE LIABLE FOR ANY 
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
+DATABASE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.