Python simple_server.make_server方法代码示例

# 需要导入模块: from wsgiref import simple_server [as 别名]
# 或者: from wsgiref.simple_server import make_server [as 别名]
def run(self, app): # pragma: no cover
        from wsgiref.simple_server import WSGIRequestHandler, WSGIServer
        from wsgiref.simple_server import make_server
        import socket

        class FixedHandler(WSGIRequestHandler):
            def address_string(self): # Prevent reverse DNS lookups please.
                return self.client_address[0]
            def log_request(*args, **kw):
                if not self.quiet:
                    return WSGIRequestHandler.log_request(*args, **kw)

        handler_cls = self.options.get('handler_class', FixedHandler)
        server_cls  = self.options.get('server_class', WSGIServer)

        if ':' in self.host: # Fix wsgiref for IPv6 addresses.
            if getattr(server_cls, 'address_family') == socket.AF_INET:
                class server_cls(server_cls):
                    address_family = socket.AF_INET6

        srv = make_server(self.host, self.port, app, server_cls, handler_cls)
        srv.serve_forever() 

# 需要导入模块: from wsgiref import simple_server [as 别名]
# 或者: from wsgiref.simple_server import make_server [as 别名]
def main():
    gmr.TextGuruMeditation.setup_autorun(version)

    app = api_app.setup_app(argv=sys.argv)

    host = cfg.CONF.api_settings.bind_host
    port = cfg.CONF.api_settings.bind_port
    LOG.info("Starting API server on %(host)s:%(port)s",
             {"host": host, "port": port})
    if cfg.CONF.api_settings.auth_strategy != constants.KEYSTONE:
        LOG.warning('Octavia configuration [api_settings] auth_strategy is '
                    'not set to "keystone". This is not a normal '
                    'configuration and you may get "Missing project ID" '
                    'errors from API calls."')
    LOG.warning('You are running the Octavia API wsgi application using '
                'simple_server. We do not recommend this outside of simple '
                'testing. We recommend you run the Octavia API wsgi with '
                'a more full function server such as gunicorn or uWSGI.')
    srv = simple_server.make_server(host, port, app)

    srv.serve_forever() 

# 需要导入模块: from wsgiref import simple_server [as 别名]
# 或者: from wsgiref.simple_server import make_server [as 别名]
def __init__(self, host='127.0.0.1', port=0, application=None, **kwargs):
        self.app = application
        if self.port_envvar in os.environ:
            port = int(os.environ[self.port_envvar])
        self._server = make_server(
            host,
            port,
            self.app,
            handler_class=Handler,
            **kwargs
        )
        self.host = self._server.server_address[0]
        self.port = self._server.server_address[1]
        self.protocol = 'http'

        self._thread = threading.Thread(
            name=self.__class__,
            target=self._server.serve_forever,
        ) 

# 需要导入模块: from wsgiref import simple_server [as 别名]
# 或者: from wsgiref.simple_server import make_server [as 别名]
def setup_class(cls):
        from httpbin import app as httpbin_app

        cls.temp_dir = tempfile.mkdtemp('warctest')

        server = make_server('localhost', 0, httpbin_app)
        addr, cls.port = server.socket.getsockname()

        def run():
            try:
                server.serve_forever()
            except  Exception as e:
                print(e)

        thread = threading.Thread(target=run)
        thread.daemon = True
        thread.start()
        time.sleep(0.1) 

# 需要导入模块: from wsgiref import simple_server [as 别名]
# 或者: from wsgiref.simple_server import make_server [as 别名]
def builtin_httpd(address, port):
    from wsgiref.simple_server import make_server
    log.info('Starting builtin httpd...')
    server = make_server(address, port, application)
    try:
        server.serve_forever()
    except (KeyboardInterrupt, SystemExit):
        if RESPONSE_WORKER:
            log.debug('Stopping workers...')
            REQUEST_HANDLER.ipc.send(None)  # HAXX
            RESPONSE_WORKER.join()
        log.info('Finished...')


# Initialize subprocess immediately. Only use this if you use the uWSGI
# `lazy-apps` setting or have a single worker only! 

# 需要导入模块: from wsgiref import simple_server [as 别名]
# 或者: from wsgiref.simple_server import make_server [as 别名]
def _start_server(self, app):
        """Starts a server and returns its origin ("http://localhost:PORT")."""
        (_, localhost) = _localhost()
        server_class = _make_ipv6_compatible_wsgi_server()
        server = simple_server.make_server(localhost, 0, app, server_class)
        executor = futures.ThreadPoolExecutor()
        future = executor.submit(server.serve_forever, poll_interval=0.01)

        def cleanup():
            server.shutdown()  # stop handling requests
            server.server_close()  # release port
            future.result(timeout=3)  # wait for server termination

        self.addCleanup(cleanup)
        if ":" in localhost and not localhost.startswith("["):
            # IPv6 IP address, probably "::1".
            localhost = "[%s]" % localhost
        return "http://%s:%d" % (localhost, server.server_port) 

# 需要导入模块: from wsgiref import simple_server [as 别名]
# 或者: from wsgiref.simple_server import make_server [as 别名]
def roulette_server_3(count: int = 1) -> None:
    from wsgiref.simple_server import make_server
    from wsgiref.validate import validator

    wheel = American(seed=1)
    roulette = Roulette(wheel)
    debug = validator(roulette)
    httpd = make_server("", 8080, debug)
    if count is None:
        httpd.serve_forever()
    else:
        for c in range(count):
            httpd.handle_request()


# Client 

# 需要导入模块: from wsgiref import simple_server [as 别名]
# 或者: from wsgiref.simple_server import make_server [as 别名]
def roulette_server_4(count: int = 1):
    from wsgiref.simple_server import make_server
    from wsgiref.validate import validator

    wheel = American()
    roulette = Roulette(wheel)
    debug = validator(roulette)
    httpd = make_server("", 8080, debug)
    if count is None:
        httpd.serve_forever()
    else:
        for c in range(count):
            httpd.handle_request()


# Client 

# 需要导入模块: from wsgiref import simple_server [as 别名]
# 或者: from wsgiref.simple_server import make_server [as 别名]
def auth_server(count: int = 1) -> None:
    from wsgiref.simple_server import make_server
    from wsgiref.validate import validator

    secure_app = Some_App()
    authenticated_app = Authenticate(users, secure_app)
    debug = validator(authenticated_app)
    httpd = make_server("", 8080, debug)
    if count is None:
        httpd.serve_forever()
    else:
        for c in range(count):
            httpd.handle_request()


# Demo 

# 需要导入模块: from wsgiref import simple_server [as 别名]
# 或者: from wsgiref.simple_server import make_server [as 别名]
def __init__(self):
        app = falcon.API(middleware=NormalizeMiddleware())
        app.req_options.auto_parse_form_urlencoded = True
        self.attach(app)

        # Set up log handlers
        log_handlers = []
        if config.LOGGING_BACKEND == "sql":
            from certidude.mysqllog import LogHandler
            from certidude.api.log import LogResource
            uri = config.cp.get("logging", "database")
            log_handlers.append(LogHandler(uri))
        elif config.LOGGING_BACKEND == "syslog":
            from logging.handlers import SysLogHandler
            log_handlers.append(SysLogHandler())
            # Browsing syslog via HTTP is obviously not possible out of the box
        elif config.LOGGING_BACKEND:
            raise ValueError("Invalid logging.backend = %s" % config.LOGGING_BACKEND)
        from certidude.push import EventSourceLogHandler
        log_handlers.append(EventSourceLogHandler())

        for j in logging.Logger.manager.loggerDict.values():
            if isinstance(j, logging.Logger): # PlaceHolder is what?
                if j.name.startswith("certidude."):
                    j.setLevel(logging.DEBUG)
                    for handler in log_handlers:
                        j.addHandler(handler)

        self.server = make_server("127.0.1.1", self.PORT, app, WSGIServer)
        setproctitle("certidude: %s" % self.NAME) 

# 需要导入模块: from wsgiref import simple_server [as 别名]
# 或者: from wsgiref.simple_server import make_server [as 别名]
def run(self):
        server = make_server(self.host, self.port, self._app())
        self.port = server.server_port
        while not self._stopped():
            server.handle_request() 

# 需要导入模块: from wsgiref import simple_server [as 别名]
# 或者: from wsgiref.simple_server import make_server [as 别名]
def main(args=None):
    parser = ArgumentParser(description="Pyro http gateway command line launcher.")
    parser.add_argument("-H", "--host", default="localhost", help="hostname to bind server on (default=%(default)s)")
    parser.add_argument("-p", "--port", type=int, default=8080, help="port to bind server on (default=%(default)d)")
    parser.add_argument("-e", "--expose", default=pyro_app.ns_regex, help="a regex of object names to expose (default=%(default)s)")
    parser.add_argument("-g", "--gatewaykey", help="the api key to use to connect to the gateway itself")
    parser.add_argument("-t", "--timeout", type=float, default=pyro_app.comm_timeout,
                        help="Pyro timeout value to use (COMMTIMEOUT setting, default=%(default)f)")

    options = parser.parse_args(args)
    pyro_app.gateway_key = (options.gatewaykey or "").encode("utf-8")
    pyro_app.ns_regex = options.expose
    pyro_app.comm_timeout = config.COMMTIMEOUT = options.timeout
    if pyro_app.ns_regex:
        print("Exposing objects with names matching: ", pyro_app.ns_regex)
    else:
        print("Warning: exposing all objects (no expose regex set)")
    try:
        ns = get_nameserver()
    except errors.PyroError:
        print("Not yet connected to a name server.")
    else:
        print("Connected to name server at: ", ns._pyroUri)
    server = make_server(options.host, options.port, pyro_app)
    print("Pyro HTTP gateway running on http://{0}:{1}/pyro/".format(*server.socket.getsockname()))
    server.serve_forever()
    server.server_close()
    return 0 

# 需要导入模块: from wsgiref import simple_server [as 别名]
# 或者: from wsgiref.simple_server import make_server [as 别名]
def run_amock(app=hello_app, data="GET / HTTP/1.0\n\n"):
    server = make_server("", 80, app, MockServer, MockHandler)
    inp, out, err, olderr = StringIO(data), StringIO(), StringIO(), sys.stderr
    sys.stderr = err

    try:
        server.finish_request((inp,out), ("127.0.0.1",8888))
    finally:
        sys.stderr = olderr

    return out.getvalue(), err.getvalue() 

# 需要导入模块: from wsgiref import simple_server [as 别名]
# 或者: from wsgiref.simple_server import make_server [as 别名]
def run(self, handler): # pragma: no cover
        from wsgiref.simple_server import make_server, WSGIRequestHandler
        if self.quiet:
            class QuietHandler(WSGIRequestHandler):
                def log_request(*args, **kw): pass
            self.options['handler_class'] = QuietHandler
        srv = make_server(self.host, self.port, handler, **self.options)
        srv.serve_forever() 

# 需要导入模块: from wsgiref import simple_server [as 别名]
# 或者: from wsgiref.simple_server import make_server [as 别名]
def run(self, port=9000, host='127.0.0.1'):
        from wsgiref.simple_server import make_server
        print('application (%s) will start at %s:%s...' %
              (self._document_root, host, port))
        server = make_server(
            host, port, self.get_wsgi_application(debug=True))
        server.serve_forever()