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 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) 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 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, 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 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
class XmlrpcListener(Listener): logger = logging.get_logger(name='xmlrpc') def __init__(self, communicator, name, params, client_request_class=None): Listener.__init__(self, communicator, name, params, client_request_class=client_request_class) if not params.has_key('service_name'): params['service_name'] = self.get_name() host = params.get('host') port = int(params.get('port')) self._server = DocXMLRPCServer(addr=(host, port), allow_none=1, logRequests=0) self.add_service(XmlrpcDispatcher(self), name=params['service_name']) def __get_instance_methods__(self, instance, prefix=None): methods = {} for o in dir(instance): if not o.startswith('_'): method = getattr(instance, o) if method.__class__.__name__ == 'instancemethod': if prefix: methods["%s.%s" % (prefix, o)] = method else: methods[o] = method return methods def add_service(self, service, **kwargs): ''' Add a service to listener. @param service: service object ''' name = kwargs.get('name', None) methods = self.__get_instance_methods__(service, name) for method_name, method in methods.items(): self._server.register_function(method, method_name) def start(self): self._server.serve_forever() def stop(self, force): try: self._server.shutdown() except Exception, error: XmlrpcListener.logger.warning(error)
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 run( s ): server = DocXMLRPCServer( (s.host_name, s.port_number), logRequests=0 ) server.register_function( s.notify ) server.register_function( s.subscribe ) server.register_function( s.unsubscribe ) server.register_function( s.unsubscribe_all ) server.register_function( s.get_logs ) print time.asctime(), "Event Server Starts - %s:%s" % (s.host_name, s.port_number) try: server.serve_forever() except KeyboardInterrupt: pass server.close() # might work..? print time.asctime(), "Event Server Stops - %s:%s" % (s.host_name, s.port_number)
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_xmlrpc_server(): '''Run an XMLRPC server that publishes the translate_stacktrace function.''' from DocXMLRPCServer import DocXMLRPCServer as XMLRPCServer logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s') with open(PIDFILE, 'w') as pidfile: pidfile.write('%s' % os.getpid()) try: # Create server server = XMLRPCServer(LISTEN_ADDR) server.register_function(translate_stacktrace) # Run the server's main loop try: server.serve_forever() except KeyboardInterrupt: pass finally: os.remove(PIDFILE)
def run_xmlrpc_server(): '''Run an XMLRPC server that publishes the translate_stacktrace function.''' from DocXMLRPCServer import DocXMLRPCServer as XMLRPCServer logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s') with open(PIDFILE, 'w') as pidfile: pidfile.write('%s' % os.getpid()) try: # Create server server = XMLRPCServer(LISTEN_ADDR) server.register_function(translate_stacktrace) # Run the server's main loop try: server.serve_forever() except KeyboardInterrupt: pass finally: os.remove(PIDFILE)
from DocXMLRPCServer import DocXMLRPCServer import time # Create server server = DocXMLRPCServer(("localhost", 8000)) # Register a function def echo(message): "Accepts a message parameter and returns it unchanged." return message # New functions for lab exercise def time(): "Returns the current time" return time.asctime() server.register_function(echo) server.register_function(time) # Run the server's main loop server.serve_forever() # DocXMLRPCServer classes automatically create and serve documentation to # browsers, visit http://localhost:8000/ to see it.
def time(): "Returns the datetime.datetime.now() to the client. That's all." return datetime.datetime.now() def add(numbers): "Returns the sum of two numbers, separated by a '+' delimiter." numbers = numbers.split('+') print numbers number1 = int(numbers[0]) print number1 number2 = int(numbers[1]) print number2 return number1 + number2 def google_utc_time(): google_utc = json.load("http://json-time.appspot.com/time.json") print google_utc.dumps() return google_utc.datetime server.register_function(echo) server.register_function(add) server.register_function(time) server.register_function(google_utc_time) # Run the server's main loop server.serve_forever() # DocXMLRPCServer classes automatically create and serve documentation to # browsers, visit http://localhost:8000/ to see it.
#!/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()
from DocXMLRPCServer import DocXMLRPCServer # Create server server = DocXMLRPCServer(("localhost", 8000)) # Register a function def echo(message): "Accepts a message parameter and returns it unchanged." return message server.register_function(echo) # Run the server's main loop server.serve_forever() # DocXMLRPCServer classes automatically create and serve documentation to # browsers, visit http://localhost:8000/ to see it.
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()
from SimpleXMLRPCServer import SimpleXMLRPCServer from DocXMLRPCServer import DocXMLRPCServer # Create server #server = SimpleXMLRPCServer(("localhost", 8000)) server = DocXMLRPCServer(("localhost", 8000)) server.register_introspection_functions() # Register pow() function; this will use the value of # pow.__name__ as the name, which is just 'pow'. server.register_function(pow) # Register a function under a different name def adder_function(x,y): return x + y server.register_function(adder_function, 'add') # Register an instance; all the methods of the instance are # published as XML-RPC methods (in this case, just 'div'). class MyFuncs: def div(self, x, y): return x // y server.register_instance(MyFuncs()) def msg(user): return '<h1>haha%s</h1>'%user server.register_function(msg) # Run the server's main loop
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()
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)
############## # XMLRPC msg # ############################ def msg(msg): # return bot.sendMsg(msg)# ############################ #################### # Start Bot Thread # ################################################## thread.start_new_thread(bot.Listen,('DevBot-1',))# ################################################## ####################### # Setup XMLRPC Server # ######################################################################## query = "SELECT address,port FROM devbot WHERE LOWER(name) = 'DevBot' \ LIMIT 1" # svrnfo = db.query(query) # try: # svrnfo = svrnfo[0] # except: # print "No instance found!" # sys.exit(1) # server = DocXMLRPCServer(svrnfo, logRequests=0) # server.set_server_name("DevBot") # server.register_function(msg) # while not bot.terminateFlag: # server.handle_request() # ########################################################################