fractal-server 2.9.0a0__tar.gz → 2.9.0a2__tar.gz

{fractal_server-2.9.0a0 → fractal_server-2.9.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fractal-server
-Version: 2.9.0a0
+Version: 2.9.0a2
 Summary: Server component of the Fractal analytics platform
 Home-page: https://github.com/fractal-analytics-platform/fractal-server
 License: BSD-3-Clause
@@ -12,7 +12,6 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: aiosqlite (>=0.19.0,<0.20.0)
 Requires-Dist: alembic (>=1.13.1,<2.0.0)
 Requires-Dist: bcrypt (==4.0.1)
 Requires-Dist: cloudpickle (>=3.0.0,<3.1.0)

fractal_server-2.9.0a2/fractal_server/__init__.py

@@ -0,0 +1 @@
+__VERSION__ = "2.9.0a2"

{fractal_server-2.9.0a0 → fractal_server-2.9.0a2}/fractal_server/app/db/__init__.py

@@ -2,17 +2,14 @@
 `db` module, loosely adapted from
 https://testdriven.io/blog/fastapi-sqlmodel/#async-sqlmodel
 """
-import sqlite3
 from typing import AsyncGenerator
 from typing import Generator
 
 from sqlalchemy import create_engine
-from sqlalchemy import event
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.ext.asyncio import create_async_engine
 from sqlalchemy.orm import Session as DBSyncSession
 from sqlalchemy.orm import sessionmaker
-from sqlalchemy.pool import StaticPool
 
 from ...config import get_settings
 from ...logger import set_logger
@@ -21,14 +18,6 @@ from ...syringe import Inject
 
 logger = set_logger(__name__)
 
-SQLITE_WARNING_MESSAGE = (
-    "SQLite is supported (supported version >=3.37, "
-    f"current {sqlite3.sqlite_version=}) "
-    "but discouraged in production. "
-    "Given its partial support for ForeignKey constraints, "
-    "database consistency cannot be guaranteed."
-)
-
 
 class DB:
     """
@@ -56,14 +45,7 @@ class DB:
         settings = Inject(get_settings)
         settings.check_db()
 
-        if settings.DB_ENGINE == "sqlite":
-            logger.warning(SQLITE_WARNING_MESSAGE)
-            # Set some sqlite-specific options
-            engine_kwargs_async = dict(poolclass=StaticPool)
-        else:
-            engine_kwargs_async = {
-                "pool_pre_ping": True,
-            }
+        engine_kwargs_async = {"pool_pre_ping": True}
 
         cls._engine_async = create_async_engine(
             settings.DATABASE_ASYNC_URL,
@@ -83,15 +65,7 @@ class DB:
         settings = Inject(get_settings)
         settings.check_db()
 
-        if settings.DB_ENGINE == "sqlite":
-            logger.warning(SQLITE_WARNING_MESSAGE)
-            # Set some sqlite-specific options
-            engine_kwargs_sync = dict(
-                poolclass=StaticPool,
-                connect_args={"check_same_thread": False},
-            )
-        else:
-            engine_kwargs_sync = {}
+        engine_kwargs_sync = {}
 
         cls._engine_sync = create_engine(
             settings.DATABASE_SYNC_URL,
@@ -107,13 +81,6 @@ class DB:
             future=True,
         )
 
-        @event.listens_for(cls._engine_sync, "connect")
-        def set_sqlite_pragma(dbapi_connection, connection_record):
-            if settings.DB_ENGINE == "sqlite":
-                cursor = dbapi_connection.cursor()
-                cursor.execute("PRAGMA journal_mode=WAL")
-                cursor.close()
-
     @classmethod
     async def get_async_db(cls) -> AsyncGenerator[AsyncSession, None]:
         """

{fractal_server-2.9.0a0 → fractal_server-2.9.0a2}/fractal_server/app/models/v2/task_group.py

@@ -48,6 +48,10 @@ class TaskGroupV2(SQLModel, table=True):
         default_factory=get_timestamp,
         sa_column=Column(DateTime(timezone=True), nullable=False),
     )
+    timestamp_last_used: Optional[datetime] = Field(
+        default=None,
+        sa_column=Column(DateTime(timezone=True), nullable=True),
+    )
 
     @property
     def pip_install_string(self) -> str:

{fractal_server-2.9.0a0 → fractal_server-2.9.0a2}/fractal_server/app/routes/api/v2/_aux_functions_tasks.py

@@ -221,27 +221,30 @@ async def _get_valid_user_group_id(
 
 
 async def _get_collection_task_group_activity_status_message(
-    task_group: TaskGroupV2, db: AsyncSession
+    task_group_id: int,
+    db: AsyncSession,
 ) -> str:
+
     res = await db.execute(
-        select(TaskGroupActivityV2).where(
-            TaskGroupActivityV2.taskgroupv2_id == task_group.id
-            and TaskGroupActivityV2.action == TaskGroupActivityActionV2.COLLECT
-        )
+        select(TaskGroupActivityV2)
+        .where(TaskGroupActivityV2.taskgroupv2_id == task_group_id)
+        .where(TaskGroupActivityV2.action == TaskGroupActivityActionV2.COLLECT)
     )
     task_group_activity_list = res.scalars().all()
     if len(task_group_activity_list) > 1:
         msg = (
-            "Expected one TaskGroupActivityV2 associated to TaskGroup "
-            f"{task_group.id}, found {len(task_group_activity_list)} "
-            f"(IDs: {[tga.id for tga in task_group_activity_list]}).\n"
+            "\nWarning: "
+            "Expected only one TaskGroupActivityV2 associated to TaskGroup "
+            f"{task_group_id}, found {len(task_group_activity_list)} "
+            f"(IDs: {[tga.id for tga in task_group_activity_list]})."
             "Warning: this should have not happened, please contact an admin."
         )
     elif len(task_group_activity_list) == 1:
         msg = (
-            "\nThere exists a task-group activity"
-            f"(ID={task_group_activity_list[0].id}) for "
-            f"such task group (ID={task_group.id}), with status "
+            "\nNote:"
+            "There exists another task-group collection "
+            f"(activity ID={task_group_activity_list[0].id}) for "
+            f"this task group (ID={task_group_id}), with status "
             f"'{task_group_activity_list[0].status}'."
         )
     else:
@@ -277,7 +280,7 @@ async def _verify_non_duplication_user_constraint(
                 ),
             )
         state_msg = await _get_collection_task_group_activity_status_message(
-            duplicate[0], db
+            duplicate[0].id, db
         )
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
@@ -319,7 +322,7 @@ async def _verify_non_duplication_group_constraint(
                 ),
             )
         state_msg = await _get_collection_task_group_activity_status_message(
-            duplicate[0], db
+            duplicate[0].id, db
         )
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,

{fractal_server-2.9.0a0 → fractal_server-2.9.0a2}/fractal_server/app/routes/api/v2/submit.py

@@ -30,6 +30,7 @@ from ...aux.validate_user_settings import validate_user_settings
 from ._aux_functions import _get_dataset_check_owner
 from ._aux_functions import _get_workflow_check_owner
 from ._aux_functions import clean_app_job_list_v2
+from fractal_server.app.models import TaskGroupV2
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.routes.api.v2._aux_functions_tasks import (
     _get_task_read_access,
@@ -61,6 +62,8 @@ async def apply_workflow(
     db: AsyncSession = Depends(get_async_db),
 ) -> Optional[JobReadV2]:
 
+    now = get_timestamp()
+
     # Remove non-submitted V2 jobs from the app state when the list grows
     # beyond a threshold
     settings = Inject(get_settings)
@@ -112,22 +115,23 @@ async def apply_workflow(
         )
 
     # Check that tasks have read-access and are `active`
+    used_task_group_ids = set()
     for wftask in workflow.task_list[
         first_task_index : last_task_index + 1  # noqa: E203
     ]:
-        await _get_task_read_access(
+        task = await _get_task_read_access(
             user_id=user.id,
             task_id=wftask.task_id,
             require_active=True,
             db=db,
         )
+        used_task_group_ids.add(task.taskgroupv2_id)
 
     # Validate user settings
     FRACTAL_RUNNER_BACKEND = settings.FRACTAL_RUNNER_BACKEND
     user_settings = await validate_user_settings(
         user=user, backend=FRACTAL_RUNNER_BACKEND, db=db
     )
-
     # Check that no other job with the same dataset_id is SUBMITTED
     stm = (
         select(JobV2)
@@ -184,8 +188,18 @@ async def apply_workflow(
     await db.commit()
     await db.refresh(job)
 
+    # Update TaskGroupV2.timestamp_last_used
+    res = await db.execute(
+        select(TaskGroupV2).where(TaskGroupV2.id.in_(used_task_group_ids))
+    )
+    used_task_groups = res.scalars().all()
+    for used_task_group in used_task_groups:
+        used_task_group.timestamp_last_used = now
+        db.add(used_task_group)
+    await db.commit()
+
     # Define server-side job directory
-    timestamp_string = get_timestamp().strftime("%Y%m%d_%H%M%S")
+    timestamp_string = now.strftime("%Y%m%d_%H%M%S")
     WORKFLOW_DIR_LOCAL = settings.FRACTAL_RUNNER_WORKING_BASE_DIR / (
         f"proj_v2_{project_id:07d}_wf_{workflow_id:07d}_job_{job.id:07d}"
         f"_{timestamp_string}"

{fractal_server-2.9.0a0 → fractal_server-2.9.0a2}/fractal_server/app/routes/api/v2/task_collection.py

@@ -35,7 +35,7 @@ from fractal_server.app.schemas.v2 import (
 )
 from fractal_server.app.schemas.v2 import TaskGroupV2OriginEnum
 from fractal_server.tasks.v2.local.collect import (
-    collect_package_local,
+    collect_local,
 )
 from fractal_server.tasks.v2.utils_package_names import _parse_wheel_filename
 from fractal_server.tasks.v2.utils_package_names import normalize_package_name
@@ -248,7 +248,7 @@ async def collect_tasks_pip(
         # SSH task collection
 
         from fractal_server.tasks.v2.ssh.collect import (
-            collect_package_ssh,
+            collect_ssh,
         )
 
         # User appropriate FractalSSH object
@@ -261,7 +261,7 @@ async def collect_tasks_pip(
         fractal_ssh = fractal_ssh_list.get(**ssh_credentials)
 
         background_tasks.add_task(
-            collect_package_ssh,
+            collect_ssh,
             task_group_id=task_group.id,
             task_group_activity_id=task_group_activity.id,
             fractal_ssh=fractal_ssh,
@@ -271,7 +271,7 @@ async def collect_tasks_pip(
     else:
         # Local task collection
         background_tasks.add_task(
-            collect_package_local,
+            collect_local,
             task_group_id=task_group.id,
             task_group_activity_id=task_group_activity.id,
         )

{fractal_server-2.9.0a0 → fractal_server-2.9.0a2}/fractal_server/app/routes/aux/_timestamp.py

@@ -4,15 +4,10 @@ from datetime import timezone
 from fastapi import HTTPException
 from fastapi import status
 
-from fractal_server.config import get_settings
-from fractal_server.syringe import Inject
-
 
 def _convert_to_db_timestamp(dt: datetime) -> datetime:
     """
     This function takes a timezone-aware datetime and converts it to UTC.
-    If using SQLite, it also removes the timezone information in order to make
-    the datetime comparable with datetimes in the database.
     """
     if dt.tzinfo is None:
         raise HTTPException(
@@ -20,6 +15,4 @@ def _convert_to_db_timestamp(dt: datetime) -> datetime:
             detail=f"The timestamp provided has no timezone information: {dt}",
         )
     _dt = dt.astimezone(timezone.utc)
-    if Inject(get_settings).DB_ENGINE == "sqlite":
-        return _dt.replace(tzinfo=None)
     return _dt

{fractal_server-2.9.0a0 → fractal_server-2.9.0a2}/fractal_server/app/schemas/_validators.py

@@ -108,8 +108,7 @@ def val_unique_list(attribute: str):
 def valutc(attribute: str):
     def val(timestamp: Optional[datetime]) -> Optional[datetime]:
         """
-        Replacing `tzinfo` with `timezone.utc` is just required by SQLite data.
-        If using Postgres, this function leaves the datetime exactly as it is.
+        Replace `tzinfo` with `timezone.utc`.
         """
         if timestamp is not None:
             return timestamp.replace(tzinfo=timezone.utc)

{fractal_server-2.9.0a0 → fractal_server-2.9.0a2}/fractal_server/app/schemas/v2/task_group.py

@@ -1,6 +1,5 @@
 from datetime import datetime
 from enum import Enum
-from typing import Literal
 from typing import Optional
 
 from pydantic import BaseModel
@@ -74,7 +73,7 @@ class TaskGroupReadV2(BaseModel):
     user_id: int
     user_group_id: Optional[int] = None
 
-    origin: Literal["pypi", "wheel-file", "other"]
+    origin: TaskGroupV2OriginEnum
     pkg_name: str
     version: Optional[str] = None
     python_version: Optional[str] = None
@@ -90,6 +89,7 @@ class TaskGroupReadV2(BaseModel):
 
     active: bool
     timestamp_created: datetime
+    timestamp_last_used: Optional[datetime] = None
 
 
 class TaskGroupUpdateV2(BaseModel, extra=Extra.forbid):

{fractal_server-2.9.0a0 → fractal_server-2.9.0a2}/fractal_server/config.py

@@ -16,7 +16,6 @@ import shutil
 import sys
 from os import environ
 from os import getenv
-from os.path import abspath
 from pathlib import Path
 from typing import Literal
 from typing import Optional
@@ -167,10 +166,6 @@ class Settings(BaseSettings):
     ###########################################################################
     # DATABASE
     ###########################################################################
-    DB_ENGINE: Literal["sqlite", "postgres-psycopg"] = "sqlite"
-    """
-    Database engine to use (supported: `sqlite`, `postgres-psycopg`).
-    """
     DB_ECHO: bool = False
     """
     If `True`, make database operations verbose.
@@ -196,44 +191,21 @@ class Settings(BaseSettings):
     Name of the PostgreSQL database to connect to.
     """
 
-    SQLITE_PATH: Optional[str]
-    """
-    File path where the SQLite database is located (or will be located).
-    """
-
     @property
     def DATABASE_ASYNC_URL(self) -> URL:
-        if self.DB_ENGINE == "postgres-psycopg":
-            url = URL.create(
-                drivername="postgresql+psycopg",
-                username=self.POSTGRES_USER,
-                password=self.POSTGRES_PASSWORD,
-                host=self.POSTGRES_HOST,
-                port=self.POSTGRES_PORT,
-                database=self.POSTGRES_DB,
-            )
-        else:
-            if not self.SQLITE_PATH:
-                raise FractalConfigurationError(
-                    "SQLITE_PATH path cannot be None"
-                )
-            sqlite_path = abspath(self.SQLITE_PATH)
-            url = URL.create(
-                drivername="sqlite+aiosqlite",
-                database=sqlite_path,
-            )
+        url = URL.create(
+            drivername="postgresql+psycopg",
+            username=self.POSTGRES_USER,
+            password=self.POSTGRES_PASSWORD,
+            host=self.POSTGRES_HOST,
+            port=self.POSTGRES_PORT,
+            database=self.POSTGRES_DB,
+        )
         return url
 
     @property
     def DATABASE_SYNC_URL(self):
-        if self.DB_ENGINE == "postgres-psycopg":
-            return self.DATABASE_ASYNC_URL.set(drivername="postgresql+psycopg")
-        else:
-            if not self.SQLITE_PATH:
-                raise FractalConfigurationError(
-                    "SQLITE_PATH path cannot be None"
-                )
-            return self.DATABASE_ASYNC_URL.set(drivername="sqlite")
+        return self.DATABASE_ASYNC_URL.set(drivername="postgresql+psycopg")
 
     ###########################################################################
     # FRACTAL SPECIFIC
@@ -533,25 +505,8 @@ class Settings(BaseSettings):
         """
         Checks that db environment variables are properly set.
         """
-        if self.DB_ENGINE == "postgres-psycopg":
-            if not self.POSTGRES_DB:
-                raise FractalConfigurationError(
-                    "POSTGRES_DB cannot be None when DB_ENGINE="
-                    "postgres-psycopg."
-                )
-
-            try:
-                import psycopg  # noqa: F401
-            except ModuleNotFoundError:
-                raise FractalConfigurationError(
-                    "DB engine is `postgres-psycopg` but `psycopg` is not "
-                    "available"
-                )
-        else:
-            if not self.SQLITE_PATH:
-                raise FractalConfigurationError(
-                    "SQLITE_PATH cannot be None when DB_ENGINE=sqlite."
-                )
+        if not self.POSTGRES_DB:
+            raise FractalConfigurationError("POSTGRES_DB cannot be None.")
 
     def check_runner(self) -> None:
 

{fractal_server-2.9.0a0 → fractal_server-2.9.0a2}/fractal_server/migrations/versions/3082479ac4ea_taskgroup_activity_and_venv_info_to_.py

@@ -67,6 +67,13 @@ def upgrade() -> None:
         batch_op.add_column(
             sa.Column("venv_file_number", sa.Integer(), nullable=True)
         )
+        batch_op.add_column(
+            sa.Column(
+                "timestamp_last_used",
+                sa.DateTime(timezone=True),
+                nullable=True,
+            )
+        )
 
     # ### end Alembic commands ###
 
@@ -74,6 +81,7 @@ def upgrade() -> None:
 def downgrade() -> None:
     # ### commands auto generated by Alembic - please adjust! ###
     with op.batch_alter_table("taskgroupv2", schema=None) as batch_op:
+        batch_op.drop_column("timestamp_last_used")
         batch_op.drop_column("venv_file_number")
         batch_op.drop_column("venv_size_in_kB")
         batch_op.drop_column("pip_freeze")

{fractal_server-2.9.0a0 → fractal_server-2.9.0a2}/fractal_server/ssh/_fabric.py

@@ -196,23 +196,57 @@ class FractalSSH(object):
         """
         Open the SSH connection and handle exceptions.
 
-        This function can be called from within other functions that use
-        `connection`, so that we can provide a meaningful error in case the
-        SSH connection cannot be opened.
+        This method should always be called at the beginning of background
+        operations that use FractalSSH, so that:
+
+        1. We try to restore unusable connections (e.g. due to closed socket).
+        2. We provide an informative error if connection cannot be established.
         """
-        if not self._connection.is_connected:
+        self.logger.debug(
+            f"[check_connection] {self._connection.is_connected=}"
+        )
+        if self._connection.is_connected:
+            # Even if the connection appears open, it could be broken for
+            # external reasons (e.g. the socket is closed because the SSH
+            # server was restarted). In these cases, we catch the error and
+            # try to re-open the connection.
             try:
-                with _acquire_lock_with_timeout(
-                    lock=self._lock,
-                    label="_connection.open",
-                    timeout=self.default_lock_timeout,
-                ):
-                    self._connection.open()
-            except Exception as e:
-                raise RuntimeError(
-                    f"Cannot open SSH connection. Original error:\n{str(e)}"
+                self.logger.info(
+                    "[check_connection] Run dummy command to check connection."
+                )
+                # Run both an SFTP and an SSH command, as they correspond to
+                # different sockets
+                self.remote_exists("/dummy/path/")
+                self.run_command(cmd="whoami")
+                self.logger.info(
+                    "[check_connection] SSH connection is already OK, exit."
+                )
+                return
+            except (OSError, EOFError) as e:
+                self.logger.warning(
+                    f"[check_connection] Detected error {str(e)}, re-open."
+                )
+        # Try opening the connection (if it was closed) or to re-open it (if
+        # an error happened).
+        try:
+            self.close()
+            with _acquire_lock_with_timeout(
+                lock=self._lock,
+                label="_connection.open",
+                timeout=self.default_lock_timeout,
+                logger_name=self.logger_name,
+            ):
+                self._connection.open()
+                self._connection.client.open_sftp()
+                self.logger.info(
+                    "[check_connection] SSH connection opened, exit."
                 )
 
+        except Exception as e:
+            raise RuntimeError(
+                f"Cannot open SSH connection. Original error:\n{str(e)}"
+            )
+
     def close(self) -> None:
         """
         Aggressively close `self._connection`.
@@ -228,9 +262,8 @@ class FractalSSH(object):
             timeout=self.default_lock_timeout,
         ):
             self._connection.close()
-
-        if self._connection.client is not None:
-            self._connection.client.close()
+            if self._connection.client is not None:
+                self._connection.client.close()
 
     def run_command(
         self,

{fractal_server-2.9.0a0 → fractal_server-2.9.0a2}/fractal_server/tasks/v2/local/__init__.py

@@ -1,3 +1,3 @@
-from .collect import collect_package_local  # noqa
+from .collect import collect_local  # noqa
 from .deactivate import deactivate_local  # noqa
 from .reactivate import reactivate_local  # noqa

{fractal_server-2.9.0a0 → fractal_server-2.9.0a2}/fractal_server/tasks/v2/local/collect.py

@@ -47,7 +47,7 @@ def _copy_wheel_file_local(task_group: TaskGroupV2) -> str:
     return dest
 
 
-def collect_package_local(
+def collect_local(
     *,
     task_group_activity_id: int,
     task_group_id: int,