def _marshaled_single_dispatch(self, request):
# TODO - Use the multiprocessing and skip the response if
# it is a notification
# Put in support for custom dispatcher here
# (See SimpleXMLRPCServer._marshaled_dispatch)
method = request.get('method')
params = request.get('params')
try:
response = self._dispatch(method, params)
except:
exc_type, exc_value, exc_tb = sys.exc_info()
fault = Fault(-32603, '%s:%s' % (exc_type, exc_value))
return fault.response()
if 'id' not in request.keys() or request['id'] == None:
# It's a notification
return None
try:
response = jsonrpclib.dumps(response,
methodresponse=True,
rpcid=request['id'])
return response
except:
exc_type, exc_value, exc_tb = sys.exc_info()
fault = Fault(-32603, '%s:%s' % (exc_type, exc_value))
return fault.response()
def _marshaled_single_dispatch(self, request):
# TODO - Use the multiprocessing and skip the response if
# it is a notification
# Put in support for custom dispatcher here
# (See SimpleXMLRPCServer._marshaled_dispatch)
method = request.get('method')
params = request.get('params')
try:
response = self._dispatch(method, params)
except:
exc_type, exc_value, exc_tb = sys.exc_info()
fault = Fault(-32603, '%s:%s' % (exc_type, exc_value))
return fault.response()
if 'id' not in request.keys() or request['id'] == None:
# It's a notification
return None
try:
response = jsonrpclib.dumps(response,
methodresponse=True,
rpcid=request['id']
)
return response
except:
exc_type, exc_value, exc_tb = sys.exc_info()
fault = Fault(-32603, '%s:%s' % (exc_type, exc_value))
return fault.response()
def __init__(self, method, data):
import jsonrpclib
data = jsonrpclib.dumps(data, methodresponse=True, rpcid=1)
method_call = '\'{"method": "%s", "id": 1}\'' % method
super(JSONRPCMethod, self).__init__(method, data, method_call)
def __init__(self, method, data):
import jsonrpclib
data = jsonrpclib.dumps(data, methodresponse=True, rpcid=1)
method_call = '\'{"method": "%s", "id": 1}\'' % method
super(JSONRPCMethod, self).__init__(method, data, method_call)
def post(self, *args, **kwargs):
"""
JSON-RPC 2.0
Request Object:
{u'jsonrpc': u'2.0', u'params': [1, 2], u'id': u'3ebm619c', u'method': u'add'}
Response Object:
{"jsonrpc": "2.0", "result": 3, "id": "3ebm619c"}
"""
import jsonrpclib
try:
json_request = jsonrpclib.loads(self.request.body)
params = json_request.get("params", [])
method_name = json_request.get("method", "")
except:
# Bad request formatting, bad.
raise Exception('Deal with how you want.')
if method_name in dir(RequestHandler):
# Pre-existing, not an implemented attribute
raise AttributeError('%s is not implemented.' % method_name)
try:
method = getattr(self, method_name)
except:
# Attribute doesn't exist
raise AttributeError('%s is not a valid method.' % method_name)
if not callable(method):
# Not callable, so not a method
raise Exception('Attribute %s is not a method.' % method_name)
if method_name.startswith('_') or \
('private' in dir(method) and method.private is True):
# No, no. That's private.
raise Exception('Private function %s called.' % method_name)
response = method(*params)
response_json = jsonrpclib.dumps(response, methodresponse=True, rpcid=json_request["id"])
self.set_header("Content-Type", "text/json")
self.write(response_json)
def serialize(self):
if self.uri[-1] != "/":
self.uri += "/"
self.path += "/"
data = jsonrpclib.dumps(self.params, self.method).encode("utf8")
self.headers["Content-Type"] = "application/json-rpc; charset=utf-8"
cl = len(data)
self.headers["Content-Length"] = cl
self.set_content_length(cl)
return data
def do_GET(self):
"""
self.send_response(501)
response = 'Not Implemented (%s): %s' % (self.path, self.rpc_paths)
self.send_header("Content-type", "text/plain")
self.send_header("Content-length", str(len(response)))
self.end_headers()
self.wfile.write(response)
"""
pq = self.path.split('?', 1)
if pq[0] and pq[0][-1] == '/':
pq[0] = pq[0][:-1]
path = pq[0].split('/')
method = path.pop(-1)
path = '/'.join(path)
if self.rpc_paths:
if not (path in self.rpc_paths):
self.report_404()
return
#print "1111", path, method
try:
params = []
kwargs = {}
if len(pq) > 1:
for kv in pq.pop(1).split('&'):
kv = kv.split('=', 1)
if len(kv) > 1:
kwargs[urllib.unquote(kv[0]).strip()] = urllib.unquote(
kv[1]).strip()
else:
params.append(urllib.unquote(kv[0]).strip())
data = jsonrpclib.dumps(params,
kwargs,
method,
methodresponse=None,
encoding=None,
allow_none=1)
#print self.server
#print data
response = self.server._marshaled_dispatch(
data, getattr(self, '_dispatch', None), path)
except Exception, e: # This should only happen if the module is buggy
# internal error, report as HTTP server error
self.send_response(500)
# Send information about the exception if requested
if hasattr(self.server, '_send_traceback_header') and \
self.server._send_traceback_header:
self.send_header("X-exception", str(e))
self.send_header("X-traceback", traceback.format_exc())
self.send_header("Cache-control", "no-cache")
self.send_header("Content-length", "0")
self.end_headers()
def _marshaled_dispatch(self, data, dispatch_method=None, path=None):
"""Dispatches an JSON-RPC method from marshalled (JSON) data.
JSON-RPC methods are dispatched from the marshalled (JSON) 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
SimpleJSONRPCRequestHandler.do_POST) but overriding the
existing method through subclassing is the preferred means
of changing method dispatch behavior.
"""
try:
params, kwargs, method = jsonrpclib.loads(data)
#print "method:", method
# generate response
if dispatch_method is not None:
response = dispatch_method(method, params, kwargs)
else:
response = self._dispatch(method, params, kwargs)
#print 333, response
#sys.stdout.flush()
if isinstance(response, self._type_function):
return response
# wrap response in a singleton tuple
response = (response, )
response = jsonrpclib.dumps(response,
None,
methodresponse=1,
allow_none=self.allow_none,
encoding=self.encoding)
except Fault, fault:
response = jsonrpclib.dumps(fault,
None,
allow_none=self.allow_none,
encoding=self.encoding)
def XBMCfunction(func, params=[]):
jsondata = jsonrpclib.dumps(params, func)
#print jsondata
base64string = base64.encodestring('%s:%s' % ('xbmc', 'xbmc'))[:-1]
authheader = "Basic %s" % base64string
req = urllib2.Request("http://192.168.0.10:8080/jsonrpc", jsondata)
req.add_header("Authorization", authheader)
req.add_header('Content-Type', 'application/json')
handle = urllib2.urlopen(req, timeout=1)
html = handle.read()
#print html
result = json.loads(html)
return result['result']
def _marshaled_dispatch(self, data, dispatch_method=None, path=None):
#print 2222, self.dispatchers
try:
response = self.dispatchers[path]._marshaled_dispatch(
data, dispatch_method, path)
except:
# report low level exception back to server
# (each dispatcher should have handled their own
# exceptions)
exc_type, exc_value = sys.exc_info()[:2]
response = jsonrpclib.dumps(jsonrpclib.Fault(
1, "%s:%s" % (exc_type, exc_value)),
None,
encoding=self.encoding,
allow_none=self.allow_none)
return response
def post(self, *args, **kwargs):
"""
JSON-RPC 2.0
Request Object:
{u'jsonrpc': u'2.0', u'params': [1, 2], u'id': u'3ebm619c', u'method': u'add'}
Response Object:
{"jsonrpc": "2.0", "result": 3, "id": "3ebm619c"}
"""
import jsonrpclib
try:
json_request = jsonrpclib.loads(self.request.body)
params = json_request.get("params", [])
method_name = json_request.get("method", "")
except:
# Bad request formatting, bad.
raise Exception('Deal with how you want.')
if method_name in dir(RequestHandler):
# Pre-existing, not an implemented attribute
raise AttributeError('%s is not implemented.' % method_name)
try:
method = getattr(self, method_name)
except:
# Attribute doesn't exist
raise AttributeError('%s is not a valid method.' % method_name)
if not callable(method):
# Not callable, so not a method
raise Exception('Attribute %s is not a method.' % method_name)
if method_name.startswith('_') or \
('private' in dir(method) and method.private is True):
# No, no. That's private.
raise Exception('Private function %s called.' % method_name)
response = method(*params)
response_json = jsonrpclib.dumps(response,
methodresponse=True,
rpcid=json_request["id"])
self.set_header("Content-Type", "text/json")
self.write(response_json)
def _dump(self, data, rpcid=1):
return jsonrpclib.dumps(data, methodresponse=True, rpcid=rpcid)
def _dump(self, data, rpcid=1):
return jsonrpclib.dumps(data, methodresponse=True, rpcid=rpcid)
method = request.get('method')
params = request.get('params')
try:
response = self._dispatch(method, params)
except Fault, fault:
return fault.response()
except:
exc_type, exc_value, exc_tb = sys.exc_info()
fault = Fault(-32603, '%s:%s' % (exc_type, exc_value))
return fault.response()
if 'id' not in request.keys() or request['id'] == None:
# It's a notification
return None
try:
response = jsonrpclib.dumps(response,
methodresponse=True,
rpcid=request['id']
)
return response
except:
exc_type, exc_value, exc_tb = sys.exc_info()
fault = Fault(-32603, '%s:%s' % (exc_type, exc_value))
return fault.response()
def _dispatch(self, method, params):
func = None
try:
func = self.funcs[method]
except KeyError:
if self.instance is not None:
if hasattr(self.instance, '_dispatch'):
return self.instance._dispatch(method, params)
def handle_request(self, environ, start_response, request_text=None):
"""Handle a single JSON-RPC request passed through a CGI post method.
If no JSON data is given then it is read from stdin. The resulting
JSON-RPC response is printed to stdout along with the correct HTTP
headers.
"""
#print 111, environ
#sys.stdout.flush()
if request_text is None and environ.get('REQUEST_METHOD',
None) == 'GET':
"""Handle a single HTTP GET request.
Default implementation indicates an error because
JSON-RPC uses the POST method.
"""
pq = environ.get("REQUEST_URI", '').split('?', 1)
if pq[0] and pq[0][-1] == '/':
pq[0] = pq[0][:-1]
method = pq[0].split('/')[-1]
params = []
kwargs = {}
if len(pq) > 1:
for kv in pq.pop(1).split('&'):
kv = kv.split('=', 1)
if len(kv) > 1:
kwargs[urllib.unquote(kv[0]).strip()] = urllib.unquote(
kv[1]).strip()
else:
params.append(urllib.unquote(kv[0]).strip())
length = -1
request_text = jsonrpclib.dumps(params,
kwargs,
method,
methodresponse=None,
encoding=None,
allow_none=1)
"""Handle a single JSON-RPC request"""
response = jsonrpclib.gzip_encode(
self._marshaled_dispatch(request_text))
start_response("200 OK", [
("Content-Type", "application/json; charset=UTF-8"),
("Cache-Control", "no-cache"),
("Content-Encoding", "gzip"),
("Content-Length", str(len(response))),
])
"""
code = 501
#code = 400
message, explain = BaseHTTPServer.BaseHTTPRequestHandler.responses[code]
response = BaseHTTPServer.DEFAULT_ERROR_MESSAGE % {
'code': code,
'message': message,
'explain': explain,
}
start_response("%d %s" % (code, message), [
("Content-Type", BaseHTTPServer.DEFAULT_ERROR_CONTENT_TYPE),
("Content-Length", str(len(response))),
])
"""
else:
# POST data is normally available through stdin
try:
length = int(environ.get("CONTENT_LENGTH", None))
except (TypeError, ValueError):
length = -1
if request_text is None:
request_text = environ["wsgi.input"].read(length)
if "gzip" == environ.get("HTTP_CONTENT_ENCODING",
environ.get("CONTENT_ENCODING")):
request_text = jsonrpclib.gzip_decode(request_text)
"""Handle a single JSON-RPC request"""
response = jsonrpclib.gzip_encode(
self._marshaled_dispatch(request_text))
start_response("200 OK", [
("Content-Type", "application/json"),
("Content-Encoding", "gzip"),
("Content-Length", str(len(response))),
])
return [
response,
]
response = jsonrpclib.dumps(fault,
None,
allow_none=self.allow_none,
encoding=self.encoding)
except:
# report exception back to server
exc_type, exc_value, exc_tb = sys.exc_info()
if hasattr(
self,
'_send_traceback_header') and self._send_traceback_header:
exc_value = str(exc_value) + '\n' + traceback.format_exc()
print exc_value
sys.stdout.flush()
response = jsonrpclib.dumps(
jsonrpclib.Fault(1, "%s:%s" % (exc_type, exc_value)),
None,
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 +
