clan-app: Move middleware to it's own folder

pkgs/clan-app/clan_app/middleware/__init__.py

@@ -0,0 +1,14 @@
+"""Middleware components shared by API bridge implementations."""
+
+from .argument_parsing import ArgumentParsingMiddleware
+from .base import Middleware, MiddlewareContext
+from .logging import LoggingMiddleware
+from .method_execution import MethodExecutionMiddleware
+
+__all__ = [
+    "ArgumentParsingMiddleware",
+    "LoggingMiddleware",
+    "MethodExecutionMiddleware",
+    "Middleware",
+    "MiddlewareContext",
+]

pkgs/clan-app/clan_app/middleware/argument_parsing.py

@@ -0,0 +1,49 @@
+import logging
+from dataclasses import dataclass
+
+from clan_lib.api import MethodRegistry, from_dict
+
+from clan_app.api.api_bridge import BackendRequest
+
+from .base import Middleware, MiddlewareContext
+
+log = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class ArgumentParsingMiddleware(Middleware):
+    """Middleware that handles argument parsing and dataclass construction."""
+
+    api: MethodRegistry
+
+    def process(self, context: MiddlewareContext) -> None:
+        try:
+            # Convert dictionary arguments to dataclass instances
+            reconciled_arguments = {}
+            for k, v in context.request.args.items():
+                # Get the expected argument type from the API
+                arg_class = self.api.get_method_argtype(context.request.method_name, k)
+
+                # Convert dictionary to dataclass instance
+                reconciled_arguments[k] = from_dict(arg_class, v)
+
+            # Create a new request with reconciled arguments
+
+            updated_request = BackendRequest(
+                method_name=context.request.method_name,
+                args=reconciled_arguments,
+                header=context.request.header,
+                op_key=context.request.op_key,
+            )
+            context.request = updated_request
+
+        except Exception as e:
+            log.exception(
+                f"Error while parsing arguments for {context.request.method_name}",
+            )
+            context.bridge.send_api_error_response(
+                context.request.op_key or "unknown",
+                str(e),
+                ["argument_parsing", context.request.method_name],
+            )
+            raise

pkgs/clan-app/clan_app/middleware/base.py

@@ -0,0 +1,31 @@
+from abc import ABC, abstractmethod
+from contextlib import AbstractContextManager, ExitStack
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from clan_app.api.api_bridge import ApiBridge, BackendRequest
+
+
+@dataclass
+class MiddlewareContext:
+    request: "BackendRequest"
+    bridge: "ApiBridge"
+    exit_stack: ExitStack
+
+
+@dataclass(frozen=True)
+class Middleware(ABC):
+    """Abstract base class for middleware components."""
+
+    @abstractmethod
+    def process(self, context: MiddlewareContext) -> None:
+        """Process the request through this middleware."""
+
+    def register_context_manager(
+        self,
+        context: MiddlewareContext,
+        cm: AbstractContextManager[Any],
+    ) -> Any:
+        """Register a context manager with the exit stack."""
+        return context.exit_stack.enter_context(cm)

pkgs/clan-app/clan_app/middleware/logging.py

@@ -0,0 +1,103 @@
+import io
+import logging
+import types
+from dataclasses import dataclass
+from typing import Any
+
+from clan_lib.async_run import AsyncContext, get_async_ctx, set_async_ctx
+from clan_lib.custom_logger import RegisteredHandler, setup_logging
+from clan_lib.log_manager import LogManager
+
+from .base import Middleware, MiddlewareContext
+
+log = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class LoggingMiddleware(Middleware):
+    """Middleware that sets up logging context without executing methods."""
+
+    log_manager: LogManager
+
+    def process(self, context: MiddlewareContext) -> None:
+        method = context.request.method_name
+
+        try:
+            # Handle log group configuration
+            log_group: list[str] | None = context.request.header.get("logging", {}).get(
+                "group_path",
+                None,
+            )
+            if log_group is not None:
+                if not isinstance(log_group, list):
+                    msg = f"Expected log_group to be a list, got {type(log_group)}"
+                    raise TypeError(msg)  # noqa: TRY301
+                log.warning(
+                    f"Using log group {log_group} for {context.request.method_name} with op_key {context.request.op_key}",
+                )
+            # Create log file
+            log_file = self.log_manager.create_log_file(
+                method,
+                op_key=context.request.op_key or "unknown",
+                group_path=log_group,
+            ).get_file_path()
+
+        except Exception as e:
+            log.exception(
+                f"Error while handling request header of {context.request.method_name}",
+            )
+            context.bridge.send_api_error_response(
+                context.request.op_key or "unknown",
+                str(e),
+                ["header_middleware", context.request.method_name],
+            )
+            return
+
+        # Register logging context manager
+        class LoggingContextManager:
+            def __init__(self, log_file: Any) -> None:
+                self.log_file = log_file
+                self.log_f: Any = None
+                self.handler: RegisteredHandler | None = None
+                self.original_ctx: AsyncContext | None = None
+
+            def __enter__(self) -> "LoggingContextManager":
+                self.log_f = self.log_file.open("ab")
+                self.original_ctx = get_async_ctx()
+
+                # Set up async context for logging
+                ctx = AsyncContext(**self.original_ctx.__dict__)
+                ctx.stderr = self.log_f
+                ctx.stdout = self.log_f
+                set_async_ctx(ctx)
+
+                # Set up logging handler
+                handler_stream = io.TextIOWrapper(
+                    self.log_f,  # type: ignore[arg-type]
+                    encoding="utf-8",
+                    write_through=True,
+                    line_buffering=True,
+                )
+                self.handler = setup_logging(
+                    log.getEffectiveLevel(),
+                    log_file=handler_stream,
+                )
+
+                return self
+
+            def __exit__(
+                self,
+                exc_type: type[BaseException] | None,
+                exc_val: BaseException | None,
+                exc_tb: types.TracebackType | None,
+            ) -> None:
+                if self.handler:
+                    self.handler.root_logger.removeHandler(self.handler.new_handler)
+                    self.handler.new_handler.close()
+                if self.original_ctx:
+                    set_async_ctx(self.original_ctx)
+                if self.log_f:
+                    self.log_f.close()
+
+        # Register the logging context manager
+        self.register_context_manager(context, LoggingContextManager(log_file))

pkgs/clan-app/clan_app/middleware/method_execution.py

@@ -0,0 +1,41 @@
+import logging
+from dataclasses import dataclass
+
+from clan_lib.api import MethodRegistry
+
+from clan_app.api.api_bridge import BackendResponse
+
+from .base import Middleware, MiddlewareContext
+
+log = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class MethodExecutionMiddleware(Middleware):
+    """Middleware that handles actual method execution."""
+
+    api: MethodRegistry
+
+    def process(self, context: MiddlewareContext) -> None:
+        method = self.api.functions[context.request.method_name]
+
+        try:
+            # Execute the actual method
+            result = method(**context.request.args)
+
+            response = BackendResponse(
+                body=result,
+                header={},
+                _op_key=context.request.op_key or "unknown",
+            )
+            context.bridge.send_api_response(response)
+
+        except Exception as e:
+            log.exception(
+                f"Error while handling result of {context.request.method_name}",
+            )
+            context.bridge.send_api_error_response(
+                context.request.op_key or "unknown",
+                str(e),
+                ["method_execution", context.request.method_name],
+            )