class HTTPRunner: def __init__(self, http_app: Callable): self._http_app = http_app self.log = logging.getLogger(self.__class__.__name__) self._uv_server = None def start_http(self): self.log.info("Starting the HTTP thread") self._http_thread = threading.Thread(target=self._run_uvicorn, name="HTTP-Thread") self._http_thread.start() self.log.info("HTTP thread started") def stop_http(self): self.log.info("Stopping the HTTP thread ") self._uv_server.handle_exit(None, None) self.log.info("Waiting for the HTTP thread to finish") self._http_thread.join() def _run_uvicorn(self): self.log.info("Starting a new event loop in current thread") loop = uvloop.new_event_loop() #loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) self.log.info("Running the uvicorn") from uvicorn import Server, Config uvconfig = Config(self._http_app, port=5000, log_level="debug", loop="asyncio") self._uv_server = Server(uvconfig) self._uv_server.run()
def server(self, loop): """ prepare the server and initialize it so it be ready to run inside a thread this code is inspired by the following link: - https://github.com/encode/uvicorn/issues/706#issuecomment-652220153 """ app = FastAPI() app.x = self app.redis = redis.Redis( host=self.redis_config["host"], port=self.redis_config["port"], password=self.redis_config["password"], db=self.redis_config["db"] ) app.include_router(routes.router) config = Config( app=app, loop=loop, workers=self.server_workers_count, port=self.server_listen_port, host=self.server_listen_host, access_log=self.enable_access_log, debug=False ) server = Server(config) loop.run_until_complete(server.serve())
def parse_cli(): """Run the FastAPI server""" # Find numerical value of log level try: level_num = logger.level(LOG_LEVEL).no except ValueError as err: logging.error( f"Unknown log level {err}. Use one of {', '.join(logger._core.levels)}" ) raise SystemExit() # Set up server server = Server( Config( "api.main:app", host="0.0.0.0", log_level=level_num, port=5000, proxy_headers=True, ), ) # Set up logging last, to make sure no library overwrites it (they # shouldn't, but it happens) log.init(LOG_LEVEL) # Start server server.run()
async def app(event_loop, db, request): globalregistry.reset() settings = get_db_settings(request.node) app = make_app(settings=settings, loop=event_loop) server_settings = settings.get("test_server_settings", {}) host = server_settings.get("host", "127.0.0.1") port = int(server_settings.get("port", 8000)) from uvicorn import Config, Server config = Config(app, host=host, port=port, lifespan="on") server = Server(config=config) task = asyncio.ensure_future(server.serve(), loop=event_loop) while app.app is None and not task.done(): # Wait for app initialization await asyncio.sleep(0.05) if task.done(): task.result() await _clear_dbs(app.app.root) yield host, port server.should_exit = True await asyncio.sleep(1) # There is no other way to wait for server shutdown clear_task_vars()
def start_uvicorn(): uvicorn_config = Config('src.app:app', host=settings.SERVICE_HOST, port=settings.SERVICE_PORT, log_level=settings.SERVICE_LOG_LEVEL.lower(), loop="asyncio") server = Server(config=uvicorn_config) server.run()
def run_api(bot): from uvicorn import Server, Config web_cog = bot.get_cog("web") if web_cog is None: return server = Server(Config(web_cog.app, host="0.0.0.0", port=1234)) server.config.setup_event_loop() return bot.loop.create_task(server.serve())
async def create_server(config): server = Server(config) task = asyncio.ensure_future(server.serve()) try: yield task finally: await server.shutdown() task.cancel()
async def do_tests(): # Create dummy files os.makedirs("tests") os.makedirs("tests/client") os.makedirs("tests/server") os.makedirs("tests/server/empty_dir") os.makedirs("tests/server/sub1") os.makedirs("tests/server/sub1/sub2") for filename in [ "tests/server/f1", "tests/server/f2", "tests/server/sub1/f3", "tests/server/sub1/sub2/f4", ]: async with aiofiles.open(filename, mode='wb') as f: await f.write(os.urandom(10240)) # Launch server http_mv_server.files_path = os.path.join(os.getcwd(), "tests/server") http_mv_server.files_pattern = "**" server = Server( config=Config(http_mv_server.app, host='127.0.0.1', port=8000)) loop = asyncio.get_event_loop() loop.create_task(server.serve(sockets=None)) await asyncio.sleep(2) # Create server # Launch client await http_mv_client("http://127.0.0.1:8000", "tests/client") # Check files_local = glob.glob("tests/**", recursive=True) files_supposed = [ "tests/client/f1", "tests/client/f2", "tests/client/sub1/f3", "tests/client/sub1/sub2/f4", "tests\\client\\f1", "tests\\client\\f2", "tests\\client\\sub1\\f3", "tests\\client\\sub1\\sub2\\f4", ] for file in files_local: if file in files_supposed: os.remove(file) os.rmdir("tests/client/sub1/sub2") os.rmdir("tests/client/sub1") os.rmdir("tests/client/") # Exit server server.handle_exit(None, None) await asyncio.sleep(2) # Gracefully # Clean os.rmdir("tests/server/sub1/sub2") os.rmdir("tests/server/sub1") os.rmdir("tests/server/empty_dir") os.rmdir("tests/server") os.rmdir("tests")
def _start_uvicorn(app: 'FastAPI'): config = Config(app=app, host=jinad_args.host, port=jinad_args.port_expose, loop='uvloop', log_level='error') server = Server(config=config) server.run() daemon_logger.info('Goodbye!')
def uvicorn_serve(app: 'FastAPI'): from uvicorn import Config, Server config = Config(app=app, host=server_config.HOST, port=server_config.PORT, loop='uvloop', log_level='error') server = Server(config=config) server.run()
async def run_server(config: Config, sockets=None): server = Server(config=config) cancel_handle = asyncio.ensure_future(server.serve(sockets=sockets)) await asyncio.sleep(0.1) try: yield server finally: await server.shutdown() cancel_handle.cancel()
def _start_uvicorn(app: 'FastAPI'): config = Config( app=app, host=jinad_args.host, port=jinad_args.port, loop='uvloop', log_level='error', ) server = Server(config=config) server.run()
def _start_uvicorn(app: 'FastAPI'): from .config import server_config config = Config(app=app, host=server_config.HOST, port=server_config.PORT, loop='uvloop', log_level='error') server = Server(config=config) server.run() daemon_logger.info('Bye!')
def _start_uvicorn(app: 'FastAPI'): config = Config(app=app, host=jinad_args.host, port=jinad_args.port_expose, loop='uvloop', log_level='error') server = Server(config=config) server.run() from jina import __stop_msg__ daemon_logger.success(__stop_msg__)
def _run_uvicorn(self): self.log.info("Starting a new event loop in current thread") loop = uvloop.new_event_loop() #loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) self.log.info("Running the uvicorn") from uvicorn import Server, Config uvconfig = Config(self._http_app, port=5000, log_level="debug", loop="asyncio") self._uv_server = Server(uvconfig) self._uv_server.run()
def __init__(self, name: str, port: Optional[int] = None, **kwargs): """ Args: name: the name of the service port: the port to bind to when serving, default will bind to an available port **kwargs: forwarded to the uvicorn configuration. """ self._app = Starlette(debug=True) self._route_lock = Lock() # since the main thread won't catch errors in handlers, this class will store any error raised while handling, # and raise them in the main thread as soon as we can self._pending_exception: Optional[Exception] = None if 'log_config' not in kwargs: log_config = deepcopy(uvicorn_logging_config) log_config['formatters']['access']['fmt'] = \ f'%(levelprefix)s {name} %(client_addr)s - "%(request_line)s" %(status_code)s' log_config['formatters']['default'][ 'fmt'] = f'%(levelprefix)s {name} %(message)s' kwargs['log_config'] = log_config kwargs.setdefault('host', '0.0.0.0') self._port = port config = Config(self._app, **kwargs, port=self._port) self._server = Server(config) self._serve_thread = Thread(name=f'{name}_thread', target=self._server.run)
async def run(self, arguments, settings, app): host = arguments.host or app.settings.get("host", "0.0.0.0") port = arguments.port or app.settings.get("address", settings.get("port")) loggers = app.settings.get("logging") if arguments.asgi_server == "uvicorn": from uvicorn import Config # type: ignore from uvicorn import Server # type: ignore from uvicorn.config import LOGGING_CONFIG # type: ignore config = Config( app, host=host, port=port, reload=arguments.reload, log_config=loggers or LOGGING_CONFIG, **app.server_settings.get("uvicorn", {}), ) server = Server(config) await server.serve() elif arguments.asgi_server == "hypercorn": from hypercorn.asyncio import serve # type: ignore from hypercorn.config import Config # type: ignore from hypercorn.logging import CONFIG_DEFAULTS # type: ignore config = Config() config.bind = [f"{host}:{port}"] config.use_reloader = arguments.reload config.logconfig_dict = loggers or CONFIG_DEFAULTS config.accesslog = "-" config.errorlog = "-" await serve(app, config) else: raise Exception(f"Server {arguments.asgi_server} not supported")
def test_fragmentation(): def receive_all(sock): chunks = [] while True: chunk = sock.recv(1024) if not chunk: break chunks.append(chunk) return b"".join(chunks) app = Response("Hello, world", media_type="text/plain") def send_fragmented_req(path): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect(("127.0.0.1", 8000)) d = ( f"GET {path} HTTP/1.1\r\n" "Host: localhost\r\n" "Connection: close\r\n\r\n" ).encode() split = len(path) // 2 sock.sendall(d[:split]) time.sleep(0.01) sock.sendall(d[split:]) resp = receive_all(sock) # see https://github.com/kmonsoor/py-amqplib/issues/45 # we skip the error on bsd systems if python is too slow try: sock.shutdown(socket.SHUT_RDWR) except Exception: # pragma: no cover pass sock.close() return resp config = Config(app=app, http="httptools") server = Server(config=config) t = threading.Thread(target=server.run) t.daemon = True t.start() time.sleep(1) # wait for uvicorn to start path = "/?param=" + "q" * 10 response = send_fragmented_req(path) bad_response = b"HTTP/1.1 400 Bad Request" assert bad_response != response[: len(bad_response)] server.should_exit = True t.join()
def setup_server(host: str, port: int, log_level: str): config = Config( "tinychronicler:server", host=host, port=port, log_level=log_level, ) server = Server(config=config) return server
async def serve(): config = Config( app=APP, host=settings.SERVER_HOST, port=settings.SERVER_PORT ) server = Server(config) await server.serve()
async def api_run(loop1): print('api') asyncio.set_event_loop(loop1) config = Config(app=app, host="0.0.0.0", loop=loop1, port=5000, reload=True) server = Server(config) await server.serve()
class UvicornServer: app: FastAPI config: Config request_state: RequestState prerun_tasks: list[Callable[[], Any]] = field(default_factory=list) def __post_init__(self): self.config.callback_notify = self.on_tick @classmethod def from_request(cls, request: UvicornServerRequest) -> UvicornServer: app = FastAPI() return cls( app=app, config=Config( app, host=request.address, port=request.port, timeout_notify=0.25, log_config=None, ), request_state=request.request_state, ) def create_server(self) -> ExplorerServer: self.server = Server(config=self.config) return ExplorerServer(main=self.run) async def on_tick(self) -> None: if self.request_state.scheduler_session.is_cancelled: print() # Linebreak after the echoed ^C on the terminal. logger.info(" => Exiting...") self.server.should_exit = True def run(self) -> ExitCode: logging.info("Starting the Explorer Web UI server...") for task in self.prerun_tasks: task() self.server.run() return 0
class SwaVanRestMockServer(SwaVanMockTask): def __init__(self, _mock: Mock): self._id = _mock.id self._mock = _mock _headers = [('server', 'swavan')] _config = Config(app=SwaVanHttp(_mock).app, host="localhost", headers=_headers, port=int(_mock.port), access_log=False) if _mock.enable_https: _key = full_path("data/__certs__/swavan.key") _crt = full_path("data/__certs__/swavan.crt") if _mock.use_default_cert: if os.path.isfile(_key) and os.path.isfile(_crt): _config.ssl_keyfile = _key _config.ssl_certfile = _crt SwaVanLogRecorder.send_log(f"Using default cert") else: if os.path.isfile(_mock.ssl_key_file_url) and os.path.isfile( _mock.ssl_cert_file_url): _config.ssl_keyfile = _mock.ssl_key_file_url _config.ssl_certfile = _mock.ssl_cert_file_url SwaVanLogRecorder.send_log(f"Using custom cert") self._core_server = Server(config=_config) def start(self): if self._core_server: self._core_server.run() def stop(self): self._core_server.should_exit = True def set_id(self, _id: str): self._id = _id def set_mock(self, _mock: Mock): self._mock = _mock @property def id(self) -> str: return self._mock.id
def setup(self): with ImportExtensions(required=True): from uvicorn import Config, Server # change log_level for REST server debugging self._server = Server(config=Config(app=self._get_fastapi_app(), host=self.args.host, port=self.args.port_expose, log_level='critical')) self.logger.success( f'{self.__class__.__name__} is listening at: {self.args.host}:{self.args.port_expose}' )
def test_default_default_headers(): config = Config(app=app, loop="asyncio", limit_max_requests=1) server = Server(config=config) thread = threading.Thread(target=server.run) thread.start() while not server.started: time.sleep(0.01) response = requests.get("http://127.0.0.1:8000") assert response.headers["server"] == "uvicorn" and response.headers["date"] thread.join()
def configure(self, value: http_pb2.Server): assert isinstance(value, http_pb2.Server), type(value) app = _healthcheck_middleware(self._app) app = OpenTelemetryMiddleware(app) config = Config( app, value.bind.host, value.bind.port, log_config=None, access_log=False, ) self.server = Server(config) logging.getLogger("uvicorn.error").setLevel(logging.ERROR)
def __init__(self, _mock: Mock): self._id = _mock.id self._mock = _mock _headers = [('server', 'swavan')] _config = Config(app=SwaVanHttp(_mock).app, host="localhost", headers=_headers, port=int(_mock.port), access_log=False) if _mock.enable_https: _key = full_path("data/__certs__/swavan.key") _crt = full_path("data/__certs__/swavan.crt") if _mock.use_default_cert: if os.path.isfile(_key) and os.path.isfile(_crt): _config.ssl_keyfile = _key _config.ssl_certfile = _crt SwaVanLogRecorder.send_log(f"Using default cert") else: if os.path.isfile(_mock.ssl_key_file_url) and os.path.isfile( _mock.ssl_cert_file_url): _config.ssl_keyfile = _mock.ssl_key_file_url _config.ssl_certfile = _mock.ssl_cert_file_url SwaVanLogRecorder.send_log(f"Using custom cert") self._core_server = Server(config=_config)
def setup_app_and_run(directory, config_path, runner, tool_override): uvicorn_config = Config(app, host="127.0.0.1", port=8889, log_level="info") uvicorn_config.setup_event_loop() server = Server(uvicorn_config) app.loop = asyncio.get_event_loop() # EM app.em = EventEmitter(app.loop) config = read_toml_config(config_path, tool_override) # TODO: Re-add support for multiple test suites app.suite = TestSuite(config["name"], runner, app.em, config) app.suites: Dict[str, TestSuite] = {config["name"]: app.suite} # Tests app.tests = Tests(app.suites) app.ws_client = WebsocketClients() app.directory = directory async def forward_notifications(message): LOGGER.debug("Forwarding to %d clients: %r", len(app.ws_client.clients), message) data = { "jsonrpc": "2.0", "id": None, "method": "test", "params": message } await app.ws_client.broadcast(json.dumps(data)) app.em.register(forward_notifications) app.em.register(process_notification) app.loop.run_until_complete(server.serve())
async def run_app(self): """ Run app with the given parameters to init. Not supposed to be used manually by user. :return: None """ config = Config(app=self.app, host=self._host, port=self._port, debug=self._debug, ssl_certfile=self._ssl_context[0], ssl_keyfile=self._ssl_context[1]) server = Server(config) await server.serve() await self._bot.close_session()
def test_override_server_header_multiple_times(): config = Config( app=app, loop="asyncio", limit_max_requests=1, headers=[("Server", "over-ridden"), ("Server", "another-value")], ) server = Server(config=config) thread = threading.Thread(target=server.run) thread.start() while not server.started: time.sleep(0.01) response = requests.get("http://127.0.0.1:8000") assert (response.headers["server"] == "over-ridden, another-value" and response.headers["date"]) thread.join()