argus-alm 0.12.2__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,18 +98,28 @@ 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
     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 release_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]:
@@ -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
@@ -24,7 +25,7 @@ class GenericRun(PluginModelBase):
     @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 release_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, cluster: ScyllaCluster = None) -> list[str]:
@@ -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/loader.py

@@ -32,8 +32,8 @@ def plugin_loader() -> dict[str, PluginInfoBase]:
 AVAILABLE_PLUGINS = plugin_loader()
 
 
-def all_plugin_models() -> list[PluginModelBase]:
-    return [model for plugin in AVAILABLE_PLUGINS.values() for model in plugin.all_models]
+def all_plugin_models(include_all=False) -> list[PluginModelBase]:
+    return [model for plugin in AVAILABLE_PLUGINS.values() for model in plugin.all_models if issubclass(model, PluginModelBase) or include_all]
 
 
 def all_plugin_types():

argus/backend/plugins/sct/controller.py

@@ -81,6 +81,17 @@ def sct_resource_update_shards(run_id: str, resource_name: str):
     }
 
 
+@bp.route("/<string:run_id>/resource/<string:resource_name>/update", methods=["POST"])
+@api_login_required
+def sct_resource_update(run_id: str, resource_name: str):
+    payload = get_payload(request)
+    result = SCTService.update_resource(run_id=run_id, resource_name=resource_name, update_data=payload["update_data"])
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
 @bp.route("/<string:run_id>/nemesis/submit", methods=["POST"])
 @api_login_required
 def sct_nemesis_submit(run_id: str):
@@ -152,3 +163,23 @@ def sct_get_kernel_report(release_name: str):
         "status": "ok",
         "response": result
     }
+
+
+@bp.route("/<string:run_id>/junit/submit", methods=["POST"])
+@api_login_required
+def sct_submit_junit_report(run_id: str):
+    payload = get_payload(request)
+    result = SCTService.junit_submit(run_id, payload["file_name"], payload["content"])
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+@bp.route("/<string:run_id>/junit/get_all", methods=["GET"])
+@api_login_required
+def sct_get_junit_reports(run_id: str):
+    result = SCTService.junit_get_all(run_id)
+    return {
+        "status": "ok",
+        "response": result
+    }

argus/backend/plugins/sct/plugin.py

@@ -1,6 +1,6 @@
 from flask import Blueprint
 
-from argus.backend.plugins.sct.testrun import SCTTestRun
+from argus.backend.plugins.sct.testrun import SCTJunitReports, SCTTestRun
 from argus.backend.plugins.sct.controller import bp as sct_bp
 from argus.backend.plugins.core import PluginInfoBase, PluginModelBase
 from argus.backend.plugins.sct.udt import (
@@ -23,6 +23,7 @@ class PluginInfo(PluginInfoBase):
     controller: Blueprint = sct_bp
     all_models = [
         SCTTestRun,
+        SCTJunitReports,
     ]
     all_types = [
         NemesisRunInfo,

argus/backend/plugins/sct/service.py

@@ -1,12 +1,16 @@
+import base64
 from dataclasses import dataclass
+from datetime import datetime
 from functools import reduce
 import logging
 import math
+import re
 from time import time
+from xml.etree import ElementTree
 from flask import g
 from argus.backend.models.web import ArgusEventTypes
-from argus.backend.plugins.sct.testrun import SCTTestRun, SubtestType
-from argus.backend.plugins.sct.types import GeminiResultsRequest, PerformanceResultsRequest
+from argus.backend.plugins.sct.testrun import SCTJunitReports, SCTTestRun, SubtestType
+from argus.backend.plugins.sct.types import GeminiResultsRequest, PerformanceResultsRequest, ResourceUpdateRequest
 from argus.backend.plugins.sct.udt import (
     CloudInstanceDetails,
     CloudResource,
@@ -60,7 +64,8 @@ class SCTService:
             run: SCTTestRun = SCTTestRun.get(id=run_id)
             for package_dict in packages:
                 package = PackageVersion(**package_dict)
-                run.packages.append(package)
+                if package not in run.packages:
+                    run.packages.append(package)
             run.save()
         except SCTTestRun.DoesNotExist as exception:
             LOGGER.error("Run %s not found for SCTTestRun", run_id)
@@ -277,6 +282,33 @@ class SCTService:
 
         return "updated"
 
+    @staticmethod
+    def update_resource(run_id: str, resource_name: str, update_data: ResourceUpdateRequest) -> str:
+        try:
+            fields_updated = {}
+            run: SCTTestRun = SCTTestRun.get(id=run_id)
+            resource = next(res for res in run.get_resources() if res.name == resource_name)
+            instance_info = update_data.pop("instance_info", None)
+            resource.state = ResourceState(update_data.get("state", resource.state)).value
+            if instance_info:
+                resource_instance_info = resource.get_instance_info()
+                for k, v in instance_info.items():
+                    if k in resource_instance_info.keys():
+                        resource_instance_info[k] = v
+                        fields_updated[k] = v
+            run.save()
+        except StopIteration as exception:
+            LOGGER.error("Resource %s not found in run %s", resource_name, run_id)
+            raise SCTServiceException("Resource not found", resource_name) from exception
+        except SCTTestRun.DoesNotExist as exception:
+            LOGGER.error("Run %s not found for SCTTestRun", run_id)
+            raise SCTServiceException("Run not found", run_id) from exception
+
+        return {
+            "state": "updated",
+            "fields": fields_updated
+        }
+
     @staticmethod
     def terminate_resource(run_id: str, resource_name: str, reason: str) -> str:
         try:
@@ -348,6 +380,8 @@ class SCTService:
                 wrapper = EventsBySeverity(severity=event.severity,
                                            event_amount=event.total_events, last_events=event.messages)
                 run.get_events().append(wrapper)
+            coredumps = SCTService.locate_coredumps(run, run.get_events())
+            run.submit_logs(coredumps)
             run.save()
         except SCTTestRun.DoesNotExist as exception:
             LOGGER.error("Run %s not found for SCTTestRun", run_id)
@@ -355,6 +389,39 @@ class SCTService:
 
         return "added"
 
+    @staticmethod
+    def locate_coredumps(run: SCTTestRun, events: list[EventsBySeverity]) -> list[dict]:
+        flat_messages: list[str] = []
+        links = []
+        for es in events:
+            flat_messages.extend(es.last_events)
+        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"core.scylla-{node_name}{timestamp_component}.gz",
+                    "log_link": url
+                }
+                links.append(log_link)
+        return links
+
     @staticmethod
     def get_scylla_version_kernels_report(release_name: str):
         all_release_runs = SCTTestRun.get_version_data_for_release(release_name=release_name)
@@ -391,3 +458,34 @@ class SCTService:
             "versions": kernels_by_version,
             "metadata": kernel_metadata
         }
+    
+    @staticmethod
+    def junit_submit(run_id: str, file_name: str, content: str) -> bool:
+        try:
+            report = SCTJunitReports.get(test_id=run_id, file_name=file_name)
+            if report:
+                raise SCTServiceException(f"Report {file_name} already exists.", file_name)
+        except SCTJunitReports.DoesNotExist:
+            pass
+        report = SCTJunitReports()
+        report.test_id = run_id
+        report.file_name = file_name
+        
+        xml_content = str(base64.decodebytes(bytes(content, encoding="utf-8")), encoding="utf-8")
+        try:
+            _ = ElementTree.fromstring(xml_content)
+        except Exception:
+            raise SCTServiceException(f"Malformed JUnit report submitted")
+
+        report.report = xml_content
+        report.save()
+
+        return True
+
+    @staticmethod
+    def junit_get_all(run_id: str) -> list[SCTJunitReports]:
+        return list(SCTJunitReports.filter(test_id=run_id).all())
+    
+    @staticmethod
+    def junit_get_single(run_id: str, file_name: str) -> SCTJunitReports:
+        return SCTJunitReports.get(test_id=run_id, file_name=file_name)