feat: annuleren taak toegevoegd

2026-03-15 13:06:48 +01:00
parent 7d910479f9
commit a52493459a
32 changed files with 835 additions and 61 deletions
@@ -95,12 +95,14 @@ class TaskRunner:
        thread.start()

    def _run_copy_file(self, task_id: str, source: str, destination: str, total_bytes: int) -> None:
-        self._repository.mark_running(
+        if not self._repository.mark_running(
            task_id=task_id,
            done_bytes=0,
            total_bytes=total_bytes,
            current_item=source,
-        )
+        ):
+            self._finalize_if_already_cancelled(task_id, done_bytes=0, total_bytes=total_bytes)
+            return

        progress = {"done": 0}

@@ -115,12 +117,11 @@ class TaskRunner:

        try:
            self._filesystem.copy_file(source=source, destination=destination, on_progress=on_progress)
-            self._repository.mark_completed(
+            self._complete_or_cancel_file_task(
                task_id=task_id,
                done_bytes=total_bytes,
                total_bytes=total_bytes,
            )
-            self._update_history_completed(task_id)
        except OSError as exc:
            self._repository.mark_failed(
                task_id=task_id,
@@ -133,21 +134,22 @@ class TaskRunner:
            self._update_history_failed(task_id, str(exc))

    def _run_copy_directory(self, task_id: str, source: str, destination: str) -> None:
-        self._repository.mark_running(
+        if not self._repository.mark_running(
            task_id=task_id,
            done_items=0,
            total_items=1,
            current_item=source,
-        )
+        ):
+            self._finalize_if_already_cancelled(task_id, done_items=0, total_items=1)
+            return

        try:
            self._filesystem.copy_directory(source=source, destination=destination)
-            self._repository.mark_completed(
+            self._complete_or_cancel_item_task(
                task_id=task_id,
                done_items=1,
                total_items=1,
            )
-            self._update_history_completed(task_id)
        except OSError as exc:
            self._repository.mark_failed(
                task_id=task_id,
@@ -164,15 +166,20 @@ class TaskRunner:
    def _run_copy_batch(self, task_id: str, items: list[dict[str, str]]) -> None:
        total_items = len(items)
        current_item = items[0]["source"] if items else None
-        self._repository.mark_running(
+        if not self._repository.mark_running(
            task_id=task_id,
            done_items=0,
            total_items=total_items,
            current_item=current_item,
-        )
+        ):
+            self._finalize_if_already_cancelled(task_id, done_items=0, total_items=total_items)
+            return

        completed_items = 0
        for index, item in enumerate(items):
+            if self._is_cancel_requested(task_id):
+                self._finalize_cancelled(task_id, done_items=completed_items, total_items=total_items)
+                return
            source = item["source"]
            destination = item["destination"]
            try:
@@ -188,6 +195,9 @@ class TaskRunner:
                    total_items=total_items,
                    current_item=next_item,
                )
+                if self._is_cancel_requested(task_id):
+                    self._finalize_cancelled(task_id, done_items=completed_items, total_items=total_items)
+                    return
            except OSError as exc:
                self._repository.mark_failed(
                    task_id=task_id,
@@ -202,12 +212,11 @@ class TaskRunner:
                self._update_history_failed(task_id, str(exc))
                return

-        self._repository.mark_completed(
+        self._complete_or_cancel_item_task(
            task_id=task_id,
            done_items=total_items,
            total_items=total_items,
        )
-        self._update_history_completed(task_id)

    def _run_move_file(
        self,
@@ -217,24 +226,25 @@ class TaskRunner:
        total_bytes: int,
        same_root: bool,
    ) -> None:
-        self._repository.mark_running(
+        if not self._repository.mark_running(
            task_id=task_id,
            done_bytes=0,
            total_bytes=total_bytes,
            current_item=source,
-        )
+        ):
+            self._finalize_if_already_cancelled(task_id, done_bytes=0, total_bytes=total_bytes)
+            return

        progress = {"done": 0}

        try:
            if same_root:
                self._filesystem.move_file(source=source, destination=destination)
-                self._repository.mark_completed(
+                self._complete_or_cancel_file_task(
                    task_id=task_id,
                    done_bytes=total_bytes,
                    total_bytes=total_bytes,
                )
-                self._update_history_completed(task_id)
                return

            def on_progress(done_bytes: int) -> None:
@@ -248,12 +258,11 @@ class TaskRunner:

            self._filesystem.copy_file(source=source, destination=destination, on_progress=on_progress)
            self._filesystem.delete_file(Path(source))
-            self._repository.mark_completed(
+            self._complete_or_cancel_file_task(
                task_id=task_id,
                done_bytes=total_bytes,
                total_bytes=total_bytes,
            )
-            self._update_history_completed(task_id)
        except OSError as exc:
            self._repository.mark_failed(
                task_id=task_id,
@@ -266,21 +275,22 @@ class TaskRunner:
            self._update_history_failed(task_id, str(exc))

    def _run_move_directory(self, task_id: str, source: str, destination: str) -> None:
-        self._repository.mark_running(
+        if not self._repository.mark_running(
            task_id=task_id,
            done_items=0,
            total_items=1,
            current_item=source,
-        )
+        ):
+            self._finalize_if_already_cancelled(task_id, done_items=0, total_items=1)
+            return

        try:
            self._filesystem.move_directory(source=source, destination=destination)
-            self._repository.mark_completed(
+            self._complete_or_cancel_item_task(
                task_id=task_id,
                done_items=1,
                total_items=1,
            )
-            self._update_history_completed(task_id)
        except OSError as exc:
            self._repository.mark_failed(
                task_id=task_id,
@@ -295,15 +305,20 @@ class TaskRunner:
    def _run_move_batch(self, task_id: str, items: list[dict[str, str]]) -> None:
        total_items = len(items)
        current_item = items[0]["source"] if items else None
-        self._repository.mark_running(
+        if not self._repository.mark_running(
            task_id=task_id,
            done_items=0,
            total_items=total_items,
            current_item=current_item,
-        )
+        ):
+            self._finalize_if_already_cancelled(task_id, done_items=0, total_items=total_items)
+            return

        completed_items = 0
        for index, item in enumerate(items):
+            if self._is_cancel_requested(task_id):
+                self._finalize_cancelled(task_id, done_items=completed_items, total_items=total_items)
+                return
            source = item["source"]
            destination = item["destination"]
            try:
@@ -319,6 +334,9 @@ class TaskRunner:
                    total_items=total_items,
                    current_item=next_item,
                )
+                if self._is_cancel_requested(task_id):
+                    self._finalize_cancelled(task_id, done_items=completed_items, total_items=total_items)
+                    return
            except OSError as exc:
                self._repository.mark_failed(
                    task_id=task_id,
@@ -333,25 +351,29 @@ class TaskRunner:
                self._update_history_failed(task_id, str(exc))
                return

-        self._repository.mark_completed(
+        self._complete_or_cancel_item_task(
            task_id=task_id,
            done_items=total_items,
            total_items=total_items,
        )
-        self._update_history_completed(task_id)

    def _run_duplicate_batch(self, task_id: str, items: list[dict[str, str]]) -> None:
        total_items = len(items)
        current_item = items[0]["source"] if items else None
-        self._repository.mark_running(
+        if not self._repository.mark_running(
            task_id=task_id,
            done_items=0,
            total_items=total_items,
            current_item=current_item,
-        )
+        ):
+            self._finalize_if_already_cancelled(task_id, done_items=0, total_items=total_items)
+            return

        completed_items = 0
        for index, item in enumerate(items):
+            if self._is_cancel_requested(task_id):
+                self._finalize_cancelled(task_id, done_items=completed_items, total_items=total_items)
+                return
            source = item["source"]
            destination = item["destination"]
            try:
@@ -367,6 +389,9 @@ class TaskRunner:
                    total_items=total_items,
                    current_item=next_item,
                )
+                if self._is_cancel_requested(task_id):
+                    self._finalize_cancelled(task_id, done_items=completed_items, total_items=total_items)
+                    return
            except OSError as exc:
                self._cleanup_partial_duplicate(Path(destination))
                self._repository.mark_failed(
@@ -382,20 +407,21 @@ class TaskRunner:
                self._update_history_failed(task_id, str(exc))
                return

-        self._repository.mark_completed(
+        self._complete_or_cancel_item_task(
            task_id=task_id,
            done_items=total_items,
            total_items=total_items,
        )
-        self._update_history_completed(task_id)

    def _run_delete_path(self, task_id: str, target: str, kind: str, recursive: bool) -> None:
-        self._repository.mark_running(
+        if not self._repository.mark_running(
            task_id=task_id,
            done_items=0,
            total_items=1,
            current_item=target,
-        )
+        ):
+            self._finalize_if_already_cancelled(task_id, done_items=0, total_items=1)
+            return

        try:
            path = Path(target)
@@ -405,12 +431,11 @@ class TaskRunner:
                self._filesystem.delete_directory_recursive(path)
            else:
                self._filesystem.delete_empty_directory(path)
-            self._repository.mark_completed(
+            self._complete_or_cancel_item_task(
                task_id=task_id,
                done_items=1,
                total_items=1,
            )
-            self._update_history_completed(task_id)
        except OSError as exc:
            self._repository.mark_failed(
                task_id=task_id,
@@ -466,6 +491,88 @@ class TaskRunner:
            return
        path.unlink()

+    def _is_cancel_requested(self, task_id: str) -> bool:
+        task = self._repository.get_task(task_id)
+        return bool(task) and task["status"] == "cancelling"
+
+    def _finalize_if_already_cancelled(
+        self,
+        task_id: str,
+        *,
+        done_bytes: int | None = None,
+        total_bytes: int | None = None,
+        done_items: int | None = None,
+        total_items: int | None = None,
+    ) -> None:
+        task = self._repository.get_task(task_id)
+        if task and task["status"] == "cancelled":
+            self._update_history_cancelled(task_id)
+            return
+        if task and task["status"] == "cancelling":
+            self._finalize_cancelled(
+                task_id,
+                done_bytes=done_bytes,
+                total_bytes=total_bytes,
+                done_items=done_items,
+                total_items=total_items,
+            )
+
+    def _complete_or_cancel_file_task(
+        self,
+        *,
+        task_id: str,
+        done_bytes: int | None,
+        total_bytes: int | None,
+    ) -> None:
+        if self._is_cancel_requested(task_id):
+            self._finalize_cancelled(task_id, done_bytes=done_bytes, total_bytes=total_bytes)
+            return
+        if self._repository.mark_completed(
+            task_id=task_id,
+            done_bytes=done_bytes,
+            total_bytes=total_bytes,
+        ):
+            self._update_history_completed(task_id)
+            return
+        self._finalize_if_already_cancelled(task_id, done_bytes=done_bytes, total_bytes=total_bytes)
+
+    def _complete_or_cancel_item_task(
+        self,
+        *,
+        task_id: str,
+        done_items: int | None,
+        total_items: int | None,
+    ) -> None:
+        if self._is_cancel_requested(task_id):
+            self._finalize_cancelled(task_id, done_items=done_items, total_items=total_items)
+            return
+        if self._repository.mark_completed(
+            task_id=task_id,
+            done_items=done_items,
+            total_items=total_items,
+        ):
+            self._update_history_completed(task_id)
+            return
+        self._finalize_if_already_cancelled(task_id, done_items=done_items, total_items=total_items)
+
+    def _finalize_cancelled(
+        self,
+        task_id: str,
+        *,
+        done_bytes: int | None = None,
+        total_bytes: int | None = None,
+        done_items: int | None = None,
+        total_items: int | None = None,
+    ) -> None:
+        if self._repository.finalize_cancelled(
+            task_id=task_id,
+            done_bytes=done_bytes,
+            total_bytes=total_bytes,
+            done_items=done_items,
+            total_items=total_items,
+        ):
+            self._update_history_cancelled(task_id)
+
    def _update_history_completed(self, task_id: str) -> None:
        if self._history_repository:
            self._history_repository.update_entry(entry_id=task_id, status="completed")
@@ -478,3 +585,7 @@ class TaskRunner:
                error_code="io_error",
                error_message=error_message,
            )
+
+    def _update_history_cancelled(self, task_id: str) -> None:
+        if self._history_repository:
+            self._history_repository.update_entry(entry_id=task_id, status="cancelled")