codex-storage
/
deluge
mirror of https://github.com/codex-storage/deluge.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

big client.py refactor

This commit is contained in:
Martijn Voncken 2008-02-22 22:16:13 +00:00
parent 21c4025a7b
commit d53a606b0e
23 changed files with 257 additions and 242 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
deluge/plugins/queue/queue/ui.py
View File

@ -34,7 +34,7 @@
import gettext
import locale
import pkg_resources
import deluge.ui.client as client
from deluge.ui.client import aclient as client
from deluge.log import LOG as log
class UI:
@ -78,7 +78,7 @@ class UI:
torrent_ids = self.plugin.get_selected_torrents()
for torrent_id in torrent_ids:
try:
client.get_core().queue_queue_top(torrent_id)
client.queue_queue_top(torrent_id)
except Exception, e:
log.debug("Unable to queue top torrent: %s", e)
return
@ -89,7 +89,7 @@ class UI:
torrent_ids = self.plugin.get_selected_torrents()
for torrent_id in torrent_ids:
try:
client.get_core().queue_queue_up(torrent_id)
client.queue_queue_up(torrent_id)
except Exception, e:
log.debug("Unable to queue up torrent: %s", e)
return
@ -100,7 +100,7 @@ class UI:
torrent_ids = self.plugin.get_selected_torrents()
for torrent_id in torrent_ids:
try:
client.get_core().queue_queue_down(torrent_id)
client.queue_queue_down(torrent_id)
except Exception, e:
log.debug("Unable to queue down torrent: %s", e)
return
@ -111,7 +111,7 @@ class UI:
torrent_ids = self.plugin.get_selected_torrents()
for torrent_id in torrent_ids:
try:
client.get_core().queue_queue_bottom(torrent_id)
client.queue_queue_bottom(torrent_id)
except Exception, e:
log.debug("Unable to queue bottom torrent: %s", e)
return

349
deluge/ui/client.py
View File

@ -1,7 +1,8 @@
#
# client.py
#
# Copyright (C) 2007 Andrew Resch ('andar') <andrewresch@gmail.com>
# Copyright (C) 2007/2008 Andrew Resch ('andar') <andrewresch@gmail.com>
# Copyright (C) 2008 Martijn Voncken <mvoncken@gmail.com>
#
# Deluge is free software.
#
@ -55,14 +56,14 @@ class CoreProxy(gobject.GObject):
log.debug("CoreProxy init..")
gobject.GObject.__init__(self)
self._uri = None
self._core = None
self.rpc_core = None
self._multi = None
self._callbacks = []
self._multi_timer = None
def call(self, func, callback, *args):
if self._core is None or self._multi is None:
if self.get_core() is None:
if self.rpc_core is None or self._multi is None:
if self.rpc_core is None:
raise deluge.error.NoCoreError("The core proxy is invalid.")
return
_func = getattr(self._multi, func)
@ -84,7 +85,7 @@ class CoreProxy(gobject.GObject):
if len(self._callbacks) == 0:
return True
if self._multi is not None and self._core is not None:
if self._multi is not None and self.rpc_core is not None:
try:
try:
for i, ret in enumerate(self._multi()):
@ -102,7 +103,7 @@ class CoreProxy(gobject.GObject):
finally:
self._callbacks = []
self._multi = xmlrpclib.MultiCall(self._core)
self._multi = xmlrpclib.MultiCall(self.rpc_core)
return True
def set_core_uri(self, uri):
@ -110,7 +111,7 @@ class CoreProxy(gobject.GObject):
if uri == None and self._uri != None:
self._uri = None
self._core = None
self.rpc_core = None
self._multi = None
try:
gobject.source_remove(self._multi_timer)
@ -120,7 +121,7 @@ class CoreProxy(gobject.GObject):
return
if uri != self._uri and self._uri != None:
self._core = None
self.rpc_core = None
self._multi = None
try:
gobject.source_remove(self._multi_timer)
@ -130,85 +131,68 @@ class CoreProxy(gobject.GObject):
self._uri = uri
# Get a new core
self.get_core()
self.get_rpc_core()
def get_core_uri(self):
"""Returns the URI of the core currently being used."""
return self._uri
def get_core(self):
if self._core is None and self._uri is not None:
def get_rpc_core(self):
if self.rpc_core is None and self._uri is not None:
log.debug("Creating ServerProxy..")
self._core = xmlrpclib.ServerProxy(self._uri, allow_none=True)
self._multi = xmlrpclib.MultiCall(self._core)
self.rpc_core = xmlrpclib.ServerProxy(self._uri, allow_none=True)
self._multi = xmlrpclib.MultiCall(self.rpc_core)
self._multi_timer = gobject.timeout_add(200, self.do_multicall)
# Call any callbacks registered
self.emit("new_core")
return self._core
return self.rpc_core
_core = CoreProxy()
def get_core():
"""Get the core object and return it"""
return _core
class BaseClient(object):
"""
wraps all calls to core/coreproxy
base for AClient and SClient
"""
no_callback_list = [ "add_torrent_url", "pause_all_torrents",
"resume_all_torrent", "set_config", "enable_plugin",
"disable_plugin", "set_torrent_trackers",
"set_torrent_max_connections", "set_torrent_max_upload_slots",
"set_torrent_max_upload_speed", "set_torrent_max_download_speed",
"set_torrent_private_flag", "set_torrent_file_priorities",
"block_ip_range",
"remove_torrent", "pause_torrent", "move_torrent" ,
"resume_torrent","force_reannounce", "force_recheck",
"deregister_client","register_client",
"add_torrent_file"]
def connect_on_new_core(callback):
"""Connect a callback whenever a new core is connected to."""
return _core.connect("new_core", callback)
def __init__(self):
self.core = _core
def connect_on_no_core(callback):
"""Connect a callback whenever the core is disconnected from."""
return _core.connect("no_core", callback)
#xml-rpc introspection
def list_methods(self):
registered = self.core.rpc_core.system.listMethods( )
return sorted(registered)
def set_core_uri(uri):
"""Sets the core uri"""
return _core.set_core_uri(uri)
def methodSignature(self, method_name):
"broken :("
return self.core.rpc_core.system.methodSignature(method_name)
def get_core_uri():
"""Get the core URI"""
return _core.get_core_uri()
def methodHelp(self, method_name):
return self.core.rpc_core.system.methodHelp(method_name)
def is_localhost():
"""Returns True if core is a localhost"""
# Get the uri
uri = _core.get_core_uri()
if uri != None:
# Get the host
host = uri[7:].split(":")[0]
if host == "localhost" or host == "127.0.0.1":
return True
#wrappers, getattr
def get_method(self, method_name):
"Override this in subclass."
raise NotImplementedError()
return False
def __getattr__(self, method_name):
return self.get_method(method_name)
#raise AttributeError("no attr/method named:%s" % attr)
def connected():
"""Returns True if connected to a host, and False if not."""
if get_core_uri() != None:
return True
return False
def shutdown():
"""Shutdown the core daemon"""
try:
get_core().call("shutdown", None)
force_call(block=False)
finally:
set_core_uri(None)
def force_call(block=True):
"""Forces the multicall batch to go now and not wait for the timer. This
call also blocks until all callbacks have been dealt with."""
get_core().do_multicall(block=block)
## Core methods ##
def register_client(port):
get_core().call("register_client", None, port)
def deregister_client():
get_core().call("deregister_client", None)
def add_torrent_file(torrent_files, torrent_options=None):
#custom wrapped methods:
def add_torrent_file(self, torrent_files, torrent_options=None):
"""Adds torrent files to the core
Expects a list of torrent files
A list of torrent_option dictionaries in the same order of torrent_files
@ -239,131 +223,162 @@ def add_torrent_file(torrent_files, torrent_options=None):
options = None
else:
options = None
self.get_method("add_torrent_file")(filename, fdump, options)
get_core().call("add_torrent_file", None,
filename, fdump, options)
#utility:
def has_callback(self, method_name):
return (method_name in self.no_callback_list)
def add_torrent_url(torrent_url, options=None):
"""Adds torrents to the core via url"""
from deluge.common import is_url
if is_url(torrent_url):
get_core().call("add_torrent_url", None,
torrent_url, str(), options)
def is_localhost(self):
"""Returns True if core is a localhost"""
# Get the uri
uri = self.core.get_core_uri()
if uri != None:
# Get the host
host = uri[7:].split(":")[0]
if host == "localhost" or host == "127.0.0.1":
return True
return False
def get_core_uri(self):
"""Get the core URI"""
return self.core.get_core_uri()
def set_core_uri(self, uri = 'http://localhost:58846'):
"""Sets the core uri"""
return self.core.set_core_uri(uri)
def connected(self):
"""Returns True if connected to a host, and False if not."""
if self.get_core_uri() != None:
return True
return False
def shutdown(self):
"""Shutdown the core daemon"""
try:
self.core.call("shutdown", None)
self.core.force_call(block=False)
finally:
self.set_core_uri(None)
#events:
def connect_on_new_core(self, callback):
"""Connect a callback whenever a new core is connected to."""
return self.core.connect("new_core", callback)
def connect_on_no_core(self, callback):
"""Connect a callback whenever the core is disconnected from."""
return self.core.connect("no_core", callback)
class SClient(BaseClient):
"""
sync proxy
"""
def get_method(self, method_name):
return getattr(self.core.rpc_core, method_name)
class AClient(BaseClient):
"""
async proxy
"""
def get_method(self, method_name):
if self.has_callback(method_name):
def async_proxy_nocb(*args, **kwargs):
return self.core.call(method_name,None, *args, **kwargs)
return async_proxy_nocb
else:
log.warning("Invalid URL %s", torrent_url)
def async_proxy(*args, **kwargs):
return self.core.call(method_name, *args, **kwargs)
return async_proxy
def remove_torrent(torrent_ids, remove_torrent=False, remove_data=False):
"""Removes torrent_ids from the core.. Expects a list of torrent_ids"""
log.debug("Attempting to remove torrents: %s", torrent_ids)
get_core().call("remove_torrent", None, torrent_ids, remove_torrent, remove_data)
def force_call(self, block=True):
"""Forces the multicall batch to go now and not wait for the timer. This
call also blocks until all callbacks have been dealt with."""
self.core.do_multicall(block=block)
def pause_torrent(torrent_ids):
"""Pauses torrent_ids"""
get_core().call("pause_torrent", None, torrent_ids)
sclient = SClient()
aclient = AClient()
def move_torrent(torrent_ids, folder):
"""Pauses torrent_ids"""
get_core().call("move_torrent", None, torrent_ids, folder)
#------------------------------------------------------------------------------
#tests:
#------------------------------------------------------------------------------
def pause_all_torrents():
"""Pauses all torrents"""
get_core().call("pause_all_torrents", None)
def test_introspection():
print "*start introspection test*"
sclient.set_core_uri()
print "list_methods", sclient.list_methods()
print "sig of block_ip_range", sclient.methodSignature('block_ip_range')
print "doc of block_ip_range", sclient.methodHelp('block_ip_range')
def resume_all_torrents():
"""Resumes all torrents"""
get_core().call("resume_all_torrents", None)
def test_sync():
print "*start sync test*"
sclient.set_core_uri()
def resume_torrent(torrent_ids):
"""Resume torrent_ids"""
get_core().call("resume_torrent", None, torrent_ids)
#get list of torrents and display the 1st.
torrent_ids = sclient.get_session_state()
print "session_state():", torrent_ids
print ("get_torrent_status(%s):" % torrent_ids[0],
sclient.get_torrent_status(torrent_ids[0], []))
def force_reannounce(torrent_ids):
"""Reannounce to trackers"""
get_core().call("force_reannounce", None, torrent_ids)
sclient.pause_torrent(torrent_ids)
def get_torrent_status(callback, torrent_id, keys):
"""Builds the status dictionary and returns it"""
get_core().call("get_torrent_status", callback, torrent_id, keys)
print "paused:", [
sclient.get_torrent_status(id, ['paused'])['paused']
for id in torrent_ids]
def get_torrents_status(callback, torrent_ids, keys):
"""Builds a dictionary of torrent_ids status. Expects 2 lists. This is
asynchronous so the return value will be sent as the signal
'torrent_status'"""
get_core().call("get_torrents_status", callback, torrent_ids, keys)
sclient.resume_torrent(torrent_ids)
print "resumed:", [
sclient.get_torrent_status(id, ['paused'])['paused']
for id in torrent_ids]
def get_session_state(callback):
get_core().call("get_session_state", callback)
def test_async():
print "*start async test*"
torrent_ids = []
def get_config(callback):
get_core().call("get_config", callback)
#callbacks:
def cb_session_state(temp_torrent_list):
print "session_state:" , temp_torrent_list
torrent_ids.extend(temp_torrent_list)
def get_config_value(callback, key):
get_core().call("get_config_value", callback, key)
def cb_torrent_status_full(status):
print "\ntorrent_status_full=", status
def set_config(config):
if config == {}:
return
get_core().call("set_config", None, config)
def cb_torrent_status_paused(torrent_state):
print "(paused=%s)," % torrent_state['paused'],
def get_listen_port(callback):
get_core().call("get_listen_port", callback)
#/callbacks
def get_available_plugins(callback):
get_core().call("get_available_plugins", callback)
aclient.set_core_uri()
aclient.get_session_state(cb_session_state)
def get_enabled_plugins(callback):
get_core().call("get_enabled_plugins", callback)
print "force_call 1"
aclient.force_call(block=True)
print "end force_call 1:", len(torrent_ids)
def get_download_rate(callback):
get_core().call("get_download_rate", callback)
def get_upload_rate(callback):
get_core().call("get_upload_rate", callback)
#has_callback+multicall
aclient.pause_torrent(torrent_ids)
aclient.force_call(block=True)
for id in torrent_ids:
aclient.get_torrent_status(cb_torrent_status_paused, id , ['paused'])
def get_num_connections(callback):
get_core().call("get_num_connections", callback)
aclient.get_torrent_status(cb_torrent_status_full, torrent_ids[0], [])
def get_dht_nodes(callback):
get_core().call("get_dht_nodes", callback)
print "force_call 2"
aclient.force_call(block=True)
print "end force-call 2"
def enable_plugin(plugin):
get_core().call("enable_plugin", None, plugin)
def disable_plugin(plugin):
get_core().call("disable_plugin", None, plugin)
def force_recheck(torrent_ids):
"""Forces a data recheck on torrent_ids"""
get_core().call("force_recheck", None, torrent_ids)
print "resume:"
aclient.resume_torrent(torrent_ids)
for id in torrent_ids:
aclient.get_torrent_status(cb_torrent_status_paused, id , ['paused'])
def set_torrent_trackers(torrent_id, trackers):
"""Sets the torrents trackers"""
get_core().call("set_torrent_trackers", None, torrent_id, trackers)
aclient.force_call(block=True)
def set_torrent_max_connections(torrent_id, value):
"""Sets a torrents max number of connections"""
get_core().call("set_torrent_max_connections", None, torrent_id, value)
def set_torrent_max_upload_slots(torrent_id, value):
"""Sets a torrents max number of upload slots"""
get_core().call("set_torrent_max_upload_slots", None, torrent_id, value)
def set_torrent_max_upload_speed(torrent_id, value):
"""Sets a torrents max upload speed"""
get_core().call("set_torrent_max_upload_speed", None, torrent_id, value)
def set_torrent_max_download_speed(torrent_id, value):
"""Sets a torrents max download speed"""
get_core().call("set_torrent_max_download_speed", None, torrent_id, value)
def set_torrent_private_flag(torrent_id, value):
"""Sets a torrents private flag"""
get_core().call("set_torrent_private_flag", None, torrent_id, value)
def set_torrent_file_priorities(torrent_id, priorities):
"""Sets a torrents file priorities"""
get_core().call("set_torrent_file_priorities", None, torrent_id, priorities)
def block_ip_range(range):
"""Blocks a ip range.. (start, end)"""
get_core().call("block_ip_range", None, range)
if __name__ == "__main__":
test_introspection()
test_sync()
test_async()

2
deluge/ui/gtkui/aboutdialog.py
View File

@ -37,7 +37,7 @@ import gtk
import pkg_resources
import deluge.common
import deluge.ui.client as client
from deluge.ui.client import aclient as client
class AboutDialog:
def __init__(self):

2
deluge/ui/gtkui/addtorrentdialog.py
View File

@ -38,7 +38,7 @@ import gettext
import pkg_resources
import deluge.ui.client as client
from deluge.ui.client import aclient as client
import deluge.component as component
import deluge.ui.gtkui.listview as listview
from deluge.configmanager import ConfigManager

2
deluge/ui/gtkui/connectionmanager.py
View File

@ -42,7 +42,7 @@ import threading
import deluge.component as component
import deluge.xmlrpclib as xmlrpclib
import deluge.common
import deluge.ui.client as client
from deluge.ui.client import aclient as client
from deluge.configmanager import ConfigManager
from deluge.log import LOG as log

2
deluge/ui/gtkui/coreconfig.py
View File

@ -32,7 +32,7 @@
# statement from all source files in the program, then also delete it here.
import deluge.component as component
import deluge.ui.client as client
from deluge.ui.client import aclient as client
from deluge.log import LOG as log
class CoreConfig(component.Component):

2
deluge/ui/gtkui/dbusinterface.py
View File

@ -46,7 +46,7 @@ elif dbus.version >= (0,80,0):
DBusGMainLoop(set_as_default=True)
import deluge.component as component
import deluge.ui.client as client
from deluge.ui.client import aclient as client
import deluge.common
from deluge.log import LOG as log

2
deluge/ui/gtkui/edittrackersdialog.py
View File

@ -35,7 +35,7 @@ import gtk, gtk.glade
import pkg_resources
import deluge.common
import deluge.ui.client as client
from deluge.ui.client import aclient as client
import deluge.component as component
from deluge.log import LOG as log

2
deluge/ui/gtkui/gtkui.py
View File

@ -44,7 +44,7 @@ import pkg_resources
import signal
import deluge.component as component
import deluge.ui.client as client
from deluge.ui.client import aclient as client
from mainwindow import MainWindow
from menubar import MenuBar
from toolbar import ToolBar

2
deluge/ui/gtkui/mainwindow.py
View File

@ -37,7 +37,7 @@ import gtk, gtk.glade
import gobject
import pkg_resources
import deluge.ui.client as client
from deluge.ui.client import aclient as client
import deluge.component as component
from deluge.configmanager import ConfigManager

2
deluge/ui/gtkui/menubar.py
View File

@ -37,7 +37,7 @@ import gtk, gtk.glade
import pkg_resources
import deluge.component as component
import deluge.ui.client as client
from deluge.ui.client import aclient as client
import deluge.common as common
from deluge.log import LOG as log

2
deluge/ui/gtkui/pluginmanager.py
View File

@ -33,7 +33,7 @@
import deluge.component as component
import deluge.pluginmanagerbase
import deluge.ui.client as client
from deluge.ui.client import aclient as client
from deluge.configmanager import ConfigManager
from deluge.log import LOG as log

2
deluge/ui/gtkui/preferences.py
View File

@ -38,7 +38,7 @@ import pkg_resources
import deluge.component as component
from deluge.log import LOG as log
import deluge.ui.client as client
from deluge.ui.client import aclient as client
import deluge.common
from deluge.configmanager import ConfigManager

2
deluge/ui/gtkui/queuedtorrents.py
View File

@ -38,7 +38,7 @@ import gobject
import pkg_resources
import deluge.component as component
import deluge.ui.client as client
from deluge.ui.client import aclient as client
import deluge.common
from deluge.configmanager import ConfigManager
from deluge.log import LOG as log

2
deluge/ui/gtkui/removetorrentdialog.py
View File

@ -35,7 +35,7 @@ import gtk, gtk.glade
import pkg_resources
import deluge.common
import deluge.ui.client as client
from deluge.ui.client import aclient as client
import deluge.component as component
from deluge.log import LOG as log

2
deluge/ui/gtkui/signals.py
View File

@ -32,7 +32,7 @@
# statement from all source files in the program, then also delete it here.
import deluge.component as component
import deluge.ui.client as client
from deluge.ui.client import aclient as client
from deluge.ui.signalreceiver import SignalReceiver
from deluge.log import LOG as log

2
deluge/ui/gtkui/statusbar.py
View File

@ -35,7 +35,7 @@ import gtk
import deluge.component as component
import deluge.common
import deluge.ui.client as client
from deluge.ui.client import aclient as client
from deluge.log import LOG as log
class StatusBarItem:

2
deluge/ui/gtkui/systemtray.py
View File

@ -35,7 +35,7 @@ import gtk
import pkg_resources
import deluge.component as component
import deluge.ui.client as client
from deluge.ui.client import aclient as client
import deluge.common
from deluge.configmanager import ConfigManager
from deluge.log import LOG as log

2
deluge/ui/gtkui/toolbar.py
View File

@ -39,7 +39,7 @@ import gobject
import deluge.component as component
from deluge.log import LOG as log
from deluge.common import TORRENT_STATE
import deluge.ui.client as client
from deluge.ui.client import aclient as client
class ToolBar(component.Component):
def __init__(self):

2
deluge/ui/gtkui/torrentdetails.py
View File

@ -39,7 +39,7 @@ import gtk, gtk.glade
import gettext
import deluge.component as component
import deluge.ui.client as client
from deluge.ui.client import aclient as client
import deluge.common
from deluge.log import LOG as log

2
deluge/ui/gtkui/torrentview.py
View File

@ -44,7 +44,7 @@ import traceback
import deluge.common
import deluge.component as component
import deluge.ui.client as client
from deluge.ui.client import aclient as client
from deluge.log import LOG as log
import deluge.ui.gtkui.listview as listview

2
deluge/ui/null/deluge_shell.py
View File

@ -23,7 +23,7 @@ deluge-shell: Deluge shell.
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301
# USA
import deluge.ui.client as client
from deluge.ui.client import aclient as client
import deluge.common as common
import deluge.error
import readline

2
deluge/ui/signalreceiver.py
View File

@ -37,7 +37,7 @@ import random
import gobject
import deluge.ui.client as client
from deluge.ui.client import aclient as client
import deluge.SimpleXMLRPCServer as SimpleXMLRPCServer
from SocketServer import ThreadingMixIn
import deluge.xmlrpclib as xmlrpclib