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()
