@GitHK review: rename

Author: pcrespov

packages/service-library/src/servicelib/db_asyncpg_utils.py

@@ -33,7 +33,7 @@ async def create_async_engine_and_database_ready(
             "application_name": settings.POSTGRES_CLIENT_NAME,
         }
 
-    engine: AsyncEngine = create_async_engine(
+    engine = create_async_engine(
         settings.dsn_with_async_sqlalchemy,
         pool_size=settings.POSTGRES_MINSIZE,
         max_overflow=settings.POSTGRES_MAXSIZE - settings.POSTGRES_MINSIZE,

packages/service-library/src/servicelib/fastapi/postgres_lifespan.py

@@ -1,8 +1,9 @@
+import asyncio
 import logging
 from collections.abc import AsyncIterator
 from enum import Enum
 
-from fastapi_lifespan_manager import LifespanManager, State
+from fastapi_lifespan_manager import State
 from servicelib.logging_utils import log_catch, log_context
 from settings_library.postgres import PostgresSettings
 from sqlalchemy.ext.asyncio import AsyncEngine
@@ -13,41 +14,41 @@
 _logger = logging.getLogger(__name__)
 
 
-postgres_lifespan_manager = LifespanManager()
-
-
-class PostgresLifespanStateKeys(str, Enum):
+class PostgresLifespanState(str, Enum):
     POSTGRES_SETTINGS = "postgres_settings"
     POSTGRES_ASYNC_ENGINE = "postgres.async_engine"
 
 
 class PostgresConfigurationError(LifespanOnStartupError):
-    msg_template = "Invalid postgres settings [={pg_settings}] on startup. Note that postgres cannot be disabled using settings"
+    msg_template = "Invalid postgres settings [={settings}] on startup. Note that postgres cannot be disabled using settings"
+
 
+def create_input_state(settings: PostgresSettings) -> State:
+    return {PostgresLifespanState.POSTGRES_SETTINGS: settings}
 
-@postgres_lifespan_manager.add
-async def setup_postgres_database(_, state: State) -> AsyncIterator[State]:
+
+async def postgres_database_lifespan(_, state: State) -> AsyncIterator[State]:
 
     with log_context(_logger, logging.INFO, f"{__name__}"):
 
-        pg_settings: PostgresSettings | None = state[
-            PostgresLifespanStateKeys.POSTGRES_SETTINGS
-        ]
+        settings = state[PostgresLifespanState.POSTGRES_SETTINGS]
 
-        if pg_settings is None or not isinstance(pg_settings, PostgresSettings):
-            raise PostgresConfigurationError(pg_settings=pg_settings, module="postgres")
+        if settings is None or not isinstance(settings, PostgresSettings):
+            raise PostgresConfigurationError(settings=settings)
 
-        assert isinstance(pg_settings, PostgresSettings)  # nosec
+        assert isinstance(settings, PostgresSettings)  # nosec
 
+        # connect to database
         async_engine: AsyncEngine = await create_async_engine_and_database_ready(
-            pg_settings
+            settings
         )
 
         try:
+
             yield {
-                PostgresLifespanStateKeys.POSTGRES_ASYNC_ENGINE: async_engine,
+                PostgresLifespanState.POSTGRES_ASYNC_ENGINE: async_engine,
             }
 
         finally:
             with log_catch(_logger, reraise=False):
-                await async_engine.dispose()
+                await asyncio.wait_for(async_engine.dispose(), timeout=10)

packages/service-library/tests/fastapi/test_lifespan_utils.py

@@ -56,7 +56,7 @@ async def cache_lifespan(app: FastAPI) -> AsyncIterator[State]:
 
 
 @pytest.fixture
-def postgres_lifespan_mng() -> LifespanManager:
+def postgres_lifespan() -> LifespanManager:
     lifespan_manager = LifespanManager()
 
     @lifespan_manager.add
@@ -70,8 +70,8 @@ async def _setup_postgres_async_engine(_, state: State) -> AsyncIterator[State]:
         with log_context(logging.INFO, "postgres_async_engine"):
             # pass state to children
 
-            state["postgres"].update(aengine="Some Async Engine")
-            yield state
+            current = state["postgres"]
+            yield {"postgres": {"aengine": "Some Async Engine", **current}}
 
     return lifespan_manager
 
@@ -94,13 +94,13 @@ async def _setup_rabbitmq(app: FastAPI) -> AsyncIterator[State]:
 
 
 async def test_app_lifespan_composition(
-    postgres_lifespan_mng: LifespanManager, rabbitmq_lifespan: LifespanManager
+    postgres_lifespan: LifespanManager, rabbitmq_lifespan: LifespanManager
 ):
     # The app has its own database and rpc-server to initialize
     # this is how you connect the lifespans pre-defined in servicelib
 
-    @postgres_lifespan_mng.add
-    async def setup_database(app: FastAPI, state: State) -> AsyncIterator[State]:
+    @postgres_lifespan.add
+    async def database_lifespan(app: FastAPI, state: State) -> AsyncIterator[State]:
 
         with log_context(logging.INFO, "app database"):
             assert state["postgres"] == {
@@ -119,7 +119,7 @@ async def setup_database(app: FastAPI, state: State) -> AsyncIterator[State]:
             assert app.state.database_engine
 
     @rabbitmq_lifespan.add
-    async def setup_rpc_server(app: FastAPI, state: State) -> AsyncIterator[State]:
+    async def rpc_service_lifespan(app: FastAPI, state: State) -> AsyncIterator[State]:
         with log_context(logging.INFO, "app rpc-server"):
             assert "rabbitmq_rpc_server" in state
 
@@ -129,7 +129,7 @@ async def setup_rpc_server(app: FastAPI, state: State) -> AsyncIterator[State]:
 
     # Composes lifepans
     app_lifespan = LifespanManager()
-    app_lifespan.include(postgres_lifespan_mng)
+    app_lifespan.include(postgres_lifespan)
     app_lifespan.include(rabbitmq_lifespan)
 
     app = FastAPI(lifespan=app_lifespan)
@@ -165,7 +165,7 @@ async def setup_rpc_server(app: FastAPI, state: State) -> AsyncIterator[State]:
 
 
 @pytest.fixture
-def failing_lifespan_manager(mocker: MockerFixture):
+def failing_lifespan_manager(mocker: MockerFixture) -> dict[str, Any]:
     startup_step = mocker.MagicMock()
     shutdown_step = mocker.MagicMock()
     handle_error = mocker.MagicMock()
@@ -174,8 +174,8 @@ def raise_error():
         msg = "failing module"
         raise RuntimeError(msg)
 
-    async def setup_failing_on_startup(app: FastAPI) -> AsyncIterator[State]:
-        _name = setup_failing_on_startup.__name__
+    async def lifespan_failing_on_startup(app: FastAPI) -> AsyncIterator[State]:
+        _name = lifespan_failing_on_startup.__name__
 
         with log_context(logging.INFO, _name):
             try:
@@ -187,8 +187,8 @@ async def setup_failing_on_startup(app: FastAPI) -> AsyncIterator[State]:
             yield {}
             shutdown_step(_name)
 
-    async def setup_failing_on_shutdown(app: FastAPI) -> AsyncIterator[State]:
-        _name = setup_failing_on_shutdown.__name__
+    async def lifespan_failing_on_shutdown(app: FastAPI) -> AsyncIterator[State]:
+        _name = lifespan_failing_on_shutdown.__name__
 
         with log_context(logging.INFO, _name):
             startup_step(_name)
@@ -204,16 +204,16 @@ async def setup_failing_on_shutdown(app: FastAPI) -> AsyncIterator[State]:
         "startup_step": startup_step,
         "shutdown_step": shutdown_step,
         "handle_error": handle_error,
-        "setup_failing_on_startup": setup_failing_on_startup,
-        "setup_failing_on_shutdown": setup_failing_on_shutdown,
+        "lifespan_failing_on_startup": lifespan_failing_on_startup,
+        "lifespan_failing_on_shutdown": lifespan_failing_on_shutdown,
     }
 
 
 async def test_app_lifespan_with_error_on_startup(
     failing_lifespan_manager: dict[str, Any],
 ):
     app_lifespan = LifespanManager()
-    app_lifespan.add(failing_lifespan_manager["setup_failing_on_startup"])
+    app_lifespan.add(failing_lifespan_manager["lifespan_failing_on_startup"])
     app = FastAPI(lifespan=app_lifespan)
 
     with pytest.raises(LifespanOnStartupError) as err_info:
@@ -225,8 +225,8 @@ async def test_app_lifespan_with_error_on_startup(
     assert not failing_lifespan_manager["startup_step"].called
     assert not failing_lifespan_manager["shutdown_step"].called
     assert exception.error_context() == {
-        "module": "setup_failing_on_startup",
-        "message": "Failed during startup of setup_failing_on_startup",
+        "module": "lifespan_failing_on_startup",
+        "message": "Failed during startup of lifespan_failing_on_startup",
         "code": "RuntimeError.LifespanError.LifespanOnStartupError",
     }
 
@@ -235,7 +235,7 @@ async def test_app_lifespan_with_error_on_shutdown(
     failing_lifespan_manager: dict[str, Any],
 ):
     app_lifespan = LifespanManager()
-    app_lifespan.add(failing_lifespan_manager["setup_failing_on_shutdown"])
+    app_lifespan.add(failing_lifespan_manager["lifespan_failing_on_shutdown"])
     app = FastAPI(lifespan=app_lifespan)
 
     with pytest.raises(LifespanOnShutdownError) as err_info:
@@ -247,7 +247,7 @@ async def test_app_lifespan_with_error_on_shutdown(
     assert failing_lifespan_manager["startup_step"].called
     assert not failing_lifespan_manager["shutdown_step"].called
     assert exception.error_context() == {
-        "module": "setup_failing_on_shutdown",
-        "message": "Failed during shutdown of setup_failing_on_shutdown",
+        "module": "lifespan_failing_on_shutdown",
+        "message": "Failed during shutdown of lifespan_failing_on_shutdown",
         "code": "RuntimeError.LifespanError.LifespanOnShutdownError",
     }

packages/service-library/tests/fastapi/test_postgres_lifespan.py

@@ -18,8 +18,8 @@
 from pytest_simcore.helpers.typing_env import EnvVarsDict
 from servicelib.fastapi.postgres_lifespan import (
     PostgresConfigurationError,
-    PostgresLifespanStateKeys,
-    postgres_lifespan_manager,
+    PostgresLifespanState,
+    postgres_database_lifespan,
 )
 from settings_library.application import BaseApplicationSettings
 from settings_library.postgres import PostgresSettings
@@ -58,25 +58,26 @@ async def my_app_settings(app: FastAPI) -> AsyncIterator[State]:
         app.state.settings = AppSettings.create_from_envs()
 
         yield {
-            PostgresLifespanStateKeys.POSTGRES_SETTINGS: app.state.settings.CATALOG_POSTGRES
+            PostgresLifespanState.POSTGRES_SETTINGS: app.state.settings.CATALOG_POSTGRES
         }
 
     async def my_database_setup(app: FastAPI, state: State) -> AsyncIterator[State]:
-        app.state.my_db_engine = state[PostgresLifespanStateKeys.POSTGRES_ASYNC_ENGINE]
+        app.state.my_db_engine = state[PostgresLifespanState.POSTGRES_ASYNC_ENGINE]
 
         yield {}
 
     # compose lifespans
     app_lifespan = LifespanManager()
     app_lifespan.add(my_app_settings)
 
-    postgres_lifespan_manager.add(my_database_setup)
-    app_lifespan.include(postgres_lifespan_manager)
+    # potsgres
+    app_lifespan.add(postgres_database_lifespan)
+    app_lifespan.add(my_database_setup)
 
     return app_lifespan
 
 
-async def test_setup_postgres_database_in_an_app(
+async def test_lifespan_postgres_database_in_an_app(
     is_pdb_enabled: bool,
     app_environment: EnvVarsDict,
     mock_create_async_engine_and_database_ready: MockType,
@@ -97,14 +98,14 @@ async def test_setup_postgres_database_in_an_app(
 
         # Verify that the async engine is in the lifespan manager state
         assert (
-            PostgresLifespanStateKeys.POSTGRES_ASYNC_ENGINE
+            PostgresLifespanState.POSTGRES_ASYNC_ENGINE
             in asgi_manager._state  # noqa: SLF001
         )
         assert app.state.my_db_engine
         assert (
             app.state.my_db_engine
             == asgi_manager._state[  # noqa: SLF001
-                PostgresLifespanStateKeys.POSTGRES_ASYNC_ENGINE
+                PostgresLifespanState.POSTGRES_ASYNC_ENGINE
             ]
         )
 
@@ -118,20 +119,20 @@ async def test_setup_postgres_database_in_an_app(
     async_engine.dispose.assert_called_once()
 
 
-async def test_setup_postgres_database_dispose_engine_on_failure(
+async def test_lifespan_postgres_database_dispose_engine_on_failure(
     is_pdb_enabled: bool,
     app_environment: EnvVarsDict,
     mock_create_async_engine_and_database_ready: MockType,
     app_lifespan: LifespanManager,
 ):
-    expected_msg = "my_faulty_setup error"
+    expected_msg = "my_faulty_lifespan error"
 
     def raise_error():
         raise RuntimeError(expected_msg)
 
     @app_lifespan.add
-    async def my_faulty_setup(app: FastAPI, state: State) -> AsyncIterator[State]:
-        assert PostgresLifespanStateKeys.POSTGRES_ASYNC_ENGINE in state
+    async def my_faulty_lifespan(app: FastAPI, state: State) -> AsyncIterator[State]:
+        assert PostgresLifespanState.POSTGRES_ASYNC_ENGINE in state
         raise_error()
         yield {}
 
@@ -154,14 +155,13 @@ async def test_setup_postgres_database_with_empty_pg_settings(
     is_pdb_enabled: bool,
 ):
     async def my_app_settings(app: FastAPI) -> AsyncIterator[State]:
-        yield {PostgresLifespanStateKeys.POSTGRES_SETTINGS: None}
+        yield {PostgresLifespanState.POSTGRES_SETTINGS: None}
 
-    app_lifespan_manager = LifespanManager()
-    app_lifespan_manager.add(my_app_settings)
-
-    app_lifespan_manager.include(postgres_lifespan_manager)
+    app_lifespan = LifespanManager()
+    app_lifespan.add(my_app_settings)
+    app_lifespan.add(postgres_database_lifespan)
 
-    app = FastAPI(lifespan=app_lifespan_manager)
+    app = FastAPI(lifespan=app_lifespan)
 
     with pytest.raises(PostgresConfigurationError, match="postgres cannot be disabled"):
         async with ASGILifespanManager(

services/catalog/src/simcore_service_catalog/api/rpc/routes.py

@@ -11,7 +11,7 @@
 _logger = logging.getLogger(__name__)
 
 
-async def setup_rpc_api_routes(app: FastAPI) -> AsyncIterator[State]:
+async def rpc_api_lifespan(app: FastAPI) -> AsyncIterator[State]:
     rpc_server = get_rabbitmq_rpc_server(app)
     await rpc_server.register_router(_services.router, CATALOG_RPC_NAMESPACE, app)
     try:

services/catalog/src/simcore_service_catalog/core/background_tasks.py

@@ -236,7 +236,7 @@ async def stop_registry_sync_task(app: FastAPI) -> None:
     _logger.info("registry syncing task stopped")
 
 
-async def setup_background_task(app: FastAPI) -> AsyncIterator[State]:
+async def background_task_lifespan(app: FastAPI) -> AsyncIterator[State]:
     await start_registry_sync_task(app)
     try:
         yield {}