Enforce Editor Lock for Write, Append, and Upload Operations in DataNode

taipy/core/data/_file_datanode_mixin.py

@@ -20,6 +20,7 @@
 from taipy.common.logger._taipy_logger import _TaipyLogger
 
 from .._entity._reload import _self_reload
+from ..exceptions import DataNodeIsBeingEdited
 from ..reason import InvalidUploadFile, NoFileToDownload, NotAFile, ReasonCollection, UploadFileCanNotBeRead
 from .data_node import DataNode
 from .data_node_id import Edit
@@ -100,7 +101,15 @@
 
         return ""
 
-    def _upload(self, path: str, upload_checker: Optional[Callable[[str, Any], bool]] = None) -> ReasonCollection:
+    def _upload(
+        self,
+        data: Optional[Any] = None,
+        path: str = "",
+        upload_checker: Optional[Callable[[str, Any], bool]] = None,
+        job_id: Optional["JobId"] = None,
+        editor_id: Optional[str] = None,
+        **kwargs: Dict[str, Any]
+    ) -> None:
         """Upload a file data to the data node.
 
         Arguments:
@@ -112,6 +121,9 @@
         Returns:
             True if the upload was successful, otherwise False.
         """
+        if self.edit_in_progress and self.editor_id != editor_id:
+            raise DataNodeIsBeingEdited(self.id, self.editor_id)
+
         from ._data_manager_factory import _DataManagerFactory
 
         reason_collection = ReasonCollection()
@@ -124,7 +136,7 @@
             self.__logger.error(f"Error while uploading {upload_path.name} to data node {self.id}:")  # type: ignore[attr-defined]
             self.__logger.error(f"Error: {err}")
             reason_collection._add_reason(self.id, UploadFileCanNotBeRead(upload_path.name, self.id))  # type: ignore[attr-defined]
             return reason_collection
 
         if upload_checker is not None:
             try:
@@ -138,15 +150,15 @@
 
             if not can_upload:
                 reason_collection._add_reason(self.id, InvalidUploadFile(upload_path.name, self.id))  # type: ignore[attr-defined]
                 return reason_collection
 
         shutil.copy(upload_path, self.path)
-
-        self.track_edit(timestamp=datetime.now())  # type: ignore[attr-defined]
+        self._write(data)
+        self.track_edit(job_id=job_id, editor_id=editor_id, **kwargs)  # type: ignore[attr-defined]
         self.unlock_edit()  # type: ignore[attr-defined]
         _DataManagerFactory._build_manager()._set(self)  # type: ignore[arg-type]
 
         return reason_collection
 
     def _read_from_path(self, path: Optional[str] = None, **read_kwargs) -> Any:
         raise NotImplementedError

taipy/core/data/data_node.py

@@ -415,7 +415,7 @@ def read(self) -> Any:
             )
             return None
 
-    def append(self, data, job_id: Optional[JobId] = None, **kwargs: Dict[str, Any]):
+    def append(self, data, job_id: Optional[JobId] = None, editor_id: Optional[str] = None, **kwargs: Dict[str, Any]):
         """Append some data to this data node.
 
         Arguments:
@@ -426,12 +426,14 @@ def append(self, data, job_id: Optional[JobId] = None, **kwargs: Dict[str, Any])
         """
         from ._data_manager_factory import _DataManagerFactory
 
+        if self.edit_in_progress and self.editor_id != editor_id:
+            raise DataNodeIsBeingEdited(self.id, self.editor_id)
+
         self._append(data)
-        self.track_edit(job_id=job_id, **kwargs)
-        self.unlock_edit()
+        self.track_edit(job_id=job_id, editor_id=editor_id, **kwargs)
         _DataManagerFactory._build_manager()._set(self)
 
-    def write(self, data, job_id: Optional[JobId] = None, **kwargs: Dict[str, Any]):
+    def write(self, data, job_id: Optional[JobId] = None, editor_id: Optional[str] = None, **kwargs: Dict[str, Any]):
         """Write some data to this data node.
 
         Arguments:
@@ -442,9 +444,16 @@ def write(self, data, job_id: Optional[JobId] = None, **kwargs: Dict[str, Any]):
         """
         from ._data_manager_factory import _DataManagerFactory
 
+        if self.edit_in_progress and editor_id and self.editor_id != editor_id:
+            raise DataNodeIsBeingEdited(self.id, self.editor_id)
+
+        if not editor_id and self.edit_in_progress:
+            print("Orchestrator writing without editor_id")
+
         self._write(data)
-        self.track_edit(job_id=job_id, **kwargs)
-        self.unlock_edit()
+        self.last_edit_date = datetime.now()
+        self.edit_in_progress = False  # Ensure it's not locked after writing
+        self.track_edit(job_id=job_id, editor_id=editor_id, **kwargs)
         _DataManagerFactory._build_manager()._set(self)
 
     def track_edit(self, **options):
@@ -471,6 +480,10 @@ def lock_edit(self, editor_id: Optional[str] = None):
         Arguments:
             editor_id (Optional[str]): The editor's identifier.
         """
+
+        if self._editor_expiration_date and datetime.now() > self._editor_expiration_date:
+            self.unlock_edit()
+
         if editor_id:
             if (
                 self.edit_in_progress

taipy/core/data/in_memory.py

@@ -13,7 +13,6 @@
 from typing import Any, Dict, List, Optional, Set
 
 from taipy.common.config.common.scope import Scope
-
 from .._version._version_manager_factory import _VersionManagerFactory
 from .data_node import DataNode
 from .data_node_id import DataNodeId, Edit
@@ -98,3 +97,14 @@ def _read(self):
 
     def _write(self, data):
         in_memory_storage[self.id] = data
+
+    def _append(self, data):
+        """Append data to the existing data in the in-memory storage."""
+        if self.id not in in_memory_storage:
+            in_memory_storage[self.id] = []
+
+        if not isinstance(in_memory_storage[self.id], list):
+            in_memory_storage[self.id] = [in_memory_storage[self.id]]
+
+        in_memory_storage[self.id].append(data)  # Append new data
+

tests/core/data/test_data_node.py

@@ -745,3 +745,33 @@ def test_change_data_node_name(self):
         # This new syntax will be the only one allowed: https://github.com/Avaiga/taipy-core/issues/806
         dn.properties["name"] = "baz"
         assert dn.name == "baz"
+
+    def test_locked_data_node_write_should_fail_with_wrong_editor(self):
+        dn = InMemoryDataNode("dn", Scope.SCENARIO)
+        dn.lock_edit("editor_1")
+
+        # Should raise exception for wrong editor
+        with pytest.raises(DataNodeIsBeingEdited):
+            dn.write("data", editor_id="editor_2")
+
+        # Should succeed with correct editor
+        dn.write("data", editor_id="editor_1")
+        assert dn.read() == "data"
+
+    def test_locked_data_node_append_should_fail_with_wrong_editor(self):
+        dn = InMemoryDataNode("dn", Scope.SCENARIO)
+        dn.lock_edit("editor_1")
+
+        with pytest.raises(DataNodeIsBeingEdited):
+            dn.append("data", editor_id="editor_2")
+
+        dn.append("data", editor_id="editor_1")
+        assert dn.read() == ["data"]
+
+    def test_orchestrator_write_without_editor_id(self):
+        dn = InMemoryDataNode("dn", Scope.SCENARIO)
+        dn.lock_edit("editor_1")
+
+        # Orchestrator write without editor_id should succeed
+        dn.write("orchestrator_data")
+        assert dn.read() == "orchestrator_data"