1st trial

Author: sanderegg

services/web/server/src/simcore_service_webserver/exporter/_handlers.py

@@ -1,6 +1,7 @@
 import logging
 from collections.abc import Callable, Coroutine
 from contextlib import AsyncExitStack
+from pathlib import Path
 from typing import Any
 
 from aiofiles.tempfile import TemporaryDirectory as AioTemporaryDirectory
@@ -11,8 +12,7 @@
 from .._constants import RQ_PRODUCT_KEY
 from .._meta import API_VTAG
 from ..login.decorators import login_required
-from ..projects.lock import lock_project
-from ..projects.projects_api import retrieve_and_notify_project_locked_state
+from ..projects.projects_api import with_project_locked_notified_state
 from ..security.decorators import permission_required
 from ..users.api import get_user_fullname
 from ._formatter.archive import get_sds_archive_path
@@ -42,18 +42,18 @@ async def export_project(request: web.Request):
     user_id = request[RQT_USERID_KEY]
     project_uuid = request.match_info.get("project_id")
     assert project_uuid  # nosec
-    delete_tmp_dir: Callable[[], Coroutine[Any, Any, None]] | None = None
-    try:
-        async with AsyncExitStack() as tmp_dir_stack, lock_project(
-            request.app,
-            project_uuid,
-            ProjectStatus.EXPORTING,
-            user_id,
-            await get_user_fullname(request.app, user_id=user_id),
-        ):
-            await retrieve_and_notify_project_locked_state(
-                user_id, project_uuid, request.app
-            )
+
+    @with_project_locked_notified_state(
+        request.app,
+        project_uuid=project_uuid,
+        status=ProjectStatus.EXPORTING,
+        user_id=user_id,
+        user_name=await get_user_fullname(request.app, user_id=user_id),
+        notify_users=True,
+    )
+    async def _() -> tuple[Callable[[], Coroutine[Any, Any, None]], Path]:
+        # @GitHK what is this supposed to be doing??
+        async with AsyncExitStack() as tmp_dir_stack:
             tmp_dir = await tmp_dir_stack.enter_async_context(AioTemporaryDirectory())
             file_to_download = await get_sds_archive_path(
                 app=request.app,
@@ -68,14 +68,14 @@ async def export_project(request: web.Request):
                 msg = f"Must provide a file to download, not {file_to_download!s}"
                 raise SDSException(msg)
             # this allows to transfer deletion of the tmp dir responsibility
-            delete_tmp_dir = tmp_dir_stack.pop_all().aclose
-    finally:
-        await retrieve_and_notify_project_locked_state(
-            user_id, project_uuid, request.app
-        )
+        return tmp_dir_stack.pop_all().aclose, file_to_download
+
+    delete_tmp_dir_callable, file_to_download = await _()
 
     headers = {"Content-Disposition": f'attachment; filename="{file_to_download.name}"'}
-    assert delete_tmp_dir  # nosec
+    assert delete_tmp_dir_callable  # nosec
     return CleanupFileResponse(
-        remove_tmp_dir_cb=delete_tmp_dir, path=file_to_download, headers=headers
+        remove_tmp_dir_cb=delete_tmp_dir_callable,
+        path=file_to_download,
+        headers=headers,
     )

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

@@ -1,7 +1,6 @@
 import asyncio
 import logging
 from collections.abc import Coroutine
-from contextlib import AsyncExitStack
 from typing import Any, TypeAlias
 
 from aiohttp import web
@@ -164,17 +163,7 @@ async def _copy_files_from_source_project(
         != ProjectTypeDB.TEMPLATE
     )
 
-    async with AsyncExitStack() as stack:
-        if needs_lock_source_project:
-            await stack.enter_async_context(
-                projects_api.lock_with_notification(
-                    app,
-                    source_project["uuid"],
-                    ProjectStatus.CLONING,
-                    user_id,
-                    await get_user_fullname(app, user_id=user_id),
-                )
-            )
+    async def _copy() -> None:
         starting_value = task_progress.percent
         async for long_running_task in copy_data_folders_from_project(
             app, source_project, new_project, nodes_map, user_id
@@ -191,6 +180,18 @@ async def _copy_files_from_source_project(
             if long_running_task.done():
                 await long_running_task.result()
 
+    if needs_lock_source_project:
+        await projects_api.with_project_locked_notified_state(
+            app,
+            project_uuid=source_project["uuid"],
+            status=ProjectStatus.CLONING,
+            user_id=user_id,
+            user_name=await get_user_fullname(app, user_id=user_id),
+            notify_users=True,
+        )(_copy)()
+    else:
+        await _copy()
+
 
 async def _compose_project_data(
     app: web.Application,

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

@@ -1,40 +1,46 @@
-import logging
-from collections.abc import AsyncIterator
-from contextlib import asynccontextmanager
+from collections.abc import Callable, Coroutine
+from functools import wraps
+from typing import Any, ParamSpec, TypeVar
 
 from aiohttp import web
 from models_library.projects import ProjectID
 from models_library.projects_access import Owner
 from models_library.projects_state import ProjectLocked, ProjectStatus
-from servicelib.project_lock import PROJECT_REDIS_LOCK_KEY
-from servicelib.project_lock import lock_project as common_lock_project
+from servicelib.project_lock import PROJECT_REDIS_LOCK_KEY, with_locked_project
 
 from ..redis import get_redis_lock_manager_client, get_redis_lock_manager_client_sdk
 from ..users.api import FullNameDict
 
-_logger = logging.getLogger(__name__)
+P = ParamSpec("P")
+R = TypeVar("R")
 
 
-@asynccontextmanager
-async def lock_project(
+def with_locked_project_from_app(
     app: web.Application,
+    *,
     project_uuid: str | ProjectID,
     status: ProjectStatus,
     user_id: int,
     user_fullname: FullNameDict,
-) -> AsyncIterator[None]:
-    """Context manager to lock and unlock a project by user_id
+) -> Callable[
+    [Callable[P, Coroutine[Any, Any, R]]], Callable[P, Coroutine[Any, Any, R]]
+]:
+    def _decorator(
+        func: Callable[P, Coroutine[Any, Any, R]],
+    ) -> Callable[P, Coroutine[Any, Any, R]]:
+        @with_locked_project(
+            get_redis_lock_manager_client_sdk(app),
+            project_uuid=project_uuid,
+            status=status,
+            owner=Owner(user_id=user_id, **user_fullname),
+        )
+        @wraps(func)
+        async def _wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            return await func(*args, **kwargs)
 
-    Raises:
-        ProjectLockError: if project is already locked
-    """
-    async with common_lock_project(
-        get_redis_lock_manager_client_sdk(app),
-        project_uuid=project_uuid,
-        status=status,
-        owner=Owner(user_id=user_id, **user_fullname),
-    ):
-        yield
+        return _wrapper
+
+    return _decorator
 
 
 async def is_project_locked(