node locking

Makefile

@@ -89,7 +89,31 @@ export DOCKER_REGISTRY  ?= itisfoundation
 
 MAKEFILES_WITH_OPENAPI_SPECS := $(shell find . -mindepth 2 -type f -name 'Makefile' -not -path '*/.*' -exec grep -l '^openapi-specs:' {} \; | xargs realpath)
 
+# WSL 2 tricks
+define _check_wsl_mirroring
+$(shell \
+    if [ "$(IS_WSL2)" = "WSL2" ]; then \
+        win_user=$$(powershell.exe '$$env:UserName' | tr -d '\r' | tail -n 1 | xargs); \
+        config_path="/mnt/c/Users/$$win_user/.wslconfig"; \
+        if [ -f "$$config_path" ] && grep -q "networkingMode.*=.*mirrored" "$$config_path" 2>/dev/null; then \
+            echo "true"; \
+        else \
+            echo "false"; \
+        fi; \
+    else \
+        echo "false"; \
+    fi \
+)
+endef
+
+WSL_MIRRORED := $(_check_wsl_mirroring)
+
+
+ifeq ($(WSL_MIRRORED),true)
+get_my_ip := 127.0.0.1
+else
 get_my_ip := $(shell (hostname --all-ip-addresses || hostname -i) 2>/dev/null | cut --delimiter=" " --fields=1)
+endif
 
 # NOTE: this is only for WSL2 as the WSL2 subsystem IP is changing on each reboot
 ifeq ($(IS_WSL2),WSL2)

packages/models-library/src/models_library/api_schemas_directorv2/dynamic_services_service.py

@@ -2,6 +2,7 @@
 from pathlib import Path
 
 from pydantic import BaseModel, ConfigDict, Field
+from pydantic.config import JsonDict
 
 from ..basic_types import PortInt
 from ..projects import ProjectID
@@ -88,40 +89,45 @@ class RunningDynamicServiceDetails(ServiceDetails):
         alias="service_message",
     )
 
+    @staticmethod
+    def _update_json_schema_extra(schema: JsonDict) -> None:
+        schema.update(
+            {
+                "examples": [  # legacy
+                    {
+                        "service_key": "simcore/services/dynamic/raw-graphs",
+                        "service_version": "2.10.6",
+                        "user_id": 1,
+                        "project_id": "32fb4eb6-ab30-11ef-9ee4-0242ac140008",
+                        "service_uuid": "0cd049ba-cd6b-4a12-b416-a50c9bc8e7bb",
+                        "service_basepath": "/x/0cd049ba-cd6b-4a12-b416-a50c9bc8e7bb",
+                        "service_host": "raw-graphs_0cd049ba-cd6b-4a12-b416-a50c9bc8e7bb",
+                        "service_port": 4000,
+                        "published_port": None,
+                        "entry_point": "",
+                        "service_state": "running",
+                        "service_message": "",
+                    },
+                    # new style
+                    {
+                        "service_key": "simcore/services/dynamic/jupyter-math",
+                        "service_version": "3.0.3",
+                        "user_id": 1,
+                        "project_id": "32fb4eb6-ab30-11ef-9ee4-0242ac140008",
+                        "service_uuid": "6e3cad3a-eb64-43de-b476-9ac3c413fd9c",
+                        "boot_type": "V2",
+                        "service_host": "dy-sidecar_6e3cad3a-eb64-43de-b476-9ac3c413fd9c",
+                        "service_port": 8888,
+                        "service_state": "running",
+                        "service_message": "",
+                    },
+                ]
+            }
+        )
+
     model_config = ConfigDict(
         ignored_types=(cached_property,),
-        json_schema_extra={
-            "examples": [
-                # legacy
-                {
-                    "service_key": "simcore/services/dynamic/raw-graphs",
-                    "service_version": "2.10.6",
-                    "user_id": 1,
-                    "project_id": "32fb4eb6-ab30-11ef-9ee4-0242ac140008",
-                    "service_uuid": "0cd049ba-cd6b-4a12-b416-a50c9bc8e7bb",
-                    "service_basepath": "/x/0cd049ba-cd6b-4a12-b416-a50c9bc8e7bb",
-                    "service_host": "raw-graphs_0cd049ba-cd6b-4a12-b416-a50c9bc8e7bb",
-                    "service_port": 4000,
-                    "published_port": None,
-                    "entry_point": "",
-                    "service_state": "running",
-                    "service_message": "",
-                },
-                # new style
-                {
-                    "service_key": "simcore/services/dynamic/jupyter-math",
-                    "service_version": "3.0.3",
-                    "user_id": 1,
-                    "project_id": "32fb4eb6-ab30-11ef-9ee4-0242ac140008",
-                    "service_uuid": "6e3cad3a-eb64-43de-b476-9ac3c413fd9c",
-                    "boot_type": "V2",
-                    "service_host": "dy-sidecar_6e3cad3a-eb64-43de-b476-9ac3c413fd9c",
-                    "service_port": 8888,
-                    "service_state": "running",
-                    "service_message": "",
-                },
-            ]
-        },
+        json_schema_extra=_update_json_schema_extra,
     )
 
     @cached_property

packages/models-library/src/models_library/api_schemas_webserver/projects_nodes.py

@@ -2,6 +2,7 @@
 from typing import Annotated, Any, Literal, TypeAlias
 
 from pydantic import ConfigDict, Field
+from pydantic.config import JsonDict
 
 from ..access_rights import ExecutableAccessRights
 from ..api_schemas_directorv2.dynamic_services import RetrieveDataOut
@@ -163,14 +164,20 @@ class NodeGetIdle(OutputSchema):
     def from_node_id(cls, node_id: NodeID) -> "NodeGetIdle":
         return cls(service_state="idle", service_uuid=node_id)
 
-    model_config = ConfigDict(
-        json_schema_extra={
-            "example": {
-                "service_uuid": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
-                "service_state": "idle",
+    @staticmethod
+    def _update_json_schema_extra(schema: JsonDict) -> None:
+        schema.update(
+            {
+                "examples": [
+                    {
+                        "service_uuid": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+                        "service_state": "idle",
+                    }
+                ]
             }
-        }
-    )
+        )
+
+    model_config = ConfigDict(json_schema_extra=_update_json_schema_extra)
 
 
 class NodeGetUnknown(OutputSchema):

packages/models-library/src/models_library/projects_nodes.py

@@ -2,7 +2,8 @@
 Models Node as a central element in a project's pipeline
 """
 
-from typing import Annotated, Any, TypeAlias, Union
+from enum import auto
+from typing import Annotated, Any, Self, TypeAlias, Union
 
 from common_library.basic_types import DEFAULT_FACTORY
 from pydantic import (
@@ -16,10 +17,12 @@
     StrictInt,
     StringConstraints,
     field_validator,
+    model_validator,
 )
 from pydantic.config import JsonDict
 
 from .basic_types import EnvVarKey, KeyIDStr
+from .groups import GroupID
 from .projects_access import AccessEnum
 from .projects_nodes_io import (
     DatCoreFileLink,
@@ -31,8 +34,9 @@
 from .projects_nodes_layout import Position
 from .projects_state import RunningState
 from .services import ServiceKey, ServiceVersion
+from .utils.enums import StrAutoEnum
 
-InputTypes = Union[
+InputTypes = Union[  # noqa: UP007
     # NOTE: WARNING the order in Union[*] below matters!
     StrictBool,
     StrictInt,
@@ -44,7 +48,7 @@
     DownloadLink,
     list[Any] | dict[str, Any],  # arrays | object
 ]
-OutputTypes = Union[
+OutputTypes = Union[  # noqa: UP007
     # NOTE: WARNING the order in Union[*] below matters!
     StrictBool,
     StrictInt,
@@ -71,6 +75,69 @@
 UnitStr: TypeAlias = Annotated[str, StringConstraints(strip_whitespace=True)]
 
 
+class NodeShareStatus(StrAutoEnum):
+    OPENING = auto()
+    OPENED = auto()
+    CLOSING = auto()
+
+
+class NodeShareState(BaseModel):
+    locked: Annotated[
+        bool,
+        Field(
+            description="True if the node is locked, False otherwise",
+        ),
+    ]
+
+    current_user_groupids: Annotated[
+        list[GroupID] | None,
+        Field(
+            description="Group(s) that currently have access to the node (or locked it)"
+        ),
+    ] = None
+
+    status: Annotated[
+        NodeShareStatus | None,
+        Field(
+            description="Reason why the node is locked, None if not locked",
+        ),
+    ] = None
+
+    @model_validator(mode="after")
+    def _validate_lock_state(self) -> Self:
+        if self.locked and (self.current_user_groupids is None or self.status is None):
+            msg = "If the node is locked, both 'current_user_groupids' and 'status' must be set"
+            raise ValueError(msg)
+
+        return self
+
+    @staticmethod
+    def _update_json_schema_extra(schema: JsonDict) -> None:
+        schema.update(
+            {
+                "examples": [
+                    {
+                        "locked": False,
+                    },
+                    {
+                        "locked": True,
+                        "current_user_groupids": [666],
+                        "status": "OPENING",
+                    },
+                    {
+                        "locked": False,
+                        "current_user_groupids": [666, 4563],
+                        "status": "OPENED",
+                    },
+                ]
+            }
+        )
+
+    model_config = ConfigDict(
+        extra="forbid", json_schema_extra=_update_json_schema_extra
+    )
+
+
 class NodeState(BaseModel):
     modified: Annotated[
         bool,
@@ -104,6 +171,10 @@ class NodeState(BaseModel):
         ),
     ] = 0
 
+    lock_state: Annotated[
+        NodeShareState | None, Field(description="the node's lock state")
+    ] = None
+
     model_config = ConfigDict(
         extra="forbid",
         populate_by_name=True,
@@ -192,7 +263,7 @@ class Node(BaseModel):
     ] = DEFAULT_FACTORY
 
     inputs_required: Annotated[
-        list[InputID],
+        list[InputID] | None,
         Field(
             default_factory=list,
             description="Defines inputs that are required in order to run the service",
@@ -286,7 +357,6 @@ def _convert_empty_str_to_none(cls, v):
     @classmethod
     def _convert_from_enum(cls, v):
         if isinstance(v, str):
-
             # the old version of state was a enum of RunningState
             running_state_value = _convert_old_enum_name(v)
             return NodeState(current_status=running_state_value)

packages/models-library/src/models_library/utils/enums.py

@@ -6,7 +6,9 @@
 @unique
 class StrAutoEnum(StrEnum):
     @staticmethod
-    def _generate_next_value_(name, start, count, last_values):
+    def _generate_next_value_(
+        name: str, start: int, count: int, last_values: list[str]  # noqa: ARG004
+    ) -> str:
         return name.upper()
 
 

packages/models-library/tests/test_project_nodes.py

@@ -29,6 +29,7 @@ def test_create_minimal_node(minimal_node_data_sample: dict[str, Any]):
     assert node.state.current_status == RunningState.NOT_STARTED
     assert node.state.modified is True
     assert node.state.dependencies == set()
+    assert node.state.lock_state is None
 
     assert node.parent is None
     assert node.progress is None
@@ -37,7 +38,7 @@ def test_create_minimal_node(minimal_node_data_sample: dict[str, Any]):
 
 
 def test_create_minimal_node_with_new_data_type(
-    minimal_node_data_sample: dict[str, Any]
+    minimal_node_data_sample: dict[str, Any],
 ):
     old_node_data = minimal_node_data_sample
     # found some old data with this aspect

packages/pytest-simcore/src/pytest_simcore/db_entries_mocks.py

@@ -41,7 +41,6 @@ def create_registered_user(
     with contextlib.ExitStack() as stack:
 
         def _(**user_kwargs) -> dict[str, Any]:
-
             user_id = len(created_user_ids) + 1
             user = stack.enter_context(
                 sync_insert_and_get_user_and_secrets_lifespan(
@@ -122,8 +121,11 @@ async def _(
             await project_nodes_repo.add(
                 con,
                 nodes=[
-                    ProjectNodeCreate(node_id=NodeID(node_id), **default_node_config)
-                    for node_id in inserted_project.workbench
+                    ProjectNodeCreate(
+                        node_id=NodeID(node_id),
+                        **(default_node_config | node_data.model_dump(mode="json")),
+                    )
+                    for node_id, node_data in inserted_project.workbench.items()
                 ],
             )
             await con.execute(