dstack 0.18.44__py3-none-any.whl → 0.19.0rc1__py3-none-any.whl

dstack/_internal/server/models.py

@@ -1,3 +1,4 @@
+import enum
 import uuid
 from datetime import datetime
 from typing import Callable, List, Optional, Union
@@ -29,7 +30,7 @@ from dstack._internal.core.models.fleets import FleetStatus
 from dstack._internal.core.models.gateways import GatewayStatus
 from dstack._internal.core.models.instances import InstanceStatus
 from dstack._internal.core.models.profiles import (
-    DEFAULT_POOL_TERMINATION_IDLE_TIME,
+    DEFAULT_FLEET_TERMINATION_IDLE_TIME,
     TerminationPolicy,
 )
 from dstack._internal.core.models.repos.base import RepoType
@@ -112,7 +113,11 @@ class EncryptedString(TypeDecorator):
         cls._encrypt_func = encrypt_func
         cls._decrypt_func = decrypt_func
 
-    def process_bind_param(self, value: Union[DecryptedString, str], dialect):
+    def process_bind_param(
+        self, value: Optional[Union[DecryptedString, str]], dialect
+    ) -> Optional[str]:
+        if value is None:
+            return None
         if isinstance(value, str):
             # Passing string allows binding an encrypted value directly
             # e.g. for comparisons
@@ -130,6 +135,29 @@ class EncryptedString(TypeDecorator):
             return DecryptedString(plaintext=None, decrypted=False, exc=e)
 
 
+class EnumAsString(TypeDecorator):
+    """
+    A custom type decorator that stores enums as strings in the DB.
+    """
+
+    impl = String
+    cache_ok = True
+
+    def __init__(self, enum_class: type[enum.Enum], *args, **kwargs):
+        self.enum_class = enum_class
+        super().__init__(*args, **kwargs)
+
+    def process_bind_param(self, value: Optional[enum.Enum], dialect) -> Optional[str]:
+        if value is None:
+            return None
+        return value.name
+
+    def process_result_value(self, value: Optional[str], dialect) -> Optional[enum.Enum]:
+        if value is None:
+            return None
+        return self.enum_class[value]
+
+
 constraint_naming_convention = {
     "ix": "ix_%(column_0_label)s",
     "uq": "uq_%(table_name)s_%(column_0_name)s",
@@ -193,8 +221,13 @@ class ProjectModel(BaseModel):
         foreign_keys=[default_gateway_id]
     )
 
+    # TODO: Drop after the release without pools
+    # Note that multi-replica deployments can break if
+    # upgrading from an old version that uses pools to the version that drops pools from the DB.
     default_pool_id: Mapped[Optional[UUIDType]] = mapped_column(
-        ForeignKey("pools.id", use_alter=True, ondelete="SET NULL"), nullable=True
+        ForeignKey("pools.id", use_alter=True, ondelete="SET NULL"),
+        nullable=True,
+        deferred=True,  # Not loaded so it can be deleted in the next releases
     )
     default_pool: Mapped[Optional["PoolModel"]] = relationship(foreign_keys=[default_pool_id])
 
@@ -222,7 +255,7 @@ class BackendModel(BaseModel):
     )
     project_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("projects.id", ondelete="CASCADE"))
     project: Mapped["ProjectModel"] = relationship()
-    type: Mapped[BackendType] = mapped_column(Enum(BackendType))
+    type: Mapped[BackendType] = mapped_column(EnumAsString(BackendType, 100))
 
     config: Mapped[str] = mapped_column(String(20000))
     auth: Mapped[DecryptedString] = mapped_column(EncryptedString(20000))
@@ -428,6 +461,7 @@ class GatewayComputeModel(BaseModel):
     app_updated_at: Mapped[datetime] = mapped_column(NaiveDateTime, default=get_current_datetime)
 
 
+# TODO: Drop after the release without pools
 class PoolModel(BaseModel):
     __tablename__ = "pools"
 
@@ -493,8 +527,12 @@ class InstanceModel(BaseModel):
     project_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("projects.id", ondelete="CASCADE"))
     project: Mapped["ProjectModel"] = relationship(foreign_keys=[project_id])
 
-    pool_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("pools.id"))
-    pool: Mapped["PoolModel"] = relationship(back_populates="instances")
+    # TODO: Drop after the release without pools
+    pool_id: Mapped[Optional[uuid.UUID]] = mapped_column(
+        ForeignKey("pools.id"),
+        deferred=True,  # Not loaded so it can be deleted in the next releases
+    )
+    pool: Mapped[Optional["PoolModel"]] = relationship(back_populates="instances")
 
     fleet_id: Mapped[Optional[uuid.UUID]] = mapped_column(ForeignKey("fleets.id"))
     fleet: Mapped[Optional["FleetModel"]] = relationship(back_populates="instances")
@@ -517,9 +555,10 @@ class InstanceModel(BaseModel):
 
     # temination policy
     termination_policy: Mapped[Optional[TerminationPolicy]] = mapped_column(String(100))
-    # TODO: Suggestion: do not assign DEFAULT_POOL_TERMINATION_IDLE_TIME as the default here (make Optional instead; also instead of -1)
+    # TODO: Suggestion: do not assign DEFAULT_FLEET_TERMINATION_IDLE_TIME as the default here
+    # (make Optional instead; also instead of -1)
     termination_idle_time: Mapped[int] = mapped_column(
-        Integer, default=DEFAULT_POOL_TERMINATION_IDLE_TIME
+        Integer, default=DEFAULT_FLEET_TERMINATION_IDLE_TIME
     )
 
     # retry policy
@@ -533,7 +572,7 @@ class InstanceModel(BaseModel):
     last_termination_retry_at: Mapped[Optional[datetime]] = mapped_column(NaiveDateTime)
 
     # backend
-    backend: Mapped[Optional[BackendType]] = mapped_column(Enum(BackendType))
+    backend: Mapped[Optional[BackendType]] = mapped_column(EnumAsString(BackendType, 100))
     backend_data: Mapped[Optional[str]] = mapped_column(Text)
 
     # offer

dstack/_internal/server/routers/backends.py

@@ -3,13 +3,12 @@ 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.backends import (
-    AnyConfigInfoWithCreds,
-    AnyConfigInfoWithCredsPartial,
-    AnyConfigValues,
+import dstack._internal.core.backends.configurators
+from dstack._internal.core.backends.models import (
+    AnyBackendConfigWithCreds,
     BackendInfoYAML,
 )
+from dstack._internal.core.errors import ResourceNotExistsError
 from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.server import settings
 from dstack._internal.server.db import get_session
@@ -19,7 +18,7 @@ from dstack._internal.server.schemas.backends import (
     DeleteBackendsRequest,
     UpdateBackendYAMLRequest,
 )
-from dstack._internal.server.security.permissions import Authenticated, ProjectAdmin
+from dstack._internal.server.security.permissions import ProjectAdmin
 from dstack._internal.server.services import backends
 from dstack._internal.server.services.backends import handlers as backends_handlers
 from dstack._internal.server.services.config import (
@@ -44,23 +43,15 @@ project_router = APIRouter(
 
 @root_router.post("/list_types")
 async def list_backend_types() -> List[BackendType]:
-    return backends.list_available_backend_types()
-
-
-@root_router.post("/config_values")
-async def get_backend_config_values(
-    body: AnyConfigInfoWithCredsPartial,
-    user: UserModel = Depends(Authenticated()),
-) -> AnyConfigValues:
-    return await backends.get_backend_config_values(config=body)
+    return dstack._internal.core.backends.configurators.list_available_backend_types()
 
 
 @project_router.post("/create")
 async def create_backend(
-    body: AnyConfigInfoWithCreds,
+    body: AnyBackendConfigWithCreds,
     session: AsyncSession = Depends(get_session),
     user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectAdmin()),
-) -> AnyConfigInfoWithCreds:
+) -> AnyBackendConfigWithCreds:
     _, project = user_project
     config = await backends.create_backend(session=session, project=project, config=body)
     if settings.SERVER_CONFIG_ENABLED:
@@ -70,10 +61,10 @@ async def create_backend(
 
 @project_router.post("/update")
 async def update_backend(
-    body: AnyConfigInfoWithCreds,
+    body: AnyBackendConfigWithCreds,
     session: AsyncSession = Depends(get_session),
     user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectAdmin()),
-) -> AnyConfigInfoWithCreds:
+) -> AnyBackendConfigWithCreds:
     _, project = user_project
     config = await backends.update_backend(session=session, project=project, config=body)
     if settings.SERVER_CONFIG_ENABLED:
@@ -99,12 +90,12 @@ async def delete_backends(
 async def get_backend_config_info(
     backend_name: BackendType,
     user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectAdmin()),
-) -> AnyConfigInfoWithCreds:
+) -> AnyBackendConfigWithCreds:
     _, project = user_project
-    config_info = await backends.get_config_info(project=project, backend_type=backend_name)
-    if config_info is None:
+    config = await backends.get_backend_config(project=project, backend_type=backend_name)
+    if config is None:
         raise ResourceNotExistsError()
-    return config_info
+    return config
 
 
 @project_router.post("/create_yaml")

dstack/_internal/server/routers/instances.py

@@ -3,8 +3,8 @@ from typing import List
 from fastapi import APIRouter, Depends
 from sqlalchemy.ext.asyncio import AsyncSession
 
-import dstack._internal.server.services.pools as pools
-from dstack._internal.core.models.pools import Instance
+import dstack._internal.server.services.instances as instances
+from dstack._internal.core.models.instances import Instance
 from dstack._internal.server.db import get_session
 from dstack._internal.server.models import UserModel
 from dstack._internal.server.schemas.instances import ListInstancesRequest
@@ -31,12 +31,11 @@ async def list_instances(
     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 await pools.list_user_pool_instances(
+    return await instances.list_user_instances(
         session=session,
         user=user,
         project_names=body.project_names,
         fleet_ids=body.fleet_ids,
-        pool_name=None,
         only_active=body.only_active,
         prev_created_at=body.prev_created_at,
         prev_id=body.prev_id,

dstack/_internal/server/routers/metrics.py

@@ -40,14 +40,16 @@ async def get_job_metrics(
     By default, returns one latest sample. To control time window/number of samples, use
     `limit`, `after`, `before`.
 
-    Supported metrics: [
-        "cpu_usage_percent",
-        "memory_usage_bytes",
-        "memory_working_set_bytes",
-        "gpus_detected_num",
-        "gpu_memory_usage_bytes_gpu{i}",
-        "gpu_util_percent_gpu{i}"
-    ]
+    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
 

dstack/_internal/server/routers/prometheus.py

@@ -26,7 +26,7 @@ async def get_prometheus_metrics(
     return await prometheus.get_metrics(session=session)
 
 
-@router.get("/metrics/project/{project_name}")
+@router.get("/metrics/project/{project_name}", deprecated=True)
 async def get_project_prometheus_metrics(
     session: Annotated[AsyncSession, Depends(get_session)],
     project: Annotated[ProjectModel, Depends(Project())],

dstack/_internal/server/routers/repos.py

@@ -66,14 +66,13 @@ async def init_repo(
     You can create `virtual` repos if you don't use git repos.
     """
     user, project = user_project
-    repo_creds = body.repo_creds.to_remote_repo_creds(body.repo_info) if body.repo_creds else None
     await repos.init_repo(
         session=session,
         project=project,
         user=user,
         repo_id=body.repo_id,
         repo_info=body.repo_info,
-        repo_creds=repo_creds,
+        repo_creds=body.repo_creds,
     )
 
 

dstack/_internal/server/routers/runs.py

@@ -3,16 +3,13 @@ from typing import List, Tuple
 from fastapi import APIRouter, Depends
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from dstack._internal.core.errors import ComputeError, ResourceNotExistsError, ServerClientError
-from dstack._internal.core.models.pools import Instance
-from dstack._internal.core.models.runs import PoolInstanceOffers, Run, RunPlan
+from dstack._internal.core.errors import ResourceNotExistsError
+from dstack._internal.core.models.runs import Run, RunPlan
 from dstack._internal.server.db import get_session
 from dstack._internal.server.models import ProjectModel, UserModel
 from dstack._internal.server.schemas.runs import (
     ApplyRunPlanRequest,
-    CreateInstanceRequest,
     DeleteRunsRequest,
-    GetOffersRequest,
     GetRunPlanRequest,
     GetRunRequest,
     ListRunsRequest,
@@ -20,10 +17,7 @@ from dstack._internal.server.schemas.runs import (
     SubmitRunRequest,
 )
 from dstack._internal.server.security.permissions import Authenticated, ProjectMember
-from dstack._internal.server.services import fleets, runs
-from dstack._internal.server.services.pools import (
-    get_or_create_pool_by_name,
-)
+from dstack._internal.server.services import runs
 from dstack._internal.server.utils.routers import get_base_api_additional_responses
 
 root_router = APIRouter(
@@ -132,23 +126,6 @@ async def apply_plan(
     )
 
 
-# apply_plan replaces submit_run since it can create new runs.
-# submit_run can be deprecated in the future.
-@project_router.post("/submit")
-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,
-    )
-
-
 @project_router.post("/stop")
 async def stop_runs(
     body: StopRunsRequest,
@@ -180,40 +157,17 @@ async def delete_runs(
     await runs.delete_runs(session=session, project=project, runs_names=body.runs_names)
 
 
-# FIXME: get_offers and create_instance semantically belong to pools, not runs
-@project_router.post("/get_offers", deprecated=True)
-async def get_offers(
-    body: GetOffersRequest,
+# 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()),
-) -> PoolInstanceOffers:
-    _, project = user_project
-    pool = await get_or_create_pool_by_name(session, project, body.profile.pool_name)
-    offers = await fleets.get_create_instance_offers(
+) -> Run:
+    user, project = user_project
+    return await runs.submit_run(
+        session=session,
+        user=user,
         project=project,
-        profile=body.profile,
-        requirements=body.requirements,
+        run_spec=body.run_spec,
     )
-    instances = [instance for _, instance in offers]
-    return PoolInstanceOffers(pool_name=pool.name, instances=instances)
-
-
-# FIXME: get_offers and create_instance semantically belong to pools, not runs
-@project_router.post("/create_instance", deprecated=True)
-async def create_instance(
-    body: CreateInstanceRequest,
-    session: AsyncSession = Depends(get_session),
-    user_project: Tuple[UserModel, ProjectModel] = Depends(ProjectMember()),
-) -> Instance:
-    user, project = user_project
-    try:
-        instance = await fleets.create_instance(
-            session=session,
-            project=project,
-            user=user,
-            profile=body.profile,
-            requirements=body.requirements,
-        )
-    except ComputeError as e:
-        raise ServerClientError(str(e))
-    return instance

dstack/_internal/server/schemas/gateways.py

@@ -1,6 +1,6 @@
-from typing import Dict, List, Optional
+from typing import Annotated, Any, Dict, List, Optional
 
-from pydantic import root_validator
+from pydantic import Field
 
 from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.core.models.common import CoreModel
@@ -8,27 +8,18 @@ from dstack._internal.core.models.gateways import GatewayConfiguration
 
 
 class CreateGatewayRequest(CoreModel):
-    name: Optional[str]
-    backend_type: Optional[BackendType]
-    region: Optional[str]
-    configuration: Optional[GatewayConfiguration]
-
-    @root_validator
-    def fill_configuration(cls, values: Dict) -> Dict:
-        if values.get("configuration", None) is not None:
-            return values
-        backend_type = values.get("backend_type", None)
-        region = values.get("region", None)
-        if backend_type is None:
-            raise ValueError("backend_type must be specified")
-        if region is None:
-            raise ValueError("region must be specified")
-        values["configuration"] = GatewayConfiguration(
-            name=values.get("name", None),
-            backend=backend_type,
-            region=region,
-        )
-        return values
+    configuration: GatewayConfiguration
+    # Deprecated and unused. Left for compatibility with 0.18 clients.
+    name: Annotated[Optional[str], Field(exclude=True)] = None
+    backend_type: Annotated[Optional[BackendType], Field(exclude=True)] = None
+    region: Annotated[Optional[str], Field(exclude=True)] = None
+
+    class Config:
+        @staticmethod
+        def schema_extra(schema: Dict[str, Any]) -> None:
+            del schema["properties"]["name"]
+            del schema["properties"]["backend_type"]
+            del schema["properties"]["region"]
 
 
 class GetGatewayRequest(CoreModel):

dstack/_internal/server/schemas/projects.py

@@ -1,4 +1,6 @@
-from typing import List
+from typing import Annotated, List
+
+from pydantic import Field
 
 from dstack._internal.core.models.common import CoreModel
 from dstack._internal.core.models.users import ProjectRole
@@ -13,7 +15,10 @@ class DeleteProjectsRequest(CoreModel):
 
 
 class MemberSetting(CoreModel):
-    username: str
+    username: Annotated[
+        str,
+        Field(description="The username or email of the user"),
+    ]
     project_role: ProjectRole
 
 

dstack/_internal/server/schemas/repos.py

@@ -4,46 +4,10 @@ from pydantic import Field
 
 from dstack._internal.core.models.common import CoreModel
 from dstack._internal.core.models.repos import AnyRepoInfo
-from dstack._internal.core.models.repos.base import RepoProtocol
-from dstack._internal.core.models.repos.remote import RemoteRepoCreds, RemoteRepoInfo
+from dstack._internal.core.models.repos.remote import RemoteRepoCreds
 from dstack._internal.server.schemas.common import RepoRequest
 
 
-# TODO: in 0.19, either remove this model or make clone_url required
-class RemoteRepoCredsDto(CoreModel):
-    protocol: RepoProtocol
-    clone_url: Optional[str]
-    private_key: Optional[str]
-    oauth_token: Optional[str]
-
-    @staticmethod
-    def from_remote_repo_creds(creds: RemoteRepoCreds) -> "RemoteRepoCredsDto":
-        return RemoteRepoCredsDto(
-            protocol=creds.protocol,
-            clone_url=creds.clone_url,
-            private_key=creds.private_key,
-            oauth_token=creds.oauth_token,
-        )
-
-    def to_remote_repo_creds(self, info: RemoteRepoInfo) -> RemoteRepoCreds:
-        if (clone_url := self.clone_url) is None:
-            netloc = (
-                f"{info.repo_host_name}:{info.repo_port}"
-                if info.repo_port
-                else info.repo_host_name
-            )
-            if self.protocol == RepoProtocol.SSH:
-                clone_url = f"ssh://git@{netloc}/{info.repo_user_name}/{info.repo_name}.git"
-            else:
-                clone_url = f"https://{netloc}/{info.repo_user_name}/{info.repo_name}.git"
-        return RemoteRepoCreds(
-            protocol=self.protocol,
-            clone_url=clone_url,
-            private_key=self.private_key,
-            oauth_token=self.oauth_token,
-        )
-
-
 class GetRepoRequest(RepoRequest):
     include_creds: bool
 
@@ -51,7 +15,7 @@ class GetRepoRequest(RepoRequest):
 class SaveRepoCredsRequest(RepoRequest):
     repo_info: AnyRepoInfo
     repo_creds: Annotated[
-        Optional[RemoteRepoCredsDto],
+        Optional[RemoteRepoCreds],
         Field(description="The repo creds for accessing private remote repo"),
     ]
 

dstack/_internal/server/schemas/runner.py

@@ -64,6 +64,7 @@ class SubmitBody(CoreModel):
                 "gateway",
                 "single_branch",
                 "max_duration",
+                "ssh_key",
                 "working_dir",
             }
         ),

dstack/_internal/server/schemas/runs.py

@@ -5,9 +5,7 @@ from uuid import UUID
 from pydantic import Field
 
 from dstack._internal.core.models.common import CoreModel
-from dstack._internal.core.models.instances import SSHKey
-from dstack._internal.core.models.profiles import Profile
-from dstack._internal.core.models.runs import ApplyRunPlanInput, Requirements, RunSpec
+from dstack._internal.core.models.runs import ApplyRunPlanInput, RunSpec
 
 
 class ListRunsRequest(CoreModel):
@@ -30,27 +28,6 @@ class GetRunPlanRequest(CoreModel):
     run_spec: RunSpec
 
 
-class GetOffersRequest(CoreModel):
-    profile: Profile
-    requirements: Requirements
-
-
-class CreateInstanceRequest(CoreModel):
-    profile: Profile
-    requirements: Requirements
-
-
-class AddRemoteInstanceRequest(CoreModel):
-    pool_name: Optional[str]
-    instance_name: Optional[str]
-    instance_network: Optional[str]
-    region: Optional[str]
-    host: str
-    port: int
-    ssh_user: str
-    ssh_keys: List[SSHKey]
-
-
 class SubmitRunRequest(CoreModel):
     run_spec: RunSpec