argus-alm 0.12.4b1__tar.gz → 0.12.5__tar.gz

{argus_alm-0.12.4b1 → argus_alm-0.12.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: argus-alm
-Version: 0.12.4b1
+Version: 0.12.5
 Summary: Argus
 Home-page: https://github.com/scylladb/argus
 License: Apache-2.0

{argus_alm-0.12.4b1 → argus_alm-0.12.5}/argus/backend/controller/client_api.py

@@ -90,3 +90,14 @@ def run_finalize(run_type: str, run_id: str):
         "status": "ok",
         "response": result
     }
+
+
+@bp.route("/testrun/<string:run_type>/<string:run_id>/submit_results", methods=["POST"])
+@api_login_required
+def submit_results(run_type: str, run_id: str):
+    payload = get_payload(request)
+    result = ClientService().submit_results(run_type=run_type, run_id=run_id, results=payload)
+    return {
+        "status": "ok",
+        "response": result
+    }

{argus_alm-0.12.4b1 → argus_alm-0.12.5}/argus/backend/controller/testrun_api.py

@@ -63,6 +63,17 @@ def test_run_activity(run_id: str):
     }
 
 
+
+@bp.route("/run/<string:test_id>/<string:run_id>/fetch_results", methods=["GET"])
+@api_login_required
+def fetch_results(test_id: str, run_id: str):
+    tables = TestRunService().fetch_results(test_id=UUID(test_id), run_id=UUID(run_id))
+    return {
+        "status": "ok",
+        "tables": tables
+    }
+
+
 @bp.route("/test/<string:test_id>/run/<string:run_id>/status/set", methods=["POST"])
 @api_login_required
 def set_testrun_status(test_id: str, run_id: str):

argus_alm-0.12.5/argus/backend/models/result.py

@@ -0,0 +1,41 @@
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine.usertype import UserType
+from enum import Enum
+
+
+class Status(Enum):
+    PASS = 0
+    WARNING = 1
+    ERROR = 2
+
+
+class ColumnMetadata(UserType):
+    name = columns.Ascii()
+    unit = columns.Text()
+    type = columns.Ascii()
+
+
+class ArgusGenericResultMetadata(Model):
+    __table_name__ = "generic_result_metadata_v1"
+    test_id = columns.UUID(partition_key=True)
+    name = columns.Text(required=True, primary_key=True)
+    description = columns.Text()
+    columns_meta = columns.List(value_type=columns.UserDefinedType(ColumnMetadata))
+    rows_meta = columns.List(value_type=columns.Ascii())
+
+    def __init__(self, **kwargs):
+        kwargs["columns_meta"] = [ColumnMetadata(**col) for col in kwargs.pop('columns_meta', [])]
+        super().__init__(**kwargs)
+
+
+class ArgusGenericResultData(Model):
+    __table_name__ = "generic_result_data_v1"
+    test_id = columns.UUID(partition_key=True)
+    name = columns.Text(partition_key=True)
+    run_id = columns.UUID(primary_key=True)
+    column = columns.Ascii(primary_key=True, index=True)
+    row = columns.Ascii(primary_key=True, index=True)
+    sut_timestamp = columns.DateTime()  # for sorting
+    value = columns.Double()
+    status = columns.Ascii()

{argus_alm-0.12.4b1 → argus_alm-0.12.5}/argus/backend/models/web.py

@@ -6,6 +6,8 @@ from cassandra.cqlengine.usertype import UserType
 from cassandra.cqlengine import columns
 from cassandra.util import uuid_from_time, unix_time_from_uuid1  # pylint: disable=no-name-in-module
 
+from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData
+
 
 def uuid_now():
     return uuid_from_time(datetime.utcnow())
@@ -377,6 +379,8 @@ USED_MODELS: list[Model] = [
     ArgusScheduleAssignee,
     ArgusScheduleGroup,
     ArgusScheduleTest,
+    ArgusGenericResultMetadata,
+    ArgusGenericResultData,
 ]
 
 USED_TYPES: list[UserType] = [

{argus_alm-0.12.4b1 → argus_alm-0.12.5}/argus/backend/plugins/core.py

@@ -30,7 +30,7 @@ class PluginModelBase(Model):
     _plugin_name = "unknown"
     # Metadata
     build_id = columns.Text(required=True, partition_key=True)
-    start_time = columns.DateTime(required=True, primary_key=True, clustering_order="DESC", default=datetime.utcnow, custom_index=True)
+    start_time = columns.DateTime(required=True, primary_key=True, clustering_order="DESC", default=datetime.now, custom_index=True)
     id = columns.UUID(index=True, required=True)
     release_id = columns.UUID(index=True)
     group_id = columns.UUID(index=True)
@@ -105,7 +105,7 @@ class PluginModelBase(Model):
             assignees = ArgusScheduleAssignee.filter(
                 schedule_id=schedule.id
             ).all()
-            assignees_uuids.append(*[assignee.assignee for assignee in assignees])
+            assignees_uuids.extend([assignee.assignee for assignee in assignees])
 
         return assignees_uuids[0] if len(assignees_uuids) > 0 else None
 
@@ -213,6 +213,8 @@ class PluginModelBase(Model):
     def finish_run(self, payload: dict = None):
         raise NotImplementedError()
 
+    def sut_timestamp(self) -> float:
+        raise NotImplementedError()
 
 class PluginInfoBase:
     # pylint: disable=too-few-public-methods

argus_alm-0.12.5/argus/backend/plugins/driver_matrix_tests/controller.py

@@ -0,0 +1,24 @@
+from flask import Blueprint, request
+
+from argus.backend.error_handlers import handle_api_exception
+from argus.backend.service.user import api_login_required
+from argus.backend.plugins.driver_matrix_tests.service import DriverMatrixService
+
+bp = Blueprint("driver_matrix_api", __name__, url_prefix="/driver_matrix")
+bp.register_error_handler(Exception, handle_api_exception)
+
+
+@bp.route("/test_report", methods=["GET"])
+@api_login_required
+def driver_matrix_test_report():
+
+    build_id = request.args.get("buildId")
+    if not build_id:
+        raise Exception("No build id provided")
+    
+
+    result = DriverMatrixService().tested_versions_report(build_id=build_id)
+    return {
+        "status": "ok",
+        "response": result
+    }

argus_alm-0.12.5/argus/backend/plugins/driver_matrix_tests/model.py

@@ -0,0 +1,175 @@
+from dataclasses import dataclass
+from datetime import datetime
+from functools import reduce
+import re
+from uuid import UUID
+from cassandra.cqlengine import columns
+from argus.backend.db import ScyllaCluster
+from argus.backend.models.web import ArgusRelease
+from argus.backend.plugins.core import PluginModelBase
+from argus.backend.plugins.driver_matrix_tests.udt import TestCollection, TestSuite, TestCase, EnvironmentInfo
+from argus.backend.plugins.driver_matrix_tests.raw_types import RawMatrixTestResult
+from argus.backend.util.enums import TestStatus
+
+
+class DriverMatrixPluginError(Exception):
+    pass
+
+
+@dataclass(init=True, repr=True, frozen=True)
+class DriverMatrixRunSubmissionRequest():
+    schema_version: str
+    run_id: str
+    job_name: str
+    job_url: str
+    test_environment: dict[str, str]
+    matrix_results: list[RawMatrixTestResult]
+
+
+class DriverTestRun(PluginModelBase):
+    _plugin_name = "driver-matrix-tests"
+    __table_name__ = "driver_test_run"
+    scylla_version = columns.Text()
+    test_collection = columns.List(value_type=columns.UserDefinedType(user_type=TestCollection))
+    environment_info = columns.List(value_type=columns.UserDefinedType(user_type=EnvironmentInfo))
+
+    _no_upstream = ["rust"]
+
+    _artifact_fnames = {
+        "cpp": r"TEST-(?P<driver_name>[\w]*)-(?P<version>[\d\.-]*)",
+        "gocql": r"xunit\.(?P<driver_name>[\w]*)\.(?P<proto>v\d)\.(?P<version>[v\d\.]*)",
+        "python": r"pytest\.(?P<driver_name>[\w]*)\.(?P<proto>v\d)\.(?P<version>[\d\.]*)",
+        "java": r"TEST-(?P<version>[\d\.\w-]*)",
+        "rust": r"(?P<driver_name>rust)_results_v(?P<version>[\d\w\-.]*)",
+    }
+
+    @classmethod
+    def _stats_query(cls) -> str:
+        return ("SELECT id, test_id, group_id, release_id, status, start_time, build_job_url, build_id, "
+                f"assignee, end_time, investigation_status, heartbeat, scylla_version FROM {cls.table_name()} WHERE build_id IN ? PER PARTITION LIMIT 15")
+
+    @classmethod
+    def get_distinct_product_versions(cls, release: ArgusRelease) -> list[str]:
+        cluster = ScyllaCluster.get()
+        statement = cluster.prepare(f"SELECT scylla_version FROM {cls.table_name()} WHERE release_id = ?")
+        rows = cluster.session.execute(query=statement, parameters=(release.id,))
+        unique_versions = {r["scylla_version"] for r in rows if r["scylla_version"]}
+
+        return sorted(list(unique_versions), reverse=True)
+
+    @classmethod
+    def load_test_run(cls, run_id: UUID) -> 'DriverTestRun':
+        return cls.get(id=run_id)
+
+    @classmethod
+    def parse_driver_name(cls, raw_file_name: str) -> str:
+        for test, pattern in cls._artifact_fnames.items():
+            match = re.match(pattern, raw_file_name)
+            if not match:
+                continue
+            driver_info = match.groupdict()
+            if test == "java":
+                version = driver_info["version"]
+                return "scylla" if len(version.split(".")) > 3 or "scylla" in version else "datastax"
+            else:
+                return driver_info["driver_name"]
+        return "unknown_driver"
+
+
+    @classmethod
+    def submit_run(cls, request_data: dict) -> 'DriverTestRun':
+        req = DriverMatrixRunSubmissionRequest(**request_data)
+        run = cls()
+        run.id = req.run_id  # pylint: disable=invalid-name
+        run.build_id = req.job_name
+        run.build_job_url = req.job_url
+        run.assign_categories()
+        try:
+            run.assignee = run.get_scheduled_assignee()
+        except Exception:  # pylint: disable=broad-except
+            run.assignee = None
+        for key, value in req.test_environment.items():
+            env_info = EnvironmentInfo()
+            env_info.key = key
+            env_info.value = value
+            run.environment_info.append(env_info)
+
+        run.scylla_version = req.test_environment.get("scylla-version")
+        run.test_collection = []
+
+        for result in req.matrix_results:
+            collection = TestCollection()
+            collection.name = result.get("name")
+            collection.driver = cls.parse_driver_name(collection.name)
+            collection.tests_total = result.get("tests")
+            collection.failures = result.get("failures")
+            collection.errors = result.get("errors")
+            collection.skipped = result.get("skipped")
+            collection.passed = result.get("passed")
+            collection.disabled = result.get("disabled")
+            collection.time = result.get("time")
+            timestamp = result.get("timestamp")
+            # TODO: Not needed once python>=3.11
+            timestamp = timestamp[0:-1] if timestamp[-1] == "Z" else timestamp
+            collection.timestamp = datetime.fromisoformat(timestamp)
+            for raw_suite in result.get("suites"):
+                suite = TestSuite()
+                suite.name = raw_suite.get("name")
+                suite.tests_total = raw_suite.get("tests")
+                suite.failures = raw_suite.get("failures")
+                suite.errors = raw_suite.get("errors")
+                suite.skipped = raw_suite.get("skipped")
+                suite.passed = raw_suite.get("passed")
+                suite.disabled = raw_suite.get("disabled")
+                suite.time = raw_suite.get("time")
+
+                for raw_case in raw_suite.get("cases"):
+                    case = TestCase()
+                    case.name = raw_case.get("name")
+                    case.status = raw_case.get("status")
+                    case.time = raw_case.get("time")
+                    case.classname = raw_case.get("classname")
+                    case.message = raw_case.get("message")
+                    suite.cases.append(case)
+
+                collection.suites.append(suite)
+            run.test_collection.append(collection)
+
+        run.status = run._determine_run_status().value
+        run.save()
+        return run
+
+    def get_resources(self) -> list:
+        return []
+
+    def get_nemeses(self) -> list:
+        return []
+
+    def _determine_run_status(self):
+        if len(self.test_collection) < 2:
+            return TestStatus.FAILED
+
+        driver_types = {collection.driver for collection in self.test_collection}
+        if len(driver_types) <= 1 and not any(driver for driver in self._no_upstream if driver in driver_types):
+            return TestStatus.FAILED
+
+        failure_count = reduce(lambda acc, val: acc + (val.failures + val.errors), self.test_collection, 0)
+        if failure_count > 0:
+            return TestStatus.FAILED
+
+        return TestStatus.PASSED
+
+    def change_status(self, new_status: TestStatus):
+        raise DriverMatrixPluginError("This method is obsolete. Status is now determined on submission.")
+
+    def get_events(self) -> list:
+        return []
+
+    def submit_product_version(self, version: str):
+        self.scylla_version = version
+
+    def finish_run(self, payload: dict = None):
+        self.end_time = datetime.utcnow()
+
+    def submit_logs(self, logs: list[dict]):
+        pass

{argus_alm-0.12.4b1 → argus_alm-0.12.5}/argus/backend/plugins/driver_matrix_tests/raw_types.py

@@ -1,6 +1,4 @@
-from dataclasses import dataclass
 from typing import TypedDict
-from uuid import UUID
 
 
 class RawMatrixTestCase(TypedDict):
@@ -35,28 +33,3 @@ class RawMatrixTestResult(TypedDict):
     time: float
     timestamp: str
     suites: list[RawMatrixTestSuite]
-
-
-@dataclass(init=True, frozen=True)
-class DriverMatrixSubmitResultRequest():
-    schema_version: str
-    run_id: UUID
-    driver_type: str
-    driver_name: str
-    raw_xml: str
-
-
-@dataclass(init=True, frozen=True)
-class DriverMatrixSubmitFailureRequest():
-    schema_version: str
-    run_id: UUID
-    driver_type: str
-    driver_name: str
-    failure_reason: str
-
-
-@dataclass(init=True, frozen=True)
-class DriverMatrixSubmitEnvRequest():
-    schema_version: str
-    run_id: UUID
-    raw_env: str

{argus_alm-0.12.4b1 → argus_alm-0.12.5}/argus/backend/plugins/driver_matrix_tests/service.py

@@ -1,13 +1,8 @@
-import base64
-import logging
-from uuid import UUID
 from argus.backend.db import ScyllaCluster
 from argus.backend.models.web import ArgusRelease, ArgusTest
 from argus.backend.plugins.driver_matrix_tests.model import DriverTestRun
 
 
-LOGGER = logging.getLogger(__name__)
-
 class DriverMatrixService:
     def tested_versions_report(self, build_id: str) -> dict:
         db = ScyllaCluster.get()
@@ -45,16 +40,3 @@ class DriverMatrixService:
             "versions": version_map,
         }
         return response
-
-    def submit_driver_result(self, run_id: UUID | str, driver_name: str, driver_type: str, raw_xml: str) -> bool:
-        xml_data = base64.decodebytes(bytes(raw_xml, encoding="utf-8"))
-        DriverTestRun.submit_driver_result(UUID(run_id), driver_name, driver_type, xml_data)
-        return True
-
-    def submit_driver_failure(self, run_id: UUID | str, driver_name: str, driver_type: str, failure_reason: str) -> bool:
-        DriverTestRun.submit_driver_failure(UUID(run_id), driver_name, driver_type, failure_reason)
-        return True
-
-    def submit_env_info(self, run_id: UUID | str, raw_env: str) -> bool:
-        DriverTestRun.submit_env_info(UUID(run_id), raw_env)
-        return True

{argus_alm-0.12.4b1 → argus_alm-0.12.5}/argus/backend/plugins/driver_matrix_tests/udt.py

@@ -12,12 +12,12 @@ class TestCase(UserType):
 
 class TestSuite(UserType):
     name = columns.Text()
-    tests_total = columns.Integer(default=lambda: 0)
-    failures = columns.Integer(default=lambda: 0)
-    disabled = columns.Integer(default=lambda: 0)
-    skipped = columns.Integer(default=lambda: 0)
-    passed = columns.Integer(default=lambda: 0)
-    errors = columns.Integer(default=lambda: 0)
+    tests_total = columns.Integer()
+    failures = columns.Integer()
+    disabled = columns.Integer()
+    skipped = columns.Integer()
+    passed = columns.Integer()
+    errors = columns.Integer()
     time = columns.Float()
     cases = columns.List(value_type=columns.UserDefinedType(user_type=TestCase))
 
@@ -25,15 +25,14 @@ class TestSuite(UserType):
 class TestCollection(UserType):
     name = columns.Text()
     driver = columns.Text()
-    tests_total = columns.Integer(default=lambda: 0)
-    failure_message = columns.Text()
-    failures = columns.Integer(default=lambda: 0)
-    disabled = columns.Integer(default=lambda: 0)
-    skipped = columns.Integer(default=lambda: 0)
-    passed = columns.Integer(default=lambda: 0)
-    errors = columns.Integer(default=lambda: 0)
+    tests_total = columns.Integer()
+    failures = columns.Integer()
+    disabled = columns.Integer()
+    skipped = columns.Integer()
+    passed = columns.Integer()
+    errors = columns.Integer()
     timestamp = columns.DateTime()
-    time = columns.Float(default=lambda: 0.0)
+    time = columns.Float()
     suites = columns.List(value_type=columns.UserDefinedType(user_type=TestSuite))
 
 

{argus_alm-0.12.4b1 → argus_alm-0.12.5}/argus/backend/plugins/sct/testrun.py

@@ -249,6 +249,13 @@ class SCTTestRun(PluginModelBase):
 
         self._collect_event_message(event, event_message)
 
+    def sut_timestamp(self) -> float:
+        """converts scylla-server date to timestamp and adds revision in subseconds precision to diffirentiate
+        scylla versions from the same day. It's not perfect, but we don't know exact version time."""
+        scylla_package = [package for package in self.packages if package.name == "scylla-server"][0]
+        return (datetime.strptime(scylla_package.date, '%Y%m%d').timestamp()
+                + int(scylla_package.revision_id, 16) % 1000000 / 1000000)
+
 
 class SCTJunitReports(Model):
     test_id = columns.UUID(primary_key=True, partition_key=True, required=True)

{argus_alm-0.12.4b1 → argus_alm-0.12.5}/argus/backend/service/client_service.py

@@ -1,5 +1,6 @@
 from uuid import UUID
 from argus.backend.db import ScyllaCluster
+from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData
 from argus.backend.plugins.core import PluginModelBase
 from argus.backend.plugins.loader import AVAILABLE_PLUGINS
 from argus.backend.util.enums import TestStatus
@@ -69,3 +70,20 @@ class ClientService:
         run.save()
 
         return "Finalized"
+
+    def submit_results(self, run_type: str, run_id: str, results: dict) -> str:
+        model = self.get_model(run_type)
+        run = model.load_test_run(UUID(run_id))
+        ArgusGenericResultMetadata(test_id=run.test_id, **results["meta"]).save()
+        if results.get("sut_timestamp", 0) == 0:
+            results["sut_timestamp"] = run.sut_timestamp()  # automatic sut_timestamp
+        table_name = results["meta"]["name"]
+        sut_timestamp = results["sut_timestamp"]
+        for cell in results["results"]:
+            ArgusGenericResultData(test_id=run.test_id,
+                                   run_id=run.id,
+                                   name=table_name,
+                                   sut_timestamp=sut_timestamp,
+                                   **cell
+                                   ).save()
+        return "Submitted"

{argus_alm-0.12.4b1 → argus_alm-0.12.5}/argus/backend/service/testrun.py

@@ -13,6 +13,7 @@ from flask import g
 from cassandra.query import BatchStatement, ConsistencyLevel
 from cassandra.cqlengine.query import BatchQuery
 from argus.backend.db import ScyllaCluster
+from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData
 
 from argus.backend.models.web import (
     ArgusEvent,
@@ -306,6 +307,24 @@ class TestRunService:
         }
         return response
 
+    def fetch_results(self, test_id: UUID, run_id: UUID) -> dict:
+        query_fields = ["column", "row", "value", "status"]
+        tables_meta = ArgusGenericResultMetadata.filter(test_id=test_id)
+        tables = []
+        for table in tables_meta:
+            cells = ArgusGenericResultData.objects.filter(test_id=test_id, run_id=run_id, name=table.name).only(query_fields)
+            if not cells:
+                continue
+            tables.append({'meta': {
+                'name': table.name,
+                'description': table.description,
+                'columns_meta': table.columns_meta,
+                'rows_meta': table.rows_meta
+            },
+                'cells': [{k:v for k,v in cell.items() if k in query_fields} for cell in cells]})
+
+        return tables
+
     def submit_github_issue(self, issue_url: str, test_id: UUID, run_id: UUID):
         user_tokens = UserOauthToken.filter(user_id=g.user.id).all()
         token = None

{argus_alm-0.12.4b1 → argus_alm-0.12.5}/argus/client/base.py

@@ -7,6 +7,7 @@ from uuid import UUID
 import requests
 
 from argus.backend.util.enums import TestStatus
+from argus.client.generic_result import GenericResultTable
 from argus.client.sct.types import LogLink
 
 JSON = dict[str, Any] | list[Any] | int | str | float | bool | Type[None]
@@ -28,6 +29,8 @@ class ArgusClient:
         SET_STATUS = "/testrun/$type/$id/set_status"
         SET_PRODUCT_VERSION = "/testrun/$type/$id/update_product_version"
         SUBMIT_LOGS = "/testrun/$type/$id/logs/submit"
+        SUBMIT_RESULTS = "/testrun/$type/$id/submit_results"
+        FETCH_RESULTS = "/testrun/$type/$id/fetch_results"
         FINALIZE = "/testrun/$type/$id/finalize"
 
     def __init__(self, auth_token: str, base_url: str, api_version="v1") -> None:
@@ -190,3 +193,16 @@ class ArgusClient:
             }
         )
         self.check_response(response)
+
+    def submit_results(self, result: GenericResultTable) -> None:
+        response = self.post(
+            endpoint=self.Routes.SUBMIT_RESULTS,
+            location_params={"type": self.test_type, "id": str(self.run_id)},
+            body={
+                **self.generic_body,
+                "run_id": str(self.run_id),
+                ** result.as_dict(),
+            }
+        )
+        self.check_response(response)
+