aws-durable-execution-sdk-python-testing 1.0.0__py3-none-any.whl

aws_durable_execution_sdk_python_testing/web/serialization.py

@@ -0,0 +1,245 @@
+"""Serialization interfaces and AWS boto integration for HTTP request/response models.
+
+This module provides Protocol interfaces for serialization and deserialization,
+along with AWS-compatible implementations using boto's rest-json serializers.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, Protocol
+from datetime import datetime
+
+import aws_durable_execution_sdk_python
+import botocore.loaders  # type: ignore
+from botocore.model import ServiceModel  # type: ignore
+from botocore.parsers import create_parser  # type: ignore
+from botocore.serialize import create_serializer  # type: ignore
+
+from aws_durable_execution_sdk_python_testing.exceptions import (
+    InvalidParameterValueException,
+)
+
+
+class Serializer(Protocol):
+    """Interface for serializing data to bytes."""
+
+    def to_bytes(self, data: Any) -> bytes:
+        """Serialize data to bytes.
+
+        Args:
+            data: The data to serialize
+
+        Returns:
+            bytes: The serialized data
+
+        Raises:
+            InvalidParameterValueException: If serialization fails
+        """
+        ...  # pragma: no cover
+
+
+class Deserializer(Protocol):
+    """Interface for deserializing bytes to data."""
+
+    def from_bytes(self, data: bytes) -> dict[str, Any]:
+        """Deserialize bytes to dictionary.
+
+        Args:
+            data: The bytes to deserialize
+
+        Returns:
+            dict: The deserialized data
+
+        Raises:
+            InvalidParameterValueException: If deserialization fails
+        """
+        ...  # pragma: no cover
+
+
+class JSONSerializer:
+    """JSON serializer with datetime support."""
+
+    def to_bytes(self, data: Any) -> bytes:
+        """Serialize data to JSON bytes."""
+        try:
+            json_string = json.dumps(
+                data, separators=(",", ":"), default=self._default_handler
+            )
+            return json_string.encode("utf-8")
+        except (TypeError, ValueError) as e:
+            raise InvalidParameterValueException(
+                f"Failed to serialize data to JSON: {str(e)}"
+            )
+
+    def _default_handler(self, obj: Any) -> float:
+        """Handle non-permitive objects."""
+        if isinstance(obj, datetime):
+            return obj.timestamp()
+        # Raise TypeError for unsupported types
+        raise TypeError(f"Object of type {type(obj).__name__} is not JSON serializable")
+
+
+class AwsRestJsonSerializer:
+    """AWS rest-json serializer using boto."""
+
+    def __init__(self, operation_name: str, serializer: Any, operation_model: Any):
+        """Initialize the AWS rest-json serializer.
+
+        Args:
+            operation_name: Name of the AWS operation
+            serializer: Boto serializer instance
+            operation_model: Boto operation model
+        """
+        self._operation_name = operation_name
+        self._serializer = serializer
+        self._operation_model = operation_model
+
+    @classmethod
+    def create(cls, operation_name: str) -> AwsRestJsonSerializer:
+        """Create serializer with boto components.
+
+        Args:
+            operation_name: Name of the AWS operation
+
+        Returns:
+            AwsRestJsonSerializer: Configured serializer instance
+
+        Raises:
+            InvalidParameterValueException: If serializer creation fails
+        """
+        try:
+            package_path = os.path.dirname(aws_durable_execution_sdk_python.__file__)
+            data_path = f"{package_path}/botocore/data"
+
+            # Load service model
+            os.environ["AWS_DATA_PATH"] = data_path
+            loader = botocore.loaders.Loader()
+            loader.search_paths.append(data_path)
+
+            raw_model = loader.load_service_model("lambdainternal", "service-2")
+            service_model = ServiceModel(raw_model)
+
+            # Create serializer (rest-json protocol)
+            serializer = create_serializer("rest-json", include_validation=True)
+            operation_model = service_model.operation_model(operation_name)
+
+            return cls(operation_name, serializer, operation_model)
+        except Exception as e:
+            msg = f"Failed to create serializer for {operation_name}: {e}"
+            raise InvalidParameterValueException(msg) from e
+
+    def to_bytes(self, data: dict[str, Any]) -> bytes:
+        """Serialize data using boto rest-json serializer.
+
+        Args:
+            data: Dictionary data to serialize
+
+        Returns:
+            bytes: Serialized data
+
+        Raises:
+            InvalidParameterValueException: If serialization fails
+        """
+        if not self._serializer or not self._operation_model:
+            msg = f"Serializer not initialized for {self._operation_name}"
+            raise InvalidParameterValueException(msg)
+
+        try:
+            serialized = self._serializer.serialize_to_request(
+                data, self._operation_model
+            )
+            body = serialized.get("body", b"")
+
+            if isinstance(body, str):
+                return body.encode("utf-8")
+
+            return body  # noqa: TRY300
+        except Exception as e:
+            msg = f"Failed to serialize data for {self._operation_name}: {e}"
+            raise InvalidParameterValueException(msg) from e
+
+
+class AwsRestJsonDeserializer:
+    """AWS rest-json deserializer using boto."""
+
+    def __init__(self, operation_name: str, parser: Any, operation_model: Any):
+        """Initialize the AWS rest-json deserializer.
+
+        Args:
+            operation_name: Name of the AWS operation
+            parser: Boto parser instance
+            operation_model: Boto operation model
+        """
+        self._operation_name = operation_name
+        self._parser = parser
+        self._operation_model = operation_model
+
+    @classmethod
+    def create(cls, operation_name: str) -> AwsRestJsonDeserializer:
+        """Create deserializer with boto components.
+
+        Args:
+            operation_name: Name of the AWS operation
+
+        Returns:
+            AwsRestJsonDeserializer: Configured deserializer instance
+
+        Raises:
+            InvalidParameterValueException: If deserializer creation fails
+        """
+        try:
+            package_path = os.path.dirname(aws_durable_execution_sdk_python.__file__)
+            data_path = f"{package_path}/botocore/data"
+
+            # Load service model
+            os.environ["AWS_DATA_PATH"] = data_path
+            loader = botocore.loaders.Loader()
+            loader.search_paths.append(data_path)
+
+            raw_model = loader.load_service_model("lambdainternal", "service-2")
+            service_model = ServiceModel(raw_model)
+
+            # Create parser (rest-json protocol)
+            parser = create_parser("rest-json")
+            operation_model = service_model.operation_model(operation_name)
+
+            return cls(operation_name, parser, operation_model)
+        except Exception as e:
+            msg = f"Failed to create deserializer for {operation_name}: {e}"
+            raise InvalidParameterValueException(msg) from e
+
+    def from_bytes(self, data: bytes) -> dict[str, Any]:
+        """Deserialize bytes using boto rest-json parser.
+
+        Args:
+            data: Bytes to deserialize
+
+        Returns:
+            dict: Deserialized data
+
+        Raises:
+            InvalidParameterValueException: If deserialization fails
+        """
+        if not self._parser or not self._operation_model:
+            msg = f"Parser not initialized for {self._operation_name}"
+            raise InvalidParameterValueException(msg)
+
+        try:
+            if self._operation_model.output_shape:
+                # Create response dict for boto parser
+                response_dict = {
+                    "body": data,
+                    "headers": {"content-type": "application/json"},
+                    "status_code": 200,
+                }
+                return self._parser.parse(
+                    response_dict, self._operation_model.output_shape
+                )
+
+            # If no output shape, just parse as JSON
+            return json.loads(data.decode("utf-8"))
+        except Exception as e:
+            msg = f"Failed to deserialize data for {self._operation_name}: {e}"
+            raise InvalidParameterValueException(msg) from e

aws_durable_execution_sdk_python_testing/web/server.py

@@ -0,0 +1,243 @@
+"""Local testing web server for AWS Lambda Durable Functions that mimics the actual Lambda backend services."""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import TYPE_CHECKING, Self
+from urllib.parse import parse_qs, urlparse
+
+from aws_durable_execution_sdk_python_testing.exceptions import (
+    AwsApiException,
+    ServiceException,
+    UnknownRouteError,
+)
+
+
+if TYPE_CHECKING:
+    from aws_durable_execution_sdk_python_testing.executor import Executor
+
+
+# Removed deprecated imports from web.errors
+from aws_durable_execution_sdk_python_testing.web.handlers import (
+    CheckpointDurableExecutionHandler,
+    EndpointHandler,
+    GetDurableExecutionHandler,
+    GetDurableExecutionHistoryHandler,
+    GetDurableExecutionStateHandler,
+    HealthHandler,
+    ListDurableExecutionsByFunctionHandler,
+    ListDurableExecutionsHandler,
+    MetricsHandler,
+    SendDurableExecutionCallbackFailureHandler,
+    SendDurableExecutionCallbackHeartbeatHandler,
+    SendDurableExecutionCallbackSuccessHandler,
+    StartExecutionHandler,
+    StopDurableExecutionHandler,
+    UpdateLambdaEndpointHandler,
+)
+from aws_durable_execution_sdk_python_testing.web.models import (
+    HTTPRequest,
+    HTTPResponse,
+)
+from aws_durable_execution_sdk_python_testing.web.routes import (
+    BytesPayloadRoute,
+    CallbackFailureRoute,
+    CallbackHeartbeatRoute,
+    CallbackSuccessRoute,
+    CheckpointDurableExecutionRoute,
+    GetDurableExecutionHistoryRoute,
+    GetDurableExecutionRoute,
+    GetDurableExecutionStateRoute,
+    HealthRoute,
+    ListDurableExecutionsByFunctionRoute,
+    ListDurableExecutionsRoute,
+    MetricsRoute,
+    Route,
+    Router,
+    StartExecutionRoute,
+    StopDurableExecutionRoute,
+    UpdateLambdaEndpointRoute,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class WebServiceConfig:
+    """Configuration for the web service."""
+
+    host: str = "localhost"
+    port: int = 5000
+    log_level: int = logging.INFO
+    max_request_size: int = 10 * 1024 * 1024  # 10MB
+
+
+class RequestHandler(BaseHTTPRequestHandler):
+    """HTTP request handler for durable execution operations."""
+
+    def __init__(self, request, client_address, server) -> None:
+        self.executor: Executor = server.executor
+        self.router: Router = server.router  # Access shared router
+        self.endpoint_handlers: dict[type[Route], EndpointHandler] = (
+            server.endpoint_handlers
+        )  # Access shared handlers
+        super().__init__(request, client_address, server)
+
+    def do_GET(self) -> None:  # noqa: N802
+        """Handle GET requests."""
+        self._handle_request("GET")
+
+    def do_POST(self) -> None:  # noqa: N802
+        """Handle POST requests."""
+        self._handle_request("POST")
+
+    def do_PUT(self) -> None:  # noqa: N802
+        """Handle PUT requests."""
+        self._handle_request("PUT")
+
+    def _handle_request(self, method: str) -> None:
+        """Handle HTTP request with strongly-typed routing."""
+        try:
+            # Parse URL path and method into strongly-typed Route object using shared router
+            url_path: str = self.path.split("?")[0]
+            parsed_route: Route = self.router.find_route(url_path, method)
+
+            # Find handler for this route type
+            handler: EndpointHandler | None = self.endpoint_handlers.get(
+                type(parsed_route)
+            )
+
+            if not handler:
+                raise UnknownRouteError(method, url_path)  # noqa: TRY301
+
+            # Parse query parameters and request body
+            parsed_url = urlparse(self.path)
+            query_params: dict[str, list[str]] = parse_qs(parsed_url.query)
+            content_length: int = int(self.headers.get("Content-Length", 0))
+            body_bytes: bytes = (
+                self.rfile.read(content_length) if content_length > 0 else b""
+            )
+
+            # For callback operations, use raw bytes directly
+            if isinstance(parsed_route, BytesPayloadRoute):
+                request = HTTPRequest.from_raw_bytes(
+                    body_bytes=body_bytes,
+                    method=method,
+                    path=parsed_route,
+                    headers=dict(self.headers),
+                    query_params=query_params,
+                )
+            else:
+                # Create strongly-typed HTTP request object with pre-parsed body
+                request = HTTPRequest.from_bytes(
+                    body_bytes=body_bytes,
+                    operation_name=None,
+                    method=method,
+                    path=parsed_route,
+                    headers=dict(self.headers),
+                    query_params=query_params,
+                )
+
+            # Handle request with appropriate handler
+            response: HTTPResponse = handler.handle(parsed_route, request)
+
+            # Send HTTP response
+            self._send_response(response)
+
+        except Exception as e:
+            logger.exception("Request handling failed")
+
+            aws_exception: AwsApiException = (
+                e if isinstance(e, AwsApiException) else ServiceException(str(e))
+            )
+
+            http_response = HTTPResponse.create_error_from_exception(aws_exception)
+            self._send_response(http_response)
+
+    def _send_response(self, response: HTTPResponse) -> None:
+        """Send HTTP response to client."""
+        self.send_response(response.status_code)
+        for header_name, header_value in response.headers.items():
+            self.send_header(header_name, header_value)
+        self.end_headers()
+
+        # Convert response body to bytes for transmission
+        if response.body:
+            self.wfile.write(response.body_to_bytes())
+
+    def log_message(self, format_string: str, *args) -> None:
+        """Override to use Python logging instead of stderr."""
+        logger.info("%s - %s", self.address_string(), format_string % args)
+
+
+class WebServer(ThreadingHTTPServer):
+    """Multi-threaded HTTP server for durable execution operations."""
+
+    def __init__(self, config: WebServiceConfig, executor: Executor) -> None:
+        """Initialize the web server.
+
+        Args:
+            config: Server configuration
+            executor: Executor instance for handling operations
+        """
+        self.config = config
+        self.executor = executor
+
+        # Configure logging
+        logging.basicConfig(level=config.log_level)
+        logging.getLogger("botocore").setLevel(logging.WARNING)
+
+        # Create shared router and endpoint handlers
+        self.router = Router()  # Shared across all request handlers
+        self.endpoint_handlers = (
+            self._create_endpoint_handlers()
+        )  # Shared handler registry
+
+        # Initialize the HTTP server
+        super().__init__((config.host, config.port), RequestHandler)
+
+        logger.info("Web server initialized on %s:%s", config.host, config.port)
+
+    def _create_endpoint_handlers(self) -> dict[type[Route], EndpointHandler]:
+        """Create endpoint handlers registry - called once during server initialization."""
+        return {
+            StartExecutionRoute: StartExecutionHandler(self.executor),
+            GetDurableExecutionRoute: GetDurableExecutionHandler(self.executor),
+            CheckpointDurableExecutionRoute: CheckpointDurableExecutionHandler(
+                self.executor
+            ),
+            StopDurableExecutionRoute: StopDurableExecutionHandler(self.executor),
+            GetDurableExecutionStateRoute: GetDurableExecutionStateHandler(
+                self.executor
+            ),
+            GetDurableExecutionHistoryRoute: GetDurableExecutionHistoryHandler(
+                self.executor
+            ),
+            ListDurableExecutionsRoute: ListDurableExecutionsHandler(self.executor),
+            ListDurableExecutionsByFunctionRoute: ListDurableExecutionsByFunctionHandler(
+                self.executor
+            ),
+            CallbackSuccessRoute: SendDurableExecutionCallbackSuccessHandler(
+                self.executor
+            ),
+            CallbackFailureRoute: SendDurableExecutionCallbackFailureHandler(
+                self.executor
+            ),
+            CallbackHeartbeatRoute: SendDurableExecutionCallbackHeartbeatHandler(
+                self.executor
+            ),
+            HealthRoute: HealthHandler(self.executor),
+            UpdateLambdaEndpointRoute: UpdateLambdaEndpointHandler(self.executor),
+            MetricsRoute: MetricsHandler(self.executor),
+        }
+
+    def __enter__(self) -> Self:
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Context manager exit - cleanup server resources."""
+        self.server_close()