def lookupProcedure(self, procedurePath): """ Lookup a method dynamically. 1. First, see if it's provided by a sub-handler. 2. Or try a self-defined method (prefixed with `xmlrpc_`) 3. Lastly, try dynamically mapped methods. 4. Or fail loudly. """ log.msg("LOOKING UP:", procedurePath) if procedurePath.find(self.separator) != -1: prefix, procedurePath = procedurePath.split(self.separator, 1) handler = self.getSubHandler(prefix) if handler is None: raise xmlrpc.NoSuchFunction(self.NOT_FOUND, "no such subHandler %s" % prefix) return handler.lookupProcedure(procedurePath) # Try self-defined methods first... f = getattr(self, "xmlrpc_%s" % procedurePath, None) # Try mapped methods second... if f is None: f = self._procedure_map.get(procedurePath, None) if not f: raise xmlrpc.NoSuchFunction(self.NOT_FOUND, "procedure %s not found" % procedurePath) elif not callable(f): raise xmlrpc.NoSuchFunction(self.NOT_FOUND, "procedure %s not callable" % procedurePath) else: return f
def lookupProcedure(self, procedurePath): """Override XMLRPC lookupProcedure in order to call getSubHandler also if the procedurePath was not registered""" pp = procedurePath.split(self.separator) # If just one item, it is a function of FileServer itself if len(pp) == 1: f = getattr(self, 'xmlrpc_' + pp[0], False) if f is False: raise xmlrpc.NoSuchFunction( self.NOT_FOUND, "FileServer procedure %s not found" % procedurePath) return f # Function name is always the last item f = pp.pop(-1) # Filename requires rejoining the remaining part of pp prefix = '/'.join(pp) # Retrieve the served file sub = self.getSubHandler(prefix) if sub is False: raise xmlrpc.NoSuchFunction( self.NOT_FOUND, "SharedFile %s not found for procedure %s" % (prefix, procedurePath)) # Retrieve the function - try first with xmlrpc_ prefix cb = getattr(sub, 'xmlrpc_' + f, False) # try as-is if cb is False: cb = getattr(sub, f, False) if cb is False: raise xmlrpc.NoSuchFunction( self.NOT_FOUND, "SharedFile method %s not found on handler %s for procedure %s" % (f, prefix, procedurePath)) # Return the function return cb
def lookupProcedure(self, procedurePath): try: return self.methods[procedurePath] except KeyError as e: raise xmlrpc.NoSuchFunction( self.NOT_FOUND, "procedure %s not found: %s" % (procedurePath, e))
def lookupProcedure(self, procedureName): """ Lookup a procedure from a fixed set of choices, either I{echo} or I{system.listeMethods}. """ if procedureName == 'echo': return self.echo raise xmlrpc.NoSuchFunction( self.NOT_FOUND, 'procedure %s not found' % (procedureName,))
def lookupProcedure(self, procedureName): """ Lookup a procedure from a fixed set of choices, either I{echo} or I{system.listeMethods}. """ if procedureName == "echo": return self.echo raise xmlrpc.NoSuchFunction( self.NOT_FOUND, "procedure {} not found".format(procedureName))
def _getFunction(self, functionPath): """ """ if functionPath.find(self.separator) != -1: prefix, functionPath = functionPath.split(self.separator, 1) handler = self.getSubHandler(prefix) if handler is None: raise xmlrpc.NoSuchFunction(self.NOT_FOUND, "no such subHandler %s" % prefix) return handler._getFunction(functionPath) f = getattr(self.api, functionPath, None) if not f: raise xmlrpc.NoSuchFunction(self.NOT_FOUND, "function %s not found" % functionPath) elif not callable(f): raise xmlrpc.NoSuchFunction( self.NOT_FOUND, "function %s not callable" % functionPath) return f
def lookupProcedure(self, procedurePath): with log.enter(obj=self, args={'procedurePath': procedurePath}) as tm: try: if (self.handlers.has_key(procedurePath)): return self.handlers[procedurePath] else: wsgi_path = procedurePath.split('.') wsgi_module = import_module('.'.join( wsgi_path[:len(wsgi_path) - 1])) wsgi_app = getattr(wsgi_module, wsgi_path[len(wsgi_path) - 1]) handler = DtxXmlRpcHandler(wsgi_app) self.handlers[procedurePath] = handler return handler except: log.err(traceback.format_exc()) raise xmlrpc.NoSuchFunction( self.NOT_FOUND, "Procedure %s not found" % procedurePath)
def _getFunction(self, methodName): while self.__pause: time.sleep(1) self.__numRequests = self.__numRequests + 1 function = None try: def defer_function(*args): return deferToThread(self.__XRMethods[methodName], *args) function = defer_function self.__logger.info( "[%s] processing defered XML-RPC call to: %s ..." % (self.__numRequests, methodName)) except KeyError: self.__logger.warn( "[%s] fault %s on XML-RPC call to %s, method not found." % ( self.__numRequests, self.NOT_FOUND, methodName)) raise xmlrpc.NoSuchFunction(self.NOT_FOUND, "method %s not found" % methodName) return function
def lookupProcedure(self, procedurePath): try: return self._procedureToCallable[procedurePath] except KeyError as e: raise xmlrpc.NoSuchFunction( self.NOT_FOUND, "procedure %s not found" % procedurePath)
def lookupProcedure(self, procedurePath): try: return self.apiFunctions[procedurePath] except KeyError: raise xmlrpc.NoSuchFunction(self.NOT_FOUND, "procedure %s not found" % procedurePath)