def get_app(options):
"""Get app."""
router = SwaggerRouter(swagger_ui='/swagger/')
app = web.Application(
router=router,
middlewares=[
jsonify,
SentryMiddleware(),
log_middleware,
],
)
app['logger'] = pygogo.Gogo(
__name__,
low_formatter=pygogo.formatters.structured_formatter,
verbose=options.option('debug'))
if options.option('debug'):
logging.basicConfig(level=logging.DEBUG)
app['sessions'] = {}
app['logger'].get_logger().debug("starting")
app['config'] = configparser.ConfigParser()
app['config'].read(options.option('config') or '')
setup(app)
setup_routes(app)
return app
def setup_routes(app):
app.router.add_get("/api/product/{id}", food_view.get_food)
app.router.add_get("/api/products", food_view.get_all_food)
app.router.add_get("/api/order/{id}", reservation_view.get_order)
app.router.add_post("/api/order", reservation_view.create_order)
app.router.add_post("/api/login", keeper_view.login)
app.router.add_get("/api/need_cookies_page", keeper_view.need_cookies_page)
app.router.add_get("/api/reservation_count_by_month", keeper_view.reservation_count_by_month)
app.router.add_get("/api/reservation_quantity_pie_data", keeper_view.reservation_quantity_piedata)
app.router.add_get("/api/total_static_info", keeper_view.total_static_info)
app.router.add_get("/api/transaction_count_by_month", keeper_view.transaction_count_by_month)
app.router.add_get("/api/turnover_piedata", keeper_view.turnover_piedata)
cors = aiohttp_cors.setup(app, defaults={
"*": aiohttp_cors.ResourceOptions(
allow_credentials=True,
expose_headers="*",
allow_headers="*",
)
})
for route in list(app.router.routes()):
cors.add(route)
setup(app)
return app
def create_app() -> web.Application:
"""Create and configure the aiohttp.web application."""
config = Configuration()
configure_logging(
profile=config.profile,
log_level=config.log_level,
name=config.logger_name,
)
root_app = web.Application()
root_app["safir/config"] = config
setup_metadata(package_name="mobu", app=root_app)
setup_middleware(root_app)
root_app.add_routes(init_internal_routes())
root_app.cleanup_ctx.append(init_http_session)
sub_app = web.Application()
manager = MonkeyBusinessManager()
root_app["mobu/monkeybusinessmanager"] = manager
root_app.on_startup.append(manager.init)
root_app.on_cleanup.append(manager.cleanup)
setup_middleware(sub_app)
setup(sub_app)
sub_app.add_routes(init_external_routes())
root_app.add_subapp(f'/{root_app["safir/config"].name}', sub_app)
return root_app
async def create_app():
app = web.Application()
setup(app)
app.add_routes(get_routes())
app.on_startup.append(startup_tasks)
app.on_cleanup.append(cleanup_tasks)
return app
async def init_app(config):
app = web.Application()
app['config'] = config
setup_routes(app)
await init_db(app)
setup(app)
return app
def create_app(settings: Optional[Settings] = None) -> web.Application:
"""Identification provider entry point: builds and run a webserver."""
settings = settings or load_conf()
app = web.Application(middlewares=[enforce_json, vary_origin])
setup(app)
app["settings"] = settings
app["identity_backend"] = import_idp(
settings["identity_backend"]["class"])(
options=settings["identity_backend"].get("options", {}))
async def on_startup_wrapper(app):
"""Wrapper to call __aenter__."""
await app["identity_backend"].__aenter__()
async def on_cleanup_wrapper(app):
"""Wrapper to call __exit__."""
await app["identity_backend"].__aexit__(None, None, None)
app.on_startup.append(on_startup_wrapper)
app.on_cleanup.append(on_cleanup_wrapper)
app.add_routes([
web.get("/", views.get_root),
web.get("/users/", views.get_users),
web.post("/users/", views.post_users),
web.get("/jwt/", views.get_jwts),
web.post("/jwt/", views.post_jwt),
web.get("/jwt/{jid}", views.get_jwt),
web.get("/users/", views.get_users),
web.patch("/users/{user_id}/", views.patch_user),
web.get("/password_recoveries/", views.get_password_recoveries),
web.post("/password_recoveries/", views.post_password_recoveries),
web.get("/health", views.get_health),
])
cors = aiohttp_cors.setup(
app,
defaults={
"*":
aiohttp_cors.ResourceOptions(
allow_credentials=True,
expose_headers="*",
allow_headers="*",
allow_methods=[
"GET", "OPTIONS", "PUT", "POST", "DELETE", "PATCH"
],
)
},
)
for route in list(app.router.routes()):
cors.add(route)
return app
def setup_routes(app):
# 添加面向用户路由
app.router.add_get("/api/product/{id}", food_view.get_food)
app.router.add_get("/api/products", food_view.get_all_food)
app.router.add_get("/api/order/{id}", reservation_view.get_order)
app.router.add_get("/api/order_by_table/{id}",
reservation_view.get_order_by_table)
app.router.add_get("/api/comments", comment_view.get_comments)
app.router.add_get("/api/shop", shop_view.get_shop)
app.router.add_post("/api/comments", comment_view.create_comment)
app.router.add_post("/api/order", reservation_view.create_order)
app.router.add_post("/api/payment", payment_view.create_payment)
# 添加面向管理人路由
app.router.add_post("/api/login", keeper_view.login)
app.router.add_get("/api/need_cookies_page", keeper_view.need_cookies_page)
app.router.add_get("/api/reservation_count_by_month",
keeper_view.reservation_count_by_month)
app.router.add_get("/api/reservation_count_by_week",
keeper_view.reservation_count_by_week)
app.router.add_get("/api/reservation_count_by_day",
keeper_view.reservation_count_by_day)
app.router.add_get("/api/basic_static", keeper_view.basic_static)
app.router.add_get("/api/payment/{reservation_id}",
payment_view.get_payment)
# 添加获取数据的路由
app.router.add_get("/api/reservation_quantity_pie_data",
keeper_view.reservation_quantity_piedata)
app.router.add_get("/api/total_static_info", keeper_view.total_static_info)
app.router.add_get("/api/transaction_count_by_month",
keeper_view.transaction_count_by_month)
app.router.add_get("/api/transaction_count_by_week",
keeper_view.transaction_count_by_week)
app.router.add_get("/api/transaction_count_by_day",
keeper_view.transaction_count_by_day)
app.router.add_get("/api/payments", keeper_view.get_all_payment)
app.router.add_get("/api/turnover_piedata", keeper_view.turnover_piedata)
# 解决前后端分离导致的跨域访问问题，这里设置为允许任意的IP进行跨域访问
cors = aiohttp_cors.setup(app,
defaults={
"*":
aiohttp_cors.ResourceOptions(
allow_credentials=True,
expose_headers="*",
allow_headers="*",
)
})
for route in list(app.router.routes()):
cors.add(route)
setup(app)
return app
async def init_app():
healthcheck = HealthcheckController()
app = web.Application()
app.add_routes([
web.get('/healthcheck', healthcheck.handle_get),
web.post('/api/v1/product', create),
web.get('/api/v1/products', find),
web.get('/api/v1/product/{id}', find_by_id)
])
setup(app)
return app
def start_server(self):
"""Start server by loading config and calling other startup functions
"""
prepare_logger(self._log_level)
Config.read_config(self._config_path)
logging.info(f'Starting Hub V{VERSION}...')
logging.info('Loaded Config...')
logging.info('Running API\'s in secure mode...')
self.app = web.Application(middlewares=[auth])
if Config.enable_rest_api:
logging.info('REST API enabled')
cors = aiohttp_cors.setup(self.app,
defaults={
"*":
aiohttp_cors.ResourceOptions(
allow_credentials=True,
expose_headers="*",
allow_headers="*",
)
})
setup_routes(self.app, cors)
self.sio = None
if Config.enable_socket_io_api:
logging.info('Socket.io API enabled')
self.sio = socketio.AsyncServer(
async_mode='aiohttp',
# ping_timeout=60,
# ping_interval=25,
# cookie=None,
cors_allowed_origins='*')
self.sio.attach(self.app)
logging.getLogger('socketio').setLevel(logging.ERROR)
logging.getLogger('engineio').setLevel(logging.ERROR)
logging.getLogger('aiohttp').setLevel(logging.ERROR)
logging.getLogger('siridb.connector').setLevel(logging.ERROR)
self.app.on_cleanup.append(self._stop_server_from_aiohttp_cleanup)
self.app.on_startup.append(self._start_server_from_aiohttp_startup)
# Setup aiojobs
setup(self.app)
try:
web.run_app(self.app,
print=print_custom_aiohttp_startup_message,
port=self.port)
except (asyncio.CancelledError, RuntimeError):
pass
def init(db,
cr_config,
connection_timeout=6,
test_without_hardware=False,
loop=None,
shift_start_time=None):
# инициализация приложения комманд
app = web.Application(loop=loop, middlewares=[
rest_auth_middleware,
])
app.add_routes(make_command_routes())
app['EXECUTION_WAITING_TIMEOUT'] = connection_timeout
setup(app, close_timeout=connection_timeout)
app.cleanup_ctx.append(
make_context(db, cr_config, test_without_hardware, shift_start_time))
return app
def make_app():
controller.start()
app = web.Application(loop=asyncio.get_event_loop())
app["static_root_url"] = "/src"
app.router.add_get("/", get_index)
app.router.add_get("/favicon", get_favicon)
app.router.add_static("/js", path="./dist/js")
app.router.add_static("/css", path="./dist/css")
app.router.add_route("GET", r"/{tail:.*}", query_handler.handle_get)
app.router.add_route("PATCH", r"/{tail:.*}",
modification_handler.handle_patch_from_client)
app.router.add_route("POST", r"/{tail:.*}",
modification_handler.handle_patch_from_client)
setup(app)
return app
async def init_app():
app = web.Application(middlewares=[auth_token])
app['pool'] = await asyncpg.create_pool(config.DATABASE['default'])
cors = aiohttp_cors.setup(app,
defaults={
"*":
aiohttp_cors.ResourceOptions(
allow_credentials=True,
expose_headers="*",
allow_headers="*",
)
})
setup_routes(app, cors)
app['config'] = config
setup(app)
return app
async def init_app() -> web.Application:
app = web.Application()
app.add_routes(routes)
cors = aiohttp_cors.setup(app,
defaults={
"*":
aiohttp_cors.ResourceOptions(
allow_credentials=True,
expose_headers="*",
allow_headers="*",
)
})
for route in list(app.router.routes()):
cors.add(route)
setup(app)
app.cleanup_ctx.append(engine_pool)
return app
async def init_app() -> web.Application:
"""
Инициализация приложения
Returns:
app(web.Application): инстанс приложения
"""
args = init_args()
app = web.Application()
app['db_conn'] = await asyncpg.create_pool(
f'postgres://{args.user}:{args.passwd}@{args.host}:{args.port}/{args.dbname}'
)
app.add_routes(routes)
setup(app)
asyncio.get_event_loop().create_task(
background_parser(app['db_conn'],
timeout=args.timeout,
max_news_count=args.max_news))
return app
def app(self):
"""Asynchrone http server for workshop master
Routes:
index (post): vk group notification handler
"""
async def notification_handler(request):
update = await request.json()
return await self.dispatcher.handle(request, update)
async def shutdown(app):
await self.dispatcher.close()
app = web.Application()
app.router.add_post(
'/', notification_handler) # route for recieve vk notification
app.on_shutdown.append(shutdown)
setup(app) # setup app for aiojobs background tasks
return app
async def init_app():
app = web.Application()
setup(app)
app.add_routes([
web.get('/users', api),
web.get('/my_users', api),
web.get('/users/{login}', api),
web.get('/expenses/{login}', api),
web.get('/expenses/{login}/{expense}', api),
web.put('/users/{login}', api),
web.put('/expenses/{login}/{expense}', api),
web.delete('/users/{login}', api),
web.delete('/expenses/{login}/{expense}', api),
])
app.db_pool = await asyncpg.create_pool(host=DB_HOST,
port=DB_PORT,
user=DB_USER,
password=DB_PASSWORD,
database=DB_NAME,
init=init_connection)
return app
async def start(self) -> None:
if self.started:
raise Exception("already started")
# start aiojobs scheduler
setup(app=self.app)
self.started = True
for route in self.routes:
self.app.add_routes(
[web.get(route.path, self._generate_handler(route))])
await self.runner.setup()
site = web.TCPSite(
self.runner,
host=self.host,
port=self.port,
ssl_context=self.ssl_context,
)
await site.start()
async def http_app_factory() -> Application:
"""Создает, настраивает и возвращает Application-объект для запуска в контейнере через gunicorn."""
redis_pool: Redis = await aioredis.create_redis_pool(
('redis', 6379),
db=0,
)
app: Application = Application()
app['redis'] = redis_pool
app['http_client_session'] = ClientSession(conn_timeout=180,
read_timeout=180,
trust_env=True)
app['tg_api']: TelegramAPI = TelegramAPI(app['http_client_session'])
app['dispatcher'] = Dispatcher(app['redis'], app['tg_api'],
app['http_client_session'])
app.router.add_route('POST', '/webhook/', WebhookHandler)
setup(app)
app.on_startup.append(init_webhook)
app.on_cleanup.append(close_client_session)
app.on_shutdown.append(close_redis)
return app
async def main():
app = web.Application()
host = os.environ.get('MONGO_HOST', 'localhost')
port = os.environ.get('MONGO_PORT', 27017)
mongodb_url = f'mongodb://{host}:{port}'
logging.info(f'using {mongodb_url=}')
data_dir = Path(
os.environ.get('DATA_DIR',
Path(__file__).resolve().parent / 'data'))
origin = os.environ.get('ORIGIN', 'http://localhost:8081')
BASE_URL.set(f'{origin}/u/')
DATA_DIR.set(data_dir)
data_dir.mkdir(parents=True, exist_ok=True)
app['db'] = motor.motor_asyncio.AsyncIOMotorClient(mongodb_url)
await refresh_svgs(app['db'])
await initialize_db(app['db'])
col = app['db'].url_shortener.get_collection('urls')
await col.create_index('url', unique=True)
await col.create_index('id', unique=True)
app.on_cleanup.append(on_cleanup)
app.add_routes(routes)
setup(app)
return app
from aiohttp import web
from aiojobs.aiohttp import setup
from views import wshandler
async def on_shutdown(app):
for player in app["players"]:
await player.ws.close()
def init():
app = web.Application()
app["players"] = []
app["games"] = []
app.router.add_get("/", wshandler)
app.on_shutdown.append(on_shutdown)
return app
if __name__ == "__main__":
app = init()
setup(app)
web.run_app(app)
async def web_app():
app = web.Application()
app.add_routes([web.get('/', handle),web.get('/{name}',handle),web.static('/public','/app/public'),
web.get('/png/{color}/{text}', handleImg)])
setup(app)
return app
from hopeit.server.errors import ErrorInfo
from hopeit.server.names import route_name
from hopeit.server.api import app_route_name
from hopeit.app.config import AppConfig, EventType, EventDescriptor, parse_app_config_json, EventPlugMode
import hopeit.server.runtime as runtime
__all__ = ['parse_args', 'main', 'start_server', 'start_app', 'stop_server']
logger: EngineLoggerWrapper = logging.getLogger(__name__) # type: ignore
extra = extra_logger()
ResponseType = Union[web.Response, web.FileResponse]
# server = Server()
web_server = web.Application()
aiojobs_http.setup(web_server)
auth_info_default = {}
def main(host: Optional[str], port: Optional[int], path: Optional[str],
start_streams: bool, config_files: List[str],
api_file: Optional[str]):
loop = asyncio.get_event_loop()
scheduler = loop.run_until_complete(aiojobs.create_scheduler())
logger.info("Loading engine config file=%s...",
config_files[0]) # type: ignore
server_config = _load_engine_config(config_files[0])
loop.run_until_complete(start_server(server_config))
if server_config.auth.domain:
auth_info_default['domain'] = server_config.auth.domain
import logging
from aiojobs.aiohttp import setup
from aiohttp import web
from app import App
from utils import registry
from handlers import WSHandler
logging.basicConfig(format = '%(levelname)s (%(funcName)s) in [%(name)s] @ [%(asctime)s] => %(message)s',
level = 'DEBUG')
app_wrapper = App()
registry.set_app(app_wrapper)
app_wrapper.add_routes_from_registry(registry)
setup(app_wrapper.app)
web.run_app(app_wrapper.app, host = 'localhost', port = '5000')
def main():
app = web.Application(middlewares=[basic_auth])
app.add_routes(routes)
setup(app)
web.run_app(app, host='0.0.0.0', port=80)
authentication_service_configuration.host = override_host
app["authentication_service_api"] = authentication_service.api.AuthenticationApi(
api_client=authentication_service.ApiClient(
header_name="X-API-KEY",
header_value=settings.AUTHENTICATION_SERVICE_API_KEY,
configuration=authentication_service_configuration))
logger.info("Access Control/Operational: {}".format(
access_control_configuration.host))
logger.info("Authentication Service: {}".format(
authentication_service_configuration.host))
logger.info("User Data Store: {}".format(
user_data_store_configuration.host))
logger.info("Redis: {}".format(REDIS))
setup(app) # Set up aiojobs scheduler
app.on_startup.append(on_startup)
app.on_shutdown.append(on_shutdown)
add_routes(app, with_ui=settings.WITH_UI)
if settings.WITH_UI:
# Override default spec view.
app.router._resources = [
resource for resource in app.router._resources
if not hasattr(resource, "_path")
or resource._path != "/the_specification"
]
app.router.add_view(r"/the_specification", views.SwaggerSpec)
# Add Prometheus metrics end-point
app.router.add_get("/metrics", metrics)
from apps.telegram.controllers import AsyncTelegramController
routes = web.RouteTableDef()
controller = AsyncTelegramController(str(DJANGO_SERVER_URL))
async def logger(request):
print(f"[{time.ctime()}]: {request}")
async def get_event_loop():
try:
return asyncio.get_event_loop()
except RuntimeError:
return asyncio.get_running_loop()
@routes.get('/')
async def main(request):
await spawn(request, logger(request))
await controller.create_client_session()
await controller.start_session()
return web.json_response({"status": 200})
if __name__ == '__main__':
application = web.Application()
application.add_routes(routes)
setup(application)
web.run_app(application, port=8888)
async def new(cls,
data_root: str,
pidfile: str,
host: str = None,
port: str = None,
preload: bool = False,
close_timeout: int = 10,
strategy: str = model.Strategy.No.value,
logger: logging.Logger = internal_logger):
"""Create new instance of the server."""
self = cls()
pidfile = pathlib.Path(pidfile)
self.pid = pid.PidFile(piddir=pidfile.parent, pidname=pidfile.name)
# Create a data root directory where all server data is persisted.
data_root = pathlib.Path(data_root)
data_root.mkdir(parents=True, exist_ok=True)
# TODO: use different execution strategies for models and
# fallback to the server-default execution strategy.
loader = model.Loader(strategy=strategy, logger=logger)
storage = saving.FsModelsStorage.new(path=data_root, loader=loader)
models = await model.Cache.new(storage=storage, preload=preload)
# Experiments storage based on regular file system.
experiments = saving.FsExperimentsStorage.new(path=data_root)
self.app = aiohttp.web.Application(client_max_size=1024**10)
self.app.on_startup.append(cls.app_callback(self.pid.create))
self.app.on_response_prepare.append(self._prepare_response)
self.app.on_shutdown.append(cls.app_callback(storage.close))
self.app.on_shutdown.append(cls.app_callback(experiments.close))
self.app.on_shutdown.append(cls.app_callback(self.pid.close))
route = partial(route_to, api_version=tensorcraft.__apiversion__)
models_view = httpapi.ModelView(models)
server_view = httpapi.ServerView(models)
experiments_view = httpapi.ExperimentView(experiments)
self.app.add_routes([
# Model-related endpoints.
aiohttp.web.get(models_view.list.url, route(models_view.list)),
aiohttp.web.put(models_view.save.url, route(models_view.save)),
aiohttp.web.get(models_view.export.url, route(models_view.export)),
aiohttp.web.delete(models_view.delete.url,
route(models_view.delete)),
aiohttp.web.post(models_view.predict.url,
route(models_view.predict)),
# Experiment-related endpoints.
aiohttp.web.post(experiments_view.create.url,
route(experiments_view.create)),
aiohttp.web.post(experiments_view.create_epoch.url,
route(experiments_view.create_epoch)),
aiohttp.web.get(experiments_view.get.url,
route(experiments_view.get)),
aiohttp.web.get(experiments_view.list.url,
route(experiments_view.list)),
# Server-related endpoints.
aiohttp.web.get(server_view.status.url, route(server_view.status)),
# aiohttp.web.static("/ui", "static"),
])
setup(self.app)
logger.info("Server initialization completed")
return self
