Python SimpleXMLRPCServer.server_close方法代码示例

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import server_close [as 别名]
class Server(threading.Thread):
	"""
	Thread for incoming messages (server side of the peer)
	"""
	def __init__(self, peer):
		threading.Thread.__init__(self)
		self.loop = True
		self.peer = peer
		try:
			self.server = SimpleXMLRPCServer((peer.IPaddr, peer.portno), allow_none=True, logRequests = False) # we change this for not show unnecessary messages
			self.server.register_instance(self.peer)
		except Exception as e:
			print(e)
			sys.exit(0)
	
	def log(self, *msg):
		print("[%s]" % self.peer.name, *msg)
	
	def stop(self):
		self.server.server_close()
		self.loop = False

	def run(self):
		while self.loop:
			#self.log("xmlrpc server is handling a request...")
			self.server.handle_request()
		self.log("Server Done!")

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import server_close [as 别名]
	def xmlrpc_run(self, port=13100, bind='127.0.0.1', logRequests=False):
		'''Run xmlrpc server'''
		import umsgpack
		try:
			from xmlrpc.server import SimpleXMLRPCServer
			from xmlrpc.client import Binary
		except ImportError:
			from SimpleXMLRPCServer import SimpleXMLRPCServer
			from xmlrpclib import Binary

		logger.info("bloomfilter starting...")

		server = SimpleXMLRPCServer((bind, port), allow_none=True, logRequests=logRequests)
		server.register_introspection_functions()
		server.register_multicall_functions()

		server.register_function(self.quit, '_quit')

		server.register_function(self.add, 'add')

		server.timeout = 0.5
		while not self._quit:
			server.handle_request()

		logger.info("bloomfilter exiting...")
		server.server_close()

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import server_close [as 别名]
class RPCServer:
    def __init__(self, addr, port, peer):
        self.peer = peer
        self._server = SimpleXMLRPCServer((addr, port))
        self._server.register_function(self.peer.append_entry, "append_entry")
        self._server.register_function(self.peer.request_vote, "request_vote")

    def start(self):
        server_thread = threading.Thread(target=self._server.serve_forever)
        server_thread.daemn = True
        server_thread.start()

    def close(self):
        self._server.shutdown()
        self._server.server_close()

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import server_close [as 别名]
def start_server():
    print('Intializing NLP engine... (this may take a while)')

    nlp.init()

    print('Starting HTTP server at <http://localhost:{port}>.'.format(port=PORT))
    if not fork_and_daemonize():
        exit(0)

    server = SimpleXMLRPCServer(('localhost', PORT), allow_none=True)
    server.register_function(ping)
    server.register_function(query)
    try:
        server.serve_forever()
    except:
        server.server_close()

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import server_close [as 别名]
class PilotwireServer:

    def __init__(self, port, debug, controller_name):
        self.xmlrpc_server = SimpleXMLRPCServer(('', port), logRequests=debug)
        manager = DriverManager(
            namespace='pilotwire.controller',
            name=controller_name,
            invoke_on_load=True,
        )
        self.controller = manager.driver
        self.xmlrpc_server.register_instance(XMLRPCMethods(self.controller))

    def start(self):
        self.xmlrpc_server.serve_forever()

    def stop(self):
        self.xmlrpc_server.shutdown()
        self.xmlrpc_server.server_close()

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import server_close [as 别名]
class ServerThread(threading.Thread):
    """XML-RPC server thread to handle messages from CCU / Homegear"""
    def __init__(   self,
                    local = LOCAL,
                    localport = LOCALPORT,
                    remote = REMOTE,
                    remoteport = REMOTEPORT,
                    devicefile = DEVICEFILE,
                    interface_id = INTERFACE_ID,
                    eventcallback = False,
                    systemcallback = False):
        global LOCAL, LOCALPORT, REMOTE, REMOTEPORT, DEVICEFILE, INTERFACE_ID
        LOG.debug("ServerThread.__init__")
        threading.Thread.__init__(self)
        INTERFACE_ID = interface_id
        LOCAL = local
        LOCALPORT = localport
        REMOTE = remote
        REMOTEPORT = remoteport
        DEVICEFILE = devicefile
        self.eventcallback = eventcallback
        self.systemcallback = systemcallback
        self.proxy = False
        
        # Setup server to handle requests from CCU / Homegear
        LOG.debug("ServerThread.__init__: Setting up server")
        self.server = SimpleXMLRPCServer( (LOCAL, int(LOCALPORT)),
                            requestHandler=RequestHandler )
        self.server.register_introspection_functions()
        self.server.register_multicall_functions()
        LOG.debug("ServerThread.__init__: Registering RPC functions")
        
        self.server.register_instance(RPCFunctions(devicefile = DEVICEFILE, proxy = self.proxy, eventcallback = self.eventcallback, systemcallback = self.systemcallback))

    def run(self):
        LOG.info("Starting server at http://%s:%i" % (LOCAL, int(LOCALPORT)))
        self.server.serve_forever()
    
    def connect(self):
        # Create proxy to interact with CCU / Homegear
        LOG.info("Creating proxy. Connecting to http://%s:%i" % (REMOTE, int(REMOTEPORT)))
        try:
            self.proxy = xmlrpc.client.ServerProxy("http://%s:%i" % (REMOTE, int(REMOTEPORT)))
        except:
            LOG.warning("Failed connecting to proxy at http://%s:%i" % (REMOTE, int(REMOTEPORT)))
            raise Exception
    
    def proxyInit(self):
        """To receive events the proxy has to tell the CCU / Homegear where to send the events. For that we call the init-method."""
        # Call init() with local XML RPC config and interface_id (the name of the receiver) to receive events. XML RPC server has to be running.
        LOG.debug("ServerThread.proxyInit: init(http://%s:%i, '%s')" % (LOCAL, int(LOCALPORT), INTERFACE_ID) )
        try:
            self.proxy.init("http://%s:%i" % (LOCAL, int(LOCALPORT)), INTERFACE_ID)
            LOG.info("Proxy initialized")
        except:
            LOG.warning("Failed to initialize proxy")
            raise Exception
    
    def stop(self):
        """To stop the server we de-init from the CCU / Homegear, then shut down our XML-RPC server."""
        if self.proxy:
            LOG.debug("ServerThread.stop: Deregistering proxy")
            try:
                self.proxy.init("http://%s:%i" % (LOCAL, int(LOCALPORT)))
            except:
                LOG.warning("Failed to deregister proxy")
        LOG.info("Shutting down server")
        self.server.shutdown()
        LOG.debug("ServerThread.stop: Stopping ServerThread")
        self.server.server_close()
        LOG.info("Server stopped")

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import server_close [as 别名]
        PWMOUT = 12

        GPIO.setmode(GPIO.BOARD)
        GPIO.setup(PWMOUT, GPIO.OUT)

        servo = GPIO.PWM(PWMOUT, 50)
        servo.start(0.0)

        dc = 0.0
        for ii in range(5):

            for dc in range(2, 14, 1):
                servo.ChangeDutyCycle(dc)
                time.sleep(0.1)

            for dc in range(14, 2, -1):
                servo.ChangeDutyCycle(dc)
                time.sleep(0.1)

        servo.stop()
        GPIO.cleanup()

if __name__ == "__main__":
    server = SimpleXMLRPCServer((SERVER, PORT), allow_none=True)
    server.register_instance(SERVOFunc())
    try:
        server.serve_forever()
    finally:
        server.server_close()
        sys.exit(0)

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import server_close [as 别名]
class ServerThread(threading.Thread):
    """XML-RPC server thread to handle messages from CCU / Homegear"""
    def __init__(self,
                 local=LOCAL,
                 localport=LOCALPORT,
                 remotes=REMOTES,
                 devicefile=DEVICEFILE,
                 interface_id=INTERFACE_ID,
                 eventcallback=False,
                 systemcallback=False,
                 resolveparamsets=False):
        LOG.debug("ServerThread.__init__")
        threading.Thread.__init__(self)

        # Member
        self._interface_id = interface_id
        self._local = local
        self._localport = int(localport)
        self._devicefile = devicefile
        self.remotes = remotes
        self.eventcallback = eventcallback
        self.systemcallback = systemcallback
        self.resolveparamsets = resolveparamsets
        self.proxies = {}

        # Create proxies to interact with CCU / Homegear
        LOG.debug("__init__: Creating proxies")
        for remote, host in self.remotes.items():
            try:
                socket.inet_pton(socket.AF_INET, host['ip'])
            except Exception as err:
                LOG.warning("Skipping proxy: %s" % str(err))
                continue
            LOG.info("Creating proxy %s. Connecting to http://%s:%i" % (remote, host['ip'], host['port']))
            try:
                self.proxies["%s-%s" % (self._interface_id, remote)] = LockingServerProxy("http://%s:%i" % (host['ip'], host['port']))
            except Exception as err:
                LOG.warning("Failed connecting to proxy at http://%s:%i" % (host['ip'], host['port']))
                LOG.debug("__init__: Exception: %s" % str(err))
                raise Exception

        if not self.proxies:
            LOG.warning("No proxies available. Aborting.")
            raise Exception

        self._rpcfunctions = RPCFunctions(devicefile=self._devicefile,
                                          proxies=self.proxies,
                                          remotes=self.remotes,
                                          eventcallback=self.eventcallback,
                                          systemcallback=self.systemcallback,
                                          resolveparamsets=self.resolveparamsets)

        # Setup server to handle requests from CCU / Homegear
        LOG.debug("ServerThread.__init__: Setting up server")
        self.server = SimpleXMLRPCServer((self._local, self._localport),
                                         requestHandler=RequestHandler,
                                         logRequests=False)
        self._localport = self.server.socket.getsockname()[1]
        self.server.register_introspection_functions()
        self.server.register_multicall_functions()
        LOG.debug("ServerThread.__init__: Registering RPC functions")
        self.server.register_instance(self._rpcfunctions, allow_dotted_names=True)

    def run(self):
        LOG.info("Starting server at http://%s:%i" % (self._local, self._localport))
        self.server.serve_forever()

    def proxyInit(self):
        """
        To receive events the proxy has to tell the CCU / Homegear where to send the events. For that we call the init-method.
        """
        # Call init() with local XML RPC config and interface_id (the name of the receiver) to receive events. XML RPC server has to be running.
        for interface_id, proxy in self.proxies.items():
            LOG.debug("ServerThread.proxyInit: init('http://%s:%i', '%s')" % (proxy._localip, self._localport, interface_id))
            try:
                proxy.init("http://%s:%i" % (proxy._localip, self._localport), interface_id)
                LOG.info("Proxy initialized")
            except Exception as err:
                LOG.debug("proxyInit: Exception: %s" % str(err))
                LOG.warning("Failed to initialize proxy")
                raise Exception

    def stop(self):
        """To stop the server we de-init from the CCU / Homegear, then shut down our XML-RPC server."""
        stopped = []
        for interface_id in self.proxies:
            if not self.proxies[interface_id]._localip in stopped:
                LOG.debug("ServerThread.stop: Deregistering proxy for server %s" % self.proxies[interface_id]._localip)
                try:
                    self.proxies[interface_id].init("http://%s:%i" % (self.proxies[interface_id]._localip, self._localport))
                    stopped.append(self.proxies[interface_id]._localip)
                except Exception as err:
                    LOG.warning("Failed to deregister proxy")
                    LOG.debug("stop: Exception: %s" % str(err))
        del self.proxies[:]
        LOG.info("Shutting down server")
        self.server.shutdown()
        LOG.debug("ServerThread.stop: Stopping ServerThread")
        self.server.server_close()
        LOG.info("Server stopped")
#.........这里部分代码省略.........