def run_server(self, runner: web.AppRunner):
self.server_loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.server_loop)
self.server_loop.run_until_complete(runner.setup())
self.site = web.TCPSite(runner, "localhost", 8080)
self.server_loop.create_task(self.site.start())
self.server_loop.run_forever()
async def http_server(datadump, connection):
# Create context for HTTP server
app = Application()
# Configure CORS options
# Check https://github.com/aio-libs/aiohttp-cors for details
cors_default_options = {}
for host in WHITELIST:
cors_default_options[host] = aiohttp_cors.ResourceOptions(
allow_methods=['GET'],
allow_headers=('Origin', 'X-Requested-With', 'Content-Type',
'Accept', 'x-timebase', 'Link'))
cors = aiohttp_cors.setup(app, defaults=cors_default_options)
# Configure routes
router = Router(datadump, connection)
router.register(app.router)
# Configure CORS on all routes
for route in list(app.router.routes()):
cors.add(route)
runner = AppRunner(app)
await runner.setup()
site = TCPSite(runner, '0.0.0.0', HTTP_PORT)
return runner, site
async def run_bot():
app = Application()
cors = aiohttp_cors.setup(app, defaults={
"*": aiohttp_cors.ResourceOptions(
allow_credentials=True,
expose_headers="*",
allow_headers="*",
)
})
app.add_routes(routes)
for route in list(app.router.routes()):
cors.add(route)
runner = AppRunner(app)
await runner.setup()
with open("config.json") as conf:
conf = json.load(conf)
site = TCPSite(runner, conf["ip"], conf["port"])
bot = DiscordFoundry()
app['bot'] = bot
app['cors'] = cors
await site.start()
try:
await bot.start(bot.config["token"])
except Exception:
await bot.close(),
raise
finally:
await runner.cleanup()
def __init__(self, manager):
self.manager = manager
self.app = Application()
self.app['websockets'] = WeakSet()
self.app.router.add_get('/', self.on_connect)
self.app.on_shutdown.append(self.on_shutdown)
self.runner = AppRunner(self.app)
async def async_main(conf):
async with AsyncExitStack() as stack:
alert_webhooks = await stack.enter_async_context(
AlertWebhooks(conf.alert_webhooks))
model = await stack.enter_async_context(
get_model(conf, alert_webhooks=alert_webhooks))
alert_webhooks.set_model(model)
app = Application()
app['model'] = model
app.router.add_routes(routes)
GraphQLView.attach(app,
route_path='/graphql',
schema=graphql_schema,
graphiql=True,
enable_async=True,
executor=GQLAIOExecutor())
runner = AppRunner(app)
await runner.setup()
host = conf.http_interface.bind_host
port = conf.http_interface.bind_port
site = TCPSite(runner, host, port)
await site.start()
stop_event = asyncio.Event()
asyncio.get_running_loop().add_signal_handler(SIGINT, stop_event.set)
asyncio.get_running_loop().add_signal_handler(SIGTERM, stop_event.set)
logger.debug('Listening on http://%s:%s', host or 'localhost', port)
await stop_event.wait()
logger.debug('Cleanup...')
t = asyncio.create_task(log_still_running_tasks())
await runner.cleanup()
t.cancel()
logger.debug('Cleanup done')
async def restart_webserver(self, *imports):
'''
Stops the current running webserver and starts a new one
Args:
*imports: str
A list of modules to import that contain a "routes" attribute
'''
try:
await self.web_runner.cleanup()
except Exception as e:
print("Error with closing previous server: ", e)
# Make and link all the relevant options
app = Application(loop=self.loop)
for i in imports:
x = import_module(i)
app.add_routes(x.routes)
app['bot'] = self
# Run the site
self.web_runner = AppRunner(app)
await self.web_runner.setup()
site = TCPSite(self.web_runner, self.commandline_args.host,
self.commandline_args.port)
await site.start()
print(
f"Server started: http://{self.commandline_args.host}:{self.commandline_args.port}/"
)
async def start(self):
self.app.router.add_route("*", "/ws-rpc", self.handle_request)
self.app.router.add_route("*", "/status", self.status)
self.runner = AppRunner(self.app)
await self.runner.setup()
self.site = TCPSite(self.runner, self._host, self._port)
await self.site.start()
def __init__(
self,
node: Node,
) -> None:
self.node = node
self._app = Application(middlewares=[request_middleware])
self._app.add_routes([
web.post("/", self.handle_request),
web.get("/", self.handle_get_request)
])
self._app.add_routes([
web.post("/ws", self.handle_ws_request),
web.get("/ws", self.handle_ws_request)
])
self._runner = AppRunner(self._app)
self._site = None
self._handler = self.request_handler()
self._stop_requested = False
self._stop_waiter = asyncio.get_event_loop().create_future()
self._started = False
self._encoded_auth = None
self._ws_connections: Dict[str, List[WsConnection]] = defaultdict(list)
rpc_user = self.node.opts.rpc_user
if rpc_user:
rpc_password = self.node.opts.rpc_password
self._encoded_auth = base64.b64encode(
f"{rpc_user}:{rpc_password}".encode("utf-8")).decode("utf-8")
async def start_server_async():
runner = AppRunner(app)
await runner.setup()
site = TCPSite(runner, 'localhost', 7474)
try:
await site.start()
except OSError as e:
logger.warning(e)
async def run_async(self, host=None, port=None, loop=None):
wsgi = WSGIHandler(application=self, loop=loop)
app = Application(loop=loop)
app.router.add_route("*", "/{path_info:.*}", wsgi)
runner = AppRunner(app)
await runner.setup()
site = TCPSite(runner, host, port)
await site.start()
async def run_server():
"""Для запуска вне контейнера."""
app: Application = await http_app_factory()
runner: AppRunner = AppRunner(app)
await runner.setup()
site: TCPSite = TCPSite(runner, 'localhost', 8080)
await site.start()
await runner.cleanup()
def __init__(self, app: AppT, **kwargs: Any) -> None:
super().__init__(app, **kwargs)
self.web_app: Application = Application()
self._runner: AppRunner = AppRunner(self.web_app, access_log=None)
self._transport_handlers = {
'tcp': self._new_transport_tcp,
'unix': self._new_transport_unix,
}
def run_server(self, runner: web.AppRunner):
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.run_until_complete(runner.setup())
site = web.TCPSite(runner, Config.api_host, Config.api_port)
loop.run_until_complete(site.start())
logger.info(f'HTTP API serve at {Config.api_host}:{Config.api_port}')
loop.run_forever()
def __init__(self, app: AppT, **kwargs: Any) -> None:
super().__init__(app, **kwargs)
self.web_app: Application = Application()
self.cors_options = _prepare_cors_options(app.conf.web_cors_options
or {})
self._runner: AppRunner = AppRunner(self.web_app, access_log=None)
self._transport_handlers = {
"tcp": self._new_transport_tcp,
"unix": self._new_transport_unix,
}
async def run(self):
runner = AppRunner(self._web_app)
await runner.setup()
host = self._config.get('http.host')
port = self._config.get('http.port')
site = TCPSite(runner, host, port)
logging.info("Running nanobrew on %s:%d" % (host, port))
await site.start()
async def main(loop=None):
intent_controller = IntentController(model)
application = Application(middlewares=[middleware.logging], logger=logger)
application.router.add_post('/api/intent', intent_controller.post)
runner = AppRunner(application)
await runner.setup()
site = TCPSite(runner, environ['APP_HOST'], int(environ['APP_PORT']))
await site.start()
async def server_context(app: Application, port: int):
log_format = '%s %r (%b) %Tfs'
runner = AppRunner(app, access_log_format=log_format)
await runner.setup()
try:
site = TCPSite(runner, port=port)
await site.start()
yield
finally:
await runner.cleanup()
def configure(self, value: http_pb2.Server) -> None:
assert isinstance(value, http_pb2.Server), type(value)
self._app.middlewares.append(_healthcheck_middleware)
self._app.middlewares.append(_opentracing_middleware)
self._runner = AppRunner(self._app, access_log=self._access_log)
self._site_factory = lambda: TCPSite(
self._runner,
value.bind.host,
value.bind.port,
)
async def run(self):
runner = AppRunner(self.web_app)
await runner.setup()
# @TODO Get this from config.
host = "0.0.0.0"
port = 5300
site = TCPSite(runner, host, port)
logging.info("Running nanobrew on %s:%d" % (host, port))
await site.start()
async def create_app_server_once(
app: Application, *, host: str = "127.0.0.1", port: int = 8080
) -> AsyncIterator[URL]:
runner = AppRunner(app, access_log=None)
try:
await runner.setup()
site = TCPSite(runner, host, port, shutdown_timeout=0.0)
await site.start()
yield URL(site.name)
finally:
await runner.shutdown()
await runner.cleanup()
async def start(self):
self.runner = AppRunner(
await self.create_application(),
access_log_class=AccessLogger,
access_log_format=AccessLogger.LOG_FORMAT,
)
await self.runner.setup()
self.site = await self.create_site()
await self.site.start()
async def main(loop=None):
recognize_controller = ResolverController(intents, ner, topic)
application = Application(middlewares=[middleware.logging],
logger=logger)
application.router.add_post('/api/recognize',
recognize_controller.post)
runner = AppRunner(application)
await runner.setup()
site = TCPSite(runner, environ['APP_HOST'], int(environ['APP_PORT']))
await site.start()
async def async_main(conf):
async with ClientSession() as session:
current_alerts = await wait_for(retrieve_alerts(conf, session), 30)
assert isinstance(current_alerts, list)
logger.debug('Initial alerts:\n%s',
'\n'.join(json.dumps(a) for a in current_alerts))
notify_aux = None
app = Application()
app['conf'] = conf
app['current_alerts'] = current_alerts
app['client_session'] = session
app.router.add_routes(routes)
runner = AppRunner(app)
await runner.setup()
try:
site = TCPSite(runner, conf.bind_host, conf.bind_port)
await site.start()
logger.info('Listening on http://%s:%s', conf.bind_host,
conf.bind_port)
await setup_telegram_webhook(conf, session)
while True:
await sleep(conf.sleep_interval)
try:
new_alerts = await wait_for(retrieve_alerts(conf, session),
60)
except Exception as e:
logger.info('Failed to retrieve alerts: %s', e)
await sleep(60)
continue
if {a['alertId']
for a in new_alerts
} != {a['alertId']
for a in current_alerts}:
logger.debug('Retrieved alerts:\n%s',
'\n'.join(json.dumps(a) for a in new_alerts))
notify_aux = await notify_about_alerts(conf, session,
current_alerts,
new_alerts, notify_aux)
current_alerts[:] = new_alerts
except CancelledError:
pass
except Exception as e:
logger.exception('async_main failed: %r', e)
await tg_request(
conf, session, 'sendMessage', {
'chat_id': conf.telegram_chat_id,
'text':
f'\U0001F4A5 Exception: `{tg_md2_escape(repr(e))}`',
'parse_mode': 'MarkdownV2',
})
finally:
await runner.cleanup()
async def root_url(event_loop):
application = build_app()
runner = AppRunner(application)
await runner.setup()
site = TCPSite(runner, "127.0.0.1", 0)
await site.start()
try:
for socket in site._server.sockets:
host, port = socket.getsockname()
break
yield f"http://{host}:{port}"
finally:
await runner.cleanup()
async def main(loop=None):
message_controller = MessageController(recognizer)
search_controller = SearchController(db)
application = Application(middlewares=[middleware.logging],
logger=logger)
application.router.add_post('/api/messages', message_controller.post)
application.router.add_get('/api/search', search_controller.search)
runner = AppRunner(application)
await runner.setup()
site = TCPSite(runner, environ['APP_HOST'], int(environ['APP_PORT']))
await site.start()
async def on_ready():
logger.info("\nLogged in as:\n{0} (ID: {0.id})".format(bot.user))
app = Application()
app.add_routes(routes)
# Pass bot to webserver
app["bot"] = bot
runner = AppRunner(app)
await runner.setup()
site = TCPSite(runner, "0.0.0.0", 9080)
await site.start()
async def _create_test_web_server_core() -> _TestWebServerCore:
calls = []
app = Application(middlewares=[_get_test_middleware(calls)])
app.router.add_static('/static/', _dir_path)
app.router.add_get('/dynamic/test4.txt', _handle_test4)
app.router.add_get('/dynamic/test5.txt', _handle_test5)
app.router.add_get('/dynamic/test6.txt', _handle_test6)
runner = AppRunner(app)
await runner.setup()
host = 'localhost'
port = unused_port()
site = TCPSite(runner, host, port)
await site.start()
return _TestWebServerCore(host, port, calls, runner, site)
async def start(self):
"""
Setup and start API application.
"""
runner = AppRunner(self.app)
await runner.setup()
api_server = TCPSite(runner,
host=self._listen_addr,
port=self._listen_port)
log.info("Starting API server...")
try:
await api_server.start()
except BaseException:
await runner.cleanup()
async def start(self) -> None:
if self.runner is not None:
raise RuntimeError("Can not start twice")
self.runner = AppRunner(
await self.create_application(),
access_log_class=AccessLogger,
access_log_format=AccessLogger.LOG_FORMAT,
)
await self.runner.setup()
self.site = await self.create_site()
await self.site.start()
async def start(self):
self.runner = AppRunner(
await self.create_application(),
access_log_class=AccessLogger,
access_log_format=AccessLogger.LOG_FORMAT,
)
await self.runner.setup()
self.site = SockSite(
self.runner, self.socket,
shutdown_timeout=self.shutdown_timeout
)
await self.site.start()
