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

dstack/_internal/server/routers/instances.py

@@ -0,0 +1,77 @@
+from typing import List
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+import dstack._internal.server.services.instances as instances_services
+from dstack._internal.core.models.instances import Instance
+from dstack._internal.server.db import get_session
+from dstack._internal.server.models import ProjectModel, UserModel
+from dstack._internal.server.schemas.instances import (
+    GetInstanceHealthChecksRequest,
+    GetInstanceHealthChecksResponse,
+    ListInstancesRequest,
+)
+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/instances",
+    tags=["instances"],
+    responses=get_base_api_additional_responses(),
+)
+project_router = APIRouter(
+    prefix="/api/project/{project_name}/instances",
+    tags=["instances"],
+    responses=get_base_api_additional_responses(),
+)
+
+
+@root_router.post("/list", response_model=List[Instance])
+async def list_instances(
+    body: ListInstancesRequest,
+    session: AsyncSession = Depends(get_session),
+    user: UserModel = Depends(Authenticated()),
+):
+    """
+    Returns all instances visible to user sorted by descending `created_at`.
+    `project_names` and `fleet_ids` can be specified as filters.
+
+    The results are paginated. To get the next page, pass `created_at` and `id` of
+    the last instance from the previous page as `prev_created_at` and `prev_id`.
+    """
+    return CustomORJSONResponse(
+        await instances_services.list_user_instances(
+            session=session,
+            user=user,
+            project_names=body.project_names,
+            fleet_ids=body.fleet_ids,
+            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("/get_instance_health_checks", response_model=GetInstanceHealthChecksResponse)
+async def get_instance_health_checks(
+    body: GetInstanceHealthChecksRequest,
+    session: AsyncSession = Depends(get_session),
+    user_project: tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
+):
+    _, project = user_project
+    health_checks = await instances_services.get_instance_health_checks(
+        session=session,
+        project=project,
+        fleet_name=body.fleet_name,
+        instance_num=body.instance_num,
+        after=body.after,
+        before=body.before,
+        limit=body.limit,
+    )
+    return CustomORJSONResponse(GetInstanceHealthChecksResponse(health_checks=health_checks))

dstack/_internal/server/routers/logs.py

@@ -0,0 +1,34 @@
+from typing import Tuple
+
+from fastapi import APIRouter, Depends
+
+from dstack._internal.core.models.logs import JobSubmissionLogs
+from dstack._internal.server.models import ProjectModel, UserModel
+from dstack._internal.server.schemas.logs import PollLogsRequest
+from dstack._internal.server.security.permissions import ProjectMember
+from dstack._internal.server.services import logs
+from dstack._internal.server.utils.routers import (
+    CustomORJSONResponse,
+    get_base_api_additional_responses,
+)
+
+router = APIRouter(
+    prefix="/api/project/{project_name}/logs",
+    tags=["logs"],
+    responses=get_base_api_additional_responses(),
+)
+
+
+@router.post(
+    "/poll",
+    response_model=JobSubmissionLogs,
+)
+async def poll_logs(
+    body: PollLogsRequest,
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
+):
+    _, project = user_project
+    # The runner guarantees logs have different timestamps if throughput < 1k logs / sec.
+    # Otherwise, some logs with duplicated timestamps may be filtered out.
+    # This limitation is imposed by cloud log services that support up to millisecond timestamp resolution.
+    return CustomORJSONResponse(await logs.poll_logs_async(project=project, request=body))

dstack/_internal/server/routers/metrics.py

@@ -0,0 +1,82 @@
+from datetime import datetime
+from typing import Optional, Tuple
+from uuid import UUID
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from dstack._internal.core.errors import ResourceNotExistsError
+from dstack._internal.core.models.metrics import JobMetrics
+from dstack._internal.server.db import get_session
+from dstack._internal.server.models import ProjectModel, UserModel
+from dstack._internal.server.security.permissions import ProjectMember
+from dstack._internal.server.services import metrics
+from dstack._internal.server.services.jobs import get_run_job_model
+from dstack._internal.server.utils.routers import (
+    CustomORJSONResponse,
+    get_base_api_additional_responses,
+)
+
+router = APIRouter(
+    prefix="/api/project/{project_name}/metrics",
+    tags=["metrics"],
+    responses=get_base_api_additional_responses(),
+)
+
+
+@router.get(
+    "/job/{run_name}",
+    response_model=JobMetrics,
+)
+async def get_job_metrics(
+    run_name: str,
+    run_id: Optional[UUID] = None,
+    replica_num: int = 0,
+    job_num: int = 0,
+    limit: int = 1,
+    after: Optional[datetime] = None,
+    before: Optional[datetime] = None,
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
+):
+    """
+    Returns job-level metrics such as hardware utilization
+    given `run_name`, `run_id`, `replica_num`, and `job_num`.
+    If only `run_name` is specified, returns metrics of `(replica_num=0, job_num=0)`
+    of the latest run with the given name.
+    By default, returns one latest sample. To control time window/number of samples, use
+    `limit`, `after`, `before`.
+
+    Supported metrics (all optional):
+    * `cpus_detected_num`
+    * `cpu_usage_percent`
+    * `memory_total_bytes`
+    * `memory_usage_bytes`
+    * `memory_working_set_bytes`
+    * `gpus_detected_num`
+    * `gpu_memory_total_bytes`
+    * `gpu_memory_usage_bytes_gpu{i}`
+    * `gpu_util_percent_gpu{i}`
+    """
+    _, project = user_project
+
+    job_model = await get_run_job_model(
+        session=session,
+        project=project,
+        run_name=run_name,
+        run_id=run_id,
+        replica_num=replica_num,
+        job_num=job_num,
+    )
+    if job_model is None:
+        raise ResourceNotExistsError("Found no job with given parameters")
+
+    return CustomORJSONResponse(
+        await metrics.get_job_metrics(
+            session=session,
+            job_model=job_model,
+            limit=limit,
+            after=after,
+            before=before,
+        )
+    )

dstack/_internal/server/routers/projects.py

@@ -0,0 +1,205 @@
+from typing import List, Optional, Tuple
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from dstack._internal.core.models.projects import Project, ProjectsInfoListOrProjectsList
+from dstack._internal.server.db import get_session
+from dstack._internal.server.models import ProjectModel, UserModel
+from dstack._internal.server.schemas.projects import (
+    AddProjectMemberRequest,
+    CreateProjectRequest,
+    DeleteProjectsRequest,
+    ListProjectsRequest,
+    RemoveProjectMemberRequest,
+    SetProjectMembersRequest,
+    UpdateProjectRequest,
+)
+from dstack._internal.server.security.permissions import (
+    Authenticated,
+    ProjectAdmin,
+    ProjectManager,
+    ProjectManagerOrPublicProject,
+    ProjectManagerOrSelfLeave,
+    ProjectMemberOrPublicAccess,
+)
+from dstack._internal.server.services import fleets, projects
+from dstack._internal.server.utils.routers import (
+    CustomORJSONResponse,
+    get_base_api_additional_responses,
+)
+
+router = APIRouter(
+    prefix="/api/projects",
+    tags=["projects"],
+    responses=get_base_api_additional_responses(),
+)
+
+
+@router.post("/list", response_model=ProjectsInfoListOrProjectsList)
+async def list_projects(
+    body: Optional[ListProjectsRequest] = None,
+    session: AsyncSession = Depends(get_session),
+    user: UserModel = Depends(Authenticated()),
+):
+    """
+    Returns projects visible to the user.
+
+    Returns all accessible projects (member projects for regular users, all non-deleted
+    projects for global admins, plus public projects if `include_not_joined` is `True`).
+
+    `members` and `backends` are always empty - call `/api/projects/{project_name}/get` to retrieve them.
+    """
+    if body is None:
+        # For backward compatibility
+        body = ListProjectsRequest()
+    return CustomORJSONResponse(
+        await projects.list_user_accessible_projects(
+            session=session,
+            user=user,
+            include_not_joined=body.include_not_joined,
+            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("/list_only_no_fleets", response_model=List[Project])
+async def list_only_no_fleets(
+    session: AsyncSession = Depends(get_session),
+    user: UserModel = Depends(Authenticated()),
+):
+    """
+    Returns only projects where the user is a member and that have no active fleets,
+    sorted by ascending `created_at`.
+
+    Active fleets are those with `deleted == False`. Projects with deleted fleets
+    (but no active fleets) are included.
+
+    `members` and `backends` are always empty - call `/api/projects/{project_name}/get` to retrieve them.
+    """
+    return CustomORJSONResponse(
+        await fleets.list_projects_with_no_active_fleets(session=session, user=user)
+    )
+
+
+@router.post("/create", response_model=Project)
+async def create_project(
+    body: CreateProjectRequest,
+    session: AsyncSession = Depends(get_session),
+    user: UserModel = Depends(Authenticated()),
+):
+    return CustomORJSONResponse(
+        await projects.create_project(
+            session=session,
+            user=user,
+            project_name=body.project_name,
+            is_public=body.is_public,
+        )
+    )
+
+
+@router.post("/delete")
+async def delete_projects(
+    body: DeleteProjectsRequest,
+    session: AsyncSession = Depends(get_session),
+    user: UserModel = Depends(Authenticated()),
+):
+    await projects.delete_projects(
+        session=session,
+        user=user,
+        projects_names=body.projects_names,
+    )
+
+
+@router.post("/{project_name}/get", response_model=Project)
+async def get_project(
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMemberOrPublicAccess()),
+):
+    _, project = user_project
+    return CustomORJSONResponse(projects.project_model_to_project(project))
+
+
+@router.post(
+    "/{project_name}/set_members",
+    response_model=Project,
+)
+async def set_project_members(
+    body: SetProjectMembersRequest,
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectManager()),
+):
+    user, project = user_project
+    await projects.set_project_members(
+        session=session,
+        user=user,
+        project=project,
+        members=body.members,
+    )
+    await session.refresh(project)
+    return CustomORJSONResponse(projects.project_model_to_project(project))
+
+
+@router.post(
+    "/{project_name}/add_members",
+    response_model=Project,
+)
+async def add_project_members(
+    body: AddProjectMemberRequest,
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectManagerOrPublicProject()),
+):
+    user, project = user_project
+    await projects.add_project_members(
+        session=session,
+        user=user,
+        project=project,
+        members=body.members,
+    )
+    await session.refresh(project)
+    return CustomORJSONResponse(projects.project_model_to_project(project))
+
+
+@router.post(
+    "/{project_name}/remove_members",
+    response_model=Project,
+)
+async def remove_project_members(
+    body: RemoveProjectMemberRequest,
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectManagerOrSelfLeave()),
+):
+    user, project = user_project
+    await projects.remove_project_members(
+        session=session,
+        user=user,
+        project=project,
+        usernames=body.usernames,
+    )
+    await session.refresh(project)
+    return CustomORJSONResponse(projects.project_model_to_project(project))
+
+
+@router.post(
+    "/{project_name}/update",
+    response_model=Project,
+)
+async def update_project(
+    body: UpdateProjectRequest,
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectAdmin()),
+):
+    user, project = user_project
+    await projects.update_project(
+        session=session,
+        user=user,
+        project=project,
+        is_public=body.is_public,
+    )
+    await session.refresh(project)
+    return CustomORJSONResponse(projects.project_model_to_project(project))

dstack/_internal/server/routers/prometheus.py

@@ -0,0 +1,35 @@
+import os
+from typing import Annotated
+
+import prometheus_client
+from fastapi import APIRouter, Depends
+from fastapi.responses import PlainTextResponse
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from dstack._internal.server import settings
+from dstack._internal.server.db import get_session
+from dstack._internal.server.security.permissions import OptionalServiceAccount
+from dstack._internal.server.services.prometheus import custom_metrics
+from dstack._internal.server.utils.routers import error_not_found
+
+_auth = OptionalServiceAccount(os.getenv("DSTACK_PROMETHEUS_AUTH_TOKEN"))
+
+router = APIRouter(
+    tags=["prometheus"],
+    default_response_class=PlainTextResponse,
+    dependencies=[Depends(_auth)],
+)
+
+
+@router.get("/metrics")
+async def get_prometheus_metrics(
+    session: Annotated[AsyncSession, Depends(get_session)],
+) -> str:
+    # Note: Prometheus warns against storing high cardinality values in labels,
+    # yet both client and custom metrics have labels like project, run, fleet, etc.
+    # This may require a very big Prometheus server with lots of storage.
+    if not settings.ENABLE_PROMETHEUS_METRICS:
+        raise error_not_found()
+    custom_metrics_ = await custom_metrics.get_metrics(session=session)
+    client_metrics = prometheus_client.generate_latest().decode()
+    return custom_metrics_ + client_metrics

dstack/_internal/server/routers/repos.py

@@ -0,0 +1,118 @@
+from typing import List, Tuple
+
+from fastapi import APIRouter, Depends, Request, UploadFile
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from dstack._internal.core.errors import ResourceNotExistsError, ServerClientError
+from dstack._internal.core.models.repos import RepoHead, RepoHeadWithCreds
+from dstack._internal.server.db import get_session
+from dstack._internal.server.models import ProjectModel, UserModel
+from dstack._internal.server.schemas.repos import (
+    DeleteReposRequest,
+    GetRepoRequest,
+    SaveRepoCredsRequest,
+)
+from dstack._internal.server.security.permissions import ProjectMember
+from dstack._internal.server.services import repos
+from dstack._internal.server.settings import SERVER_CODE_UPLOAD_LIMIT
+from dstack._internal.server.utils.routers import (
+    CustomORJSONResponse,
+    get_base_api_additional_responses,
+    get_request_size,
+)
+from dstack._internal.utils.common import sizeof_fmt
+
+router = APIRouter(
+    prefix="/api/project/{project_name}/repos",
+    tags=["repos"],
+    responses=get_base_api_additional_responses(),
+)
+
+
+@router.post("/list", response_model=List[RepoHead])
+async def list_repos(
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
+):
+    _, project = user_project
+    return CustomORJSONResponse(await repos.list_repos(session=session, project=project))
+
+
+@router.post("/get", response_model=RepoHeadWithCreds)
+async def get_repo(
+    body: GetRepoRequest,
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
+):
+    user, project = user_project
+    repo = await repos.get_repo(
+        session=session,
+        project=project,
+        user=user,
+        repo_id=body.repo_id,
+        include_creds=body.include_creds,
+    )
+    if repo is None:
+        raise ResourceNotExistsError()
+    return CustomORJSONResponse(repo)
+
+
+@router.post("/init")
+async def init_repo(
+    body: SaveRepoCredsRequest,
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
+):
+    """
+    Creates or updates a repo with the repo info and repo creds.
+    Runs belong to repos, so this endpoint must be called before applying run configurations.
+    You can create `virtual` repos if you don't use git repos.
+    """
+    user, project = user_project
+    await repos.init_repo(
+        session=session,
+        project=project,
+        user=user,
+        repo_id=body.repo_id,
+        repo_info=body.repo_info,
+        repo_creds=body.repo_creds,
+    )
+
+
+@router.post("/delete")
+async def delete_repos(
+    body: DeleteReposRequest,
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
+):
+    _, project = user_project
+    await repos.delete_repos(session=session, project=project, repos_ids=body.repos_ids)
+
+
+@router.post("/upload_code")
+async def upload_code(
+    request: Request,
+    repo_id: str,
+    file: UploadFile,
+    session: AsyncSession = Depends(get_session),
+    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
+):
+    request_size = get_request_size(request)
+    if SERVER_CODE_UPLOAD_LIMIT > 0 and request_size > SERVER_CODE_UPLOAD_LIMIT:
+        diff_size_fmt = sizeof_fmt(request_size)
+        limit_fmt = sizeof_fmt(SERVER_CODE_UPLOAD_LIMIT)
+        if diff_size_fmt == limit_fmt:
+            diff_size_fmt = f"{request_size}B"
+            limit_fmt = f"{SERVER_CODE_UPLOAD_LIMIT}B"
+        raise ServerClientError(
+            f"Repo diff size is {diff_size_fmt}, which exceeds the limit of {limit_fmt}."
+            " Use .gitignore to exclude large files from the repo."
+            " This limit can be modified by setting the DSTACK_SERVER_CODE_UPLOAD_LIMIT environment variable."
+        )
+    _, project = user_project
+    await repos.upload_code(
+        session=session,
+        project=project,
+        repo_id=repo_id,
+        file=file,
+    )