Python server.SimpleXMLRPCServer类代码示例

class KeyValueServer:
    _rpc_methods_ = ['get', 'set', 'delete', 'exists', 'keys']
    def __init__(self, address):
        self._data = {}
        self._serv = SimpleXMLRPCServer(address, allow_none=True)
        for name in self._rpc_methods_:
            self._serv.register_function(getattr(self, name))

    def get(self, name):
        return self._data[name]

    def set(self, name, value):
        self._data[name] = value

    def delete(self, name):
        del self._data[name]

    def exists(self, name):
        return name in self._data

    def keys(self):
        return list(self._data)

    def serve_forever(self):
        self._serv.serve_forever()

class KeyValueServer:
    _rpc_methods = ["get", "set", "exists", "delete", "keys"]

    def __init__(self, address):
        self._data = {}
        self._serv = SimpleXMLRPCServer(address, allow_none=True)
        for method in self._rpc_methods:
            self._serv.register_function(getattr(self, method), method)

    def get(self, name):
        return self._data["name"]

    def set(self, name, value):
        self._data["name"] = value

    def exists(self, name):
        return name in self._data

    def delete(self, name):
        del self._data["name"]

    def keys(self):
        # dict_keys is not supported
        return list(self._data.keys())

    def serve_forever(self):
        self._serv.serve_forever()

 def _start(self):
     """
     Used internally to start the XML-RPC server.
     """
     s = SimpleXMLRPCServer(("", getPort(self.url)), logRequests=False)
     s.register_instance(self)
     s.serve_forever()

 def __init__(self, port=8270, port_file=None):
     SimpleXMLRPCServer.__init__(self, ("127.0.0.1", int(port)))
     self.register_function(self.get_keyword_names)
     self.register_function(self.get_keyword_documentation)
     self.register_function(self.run_keyword)
     announce_port(self.socket, port_file)
     self.serve_forever()

 def __init__(self, addr, log_requests=1):
     """
     Overrides SimpleXMLRPCServer to set option to allow_reuse_address.
     """
     # allow_reuse_address defaults to False in Python 2.4.  We set it 
     # to True to allow quick restart on the same port.  This is equivalent 
     # to calling setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
     self.allow_reuse_address = True
     if rosgraph.network.use_ipv6():
         logger = logging.getLogger('xmlrpc')
         # The XMLRPC library does not support IPv6 out of the box
         # We have to monipulate private members and duplicate
         # code from the constructor.
         # TODO IPV6: Get this into SimpleXMLRPCServer 
         SimpleXMLRPCServer.__init__(self, addr, SilenceableXMLRPCRequestHandler, log_requests,  bind_and_activate=False)
         self.address_family = socket.AF_INET6
         self.socket = socket.socket(self.address_family, self.socket_type)
         logger.info('binding ipv6 xmlrpc socket to' + str(addr))
         # TODO: set IPV6_V6ONLY to 0:
         # self.socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
         self.server_bind()
         self.server_activate()
         logger.info('bound to ' + str(self.socket.getsockname()[0:2]))
     else:
         SimpleXMLRPCServer.__init__(self, addr, SilenceableXMLRPCRequestHandler, log_requests)

    def __init__(self, dbfile, logfile, interface, daemon=True):
        ''' constructor '''
        try:
            SimpleXMLRPCServer.__init__(self, interface,
                                        logRequests=False, allow_none=True)
        except socket.error:
            ip=socket.gethostbyname(interface[0])
            port=interface[1]
            msg="PR Server unable to bind to %s:%s\n" % (ip, port)
            sys.stderr.write(msg)
            raise PRServiceConfigError

        self.dbfile=dbfile
        self.daemon=daemon
        self.logfile=logfile
        self.working_thread=None
        self.host, self.port = self.socket.getsockname()
        self.pidfile=PIDPREFIX % (self.host, self.port)

        self.register_function(self.getPR, "getPR")
        self.register_function(self.quit, "quit")
        self.register_function(self.ping, "ping")
        self.register_function(self.export, "export")
        self.register_function(self.dump_db, "dump_db")
        self.register_function(self.importone, "importone")
        self.register_introspection_functions()

        self.requestqueue = queue.Queue()
        self.handlerthread = threading.Thread(target = self.process_request_thread)
        self.handlerthread.daemon = False

class Server:

    def __init__(self, address):
        self._rpc_methods_ = ['get', 'put', 'put_back', 'tick', 'keys']
        self._data = {}
        self._serv = SimpleXMLRPCServer(address, allow_none=True)
        for name in self._rpc_methods_:
            self._serv.register_function(getattr(self, name))

    def get(self, key):
        return self._data[key]

    def put(self, key, value):
        self._data[key] = value

    def put_back(self, key, value):
        pass

    def tick(self):
        pass

    def keys(self):
        return list(self._data)

    def serve_forever(self):
        self._serv.serve_forever()

def runServers(xmlrpc=False,tcpPy=False):
    """Run python telnet server and info socket. They will be run at localhost on ports 9000 (or higher if used) and 21000 (or higer if used) respectively.
    
    The python telnet server accepts only connection from localhost,
    after authentication by random cookie, which is printed on stdout
    at server startup.

    The info socket provides read-only access to several simulation parameters
    at runtime. Each connection receives pickled dictionary with those values.
    This socket is primarily used by woo-multi batch scheduler.
    """
    if tcpPy:
        import woo.runtime
        srv=GenericTCPServer(handler=woo.remote.PythonConsoleSocketEmulator,title='TCP python prompt',cookie=True,minPort=9000)
        woo.runtime.cookie=srv.server.cookie
    if xmlrpc:
        if future.utils.PY3: from xmlrpc.server import SimpleXMLRPCServer
        else: from SimpleXMLRPCServer import SimpleXMLRPCServer
        port,maxPort=21000,65535 # minimum port number
        while port<maxPort:
            try:
                info=SimpleXMLRPCServer(('',port),logRequests=False,allow_none=True); break
            except socket.error: port+=1
        if port==maxPort: raise RuntimeError("No free port to listen on in range 21000-%d"%maxPort)
        # register methods, as per http://docs.python.org/library/simplexmlrpcserver.html#simplexmlrpcserver-example
        info.register_instance(InfoProvider()) # gets all defined methods by introspection
        #prov=InfoProvider()
        #for m in prov.exposedMethods(): info.register_function(m)
        _runInBackground(info.serve_forever)
        print('XMLRPC info provider on http://localhost:%d'%port)
    sys.stdout.flush()

 def __init__(self, addr, log_requests=1):
     """
     Overrides SimpleXMLRPCServer to set option to allow_reuse_address.
     """
     # allow_reuse_address defaults to False in Python 2.4.  We set it 
     # to True to allow quick restart on the same port.  This is equivalent 
     # to calling setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
     self.allow_reuse_address = True
     if rosgraph.network.use_ipv6():
         logger = logging.getLogger('xmlrpc')
         # The XMLRPC library does not support IPv6 out of the box
         # We have to monipulate private members and duplicate
         # code from the constructor.
         # TODO IPV6: Get this into SimpleXMLRPCServer 
         SimpleXMLRPCServer.__init__(self, addr, SilenceableXMLRPCRequestHandler, log_requests,  bind_and_activate=False)
         self.address_family = socket.AF_INET6
         self.socket = socket.socket(self.address_family, self.socket_type)
         logger.info('binding ipv6 xmlrpc socket to' + str(addr))
         # TODO: set IPV6_V6ONLY to 0:
         # self.socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
         self.server_bind()
         self.server_activate()
         logger.info('bound to ' + str(self.socket.getsockname()[0:2]))
         # TODO IPV6: check Windows compatibility
         # [Bug #1222790] If possible, set close-on-exec flag; if a
         # method spawns a subprocess, the subprocess shouldn't have
         # the listening socket open.
         if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
             flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
             flags |= fcntl.FD_CLOEXEC
             fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
     else:
         SimpleXMLRPCServer.__init__(self, addr, SilenceableXMLRPCRequestHandler, log_requests)

 def __init__(self, library, port=8270, port_file=None):
     SimpleXMLRPCServer.__init__(self, ('127.0.0.1', int(port)))
     self.library = library
     self._shutdown = False
     self._register_functions()
     announce_port(self.socket, port_file)
     self.serve_forever()

def run_xmlrpc_server():
  port = 1210
  oo_proxy = OOProxy()
  #server = SimpleXMLRPCServer.SimpleXMLRPCServer(("localhost", port))
  server = SimpleXMLRPCServer(("localhost", port))
  server.register_instance(oo_proxy)
  #Go into the main listener loop
  server.serve_forever()

    def test_exposeFunction2(self):
        """Expose a function using a different name via XML-RPC."""
        server = SimpleXMLRPCServer((HOST, PORT + 2))
        server.register_function(multiply, "mult")
        ServerThread(server).start()

        # Access the exposed service.
        client = xmlrpc.client.ServerProxy("http://%s:%d" % (HOST, PORT + 2))
        self.assertEqual(client.mult(7, 11), 77)

    def test_exposeFunction1(self):
        """Expose a function via XML-RPC."""
        server = SimpleXMLRPCServer((HOST, PORT + 1))
        server.register_function(multiply)
        ServerThread(server).start()

        # Access the exposed service.
        client = xmlrpc.client.ServerProxy("http://%s:%d" % (HOST, PORT + 1))
        self.assertEqual(client.multiply(5, 10), 50)

def buildServer():
    """build an XMLRPC Server and serve forever \
    waiting for problem to submit.
    """
    global config
    server = SimpleXMLRPCServer((config.get("XMLRPCServer","host"), \
		    config.getint("XMLRPCServer","port")))
    server.register_function(receive, "send")
    server.serve_forever()

def main():
    server = SimpleXMLRPCServer(("localhost", PORT))
    print("We've got a connection and are listening on port {}...huzzah".format(PORT))

    # 注册函数,这样它可以被即将创建的客户端代码使用
    server.register_function(square, "square")

    # 启动服务器
    server.serve_forever()