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

tests/_internal/server/services/{test_pools.py → test_instances.py}

@@ -3,15 +3,18 @@ import uuid
 import pytest
 from sqlalchemy.ext.asyncio import AsyncSession
 
-import dstack._internal.server.services.pools as services_pools
+import dstack._internal.server.services.instances as instances_services
 from dstack._internal.core.models.backends.base import BackendType
-from dstack._internal.core.models.instances import InstanceStatus, InstanceType, Resources
-from dstack._internal.core.models.pools import Instance
+from dstack._internal.core.models.instances import (
+    Instance,
+    InstanceStatus,
+    InstanceType,
+    Resources,
+)
 from dstack._internal.core.models.profiles import Profile
 from dstack._internal.server.models import InstanceModel
 from dstack._internal.server.testing.common import (
     create_instance,
-    create_pool,
     create_project,
     create_user,
     get_volume,
@@ -27,21 +30,18 @@ class TestFilterPoolInstances:
     async def test_returns_all_instances(self, test_db, session: AsyncSession):
         user = await create_user(session=session)
         project = await create_project(session=session, owner=user)
-        pool = await create_pool(session=session, project=project)
         aws_instance = await create_instance(
             session=session,
             project=project,
-            pool=pool,
             backend=BackendType.AWS,
         )
         runpod_instance = await create_instance(
             session=session,
             project=project,
-            pool=pool,
             backend=BackendType.RUNPOD,
         )
         instances = [aws_instance, runpod_instance]
-        res = services_pools.filter_pool_instances(
+        res = instances_services.filter_pool_instances(
             pool_instances=instances,
             profile=Profile(name="test"),
         )
@@ -52,21 +52,18 @@ class TestFilterPoolInstances:
     async def test_returns_multinode_instances(self, test_db, session: AsyncSession):
         user = await create_user(session=session)
         project = await create_project(session=session, owner=user)
-        pool = await create_pool(session=session, project=project)
         aws_instance = await create_instance(
             session=session,
             project=project,
-            pool=pool,
             backend=BackendType.AWS,
         )
         runpod_instance = await create_instance(
             session=session,
             project=project,
-            pool=pool,
             backend=BackendType.RUNPOD,
         )
         instances = [aws_instance, runpod_instance]
-        res = services_pools.filter_pool_instances(
+        res = instances_services.filter_pool_instances(
             pool_instances=instances,
             profile=Profile(name="test"),
             multinode=True,
@@ -78,29 +75,25 @@ class TestFilterPoolInstances:
     async def test_returns_volume_instances(self, test_db, session: AsyncSession):
         user = await create_user(session=session)
         project = await create_project(session=session, owner=user)
-        pool = await create_pool(session=session, project=project)
         aws_instance = await create_instance(
             session=session,
             project=project,
-            pool=pool,
             backend=BackendType.AWS,
         )
         runpod_instance1 = await create_instance(
             session=session,
             project=project,
-            pool=pool,
             backend=BackendType.RUNPOD,
             region="eu",
         )
         runpod_instance2 = await create_instance(
             session=session,
             project=project,
-            pool=pool,
             backend=BackendType.RUNPOD,
             region="us",
         )
         instances = [aws_instance, runpod_instance1, runpod_instance2]
-        res = services_pools.filter_pool_instances(
+        res = instances_services.filter_pool_instances(
             pool_instances=instances,
             profile=Profile(name="test"),
             volumes=[
@@ -116,36 +109,6 @@ class TestFilterPoolInstances:
         assert res == [runpod_instance2]
 
 
-class TestGenerateInstanceName:
-    @pytest.mark.asyncio
-    @pytest.mark.parametrize("test_db", ["sqlite", "postgres"], indirect=True)
-    async def test_generates_instance_name(self, test_db, session: AsyncSession):
-        user = await create_user(session=session)
-        project = await create_project(session=session, owner=user)
-        pool = await services_pools.create_pool(session=session, project=project, name="test_pool")
-        im = InstanceModel(
-            name="test_instnce",
-            project=project,
-            pool=pool,
-            status=InstanceStatus.PENDING,
-            unreachable=False,
-            job_provisioning_data="",
-            offer="",
-            backend=BackendType.REMOTE,
-            region="",
-            price=0,
-        )
-        session.add(im)
-        await session.commit()
-
-        name = await services_pools.generate_instance_name(
-            session=session, project=project, pool_name="test_pool"
-        )
-        car, _, cdr = name.partition("-")
-        assert len(car) > 0
-        assert len(cdr) > 0
-
-
 class TestInstanceModelToInstance:
     @pytest.mark.asyncio
     @pytest.mark.parametrize("test_db", ["sqlite", "postgres"], indirect=True)
@@ -181,11 +144,10 @@ class TestInstanceModelToInstance:
             status=InstanceStatus.PENDING,
             unreachable=False,
             project=project,
-            pool=None,
             job_provisioning_data='{"ssh_proxy":null, "backend":"local","hostname":"hostname_test","region":"eu-west","price":1.0,"username":"user1","ssh_port":12345,"dockerized":false,"instance_id":"test_instance","instance_type": {"name": "instance", "resources": {"cpus": 1, "memory_mib": 512, "gpus": [], "spot": false, "disk": {"size_mib": 102400}, "description":""}}}',
             offer='{"price":"LOCAL", "price":1.0, "backend":"local", "region":"eu-west-1", "availability":"available","instance": {"name": "instance", "resources": {"cpus": 1, "memory_mib": 512, "gpus": [], "spot": false, "disk": {"size_mib": 102400}, "description":""}}}',
             total_blocks=1,
             busy_blocks=0,
         )
-        instance = services_pools.instance_model_to_instance(im)
+        instance = instances_services.instance_model_to_instance(im)
         assert instance == expected_instance

tests/_internal/server/services/test_metrics.py

@@ -0,0 +1,167 @@
+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,
+    get_job_provisioning_data,
+)
+
+
+@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,
+        )
+        jpd = get_job_provisioning_data(
+            cpu_count=64, memory_gib=128, gpu_count=2, gpu_memory_gib=32
+        )
+        job = await create_job(
+            session=session,
+            run=run,
+            job_provisioning_data=jpd,
+        )
+        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="cpus_detected_num", timestamps=ts, values=[64] * len(ts)),
+            Metric(name="memory_total_bytes", timestamps=ts, values=[137438953472] * len(ts)),
+            Metric(name="gpus_detected_num", timestamps=ts, values=[2] * len(ts)),
+            Metric(name="gpu_memory_total_bytes", timestamps=ts, values=[34359738368] * len(ts)),
+            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),
+        ]

tests/_internal/server/services/test_repos.py

@@ -7,7 +7,7 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from dstack._internal.core.models.repos import RemoteRepoCreds, RemoteRepoInfo, RepoHeadWithCreds
-from dstack._internal.core.models.repos.base import RepoProtocol, RepoType
+from dstack._internal.core.models.repos.base import RepoType
 from dstack._internal.core.models.users import GlobalRole, ProjectRole
 from dstack._internal.server.models import ProjectModel, RepoCredsModel, UserModel
 from dstack._internal.server.services.projects import add_project_member
@@ -90,7 +90,6 @@ class TestGetRemoteRepo:
     ):
         repo_info = RemoteRepoInfo(repo_type="remote", repo_name="test")
         legacy_repo_creds = RemoteRepoCreds(
-            protocol=RepoProtocol.HTTPS,
             clone_url="https://git.example.com/repo.git",
             private_key=None,
             oauth_token="legacy-oauth-token",
@@ -104,7 +103,6 @@ class TestGetRemoteRepo:
             creds=legacy_repo_creds.dict(),
         )
         user_repo_creds = RemoteRepoCreds(
-            protocol=RepoProtocol.HTTPS,
             clone_url="https://git.example.com/repo.git",
             private_key=None,
             oauth_token="user-oauth-token",
@@ -142,7 +140,6 @@ class TestGetRemoteRepo:
         # another user's creds should be ignored
         another_user = await _create_user(session, project, name="another-user")
         another_user_repo_creds = RemoteRepoCreds(
-            protocol=RepoProtocol.HTTPS,
             clone_url="https://git.example.com/repo.git",
             private_key=None,
             oauth_token="another-oauth-token",
@@ -185,7 +182,6 @@ class TestGetRemoteRepo:
         repo_info = RemoteRepoInfo(repo_type="remote", repo_name="test")
         if with_legacy_creds:
             legacy_repo_creds = RemoteRepoCreds(
-                protocol=RepoProtocol.HTTPS,
                 clone_url="https://git.example.com/repo.git",
                 private_key=None,
                 oauth_token="legacy-oauth-token",
@@ -201,7 +197,6 @@ class TestGetRemoteRepo:
             creds=legacy_repo_creds.dict() if legacy_repo_creds else None,
         )
         user_repo_creds = RemoteRepoCreds(
-            protocol=RepoProtocol.HTTPS,
             clone_url="https://git.example.com/repo.git",
             private_key=None,
             oauth_token="user-oauth-token",
@@ -228,7 +223,6 @@ class TestGetRemoteRepo:
     ):
         repo_info = RemoteRepoInfo(repo_type="remote", repo_name="test")
         legacy_repo_creds = RemoteRepoCreds(
-            protocol=RepoProtocol.HTTPS,
             clone_url="https://git.example.com/repo.git",
             private_key=None,
             oauth_token="legacy-oauth-token",
@@ -259,7 +253,6 @@ class TestInitRemoteRepo:
     ):
         repo_info = RemoteRepoInfo(repo_type="remote", repo_name="test")
         repo_creds = RemoteRepoCreds(
-            protocol=RepoProtocol.HTTPS,
             clone_url="https://git.example.com/repo.git",
             private_key=None,
             oauth_token="oauth-token",
@@ -283,7 +276,6 @@ class TestInitRemoteRepo:
         old_repo_info = RemoteRepoInfo(repo_type="remote", repo_name="old-name")
         new_repo_info = RemoteRepoInfo(repo_type="remote", repo_name="new-name")
         our_repo_creds = RemoteRepoCreds(
-            protocol=RepoProtocol.HTTPS,
             clone_url="https://git.example.com/repo.git",
             private_key=None,
             oauth_token="our-oauth-token",
@@ -323,7 +315,6 @@ class TestInitRemoteRepo:
             creds=None,
         )
         old_repo_creds = RemoteRepoCreds(
-            protocol=RepoProtocol.HTTPS,
             clone_url="https://git.example.com/repo.git",
             private_key=None,
             oauth_token="oauth-token",
@@ -335,7 +326,6 @@ class TestInitRemoteRepo:
             creds=old_repo_creds.dict(),
         )
         new_repo_creds = RemoteRepoCreds(
-            protocol=RepoProtocol.HTTPS,
             clone_url="ssh://git@git.example.com/repo.git",
             private_key="private-key",
             oauth_token=None,
@@ -357,7 +347,6 @@ class TestInitRemoteRepo:
     ):
         repo_info = RemoteRepoInfo(repo_type="remote", repo_name="test")
         legacy_repo_creds = RemoteRepoCreds(
-            protocol=RepoProtocol.HTTPS,
             clone_url="https://git.example.com/repo.git",
             private_key=None,
             oauth_token="legacy-oauth-token",
@@ -371,7 +360,6 @@ class TestInitRemoteRepo:
             creds=legacy_repo_creds.dict(),
         )
         our_repo_creds = RemoteRepoCreds(
-            protocol=RepoProtocol.HTTPS,
             clone_url="https://git.example.com/repo.git",
             private_key=None,
             oauth_token="our-oauth-token",
@@ -384,7 +372,6 @@ class TestInitRemoteRepo:
         )
         another_user = await _create_user(session, project, name="another-user")
         another_user_repo_creds = RemoteRepoCreds(
-            protocol=RepoProtocol.HTTPS,
             clone_url="https://git.example.com/repo.git",
             private_key=None,
             oauth_token="another-oauth-token",

tests/_internal/server/services/test_runs.py

@@ -15,7 +15,6 @@ from dstack._internal.server.services.jobs import check_can_attach_job_volumes
 from dstack._internal.server.services.runs import scale_run_replicas
 from dstack._internal.server.testing.common import (
     create_job,
-    create_pool,
     create_project,
     create_repo,
     create_run,
@@ -39,9 +38,6 @@ async def make_run(
         session=session,
         project_id=project.id,
     )
-    project.default_pool = await create_pool(
-        session=session, project=project, pool_name="default-pool"
-    )
     run_name = "test-run"
     profile = Profile(name="test-profile")
     run_spec = get_run_spec(