moved project_lock in servicelib

Author: sanderegg

packages/service-library/src/servicelib/redis/__init__.py

@@ -7,17 +7,29 @@
     LockLostError,
 )
 from ._models import RedisManagerDBConfig
+from ._project_lock import (
+    PROJECT_REDIS_LOCK_KEY,
+    ProjectLockError,
+    get_project_locked_state,
+    is_project_locked,
+    with_project_locked,
+)
 from ._utils import handle_redis_returns_union_types
 
 __all__: tuple[str, ...] = (
     "CouldNotAcquireLockError",
     "CouldNotConnectToRedisError",
     "exclusive",
+    "get_project_locked_state",
     "handle_redis_returns_union_types",
+    "is_project_locked",
     "LockLostError",
+    "PROJECT_REDIS_LOCK_KEY",
+    "ProjectLockError",
     "RedisClientSDK",
     "RedisClientsManager",
     "RedisManagerDBConfig",
+    "with_project_locked",
 )
 
 # nopycln: file

packages/service-library/src/servicelib/project_lock.py renamed to packages/service-library/src/servicelib/redis/_project_lock.py

@@ -1,4 +1,3 @@
-import datetime
 import functools
 from collections.abc import Callable, Coroutine
 from typing import Any, Final, ParamSpec, TypeAlias, TypeVar
@@ -9,10 +8,9 @@
 from models_library.projects_access import Owner
 from models_library.projects_state import ProjectLocked, ProjectStatus
 
-from .redis import CouldNotAcquireLockError, RedisClientSDK, exclusive
+from . import CouldNotAcquireLockError, RedisClientSDK, exclusive
 
-PROJECT_REDIS_LOCK_KEY: str = "project_lock:{}"
-PROJECT_LOCK_TIMEOUT: Final[datetime.timedelta] = datetime.timedelta(seconds=10)
+PROJECT_REDIS_LOCK_KEY: Final[str] = "project_lock:{}"
 
 ProjectLockError: TypeAlias = redis.exceptions.LockError
 

packages/service-library/tests/redis/test_decorators.py

@@ -75,7 +75,7 @@ async def _():
             pass
 
 
-async def test_exclusive_decorator(
+async def test_exclusive_decorator_runs_original_method(
     redis_client_sdk: RedisClientSDK,
     lock_name: str,
     sleep_duration: float,

packages/service-library/tests/redis/test_project_lock.py

@@ -0,0 +1,131 @@
+# pylint: disable=no-value-for-parameter
+# pylint: disable=protected-access
+# pylint: disable=redefined-outer-name
+# pylint: disable=unused-argument
+# pylint: disable=unused-variable
+
+import asyncio
+from typing import cast
+from uuid import UUID
+
+import pytest
+from faker import Faker
+from models_library.projects import ProjectID
+from models_library.projects_access import Owner
+from models_library.projects_state import ProjectLocked, ProjectStatus
+from servicelib.async_utils import cancel_wait_task
+from servicelib.redis import (
+    PROJECT_REDIS_LOCK_KEY,
+    ProjectLockError,
+    RedisClientSDK,
+    get_project_locked_state,
+    is_project_locked,
+    with_project_locked,
+)
+
+pytest_simcore_core_services_selection = [
+    "redis",
+]
+pytest_simcore_ops_services_selection = [
+    "redis-commander",
+]
+
+
+@pytest.fixture()
+def project_uuid(faker: Faker) -> ProjectID:
+    return cast(UUID, faker.uuid4(cast_to=None))
+
+
+assert "json_schema_extra" in Owner.model_config
+assert isinstance(Owner.model_config["json_schema_extra"], dict)
+assert isinstance(Owner.model_config["json_schema_extra"]["examples"], list)
+
+
+@pytest.fixture(params=Owner.model_config["json_schema_extra"]["examples"])
+def owner(request: pytest.FixtureRequest) -> Owner:
+    return Owner(**request.param)
+
+
+@pytest.mark.parametrize(
+    "project_status",
+    [
+        ProjectStatus.CLOSING,
+        ProjectStatus.CLONING,
+        ProjectStatus.EXPORTING,
+        ProjectStatus.OPENING,
+        ProjectStatus.MAINTAINING,
+    ],
+)
+async def test_with_project_locked(
+    redis_client_sdk: RedisClientSDK,
+    project_uuid: ProjectID,
+    owner: Owner,
+    project_status: ProjectStatus,
+):
+    @with_project_locked(
+        redis_client_sdk,
+        project_uuid=project_uuid,
+        status=project_status,
+        owner=owner,
+    )
+    async def _locked_fct() -> None:
+        assert await is_project_locked(redis_client_sdk, project_uuid) is True
+        locked_state = await get_project_locked_state(redis_client_sdk, project_uuid)
+        assert locked_state is not None
+        assert locked_state == ProjectLocked(
+            value=True,
+            owner=owner,
+            status=project_status,
+        )
+        # check lock name formatting is correct
+        redis_lock = await redis_client_sdk.redis.get(
+            PROJECT_REDIS_LOCK_KEY.format(project_uuid)
+        )
+        assert redis_lock
+        assert ProjectLocked.model_validate_json(redis_lock) == ProjectLocked(
+            value=True,
+            owner=owner,
+            status=project_status,
+        )
+
+    assert await get_project_locked_state(redis_client_sdk, project_uuid) is None
+    assert await is_project_locked(redis_client_sdk, project_uuid) is False
+    await _locked_fct()
+    assert await is_project_locked(redis_client_sdk, project_uuid) is False
+    assert await get_project_locked_state(redis_client_sdk, project_uuid) is None
+
+
+@pytest.mark.parametrize(
+    "project_status",
+    [
+        ProjectStatus.CLOSING,
+        ProjectStatus.CLONING,
+        ProjectStatus.EXPORTING,
+        ProjectStatus.OPENING,
+        ProjectStatus.MAINTAINING,
+    ],
+)
+async def test_lock_already_locked_project_raises(
+    redis_client_sdk: RedisClientSDK,
+    project_uuid: ProjectID,
+    owner: Owner,
+    project_status: ProjectStatus,
+):
+    started_event = asyncio.Event()
+
+    @with_project_locked(
+        redis_client_sdk,
+        project_uuid=project_uuid,
+        status=project_status,
+        owner=owner,
+    )
+    async def _locked_fct() -> None:
+        started_event.set()
+        await asyncio.sleep(10)
+
+    task1 = asyncio.create_task(_locked_fct(), name="pytest_task_1")
+    await started_event.wait()
+    with pytest.raises(ProjectLockError):
+        await _locked_fct()
+
+    await cancel_wait_task(task1)

packages/service-library/tests/test_project_lock.py

@@ -5,7 +5,7 @@
 from models_library.projects import ProjectID
 from models_library.projects_state import ProjectStatus
 from servicelib.logging_utils import log_context
-from servicelib.project_lock import with_project_locked
+from servicelib.redis import with_project_locked
 from simcore_postgres_database.utils_projects import (
     DBProjectNotFoundError,
     ProjectsRepo,

services/efs-guardian/src/simcore_service_efs_guardian/services/background_tasks.py

@@ -36,7 +36,7 @@
     X_SIMCORE_USER_AGENT,
 )
 from servicelib.mimetype_constants import MIMETYPE_APPLICATION_JSON
-from servicelib.project_lock import get_project_locked_state
+from servicelib.redis import get_project_locked_state
 from servicelib.rest_constants import RESPONSE_MODEL_POLICY
 
 from .._meta import API_VTAG as VTAG

services/web/server/src/simcore_service_webserver/projects/_crud_handlers.py

@@ -5,7 +5,7 @@
 
 from models_library.projects import ProjectID
 from models_library.users import UserID
-from servicelib.project_lock import ProjectLockError
+from servicelib.redis import ProjectLockError
 
 from ..errors import WebServerBaseError
 

services/web/server/src/simcore_service_webserver/projects/exceptions.py

@@ -72,11 +72,6 @@
     X_SIMCORE_USER_AGENT,
 )
 from servicelib.logging_utils import get_log_record_extra, log_context
-from servicelib.project_lock import (
-    get_project_locked_state,
-    is_project_locked,
-    with_project_locked,
-)
 from servicelib.rabbitmq import RemoteMethodNotRegisteredError, RPCServerError
 from servicelib.rabbitmq.rpc_interfaces.catalog import services as catalog_rpc
 from servicelib.rabbitmq.rpc_interfaces.clusters_keeper.ec2_instances import (
@@ -86,6 +81,11 @@
     ServiceWaitingForManualInterventionError,
     ServiceWasNotFoundError,
 )
+from servicelib.redis import (
+    get_project_locked_state,
+    is_project_locked,
+    with_project_locked,
+)
 from servicelib.redis._decorators import exclusive
 from servicelib.utils import fire_and_forget_task, logged_gather
 from simcore_postgres_database.models.users import UserRole