2 from jsonrpclib import Fault
3 import SimpleXMLRPCServer
14 def get_version(request):
16 if 'jsonrpc' in request.keys():
18 if 'id' in request.keys():
22 def validate_request(request):
23 if type(request) is not types.DictType:
25 -32600, 'Request must be {}, not %s.' % type(request)
28 rpcid = request.get('id', None)
29 version = get_version(request)
31 fault = Fault(-32600, 'Request %s invalid.' % request, rpcid=rpcid)
33 request.setdefault('params', [])
34 method = request.get('method', None)
35 params = request.get('params')
36 param_types = (types.ListType, types.DictType, types.TupleType)
37 if not method or type(method) not in types.StringTypes or \
38 type(params) not in param_types:
40 -32600, 'Invalid request parameters or method.', rpcid=rpcid
45 class SimpleJSONRPCDispatcher(SimpleXMLRPCServer.SimpleXMLRPCDispatcher):
47 def __init__(self, encoding=None):
48 SimpleXMLRPCServer.SimpleXMLRPCDispatcher.__init__(self,
52 def _marshaled_dispatch(self, data, dispatch_method = None):
55 request = jsonrpclib.loads(data)
57 fault = Fault(-32700, 'Request %s invalid. (%s)' % (data, e))
58 response = fault.response()
61 fault = Fault(-32600, 'Request invalid -- no request data.')
62 return fault.response()
63 if type(request) is types.ListType:
64 # This SHOULD be a batch, by spec
66 for req_entry in request:
67 result = validate_request(req_entry)
68 if type(result) is Fault:
69 responses.append(result.response())
71 resp_entry = self._marshaled_single_dispatch(req_entry)
72 if resp_entry is not None:
73 responses.append(resp_entry)
74 if len(responses) > 0:
75 response = '[%s]' % ','.join(responses)
79 result = validate_request(request)
80 if type(result) is Fault:
81 return result.response()
82 response = self._marshaled_single_dispatch(request)
85 def _marshaled_single_dispatch(self, request):
86 # TODO - Use the multiprocessing and skip the response if
87 # it is a notification
88 # Put in support for custom dispatcher here
89 # (See SimpleXMLRPCServer._marshaled_dispatch)
90 method = request.get('method')
91 params = request.get('params')
93 response = self._dispatch(method, params)
95 exc_type, exc_value, exc_tb = sys.exc_info()
96 fault = Fault(-32603, '%s:%s' % (exc_type, exc_value))
97 return fault.response()
98 if 'id' not in request.keys() or request['id'] == None:
102 response = jsonrpclib.dumps(response,
108 exc_type, exc_value, exc_tb = sys.exc_info()
109 fault = Fault(-32603, '%s:%s' % (exc_type, exc_value))
110 return fault.response()
112 def _dispatch(self, method, params):
115 func = self.funcs[method]
117 if self.instance is not None:
118 if hasattr(self.instance, '_dispatch'):
119 return self.instance._dispatch(method, params)
122 func = SimpleXMLRPCServer.resolve_dotted_attribute(
127 except AttributeError:
131 if type(params) is types.ListType:
132 response = func(*params)
134 response = func(**params)
137 return Fault(-32602, 'Invalid parameters.')
139 err_lines = traceback.format_exc().splitlines()
140 trace_string = '%s | %s' % (err_lines[-3], err_lines[-1])
141 fault = jsonrpclib.Fault(-32603, 'Server error: %s' %
145 return Fault(-32601, 'Method %s not supported.' % method)
147 class SimpleJSONRPCRequestHandler(
148 SimpleXMLRPCServer.SimpleXMLRPCRequestHandler):
151 if not self.is_rpc_path_valid():
155 max_chunk_size = 10*1024*1024
156 size_remaining = int(self.headers["content-length"])
158 while size_remaining:
159 chunk_size = min(size_remaining, max_chunk_size)
160 L.append(self.rfile.read(chunk_size))
161 size_remaining -= len(L[-1])
163 response = self.server._marshaled_dispatch(data)
164 self.send_response(200)
166 self.send_response(500)
167 err_lines = traceback.format_exc().splitlines()
168 trace_string = '%s | %s' % (err_lines[-3], err_lines[-1])
169 fault = jsonrpclib.Fault(-32603, 'Server error: %s' % trace_string)
170 response = fault.response()
173 self.send_header("Content-type", "application/json-rpc")
174 self.send_header("Content-length", str(len(response)))
176 self.wfile.write(response)
178 self.connection.shutdown(1)
180 class SimpleJSONRPCServer(SocketServer.TCPServer, SimpleJSONRPCDispatcher):
182 allow_reuse_address = True
184 def __init__(self, addr, requestHandler=SimpleJSONRPCRequestHandler,
185 logRequests=True, encoding=None, bind_and_activate=True):
186 self.logRequests = logRequests
187 SimpleJSONRPCDispatcher.__init__(self, encoding)
188 # TCPServer.__init__ has an extra parameter on 2.6+, so
189 # check Python version and decide on how to call it
190 vi = sys.version_info
191 # if python 2.5 and lower
192 if vi[0] < 3 and vi[1] < 6:
193 SocketServer.TCPServer.__init__(self, addr, requestHandler)
195 SocketServer.TCPServer.__init__(self, addr, requestHandler,
197 if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
198 flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
199 flags |= fcntl.FD_CLOEXEC
200 fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
202 class CGIJSONRPCRequestHandler(SimpleJSONRPCDispatcher):
204 def __init__(self, encoding=None):
205 SimpleJSONRPCDispatcher.__init__(self, encoding)
207 def handle_jsonrpc(self, request_text):
208 response = self._marshaled_dispatch(request_text)
209 print 'Content-Type: application/json-rpc'
210 print 'Content-Length: %d' % len(response)
212 sys.stdout.write(response)
214 handle_xmlrpc = handle_jsonrpc