argus-alm 0.12.3__py3-none-any.whl → 0.12.4b1__py3-none-any.whl

argus/backend/plugins/driver_matrix_tests/model.py

@@ -1,8 +1,12 @@
 from dataclasses import dataclass
 from datetime import datetime
 from functools import reduce
+import logging
+from pprint import pformat
 import re
+from typing import Literal, TypedDict
 from uuid import UUID
+from xml.etree import ElementTree
 from cassandra.cqlengine import columns
 from argus.backend.db import ScyllaCluster
 from argus.backend.models.web import ArgusRelease
@@ -12,6 +16,8 @@ from argus.backend.plugins.driver_matrix_tests.raw_types import RawMatrixTestRes
 from argus.backend.util.enums import TestStatus
 
 
+LOGGER = logging.getLogger(__name__)
+
 class DriverMatrixPluginError(Exception):
     pass
 
@@ -26,6 +32,65 @@ class DriverMatrixRunSubmissionRequest():
     matrix_results: list[RawMatrixTestResult]
 
 
+@dataclass(init=True, repr=True, frozen=True)
+class DriverMatrixRunSubmissionRequestV2():
+    schema_version: str
+    run_id: str
+    job_name: str
+    job_url: str
+
+
+TestTypeType = Literal['java', 'cpp', 'python', 'gocql']
+
+
+class AdaptedXUnitData(TypedDict):
+    timestamp: str
+
+
+def python_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
+    testsuites = list(xml.getroot().iter("testsuite"))
+
+    return {
+        "timestamp": testsuites[0].attrib.get("timestamp"),
+    }
+
+
+def java_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
+    testsuites = xml.getroot()
+    ts_now = datetime.utcnow().timestamp()
+    try:
+        time_taken = float(testsuites.attrib.get("time"))
+    except ValueError:
+        time_taken = 0.0
+
+    timestamp = datetime.utcfromtimestamp(ts_now - time_taken).isoformat()
+
+    return {
+        "timestamp": timestamp,
+    }
+
+
+def cpp_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
+    testsuites = xml.getroot()
+
+    return {
+        "timestamp": testsuites.attrib.get("timestamp"),
+    }
+
+
+def gocql_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
+    testsuites = list(xml.getroot().iter("testsuite"))
+
+    return {
+        "timestamp": testsuites[0].attrib.get("timestamp"),
+    }
+
+
+def generic_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
+    return {
+        "timestamp": datetime.utcnow().isoformat()
+    }
+
 class DriverTestRun(PluginModelBase):
     _plugin_name = "driver-matrix-tests"
     __table_name__ = "driver_test_run"
@@ -33,12 +98,22 @@ class DriverTestRun(PluginModelBase):
     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"]
+
+    _TEST_ADAPTERS = {
+        "java": java_driver_matrix_adapter,
+        "cpp": cpp_driver_matrix_adapter,
+        "python": python_driver_matrix_adapter,
+        "gocql": gocql_driver_matrix_adapter,
+    }
+
 
     _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
@@ -76,6 +151,173 @@ class DriverTestRun(PluginModelBase):
 
     @classmethod
     def submit_run(cls, request_data: dict) -> 'DriverTestRun':
+        if request_data["schema_version"] == "v2":
+            req = DriverMatrixRunSubmissionRequestV2(**request_data)
+        else:
+            return cls.submit_matrix_run(request_data)
+
+        run = cls()
+        run.id = req.run_id
+        run.build_id = req.job_name
+        run.build_job_url = req.job_url
+        run.start_time = datetime.utcnow()
+        run.assign_categories()
+        try:
+            run.assignee = run.get_scheduled_assignee()
+        except Exception:  # pylint: disable=broad-except
+            run.assignee = None
+
+        run.status = TestStatus.CREATED.value
+        run.save()
+        return run
+
+    @classmethod
+    def submit_driver_result(cls, run_id: UUID, driver_name: str, driver_type: TestTypeType, xml_data: str):
+        run: DriverTestRun = cls.get(id=run_id)
+
+        collection = run.parse_result_xml(driver_name, xml_data, driver_type)
+        run.test_collection.append(collection)
+
+        if run.status == TestStatus.CREATED:
+            run.status = TestStatus.RUNNING.value
+
+        run.save()
+        return run
+
+
+    @classmethod
+    def submit_driver_failure(cls, run_id: UUID, driver_name: str, driver_type: TestTypeType, fail_message: str):
+        run: DriverTestRun = cls.get(id=run_id)
+
+        collection = TestCollection()
+        collection.failures = 1
+        collection.failure_message = fail_message
+        collection.name = driver_name
+        driver_info = run.get_driver_info(driver_name, driver_type)
+        collection.driver = driver_info.get("driver_name")
+        collection.tests_total = 1
+        run.test_collection.append(collection)
+
+        if run.status == TestStatus.CREATED:
+            run.status = TestStatus.RUNNING.value
+
+        run.save()
+        return run
+
+    @classmethod
+    def submit_env_info(cls, run_id: UUID, env_data: str):
+        run: DriverTestRun = cls.get(id=run_id)
+        env = run.parse_build_environment(env_data)
+
+        for key, value in env.items():
+            env_info = EnvironmentInfo()
+            env_info.key = key
+            env_info.value = value
+            run.environment_info.append(env_info)
+
+        run.scylla_version = env.get("scylla-version")
+
+        run.save()
+        return run
+
+    def parse_build_environment(self, raw_env: str) -> dict[str, str]:
+        result = {}
+        for line in raw_env.split("\n"):
+            if not line:
+                continue
+            LOGGER.debug("ENV: %s", line)
+            key, val = line.split(": ")
+            result[key] = val.strip()
+
+        return result
+
+    def get_test_cases(self, cases: list[ElementTree.Element]) -> list[TestCase]:
+        result = []
+        for raw_case in cases:
+            children = list(raw_case.findall("./*"))
+            if len(children) > 0:
+                status = children[0].tag
+                message = f"{children[0].attrib.get('message', 'no-message')} ({children[0].attrib.get('type', 'no-type')})"
+            else:
+                status = "passed"
+                message = ""
+
+            case = TestCase()
+            case.name = raw_case.attrib["name"]
+            case.status = status
+            case.time = float(raw_case.attrib.get("time", 0.0))
+            case.classname = raw_case.attrib.get("classname", "")
+            case.message = message
+            result.append(case)
+
+        return result
+
+    def get_driver_info(self, xml_name: str, test_type: TestTypeType) -> dict[str, str]:
+        if test_type == "cpp":
+            filename_re = r"TEST-(?P<driver_name>[\w]*)-(?P<version>[\d\.]*)(\.xml)?"
+        else:
+            filename_re = r"(?P<name>[\w]*)\.(?P<driver_name>[\w]*)\.(?P<proto>v\d)\.(?P<version>[\d\.]*)(\.xml)?"
+
+        match = re.match(filename_re, xml_name)
+
+        return match.groupdict() if match else {}
+
+    def get_passed_count(self, suite_attribs: dict[str, str]) -> int:
+        if (pass_count := suite_attribs.get("passed")):
+            return int(pass_count)
+        total = int(suite_attribs.get("tests", 0))
+        errors = int(suite_attribs.get("errors", 0))
+        skipped = int(suite_attribs.get("skipped", 0))
+        failures = int(suite_attribs.get("failures", 0))
+
+        return total - errors - skipped - failures
+
+    def parse_result_xml(self, name: str, xml_data: str, test_type: TestTypeType) -> TestCollection:
+        xml: ElementTree.ElementTree = ElementTree.ElementTree(ElementTree.fromstring(xml_data))
+        LOGGER.debug("%s", pformat(xml))
+        testsuites = xml.getroot()
+        adapted_data = self._TEST_ADAPTERS.get(test_type, generic_adapter)(xml)
+
+        driver_info = self.get_driver_info(name, test_type)
+        test_collection = TestCollection()
+        test_collection.timestamp = datetime.fromisoformat(adapted_data["timestamp"][0:-1] if adapted_data["timestamp"][-1] == "Z" else adapted_data["timestamp"])
+        test_collection.name = name
+        test_collection.driver = driver_info.get("driver_name")
+        test_collection.tests_total = 0
+        test_collection.failures = 0
+        test_collection.errors = 0
+        test_collection.disabled = 0
+        test_collection.skipped = 0
+        test_collection.passed = 0
+        test_collection.time = 0.0
+        test_collection.suites = []
+
+        for xml_suite in testsuites.iter("testsuite"):
+            suite = TestSuite()
+            suite.name = xml_suite.attrib["name"]
+            suite.tests_total = int(xml_suite.attrib.get("tests", 0))
+            suite.failures = int(xml_suite.attrib.get("failures", 0))
+            suite.disabled = int(0)
+            suite.passed = self.get_passed_count(xml_suite.attrib)
+            suite.skipped = int(xml_suite.attrib.get("skipped", 0))
+            suite.errors = int(xml_suite.attrib.get("errors", 0))
+            suite.time = float(xml_suite.attrib["time"])
+            suite.cases = self.get_test_cases(xml_suite.findall("testcase"))
+
+            test_collection.suites.append(suite)
+            test_collection.tests_total += suite.tests_total
+            test_collection.failures += suite.failures
+            test_collection.errors += suite.errors
+            test_collection.disabled += suite.disabled
+            test_collection.skipped += suite.skipped
+            test_collection.passed += suite.passed
+            test_collection.time += suite.time
+
+        return test_collection
+
+    @classmethod
+    def submit_matrix_run(cls, request_data):
+        # Legacy method
         req = DriverMatrixRunSubmissionRequest(**request_data)
         run = cls()
         run.id = req.run_id  # pylint: disable=invalid-name
@@ -144,21 +386,26 @@ class DriverTestRun(PluginModelBase):
         return []
 
     def _determine_run_status(self):
+        for collection in self.test_collection:
+            # patch failure
+            if collection.failure_message:
+                return TestStatus.FAILED
+
         if len(self.test_collection) < 2:
             return TestStatus.FAILED
 
         driver_types = {collection.driver for collection in self.test_collection}
-        if len(driver_types) <= 1:
+        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)
+        failure_count = reduce(lambda acc, val: acc + (val.failures or 0 + val.errors or 0), 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.")
+        self.status = new_status
 
     def get_events(self) -> list:
         return []
@@ -168,6 +415,7 @@ class DriverTestRun(PluginModelBase):
 
     def finish_run(self, payload: dict = None):
         self.end_time = datetime.utcnow()
+        self.status = self._determine_run_status().value
 
     def submit_logs(self, logs: list[dict]):
         pass

argus/backend/plugins/driver_matrix_tests/raw_types.py

@@ -1,4 +1,6 @@
+from dataclasses import dataclass
 from typing import TypedDict
+from uuid import UUID
 
 
 class RawMatrixTestCase(TypedDict):
@@ -33,3 +35,28 @@ 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/backend/plugins/driver_matrix_tests/service.py

@@ -1,8 +1,13 @@
+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()
@@ -40,3 +45,16 @@ 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/backend/plugins/driver_matrix_tests/udt.py

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

argus/backend/plugins/generic/model.py

@@ -1,4 +1,5 @@
 from datetime import datetime
+import re
 from uuid import UUID
 from cassandra.cqlengine import columns
 from cassandra.cqlengine.models import Model
@@ -37,8 +38,10 @@ class GenericRun(PluginModelBase):
         return sorted(list(unique_versions), reverse=True)
 
     def submit_product_version(self, version: str):
-        self.scylla_version = version
-        self.set_product_version(version)
+        pattern = re.compile(r"((?P<short>[\w.~]+)-(?P<build>(0\.)?(?P<date>[0-9]{8,8})\.(?P<commit>\w+).*))")
+        if match := pattern.search(version):
+            self.scylla_version = match.group("short")
+            self.set_full_version(version)
 
     @classmethod
     def load_test_run(cls, run_id: UUID) -> 'GenericRun':

argus/backend/plugins/sct/service.py

@@ -1,5 +1,6 @@
 import base64
 from dataclasses import dataclass
+from datetime import datetime
 from functools import reduce
 import logging
 import math
@@ -397,14 +398,25 @@ class SCTService:
         coredump_events = filter(lambda v: "coredumpevent" in v.lower(), flat_messages)
         for idx, event in enumerate(coredump_events):
             core_pattern = r"corefile_url=(?P<url>.+)$"
+            ts_pattern = r"^(?P<ts>\d{4}-\d{2}-\d{2} ([\d:]*)\.\d{3})"
             node_name_pattern = r"node=(?P<name>.+)$"
             core_url_match = re.search(core_pattern, event, re.MULTILINE)
             node_name_match = re.search(node_name_pattern, event, re.MULTILINE)
+            ts_match = re.search(ts_pattern, event)
             if core_url_match:
                 node_name = node_name_match.group("name") if node_name_match else f"unknown-node-{idx}"
+                split_name = node_name.split(" ")
+                node_name = split_name[1] if len(split_name) >= 2 else node_name
                 url = core_url_match.group("url")
+                timestamp_component = ""
+                if ts_match:
+                    try:
+                        timestamp = datetime.fromisoformat(ts_match.group("ts"))
+                        timestamp_component = timestamp.strftime("-%Y-%m-%d_%H-%M-%S")
+                    except ValueError:
+                        pass
                 log_link = {
-                    "log_name": f"COREDUMP-{node_name}",
+                    "log_name": f"core.scylla-{node_name}{timestamp_component}.gz",
                     "log_link": url
                 }
                 links.append(log_link)