def _dispatch(self, *args, **kw): try: result = SimpleXMLRPCDispatcher._dispatch(self, *args, **kw) # self.logger.debug("Result: %s" % (result, )) return result except: self.logger.exception("Error while processing request") raise
def _dispatch(self, method, params): try: return SimpleXMLRPCDispatcher._dispatch(self, method, params) except Exception, e: message = "XML-RPC request caused exception:\n" message += "Method: %s\n" % (method) message += "Parameters: %s" % (str(params)) self.logger.exception(message) raise
def _dispatch(self, method, params): """ Custom _dispatch so we can log time used to execute method. """ start = datetime.utcnow() try: result = SimpleXMLRPCDispatcher._dispatch(self, method, params) except: logger.debug('Time: %s %s %s', datetime.utcnow() - start, str(method), str(params)[0:50]) raise logger.debug('Time: %s %s %s', datetime.utcnow() - start, str(method), str(params)[0:50]) return result
def _dispatch(self, method, params): """ Custom _dispatch so we can log exceptions and the time taken to execute each method. """ start = datetime.utcnow() try: result = SimpleXMLRPCDispatcher._dispatch(self, method, params) except: logger.exception('Error handling XML-RPC call %s', str(method)) logger.debug('Time: %s %s %s', datetime.utcnow() - start, str(method), str(params)[0:50]) raise logger.debug('Time: %s %s %s', datetime.utcnow() - start, str(method), str(params)[0:50]) return result
def _dispatch(self, method, params): """Dispatches an RPC call. :param method: the name of the function to call :type method: string :param params: the arguments to pass to method :type params: list """ requires_auth = method in self.methods_requiring_authentication if requires_auth: if not len(params) >= 2: raise RPCAuthenticationError('<no_username_given>') username, password, params = params[0], params[1], params[2:] if (username, password) != (self.username, self.password): raise RPCAuthenticationError(username) return SimpleXMLRPCDispatcher._dispatch(self, method, params)
class ServerGateway(object): def __init__(self, prefix): self.prefix = prefix try: # Python 2.4 self.dispatcher = SimpleXMLRPCDispatcher() except TypeError: # Python 2.5 self.dispatcher = SimpleXMLRPCDispatcher(allow_none=False, encoding=None) def add_function(self, name, func): self.dispatcher.register_function(func, ".".join([self.prefix, name])) def connect( self, func=None, name=None): def _connector(func): self.add_function(not name and func.__name__ or name, func) return func if not func: return _connector else: _connector(func) return func def __call__(self, request, *args, **kwargs): if kwargs: raise RuntimeError("Xmlrpc server gateway cannot handle key variable argumets") def custom_dispatch(method, params): return self.dispatcher._dispatch(method, params + tuple(args)) response = HttpResponse() if len(request.POST): response.write(self.dispatcher._marshaled_dispatch(request.raw_post_data, custom_dispatch)) else: methods = self.dispatcher.system_listMethods() response['Content-Type'] = 'text/plain' for method in methods: # __doc__ help = self.dispatcher.system_methodHelp(method) response.write("%s:\n %s\n\n" % (method, help)) response['Content-Length'] = str(len(response.content)) return response
class XmlRpc(object): def __init__(self, encoding=None, allow_none=True, use_datetime=0): self.__queue = [] self.__encoding = encoding self.__allow_none = allow_none self.__use_datetime = use_datetime self.__dispatcher = SimpleXMLRPCDispatcher(allow_none=allow_none, encoding=encoding) def splitfmt(self): return "xml" def initiate_request(self, method, args, kwargs, completion): if kwargs: raise NotImplemented("Keyword arguments not supported in XML-RPC mode") self.__queue.append(completion) return xmlrpc_dumps(args, method, encoding=self.__encoding, allow_none=self.__allow_none) def handle_response(self, rstr): completion = self.__queue.pop(0) try: response = xmlrpc_loads(rstr, self.__use_datetime) completion(response[0][0], None) except Fault as f: completion(None, f) def dispatch_request(self, reqstr): p,m = xmlrpc_loads(reqstr, self.__use_datetime) try: rsp = self.__dispatcher._dispatch(m, p) response = xmlrpc_dumps((rsp,), allow_none=self.__allow_none, encoding=self.__encoding) except Fault as fault: response = xmlrpc_dumps(fault, allow_none=self.__allow_none, encoding=self.__encoding) except: exc_type, exc_value, exc_tb = sys.exc_info() response = xmlrpc_dumps( Fault(1, "%s:%s" % (exc_type, exc_value)), encoding=self.__encoding, allow_none=self.__allow_none) return response def register_function(self, func, name=None): self.__dispatcher.register_function(func, name)
def _dispatch(self, method, params): """Executes the requested method and measure how long it took :param method: method name :param params: method parameters :return: Returns a tuple: the method result and the measured time, unless it is a sys method, doesn't need to measure sys methods :raise xmlrpclib.Fault: """ logger.info("CALL {}({})".format(method, ", ".join([repr(p) for p in params]))) try: before = datetime.now() if params: cavity = None first = params[0] print type(first), first if isinstance(first, str): print self._cavities cavity = self._cavities.get(first, None) print 'cavity is', cavity if cavity is not None: logger.set_tid(cavity) logger.info('hahaha') result = SimpleXMLRPCDispatcher._dispatch(self, method, params) delta = datetime.now() - before delta = unicode('%s.%06d' % (delta.seconds, delta.microseconds)) if not method.startswith('sys'): return result, delta else: return result except Exception: exc_type, exc_value, exc_tb = sys.exc_info() tb = traceback.format_exc() msg = "%s: %s\n%s" % (exc_type, exc_value, tb) logger.exception("FAULT {}: {}".format(method, msg)) raise xmlrpclib.Fault(1, msg)
def _dispatch(self, method, auth, response_method, params): params = (self.auth, response_method, params) SimpleXMLRPCDispatcher._dispatch(self, method, params)
def _dispatch(self, method, params): if not method.startswith('system.'): # Add store to all of our own methods params = (self.store,)+tuple(params) return SimpleXMLRPCDispatcher._dispatch(self, method, params)
def _dispatch(self, method, params): retn = SimpleXMLRPCDispatcher._dispatch(self, method, params) retn = translate(retn) return retn