async def run(self): while True: # ждем postgres try: self.db = await asyncpg.connect( self.__db_url) # todo здесь бы неплохо пул конектов break except Exception as exc: self.logger.info('Wait postgresql connection') await self.loop.sleep(2) app = web.Application() app.add_routes([ web.post('/api/v1/', self.api), web.post('/reports/', self.reports) ]) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, host=self.__address, port=self.__port) await site.start() self.logger.info('Listen %s:%s', self.__address, self.__port)
async def test_tcpsite_default_host(make_runner): runner = make_runner() await runner.setup() site = web.TCPSite(runner) assert site.name == "http://0.0.0.0:8080" calls = [] async def mock_create_server(*args, **kwargs): calls.append((args, kwargs)) with patch("asyncio.get_event_loop") as mock_get_loop: mock_get_loop.return_value.create_server = mock_create_server await site.start() assert len(calls) == 1 server, host, port = calls[0][0] assert server is runner.server assert host is None assert port == 8080
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) -> None: """ Start this transport. Raises: InboundTransportSetupError: 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 InboundTransportSetupError( "Unable to start webserver with host " + f"'{self.host}' and port '{self.port}'\n")
async def init(loop): await orm.create_pool(loop=loop, host='127.0.0.1', port=3306, user='******', password='******', db='awesome') # await orm.create_pool(loop = loop, host = '18.141.24.49', port = 3306, user = '******', password = '******', db = 'awesome') app = web.Application( loop=loop, middlewares=[logger_factory, auth_factory, response_factory]) init_jinja2(app, filters=dict(datetime=datetime_filter)) add_routes(app, 'handlers') add_static(app) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, 'localhost', 9000) await site.start() logging.info('server started at http://127.0.0.1:9000...')
async def start(self) -> None: """ Start the webserver. Raises: AdminSetupError: If there was an error starting the webserver """ self.app = await self.make_application() runner = web.AppRunner(self.app) await runner.setup() self.site = web.TCPSite(runner, host=self.host, port=self.port) try: await self.site.start() except OSError: raise AdminSetupError( "Unable to start webserver with host " + f"'{self.host}' and port '{self.port}'\n" )
async def instance_metadata_server(): ims = InstanceMetadataServer() app = web.Application() app.add_routes([ web.get("/latest/meta-data/iam/security-credentials/", ims.role_handler) ]) app.add_routes([ web.get( "/latest/meta-data/iam/security-credentials/{role:.*}", ims.credentials_handler, ) ]) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, "127.0.0.1", 0) await site.start() ims.port = site._server.sockets[0].getsockname()[1] yield ims await runner.cleanup()
async def start(self): try: self.web_runner = web.AppRunner(self.web_app) await self.web_runner.setup() self.web_site = web.TCPSite( self.web_runner, os.environ['APISERVER_WEB_HOST'], int(os.environ['APISERVER_WEB_PORT']), ) await self.web_site.start() await self.econ.connect() await websockets.serve( self.websocket_feed, os.environ['APISERVER_WS_HOST'], int(os.environ['APISERVER_WS_PORT']), ) await self.read_econ() except Exception: asyncio.get_running_loop().stop() raise
async def init_plugin(self, wechaty: Wechaty): """init the gitlab event plugin""" log.info('starting the server') self.bot = wechaty # start the server app = web.Application() app['bot'] = wechaty app['bot-options'] = self.options app.add_routes(routes) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, '0.0.0.0', self.options.listen_port) loop = asyncio.get_event_loop() asyncio.run_coroutine_threadsafe(site.start(), loop=loop) log.info( f'the server has started ... 0.0.0.0: {self.options.listen_port}')
async def __run_server(): global __httpd app = web.Application() # 添加启动时任务 app.on_startup.append(__before_server_start) # 添加应用关闭时回调 app.on_shutdown.append(__before_server_stop) app.add_routes([ web.post("/screen_event/{name}",__screen_event), web.get("/screen_event/{name}",__screen_event), web.post("/keypad_event/{name}/{key}/{op}",__keypad_event), web.get("/keypad_event/{name}/{key}/{op}",__keypad_event), web.get("/{name}",__screen_page), web.get("/",__index_page), ]) __httpd = web.AppRunner(app) await __httpd.setup() site = web.TCPSite(__httpd, __HOST, __PORT) await site.start() print("服务启动在 {:s}:{:d}\n浏览器访问以获取ssd1306屏幕内容".format(__HOST,__PORT))
async def run_bot(): app = web.Application() setattr(bot, "koala_web_app", app) load_all_cogs() runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, '0.0.0.0', API_PORT) await site.start() try: await bot.start(BOT_TOKEN) except Exception: bot.close(), raise finally: await runner.cleanup()
async def kick_off(self, my_loop): """ start web server and scratch2.0 """ self.loop = my_loop try: app = web.Application() app.router.add_route('GET', '/poll', self.poll) app.router.add_route('GET', '/send_hi', self.send_hi) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, '127.0.0.1', 50209) await site.start() # start scratch os_string = "start /b " + self.scratch_executable + ' ' + self.scratch_project await asyncio.sleep(self.windows_wait_time) os.system(os_string) await self.poll_watchdog() except: pass
async def run_async(self): """ Starts the server in an already-running asyncio loop. """ self.app_runner = web.AppRunner(self.app) await self.app_runner.setup() site = web.TCPSite(self.app_runner, port=self.http_port, host=self.http_host, ssl_context=self.ssl_context) await site.start() protocol = 'https' if self.ssl_context else 'http' print("") print("*" * 80) print("Your VTN Server is now running at ".center(80)) print( f"{protocol}://{self.http_host}:{self.http_port}{self.http_path_prefix}" .center(80)) print("*" * 80) print("")
async def asyncInit(app): runner = web.AppRunner(app) token = app['config'].get('api', {}).get('pubtoken') tokenInfo = bool(token) logger.info(f'Check token {tokenInfo}') if token: app['brokerClient'] = await getAsyncClient(token) await runner.setup() site = web.TCPSite( runner, app['config']['host'], app['config']['port'] ) logger.info('Serve at {}:{}'.format( app['config']['host'], app['config']['port'] )) await site.start() while True: await asyncio.sleep(3600)
async def http_server(self): # Note: Authentication for webhooks is handled by nginx, not the bot app = web.Application() app.router.add_post('/github', self.github_handler) runner = web.AppRunner(app) await runner.setup() self.server = web.TCPSite(runner, 'localhost', self.config['port']) # Silence access logging to console/logfile logging.getLogger('aiohttp.access').setLevel(logging.WARNING) # wait for bot to be ready, then start and find the channels await self.bot.wait_until_ready() self.commits_channel = self.bot.get_channel(self.config['github']['commits_channel']) self.brief_channel = self.bot.get_channel(self.config['github']['brief_commits_channel']) self.wiki_channel = self.bot.get_channel(self.config['github']['wiki_channel']) self.ci_channels = [] for cid in self.config['ci_channels']: self.ci_channels.append(self.bot.get_channel(cid)) logger.info(f'Start listening on localhost:{self.config["port"]}') await self.server.start()
async def init(loop): await orm.create_pool(loop=loop, host='127.0.0.1', port=3306, user='******', password='******', db='awesome') app = web.Application( middlewares=[ #拦截器 一个URL在被某个函数处理前,可以经过一系列的middleware的处理。 logger_factory, auth_factory, response_factory ]) init_jinja2(app, filters=dict(datetime=datetime_filter)) add_routes(app, 'handlers') add_static(app) # srv = await loop.create_server(app.make_handler(), '127.0.0.1', 9000)#Deprecated 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...') return await site.start()
async def init(loop): #db = configs.configs.db await orm.create_pool(loop=loop, ) #DeprecationWarning: loop argument is deprecated app = web.Application( loop=loop, middlewares=[ #拦截器 一个URL在被某个函数处理前,可以经过一系列的middleware的处理。 logger_factory, response_factory #工厂模式 ]) init_jinja2(app, filters=dict(datetime=datetime_filter)) add_routes(app, 'handlers') add_static(app) # DeprecationWarning: Application.make_handler(...) is deprecated, use AppRunner API instead runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, '192.168.2.101', 9000) logging.info('server started at http://192.168.2.101:9000...') await site.start()
async def init(config: Dict[str, Any], controller_: controller.Controller): presenter = Presenter(controller_) app = web.Application(middlewares=[utils.handle]) app.add_routes( [ web.post("/notes.get", presenter.notes_get), web.post("/notes.list", presenter.notes_list), web.post("/notes.create", presenter.notes_create), web.post("/notes.update", presenter.notes_update), web.post("/notes.delete", presenter.notes_delete), ] ) runner = web.AppRunner(app, access_log=False) await runner.setup() site = web.TCPSite(runner, config["host"], config["port"], backlog=config["backlog"], reuse_port=True) await site.start()
def __init__(self, host='0.0.0.0', port=8080, *, interface=False, main_chronometer=None, give_clue=None, buzzer=None): Server.__init__(self, name=None) web.Application.__init__(self) if interface: self._activate_interface() self.add_routes(routes) runner = web.AppRunner(self, logger=self._logger) asyncio.run_until_complete(runner.setup()) self.site = web.TCPSite(runner, host, port) self._start(host, port) self.main_chronometer = main_chronometer self.give_clue = give_clue self.buzzer = buzzer
async def run_api(*, host: str, port: int, app_state: t.Mapping[str, t.Any]) -> web.AppRunner: app = web.Application(middlewares=[ tracing_middleware_factory( trace_id, request_then_uuid_factory()), # type: ignore error_middleware ]) # type: ignore app.update(app_state) setup_routes(app) runner = web.AppRunner(app, access_log=False, handle_signals=True) await runner.setup() site = web.TCPSite(runner, host, port) await site.start() logger.info(f"======== Running on {site.name} ========") return runner
async def start_jsonrpc(self, config: SimpleConfig, fd): self.app = web.Application() self.app.router.add_post("/", self.handle) self.rpc_user, self.rpc_password = get_rpc_credentials(config) self.methods = jsonrpcserver.methods.Methods() self.methods.add(self.ping) self.methods.add(self.gui) self.cmd_runner = Commands(config=self.config, network=self.network, daemon=self) for cmdname in known_commands: self.methods.add(getattr(self.cmd_runner, cmdname)) self.methods.add(self.run_cmdline) self.host = config.get('rpchost', '127.0.0.1') self.port = config.get('rpcport', 0) self.runner = web.AppRunner(self.app) await self.runner.setup() site = web.TCPSite(self.runner, self.host, self.port) await site.start() socket = site._server.sockets[0] os.write(fd, bytes(repr((socket.getsockname(), time.time())), 'utf8')) os.close(fd)
def main(): aio_app = web.Application() # 建立一個 reference dict 準備關聯全部 ws 連線物件, key 為 {channel_id} aio_app["websockets"] = weakref.WeakValueDictionary() aio_app.router.add_route('GET', '/index', criteria) aio_app.router.add_route('GET', '/result', result_page) # aio_app.router.add_route('GET', '/index2', index) aio_app.add_routes([web.static('/static', './static')]) aio_app.router.add_route('GET', '/socket/{channel_id}', socket_handler) aio_app.router.add_route('GET', '/socket/cancel/{channel_id}', cancel_tasks) runner = web.AppRunner(aio_app, access_log=logger) loop.run_until_complete(runner.setup()) site = web.TCPSite(runner, WS_HOST, WS_PORT) loop.run_until_complete(site.start()) loop.run_forever()
async def webhook(self): async def vote_handler(request): req_auth = request.headers.get('Authorization') if self.webhook_auth == req_auth: data = await request.json() if data.get('type') == 'upvote': event_name = 'dbl_vote' elif data.get('type') == 'test': event_name = 'dbl_test' self.bot.dispatch(event_name, data) return web.Response() else: return web.Response(status=401) app = web.Application(loop=self.loop) app.router.add_post(self.webhook_path, vote_handler) runner = web.AppRunner(app) await runner.setup() self._webserver = web.TCPSite(runner, '0.0.0.0', self.webhook_port) await self._webserver.start()
async def init(loop): app = web.Application() # infos = [r for r in app.router.resources()] # print(type(infos)) # if infos: # print(infos[0].split("\n\r")) # # logfile = "../../logs/web.log" # print(os.path.abspath(logfile)) # ip = "" # path = "" # weblog(logfile,ip, path) app.router.add_route('GET', '/', index) app.router.add_route('GET', '/check', check) web.run_app(app) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner=runner, port=getPort()) await site.start()
async def run(self): self.runner = web.AppRunner(self.app) await self.runner.setup() if self.socktype == 'unix': site = web.UnixSite(self.runner, self.sockpath) elif self.socktype == 'tcp': site = web.TCPSite(self.runner, self.host, self.port) else: raise Exception(f"unknown socktype '{self.socktype!r}'") await site.start() socket = site._server.sockets[0] if self.socktype == 'unix': addr = self.sockpath elif self.socktype == 'tcp': addr = socket.getsockname() else: raise Exception(f"impossible socktype ({self.socktype!r})") os.write(self.fd, bytes(repr((self.socktype, addr, time.time())), 'utf8')) os.close(self.fd) self.logger.info(f"now running and listening. socktype={self.socktype}, addr={addr}")
def __run_hook(self, runner: 'web.AppRunner'): self.__hook_runner = runner self.__hook_loop = asyncio.new_event_loop() asyncio.set_event_loop(self.__hook_loop) self.__hook_loop.run_until_complete(runner.setup()) site = web.TCPSite(runner, str(self._host), self._port, ssl_context=self.__ssl_context) self.__hook_loop.run_until_complete(site.start()) self.__logger.info('started twitch API hook on port ' + str(self._port)) # add refresh task if self.auto_renew_subscription: self.__task_refresh = self.__hook_loop.create_task( self.__refresh_task()) try: self.__hook_loop.run_forever() except (CancelledError, asyncio.CancelledError): pass
async def async_main(port, url): async def handle_healthcheck(_): async with aiohttp.ClientSession() as client_session: async with client_session.get(url) as response: response = await response.text() return web.Response(text=response) async def handle_healthcheck_alb(_): return web.Response(text="OK") app = web.Application() app.add_routes([ web.get("/check", handle_healthcheck), web.get("/check_alb", handle_healthcheck_alb), ]) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, "0.0.0.0", port) await site.start()
async def listen_webhooks(self, webhook_port): self.webhook_port = webhook_port if RUN_MODE == "pwd": self.webhook_url = f"http://localhost:{str(webhook_port)}/webhooks" else: self.webhook_url = ( f"http://{self.external_host}:{str(webhook_port)}/webhooks") app = web.Application() app.add_routes([ web.post("/webhooks/topic/{topic}/", self._receive_webhook), # route for fetching proof request for connectionless requests web.get( "/webhooks/pres_req/{pres_req_id}/", self._send_connectionless_proof_req, ), ]) runner = web.AppRunner(app) await runner.setup() self.webhook_site = web.TCPSite(runner, "0.0.0.0", webhook_port) await self.webhook_site.start()
async def init(loop): await orm.create_pool(loop=loop, host='127.0.0.1', port=3306, user='******', password='******', db='awesome') app = web.Application(middlewares=[logger_factory, response_factory]) init_jinja2(app, filters=dict(datetime=datetime_filter)) add_routes(app, 'handlers') add_static(app) runner = web.AppRunner(app) # app.make_handler()这个方法用不了,改用APPrunner,虽然我没看懂,但是官方替换是这样得 await runner.setup() site = web.TCPSite( runner, '127.0.0.1', 8000 ) #当用8000接口,显示错误:OSError: [Errno 10048] error while attempting to bind on address ('127.0.0.1', 8000): 通常每个套接字地址(协议/网络地址/ 端口)只允许使用一次。那么换成8001或8002,这样一般就可以了 await site.start() logging.info('server started at http://127.0.0.1:8000...') return site
def run_webserver(host, port, ssl_context, password, loop, from_web_queue, to_web_queue): asyncio.set_event_loop(loop) runner = create_app_runner(host, port, ssl_context is not None, password, from_web_queue) to_web_queue.start(loop) from_web_queue.start(loop) loop.run_until_complete(runner.setup()) server = web.TCPSite(runner, host, port, ssl_context=ssl_context) server_task = loop.create_task(server.start()) to_web_queue_task = loop.create_task(handle_to_web_queue(to_web_queue, loop, server_task)) threading.Thread(name="WebQueue", target=handle_from_web_queue, args=(from_web_queue,)).start() loop.run_until_complete(asyncio.wait([server_task, to_web_queue_task])) loop.close()