argus-alm 0.10.1b4__tar.gz → 0.11.0__tar.gz

{argus_alm-0.10.1b4 → argus_alm-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: argus-alm
-Version: 0.10.1b4
+Version: 0.11.0
 Summary: Argus
 Home-page: https://github.com/scylladb/argus
 License: Apache-2.0
@@ -11,9 +11,7 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Requires-Dist: PyYAML (>=5.4.1,<6.0.0)
-Requires-Dist: pydantic (>=1.8.2,<2.0.0)
-Requires-Dist: scylla-driver (>=3.24.8,<4.0.0)
+Requires-Dist: requests (>=2.26.0,<3.0.0)
 Project-URL: Repository, https://github.com/scylladb/argus
 Description-Content-Type: text/markdown
 

{argus_alm-0.10.1b4 → argus_alm-0.11.0}/argus/backend/controller/api.py

@@ -332,8 +332,6 @@ def set_test_plugin(test_id: str):
     payload = get_payload(request)
 
     current_user: User = g.user
-    if not current_user.is_admin():
-        raise Exception("Cannot set plugin as a non-administrator")
     test: ArgusTest = ArgusTest.get(id=UUID(test_id))
     test.plugin_name = payload["plugin_name"]
     test.save()

{argus_alm-0.10.1b4 → argus_alm-0.11.0}/argus/backend/controller/testrun_api.py

@@ -257,3 +257,15 @@ def test_run_delete_comment(test_id: str, run_id: str, comment_id: str):
         "status": "ok",
         "response": result
     }
+
+
+@bp.route("/terminate_stuck_runs", methods=["POST"])
+@api_login_required
+def sct_terminate_stuck_runs():
+    result = TestRunService().terminate_stuck_runs()
+    return {
+        "status": "ok",
+        "response": {
+            "total": result
+        }
+    }

{argus_alm-0.10.1b4 → argus_alm-0.11.0}/argus/backend/plugins/core.py

@@ -122,6 +122,24 @@ class PluginModelBase(Model):
 
         return list(rows)
 
+    @classmethod
+    def get_run_meta_by_build_id(cls, build_id: str, limit: int = 10):
+        cluster = ScyllaCluster.get()
+        query = cluster.prepare("SELECT id, test_id, group_id, release_id, status, start_time, build_job_url, build_id, "
+                                f"assignee, end_time, investigation_status, heartbeat FROM {cls.table_name()} WHERE build_id = ? LIMIT ?")
+        rows = cluster.session.execute(query=query, parameters=(build_id, limit))
+
+        return list(rows)
+
+    @classmethod
+    def get_run_meta_by_run_id(cls, run_id: UUID | str):
+        cluster = ScyllaCluster.get()
+        query = cluster.prepare("SELECT id, test_id, group_id, release_id, status, start_time, build_job_url, build_id, "
+                                f"assignee, end_time, investigation_status, heartbeat FROM {cls.table_name()} WHERE id = ?")
+        rows = cluster.session.execute(query=query, parameters=(run_id,))
+
+        return list(rows)
+
     @classmethod
     def load_test_run(cls, run_id: UUID) -> 'PluginModelBase':
         raise NotImplementedError()

{argus_alm-0.10.1b4 → argus_alm-0.11.0}/argus/backend/plugins/sct/testrun.py

@@ -4,6 +4,7 @@ from dataclasses import dataclass
 from uuid import UUID
 
 from cassandra.cqlengine import columns
+from cassandra.cqlengine.models import _DoesNotExist
 from argus.backend.db import ScyllaCluster
 from argus.backend.models.web import ArgusRelease
 from argus.backend.plugins.core import PluginModelBase
@@ -44,7 +45,7 @@ class SCTTestRunSubmissionRequest():
 
 
 class SCTTestRun(PluginModelBase):
-    __table_name__ = "test_runs_v8"
+    __table_name__ = "sct_test_run"
     _plugin_name = "scylla-cluster-tests"
 
     # Test Details
@@ -105,7 +106,10 @@ class SCTTestRun(PluginModelBase):
         run = cls()
         run.build_id = req.job_name
         run.assign_categories()
-        run.assignee = run.get_scheduled_assignee()
+        try:
+            run.assignee = run.get_scheduled_assignee()
+        except _DoesNotExist:
+            run.assignee = None
         run.start_time = datetime.utcnow()
         run.id = UUID(req.run_id)  # pylint: disable=invalid-name
         run.scm_revision_id = req.commit_id

argus_alm-0.11.0/argus/backend/plugins/sirenada/model.py

@@ -0,0 +1,113 @@
+from datetime import datetime
+from uuid import UUID, uuid4
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.usertype import UserType
+from cassandra.cqlengine.models import Model
+from argus.backend.db import ScyllaCluster
+from argus.backend.models.web import ArgusRelease
+from argus.backend.plugins.core import PluginModelBase
+from argus.backend.plugins.sirenada.types import RawSirenadaRequest, SirenadaPluginException
+from argus.backend.util.enums import TestStatus
+
+
+class SirenadaTest(UserType):
+    test_name = columns.Text()
+    class_name = columns.Text()
+    file_name = columns.Text()
+    browser_type = columns.Text()
+    cluster_type = columns.Text()
+    status = columns.Text()
+    duration = columns.Float()
+    message = columns.Text()
+    start_time = columns.DateTime()
+    stack_trace = columns.Text()
+    screenshot_file = columns.Text()
+    s3_folder_id = columns.Text()
+    requests_file = columns.Text()
+    sirenada_test_id = columns.Text()
+    sirenada_user = columns.Text()
+    sirenada_password = columns.Text()
+
+
+
+class SirenadaRun(PluginModelBase):
+    _plugin_name = "sirenada"
+    __table_name__ = "sirenada_run"
+    logs = columns.Map(key_type=columns.Text(), value_type=columns.Text())
+    # TODO: Legacy field name, should be renamed to product_version and abstracted
+    scylla_version = columns.Text()
+    region = columns.Text()
+    sirenada_test_ids = columns.List(value_type=columns.Text())
+    s3_folder_ids = columns.List(value_type=columns.Tuple(columns.Text(), columns.Text()))
+    browsers = columns.List(value_type=columns.Text())
+    clusters = columns.List(value_type=columns.Text())
+    sct_test_id = columns.UUID()
+    results = columns.List(value_type=columns.UserDefinedType(user_type=SirenadaTest))
+
+    @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 = ?")
+
+    @classmethod
+    def get_distinct_product_versions(cls, release: ArgusRelease, cluster: ScyllaCluster = None) -> list[str]:
+        if not cluster:
+            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)
+
+    def submit_product_version(self, version: str):
+        self.scylla_version = version
+
+    def submit_logs(self, logs: dict[str, str]):
+        raise SirenadaPluginException("Log submission is not supported for Sirenada")
+
+    def finish_run(self):
+        raise SirenadaPluginException("Sirenada runs do not need finalization")
+
+    @classmethod
+    def load_test_run(cls, run_id: UUID) -> 'SirenadaRun':
+        return cls.get(id=run_id)
+
+    @classmethod
+    def submit_run(cls, request_data: RawSirenadaRequest) -> 'SirenadaRun':
+        try:
+            run = cls.get(id=UUID(request_data["run_id"]))
+        except cls.DoesNotExist:
+            run = cls()
+            run.id = request_data["run_id"]
+            run.build_id = request_data["build_id"]
+            run.start_time = datetime.utcnow()
+            run.assign_categories()
+            run.build_job_url = request_data["build_job_url"]
+            run.region = request_data["region"]
+            run.status = TestStatus.PASSED.value
+            try:
+                run.assignee = run.get_scheduled_assignee()
+            except Model.DoesNotExist:
+                run.assignee = None
+
+        for raw_case in request_data["results"]:
+            case = SirenadaTest(**raw_case)
+            if case.status in ["failed", "error"] and run.status not in [TestStatus.FAILED.value, TestStatus.ABORTED.value]:
+                run.status = TestStatus.FAILED.value
+            run.results.append(case)
+
+            if case.sirenada_test_id not in run.sirenada_test_ids:
+                run.sirenada_test_ids.append(case.sirenada_test_id)
+
+            if case.browser_type not in run.browsers:
+                run.browsers.append(case.browser_type)
+
+            if case.cluster_type not in run.clusters:
+                run.clusters.append(case.cluster_type)
+
+            if (case.s3_folder_id, case.sirenada_test_id) not in run.s3_folder_ids and case.s3_folder_id:
+                run.s3_folder_ids.append((case.s3_folder_id, case.sirenada_test_id))
+
+        run.save()
+
+        return run

argus_alm-0.11.0/argus/backend/plugins/sirenada/plugin.py

@@ -0,0 +1,17 @@
+from flask import Blueprint
+
+from argus.backend.plugins.core import PluginInfoBase, PluginModelBase
+from argus.backend.plugins.sirenada.model import SirenadaRun, SirenadaTest
+
+
+class PluginInfo(PluginInfoBase):
+    # pylint: disable=too-few-public-methods
+    name: str = "sirenada"
+    model: PluginModelBase = SirenadaRun
+    controller: Blueprint = None
+    all_models = [
+        SirenadaRun
+    ]
+    all_types = [
+        SirenadaTest
+    ]

argus_alm-0.11.0/argus/backend/plugins/sirenada/types.py

@@ -0,0 +1,35 @@
+from typing import TypedDict
+
+
+class RawSirenadaTestCase(TypedDict):
+    test_name: str
+    class_name: str
+    file_name: str
+    browser_type: str
+    cluster_type: str
+    status: str
+    duration: float
+    message: str
+    start_time: str
+    stack_trace: str
+    screenshot_file: str
+    s3_folder_id: str
+    requests_file: str
+    sirenada_test_id: str
+    sirenada_user: str
+    sirenada_password: str
+
+
+class RawSirenadaRequest(TypedDict):
+    build_id: str
+    build_job_url: str
+    run_id: str # UUID
+    region: list[str]
+    browsers: list[str]
+    clusters: list[str]
+    sct_test_id: str
+    results: list[RawSirenadaTestCase]
+
+
+class SirenadaPluginException(Exception):
+    pass

{argus_alm-0.10.1b4 → argus_alm-0.11.0}/argus/backend/service/argus_service.py

@@ -24,6 +24,7 @@ from argus.backend.models.web import (
     User,
 )
 from argus.backend.events.event_processors import EVENT_PROCESSORS
+from argus.backend.service.testrun import TestRunService
 
 LOGGER = logging.getLogger(__name__)
 
@@ -418,6 +419,19 @@ class ArgusService:
         groups = ArgusScheduleGroup.filter(schedule_id=schedule.id).all()
         assignees = ArgusScheduleAssignee.filter(schedule_id=schedule.id).all()
 
+        full_schedule = dict(schedule)
+        full_schedule["tests"] = [test.test_id for test in tests]
+        full_schedule["groups"] = [group.group_id for group in groups]
+        full_schedule["assignees"] = [assignee.assignee for assignee in assignees]
+
+        schedule_user = User.get(id=assignees[0].assignee)
+
+        jobs_for_schedule = self.get_jobs_for_user(user=schedule_user, ignore_time=True, schedules=[full_schedule])
+
+        service = TestRunService()
+        for job in jobs_for_schedule:
+            service.change_run_assignee(test_id=job["test_id"], run_id=job["id"], new_assignee=None)
+
         for entities in [tests, groups, assignees]:
             for entity in entities:
                 entity.delete()
@@ -517,15 +531,15 @@ class ArgusService:
 
         return response
 
-    def get_jobs_for_user(self, user: User):
+    def get_jobs_for_user(self, user: User, ignore_time: bool = False, schedules: list[dict] = None):
         runs = [run for plugin in all_plugin_models() for run in plugin.get_jobs_assigned_to_user(user=user)]
-        schedules = self.get_schedules_for_user(user)
+        schedules = self.get_schedules_for_user(user) if not schedules else schedules
         valid_runs = []
         today = datetime.datetime.now()
         month_ago = today - datetime.timedelta(days=30)
         for run in runs:
             run_date = run["start_time"]
-            if user.id == run["assignee"] and run_date >= month_ago:
+            if user.id == run["assignee"] and run_date >= month_ago and not ignore_time:
                 valid_runs.append(run)
                 continue
             for schedule in schedules:
@@ -545,7 +559,7 @@ class ArgusService:
                     break
         return valid_runs
 
-    def get_schedules_for_user(self, user: User):
+    def get_schedules_for_user(self, user: User) -> list[dict]:
         all_assigned_schedules = ArgusScheduleAssignee.filter(assignee=user.id).all()
         schedule_keys = [(schedule_assignee.release_id, schedule_assignee.schedule_id)
                          for schedule_assignee in all_assigned_schedules]

{argus_alm-0.10.1b4 → argus_alm-0.11.0}/argus/backend/service/stats.py

@@ -3,6 +3,7 @@ import logging
 from datetime import datetime
 from typing import TypedDict
 from uuid import UUID
+
 from argus.backend.plugins.loader import all_plugin_models
 from argus.backend.util.common import get_build_number
 from argus.backend.util.enums import TestStatus, TestInvestigationStatus
@@ -92,16 +93,28 @@ class ReleaseStats:
         self.all_tests = []
 
     def to_dict(self) -> dict:
+        converted_groups = {str(group.group.id): group.to_dict() for group in self.groups}
+        aggregated_investigation_status = {}
+        for group in converted_groups.values():
+            for investigation_status in TestInvestigationStatus:
+                current_status = aggregated_investigation_status.get(investigation_status.value, {})
+                result = {
+                    status.value: current_status.get(status.value, 0) + group.get(investigation_status.value, {}).get(status, 0)
+                    for status in TestStatus
+                }
+                aggregated_investigation_status[investigation_status.value] = result
+
         return {
             "release": dict(self.release.items()),
-            "groups": {str(group.group.id): group.to_dict() for group in self.groups},
+            "groups": converted_groups,
             "total": self.total_tests,
             **self.status_map,
             "disabled": not self.release.enabled,
             "perpetual": self.release.perpetual,
             "lastStatus": self.last_investigation_status,
             "lastInvestigationStatus": self.last_investigation_status,
-            "hasBugReport": self.has_bug_report
+            "hasBugReport": self.has_bug_report,
+            **aggregated_investigation_status
         }
 
     def collect(self, rows: list[TestRunStatRow], limited=False, force=False) -> None:
@@ -144,6 +157,15 @@ class GroupStats:
         self.tests: list[TestStats] = []
 
     def to_dict(self) -> dict:
+        converted_tests = {str(test.test.id): test.to_dict() for test in self.tests}
+        investigation_progress = {}
+        for test in converted_tests.values():
+            progress_for_status = investigation_progress.get(test["investigation_status"], {})
+            status_count = progress_for_status.get(test["status"], 0)
+            status_count += 1
+            progress_for_status[test["status"]] = status_count
+            investigation_progress[test["investigation_status"]] = progress_for_status
+
         return {
             "group": dict(self.group.items()),
             "total": self.total_tests,
@@ -151,7 +173,8 @@ class GroupStats:
             "lastStatus": self.last_status,
             "lastInvestigationStatus": self.last_investigation_status,
             "disabled": self.disabled,
-            "tests": {str(test.test.id): test.to_dict() for test in self.tests}
+            "tests": converted_tests,
+            **investigation_progress
         }
 
     def collect(self, limited=False):

{argus_alm-0.10.1b4 → argus_alm-0.11.0}/argus/backend/service/testrun.py

@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timedelta
 import json
 import logging
 import re
@@ -34,6 +34,10 @@ from argus.backend.util.enums import TestInvestigationStatus, TestStatus
 LOGGER = logging.getLogger(__name__)
 
 
+class TestRunServiceException(Exception):
+    pass
+
+
 class TestRunService:
     ASSIGNEE_PLACEHOLDER = "none-none-none"
 
@@ -64,14 +68,14 @@ class TestRunService:
         if not plugin:
             return []
 
-        last_runs: list[PluginModelBase] = list(plugin.model.filter(build_id=test.build_system_id).limit(limit).all())
-        last_runs_ids = [run.id for run in last_runs]
+        last_runs: list[dict] = plugin.model.get_run_meta_by_build_id(build_id=test.build_system_id, limit=limit)
+        last_runs_ids = [run["id"] for run in last_runs]
         for added_run in additional_runs:
             if added_run not in last_runs_ids:
-                last_runs.append(plugin.model.get(id=added_run))
+                last_runs.extend(plugin.model.get_run_meta_by_run_id(run_id=added_run))
 
         for row in last_runs:
-            setattr(row, "build_number", get_build_number(build_job_url=row.build_job_url))
+            row["build_number"] = get_build_number(build_job_url=row["build_job_url"])
 
         return last_runs
 
@@ -91,7 +95,10 @@ class TestRunService:
         return response
 
     def change_run_status(self, test_id: UUID, run_id: UUID, new_status: TestStatus):
-        test = ArgusTest.get(id=test_id)
+        try:
+            test = ArgusTest.get(id=test_id)
+        except ArgusTest.DoesNotExist as exc:
+            raise TestRunServiceException("Test entity does not exist for provided test_id", test_id) from exc
         plugin = self.get_plugin(plugin_name=test.plugin_name)
         run: PluginModelBase = plugin.model.get(id=run_id)
         old_status = run.status
@@ -384,7 +391,7 @@ class TestRunService:
             response = []
             for issue in all_issues:
                 runs = runs_by_issue.get(issue, [])
-                runs.append(issue.run_id)
+                runs.append({"test_id": issue.test_id, "run_id": issue.run_id})
                 runs_by_issue[issue] = runs
 
             for issue, runs in runs_by_issue.items():
@@ -419,3 +426,39 @@ class TestRunService:
         return {
             "deleted": issue_id
         }
+
+    def terminate_stuck_runs(self):
+        sct = AVAILABLE_PLUGINS.get("scylla-cluster-tests").model
+        now = datetime.utcnow()
+        stuck_period = now - timedelta(minutes=45)
+        stuck_runs_running = sct.filter(heartbeat__lt=int(
+            stuck_period.timestamp()), status=TestStatus.RUNNING.value).allow_filtering().all()
+        stuck_runs_created = sct.filter(heartbeat__lt=int(
+            stuck_period.timestamp()), status=TestStatus.CREATED.value).allow_filtering().all()
+
+        all_stuck_runs = [*stuck_runs_running, *stuck_runs_created]
+        LOGGER.info("Found %s stuck runs", len(all_stuck_runs))
+
+        for run in all_stuck_runs:
+            LOGGER.info("Will set %s as ABORTED", run.id)
+            old_status = run.status
+            run.status = TestStatus.ABORTED.value
+            run.save()
+
+            self.create_run_event(
+                kind=ArgusEventTypes.TestRunStatusChanged,
+                body={
+                    "message": "Run was automatically terminated due to not responding for more than 45 minutes "
+                               "(Status changed from {old_status} to {new_status}) by {username}",
+                    "old_status": old_status,
+                    "new_status": run.status,
+                    "username": g.user.username
+                },
+                user_id=g.user.id,
+                run_id=run.id,
+                release_id=run.release_id,
+                group_id=run.group_id,
+                test_id=run.test_id
+            )
+
+        return len(all_stuck_runs)

{argus_alm-0.10.1b4 → argus_alm-0.11.0}/argus/client/base.py

@@ -59,9 +59,10 @@ class ArgusClient:
         response_data: JSON = response.json()
         LOGGER.debug("API Response: %s", response_data)
         if response_data.get("status") != "ok":
+            exc_args = response_data["response"]["arguments"]
             raise ArgusClientError(
                 f"API Error encountered using endpoint: {response.request.method} {response.request.path_url}",
-                response_data["response"]["arguments"][0],
+                exc_args[0] if len(exc_args) > 0 else response_data.get("response", {}).get("exception", "#NoMessage"),
             )
 
     def get_url_for_endpoint(self, endpoint: str, location_params: dict[str, str] | None) -> str:

{argus_alm-0.10.1b4 → argus_alm-0.11.0}/argus/client/driver_matrix_tests/client.py

@@ -1,6 +1,6 @@
 from functools import reduce
 from datetime import datetime
-from typing import TypedDict
+from typing import TypedDict, Literal
 import re
 import logging
 from uuid import UUID
@@ -124,7 +124,7 @@ class ArgusDriverMatrixClient(ArgusClient):
 
         return total - errors - skipped - failures
 
-    def parse_result_xml(self, xml_path: Path, test_type: str, env: dict[str, str] = None) -> RawMatrixTestResult:
+    def parse_result_xml(self, xml_path: Path, test_type:  Literal['java', 'cpp', 'python']) -> RawMatrixTestResult:
         with xml_path.open(mode="rt", encoding="utf-8") as xml_file:
             xml = ElementTree.parse(source=xml_file)
             LOGGER.info("%s", pformat(xml))
@@ -171,18 +171,18 @@ class ArgusDriverMatrixClient(ArgusClient):
             "suites": all_suites
         }
 
-    def get_results(self, result_path: str, test_type: str, env: dict[str, str] = None) -> list[RawMatrixTestResult]:
+    def get_results(self, result_path: str, test_type: Literal['java', 'cpp', 'python']) -> list[RawMatrixTestResult]:
         xmls = glob(f"{result_path}/**/*.xml", recursive=True)
         LOGGER.info("Will use following XMLs: %s", pformat(xmls))
         results = []
         for xml in xmls:
-            result = self.parse_result_xml(Path(xml), test_type, env=env)
+            result = self.parse_result_xml(Path(xml), test_type)
             results.append(result)
         return results
 
-    def submit(self, build_id: str, build_url: str, env_path: str, result_path: str, test_type: str):
+    def submit(self, build_id: str, build_url: str, env_path: str, result_path: str, test_type: Literal['java', 'cpp', 'python']):
         env = self.parse_build_environment(env_path)
-        results = self.get_results(result_path, test_type, env)
+        results = self.get_results(result_path, test_type)
 
         self.submit_driver_matrix_run(job_name=build_id, job_url=build_url, test_environment=env, results=results)
         failures = reduce(lambda total, coll: (coll["failures"] + coll["errors"]) + total, results, 0)

argus_alm-0.11.0/argus/client/sirenada/client.py

@@ -0,0 +1,151 @@
+import json
+import logging
+from glob import glob, escape
+from pathlib import Path
+from typing import TypedDict
+from xml.etree import ElementTree
+
+from argus.backend.plugins.sirenada.types import RawSirenadaRequest, RawSirenadaTestCase
+
+from argus.client.base import ArgusClient
+
+
+LOGGER = logging.getLogger(__name__)
+
+class SirenadaEnv(TypedDict):
+    SIRENADA_JOB_ID: str
+    SIRENADA_BROWSER: str
+    SIRENADA_REGION: str
+    SIRENADA_CLUSTER: str
+    WORKSPACE: str
+    BUILD_NUMBER: str
+    BUILD_URL: str
+    JOB_NAME: str
+
+
+class TestCredentials(TypedDict):
+    SIRENADA_TEST_ID: str
+    SIRENADA_USER_NAME: str
+    SIRENADA_USER_PASS: str
+    SIRENADA_OTP_SECRET: str
+    ClusterID: str
+    region: str
+
+class ArgusSirenadaClient(ArgusClient):
+    test_type = "sirenada"
+    schema_version: None = "v1"
+    _junit_xml_filename = "junit_results.xml"
+    _credentials_filename = "test_credentials.json"
+    _bucket_url_template = "https://sirenada-results.s3.us-east-1.amazonaws.com/{s3_id}/{test_results_dir}/{filename}"
+    TEST_TAG_MAPPING = {
+        "failure": "failed",
+        "error": "aborted",
+        "skipped": "skipped"
+    }
+
+    def __init__(self, auth_token: str, base_url: str, api_version="v1") -> None:
+        self.results_path: Path | None = None
+        super().__init__(auth_token, base_url, api_version)
+
+    def _verify_required_files_exist(self, results_path: Path):
+        assert (results_path / self._junit_xml_filename).exists(), "Missing jUnit XML results file!"
+        assert (results_path / self._credentials_filename).exists(), "Missing test credentials file!"
+
+    @staticmethod
+    def _verify_env(env: SirenadaEnv):
+        for key in SirenadaEnv.__annotations__.keys():
+            assert env.get(key), f"Missing required key {key} in the environment"
+
+    def _set_files_for_failed_test(self, test_case: RawSirenadaTestCase):
+        test_results_dir = f"sirenada-{test_case['sirenada_test_id']}"
+        results_dir: Path = self.results_path / test_results_dir
+
+        just_class_name = test_case.get("class_name").split(".")[-1]
+        requests_pattern = f"{just_class_name}-{test_case.get('test_name')}.requests.json"
+        screenshot_pattern = f"{just_class_name}-{escape(test_case.get('test_name'))}-*.png"
+
+        if not results_dir.exists():
+            return
+
+        if not (s3_bucket_id_path := (results_dir / "s3_id")).exists():
+            return
+
+        with open(s3_bucket_id_path, "rt") as s3_id_file:
+            test_case["s3_folder_id"] = s3_id_file.read().strip()
+
+        test_case["requests_file"] = self._bucket_url_template.format(
+            s3_id=test_case.get("s3_folder_id"),
+            test_results_dir=test_results_dir,
+            filename=requests_pattern,
+        )
+
+        screenshots = glob(pathname=screenshot_pattern, root_dir=results_dir)
+        if len(screenshots) > 0:
+            test_case["screenshot_file"] = self._bucket_url_template.format(
+                s3_id=test_case.get("s3_folder_id"),
+                test_results_dir=test_results_dir,
+                filename=screenshots[0],
+            )
+
+    def _set_case_status(self, raw_case: RawSirenadaTestCase, junit_case: ElementTree.Element):
+        subelements = list(junit_case.iter())
+        if len(subelements) == 2:
+            status_node = subelements[1]
+            raw_case["status"] = self.TEST_TAG_MAPPING.get(status_node.tag, "failed")
+            raw_case["message"] = status_node.get("message", "#NO_MESSAGE")
+            raw_case["stack_trace"] = status_node.text
+            self._set_files_for_failed_test(raw_case)
+        else:
+            raw_case["status"] = "passed"
+
+    def _parse_junit_results(self, junit_xml: Path, credentials: TestCredentials, env: SirenadaEnv) -> list[RawSirenadaTestCase]:
+        etree = ElementTree.parse(source=junit_xml)
+        cases = list(etree.iter("testcase"))
+        assert len(cases) > 0, "No test cases found in test results XML."
+
+        parsed_cases: list[RawSirenadaTestCase] = []
+        for case in cases:
+            raw_case: RawSirenadaTestCase = {}
+            raw_case["class_name"] = case.get("classname", "#NO_CLASSNAME")
+            raw_case["file_name"] = case.get("file", "#NO_FILE")
+            raw_case["test_name"] = case.get("name", "#NO_TEST_NAME")
+            raw_case["browser_type"] = env.get("SIRENADA_BROWSER")
+            raw_case["cluster_type"] = env.get("SIRENADA_CLUSTER")
+            raw_case["duration"] = float(case.attrib.get("time", "0.0"))
+            raw_case["sirenada_test_id"] = credentials.get("SIRENADA_TEST_ID")
+            raw_case["sirenada_user"] = credentials.get("SIRENADA_USER_NAME")
+            raw_case["sirenada_password"] = credentials.get("SIRENADA_USER_PASS")
+            self._set_case_status(raw_case, case)
+            parsed_cases.append(raw_case)
+
+        return parsed_cases
+
+    @staticmethod
+    def _read_credentials(credentials_path: Path) -> TestCredentials:
+        with open(credentials_path, "rt") as creds_file:
+            credentials: TestCredentials = json.load(creds_file)
+
+        assert credentials.get("SIRENADA_TEST_ID"), "Credentials are missing required field: SIRENADA_TEST_ID"
+        return credentials
+
+    def submit_sirenada_run(self, env: SirenadaEnv, test_results_path: Path):
+        self.results_path = test_results_path
+        try:
+            self._verify_env(env)
+            self._verify_required_files_exist(self.results_path)
+        except AssertionError as exc:
+            LOGGER.critical("%s", exc.args[0])
+            raise exc
+
+        credentials = self._read_credentials(self.results_path / self._credentials_filename)
+        results = self._parse_junit_results(junit_xml=self.results_path / self._junit_xml_filename, credentials=credentials, env=env)
+        request_body: RawSirenadaRequest = {}
+
+        request_body["run_id"] = env.get("SIRENADA_JOB_ID")
+        request_body["build_id"] = env.get("JOB_NAME")
+        request_body["build_job_url"] = env.get("BUILD_URL")
+        request_body["region"] = env.get("SIRENADA_REGION")
+        request_body["results"] = results
+
+        response = self.submit_run(run_type=self.test_type, run_body=request_body)
+        self.check_response(response)

{argus_alm-0.10.1b4 → argus_alm-0.11.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "argus-alm"
-version = "0.10.1b4"
+version = "0.11.0"
 description = "Argus"
 authors = ["Alexey Kartashov <alexey.kartashov@scylladb.com>"]
 license = "Apache-2.0"
@@ -15,19 +15,17 @@ optional = true
 optional = true
 
 [tool.poetry.dependencies]
+requests = "^2.26.0"
 python = "^3.10"
-pydantic = "^1.8.2"
-PyYAML = "^5.4.1"
-scylla-driver = "^3.24.8"
-
 
 [tool.poetry.group.web-backend.dependencies]
+PyYAML = "^5.4.1"
+scylla-driver = "^3.24.8"
 Flask = "2.0.2"
 Flask-WTF = "1.0.0"
 Flask-Login = "0.5.0"
 humanize = "3.13.1"
 python-magic = "0.4.24"
-requests = "2.26.0"
 uwsgi = "2.0.20"
 python-jenkins = "^1.7.0"
 python-slugify = "^6.1.1"

{argus_alm-0.10.1b4 → argus_alm-0.11.0}/setup.py

@@ -10,24 +10,24 @@ packages = \
  'argus.backend.plugins',
  'argus.backend.plugins.driver_matrix_tests',
  'argus.backend.plugins.sct',
+ 'argus.backend.plugins.sirenada',
  'argus.backend.service',
  'argus.backend.util',
  'argus.client',
  'argus.client.driver_matrix_tests',
  'argus.client.sct',
+ 'argus.client.sirenada',
  'argus.db']
 
 package_data = \
 {'': ['*']}
 
 install_requires = \
-['PyYAML>=5.4.1,<6.0.0',
- 'pydantic>=1.8.2,<2.0.0',
- 'scylla-driver>=3.24.8,<4.0.0']
+['requests>=2.26.0,<3.0.0']
 
 setup_kwargs = {
     'name': 'argus-alm',
-    'version': '0.10.1b4',
+    'version': '0.11.0',
     'description': 'Argus',
     'long_description': '# Argus\n\n## Description\n\nArgus is a test tracking system intended to provide observability into automated test pipelines which use long-running resources. It allows observation of a test status, its events and its allocated resources. It also allows easy comparison between particular runs of a specific test.\n\n## Installation notes\n\n### Prerequisites\n\n- Python >=3.10.0 (system-wide or pyenv)\n\n- NodeJS >=16 (with npm)\n\n- Yarn (can be installed globally with `npm -g install yarn`)\n\n- nginx\n\n- poetry >=1.2.0b1\n\n### From source\n\n#### Production\n\nPerform the following steps:\n\nCreate a user that will be used by uwsgi:\n\n```bash\nuseradd -m -s /bin/bash argus\nsudo -iu argus\n```\n\n(Optional) Install pyenv and create a virtualenv for this user:\n\n```bash\npyenv install 3.10.0\npyenv virtualenv argus\npyenv activate argus\n```\n\nClone the project into a directory somewhere where user has full write permissions\n\n```bash\ngit clone https://github.com/scylladb/argus ~/app\ncd ~/app\n```\n\nInstall project dependencies:\n\n```bash\npoetry install --with default,dev,web-backend,docker-image\nyarn install\n```\n\nCompile frontend files from `/frontend` into `/public/dist`\n\n```bash\nyarn webpack\n```\n\nCreate a `argus.local.yaml` configuration file (used to configure database connection) and a `argus_web.yaml` (used for webapp secrets) in your application install directory.\n\n```bash\ncp argus_web.example.yaml argus_web.yaml\ncp argus.yaml argus.local.yaml\n```\n\nOpen `argus.local.yaml` and add the database connection information (contact_points, user, password and keyspace name).\n\nOpen `argus_web.yaml` and change the `SECRET_KEY` value to something secure, like a sha512 digest of random bytes. Fill out GITHUB_* variables with their respective values.\n\nCopy nginx configuration file from `docs/configs/argus.nginx.conf` to nginx virtual hosts directory:\n\nUbuntu:\n\n```bash\nsudo cp docs/configs/argus.nginx.conf /etc/nginx/sites-available/argus\nsudo ln -s /etc/nginx/sites-enabled/argus /etc/nginx/sites-available/argus\n```\n\nRHEL/Centos/Alma/Fedora:\n\n```bash\nsudo cp docs/configs/argus.nginx.conf /etc/nginx/conf.d/argus.conf\n```\n\nAdjust the webhost settings in that file as necessary, particularly `listen` and `server_name` directives.\n\nCopy systemd service file from `docs/config/argus.service` to `/etc/systemd/system` directory:\n\n```bash\nsudo cp docs/config/argus.service /etc/systemd/system\n```\n\nOpen it and adjust the path to the `start_argus.sh` script in the `ExecStart=` directive and the user/group, then reload systemd daemon configuration and enable (and optionally start) the service.\n\nWARNING: `start_argus.sh` assumes pyenv is installed into `~/.pyenv`\n\n```bash\nsudo systemctl daemon-reload\nsudo systemctl enable --now argus.service\n```\n\n#### Development\n\nClone the project into a directory somewhere\n\n```bash\ngit clone https://github.com/scylladb/argus\ncd argus\n```\n\nInstall project dependencies:\n\n```bash\npoetry install --with default,dev,web-backend,docker-image\nyarn install\n```\n\nCompile frontend files from `/frontend` into `/public/dist`. Add --watch to recompile files on change.\n\n```bash\nyarn webpack --watch\n```\n##### Configuration\nCreate a `argus.local.yaml` configuration file (used to configure database connection) and a `argus_web.yaml` (used for webapp secrets) in your application install directory.\n\nSee `Production` section for more details.\nTo configure Github authentication follow steps:\n1. Authorize OAuth App\n   1. go to your Account Settings (top right corner) -> Developer settings (left pane) -> OAuth Apps\n   2. Click Create New OAuth App button\n   3. Fill the fields (app name: `argus-dev`, homepage URL `http://localhost:5000`, Auth callback URL: `http://localhost:5000/profile/oauth/github`)\n   4. Confirm and get the tokens/ids required for config\n2. Create Jenkins token for your account\n   1. Go to `Configure` in top right corner\n   2. Click `Add new Token`\n   3. Get it and paste to config to `JENKINS_API_TOKEN` param\n##### Database Initialization\n\nYou can initialize a scylla cluster in any way you like, either using docker image with docker-compose or using cassandra cluster manager. You will need to create the keyspace manually before you can sync database models.\n\nCreate keyspace according to your configuration.\ne.g. (need to test if it works with RF=1 if not, make it 3)\n```\nCREATE KEYSPACE argus WITH replication = {\'class\': \'SimpleStrategy\', \'replication_factor\' : 1}\n```\n\nInitial sync can be done as follows:\n\n```py\nfrom argus.backend.db import ScyllaCluster\nfrom argus.db.testrun import TestRun\ndb = ScyllaCluster.get()\n\ndb.sync_models() # Syncronizes Object Mapper models\nTestRun.init_own_table() # Syncronizes TestRun table (separate from python-driver Object Mapper)\n\n```\n\nYou can also use `flask sync-models` afterwards during development when making small changes to models.\n\nIt is recommended to set up jenkins api key and run `flask scan-jenkins` afterwards to get basic release/group/test structure.\n\nThere are scripts in `./scripts` directory that can be used to download data from production, upload them into your dev db and fix their relations to other models in your instance of the application. Specifically, `download_runs_from_prod.py` requires additional config, `argus.local.prod.yaml` which is the config used to connect to the production cluster. The scripts are split to prevent mistakes and accidentally affecting production cluster.\n\n##### Configuration\n\nCreate a `argus.local.yaml` configuration file (used to configure database connection) and a `argus_web.yaml` (used for webapp secrets) in your application install directory.\n\n```bash\ncp argus_web.example.yaml argus_web.yaml\ncp argus.yaml argus.local.yaml\n```\n\nOpen `argus.local.yaml` and add the database connection information (contact_points, user, password and keyspace name).\n\nOpen `argus_web.yaml` and change the `SECRET_KEY` value to something secure, like a sha512 digest of random bytes. Fill out GITHUB_* and JENKINS_* variables with their respective values.\n\nRun the application from CLI using:\n\n```bash\nFLASK_ENV="development" FLASK_APP="argus_backend:start_server" FLASK_DEBUG=1 CQLENG_ALLOW_SCHEMA_MANAGEMENT=1 flask run\n```\n\nOmit `FLASK_DEBUG` if running your own debugger (pdb, pycharm, vscode)\n',
     'author': 'Alexey Kartashov',