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),
])
