src/liquidcode/application/app.py - develop-0.4 - liquid-g/liquid-code

src/liquidcode/application/app.py
191 строка7 KB
User
0.4.19 - refactor: удалить прокси-методы _load_middleware_* в app.py (T-002)
07 июл 2026, 22:22
07 июл 2026, 22:229d1cf79
import logging
import os
from typing import Any, Callable, Optional, Type, List, Dict

from .config_loader import load_config_to_app
from .default_route import ensure_default_route, set_default_route as _set_default_route
from .middleware_loader import load_middleware_config
from ..container import Container
from ..discovery import discover_controllers, discover_services
from ..event_dispatcher import EventDispatcher
from ..kernel import Kernel
from ..routing import Router
from ..server import HTTPServerManager
from ..template import TemplateManager

logger = logging.getLogger(__name__)


class Application:
    def __init__(
            self,
            container: Optional[Container] = None,
            response_class: Optional[Type] = None,
            profiler_enabled: bool = False,
            enable_service_discovery: bool = True,
            enable_controller_discovery: bool = True,
            enable_events: bool = True,
    ) -> None:
        self.container = container or Container()
        self.router = Router()

        # Регистрируем Application в контейнере для DI
        self.container.set(Application, self)

        event_dispatcher = EventDispatcher() if enable_events else None

        # Настройки по умолчанию
        self.host = 'localhost'
        self.port = 8000
        self._websocket_port = 8765
        self._static_prefix = '/static'
        self._static_dir = 'public'
        self._template_dir = 'templates'
        self._debug = False

        self.template_manager = TemplateManager(self._template_dir)
        self.container.set(TemplateManager, self.template_manager)

        self._config_loaded = False

        self.kernel = Kernel(
            self.router,
            self.container,
            response_class,
            profiler_enabled,
            event_dispatcher,
            self._debug
        )

        if enable_service_discovery:
            self.discover_services()
        if enable_controller_discovery:
            self.discover_controllers()

    # ---------- Переменные окружения ----------
    def load_env(self, file_path: str = '.env') -> None:
        from ..env import load_env as load_env_file
        load_env_file(file_path)

    # ---------- Конфигурация ----------
    def load_config(self, file_path: str) -> None:
        load_config_to_app(self, file_path)

    def load_middleware_config(self, file_path: str = 'config/middleware.yaml') -> None:
        load_middleware_config(self, file_path)

    # ---------- Шаблоны ----------
    def render_template(self, template_name: str, **context: Any) -> str:
        return self.template_manager.render(template_name, **context)

    # ---------- Статика ----------
    def set_static(self, prefix: str = '/static', directory: str = 'public') -> None:
        self._static_prefix = prefix.rstrip('/')
        self._static_dir = directory
        if not os.path.exists(self._static_dir):
            logger.warning(f"Директория статики '{self._static_dir}' не существует.")
        logger.info(f"Статика из '{directory}' доступна по '{prefix}'")

    # ---------- Контроллеры ----------
    def add_controller(self, controller_class: Type[Any]) -> None:
        self.router.add_routes_from_controller(controller_class)
        logger.info(f"Зарегистрирован контроллер {controller_class.__name__}")

    def discover_controllers(self, directory: str = 'src/Controller') -> None:
        discover_controllers(directory, self.add_controller)

    # ---------- Сервисы ----------
    def discover_services(self, directory: str = 'src/Service') -> None:
        discover_services(directory, self.container)

    # ---------- Маршруты ----------
    def get_routes(self) -> List[Dict[str, Any]]:
        return self.router.all_routes()

    def route(self, path: str, methods: Optional[List[str]] = None):
        def decorator(func):
            self.router.add_route(path, func, methods or ['GET'])
            return func

        return decorator

    def websocket_route(self, path: str):
        def decorator(func):
            self.router.add_route(path, func, ['WEBSOCKET'])
            return func

        return decorator

    # ---------- Middleware ----------
    def add_middleware(self, middleware: Callable) -> None:
        self.kernel.add_middleware(middleware)

    def group(self, prefix: str, middlewares: Optional[List[Callable]] = None):
        return self.router.group(prefix, middlewares)

    # ---------- Хуки ----------
    def add_before_request(self, hook: Callable) -> None:
        self.kernel.add_before_request(hook)

    def add_after_request(self, hook: Callable) -> None:
        self.kernel.add_after_request(hook)

    def add_exception(self, hook: Callable) -> None:
        self.kernel.add_exception(hook)

    def add_terminate(self, hook: Callable) -> None:
        self.kernel.add_terminate(hook)

    # ---------- События ----------
    def add_listener(self, event_name: str, listener: Callable, priority: int = 0) -> None:
        if self.kernel.event_dispatcher is None:
            raise RuntimeError("Event dispatcher is disabled. Enable events with enable_events=True.")
        self.kernel.event_dispatcher.add_listener(event_name, listener, priority)

    # ---------- Профайлер ----------
    def enable_profiler(self) -> None:
        self.kernel.profiler_enabled = True
        logger.info("Профилировщик включён")

    # ---------- Debug режим ----------
    def set_debug(self, debug: bool) -> None:
        """Включает или выключает debug-режим."""
        self._debug = debug
        self.kernel.debug = debug
        logger.info(f"Debug-режим {'включён' if debug else 'выключён'}")

    # ---------- Запуск серверов ----------
    def run(self, host: Optional[str] = None, port: Optional[int] = None) -> None:
        self._ensure_logging()
        ensure_default_route(self)

        manager = HTTPServerManager(self.kernel, self.host, self.port)
        manager.set_debug(self._debug)
        manager.run(host, port)

    def run_websocket(self, host: Optional[str] = None, port: Optional[int] = None) -> None:
        from ..server.websocket import WebSocketServerManager
        actual_port = port if port is not None else self._websocket_port
        manager = WebSocketServerManager(self.kernel, self.host, actual_port)
        manager.run(host, port)

    # ---------- Вспомогательные ----------
    def set_default_route(self, handler: Callable) -> None:
        _set_default_route(self, handler)

    def _ensure_default_route(self) -> None:
        ensure_default_route(self)

    def _ensure_logging(self) -> None:
        root_logger = logging.getLogger()
        if not root_logger.handlers:
            handler = logging.StreamHandler()
            level = logging.DEBUG if self._debug else logging.WARNING
            handler.setLevel(level)
            formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
            handler.setFormatter(formatter)
            root_logger.addHandler(handler)
            root_logger.setLevel(level)
            # Если включен debug-режим, включаем его в ядре
            if self._debug:
                self.kernel.debug = True