本文整理汇总了Python中xmlrpc.server.SimpleXMLRPCServer.shutdown方法的典型用法代码示例。如果您正苦于以下问题:Python SimpleXMLRPCServer.shutdown方法的具体用法?Python SimpleXMLRPCServer.shutdown怎么用?Python SimpleXMLRPCServer.shutdown使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类xmlrpc.server.SimpleXMLRPCServer
的用法示例。
在下文中一共展示了SimpleXMLRPCServer.shutdown方法的9个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: RemoteController
# 需要导入模块: 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
示例2: __init__
# 需要导入模块: 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()
示例3: RemoteController
# 需要导入模块: 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
示例4: __init__
# 需要导入模块: 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()
示例5: SimpleXMLRPCServer
# 需要导入模块: 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)
示例6: ServerThread
# 需要导入模块: 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")
示例7: __init__
# 需要导入模块: 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)
示例8: DroidMaster
# 需要导入模块: 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")
示例9: ServerThread
# 需要导入模块: 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")
#.........这里部分代码省略.........