dstack 0.18.43__py3-none-any.whl → 0.19.0__py3-none-any.whl

tests/_internal/server/routers/test_runs.py

@@ -13,7 +13,13 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.core.models.common import ApplyAction
-from dstack._internal.core.models.configurations import ServiceConfiguration
+from dstack._internal.core.models.configurations import (
+    AnyRunConfiguration,
+    DevEnvironmentConfiguration,
+    ScalingSpec,
+    ServiceConfiguration,
+    TaskConfiguration,
+)
 from dstack._internal.core.models.gateways import GatewayStatus
 from dstack._internal.core.models.instances import (
     InstanceAvailability,
@@ -22,15 +28,12 @@ from dstack._internal.core.models.instances import (
     InstanceType,
     Resources,
 )
-from dstack._internal.core.models.profiles import DEFAULT_POOL_NAME, Profile
-from dstack._internal.core.models.resources import Range, ResourcesSpec
+from dstack._internal.core.models.resources import Range
 from dstack._internal.core.models.runs import (
     ApplyRunPlanInput,
-    JobProvisioningData,
     JobSpec,
     JobStatus,
     JobTerminationReason,
-    Requirements,
     Run,
     RunSpec,
     RunStatus,
@@ -38,10 +41,9 @@ from dstack._internal.core.models.runs import (
 )
 from dstack._internal.core.models.users import GlobalRole, ProjectRole
 from dstack._internal.core.models.volumes import InstanceMountPoint, MountPoint
-from dstack._internal.server.background.tasks.process_instances import process_instances
 from dstack._internal.server.main import app
 from dstack._internal.server.models import JobModel, RunModel
-from dstack._internal.server.schemas.runs import ApplyRunPlanRequest, CreateInstanceRequest
+from dstack._internal.server.schemas.runs import ApplyRunPlanRequest
 from dstack._internal.server.services.projects import add_project_member
 from dstack._internal.server.services.runs import run_model_to_run
 from dstack._internal.server.testing.common import (
@@ -50,7 +52,6 @@ from dstack._internal.server.testing.common import (
     create_gateway_compute,
     create_instance,
     create_job,
-    create_pool,
     create_project,
     create_repo,
     create_run,
@@ -114,18 +115,14 @@ def get_dev_env_run_plan_dict(
                 "availability_zones": None,
                 "instance_types": None,
                 "creation_policy": None,
-                "instance_name": None,
                 "single_branch": None,
                 "max_duration": "off",
                 "stop_duration": None,
                 "max_price": None,
-                "pool_name": DEFAULT_POOL_NAME,
                 "retry": None,
-                "retry_policy": None,
                 "spot_policy": "spot",
                 "idle_duration": None,
-                "termination_idle_time": 300,
-                "termination_policy": None,
+                "utilization_policy": None,
                 "reservation": None,
             },
             "configuration_path": "dstack.yaml",
@@ -136,18 +133,14 @@ def get_dev_env_run_plan_dict(
                 "instance_types": None,
                 "creation_policy": None,
                 "default": False,
-                "instance_name": None,
                 "max_duration": "off",
                 "stop_duration": None,
                 "max_price": None,
                 "name": "string",
-                "pool_name": DEFAULT_POOL_NAME,
                 "retry": None,
-                "retry_policy": None,
                 "spot_policy": "spot",
                 "idle_duration": None,
-                "termination_idle_time": 300,
-                "termination_policy": None,
+                "utilization_policy": None,
                 "reservation": None,
             },
             "repo_code_hash": None,
@@ -190,6 +183,7 @@ def get_dev_env_run_plan_dict(
                     "single_branch": False,
                     "max_duration": None,
                     "stop_duration": 300,
+                    "utilization_policy": None,
                     "registry_auth": None,
                     "requirements": {
                         "resources": {
@@ -205,7 +199,7 @@ def get_dev_env_run_plan_dict(
                     },
                     "retry": None,
                     "volumes": volumes,
-                    "retry_policy": {"retry": False, "duration": None},
+                    "ssh_key": None,
                     "working_dir": ".",
                 },
                 "offers": [json.loads(o.json()) for o in offers],
@@ -271,18 +265,14 @@ def get_dev_env_run_dict(
                 "availability_zones": None,
                 "instance_types": None,
                 "creation_policy": None,
-                "instance_name": None,
                 "single_branch": None,
                 "max_duration": "off",
                 "stop_duration": None,
                 "max_price": None,
-                "pool_name": DEFAULT_POOL_NAME,
                 "retry": None,
-                "retry_policy": None,
                 "spot_policy": "spot",
                 "idle_duration": None,
-                "termination_idle_time": 300,
-                "termination_policy": None,
+                "utilization_policy": None,
                 "reservation": None,
             },
             "configuration_path": "dstack.yaml",
@@ -293,18 +283,14 @@ def get_dev_env_run_dict(
                 "instance_types": None,
                 "creation_policy": None,
                 "default": False,
-                "instance_name": None,
                 "max_duration": "off",
                 "stop_duration": None,
                 "max_price": None,
                 "name": "string",
-                "pool_name": DEFAULT_POOL_NAME,
                 "retry": None,
-                "retry_policy": None,
                 "spot_policy": "spot",
                 "idle_duration": None,
-                "termination_idle_time": 300,
-                "termination_policy": None,
+                "utilization_policy": None,
                 "reservation": None,
             },
             "repo_code_hash": None,
@@ -347,6 +333,7 @@ def get_dev_env_run_dict(
                     "single_branch": False,
                     "max_duration": None,
                     "stop_duration": 300,
+                    "utilization_policy": None,
                     "registry_auth": None,
                     "requirements": {
                         "resources": {
@@ -362,7 +349,7 @@ def get_dev_env_run_dict(
                     },
                     "retry": None,
                     "volumes": [],
-                    "retry_policy": {"retry": False, "duration": None},
+                    "ssh_key": None,
                     "working_dir": ".",
                 },
                 "job_submissions": [
@@ -891,66 +878,77 @@ class TestGetRunPlan:
 
     @pytest.mark.asyncio
     @pytest.mark.parametrize("test_db", ["sqlite", "postgres"], indirect=True)
-    async def test_returns_update_action_when_changing_updatable_fields(
-        self, test_db, session: AsyncSession, client: AsyncClient
-    ):
-        user = await create_user(session=session, global_role=GlobalRole.USER)
-        project = await create_project(session=session, owner=user)
-        await add_project_member(
-            session=session, project=project, user=user, project_role=ProjectRole.USER
-        )
-        repo = await create_repo(session=session, project_id=project.id)
-        run_spec = get_run_spec(
-            run_name="test-service",
-            repo_id=repo.name,
-            configuration=ServiceConfiguration(
-                type="service",
-                commands=["one", "two"],
-                port=80,
-                replicas=1,
+    @pytest.mark.parametrize(
+        ("old_conf", "new_conf", "action"),
+        [
+            pytest.param(
+                ServiceConfiguration(
+                    commands=["one", "two"],
+                    port=80,
+                    replicas=1,
+                    scaling=None,
+                ),
+                ServiceConfiguration(
+                    commands=["one", "two"],
+                    port=80,
+                    replicas="2..4",
+                    scaling=ScalingSpec(metric="rps", target=5),
+                ),
+                "update",
+                id="update-service",
             ),
-        )
-        run_model = await create_run(
-            session=session,
-            project=project,
-            repo=repo,
-            user=user,
-            run_name=run_spec.run_name,
-            run_spec=run_spec,
-        )
-        run = run_model_to_run(run_model)
-        run_spec.configuration.replicas = 2
-        response = await client.post(
-            f"/api/project/{project.name}/runs/get_plan",
-            headers=get_auth_headers(user.token),
-            json={"run_spec": run_spec.dict()},
-        )
-        assert response.status_code == 200
-        response_json = response.json()
-        assert response_json["action"] == "update"
-        assert response_json["current_resource"] == json.loads(run.json())
-
-    @pytest.mark.asyncio
-    @pytest.mark.parametrize("test_db", ["sqlite", "postgres"], indirect=True)
-    async def test_returns_create_action_when_changing_non_updatable_fields(
-        self, test_db, session: AsyncSession, client: AsyncClient
-    ):
+            pytest.param(
+                ServiceConfiguration(
+                    commands=["one", "two"],
+                    port=80,
+                    replicas=1,
+                    scaling=None,
+                ),
+                ServiceConfiguration(
+                    commands=["one", "two"],
+                    port=8080,  # not updatable
+                    replicas="2..4",
+                    scaling=ScalingSpec(metric="rps", target=5),
+                ),
+                "create",
+                id="no-update-service",
+            ),
+            pytest.param(
+                DevEnvironmentConfiguration(ide="vscode", inactivity_duration=False),
+                DevEnvironmentConfiguration(ide="vscode", inactivity_duration="30m"),
+                "update",
+                id="update-dev-env",
+            ),
+            pytest.param(
+                TaskConfiguration(image="test-image-1"),
+                TaskConfiguration(image="test-image-2"),
+                "create",
+                id="no-update-task",
+            ),
+            pytest.param(
+                DevEnvironmentConfiguration(ide="vscode", image="test-image"),
+                TaskConfiguration(image="test-image"),
+                "create",
+                id="no-update-on-type-change",
+            ),
+        ],
+    )
+    async def test_returns_update_or_create_action_on_conf_change(
+        self,
+        test_db,
+        session: AsyncSession,
+        client: AsyncClient,
+        old_conf: AnyRunConfiguration,
+        new_conf: AnyRunConfiguration,
+        action: str,
+    ) -> None:
         user = await create_user(session=session, global_role=GlobalRole.USER)
         project = await create_project(session=session, owner=user)
         await add_project_member(
             session=session, project=project, user=user, project_role=ProjectRole.USER
         )
         repo = await create_repo(session=session, project_id=project.id)
-        run_spec = get_run_spec(
-            run_name="test-service",
-            repo_id=repo.name,
-            configuration=ServiceConfiguration(
-                type="service",
-                commands=["one", "two"],
-                port=80,
-                replicas=1,
-            ),
-        )
+        run_spec = get_run_spec(run_name="test-run", repo_id=repo.name, configuration=old_conf)
         run_model = await create_run(
             session=session,
             project=project,
@@ -960,7 +958,7 @@ class TestGetRunPlan:
             run_spec=run_spec,
         )
         run = run_model_to_run(run_model)
-        run_spec.configuration.port = 8080
+        run_spec.configuration = new_conf
         response = await client.post(
             f"/api/project/{project.name}/runs/get_plan",
             headers=get_auth_headers(user.token),
@@ -968,7 +966,7 @@ class TestGetRunPlan:
         )
         assert response.status_code == 200
         response_json = response.json()
-        assert response_json["action"] == "create"
+        assert response_json["action"] == action
         assert response_json["current_resource"] == json.loads(run.json())
 
 
@@ -1318,11 +1316,9 @@ class TestStopRuns:
             user=user,
             status=RunStatus.RUNNING,
         )
-        pool = await create_pool(session=session, project=project)
         instance = await create_instance(
             session=session,
             project=project,
-            pool=pool,
             status=InstanceStatus.BUSY,
         )
         job = await create_job(
@@ -1471,194 +1467,6 @@ class TestDeleteRuns:
         assert len(res.scalars().all()) == 1
 
 
-class TestCreateInstance:
-    @pytest.mark.asyncio
-    @pytest.mark.parametrize("test_db", ["sqlite", "postgres"], indirect=True)
-    async def test_returns_403_if_not_project_member(
-        self, test_db, session: AsyncSession, client: AsyncClient
-    ):
-        user = await create_user(session=session, global_role=GlobalRole.USER)
-        project = await create_project(session=session, owner=user)
-        response = await client.post(
-            f"/api/project/{project.name}/runs/create_instance",
-            headers=get_auth_headers(user.token),
-        )
-        assert response.status_code == 403
-
-    @pytest.mark.asyncio
-    @pytest.mark.parametrize("test_db", ["sqlite", "postgres"], indirect=True)
-    async def test_creates_instance(self, test_db, session: AsyncSession, client: AsyncClient):
-        user = await create_user(session=session, global_role=GlobalRole.USER)
-        project = await create_project(session=session, owner=user)
-        await add_project_member(
-            session=session, project=project, user=user, project_role=ProjectRole.USER
-        )
-        request = CreateInstanceRequest(
-            profile=Profile(name="test_profile"),
-            requirements=Requirements(resources=ResourcesSpec(cpu=1)),
-        )
-        instance_id = UUID("1b0e1b45-2f8c-4ab6-8010-a0d1a3e44e0e")
-        with (
-            patch(
-                "dstack._internal.server.services.offers.get_offers_by_requirements"
-            ) as run_plan_by_req,
-            patch("uuid.uuid4") as uuid_mock,
-        ):
-            uuid_mock.return_value = instance_id
-            offer = InstanceOfferWithAvailability(
-                backend=BackendType.AWS,
-                instance=InstanceType(
-                    name="instance",
-                    resources=Resources(cpus=1, memory_mib=512, spot=False, gpus=[]),
-                ),
-                region="eu",
-                price=1.0,
-                availability=InstanceAvailability.AVAILABLE,
-            )
-            backend = Mock()
-            backend.compute.return_value.get_offers_cached.return_value = [offer]
-            backend.compute.return_value.create_instance.return_value = JobProvisioningData(
-                backend=offer.backend,
-                instance_type=offer.instance,
-                instance_id="test_instance",
-                hostname="1.1.1.1",
-                internal_ip=None,
-                region=offer.region,
-                price=offer.price,
-                username="ubuntu",
-                ssh_port=22,
-                ssh_proxy=None,
-                dockerized=True,
-                backend_data=None,
-            )
-            backend.TYPE = BackendType.AWS
-            run_plan_by_req.return_value = [(backend, offer)]
-            response = await client.post(
-                f"/api/project/{project.name}/runs/create_instance",
-                headers=get_auth_headers(user.token),
-                json=request.dict(),
-            )
-            assert response.status_code == 200
-            result = response.json()
-            expected = {
-                "id": str(instance_id),
-                "project_name": project.name,
-                "backend": None,
-                "instance_type": None,
-                "name": result["name"],
-                "fleet_id": None,
-                "fleet_name": None,
-                "instance_num": 0,
-                "job_name": None,
-                "hostname": None,
-                "status": "pending",
-                "unreachable": False,
-                "termination_reason": None,
-                "created": result["created"],
-                "pool_name": None,
-                "region": None,
-                "availability_zone": None,
-                "price": None,
-                "total_blocks": 1,
-                "busy_blocks": 0,
-            }
-            assert result == expected
-
-    @pytest.mark.asyncio
-    @pytest.mark.parametrize("test_db", ["sqlite", "postgres"], indirect=True)
-    async def test_error_if_backends_do_not_support_create_instance(
-        self, test_db, session: AsyncSession, client: AsyncClient
-    ):
-        user = await create_user(session=session, global_role=GlobalRole.USER)
-        project = await create_project(session=session, owner=user)
-        await add_project_member(
-            session=session, project=project, user=user, project_role=ProjectRole.USER
-        )
-        request = CreateInstanceRequest(
-            profile=Profile(name="test_profile"),
-            requirements=Requirements(resources=ResourcesSpec(cpu=1)),
-        )
-        with patch(
-            "dstack._internal.server.services.offers.get_offers_by_requirements"
-        ) as run_plan_by_req:
-            offer = InstanceOfferWithAvailability(
-                backend=BackendType.AZURE,
-                instance=InstanceType(
-                    name="instance",
-                    resources=Resources(cpus=1, memory_mib=512, spot=False, gpus=[]),
-                ),
-                region="eu",
-                price=1.0,
-                availability=InstanceAvailability.AVAILABLE,
-            )
-            backend = Mock()
-            backend.TYPE = BackendType.AZURE
-            backend.compute.return_value.get_offers_cached.return_value = [offer]
-            backend.compute.return_value.create_instance.side_effect = NotImplementedError()
-            run_plan_by_req.return_value = [(backend, offer)]
-            response = await client.post(
-                f"/api/project/{project.name}/runs/create_instance",
-                headers=get_auth_headers(user.token),
-                json=request.dict(),
-            )
-            assert response.status_code == 200
-            await process_instances()
-
-    @pytest.mark.asyncio
-    @pytest.mark.parametrize("test_db", ["sqlite", "postgres"], indirect=True)
-    async def test_backend_does_not_support_create_instance(
-        self, test_db, session: AsyncSession, client: AsyncClient
-    ):
-        user = await create_user(session=session, global_role=GlobalRole.USER)
-        project = await create_project(session=session, owner=user)
-        await add_project_member(
-            session=session, project=project, user=user, project_role=ProjectRole.USER
-        )
-        request = CreateInstanceRequest(
-            profile=Profile(name="test_profile"),
-            requirements=Requirements(resources=ResourcesSpec(cpu=1)),
-        )
-
-        with patch(
-            "dstack._internal.server.services.offers.get_offers_by_requirements"
-        ) as run_plan_by_req:
-            offers = InstanceOfferWithAvailability(
-                backend=BackendType.VASTAI,
-                instance=InstanceType(
-                    name="instance",
-                    resources=Resources(cpus=1, memory_mib=512, spot=False, gpus=[]),
-                ),
-                region="eu",
-                price=1.0,
-                availability=InstanceAvailability.AVAILABLE,
-            )
-
-            backend = Mock()
-            backend.TYPE = BackendType.VASTAI
-            backend.compute.return_value.get_offers_cached.return_value = [offers]
-            backend.compute.return_value.create_instance.side_effect = NotImplementedError()
-            run_plan_by_req.return_value = [(backend, offers)]
-
-            response = await client.post(
-                f"/api/project/{project.name}/runs/create_instance",
-                headers=get_auth_headers(user.token),
-                json=request.dict(),
-            )
-
-            assert response.status_code == 400
-
-            result = response.json()
-            expected = {
-                "detail": [
-                    {
-                        "msg": "Backends  do not support create_instance. Try to select other backends.",
-                        "code": "error",
-                    }
-                ]
-            }
-            assert result == expected
-
-
 @pytest.mark.parametrize("test_db", ["sqlite", "postgres"], indirect=True)
 class TestSubmitService:
     @pytest.fixture(autouse=True)

tests/_internal/server/routers/test_volumes.py

@@ -14,8 +14,8 @@ from dstack._internal.core.models.users import GlobalRole, ProjectRole
 from dstack._internal.server.models import VolumeAttachmentModel, VolumeModel
 from dstack._internal.server.services.projects import add_project_member
 from dstack._internal.server.testing.common import (
+    ComputeMockSpec,
     create_instance,
-    create_pool,
     create_project,
     create_user,
     create_volume,
@@ -366,6 +366,7 @@ class TestDeleteVolumes:
         ) as m:
             aws_mock = Mock()
             m.return_value = aws_mock
+            aws_mock.compute.return_value = Mock(spec=ComputeMockSpec)
             response = await client.post(
                 f"/api/project/{project.name}/volumes/delete",
                 headers=get_auth_headers(user.token),
@@ -383,7 +384,6 @@ class TestDeleteVolumes:
     ):
         user = await create_user(session, global_role=GlobalRole.USER)
         project = await create_project(session)
-        pool = await create_pool(session=session, project=project)
         await add_project_member(
             session=session, project=project, user=user, project_role=ProjectRole.USER
         )
@@ -396,7 +396,6 @@ class TestDeleteVolumes:
         instance = await create_instance(
             session=session,
             project=project,
-            pool=pool,
         )
         volume.attachments.append(VolumeAttachmentModel(instance=instance))
         await session.commit()

tests/_internal/server/services/jobs/configurators/test_task.py

@@ -0,0 +1,35 @@
+from unittest.mock import patch
+
+import pytest
+
+from dstack._internal.core.models.configurations import TaskConfiguration
+from dstack._internal.core.models.runs import JobSSHKey
+from dstack._internal.server.services.jobs.configurators.task import TaskJobConfigurator
+from dstack._internal.server.testing.common import get_run_spec
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("image_config_mock")
+class TestTaskJobConfigurator:
+    async def test_ssh_key_single_node(self):
+        configuration = TaskConfiguration(nodes=1, image="debian")
+        run_spec = get_run_spec(run_name="run", repo_id="id", configuration=configuration)
+        configurator = TaskJobConfigurator(run_spec)
+
+        job_specs = await configurator.get_job_specs(replica_num=0)
+
+        assert len(job_specs) == 1
+        assert job_specs[0].ssh_key is None
+
+    async def test_ssh_key_multi_node(self):
+        configuration = TaskConfiguration(nodes=2, image="debian")
+        run_spec = get_run_spec(run_name="run", repo_id="id", configuration=configuration)
+        configurator = TaskJobConfigurator(run_spec)
+
+        with patch("dstack._internal.utils.crypto.generate_rsa_key_pair_bytes") as gen_mock:
+            gen_mock.side_effect = [(b"private1", b"public1"), (b"private2", b"public2")]
+            job_specs = await configurator.get_job_specs(replica_num=0)
+
+        assert len(job_specs) == 2
+        assert job_specs[0].ssh_key == JobSSHKey(private="private1", public="public1")
+        assert job_specs[1].ssh_key == JobSSHKey(private="private1", public="public1")

tests/_internal/server/services/test_config.py

@@ -6,11 +6,14 @@ import yaml
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from dstack._internal.core.models.backends.azure import AzureConfigInfoWithCreds, AzureDefaultCreds
+from dstack._internal.core.backends.azure.models import (
+    AzureBackendConfigWithCreds,
+    AzureDefaultCreds,
+)
 from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.server import settings
 from dstack._internal.server.models import BackendModel, ProjectModel
-from dstack._internal.server.services.config import AzureConfig, ServerConfigManager
+from dstack._internal.server.services.config import ServerConfigManager
 from dstack._internal.server.testing.common import (
     create_project,
     create_user,
@@ -38,7 +41,7 @@ class TestServerConfigManager:
                 ) as create_backend_mock,
             ):
                 list_available_backend_types_mock.return_value = [BackendType.AZURE]
-                default_config = AzureConfigInfoWithCreds(
+                default_config = AzureBackendConfigWithCreds(
                     tenant_id="test_tenant",
                     subscription_id="test_subscription",
                     locations=["westeurope"],
@@ -52,7 +55,7 @@ class TestServerConfigManager:
                 list_available_backend_types_mock.assert_called()
                 get_configurator_mock.assert_called()
                 create_backend_mock.assert_called()
-                assert manager.config.projects[0].backends[0] == AzureConfig(
+                assert manager.config.projects[0].backends[0] == AzureBackendConfigWithCreds(
                     tenant_id="test_tenant",
                     subscription_id="test_subscription",
                     regions=["westeurope"],

tests/_internal/server/services/test_fleets.py

@@ -4,7 +4,7 @@ from unittest.mock import Mock
 import pytest
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from dstack._internal.core.backends.base import Backend
+from dstack._internal.core.backends.base.backend import Backend
 from dstack._internal.core.errors import ServerClientError
 from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.core.models.fleets import (
@@ -20,7 +20,6 @@ from dstack._internal.server.services.fleets import get_plan
 from dstack._internal.server.testing.common import (
     create_fleet,
     create_instance,
-    create_pool,
     create_project,
     create_user,
     get_fleet_spec,
@@ -45,7 +44,6 @@ class TestGetPlanSSHFleetHostsValidation:
         self, session: AsyncSession, project: ProjectModel, spec: FleetSpec
     ) -> FleetModel:
         assert spec.configuration.ssh_config is not None, spec.configuration
-        pool = await create_pool(session=session, project=project)
         fleet = await create_fleet(session=session, project=project, spec=spec)
         for host in spec.configuration.ssh_config.hosts:
             if isinstance(host, SSHHostParams):
@@ -56,7 +54,6 @@ class TestGetPlanSSHFleetHostsValidation:
             await create_instance(
                 session=session,
                 project=project,
-                pool=pool,
                 fleet=fleet,
                 backend=BackendType.REMOTE,
                 remote_connection_info=rci,