argus-alm 0.11.3__py3-none-any.whl → 0.11.6__py3-none-any.whl

argus/backend/service/argus_service.py

@@ -7,7 +7,7 @@ from uuid import UUID
 from cassandra.util import uuid_from_time  # pylint: disable=no-name-in-module
 from flask import current_app
 from argus.backend.db import ScyllaCluster
-from argus.backend.plugins.loader import all_plugin_models
+from argus.backend.plugins.loader import AVAILABLE_PLUGINS, all_plugin_models
 from argus.backend.plugins.sct.testrun import SCTTestRun
 from argus.backend.service.notification_manager import NotificationManagerService
 from argus.backend.models.web import (
@@ -425,12 +425,16 @@ class ArgusService:
         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 model in all_plugin_models():
+            for run in model.get_jobs_assigned_to_user(schedule_user):
+                if run["release_id"] != release.id:
+                    continue
+                if run["test_id"] not in full_schedule["tests"]:
+                    continue
+                if schedule.period_start < run["start_time"] < schedule.period_end:
+                    service.change_run_assignee(test_id=run["test_id"], run_id=run["id"], new_assignee=None)
 
         for entities in [tests, groups, assignees]:
             for entity in entities:
@@ -531,33 +535,13 @@ class ArgusService:
 
         return response
 
-    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) if not schedules else schedules
-        valid_runs = []
+    def get_jobs_for_user(self, user: User):
         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 and not ignore_time:
-                valid_runs.append(run)
-                continue
-            for schedule in schedules:
-                if not run["release_id"] == schedule["release_id"]:
-                    continue
-                if not schedule["period_start"] < run_date < schedule["period_end"]:
-                    continue
-                if run["assignee"] in schedule["assignees"]:
-                    valid_runs.append(run)
-                    break
-                if run["group_id"] in schedule["groups"]:
-                    valid_runs.append(run)
-                    break
-                filtered_tests = [test for test in schedule["tests"] if test == run["test_id"]]
-                if len(filtered_tests) > 0:
-                    valid_runs.append(run)
-                    break
-        return valid_runs
+        validity_period = today - datetime.timedelta(days=current_app.config.get("JOB_VALIDITY_PERIOD_DAYS", 30))
+        for plugin in all_plugin_models():
+            for run in plugin.get_jobs_assigned_to_user(user=user):
+                if run["start_time"] >= validity_period:
+                    yield run
 
     def get_schedules_for_user(self, user: User) -> list[dict]:
         all_assigned_schedules = ArgusScheduleAssignee.filter(assignee=user.id).all()

argus/backend/service/build_system_monitor.py

@@ -78,7 +78,7 @@ class JenkinsMonitor(ArgusTestsMonitor):
     def collect(self):
         click.echo("Collecting new tests from jenkins")
         all_jobs = self._jenkins.get_all_jobs()
-        all_monitored_folders = [job for job in all_jobs if job["name"] in self._monitored_releases]
+        all_monitored_folders = [job for job in all_jobs if job["fullname"] in self._monitored_releases]
         for release in all_monitored_folders:
             LOGGER.info("Processing release %s", release["name"])
             try:
@@ -89,8 +89,23 @@ class JenkinsMonitor(ArgusTestsMonitor):
                 saved_release = self.create_release(release["name"])
                 self._existing_releases.append(saved_release)
 
-            groups = self.collect_groups_for_release(release["jobs"])
+            try:
+                groups = self.collect_groups_for_release(release["jobs"])
+            except KeyError:
+                LOGGER.error("Empty release!\n %s", release)
+                continue
             folder_stack = [dict(parent_name="", parent_display_name="", group=g) for g in reversed(groups)]
+            root_folder = {
+                "parent_name": "",
+                "parent_display_name": "",
+                "group":  {
+                    "name": f"{release['fullname']}-root",
+                    "displayName": "-- root directory --",
+                    "fullname": release["fullname"],
+                    "jobs": self.collect_root_folder_jobs(release["jobs"]),
+                }
+            }
+            folder_stack.append(root_folder)
             while len(folder_stack) != 0:
                 group_dict = folder_stack.pop()
                 group = group_dict["group"]
@@ -104,7 +119,7 @@ class JenkinsMonitor(ArgusTestsMonitor):
                     LOGGER.warning(
                         "Group %s for release %s doesn't exist, creating...", group_name, saved_release.name)
                     try:
-                        display_name = self._jenkins.get_job_info(name=group["fullname"])["displayName"]
+                        display_name = group.get("displayName", self._jenkins.get_job_info(name=group["fullname"])["displayName"])
                         display_name = display_name if not group_dict[
                             "parent_display_name"] else f"{group_dict['parent_display_name']} - {display_name}"
                     except Exception:
@@ -138,3 +153,6 @@ class JenkinsMonitor(ArgusTestsMonitor):
         groups = [group for group in groups if self.check_filter(group["name"])]
 
         return groups
+
+    def collect_root_folder_jobs(self, jobs):
+        return [job for job in jobs if "WorkflowJob" in job["_class"]]

argus/backend/service/event_service.py

@@ -0,0 +1,18 @@
+from datetime import datetime
+import json
+from argus.backend.models.web import ArgusEvent, ArgusEventTypes
+
+
+class EventService:
+    @staticmethod
+    def create_run_event(kind: ArgusEventTypes, body: dict, user_id=None, run_id=None, release_id=None, group_id=None, test_id=None):
+        event = ArgusEvent()
+        event.release_id = release_id
+        event.group_id = group_id
+        event.test_id = test_id
+        event.user_id = user_id
+        event.run_id = run_id
+        event.body = json.dumps(body, ensure_ascii=True, separators=(',', ':'))
+        event.kind = kind.value
+        event.created_at = datetime.utcnow()
+        event.save()

argus/backend/service/stats.py

@@ -76,6 +76,70 @@ class ComparableTestStatus:
         return self._get_prio() <= __o._get_prio()
 
 
+class ComparableTestInvestigationStatus:
+    PRIORITY_MAP = {
+        TestInvestigationStatus.NOT_INVESTIGATED: 10,
+        TestInvestigationStatus.IN_PROGRESS: 9,
+        TestInvestigationStatus.INVESTIGATED: 8,
+        TestInvestigationStatus.IGNORED: 7,
+    }
+
+    def __init__(self, status: TestInvestigationStatus):
+        self._status = status
+
+    def _get_prio(self):
+        return self.PRIORITY_MAP.get(self._status, 0)
+
+    def __eq__(self, __o: object) -> bool:
+        if not isinstance(__o, ComparableTestInvestigationStatus):
+            return False
+        return self._get_prio() == __o._get_prio()
+
+    def __ne__(self, __o: object) -> bool:
+        if not isinstance(__o, ComparableTestInvestigationStatus):
+            return False
+        return not self.__eq__(__o)
+
+    def __lt__(self, __o: object) -> bool:
+        if not isinstance(__o, ComparableTestInvestigationStatus):
+            return False
+        return self._get_prio() < __o._get_prio()
+
+    def __gt__(self, __o: object) -> bool:
+        if not isinstance(__o, ComparableTestInvestigationStatus):
+            return False
+        return self._get_prio() > __o._get_prio()
+
+    def __ge__(self, __o: object) -> bool:
+        if not isinstance(__o, ComparableTestInvestigationStatus):
+            return False
+        return self._get_prio() >= __o._get_prio()
+
+    def __le__(self, __o: object) -> bool:
+        if not isinstance(__o, ComparableTestInvestigationStatus):
+            return False
+        return self._get_prio() <= __o._get_prio()
+
+
+def generate_field_status_map(
+        last_runs: list[TestRunStatRow],
+        field_name = "status",
+        container_class = TestStatus,
+        cmp_class = ComparableTestStatus
+    ) -> dict[int, str]:
+
+    status_map = {}
+    for run in last_runs:
+        run_number = get_build_number(run["build_job_url"])
+        match status := status_map.get(run_number):
+            case str():
+                if cmp_class(container_class(status)) < cmp_class(container_class(run[field_name])):
+                    status_map[run_number] = run[field_name]
+            case _:
+                status_map[run_number] = run[field_name]
+    return status_map
+
+
 class ReleaseStats:
     def __init__(self, release: ArgusRelease) -> None:
         self.release = release
@@ -227,18 +291,6 @@ class TestStats:
             "hasComments": self.has_comments
         }
 
-    def _generate_status_map(self, last_runs: list[TestRunStatRow]) -> dict[int, str]:
-        status_map = {}
-        for run in last_runs:
-            run_number = get_build_number(run["build_job_url"])
-            match status := status_map.get(run_number):
-                case str():
-                    if ComparableTestStatus(TestStatus(status)) < ComparableTestStatus(TestStatus(run["status"])):
-                        status_map[run_number] = run["status"]
-                case _:
-                    status_map[run_number] = run["status"]
-        return status_map
-
     def collect(self, limited=False):
 
         # TODO: Parametrize run limit
@@ -252,10 +304,12 @@ class TestStats:
             self.status = TestStatus.NOT_RUN if self.is_scheduled else TestStatus.NOT_PLANNED
             self.parent_group.increment_status(status=self.status)
             return
-        status_map = self._generate_status_map(last_runs)
+        status_map = generate_field_status_map(last_runs)
+        investigation_status_map = generate_field_status_map(
+            last_runs, "investigation_status", TestInvestigationStatus, ComparableTestInvestigationStatus)
 
         self.status = status_map.get(get_build_number(last_run["build_job_url"]))
-        self.investigation_status = TestInvestigationStatus(last_run["investigation_status"])
+        self.investigation_status = investigation_status_map.get(get_build_number(last_run["build_job_url"]))
         self.start_time = last_run["start_time"]
 
         self.parent_group.increment_status(status=self.status)
@@ -300,7 +354,7 @@ class ReleaseStatsCollector:
 
         if self.release_version:
             self.release_rows = list(
-                filter(lambda row: row["scylla_version"] == self.release_version, self.release_rows))
+                filter(lambda row: row["scylla_version"] == self.release_version or not row["scylla_version"], self.release_rows))
 
         self.release_stats = ReleaseStats(release=self.release)
         self.release_stats.collect(rows=self.release_rows, limited=limited, force=force)

argus/backend/service/testrun.py

@@ -8,6 +8,9 @@ from uuid import UUID
 
 import requests
 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.web import (
     ArgusEvent,
@@ -27,7 +30,9 @@ from argus.backend.plugins.core import PluginInfoBase, PluginModelBase
 
 from argus.backend.plugins.loader import AVAILABLE_PLUGINS
 from argus.backend.events.event_processors import EVENT_PROCESSORS
+from argus.backend.service.event_service import EventService
 from argus.backend.service.notification_manager import NotificationManagerService
+from argus.backend.service.stats import ComparableTestStatus
 from argus.backend.util.common import get_build_number, strip_html_tags
 from argus.backend.util.enums import TestInvestigationStatus, TestStatus
 
@@ -77,6 +82,8 @@ class TestRunService:
         for row in last_runs:
             row["build_number"] = get_build_number(build_job_url=row["build_job_url"])
 
+        last_runs = sorted(last_runs, reverse=True, key=lambda run: (run["build_number"], ComparableTestStatus(TestStatus(run["status"]))))
+
         return last_runs
 
     def get_runs_by_id(self, test_id: UUID, runs: list[UUID]):  # FIXME: Not needed, use get_run and individual polling
@@ -105,7 +112,7 @@ class TestRunService:
         run.status = new_status.value
         run.save()
 
-        self.create_run_event(
+        EventService.create_run_event(
             kind=ArgusEventTypes.TestRunStatusChanged,
             body={
                 "message": "Status was changed from {old_status} to {new_status} by {username}",
@@ -133,7 +140,7 @@ class TestRunService:
         run.investigation_status = new_status.value
         run.save()
 
-        self.create_run_event(
+        EventService.create_run_event(
             kind=ArgusEventTypes.TestRunStatusChanged,
             body={
                 "message": "Investigation status was changed from {old_status} to {new_status} by {username}",
@@ -172,7 +179,7 @@ class TestRunService:
                 LOGGER.warning("Non existent assignee was present on the run %s for test %s: %s",
                                run_id, test_id, old_assignee)
                 old_assignee = None
-        self.create_run_event(
+        EventService.create_run_event(
             kind=ArgusEventTypes.AssigneeChanged,
             body={
                 "message": "Assignee was changed from \"{old_user}\" to \"{new_user}\" by {username}",
@@ -241,7 +248,7 @@ class TestRunService:
                 content_params=params
             )
 
-        self.create_run_event(kind=ArgusEventTypes.TestRunCommentPosted, body={
+        EventService.create_run_event(kind=ArgusEventTypes.TestRunCommentPosted, body={
             "message": "A comment was posted by {username}",
             "username": g.user.username
         }, user_id=g.user.id, run_id=run_id, release_id=release.id, test_id=test.id)
@@ -254,7 +261,7 @@ class TestRunService:
             raise Exception("Unable to delete other user comments")
         comment.delete()
 
-        self.create_run_event(kind=ArgusEventTypes.TestRunCommentDeleted, body={
+        EventService.create_run_event(kind=ArgusEventTypes.TestRunCommentDeleted, body={
             "message": "A comment was deleted by {username}",
             "username": g.user.username
         }, user_id=g.user.id, run_id=run_id, release_id=comment.release_id, test_id=test_id)
@@ -270,25 +277,13 @@ class TestRunService:
         comment.mentions = mentions
         comment.save()
 
-        self.create_run_event(kind=ArgusEventTypes.TestRunCommentUpdated, body={
+        EventService.create_run_event(kind=ArgusEventTypes.TestRunCommentUpdated, body={
             "message": "A comment was edited by {username}",
             "username": g.user.username
         }, user_id=g.user.id, run_id=run_id, release_id=comment.release_id, test_id=test_id)
 
         return self.get_run_comments(run_id=run_id)
 
-    def create_run_event(self, kind: ArgusEventTypes, body: dict, user_id=None, run_id=None, release_id=None, group_id=None, test_id=None):
-        event = ArgusEvent()
-        event.release_id = release_id
-        event.group_id = group_id
-        event.test_id = test_id
-        event.user_id = user_id
-        event.run_id = run_id
-        event.body = json.dumps(body, ensure_ascii=True, separators=(',', ':'))
-        event.kind = kind.value
-        event.created_at = datetime.utcnow()
-        event.save()
-
     def get_run_events(self, run_id: UUID):
         response = {}
         all_events = ArgusEvent.filter(run_id=run_id).all()
@@ -355,7 +350,7 @@ class TestRunService:
         new_issue.last_status = issue_state.get("state")
         new_issue.save()
 
-        self.create_run_event(
+        EventService.create_run_event(
             kind=ArgusEventTypes.TestRunIssueAdded,
             body={
                 "message": "An issue titled \"{title}\" was added by {username}",
@@ -406,7 +401,7 @@ class TestRunService:
     def delete_github_issue(self, issue_id: UUID) -> dict:
         issue: ArgusGithubIssue = ArgusGithubIssue.get(id=issue_id)
 
-        self.create_run_event(
+        EventService.create_run_event(
             kind=ArgusEventTypes.TestRunIssueRemoved,
             body={
                 "message": "An issue titled \"{title}\" was removed by {username}",
@@ -445,7 +440,7 @@ class TestRunService:
             run.status = TestStatus.ABORTED.value
             run.save()
 
-            self.create_run_event(
+            EventService.create_run_event(
                 kind=ArgusEventTypes.TestRunStatusChanged,
                 body={
                     "message": "Run was automatically terminated due to not responding for more than 45 minutes "
@@ -462,3 +457,46 @@ class TestRunService:
             )
 
         return len(all_stuck_runs)
+
+    def ignore_jobs(self, test_id: UUID, reason: str):
+        test: ArgusTest = ArgusTest.get(id=test_id)
+        plugin = self.get_plugin(plugin_name=test.plugin_name)
+
+        if not reason:
+            raise TestRunServiceException("Reason for ignore cannot be empty")
+
+        cluster = ScyllaCluster.get()
+        batch = BatchStatement(consistency_level=ConsistencyLevel.QUORUM)
+        event_batch = BatchQuery()
+        jobs_affected = 0
+        for job in plugin.model.get_jobs_meta_by_test_id(test.id):
+            if job["status"] != TestStatus.PASSED and job["investigation_status"] == TestInvestigationStatus.NOT_INVESTIGATED:
+                batch.add(
+                    plugin.model.prepare_investigation_status_update_query(
+                        build_id=job["build_id"],
+                        start_time=job["start_time"],
+                        new_status=TestInvestigationStatus.IGNORED
+                    )
+                )
+
+                ArgusEvent.batch(event_batch).create(
+                    release_id = job["release_id"],
+                    group_id = job["group_id"],
+                    test_id = test_id,
+                    user_id = g.user.id,
+                    run_id = job["id"],
+                    body = json.dumps({
+                        "message": "Run was marked as ignored by {username} due to the following reason: {reason}",
+                        "username": g.user.username,
+                        "reason": reason,
+                    }, ensure_ascii=True, separators=(',', ':')),
+                    kind = ArgusEventTypes.TestRunBatchInvestigationStatusChange.value,
+                    created_at = datetime.utcnow(),
+                )
+
+                jobs_affected += 1
+
+        cluster.session.execute(batch)
+        event_batch.execute()
+
+        return jobs_affected

argus/backend/util/encoders.py

@@ -1,4 +1,5 @@
 from datetime import datetime
+import logging
 from json.encoder import JSONEncoder
 from uuid import UUID
 
@@ -6,6 +7,8 @@ import cassandra.cqlengine.usertype as ut
 import cassandra.cqlengine.models as m
 
 
+LOGGER = logging.getLogger(__name__)
+
 class ArgusJSONEncoder(JSONEncoder):
     def default(self, o):
         match o:

argus/backend/util/enums.py

@@ -25,6 +25,7 @@ class TestInvestigationStatus(str, Enum):
     NOT_INVESTIGATED = "not_investigated"
     IN_PROGRESS = "in_progress"
     INVESTIGATED = "investigated"
+    IGNORED = "ignored"
 
 
 class ResourceState(str, Enum):

argus/client/driver_matrix_tests/client.py

@@ -16,6 +16,7 @@ from argus.backend.plugins.driver_matrix_tests.raw_types import RawMatrixTestRes
 
 LOGGER = logging.getLogger(__name__)
 
+TestTypeType = Literal['java', 'cpp', 'python', 'gocql']
 
 class AdaptedXUnitData(TypedDict):
     timestamp: str
@@ -52,6 +53,14 @@ def cpp_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
     }
 
 
+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()
@@ -66,6 +75,7 @@ class ArgusDriverMatrixClient(ArgusClient):
         "java": java_driver_matrix_adapter,
         "cpp": cpp_driver_matrix_adapter,
         "python": python_driver_matrix_adapter,
+        "gocql": gocql_driver_matrix_adapter,
     }
 
     def __init__(self, run_id: UUID, auth_token: str, base_url: str, api_version="v1") -> None:
@@ -107,8 +117,11 @@ class ArgusDriverMatrixClient(ArgusClient):
 
         return raw_cases
 
-    def get_driver_info(self, xml_name: str) -> dict[str, str]:
-        filename_re = r"(?P<name>[\w]*)\.(?P<driver_name>[\w]*)\.(?P<proto>v\d)\.(?P<version>[\d\.]*)\.xml"
+    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)
 
@@ -124,14 +137,14 @@ class ArgusDriverMatrixClient(ArgusClient):
 
         return total - errors - skipped - failures
 
-    def parse_result_xml(self, xml_path: Path, test_type:  Literal['java', 'cpp', 'python']) -> RawMatrixTestResult:
+    def parse_result_xml(self, xml_path: Path, test_type:  TestTypeType) -> RawMatrixTestResult:
         with xml_path.open(mode="rt", encoding="utf-8") as xml_file:
             xml = ElementTree.parse(source=xml_file)
             LOGGER.info("%s", pformat(xml))
         testsuites = xml.getroot()
         adapted_data = self.TEST_ADAPTERS.get(test_type, generic_adapter)(xml)
 
-        driver_info = self.get_driver_info(xml_path.name)
+        driver_info = self.get_driver_info(xml_path.name, test_type)
         test_collection = {
             "timestamp": adapted_data["timestamp"],
             "name": xml_path.stem,
@@ -171,7 +184,7 @@ class ArgusDriverMatrixClient(ArgusClient):
             "suites": all_suites
         }
 
-    def get_results(self, result_path: str, test_type: Literal['java', 'cpp', 'python']) -> list[RawMatrixTestResult]:
+    def get_results(self, result_path: str, test_type: TestTypeType) -> list[RawMatrixTestResult]:
         xmls = glob(f"{result_path}/**/*.xml", recursive=True)
         LOGGER.info("Will use following XMLs: %s", pformat(xmls))
         results = []
@@ -180,7 +193,7 @@ class ArgusDriverMatrixClient(ArgusClient):
             results.append(result)
         return results
 
-    def submit(self, build_id: str, build_url: str, env_path: str, result_path: str, test_type: Literal['java', 'cpp', 'python']):
+    def submit(self, build_id: str, build_url: str, env_path: str, result_path: str, test_type: TestTypeType):
         env = self.parse_build_environment(env_path)
         results = self.get_results(result_path, test_type)
 

argus/client/sct/client.py

@@ -1,5 +1,6 @@
 from uuid import UUID
 from dataclasses import asdict
+from argus.backend.plugins.sct.types import GeminiResultsRequest, PerformanceResultsRequest
 from argus.backend.util.enums import ResourceState, TestStatus
 from argus.client.base import ArgusClient
 from argus.client.sct.types import EventsInfo, LogLink, Package
@@ -14,8 +15,11 @@ class ArgusSCTClient(ArgusClient):
         SUBMIT_SCREENSHOTS = "/sct/$id/screenshots/submit"
         CREATE_RESOURCE = "/sct/$id/resource/create"
         TERMINATE_RESOURCE = "/sct/$id/resource/$name/terminate"
+        SET_SCT_RUNNER  = "/sct/$id/sct_runner/set"
         UPDATE_SHARDS_FOR_RESOURCE = "/sct/$id/resource/$name/shards"
         SUBMIT_NEMESIS = "/sct/$id/nemesis/submit"
+        SUBMIT_GEMINI_RESULTS = "/sct/$id/gemini/submit"
+        SUBMIT_PERFORMANCE_RESULTS = "/sct/$id/performance/submit"
         FINALIZE_NEMESIS = "/sct/$id/nemesis/finalize"
         SUBMIT_EVENTS = "/sct/$id/events/submit"
 
@@ -23,8 +27,7 @@ class ArgusSCTClient(ArgusClient):
         super().__init__(auth_token, base_url, api_version)
         self.run_id = run_id
 
-    def submit_sct_run(self, job_name: str, job_url: str, started_by: str, commit_id: str,
-                       runner_public_ip: str, runner_private_ip: str, sct_config: dict) -> None:
+    def submit_sct_run(self, job_name: str, job_url: str, started_by: str, commit_id: str, sct_config: dict) -> None:
         """
             Submits an SCT run to argus.
         """
@@ -34,8 +37,6 @@ class ArgusSCTClient(ArgusClient):
             "job_url": job_url,
             "started_by": started_by,
             "commit_id": commit_id,
-            "runner_public_ip": runner_public_ip,
-            "runner_private_ip": runner_private_ip,
             "sct_config": sct_config,
         })
 
@@ -48,6 +49,23 @@ class ArgusSCTClient(ArgusClient):
         response = super().set_status(run_type=self.test_type, run_id=self.run_id, new_status=new_status)
         self.check_response(response)
 
+    def set_sct_runner(self, public_ip: str, private_ip: str, region: str, backend: str) -> None:
+        """
+            Sets runner information for an SCT run.
+        """
+        response = self.post(
+            endpoint=self.Routes.SET_SCT_RUNNER,
+            location_params={"id": str(self.run_id)},
+            body={
+                **self.generic_body,
+                "public_ip": public_ip,
+                "private_ip": private_ip,
+                "region": region,
+                "backend": backend,
+            }
+        )
+        self.check_response(response)
+
     def update_scylla_version(self, version: str) -> None:
         """
             Updates scylla server version used for filtering test results by version.
@@ -98,6 +116,34 @@ class ArgusSCTClient(ArgusClient):
         )
         self.check_response(response)
 
+    def submit_gemini_results(self, gemini_data: GeminiResultsRequest) -> None:
+        """
+            Submits gemini results such as oracle node information and gemini command & its results
+        """
+        response = self.post(
+            endpoint=self.Routes.SUBMIT_GEMINI_RESULTS,
+            location_params={"id": str(self.run_id)},
+            body={
+                **self.generic_body,
+                "gemini_data": gemini_data,
+            }
+        )
+        self.check_response(response)
+
+    def submit_performance_results(self, performance_results: PerformanceResultsRequest) -> None:
+        """
+            Submits results of a performance run. Things such as throughput stats, overall and per op
+        """
+        response = self.post(
+            endpoint=self.Routes.SUBMIT_PERFORMANCE_RESULTS,
+            location_params={"id": str(self.run_id)},
+            body={
+                **self.generic_body,
+                "performance_results": performance_results,
+            }
+        )
+        self.check_response(response)
+
     def create_resource(self, name: str, resource_type: str, public_ip: str, private_ip: str,
                         region: str, provider: str, shards_amount: int, state=ResourceState.RUNNING) -> None:
         """

{argus_alm-0.11.3.dist-info → argus_alm-0.11.6.dist-info}/METADATA

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