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

tests/_internal/server/routers/test_repos.py

@@ -128,7 +128,6 @@ class TestGetRepo:
         user = await create_user(session=session, global_role=GlobalRole.USER)
         project = await create_project(session=session, owner=user)
         legacy_creds = {
-            "protocol": "https",
             "clone_url": "https://github.com/dstackai/dstack.git",
             "private_key": None,
             "oauth_token": "test_token",
@@ -157,14 +156,12 @@ class TestGetRepo:
         user = await create_user(session=session, global_role=GlobalRole.USER)
         project = await create_project(session=session, owner=user)
         legacy_creds = {
-            "protocol": "https",
             "clone_url": "https://github.com/dstackai/dstack.git",
             "private_key": None,
             "oauth_token": "legacy_creds",
         }
         repo = await create_repo(session=session, project_id=project.id, creds=legacy_creds)
         user_creds = {
-            "protocol": "https",
             "clone_url": "https://github.com/dstackai/dstack.git",
             "private_key": None,
             "oauth_token": "user_creds",
@@ -214,13 +211,9 @@ class TestInitRepo:
             "repo_id": "test_repo",
             "repo_info": {
                 "repo_type": "remote",
-                "repo_host_name": "",
-                "repo_port": None,
-                "repo_user_name": "",
                 "repo_name": "dstack",
             },
             "repo_creds": {
-                "protocol": "https",
                 "clone_url": "https://github.com/dstackai/dstack.git",
                 "private_key": None,
                 "oauth_token": "test_token",
@@ -254,13 +247,9 @@ class TestInitRepo:
             "repo_id": "test_repo",
             "repo_info": {
                 "repo_type": "remote",
-                "repo_host_name": "",
-                "repo_port": None,
-                "repo_user_name": "",
                 "repo_name": "dstack",
             },
             "repo_creds": {
-                "protocol": "https",
                 "clone_url": "https://github.com/dstackai/dstack.git",
                 "private_key": None,
                 "oauth_token": "test_token",
@@ -276,13 +265,9 @@ class TestInitRepo:
             "repo_id": "test_repo",
             "repo_info": {
                 "repo_type": "remote",
-                "repo_host_name": "",
-                "repo_port": None,
-                "repo_user_name": "",
                 "repo_name": "dstack",
             },
             "repo_creds": {
-                "protocol": "https",
                 "clone_url": "https://github.com/dstackai/dstack.git",
                 "private_key": None,
                 "oauth_token": "test_token_updated",

tests/_internal/server/routers/test_runs.py

@@ -28,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,
@@ -44,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 (
@@ -56,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,
@@ -120,18 +115,13 @@ 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,
             },
@@ -143,18 +133,13 @@ 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,
             },
@@ -214,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],
@@ -280,18 +265,13 @@ 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,
             },
@@ -303,18 +283,13 @@ 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,
             },
@@ -374,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": [
@@ -1341,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(
@@ -1494,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,