def create_application() -> FastAPI:
application = FastAPI(title=PROJECT_NAME, version=VERSION)
# 添加事件
application.add_event_handler("startup",
create_start_app_handler(application))
application.add_event_handler("shutdown",
create_stop_app_handler(application))
# 添加错误处理
application.add_exception_handler(HTTPException, http_error_handler)
application.add_exception_handler(RequestValidationError,
http422_error_handler)
application.add_exception_handler(RequestValidationError,
request_validation_exception_handler)
application.add_exception_handler(UnicornException,
unicorn_exception_handler)
# 添加中间件
init_middlewares(application)
application.add_middleware(CustomMiddleware)
# 添加路由
application.include_router(api_router)
return application
def init_app(self,
app: FastAPI,
uri: Optional[str] = None,
db_name: Optional[str] = None,
env: str = "development") -> None:
"""Define self.app_string and add 'startup' and 'shutdown' event handlers to the given FastAPI application.
:param app: The relevant FastAPI application
:type app: class: FastAPI
:param uri: Where to find the database; defaults to None, in which case localhost:27027 will be used
:type uri: str, optional
:param db_name: Name of the database to use; if None, a name will be generated based on the title of the FastAPI app provided to the init_app method
:type db_name: str, optional
:param env: The environment in which the app is running, defaults to 'development'
:type env: str
:raises AlreadyInitializedError: Cannot init an app that has already been initialized
"""
async def connect():
await self.connect_to_mongo(uri=uri, db_name=db_name)
async def close():
await self.close_mongo_connection()
if any(obj is not None
for obj in (self.app_string, self.client, self.db, self.fs,
self.environment)):
raise AlreadyInitializedError("Engine is already initialized.")
self.app_string = ''.join(c if c.isalpha() else "_"
for c in list(app.title.lower()))
self.environment = env
app.add_event_handler("startup", connect)
app.add_event_handler("shutdown", close)
def _init_fastapi_app():
app = FastAPI(
title='Imune',
description='Imune API',
version='0.0.1',
redoc_url=None,
)
app.add_middleware(
CORSMiddleware,
allow_origins=['*'],
allow_credentials=True,
allow_methods=['*'],
allow_headers=['*'],
)
routers = [
user_router, login_router, vaccine_router, person_router, batch_router,
vaccinate_router, occurrence_router
]
[app.include_router(**r) for r in routers]
app.add_event_handler('startup', connect_to_mongo)
app.add_event_handler("startup", apply_migrations)
app.add_event_handler('shutdown', close_mongo_connection)
app.add_exception_handler(NotFoundException, not_found_exception_handler)
app.add_exception_handler(BusinessValidationException,
business_validation_exception_handler)
app.add_exception_handler(ApiBaseException, generic_render)
app.add_exception_handler(EnvironmentException, generic_render)
app.add_exception_handler(LoginException, generic_render)
return app
def get_app() -> FastAPI:
fast_app = FastAPI(title=APP_NAME, version=APP_VERSION, debug=IS_DEBUG)
fast_app.include_router(api_router, prefix=API_PREFIX)
fast_app.add_event_handler("startup", start_app_handler(fast_app))
fast_app.add_event_handler("shutdown", stop_app_handler(fast_app))
return fast_app
def get_application() -> FastAPI:
application = FastAPI(title=config.PROJECT_NAME,
debug=config.DEBUG,
version=config.VERSION)
application.add_middleware(
CORSMiddleware,
allow_origins=config.ALLOWED_HOSTS or ["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
application.add_event_handler(
"startup", events.create_startup_app_handler(application))
application.add_event_handler(
"shutdown", events.create_shutdown_app_handler(application))
application.add_exception_handler(HTTPException, http_error_handler)
application.add_exception_handler(RequestValidationError,
http422_error_handler)
application.include_router(api_router, prefix=config.API_PREFIX)
return application
def get_application():
application = FastAPI(title='FastAPI')
application.add_event_handler("startup", create_start_app_handler(application))
application.add_event_handler("shutdown", create_stop_app_handler(application))
application.include_router(api_router, prefix='/api')
application.add_exception_handler(HTTPException, http_error_handler)
return application
def setup(app: FastAPI, settings: Optional[WebServerSettings] = None) -> None:
if not settings:
settings = WebServerSettings()
assert settings is not None # nosec
setup_client_instance(app,
WebserverApi,
api_baseurl=settings.base_url,
service_name="webserver")
# TODO: old startup. need to integrat
# TODO: init client and then build sessions from client using depenencies
def on_startup() -> None:
# normalize & encrypt
secret_key = _get_secret_key(settings)
app.state.webserver_fernet = fernet.Fernet(secret_key)
# init client
logger.debug("Setup webserver at %s...", settings.base_url)
client = AsyncClient(base_url=settings.base_url)
app.state.webserver_client = client
async def on_shutdown() -> None:
with suppress(AttributeError):
client: AsyncClient = app.state.webserver_client
await client.aclose()
del app.state.webserver_client
logger.debug("Webserver closed successfully")
app.add_event_handler("startup", on_startup)
app.add_event_handler("shutdown", on_shutdown)
def init_app(settings: Optional[AppSettings] = None) -> FastAPI:
if settings is None:
settings = AppSettings.create_from_envs()
assert settings # nosec
logging.basicConfig(level=settings.LOG_LEVEL.value)
logging.root.setLevel(settings.LOG_LEVEL.value)
logger.debug(settings.json(indent=2))
app = FastAPI(
debug=settings.SC_BOOT_MODE
in [BootModeEnum.DEBUG, BootModeEnum.DEVELOPMENT, BootModeEnum.LOCAL],
title=PROJECT_NAME,
description=SUMMARY,
version=API_VERSION,
openapi_url=f"/api/{API_VTAG}/openapi.json",
docs_url="/dev/doc",
redoc_url=None, # default disabled
)
override_fastapi_openapi_method(app)
app.state.settings = settings
if settings.SC_BOOT_MODE == BootModeEnum.DEBUG:
remote_debug.setup(app)
if settings.DIRECTOR_V0.DIRECTOR_V0_ENABLED:
director_v0.setup(app, settings.DIRECTOR_V0)
if settings.POSTGRES.DIRECTOR_V2_POSTGRES_ENABLED:
db.setup(app, settings.POSTGRES)
if settings.DYNAMIC_SERVICES.DIRECTOR_V2_DYNAMIC_SERVICES_ENABLED:
dynamic_services.setup(app, settings.DYNAMIC_SERVICES)
if settings.DYNAMIC_SERVICES.DYNAMIC_SIDECAR and (
settings.DYNAMIC_SERVICES.DYNAMIC_SCHEDULER
and settings.DYNAMIC_SERVICES.DYNAMIC_SCHEDULER.
DIRECTOR_V2_DYNAMIC_SCHEDULER_ENABLED):
dynamic_sidecar.setup(app)
if settings.DASK_SCHEDULER.DIRECTOR_V2_DASK_CLIENT_ENABLED:
dask_clients_pool.setup(app, settings.DASK_SCHEDULER)
if settings.DASK_SCHEDULER.DIRECTOR_V2_DASK_SCHEDULER_ENABLED:
rabbitmq.setup(app)
comp_scheduler.setup(app)
if settings.DIRECTOR_V2_TRACING:
setup_tracing(app, settings.DIRECTOR_V2_TRACING)
# setup app --
app.add_event_handler("startup", on_startup)
app.add_event_handler("shutdown", on_shutdown)
_set_exception_handlers(app)
app.include_router(api_router)
config_all_loggers()
return app
def setup_client_instance(app: FastAPI,
api_cls: Type[BaseServiceClientApi],
api_baseurl: str,
service_name: str,
api_general_timeout: float = 5.0,
**extra_fields) -> None:
"""Helper to add init/cleanup of ServiceClientApi instances in the app lifespam"""
assert issubclass(api_cls, BaseServiceClientApi)
def _create_instance() -> None:
api_cls.create_once(app,
client=httpx.AsyncClient(
http2=True,
base_url=api_baseurl,
timeout=api_general_timeout),
service_name=service_name,
**extra_fields)
async def _cleanup_instance() -> None:
api_obj: Optional[BaseServiceClientApi] = api_cls.pop_instance(app)
if api_obj:
await api_obj.client.aclose()
app.add_event_handler("startup", _create_instance)
app.add_event_handler("shutdown", _cleanup_instance)
def get_fastapi_app(title: str = "",
debug: bool = False,
version: str = "0.0.0"):
initial_app = FastAPI(title=title, debug=debug, version=version)
initial_app.add_middleware(
CORSMiddleware,
allow_origins=ALLOWED_HOSTS or ["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
# App Startup/Shutdown Events
initial_app.add_event_handler("startup",
create_start_app_handler(initial_app))
initial_app.add_event_handler("shutdown",
create_stop_app_handler(initial_app))
# Exception Handlers
initial_app.add_exception_handler(HTTPException, http_error_handler)
initial_app.add_exception_handler(RequestValidationError,
http422_error_handler)
# Add Routes
initial_app.include_router(api_router, prefix=API_PREFIX)
return initial_app
def get_application() -> FastAPI:
application = FastAPI(title=PROJECT_NAME, debug=DEBUG, version=VERSION)
application.add_middleware(
CORSMiddleware,
allow_origins=ALLOWED_HOSTS or ["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
application.mount("/static",
StaticFiles(directory="static"),
name="static")
application.add_event_handler("startup",
create_start_app_handler(application))
application.add_event_handler("shutdown",
create_stop_app_handler(application))
application.add_exception_handler(HTTPException, http_error_handler)
application.add_exception_handler(RequestValidationError,
http422_error_handler)
application.include_router(api_router, prefix=API_PREFIX)
application.include_router(html_router, prefix='')
return application
def create_app():
logger.add(settings.LOG_FILE,
level=settings.LOG_LEVEL,
backtrace=settings.LOG_BACKTRACE)
app = FastAPI(
debug=settings.DEBUG,
title=settings.PROJECT_NAME,
)
# add middleware
app.add_middleware(GZipMiddleware, minimum_size=1000)
# add event handlers
app.add_event_handler("startup", create_start_app_handler(app))
app.add_event_handler("shutdown", create_stop_app_handler(app))
# add routes
app.include_router(api_router, prefix="/api")
app.mount("/static",
StaticFiles(directory="frontend/dist/static"),
name="static")
app.mount("/",
StaticFiles(html=True, directory="frontend/dist/"),
name="index")
return app
def get_app() -> FastAPI:
app = FastAPI()
origin = ALLOWED_HOSTS or ["*"]
# 开启cors (跨源资源共享)
app.add_middleware(
CORSMiddleware,
allow_origins=origin,
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
# 500字节以上开启gzip
app.add_middleware(GZipMiddleware, minimum_size=500)
# 添加中间件计算程序运行时间
@app.middleware("http")
async def add_process_time_helper(request: Request, call_next):
start_time = time.time()
response = await call_next(request)
process_time = time.time() - start_time
response.headers["X-Process-Time"] = str(process_time)
return response
app.include_router(router, prefix=API_V1_STR)
# 添加数据库连接和关闭事件
app.add_event_handler("startup", connect_to_mongo)
app.add_event_handler("shutdown", close_mongo_connection)
return app
def bootstrap_app():
app = FastAPI(title="automated terrarium dashboard API",
openapi_prefix=API_PREFIX)
app.add_event_handler("startup", startup_handler)
app.include_router(temperature.router, prefix="/sensor")
app.include_router(humidity.router, prefix="/sensor")
app.include_router(device.router, prefix="/device")
app.include_router(sensor.router, prefix="/sensors")
app.include_router(door.router, prefix="/sensor")
app.include_router(relay.router, prefix="/relay")
app.include_router(settings.router, prefix="/settings")
session = base.session_factory(True)
startup.migrate(session)
if __debug__:
from starlette.middleware.cors import CORSMiddleware
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
return app
def add_databases_to_app(app: FastAPI,
dbs: Dict[str, DatabaseDefinition]) -> FastAPI:
"""Add instances of :class:`Database` as attribute of app.
For each database as defined in the ``config.yml`` as external-resource,
create a :class:`Database` instance with defined parameters, add this
instance to the ``app.databases``-attribute and add ``startup`` and
``shutdown`` handlers to connect / disconnect to the database on
app-startup / app-shutdown.
Parameters:
app: the app to add the database definitions to.
dbs: the databases to add to the app.
Returns:
modified app containing the attribute app.databases and event handler
for startup and shutdown for the databases.
"""
for _, db_definition in dbs.items():
database = Database(dsn=db_definition.dsn,
logger=app.logger,
min_size=db_definition.min_size,
max_size=db_definition.max_size)
app.add_event_handler('startup', database.connect)
app.add_event_handler('shutdown', database.disconnect)
try:
app.databases.update({db_definition.name: database})
except AttributeError:
app.databases = {db_definition.name: database}
return app
def create_app():
app = FastAPI(title=config.PROJECT_NAME,
debug=config.DEBUG,
version=config.VERSION,
docs_url=None,
redoc_url=None)
app.add_middleware(
CORSMiddleware,
allow_origins=config.ALLOWED_HOSTS or ["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
add_timing_middleware(app,
record=logger.info,
prefix="solr",
exclude="untimed")
app.add_event_handler("startup", create_start_app_handler())
app.add_event_handler("shutdown", create_stop_app_handler())
# router
app.include_router(service_routes, prefix=config.PAGE_PREFIX)
# app.include_router(api_routes, prefix=config.API_PREFIX)
app.include_router(api_routes)
init_logger()
from src.scheduler import customized_jobs
customized_jobs.add_a_job()
return app
def assemble_application() -> FastAPI:
"""
Creates the application from using the env vars as a context
Also stores inside the state all instances of classes
needed in other requests and used to share data.
"""
dynamic_sidecar_settings = DynamicSidecarSettings.create_from_envs()
logging.basicConfig(level=dynamic_sidecar_settings.loglevel)
logging.root.setLevel(dynamic_sidecar_settings.loglevel)
logger.debug(dynamic_sidecar_settings.json(indent=2))
application = FastAPI(
debug=dynamic_sidecar_settings.DEBUG,
openapi_url=f"/api/{API_VTAG}/openapi.json",
docs_url="/dev/doc",
)
override_fastapi_openapi_method(application)
# store "settings" and "shared_store" for later usage
application.state.settings = dynamic_sidecar_settings
application.state.shared_store = SharedStore(
settings=dynamic_sidecar_settings) # type: ignore
# used to keep track of the health of the application
# also will be used in the /health endpoint
application.state.application_health = ApplicationHealth()
# enable debug if required
if dynamic_sidecar_settings.is_development_mode:
remote_debug_setup(application)
if dynamic_sidecar_settings.RABBIT_SETTINGS:
setup_rabbitmq(application)
# requires rabbitmq to be in place
setup_background_log_fetcher(application)
# add routing paths
application.include_router(main_router)
setup_directory_watcher(application)
def create_start_app_handler() -> Callable[[], Coroutine[Any, Any, None]]:
async def on_startup() -> None:
await login_registry(application.state.settings.REGISTRY_SETTINGS)
print(WELCOME_MSG, flush=True)
return on_startup
def create_stop_app_handler() -> Callable[[], Coroutine[Any, Any, None]]:
async def on_shutdown() -> None:
await on_shutdown_handler(application)
logger.info("shutdown cleanup completed")
return on_shutdown
application.add_event_handler("startup", create_start_app_handler())
application.add_event_handler("shutdown", create_stop_app_handler())
return application
def get_application() -> FastAPI:
application = FastAPI(title=PROJECT_NAME, debug=DEBUG, version=VERSION)
application.include_router(api_router, prefix=API_PREFIX)
pre_load = False
if pre_load:
application.add_event_handler("startup", create_start_app_handler(application))
return application
def get_application() -> FastAPI:
settings = get_app_settings()
settings.configure_logging()
application = FastAPI(**settings.fastapi_kwargs)
application.add_middleware(
CORSMiddleware,
allow_origins=settings.allowed_hosts,
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
application.add_event_handler(
"startup",
create_start_app_handler(application, settings),
)
application.add_event_handler(
"shutdown",
create_stop_app_handler(application),
)
application.add_exception_handler(HTTPException, http_error_handler)
application.add_exception_handler(RequestValidationError, http422_error_handler)
application.include_router(api_router, prefix=settings.api_prefix)
return application
def get_application() -> FastAPI:
application = FastAPI(title=config.PROJECT_NAME,
debug=config.DEBUG,
description=config.API_DESCRIPTION,
version=config.VERSION,
docs_url=None,
redoc_url=None,
openapi_url=None)
application.add_event_handler("startup",
create_start_app_handler(application))
application.add_event_handler("shutdown",
create_stop_app_handler(application))
try:
application.add_middleware(
RequestTracerMiddleware,
exporter=AzureExporter(
connection_string=
f'InstrumentationKey={os.getenv("APPINSIGHTS_INSTRUMENTATIONKEY")}',
sampler=ProbabilitySampler(1.0)))
except Exception as e:
logging.error(f"Failed to add RequestTracerMiddleware: {e}")
application.add_middleware(ServerErrorMiddleware,
handler=generic_error_handler)
application.add_exception_handler(HTTPException, http_error_handler)
application.add_exception_handler(RequestValidationError,
http422_error_handler)
application.include_router(api_router)
return application
def get_app() -> FastAPI:
rec_engine = FastAPI(title=APP_NAME, version=APP_VERSION, debug=IS_DEBUG)
rec_engine.include_router(api_router, prefix=API_PREFIX)
rec_engine.add_event_handler("startup", start_app_handler(rec_engine))
rec_engine.add_event_handler("shutdown", stop_app_handler(rec_engine))
return rec_engine
def get_application(settings: Optional[ServiceSettings] = None):
"""Application factory."""
if settings is None:
settings = ServiceSettings()
docs_enabled = settings.docs_enabled
application = FastAPI(
title=settings.app_title,
version=settings.app_version,
openapi_tags=OPENAPI_TAGS,
debug=settings.fastapi_debug,
openapi_url=settings.docs_openapi_url if docs_enabled else None,
docs_url=settings.docs_url if docs_enabled else None,
redoc_url=settings.docs_redoc_url if docs_enabled else None,
openapi_prefix=settings.docs_openapi_prefix,
root_path=settings.fastapi_root_path,
)
if settings.prometheus_enabled:
application.add_middleware(
PrometheusMiddleware,
group_paths=settings.prometheus_group_paths,
app_name=settings.prometheus_app_name,
prefix=settings.prometheus_prefix,
)
if settings.keycloak_url is not None:
keycloak_url = settings.keycloak_url
realm = settings.keycloak_realm
update_oauth2_scheme(
f"{keycloak_url}auth/realms/{realm}/protocol/openid-connect/auth",
f"{keycloak_url}auth/realms/{realm}/protocol/openid-connect/token",
)
application.add_event_handler(
"startup", app_event_handler.start_app_handler(application, settings)
)
application.add_event_handler(
"shutdown", app_event_handler.stop_app_handler(application)
)
application.include_router(get_router(settings))
application.middleware("http")(request_context.add_log_context)
application.exception_handler(HTTPException)(
exception_handlers.http_exception_handler
)
application.exception_handler(RequestValidationError)(
exception_handlers.validation_exception_handler
)
sentry_sdk.init(
dsn=settings.sentry_dsn,
sample_rate=settings.sentry_traces_sample_rate,
release=settings.app_version,
)
return application
def setup_tracing(app: FastAPI, tracing_settings: TracingSettings):
async def start_app() -> None:
settings.service_name = tracing_settings.TRACING_CLIENT_NAME
settings.jaeger_host = tracing_settings.TRACING_THRIFT_COMPACT_ENDPOINT.host
settings.jaeger_port = tracing_settings.TRACING_THRIFT_COMPACT_ENDPOINT.port
setup_opentracing(app)
app.add_middleware(OpentracingMiddleware)
app.add_event_handler("startup", start_app)
def get_app() -> FastAPI:
logger.info("App Initialization")
fast_app = FastAPI(title=settings.APP_NAME, version=settings.APP_VERSION)
fast_app.include_router(api_router, prefix=settings.API_PREFIX)
fast_app.add_event_handler("startup", start_app_handler(fast_app))
fast_app.add_event_handler("shutdown", stop_app_handler(fast_app))
fast_app.add_middleware(RequestContextLogMiddleware)
return fast_app
def create_app() -> FastAPI:
application = FastAPI()
application.add_event_handler('startup', startup_handler(application))
application.add_event_handler('shutdown', shutdown_handler(application))
application.include_router(router)
return application
def create_app() -> FastAPI:
app = FastAPI(debug=settings.DEBUG)
app.include_router(router)
handler = StartAndStopEventHandler(app)
app.add_event_handler("startup", handler.on_startup)
app.add_event_handler("shutdown", handler.on_shutdown)
app.add_middleware(AddIdentifierMiddleWare)
return app
def get_application() -> FastAPI:
"""Initialize app"""
application = FastAPI()
application.add_event_handler('startup', create_engine(application))
application.add_event_handler('shutdown', close_engine(application))
init_routes(application)
return application
def get_application() -> FastAPI:
application = FastAPI()
application.add_event_handler("startup", create_start_app_handler(application))
application.add_event_handler("shutdown", create_stop_app_handler(application))
application.include_router(api_router)
return application
def setup(app: FastAPI):
app.add_event_handler("startup", startup)
app.middleware("http")(add_session_to_request)
async_sqlalchemy_url = os.getenv("async_sqlalchemy_url")
if async_sqlalchemy_url:
assert asyncio_support, asyncio_support_err
app.add_event_handler("startup", asyncio_support.startup)
app.middleware("http")(asyncio_support.add_session_to_request)
def get_app() -> FastAPI:
"""FastAPI app controller"""
fast_app = FastAPI(title=APP_NAME, version=APP_VERSION, debug=IS_DEBUG)
instrumentator.instrument(fast_app).expose(fast_app,
include_in_schema=False,
should_gzip=False)
fast_app.include_router(api_router)
fast_app.add_event_handler("startup", start_app_handler(fast_app))
fast_app.add_event_handler("shutdown", stop_app_handler(fast_app))
return fast_app
