fastapi-modular 0.1.0__py3-none-any.whl

pymodular/core/error_handlers.py

@@ -0,0 +1,272 @@
+"""Chuẩn hoá mọi lỗi HTTP về cùng một hình dạng JSON.
+
+{"code": "...", "message": "...", "details": ..., "request_id": "..."}
+"""
+
+from __future__ import annotations
+
+from fastapi import FastAPI, Request
+from fastapi.exceptions import RequestValidationError
+from fastapi.responses import JSONResponse
+from starlette.exceptions import HTTPException as StarletteHTTPException
+
+from pymodular.core.context import get_request_id, get_trace_id
+from pymodular.core.exceptions import AppError
+from pymodular.core.logging import get_logger
+
+log = get_logger(__name__)
+
+
+def _response(status_code: int, payload: dict[str, object]) -> JSONResponse:
+    payload["request_id"] = get_request_id()
+    # Trả cả trace_id để người dùng báo lỗi kèm mã này là tra được toàn bộ
+    # hành trình qua các dịch vụ, không chỉ log của riêng dịch vụ này.
+    trace_id = get_trace_id()
+    if trace_id:
+        payload["trace_id"] = trace_id
+    return JSONResponse(status_code=status_code, content=payload)
+
+
+def _unavailable(exc: Exception, *, debug: bool) -> JSONResponse:
+    """Database không với tới được — lỗi vận hành, không phải bug.
+
+    Trả 503 chứ không phải 500: load balancer và client biết đây là tình trạng
+    tạm thời và nên thử lại, còn 500 nghĩa là "gửi lại cũng vô ích".
+    """
+    log.warning("db.unavailable", error=f"{type(exc).__name__}: {exc}")
+    return _response(
+        503,
+        {
+            "code": "database_unavailable",
+            "message": "Không kết nối được cơ sở dữ liệu, vui lòng thử lại",
+            **({"details": f"{type(exc).__name__}: {exc}"} if debug else {}),
+        },
+    )
+
+
+def _register_circuit_handler(app: FastAPI, *, debug: bool) -> None:
+    """Mạch đang ngắt -> 503 kèm Retry-After, không chạm database."""
+    from pymodular.infrastructure.database.circuit import CircuitOpenError
+
+    @app.exception_handler(CircuitOpenError)
+    async def _circuit_open(_: Request, exc: CircuitOpenError) -> JSONResponse:
+        log.warning("db.circuit_rejected", backend=exc.backend, retry_after=exc.retry_after)
+        response = _response(
+            503,
+            {
+                "code": "database_unavailable",
+                "message": "Không kết nối được cơ sở dữ liệu, vui lòng thử lại",
+                **({"details": str(exc)} if debug else {}),
+            },
+        )
+        response.headers["Retry-After"] = str(max(1, int(exc.retry_after)))
+        return response
+
+
+def _register_duplicate_handler(app: FastAPI, *, debug: bool) -> None:
+    """Trùng khoá do backend memory phát hiện -> 409, giống SQL và Mongo."""
+    from pymodular.infrastructure.database.base import DuplicateKeyViolation
+
+    @app.exception_handler(DuplicateKeyViolation)
+    async def _duplicate(_: Request, exc: DuplicateKeyViolation) -> JSONResponse:
+        log.warning("db.duplicate_key", storage=exc.storage, columns=list(exc.columns))
+        return _response(
+            409,
+            {
+                "code": "integrity_error",
+                "message": "Thao tác vi phạm ràng buộc dữ liệu",
+                **({"details": str(exc)} if debug else {}),
+            },
+        )
+
+
+def _register_connection_handlers(app: FastAPI, *, debug: bool) -> None:
+    """Lỗi socket thuần (ConnectionRefused/Reset/Aborted) -> 503."""
+
+    @app.exception_handler(ConnectionError)
+    async def _connection_error(_: Request, exc: ConnectionError) -> JSONResponse:
+        return _unavailable(exc, debug=debug)
+
+    @app.exception_handler(TimeoutError)
+    async def _timeout_error(_: Request, exc: TimeoutError) -> JSONResponse:
+        # Quá hạn khi gọi database cũng là "tạm thời không phục vụ được".
+        return _unavailable(exc, debug=debug)
+
+
+def _register_mongo_handlers(app: FastAPI, *, debug: bool) -> None:
+    """Handler cho lỗi MongoDB — chỉ khi project thực sự cài driver."""
+    try:
+        from pymongo.errors import ConnectionFailure, DuplicateKeyError, PyMongoError
+    except ModuleNotFoundError:
+        log.debug("error_handlers.pymongo_missing")
+        return
+
+    @app.exception_handler(ConnectionFailure)
+    async def _mongo_unavailable(_: Request, exc: Exception) -> JSONResponse:
+        # ConnectionFailure là cha của AutoReconnect, NetworkTimeout,
+        # ServerSelectionTimeoutError — tức mọi tình huống "Mongo không với tới được".
+        return _unavailable(exc, debug=debug)
+
+    @app.exception_handler(DuplicateKeyError)
+    async def _mongo_duplicate(_: Request, exc: Exception) -> JSONResponse:
+        log.warning("db.duplicate_key", error=str(exc))
+        return _response(
+            409,
+            {
+                "code": "integrity_error",
+                "message": "Thao tác vi phạm ràng buộc dữ liệu",
+                **({"details": str(exc)} if debug else {}),
+            },
+        )
+
+    @app.exception_handler(PyMongoError)
+    async def _mongo_error(_: Request, exc: Exception) -> JSONResponse:
+        log.exception("db.error", error=str(exc))
+        return _response(
+            500,
+            {
+                "code": "database_error",
+                "message": "Lỗi truy cập cơ sở dữ liệu",
+                **({"details": str(exc)} if debug else {}),
+            },
+        )
+
+
+def _register_amqp_handlers(app: FastAPI, *, debug: bool) -> None:
+    """Handler cho lỗi RabbitMQ — chỉ khi project thực sự cài aio-pika."""
+    try:
+        from aiormq.exceptions import AMQPError, ChannelInvalidStateError
+    except ModuleNotFoundError:
+        log.debug("error_handlers.aio_pika_missing")
+        return
+
+    # ChannelInvalidStateError KHÔNG kế thừa AMQPError mà kế thừa RuntimeError
+    # — đăng ký thiếu nó thì "gửi tin lúc broker vừa chết" rơi vào handler 500
+    # chung thay vì 503. Đây là lỗi tôi gặp khi thử tắt broker giữa chừng.
+    @app.exception_handler(AMQPError)
+    @app.exception_handler(ChannelInvalidStateError)
+    async def _amqp_error(_: Request, exc: Exception) -> JSONResponse:
+        # Mọi lỗi AMQP đều là "hạ tầng nhắn tin đang trục trặc" dưới góc nhìn
+        # client: kết nối rớt, kênh bị đóng, broker từ chối. Trả 503 để client
+        # biết thử lại sau, thay vì 500 nghĩa là gửi lại cũng vô ích.
+        log.warning("mq.unavailable", error=f"{type(exc).__name__}: {exc}")
+        return _response(
+            503,
+            {
+                "code": "rabbitmq_unavailable",
+                "message": "RabbitMQ không sẵn sàng, vui lòng thử lại",
+                **({"details": f"{type(exc).__name__}: {exc}"} if debug else {}),
+            },
+        )
+
+
+def _register_db_handlers(app: FastAPI, *, debug: bool) -> None:
+    """Đăng ký handler cho lỗi SQLAlchemy — chỉ khi project thực sự cài SQLAlchemy.
+
+    Template này không bắt buộc dùng DB; khi chưa cài (chưa dùng Postgres/SQLite)
+    thì bỏ qua, các lỗi khác vẫn rơi vào handler Exception chung.
+    """
+    try:
+        from sqlalchemy.exc import (
+            IntegrityError,
+            InterfaceError,
+            OperationalError,
+            SQLAlchemyError,
+        )
+    except ModuleNotFoundError:
+        log.debug("error_handlers.sqlalchemy_missing")
+        return
+
+    # Starlette chọn handler khớp nhất theo MRO, nên hai handler dưới đây thắng
+    # handler SQLAlchemyError chung ở cuối hàm.
+    @app.exception_handler(OperationalError)
+    @app.exception_handler(InterfaceError)
+    async def _sql_unavailable(_: Request, exc: Exception) -> JSONResponse:
+        return _unavailable(exc, debug=debug)
+
+    @app.exception_handler(IntegrityError)
+    async def _integrity_error(_: Request, exc: IntegrityError) -> JSONResponse:
+        log.warning("db.integrity_error", error=str(exc.orig))
+        return _response(
+            409,
+            {
+                "code": "integrity_error",
+                "message": "Thao tác vi phạm ràng buộc dữ liệu",
+                **({"details": str(exc.orig)} if debug else {}),
+            },
+        )
+
+    @app.exception_handler(SQLAlchemyError)
+    async def _db_error(_: Request, exc: SQLAlchemyError) -> JSONResponse:
+        log.exception("db.error", error=str(exc))
+        return _response(
+            500,
+            {
+                "code": "database_error",
+                "message": "Lỗi truy cập cơ sở dữ liệu",
+                **({"details": str(exc)} if debug else {}),
+            },
+        )
+
+
+def register_error_handlers(app: FastAPI, *, debug: bool = False) -> None:
+    @app.exception_handler(AppError)
+    async def _app_error(_: Request, exc: AppError) -> JSONResponse:
+        if exc.status_code >= 500:
+            log.error("app.error", code=exc.error_code, message=exc.message)
+        return _response(exc.status_code, exc.to_dict())
+
+    @app.exception_handler(RequestValidationError)
+    async def _validation_error(_: Request, exc: RequestValidationError) -> JSONResponse:
+        return _response(
+            422,
+            {
+                "code": "validation_error",
+                "message": "Dữ liệu đầu vào không hợp lệ",
+                "details": [
+                    {
+                        "field": ".".join(str(p) for p in err["loc"][1:]) or str(err["loc"][0]),
+                        "message": err["msg"],
+                        "type": err["type"],
+                    }
+                    for err in exc.errors()
+                ],
+            },
+        )
+
+    @app.exception_handler(NotImplementedError)
+    async def _not_implemented(_: Request, exc: NotImplementedError) -> JSONResponse:
+        # Khung do `make module` sinh ra dùng `raise NotImplementedError(...)`.
+        return _response(
+            501,
+            {
+                "code": "not_implemented",
+                "message": str(exc) or "Chức năng chưa được cài đặt",
+            },
+        )
+
+    @app.exception_handler(StarletteHTTPException)
+    async def _http_error(_: Request, exc: StarletteHTTPException) -> JSONResponse:
+        return _response(
+            exc.status_code,
+            {"code": f"http_{exc.status_code}", "message": str(exc.detail)},
+        )
+
+    _register_circuit_handler(app, debug=debug)
+    _register_duplicate_handler(app, debug=debug)
+    _register_connection_handlers(app, debug=debug)
+    _register_db_handlers(app, debug=debug)
+    _register_mongo_handlers(app, debug=debug)
+    _register_amqp_handlers(app, debug=debug)
+
+    @app.exception_handler(Exception)
+    async def _unhandled(_: Request, exc: Exception) -> JSONResponse:
+        log.exception("app.unhandled_error", error=str(exc))
+        return _response(
+            500,
+            {
+                "code": "internal_error",
+                "message": "Internal server error",
+                **({"details": f"{type(exc).__name__}: {exc}"} if debug else {}),
+            },
+        )

pymodular/core/exceptions.py

@@ -0,0 +1,104 @@
+"""Cây exception của tầng ứng dụng.
+
+Service/repository chỉ ném các lỗi này; việc dịch sang HTTP status hay gRPC
+status code do tầng ngoài (error_handlers / interceptor) đảm nhiệm. Nhờ vậy
+domain không phụ thuộc vào giao thức.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class AppError(Exception):
+    """Lỗi nghiệp vụ gốc."""
+
+    status_code: int = 500
+    error_code: str = "internal_error"
+    message: str = "Internal server error"
+
+    def __init__(
+        self,
+        message: str | None = None,
+        *,
+        error_code: str | None = None,
+        details: Any = None,
+    ) -> None:
+        self.message = message or self.message
+        self.error_code = error_code or self.error_code
+        self.details = details
+        super().__init__(self.message)
+
+    def to_dict(self) -> dict[str, Any]:
+        payload: dict[str, Any] = {"code": self.error_code, "message": self.message}
+        if self.details is not None:
+            payload["details"] = self.details
+        return payload
+
+
+class BadRequestError(AppError):
+    status_code = 400
+    error_code = "bad_request"
+    message = "Bad request"
+
+
+class UnauthorizedError(AppError):
+    status_code = 401
+    error_code = "unauthorized"
+    message = "Not authenticated"
+
+
+class ForbiddenError(AppError):
+    status_code = 403
+    error_code = "forbidden"
+    message = "Permission denied"
+
+
+class NotFoundError(AppError):
+    status_code = 404
+    error_code = "not_found"
+    message = "Resource not found"
+
+
+class ConflictError(AppError):
+    status_code = 409
+    error_code = "conflict"
+    message = "Resource conflict"
+
+
+class ValidationError(AppError):
+    status_code = 422
+    error_code = "validation_error"
+    message = "Validation failed"
+
+
+class TooManyRequestsError(AppError):
+    status_code = 429
+    error_code = "too_many_requests"
+    message = "Too many requests"
+
+
+class NotImplementedYetError(AppError):
+    """Hàm mới được sinh khung, chưa viết thân.
+
+    Trả 501 chứ không phải 500: 501 nói "chức năng này chưa tồn tại", còn 500
+    nói "có bug". Nhờ vậy khung do `pym module` sinh ra không bị nhầm là hỏng.
+    """
+
+    status_code = 501
+    error_code = "not_implemented"
+    message = "Chức năng chưa được cài đặt"
+
+
+class ServiceUnavailableError(AppError):
+    status_code = 503
+    error_code = "service_unavailable"
+    message = "Service temporarily unavailable"
+
+
+class ComponentNotEnabledError(AppError):
+    """Code cố dùng một hạ tầng đang bị tắt trong config."""
+
+    status_code = 503
+    error_code = "component_not_enabled"
+    message = "Required infrastructure component is not enabled"

pymodular/core/guards.py

@@ -0,0 +1,117 @@
+"""Guard — chặn request trước khi vào handler (tương đương @UseGuards của Nest).
+
+Guard KHÔNG phải nơi chứa nghiệp vụ; nó chỉ trả lời một câu: request này có
+được đi tiếp không. Muốn từ chối thì ném lỗi nghiệp vụ (UnauthorizedError /
+ForbiddenError) — error_handlers sẽ dịch sang HTTP.
+
+Gắn ở cấp controller (áp cho mọi route) hoặc cấp từng route; hai nơi cộng dồn:
+
+    @controller(prefix="/devices", guards=[RequireHeader])
+    class DeviceController:
+        @delete("/{device_id}", guards=[AdminOnly])
+        async def remove(self, device_id: str) -> None: ...
+
+Guard là provider bình thường nên nhận được phụ thuộc qua __init__.
+
+Template CHƯA có xác thực thật. Chỗ để cắm vào: viết một guard đọc header/token
+rồi gọi `principal.assume(...)`, phần còn lại của hệ thống dùng ngay được.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Protocol, runtime_checkable
+
+from starlette.requests import HTTPConnection
+
+from pymodular.core.container import Scope, container, injectable
+from pymodular.core.exceptions import ForbiddenError, UnauthorizedError
+from pymodular.core.logging import get_logger
+
+log = get_logger(__name__)
+
+
+@runtime_checkable
+class Guard(Protocol):
+    """Ném lỗi để chặn; trả về bình thường để cho đi tiếp.
+
+    Tham số là `HTTPConnection` — lớp cha chung của `Request` (HTTP) và
+    `WebSocket`. Nhờ vậy MỘT guard dùng được cho cả hai phía, miễn là nó chỉ
+    đọc những thứ có ở cả hai: headers, query_params, cookies, client.
+
+    Lưu ý khi viết guard cho WebSocket: trình duyệt KHÔNG cho đặt header tuỳ
+    ý trên kết nối WebSocket, nên token thường đi qua query (?token=...) hoặc
+    qua Sec-WebSocket-Protocol. Guard nào bắt buộc header sẽ không dùng được
+    từ trình duyệt.
+    """
+
+    async def check(self, connection: HTTPConnection) -> None: ...
+
+
+@injectable(scope=Scope.REQUEST)
+@dataclass
+class Principal:
+    """Ai đang gọi request này.
+
+    Mặc định là ẩn danh. Guard xác thực gọi `assume()` để điền vào; phần còn
+    lại của ứng dụng đọc qua `current_principal()`.
+
+    Vòng đời theo request nên không có chuyện dữ liệu của người này rò sang
+    người khác — container chặn sẵn việc provider singleton giữ nó.
+    """
+
+    id: str | None = None
+    roles: frozenset[str] = field(default_factory=frozenset)
+
+    @property
+    def is_authenticated(self) -> bool:
+        return self.id is not None
+
+    def assume(self, *, id: str, roles: frozenset[str] | set[str] | None = None) -> None:
+        self.id = id
+        self.roles = frozenset(roles or ())
+
+    def require_authenticated(self) -> None:
+        if not self.is_authenticated:
+            raise UnauthorizedError()
+
+    def require_role(self, *required: str) -> None:
+        self.require_authenticated()
+        if not self.roles.intersection(required):
+            raise ForbiddenError(
+                f"Cần một trong các vai trò: {', '.join(sorted(required))}"
+            )
+
+
+def current_principal() -> Principal:
+    """Lấy Principal của request đang chạy.
+
+    Gọi trong thân method chứ không nhận qua __init__: service là singleton,
+    còn Principal theo request — container sẽ chặn nếu bạn cố inject thẳng.
+    """
+    return container.resolve(Principal)
+
+
+# --------------------------------------------------------------------- guard mẫu
+@injectable
+class RequireHeader:
+    """Guard mẫu: bắt buộc có header `X-Client-Id`.
+
+    Cố ý chọn ví dụ không phải xác thực, để bạn thấy khung guard mà không bị
+    nhầm là template đã có bảo mật. Guard xác thực thật viết cùng khuôn: đọc
+    request, quyết định, ném lỗi hoặc gọi `principal.assume(...)`.
+    """
+
+    HEADER = "x-client-id"
+    QUERY = "client_id"
+
+    async def check(self, connection: HTTPConnection) -> None:
+        # Nhận cả qua query để dùng được từ WebSocket trong trình duyệt (nơi
+        # không đặt được header).
+        client_id = connection.headers.get(self.HEADER) or connection.query_params.get(self.QUERY)
+        if not client_id:
+            raise UnauthorizedError(f"Thiếu header {self.HEADER} (hoặc ?{self.QUERY}=)")
+
+        # Guard xác thực thật sẽ kiểm tra chữ ký/token ở đây rồi mới assume.
+        current_principal().assume(id=client_id, roles={"client"})
+        log.debug("guard.client_identified", client_id=client_id)

pymodular/core/lifespan.py

@@ -0,0 +1,150 @@
+"""Vòng đời hạ tầng: mở kết nối khi boot, dọn dẹp khi tắt.
+
+Đây là phần của KHUNG — database, WebSocket, và những lớp hạ tầng đang bật.
+Việc riêng của ứng dụng thì đừng sửa vào đây; BỌC nó lại trong dự án của bạn:
+
+    # src/core/lifespan.py
+    from pymodular import lifespan as framework_lifespan
+
+    @asynccontextmanager
+    async def lifespan(app):
+        async with framework_lifespan(app):   # database, hàng đợi... sẵn sàng
+            await warm_cache()                # việc riêng lúc khởi động
+            try:
+                yield
+            finally:
+                await flush_ledger()          # việc riêng lúc tắt, TRƯỚC khi khung đóng
+
+    # src/main.py
+    app = new_fastapi(settings, lifespan=lifespan)
+
+`pym init` sinh sẵn file đó, chỉ việc điền vào.
+"""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+
+from pymodular.core.config import Settings, check_deprecated_env, get_settings
+from pymodular.core.container import _ENTITIES, container
+from pymodular.core.logging import get_logger
+from pymodular.core.websocket import WebSocketServer
+
+log = get_logger(__name__)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncIterator[None]:
+    # Lấy từ container: create_app() đã nạp vào đó, nên Settings truyền tay khi
+    # test được tôn trọng thay vì đọc lại .env.
+    try:
+        settings = container.resolve(Settings)
+    except RuntimeError:
+        settings = get_settings()
+    app.state.container = container
+
+    for problem in settings.check_production_safety():
+        log.warning("config.unsafe_for_production", problem=problem)
+
+    # Biến môi trường tên cũ bị pydantic bỏ qua trong im lặng: app chạy với giá
+    # trị mặc định mà không ai biết. Gom vào MỘT dòng — mười ba dòng cảnh báo
+    # rời rạc thì người ta cuộn qua, một dòng có số đếm thì đọc.
+    if deprecated := check_deprecated_env():
+        log.warning(
+            "config.deprecated_env",
+            count=len(deprecated),
+            problems=deprecated,
+            hint="những biến này đang BỊ BỎ QUA, app dùng giá trị mặc định thay thế",
+        )
+
+    # Import muộn: Database kéo theo factory driver, mà factory chỉ được chạm
+    # tới sau khi mọi module đã nạp xong (entity phải đăng ký trước create_schema).
+    from pymodular.infrastructure.database import Database
+    from pymodular.infrastructure.kafka import KafkaBroker, KafkaRunner
+    from pymodular.infrastructure.mqtt import MqttClient, MqttRunner
+    from pymodular.infrastructure.rabbitmq import RabbitBroker, RabbitmqRunner
+    from pymodular.infrastructure.redis import RedisClient, RedisRunner
+
+    database = container.resolve(Database)
+
+    log.info("app.starting", env=settings.env, version=settings.version)
+    await database.startup(*_ENTITIES.values())
+    app.state.database = database
+
+    # Lớp WebSocket: mở kênh phát tin xuyên worker (nếu dùng adapter redis).
+    websockets = container.resolve(WebSocketServer)
+    await websockets.startup()
+    app.state.websockets = websockets
+
+    # RabbitMQ (tuỳ chọn). Tắt thì hai lời gọi dưới đây đều không làm gì.
+    # Bật mà broker chưa lên thì app VẪN CHẠY và nối lại ngầm.
+    broker = container.resolve(RabbitBroker)
+    await broker.startup()
+    consumers = container.resolve(RabbitmqRunner)
+    await consumers.startup()
+    app.state.broker = broker
+
+    # Ba lớp dưới đây cũng TUỲ CHỌN và độc lập nhau. Tắt (mặc định) thì mỗi lời
+    # gọi startup() là một lệnh `return` — không import thư viện, không mở kết
+    # nối. Bật mà server chưa lên thì app VẪN CHẠY và nối lại ngầm.
+    redis = container.resolve(RedisClient)
+    await redis.startup()
+    channels = container.resolve(RedisRunner)
+    await channels.startup()
+    app.state.redis = redis
+
+    # MqttRunner phải chạy TRƯỚC client: nó là chỗ khai danh sách topic, mà
+    # client đăng ký topic ngay trong lần bắt tay đầu tiên.
+    mqtt_runner = container.resolve(MqttRunner)
+    await mqtt_runner.startup()
+    mqtt = container.resolve(MqttClient)
+    await mqtt.startup()
+    app.state.mqtt = mqtt
+
+    kafka = container.resolve(KafkaBroker)
+    await kafka.startup()
+    kafka_consumers = container.resolve(KafkaRunner)
+    await kafka_consumers.startup()
+    app.state.kafka = kafka
+
+    log.info(
+        "app.started",
+        driver=database.driver,
+        ws_adapter=websockets.adapter_name,
+        mq=broker.stats(),
+        redis=redis.stats(),
+        mqtt=mqtt.stats(),
+        kafka=kafka.stats(),
+        entities=sorted(_ENTITIES),
+        providers=sorted(container.registered),
+    )
+
+    try:
+        yield
+    finally:
+        log.info("app.stopping")
+        # Thứ tự tắt là ngược lại thứ tự bật, và có lý do cho từng bước:
+        #   consumer trước  — chúng còn đang truy vấn database
+        #   WebSocket       — client nhận mã 1001 để nối lại ngay
+        #   broker, rồi database — hai thứ mọi tầng trên đều dựa vào
+        await kafka_consumers.shutdown()
+        await kafka.shutdown()
+        await mqtt.shutdown()
+        await channels.shutdown()
+        await consumers.shutdown()
+        await websockets.shutdown()
+        await broker.shutdown()
+        await redis.shutdown()
+        await database.shutdown()
+        container.reset()
+        app.state.container = None
+        app.state.database = None
+        app.state.websockets = None
+        app.state.broker = None
+        app.state.redis = None
+        app.state.mqtt = None
+        app.state.kafka = None
+        log.info("app.stopped")