dstack 0.0.9__py3-none-any.whl → 0.20.7__py3-none-any.whl

dstack/_internal/server/routers/runs.py

@@ -0,0 +1,216 @@
+from typing import Annotated, List, Optional, Tuple
+
+from fastapi import APIRouter, Depends
+from packaging.version import Version
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from dstack._internal.core.errors import ResourceNotExistsError
+from dstack._internal.core.models.runs import Run, RunPlan
+from dstack._internal.server.compatibility.common import patch_offers_list
+from dstack._internal.server.db import get_session
+from dstack._internal.server.models import ProjectModel, UserModel
+from dstack._internal.server.schemas.runs import (
+    ApplyRunPlanRequest,
+    DeleteRunsRequest,
+    GetRunPlanRequest,
+    GetRunRequest,
+    ListRunsRequest,
+    StopRunsRequest,
+    SubmitRunRequest,
+)
+from dstack._internal.server.security.permissions import Authenticated, ProjectMember
+from dstack._internal.server.services import runs, users
+from dstack._internal.server.utils.routers import (
+    CustomORJSONResponse,
+    get_base_api_additional_responses,
+    get_client_version,
+)
+
+root_router = APIRouter(
+    prefix="/api/runs",
+    tags=["runs"],
+    responses=get_base_api_additional_responses(),
+)
+project_router = APIRouter(
+    prefix="/api/project/{project_name}/runs",
+    tags=["runs"],
+    responses=get_base_api_additional_responses(),
+)
+
+
+def use_legacy_repo_dir(
+    client_version: Annotated[Optional[Version], Depends(get_client_version)],
+) -> bool:
+    return client_version is not None and client_version < Version("0.19.27")
+
+
+@root_router.post(
+    "/list",
+    response_model=List[Run],
+)
+async def list_runs(
+    body: ListRunsRequest,
+    session: AsyncSession = Depends(get_session),
+    user: UserModel = Depends(Authenticated()),
+):
+    """
+    Returns all runs visible to user sorted by descending `submitted_at`.
+    `project_name`, `repo_id`, `username`, and `only_active` can be specified as filters.
+    Setting `only_active` to `true` excludes finished runs and deleted runs.
+    Specifying `repo_id` without `project_name` returns no runs.
+
+    The results are paginated. To get the next page, pass `submitted_at` and `id` of
+    the last run from the previous page as `prev_submitted_at` and `prev_run_id`.
+    """
+    return CustomORJSONResponse(
+        await runs.list_user_runs(
+            session=session,
+            user=user,
+            project_name=body.project_name,
+            repo_id=body.repo_id,
+            username=body.username,
+            only_active=body.only_active,
+            include_jobs=body.include_jobs,
+            job_submissions_limit=body.job_submissions_limit,
+            prev_submitted_at=body.prev_submitted_at,
+            prev_run_id=body.prev_run_id,
+            limit=body.limit,
+            ascending=body.ascending,
+        )
+    )
+
+
+@project_router.post(
+    "/get",
+    response_model=Run,
+)
+async def get_run(
+    body: GetRunRequest,
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
+):
+    """
+    Returns a run given `run_name` or `id`.
+    If given `run_name`, does not return deleted runs.
+    If given `id`, returns deleted runs.
+    """
+    _, project = user_project
+    run = await runs.get_run(
+        session=session,
+        project=project,
+        run_name=body.run_name,
+        run_id=body.id,
+    )
+    if run is None:
+        raise ResourceNotExistsError("Run not found")
+    return CustomORJSONResponse(run)
+
+
+@project_router.post(
+    "/get_plan",
+    response_model=RunPlan,
+)
+async def get_plan(
+    body: GetRunPlanRequest,
+    session: Annotated[AsyncSession, Depends(get_session)],
+    user_project: Annotated[tuple[UserModel, ProjectModel], Depends(ProjectMember())],
+    client_version: Annotated[Optional[Version], Depends(get_client_version)],
+    legacy_repo_dir: Annotated[bool, Depends(use_legacy_repo_dir)],
+):
+    """
+    Returns a run plan for the given run spec.
+    This is an optional step before calling `/apply`.
+    """
+    user, project = user_project
+    if not user.ssh_public_key and not body.run_spec.ssh_key_pub:
+        await users.refresh_ssh_key(session=session, actor=user)
+    run_plan = await runs.get_plan(
+        session=session,
+        project=project,
+        user=user,
+        run_spec=body.run_spec,
+        max_offers=body.max_offers,
+        legacy_repo_dir=legacy_repo_dir,
+    )
+    for job_plan in run_plan.job_plans:
+        patch_offers_list(job_plan.offers, client_version)
+    return CustomORJSONResponse(run_plan)
+
+
+@project_router.post(
+    "/apply",
+    response_model=Run,
+)
+async def apply_plan(
+    body: ApplyRunPlanRequest,
+    session: Annotated[AsyncSession, Depends(get_session)],
+    user_project: Annotated[tuple[UserModel, ProjectModel], Depends(ProjectMember())],
+    legacy_repo_dir: Annotated[bool, Depends(use_legacy_repo_dir)],
+):
+    """
+    Creates a new run or updates an existing run.
+    Errors if the expected current resource from the plan does not match the current resource.
+    Use `force: true` to apply even if the current resource does not match.
+    If the existing run is active and cannot be updated, it must be stopped first.
+    """
+    user, project = user_project
+    if not user.ssh_public_key and not body.plan.run_spec.ssh_key_pub:
+        await users.refresh_ssh_key(session=session, actor=user)
+    return CustomORJSONResponse(
+        await runs.apply_plan(
+            session=session,
+            user=user,
+            project=project,
+            plan=body.plan,
+            force=body.force,
+            legacy_repo_dir=legacy_repo_dir,
+        )
+    )
+
+
+@project_router.post("/stop")
+async def stop_runs(
+    body: StopRunsRequest,
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
+):
+    """
+    Stop one or more runs.
+    """
+    user, project = user_project
+    await runs.stop_runs(
+        session=session,
+        user=user,
+        project=project,
+        runs_names=body.runs_names,
+        abort=body.abort,
+    )
+
+
+@project_router.post("/delete")
+async def delete_runs(
+    body: DeleteRunsRequest,
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
+):
+    """
+    Delete one or more runs. The runs must be stopped before they can be deleted.
+    """
+    user, project = user_project
+    await runs.delete_runs(session=session, user=user, project=project, runs_names=body.runs_names)
+
+
+# apply_plan replaces submit_run since it can create new runs.
+@project_router.post("/submit", deprecated=True)
+async def submit_run(
+    body: SubmitRunRequest,
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
+) -> Run:
+    user, project = user_project
+    return await runs.submit_run(
+        session=session,
+        user=user,
+        project=project,
+        run_spec=body.run_spec,
+    )

dstack/_internal/server/routers/secrets.py

@@ -0,0 +1,86 @@
+from typing import List, Tuple
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from dstack._internal.core.errors import ResourceNotExistsError
+from dstack._internal.core.models.secrets import Secret
+from dstack._internal.server.db import get_session
+from dstack._internal.server.models import ProjectModel, UserModel
+from dstack._internal.server.schemas.secrets import (
+    CreateOrUpdateSecretRequest,
+    DeleteSecretsRequest,
+    GetSecretRequest,
+)
+from dstack._internal.server.security.permissions import ProjectAdmin
+from dstack._internal.server.services import secrets as secrets_services
+from dstack._internal.server.utils.routers import CustomORJSONResponse
+
+router = APIRouter(
+    prefix="/api/project/{project_name}/secrets",
+    tags=["secrets"],
+)
+
+
+@router.post("/list", response_model=List[Secret])
+async def list_secrets(
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectAdmin()),
+):
+    _, project = user_project
+    return CustomORJSONResponse(
+        await secrets_services.list_secrets(
+            session=session,
+            project=project,
+        )
+    )
+
+
+@router.post("/get", response_model=Secret)
+async def get_secret(
+    body: GetSecretRequest,
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectAdmin()),
+):
+    _, project = user_project
+    secret = await secrets_services.get_secret(
+        session=session,
+        project=project,
+        name=body.name,
+    )
+    if secret is None:
+        raise ResourceNotExistsError()
+    return CustomORJSONResponse(secret)
+
+
+@router.post("/create_or_update", response_model=Secret)
+async def create_or_update_secret(
+    body: CreateOrUpdateSecretRequest,
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectAdmin()),
+):
+    user, project = user_project
+    return CustomORJSONResponse(
+        await secrets_services.create_or_update_secret(
+            session=session,
+            project=project,
+            name=body.name,
+            value=body.value,
+            user=user,
+        )
+    )
+
+
+@router.post("/delete")
+async def delete_secrets(
+    body: DeleteSecretsRequest,
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectAdmin()),
+):
+    user, project = user_project
+    await secrets_services.delete_secrets(
+        session=session,
+        project=project,
+        names=body.secrets_names,
+        user=user,
+    )

dstack/_internal/server/routers/server.py

@@ -0,0 +1,19 @@
+from fastapi import APIRouter
+
+from dstack._internal import settings
+from dstack._internal.core.models.server import ServerInfo
+from dstack._internal.server.utils.routers import CustomORJSONResponse
+
+router = APIRouter(
+    prefix="/api/server",
+    tags=["server"],
+)
+
+
+@router.post("/get_info", response_model=ServerInfo)
+async def get_server_info():
+    return CustomORJSONResponse(
+        ServerInfo(
+            server_version=settings.DSTACK_VERSION,
+        )
+    )

dstack/_internal/server/routers/users.py

@@ -0,0 +1,158 @@
+from typing import Optional
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from dstack._internal.core.errors import ResourceNotExistsError
+from dstack._internal.core.models.users import User, UsersInfoListOrUsersList, UserWithCreds
+from dstack._internal.server.db import get_session
+from dstack._internal.server.models import UserModel
+from dstack._internal.server.schemas.users import (
+    CreateUserRequest,
+    DeleteUsersRequest,
+    GetUserRequest,
+    ListUsersRequest,
+    RefreshTokenRequest,
+    UpdateUserRequest,
+)
+from dstack._internal.server.security.permissions import Authenticated, GlobalAdmin
+from dstack._internal.server.services import events, users
+from dstack._internal.server.utils.routers import (
+    CustomORJSONResponse,
+    get_base_api_additional_responses,
+)
+
+router = APIRouter(
+    prefix="/api/users",
+    tags=["users"],
+    responses=get_base_api_additional_responses(),
+)
+
+
+@router.post("/list", response_model=UsersInfoListOrUsersList)
+async def list_users(
+    body: Optional[ListUsersRequest] = None,
+    session: AsyncSession = Depends(get_session),
+    user: UserModel = Depends(Authenticated()),
+):
+    """
+    Returns users visible to the user, sorted by descending `created_at`.
+
+    Admins see all non-deleted users. Non-admins only see themselves.
+
+    The results are paginated. To get the next page, pass `created_at` and `id` of
+    the last user from the previous page as `prev_created_at` and `prev_id`.
+    """
+    if body is None:
+        # For backward compatibility
+        body = ListUsersRequest()
+    return CustomORJSONResponse(
+        await users.list_users_for_user(
+            session=session,
+            user=user,
+            return_total_count=body.return_total_count,
+            name_pattern=body.name_pattern,
+            prev_created_at=body.prev_created_at,
+            prev_id=body.prev_id,
+            limit=body.limit,
+            ascending=body.ascending,
+        )
+    )
+
+
+@router.post("/get_my_user", response_model=UserWithCreds)
+async def get_my_user(
+    session: AsyncSession = Depends(get_session),
+    user: UserModel = Depends(Authenticated()),
+):
+    if user.ssh_private_key is None or user.ssh_public_key is None:
+        # Generate keys for pre-0.19.33 users
+        await users.refresh_ssh_key(session=session, actor=user)
+    return CustomORJSONResponse(users.user_model_to_user_with_creds(user))
+
+
+@router.post("/get_user", response_model=UserWithCreds)
+async def get_user(
+    body: GetUserRequest,
+    session: AsyncSession = Depends(get_session),
+    user: UserModel = Depends(Authenticated()),
+):
+    res = await users.get_user_with_creds_by_name(
+        session=session, current_user=user, username=body.username
+    )
+    if res is None:
+        raise ResourceNotExistsError()
+    return CustomORJSONResponse(res)
+
+
+@router.post("/create", response_model=User)
+async def create_user(
+    body: CreateUserRequest,
+    session: AsyncSession = Depends(get_session),
+    user: UserModel = Depends(GlobalAdmin()),
+):
+    res = await users.create_user(
+        session=session,
+        username=body.username,
+        global_role=body.global_role,
+        email=body.email,
+        active=body.active,
+        creator=user,
+    )
+    return CustomORJSONResponse(users.user_model_to_user(res))
+
+
+@router.post("/update", response_model=User)
+async def update_user(
+    body: UpdateUserRequest,
+    session: AsyncSession = Depends(get_session),
+    user: UserModel = Depends(GlobalAdmin()),
+):
+    res = await users.update_user(
+        session=session,
+        actor=events.UserActor.from_user(user),
+        username=body.username,
+        global_role=body.global_role,
+        email=body.email,
+        active=body.active,
+    )
+    if res is None:
+        raise ResourceNotExistsError()
+    return CustomORJSONResponse(users.user_model_to_user(res))
+
+
+@router.post("/refresh_ssh_key", response_model=UserWithCreds)
+async def refresh_ssh_key(
+    body: RefreshTokenRequest,
+    session: AsyncSession = Depends(get_session),
+    user: UserModel = Depends(Authenticated()),
+):
+    res = await users.refresh_ssh_key(session=session, actor=user, username=body.username)
+    if res is None:
+        raise ResourceNotExistsError()
+    return CustomORJSONResponse(users.user_model_to_user_with_creds(res))
+
+
+@router.post("/refresh_token", response_model=UserWithCreds)
+async def refresh_token(
+    body: RefreshTokenRequest,
+    session: AsyncSession = Depends(get_session),
+    user: UserModel = Depends(Authenticated()),
+):
+    res = await users.refresh_user_token(session=session, actor=user, username=body.username)
+    if res is None:
+        raise ResourceNotExistsError()
+    return CustomORJSONResponse(users.user_model_to_user_with_creds(res))
+
+
+@router.post("/delete")
+async def delete_users(
+    body: DeleteUsersRequest,
+    session: AsyncSession = Depends(get_session),
+    user: UserModel = Depends(GlobalAdmin()),
+):
+    await users.delete_users(
+        session=session,
+        actor=user,
+        usernames=body.users,
+    )

dstack/_internal/server/routers/volumes.py

@@ -0,0 +1,122 @@
+from typing import List, Tuple
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+import dstack._internal.server.services.volumes as volumes_services
+from dstack._internal.core.errors import ResourceNotExistsError
+from dstack._internal.core.models.volumes import Volume
+from dstack._internal.server.db import get_session
+from dstack._internal.server.models import ProjectModel, UserModel
+from dstack._internal.server.schemas.volumes import (
+    CreateVolumeRequest,
+    DeleteVolumesRequest,
+    GetVolumeRequest,
+    ListVolumesRequest,
+)
+from dstack._internal.server.security.permissions import Authenticated, ProjectMember
+from dstack._internal.server.utils.routers import (
+    CustomORJSONResponse,
+    get_base_api_additional_responses,
+)
+
+root_router = APIRouter(
+    prefix="/api/volumes",
+    tags=["volumes"],
+    responses=get_base_api_additional_responses(),
+)
+project_router = APIRouter(prefix="/api/project/{project_name}/volumes", tags=["volumes"])
+
+
+@root_router.post("/list", response_model=List[Volume])
+async def list_volumes(
+    body: ListVolumesRequest,
+    session: AsyncSession = Depends(get_session),
+    user: UserModel = Depends(Authenticated()),
+):
+    """
+    Returns all volumes visible to user sorted by descending `created_at`.
+    `project_name` and `only_active` can be specified as filters.
+
+    The results are paginated. To get the next page, pass `created_at` and `id` of
+    the last fleet from the previous page as `prev_created_at` and `prev_id`.
+    """
+    return CustomORJSONResponse(
+        await volumes_services.list_volumes(
+            session=session,
+            user=user,
+            project_name=body.project_name,
+            only_active=body.only_active,
+            prev_created_at=body.prev_created_at,
+            prev_id=body.prev_id,
+            limit=body.limit,
+            ascending=body.ascending,
+        )
+    )
+
+
+@project_router.post("/list", response_model=List[Volume])
+async def list_project_volumes(
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
+):
+    """
+    Returns all volumes in the project.
+    """
+    _, project = user_project
+    return CustomORJSONResponse(
+        await volumes_services.list_project_volumes(session=session, project=project)
+    )
+
+
+@project_router.post("/get", response_model=Volume)
+async def get_volume(
+    body: GetVolumeRequest,
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
+):
+    """
+    Returns a volume given a volume name.
+    """
+    _, project = user_project
+    volume = await volumes_services.get_volume_by_name(
+        session=session, project=project, name=body.name
+    )
+    if volume is None:
+        raise ResourceNotExistsError()
+    return CustomORJSONResponse(volume)
+
+
+@project_router.post("/create", response_model=Volume)
+async def create_volume(
+    body: CreateVolumeRequest,
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
+):
+    """
+    Creates a volume given a volume configuration.
+    """
+    user, project = user_project
+    return CustomORJSONResponse(
+        await volumes_services.create_volume(
+            session=session,
+            project=project,
+            user=user,
+            configuration=body.configuration,
+        )
+    )
+
+
+@project_router.post("/delete")
+async def delete_volumes(
+    body: DeleteVolumesRequest,
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
+):
+    """
+    Deletes one or more volumes.
+    """
+    user, project = user_project
+    await volumes_services.delete_volumes(
+        session=session, project=project, names=body.names, user=user
+    )

dstack/_internal/server/schemas/auth.py

@@ -0,0 +1,83 @@
+from typing import Annotated, Optional
+
+from pydantic import Field
+
+from dstack._internal.core.models.common import CoreModel
+
+
+class OAuthInfoResponse(CoreModel):
+    enabled: Annotated[
+        bool, Field(description="Whether the OAuth2 provider is configured on the server.")
+    ]
+
+
+class OAuthAuthorizeRequest(CoreModel):
+    local_port: Annotated[
+        Optional[int],
+        Field(
+            description="If specified, the user is redirected to localhost:local_port after the redirect from the provider.",
+            ge=1,
+            le=65535,
+        ),
+    ] = None
+    base_url: Annotated[
+        Optional[str],
+        Field(
+            description=(
+                "The server base URL used to access the dstack server, e.g. `http://localhost:3000`."
+                " Used to build redirect URLs when the dstack server is available on multiple domains."
+            )
+        ),
+    ] = None
+
+
+class OAuthAuthorizeResponse(CoreModel):
+    authorization_url: Annotated[str, Field(description="An OAuth2 authorization URL.")]
+
+
+class OAuthCallbackRequest(CoreModel):
+    code: Annotated[
+        str,
+        Field(
+            description="The OAuth2 authorization code received from the provider in the redirect URL."
+        ),
+    ]
+    state: Annotated[
+        str,
+        Field(description="The state parameter received from the provider in the redirect URL."),
+    ]
+    base_url: Annotated[
+        Optional[str],
+        Field(
+            description=(
+                "The server base URL used to access the dstack server, e.g. `http://localhost:3000`."
+                " Used to build redirect URLs when the dstack server is available on multiple domains."
+                " It must match the base URL specified when generating the authorization URL."
+            )
+        ),
+    ] = None
+
+
+class OAuthGetNextRedirectRequest(CoreModel):
+    code: Annotated[
+        str,
+        Field(
+            description="The OAuth2 authorization code received from the provider in the redirect URL."
+        ),
+    ]
+    state: Annotated[
+        str,
+        Field(description="The state parameter received from the provider in the redirect URL."),
+    ]
+
+
+class OAuthGetNextRedirectResponse(CoreModel):
+    redirect_url: Annotated[
+        Optional[str],
+        Field(
+            description=(
+                "The URL that the user needs to be redirected to."
+                " If `null`, there is no next redirect."
+            )
+        ),
+    ]

dstack/_internal/server/schemas/backends.py

@@ -0,0 +1,16 @@
+from typing import List
+
+from dstack._internal.core.models.backends.base import BackendType
+from dstack._internal.core.models.common import CoreModel
+
+
+class DeleteBackendsRequest(CoreModel):
+    backends_names: List[BackendType]
+
+
+class CreateBackendYAMLRequest(CoreModel):
+    config_yaml: str
+
+
+class UpdateBackendYAMLRequest(CreateBackendYAMLRequest):
+    pass