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
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 xmlrpcserver(run, port): server = DocXMLRPCServer(("localhost", port)) server.register_introspection_functions() server.register_function(gimp.gtkrc, "gtkrc") server.register_instance(gimp) if run: server.serve_forever() pass
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 start(): """ Start the XML-RPC server, and print out the port number that it is listening on. """ server = XMLRPCServer(("127.0.0.1", 0), JPushyXMLRPCRequestHandler) # print out the port number print server.socket.getsockname()[1] sys.stdout.flush() server.allow_none = True server.register_introspection_functions() server.register_instance(JPushyFunctions()) server.serve_forever()
def start(): """ Start the XML-RPC server, and print out the port number that it is listening on. """ server = XMLRPCServer(("127.0.0.1", 0), JPushyXMLRPCRequestHandler) # print out the port number print server.socket.getsockname()[1] sys.stdout.flush() server.allow_none = True server.register_introspection_functions() server.register_instance(JPushyFunctions()) server.serve_forever()
def start( address, scheduler, debug=False ): global count if debug: s = DocXMLRPCServer( address, allow_none=True ) s.register_introspection_functions() else: s = SimpleXMLRPCServer( address, allow_none=True ) handler = RPCHandler( scheduler ) s.register_multicall_functions() s.register_instance( handler ) s.thread = threading.Thread( name="RPC", target=s.serve_forever ) s.thread.daemon = True s.thread.start() logging.info( "rpc interface started" ) return s, s.thread, handler
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 run( s ): server = DocXMLRPCServer( (s.host_name, s.port_number), logRequests=0 ) server.register_function( s.notify ) server.register_function( s.create_user ) server.register_function( s.delete_user ) server.register_function( s.email_pw ) server.register_function( s.change_pw ) server.register_function( s.create_namespace ) server.register_function( s.delete_namespace ) server.register_function( s.set ) server.register_function( s.unset ) server.register_function( s.get_description_url ) server.register_introspection_functions() print time.asctime(), "Local Names Store Server Starts - %s:%s" % (s.host_name, s.port_number) try: server.serve_forever() except KeyboardInterrupt: pass print time.asctime(), "Local Names Store Server Stops - %s:%s" % (s.host_name, s.port_number)
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
#!/usr/bin/python from DocXMLRPCServer import DocXMLRPCServer def sumAndDifference(x,y): """This method returns sum and difference of arguments as struct with two fields: 'sum' and 'difference'""" return {'sum':x+y,'difference':x-y} server = DocXMLRPCServer(("localhost", 5777)) server.register_function(sumAndDifference,"sample.sumAndDifference") server.register_introspection_functions() server.register_multicall_functions() server.serve_forever()
q = q.filter(fias_db.Addrobj.formalname.ilike(name_like)) if q.count() > return_limit: return "Too big list" else: res = [] for one in q.all(): ao = melt.fias_AO(one, session=session) one_ = dict( formalname=one.formalname, shortname=one.shortname, aolevel=one.aolevel, code=one.code, okato=str(one.okato) if one.okato else '', postalcode=str(one.postalcode) if one.postalcode else '', name=ao.name, fullname=ao.fullname, aoguid=str(one.aoguid)) res.append(one_) return res if __name__ == "__main__": from DocXMLRPCServer import DocXMLRPCServer serv = DocXMLRPCServer(("127.0.0.1", 8080), allow_none=True) serv.register_function(GetAreas) serv.register_function(GetAreaProperty) serv.register_function(GetBuildings) serv.register_function(GetBuildingProperties) serv.register_introspection_functions() serv.serve_forever()