def start_webserver(host: int, port: int) -> None:
"""Start the Quart webserver."""
config = Config()
config.bind = [f"{host}:{port}"]
app = create_app()
asyncio.run(serve(app, config)) # type: ignore
def runserver(host: str, port: str, debug: bool, initdb: bool, verbose: bool):
"""
Run the Quart app.
:param host: Host to run it on.
:param port: Port to run it on.
:param debug: Run server in debug mode?
:param initdb: Create models before running API?
:param verbose: Set logging to DEBUG instead of INFO
"""
if verbose:
logging.basicConfig(level=logging.DEBUG)
if not run_async(
prepare_postgres(
retries=6, interval=10.0, db_uri=ENV["DB_URI"], loop=loop)):
exit(1) # Connecting to our postgres server failed.
if initdb:
run_async(safe_create_tables(verbose=verbose))
app.debug = debug
config = Config()
config.bind = [host + ":" + port]
run_async(serve(app, config))
def test_create_sockets_multiple(monkeypatch: MonkeyPatch) -> None:
mock_socket = Mock()
monkeypatch.setattr(socket, "socket", mock_socket)
config = Config()
config.bind = ["127.0.0.1", "unix:/tmp/hypercorn.sock"]
sockets = config.create_sockets()
assert len(sockets.insecure_sockets) == 2
async def start_http(self, nursery, bind_host="0.0.0.0", port=8000):
from hypercorn.config import Config
from hypercorn.trio import serve
config = Config()
config.bind = [f"{bind_host}:{port}"]
await nursery.start(serve, self.app, config)
async def __start_webserver(self):
class SinglePageApplication(StaticFiles):
async def get_response(self, path, scope):
response = await super().get_response(path, scope)
if response.status_code == 404:
response = await super().get_response('.', scope)
return response
app = FastAPI()
server_config = Config()
server_config.accesslog = '-'
server_config.behind_proxy = config['behind_proxy']
server_config.keyfile = config['keyfile']
server_config.certfile = config['certfile']
if config['production']:
server_config.bind = ['0.0.0.0:8000', '[::]:8000']
api = FastAPI()
api.include_router(router)
app.mount('/api', api)
if not config['production'] and config['cors_allow_origin']:
app.add_middleware(
CORSMiddleware,
allow_origins=config['cors_allow_origin'],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
if config['frontend_path'] is not None:
app.mount(
'/',
app=SinglePageApplication(directory=config['frontend_path'],
html=True),
)
await serve(app, server_config)
async def run_server() -> None:
async with trio_asyncio.open_loop():
asyncio._set_running_loop(asyncio.get_event_loop()) # noqa
config = HyperConfig()
config.bind = [f"127.0.0.1:5000"]
config.use_reloader = True
await serve(app, config)
def run(options, connection_uri):
from app.main import app
click.secho("Checking configuration ...", fg="yellow")
try:
urlparse(connection_uri)._replace(
path="/{{cookiecutter.project_name}}").geturl()
assert (hasattr(options, 'production'))
except Exception as e:
click.echo(e)
click.secho("Failed to validate database URI and password", fg="red")
click.secho("Starting server ...", fg="yellow")
config = Config()
config.bind = ["0.0.0.0:8080"]
config.errorlog = logger
config.accesslog = logger
if options.production:
config.loglevel = "DEBUG"
else:
config.loglevel = "INFO"
if 'uvloop' in sys.modules:
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.run_until_complete(serve(app, config))
else:
asyncio.run(serve(app, config))
async def run(config_file: Optional[TextIO], host: str, port: int,
dev: bool) -> None:
"""Run the application.
Create default folders for config and data and the default config file if
no one is given, create the fastapi app and start the server.
TODO:
* setup loging
* use a FastAPI's "start" event to setup the app, and switch back to uvicorn?
"""
if not path.exists(DEFAULT_CONFIG_FOLDER):
mkdir(DEFAULT_CONFIG_FOLDER)
if not path.exists(DEFAULT_DATA_FOLDER):
mkdir(DEFAULT_DATA_FOLDER)
######################
# read configuration #
######################
if config_file is None:
config_file = open(
path.join(XDG_CONFIG_HOME, "escarpolette", "escarpolette.conf"),
"w+")
config = Config(config_file)
config_file.close()
###############
# set logging #
###############
level = logging.INFO
if dev:
level = logging.DEBUG
logging.basicConfig(
level=level,
format=
"%(asctime)s - %(levelname)s - %(thread)d - %(name)s:%(lineno)s - %(message)s",
)
###################
# create ASGI app #
###################
app = await create_app(config)
####################
# start web server #
####################
host = host or config.HOST
port = port or config.PORT
server_config = HConfig()
server_config.bind = [f"{host}:{port}"]
loop = asyncio.get_event_loop()
future = loop.create_task(serve(app, server_config))
await future
def quart_run(self):
# looked at the hypercorn and quart Python project to figure out
# how to start the application separately, without going through
# the Quart.app.run APIs
config = HyperConfig()
config.debug = self.debug
config.access_log_format = "%(h)s %(r)s %(s)s %(b)s %(D)s"
config.accesslog = self.LOGGER
config.bind = [
"{host}:{port}".format(**{
'host': self._App_host,
'port': self._App_port
})
]
config.certfile = self._App_server_crt
config.keyfile = self._App_server_key
config.errorlog = config.accesslog
config.use_reloader = True
scheme = "https" if config.ssl_enabled else "http"
self.LOGGER.info("Running on {}://{} (CTRL + C to quit)".format(
scheme, config.bind[0]))
loop = None #asyncio.get_event_loop()
if loop is not None:
loop.set_debug(debug or False)
loop.run_until_complete(serve(self, config))
else:
asyncio.run(serve(self, config), debug=config.debug)
def handle(self, *args, **options):
port = options["port"]
set_perms = options["set_perms"]
verbosity = "-v 1" if DEBUG else "-v 0"
# Run any preconfiguration tasks
if not options["disable_preconfig"]:
preconfig_args = [
"preconfig_conreq",
options["uid"],
options["gid"],
]
if not set_perms:
preconfig_args.append("--no-perms")
call_command(*preconfig_args)
# Execute tests to ensure Conreq is healthy before starting
if not options["skip_checks"]:
call_command("test", "--noinput", "--parallel", "--failfast")
# Perform any debug related clean-up
if DEBUG:
print("Conreq is in DEBUG mode.")
print("Clearing cache...")
cache.clear()
print("Removing stale background tasks...")
self.reset_huey_db()
# Migrate the database
call_command("migrate", "--noinput", verbosity)
if not DEBUG:
# Collect static files
call_command("collectstatic", "--link", "--clear", "--noinput",
verbosity)
call_command("compress", "--force", verbosity)
# Run background task management
proc = Process(target=self.start_huey, daemon=True)
proc.start()
# Run the production webserver
if not DEBUG:
config = HypercornConfig()
config.bind = f"0.0.0.0:{port}"
config.websocket_ping_interval = 20
config.workers = 3
config.application_path = "conreq.asgi:application"
config.accesslog = ACCESS_LOG_FILE
# Additonal webserver configuration
if os.path.exists(HYPERCORN_TOML):
config.from_toml(HYPERCORN_TOML)
# Run the webserver
run_hypercorn(config)
# Run the development webserver
if DEBUG:
call_command("runserver", f"0.0.0.0:{port}")
def run(host, port):
# use 127.0.0.1 instead of localhost to avoid delays related to ipv6.
# http://werkzeug.pocoo.org/docs/serving/#troubleshooting
init_app()
config = Config()
config.bind = ["{}:{}".format(host, port)]
asyncio.run(serve(app, config), debug=True)
async def run( # type: ignore
self, # app
host: str = "127.0.0.1",
port: int = 5000,
debug: Optional[bool] = None,
ca_certs: Optional[str] = None,
certfile: Optional[str] = None,
keyfile: Optional[str] = None,
**kwargs: Any,
) -> None:
"""Run this application.
"""
config = HyperConfig()
config.access_log_format = "%(h)s %(r)s %(s)s %(b)s %(D)s"
config.access_logger = create_serving_logger() # type: ignore
config.bind = [f"{host}:{port}"]
config.ca_certs = ca_certs
config.certfile = certfile
# if debug is not None:
# config.debug = debug
config.error_logger = config.access_logger # type: ignore
config.keyfile = keyfile
config.use_reloader = False
scheme = "http" if config.ssl_enabled is None else "https"
await hyper_serve(self, config)
async def run(self):
# Serve static files from ./static
static_folder = os.path.join(os.path.dirname(__file__), 'static')
app = QuartTrio(__name__, static_folder=static_folder)
app.add_url_rule('/',
'static',
app.send_static_file,
defaults={'filename': 'index.html'})
app.add_url_rule('/<path:filename>', 'static', app.send_static_file)
app.add_url_rule('/tasks.json', 'task_tree', self.dispatch_task_tree,
['GET'])
app.add_url_rule('/task/<int:task_id>/stacktrace.json',
'task_stacktrace', self.dispatch_task_stacktrace,
['GET'])
app.add_url_rule('/nursery/<int:nursery_id>/cancel', 'nursery_cancel',
self.dispatch_nursery_cancel, ['GET'])
app.add_url_rule('/stats.json', 'stats', self.dispatch_stats, ['GET'])
config = HyperConfig()
#config.access_log_format = '%(h)s %(r)s %(s)s %(b)s %(D)s'
#config.access_logger = create_serving_logger() # type: ignore
config.bind = [f'{self._host}:{self._port}']
config.error_logger = config.access_logger # type: ignore
#trio.hazmat.add_instrument(self)
await serve(cors(app), config)
def run_app_sync(*args, loop=None, shutdown_event=None):
kwargs = {}
config = Config()
cert_file_name, key_file_name = ssl_creds or (None, None)
if cert_file_name:
kwargs['certfile'] = cert_file_name
config.certfile = cert_file_name
if key_file_name:
kwargs['keyfile'] = key_file_name
config.keyfile = key_file_name
setup_quart_logging()
config.bind = ['0.0.0.0:%s' % port]
loop = loop or ensure_event_loop()
run_kwargs = {}
if shutdown_event:
run_kwargs['shutdown_trigger'] = shutdown_event.wait
try:
try:
return loop.run_until_complete(serve(app, config, **run_kwargs))
except Exception as e:
if 'SSLError' in str(e):
c_exists = os.path.exists(cert_file_name)
k_exists = os.path.exists(key_file_name)
c_size = len(load_file(cert_file_name)) if c_exists else 0
k_size = len(load_file(key_file_name)) if k_exists else 0
LOG.warning('Unable to create SSL context. Cert files exist: %s %s (%sB), %s %s (%sB)' %
(cert_file_name, c_exists, c_size, key_file_name, k_exists, k_size))
raise
finally:
try:
_cancel_all_tasks(loop)
loop.run_until_complete(loop.shutdown_asyncgens())
finally:
asyncio.set_event_loop(None)
loop.close()
def run_app_sync(*args, loop=None, shutdown_event=None):
kwargs = {}
config = Config()
cert_file_name, key_file_name = ssl_creds or (None, None)
if cert_file_name:
kwargs['certfile'] = cert_file_name
config.certfile = cert_file_name
if key_file_name:
kwargs['keyfile'] = key_file_name
config.keyfile = key_file_name
setup_quart_logging()
config.bind = ['0.0.0.0:%s' % port]
loop = loop or ensure_event_loop()
run_kwargs = {}
if shutdown_event:
run_kwargs['shutdown_trigger'] = shutdown_event.wait
try:
return loop.run_until_complete(serve(app, config, **run_kwargs))
finally:
try:
_cancel_all_tasks(loop)
loop.run_until_complete(loop.shutdown_asyncgens())
finally:
asyncio.set_event_loop(None)
loop.close()
async def start_http(self, nursery, port=0):
from hypercorn.config import Config
from hypercorn.trio import serve
config = Config()
config.bind = [f"localhost:{port}"]
[base_url] = await nursery.start(serve, self._app, config)
self.base_url = base_url
return base_url
async def startQuart(si):
print(f"{si['serviceName']}({si['instanceID']})(v{si['serviceVersion']}) running at {si['serviceIP']}:{si['servicePort']}")
config = Config()
config.bind = [f"{si['serviceIP']}:{si['servicePort']}"]
# config.bind = [f"0.0.0.0:{si['servicePort']}"]
config.access_log_format = '%(h)s %(r)s %(s)s %(b)s %(D)s'
config.accesslog = create_serving_logger()
config.errorlog = config.accesslog
loop = asyncio.get_event_loop()
await loop.create_task(serve(app, config))
def api():
import asyncio
from hypercorn.config import Config as HypConfig
from hypercorn.asyncio import serve
hyp_config = HypConfig()
hyp_config.bind = [config.API_BIND_ADDR]
hyp_config.certfile = config.API_TLS_CERT_PATH or None
hyp_config.keyfile = config.API_TLS_KEY_PATH or None
asyncio.run(serve(app, hyp_config))
def test_create_sockets_fd(monkeypatch: MonkeyPatch) -> None:
mock_fromfd = Mock()
monkeypatch.setattr(socket, "fromfd", mock_fromfd)
config = Config()
config.bind = ["fd://2"]
sockets = config.create_sockets()
sock = sockets.insecure_sockets[0]
mock_fromfd.assert_called_with(2, socket.AF_UNIX, socket.SOCK_STREAM)
sock.setsockopt.assert_called_with(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # type: ignore
sock.setblocking.assert_called_with(False) # type: ignore
sock.set_inheritable.assert_called_with(True) # type: ignore
def start_hypercorn_server(app: Application, config: EasyDict) -> None:
"""Start the hypercorn ASGI server"""
web_config = Config()
web_config.bind = [f'{config.host}:{config.port}']
if config.ssl.enabled:
web_config.keyfile = expand_path(config.ssl.keyfile)
web_config.certfile = expand_path(config.ssl.certfile)
asyncio.run(serve(app, web_config))
async def run_server() -> None:
async with trio_asyncio.open_loop():
# trio_asyncio has difficulties with aioredis, workaround here:
# https://github.com/python-trio/trio-asyncio/issues/63 (answer from @parity3)
asyncio._set_running_loop(asyncio.get_event_loop())
config = HyperConfig()
config.bind = [f"0.0.0.0:5000"]
config.use_reloader = True
app.static_folder = "frontend"
await serve(app, config)
def start_http_server(app: Application, config: Dict[str, Any]) -> None:
"""Start the HTTP server given the ASGI application and some config.
:param app: The ASGI application.
:type app: Application
:param config: A dictionary of configuration.
:type config: Dict[str, Any]
"""
http_config = Config()
http_config.bind = [f"{config['host']}:{config['port']}"]
asyncio.run(serve(app, http_config))
def run_server_loop(app, port):
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
config = Config()
config.bind = [f"localhost:{port}"]
# As of Hypercorn 0.11.0, need to explicitly set signal handlers to a no-op
# (otherwise it will try to set signal handlers assuming it is on the main thread which throws an error)
loop.run_until_complete(
serve(app, config, shutdown_trigger=lambda: asyncio.Future()))
loop.close()
def test_create_sockets_unix(monkeypatch: MonkeyPatch) -> None:
mock_socket = Mock()
monkeypatch.setattr(socket, "socket", mock_socket)
config = Config()
config.bind = ["unix:/tmp/hypercorn.sock"]
sockets = config.create_sockets()
sock = sockets.insecure_sockets[0]
mock_socket.assert_called_with(socket.AF_UNIX, socket.SOCK_STREAM)
sock.setsockopt.assert_called_with(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # type: ignore
sock.bind.assert_called_with("/tmp/hypercorn.sock") # type: ignore
sock.setblocking.assert_called_with(False) # type: ignore
sock.set_inheritable.assert_called_with(True) # type: ignore
async def start_server(root: str, debug: bool, port: int) -> None:
app.config["DEBUG"] = debug
cfg = Config()
cfg.bind = [f"localhost:{port}"]
async with open_watcher(root) as watcher:
app.config["REFRESHER_WATCHER"] = watcher
logger.info("Serving and watching: %s", watcher.root.resolve())
# https://pgjones.gitlab.io/hypercorn/how_to_guides/api_usage.html
await serve(app, cfg)
def serve(title: str, description: str, mapping: Dict[str, Definition],
port: int):
app = FastAPI(title=title, description=description)
router = GeneratedRouter(mapping)
app.include_router(router)
conf = Config()
conf.bind = [f"0.0.0.0:{port}"]
loop = asyncio.get_event_loop()
loop.add_signal_handler(signal.SIGTERM, _signal_handler)
loop.run_until_complete(
hyper_serve(app, conf, shutdown_trigger=shutdown_event.wait))
def main():
config = Config()
config.bind = "0.0.0.0:8080"
config.use_reloader = bool(os.getenv("AUTO_RELOAD", False))
loop = asyncio.get_event_loop()
loop.add_signal_handler(signal.SIGTERM, _signal_handler)
loop.run_until_complete(
serve(
app,
config,
shutdown_trigger=shutdown_event.wait,
)
)
def main(host="localhost", port=8000, server="uvicorn"):
if server == "uvicorn":
uvicorn.run("minij_proxy_asgi:application",
host=host,
port=port,
log_level="info")
elif server == "hypercorn":
from hypercorn.asyncio import serve
from hypercorn.config import Config
config = Config()
config.bind = [f"{host}:{port}"]
asyncio.run(serve(application, config))
def run_production():
import asyncio
import uvloop
from hypercorn.asyncio import serve
from hypercorn.config import Config
config = Config()
config.bind = ['%s:%s' % (api_config.HOST, api_config.PORT)]
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.run_until_complete(serve(app, config))
pass
def run_app_sync(*args, loop=None, shutdown_event=None):
kwargs = {}
config = Config()
cert_file_name, key_file_name = ssl_creds or (None, None)
if cert_file_name:
kwargs["certfile"] = cert_file_name
config.certfile = cert_file_name
if key_file_name:
kwargs["keyfile"] = key_file_name
config.keyfile = key_file_name
setup_quart_logging()
config.bind = [f"{bind_address}:{port}" for bind_address in bind_addresses]
config.workers = len(bind_addresses)
loop = loop or ensure_event_loop()
run_kwargs = {}
if shutdown_event:
run_kwargs["shutdown_trigger"] = shutdown_event.wait
try:
try:
return loop.run_until_complete(serve(app, config, **run_kwargs))
except Exception as e:
LOG.info(
"Error running server event loop on port %s: %s %s",
port,
e,
traceback.format_exc(),
)
if "SSL" in str(e):
c_exists = os.path.exists(cert_file_name)
k_exists = os.path.exists(key_file_name)
c_size = len(load_file(cert_file_name)) if c_exists else 0
k_size = len(load_file(key_file_name)) if k_exists else 0
LOG.warning(
"Unable to create SSL context. Cert files exist: %s %s (%sB), %s %s (%sB)",
cert_file_name,
c_exists,
c_size,
key_file_name,
k_exists,
k_size,
)
raise
finally:
try:
_cancel_all_tasks(loop)
loop.run_until_complete(loop.shutdown_asyncgens())
finally:
asyncio.set_event_loop(None)
loop.close()
