# $Id: proxy.py,v 1.20 2011/05/26 20:19:17 edwlan Exp $ # # Copyright (c) 2011 Edward Langley # All rights reserved. # # 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 project's 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 # HOLDER 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. # # import copy import urllib import urlparse import itertools import traceback import random import time import UserDict, collections collections.Mapping.register(UserDict.DictMixin) from hashlib import sha1 import jsonrpc.jsonutil __all__ = ['JSONRPCProxy', 'ProxyEvents'] class NewStyleBaseException(Exception): def _get_message(self): return self._message def _set_message(self, message): self._message = message message = property(_get_message, _set_message) class JSONRPCException(NewStyleBaseException): def __init__(self, rpcError): Exception.__init__(self, rpcError.get('message')) self.data = rpcError.get('data') self.message = rpcError.get('message') self.code = rpcError.get('code') class IDGen(object): def __init__(self): self._hasher = sha1() self._id = 0 def __get__(self, *_, **__): self._id += 1 self._hasher.update(str(self._id)) self._hasher.update(time.ctime()) self._hasher.update(str(random.random)) return self._hasher.hexdigest() class ProxyEvents(object): '''An event handler for JSONRPCProxy''' #: an instance of a class which defines a __get__ method, used to generate a request id IDGen = IDGen() def __init__(self, proxy): '''Allow a subclass to do its own initialization, gets any arguments leftover from __init__''' self.proxy = proxy def get_postdata(self, args, kwargs): '''allow a subclass to modify the method's arguments e.g. if an authentication token is necessary, the subclass can automatically insert it into every call''' return args, kwargs def proc_response(self, data): '''allow a subclass to access the response data before it is returned to the user''' return data inst = lambda x:x() class JSONRPCProxy(object): '''A class implementing a JSON-RPC Proxy. :param str host: The HTTP server hosting the JSON-RPC server :param str path: The path where the JSON-RPC server can be found There are two ways of instantiating this class: - JSONRPCProxy.from_url(url) -- give the absolute url to the JSON-RPC server - JSONRPC(host, path) -- break up the url into smaller parts ''' #: Override this attribute to customize proxy behavior _eventhandler = ProxyEvents def customize(self, eventhandler): self._eventhandler = eventhandler(self) def _transformURL(self, serviceURL, path): if serviceURL[-1] == '/': serviceURL = serviceURL[:-1] if path[0] != '/': path = '/%s'%path if path[-1] != '/' and '?' not in path: path = '%s/'%path return serviceURL, path def _get_postdata(self, args, kwargs): args,kwargs = self._eventhandler.get_postdata(args, kwargs) if kwargs.has_key('__args'): raise ValueError, 'invalid argument name: __args' kwargs['__args'] = args or () postdata = jsonrpc.jsonutil.encode({ "method": self._serviceName, 'params': kwargs, 'id': self._eventhandler.IDGen, 'jsonrpc': '2.0' }) return postdata ## Public interface @classmethod def from_url(cls, url, ctxid=None, serviceName=None): '''Create a JSONRPCProxy from a URL''' urlsp = urlparse.urlsplit(url) url = '%s://%s' % (urlsp.scheme, urlsp.netloc) path = urlsp.path if urlsp.query: path = '%s?%s' % (path, urlsp.query) if urlsp.fragment: path = '%s#%s' % (path, urlsp.fragment) return cls(url, path, serviceName, ctxid) def __init__(self, host, path='/jsonrpc', serviceName=None, *args, **kwargs): self.serviceURL = host self._serviceName = serviceName self._path = path self.serviceURL, self._path = self._transformURL(host, path) self.customize(self._eventhandler) def __getattr__(self, name): if self._serviceName != None: name = "%s.%s" % (self._serviceName, name) return self.__class__(self.serviceURL, path=self._path, serviceName=name) def __call__(self, *args, **kwargs): url = '%(host)s%(path)s' % dict(host = self.serviceURL, path = self._path) postdata = self._get_postdata(args, kwargs) respdata = urllib.urlopen(url, postdata).read() resp = jsonrpc.jsonutil.decode(respdata) if resp.get('error') != None: raise JSONRPCException(resp['error']) else: resp = self._eventhandler.proc_response(resp) result = resp['result'] return result def call(self, method, *args, **kwargs): '''call a JSON-RPC method It's better to use instance.(\\*args, \\*\\*kwargs), but this version might be useful occasionally ''' p = self.__class__(self.serviceURL, path=self._path, serviceName=method) return p(*args, **kwargs) def batch_call(self, names, *params): '''call several methods at once, return a list of (result, error) pairs :param names: a list of method names :param \\*params: a list of (arg,kwarg) pairs corresponding to each method name ''' methods = ( (getattr(self, name),param) for name,param in itertools.izip(names, params) ) data = (method._get_postdata(*params) for method, params in methods) postdata = '[%s]' % ','.join(data) respdata = urllib.urlopen(self.serviceURL, postdata).read() resp = jsonrpc.jsonutil.decode(respdata) return [(res.get('result'), res.get('error')) for res in resp]