feat: add hardware selectors and revision API

Author: Gustavo Flores

backend/kernelCI_app/queries/hardware.py

@@ -201,6 +201,134 @@ def get_hardware_listing_data(
         return cursor.fetchall()
 
 
+def get_hardware_selectors(origin: str) -> list[dict]:
+    params = {"origin": origin}
+
+    query = """
+        WITH qualified_revisions AS (
+            SELECT
+                c.tree_name,
+                c.git_repository_url,
+                c.git_repository_branch,
+                c.git_commit_hash,
+                c.git_commit_name,
+                MAX(c.start_time) AS latest_start_time
+            FROM
+                checkouts c
+                INNER JOIN builds b ON b.checkout_id = c.id
+                INNER JOIN tests ON tests.build_id = b.id
+            WHERE
+                tests.origin = %(origin)s
+                AND tests.environment_misc ->> 'platform' IS NOT NULL
+            GROUP BY
+                c.tree_name,
+                c.git_repository_url,
+                c.git_repository_branch,
+                c.git_commit_hash,
+                c.git_commit_name
+        )
+        SELECT
+            qr.tree_name,
+            qr.git_repository_url,
+            qr.git_repository_branch,
+            qr.git_commit_hash,
+            qr.git_commit_name,
+            qr.latest_start_time,
+            MAX(qr.latest_start_time) OVER (
+                PARTITION BY
+                    qr.tree_name,
+                    qr.git_repository_url,
+                    qr.git_repository_branch
+            ) AS branch_latest_start_time
+        FROM
+            qualified_revisions qr
+        ORDER BY
+            qr.tree_name ASC,
+            branch_latest_start_time DESC,
+            qr.latest_start_time DESC
+    """
+
+    with connection.cursor() as cursor:
+        cursor.execute(query, params)
+        return dict_fetchall(cursor)
+
+
+def get_hardware_listing_data_by_revision(
+    *,
+    origin: str,
+    tree_name: str,
+    git_repository_url: str,
+    git_repository_branch: str,
+    git_commit_hash: str,
+) -> list[dict]:
+    count_clauses = _get_hardware_listing_count_clauses()
+    params = {
+        "origin": origin,
+        "tree_name": tree_name,
+        "git_repository_url": git_repository_url,
+        "git_repository_branch": git_repository_branch,
+        "git_commit_hash": git_commit_hash,
+    }
+
+    query = f"""
+        WITH relevant_tests AS (
+            SELECT
+                tests.environment_compatible,
+                tests.environment_misc ->> 'platform' AS platform,
+                tests.status,
+                tests.path,
+                tests.id,
+                b.id AS build_id,
+                b.status AS build_status
+            FROM
+                checkouts c
+                INNER JOIN builds b ON b.checkout_id = c.id
+                INNER JOIN tests ON tests.build_id = b.id
+            WHERE
+                c.tree_name = %(tree_name)s
+                AND c.git_repository_url = %(git_repository_url)s
+                AND c.git_repository_branch = %(git_repository_branch)s
+                AND c.git_commit_hash = %(git_commit_hash)s
+                AND tests.origin = %(origin)s
+                AND tests.environment_misc ->> 'platform' IS NOT NULL
+        ),
+        compatible_values AS (
+            SELECT
+                platform,
+                UNNEST(environment_compatible) AS compatible
+            FROM
+                relevant_tests
+            WHERE
+                environment_compatible IS NOT NULL
+        ),
+        compatible_agg AS (
+            SELECT
+                platform,
+                ARRAY_AGG(DISTINCT compatible ORDER BY compatible) AS hardware
+            FROM
+                compatible_values
+            GROUP BY
+                platform
+        )
+        SELECT
+            relevant_tests.platform,
+            compatible_agg.hardware,
+            {count_clauses}
+        FROM
+            relevant_tests
+            LEFT JOIN compatible_agg ON compatible_agg.platform = relevant_tests.platform
+        GROUP BY
+            relevant_tests.platform,
+            compatible_agg.hardware
+        ORDER BY
+            relevant_tests.platform ASC
+    """
+
+    with connection.cursor() as cursor:
+        cursor.execute(query, params)
+        return dict_fetchall(cursor)
+
+
 def get_hardware_listing_data_bulk(
     keys: list[tuple[str, str]],
     start_date: datetime,

backend/kernelCI_app/tests/unitTests/url_patterns_test.py

@@ -133,3 +133,11 @@ def test_tree_commit_hash_patterns(self):
         url = reverse("treeDetailsSummaryView", kwargs={"commit_hash": commit_hash})
         resolved = resolve(url)
         assert resolved.kwargs["commit_hash"] == commit_hash
+
+    def test_hardware_selectors_route(self):
+        url = reverse("hardwareSelectors")
+        resolved = resolve(url)
+
+        assert url == "/api/hardware/selectors/"
+        assert resolved.url_name == "hardwareSelectors"
+        assert "hardware_id" not in resolved.kwargs

backend/kernelCI_app/typeModels/hardwareListingByRevision.py

@@ -0,0 +1,36 @@
+from typing import Annotated
+
+from pydantic import BaseModel, BeforeValidator, Field
+
+from kernelCI_app.constants.general import DEFAULT_ORIGIN
+from kernelCI_app.constants.localization import DocStrings
+
+
+class HardwareListingByRevisionQueryParamsDocumentationOnly(BaseModel):
+    origin: Annotated[
+        str,
+        Field(
+            default=DEFAULT_ORIGIN,
+            description=DocStrings.HARDWARE_LISTING_ORIGIN_DESCRIPTION,
+        ),
+    ]
+    tree_name: str = Field(description=DocStrings.TREE_NAME_PATH_DESCRIPTION)
+    git_repository_url: str = Field(
+        description=DocStrings.TREE_QUERY_GIT_URL_DESCRIPTION
+    )
+    git_repository_branch: str = Field(
+        description=DocStrings.DEFAULT_GIT_BRANCH_DESCRIPTION
+    )
+    git_commit_hash: str = Field(description=DocStrings.COMMIT_HASH_PATH_DESCRIPTION)
+
+
+class HardwareListingByRevisionQueryParams(BaseModel):
+    origin: Annotated[
+        str,
+        Field(default=DEFAULT_ORIGIN),
+        BeforeValidator(lambda o: DEFAULT_ORIGIN if o is None else o),
+    ]
+    tree_name: str
+    git_repository_url: str
+    git_repository_branch: str
+    git_commit_hash: str

backend/kernelCI_app/typeModels/hardwareSelectors.py

@@ -0,0 +1,48 @@
+from datetime import datetime
+from typing import Annotated
+
+from pydantic import BaseModel, BeforeValidator, Field
+
+from kernelCI_app.constants.general import DEFAULT_ORIGIN
+from kernelCI_app.constants.localization import DocStrings
+
+
+class HardwareSelectorRevision(BaseModel):
+    git_commit_hash: str
+    git_commit_name: str | None = None
+    start_time: datetime
+
+
+class HardwareSelectorBranch(BaseModel):
+    git_repository_url: str
+    git_repository_branch: str
+    latest_start_time: datetime
+    revisions: list[HardwareSelectorRevision]
+
+
+class HardwareSelectorTree(BaseModel):
+    tree_name: str
+    latest_start_time: datetime
+    branches: list[HardwareSelectorBranch]
+
+
+class HardwareSelectorsResponse(BaseModel):
+    trees: list[HardwareSelectorTree]
+
+
+class HardwareSelectorsQueryParamsDocumentationOnly(BaseModel):
+    origin: Annotated[
+        str,
+        Field(
+            default=DEFAULT_ORIGIN,
+            description=DocStrings.HARDWARE_LISTING_ORIGIN_DESCRIPTION,
+        ),
+    ]
+
+
+class HardwareSelectorsQueryParams(BaseModel):
+    origin: Annotated[
+        str,
+        Field(default=DEFAULT_ORIGIN),
+        BeforeValidator(lambda o: DEFAULT_ORIGIN if o is None else o),
+    ]

backend/kernelCI_app/urls.py

@@ -115,6 +115,11 @@ def view_cache(view):
         name="testIssues",
     ),
     path("log-downloader/", view_cache(views.LogDownloaderView), name="logDownloader"),
+    path(
+        "hardware/selectors/",
+        view_cache(views.HardwareSelectorsView),
+        name="hardwareSelectors",
+    ),
     path(
         "hardware/<str:hardware_id>",
         view_cache(views.HardwareDetails),
@@ -146,6 +151,11 @@ def view_cache(view):
         name="hardwareDetailsTests",
     ),
     path("hardware/", view_cache(views.HardwareView), name="hardware"),
+    path(
+        "hardware-by-revision/",
+        view_cache(views.HardwareByRevisionView),
+        name="hardwareByRevision",
+    ),
     path("hardware-v2/", view_cache(views.HardwareViewV2), name="hardware-v2"),
     path("issue/", view_cache(views.IssueView), name="issue"),
     path(

backend/kernelCI_app/views/hardwareByRevisionView.py

@@ -0,0 +1,90 @@
+from http import HTTPStatus
+
+from drf_spectacular.utils import extend_schema
+from pydantic import ValidationError
+from rest_framework.request import Request
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from kernelCI_app.queries.hardware import get_hardware_listing_data_by_revision
+from kernelCI_app.typeModels.hardwareListing import (
+    HardwareItem,
+    HardwareListingResponse,
+)
+from kernelCI_app.typeModels.hardwareListingByRevision import (
+    HardwareListingByRevisionQueryParams,
+    HardwareListingByRevisionQueryParamsDocumentationOnly,
+)
+
+
+class HardwareByRevisionView(APIView):
+    def _sanitize_records(self, hardwares_raw: list[dict]) -> list[HardwareItem]:
+        hardwares = []
+        for hardware in hardwares_raw:
+            hardwares.append(
+                HardwareItem(
+                    platform=hardware["platform"],
+                    hardware=hardware["hardware"],
+                    build_status_summary={
+                        "PASS": hardware["pass_builds"],
+                        "FAIL": hardware["fail_builds"],
+                        "NULL": hardware["null_builds"],
+                        "ERROR": hardware["error_builds"],
+                        "MISS": hardware["miss_builds"],
+                        "DONE": hardware["done_builds"],
+                        "SKIP": hardware["skip_builds"],
+                    },
+                    boot_status_summary={
+                        "PASS": hardware["pass_boots"],
+                        "FAIL": hardware["fail_boots"],
+                        "NULL": hardware["null_boots"],
+                        "ERROR": hardware["error_boots"],
+                        "MISS": hardware["miss_boots"],
+                        "DONE": hardware["done_boots"],
+                        "SKIP": hardware["skip_boots"],
+                    },
+                    test_status_summary={
+                        "PASS": hardware["pass_tests"],
+                        "FAIL": hardware["fail_tests"],
+                        "NULL": hardware["null_tests"],
+                        "ERROR": hardware["error_tests"],
+                        "MISS": hardware["miss_tests"],
+                        "DONE": hardware["done_tests"],
+                        "SKIP": hardware["skip_tests"],
+                    },
+                )
+            )
+
+        return hardwares
+
+    @extend_schema(
+        parameters=[HardwareListingByRevisionQueryParamsDocumentationOnly],
+        responses=HardwareListingResponse,
+    )
+    def get(self, request: Request):
+        try:
+            query_params = HardwareListingByRevisionQueryParams(
+                origin=request.GET.get("origin"),
+                tree_name=request.GET.get("tree_name"),
+                git_repository_url=request.GET.get("git_repository_url"),
+                git_repository_branch=request.GET.get("git_repository_branch"),
+                git_commit_hash=request.GET.get("git_commit_hash"),
+            )
+        except ValidationError as e:
+            return Response(data=e.json(), status=HTTPStatus.BAD_REQUEST)
+
+        hardwares_raw = get_hardware_listing_data_by_revision(
+            origin=query_params.origin,
+            tree_name=query_params.tree_name,
+            git_repository_url=query_params.git_repository_url,
+            git_repository_branch=query_params.git_repository_branch,
+            git_commit_hash=query_params.git_commit_hash,
+        )
+
+        try:
+            sanitized_records = self._sanitize_records(hardwares_raw=hardwares_raw)
+            result = HardwareListingResponse(hardware=sanitized_records)
+        except ValidationError as e:
+            return Response(data=e.json(), status=HTTPStatus.INTERNAL_SERVER_ERROR)
+
+        return Response(data=result.model_dump(), status=HTTPStatus.OK)