jararaca 0.3.11a16__py3-none-any.whl → 0.3.12__py3-none-any.whl

jararaca/microservice.py

@@ -325,6 +325,48 @@ def provide_container(container: Container) -> Generator[None, None, None]:
             current_container_ctx.reset(token)
 
 
+class ShutdownState(Protocol):
+
+    def request_shutdown(self) -> None: ...
+
+    def is_shutdown_requested(self) -> bool: ...
+
+
+shutdown_state_ctx = ContextVar[ShutdownState]("shutdown_state")
+
+
+def is_shutting_down() -> bool:
+    """
+    Check if the application is in the process of shutting down.
+    """
+    return shutdown_state_ctx.get().is_shutdown_requested()
+
+
+def request_shutdown() -> None:
+    """
+    Request the application to shut down.
+    This will set the shutdown event, allowing the application to gracefully shut down.
+    """
+    shutdown_state_ctx.get().request_shutdown()
+
+
+@contextmanager
+def provide_shutdown_state(
+    state: ShutdownState,
+) -> Generator[None, None, None]:
+    """
+    Context manager to provide the shutdown state.
+    This is used to manage the shutdown event for the application.
+    """
+
+    token = shutdown_state_ctx.set(state)
+    try:
+        yield
+    finally:
+        with suppress(ValueError):
+            shutdown_state_ctx.reset(token)
+
+
 __all__ = [
     "AppTransactionContext",
     "AppInterceptor",

jararaca/persistence/interceptors/aiosqa_interceptor.py

@@ -1,7 +1,7 @@
 from contextlib import asynccontextmanager, contextmanager, suppress
 from contextvars import ContextVar
 from dataclasses import dataclass
-from typing import Any, AsyncGenerator, Generator
+from typing import Any, AsyncGenerator, Generator, Protocol
 
 from sqlalchemy.ext.asyncio import (
     AsyncSession,
@@ -12,9 +12,47 @@ from sqlalchemy.ext.asyncio import (
 from sqlalchemy.ext.asyncio.engine import AsyncEngine
 
 from jararaca.microservice import AppInterceptor, AppTransactionContext
-from jararaca.reflect.metadata import SetMetadata, get_metadata_value
+from jararaca.persistence.interceptors.constants import DEFAULT_CONNECTION_NAME
+from jararaca.persistence.interceptors.decorators import (
+    INJECT_PERSISTENCE_SESSION_METADATA_TEMPLATE,
+)
+from jararaca.reflect.metadata import get_metadata_value
+
+
+class SessionManager(Protocol):
+    def spawn_session(self, connection_name: str | None = None) -> AsyncSession: ...
+
+
+ctx_session_manager: ContextVar[SessionManager | None] = ContextVar(
+    "ctx_session_manager", default=None
+)
+
+
+@contextmanager
+def providing_session_manager(
+    session_manager: SessionManager,
+) -> Generator[None, Any, None]:
+    """
+    Context manager to provide a session manager for the current context.
+    """
+    token = ctx_session_manager.set(session_manager)
+    try:
+        yield
+    finally:
+        with suppress(ValueError):
+            ctx_session_manager.reset(token)
+
+
+def use_session_manager() -> SessionManager:
+    """
+    Retrieve the current session manager from the context variable.
+    Raises ValueError if no session manager is set.
+    """
+    session_manager = ctx_session_manager.get()
+    if session_manager is None:
+        raise ValueError("No session manager set in the context.")
+    return session_manager
 
-DEFAULT_CONNECTION_NAME = "default"
 
 ctx_default_connection_name: ContextVar[str] = ContextVar(
     "ctx_default_connection_name", default=DEFAULT_CONNECTION_NAME
@@ -69,13 +107,21 @@ async def providing_new_session(
     connection_name: str | None = None,
 ) -> AsyncGenerator[AsyncSession, None]:
 
-    current_session = use_session(connection_name)
+    session_manager = use_session_manager()
+    current_session = session_manager.spawn_session(connection_name)
 
     async with AsyncSession(
         current_session.bind,
     ) as new_session, new_session.begin() as new_tx:
         with providing_session(new_session, new_tx, connection_name):
-            yield new_session
+            try:
+                yield new_session
+                if new_tx.is_active:
+                    await new_tx.commit()
+            except Exception:
+                if new_tx.is_active:
+                    await new_tx.rollback()
+                raise
 
 
 def use_session(connection_name: str | None = None) -> AsyncSession:
@@ -129,50 +175,7 @@ class AIOSQAConfig:
         self.inject_default = inject_default
 
 
-INJECT_CONNECTION_METADATA = "inject_connection_metadata_{connection_name}"
-
-
-def set_inject_connection(
-    inject: bool, connection_name: str = DEFAULT_CONNECTION_NAME
-) -> SetMetadata:
-    """
-    Set whether to inject the connection metadata for the given connection name.
-    This is useful when you want to control whether the connection metadata
-    should be injected into the context or not.
-    """
-
-    return SetMetadata(
-        INJECT_CONNECTION_METADATA.format(connection_name=connection_name), inject
-    )
-
-
-def uses_connection(
-    connection_name: str = DEFAULT_CONNECTION_NAME,
-) -> SetMetadata:
-    """
-    Use connection metadata for the given connection name.
-    This is useful when you want to inject the connection metadata into the context,
-    for example, when you are using a specific connection for a specific operation.
-    """
-    return SetMetadata(
-        INJECT_CONNECTION_METADATA.format(connection_name=connection_name), True
-    )
-
-
-def dnt_uses_connection(
-    connection_name: str = DEFAULT_CONNECTION_NAME,
-) -> SetMetadata:
-    """
-    Do not use connection metadata for the given connection name.
-    This is useful when you want to ensure that the connection metadata is not injected
-    into the context, for example, when you are using a different connection for a specific operation.
-    """
-    return SetMetadata(
-        INJECT_CONNECTION_METADATA.format(connection_name=connection_name), False
-    )
-
-
-class AIOSqlAlchemySessionInterceptor(AppInterceptor):
+class AIOSqlAlchemySessionInterceptor(AppInterceptor, SessionManager):
 
     def __init__(self, config: AIOSQAConfig):
         self.config = config
@@ -189,27 +192,33 @@ class AIOSqlAlchemySessionInterceptor(AppInterceptor):
         self, app_context: AppTransactionContext
     ) -> AsyncGenerator[None, None]:
 
-        uses_connection_metadata = get_metadata_value(
-            INJECT_CONNECTION_METADATA.format(
-                connection_name=self.config.connection_name
-            ),
-            self.config.inject_default,
-        )
-
-        if not uses_connection_metadata:
-            yield
-            return
-
-        async with self.sessionmaker() as session, session.begin() as tx:
-            token = ctx_default_connection_name.set(self.config.connection_name)
-            with providing_session(session, tx, self.config.connection_name):
-                try:
-                    yield
-                    if tx.is_active:
-                        await tx.commit()
-                except Exception as e:
-                    await tx.rollback()
-                    raise e
-                finally:
-                    with suppress(ValueError):
-                        ctx_default_connection_name.reset(token)
+        with providing_session_manager(self):
+            uses_connection_metadata = get_metadata_value(
+                INJECT_PERSISTENCE_SESSION_METADATA_TEMPLATE.format(
+                    connection_name=self.config.connection_name
+                ),
+                self.config.inject_default,
+            )
+
+            if not uses_connection_metadata:
+                yield
+                return
+
+            async with self.sessionmaker() as session, session.begin() as tx:
+                token = ctx_default_connection_name.set(self.config.connection_name)
+                with providing_session(session, tx, self.config.connection_name):
+                    try:
+                        yield
+                        if tx.is_active:
+                            await tx.commit()
+                    except Exception as e:
+                        await tx.rollback()
+                        raise e
+                    finally:
+                        with suppress(ValueError):
+                            ctx_default_connection_name.reset(token)
+
+    def spawn_session(self, connection_name: str | None = None) -> AsyncSession:
+        connection_name = ensure_name(connection_name)
+        session = self.sessionmaker()
+        return session

jararaca/persistence/interceptors/constants.py

@@ -0,0 +1 @@
+DEFAULT_CONNECTION_NAME = "default"

jararaca/persistence/interceptors/decorators.py

@@ -0,0 +1,45 @@
+from jararaca.persistence.interceptors.constants import DEFAULT_CONNECTION_NAME
+from jararaca.reflect.metadata import SetMetadata
+
+INJECT_PERSISTENCE_SESSION_METADATA_TEMPLATE = (
+    "inject_persistence_template_{connection_name}"
+)
+
+
+def set_use_persistence_session(
+    inject: bool, connection_name: str = DEFAULT_CONNECTION_NAME
+) -> SetMetadata:
+    """
+    Set whether to inject the connection metadata for the given connection name.
+    This is useful when you want to control whether the connection metadata
+    should be injected into the context or not.
+    """
+
+    return SetMetadata(
+        INJECT_PERSISTENCE_SESSION_METADATA_TEMPLATE.format(
+            connection_name=connection_name
+        ),
+        inject,
+    )
+
+
+def uses_persistence_session(
+    connection_name: str = DEFAULT_CONNECTION_NAME,
+) -> SetMetadata:
+    """
+    Use connection metadata for the given connection name.
+    This is useful when you want to inject the connection metadata into the context,
+    for example, when you are using a specific connection for a specific operation.
+    """
+    return set_use_persistence_session(True, connection_name=connection_name)
+
+
+def skip_persistence_session(
+    connection_name: str = DEFAULT_CONNECTION_NAME,
+) -> SetMetadata:
+    """
+    Decorator to skip using connection metadata for the given connection name.
+    This is useful when you want to ensure that the connection metadata is not injected
+    into the context, for example, when you are using a different connection for a specific operation.
+    """
+    return set_use_persistence_session(False, connection_name=connection_name)

jararaca/presentation/server.py

@@ -1,4 +1,8 @@
+import os
+import signal
+import threading
 from contextlib import asynccontextmanager
+from signal import SIGINT, SIGTERM
 from typing import Any, AsyncGenerator
 
 from fastapi import Depends, FastAPI, Request, WebSocket
@@ -10,7 +14,9 @@ from jararaca.lifecycle import AppLifecycle
 from jararaca.microservice import (
     AppTransactionContext,
     HttpTransactionData,
+    ShutdownState,
     WebSocketTransactionData,
+    provide_shutdown_state,
 )
 from jararaca.presentation.decorators import RestController
 from jararaca.presentation.http_microservice import HttpMicroservice
@@ -76,10 +82,49 @@ class HttpAppLifecycle:
             yield
 
 
+class HttpShutdownState(ShutdownState):
+    def __init__(self) -> None:
+        self._requested = False
+        self.old_signal_handlers = {
+            SIGINT: signal.getsignal(SIGINT),
+            SIGTERM: signal.getsignal(SIGTERM),
+        }
+        self.thread_lock = threading.Lock()
+
+    def request_shutdown(self) -> None:
+        if not self._requested:
+            self._requested = True
+            os.kill(os.getpid(), SIGINT)
+
+    def is_shutdown_requested(self) -> bool:
+        return self._requested
+
+    def handle_signal(self, signum: int, frame: Any) -> None:
+        print(f"Received signal {signum}, initiating shutdown...")
+        if self._requested:
+            print("Shutdown already requested, ignoring signal.")
+            return
+        print("Requesting shutdown...")
+        self._requested = True
+
+        # remove the signal handler to prevent recursion
+        for sig in (SIGINT, SIGTERM):
+            if self.old_signal_handlers[sig] is not None:
+                signal.signal(sig, self.old_signal_handlers[sig])
+
+        signal.raise_signal(signum)
+
+    def setup_signal_handlers(self) -> None:
+        signal.signal(SIGINT, self.handle_signal)
+        signal.signal(SIGTERM, self.handle_signal)
+
+
 class HttpUowContextProviderDependency:
 
     def __init__(self, uow_provider: UnitOfWorkContextProvider) -> None:
         self.uow_provider = uow_provider
+        self.shutdown_state = HttpShutdownState()
+        self.shutdown_state.setup_signal_handlers()
 
     async def __call__(
         self, websocket: WebSocket = None, request: Request = None  # type: ignore
@@ -101,17 +146,18 @@ class HttpUowContextProviderDependency:
             "ControllerMemberReflect, but got: {}".format(type(member))
         )
 
-        async with self.uow_provider(
-            AppTransactionContext(
-                controller_member_reflect=member,
-                transaction_data=(
-                    HttpTransactionData(request=request)
-                    if request
-                    else WebSocketTransactionData(websocket=websocket)
-                ),
-            )
-        ):
-            yield
+        with provide_shutdown_state(self.shutdown_state):
+            async with self.uow_provider(
+                AppTransactionContext(
+                    controller_member_reflect=member,
+                    transaction_data=(
+                        HttpTransactionData(request=request)
+                        if request
+                        else WebSocketTransactionData(websocket=websocket)
+                    ),
+                )
+            ):
+                yield
 
 
 def create_http_server(

jararaca/presentation/websocket/redis.py

@@ -1,4 +1,5 @@
 import asyncio
+import logging
 from dataclasses import dataclass
 from typing import Any
 
@@ -10,6 +11,8 @@ from jararaca.presentation.websocket.websocket_interceptor import (
     WebSocketConnectionBackend,
 )
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class BroadcastMessage:
@@ -55,6 +58,7 @@ class RedisWebSocketConnectionBackend(WebSocketConnectionBackend):
         send_pubsub_channel: str,
         consume_broadcast_timeout: int = 1,
         consume_send_timeout: int = 1,
+        retry_delay: float = 5.0,
     ) -> None:
 
         self.redis = conn
@@ -66,6 +70,35 @@ class RedisWebSocketConnectionBackend(WebSocketConnectionBackend):
 
         self.consume_broadcast_timeout = consume_broadcast_timeout
         self.consume_send_timeout = consume_send_timeout
+        self.retry_delay = retry_delay
+        self.__shutdown_event: asyncio.Event | None = None
+
+        self.__send_func: SendFunc | None = None
+        self.__broadcast_func: BroadcastFunc | None = None
+
+    @property
+    def shutdown_event(self) -> asyncio.Event:
+        if self.__shutdown_event is None:
+            raise RuntimeError(
+                "Shutdown event is not set. Please configure the backend before using it."
+            )
+        return self.__shutdown_event
+
+    @property
+    def send_func(self) -> SendFunc:
+        if self.__send_func is None:
+            raise RuntimeError(
+                "Send function is not set. Please configure the backend before using it."
+            )
+        return self.__send_func
+
+    @property
+    def broadcast_func(self) -> BroadcastFunc:
+        if self.__broadcast_func is None:
+            raise RuntimeError(
+                "Broadcast function is not set. Please configure the backend before using it."
+            )
+        return self.__broadcast_func
 
     async def broadcast(self, message: bytes) -> None:
         await self.redis.publish(
@@ -82,22 +115,95 @@ class RedisWebSocketConnectionBackend(WebSocketConnectionBackend):
     def configure(
         self, broadcast: BroadcastFunc, send: SendFunc, shutdown_event: asyncio.Event
     ) -> None:
+        if self.__shutdown_event is not None:
+            raise RuntimeError("Backend is already configured.")
+        self.__shutdown_event = shutdown_event
+        self.__send_func = send
+        self.__broadcast_func = broadcast
+        self.setup_send_consumer()
+        self.setup_broadcast_consumer()
 
-        broadcast_task = asyncio.get_event_loop().create_task(
-            self.consume_broadcast(broadcast, shutdown_event)
-        )
+    def setup_send_consumer(self) -> None:
 
         send_task = asyncio.get_event_loop().create_task(
-            self.consume_send(send, shutdown_event)
+            self.consume_send(self.send_func, self.shutdown_event)
         )
 
-        self.tasks.add(broadcast_task)
         self.tasks.add(send_task)
+        send_task.add_done_callback(self.handle_send_task_done)
+
+    def setup_broadcast_consumer(self) -> None:
+
+        broadcast_task = asyncio.get_event_loop().create_task(
+            self.consume_broadcast(self.broadcast_func, self.shutdown_event)
+        )
+
+        self.tasks.add(broadcast_task)
+
+        broadcast_task.add_done_callback(self.handle_broadcast_task_done)
+
+    def handle_broadcast_task_done(self, task: asyncio.Task[Any]) -> None:
+        if task.cancelled():
+            logger.warning("Broadcast task was cancelled.")
+        elif task.exception() is not None:
+            logger.exception(
+                f"Broadcast task raised an exception:", exc_info=task.exception()
+            )
+        else:
+            logger.warning("Broadcast task somehow completed successfully.")
+
+        if not self.shutdown_event.is_set():
+            logger.warning(
+                "Broadcast task completed, but shutdown event is not set. This is unexpected."
+            )
+            # Add delay before retrying to avoid excessive CPU usage
+            asyncio.get_event_loop().create_task(
+                self._retry_broadcast_consumer_with_delay()
+            )
+
+    def handle_send_task_done(self, task: asyncio.Task[Any]) -> None:
+        if task.cancelled():
+            logger.warning("Send task was cancelled.")
+        elif task.exception() is not None:
+            logger.exception(
+                f"Send task raised an exception:", exc_info=task.exception()
+            )
+        else:
+            logger.warning("Send task somehow completed successfully.")
+
+        if not self.shutdown_event.is_set():
+            logger.warning(
+                "Send task completed, but shutdown event is not set. This is unexpected."
+            )
+            # Add delay before retrying to avoid excessive CPU usage
+            asyncio.get_event_loop().create_task(self._retry_send_consumer_with_delay())
+
+    async def _retry_broadcast_consumer_with_delay(self) -> None:
+        """Retry setting up broadcast consumer after a delay to avoid excessive CPU usage."""
+        logger.info(
+            f"Waiting {self.retry_delay} seconds before retrying broadcast consumer..."
+        )
+        await asyncio.sleep(self.retry_delay)
+
+        if not self.shutdown_event.is_set():
+            logger.info("Retrying broadcast consumer setup...")
+            self.setup_broadcast_consumer()
+
+    async def _retry_send_consumer_with_delay(self) -> None:
+        """Retry setting up send consumer after a delay to avoid excessive CPU usage."""
+        logger.info(
+            f"Waiting {self.retry_delay} seconds before retrying send consumer..."
+        )
+        await asyncio.sleep(self.retry_delay)
+
+        if not self.shutdown_event.is_set():
+            logger.info("Retrying send consumer setup...")
+            self.setup_send_consumer()
 
     async def consume_broadcast(
         self, broadcast: BroadcastFunc, shutdown_event: asyncio.Event
     ) -> None:
-
+        logger.info("Starting broadcast consumer...")
         async with self.redis.pubsub() as pubsub:
             await pubsub.subscribe(self.broadcast_pubsub_channel)
 
@@ -122,7 +228,7 @@ class RedisWebSocketConnectionBackend(WebSocketConnectionBackend):
                     task.add_done_callback(self.tasks.discard)
 
     async def consume_send(self, send: SendFunc, shutdown_event: asyncio.Event) -> None:
-
+        logger.info("Starting send consumer...")
         async with self.redis.pubsub() as pubsub:
             await pubsub.subscribe(self.send_pubsub_channel)
 

jararaca/reflect/metadata.py

@@ -6,7 +6,7 @@ from typing import Any, Awaitable, Callable, Mapping, TypeVar, Union, cast
 DECORATED = TypeVar("DECORATED", bound=Union[Callable[..., Awaitable[Any]], type])
 
 
-@dataclass
+@dataclass(frozen=True)
 class ControllerInstanceMetadata:
     value: Any
     inherited: bool

jararaca/rpc/http/__init__.py

@@ -0,0 +1,97 @@
+# HTTP RPC Module - Complete REST Client Implementation
+"""
+This module provides a complete REST client implementation with support for:
+- HTTP method decorators (@Get, @Post, @Put, @Patch, @Delete)
+- Request parameter decorators (@Query, @Header, @PathParam, @Body, @FormData, @File)
+- Configuration decorators (@Timeout, @Retry, @ContentType)
+- Authentication middleware (BearerTokenAuth, BasicAuth, ApiKeyAuth)
+- Caching and response middleware
+- Request/response hooks for customization
+"""
+
+from .backends.httpx import HTTPXHttpRPCAsyncBackend
+from .decorators import (  # HTTP Method decorators; Request parameter decorators; Configuration decorators; Client builder and core classes; Authentication classes; Middleware and hooks; Configuration classes; Data structures; Error handlers; Exceptions
+    ApiKeyAuth,
+    AuthenticationMiddleware,
+    BasicAuth,
+    BearerTokenAuth,
+    Body,
+    CacheMiddleware,
+    ContentType,
+    Delete,
+    File,
+    FormData,
+    Get,
+    GlobalHttpErrorHandler,
+    Header,
+    HttpMapping,
+    HttpRpcClientBuilder,
+    HttpRPCRequest,
+    HttpRPCResponse,
+    Patch,
+    PathParam,
+    Post,
+    Put,
+    Query,
+    RequestAttribute,
+    RequestHook,
+    ResponseHook,
+    ResponseMiddleware,
+    RestClient,
+    Retry,
+    RetryConfig,
+    RouteHttpErrorHandler,
+    RPCRequestNetworkError,
+    RPCUnhandleError,
+    Timeout,
+    TimeoutException,
+)
+
+__all__ = [
+    # HTTP Method decorators
+    "Get",
+    "Post",
+    "Put",
+    "Patch",
+    "Delete",
+    # Request parameter decorators
+    "Query",
+    "Header",
+    "PathParam",
+    "Body",
+    "FormData",
+    "File",
+    # Configuration decorators
+    "Timeout",
+    "Retry",
+    "ContentType",
+    # Client builder and core classes
+    "RestClient",
+    "HttpRpcClientBuilder",
+    "HttpMapping",
+    "RequestAttribute",
+    # Authentication classes
+    "BearerTokenAuth",
+    "BasicAuth",
+    "ApiKeyAuth",
+    "AuthenticationMiddleware",
+    # Middleware and hooks
+    "CacheMiddleware",
+    "ResponseMiddleware",
+    "RequestHook",
+    "ResponseHook",
+    # Configuration classes
+    "RetryConfig",
+    # Data structures
+    "HttpRPCRequest",
+    "HttpRPCResponse",
+    # Error handlers
+    "GlobalHttpErrorHandler",
+    "RouteHttpErrorHandler",
+    # Exceptions
+    "RPCRequestNetworkError",
+    "RPCUnhandleError",
+    "TimeoutException",
+    # Backend
+    "HTTPXHttpRPCAsyncBackend",
+]

jararaca/rpc/http/backends/__init__.py

@@ -0,0 +1,10 @@
+# HTTP RPC Backends
+"""
+Backend implementations for HTTP RPC clients.
+"""
+
+from .httpx import HTTPXHttpRPCAsyncBackend
+
+__all__ = [
+    "HTTPXHttpRPCAsyncBackend",
+]