class XMLRPCServer: def __init__(self, host, port, logic): """Initialise XMLRPC""" #Create XMLRPC server with functions from XMLRPCInterface class below self.rpcserver = DocXMLRPCServer((host, port), logRequests=0) self.rpcserver.register_instance(XMLRPCInterface(logic)) self.port = port #Set up documentation interface properties self.rpcserver.set_server_title("Truemix XMLRPC API") self.rpcserver.set_server_name("Truemix XMLRPC API Documentation") self.rpcserver.set_server_documentation( "Truemix is a radio automation system with a server/client" " organisation. This XMLRPC API allows you to write your own" " applications that connect with the Truemix backend server." ) def start_serving(self): try: #Advertise the service with avahi and dbus bus = dbus.SystemBus() server = dbus.Interface(bus.get_object(avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER), avahi.DBUS_INTERFACE_SERVER) g = dbus.Interface(bus.get_object(avahi.DBUS_NAME, server.EntryGroupNew()), avahi.DBUS_INTERFACE_ENTRY_GROUP) g.AddService(avahi.IF_UNSPEC, avahi.PROTO_UNSPEC, dbus.UInt32(0), "Truemix Server", "_truemix-xmlrpc._tcp", "", "", dbus.UInt16(self.port), "") g.Commit() except dbus.exceptions.DBusException: #Unable to advertise server pass #Start the xmlrpc server self.rpcserver.serve_forever()
def make_server(): serv = DocXMLRPCServer(("localhost", 0), logRequests=False) try: # Add some documentation serv.set_server_title("DocXMLRPCServer Test Documentation") serv.set_server_name("DocXMLRPCServer Test Docs") serv.set_server_documentation( "This is an XML-RPC server's documentation, but the server " "can be used by POSTing to /RPC2. Try self.add, too.") # Create and register classes and functions class TestClass(object): def test_method(self, arg): """Test method's docs. This method truly does very little.""" self.arg = arg serv.register_introspection_functions() serv.register_instance(TestClass()) def add(x, y): """Add two instances together. This follows PEP008, but has nothing to do with RFC1952. Case should matter: pEp008 and rFC1952. Things that start with http and ftp should be auto-linked, too: http://google.com. """ return x + y serv.register_function(add) serv.register_function(lambda x, y: x - y) return serv except: serv.server_close() raise
def GenerateDjangoXMLRPCHandler2(class_instance, server_name='Citrix Geppetto v0.1'): server = DocXMLRPCServer(("localhost", 0), bind_and_activate=False, allow_none=True) server.register_introspection_functions() members = inspect.getmembers(class_instance) members.sort(key=lambda x: x[0]) for member_name, member in members: if inspect.ismethod(member): if not member_name.startswith('_'): s = member_name.replace('___', '.') server.register_function(member, s) server.set_server_name(server_name) server.set_server_title(server_name) server.set_server_documentation(class_instance.__doc__) def handler(request): if request.method == "POST": response = HttpResponse(content_type="application/xml") response.write(server._marshaled_dispatch(request.raw_post_data)) return response elif request.method == "GET": response = HttpResponse(content_type="text/html") response.write(server.generate_html_documentation()) return response else: return HttpResponseNotAllowed("GET", "POST") return handler
class APIService(threading.Thread): @trace def __init__(self, pid, passive, active, background, debug, port, hostname): super(APIService, self).__init__() self._stop = threading.Event() self.pid = pid self.abort = False self.aborted = False self.port = port self.hostname = hostname self.api = API(pid, passive, active, background) cbdebug("Initializing API Service on port " + str(self.port)) if debug is None: self.server = AsyncDocXMLRPCServer((self.hostname, int(self.port)), allow_none=True) else: self.server = DocXMLRPCServer((self.hostname, int(self.port)), allow_none=True) self.server.abort = False self.server.aborted = False self.server.set_server_title("API Service (xmlrpc)") self.server.set_server_name("API Service (xmlrpc)") #self.server.register_introspection_functions() self.api.signatures = {} for methodtuple in inspect.getmembers(self.api, predicate=inspect.ismethod): name = methodtuple[0] if name in ["__init__", "success", "error"]: continue func = getattr(self.api, name) argspec = inspect.getargspec(func) spec = argspec[0] defaults = [] if argspec[3] is None else argspec[3] num_spec = len(spec) num_defaults = len(defaults) diff = num_spec - num_defaults named = diff - 1 doc = "Usage: " for x in range(1, diff): doc += spec[x] + ", " for x in range(diff, num_spec): doc += spec[x] + " = " + str(defaults[x - diff]) + ", " doc = doc[:-2] self.api.signatures[name] = {"args": spec[1:], "named": named} self.server.register_function(unwrap_kwargs(func, doc), name) # self.server.register_instance(self.api) cbdebug("API Service started") @trace def run(self): cbdebug("API Service waiting for requests...") self.server.serve_forever() cbdebug("API Service shutting down...") @trace def stop(self): cbdebug("Calling API Service shutdown....") self._stop.set() self.server.shutdown()
def make_server(): serv = DocXMLRPCServer(("localhost", 0), logRequests=False) try: # Add some documentation serv.set_server_title("DocXMLRPCServer Test Documentation") serv.set_server_name("DocXMLRPCServer Test Docs") serv.set_server_documentation( "This is an XML-RPC server's documentation, but the server " "can be used by POSTing to /RPC2. Try self.add, too.") # Create and register classes and functions class TestClass(object): def test_method(self, arg): """Test method's docs. This method truly does very little.""" self.arg = arg serv.register_introspection_functions() serv.register_instance(TestClass()) def add(x, y): """Add two instances together. This follows PEP008, but has nothing to do with RFC1952. Case should matter: pEp008 and rFC1952. Things that start with http and ftp should be auto-linked, too: http://google.com. """ return x + y serv.register_function(add) serv.register_function(lambda x, y: x-y) return serv except: serv.server_close() raise
class APIService ( threading.Thread ): @trace def __init__(self, pid, passive, active, background, debug, port, hostname) : super(APIService, self).__init__() self._stop = threading.Event() self.pid = pid self.abort = False self.aborted = False self.port = port self.hostname = hostname self.api = API(pid, passive, active, background, port, debug) cbdebug("Initializing API Service on " + hostname + ":" + str(port)) if debug is None : self.server = AsyncDocXMLRPCServer((self.hostname, int(self.port)), allow_none = True) else : self.server = DocXMLRPCServer((self.hostname, int(self.port)), allow_none = True) self.server.abort = False self.server.aborted = False self.server.set_server_title("API Service (xmlrpc)") self.server.set_server_name("API Service (xmlrpc)") #self.server.register_introspection_functions() self.api.signatures = {} for methodtuple in inspect.getmembers(self.api, predicate=inspect.ismethod) : name = methodtuple[0] if name in ["__init__", "success", "error", "migrate" ] : continue func = getattr(self.api, name) argspec = inspect.getargspec(func) spec = argspec[0] defaults = [] if argspec[3] is None else argspec[3] num_spec = len(spec) num_defaults = len(defaults) diff = num_spec - num_defaults named = diff - 1 doc = "Usage: " for x in range(1, diff) : doc += spec[x] + ", " for x in range(diff, num_spec) : doc += spec[x] + " = " + str(defaults[x - diff]) + ", " doc = doc[:-2] self.api.signatures[name] = {"args" : spec[1:], "named" : named } self.server.register_function(unwrap_kwargs(func, doc), name) # self.server.register_instance(self.api) cbdebug("API Service started") @trace def run(self): cbdebug("API Service waiting for requests...") self.server.serve_forever() cbdebug("API Service shutting down...") @trace def stop (self) : cbdebug("Calling API Service shutdown....") self._stop.set() self.server.shutdown()
def testserver(): class ThreadingServer(ThreadingMixIn,DocXMLRPCServer): pass server = DocXMLRPCServer(('localhost',8888),DocXMLRPCRequestHandler,allow_none=True) server.set_server_title("Chapter 18 document") server.set_server_name("chapter") server.set_server_documentation("""welcome""") server.register_instance(Math()) server.register_introspection_functions() server.register_function(int) server.register_function(list.sort)
def server(evt, numrequests): serv = DocXMLRPCServer(("localhost", 0), logRequests=False) try: global PORT PORT = serv.socket.getsockname()[1] # Add some documentation serv.set_server_title("DocXMLRPCServer Test Documentation") serv.set_server_name("DocXMLRPCServer Test Docs") serv.set_server_documentation( """This is an XML-RPC server's documentation, but the server can be used by POSTing to /RPC2. Try self.add, too.""" ) # Create and register classes and functions class TestClass(object): def test_method(self, arg): """Test method's docs. This method truly does very little.""" self.arg = arg serv.register_introspection_functions() serv.register_instance(TestClass()) def add(x, y): """Add two instances together. This follows PEP008, but has nothing to do with RFC1952. Case should matter: pEp008 and rFC1952. Things that start with http and ftp should be auto-linked, too: http://google.com. """ return x + y serv.register_function(add) serv.register_function(lambda x, y: x - y) while numrequests > 0: serv.handle_request() numrequests -= 1 except socket.timeout: pass finally: serv.server_close() PORT = None evt.set()
def server(evt, numrequests): serv = DocXMLRPCServer(("localhost", 0), logRequests=False) try: global PORT PORT = serv.socket.getsockname()[1] # Add some documentation serv.set_server_title("DocXMLRPCServer Test Documentation") serv.set_server_name("DocXMLRPCServer Test Docs") serv.set_server_documentation( """This is an XML-RPC server's documentation, but the server can be used by POSTing to /RPC2. Try self.add, too.""") # Create and register classes and functions class TestClass(object): def test_method(self, arg): """Test method's docs. This method truly does very little.""" self.arg = arg serv.register_introspection_functions() serv.register_instance(TestClass()) def add(x, y): """Add two instances together. This follows PEP008, but has nothing to do with RFC1952. Case should matter: pEp008 and rFC1952. Things that start with http and ftp should be auto-linked, too: http://google.com. """ return x + y serv.register_function(add) serv.register_function(lambda x, y: x - y) while numrequests > 0: serv.handle_request() numrequests -= 1 except socket.timeout: pass finally: serv.server_close() PORT = None evt.set()
def GenerateDjangoXMLRPCHandler(class_instance, server_name="Citrix Service"): server = DocXMLRPCServer(("localhost", 0), bind_and_activate=False, allow_none=True) server.register_introspection_functions() server.register_instance(class_instance) server.set_server_name(server_name) server.set_server_title(server_name) server.set_server_documentation(class_instance.__doc__) def handler(request): if request.method == "POST": response = HttpResponse(content_type="application/xml") response.write(server._marshaled_dispatch(request.raw_post_data)) return response elif request.method == "GET": response = HttpResponse(content_type="text/html") response.write(server.generate_html_documentation()) return response else: return HttpResponseNotAllowed("GET", "POST") return handler
class APIService ( threading.Thread ): @trace def __init__(self, pid, passive, active, background, debug, port, hostname) : super(APIService, self).__init__() self._stop = threading.Event() self.pid = pid self.abort = False self.aborted = False self.port = port self.hostname = hostname self.api = API(pid, passive, active, background) cbdebug("Initializing API Service on port " + str(self.port)) if debug is None : self.server = AsyncDocXMLRPCServer((self.hostname, int(self.port)), allow_none = True) else : self.server = DocXMLRPCServer((self.hostname, int(self.port)), allow_none = True) self.server.abort = False self.server.aborted = False self.server.set_server_title("API Service (xmlrpc)") self.server.set_server_name("API Service (xmlrpc)") #self.server.register_introspection_functions() self.server.register_instance(self.api) cbdebug("API Service started") @trace def run(self): cbdebug("API Service waiting for requests...") self.server.serve_forever() cbdebug("API Service shutting down...") @trace def stop (self) : cbdebug("Calling API Service shutdown....") self._stop.set() self.server.shutdown()