def run(self): access_log = self.log.access_log if self.cfg.accesslog else None params = dict( logger=self.log, keepalive_timeout=self.cfg.keepalive, access_log=access_log, access_log_format=self._get_valid_log_format( self.cfg.access_log_format)) self._runner = web.AppRunner(self.wsgi, **params) self.loop.run_until_complete(self._runner.setup()) self._task = self.loop.create_task(self._run()) with suppress(Exception): # ignore all finalization problems self.loop.run_until_complete(self._task) if hasattr(self.loop, 'shutdown_asyncgens'): self.loop.run_until_complete(self.loop.shutdown_asyncgens()) self.loop.close() sys.exit(self.exit_code)
async def start_emulated_hue_bridge(event): """Start the emulated hue bridge.""" upnp_listener.start() nonlocal site nonlocal runner runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, config.host_ip_addr, config.listen_port) try: await site.start() except OSError as error: _LOGGER.error("Failed to create HTTP server at port %d: %s", config.listen_port, error) else: hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, stop_emulated_hue_bridge)
async def init(loop): await orm.create_pool(loop=loop, host='127.0.0.1', port=3306, user='******', password='******', db='awesome') app = web.Application(loop=loop, middlewares=[logger_factory, response_factory]) # app.router.add_route('GET', '/', index) runner = web.AppRunner(app) init_jinja2(app, filters=dict(datetime=datetime_filter)) add_routes(app, 'handlers') add_static(app) await runner.setup() srv = web.TCPSite(runner, '127.0.0.1', 9000) logging.info('server started at http://127.0.0.1:9000 ...') await srv.start()
async def serve(self): app = web.Application() app.add_routes([ web.get ("/", self.serve_index), web.post("/vgm", self.serve_vgm), ]) try: from aiohttp_remotes import XForwardedRelaxed, setup as setup_remotes await setup_remotes(app, XForwardedRelaxed()) except ImportError: self._logger.warning("aiohttp_remotes not installed; X-Forwarded-For will not be used") runner = web.AppRunner(app, access_log_format='%a(%{X-Forwarded-For}i) "%r" %s "%{Referer}i" "%{User-Agent}i"') await runner.setup() site = web.TCPSite(runner, "localhost", 8080) await site.start() await asyncio.Future()
def start(self, port): self._loop = asyncio.get_event_loop() # Set up the HTTP server app = web.Application() app.router.add_get('/', self._root_handler) app.router.add_get('/ws', self._websocket_handler) runner = web.AppRunner(app) self._loop.run_until_complete(runner.setup()) site = web.TCPSite(runner, '0.0.0.0', port) self._loop.run_until_complete(site.start()) _LOGGER.info('listening on port %d', port) t = threading.Thread(target=self._run_thread) t.start()
async def test_http_head_200_chunked(self): async def handle_head(request): await request.content.read() return web.Response(status=200, headers={'transfer-encoding': 'chunked'}) app = web.Application() app.add_routes([web.head('/page', handle_head)]) runner = web.AppRunner(app) await runner.setup() self.add_async_cleanup(runner.cleanup) site = web.TCPSite(runner, '0.0.0.0', 8080) await site.start() request, close = Pool() self.add_async_cleanup(close) code, _, body = await request(b'HEAD', 'http://localhost:8080/page') await buffered(body) self.assertEqual(code, b'200')
async def run(self): LOG.info("starting webserver on %s:%d", self.host, self.port) runner = web.AppRunner(self.app) await runner.setup() site = web.TCPSite(runner, self.host, self.port) asyncio.create_task(site.start(), name="site") if self.jitter: jitter_delay = random.uniform(0, self.jitter) LOG.info( "delaying by random delay of [0, %d] seconds of %f seconds", self.jitter, jitter_delay, ) await asyncio.sleep(jitter_delay) return await repeat(self.interval, self.call_client)
async def webhooks_setup(self): # holy f*****g shit that's hot async def handler(req): if req.headers.get('Authorization') == self.k.topgg_webhook: self.bot.dispatch('topgg_event', cj.classify(await req.json())) else: return web.Response(status=401) return web.Response() app = web.Application() app.router.add_post(self.d.hookspath, handler) self.server_runner = web.AppRunner(app) await self.server_runner.setup() self.webhook_server = web.TCPSite(self.server_runner, '0.0.0.0', self.d.hooksport) await self.webhook_server.start()
async def run_apps(_app): _app.add_routes([ web.get( '/', websocket_handler, ), web.static('/static', './static', show_index=True) ]) runner = web.AppRunner(_app) await runner.setup() ws_endpoint = web.TCPSite(runner, 'localhost', 8080) await ws_endpoint.start() context = ssl.SSLContext(ssl.PROTOCOL_SSLv23) context.load_cert_chain('./ssl/localhost.crt', './ssl/localhost.key') wss_endpoint = web.TCPSite(runner, 'localhost', 8443, ssl_context=context) await wss_endpoint.start()
async def start(self) -> None: """ Start this transport. Raises: HttpSetupError: If there was an error starting the webserver """ app = web.Application() app.add_routes([web.get("/", self.invite_message_handler)]) app.add_routes([web.post("/", self.inbound_message_handler)]) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, host=self.host, port=self.port) try: await site.start() except OSError: raise HttpSetupError("Unable to start webserver with host " + f"'{self.host}' and port '{self.port}'\n")
def __init__(self, container: Container): # noinspection PyTypeChecker self._app = web.Application(logger=log, router=Router()) self._app.middlewares.append(self.error_middleware) self._app.middlewares.append(validation_middleware) JWTManager.setup_middleware(self._app) access_log_format = AppConfig.get("control_server.access_log_format") self._runner = web.AppRunner(self._app, access_log=access_log, access_log_format=access_log_format) self._site: Union[web.TCPSite, None] = None self._container = container self._resources = {} self._tasks = [] self._task_registrators = [] self.register_resources()
async def start(self): global sio sio = AsyncServer(async_mode='aiohttp') self.sio = sio @sio.event async def connect(sid, environ): self.client_ids.append( environ['aiohttp.request'].headers['Client-Id']) global client_sid client_sid = sid await sio.emit('response', {'type': 'response'}) self.enable_sync() sio.attach(self.app, socketio_path='ws') self.runner = web.AppRunner(self.app) await self.runner.setup() site = web.TCPSite(self.runner, 'localhost', 8080) await site.start()
async def init(loop): await www.orm.create_pool(loop=loop, host='127.0.0.1', port=3306, user='******', password='******', db='awesome') app = web.Application( loop=loop, middlewares=[logger_factory, response_factory, auth_factory]) init_jinjia2(app, filters=dict(datetime=datetime_filter)) add_routes(app, 'handlers') add_static(app) runner = web.AppRunner(app) # 耗时的异步操作需要等待 await runner.setup() site = web.TCPSite(runner, '127.0.0.1', 9000) # 同是耗时任务,需要等待 await site.start()
async def init(loop_obj): await Bakup.Web.www.orm.create_pool(loop=loop_obj, host='127.0.0.1', port=3306, user='******', password='******', db='router_scan') app = web.Application(middlewares=[logger_factory, response_factory]) init_jinja2(app, filters=dict(datetime=datetime_filter)) add_routes(app, 'handlers') add_static(app) # srv = await loop_obj.create_server(app.make_handler(), '127.0.0.1', 9000) # logging.info('server started at http://127.0.0.1:9000...') # return srv runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, '127.0.0.1', 9000) logging.info('server started at http://127.0.0.1:9000...') await site.start()
async def start(self, ctx): """ Starts the web server. """ if self.is_running: await ctx.send("The server is already running!") return cache.prepare() with open(self.config_path) as config_file: config = yaml.load(config_file, Loader=CustomLoader) self.music_manager = MusicManager(config["music"], self.on_state_change) self.discord_context = ctx self.runner = web.AppRunner(self.app) await self.runner.setup() site = web.TCPSite(self.runner, self.host, self.port) logger.info(f"Server started on http://{self.host}:{self.port}") self.is_running = True await site.start()
async def startup(self, app): app[RouteTypes.HTTP] = {} routes = app.routes_registry.http_routes if not routes: return app[RouteTypes.HTTP]["app"] = http_app = web.Application() for route in routes: for route_def in route.aiohttp_routes(): route_def.register(http_app.router) app[RouteTypes.HTTP]["runner"] = web.AppRunner(http_app) await app[RouteTypes.HTTP]["runner"].setup() app[RouteTypes.HTTP]["site"] = web.TCPSite( runner=app[RouteTypes.HTTP]["runner"], host=settings.HTTP_HOST, port=settings.HTTP_PORT, ) await app[RouteTypes.HTTP]["site"].start()
async def main(): @web.middleware async def set_server_name(request, handler): try: resp = await handler(request) except Exception as e: resp = web.Response(status=500, text=f"{e}") resp.headers['Server'] = 'madliar/2.1.1a11(Darwin)' return resp app = web.Application(middlewares=[set_server_name]) async def home_page(request): return web.Response(text=f"OK.\n\n{datetime.datetime.now()}") app.add_routes([ web.get('/', home_page), web.get('/lt_{token}', lt.lt), web.route('*', '/lt/dxj/login', dxj.login), web.get('/lt/dxj/settings', dxj.settings), web.post('/lt/dxj/change_password', dxj.change_password), web.post('/lt/dxj/post_settings', dxj.post_settings), web.get('/lt/dxj/logout', dxj.logout), web.post('/lt/login', lt.login), web.get('/lt/settings', lt.settings), web.post('/lt/post_settings', lt.post_settings), web.get('/lt/broadcast', lt.broadcast), web.get('/lt/query_gifts', lt.query_gifts), web.get('/lt/query_raffles', lt.query_raffles), web.get('/lt/query_raffles_by_user', lt.query_raffles_by_user), web.get('/lt/trends_qq_notice', lt.trends_qq_notice), web.route('*', "/lt/cq_handler", cq.handler), ]) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, '0.0.0.0', 1024) await site.start() print("Site started.") while True: await asyncio.sleep(100)
async def ipn_server(queue, async_client): host = "0.0.0.0" port = 8080 async def handle_post(request): data = await request.json() # to ensure status during IPN matches the one sent status = await get_status(async_client, data["id"]) queue.put((data, status)) return web.json_response({}) app = web.Application() app.router.add_post("/", handle_post) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, host, port) await site.start() yield f"http://{host}:{port}" await runner.cleanup()
async def server(robot: RobotV2): app = web.Application() app['robot'] = robot # ops = OperationsV1() ops = DummyOperations() ops.register(app) lookup = aiohttp_mako.setup(app, input_encoding='utf-8', output_encoding='utf-8', default_filters=['decode.utf8']) with open("page.mako") as f: template = f.read() lookup.put_string('index.html', template) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, '0.0.0.0', 8080) await site.start() while True: await asyncio.sleep(1)
async def test_http_delete_200_with_body(self): async def handle_delete(request): await request.content.read() return web.Response(status=200, body=b'some-data') app = web.Application() app.add_routes([web.delete('/page', handle_delete)]) runner = web.AppRunner(app) await runner.setup() self.add_async_cleanup(runner.cleanup) site = web.TCPSite(runner, '0.0.0.0', 8080) await site.start() request, close = Pool() self.add_async_cleanup(close) code, _, body = await request(b'DELETE', 'http://localhost:8080/page') self.assertEqual(code, b'200') body_bytes = await buffered(body) self.assertEqual(body_bytes, b'some-data')
def __init__( self, host: str, port: int, routes: List[Route], ssl_context: ssl.SSLContext = None, tokens: Dict[str, Token] = None, ): self.host = host self.port = port self.ssl_context = ssl_context self.tokens = tokens or {} # type: Dict[str, Token] self.routes = routes self.app = web.Application() self.app["websockets"] = weakref.WeakSet() # store open connections self.app.on_shutdown.append(self.on_shutdown) self.runner = web.AppRunner(self.app) self.started = False
async def test_http_post_204_without_content(self): async def handle_post(request): await request.content.read() return web.Response(status=204) app = web.Application() app.add_routes([web.post('/page', handle_post)]) runner = web.AppRunner(app) await runner.setup() self.add_async_cleanup(runner.cleanup) site = web.TCPSite(runner, '0.0.0.0', 8080) await site.start() request, close = Pool() self.add_async_cleanup(close) code, _, body = await request(b'POST', 'http://localhost:8080/page') self.assertEqual(code, b'204') body_bytes = await buffered(body) self.assertEqual(body_bytes, b'')
async def start(self) -> None: """ Start this transport. Raises: InboundTransportSetupError: If there was an error starting the webserver """ app = await self.make_application() runner = web.AppRunner(app) await runner.setup() self.site = web.TCPSite(runner, host=self.host, port=self.port) try: await self.site.start() except OSError: raise InboundTransportSetupError( "Unable to start webserver with host " + f"'{self.host}' and port '{self.port}'\n" )
def start(self): app = web.Application(client_max_size=JSON_RPC_CLIENT_REQUEST_MAX_SIZE) cors = aiohttp_cors.setup(app) route = app.router.add_post("/", self.__handle) cors.add( route, { "*": aiohttp_cors.ResourceOptions( allow_credentials=True, expose_headers=("X-Custom-Server-Header",), allow_methods=["POST", "PUT"], allow_headers=("X-Requested-With", "Content-Type"), ) }, ) self.runner = web.AppRunner(app, access_log=None) self.loop.run_until_complete(self.runner.setup()) site = web.TCPSite(self.runner, "0.0.0.0", self.port) self.loop.run_until_complete(site.start())
async def start(self): app = web.Application() app.add_routes([web.route('*', '/{tail:.*}', self.handle_request)]) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader(self.dir)) middleware = SnareMiddleware( error_404=self.meta['/status_404'].get('hash'), headers=self.meta['/status_404'].get('headers', []), server_header=self.run_args.server_header) middleware.setup_middlewares(app) self.runner = web.AppRunner(app) await self.runner.setup() site = web.TCPSite(self.runner, self.run_args.host_ip, self.run_args.port) await site.start() names = sorted(str(s.name) for s in self.runner.sites) print("======== Running on {} ========\n" "(Press CTRL+C to quit)".format(', '.join(names)))
async def run(self) -> None: fernet_key = fernet.Fernet.generate_key() secret_key = base64.urlsafe_b64decode(fernet_key) setup(self.app, EncryptedCookieStorage(secret_key)) runner = web.AppRunner(self.app) await runner.setup() site = web.TCPSite(runner, SERVER_CONF.HOST, SERVER_CONF.PORT) await site.start() _LOGGER.info( f"API server started on: http://{SERVER_CONF.HOST}:{SERVER_CONF.PORT}" ) _LOGGER.info(f"routes count: {len(self.app.router._resources)}") while True: await asyncio.sleep(3600)
async def run(self): root = self.config.get('payserver_root', '/r') app = web.Application() app.add_routes([web.get('/api/get_invoice', self.get_request)]) app.add_routes([web.get('/api/get_status', self.get_status)]) app.add_routes([web.get('/bip70/{key}.bip70', self.get_bip70_request)]) app.add_routes( [web.static(root, os.path.join(os.path.dirname(__file__), 'www'))]) if self.config.get('payserver_allow_create_invoice'): app.add_routes( [web.post('/api/create_invoice', self.create_request)]) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, host=str(self.addr.host), port=self.addr.port, ssl_context=self.config.get_ssl_context()) await site.start() self.logger.info(f"now running and listening. addr={self.addr}")
async def _run_app(self) -> web.AppRunner: runner = web.AppRunner(self.app, logger=self.log, keepalive_timeout=15.0, access_log=None) await runner.setup() assert runner is not None server = runner.server assert server is not None for sock in self.sock: site = web.SockSite(runner, sock=sock, shutdown_timeout=self.graceful_timeout / 100 * 95) await site.start() return runner
async def start(self): """Start the aiohttp server.""" if self.ssl_certificate: try: if self.ssl_profile == SSL_INTERMEDIATE: context = ssl_util.server_context_intermediate() else: context = ssl_util.server_context_modern() await self.hass.async_add_executor_job(context.load_cert_chain, self.ssl_certificate, self.ssl_key) except OSError as error: _LOGGER.error("Could not read SSL certificate from %s: %s", self.ssl_certificate, error) return if self.ssl_peer_certificate: context.verify_mode = ssl.CERT_REQUIRED await self.hass.async_add_executor_job( context.load_verify_locations, self.ssl_peer_certificate) else: context = None # Aiohttp freezes apps after start so that no changes can be made. # However in Home Assistant components can be discovered after boot. # This will now raise a RunTimeError. # To work around this we now prevent the router from getting frozen # pylint: disable=protected-access self.app._router.freeze = lambda: None self.runner = web.AppRunner(self.app) await self.runner.setup() self.site = web.TCPSite(self.runner, self.server_host, self.server_port, ssl_context=context) try: await self.site.start() except OSError as error: _LOGGER.error("Failed to create HTTP server at port %d: %s", self.server_port, error)
async def test_controller_timeout(): """ Make sure the controller terminates, even if the site keeps reloading/fetching stuff """ async def f(req): return web.Response(body="""<html> <body> <p>hello</p> <script> window.setTimeout (function () { window.location = '/' }, 250); window.setInterval (function () { fetch('/').then (function (e) { console.log (e) }) }, 150); </script> </body> </html>""", status=200, content_type='text/html', charset='utf-8') url = URL.build(scheme='http', host='localhost', port=8080) app = web.Application() app.router.add_route('GET', '/', f) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, url.host, url.port) await site.start() loop = asyncio.get_event_loop() try: logger = Logger() settings = ControllerSettings(idleTimeout=1, timeout=5) controller = SinglePageController(url=url, logger=logger, service=Process(), behavior=[], settings=settings) # give the controller a little more time to finish, since there are # hard-coded asyncio.sleep calls in there right now. # XXX fix this before = loop.time() await asyncio.wait_for(controller.run(), settings.timeout * 2) after = loop.time() assert after - before >= settings.timeout finally: await runner.cleanup()