fractal-server 2.14.4a0__tar.gz → 2.14.5__tar.gz

{fractal_server-2.14.4a0 → fractal_server-2.14.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fractal-server
-Version: 2.14.4a0
+Version: 2.14.5
 Summary: Backend component of the Fractal analytics platform
 License: BSD-3-Clause
 Author: Tommaso Comparin
@@ -12,7 +12,6 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: alembic (>=1.13.1,<2.0.0)
-Requires-Dist: cloudpickle (>=3.1.0,<3.2.0)
 Requires-Dist: cryptography (>=44.0.1,<44.1.0)
 Requires-Dist: fabric (>=3.2.2,<3.3.0)
 Requires-Dist: fastapi (>=0.115.0,<0.116.0)
@@ -65,8 +64,3 @@ Fractal was conceived in the Liberali Lab at the Friedrich Miescher Institute fo
 
 Unless otherwise specified, Fractal components are released under the BSD 3-Clause License, and copyright is with the BioVisionCenter at the University of Zurich.
 
-The SLURM compatibility layer is based on
-[`clusterfutures`](https://github.com/sampsyo/clusterfutures), by
-[@sampsyo](https://github.com/sampsyo) and collaborators, and it is released
-under the terms of the MIT license.
-

{fractal_server-2.14.4a0 → fractal_server-2.14.5}/README.md

@@ -29,8 +29,3 @@ See https://fractal-analytics-platform.github.io/fractal-server.
 Fractal was conceived in the Liberali Lab at the Friedrich Miescher Institute for Biomedical Research and in the Pelkmans Lab at the University of Zurich by [@jluethi](https://github.com/jluethi) and [@gusqgm](https://github.com/gusqgm). The Fractal project is now developed at the [BioVisionCenter](https://www.biovisioncenter.uzh.ch/en.html) at the University of Zurich and the project lead is with [@jluethi](https://github.com/jluethi). The core development is done under contract by [eXact lab S.r.l.](https://www.exact-lab.it).
 
 Unless otherwise specified, Fractal components are released under the BSD 3-Clause License, and copyright is with the BioVisionCenter at the University of Zurich.
-
-The SLURM compatibility layer is based on
-[`clusterfutures`](https://github.com/sampsyo/clusterfutures), by
-[@sampsyo](https://github.com/sampsyo) and collaborators, and it is released
-under the terms of the MIT license.

fractal_server-2.14.5/fractal_server/__init__.py

@@ -0,0 +1 @@
+__VERSION__ = "2.14.5"

{fractal_server-2.14.4a0 → fractal_server-2.14.5}/fractal_server/app/runner/exceptions.py

@@ -46,12 +46,7 @@ class JobExecutionError(RuntimeError):
     Forwards errors in the execution of a task that are due to external factors
 
     This error wraps and forwards errors occurred during the execution of
-    tasks, but related to external factors like:
-
-    1. A negative exit code (e.g. because the task received a TERM or KILL
-       signal);
-    2. An error on the executor side (e.g. the SLURM executor could not
-       find the pickled file with task output).
+    tasks, but related to external factors like an error on the executor side.
 
     This error also adds information that is useful to track down and debug the
     failing task within a workflow.

{fractal_server-2.14.4a0 → fractal_server-2.14.5}/fractal_server/app/runner/executors/base_runner.py

@@ -26,7 +26,10 @@ class BaseRunner(object):
 
     def submit(
         self,
-        func: callable,
+        base_command: str,
+        workflow_task_order: int,
+        workflow_task_id: int,
+        task_name: str,
         parameters: dict[str, Any],
         history_unit_id: int,
         task_type: TaskTypeType,
@@ -38,7 +41,10 @@ class BaseRunner(object):
         Run a single fractal task.
 
         Args:
-            func: Function to be executed.
+            base_command:
+            workflow_task_order:
+            workflow_task_id:
+            task_name:
             parameters: Dictionary of parameters.
             history_unit_id:
                 Database ID of the corresponding `HistoryUnit` entry.
@@ -51,7 +57,10 @@ class BaseRunner(object):
 
     def multisubmit(
         self,
-        func: callable,
+        base_command: str,
+        workflow_task_order: int,
+        workflow_task_id: int,
+        task_name: str,
         list_parameters: list[dict[str, Any]],
         history_unit_ids: list[int],
         list_task_files: list[TaskFiles],
@@ -63,7 +72,10 @@ class BaseRunner(object):
         Run a parallel fractal task.
 
         Args:
-            func: Function to be executed.
+            base_command:
+            workflow_task_order:
+            workflow_task_id:
+            task_name:
             parameters:
                 Dictionary of parameters. Must include `zarr_urls` key.
             history_unit_ids:

fractal_server-2.14.5/fractal_server/app/runner/executors/call_command_wrapper.py

@@ -0,0 +1,52 @@
+import os
+import shlex
+import shutil
+import subprocess  # nosec
+
+from fractal_server.app.runner.exceptions import TaskExecutionError
+from fractal_server.string_tools import validate_cmd
+
+
+def call_command_wrapper(*, cmd: str, log_path: str) -> None:
+    """
+    Call a command and write its stdout and stderr to files
+
+    Args:
+        cmd:
+        log_path:
+    """
+    try:
+        validate_cmd(cmd)
+    except ValueError as e:
+        raise TaskExecutionError(f"Invalid command. Original error: {str(e)}")
+
+    split_cmd = shlex.split(cmd)
+
+    # Verify that task command is executable
+    if shutil.which(split_cmd[0]) is None:
+        msg = (
+            f'Command "{split_cmd[0]}" is not valid. '
+            "Hint: make sure that it is executable."
+        )
+        raise TaskExecutionError(msg)
+
+    with open(log_path, "w") as fp_log:
+        try:
+            result = subprocess.run(  # nosec
+                split_cmd,
+                stderr=fp_log,
+                stdout=fp_log,
+            )
+        except Exception as e:
+            # This is likely unreachable
+            raise e
+
+    if result.returncode != 0:
+        stderr = ""
+        if os.path.isfile(log_path):
+            with open(log_path, "r") as fp_stderr:
+                stderr = fp_stderr.read()
+        raise TaskExecutionError(
+            f"Task failed with returncode={result.returncode}.\n"
+            f"STDERR: {stderr}"
+        )

{fractal_server-2.14.4a0 → fractal_server-2.14.5}/fractal_server/app/runner/executors/local/runner.py

@@ -1,9 +1,11 @@
+import json
 from concurrent.futures import Future
 from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
 from typing import Any
 from typing import Literal
 
+from ..call_command_wrapper import call_command_wrapper
 from .get_local_config import LocalBackendConfig
 from fractal_server.app.db import get_sync_db
 from fractal_server.app.runner.exceptions import TaskExecutionError
@@ -16,10 +18,40 @@ from fractal_server.app.runner.v2.db_tools import update_status_of_history_unit
 from fractal_server.app.schemas.v2 import HistoryUnitStatus
 from fractal_server.logger import set_logger
 
-
 logger = set_logger(__name__)
 
 
+def run_single_task(
+    base_command: str,
+    parameters: dict[str, Any],
+    task_files: TaskFiles,
+):
+
+    # Write args.json file
+    with open(task_files.args_file_local, "w") as f:
+        json.dump(parameters, f)
+
+    # Run command
+    full_command = (
+        f"{base_command} "
+        f"--args-json {task_files.args_file_local} "
+        f"--out-json {task_files.metadiff_file_local}"
+    )
+
+    call_command_wrapper(
+        cmd=full_command,
+        log_path=task_files.log_file_local,
+    )
+
+    try:
+        with open(task_files.metadiff_file_local, "r") as f:
+            out_meta = json.load(f)
+        return out_meta
+    except FileNotFoundError:
+        # Command completed, but it produced no metadiff file
+        return None
+
+
 class LocalRunner(BaseRunner):
     executor: ThreadPoolExecutor
     root_dir_local: Path
@@ -47,17 +79,20 @@ class LocalRunner(BaseRunner):
 
     def submit(
         self,
-        func: callable,
+        base_command: str,
+        workflow_task_order: int,
+        workflow_task_id: int,
+        task_name: str,
         parameters: dict[str, Any],
         history_unit_id: int,
         task_files: TaskFiles,
+        config: LocalBackendConfig,
         task_type: Literal[
             "non_parallel",
             "converter_non_parallel",
             "compound",
             "converter_compound",
         ],
-        config: LocalBackendConfig,
         user_id: int,
     ) -> tuple[Any, Exception]:
         logger.debug("[submit] START")
@@ -69,9 +104,10 @@ class LocalRunner(BaseRunner):
 
             # SUBMISSION PHASE
             future = self.executor.submit(
-                func,
+                run_single_task,
+                base_command=base_command,
                 parameters=parameters,
-                remote_files=task_files.remote_files_dict,
+                task_files=task_files,
             )
         except Exception as e:
             logger.error(
@@ -111,7 +147,10 @@ class LocalRunner(BaseRunner):
 
     def multisubmit(
         self,
-        func: callable,
+        base_command: str,
+        workflow_task_order: int,
+        workflow_task_id: int,
+        task_name: str,
         list_parameters: list[dict],
         history_unit_ids: list[int],
         list_task_files: list[TaskFiles],
@@ -139,8 +178,9 @@ class LocalRunner(BaseRunner):
             )
 
             workdir_local = list_task_files[0].wftask_subfolder_local
-            if task_type == "parallel":
-                workdir_local.mkdir()
+            # Note: the `mkdir` is not needed for compound tasks, but it is
+            # needed for parallel tasks
+            workdir_local.mkdir(exist_ok=True)
 
             # Set `n_elements` and `parallel_tasks_per_job`
             n_elements = len(list_parameters)
@@ -178,11 +218,10 @@ class LocalRunner(BaseRunner):
                 positional_index = ind_chunk + ind_within_chunk
                 try:
                     future = self.executor.submit(
-                        func,
-                        parameters=kwargs,
-                        remote_files=list_task_files[
-                            positional_index
-                        ].remote_files_dict,
+                        run_single_task,
+                        base_command=base_command,
+                        parameters=list_parameters[positional_index],
+                        task_files=list_task_files[positional_index],
                     )
                     active_futures[positional_index] = future
                 except Exception as e:

{fractal_server-2.14.4a0 → fractal_server-2.14.5}/fractal_server/app/runner/executors/slurm_common/base_slurm_runner.py

@@ -7,7 +7,8 @@ from typing import Any
 from typing import Literal
 from typing import Optional
 
-import cloudpickle
+from pydantic import BaseModel
+from pydantic import ConfigDict
 
 from ..slurm_common._slurm_config import SlurmConfig
 from ..slurm_common.slurm_job_task_models import SlurmJob
@@ -36,6 +37,17 @@ SHUTDOWN_EXCEPTION = JobExecutionError(SHUTDOWN_ERROR_MESSAGE)
 logger = set_logger(__name__)
 
 
+class RemoteInputData(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    python_version: tuple[int, int, int]
+    fractal_server_version: str
+    full_command: str
+
+    metadiff_file_remote: str
+    log_file_remote: str
+
+
 def create_accounting_record_slurm(
     *,
     user_id: int,
@@ -121,7 +133,6 @@ class BaseSlurmRunner(BaseRunner):
         raise NotImplementedError("Implement in child class.")
 
     def _get_finished_jobs(self, job_ids: list[str]) -> set[str]:
-
         #  If there is no Slurm job to check, return right away
         if not job_ids:
             return set()
@@ -168,58 +179,74 @@ class BaseSlurmRunner(BaseRunner):
 
     def _submit_single_sbatch(
         self,
-        func,
+        *,
+        base_command: str,
         slurm_job: SlurmJob,
         slurm_config: SlurmConfig,
     ) -> str:
         logger.debug("[_submit_single_sbatch] START")
-        # Prepare input pickle(s)
-        versions = dict(
-            python=sys.version_info[:3],
-            cloudpickle=cloudpickle.__version__,
-            fractal_server=__VERSION__,
-        )
+
         for task in slurm_job.tasks:
-            # Write input pickle
-            _args = []
-            _kwargs = dict(
-                parameters=task.parameters,
-                remote_files=task.task_files.remote_files_dict,
+            # Write input file
+            if self.slurm_runner_type == "ssh":
+                args_file_remote = task.task_files.args_file_remote
+            else:
+                args_file_remote = task.task_files.args_file_local
+            metadiff_file_remote = task.task_files.metadiff_file_remote
+            full_command = (
+                f"{base_command} "
+                f"--args-json {args_file_remote} "
+                f"--out-json {metadiff_file_remote}"
             )
-            funcser = cloudpickle.dumps((versions, func, _args, _kwargs))
-            with open(task.input_pickle_file_local, "wb") as f:
-                f.write(funcser)
+
+            input_data = RemoteInputData(
+                full_command=full_command,
+                python_version=sys.version_info[:3],
+                fractal_server_version=__VERSION__,
+                metadiff_file_remote=task.task_files.metadiff_file_remote,
+                log_file_remote=task.task_files.log_file_remote,
+            )
+
+            with open(task.input_file_local, "w") as f:
+                json.dump(input_data.model_dump(), f, indent=2)
+
+            with open(task.task_files.args_file_local, "w") as f:
+                json.dump(task.parameters, f, indent=2)
+
             logger.debug(
-                "[_submit_single_sbatch] Written "
-                f"{task.input_pickle_file_local=}"
+                "[_submit_single_sbatch] Written " f"{task.input_file_local=}"
             )
 
             if self.slurm_runner_type == "ssh":
-                # Send input pickle (only relevant for SSH)
+                # Send input file (only relevant for SSH)
                 self.fractal_ssh.send_file(
-                    local=task.input_pickle_file_local,
-                    remote=task.input_pickle_file_remote,
+                    local=task.input_file_local,
+                    remote=task.input_file_remote,
+                )
+                self.fractal_ssh.send_file(
+                    local=task.task_files.args_file_local,
+                    remote=task.task_files.args_file_remote,
                 )
                 logger.debug(
                     "[_submit_single_sbatch] Transferred "
-                    f"{task.input_pickle_file_local=}"
+                    f"{task.input_file_local=}"
                 )
 
         # Prepare commands to be included in SLURM submission script
         cmdlines = []
         for task in slurm_job.tasks:
             if self.slurm_runner_type == "ssh":
-                input_pickle_file = task.input_pickle_file_remote
+                input_file = task.input_file_remote
             else:
-                input_pickle_file = task.input_pickle_file_local
-            output_pickle_file = task.output_pickle_file_remote
+                input_file = task.input_file_local
+            output_file = task.output_file_remote
             cmdlines.append(
                 (
                     f"{self.python_worker_interpreter}"
                     " -m fractal_server.app.runner."
                     "executors.slurm_common.remote "
-                    f"--input-file {input_pickle_file} "
-                    f"--output-file {output_pickle_file}"
+                    f"--input-file {input_file} "
+                    f"--output-file {output_file}"
                 )
             )
 
@@ -363,12 +390,12 @@ class BaseSlurmRunner(BaseRunner):
         was_job_scancelled: bool = False,
     ) -> tuple[Any, Exception]:
         try:
-            with open(task.output_pickle_file_local, "rb") as f:
-                outdata = f.read()
-            success, output = cloudpickle.loads(outdata)
+            with open(task.output_file_local, "r") as f:
+                output = json.load(f)
+            success = output[0]
             if success:
                 # Task succeeded
-                result = output
+                result = output[1]
                 return (result, None)
             else:
                 # Task failed in a controlled way, and produced an `output`
@@ -376,21 +403,18 @@ class BaseSlurmRunner(BaseRunner):
                 # `exc_type_name` and `traceback_string` and with optional
                 # keys `workflow_task_order`, `workflow_task_id` and
                 # `task_name`.
-                exc_type_name = output.get("exc_type_name")
+                exc_proxy = output[1]
+                exc_type_name = exc_proxy.get("exc_type_name")
                 logger.debug(
-                    f"Output pickle contains a '{exc_type_name}' exception."
+                    f"Output file contains a '{exc_type_name}' exception."
+                )
+                traceback_string = output[1].get("traceback_string")
+                exception = TaskExecutionError(
+                    traceback_string,
+                    workflow_task_id=task.workflow_task_id,
+                    workflow_task_order=task.workflow_task_order,
+                    task_name=task.task_name,
                 )
-                traceback_string = output.get("traceback_string")
-                kwargs = {
-                    key: output[key]
-                    for key in [
-                        "workflow_task_order",
-                        "workflow_task_id",
-                        "task_name",
-                    ]
-                    if key in output.keys()
-                }
-                exception = TaskExecutionError(traceback_string, **kwargs)
                 return (None, exception)
 
         except Exception as e:
@@ -405,8 +429,8 @@ class BaseSlurmRunner(BaseRunner):
                 exception = SHUTDOWN_EXCEPTION
             return (None, exception)
         finally:
-            Path(task.input_pickle_file_local).unlink(missing_ok=True)
-            Path(task.output_pickle_file_local).unlink(missing_ok=True)
+            Path(task.input_file_local).unlink(missing_ok=True)
+            Path(task.output_file_local).unlink(missing_ok=True)
 
     def is_shutdown(self) -> bool:
         return self.shutdown_file.exists()
@@ -451,7 +475,10 @@ class BaseSlurmRunner(BaseRunner):
 
     def submit(
         self,
-        func: callable,
+        base_command: str,
+        workflow_task_order: int,
+        workflow_task_id: int,
+        task_name: str,
         parameters: dict[str, Any],
         history_unit_id: int,
         task_files: TaskFiles,
@@ -507,13 +534,16 @@ class BaseSlurmRunner(BaseRunner):
                         workdir_remote=workdir_remote,
                         workdir_local=workdir_local,
                         task_files=task_files,
+                        workflow_task_order=workflow_task_order,
+                        workflow_task_id=workflow_task_id,
+                        task_name=task_name,
                     )
                 ],
             )
 
             config.parallel_tasks_per_job = 1
             self._submit_single_sbatch(
-                func,
+                base_command=base_command,
                 slurm_job=slurm_job,
                 slurm_config=config,
             )
@@ -586,7 +616,10 @@ class BaseSlurmRunner(BaseRunner):
 
     def multisubmit(
         self,
-        func: callable,
+        base_command: str,
+        workflow_task_order: int,
+        workflow_task_id: int,
+        task_name: str,
         list_parameters: list[dict],
         history_unit_ids: list[int],
         list_task_files: list[TaskFiles],
@@ -602,7 +635,6 @@ class BaseSlurmRunner(BaseRunner):
 
         logger.debug(f"[multisubmit] START, {len(list_parameters)=}")
         try:
-
             if self.is_shutdown():
                 if task_type == "parallel":
                     with next(get_sync_db()) as db:
@@ -672,6 +704,9 @@ class BaseSlurmRunner(BaseRunner):
                             parameters=parameters,
                             zarr_url=parameters["zarr_url"],
                             task_files=list_task_files[index],
+                            workflow_task_order=workflow_task_order,
+                            workflow_task_id=workflow_task_id,
+                            task_name=task_name,
                         ),
                     )
                 jobs_to_submit.append(
@@ -687,7 +722,7 @@ class BaseSlurmRunner(BaseRunner):
             logger.debug("[multisubmit] Transfer files and submit jobs.")
             for slurm_job in jobs_to_submit:
                 self._submit_single_sbatch(
-                    func,
+                    base_command=base_command,
                     slurm_job=slurm_job,
                     slurm_config=config,
                 )

fractal_server-2.14.5/fractal_server/app/runner/executors/slurm_common/remote.py

@@ -0,0 +1,125 @@
+import argparse
+import json
+import logging
+import os
+import sys
+
+from ..call_command_wrapper import call_command_wrapper
+from fractal_server import __VERSION__
+
+
+class FractalVersionMismatch(RuntimeError):
+    """
+    Custom exception for version mismatch
+    """
+
+    pass
+
+
+def worker(
+    *,
+    in_fname: str,
+    out_fname: str,
+) -> None:
+    """
+    Execute a job, possibly on a remote node.
+
+    Arguments:
+        in_fname: Absolute path to the input file (must be readable).
+        out_fname: Absolute path of the output file (must be writeable).
+    """
+
+    # Create output folder, if missing
+    out_dir = os.path.dirname(out_fname)
+    if not os.path.exists(out_dir):
+        logging.debug(f"_slurm.remote.worker: create {out_dir=}")
+        os.mkdir(out_dir)
+
+    # Execute the job and capture exceptions
+    try:
+        with open(in_fname, "r") as f:
+            input_data = json.load(f)
+
+        server_python_version = input_data["python_version"]
+        server_fractal_server_version = input_data["fractal_server_version"]
+
+        # Fractal-server version must be identical
+        worker_fractal_server_version = __VERSION__
+        if worker_fractal_server_version != server_fractal_server_version:
+            raise FractalVersionMismatch(
+                f"{server_fractal_server_version=} but "
+                f"{worker_fractal_server_version=}"
+            )
+
+        # Python version mismatch only raises a warning
+        worker_python_version = tuple(sys.version_info[:3])
+        if worker_python_version != server_python_version:
+            if worker_python_version[:2] != server_python_version[:2]:
+                logging.warning(
+                    f"{server_python_version=} but {worker_python_version=}."
+                )
+
+        # Extract some useful paths
+        metadiff_file_remote = input_data["metadiff_file_remote"]
+        log_path = input_data["log_file_remote"]
+
+        # Execute command
+        full_command = input_data["full_command"]
+        call_command_wrapper(cmd=full_command, log_path=log_path)
+
+        try:
+            with open(metadiff_file_remote, "r") as f:
+                out_meta = json.load(f)
+            result = (True, out_meta)
+        except FileNotFoundError:
+            # Command completed, but it produced no metadiff file
+            result = (True, None)
+
+    except Exception as e:
+        # Exception objects are not serialisable. Here we save the relevant
+        # exception contents in a serializable dictionary. Note that whenever
+        # the task failed "properly", the exception is a `TaskExecutionError`
+        # and it has additional attributes.
+        import traceback
+
+        exc_type, exc_value, traceback_obj = sys.exc_info()
+        traceback_obj = traceback_obj.tb_next
+        traceback_list = traceback.format_exception(
+            exc_type,
+            exc_value,
+            traceback_obj,
+        )
+        traceback_string = "".join(traceback_list)
+        exc_proxy = dict(
+            exc_type_name=type(e).__name__,
+            traceback_string=traceback_string,
+        )
+        result = (False, exc_proxy)
+
+    # Write output file
+    with open(out_fname, "w") as f:
+        json.dump(result, f, indent=2)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--input-file",
+        type=str,
+        help="Path of input JSON file",
+        required=True,
+    )
+    parser.add_argument(
+        "--output-file",
+        type=str,
+        help="Path of output JSON file",
+        required=True,
+    )
+    parsed_args = parser.parse_args()
+    logging.debug(f"{parsed_args=}")
+
+    kwargs = dict(
+        in_fname=parsed_args.input_file,
+        out_fname=parsed_args.output_file,
+    )
+    worker(**kwargs)