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