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)
else:
try:
func = SimpleXMLRPCServer.resolve_dotted_attribute(
self.instance, method, True)
except AttributeError:
pass
if func is not None:
try:
if type(params) is types.ListType:
response = func(*params)
else:
response = func(**params)
return response
except TypeError:
return Fault(-32602, 'Invalid parameters: ')
except:
err_lines = traceback.format_exc().splitlines()
trace_string = '%s | %s' % (err_lines[-3], err_lines[-1])
fault = jsonrpclib.Fault(-32603,
'Server error: %s' % trace_string)
return fault
else:
return Fault(-32601, 'Method %s not supported.' % method)
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)
else:
try:
func = SimpleXMLRPCServer.resolve_dotted_attribute(self.instance, method, True)
except AttributeError:
pass
if func is not None:
try:
if type(params) is types.ListType:
# MODIFIED to pass service method name as well
response = func(method, *params)
else:
# MODIFIED to pass service method name as well
response = func(method, **params)
return response
except TypeError:
return Fault(-32602, "Invalid parameters.")
except:
err_lines = traceback.format_exc().splitlines()
trace_string = "%s | %s" % (err_lines[-3], err_lines[-1])
fault = jsonrpclib.Fault(-32603, "Server error: %s" % trace_string)
return fault
else:
return Fault(-32601, "Method %s not supported." % method)
def _dispatch(self, method, params, **kwargs):
"""Dispatch a rpc call to the appropriate method with parameters.
This method is copied from SimpleXMLRPCServer but adds
kwargs so that REST methods can receive keyword arguments
rather than just list of parameters, which is all XMLRPC supports.
Args:
method: string, method name
params: tuple, list of arguments
kwargs: optional, dict of keyword arguments
Returns:
output from the called method
Raises:
Exception: if unsupported method is called
"""
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, kwargs)
else:
try:
func = SimpleXMLRPCServer.resolve_dotted_attribute(
self.instance,
method,
self.allow_dotted_names)
except AttributeError:
pass
if func is not None:
return func(*params, **kwargs)
else:
raise Exception('method "%s" is not supported' % method)
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)
else:
try:
func = SimpleXMLRPCServer.resolve_dotted_attribute(
self.instance,
method,
True
)
except AttributeError:
pass
if func is not None:
try:
if type(params) is types.ListType:
response = func(*params)
else:
response = func(**params)
return response
except TypeError:
return Fault(-32602, 'Invalid parameters: ')
except:
err_lines = traceback.format_exc().splitlines()
trace_string = '%s | %s' % (err_lines[-3], err_lines[-1])
fault = jsonrpclib.Fault(-32603, 'Server error: %s' %
trace_string)
return fault
else:
return Fault(-32601, 'Method %s not supported.' % method)
def _dispatch(self, method, params, **kwargs):
"""Dispatch a rpc call to the appropriate method with parameters.
This method is copied from SimpleXMLRPCServer but adds
kwargs so that REST methods can receive keyword arguments
rather than just list of parameters, which is all XMLRPC supports.
Args:
method: string, method name
params: tuple, list of arguments
kwargs: optional, dict of keyword arguments
Returns:
output from the called method
Raises:
Exception: if unsupported method is called
"""
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, kwargs)
else:
try:
func = SimpleXMLRPCServer.resolve_dotted_attribute(
self.instance, method, self.allow_dotted_names)
except AttributeError:
pass
if func is not None:
return func(*params, **kwargs)
else:
raise Exception('method "%s" is not supported' % method)
def _dispatch(self, method, params):
"""Dispatches the XML-RPC method.
XML-RPC calls are forwarded to a registered function that
matches the called XML-RPC method name. If no such function
exists then the call is forwarded to the registered instance,
if available.
If the registered instance has a _dispatch method then that
method will be called with the name of the XML-RPC method and
its parameters as a tuple
e.g. instance._dispatch('add',(2,3))
If the registered instance does not have a _dispatch method
then the instance will be searched to find a matching method
and, if found, will be called.
Methods beginning with an '_' are considered private and will
not be called.
"""
func = None
try:
# check to see if a matching function has been registered
func = self.funcs[method]
except KeyError:
if self.instance is not None:
# check for a _dispatch method
if hasattr(self.instance, '_dispatch'):
return self.instance._dispatch(method, params)
else:
# call instance method directly
try:
func = SimpleXMLRPCServer.resolve_dotted_attribute(
self.instance,
method,
self.allow_dotted_names
)
except AttributeError:
pass
if func is not None:
try:
# since we are using a keyword xmlrpc proxy this is sending
# the info comes in form of args and kwargs
# so params has 2 items, the first being a list or tuple
# and the second a dictionary
if len(params) == 2 and isinstance(params[1],dict) and\
( isinstance(params[0],list) or isinstance(params[0],tuple) ) :
return func(*params[0], **params[1])
else:
# this is the default way in case a normal xmlrpclib.ServerProxy is used
return func(*params)
except Exception:
# extended functionality to let the client have the full traceback
msg = traceback.format_exc()
raise xmlrpclib.Fault(1, msg)
else:
raise Exception('method "%s" is not supported' % method)
def _dispatch(self, method, params):
"""Dispatches the XML-RPC method.
XML-RPC calls are forwarded to a registered function that
matches the called XML-RPC method name. If no such function
exists then the call is forwarded to the registered instance,
if available.
If the registered instance has a _dispatch method then that
method will be called with the name of the XML-RPC method and
its parameters as a tuple
e.g. instance._dispatch('add',(2,3))
If the registered instance does not have a _dispatch method
then the instance will be searched to find a matching method
and, if found, will be called.
Methods beginning with an '_' are considered private and will
not be called.
"""
func = None
try:
# check to see if a matching function has been registered
func = self.funcs[method]
except KeyError:
if self.instance is not None:
# check for a _dispatch method
if hasattr(self.instance, '_dispatch'):
return self.instance._dispatch(method, params)
else:
# call instance method directly
try:
func = SimpleXMLRPCServer.resolve_dotted_attribute(
self.instance,
method,
self.allow_dotted_names
)
except AttributeError:
pass
if func is not None:
try:
# since we are using a keyword xmlrpc proxy this is sending
# the info comes in form of args and kwargs
# so params has 2 items, the first being a list or tuple
# and the second a dictionary
if len(params) == 2 and isinstance(params[1], dict) and\
(isinstance(params[0], list) or isinstance(params[-1], tuple)):
return func(*params[0], **params[1])
else:
# this is the default way in case a normal xmlrpclib.ServerProxy is used
return func(*params)
except Exception:
# extended functionality to let the client have the full traceback
msg = traceback.format_exc()
raise xmlrpclib.Fault(1, msg)
else:
raise Exception('method "%s" is not supported' % method)
def test_dotted_attribute(self):
# Raises an AttributeError because private methods are not allowed.
self.assertRaises(AttributeError, SimpleXMLRPCServer.resolve_dotted_attribute, str, "__add")
self.assertTrue(SimpleXMLRPCServer.resolve_dotted_attribute(str, "title"))
# Get the test to run faster by sending a request with test_simple1.
# This avoids waiting for the socket timeout.
self.test_simple1()
def test_dotted_attribute(self):
# Raises an AttributeError because private methods are not allowed.
self.assertRaises(AttributeError,
SimpleXMLRPCServer.resolve_dotted_attribute, str, '__add')
self.assertTrue(SimpleXMLRPCServer.resolve_dotted_attribute(str, 'title'))
# Get the test to run faster by sending a request with test_simple1.
# This avoids waiting for the socket timeout.
self.test_simple1()
def _dispatch(self, method, params):
"""
Default method resolver and caller
:param method: Name of the method to call
:param params: List of arguments to give to the method
:return: The result of the method
"""
func = None
try:
# Try with registered methods
func = self.funcs[method]
except KeyError:
if self.instance is not None:
# Try with the registered instance
if hasattr(self.instance, '_dispatch'):
# Instance has a custom dispatcher
return self.instance._dispatch(method, params)
else:
# Resolve the method name in the instance
try:
func = xmlrpcserver.resolve_dotted_attribute(\
self.instance, method, True)
except AttributeError:
# Unknown method
pass
if func is not None:
try:
# Call the method
if type(params) is utils.ListType:
return func(*params)
else:
return func(**params)
except TypeError as ex:
# Maybe the parameters are wrong
return Fault(-32602, 'Invalid parameters: {0}'.format(ex))
except:
# Method exception
err_lines = traceback.format_exc().splitlines()
trace_string = '{0} | {1}'.format(err_lines[-3], err_lines[-1])
return Fault(-32603, 'Server error: {0}'.format(trace_string))
else:
# Unknown method
return Fault(-32601, 'Method {0} not supported.'.format(method))
def my_dispatch(self, methodName, params, auth, client_addr):
"""Dispatches the XML-RPC method.
XML-RPC calls are forwarded to a registered function that
matches the called XML-RPC method name. If no such function
exists then the call is forwarded to the registered instance,
if available.
If the registered instance has a _dispatch method then that
method will be called with the name of the XML-RPC method,
its parameters as a tuple
e.g. instance._dispatch('add',(2,3))
If the registered instance does not have a _dispatch method
then the instance will be searched to find a matching method
and, if found, will be called.
Methods beginning with an '_' (except _dispatch) are considered
private and will not be called.
"""
kwdargs = {}
func = None
# check for a _dispatch method
if (self.instance is not None) and hasattr(self.instance, '_dispatch'):
return self.instance._dispatch(methodName, params, kwdargs,
auth, client_addr)
try:
# check to see if a matching function has been registered
func = self.funcs[methodName]
except KeyError:
if self.instance is not None:
# call instance method directly
try:
func = SimpleXMLRPCServer.resolve_dotted_attribute(
self.instance,
methodName,
self.allow_dotted_names
)
except AttributeError:
pass
if func is not None:
return func(*params, **kwdargs)
else:
raise Error('method "%s" is not supported' % methodName)
def my_dispatch(self, methodName, params, auth, client_addr):
"""Dispatches the XML-RPC method.
XML-RPC calls are forwarded to a registered function that
matches the called XML-RPC method name. If no such function
exists then the call is forwarded to the registered instance,
if available.
If the registered instance has a _dispatch method then that
method will be called with the name of the XML-RPC method,
its parameters as a tuple
e.g. instance._dispatch('add',(2,3))
If the registered instance does not have a _dispatch method
then the instance will be searched to find a matching method
and, if found, will be called.
Methods beginning with an '_' (except _dispatch) are considered
private and will not be called.
"""
kwdargs = {}
func = None
# check for a _dispatch method
if (self.instance is not None) and hasattr(self.instance, '_dispatch'):
return self.instance._dispatch(methodName, params, kwdargs,
auth, client_addr)
try:
# check to see if a matching function has been registered
func = self.funcs[methodName]
except KeyError:
if self.instance is not None:
# call instance method directly
try:
func = SimpleXMLRPCServer.resolve_dotted_attribute(
self.instance,
methodName,
self.allow_dotted_names
)
except AttributeError:
pass
if func is not None:
return func(*params, **kwdargs)
else:
raise Error('method "%s" is not supported' % methodName)
def get_handler(self, method):
'''获取对应的方法的处理句柄
'''
func = None
try:
#先检查已经注册的函数
func = self.funcs[method]
except KeyError:
if self.instance is not None:
#检查已经注册的实例的成员函数
try:
func = SimpleXMLRPCServer.resolve_dotted_attribute(
self.instance, method, self.allow_dotted_names)
except AttributeError:
pass
return func
def _dispatch(self, method, params):
if self.server.instance is None:
logging.error("Client without a server instance!")
raise AskgodException("Internal server error.")
# call instance method directly
func = None
try:
func = SimpleXMLRPCServer.resolve_dotted_attribute(
self.server.instance,
method,
self.server.allow_dotted_names)
except Exception as e:
logging.info("Failed to resolv '%s': %s" % (method, e))
raise AskgodException("Unable to resolve method name.")
if not func:
logging.info("Function '%s' doesn't exist." % func)
raise AskgodException("Invalid method name.")
# Per connection data (address, DB connection, request)
client = {}
client['client_address'] = self.client_address[0]
client['db_store'] = Store(self.server.database)
client['request'] = self.request
forwarded_address = self.headers.get("X-Forwarded-For", "")
if forwarded_address:
client['client_address'] = forwarded_address
# Actually call the function
try:
retval = func(client, *params)
except not AskgodException:
logging.error(traceback.format_exc())
raise AskgodException("Internal server error.")
# Attempt to close the DB connection (if still there)
try:
client['db_store'].commit()
client['db_store'].close()
except:
pass
return retval