Python SimpleXMLRPCServer.shutdown方法代码示例

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import shutdown [as 别名]
class RemoteController(metaclass=Singleton):
    """
        Provide control over a SimpleXMLRPCServer.
    """

    def __init__(self, ip='localhost', port=8070):
        try:
            self.server = SimpleXMLRPCServer((ip, port), allow_none=True,
                                             logRequests=False)
            self._announcer = Announcer()
        except OSError as error:
            # If address already in use
            if error.errno == 98:
                raise Exception(
                    "Only one application instance can use this module")
            else:
                raise error

        self.server.register_introspection_functions()
        self.server.register_instance(RemoteDispatcher())

    @async
    def start(self):
        logging.info('REMOTE: Session started at ' +
                     str(self.server.server_address))

        self._announcer.start()
        self.server.serve_forever()  # Blocking
        self._announcer.stop()

        logging.info('REMOTE: Session ended')

    def stop(self):
        self.server.shutdown()

    @staticmethod
    def connect_to(uri):
        proxy = ServerProxy(uri, transport=TimeoutTransport())

        try:
            # Call a fictive method.
            proxy._()
        except Fault:
            # Connected, the method doesn't exist, which is expected.
            pass
        except socket.error:
            # Not connected, socket error mean that the service is unreachable.
            raise OSError('Session at ' + uri + ' is unreachable')

        # Just in case the method is registered in the XmlRPC server
        return proxy

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import shutdown [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 shutdown [as 别名]
class RemoteController(Thread, metaclass=Singleton):

    def __init__(self, ip='localhost', port=8070):
        super().__init__(daemon=True)
        self.setName('RemoteController')

        self.server = SimpleXMLRPCServer((ip, port), allow_none=True,
                                         logRequests=False)

        self.server.register_introspection_functions()
        self.server.register_instance(RemoteDispatcher())

        self._announcer = Announcer()

    def start(self):
        self._announcer.start()
        Thread.start(self)

    def run(self):
        logging.info('REMOTE: Session started at ' +
                     str(self.server.server_address))

        self.server.serve_forever()

        logging.info('REMOTE: Session ended')

    def stop(self):
        self.server.shutdown()
        self._announcer.stop()

    @staticmethod
    def connect_to(uri):
        proxy = ServerProxy(uri, transport=TimeoutTransport())

        try:
            # Call a fictive method.
            proxy._()
        except Fault:
            # Connected, the method doesn't exist, which is expected.
            pass
        except socket.error:
            # Not connected, socket error mean that the service is unreachable.
            raise Exception('Session at ' + uri + ' is unreachable')

        # Just in case the method is registered in the XmlRPC server
        return proxy

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import shutdown [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 shutdown [as 别名]
    server.serve_forever()


if __name__ == "__main__":

    server = SimpleXMLRPCServer(("localhost", 4711), logRequests=False)
    server.register_function(handle_reply_mail)
    
    if config.OFFLINE_MODE:
        sprint("Starting in offline mode")
    else:
        bot = telepot.Bot(config.BOT_TOKEN)
        bot.message_loop(handle_bot_message)
    sprint("Starting", config.BOT_NAME)
    # print(bot.getMe())

    sprint("Starting email worker thread")
    worker = threading.Thread(target=xmlrpc_worker)
    worker.start()

    sprint("Waiting for messages...")

    while True:
        try:
            time.sleep(10)
        except KeyboardInterrupt as ex:
            sprint("Shutting down...")
            server.shutdown()
            worker.join()
            sys.exit(0)

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import shutdown [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 shutdown [as 别名]
class ProntRPC:

    server = None

    def __init__(self, pronsole, port = RPC_PORT):
        self.pronsole = pronsole
        used_port = port
        while True:
            try:
                self.server = SimpleXMLRPCServer(("localhost", used_port),
                                                 allow_none = True,
                                                 logRequests = False)
                if used_port != port:
                    logging.warning(_("RPC server bound on non-default port %d") % used_port)
                break
            except socket.error as e:
                if e.errno == 98:
                    used_port += 1
                    continue
                else:
                    raise
        self.server.register_function(self.get_status, 'status')
        self.server.register_function(self.set_extruder_temperature,'settemp')
        self.server.register_function(self.set_bed_temperature,'setbedtemp')
        self.server.register_function(self.load_file,'load_file')
        self.server.register_function(self.startprint,'startprint')
        self.server.register_function(self.pauseprint,'pauseprint')
        self.server.register_function(self.resumeprint,'resumeprint')
        self.server.register_function(self.sendhome,'sendhome')
        self.server.register_function(self.connect,'connect')
        self.server.register_function(self.disconnect, 'disconnect')
        self.server.register_function(self.send, 'send')
        self.thread = Thread(target = self.run_server)
        self.thread.start()

    def run_server(self):
        self.server.serve_forever()

    def shutdown(self):
        self.server.shutdown()
        self.thread.join()

    def get_status(self):
        if self.pronsole.p.printing:
            progress = 100 * float(self.pronsole.p.queueindex) / len(self.pronsole.p.mainqueue)
        elif self.pronsole.sdprinting:
            progress = self.pronsole.percentdone
        else: progress = None
        if self.pronsole.p.printing or self.pronsole.sdprinting:
            eta = self.pronsole.get_eta()
        else:
            eta = None
        if self.pronsole.tempreadings:
            temps = parse_temperature_report(self.pronsole.tempreadings)
        else:
            temps = None
        z = self.pronsole.curlayer
        return {"filename": self.pronsole.filename,
                "progress": progress,
                "eta": eta,
                "temps": temps,
                "z": z,
                }
    def set_extruder_temperature(self, targettemp):
        if self.pronsole.p.online:
           self.pronsole.p.send_now("M104 S" + targettemp)

    def set_bed_temperature(self,targettemp):
        if self.pronsole.p.online:
           self.pronsole.p.send_now("M140 S" + targettemp)

    def load_file(self,filename):
        self.pronsole.do_load(filename)

    def startprint(self):
        self.pronsole.do_print("")

    def pauseprint(self):
        self.pronsole.do_pause("")

    def resumeprint(self):
        self.pronsole.do_resume("")
    def sendhome(self):
        self.pronsole.do_home("")
    def connect(self):
        self.pronsole.do_connect("")
    def disconnect(self):
        self.pronsole.do_disconnect("")
    def send(self, command):
        self.pronsole.p.send_now(command)

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

#.........这里部分代码省略.........

        self.start_device(available_devices[0], new_hda,
                          from_snapshot=True, init_script_path=init_script_path)

        calling_device["qemu"].send_command("delvm spawn")
        calling_device["qemu"].send_command("cont")

        self.successful_spawn_events.add(init_script_json)
        self.logger.info("Spawning worker")
        return True

    def start_worker(self):
        """
          Start the first worker (with device 0), used by DroidMaster itself
        """
        available_devices = self.get_available_devices()
        if not len(available_devices):
            self.logger.warning("No available device slot")
            return False

        device = available_devices[0]
        # if app image doesn't exist, create it first
        if not os.path.exists(self.qemu_app_hda):
            self.qemu_create_img(self.qemu_app_hda, self.qemu_hda)
            app_install_qemu = QEMUConn(self.qemu_app_hda,
                                        device["qemu_port"],
                                        device["adb_port"],
                                        self.qemu_no_graphic)
            app_install_qemu.set_up()
            app_install_qemu.connect()
            device["device"].wait_for_device()
            device["device"].install_app(self.app)
            app_install_qemu.disconnect()
            device["device"].shutdown()
            app_install_qemu.tear_down()

        new_hda = "%s.%d" % (self.qemu_app_hda, self.device_unique_id)
        self.qemu_create_img(new_hda, self.qemu_app_hda)

        self.start_device(available_devices[0], new_hda)
        return True

    def stop_worker(self, device_serial):
        self.stop_device(self.device_pool[device_serial])

    def start_daemon(self):
        self.server = SimpleXMLRPCServer((self.domain, self.rpc_port), RPCHandler)
        print("Listening on port %s..." % self.rpc_port)
        self.server.register_function(self.spawn, "spawn")
        self.server.register_function(self.start_worker, "start_worker")
        self.server.register_function(self.stop_worker, "stop_worker")
        self.server.serve_forever()

    def stop_daemon(self):
        print("Shutting down DroidMaster server...")
        self.server.shutdown()
        self.server_thread.join(0)

    def start(self):
        """
        start interacting
        :return:
        """
        if not self.enabled:
            return
        self.logger.info("Starting DroidMaster")

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import shutdown [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")
#.........这里部分代码省略.........