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 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())
async def create_server(config):
server = Server(config)
task = asyncio.ensure_future(server.serve())
try:
yield task
finally:
await server.shutdown()
task.cancel()
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 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")
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 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())
app = VersionedFastAPI(app, version="1.0.0", prefix_format="/v{major}.{minor}", enable_latest=True)
@app.get("/")
async def read_items() -> Any:
html_content = """
<html>
<head>
<title>NMEA Injector</title>
</head>
</html>
"""
return HTMLResponse(content=html_content, status_code=200)
if __name__ == "__main__":
loop = asyncio.new_event_loop()
# # Running uvicorn with log disabled so loguru can handle it
config = Config(app=app, loop=loop, host="0.0.0.0", port=2748, log_config=None)
server = Server(config)
loop.create_task(controller.load_socks_from_settings())
if args.udp:
loop.create_task(controller.add_sock(NMEASocket(kind=SocketKind.UDP, port=args.udp, component_id=220)))
if args.tcp:
loop.create_task(controller.add_sock(NMEASocket(kind=SocketKind.TCP, port=args.tcp, component_id=221)))
loop.run_until_complete(server.serve())
</html>
"""
return HTMLResponse(content=html_content, status_code=200)
if __name__ == "__main__":
loop = asyncio.new_event_loop()
# # Running uvicorn with log disabled so loguru can handle it
config = Config(app=app,
loop=loop,
host="0.0.0.0",
port=2748,
log_config=None)
server = Server(config)
if args.udp:
loop.create_task(
controller.add_sock(
NMEASocket(kind=SocketKind.UDP,
port=args.udp,
component_id=220)))
if args.tcp:
loop.create_task(
controller.add_sock(
NMEASocket(kind=SocketKind.TCP,
port=args.tcp,
component_id=221)))
loop.create_task(server.serve())
loop.run_forever()
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 start(self):
loop = asyncio.get_event_loop()
config = Config(app=self._web, host="0.0.0.0", port=8083)
server = Server(config)
loop.run_until_complete(server.serve())