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

fractal_server/tasks/v2/ssh/collect_pixi.py

@@ -0,0 +1,296 @@
+import logging
+import time
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from ....ssh._fabric import SingleUseFractalSSH
+from ..utils_background import fail_and_cleanup
+from ..utils_background import prepare_tasks_metadata
+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.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.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.ssh._fabric import SSHConfig
+from fractal_server.syringe import Inject
+from fractal_server.tasks.v2.ssh._utils import _customize_and_run_template
+from fractal_server.tasks.v2.utils_background import add_commit_refresh
+from fractal_server.tasks.v2.utils_background import get_current_log
+from fractal_server.tasks.v2.utils_templates import SCRIPTS_SUBFOLDER
+from fractal_server.utils import get_timestamp
+
+
+def collect_ssh_pixi(
+    *,
+    task_group_id: int,
+    task_group_activity_id: int,
+    ssh_config: SSHConfig,
+    tasks_base_dir: str,
+    tar_gz_file: FractalUploadedFile,
+) -> None:
+    """
+    Collect a task package over SSH
+
+    This function runs as a background task, therefore exceptions must be
+    handled.
+
+    NOTE: since this function is sync, it runs within a thread - due to
+    starlette/fastapi handling of background tasks (see
+    https://github.com/encode/starlette/blob/master/starlette/background.py).
+
+
+    Arguments:
+        task_group_id:
+        task_group_activity_id:
+        ssh_config:
+        tasks_base_dir:
+            Only used as a `safe_root` in `remove_dir`, and typically set to
+            `user_settings.ssh_tasks_dir`.
+        tar_gz_file:
+    """
+
+    LOGGER_NAME = f"{__name__}.ID{task_group_activity_id}"
+
+    # Work within a temporary folder, where also logs will be placed
+    with TemporaryDirectory() as tmpdir:
+        log_file_path = Path(tmpdir) / "log"
+        logger = set_logger(
+            logger_name=LOGGER_NAME,
+            log_file_path=log_file_path,
+        )
+        with SingleUseFractalSSH(
+            ssh_config=ssh_config,
+            logger_name=LOGGER_NAME,
+        ) as fractal_ssh:
+
+            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."
+                    )
+                    return
+
+                # Log some info
+                logger.info("START")
+                for key, value in task_group.model_dump().items():
+                    logger.debug(f"task_group.{key}: {value}")
+
+                # Check that SSH connection works
+                try:
+                    fractal_ssh.check_connection()
+                except Exception as e:
+                    logger.error("Cannot establish SSH connection.")
+                    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
+
+                try:
+
+                    # Check that the (remote) task_group path does not exist
+                    if fractal_ssh.remote_exists(task_group.path):
+                        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
+
+                    # Create remote `task_group.path` and `script_dir_remote`
+                    # folders (note that because of `parents=True` we  are in
+                    # the `no error if existing, make parent directories as
+                    # needed` scenario for `mkdir`)
+                    script_dir_remote = (
+                        Path(task_group.path) / SCRIPTS_SUBFOLDER
+                    ).as_posix()
+                    fractal_ssh.mkdir(folder=task_group.path, parents=True)
+                    fractal_ssh.mkdir(folder=script_dir_remote, parents=True)
+
+                    # Write tar.gz file locally and send it to remote path,
+                    # and set task_group.archive_path
+                    tar_gz_filename = tar_gz_file.filename
+                    archive_path = (
+                        Path(task_group.path) / tar_gz_filename
+                    ).as_posix()
+                    tmp_archive_path = (
+                        Path(tmpdir) / tar_gz_filename
+                    ).as_posix()
+                    logger.info(
+                        f"Write tar.gz-file contents into {tmp_archive_path}"
+                    )
+                    with open(tmp_archive_path, "wb") as f:
+                        f.write(tar_gz_file.contents)
+                    fractal_ssh.send_file(
+                        local=tmp_archive_path,
+                        remote=archive_path,
+                    )
+                    task_group.archive_path = archive_path
+                    task_group = add_commit_refresh(obj=task_group, db=db)
+
+                    # Set `pixi_bin`
+                    settings = Inject(get_settings)
+                    pixi_home = settings.pixi.versions[task_group.pixi_version]
+                    pixi_bin = Path(pixi_home, "bin/pixi").as_posix()
+
+                    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),
+                    }
+
+                    logger.info("installing - START")
+
+                    # Set status to ONGOING and refresh logs
+                    activity.status = TaskGroupActivityStatusV2.ONGOING
+                    activity.log = get_current_log(log_file_path)
+                    activity = add_commit_refresh(obj=activity, db=db)
+
+                    stdout = _customize_and_run_template(
+                        template_filename="pixi_1_collect.sh",
+                        replacements=replacements,
+                        script_dir_local=(
+                            Path(tmpdir) / SCRIPTS_SUBFOLDER
+                        ).as_posix(),
+                        script_dir_remote=script_dir_remote,
+                        prefix=(
+                            f"{int(time.time())}_"
+                            f"{TaskGroupActivityActionV2.COLLECT}_"
+                        ),
+                        fractal_ssh=fractal_ssh,
+                        logger_name=LOGGER_NAME,
+                    )
+                    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_remote = parsed_output["package_root"]
+                    venv_size = parsed_output["venv_size"]
+                    venv_file_number = parsed_output["venv_file_number"]
+
+                    # Read and validate remote manifest file
+                    manifest_path_remote = (
+                        f"{package_root_remote}/__FRACTAL_MANIFEST__.json"
+                    )
+                    pkg_manifest_dict = fractal_ssh.read_remote_json_file(
+                        manifest_path_remote
+                    )
+                    logger.info(f"Loaded {manifest_path_remote=}")
+                    pkg_manifest = ManifestV2(**pkg_manifest_dict)
+                    logger.info("Manifest is a valid ManifestV2")
+
+                    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_remote),
+                        pixi_bin=pixi_bin,
+                        pixi_manifest_path=(
+                            Path(
+                                task_group.path,
+                                SOURCE_DIR_NAME,
+                                "pyproject.toml",
+                            ).as_posix()
+                        ),
+                    )
+                    logger.info("_prepare_tasks_metadata - end")
+
+                    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")
+
+                    # NOTE: see issue 2626 about whether to keep `pixi.lock`
+                    # files in the database
+                    # FIXME: Read remote file
+                    pixi_lock_contents = "FIXME\n"
+                    # with Path(
+                    #     task_group.path,
+                    #     SOURCE_DIR_NAME,
+                    #     "pixi.lock",
+                    # ).open() as f:
+                    #     pixi_lock_contents = f.read()
+
+                    # Update task_group data
+                    logger.info(
+                        "Add env_info, venv_size and venv_file_number "
+                        "to TaskGroupV2 - start"
+                    )
+                    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 remote folder {task_group.path}"
+                        )
+                        fractal_ssh.remove_folder(
+                            folder=task_group.path,
+                            safe_root=tasks_base_dir,
+                        )
+                        logger.info(
+                            f"Deleted remoted folder {task_group.path}"
+                        )
+                    except Exception as e_rm:
+                        logger.error(
+                            "Removing folder failed. "
+                            f"Original error:\n{str(e_rm)}"
+                        )
+                    fail_and_cleanup(
+                        task_group=task_group,
+                        task_group_activity=activity,
+                        log_file_path=log_file_path,
+                        logger_name=LOGGER_NAME,
+                        exception=collection_e,
+                        db=db,
+                    )

fractal_server/tasks/v2/ssh/deactivate.py

@@ -113,10 +113,10 @@ def deactivate_ssh(
                     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 "
+                            f"{task_group.env_info=}. NOTE: this should "
                             "only happen for task groups created before 2.9.0."
                         )
 
@@ -161,7 +161,7 @@ def deactivate_ssh(
                         )
                         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"
@@ -174,18 +174,19 @@ def deactivate_ssh(
                             f"Handle specific cases for {task_group.origin=}."
                         )
 
-                        # Blocking situation: `wheel_path` is not set or points
-                        # to a missing path
+                        # Blocking situation: `archive_path` is not set or
+                        # points to a missing path
                         if (
-                            task_group.wheel_path is None
+                            task_group.archive_path is None
                             or not fractal_ssh.remote_exists(
-                                task_group.wheel_path
+                                task_group.archive_path
                             )
                         ):
                             error_msg = (
                                 "Invalid wheel path for task group with "
-                                f"{task_group_id=}. {task_group.wheel_path=} "
-                                "is unset or does not exist."
+                                f"{task_group_id=}. "
+                                f"{task_group.archive_path=}  is unset or "
+                                "does not exist."
                             )
                             logger.error(error_msg)
                             fail_and_cleanup(
@@ -198,58 +199,58 @@ def deactivate_ssh(
                             )
                             return
 
-                        # Recoverable situation: `wheel_path` was not yet
+                        # Recoverable situation: `archive_path` was not yet
                         # copied over to the correct server-side folder
-                        wheel_path_parent_dir = Path(
-                            task_group.wheel_path
+                        archive_path_parent_dir = Path(
+                            task_group.archive_path
                         ).parent
-                        if wheel_path_parent_dir != Path(task_group.path):
+                        if archive_path_parent_dir != Path(task_group.path):
                             logger.warning(
-                                f"{wheel_path_parent_dir.as_posix()} differs "
-                                f"from {task_group.path}. NOTE: this should "
-                                "only happen for task groups created before "
-                                "2.9.0."
+                                f"{archive_path_parent_dir.as_posix()} "
+                                f"differs 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
+                                task_group.archive_path
+                                not in task_group.env_info
                             ):
                                 raise ValueError(
-                                    f"Cannot find {task_group.wheel_path=} in "
-                                    "pip-freeze data. Exit."
+                                    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 = _copy_wheel_file_ssh(
+                            new_archive_path = _copy_wheel_file_ssh(
                                 task_group=task_group,
                                 fractal_ssh=fractal_ssh,
                                 logger_name=LOGGER_NAME,
                             )
                             logger.info(
-                                f"Copied wheel file to {new_wheel_path}."
+                                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", see
+                    # Fail if `env_info` includes "github", 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 "
                                 f"packages with direct {forbidden_string} "

fractal_server/tasks/v2/ssh/reactivate.py

@@ -128,7 +128,7 @@ def reactivate_ssh(
                         Path(task_group.path) / "_tmp_pip_freeze.txt"
                     ).as_posix()
                     with open(pip_freeze_file_local, "w") as f:
-                        f.write(task_group.pip_freeze)
+                        f.write(task_group.env_info)
                     fractal_ssh.send_file(
                         local=pip_freeze_file_local,
                         remote=pip_freeze_file_remote,

fractal_server/tasks/v2/templates/pixi_1_collect.sh

@@ -0,0 +1,70 @@
+set -e
+
+write_log(){
+    TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+    echo "[collect-task-pixi, $TIMESTAMP] $1"
+}
+
+# Replacements
+PIXI_HOME="__PIXI_HOME__"
+PACKAGE_DIR="__PACKAGE_DIR__"
+TAR_GZ_PATH="__TAR_GZ_PATH__"
+IMPORT_PACKAGE_NAME="__IMPORT_PACKAGE_NAME__"
+SOURCE_DIR_NAME="__SOURCE_DIR_NAME__"
+
+# Strip trailing `/` from `PACKAGE_DIR`
+PIXI_HOME=${PIXI_HOME%/}
+PACKAGE_DIR=${PACKAGE_DIR%/}
+
+# Known paths
+PIXI_EXECUTABLE="${PIXI_HOME}/bin/pixi"
+SOURCE_DIR="${PACKAGE_DIR}/${SOURCE_DIR_NAME}"
+PYPROJECT_TOML="${SOURCE_DIR}/pyproject.toml"
+TAR_GZ_BASENAME=$(basename "$TAR_GZ_PATH" ".tar.gz")
+
+# Pixi env variable
+export PIXI_HOME="$PIXI_HOME"
+export PIXI_CACHE_DIR="${PIXI_HOME}/cache"
+export RATTLER_AUTH_FILE="${PIXI_HOME}/credentials.json"
+
+
+TIME_START=$(date +%s)
+
+cd "$PACKAGE_DIR"
+write_log "Changed working directory to $PACKAGE_DIR"
+
+
+write_log "START 'tar xz -f $TAR_GZ_PATH $TAR_GZ_BASENAME'"
+tar xz -f "$TAR_GZ_PATH" "$TAR_GZ_BASENAME"
+write_log "END   'tar xz -f $TAR_GZ_PATH $TAR_GZ_BASENAME'"
+echo
+
+write_log "START 'mv ${PACKAGE_DIR}/${TAR_GZ_BASENAME} $SOURCE_DIR'"
+mv "${PACKAGE_DIR}/${TAR_GZ_BASENAME}" "$SOURCE_DIR"
+write_log "END   'mv ${PACKAGE_DIR}/${TAR_GZ_BASENAME} $SOURCE_DIR'"
+echo
+write_log "END extract $TAR_GZ_PATH"
+TIME_END_TAR=$(date +%s)
+write_log "Elapsed: $((TIME_END_TAR - TIME_START)) seconds"
+echo
+
+write_log "START '$PIXI_EXECUTABLE install --manifest-path $PYPROJECT_TOML'"
+${PIXI_EXECUTABLE} install --manifest-path "$PYPROJECT_TOML"
+write_log "END   '$PIXI_EXECUTABLE install --manifest-path $PYPROJECT_TOML'"
+echo
+
+PACKAGE_FOLDER=$(
+    ${PIXI_EXECUTABLE} run --manifest-path "$PYPROJECT_TOML" python \
+    -c "import $IMPORT_PACKAGE_NAME as p, os; print(os.path.dirname(p.__file__))"
+)
+write_log "Package folder: $PACKAGE_FOLDER"
+echo
+
+ENV_DISK_USAGE=$(du -sk "${PACKAGE_DIR}" | cut -f1)
+ENV_FILE_NUMBER=$(find "${PACKAGE_DIR}" -type f | wc -l)
+
+write_log "Disk usage: $ENV_DISK_USAGE"
+write_log "Number of files: $ENV_FILE_NUMBER"
+
+write_log "All ok, exit."
+echo

fractal_server/tasks/v2/utils_background.py

@@ -9,6 +9,7 @@ from fractal_server.app.schemas.v2 import TaskCreateV2
 from fractal_server.app.schemas.v2 import TaskGroupActivityStatusV2
 from fractal_server.app.schemas.v2.manifest import ManifestV2
 from fractal_server.app.schemas.v2.task_group import TaskGroupActivityActionV2
+from fractal_server.exceptions import UnreachableBranchError
 from fractal_server.logger import get_logger
 from fractal_server.logger import reset_logger_handlers
 from fractal_server.utils import get_timestamp
@@ -47,11 +48,13 @@ def fail_and_cleanup(
     reset_logger_handlers(logger)
 
 
-def _prepare_tasks_metadata(
+def prepare_tasks_metadata(
     *,
     package_manifest: ManifestV2,
-    python_bin: Path,
     package_root: Path,
+    python_bin: Path | None = None,
+    pixi_bin: str | None = None,
+    pixi_manifest_path: str | None = None,
     package_version: str | None = None,
 ) -> list[TaskCreateV2]:
     """
@@ -59,10 +62,20 @@ def _prepare_tasks_metadata(
 
     Args:
         package_manifest:
-        python_bin:
         package_root:
         package_version:
+        python_bin:
+        pixi_bin:
     """
+    if bool(pixi_bin is None) == bool(python_bin is None):
+        raise UnreachableBranchError(
+            f"Either {pixi_bin} or {python_bin} must be set."
+        )
+    if pixi_bin is not None and pixi_manifest_path is None:
+        raise UnreachableBranchError(
+            f"If {pixi_bin} is set, pixi_manifest_path must be set."
+        )
+
     task_list = []
     for _task in package_manifest.task_list:
         # Set non-command attributes
@@ -76,14 +89,29 @@ def _prepare_tasks_metadata(
         # Set command attributes
         if _task.executable_non_parallel is not None:
             non_parallel_path = package_root / _task.executable_non_parallel
-            task_attributes["command_non_parallel"] = (
-                f"{python_bin.as_posix()} " f"{non_parallel_path.as_posix()}"
-            )
+            if python_bin is not None:
+                cmd_non_parallel = (
+                    f"{python_bin.as_posix()} {non_parallel_path.as_posix()}"
+                )
+            else:
+                cmd_non_parallel = (
+                    f"{pixi_bin} run --manifest-path {pixi_manifest_path} "
+                    "--no-lockfile-update python "
+                    f"{non_parallel_path.as_posix()}"
+                )
+            task_attributes["command_non_parallel"] = cmd_non_parallel
         if _task.executable_parallel is not None:
             parallel_path = package_root / _task.executable_parallel
-            task_attributes[
-                "command_parallel"
-            ] = f"{python_bin.as_posix()} {parallel_path.as_posix()}"
+            if python_bin is not None:
+                cmd_parallel = (
+                    f"{python_bin.as_posix()} {parallel_path.as_posix()}"
+                )
+            else:
+                cmd_parallel = (
+                    f"{pixi_bin} run --manifest-path {pixi_manifest_path} "
+                    f"--no-lockfile-update python {parallel_path.as_posix()}"
+                )
+            task_attributes["command_parallel"] = cmd_parallel
         # Create object
         task_obj = TaskCreateV2(
             **_task.model_dump(

fractal_server/tasks/v2/utils_pixi.py

@@ -0,0 +1,36 @@
+from typing import TypedDict
+
+SOURCE_DIR_NAME = "source_dir"
+
+
+class ParsedOutput(TypedDict):
+    package_root: str
+    venv_size: str
+    venv_file_number: str
+
+
+def parse_collect_stdout(stdout: str) -> ParsedOutput:
+    """
+    Parse standard output of `pixi/1_collect.sh`
+    """
+    searches = [
+        ("Package folder:", "package_root"),
+        ("Disk usage:", "venv_size"),
+        ("Number of files:", "venv_file_number"),
+    ]
+    stdout_lines = stdout.splitlines()
+    attributes = dict()
+    for search, attribute_name in searches:
+        matching_lines = [_line for _line in stdout_lines if search in _line]
+        if len(matching_lines) == 0:
+            raise ValueError(f"String '{search}' not found in stdout.")
+        elif len(matching_lines) > 1:
+            raise ValueError(
+                f"String '{search}' found too many times "
+                f"({len(matching_lines)})."
+            )
+        else:
+            actual_line = matching_lines[0]
+            attribute_value = actual_line.split(search)[-1].strip(" ")
+            attributes[attribute_name] = attribute_value
+    return attributes

{fractal_server-2.14.16.dist-info → fractal_server-2.15.0a0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fractal-server
-Version: 2.14.16
+Version: 2.15.0a0
 Summary: Backend component of the Fractal analytics platform
 License: BSD-3-Clause
 Author: Tommaso Comparin