Python SimpleXMLRPCServer.__init__方法代码示例

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import __init__ [as 别名]
    def __init__(self, dbfile, logfile, interface, daemon=True):
        ''' constructor '''
        try:
            SimpleXMLRPCServer.__init__(self, interface,
                                        logRequests=False, allow_none=True)
        except socket.error:
            ip=socket.gethostbyname(interface[0])
            port=interface[1]
            msg="PR Server unable to bind to %s:%s\n" % (ip, port)
            sys.stderr.write(msg)
            raise PRServiceConfigError

        self.dbfile=dbfile
        self.daemon=daemon
        self.logfile=logfile
        self.working_thread=None
        self.host, self.port = self.socket.getsockname()
        self.pidfile=PIDPREFIX % (self.host, self.port)

        self.register_function(self.getPR, "getPR")
        self.register_function(self.quit, "quit")
        self.register_function(self.ping, "ping")
        self.register_function(self.export, "export")
        self.register_function(self.dump_db, "dump_db")
        self.register_function(self.importone, "importone")
        self.register_introspection_functions()

        self.requestqueue = queue.Queue()
        self.handlerthread = threading.Thread(target = self.process_request_thread)
        self.handlerthread.daemon = False

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import __init__ [as 别名]
 def __init__(self, port=8270, port_file=None):
     SimpleXMLRPCServer.__init__(self, ("127.0.0.1", int(port)))
     self.register_function(self.get_keyword_names)
     self.register_function(self.get_keyword_documentation)
     self.register_function(self.run_keyword)
     announce_port(self.socket, port_file)
     self.serve_forever()

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import __init__ [as 别名]
 def __init__(self, addr, log_requests=1):
     """
     Overrides SimpleXMLRPCServer to set option to allow_reuse_address.
     """
     # allow_reuse_address defaults to False in Python 2.4.  We set it 
     # to True to allow quick restart on the same port.  This is equivalent 
     # to calling setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
     self.allow_reuse_address = True
     if rosgraph.network.use_ipv6():
         logger = logging.getLogger('xmlrpc')
         # The XMLRPC library does not support IPv6 out of the box
         # We have to monipulate private members and duplicate
         # code from the constructor.
         # TODO IPV6: Get this into SimpleXMLRPCServer 
         SimpleXMLRPCServer.__init__(self, addr, SilenceableXMLRPCRequestHandler, log_requests,  bind_and_activate=False)
         self.address_family = socket.AF_INET6
         self.socket = socket.socket(self.address_family, self.socket_type)
         logger.info('binding ipv6 xmlrpc socket to' + str(addr))
         # TODO: set IPV6_V6ONLY to 0:
         # self.socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
         self.server_bind()
         self.server_activate()
         logger.info('bound to ' + str(self.socket.getsockname()[0:2]))
         # TODO IPV6: check Windows compatibility
         # [Bug #1222790] If possible, set close-on-exec flag; if a
         # method spawns a subprocess, the subprocess shouldn't have
         # the listening socket open.
         if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
             flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
             flags |= fcntl.FD_CLOEXEC
             fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
     else:
         SimpleXMLRPCServer.__init__(self, addr, SilenceableXMLRPCRequestHandler, log_requests)

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import __init__ [as 别名]
 def __init__(self, addr, log_requests=1):
     """
     Overrides SimpleXMLRPCServer to set option to allow_reuse_address.
     """
     # allow_reuse_address defaults to False in Python 2.4.  We set it 
     # to True to allow quick restart on the same port.  This is equivalent 
     # to calling setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
     self.allow_reuse_address = True
     if rosgraph.network.use_ipv6():
         logger = logging.getLogger('xmlrpc')
         # The XMLRPC library does not support IPv6 out of the box
         # We have to monipulate private members and duplicate
         # code from the constructor.
         # TODO IPV6: Get this into SimpleXMLRPCServer 
         SimpleXMLRPCServer.__init__(self, addr, SilenceableXMLRPCRequestHandler, log_requests,  bind_and_activate=False)
         self.address_family = socket.AF_INET6
         self.socket = socket.socket(self.address_family, self.socket_type)
         logger.info('binding ipv6 xmlrpc socket to' + str(addr))
         # TODO: set IPV6_V6ONLY to 0:
         # self.socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
         self.server_bind()
         self.server_activate()
         logger.info('bound to ' + str(self.socket.getsockname()[0:2]))
     else:
         SimpleXMLRPCServer.__init__(self, addr, SilenceableXMLRPCRequestHandler, log_requests)

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import __init__ [as 别名]
 def __init__(self, library, port=8270, port_file=None):
     SimpleXMLRPCServer.__init__(self, ('127.0.0.1', int(port)))
     self.library = library
     self._shutdown = False
     self._register_functions()
     announce_port(self.socket, port_file)
     self.serve_forever()

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import __init__ [as 别名]
 def __init__(self, addr, log_requests=1):
     """
     Overrides SimpleXMLRPCServer to set option to allow_reuse_address.
     """
     # allow_reuse_address defaults to False in Python 2.4.  We set it 
     # to True to allow quick restart on the same port.  This is equivalent 
     # to calling setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
     self.allow_reuse_address = True
     SimpleXMLRPCServer.__init__(self, addr, SilenceableXMLRPCRequestHandler, log_requests)

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import __init__ [as 别名]
 def __init__(self, library, port=8270, port_file=None):
     SimpleXMLRPCServer.__init__(self, ('127.0.0.1', int(port)))
     self.library = library
     self._shutdown = False
     self.register_function(self.get_keyword_names)
     self.register_function(self.get_keyword_arguments)
     self.register_function(self.run_keyword)
     announce_port(self.socket, port_file)
     self.serve_forever()

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import __init__ [as 别名]
    def __init__(self, bind_address, bind_port=61209,
                 requestHandler=GlancesXMLRPCHandler):

        try:
            self.address_family = socket.getaddrinfo(bind_address, bind_port)[0][0]
        except socket.error as e:
            logger.error("Couldn't open socket: {0}".format(e))
            sys.exit(1)

        SimpleXMLRPCServer.__init__(self, (bind_address, bind_port),
                                    requestHandler)

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import __init__ [as 别名]
 def __init__(
     self,
     addr,
     log=None,
     requestHandler=SAMPSimpleXMLRPCRequestHandler,
     logRequests=True,
     allow_none=True,
     encoding=None,
 ):
     self.log = log
     SimpleXMLRPCServer.__init__(self, addr, requestHandler, logRequests, allow_none, encoding)

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import __init__ [as 别名]
 def __init__(self, *args, **kwargs):
     class AuthRequestHandler(SimpleXMLRPCRequestHandler):
         def parse_request(myself):
             if SimpleXMLRPCRequestHandler.parse_request(myself):
                 if self.authenticate(myself.headers):
                     return True
                 else:
                     myself.send_error(401, "Authentication failure")
                     return False
     SimpleXMLRPCServer.__init__(self, requestHandler=AuthRequestHandler,
                                 *args, **kwargs
                                 )

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import __init__ [as 别名]
    def __init__(self,host,port,username,password,*args,**kargs):
        self.username = username
        self.password = password

        class VerifyingRequestHandler(SimpleXMLRPCRequestHandler):
            def parse_request(request):
                if SimpleXMLRPCRequestHandler.parse_request(request):
                    if self.authenticate(request.headers):
                        return True

                    else:
                        request.send_error(401,'Authentication failed,try again')
                return False

        SimpleXMLRPCServer.__init__(self,(host,port),requestHandler = VerifyingRequestHandler,*args,**kargs)

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import __init__ [as 别名]
    def __init__(self, interface, cooker, parent):
        # Use auto port configuration
        if (interface[1] == -1):
            interface = (interface[0], 0)
        SimpleXMLRPCServer.__init__(self, interface,
                                    requestHandler=BitBakeXMLRPCRequestHandler,
                                    logRequests=False, allow_none=True)
        self.host, self.port = self.socket.getsockname()
        self.interface = interface

        self.connection_token = None
        self.commands = BitBakeXMLRPCServerCommands(self)
        self.register_functions(self.commands, "")

        self.cooker = cooker
        self.parent = parent

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import __init__ [as 别名]
 def __init__(self, interface, single_use=False):
     """
     Constructor
     """
     BaseImplServer.__init__(self)
     self.single_use = single_use
     # Use auto port configuration
     if (interface[1] == -1):
         interface = (interface[0], 0)
     SimpleXMLRPCServer.__init__(self, interface,
                                 requestHandler=BitBakeXMLRPCRequestHandler,
                                 logRequests=False, allow_none=True)
     self.host, self.port = self.socket.getsockname()
     self.connection_token = None
     #self.register_introspection_functions()
     self.commands = BitBakeServerCommands(self)
     self.autoregister_all_functions(self.commands, "")
     self.interface = interface

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import __init__ [as 别名]
 def __init__(self, serverConfig):
     self.config = serverConfig
     SimpleXMLRPCServer.__init__(self, (self.config.server.hostname, \
             self.config.server.port))
     
     self.logger = logging.getLogger("xmlrpcserver::%s:%s" % (\
             self.config.server.hostname, self.config.server.port))
     self.logger.setLevel(logging.INFO)
     
     lh = logging.StreamHandler()
     lh.setLevel(logging.INFO)
     formatter = logging.Formatter('%(asctime)s::%(name)s::%(message)s')
     lh.setFormatter(formatter)
     self.logger.addHandler(lh)
     
     self.methodHelpList = {}
     self.methodSignatureList = {}
     self._parserHelpFile()

# 需要导入模块: from xmlrpc.server import SimpleXMLRPCServer [as 别名]
# 或者: from xmlrpc.server.SimpleXMLRPCServer import __init__ [as 别名]
    def __init__(self, host='localhost', port=4966,
                 logRequests=False, allow_none=True,
                 keepalive_time=3*24*3600):
        self.out_buffer = []

        self.larch = Interpreter(writer=self)
        self.larch.input.prompt = ''
        self.larch.input.prompt2 = ''
        self.larch.run_init_scripts()

        self.larch('_sys.client = group(keepalive_time=%f)' % keepalive_time)
        self.larch('_sys.wx = group(wxapp=None)')
        _sys = self.larch.symtable._sys
        _sys.color_exceptions = False
        _sys.client.last_event = int(time())
        _sys.client.pid_server = int(os.getpid())
        _sys.client.app = 'unknown'
        _sys.client.pid = 0
        _sys.client.user = 'unknown'
        _sys.client.machine = socket.getfqdn()

        self.client = self.larch.symtable._sys.client
        self.port = port
        SimpleXMLRPCServer.__init__(self, (host, port),
                                    logRequests=logRequests,
                                    allow_none=allow_none)

        self.register_introspection_functions()
        self.register_function(self.larch_exec, 'larch')

        for method in ('ls', 'chdir', 'cd', 'cwd', 'shutdown',
                        'set_keepalive_time', 'set_client_info',
                        'get_client_info', 'get_data', 'get_rawdata',
                        'get_messages', 'len_messages'):
            self.register_function(getattr(self, method), method)

        # sys.stdout = self
        self.finished = False
        signal.signal(signal.SIGINT, self.signal_handler)
        self.activity_thread = Thread(target=self.check_activity)