Python SimpleXMLRPCServer.register_multicall_functions方法代码示例

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import register_multicall_functions [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 register_multicall_functions [as 别名]
def main():
    server = SimpleXMLRPCServer(('127.0.0.1', 7001))
    server.register_introspection_functions()
    server.register_multicall_functions()
    server.register_function(addtogether)
    server.register_function(quadratic)
    server.register_function(remote_repr)
    print("Server ready")
    server.serve_forever()

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import register_multicall_functions [as 别名]
def run_server():
    server = SimpleXMLRPCServer(('localhost', 9000))
    server.register_function(pow)
    server.register_function(lambda x, y: x+y, 'add')
    server.register_multicall_functions()
    server.serve_forever()

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import register_multicall_functions [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 register_multicall_functions [as 别名]
def on_discard(result):
    print("Discard: ", result)
    return True

def on_finished(result):
    print("Order finished:", result)
    return True
        
if __name__ == '__main__':
    orderid = count()

    # start server to get the result...
    server = SimpleXMLRPCServer(("localhost", 43222), logRequests=False)
    print("Listening on port 43222...")
    server.register_multicall_functions()
    server.register_function(on_result, 'on_result')
    server.register_function(on_discard, 'on_discard')
    server.register_function(on_finished, 'on_finished')
    thread = threading.Thread(target=server.serve_forever)
    # Exit the server thread when the main thread terminates
    thread.setDaemon(True)
    thread.start()
    
    s = xmlrpc.client.ServerProxy('http://localhost:45312/unisono')
    # Print list of available methods
    print("we do some stuff")
    print(s.system.listMethods())
    print(s.system.methodHelp('list_available_dataitems'))
    print(s.system.methodHelp('cancel_order'))
    myID = s.register_connector(43222)

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import register_multicall_functions [as 别名]
#!/usr/bin/env python
from xmlrpc.server import SimpleXMLRPCServer
import xmlrpc.client
import os

class ServerFunc:
    def read_chat(self,file):
        with open(file, 'rb') as chat:
            return xmlrpc.client.Binary(chat.read())

    def write_chat(self,file,user,message):
        with open(file, 'a') as chat:
            chat.write(user + ' says:' + message + '\n')
            return 1
        
    def ls_chats(self):
        listing = str(os.listdir('.').pop(os.sys.argv[0]))
        return xmlrpc.client.Binary(listing)
    
if __name__ == '__main__':
    chat_server = SimpleXMLRPCServer(('127.0.0.1', 10000))
    chat_server.register_instance(ServerFunc(),allow_dotted_names=True)
    chat_server.register_function(ServerFunc().read_chat, 'read_chat')
    chat_server.register_multicall_functions()
    print('server is running')
    chat_server.serve_forever()

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import register_multicall_functions [as 别名]
#!/usr/bin/python3.4
# -*- coding=utf-8 -*-
#本脚由亁颐堂现任明教教主编写，用于乾颐盾Python课程！
#教主QQ:605658506
#亁颐堂官网www.qytang.com
#乾颐盾是由亁颐堂现任明教教主开发的综合性安全课程
#包括传统网络安全（防火墙，IPS...）与Python语言和黑客渗透课程！

#参考原始文档
#https://docs.python.org/3.1/library/xmlrpc.client.html#example-of-client-and-server-usage

import datetime
from xmlrpc.server import SimpleXMLRPCServer
import xmlrpc.client

def is_even(n):#创建函数，判断奇数偶数
    return n%2 == 0

def today():#创建函数，返回时间
    today = datetime.datetime.today()
    return xmlrpc.client.DateTime(today)

server = SimpleXMLRPCServer(("127.0.0.1", 8000))
print("Listening on port 8000...")
server.register_multicall_functions()#启动多函数注册功能！
server.register_function(is_even, "is_even")#注册函数，名字为"is_even"
server.register_function(today, "today")#注册函数，名字为"today"
server.serve_forever()#运行服务器

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