fractal-server 2.8.0__py3-none-any.whl → 2.9.0__py3-none-any.whl

fractal_server/app/routes/auth/users.py

@@ -8,9 +8,7 @@ from fastapi import status
 from fastapi_users import exceptions
 from fastapi_users import schemas
 from fastapi_users.router.common import ErrorCode
-from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlmodel import col
 from sqlmodel import func
 from sqlmodel import select
 
@@ -18,9 +16,10 @@ from . import current_active_superuser
 from ...db import get_async_db
 from ...schemas.user import UserRead
 from ...schemas.user import UserUpdate
-from ...schemas.user import UserUpdateWithNewGroupIds
 from ..aux.validate_user_settings import verify_user_has_settings
+from ._aux_auth import _get_default_usergroup_id
 from ._aux_auth import _get_single_user_with_groups
+from ._aux_auth import FRACTAL_DEFAULT_GROUP_NAME
 from fractal_server.app.models import LinkUserGroup
 from fractal_server.app.models import UserGroup
 from fractal_server.app.models import UserOAuth
@@ -28,6 +27,7 @@ from fractal_server.app.models import UserSettings
 from fractal_server.app.routes.auth._aux_auth import _user_or_404
 from fractal_server.app.schemas import UserSettingsRead
 from fractal_server.app.schemas import UserSettingsUpdate
+from fractal_server.app.schemas.user import UserUpdateGroups
 from fractal_server.app.security import get_user_manager
 from fractal_server.app.security import UserManager
 from fractal_server.logger import set_logger
@@ -55,114 +55,43 @@ async def get_user(
 @router_users.patch("/users/{user_id}/", response_model=UserRead)
 async def patch_user(
     user_id: int,
-    user_update: UserUpdateWithNewGroupIds,
+    user_update: UserUpdate,
     current_superuser: UserOAuth = Depends(current_active_superuser),
     user_manager: UserManager = Depends(get_user_manager),
     db: AsyncSession = Depends(get_async_db),
 ):
     """
     Custom version of the PATCH-user route from `fastapi-users`.
-
-    In order to keep the fastapi-users logic in place (which is convenient to
-    update user attributes), we split the endpoint into two branches. We either
-    go through the fastapi-users-based attribute-update branch, or through the
-    branch where we establish new user/group relationships.
-
-    Note that we prevent making both changes at the same time, since it would
-    be more complex to guarantee that endpoint error would leave the database
-    in the same state as before the API call.
     """
 
-    # We prevent simultaneous editing of both user attributes and user/group
-    # associations
-    user_update_dict_without_groups = user_update.dict(
-        exclude_unset=True, exclude={"new_group_ids"}
-    )
-    edit_attributes = user_update_dict_without_groups != {}
-    edit_groups = user_update.new_group_ids is not None
-    if edit_attributes and edit_groups:
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=(
-                "Cannot modify both user attributes and group membership. "
-                "Please make two independent PATCH calls"
-            ),
-        )
-
     # Check that user exists
     user_to_patch = await _user_or_404(user_id, db)
 
-    if edit_groups:
-        # Establish new user/group relationships
-
-        # Check that all required groups exist
-        # Note: The reason for introducing `col` is as in
-        # https://sqlmodel.tiangolo.com/tutorial/where/#type-annotations-and-errors,
-        stm = select(func.count()).where(
-            col(UserGroup.id).in_(user_update.new_group_ids)
+    # Modify user attributes
+    try:
+        user = await user_manager.update(
+            user_update,
+            user_to_patch,
+            safe=False,
+            request=None,
+        )
+        validated_user = schemas.model_validate(UserOAuth, user)
+        patched_user = await db.get(
+            UserOAuth, validated_user.id, populate_existing=True
+        )
+    except exceptions.InvalidPasswordException as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={
+                "code": ErrorCode.UPDATE_USER_INVALID_PASSWORD,
+                "reason": e.reason,
+            },
+        )
+    except exceptions.UserAlreadyExists:
+        raise HTTPException(
+            status.HTTP_400_BAD_REQUEST,
+            detail=ErrorCode.UPDATE_USER_EMAIL_ALREADY_EXISTS,
         )
-        res = await db.execute(stm)
-        number_matching_groups = res.scalar()
-        if number_matching_groups != len(user_update.new_group_ids):
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=(
-                    "Not all requested groups (IDs: "
-                    f"{user_update.new_group_ids}) exist."
-                ),
-            )
-
-        for new_group_id in user_update.new_group_ids:
-            link = LinkUserGroup(user_id=user_id, group_id=new_group_id)
-            db.add(link)
-
-        try:
-            await db.commit()
-        except IntegrityError as e:
-            error_msg = (
-                f"Cannot link groups with IDs {user_update.new_group_ids} "
-                f"to user {user_id}. "
-                "Likely reason: one of these links already exists.\n"
-                f"Original error: {str(e)}"
-            )
-            logger.info(error_msg)
-            raise HTTPException(
-                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                detail=error_msg,
-            )
-        patched_user = user_to_patch
-    elif edit_attributes:
-        # Modify user attributes
-        try:
-            user_update_without_groups = UserUpdate(
-                **user_update_dict_without_groups
-            )
-            user = await user_manager.update(
-                user_update_without_groups,
-                user_to_patch,
-                safe=False,
-                request=None,
-            )
-            validated_user = schemas.model_validate(UserOAuth, user)
-            patched_user = await db.get(
-                UserOAuth, validated_user.id, populate_existing=True
-            )
-        except exceptions.InvalidPasswordException as e:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail={
-                    "code": ErrorCode.UPDATE_USER_INVALID_PASSWORD,
-                    "reason": e.reason,
-                },
-            )
-        except exceptions.UserAlreadyExists:
-            raise HTTPException(
-                status.HTTP_400_BAD_REQUEST,
-                detail=ErrorCode.UPDATE_USER_EMAIL_ALREADY_EXISTS,
-            )
-    else:
-        # Nothing to do, just continue
-        patched_user = user_to_patch
 
     # Enrich user object with `group_ids_names` attribute
     patched_user_with_groups = await _get_single_user_with_groups(
@@ -203,6 +132,75 @@ async def list_users(
     return user_list
 
 
+@router_users.post("/users/{user_id}/set-groups/", response_model=UserRead)
+async def set_user_groups(
+    user_id: int,
+    user_update: UserUpdateGroups,
+    superuser: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> UserRead:
+
+    # Preliminary check that all objects exist in the db
+    user = await _user_or_404(user_id=user_id, db=db)
+    target_group_ids = user_update.group_ids
+    stm = select(func.count(UserGroup.id)).where(
+        UserGroup.id.in_(target_group_ids)
+    )
+    res = await db.execute(stm)
+    count = res.scalar()
+    if count != len(target_group_ids):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Some UserGroups in {target_group_ids} do not exist.",
+        )
+
+    # Check that default group is not being removed
+    default_group_id = await _get_default_usergroup_id(db=db)
+    if default_group_id not in target_group_ids:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                f"Cannot remove user from "
+                f"'{FRACTAL_DEFAULT_GROUP_NAME}' group.",
+            ),
+        )
+
+    # Prepare lists of links to be removed
+    res = await db.execute(
+        select(LinkUserGroup)
+        .where(LinkUserGroup.user_id == user_id)
+        .where(LinkUserGroup.group_id.not_in(target_group_ids))
+    )
+    links_to_remove = res.scalars().all()
+
+    # Prepare lists of links to be added
+    res = await db.execute(
+        select(LinkUserGroup.group_id)
+        .where(LinkUserGroup.user_id == user_id)
+        .where(LinkUserGroup.group_id.in_(target_group_ids))
+    )
+    ids_links_already_in = res.scalars().all()
+    ids_links_to_add = set(target_group_ids) - set(ids_links_already_in)
+
+    # Remove/create links as needed
+    for link in links_to_remove:
+        logger.info(
+            f"Removing LinkUserGroup with {link.user_id=} "
+            f"and {link.group_id=}."
+        )
+        await db.delete(link)
+    for group_id in ids_links_to_add:
+        logger.info(
+            f"Creating new LinkUserGroup with {user_id=} " f"and {group_id=}."
+        )
+        db.add(LinkUserGroup(user_id=user_id, group_id=group_id))
+    await db.commit()
+
+    user_with_groups = await _get_single_user_with_groups(user, db)
+
+    return user_with_groups
+
+
 @router_users.get(
     "/users/{user_id}/settings/", response_model=UserSettingsRead
 )

fractal_server/app/routes/aux/__init__.py

@@ -0,0 +1,20 @@
+from datetime import datetime
+from typing import Optional
+
+from fastapi import HTTPException
+from fastapi import status
+
+
+def _raise_if_naive_datetime(*timestamps: tuple[Optional[datetime]]) -> None:
+    """
+    Raise 422 if any not-null argument is a naive `datetime` object:
+    https://docs.python.org/3/library/datetime.html#determining-if-an-object-is-aware-or-naive
+    """
+    for timestamp in filter(None, timestamps):
+        if (timestamp.tzinfo is None) or (
+            timestamp.tzinfo.utcoffset(timestamp) is None
+        ):
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"{timestamp=} is naive. You must provide a timezone.",
+            )

fractal_server/app/runner/executors/slurm/_slurm_config.py

@@ -456,20 +456,3 @@ def _parse_mem_value(raw_mem: Union[str, int]) -> int:
 
     logger.debug(f"{info}, return {mem_MB}")
     return mem_MB
-
-
-def get_default_slurm_config():
-    """
-    Return a default `SlurmConfig` configuration object
-    """
-    return SlurmConfig(
-        partition="main",
-        cpus_per_task=1,
-        mem_per_task_MB=100,
-        target_cpus_per_job=1,
-        max_cpus_per_job=2,
-        target_mem_per_job=100,
-        max_mem_per_job=500,
-        target_num_jobs=2,
-        max_num_jobs=4,
-    )

fractal_server/app/runner/executors/slurm/ssh/executor.py

@@ -26,15 +26,16 @@ from typing import Sequence
 
 import cloudpickle
 from cfut import SlurmExecutor
-from paramiko.ssh_exception import NoValidConnectionsError
 
 from ....filenames import SHUTDOWN_FILENAME
 from ....task_files import get_task_file_paths
 from ....task_files import TaskFiles
 from ....versions import get_versions
-from ...slurm._slurm_config import get_default_slurm_config
 from ...slurm._slurm_config import SlurmConfig
 from .._batching import heuristics
+from ..utils_executors import get_pickle_file_path
+from ..utils_executors import get_slurm_file_path
+from ..utils_executors import get_slurm_script_file_path
 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
@@ -224,132 +225,12 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
         with self.jobs_lock:
             self.map_jobid_to_slurm_files_local.pop(jobid)
 
-    def get_input_pickle_file_path_local(
-        self, *, arg: str, subfolder_name: str, prefix: Optional[str] = None
-    ) -> Path:
-
-        prefix = prefix or "cfut"
-        output = (
-            self.workflow_dir_local
-            / subfolder_name
-            / f"{prefix}_in_{arg}.pickle"
-        )
-        return output
-
-    def get_input_pickle_file_path_remote(
-        self, *, arg: str, subfolder_name: str, prefix: Optional[str] = None
-    ) -> Path:
-
-        prefix = prefix or "cfut"
-        output = (
-            self.workflow_dir_remote
-            / subfolder_name
-            / f"{prefix}_in_{arg}.pickle"
-        )
-        return output
-
-    def get_output_pickle_file_path_local(
-        self, *, arg: str, subfolder_name: str, prefix: Optional[str] = None
-    ) -> Path:
-        prefix = prefix or "cfut"
-        return (
-            self.workflow_dir_local
-            / subfolder_name
-            / f"{prefix}_out_{arg}.pickle"
-        )
-
-    def get_output_pickle_file_path_remote(
-        self, *, arg: str, subfolder_name: str, prefix: Optional[str] = None
-    ) -> Path:
-        prefix = prefix or "cfut"
-        return (
-            self.workflow_dir_remote
-            / subfolder_name
-            / f"{prefix}_out_{arg}.pickle"
-        )
-
-    def get_slurm_script_file_path_local(
-        self, *, subfolder_name: str, prefix: Optional[str] = None
-    ) -> Path:
-        prefix = prefix or "_temp"
-        return (
-            self.workflow_dir_local
-            / subfolder_name
-            / f"{prefix}_slurm_submit.sbatch"
-        )
-
-    def get_slurm_script_file_path_remote(
-        self, *, subfolder_name: str, prefix: Optional[str] = None
-    ) -> Path:
-        prefix = prefix or "_temp"
-        return (
-            self.workflow_dir_remote
-            / subfolder_name
-            / f"{prefix}_slurm_submit.sbatch"
-        )
-
-    def get_slurm_stdout_file_path_local(
-        self,
-        *,
-        subfolder_name: str,
-        arg: str = "%j",
-        prefix: Optional[str] = None,
-    ) -> Path:
-        prefix = prefix or "slurmpy.stdout"
-        return (
-            self.workflow_dir_local
-            / subfolder_name
-            / f"{prefix}_slurm_{arg}.out"
-        )
-
-    def get_slurm_stdout_file_path_remote(
-        self,
-        *,
-        subfolder_name: str,
-        arg: str = "%j",
-        prefix: Optional[str] = None,
-    ) -> Path:
-        prefix = prefix or "slurmpy.stdout"
-        return (
-            self.workflow_dir_remote
-            / subfolder_name
-            / f"{prefix}_slurm_{arg}.out"
-        )
-
-    def get_slurm_stderr_file_path_local(
-        self,
-        *,
-        subfolder_name: str,
-        arg: str = "%j",
-        prefix: Optional[str] = None,
-    ) -> Path:
-        prefix = prefix or "slurmpy.stderr"
-        return (
-            self.workflow_dir_local
-            / subfolder_name
-            / f"{prefix}_slurm_{arg}.err"
-        )
-
-    def get_slurm_stderr_file_path_remote(
-        self,
-        *,
-        subfolder_name: str,
-        arg: str = "%j",
-        prefix: Optional[str] = None,
-    ) -> Path:
-        prefix = prefix or "slurmpy.stderr"
-        return (
-            self.workflow_dir_remote
-            / subfolder_name
-            / f"{prefix}_slurm_{arg}.err"
-        )
-
     def submit(
         self,
         fun: Callable[..., Any],
         *fun_args: Sequence[Any],
-        slurm_config: Optional[SlurmConfig] = None,
-        task_files: Optional[TaskFiles] = None,
+        slurm_config: SlurmConfig,
+        task_files: TaskFiles,
         **fun_kwargs: dict,
     ) -> Future:
         """
@@ -360,11 +241,9 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
             fun_args: Function positional arguments
             fun_kwargs: Function keyword arguments
             slurm_config:
-                A `SlurmConfig` object; if `None`, use
-                `get_default_slurm_config()`.
+                A `SlurmConfig` object.
             task_files:
-                A `TaskFiles` object; if `None`, use
-                `self.get_default_task_files()`.
+                A `TaskFiles` object.
 
         Returns:
             Future representing the execution of the current SLURM job.
@@ -376,12 +255,6 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
             logger.warning(error_msg)
             raise JobExecutionError(info=error_msg)
 
-        # Set defaults, if needed
-        if slurm_config is None:
-            slurm_config = get_default_slurm_config()
-        if task_files is None:
-            task_files = self.get_default_task_files()
-
         # Set slurm_file_prefix
         slurm_file_prefix = task_files.file_prefix
 
@@ -409,15 +282,7 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
             args=fun_args,
             kwargs=fun_kwargs,
         )
-        try:
-            self._put_subfolder_sftp(jobs=[job])
-        except NoValidConnectionsError as e:
-            logger.error("NoValidConnectionError")
-            logger.error(f"{str(e)=}")
-            logger.error(f"{e.errors=}")
-            for err in e.errors:
-                logger.error(f"{str(err)}")
-            raise e
+        self._put_subfolder_sftp(jobs=[job])
         future, job_id_str = self._submit_job(job)
         self.wait_thread.wait(job_id=job_id_str)
         return future
@@ -427,8 +292,8 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
         fn: Callable[..., Any],
         iterable: list[Sequence[Any]],
         *,
-        slurm_config: Optional[SlurmConfig] = None,
-        task_files: Optional[TaskFiles] = None,
+        slurm_config: SlurmConfig,
+        task_files: TaskFiles,
     ):
         """
         Return an iterator with the results of several execution of a function
@@ -451,12 +316,9 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
                 An iterable such that each element is the list of arguments to
                 be passed to `fn`, as in `fn(*args)`.
             slurm_config:
-                A `SlurmConfig` object; if `None`, use
-                `get_default_slurm_config()`.
+                A `SlurmConfig` object.
             task_files:
-                A `TaskFiles` object; if `None`, use
-                `self.get_default_task_files()`.
-
+                A `TaskFiles` object.
         """
 
         # Do not continue if auxiliary thread was shut down
@@ -481,12 +343,6 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
                 # self._exception
                 del fut
 
-        # Set defaults, if needed
-        if not slurm_config:
-            slurm_config = get_default_slurm_config()
-        if task_files is None:
-            task_files = self.get_default_task_files()
-
         # Include common_script_lines in extra_lines
         logger.debug(
             f"Adding {self.common_script_lines=} to "
@@ -559,16 +415,7 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
             current_component_index += batch_size
         logger.debug("[map] Job preparation - END")
 
-        try:
-            self._put_subfolder_sftp(jobs=jobs_to_submit)
-        except NoValidConnectionsError as e:
-            logger.error("NoValidConnectionError")
-            logger.error(f"{str(e)=}")
-            logger.error(f"{e.errors=}")
-            for err in e.errors:
-                logger.error(f"{str(err)}")
-
-            raise e
+        self._put_subfolder_sftp(jobs=jobs_to_submit)
 
         # Construct list of futures (one per SLURM job, i.e. one per batch)
         # FIXME SSH: we may create a single `_submit_many_jobs` method to
@@ -728,63 +575,80 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
                 f"Missing folder {subfolder_path.as_posix()}."
             )
 
-        # Define I/O pickle file local/remote paths
         job.input_pickle_files_local = tuple(
-            self.get_input_pickle_file_path_local(
+            get_pickle_file_path(
                 arg=job.workerids[ind],
+                workflow_dir=self.workflow_dir_local,
                 subfolder_name=job.wftask_subfolder_name,
+                in_or_out="in",
                 prefix=job.wftask_file_prefixes[ind],
             )
             for ind in range(job.num_tasks_tot)
         )
+
         job.input_pickle_files_remote = tuple(
-            self.get_input_pickle_file_path_remote(
+            get_pickle_file_path(
                 arg=job.workerids[ind],
+                workflow_dir=self.workflow_dir_remote,
                 subfolder_name=job.wftask_subfolder_name,
+                in_or_out="in",
                 prefix=job.wftask_file_prefixes[ind],
             )
             for ind in range(job.num_tasks_tot)
         )
         job.output_pickle_files_local = tuple(
-            self.get_output_pickle_file_path_local(
+            get_pickle_file_path(
                 arg=job.workerids[ind],
+                workflow_dir=self.workflow_dir_local,
                 subfolder_name=job.wftask_subfolder_name,
+                in_or_out="out",
                 prefix=job.wftask_file_prefixes[ind],
             )
             for ind in range(job.num_tasks_tot)
         )
         job.output_pickle_files_remote = tuple(
-            self.get_output_pickle_file_path_remote(
+            get_pickle_file_path(
                 arg=job.workerids[ind],
+                workflow_dir=self.workflow_dir_remote,
                 subfolder_name=job.wftask_subfolder_name,
+                in_or_out="out",
                 prefix=job.wftask_file_prefixes[ind],
             )
             for ind in range(job.num_tasks_tot)
         )
-
-        # Define SLURM-job file local/remote paths
-        job.slurm_script_local = self.get_slurm_script_file_path_local(
+        # define slurm-job file local/remote paths
+        job.slurm_script_local = get_slurm_script_file_path(
+            workflow_dir=self.workflow_dir_local,
             subfolder_name=job.wftask_subfolder_name,
             prefix=job.slurm_file_prefix,
         )
-        job.slurm_script_remote = self.get_slurm_script_file_path_remote(
+        job.slurm_script_remote = get_slurm_script_file_path(
+            workflow_dir=self.workflow_dir_remote,
             subfolder_name=job.wftask_subfolder_name,
             prefix=job.slurm_file_prefix,
         )
-        job.slurm_stdout_local = self.get_slurm_stdout_file_path_local(
+        job.slurm_stdout_local = get_slurm_file_path(
+            workflow_dir=self.workflow_dir_local,
             subfolder_name=job.wftask_subfolder_name,
+            out_or_err="out",
             prefix=job.slurm_file_prefix,
         )
-        job.slurm_stdout_remote = self.get_slurm_stdout_file_path_remote(
+        job.slurm_stdout_remote = get_slurm_file_path(
+            workflow_dir=self.workflow_dir_remote,
             subfolder_name=job.wftask_subfolder_name,
+            out_or_err="out",
             prefix=job.slurm_file_prefix,
         )
-        job.slurm_stderr_local = self.get_slurm_stderr_file_path_local(
+        job.slurm_stderr_local = get_slurm_file_path(
+            workflow_dir=self.workflow_dir_local,
             subfolder_name=job.wftask_subfolder_name,
+            out_or_err="err",
             prefix=job.slurm_file_prefix,
         )
-        job.slurm_stderr_remote = self.get_slurm_stderr_file_path_remote(
+        job.slurm_stderr_remote = get_slurm_file_path(
+            workflow_dir=self.workflow_dir_remote,
             subfolder_name=job.wftask_subfolder_name,
+            out_or_err="err",
             prefix=job.slurm_file_prefix,
         )
 
@@ -1073,16 +937,7 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
                     self.jobs_empty_cond.notify_all()
 
             # Fetch subfolder from remote host
-            try:
-                self._get_subfolder_sftp(jobs=jobs)
-            except NoValidConnectionsError as e:
-                logger.error("NoValidConnectionError")
-                logger.error(f"{str(e)=}")
-                logger.error(f"{e.errors=}")
-                for err in e.errors:
-                    logger.error(f"{str(err)}")
-
-                raise e
+            self._get_subfolder_sftp(jobs=jobs)
 
             # First round of checking whether all output files exist
             missing_out_paths = []
@@ -1321,7 +1176,6 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
         slurm_err_path: str,
         slurm_config: SlurmConfig,
     ):
-
         num_tasks_max_running = slurm_config.parallel_tasks_per_job
         mem_per_task_MB = slurm_config.mem_per_task_MB
 
@@ -1373,19 +1227,6 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
         script = "\n".join(script_lines)
         return script
 
-    def get_default_task_files(self) -> TaskFiles:
-        """
-        This will be called when self.submit or self.map are called from
-        outside fractal-server, and then lack some optional arguments.
-        """
-        task_files = TaskFiles(
-            workflow_dir_local=self.workflow_dir_local,
-            workflow_dir_remote=self.workflow_dir_remote,
-            task_order=None,
-            task_name="name",
-        )
-        return task_files
-
     def shutdown(self, wait=True, *, cancel_futures=False):
         """
         Clean up all executor variables. Note that this function is executed on
@@ -1527,7 +1368,11 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
         logger.info("[FractalSlurmSSHExecutor.ssh_handshake] START")
         cmd = f"{self.python_remote} -m fractal_server.app.runner.versions"
         stdout = self.fractal_ssh.run_command(cmd=cmd)
-        remote_versions = json.loads(stdout.strip("\n"))
+        try:
+            remote_versions = json.loads(stdout.strip("\n"))
+        except json.decoder.JSONDecodeError as e:
+            logger.error("Fractal server versions not available")
+            raise e
 
         # Check compatibility with local versions
         local_versions = get_versions()