def create_app(): """ Create basic application, define API endpoints :return: web app """ ws = WebSockets(log) csrf_policy = aiohttp_csrf.policy.FormPolicy(CSRFCongiruation.FORM_FIELD_NAME) csrf_storage = aiohttp_csrf.storage.CookieStorage(CSRFCongiruation.COOKIE_NAME) app = Application(middlewares=[auth_middleware]) app.add_routes( routes=[ # Render web.get("/register", Register.get), web.get("/login", Login.get), web.get("/chat", Chat.get), web.get("/", Home.get), # Api web.post("/api/register", Register.post), web.post("/api/login", Login.post), web.post("/api/logout", Logout.post), web.get("/api/chat/ws", ws.get), web.get("/api/health", HealthCheck.get), # Static web.static("/static/js", path=DefaultPaths.STATIC_JS, append_version=True), # Feedback web.view("/feedback", Feedback), ] ) aiohttp_csrf.setup(app, policy=csrf_policy, storage=csrf_storage) app.middlewares.append(csrf) return app
async def build_application() -> Application: app = Application() await setup_database(app) setup_routes(app) app.app_settings = settings return app
def rest_api(loop, aiohttp_client, mock_dlmgr, metadata_store): # pylint: disable=unused-argument endpoint = DownloadsEndpoint(mock_dlmgr, metadata_store=metadata_store) app = Application(middlewares=[error_middleware]) app.add_subapp('/downloads', endpoint.app) return loop.run_until_complete(aiohttp_client(app))
def build_routes(app: Application): app.add_routes([ web.get('/', root_handler), web.get('/groups', group_list_handler), web.get('/vehicles', vehicle_list_handler), web.get(r'/vehicles/{vehicle_id:\d+}', vehicle_item_handler), web.get(r'/vehicles/{vehicle_id:\d+}/configuration', vehicle_configuration_handler), ])
def bind(self, app: Application) -> None: app.add_routes( [ web.post("/conversation/{character_id}", self.main_page), web.post("/conversation/{character_id}/start", self.start), web.post("/conversation/{character_id}/read/{conversation_id}", self.read), web.post("/conversation/{character_id}/add/{conversation_id}", self.add), ] )
async def test_aux_cleanup(loop): aux_app = Application() aux_app.on_cleanup.append(cleanup_aux_app) ws = MagicMock() ws.close = MagicMock(return_value=create_future()) aux_app['websockets'] = [(ws, '/foo/bar')] aux_app.freeze() await aux_app.cleanup() assert ws.close.call_count == 1
async def test_aux_reload_html_different(): aux_app = Application() ws = MagicMock() ws.send_str = MagicMock(return_value=create_future()) aux_app.update(websockets=[(ws, '/foo/bar')], static_url='/static/', static_path='/path/to/static_files/') assert 0 == await src_reload(aux_app, '/path/to/static_files/foo/bar.html') assert ws.send_str.call_count == 0
def init_routes(app: Application) -> None: app.add_routes([ web.get("/", version_api), web.post("/", version_api), web.post("/create", create_api), web.post("/read", read_api), web.get("/read", read_api), web.post("/update", update_api), web.post("/delete", delete_api), ])
async def test_aux_reload_runtime_error(caplog): aux_app = Application() ws = MagicMock() ws.send_str = MagicMock(return_value=create_future()) ws.send_str = MagicMock(side_effect=RuntimeError('foobar')) aux_app.update(websockets=[(ws, '/foo/bar')], static_url='/static/', static_path='/path/to/static_files/') assert 0 == await src_reload(aux_app) assert ws.send_str.call_count == 1 assert 'adev.server.aux ERROR: Error broadcasting change to /foo/bar, RuntimeError: foobar\n' == caplog
def bind(self, app: Application) -> None: app.add_routes([ web.get("/zones/tiles", self.get_tiles), web.get("/zones/{row_i}/{col_i}", self.get_zone), web.get("/zones/{row_i}/{col_i}/events", self.events), web.get("/zones/{row_i}/{col_i}/characters", self.get_characters), web.get("/zones/{row_i}/{col_i}/stuff", self.get_stuff), web.get("/zones/{row_i}/{col_i}/resources", self.get_resources), web.get("/zones/{row_i}/{col_i}/builds", self.get_builds), web.post("/zones/{row_i}/{col_i}/describe/{character_id}", self.describe), web.post("/zones/{row_i}/{col_i}/messages", self.messages), web.post("/zones/{row_i}/{col_i}/messages/add", self.add_message), ])
def add_routes(app: Application) -> None: """ Register routes and cors :param app: aiohttp app """ ping: Ping = Ping() opening_hours: OpeningHours = OpeningHours() app.add_routes([ # GET handlers web.get(f"/{APP_VERSION}/", ping.get), web.get(f"/{APP_VERSION}/opening_hours", opening_hours.get), # POST Handlers web.post(f"/{APP_VERSION}/opening_hours", opening_hours.post), ])
def create_app() -> Application: """ Создает экземпляр приложения, готового к запуску """ # TODO добавить middlewares для вадидации полей сообщений app = Application(client_max_size=MAX_REQUEST_SIZE, middlewares=[check_token_middleware]) app.cleanup_ctx.append(setup_pg) app.on_startup.append(startup) app.on_shutdown.append(shutdown) # регестрируем менеджер кеша app['cache'] = CacheManager() app['encoders'] = EncoderManager() # Регистрация обработчика for handler in HANDLERS: log.debug('Registering handler %r as %r', handler, handler.URL_PATH) app.router.add_route('*', handler.URL_PATH, handler) setup_aiohttp_apispec(app=app, title="GROUP BY FACE API", swagger_path='/') # Автоматическая сериализация в json данных в HTTP ответах PAYLOAD_REGISTRY.register(AsyncGenJSONListPayload, (AsyncGeneratorType, AsyncIterable)) PAYLOAD_REGISTRY.register(JsonPayload, (Mapping, MappingProxyType)) return app
def setUp(self) -> None: """ Set up the test environment creating the database engine """ container.reset() test_engine = create_sql_engine(SqlEngineType.SQLITE) self.session_provider = SqlSessionProvider(test_engine) BASE.query = self.session_provider.query_property init_sql_db(BASE, test_engine) named_entity_type_service = NamedEntityTypeService(session_provider=self.session_provider) named_entity_service = NamedEntityService(session_provider=self.session_provider) named_entity_type = asyncio.run(named_entity_type_service.save(name='TEST')) asyncio.run(named_entity_service.save(value=self.TEST_ENTITY_1, named_entity_type_id=named_entity_type.id)) asyncio.run(named_entity_service.save(value=self.TEST_ENTITY_2, named_entity_type_id=named_entity_type.id)) noun_chunks_service = NounChunkService(session_provider=self.session_provider) asyncio.run(noun_chunks_service.save(value=self.TEST_NOUN_CHUNK_1)) asyncio.run(noun_chunks_service.save(value=self.TEST_NOUN_CHUNK_2)) asyncio.run(noun_chunks_service.save(value=self.TEST_NOUN_CHUNK_3)) self.newspaper_service = NewspaperService(session_provider=self.session_provider) app = Application() container.set('session_provider', self.session_provider) container.set('named_entity_service', named_entity_service) container.set('noun_chunk_service', noun_chunks_service) container.set('newspaper_service', self.newspaper_service) self.app = app
async def async_main(loop: asyncio.AbstractEventLoop) -> None: jira_oauth = JiraOAuth.from_file() jira_oauth.app = Application() jira_oauth.app.add_routes([web.get('/', jira_oauth.process_oauth_result)]) runner = AppRunner(app=jira_oauth.app) await runner.setup() site = TCPSite(runner=runner) await site.start() jira_oauth.redirect_url = 'http://localhost:8080/' jira_oauth.loop = loop await jira_oauth.generate_request_token_and_auth_url() jira_oauth_console = JiraOAuthConsole(jira_oauth=jira_oauth) print( f"Request Token: oauth_token={jira_oauth.request_token['oauth_token']}, " f"oauth_token_secret={jira_oauth.request_token['oauth_token_secret']}") print() jira_oauth_console.print_url() await jira_oauth.generate_access_token() print() print( f"Access Token: oauth_token={jira_oauth.access_token['oauth_token']}, " f"oauth_token_secret={jira_oauth.access_token['oauth_token_secret']}") print( "You may now access protected resources using the access tokens above." ) print() await jira_oauth_console.check_access_token()
def create_app(): app = Application(client_max_size=MAX_REQUEST_SIZE) for handler in HANDLERS: app.router.add_route('*', handler.URL_PATH, handler) return app
def create_app() -> Application: """ Создает экземпляр приложения, готового к запуску """ # TODO добавить middlewares для вадидации полей сообщений app = Application(client_max_size=MAX_REQUEST_SIZE, # middlewares=[check_token_middleware] ) aiohttp_cors.setup(app, defaults={ "*": aiohttp_cors.ResourceOptions( allow_credentials=True, expose_headers="*", allow_headers="*", ) }) app.cleanup_ctx.append(setup_pg) # Регистрация обработчика for handler in HANDLERS: log.debug('Registering handler %r as %r', handler, handler.URL_PATH) route = app.router.add_route('*', handler.URL_PATH, handler) app['aiohttp_cors'].add(route) setup_aiohttp_apispec(app=app, title="I SEE YOU API", swagger_path='/') # Автоматическая сериализация в json данных в HTTP ответах PAYLOAD_REGISTRY.register(AsyncGenJSONListPayload, (AsyncGeneratorType, AsyncIterable)) PAYLOAD_REGISTRY.register(JsonPayload, (Mapping, MappingProxyType)) return app
async def queue_listener_process(app: Application) -> None: input_images_queue = asyncio.Queue() app.input_images_queue = input_images_queue process_pool = ProcessPoolExecutor( initializer=register_signal_handler ) loop = asyncio.get_event_loop() input_queue_listener_task = loop.create_task( input_queue_listener(app) ) app.process_pool = process_pool logger.info('Services started') yield input_queue_listener_task.cancel() app.process_pool.shutdown(wait=True) logger.info('Services stopped')
async def get_application(self): """ Override the get_app method to return your application. """ app = Application() app.middlewares.append(error_middleware) app.middlewares.append(mock_auth_middleware) app.middlewares.append(validation_middleware) setup_aiohttp_apispec( app=app, title='API', version=API_VERSION, url=f'/{API_VERSION}/api/docs/swagger.json', swagger_path=f'/{API_VERSION}/api/docs/ui', securityDefinitions={ 'ApiKeyAuth': { 'type': 'apiKey', 'name': 'X-API-Key', 'in': 'header' } }, ) setup_routes(app) return app
async def test_aux_reload_no_path(): aux_app = Application() ws = MagicMock() ws.send_str = MagicMock(return_value=create_future()) aux_app.update(websockets=[(ws, '/foo/bar')], static_url='/static/', static_path='/path/to/static_files/') assert 1 == await src_reload(aux_app) assert ws.send_str.call_count == 1 send_obj = json.loads(ws.send_str.call_args[0][0]) assert send_obj == { 'command': 'reload', 'path': '/foo/bar', 'liveCSS': True, 'liveImg': True, }
def create_app(args: Namespace) -> Application: """ Создает экземпляр приложения, готового к запуску. """ app = Application( client_max_size=MAX_REQUEST_SIZE, middlewares=[error_middleware, validation_middleware] ) # Подключение на старте к postgres и отключение при остановке app.cleanup_ctx.append(partial(setup_pg, args=args)) # Регистрация обработчиков for handler in HANDLERS: log.debug('Registering handler %r as %r', handler, handler.URL_PATH) app.router.add_route('*', handler.URL_PATH, handler) # Swagger документация setup_aiohttp_apispec(app=app, title='Citizens API', swagger_path='/', error_callback=handle_validation_error) # Автоматическая сериализация в json данных в HTTP ответах PAYLOAD_REGISTRY.register(AsyncGenJSONListPayload, (AsyncGeneratorType, AsyncIterable)) PAYLOAD_REGISTRY.register(JsonPayload, (Mapping, MappingProxyType)) return app
async def get_application(self): """ Override the get_app method to return the mocked application. """ container.reset() container.set('apm', Mock(spec=Client)) app = Application() return app
def create_app(middlewares=[]): app = Application(middlewares=middlewares) for handler in HANDLERS: log.info('Registering handler %r as %r', handler, handler.URL_PATH) app.router.add_route('*', handler.URL_PATH, handler) return app
def create_app(loop, config, db): app = Application(loop=loop, middlewares=[token_middleware]) app['config'] = config app['db'] = db routes.setup(app) return app
async def test_aux_reload(caplog): aux_app = Application() ws = MagicMock() ws.send_str = MagicMock(return_value=create_future()) aux_app.update(websockets=[(ws, '/foo/bar')], static_url='/static/', static_path='/path/to/static_files/') assert 1 == await src_reload(aux_app, '/path/to/static_files/the_file.js') assert ws.send_str.call_count == 1 send_obj = json.loads(ws.send_str.call_args[0][0]) assert send_obj == { 'command': 'reload', 'path': '/static/the_file.js', 'liveCSS': True, 'liveImg': True, } assert 'adev.server.aux INFO: prompted reload of /static/the_file.js on 1 client\n' == caplog
async def repository_process(app: Application) -> None: repository = RedisRepository() await repository.connect() app.repository = repository logger.info("Repository started") yield await app.repository.disconnect() logger.info("Repository stopped")
def setUp(self) -> None: """ Set up the test environment """ container.reset() self.apm_mock = Mock(spec=Client) container.set('apm', self.apm_mock) app = Application() self.app = app
def test_init_app(self, view_mock, setup_graphql_mock, load_mock, *_): """ Test if the initialization of the app initializes all the required modules """ settings_loader(config, filename=TEST_CONFIG_PATH) base_app = Application() init_news_manager(base_app) view_mock.setup_routes.assert_called_once() setup_graphql_mock.assert_called_once() load_mock.assert_called_once()
async def create_application() -> Application: """Создание WEB приложения.""" application = Application() application['database_settings'] = database_settings application['settings'] = application_settings cors_options = aiohttp_cors.ResourceOptions(expose_headers='*', allow_headers='*') aiohttp_cors.setup(application, defaults={'*': cors_options}) application.add_routes(views.routes) setup_middlewares(application) application.on_startup.append(init_mysql) application.on_cleanup.append(close_mysql) application.on_startup.append(init_redis) application.on_cleanup.append(close_redis) application.on_startup.append(_create_logs_file) return application
def bind(self, app: Application) -> None: url_base = "/affinity/{character_id}" app.add_routes([ web.post(url_base, self.main_page), web.post(url_base + "/new", self.new), web.post(url_base + "/list", self.list), web.post(url_base + "/see/{affinity_id}", self.see), web.post(url_base + "/edit-relation/{affinity_id}", self.edit_relation), web.post(url_base + "/manage/{affinity_id}", self.manage), web.post(url_base + "/manage-requests/{affinity_id}", self.manage_requests), web.post(url_base + "/manage-relations/{affinity_id}", self.manage_relations), web.post( url_base + "/manage-relations/{affinity_id}/{relation_character_id}", self.manage_relation, ), ])
def bind(self, app: Application) -> None: app.add_routes([ web.post("/business/{character_id}", self.main_page), web.post("/business/{character_id}/offers", self.offers), web.post("/business/{character_id}/offers-create", self.create), web.post("/business/{character_id}/offers/{offer_id}", self.offer), web.post( "/business/{character_id}/see-offer/{owner_id}/{offer_id}", self.see), web.post( "/business/{character_id}/see-offer/{owner_id}/{offer_id}/deal", self.deal), web.post("/business/{character_id}/offers/{offer_id}/add-item", self.add_item), web.post( "/business/{character_id}/offers/{offer_id}/remove-item/{item_id}", self.remove_item, ), web.post("/business/{character_id}/transactions", self.transactions), # web.post("/business/{character_id}/transactions/{offer_id}", self.transaction), ])