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