docs/jsonrpc-example-code/jsonrpc.py

# A reaction to: http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/552751
from webob import Request, Response
from webob import exc
from simplejson import loads, dumps
import traceback
import sys


class JsonRpcApp(object):
    """
    Serve the given object via json-rpc (http://json-rpc.org/)
    """

    def __init__(self, obj):
        self.obj = obj

    def __call__(self, environ, start_response):
        req = Request(environ)
        try:
            resp = self.process(req)
        except ValueError, e:
            resp = exc.HTTPBadRequest(str(e))
        except exc.HTTPException, e:
            resp = e
        return resp(environ, start_response)

    def process(self, req):
        if not req.method == "POST":
            raise exc.HTTPMethodNotAllowed("Only POST allowed", allowed="POST")
        try:
            json = loads(req.body)
        except ValueError, e:
            raise ValueError("Bad JSON: %s" % e)
        try:
            method = json["method"]
            params = json["params"]
            id = json["id"]
        except KeyError, e:
            raise ValueError("JSON body missing parameter: %s" % e)
        if method.startswith("_"):
            raise exc.HTTPForbidden(
                "Bad method name %s: must not start with _" % method
            )
        if not isinstance(params, list):
            raise ValueError("Bad params %r: must be a list" % params)
        try:
            method = getattr(self.obj, method)
        except AttributeError:
            raise ValueError("No such method %s" % method)
        try:
            result = method(*params)
        except:
            text = traceback.format_exc()
            exc_value = sys.exc_info()[1]
            error_value = dict(
                name="JSONRPCError", code=100, message=str(exc_value), error=text
            )
            return Response(
                status=500,
                content_type="application/json",
                body=dumps(dict(result=None, error=error_value, id=id)),
            )
        return Response(
            content_type="application/json",
            body=dumps(dict(result=result, error=None, id=id)),
        )


class ServerProxy(object):
    """
    JSON proxy to a remote service.
    """

    def __init__(self, url, proxy=None):
        self._url = url
        if proxy is None:
            from wsgiproxy.exactproxy import proxy_exact_request

            proxy = proxy_exact_request
        self.proxy = proxy

    def __getattr__(self, name):
        if name.startswith("_"):
            raise AttributeError(name)
        return _Method(self, name)

    def __repr__(self):
        return "<%s for %s>" % (self.__class__.__name__, self._url)


class _Method(object):
    def __init__(self, parent, name):
        self.parent = parent
        self.name = name

    def __call__(self, *args):
        json = dict(method=self.name, id=None, params=list(args))
        req = Request.blank(self.parent._url)
        req.method = "POST"
        req.content_type = "application/json"
        req.body = dumps(json)
        resp = req.get_response(self.parent.proxy)
        if resp.status_code != 200 and not (
            resp.status_code == 500 and resp.content_type == "application/json"
        ):
            raise ProxyError(
                "Error from JSON-RPC client %s: %s" % (self.parent._url, resp.status),
                resp,
            )
        json = loads(resp.body)
        if json.get("error") is not None:
            e = Fault(
                json["error"].get("message"),
                json["error"].get("code"),
                json["error"].get("error"),
                resp,
            )
            raise e
        return json["result"]


class ProxyError(Exception):
    """
    Raised when a request via ServerProxy breaks
    """

    def __init__(self, message, response):
        Exception.__init__(self, message)
        self.response = response


class Fault(Exception):
    """
    Raised when there is a remote error
    """

    def __init__(self, message, code, error, response):
        Exception.__init__(self, message)
        self.code = code
        self.error = error
        self.response = response

    def __str__(self):
        return "Method error calling %s: %s\n%s" % (
            self.response.request.url,
            self.args[0],
            self.error,
        )


class DemoObject(object):
    """
    Something interesting to attach to
    """

    def add(self, *args):
        return sum(args)

    def average(self, *args):
        return sum(args) / float(len(args))

    def divide(self, a, b):
        return a / b


def make_app(expr):
    module, expression = expr.split(":", 1)
    __import__(module)
    module = sys.modules[module]
    obj = eval(expression, module.__dict__)
    return JsonRpcApp(obj)


def main(args=None):
    import optparse
    from wsgiref import simple_server

    parser = optparse.OptionParser(usage="%prog [OPTIONS] MODULE:EXPRESSION")
    parser.add_option(
        "-p", "--port", default="8080", help="Port to serve on (default 8080)"
    )
    parser.add_option(
        "-H",
        "--host",
        default="127.0.0.1",
        help="Host to serve on (default localhost; 0.0.0.0 to make public)",
    )
    options, args = parser.parse_args()
    if not args or len(args) > 1:
        print("You must give a single object reference")
        parser.print_help()
        sys.exit(2)
    app = make_app(args[0])
    server = simple_server.make_server(options.host, int(options.port), app)
    print("Serving on http://%s:%s" % (options.host, options.port))
    server.serve_forever()
    # Try python jsonrpc.py 'jsonrpc:DemoObject()'


if __name__ == "__main__":
    main()