fractal-server 2.16.5__py3-none-any.whl → 2.17.0__py3-none-any.whl

fractal_server/app/routes/api/v2/submit.py

@@ -10,25 +10,25 @@ from fastapi import Request
 from fastapi import status
 from sqlmodel import select
 
+from ...aux.validate_user_profile import validate_user_profile
 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 ._aux_functions_tasks import _check_type_filters_compatibility
 from fractal_server.app.db import AsyncSession
 from fractal_server.app.db import get_async_db
+from fractal_server.app.models import Profile
 from fractal_server.app.models import TaskGroupV2
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.models.v2 import JobV2
 from fractal_server.app.routes.api.v2._aux_functions_tasks import (
     _get_task_read_access,
 )
-from fractal_server.app.routes.auth import current_active_verified_user
-from fractal_server.app.routes.aux.validate_user_settings import (
-    validate_user_settings,
-)
+from fractal_server.app.routes.auth import current_user_act_ver_prof
 from fractal_server.app.schemas.v2 import JobCreateV2
 from fractal_server.app.schemas.v2 import JobReadV2
 from fractal_server.app.schemas.v2 import JobStatusTypeV2
+from fractal_server.app.schemas.v2 import ResourceType
 from fractal_server.config import get_settings
 from fractal_server.logger import set_logger
 from fractal_server.runner.set_start_and_last_task_index import (
@@ -37,7 +37,7 @@ from fractal_server.runner.set_start_and_last_task_index import (
 from fractal_server.runner.v2.submit_workflow import submit_workflow
 from fractal_server.syringe import Inject
 
-
+FRACTAL_CACHE_DIR = ".fractal_cache"
 router = APIRouter()
 logger = set_logger(__name__)
 
@@ -54,11 +54,14 @@ async def apply_workflow(
     job_create: JobCreateV2,
     background_tasks: BackgroundTasks,
     request: Request,
-    user: UserOAuth = Depends(current_active_verified_user),
+    user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
 ) -> JobReadV2 | None:
     # Remove non-submitted V2 jobs from the app state when the list grows
     # beyond a threshold
+    # NOTE: this may lead to a race condition on `app.state.jobsV2` if two
+    # requests take place at the same time and `clean_app_job_list_v2` is
+    # somewhat slow.
     settings = Inject(get_settings)
     if (
         len(request.app.state.jobsV2)
@@ -78,6 +81,17 @@ async def apply_workflow(
     project = output["project"]
     dataset = output["dataset"]
 
+    # Verify that user's resource matches with project resource
+    res = await db.execute(
+        select(Profile.resource_id).where(Profile.id == user.profile_id)
+    )
+    user_resource_id = res.scalar_one()
+    if project.resource_id != user_resource_id:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail="Project resource does not match with user's resource",
+        )
+
     workflow = await _get_workflow_check_owner(
         project_id=project_id, workflow_id=workflow_id, user_id=user.id, db=db
     )
@@ -122,11 +136,12 @@ async def apply_workflow(
         )
         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
+    # Get validated resource and profile
+    resource, profile = await validate_user_profile(
+        user=user,
+        db=db,
     )
+
     # Check that no other job with the same dataset_id is SUBMITTED
     stm = (
         select(JobV2)
@@ -144,7 +159,7 @@ async def apply_workflow(
         )
 
     if job_create.slurm_account is not None:
-        if job_create.slurm_account not in user_settings.slurm_accounts:
+        if job_create.slurm_account not in user.slurm_accounts:
             raise HTTPException(
                 status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
                 detail=(
@@ -153,15 +168,15 @@ async def apply_workflow(
                 ),
             )
     else:
-        if len(user_settings.slurm_accounts) > 0:
-            job_create.slurm_account = user_settings.slurm_accounts[0]
+        if len(user.slurm_accounts) > 0:
+            job_create.slurm_account = user.slurm_accounts[0]
 
     # User appropriate FractalSSH object
-    if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
+    if resource.type == ResourceType.SLURM_SSH:
         ssh_config = dict(
-            user=user_settings.ssh_username,
-            host=user_settings.ssh_host,
-            key_path=user_settings.ssh_private_key_path,
+            user=profile.username,
+            host=resource.host,
+            key_path=profile.ssh_key_path,
         )
         fractal_ssh_list = request.app.state.fractal_ssh_list
         try:
@@ -184,16 +199,14 @@ async def apply_workflow(
         dataset_id=dataset_id,
         workflow_id=workflow_id,
         user_email=user.email,
-        # The 'filters' field is not supported any more but still exists as a
-        # database column, therefore we manually exclude it from dumps.
         dataset_dump=json.loads(
-            dataset.model_dump_json(exclude={"images", "history", "filters"})
+            dataset.model_dump_json(exclude={"images", "history"})
         ),
         workflow_dump=json.loads(
             workflow.model_dump_json(exclude={"task_list"})
         ),
         project_dump=json.loads(
-            project.model_dump_json(exclude={"user_list"})
+            project.model_dump_json(exclude={"user_list", "resource_id"})
         ),
         **job_create.model_dump(),
     )
@@ -214,26 +227,23 @@ async def apply_workflow(
 
     # Define server-side job directory
     timestamp_string = job.start_timestamp.strftime("%Y%m%d_%H%M%S")
-    WORKFLOW_DIR_LOCAL = settings.FRACTAL_RUNNER_WORKING_BASE_DIR / (
+    WORKFLOW_DIR_LOCAL = Path(resource.jobs_local_dir) / (
         f"proj_v2_{project_id:07d}_wf_{workflow_id:07d}_job_{job.id:07d}"
         f"_{timestamp_string}"
     )
 
-    cache_dir = (
-        Path(user_settings.project_dir) / ".fractal_cache"
-        if user_settings.project_dir is not None
-        else None
-    )
-
     # Define user-side job directory
-    if FRACTAL_RUNNER_BACKEND == "local":
-        WORKFLOW_DIR_REMOTE = WORKFLOW_DIR_LOCAL
-    elif FRACTAL_RUNNER_BACKEND == "slurm":
-        WORKFLOW_DIR_REMOTE = cache_dir / WORKFLOW_DIR_LOCAL.name
-    elif FRACTAL_RUNNER_BACKEND == "slurm_ssh":
-        WORKFLOW_DIR_REMOTE = (
-            Path(user_settings.ssh_jobs_dir) / WORKFLOW_DIR_LOCAL.name
-        )
+    cache_dir = Path(user.project_dir, FRACTAL_CACHE_DIR)
+    match resource.type:
+        case ResourceType.LOCAL:
+            WORKFLOW_DIR_REMOTE = WORKFLOW_DIR_LOCAL
+        case ResourceType.SLURM_SUDO:
+            WORKFLOW_DIR_REMOTE = cache_dir / WORKFLOW_DIR_LOCAL.name
+        case ResourceType.SLURM_SSH:
+            WORKFLOW_DIR_REMOTE = Path(
+                profile.jobs_remote_dir,
+                WORKFLOW_DIR_LOCAL.name,
+            )
 
     # Update job folders in the db
     job.working_dir = WORKFLOW_DIR_LOCAL.as_posix()
@@ -241,20 +251,17 @@ async def apply_workflow(
     await db.merge(job)
     await db.commit()
 
-    # Expunge user settings from db, to use in background task
-    db.expunge(user_settings)
-
     background_tasks.add_task(
         submit_workflow,
         workflow_id=workflow.id,
         dataset_id=dataset.id,
         job_id=job.id,
         user_id=user.id,
-        user_settings=user_settings,
         worker_init=job.worker_init,
-        slurm_user=user_settings.slurm_user,
-        user_cache_dir=cache_dir.as_posix() if cache_dir else None,
+        user_cache_dir=cache_dir.as_posix(),
         fractal_ssh=fractal_ssh,
+        resource=resource,
+        profile=profile,
     )
     request.app.state.jobsV2.append(job.id)
     logger.info(

fractal_server/app/routes/api/v2/task.py

@@ -9,6 +9,8 @@ from sqlmodel import func
 from sqlmodel import or_
 from sqlmodel import select
 
+from ...aux.validate_user_profile import validate_user_profile
+from ._aux_functions import _get_user_resource_id
 from ._aux_functions_tasks import _get_task_full_access
 from ._aux_functions_tasks import _get_task_read_access
 from ._aux_functions_tasks import _get_valid_user_group_id
@@ -20,8 +22,7 @@ from fractal_server.app.models import LinkUserGroup
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.models.v2 import TaskGroupV2
 from fractal_server.app.models.v2 import TaskV2
-from fractal_server.app.routes.auth import current_active_user
-from fractal_server.app.routes.auth import current_active_verified_user
+from fractal_server.app.routes.auth import current_user_act_ver_prof
 from fractal_server.app.schemas.v2 import TaskCreateV2
 from fractal_server.app.schemas.v2 import TaskGroupV2OriginEnum
 from fractal_server.app.schemas.v2 import TaskReadV2
@@ -40,16 +41,20 @@ async def get_list_task(
     category: str | None = None,
     modality: str | None = None,
     author: str | None = None,
-    user: UserOAuth = Depends(current_active_user),
+    user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
 ) -> list[TaskReadV2]:
     """
     Get list of available tasks
     """
+
+    user_resource_id = await _get_user_resource_id(user_id=user.id, db=db)
+
     stm = (
         select(TaskV2)
         .join(TaskGroupV2)
         .where(TaskGroupV2.id == TaskV2.taskgroupv2_id)
+        .where(TaskGroupV2.resource_id == user_resource_id)
         .where(
             or_(
                 TaskGroupV2.user_id == user.id,
@@ -68,6 +73,7 @@ async def get_list_task(
     if author is not None:
         stm = stm.where(TaskV2.authors.icontains(author))
 
+    stm = stm.order_by(TaskV2.id)
     res = await db.execute(stm)
     task_list = list(res.scalars().all())
     await db.close()
@@ -82,7 +88,7 @@ async def get_list_task(
 @router.get("/{task_id}/", response_model=TaskReadV2)
 async def get_task(
     task_id: int,
-    user: UserOAuth = Depends(current_active_user),
+    user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
 ) -> TaskReadV2:
     """
@@ -96,7 +102,7 @@ async def get_task(
 async def patch_task(
     task_id: int,
     task_update: TaskUpdateV2,
-    user: UserOAuth = Depends(current_active_verified_user),
+    user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
 ) -> TaskReadV2 | None:
     """
@@ -137,13 +143,20 @@ async def create_task(
     task: TaskCreateV2,
     user_group_id: int | None = None,
     private: bool = False,
-    user: UserOAuth = Depends(current_active_verified_user),
+    user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
 ) -> TaskReadV2 | None:
     """
     Create a new task
     """
 
+    # Get validated resource and profile
+    resource, profile = await validate_user_profile(
+        user=user,
+        db=db,
+    )
+    resource_id = resource.id
+
     # Validate query parameters related to user-group ownership
     user_group_id = await _get_valid_user_group_id(
         user_group_id=user_group_id,
@@ -179,7 +192,11 @@ async def create_task(
     db_task = TaskV2(**task.model_dump(exclude_unset=True))
     pkg_name = db_task.name
     await _verify_non_duplication_user_constraint(
-        db=db, pkg_name=pkg_name, user_id=user.id, version=db_task.version
+        db=db,
+        pkg_name=pkg_name,
+        user_id=user.id,
+        version=db_task.version,
+        user_resource_id=resource_id,
     )
     await _verify_non_duplication_group_constraint(
         db=db,
@@ -190,6 +207,7 @@ async def create_task(
     db_task_group = TaskGroupV2(
         user_id=user.id,
         user_group_id=user_group_id,
+        resource_id=resource_id,
         active=True,
         task_list=[db_task],
         origin=TaskGroupV2OriginEnum.OTHER,
@@ -207,7 +225,7 @@ async def create_task(
 @router.delete("/{task_id}/", status_code=204)
 async def delete_task(
     task_id: int,
-    user: UserOAuth = Depends(current_active_user),
+    user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
 ) -> Response:
     """

fractal_server/app/routes/api/v2/task_collection.py

@@ -14,10 +14,8 @@ from pydantic import BaseModel
 from pydantic import model_validator
 from pydantic import ValidationError
 
-from .....config import get_settings
 from .....logger import reset_logger_handlers
 from .....logger import set_logger
-from .....syringe import Inject
 from ....db import AsyncSession
 from ....db import get_async_db
 from ....models.v2 import TaskGroupV2
@@ -26,7 +24,7 @@ from ....schemas.v2 import TaskCollectPipV2
 from ....schemas.v2 import TaskGroupActivityStatusV2
 from ....schemas.v2 import TaskGroupActivityV2Read
 from ....schemas.v2 import TaskGroupCreateV2Strict
-from ...aux.validate_user_settings import validate_user_settings
+from ...aux.validate_user_profile import validate_user_profile
 from ._aux_functions_task_lifecycle import get_package_version_from_pypi
 from ._aux_functions_tasks import _get_valid_user_group_id
 from ._aux_functions_tasks import _verify_non_duplication_group_constraint
@@ -34,12 +32,12 @@ from ._aux_functions_tasks import _verify_non_duplication_group_path
 from ._aux_functions_tasks import _verify_non_duplication_user_constraint
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.models.v2 import TaskGroupActivityV2
-from fractal_server.app.routes.auth import current_active_verified_user
+from fractal_server.app.routes.auth import current_user_act_ver_prof
+from fractal_server.app.schemas.v2 import ResourceType
 from fractal_server.app.schemas.v2 import (
     TaskGroupActivityActionV2,
 )
 from fractal_server.app.schemas.v2 import TaskGroupV2OriginEnum
-from fractal_server.ssh._fabric import SSHConfig
 from fractal_server.tasks.v2.local.collect import (
     collect_local,
 )
@@ -47,7 +45,7 @@ from fractal_server.tasks.v2.ssh import collect_ssh
 from fractal_server.tasks.v2.utils_package_names import _parse_wheel_filename
 from fractal_server.tasks.v2.utils_package_names import normalize_package_name
 from fractal_server.tasks.v2.utils_python_interpreter import (
-    get_python_interpreter_v2,
+    get_python_interpreter,
 )
 
 
@@ -162,14 +160,19 @@ async def collect_tasks_pip(
     request_data: CollectionRequestData = Depends(parse_request_data),
     private: bool = False,
     user_group_id: int | None = None,
-    user: UserOAuth = Depends(current_active_verified_user),
+    user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
 ) -> TaskGroupActivityV2Read:
     """
     Task-collection endpoint
     """
-    # Get settings
-    settings = Inject(get_settings)
+
+    # Get validated resource and profile
+    resource, profile = await validate_user_profile(
+        user=user,
+        db=db,
+    )
+    resource_id = resource.id
 
     # Get some validated request data
     task_collect = request_data.task_collect
@@ -177,26 +180,28 @@ async def collect_tasks_pip(
     # Initialize task-group attributes
     task_group_attrs = dict(
         user_id=user.id,
+        resource_id=resource_id,
         origin=request_data.origin,
     )
 
     # Set/check python version
     if task_collect.python_version is None:
-        task_group_attrs[
-            "python_version"
-        ] = settings.FRACTAL_TASKS_PYTHON_DEFAULT_VERSION
+        task_group_attrs["python_version"] = resource.tasks_python_config[
+            "default_version"
+        ]
     else:
         task_group_attrs["python_version"] = task_collect.python_version
     try:
-        get_python_interpreter_v2(
-            python_version=task_group_attrs["python_version"]
+        get_python_interpreter(
+            python_version=task_group_attrs["python_version"],
+            resource=resource,
         )
     except ValueError:
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
             detail=(
-                f"Python version {task_group_attrs['python_version']} is "
-                "not available for Fractal task collection."
+                f"Python version {task_group_attrs['python_version']} "
+                "is not available on this Fractal instance."
             ),
         )
 
@@ -259,16 +264,11 @@ async def collect_tasks_pip(
     # Set user_group_id
     task_group_attrs["user_group_id"] = user_group_id
 
-    # Validate user settings (backend-specific)
-    user_settings = await validate_user_settings(
-        user=user, backend=settings.FRACTAL_RUNNER_BACKEND, db=db
-    )
-
     # Set path and venv_path
-    if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
-        base_tasks_path = user_settings.ssh_tasks_dir
+    if resource.type == ResourceType.SLURM_SSH:
+        base_tasks_path = profile.tasks_remote_dir
     else:
-        base_tasks_path = settings.FRACTAL_TASKS_DIR.as_posix()
+        base_tasks_path = resource.tasks_local_dir
     task_group_path = (
         Path(base_tasks_path)
         / str(user.id)
@@ -294,6 +294,7 @@ async def collect_tasks_pip(
         user_id=user.id,
         pkg_name=task_group_attrs["pkg_name"],
         version=task_group_attrs["version"],
+        user_resource_id=resource_id,
         db=db,
     )
     await _verify_non_duplication_group_constraint(
@@ -304,12 +305,13 @@ async def collect_tasks_pip(
     )
     await _verify_non_duplication_group_path(
         path=task_group_attrs["path"],
+        resource_id=resource_id,
         db=db,
     )
 
     # On-disk checks
 
-    if settings.FRACTAL_RUNNER_BACKEND != "slurm_ssh":
+    if resource.type != ResourceType.SLURM_SSH:
         # Verify that folder does not exist (for local collection)
         if Path(task_group_path).exists():
             raise HTTPException(
@@ -340,33 +342,20 @@ async def collect_tasks_pip(
 
     # END of SSH/non-SSH common part
 
-    if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
-        # SSH task collection
-        # Use appropriate FractalSSH object
-        ssh_config = SSHConfig(
-            user=user_settings.ssh_username,
-            host=user_settings.ssh_host,
-            key_path=user_settings.ssh_private_key_path,
-        )
-
-        background_tasks.add_task(
-            collect_ssh,
-            task_group_id=task_group.id,
-            task_group_activity_id=task_group_activity.id,
-            ssh_config=ssh_config,
-            tasks_base_dir=user_settings.ssh_tasks_dir,
-            wheel_file=wheel_file,
-        )
-
+    if resource.type == ResourceType.SLURM_SSH:
+        collect_function = collect_ssh
     else:
-        # Local task collection
+        collect_function = collect_local
+
+    background_tasks.add_task(
+        collect_function,
+        task_group_id=task_group.id,
+        task_group_activity_id=task_group_activity.id,
+        wheel_file=wheel_file,
+        resource=resource,
+        profile=profile,
+    )
 
-        background_tasks.add_task(
-            collect_local,
-            task_group_id=task_group.id,
-            task_group_activity_id=task_group_activity.id,
-            wheel_file=wheel_file,
-        )
     logger.debug(
         "Task-collection endpoint: start background collection "
         "and return task_group_activity"

fractal_server/app/routes/api/v2/task_collection_custom.py

@@ -9,22 +9,22 @@ from fastapi import HTTPException
 from fastapi import status
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from ...aux.validate_user_profile import validate_user_profile
 from ._aux_functions_tasks import _get_valid_user_group_id
 from ._aux_functions_tasks import _verify_non_duplication_group_constraint
 from ._aux_functions_tasks import _verify_non_duplication_user_constraint
 from fractal_server.app.db import get_async_db
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.models.v2 import TaskGroupV2
-from fractal_server.app.routes.auth import current_active_verified_user
+from fractal_server.app.routes.auth import current_user_act_ver_prof
+from fractal_server.app.schemas.v2 import ResourceType
 from fractal_server.app.schemas.v2 import TaskCollectCustomV2
 from fractal_server.app.schemas.v2 import TaskCreateV2
 from fractal_server.app.schemas.v2 import TaskGroupCreateV2
 from fractal_server.app.schemas.v2 import TaskGroupV2OriginEnum
 from fractal_server.app.schemas.v2 import TaskReadV2
-from fractal_server.config import get_settings
 from fractal_server.logger import set_logger
 from fractal_server.string_tools import validate_cmd
-from fractal_server.syringe import Inject
 from fractal_server.tasks.v2.utils_background import (
     prepare_tasks_metadata,
 )
@@ -44,10 +44,12 @@ async def collect_task_custom(
     task_collect: TaskCollectCustomV2,
     private: bool = False,
     user_group_id: int | None = None,
-    user: UserOAuth = Depends(current_active_verified_user),
+    user: UserOAuth = Depends(current_user_act_ver_prof),
     db: AsyncSession = Depends(get_async_db),
 ) -> list[TaskReadV2]:
-    settings = Inject(get_settings)
+    # Get validated resource and profile
+    resource, profile = await validate_user_profile(user=user, db=db)
+    resource_id = resource.id
 
     # Validate query parameters related to user-group ownership
     user_group_id = await _get_valid_user_group_id(
@@ -57,7 +59,7 @@ async def collect_task_custom(
         db=db,
     )
 
-    if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
+    if resource.type == ResourceType.SLURM_SSH:
         if task_collect.package_root is None:
             raise HTTPException(
                 status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
@@ -150,6 +152,7 @@ async def collect_task_custom(
         user_id=user.id,
         user_group_id=user_group_id,
         version=task_collect.version,
+        resource_id=resource_id,
     )
     TaskGroupCreateV2(**task_group_attrs)
 
@@ -158,6 +161,7 @@ async def collect_task_custom(
         user_id=user.id,
         pkg_name=task_group_attrs["pkg_name"],
         version=task_group_attrs["version"],
+        user_resource_id=resource_id,
         db=db,
     )
     await _verify_non_duplication_group_constraint(