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

fractal_server/app/routes/admin/v2/resource.py

@@ -0,0 +1,229 @@
+from fastapi import APIRouter
+from fastapi import Depends
+from fastapi import HTTPException
+from fastapi import Response
+from fastapi import status
+from sqlmodel import func
+from sqlmodel import select
+
+from ._aux_functions import _check_resource_name
+from ._aux_functions import _get_resource_or_404
+from .profile import _check_profile_name
+from fractal_server.app.db import AsyncSession
+from fractal_server.app.db import get_async_db
+from fractal_server.app.models import UserOAuth
+from fractal_server.app.models.v2 import Profile
+from fractal_server.app.models.v2 import Resource
+from fractal_server.app.routes.auth import current_active_superuser
+from fractal_server.app.schemas.v2 import ProfileCreate
+from fractal_server.app.schemas.v2 import ProfileRead
+from fractal_server.app.schemas.v2 import ResourceCreate
+from fractal_server.app.schemas.v2 import ResourceRead
+from fractal_server.config import get_settings
+from fractal_server.syringe import Inject
+
+router = APIRouter()
+
+
+def _check_resource_type_match_or_422(
+    resource: Resource,
+    new_profile: ProfileCreate,
+) -> None:
+    if resource.type != new_profile.resource_type:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail=(
+                f"{resource.type=} differs from {new_profile.resource_type=}."
+            ),
+        )
+
+
+def _check_type_match_or_422(new_resource: ResourceCreate) -> None:
+    """
+    Handle case where `resource.type != FRACTAL_RUNNER_BACKEND`
+    """
+    settings = Inject(get_settings)
+    if settings.FRACTAL_RUNNER_BACKEND != new_resource.type:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail=(
+                f"{settings.FRACTAL_RUNNER_BACKEND=} != "
+                f"{new_resource.type=}"
+            ),
+        )
+
+
+@router.get("/", response_model=list[ResourceRead], status_code=200)
+async def get_resource_list(
+    superuser: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> list[ResourceRead]:
+    """
+    Query `Resource` table.
+    """
+
+    stm = select(Resource)
+    res = await db.execute(stm)
+    resource_list = res.scalars().all()
+
+    return resource_list
+
+
+@router.get("/{resource_id}/", response_model=ResourceRead, status_code=200)
+async def get_resource(
+    resource_id: int,
+    superuser: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> ResourceRead:
+    """
+    Query single `Resource`.
+    """
+    resource = await _get_resource_or_404(resource_id=resource_id, db=db)
+
+    return resource
+
+
+@router.post("/", response_model=ResourceRead, status_code=201)
+async def post_resource(
+    resource_create: ResourceCreate,
+    superuser: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> ResourceRead:
+    """
+    Create new `Resource`.
+    """
+
+    # Handle case where type!=FRACTAL_RUNNER_BACKEND
+    _check_type_match_or_422(resource_create)
+
+    await _check_resource_name(name=resource_create.name, db=db)
+
+    resource = Resource(**resource_create.model_dump())
+    db.add(resource)
+    await db.commit()
+    await db.refresh(resource)
+
+    return resource
+
+
+@router.put(
+    "/{resource_id}/",
+    response_model=ResourceRead,
+    status_code=200,
+)
+async def put_resource(
+    resource_id: int,
+    resource_update: ResourceCreate,
+    superuser: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> ResourceRead:
+    """
+    Overwrite a single `Resource`.
+    """
+
+    # Handle case where type!=FRACTAL_RUNNER_BACKEND
+    _check_type_match_or_422(resource_update)
+
+    resource = await _get_resource_or_404(resource_id=resource_id, db=db)
+
+    # Handle non-unique resource names
+    if resource_update.name and resource_update.name != resource.name:
+        await _check_resource_name(name=resource_update.name, db=db)
+
+    # Prepare new db object
+    for key, value in resource_update.model_dump().items():
+        setattr(resource, key, value)
+
+    await db.commit()
+    await db.refresh(resource)
+    return resource
+
+
+@router.delete("/{resource_id}/", status_code=204)
+async def delete_resource(
+    resource_id: int,
+    superuser: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+):
+    """
+    Delete single `Resource`.
+    """
+    resource = await _get_resource_or_404(resource_id=resource_id, db=db)
+
+    # Fail if at least one Profile is associated with the Resource.
+    res = await db.execute(
+        select(func.count(Profile.id)).where(
+            Profile.resource_id == resource_id
+        )
+    )
+    associated_profile_count = res.scalar()
+    if associated_profile_count > 0:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail=(
+                f"Cannot delete Resource {resource_id} because it's associated"
+                f" with {associated_profile_count} Profiles."
+            ),
+        )
+
+    # Delete
+    await db.delete(resource)
+    await db.commit()
+
+    return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+
+@router.get(
+    "/{resource_id}/profile/",
+    response_model=list[ProfileRead],
+    status_code=200,
+)
+async def get_resource_profiles(
+    resource_id: int,
+    superuser: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> list[ProfileRead]:
+    """
+    Query `Profile`s for single `Resource`.
+    """
+    await _get_resource_or_404(resource_id=resource_id, db=db)
+
+    res = await db.execute(
+        select(Profile).where(Profile.resource_id == resource_id)
+    )
+    profiles = res.scalars().all()
+
+    return profiles
+
+
+@router.post(
+    "/{resource_id}/profile/",
+    response_model=ProfileRead,
+    status_code=201,
+)
+async def post_profile(
+    resource_id: int,
+    profile_create: ProfileCreate,
+    superuser: UserOAuth = Depends(current_active_superuser),
+    db: AsyncSession = Depends(get_async_db),
+) -> ProfileRead:
+    """
+    Create new `Profile`.
+    """
+    resource = await _get_resource_or_404(resource_id=resource_id, db=db)
+
+    _check_resource_type_match_or_422(
+        resource=resource,
+        new_profile=profile_create,
+    )
+    await _check_profile_name(name=profile_create.name, db=db)
+
+    profile = Profile(
+        resource_id=resource_id,
+        **profile_create.model_dump(),
+    )
+
+    db.add(profile)
+    await db.commit()
+    await db.refresh(profile)
+    return profile

fractal_server/app/routes/admin/v2/task_group_lifecycle.py

@@ -22,17 +22,15 @@ from fractal_server.app.routes.api.v2._aux_functions_tasks import (
     _get_task_group_or_404,
 )
 from fractal_server.app.routes.auth import current_active_superuser
-from fractal_server.app.routes.aux.validate_user_settings import (
-    validate_user_settings,
+from fractal_server.app.routes.aux.validate_user_profile import (
+    validate_user_profile,
 )
+from fractal_server.app.schemas.v2 import ResourceType
 from fractal_server.app.schemas.v2 import TaskGroupActivityActionV2
 from fractal_server.app.schemas.v2 import TaskGroupActivityStatusV2
 from fractal_server.app.schemas.v2 import TaskGroupActivityV2Read
 from fractal_server.app.schemas.v2 import TaskGroupV2OriginEnum
-from fractal_server.config import get_settings
 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.local import deactivate_local
 from fractal_server.tasks.v2.local import delete_local
 from fractal_server.tasks.v2.local import reactivate_local
@@ -114,34 +112,23 @@ async def deactivate_task_group(
     db.add(task_group_activity)
     await db.commit()
 
-    # Submit background task
-    settings = Inject(get_settings)
-    if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
-        # Validate user settings (backend-specific)
-        user = await db.get(UserOAuth, task_group.user_id)
-        user_settings = await validate_user_settings(
-            user=user, backend=settings.FRACTAL_RUNNER_BACKEND, db=db
-        )
-        # User appropriate FractalSSH object
-        ssh_config = SSHConfig(
-            user=user_settings.ssh_username,
-            host=user_settings.ssh_host,
-            key_path=user_settings.ssh_private_key_path,
-        )
+    user = await db.get(UserOAuth, task_group.user_id)
+    # Get validated resource and profile
+    resource, profile = await validate_user_profile(user=user, db=db)
 
-        background_tasks.add_task(
-            deactivate_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,
-        )
+    # Submit background task
+    if resource.type == ResourceType.SLURM_SSH:
+        deactivate_function = deactivate_ssh
     else:
-        background_tasks.add_task(
-            deactivate_local,
-            task_group_id=task_group.id,
-            task_group_activity_id=task_group_activity.id,
-        )
+        deactivate_function = deactivate_local
+
+    background_tasks.add_task(
+        deactivate_function,
+        task_group_id=task_group.id,
+        task_group_activity_id=task_group_activity.id,
+        resource=resource,
+        profile=profile,
+    )
 
     logger.debug(
         "Admin task group deactivation endpoint: start deactivate "
@@ -229,34 +216,24 @@ async def reactivate_task_group(
     db.add(task_group_activity)
     await db.commit()
 
-    # Submit background task
-    settings = Inject(get_settings)
-    if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
-        # Validate user settings (backend-specific)
-        user = await db.get(UserOAuth, task_group.user_id)
-        user_settings = await validate_user_settings(
-            user=user, backend=settings.FRACTAL_RUNNER_BACKEND, db=db
-        )
-        # 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,
-        )
+    # Get validated resource and profile
+    user = await db.get(UserOAuth, task_group.user_id)
+    resource, profile = await validate_user_profile(user=user, db=db)
 
-        background_tasks.add_task(
-            reactivate_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,
-        )
+    # Submit background task
+    if resource.type == ResourceType.SLURM_SSH:
+        reactivate_function = reactivate_ssh
     else:
-        background_tasks.add_task(
-            reactivate_local,
-            task_group_id=task_group.id,
-            task_group_activity_id=task_group_activity.id,
-        )
+        reactivate_function = reactivate_local
+
+    background_tasks.add_task(
+        reactivate_function,
+        task_group_id=task_group.id,
+        task_group_activity_id=task_group_activity.id,
+        resource=resource,
+        profile=profile,
+    )
+
     logger.debug(
         "Admin task group reactivation endpoint: start reactivate "
         "and return task_group_activity"
@@ -292,33 +269,22 @@ async def delete_task_group(
     db.add(task_group_activity)
     await db.commit()
 
-    settings = Inject(get_settings)
-    if settings.FRACTAL_RUNNER_BACKEND == "slurm_ssh":
-        # Validate user settings (backend-specific)
-        task_owner = await db.get(UserOAuth, task_group.user_id)
-        task_owner_settings = await validate_user_settings(
-            user=task_owner, backend=settings.FRACTAL_RUNNER_BACKEND, db=db
-        )
-        # Use appropriate FractalSSH object
-        ssh_config = SSHConfig(
-            user=task_owner_settings.ssh_username,
-            host=task_owner_settings.ssh_host,
-            key_path=task_owner_settings.ssh_private_key_path,
-        )
+    # Get validated resource and profile
+    task_owner = await db.get(UserOAuth, task_group.user_id)
+    resource, profile = await validate_user_profile(user=task_owner, db=db)
 
-        background_tasks.add_task(
-            delete_ssh,
-            task_group_id=task_group.id,
-            task_group_activity_id=task_group_activity.id,
-            ssh_config=ssh_config,
-            tasks_base_dir=task_owner_settings.ssh_tasks_dir,
-        )
+    if resource.type == ResourceType.SLURM_SSH:
+        delete_function = delete_ssh
     else:
-        background_tasks.add_task(
-            delete_local,
-            task_group_id=task_group.id,
-            task_group_activity_id=task_group_activity.id,
-        )
+        delete_function = delete_local
+
+    background_tasks.add_task(
+        delete_function,
+        task_group_activity_id=task_group_activity.id,
+        task_group_id=task_group.id,
+        resource=resource,
+        profile=profile,
+    )
     logger.debug(
         "Admin task group deletion endpoint: start deletion "
         "and return task_group_activity"

fractal_server/app/routes/api/__init__.py

@@ -4,25 +4,44 @@
 from fastapi import APIRouter
 from fastapi import Depends
 
-from ....config import get_settings
-from ....syringe import Inject
+import fractal_server
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.routes.auth import current_active_superuser
-
+from fractal_server.config import get_db_settings
+from fractal_server.config import get_email_settings
+from fractal_server.config import get_settings
+from fractal_server.syringe import Inject
 
 router_api = APIRouter()
 
 
 @router_api.get("/alive/")
 async def alive():
-    settings = Inject(get_settings)
     return dict(
         alive=True,
-        version=settings.PROJECT_VERSION,
+        version=fractal_server.__VERSION__,
     )
 
 
-@router_api.get("/settings/")
-async def view_settings(user: UserOAuth = Depends(current_active_superuser)):
+@router_api.get("/settings/app/")
+async def view_settings(
+    user: UserOAuth = Depends(current_active_superuser),
+):
     settings = Inject(get_settings)
     return settings.model_dump()
+
+
+@router_api.get("/settings/database/")
+async def view_db_settings(
+    user: UserOAuth = Depends(current_active_superuser),
+):
+    settings = Inject(get_db_settings)
+    return settings.model_dump()
+
+
+@router_api.get("/settings/email/")
+async def view_email_settings(
+    user: UserOAuth = Depends(current_active_superuser),
+):
+    settings = Inject(get_email_settings)
+    return settings.model_dump()

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

@@ -11,7 +11,6 @@ from sqlalchemy.orm.attributes import flag_modified
 from sqlmodel import select
 from sqlmodel.sql.expression import SelectOfScalar
 
-from ....db import AsyncSession
 from ....models.v2 import DatasetV2
 from ....models.v2 import JobV2
 from ....models.v2 import LinkUserProjectV2
@@ -20,6 +19,10 @@ from ....models.v2 import TaskV2
 from ....models.v2 import WorkflowTaskV2
 from ....models.v2 import WorkflowV2
 from ....schemas.v2 import JobStatusTypeV2
+from fractal_server.app.db import AsyncSession
+from fractal_server.app.models import Profile
+from fractal_server.app.models import Resource
+from fractal_server.app.models import UserOAuth
 from fractal_server.logger import set_logger
 
 logger = set_logger(__name__)
@@ -538,3 +541,26 @@ async def _get_submitted_job_or_none(
             status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
             detail=error_msg,
         )
+
+
+async def _get_resource_and_profile_ids(
+    *,
+    user_id: int,
+    db: AsyncSession,
+) -> tuple[int, int] | tuple[None, None]:
+    """
+    Get `(resource_id, profile_id)` pair for a given user, or `(None,None)`.
+    """
+    stm = (
+        select(Resource.id, Profile.id)
+        .join(UserOAuth)
+        .where(Resource.id == Profile.resource_id)
+        .where(Profile.id == UserOAuth.profile_id)
+        .where(UserOAuth.id == user_id)
+    )
+    res = await db.execute(stm)
+    data = res.one_or_none()
+    if data is None:
+        return (None, None)
+    else:
+        return tuple(data)

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

@@ -32,7 +32,7 @@ async def get_history_unit_or_404(
     """
     Get an existing HistoryUnit  or raise a 404.
 
-    Arguments:
+    Args:
         history_unit_id: The `HistoryUnit` id
         db: An asynchronous db session
     """
@@ -51,7 +51,7 @@ async def get_history_run_or_404(
     """
     Get an existing HistoryRun  or raise a 404.
 
-    Arguments:
+    Args:
         history_run_id:
         db:
     """

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

@@ -59,7 +59,7 @@ async def get_package_version_from_pypi(
 
     Ref https://warehouse.pypa.io/api-reference/json.html.
 
-    Arguments:
+    Args:
         name: Package name.
         version:
             Could be a correct version (`1.3.0`), an incomplete one
@@ -165,7 +165,7 @@ async def check_no_ongoing_activity(
     """
     Find ongoing activities for the same task group.
 
-    Arguments:
+    Args:
         task_group_id:
         db:
     """
@@ -204,7 +204,7 @@ async def check_no_submitted_job(
     """
     Find submitted jobs which include tasks from a given task group.
 
-    Arguments:
+    Args:
         task_group_id: ID of the `TaskGroupV2` object.
         db: Asynchronous database session.
     """

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

@@ -33,7 +33,7 @@ async def _get_task_group_or_404(
     """
     Get an existing task group or raise a 404.
 
-    Arguments:
+    Args:
         task_group_id: The TaskGroupV2 id
         db: An asynchronous db session
     """
@@ -55,7 +55,7 @@ async def _get_task_group_read_access(
     """
     Get a task group or raise a 403 if user has no read access.
 
-    Arguments:
+    Args:
         task_group_id: ID of the required task group.
         user_id: ID of the current user.
         db: An asynchronous db session.
@@ -100,7 +100,7 @@ async def _get_task_group_full_access(
     """
     Get a task group or raise a 403 if user has no full access.
 
-    Arguments:
+    Args:
         task_group_id: ID of the required task group.
         user_id: ID of the current user.
         db: An asynchronous db session
@@ -125,7 +125,7 @@ async def _get_task_or_404(*, task_id: int, db: AsyncSession) -> TaskV2:
     """
     Get an existing task or raise a 404.
 
-    Arguments:
+    Args:
         task_id: ID of the required task.
         db: An asynchronous db session
     """
@@ -147,7 +147,7 @@ async def _get_task_full_access(
     """
     Get an existing task or raise a 404.
 
-    Arguments:
+    Args:
         task_id: ID of the required task.
         user_id: ID of the current user.
         db: An asynchronous db session.
@@ -169,7 +169,7 @@ async def _get_task_read_access(
     """
     Get an existing task or raise a 404.
 
-    Arguments:
+    Args:
         task_id: ID of the required task.
         user_id: ID of the current user.
         db: An asynchronous db session.
@@ -198,7 +198,7 @@ async def _get_valid_user_group_id(
     """
     Validate query parameters for endpoints that create some task(s).
 
-    Arguments:
+    Args:
         user_group_id:
         private:
         user_id: ID of the current user

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

@@ -17,6 +17,7 @@ from ....schemas.v2 import ProjectReadV2
 from ....schemas.v2 import ProjectUpdateV2
 from ._aux_functions import _check_project_exists
 from ._aux_functions import _get_project_check_owner
+from ._aux_functions import _get_resource_and_profile_ids
 from ._aux_functions import _get_submitted_jobs_statement
 from fractal_server.app.models import UserOAuth
 from fractal_server.app.routes.auth import current_active_user
@@ -57,8 +58,11 @@ async def create_project(
     await _check_project_exists(
         project_name=project.name, user_id=user.id, db=db
     )
+    resource_id, _ = await _get_resource_and_profile_ids(
+        user_id=user.id, db=db
+    )
 
-    db_project = ProjectV2(**project.model_dump())
+    db_project = ProjectV2(**project.model_dump(), resource_id=resource_id)
     db_project.user_list.append(user)
 
     db.add(db_project)