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 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()
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 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()
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 _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 _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()
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
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
def read_root(): my_logger.debug( f"{datetime.datetime.now()} - {str(random.randint(0, 100))}") print("Printing to STDOUT") return "Hello World!" example_app_address = "host.docker.internal" example_sba_address = "localhost" pyctuator = Pyctuator( app, "Example FastAPI", app_url=f"http://{example_app_address}:8000", pyctuator_endpoint_url=f"http://{example_app_address}:8000/pyctuator", registration_url=f"http://{example_sba_address}:8080/instances", app_description=app.description, ) # Keep the console clear - configure uvicorn (FastAPI's WSGI web app) not to log the detail of every incoming request uvicorn_logger = logging.getLogger("uvicorn") uvicorn_logger.setLevel(logging.WARNING) server = Server(config=(Config( app=app, loop="asyncio", host="0.0.0.0", logger=uvicorn_logger, ))) server.run()
def main(): config = Config(app=app, host='0.0.0.0', port=int(PORT), debug=True) server = Server(config=config) server.run()
def run_server( context: Context = None, client: dask.distributed.Client = None, host: str = "0.0.0.0", port: int = 8080, startup=False, log_level=None, blocking: bool = True, jdbc_metadata: bool = False, ): # pragma: no cover """ Run a HTTP server for answering SQL queries using ``dask-sql``. It uses the `Presto Wire Protocol <https://github.com/prestodb/presto/wiki/HTTP-Protocol>`_ for communication. This means, it has a single POST endpoint `/v1/statement`, which answers SQL queries (as string in the body) with the output as a JSON (in the format described in the documentation above). Every SQL expression that ``dask-sql`` understands can be used here. See :ref:`server` for more information. Note: The presto protocol also includes some statistics on the query in the response. These statistics are currently only filled with placeholder variables. Args: context (:obj:`dask_sql.Context`): If set, use this context instead of an empty one. client (:obj:`dask.distributed.Client`): If set, use this dask client instead of a new one. host (:obj:`str`): The host interface to listen on (defaults to all interfaces) port (:obj:`int`): The port to listen on (defaults to 8080) startup (:obj:`bool`): Whether to wait until Apache Calcite was loaded log_level: (:obj:`str`): The log level of the server and dask-sql blocking: (:obj:`bool`): If running in an environment with an event loop (e.g. a jupyter notebook), do not block. The server can be stopped with `context.stop_server()` afterwards. jdbc_metadata: (:obj:`bool`): If enabled create JDBC metadata tables using schemas and tables in the current dask_sql context Example: It is possible to run an SQL server by using the CLI script ``dask-sql-server`` or by calling this function directly in your user code: .. code-block:: python from dask_sql import run_server # Create your pre-filled context c = Context() ... run_server(context=c) After starting the server, it is possible to send queries to it, e.g. with the `presto CLI <https://prestosql.io/docs/current/installation/cli.html>`_ or via sqlalchemy (e.g. using the `PyHive <https://github.com/dropbox/PyHive#sqlalchemy>`_ package): .. code-block:: python from sqlalchemy.engine import create_engine engine = create_engine('presto://localhost:8080/') import pandas as pd pd.read_sql_query("SELECT 1 + 1", con=engine) Of course, it is also possible to call the usual ``CREATE TABLE`` commands. If in a jupyter notebook, you should run the following code .. code-block:: python from dask_sql import Context c = Context() c.run_server(blocking=False) ... c.stop_server() Note: When running in a jupyter notebook without blocking, it is not possible to access the SQL server from within the notebook, e.g. using sqlalchemy. Doing so will deadlock infinitely. """ _init_app(app, context=context, client=client) if jdbc_metadata: create_meta_data(context) if startup: app.c.sql("SELECT 1 + 1").compute() config = Config(app, host=host, port=port, log_level=log_level) server = Server(config=config) loop = asyncio.get_event_loop() if blocking: if loop and loop.is_running(): apply(loop=loop) server.run() else: if not loop or not loop.is_running(): raise AttributeError( "blocking=True needs a running event loop (e.g. in a jupyter notebook)" ) loop.create_task(server.serve()) context.sql_server = server
def main(): server = Server(Config("fad.fad:app", host="0.0.0.0", port=5000), ) server.run()
def run_server(): config = Config(app=app_main, host=APP_HOST, port=APP_PORT) server = Server(config=config) server.run()