fractal-server 2.14.16__py3-none-any.whl → 2.15.0a1__py3-none-any.whl

fractal_server/ssh/_fabric.py

@@ -204,6 +204,32 @@ class FractalSSH:
         self.logger.info(f"END reading remote JSON file {filepath}.")
         return data
 
+    def read_remote_text_file(self, filepath: str) -> dict[str, Any]:
+        """
+        Read a remote text file into a string.
+
+        Note from paramiko docs:
+        > The Python 'b' flag is ignored, since SSH treats all files as binary.
+        """
+        self.logger.info(f"START reading remote text file {filepath}.")
+        with _acquire_lock_with_timeout(
+            lock=self._lock,
+            label="read_remote_text_file",
+            timeout=self.default_lock_timeout,
+        ):
+            try:
+                with self._sftp_unsafe().open(filepath, "r") as f:
+                    data = f.read().decode()
+            except Exception as e:
+                self.log_and_raise(
+                    e=e,
+                    message=(
+                        f"Error in `read_remote_text_file`, for {filepath=}."
+                    ),
+                )
+        self.logger.info(f"END reading remote text file {filepath}.")
+        return data
+
     def check_connection(self) -> None:
         """
         Open the SSH connection and handle exceptions.

fractal_server/tasks/v2/local/__init__.py

@@ -1,3 +1,6 @@
 from .collect import collect_local  # noqa
+from .collect_pixi import collect_local_pixi  # noqa
 from .deactivate import deactivate_local  # noqa
+from .deactivate_pixi import deactivate_local_pixi  # noqa
 from .reactivate import reactivate_local  # noqa
+from .reactivate_pixi import reactivate_local_pixi  # noqa

fractal_server/tasks/v2/local/_utils.py

@@ -50,19 +50,24 @@ def check_task_files_exist(task_list: list[TaskCreateV2]) -> None:
     """
     Check that the modules listed in task commands point to existing files.
 
+    Note: commands may be like `/one/python /another/task.py` or
+    `/one/pixi [...] /another/task.py`, and in both cases `split()[-1]`
+    returns `/another/task.py`.
+
     Args:
         task_list:
     """
+
     for _task in task_list:
         if _task.command_non_parallel is not None:
-            _task_path = _task.command_non_parallel.split()[1]
+            _task_path = _task.command_non_parallel.split()[-1]
             if not Path(_task_path).exists():
                 raise FileNotFoundError(
                     f"Task `{_task.name}` has `command_non_parallel` "
                     f"pointing to missing file `{_task_path}`."
                 )
         if _task.command_parallel is not None:
-            _task_path = _task.command_parallel.split()[1]
+            _task_path = _task.command_parallel.split()[-1]
             if not Path(_task_path).exists():
                 raise FileNotFoundError(
                     f"Task `{_task.name}` has `command_parallel` "

fractal_server/tasks/v2/local/collect.py

@@ -1,5 +1,4 @@
 import json
-import logging
 import shutil
 import time
 from pathlib import Path
@@ -8,20 +7,22 @@ from tempfile import TemporaryDirectory
 from ..utils_database import create_db_tasks_and_update_task_group_sync
 from ._utils import _customize_and_run_template
 from fractal_server.app.db import get_sync_db
-from fractal_server.app.models.v2 import TaskGroupActivityV2
 from fractal_server.app.models.v2 import TaskGroupV2
+from fractal_server.app.schemas.v2 import FractalUploadedFile
 from fractal_server.app.schemas.v2 import TaskGroupActivityActionV2
 from fractal_server.app.schemas.v2 import TaskGroupActivityStatusV2
-from fractal_server.app.schemas.v2 import WheelFile
 from fractal_server.app.schemas.v2.manifest import ManifestV2
 from fractal_server.logger import reset_logger_handlers
 from fractal_server.logger import set_logger
 from fractal_server.tasks.utils import get_log_path
 from fractal_server.tasks.v2.local._utils import check_task_files_exist
-from fractal_server.tasks.v2.utils_background import _prepare_tasks_metadata
 from fractal_server.tasks.v2.utils_background import add_commit_refresh
 from fractal_server.tasks.v2.utils_background import fail_and_cleanup
+from fractal_server.tasks.v2.utils_background import (
+    get_activity_and_task_group,
+)
 from fractal_server.tasks.v2.utils_background import get_current_log
+from fractal_server.tasks.v2.utils_background import prepare_tasks_metadata
 from fractal_server.tasks.v2.utils_package_names import compare_package_names
 from fractal_server.tasks.v2.utils_python_interpreter import (
     get_python_interpreter_v2,
@@ -38,7 +39,7 @@ def collect_local(
     *,
     task_group_activity_id: int,
     task_group_id: int,
-    wheel_file: WheelFile | None = None,
+    wheel_file: FractalUploadedFile | None = None,
 ) -> None:
     """
     Collect a task package.
@@ -67,16 +68,12 @@ def collect_local(
         )
 
         with next(get_sync_db()) as db:
-            # Get main objects from db
-            activity = db.get(TaskGroupActivityV2, task_group_activity_id)
-            task_group = db.get(TaskGroupV2, task_group_id)
-            if activity is None or task_group is None:
-                # Use `logging` directly
-                logging.error(
-                    "Cannot find database rows with "
-                    f"{task_group_id=} and {task_group_activity_id=}:\n"
-                    f"{task_group=}\n{activity=}. Exit."
-                )
+            success, task_group, activity = get_activity_and_task_group(
+                task_group_activity_id=task_group_activity_id,
+                task_group_id=task_group_id,
+                db=db,
+            )
+            if not success:
                 return
 
             # Log some info
@@ -103,16 +100,18 @@ def collect_local(
                 Path(task_group.path).mkdir(parents=True)
                 logger.info(f"Created {task_group.path}")
 
-                # Write wheel file and set task_group.wheel_path
+                # Write wheel file and set task_group.archive_path
                 if wheel_file is not None:
 
-                    wheel_path = (
+                    archive_path = (
                         Path(task_group.path) / wheel_file.filename
                     ).as_posix()
-                    logger.info(f"Write wheel-file contents into {wheel_path}")
-                    with open(wheel_path, "wb") as f:
+                    logger.info(
+                        f"Write wheel-file contents into {archive_path}"
+                    )
+                    with open(archive_path, "wb") as f:
                         f.write(wheel_file.contents)
-                    task_group.wheel_path = wheel_path
+                    task_group.archive_path = archive_path
                     task_group = add_commit_refresh(obj=task_group, db=db)
 
                 # Prepare replacements for templates
@@ -220,7 +219,7 @@ def collect_local(
                 activity = add_commit_refresh(obj=activity, db=db)
 
                 logger.info("_prepare_tasks_metadata - start")
-                task_list = _prepare_tasks_metadata(
+                task_list = prepare_tasks_metadata(
                     package_manifest=pkg_manifest,
                     package_version=task_group.version,
                     package_root=Path(package_root),
@@ -241,15 +240,15 @@ def collect_local(
 
                 # Update task_group data
                 logger.info(
-                    "Add pip_freeze, venv_size and venv_file_number "
+                    "Add env_info, venv_size and venv_file_number "
                     "to TaskGroupV2 - start"
                 )
-                task_group.pip_freeze = pip_freeze_stdout
+                task_group.env_info = pip_freeze_stdout
                 task_group.venv_size_in_kB = int(venv_size)
                 task_group.venv_file_number = int(venv_file_number)
                 task_group = add_commit_refresh(obj=task_group, db=db)
                 logger.info(
-                    "Add pip_freeze, venv_size and venv_file_number "
+                    "Add env_info, venv_size and venv_file_number "
                     "to TaskGroupV2 - end"
                 )
 

fractal_server/tasks/v2/local/collect_pixi.py

@@ -0,0 +1,234 @@
+import json
+import shutil
+import time
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from ..utils_database import create_db_tasks_and_update_task_group_sync
+from ..utils_pixi import parse_collect_stdout
+from ..utils_pixi import SOURCE_DIR_NAME
+from fractal_server.app.db import get_sync_db
+from fractal_server.app.schemas.v2 import FractalUploadedFile
+from fractal_server.app.schemas.v2 import TaskGroupActivityActionV2
+from fractal_server.app.schemas.v2 import TaskGroupActivityStatusV2
+from fractal_server.app.schemas.v2.manifest import ManifestV2
+from fractal_server.config import get_settings
+from fractal_server.logger import reset_logger_handlers
+from fractal_server.logger import set_logger
+from fractal_server.syringe import Inject
+from fractal_server.tasks.utils import get_log_path
+from fractal_server.tasks.v2.local._utils import _customize_and_run_template
+from fractal_server.tasks.v2.local._utils import check_task_files_exist
+from fractal_server.tasks.v2.utils_background import add_commit_refresh
+from fractal_server.tasks.v2.utils_background import fail_and_cleanup
+from fractal_server.tasks.v2.utils_background import (
+    get_activity_and_task_group,
+)
+from fractal_server.tasks.v2.utils_background import get_current_log
+from fractal_server.tasks.v2.utils_background import prepare_tasks_metadata
+from fractal_server.tasks.v2.utils_templates import SCRIPTS_SUBFOLDER
+from fractal_server.utils import get_timestamp
+
+
+def collect_local_pixi(
+    *,
+    task_group_activity_id: int,
+    task_group_id: int,
+    tar_gz_file: FractalUploadedFile,
+) -> None:
+    settings = Inject(get_settings)
+
+    LOGGER_NAME = f"{__name__}.ID{task_group_activity_id}"
+
+    with TemporaryDirectory() as tmpdir:
+        log_file_path = get_log_path(Path(tmpdir))
+        logger = set_logger(
+            logger_name=LOGGER_NAME,
+            log_file_path=log_file_path,
+        )
+
+        with next(get_sync_db()) as db:
+            success, task_group, activity = get_activity_and_task_group(
+                task_group_activity_id=task_group_activity_id,
+                task_group_id=task_group_id,
+                db=db,
+            )
+            if not success:
+                return
+
+            logger.info("START")
+            for key, value in task_group.model_dump().items():
+                logger.debug(f"task_group.{key}: {value}")
+
+            if Path(task_group.path).exists():
+                error_msg = f"{task_group.path} already exists."
+                logger.error(error_msg)
+                fail_and_cleanup(
+                    task_group=task_group,
+                    task_group_activity=activity,
+                    logger_name=LOGGER_NAME,
+                    log_file_path=log_file_path,
+                    exception=FileExistsError(error_msg),
+                    db=db,
+                )
+                return
+
+            # Set `pixi_home`
+            pixi_home = settings.pixi.versions[task_group.pixi_version]
+
+            try:
+                Path(task_group.path).mkdir(parents=True)
+                logger.info(f"Created {task_group.path}")
+                archive_path = Path(
+                    task_group.path, tar_gz_file.filename
+                ).as_posix()
+                logger.info(f"Write tar.gz-file contents into {archive_path}.")
+                with open(archive_path, "wb") as f:
+                    f.write(tar_gz_file.contents)
+                task_group.archive_path = archive_path
+                task_group = add_commit_refresh(obj=task_group, db=db)
+
+                common_args = dict(
+                    replacements={
+                        ("__PIXI_HOME__", pixi_home),
+                        ("__PACKAGE_DIR__", task_group.path),
+                        ("__TAR_GZ_PATH__", archive_path),
+                        (
+                            "__IMPORT_PACKAGE_NAME__",
+                            task_group.pkg_name.replace("-", "_"),
+                        ),
+                        ("__SOURCE_DIR_NAME__", SOURCE_DIR_NAME),
+                    },
+                    script_dir=Path(
+                        task_group.path, SCRIPTS_SUBFOLDER
+                    ).as_posix(),
+                    prefix=(
+                        f"{int(time.time())}_"
+                        f"{TaskGroupActivityActionV2.COLLECT}_"
+                    ),
+                    logger_name=LOGGER_NAME,
+                )
+
+                activity.status = TaskGroupActivityStatusV2.ONGOING
+                activity.log = get_current_log(log_file_path)
+                activity = add_commit_refresh(obj=activity, db=db)
+
+                # Run script 1
+                _customize_and_run_template(
+                    template_filename="pixi_1_extract.sh",
+                    **common_args,
+                )
+                activity.log = get_current_log(log_file_path)
+                activity = add_commit_refresh(obj=activity, db=db)
+
+                # Run script 2
+                _customize_and_run_template(
+                    template_filename="pixi_2_install.sh",
+                    **common_args,
+                )
+                activity.log = get_current_log(log_file_path)
+                activity = add_commit_refresh(obj=activity, db=db)
+
+                # Run script 3
+                stdout = _customize_and_run_template(
+                    template_filename="pixi_3_post_install.sh",
+                    **common_args,
+                )
+                activity.log = get_current_log(log_file_path)
+                activity = add_commit_refresh(obj=activity, db=db)
+
+                # Parse stdout
+                parsed_output = parse_collect_stdout(stdout)
+                package_root = parsed_output["package_root"]
+                venv_size = parsed_output["venv_size"]
+                venv_file_number = parsed_output["venv_file_number"]
+                project_python_wrapper = parsed_output[
+                    "project_python_wrapper"
+                ]
+
+                # Read and validate manifest
+                # NOTE: we are only supporting the manifest path being relative
+                # to the top-level folder
+                manifest_path = f"{package_root}/__FRACTAL_MANIFEST__.json"
+                with open(manifest_path) as json_data:
+                    pkg_manifest_dict = json.load(json_data)
+                logger.info(f"loaded {manifest_path=}")
+                logger.info("now validating manifest content")
+                pkg_manifest = ManifestV2(**pkg_manifest_dict)
+                logger.info("validated manifest content")
+                activity.log = get_current_log(log_file_path)
+                activity = add_commit_refresh(obj=activity, db=db)
+
+                logger.info("_prepare_tasks_metadata - start")
+                task_list = prepare_tasks_metadata(
+                    package_manifest=pkg_manifest,
+                    package_version=task_group.version,
+                    package_root=Path(package_root),
+                    project_python_wrapper=Path(project_python_wrapper),
+                )
+                check_task_files_exist(task_list=task_list)
+                logger.info("_prepare_tasks_metadata - end")
+                activity.log = get_current_log(log_file_path)
+                activity = add_commit_refresh(obj=activity, db=db)
+
+                logger.info("create_db_tasks_and_update_task_group - start")
+                create_db_tasks_and_update_task_group_sync(
+                    task_list=task_list,
+                    task_group_id=task_group.id,
+                    db=db,
+                )
+                logger.info("create_db_tasks_and_update_task_group - end")
+
+                # Update task_group data
+                logger.info(
+                    "Add env_info, venv_size and venv_file_number "
+                    "to TaskGroupV2 - start"
+                )
+                with Path(
+                    task_group.path,
+                    SOURCE_DIR_NAME,
+                    "pixi.lock",
+                ).open() as f:
+                    pixi_lock_contents = f.read()
+
+                # NOTE: see issue 2626 about whether to keep `pixi.lock` files
+                # in the database
+                task_group.env_info = pixi_lock_contents
+                task_group.venv_size_in_kB = int(venv_size)
+                task_group.venv_file_number = int(venv_file_number)
+                task_group = add_commit_refresh(obj=task_group, db=db)
+                logger.info(
+                    "Add env_info, venv_size and venv_file_number "
+                    "to TaskGroupV2 - end"
+                )
+
+                # Finalize (write metadata to DB)
+                logger.info("finalising - START")
+                activity.status = TaskGroupActivityStatusV2.OK
+                activity.timestamp_ended = get_timestamp()
+                activity = add_commit_refresh(obj=activity, db=db)
+                logger.info("finalising - END")
+                logger.info("END")
+
+                reset_logger_handlers(logger)
+
+            except Exception as collection_e:
+                # Delete corrupted package dir
+                try:
+                    logger.info(f"Now delete folder {task_group.path}")
+                    shutil.rmtree(task_group.path)
+                    logger.info(f"Deleted folder {task_group.path}")
+                except Exception as rm_e:
+                    logger.error(
+                        "Removing folder failed.\n"
+                        f"Original error:\n{str(rm_e)}"
+                    )
+
+                fail_and_cleanup(
+                    task_group=task_group,
+                    task_group_activity=activity,
+                    logger_name=LOGGER_NAME,
+                    log_file_path=log_file_path,
+                    exception=collection_e,
+                    db=db,
+                )

fractal_server/tasks/v2/local/deactivate.py

@@ -1,4 +1,3 @@
-import logging
 import shutil
 import time
 from pathlib import Path
@@ -6,11 +5,10 @@ from tempfile import TemporaryDirectory
 
 from ..utils_background import add_commit_refresh
 from ..utils_background import fail_and_cleanup
+from ..utils_background import get_activity_and_task_group
 from ..utils_templates import get_collection_replacements
 from ._utils import _customize_and_run_template
 from fractal_server.app.db import get_sync_db
-from fractal_server.app.models.v2 import TaskGroupActivityV2
-from fractal_server.app.models.v2 import TaskGroupV2
 from fractal_server.app.schemas.v2 import TaskGroupActivityActionV2
 from fractal_server.app.schemas.v2 import TaskGroupV2OriginEnum
 from fractal_server.app.schemas.v2.task_group import TaskGroupActivityStatusV2
@@ -49,17 +47,12 @@ def deactivate_local(
         )
 
         with next(get_sync_db()) as db:
-
-            # Get main objects from db
-            activity = db.get(TaskGroupActivityV2, task_group_activity_id)
-            task_group = db.get(TaskGroupV2, task_group_id)
-            if activity is None or task_group is None:
-                # Use `logging` directly
-                logging.error(
-                    "Cannot find database rows with "
-                    f"{task_group_id=} and {task_group_activity_id=}:\n"
-                    f"{task_group=}\n{activity=}. Exit."
-                )
+            success, task_group, activity = get_activity_and_task_group(
+                task_group_activity_id=task_group_activity_id,
+                task_group_id=task_group_id,
+                db=db,
+            )
+            if not success:
                 return
 
             # Log some info
@@ -87,10 +80,10 @@ def deactivate_local(
                 activity.status = TaskGroupActivityStatusV2.ONGOING
                 activity = add_commit_refresh(obj=activity, db=db)
 
-                if task_group.pip_freeze is None:
+                if task_group.env_info is None:
                     logger.warning(
                         "Recreate pip-freeze information, since "
-                        f"{task_group.pip_freeze=}. NOTE: this should only "
+                        f"{task_group.env_info=}. NOTE: this should only "
                         "happen for task groups created before 2.9.0."
                     )
                     # Prepare replacements for templates
@@ -120,7 +113,7 @@ def deactivate_local(
                     logger.info("Add pip freeze stdout to TaskGroupV2 - start")
                     activity.log = get_current_log(log_file_path)
                     activity = add_commit_refresh(obj=activity, db=db)
-                    task_group.pip_freeze = pip_freeze_stdout
+                    task_group.env_info = pip_freeze_stdout
                     task_group = add_commit_refresh(obj=task_group, db=db)
                     logger.info("Add pip freeze stdout to TaskGroupV2 - end")
 
@@ -131,15 +124,15 @@ def deactivate_local(
                         f"Handle specific cases for {task_group.origin=}."
                     )
 
-                    # Blocking situation: `wheel_path` is not set or points
+                    # Blocking situation: `archive_path` is not set or points
                     # to a missing path
                     if (
-                        task_group.wheel_path is None
-                        or not Path(task_group.wheel_path).exists()
+                        task_group.archive_path is None
+                        or not Path(task_group.archive_path).exists()
                     ):
                         error_msg = (
                             "Invalid wheel path for task group with "
-                            f"{task_group_id=}. {task_group.wheel_path=} is "
+                            f"{task_group_id=}. {task_group.archive_path=} is "
                             "unset or does not exist."
                         )
                         logger.error(error_msg)
@@ -153,48 +146,52 @@ def deactivate_local(
                         )
                         return
 
-                    # Recoverable situation: `wheel_path` was not yet copied
+                    # Recoverable situation: `archive_path` was not yet copied
                     # over to the correct server-side folder
-                    wheel_path_parent_dir = Path(task_group.wheel_path).parent
-                    if wheel_path_parent_dir != Path(task_group.path):
+                    archive_path_parent_dir = Path(
+                        task_group.archive_path
+                    ).parent
+                    if archive_path_parent_dir != Path(task_group.path):
                         logger.warning(
-                            f"{wheel_path_parent_dir.as_posix()} differs from "
-                            f"{task_group.path}. NOTE: this should only "
+                            f"{archive_path_parent_dir.as_posix()} differs "
+                            f"from {task_group.path}. NOTE: this should only "
                             "happen for task groups created before 2.9.0."
                         )
 
-                        if task_group.wheel_path not in task_group.pip_freeze:
+                        if task_group.archive_path not in task_group.env_info:
                             raise ValueError(
-                                f"Cannot find {task_group.wheel_path=} in "
+                                f"Cannot find {task_group.archive_path=} in "
                                 "pip-freeze data. Exit."
                             )
 
                         logger.info(
                             f"Now copy wheel file into {task_group.path}."
                         )
-                        new_wheel_path = (
+                        new_archive_path = (
                             Path(task_group.path)
-                            / Path(task_group.wheel_path).name
+                            / Path(task_group.archive_path).name
                         ).as_posix()
-                        shutil.copy(task_group.wheel_path, new_wheel_path)
-                        logger.info(f"Copied wheel file to {new_wheel_path}.")
+                        shutil.copy(task_group.archive_path, new_archive_path)
+                        logger.info(
+                            f"Copied wheel file to {new_archive_path}."
+                        )
 
-                        task_group.wheel_path = new_wheel_path
-                        new_pip_freeze = task_group.pip_freeze.replace(
-                            task_group.wheel_path,
-                            new_wheel_path,
+                        task_group.archive_path = new_archive_path
+                        new_pip_freeze = task_group.env_info.replace(
+                            task_group.archive_path,
+                            new_archive_path,
                         )
-                        task_group.pip_freeze = new_pip_freeze
+                        task_group.env_info = new_pip_freeze
                         task_group = add_commit_refresh(obj=task_group, db=db)
                         logger.info(
-                            "Updated `wheel_path` and `pip_freeze` "
+                            "Updated `archive_path` and `env_info` "
                             "task-group attributes."
                         )
 
                 # Fail if `pip_freeze` includes "github.com", see
                 # https://github.com/fractal-analytics-platform/fractal-server/issues/2142
                 for forbidden_string in FORBIDDEN_DEPENDENCY_STRINGS:
-                    if forbidden_string in task_group.pip_freeze:
+                    if forbidden_string in task_group.env_info:
                         raise ValueError(
                             "Deactivation and reactivation of task packages "
                             f"with direct {forbidden_string} dependencies "

fractal_server/tasks/v2/local/deactivate_pixi.py

@@ -0,0 +1,102 @@
+import shutil
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from ..utils_background import add_commit_refresh
+from ..utils_background import fail_and_cleanup
+from ..utils_background import get_activity_and_task_group
+from ..utils_pixi import SOURCE_DIR_NAME
+from fractal_server.app.db import get_sync_db
+from fractal_server.app.schemas.v2.task_group import TaskGroupActivityStatusV2
+from fractal_server.logger import reset_logger_handlers
+from fractal_server.logger import set_logger
+from fractal_server.tasks.utils import get_log_path
+from fractal_server.tasks.v2.utils_background import get_current_log
+from fractal_server.utils import get_timestamp
+
+
+def deactivate_local_pixi(
+    *,
+    task_group_activity_id: int,
+    task_group_id: int,
+) -> None:
+    """
+    Deactivate a pixi task group venv.
+
+    This function is run as a background task, therefore exceptions must be
+    handled.
+
+    Arguments:
+        task_group_id:
+        task_group_activity_id:
+    """
+
+    LOGGER_NAME = f"{__name__}.ID{task_group_activity_id}"
+
+    with TemporaryDirectory() as tmpdir:
+        log_file_path = get_log_path(Path(tmpdir))
+        logger = set_logger(
+            logger_name=LOGGER_NAME,
+            log_file_path=log_file_path,
+        )
+
+        with next(get_sync_db()) as db:
+            success, task_group, activity = get_activity_and_task_group(
+                task_group_activity_id=task_group_activity_id,
+                task_group_id=task_group_id,
+                db=db,
+            )
+            if not success:
+                return
+
+            # Log some info
+            logger.debug("START")
+
+            for key, value in task_group.model_dump().items():
+                logger.debug(f"task_group.{key}: {value}")
+
+            source_dir = Path(task_group.path, SOURCE_DIR_NAME)
+            if not source_dir.exists():
+                error_msg = f"'{source_dir.as_posix()}' does not exist."
+                logger.error(error_msg)
+                fail_and_cleanup(
+                    task_group=task_group,
+                    task_group_activity=activity,
+                    logger_name=LOGGER_NAME,
+                    log_file_path=log_file_path,
+                    exception=FileNotFoundError(error_msg),
+                    db=db,
+                )
+                return
+
+            try:
+
+                activity.status = TaskGroupActivityStatusV2.ONGOING
+                activity = add_commit_refresh(obj=activity, db=db)
+
+                # Actually mark the task group as non-active
+                logger.info("Now setting `active=False`.")
+                task_group.active = False
+                task_group = add_commit_refresh(obj=task_group, db=db)
+
+                # Proceed with deactivation
+                logger.info(f"Now removing '{source_dir.as_posix()}'.")
+                shutil.rmtree(source_dir)
+                logger.info(f"All good, '{source_dir.as_posix()}' removed.")
+                activity.status = TaskGroupActivityStatusV2.OK
+                activity.log = get_current_log(log_file_path)
+                activity.timestamp_ended = get_timestamp()
+                activity = add_commit_refresh(obj=activity, db=db)
+
+                reset_logger_handlers(logger)
+
+            except Exception as e:
+                fail_and_cleanup(
+                    task_group=task_group,
+                    task_group_activity=activity,
+                    logger_name=LOGGER_NAME,
+                    log_file_path=log_file_path,
+                    exception=e,
+                    db=db,
+                )
+        return