fractal-server 2.3.3__tar.gz → 2.3.5__tar.gz

{fractal_server-2.3.3 → fractal_server-2.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fractal-server
-Version: 2.3.3
+Version: 2.3.5
 Summary: Server component of the Fractal analytics platform
 Home-page: https://github.com/fractal-analytics-platform/fractal-server
 License: BSD-3-Clause

fractal_server-2.3.5/fractal_server/__init__.py

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

{fractal_server-2.3.3 → fractal_server-2.3.5}/fractal_server/app/routes/api/__init__.py

@@ -2,9 +2,12 @@
 `api` module
 """
 from fastapi import APIRouter
+from fastapi import Depends
 
 from ....config import get_settings
 from ....syringe import Inject
+from ...models.security import UserOAuth
+from ...security import current_active_superuser
 
 
 router_api = APIRouter()
@@ -17,3 +20,9 @@ async def alive():
         alive=True,
         version=settings.PROJECT_VERSION,
     )
+
+
+@router_api.get("/settings/")
+async def view_settings(user: UserOAuth = Depends(current_active_superuser)):
+    settings = Inject(get_settings)
+    return settings.get_sanitized()

{fractal_server-2.3.3 → fractal_server-2.3.5}/fractal_server/app/routes/api/v1/project.py

@@ -250,9 +250,18 @@ async def apply_workflow(
     db: AsyncSession = Depends(get_async_db),
 ) -> Optional[ApplyWorkflowReadV1]:
 
+    settings = Inject(get_settings)
+    if settings.FRACTAL_API_V1_MODE == "include_without_submission":
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                "Legacy API is still accessible, "
+                "but the submission of legacy jobs is not available."
+            ),
+        )
+
     # Remove non-submitted V1 jobs from the app state when the list grows
     # beyond a threshold
-    settings = Inject(get_settings)
     if (
         len(request.app.state.jobsV1)
         > settings.FRACTAL_API_MAX_JOB_LIST_LENGTH

fractal_server-2.3.5/fractal_server/app/runner/compress_folder.py

@@ -0,0 +1,132 @@
+"""
+Wrap `tar` compression command.
+
+This module is used both locally (in the environment where `fractal-server`
+is running) and remotely (as a standalon Python module, executed over SSH).
+
+This is a twin-module of `extract_archive.py`.
+
+The reason for using the `tar` command via `subprocess` rather than Python
+built-in `tarfile` library has to do with performance issues we observed
+when handling files which were just created within a SLURM job, and in the
+context of a CephFS filesystem.
+"""
+import shutil
+import sys
+from pathlib import Path
+
+from fractal_server.app.runner.run_subprocess import run_subprocess
+from fractal_server.logger import get_logger
+from fractal_server.logger import set_logger
+
+
+def copy_subfolder(src: Path, dest: Path, logger_name: str):
+    cmd_cp = f"cp -r {src.as_posix()} {dest.as_posix()}"
+    logger = get_logger(logger_name=logger_name)
+    logger.debug(f"{cmd_cp=}")
+    res = run_subprocess(cmd=cmd_cp, logger_name=logger_name)
+    return res
+
+
+def create_tar_archive(
+    tarfile_path: Path,
+    subfolder_path_tmp_copy: Path,
+    logger_name: str,
+    remote_to_local: bool,
+):
+    logger = get_logger(logger_name)
+
+    if remote_to_local:
+        exclude_options = "--exclude *sbatch --exclude *_in_*.pickle "
+    else:
+        exclude_options = ""
+
+    cmd_tar = (
+        f"tar czf {tarfile_path} "
+        f"{exclude_options} "
+        f"--directory={subfolder_path_tmp_copy.as_posix()} "
+        "."
+    )
+    logger.debug(f"cmd tar:\n{cmd_tar}")
+    run_subprocess(cmd=cmd_tar, logger_name=logger_name)
+
+
+def remove_temp_subfolder(subfolder_path_tmp_copy: Path, logger_name: str):
+    logger = get_logger(logger_name)
+    try:
+        logger.debug(f"Now remove {subfolder_path_tmp_copy}")
+        shutil.rmtree(subfolder_path_tmp_copy)
+    except Exception as e:
+        logger.debug(f"ERROR during shutil.rmtree: {e}")
+
+
+def compress_folder(
+    subfolder_path: Path, remote_to_local: bool = False
+) -> str:
+    """
+    Compress e.g. `/path/archive` into `/path/archive.tar.gz`
+
+    Note that `/path/archive.tar.gz` may already exist. In this case, it will
+    be overwritten.
+
+    Args:
+        subfolder_path: Absolute path to the folder to compress.
+        remote_to_local: If `True`, exclude some files from the tar.gz archive.
+
+    Returns:
+        Absolute path to the tar.gz archive.
+    """
+
+    logger_name = "compress_folder"
+    logger = set_logger(logger_name)
+
+    logger.debug("START")
+    logger.debug(f"{subfolder_path=}")
+    parent_dir = subfolder_path.parent
+    subfolder_name = subfolder_path.name
+    tarfile_path = (parent_dir / f"{subfolder_name}.tar.gz").as_posix()
+    logger.debug(f"{tarfile_path=}")
+
+    subfolder_path_tmp_copy = (
+        subfolder_path.parent / f"{subfolder_path.name}_copy"
+    )
+    try:
+        copy_subfolder(
+            subfolder_path, subfolder_path_tmp_copy, logger_name=logger_name
+        )
+        create_tar_archive(
+            tarfile_path,
+            subfolder_path_tmp_copy,
+            logger_name=logger_name,
+            remote_to_local=remote_to_local,
+        )
+        return tarfile_path
+
+    except Exception as e:
+        logger.debug(f"ERROR: {e}")
+        sys.exit(1)
+
+    finally:
+        remove_temp_subfolder(subfolder_path_tmp_copy, logger_name=logger_name)
+
+
+def main(sys_argv: list[str]):
+
+    help_msg = (
+        "Expected use:\n"
+        "python -m fractal_server.app.runner.compress_folder "
+        "path/to/folder [--remote-to-local]\n"
+    )
+    num_args = len(sys_argv[1:])
+    if num_args == 0:
+        sys.exit(f"Invalid argument.\n{help_msg}\nProvided: {sys_argv[1:]=}")
+    elif num_args == 1:
+        compress_folder(subfolder_path=Path(sys_argv[1]))
+    elif num_args == 2 and sys_argv[2] == "--remote-to-local":
+        compress_folder(subfolder_path=Path(sys_argv[1]), remote_to_local=True)
+    else:
+        sys.exit(f"Invalid argument.\n{help_msg}\nProvided: {sys_argv[1:]=}")
+
+
+if __name__ == "__main__":
+    main(sys.argv)

{fractal_server-2.3.3 → fractal_server-2.3.5}/fractal_server/app/runner/executors/slurm/_slurm_config.py

@@ -62,6 +62,8 @@ class _SlurmConfigSet(BaseModel, extra=Extra.forbid):
     time: Optional[str]
     account: Optional[str]
     extra_lines: Optional[list[str]]
+    pre_submission_commands: Optional[list[str]]
+    gpus: Optional[str]
 
 
 class _BatchingConfigSet(BaseModel, extra=Extra.forbid):
@@ -219,6 +221,7 @@ class SlurmConfig(BaseModel, extra=Extra.forbid):
         constraint: Corresponds to SLURM option.
         gres: Corresponds to SLURM option.
         account: Corresponds to SLURM option.
+        gpus: Corresponds to SLURM option.
         time: Corresponds to SLURM option (WARNING: not fully supported).
         prefix: Prefix of configuration lines in SLURM submission scripts.
         shebang_line: Shebang line for SLURM submission scripts.
@@ -240,6 +243,8 @@ class SlurmConfig(BaseModel, extra=Extra.forbid):
             Key-value pairs to be included as `export`-ed variables in SLURM
             submission script, after prepending values with the user's cache
             directory.
+        pre_submission_commands: List of commands to be prepended to the sbatch
+            command.
     """
 
     # Required SLURM parameters (note that the integer attributes are those
@@ -254,6 +259,7 @@ class SlurmConfig(BaseModel, extra=Extra.forbid):
     job_name: Optional[str] = None
     constraint: Optional[str] = None
     gres: Optional[str] = None
+    gpus: Optional[str] = None
     time: Optional[str] = None
     account: Optional[str] = None
 
@@ -274,6 +280,8 @@ class SlurmConfig(BaseModel, extra=Extra.forbid):
     target_num_jobs: int
     max_num_jobs: int
 
+    pre_submission_commands: list[str] = Field(default_factory=list)
+
     def _sorted_extra_lines(self) -> list[str]:
         """
         Return a copy of `self.extra_lines`, where lines starting with
@@ -340,7 +348,14 @@ class SlurmConfig(BaseModel, extra=Extra.forbid):
             f"{self.prefix} --cpus-per-task={self.cpus_per_task}",
             f"{self.prefix} --mem={mem_per_job_MB}M",
         ]
-        for key in ["job_name", "constraint", "gres", "time", "account"]:
+        for key in [
+            "job_name",
+            "constraint",
+            "gres",
+            "gpus",
+            "time",
+            "account",
+        ]:
             value = getattr(self, key)
             if value is not None:
                 # Handle the `time` parameter

{fractal_server-2.3.3 → fractal_server-2.3.5}/fractal_server/app/runner/executors/slurm/ssh/executor.py

@@ -13,7 +13,6 @@
 import json
 import math
 import sys
-import tarfile
 import threading
 import time
 from concurrent.futures import Future
@@ -38,9 +37,11 @@ from ...slurm._slurm_config import SlurmConfig
 from .._batching import heuristics
 from ._executor_wait_thread import FractalSlurmWaitThread
 from fractal_server.app.runner.components import _COMPONENT_KEY_
+from fractal_server.app.runner.compress_folder import compress_folder
 from fractal_server.app.runner.exceptions import JobExecutionError
 from fractal_server.app.runner.exceptions import TaskExecutionError
 from fractal_server.app.runner.executors.slurm.ssh._slurm_job import SlurmJob
+from fractal_server.app.runner.extract_archive import extract_archive
 from fractal_server.config import get_settings
 from fractal_server.logger import set_logger
 from fractal_server.ssh._fabric import FractalSSH
@@ -822,17 +823,12 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
 
         # Create compressed subfolder archive (locally)
         local_subfolder = self.workflow_dir_local / subfolder_name
-        tarfile_name = f"{subfolder_name}.tar.gz"
-        tarfile_path_local = (
-            self.workflow_dir_local / tarfile_name
-        ).as_posix()
+        tarfile_path_local = compress_folder(local_subfolder)
+        tarfile_name = Path(tarfile_path_local).name
+        logger.info(f"Subfolder archive created at {tarfile_path_local}")
         tarfile_path_remote = (
             self.workflow_dir_remote / tarfile_name
         ).as_posix()
-        with tarfile.open(tarfile_path_local, "w:gz") as tar:
-            for this_file in local_subfolder.glob("*"):
-                tar.add(this_file, arcname=this_file.name)
-        logger.info(f"Subfolder archive created at {tarfile_path_local}")
 
         # Transfer archive
         t_0_put = time.perf_counter()
@@ -873,9 +869,22 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
 
         # Submit job to SLURM, and get jobid
         sbatch_command = f"sbatch --parsable {job.slurm_script_remote}"
-        sbatch_stdout = self.fractal_ssh.run_command(
-            cmd=sbatch_command,
-        )
+        pre_submission_cmds = job.slurm_config.pre_submission_commands
+        if len(pre_submission_cmds) == 0:
+            sbatch_stdout = self.fractal_ssh.run_command(cmd=sbatch_command)
+        else:
+            logger.debug(f"Now using {pre_submission_cmds=}")
+            script_lines = pre_submission_cmds + [sbatch_command]
+            script_content = "\n".join(script_lines)
+            script_content = f"{script_content}\n"
+            script_path_remote = (
+                f"{job.slurm_script_remote.as_posix()}_wrapper.sh"
+            )
+            self.fractal_ssh.write_remote_file(
+                path=script_path_remote, content=script_content
+            )
+            cmd = f"bash {script_path_remote}"
+            sbatch_stdout = self.fractal_ssh.run_command(cmd=cmd)
 
         # Extract SLURM job ID from stdout
         try:
@@ -885,7 +894,9 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
             error_msg = (
                 f"Submit command `{sbatch_command}` returned "
                 f"`{stdout=}` which cannot be cast to an integer "
-                f"SLURM-job ID. Original error:\n{str(e)}"
+                f"SLURM-job ID.\n"
+                f"Note that {pre_submission_cmds=}.\n"
+                f"Original error:\n{str(e)}"
             )
             logger.error(error_msg)
             raise JobExecutionError(info=error_msg)
@@ -1222,7 +1233,8 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
         tar_command = (
             f"{self.python_remote} "
             "-m fractal_server.app.runner.compress_folder "
-            f"{(self.workflow_dir_remote / subfolder_name).as_posix()}"
+            f"{(self.workflow_dir_remote / subfolder_name).as_posix()} "
+            "--remote-to-local"
         )
         stdout = self.fractal_ssh.run_command(cmd=tar_command)
         print(stdout)
@@ -1240,8 +1252,7 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
         )
 
         # Extract tarfile locally
-        with tarfile.open(tarfile_path_local) as tar:
-            tar.extractall(path=(self.workflow_dir_local / subfolder_name))
+        extract_archive(Path(tarfile_path_local))
 
         t_1 = time.perf_counter()
         logger.info("[_get_subfolder_sftp] End - " f"elapsed: {t_1-t_0:.3f} s")

{fractal_server-2.3.3 → fractal_server-2.3.5}/fractal_server/app/runner/executors/slurm/sudo/executor.py

@@ -1121,6 +1121,12 @@ class FractalSlurmExecutor(SlurmExecutor):
             slurm_err_path=str(job.slurm_stderr),
         )
 
+        # Print warning for ignored parameter
+        if len(job.slurm_config.pre_submission_commands) > 0:
+            logger.warning(
+                f"Ignoring {job.slurm_config.pre_submission_commands=}."
+            )
+
         # Submit job via sbatch, and retrieve jobid
 
         # Write script content to a job.slurm_script

fractal_server-2.3.5/fractal_server/app/runner/extract_archive.py

@@ -0,0 +1,85 @@
+"""
+Wrap `tar` extraction command.
+
+This module is used both locally (in the environment where `fractal-server`
+is running) and remotely (as a standalon Python module, executed over SSH).
+
+This is a twin-module of `compress_folder.py`.
+
+The reason for using the `tar` command via `subprocess` rather than Python
+built-in `tarfile` library has to do with performance issues we observed
+when handling files which were just created within a SLURM job, and in the
+context of a CephFS filesystem.
+"""
+import sys
+from pathlib import Path
+
+from .run_subprocess import run_subprocess
+from fractal_server.logger import set_logger
+
+
+def _remove_suffix(*, string: str, suffix: str) -> str:
+    if string.endswith(suffix):
+        return string[: -len(suffix)]
+    else:
+        raise ValueError(f"Cannot remove {suffix=} from {string=}.")
+
+
+def extract_archive(archive_path: Path):
+    """
+    Extract e.g. `/path/archive.tar.gz` archive into `/path/archive` folder
+
+    Note that `/path/archive` may already exist. In this case, files with
+    the same name are overwritten and new files are added.
+
+    Arguments:
+        archive_path: Absolute path to the archive file.
+    """
+
+    logger_name = "extract_archive"
+    logger = set_logger(logger_name)
+
+    logger.debug("START")
+    logger.debug(f"{archive_path.as_posix()=}")
+
+    # Check archive_path is valid
+    if not archive_path.exists():
+        sys.exit(f"Missing file {archive_path.as_posix()}.")
+
+    # Prepare subfolder path
+    parent_dir = archive_path.parent
+    subfolder_name = _remove_suffix(string=archive_path.name, suffix=".tar.gz")
+    subfolder_path = parent_dir / subfolder_name
+    logger.debug(f"{subfolder_path.as_posix()=}")
+
+    # Create subfolder
+    subfolder_path.mkdir(exist_ok=True)
+
+    # Run tar command
+    cmd_tar = (
+        f"tar -xzvf {archive_path} "
+        f"--directory={subfolder_path.as_posix()} "
+        "."
+    )
+    logger.debug(f"{cmd_tar=}")
+    run_subprocess(cmd=cmd_tar, logger_name=logger_name)
+
+    logger.debug("END")
+
+
+def main(sys_argv: list[str]):
+    help_msg = (
+        "Expected use:\n"
+        "python -m fractal_server.app.runner.extract_archive "
+        "path/to/archive.tar.gz"
+    )
+
+    if len(sys_argv[1:]) != 1 or not sys_argv[1].endswith(".tar.gz"):
+        sys.exit(f"Invalid argument.\n{help_msg}\nProvided: {sys_argv[1:]=}")
+    else:
+        tarfile_path = Path(sys_argv[1])
+        extract_archive(tarfile_path)
+
+
+if __name__ == "__main__":
+    main(sys.argv)

fractal_server-2.3.5/fractal_server/app/runner/run_subprocess.py

@@ -0,0 +1,27 @@
+import shlex
+import subprocess  # nosec
+from typing import Optional
+
+from fractal_server.logger import get_logger
+
+
+def run_subprocess(
+    cmd: str, logger_name: Optional[str] = None
+) -> subprocess.CompletedProcess:
+    logger = get_logger(logger_name)
+    try:
+        res = subprocess.run(  # nosec
+            shlex.split(cmd), check=True, capture_output=True, encoding="utf-8"
+        )
+        return res
+    except subprocess.CalledProcessError as e:
+        logger.debug(
+            f"Command '{e.cmd}' returned non-zero exit status {e.returncode}."
+        )
+        logger.debug(f"stdout: {e.stdout}")
+        logger.debug(f"stderr: {e.stderr}")
+        raise e
+    except Exception as e:
+        logger.debug(f"An error occurred while running command: {cmd}")
+        logger.debug(str(e))
+        raise e

{fractal_server-2.3.3 → fractal_server-2.3.5}/fractal_server/app/runner/v2/__init__.py

@@ -36,8 +36,8 @@ from ._local import process_workflow as local_process_workflow
 from ._local_experimental import (
     process_workflow as local_experimental_process_workflow,
 )
-from ._slurm import process_workflow as slurm_sudo_process_workflow
 from ._slurm_ssh import process_workflow as slurm_ssh_process_workflow
+from ._slurm_sudo import process_workflow as slurm_sudo_process_workflow
 from .handle_failed_job import assemble_filters_failed_job
 from .handle_failed_job import assemble_history_failed_job
 from .handle_failed_job import assemble_images_failed_job

{fractal_server-2.3.3/fractal_server/app/runner/v2/_slurm_ssh → fractal_server-2.3.5/fractal_server/app/runner/v2/_slurm_common}/get_slurm_config.py

@@ -18,8 +18,6 @@ from fractal_server.app.runner.executors.slurm._slurm_config import (
 
 def get_slurm_config(
     wftask: WorkflowTaskV2,
-    workflow_dir_local: Path,
-    workflow_dir_remote: Path,
     which_type: Literal["non_parallel", "parallel"],
     config_path: Optional[Path] = None,
 ) -> SlurmConfig:
@@ -43,13 +41,6 @@ def get_slurm_config(
         wftask:
             WorkflowTask for which the SLURM configuration is is to be
             prepared.
-        workflow_dir_local:
-            Server-owned directory to store all task-execution-related relevant
-            files (inputs, outputs, errors, and all meta files related to the
-            job execution). Note: users cannot write directly to this folder.
-        workflow_dir_remote:
-            User-side directory with the same scope as `workflow_dir_local`,
-            and where a user can write.
         config_path:
             Path of a Fractal SLURM configuration file; if `None`, use
             `FRACTAL_SLURM_CONFIG_FILE` variable from settings.
@@ -99,13 +90,13 @@ def get_slurm_config(
     # 1. This block of definitions takes priority over other definitions from
     #    slurm_env which are not under the `needs_gpu` subgroup
     # 2. This block of definitions has lower priority than whatever comes next
-    #    (i.e. from WorkflowTask.meta).
+    #    (i.e. from WorkflowTask.meta_parallel).
     if wftask_meta is not None:
         needs_gpu = wftask_meta.get("needs_gpu", False)
     else:
         needs_gpu = False
     logger.debug(f"[get_slurm_config] {needs_gpu=}")
-    if needs_gpu and slurm_env.gpu_slurm_config is not None:  # FIXME
+    if needs_gpu:
         for key, value in slurm_env.gpu_slurm_config.dict(
             exclude_unset=True, exclude={"mem"}
         ).items():
@@ -143,9 +134,9 @@ def get_slurm_config(
             )
             logger.error(error_msg)
             raise SlurmConfigError(error_msg)
-        for key in ["time", "gres", "constraint"]:
+        for key in ["time", "gres", "gpus", "constraint"]:
             value = wftask_meta.get(key, None)
-            if value:
+            if value is not None:
                 slurm_dict[key] = value
     if wftask_meta is not None:
         extra_lines = wftask_meta.get("extra_lines", [])

{fractal_server-2.3.3 → fractal_server-2.3.5}/fractal_server/app/runner/v2/_slurm_ssh/_submit_setup.py

@@ -17,8 +17,10 @@ from pathlib import Path
 from typing import Literal
 
 from ...task_files import get_task_file_paths
-from .get_slurm_config import get_slurm_config
 from fractal_server.app.models.v2 import WorkflowTaskV2
+from fractal_server.app.runner.v2._slurm_common.get_slurm_config import (
+    get_slurm_config,
+)
 
 
 def _slurm_submit_setup(
@@ -62,8 +64,6 @@ def _slurm_submit_setup(
     # Get SlurmConfig object
     slurm_config = get_slurm_config(
         wftask=wftask,
-        workflow_dir_local=workflow_dir_local,
-        workflow_dir_remote=workflow_dir_remote,
         which_type=which_type,
     )
 

{fractal_server-2.3.3/fractal_server/app/runner/v2/_slurm → fractal_server-2.3.5/fractal_server/app/runner/v2/_slurm_sudo}/_submit_setup.py

@@ -17,8 +17,10 @@ from pathlib import Path
 from typing import Literal
 
 from ...task_files import get_task_file_paths
-from .get_slurm_config import get_slurm_config
 from fractal_server.app.models.v2 import WorkflowTaskV2
+from fractal_server.app.runner.v2._slurm_common.get_slurm_config import (
+    get_slurm_config,
+)
 
 
 def _slurm_submit_setup(
@@ -62,8 +64,6 @@ def _slurm_submit_setup(
     # Get SlurmConfig object
     slurm_config = get_slurm_config(
         wftask=wftask,
-        workflow_dir_local=workflow_dir_local,
-        workflow_dir_remote=workflow_dir_remote,
         which_type=which_type,
     )
 

{fractal_server-2.3.3 → fractal_server-2.3.5}/fractal_server/config.py

@@ -546,7 +546,9 @@ class Settings(BaseSettings):
     attribute in their input-arguments JSON file.
     """
 
-    FRACTAL_API_V1_MODE: Literal["include", "exclude"] = "include"
+    FRACTAL_API_V1_MODE: Literal[
+        "include", "include_without_submission", "exclude"
+    ] = "include"
     """
     Whether to include the v1 API.
     """
@@ -685,6 +687,25 @@ class Settings(BaseSettings):
         self.check_db()
         self.check_runner()
 
+    def get_sanitized(self) -> dict:
+        def _must_be_sanitized(string) -> bool:
+            if not string.upper().startswith("FRACTAL") or any(
+                s in string.upper()
+                for s in ["PASSWORD", "SECRET", "PWD", "TOKEN"]
+            ):
+                return True
+            else:
+                return False
+
+        sanitized_settings = {}
+        for k, v in self.dict().items():
+            if _must_be_sanitized(k):
+                sanitized_settings[k] = "***"
+            else:
+                sanitized_settings[k] = v
+
+        return sanitized_settings
+
 
 def get_settings(settings=Settings()) -> Settings:
     return settings

{fractal_server-2.3.3 → fractal_server-2.3.5}/fractal_server/main.py

@@ -49,7 +49,7 @@ def collect_routers(app: FastAPI) -> None:
     settings = Inject(get_settings)
 
     app.include_router(router_api, prefix="/api")
-    if settings.FRACTAL_API_V1_MODE == "include":
+    if settings.FRACTAL_API_V1_MODE.startswith("include"):
         app.include_router(router_api_v1, prefix="/api/v1")
         app.include_router(
             router_admin_v1, prefix="/admin/v1", tags=["V1 Admin area"]

{fractal_server-2.3.3 → fractal_server-2.3.5}/fractal_server/ssh/_fabric.py

@@ -306,6 +306,28 @@ class FractalSSH(object):
             cmd = f"rm -r {folder}"
             self.run_command(cmd=cmd)
 
+    def write_remote_file(
+        self,
+        *,
+        path: str,
+        content: str,
+        lock_timeout: Optional[float] = None,
+    ) -> None:
+        """
+        Open a remote file via SFTP and write it.
+
+        Args:
+            path: Absolute path
+            contents: File contents
+            lock_timeout:
+        """
+        actual_lock_timeout = self.default_lock_timeout
+        if lock_timeout is not None:
+            actual_lock_timeout = lock_timeout
+        with self.acquire_timeout(timeout=actual_lock_timeout):
+            with self.sftp().open(filename=path, mode="w") as f:
+                f.write(content)
+
 
 def get_ssh_connection(
     *,

{fractal_server-2.3.3 → fractal_server-2.3.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "fractal-server"
-version = "2.3.3"
+version = "2.3.5"
 description = "Server component of the Fractal analytics platform"
 authors = [
     "Tommaso Comparin <tommaso.comparin@exact-lab.it>",
@@ -91,7 +91,7 @@ filterwarnings = [
 ]
 
 [tool.bumpver]
-current_version = "2.3.3"
+current_version = "2.3.5"
 version_pattern = "MAJOR.MINOR.PATCH[PYTAGNUM]"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true

fractal_server-2.3.3/fractal_server/__init__.py

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