dstack 0.18.43__py3-none-any.whl → 0.18.44__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,
@@ -126,6 +132,7 @@ def get_dev_env_run_plan_dict(
                 "idle_duration": None,
                 "termination_idle_time": 300,
                 "termination_policy": None,
+                "utilization_policy": None,
                 "reservation": None,
             },
             "configuration_path": "dstack.yaml",
@@ -148,6 +155,7 @@ def get_dev_env_run_plan_dict(
                 "idle_duration": None,
                 "termination_idle_time": 300,
                 "termination_policy": None,
+                "utilization_policy": None,
                 "reservation": None,
             },
             "repo_code_hash": None,
@@ -190,6 +198,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": {
@@ -283,6 +292,7 @@ def get_dev_env_run_dict(
                 "idle_duration": None,
                 "termination_idle_time": 300,
                 "termination_policy": None,
+                "utilization_policy": None,
                 "reservation": None,
             },
             "configuration_path": "dstack.yaml",
@@ -305,6 +315,7 @@ def get_dev_env_run_dict(
                 "idle_duration": None,
                 "termination_idle_time": 300,
                 "termination_policy": None,
+                "utilization_policy": None,
                 "reservation": None,
             },
             "repo_code_hash": None,
@@ -347,6 +358,7 @@ def get_dev_env_run_dict(
                     "single_branch": False,
                     "max_duration": None,
                     "stop_duration": 300,
+                    "utilization_policy": None,
                     "registry_auth": None,
                     "requirements": {
                         "resources": {
@@ -891,66 +903,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 +983,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 +991,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())
 
 

tests/_internal/server/services/test_metrics.py

@@ -0,0 +1,163 @@
+from datetime import datetime, timedelta, timezone
+
+import pytest
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from dstack._internal.core.models.metrics import Metric
+from dstack._internal.server.services.metrics import get_job_metrics
+from dstack._internal.server.testing.common import (
+    create_job,
+    create_job_metrics_point,
+    create_project,
+    create_repo,
+    create_run,
+    create_user,
+)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("test_db", ["sqlite", "postgres"], indirect=True)
+@pytest.mark.usefixtures("test_db", "image_config_mock")
+class TestGetMetrics:
+    latest_ts = datetime(2023, 1, 2, 3, 4, 25, tzinfo=timezone.utc)
+    ts: tuple[datetime, ...] = (
+        latest_ts,  # 0
+        latest_ts - timedelta(seconds=10),  # 1
+        latest_ts - timedelta(seconds=20),  # 2
+        latest_ts - timedelta(seconds=30),  # 3
+        latest_ts - timedelta(seconds=40),  # 4
+        latest_ts - timedelta(seconds=50),  # 5
+    )
+    # dt, cpu_usage_sec, memory_usage_bytes, memory_ws_bytes, gpu0_memory_usage_bytes, gpu0_util,
+    # gpu1_memory_usage_bytess, gpu1_util
+    points: tuple[tuple[datetime, int, int, int, int, int, int, int], ...] = (
+        (ts[0], 110, 512, 128, 768, 15, 128, 20),
+        (ts[1], 104, 1024, 512, 1024, 10, 256, 10),
+        (ts[2], 100, 1024, 512, 1024, 20, 128, 5),
+        (ts[3], 90, 512, 512, 2048, 40, 512, 20),
+        (ts[4], 90, 1024, 1024, 1024, 0, 128, 0),
+        (ts[5], 80, 512, 512, 1024, 10, 256, 0),
+    )
+
+    @pytest.mark.parametrize(
+        ["params", "ts", "cpu", "mem", "mem_ws", "gpu0_mem", "gpu0_util", "gpu1_mem", "gpu1_util"],
+        [
+            pytest.param(
+                {"limit": 1},
+                [ts[0]],
+                [60],
+                [512],
+                [128],
+                [768],
+                [15],
+                [128],
+                [20],
+                id="limit-1-latest",
+            ),
+            pytest.param(
+                {"limit": 3},
+                [ts[0], ts[1], ts[2]],
+                [60, 40, 100],
+                [512, 1024, 1024],
+                [128, 512, 512],
+                [768, 1024, 1024],
+                [15, 10, 20],
+                [128, 256, 128],
+                [20, 10, 5],
+                id="limit-3-latest",
+            ),
+            pytest.param(
+                {},
+                [ts[0], ts[1], ts[2], ts[3], ts[4]],
+                [60, 40, 100, 0, 100],
+                [512, 1024, 1024, 512, 1024],
+                [128, 512, 512, 512, 1024],
+                [768, 1024, 1024, 2048, 1024],
+                [15, 10, 20, 40, 0],
+                [128, 256, 128, 512, 128],
+                [20, 10, 5, 20, 0],
+                id="all",
+            ),
+            pytest.param(
+                {"after": ts[3]},
+                [ts[0], ts[1], ts[2]],
+                [60, 40, 100],
+                [512, 1024, 1024],
+                [128, 512, 512],
+                [768, 1024, 1024],
+                [15, 10, 20],
+                [128, 256, 128],
+                [20, 10, 5],
+                id="all-after",
+            ),
+            pytest.param(
+                {"before": ts[2]},
+                [ts[3], ts[4]],
+                [0, 100],
+                [512, 1024],
+                [512, 1024],
+                [2048, 1024],
+                [40, 0],
+                [512, 128],
+                [20, 0],
+                id="all-before",
+            ),
+        ],
+    )
+    async def test_get_metrics(
+        self,
+        session: AsyncSession,
+        params: dict,
+        ts: list[datetime],
+        cpu: list[int],
+        mem: list[int],
+        mem_ws: list[int],
+        gpu0_mem: list[int],
+        gpu0_util: list[int],
+        gpu1_mem: list[int],
+        gpu1_util: list[int],
+    ):
+        user = await create_user(session=session)
+        project = await create_project(session=session, owner=user)
+        repo = await create_repo(
+            session=session,
+            project_id=project.id,
+        )
+        run = await create_run(
+            session=session,
+            project=project,
+            repo=repo,
+            user=user,
+        )
+        job = await create_job(
+            session=session,
+            run=run,
+        )
+        for dt, _cpu, _mem, _mem_ws, _gpu0_mem, _gpu0_util, _gpu1_mem, _gpu1_util in self.points:
+            await create_job_metrics_point(
+                session=session,
+                job_model=job,
+                timestamp=dt,
+                cpu_usage_micro=_cpu * 1_000_000,
+                memory_usage_bytes=_mem,
+                memory_working_set_bytes=_mem_ws,
+                gpus_memory_usage_bytes=[_gpu0_mem, _gpu1_mem],
+                gpus_util_percent=[_gpu0_util, _gpu1_util],
+            )
+
+        metrics = await get_job_metrics(session, job, **params)
+
+        assert metrics.metrics == [
+            Metric(name="cpu_usage_percent", timestamps=ts, values=cpu),
+            Metric(name="memory_usage_bytes", timestamps=ts, values=mem),
+            Metric(name="memory_working_set_bytes", timestamps=ts, values=mem_ws),
+            Metric(
+                name="gpus_detected_num",
+                timestamps=[ts[0], ts[-1]] if len(ts) > 1 else ts,
+                values=[2, 2] if len(ts) > 1 else [2],
+            ),
+            Metric(name="gpu_memory_usage_bytes_gpu0", timestamps=ts, values=gpu0_mem),
+            Metric(name="gpu_memory_usage_bytes_gpu1", timestamps=ts, values=gpu1_mem),
+            Metric(name="gpu_util_percent_gpu0", timestamps=ts, values=gpu0_util),
+            Metric(name="gpu_util_percent_gpu1", timestamps=ts, values=gpu1_util),
+        ]