Python SimpleXMLRPCServer.register_instance方法代码示例

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

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import register_instance [as 别名]
class NetServer(Thread):

    def __init__(self, port=8080, logRequests=True):
        Thread.__init__(self)
        self.__port = port
        self.__logRequests = logRequests
        self.__server = None
        self.__running = False
        self.State = None
        self.start()
        while not self.__running:
            sleep(0)

    def stop(self):
        if self.State is not None:
            self.State.set_update_period(0)
        self.__server.shutdown()
        self.__server.server_close()
        self.join()

    def run(self):
        #register API
        self.State = NetServerState() # accessor for state object for tests and shutting down, etc
        self.__server = SimpleXMLRPCServer(("127.0.0.1", self.__port), CrossDomainXMLRPCRequestHandler, logRequests=self.__logRequests)
        self.__server.register_instance(self.State)
        self.__server.register_introspection_functions()

        #start server
        self.__running = True
        self.__server.serve_forever()

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

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import register_instance [as 别名]
def start_server(obj):
	"""
		Purpose:
		Start the XML-RPC server and register the "obj" class.
	"""
	try:
		commandServer = SimpleXMLRPCServer(('', 9000), allow_none=True)

		commandServer.register_introspection_functions()
		commandServer.register_instance(obj)

		print("{} - Starting to server forever".format(time.asctime()))
		#Now keep the server alive till killed or system reboots
		commandServer.serve_forever()

	except KeyboardInterrupt as err:
		print("{} - Keyboard Interrupt. Exiting.".format(time.asctime()))
		return

	except Exception as err:
		print(err)
		raise err

	except System.Exception as err:
		print(err)
		raise err

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

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import register_instance [as 别名]
def rpcserver():
    server = SimpleXMLRPCServer(('localhost', 8000), requestHandler=TestRequestHandler)
    server.register_introspection_functions()
    server.register_function(pow)
    server.register_function(adder_func, 'add')
    server.register_instance(TestRPCClass())

    server.serve_forever()

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import register_instance [as 别名]
    def test_exposeClass(self):
        """Expose an entire class and test the _dispatch method."""
        server = SimpleXMLRPCServer((HOST, PORT + 3))
        server.register_instance(MyService())
        ServerThread(server).start()

        # Access the exposed service.
        client = xmlrpc.client.ServerProxy("http://%s:%d" % (HOST, PORT + 3))
        self.assertEqual(client.squared(10), 100)

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import register_instance [as 别名]
def start():
    #NOTE: bots directory should always be on PYTHONPATH - otherwise it will not start.
    #***command line arguments**************************
    usage = '''
    This is "%(name)s" version %(version)s, part of Bots open source edi translator (http://bots.sourceforge.net).
    Server program that ensures only a single bots-engine runs at any time, and no engine run requests are
    lost/discarded. Each request goes to a queue and is run in sequence when the previous run completes.
    Use of the job queue is optional and must be configured in bots.ini (jobqueue section, enabled = True).
    Usage:
        %(name)s  -c<directory>
    Options:
        -c<directory>   directory for configuration files (default: config).

    ''' % {'name': os.path.basename(sys.argv[0]), 'version': 3.3}
    configdir = 'config'
    for arg in sys.argv[1:]:
        if arg.startswith('-c'):
            configdir = arg[2:]
            if not configdir:
                print('Error: configuration directory indicated, but no directory name.')
                sys.exit(1)
        else:
            print(usage)
            sys.exit(0)
    #***end handling command line arguments**************************
    #~ botsinit.generalinit(configdir)     #find locating of bots, configfiles, init paths etc.
    #~ if not botsglobal.ini.getboolean('jobqueue','enabled',False):
        #~ print('Error: bots jobqueue cannot start; not enabled in %s/bots.ini'%(configdir))
        #~ sys.exit(1)
    nr_threads = 2  # botsglobal.ini.getint('jobqueue','nr_threads')
    process_name = 'jobqueue'
    #~ logger = botsinit.initserverlogging(process_name)
    #~ logger.log(25,'Bots %(process_name)s started.',{'process_name':process_name})
    #~ logger.log(25,'Bots %(process_name)s configdir: "%(configdir)s".',{'process_name':process_name,'configdir':botsglobal.ini.get('directories','config')})
    port = 28082  # botsglobal.ini.getint('jobqueue','port',28082)
    #~ logger.log(25,'Bots %(process_name)s listens for xmlrpc at port: "%(port)s".',{'process_name':process_name,'port':port})

    #start launcher thread
    lauchfrequency = 5  # botsglobal.ini.getint('jobqueue','lauchfrequency',5)
    maxruntime = 60  # botsglobal.ini.getint('settings','maxruntime',60)
    for thread in range(nr_threads)
        launcher_thread = threading.Thread(name='launcher', target=launcher,
                                           args=(logger, queue, lauchfrequency, maxruntime))
        launcher_thread.start()
        #~ logger.info('Jobqueue launcher started.')

    #the main thread is the xmlrpc server: all adding, getting etc for jobqueue is done via xmlrpc.
    #~ logger.info('Jobqueue server started.')
    server = SimpleXMLRPCServer(('localhost', port), logRequests=False)
    server.register_instance(Jobqueue(logger))
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        pass

    sys.exit(0)

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import register_instance [as 别名]
def serve_agent(agent, address, port):
    """Serve agent on specified bind address and port number."""
    from xmlrpc.server import SimpleXMLRPCServer
    server = SimpleXMLRPCServer((address, port), allow_none=True)
    server.register_instance(agent)
    print("Listening on ", address, ":", port, sep="")
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        pass

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import register_instance [as 别名]
def serve_player(player, address, port):
    """Serve player on specified bind address and port number."""
    from xmlrpc.server import SimpleXMLRPCServer
    server = SimpleXMLRPCServer((address, port))
    server.register_instance(player)
    print("Listening on " + address + ":" + str(port))
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        pass

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import register_instance [as 别名]
def main():
    logging.basicConfig(format="%(asctime)s %(levelname)s "
                               "%(filename)s:%(lineno)d %(message)s")

    LOG.setLevel(logging.INFO)

    LOG.info("psutil version %s at %s", psutil.__version__, psutil.__file__)

    server = SimpleXMLRPCServer(("0.0.0.0", 9002))
    server.register_introspection_functions()
    server.register_instance(MonHelperRPCInterface())
    server.serve_forever()

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import register_instance [as 别名]
 def _start(self):
     '''
     Start the server part of client.
     '''
     global PORT
     global ADDRESS
     try:
         server = SimpleXMLRPCServer((ADDRESS, PORT))
         server.register_instance(self)
         server.serve_forever()
     except:
         PORT+=1
         self._start()

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import register_instance [as 别名]
def main():
    host = "localhost"
    port = 7500

    data_handler = DatabaseHandler()
    
    try:
        server = SimpleXMLRPCServer((host, port))
        server.register_instance(data_handler)
        server.serve_forever()
    except KeyboardInterrupt:
        print("Caught control-c, closing database connection")
        data_handler.close()

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