app['coap'] = coap app['static_root_url'] = './static' for dpt in app['dyn_resources']['public_keys']: resources.add_file_resource(coap, dpt) for dpt in app['dyn_resources']['signed_manifests']: resources.add_file_resource(coap, dpt) for dpt in app['dyn_resources']['builds']: resources.add_file_resource(coap, dpt) for dpt in app['dyn_resources']['flasher_paks']: resources.add_file_resource(coap, dpt) for dpt in app['dyn_resources']['keygens']: resources.add_file_resource(coap, dpt) for dpt in app['dyn_resources']['unsigned_manifests']: resources.add_file_resource(coap, dpt) routes.setup_routes(app, PROJECT_ROOT) asyncio.Task(aiocoap.Context.create_server_context(coap)) loop.run_until_complete(init(loop, app)) print("Server started") addrs = netifaces.ifaddresses('eth0') #addrs = netifaces.ifaddresses('wlp4s0') ipv6_add = addrs[netifaces.AF_INET6][0]['addr'] logging.debug("Server IPv6 address is: {}".format(ipv6_add)) try: loop.run_forever() except KeyboardInterrupt: pass
import asyncio import pathlib import aiohttp_jinja2 import jinja2 from aiohttp import web from routes import setup_routes from sales_stat import calculate_stat, start_calculate_stat TEMPLATES_ROOT = pathlib.Path(__file__).parent / 'templates' APP_ROOT = pathlib.Path(__file__).parent.parent app = web.Application() setup_routes(app, APP_ROOT) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader(str(TEMPLATES_ROOT))) app.on_startup.append(start_calculate_stat) web.run_app(app)
import asyncio from aiohttp import web import settings import db import routes loop = asyncio.get_event_loop() app = web.Application(loop=loop) app['config'] = settings.load_settings() app.on_startup.append(db.init_pg) app.on_shutdown.append(db.close_pg) routes.setup_routes(app) web.run_app(app)
def main(): app = web.Application() setup_routes(app) web.run_app(app)
import base64 from aiohttp import web from cryptography import fernet from aiohttp_session import setup from aiohttp_session.cookie_storage import EncryptedCookieStorage import jinja2 import aiohttp_jinja2 from routes import setup_routes from db import init_pg, close_pg from settings import config, BASE_DIR from middlewares import setup_middlewares from tracktor import start_background_tasks app = web.Application() fernet_key = fernet.Fernet.generate_key() secret_key = base64.urlsafe_b64decode(fernet_key) setup(app, EncryptedCookieStorage(secret_key, max_age=300)) app['config'] = config aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader( str(BASE_DIR / 'aiohttp_tracktor' / 'templates'))) setup_middlewares(app) setup_routes(app, BASE_DIR) app.on_startup.append(init_pg) app.on_startup.append(start_background_tasks) app.on_cleanup.append(close_pg) web.run_app(app)
from aiohttp import web from routes import setup_routes import jinja2 import aiohttp_jinja2 from settings import BASE_DIR print(str(BASE_DIR / 'templates')) app = web.Application() setup_routes(app) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader(str(BASE_DIR / 'templates'))) web.run_app(app, host='127.0.0.1', port=8080)
def init(loop): app = web.Application(loop=loop) setup_routes(app) return app
def init(loop): app = web.Application(loop=loop) setup_routes(app) app['semaphore'] = asyncio.Semaphore(CONCURRENT_REQ) app['backends'] = {'heavy': heavy_back, 'light': light_back} return app
async def get_application(self): from routes import setup_routes app = web.Application() setup_routes(app) return app
# coding: utf-8 from flask import Flask from flask_restful_swagger_2 import Api # The line below needs to be uncommented when debugging from flask_cors import CORS from routes import setup_routes app = Flask(__name__) api = Api(app, api_version='1.0', api_spec_url='/api/specs') setup_routes(api) from data_access.data_access_base import DataAccessBase DataAccessBase.initialize() CORS(app) if __name__ == '__main__': app.run(host='0.0.0.0', debug=True, port=5234)
import logging import sys from weakref import WeakValueDictionary from aiohttp import web from config import LOG_PATH, HOST, PORT from routes import setup_routes # formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s') # handler = logging.FileHandler(LOG_PATH) # handler.setFormatter(formatter) # handler.setLevel(logging.INFO) # root = logging.getLogger() # root.addHandler(handler) # root.setLevel(logging.INFO) app = web.Application() app = setup_routes(app) web.run_app(app, host=HOST, port=PORT)
def init(loop): app = web.Application(loop=loop) setup_routes(app) app['semaphore'] = asyncio.Semaphore(CONCURRENT_REQ) return app
def setup_app() -> web.Application: app = web.Application() setup_routes(app) return app
def app(): app = web.Application() setup_routes(app) web.run_app(app, host=config.IP_ADDRESS, port=config.PORT)
from flask import Flask from routes import setup_routes app = Flask(__name__) setup_routes(app) if __name__ == "__main__": app.run(debug = True)
# Create config CONFIG = WebAppConfig() # Initialize Sentry sentry_sdk.init( dsn=CONFIG.SENTRY_DSN ) # Create storage and state stores STORAGE = MongodbStorage(CONFIG.MONGO_URL, CONFIG.MONGO_DB, CONFIG.MONGO_COL) USER_STATE = UserState(STORAGE) CONVERSATION_STATE = ConversationState(STORAGE) # Create main dialog INFORMER = RateAmParserExchangeRatesInformer() MAIN_DIALOG = MainDialog(USER_STATE, CONVERSATION_STATE, INFORMER) # Create the Bot BOT = DramRateBot(CONVERSATION_STATE, USER_STATE, MAIN_DIALOG) # Create the aiohttp web app APP = web.Application(middlewares=[aiohttp_error_middleware]) setup_routes(APP, ADAPTER, BOT) if __name__ == "__main__": try: web.run_app(APP, port=CONFIG.PORT) except Exception as error: raise error
def main(): app = web.Application() setup_routes(app) app.on_startup.append(init_pg) app.on_cleanup.append(close_pg) web.run_app(app)
def init_app() -> web.Application: """Инициализирует web приложение.""" app = web.Application() setup_jinja(app) setup_routes(app) return app
def main(prefix_name: str='schedule', is_debug=False): # set uvloop asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) # get event-loop loop = asyncio.get_event_loop() logger.info('{}:debug is {}'.format(prefix_name, is_debug)) # set debug (or not) to loop loop.set_debug(is_debug) # create web application (with set debug) app = web.Application( middlewares=[filter_errors_request], loop=loop, debug=is_debug, client_max_size=1024 ** 2 * 64 ) # add Headers for request app.on_response_prepare.append(on_prepare) # set settings for DBManager DBManager().set_settings(dict( user=config.get('DB', 'user'), password=config.get('DB', 'password'), database=config.get('DB', 'database'), host=config.get('DB', 'host'), port=config.get('DB', 'port') )) # initial connection-poll in DBManager loop.run_until_complete(loop.create_task(DBManager().init_pool())) app.on_shutdown.append(DBManager().on_shutdown) # add jinja2-templates aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('templates')) # add link to session in web.app app.session_storage = SessionManager() # auth header name app.auth_header_name = config.get('SERVICE', 'auth_header_name') # add routes setup_routes(app) # get url for run web-app bind_url = urlparse(config.get('PUBLIC_API', 'bind')) # run swagger setup_swagger(app, swagger_url='/api/docs', title='Schedule online docs', description='', api_version='0.1', contact='*****@*****.**') # run web application try: web.run_app( app, host=bind_url.hostname, port=bind_url.port, reuse_address=True, reuse_port=True, shutdown_timeout=1 ) finally: loop.close()
def init(loop): app = web.Application(loop=loop) setup_routes(app) app['backends'] = {'heavy': heavy_back, 'light': light_back} return app
def init_app(): app = web.Application() setup_routes(app) return app
async def init(): app = web.Application(middlewares=MIDDLEWARES) app.cleanup_ctx.extend(SERVICES) setup_routes(app) return app
async def init(loop, conf): app = web.Application(loop=loop) executor = await setup_executor(app, conf) handler = SiteHandler(conf, executor, BASE_ROOT) setup_routes(app, handler, BASE_ROOT) return app
async def init(): app = web.Application() setup_routes(app=app) host = os.getenv("IDLP_TENSORBOARD_API_HOST", 'idlp_tensorboard_worker') port = os.getenv("IDLP_TENSORBOARD_API_PORT", '8812') return app, host, port
async def create_app() -> web.Application: """Инициализирует приложение""" application = web.Application(middlewares=MIDDLEWARES) setup_routes(application) setup_aiohttp_apispec(application, **settings.APISPEC_CONF) return application
def main(): app = web.Application() setup_routes(app) web.run_app(app, host="0.0.0.0", port=8080)
async def create_app(): app = web.Application() setup_routes(app) return app
async def main(): app = web.Application() setup_routes(app) app.on_startup.append(start_background_tasks) app.on_cleanup.append(cleanup_background_tasks) return app
def main(): app = web.Application() aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader(TMPL_FOLDER)) app['static_root_url'] = STATIC_ROOT_URL app.router.add_static('/static', 'static', name='static') app.on_startup.append(start_db) app.on_cleanup.append(close_db) # Setup redis storage if redis server is on try: import asyncio import aioredis from aiohttp_session.redis_storage import RedisStorage async def make_redis_pool(app): return await aioredis.create_redis_pool(REDIS_ADDR, timeout=5) async def dispose_redis_pool(app): redis_pool.close() await redis_pool.wait_closed() loop = asyncio.get_event_loop() redis_pool = loop.run_until_complete(make_redis_pool(app)) storage = RedisStorage(redis_pool) app.on_cleanup.append(dispose_redis_pool) # Setup encrypted storage if redis server is off except ConnectionRefusedError: logger.warning( 'Cannot connect to redis server, switching to standard "EncryptedCookieStorage"' ) import base64 from cryptography import fernet from aiohttp_session.cookie_storage import EncryptedCookieStorage fernet_key = fernet.Fernet.generate_key() secret_key = base64.urlsafe_b64decode(fernet_key) storage = EncryptedCookieStorage(secret_key) async def custom_async_error_handler(request): return web.Response(text='You silly bot, f**k off!', status=403) def setup_csrf_protection(app): csrf_policy = aiohttp_csrf.policy.FormPolicy(FORM_FIELD_NAME) csrf_storage = aiohttp_csrf.storage.CookieStorage(COOKIE_NAME) aiohttp_csrf.token_generator.HashedTokenGenerator(SECRET_PHRASE) aiohttp_csrf.setup(app, policy=csrf_policy, storage=csrf_storage, error_renderer=custom_async_error_handler) # app.middlewares.append(aiohttp_csrf.csrf_middleware) # Using middlewares, all handlers will be protected # app.middlewares.append(aiohttp_csrf.csrf_middleware) # For mannual protection # @aiohttp_csrf.csrf_protect - pretection with csrf # @aiohttp_csrf.csrf_exempt - no protection with csrf setup_routes(app) logger.debug('Routes were setup') setup_session(app, storage) logger.debug('Storage was setup') setup_csrf_protection(app) logger.debug('csrf protection was setup') # aioreloader.start() logger.debug('Start with code reload') web.run_app(app, port=APP_PORT)
import os from aiohttp import web import aiohttp_jinja2 import jinja2 from settings import config, BASE_DIR from routes import setup_routes app = web.Application() app['config'] = config setup_routes(app) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader( str(os.path.join(BASE_DIR, 'templates')))) web.run_app(app, port=8088)
import base64 from cryptography import fernet from sqlalchemy import create_engine from middleware import json_content_type_middleware from routes import setup_routes from models import metadata from utils import DBAuthorizationPolicy engine = create_engine('sqlite:///../database.db') metadata.create_all(engine) fernet_key = fernet.Fernet.generate_key() secret_key = base64.urlsafe_b64decode(fernet_key) app = web.Application() cors = aiohttp_cors.setup(app, defaults={ "*": aiohttp_cors.ResourceOptions( allow_methods=["GET", 'POST'], allow_credentials=True, expose_headers="*", allow_headers="*"), }) setup_session(app, EncryptedCookieStorage(secret_key)) setup_security(app, SessionIdentityPolicy(), DBAuthorizationPolicy()) setup_routes(app, cors) web.run_app(app, port=7000)