argus-alm 0.12.5__py3-none-any.whl → 0.12.7__py3-none-any.whl

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/sct/testrun.py

@@ -109,6 +109,7 @@ class SCTTestRun(PluginModelBase):
     stress_cmd = columns.Text()
 
     histograms = columns.List(value_type=columns.Map(key_type=columns.Text(), value_type=columns.UserDefinedType(user_type=PerformanceHDRHistogram)))
+    test_method = columns.Ascii()
 
     @classmethod
     def _stats_query(cls) -> str:
@@ -199,6 +200,7 @@ class SCTTestRun(PluginModelBase):
 
             run.config_files = req.sct_config.get("config_files")
             run.region_name = regions
+            run.test_method = req.sct_config.get("test_method")
             run.save()
 
         return run

argus/backend/service/argus_service.py

@@ -459,8 +459,13 @@ class ArgusService:
                 self.update_schedule_comment({"newComment": comment, "releaseId": test.release_id, "groupId": test.group_id, "testId": test.id})
 
         schedule_assignee: ArgusScheduleAssignee = ArgusScheduleAssignee.get(schedule_id=schedule_id)
-        schedule_assignee.assignee = assignee
-        schedule_assignee.save()
+        new_assignee = ArgusScheduleAssignee()
+        new_assignee.assignee = assignee
+        new_assignee.release_id = schedule_assignee.release_id
+        new_assignee.schedule_id = schedule_assignee.schedule_id
+        new_assignee.save()
+        schedule_assignee.delete()
+
         return True
 
     def delete_schedule(self, payload: dict) -> dict:
@@ -493,11 +498,16 @@ class ArgusService:
         full_schedule["assignees"] = [assignee.assignee for assignee in assignees]
 
         if len(assignees) > 0:
-            schedule_user = User.get(id=assignees[0].assignee)
+            try:
+                schedule_user = User.get(id=assignees[0].assignee)
+            except User.DoesNotExist:
+                schedule_user = User()
+                schedule_user.id = assignees[0].assignee
+                LOGGER.warning("Deleting orphaned user assignments")
             service = TestRunService()
 
             for model in all_plugin_models():
-                for run in model.get_jobs_assigned_to_user(schedule_user):
+                for run in model.get_jobs_assigned_to_user(schedule_user.id):
                     if run["release_id"] != release.id:
                         continue
                     if run["test_id"] not in full_schedule["tests"]:
@@ -644,7 +654,7 @@ class ArgusService:
         today = datetime.datetime.now()
         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):
+            for run in plugin.get_jobs_assigned_to_user(user_id=user.id):
                 if run["start_time"] >= validity_period:
                     yield run
 

argus/backend/service/build_system_monitor.py

@@ -20,9 +20,9 @@ class ArgusTestsMonitor(ABC):
 
     def __init__(self) -> None:
         self._cluster = ScyllaCluster.get()
-        self._existing_releases = list(ArgusRelease.all())
-        self._existing_groups = list(ArgusGroup.all())
-        self._existing_tests = list(ArgusTest.all())
+        self._existing_releases = list(ArgusRelease.objects().limit(None))
+        self._existing_groups = list(ArgusGroup.objects().limit(None))
+        self._existing_tests = list(ArgusTest.objects().limit(None))
         self._filtered_groups: list[str] = self.BUILD_SYSTEM_FILTERED_PREFIXES
 
     def create_release(self, release_name):

argus/backend/service/client_service.py

@@ -26,6 +26,14 @@ class ClientService:
         model = self.get_model(run_type)
         model.submit_run(request_data=request_data)
         return "Created"
+    
+    def get_run(self, run_type: str, run_id: str):
+        model = self.get_model(run_type)
+        try:
+            run = model.get(id=run_id)
+        except model.DoesNotExist:
+            return None
+        return run
 
     def heartbeat(self, run_type: str, run_id: str) -> int:
         model = self.get_model(run_type)
@@ -74,7 +82,11 @@ class ClientService:
     def submit_results(self, run_type: str, run_id: str, results: dict) -> str:
         model = self.get_model(run_type)
         run = model.load_test_run(UUID(run_id))
-        ArgusGenericResultMetadata(test_id=run.test_id, **results["meta"]).save()
+        existing_table = ArgusGenericResultMetadata.objects(test_id=run.test_id, name=results["meta"]["name"]).first()
+        if existing_table:
+            existing_table.update_if_changed(results["meta"])
+        else:
+            ArgusGenericResultMetadata(test_id=run.test_id, **results["meta"]).save()
         if results.get("sut_timestamp", 0) == 0:
             results["sut_timestamp"] = run.sut_timestamp()  # automatic sut_timestamp
         table_name = results["meta"]["name"]

argus/backend/service/jenkins_service.py

@@ -220,7 +220,9 @@ class JenkinsService:
     def build_job(self, build_id: str, params: dict, user_override: str = None):
         queue_number = self._jenkins.build_job(build_id, {
             **params,
-            self.RESERVED_PARAMETER_NAME: g.user.username if not user_override else user_override
+            # use the user's email as the default value for the requested by user parameter,
+            # so it would align with how SCT default works, on runs not trigger by argus
+            self.RESERVED_PARAMETER_NAME: g.user.email.split('@')[0] if not user_override else user_override
         })
         return queue_number
 

argus/backend/service/results_service.py

@@ -0,0 +1,140 @@
+import copy
+import logging
+import math
+from typing import List, Dict, Any
+from uuid import UUID
+
+from argus.backend.db import ScyllaCluster
+from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData
+
+LOGGER = logging.getLogger(__name__)
+
+default_options = {
+    "scales": {
+        "y": {
+            "beginAtZero": True,
+            "title": {
+                "display": True,
+                "text": ''
+            }
+        },
+        "x": {
+            "type": "time",
+            "time": {
+                "unit": "day",
+                "displayFormats": {
+                    "day": "yyyy-MM-dd",
+                },
+            },
+            "title": {
+                "display": True,
+                "text": 'SUT Date'
+            }
+        },
+    },
+    "elements": {
+        "line": {
+            "tension": .1,
+        }
+    },
+    "plugins": {
+        "legend": {
+            "position": 'top',
+        },
+        "title": {
+            "display": True,
+            "text": ''
+        }
+    }
+}
+
+colors = [
+    'rgba(255, 0, 0, 1.0)',  # Red
+    'rgba(0, 255, 0, 1.0)',  # Green
+    'rgba(0, 0, 255, 1.0)',  # Blue
+    'rgba(0, 255, 255, 1.0)',  # Cyan
+    'rgba(255, 0, 255, 1.0)',  # Magenta
+    'rgba(255, 255, 0, 1.0)',  # Yellow
+    'rgba(255, 165, 0, 1.0)',  # Orange
+    'rgba(128, 0, 128, 1.0)',  # Purple
+    'rgba(50, 205, 50, 1.0)',  # Lime
+    'rgba(255, 192, 203, 1.0)',  # Pink
+    'rgba(0, 128, 128, 1.0)',  # Teal
+    'rgba(165, 42, 42, 1.0)',  # Brown
+    'rgba(0, 0, 128, 1.0)',  # Navy
+    'rgba(128, 128, 0, 1.0)',  # Olive
+    'rgba(255, 127, 80, 1.0)'  # Coral
+]
+
+
+def get_sorted_data_for_column_and_row(data: List[Dict[str, Any]], column: str, row: str) -> List[Dict[str, Any]]:
+    return sorted([{"x": entry.sut_timestamp.strftime('%Y-%m-%dT%H:%M:%SZ'),
+                    "y": entry.value,
+                    "id": entry.run_id}
+                   for entry in data if entry['column'] == column and entry['row'] == row],
+                  key=lambda x: x['x'])
+
+
+def get_min_max_y(datasets: List[Dict[str, Any]]) -> (float, float):
+    """0.5 - 1.5 of min/max of 50% results"""
+    y = [entry['y'] for dataset in datasets for entry in dataset['data']]
+    if not y:
+        return 0, 0
+    sorted_y = sorted(y)
+    lower_percentile_index = int(0.25 * len(sorted_y))
+    upper_percentile_index = int(0.75 * len(sorted_y)) - 1
+    y_min = sorted_y[lower_percentile_index]
+    y_max = sorted_y[upper_percentile_index]
+    return math.floor(0.5 * y_min), math.ceil(1.5 * y_max)
+
+
+def round_datasets_to_min_max(datasets: List[Dict[str, Any]], min_y: float, max_y: float) -> List[Dict[str, Any]]:
+    """Round values to min/max and provide original value for tooltip"""
+    for dataset in datasets:
+        for entry in dataset['data']:
+            val = entry['y']
+            if val > max_y:
+                entry['y'] = max_y
+                entry['ori'] = val
+            elif val < min_y:
+                entry['y'] = min_y
+                entry['ori'] = val
+    return datasets
+
+
+def create_chartjs(table, data):
+    graphs = []
+    for column in table.columns_meta:
+        datasets = [
+            {"label": row,
+             "borderColor": colors[idx % len(colors)],
+             "borderWidth": 3,
+             "showLine": True,
+             "data": get_sorted_data_for_column_and_row(data, column.name, row)} for idx, row in enumerate(table.rows_meta)]
+        min_y, max_y = get_min_max_y(datasets)
+        datasets = round_datasets_to_min_max(datasets, min_y, max_y)
+        if not min_y + max_y:
+            # filter out those without data
+            continue
+        options = copy.deepcopy(default_options)
+        options["plugins"]["title"]["text"] = f"{table.name} - {column.name}"
+        options["scales"]["y"]["title"]["text"] = f"[{column.unit}]"
+        options["scales"]["y"]["min"] = min_y
+        options["scales"]["y"]["max"] = max_y
+        graphs.append({"options": options, "data":
+            {"datasets": datasets}})
+    return graphs
+
+
+class ResultsService:
+
+    def __init__(self, database_session=None):
+        self.session = database_session if database_session else ScyllaCluster.get_session()
+
+    def get_results(self, test_id: UUID):
+        graphs = []
+        res = ArgusGenericResultMetadata.objects(test_id=test_id).all()
+        for table in res:
+            data = ArgusGenericResultData.objects(test_id=test_id, name=table.name).all()
+            graphs.extend(create_chartjs(table, data))
+        return graphs

argus/backend/service/testrun.py

@@ -13,7 +13,7 @@ from flask import g
 from cassandra.query import BatchStatement, ConsistencyLevel
 from cassandra.cqlengine.query import BatchQuery
 from argus.backend.db import ScyllaCluster
-from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData
+from argus.backend.models.result import ArgusGenericResultMetadata
 
 from argus.backend.models.web import (
     ArgusEvent,
@@ -223,7 +223,7 @@ class TestRunService:
         mentions = set(mentions)
         for potential_mention in re.findall(self.RE_MENTION, message_stripped):
             if user := User.exists_by_name(potential_mention.lstrip("@")):
-                mentions.add(user)
+                mentions.add(user) if user.id != g.user.id else None
 
         test: ArgusTest = ArgusTest.get(id=test_id)
         plugin = self.get_plugin(test.plugin_name)
@@ -307,23 +307,28 @@ class TestRunService:
         }
         return response
 
-    def fetch_results(self, test_id: UUID, run_id: UUID) -> dict:
+    def fetch_results(self, test_id: UUID, run_id: UUID) -> list[dict]:
+        cluster = ScyllaCluster.get()
         query_fields = ["column", "row", "value", "status"]
+        raw_query = (f"SELECT {','.join(query_fields)},WRITETIME(value) as ordering "
+                     f"FROM generic_result_data_v1 WHERE test_id = ? AND run_id = ? AND name = ?")
+        query = cluster.prepare(raw_query)
         tables_meta = ArgusGenericResultMetadata.filter(test_id=test_id)
         tables = []
         for table in tables_meta:
-            cells = ArgusGenericResultData.objects.filter(test_id=test_id, run_id=run_id, name=table.name).only(query_fields)
+            cells = cluster.session.execute(query=query, parameters=(test_id, run_id, table.name))
             if not cells:
                 continue
+            cells = [dict(cell.items()) for cell in cells]
             tables.append({'meta': {
                 'name': table.name,
                 'description': table.description,
                 'columns_meta': table.columns_meta,
-                'rows_meta': table.rows_meta
+                'rows_meta': table.rows_meta,
             },
-                'cells': [{k:v for k,v in cell.items() if k in query_fields} for cell in cells]})
-
-        return tables
+                'cells': [{k: v for k, v in cell.items() if k in query_fields} for cell in cells],
+                'order': min([cell['ordering'] for cell in cells] or [0])})
+        return sorted(tables, key=lambda x: x['order'])
 
     def submit_github_issue(self, issue_url: str, test_id: UUID, run_id: UUID):
         user_tokens = UserOauthToken.filter(user_id=g.user.id).all()

argus/backend/service/user.py

@@ -17,6 +17,9 @@ from argus.backend.models.web import User, UserOauthToken, UserRoles, WebFileSto
 from argus.backend.util.common import FlaskView
 
 
+class UserServiceException(Exception):
+    pass
+
 class GithubOrganizationMissingError(Exception):
     pass
 
@@ -29,6 +32,8 @@ class UserService:
 
     @staticmethod
     def check_roles(roles: list[UserRoles] | UserRoles, user: User) -> bool:
+        if not user:
+            return False
         if isinstance(roles, str):
             return roles in user.roles
         elif isinstance(roles, list):
@@ -38,6 +43,8 @@ class UserService:
         return False
 
     def github_callback(self, req_code: str) -> dict | None:
+        if "gh" not in current_app.config.get("LOGIN_METHODS", []):
+            raise UserServiceException("Github Login is disabled")
         # pylint: disable=too-many-locals
         oauth_response = requests.post(
             "https://github.com/login/oauth/access_token",
@@ -90,7 +97,10 @@ class UserService:
         except User.DoesNotExist:
             user = User()
             user.username = user_info.get("login")
-            user.email = email_info[-1].get("email")
+            # pick only scylladb.com emails
+            scylla_email = next(iter([email.get("email") for email in email_info if email.get("email").endswith("@scylladb.com")]), None)
+            primary_email = next(iter([email.get("email") for email in email_info if email.get("primary") and email.get("verified")]), None)
+            user.email = scylla_email or primary_email
             user.full_name = user_info.get("name", user_info.get("login"))
             user.registration_date = datetime.utcnow()
             user.roles = ["ROLE_USER"]
@@ -137,6 +147,15 @@ class UserService:
     def get_users(self) -> dict:
         users = User.all()
         return {str(user.id): user.to_json() for user in users}
+    
+    def get_users_privileged(self) -> dict:
+        users = User.all()
+        users = {str(user.id): dict(user.items()) for user in users}
+        for user in users.values():
+            user.pop("password")
+            user.pop("api_token")
+
+        return users
 
     def generate_token(self, user: User):
         token_digest = f"{user.username}-{int(time())}-{base64.encodebytes(os.urandom(128)).decode(encoding='utf-8')}"
@@ -150,13 +169,51 @@ class UserService:
         user.email = new_email
         user.save()
 
-    def update_password(self, user: User, old_password: str, new_password: str):
-        if check_password_hash(user.password, old_password):
-            raise Exception("Incorrect old password")
+        return True
+
+    def toggle_admin(self, user_id: str):
+        user: User = User.get(id=user_id)
+
+        if user.id == g.user.id:
+            raise UserServiceException("Cannot toggle admin role from yourself.")
+
+        is_admin = UserService.check_roles(UserRoles.Admin, user)
+
+        if is_admin:
+            user.roles.remove(UserRoles.Admin)
+        else:
+            user.set_as_admin()
+
+        user.save()
+        return True
+
+    def delete_user(self, user_id: str):
+        user: User = User.get(id=user_id)
+        if user.id == g.user.id:
+            raise UserServiceException("Cannot delete user that you are logged in as.")
+
+        if user.is_admin():
+            raise UserServiceException("Cannot delete admin users. Unset admin flag before deleting")
+
+        user.delete()
+
+        return True
+
+    def update_password(self, user: User, old_password: str, new_password: str, force = False):
+        if not check_password_hash(user.password, old_password) and not force:
+            raise UserServiceException("Incorrect old password")
+
+        if not new_password:
+            raise UserServiceException("Empty new password")
+
+        if len(new_password) < 5:
+            raise UserServiceException("New password is too short")
 
         user.password = generate_password_hash(new_password)
         user.save()
 
+        return True
+
     def update_name(self, user: User, new_name: str):
         user.full_name = new_name
         user.save()

argus/backend/service/views.py

@@ -110,9 +110,9 @@ class UserViewService:
                 search_func = facet_wrapper(query_func=search_func, facet_query=value, facet_type=facet)
 
 
-        all_tests = ArgusTest.all()
-        all_releases = ArgusRelease.all()
-        all_groups = ArgusGroup.all()
+        all_tests = ArgusTest.objects().limit(None)
+        all_releases = ArgusRelease.objects().limit(None)
+        all_groups = ArgusGroup.objects().limit(None)
         release_by_id = {release.id: partial(self.index_mapper, type="release")(release) for release in all_releases}
         group_by_id = {group.id: partial(self.index_mapper, type="group")(group) for group in all_groups}
         index = [self.index_mapper(t) for t in all_tests]

argus/backend/util/config.py

@@ -10,8 +10,10 @@ LOGGER = logging.getLogger(__name__)
 class Config:
     CONFIG = None
     CONFIG_PATHS = [
-        Path("./config/argus_web.yaml"),
+        Path(__file__).parents[3] / "config" / "argus_web.yaml",
         Path("argus_web.yaml"),
+        Path("../config/argus_web.yaml"),
+
     ]
 
     @classmethod

argus/backend/util/encoders.py

@@ -3,6 +3,7 @@ import logging
 from json.encoder import JSONEncoder
 from uuid import UUID
 
+from flask.json.provider import DefaultJSONProvider
 import cassandra.cqlengine.usertype as ut
 import cassandra.cqlengine.models as m
 
@@ -22,3 +23,19 @@ class ArgusJSONEncoder(JSONEncoder):
                 return o.strftime("%Y-%m-%dT%H:%M:%SZ")
             case _:
                 return super().default(o)
+
+
+class ArgusJSONProvider(DefaultJSONProvider):
+
+    def default(self, o):
+        match o:
+            case UUID():
+                return str(o)
+            case ut.UserType():
+                return dict(o.items())
+            case m.Model():
+                return dict(o.items())
+            case datetime():
+                return o.strftime("%Y-%m-%dT%H:%M:%SZ")
+            case _:
+                return super().default(o)

argus/client/base.py

@@ -24,6 +24,7 @@ class ArgusClient:
     class Routes():
         # pylint: disable=too-few-public-methods
         SUBMIT = "/testrun/$type/submit"
+        GET = "/testrun/$type/$id/get"
         HEARTBEAT = "/testrun/$type/$id/heartbeat"
         GET_STATUS = "/testrun/$type/$id/get_status"
         SET_STATUS = "/testrun/$type/$id/set_status"
@@ -125,7 +126,23 @@ class ArgusClient:
             **self.generic_body,
             **run_body
         })
-    
+
+    def get_run(self, run_type: str = None, run_id: UUID | str = None) -> requests.Response:
+
+        if not run_type and hasattr(self, "test_type"):
+            run_type = self.test_type
+
+        if not run_id and hasattr(self, "run_id"):
+            run_id = self.run_id
+
+        if not (run_type and run_id):
+            raise ValueError("run_type and run_id must be set in func params or object attributes")
+
+        response = self.get(endpoint=self.Routes.GET, location_params={"type": run_type, "id": run_id })
+        self.check_response(response)
+
+        return response.json()["response"]
+
     def get_status(self, run_type: str = None, run_id: UUID = None) -> TestStatus:
         if not run_type and hasattr(self, "test_type"):
             run_type = self.test_type

argus/client/driver_matrix_tests/cli.py

@@ -0,0 +1,110 @@
+import base64
+import json
+from pathlib import Path
+import click
+import logging
+from argus.backend.util.enums import TestStatus
+
+from argus.client.driver_matrix_tests.client import ArgusDriverMatrixClient
+
+LOGGER = logging.getLogger(__name__)
+
+
+@click.group
+def cli():
+    pass
+
+
+def _submit_driver_result_internal(api_key: str, base_url: str, run_id: str, metadata_path: str):
+    metadata = json.loads(Path(metadata_path).read_text(encoding="utf-8"))
+    LOGGER.info("Submitting results for %s [%s/%s] to Argus...", run_id, metadata["driver_name"], metadata["driver_type"])
+    raw_xml = (Path(metadata_path).parent / metadata["junit_result"]).read_bytes()
+    client = ArgusDriverMatrixClient(run_id=run_id, auth_token=api_key, base_url=base_url)
+    client.submit_driver_result(driver_name=metadata["driver_name"], driver_type=metadata["driver_type"], raw_junit_data=base64.encodebytes(raw_xml))
+    LOGGER.info("Done.")
+
+def _submit_driver_failure_internal(api_key: str, base_url: str, run_id: str, metadata_path: str):
+    metadata = json.loads(Path(metadata_path).read_text(encoding="utf-8"))
+    LOGGER.info("Submitting failure for %s [%s/%s] to Argus...", run_id, metadata["driver_name"], metadata["driver_type"])
+    client = ArgusDriverMatrixClient(run_id=run_id, auth_token=api_key, base_url=base_url)
+    client.submit_driver_failure(driver_name=metadata["driver_name"], driver_type=metadata["driver_type"], failure_reason=metadata["failure_reason"])
+    LOGGER.info("Done.")
+
+
+@click.command("submit-run")
+@click.option("--api-key", help="Argus API key for authorization", required=True)
+@click.option("--base-url", default="https://argus.scylladb.com", help="Base URL for argus instance")
+@click.option("--id", "run_id", required=True, help="UUID (v4 or v1) unique to the job")
+@click.option("--build-id", required=True, help="Unique job identifier in the build system, e.g. scylla-master/group/job for jenkins (The full path)")
+@click.option("--build-url", required=True, help="Job URL in the build system")
+def submit_driver_matrix_run(api_key: str, base_url: str, run_id: str, build_id: str, build_url: str):
+    LOGGER.info("Submitting %s (%s) to Argus...", build_id, run_id)
+    client = ArgusDriverMatrixClient(run_id=run_id, auth_token=api_key, base_url=base_url)
+    client.submit_driver_matrix_run(job_name=build_id, job_url=build_url)
+    LOGGER.info("Done.")
+
+
+@click.command("submit-driver")
+@click.option("--api-key", help="Argus API key for authorization", required=True)
+@click.option("--base-url", default="https://argus.scylladb.com", help="Base URL for argus instance")
+@click.option("--id", "run_id", required=True, help="UUID (v4 or v1) unique to the job")
+@click.option("--metadata-path", required=True, help="Path to the metadata .json file that contains path to junit xml and other required information")
+def submit_driver_result(api_key: str, base_url: str, run_id: str, metadata_path: str):
+    _submit_driver_result_internal(api_key=api_key, base_url=base_url, run_id=run_id, metadata_path=metadata_path)
+
+
+@click.command("fail-driver")
+@click.option("--api-key", help="Argus API key for authorization", required=True)
+@click.option("--base-url", default="https://argus.scylladb.com", help="Base URL for argus instance")
+@click.option("--id", "run_id", required=True, help="UUID (v4 or v1) unique to the job")
+@click.option("--metadata-path", required=True, help="Path to the metadata .json file that contains path to junit xml and other required information")
+def submit_driver_failure(api_key: str, base_url: str, run_id: str, metadata_path: str):
+    _submit_driver_failure_internal(api_key=api_key, base_url=base_url, run_id=run_id, metadata_path=metadata_path)
+
+
+@click.command("submit-or-fail-driver")
+@click.option("--api-key", help="Argus API key for authorization", required=True)
+@click.option("--base-url", default="https://argus.scylladb.com", help="Base URL for argus instance")
+@click.option("--id", "run_id", required=True, help="UUID (v4 or v1) unique to the job")
+@click.option("--metadata-path", required=True, help="Path to the metadata .json file that contains path to junit xml and other required information")
+def submit_or_fail_driver(api_key: str, base_url: str, run_id: str, metadata_path: str):
+    metadata = json.loads(Path(metadata_path).read_text(encoding="utf-8"))
+    if metadata.get("failure_reason"):
+        _submit_driver_failure_internal(api_key=api_key, base_url=base_url, run_id=run_id, metadata_path=metadata_path)
+    else:
+        _submit_driver_result_internal(api_key=api_key, base_url=base_url, run_id=run_id, metadata_path=metadata_path)
+
+
+@click.command("submit-env")
+@click.option("--api-key", help="Argus API key for authorization", required=True)
+@click.option("--base-url", default="https://argus.scylladb.com", help="Base URL for argus instance")
+@click.option("--id", "run_id", required=True, help="UUID (v4 or v1) unique to the job")
+@click.option("--env-path", required=True, help="Path to the Build-00.txt file that contains environment information about Scylla")
+def submit_driver_env(api_key: str, base_url: str, run_id: str, env_path: str):
+    LOGGER.info("Submitting environment for run %s to Argus...", run_id)
+    raw_env = Path(env_path).read_text()
+    client = ArgusDriverMatrixClient(run_id=run_id, auth_token=api_key, base_url=base_url)
+    client.submit_env(raw_env)
+    LOGGER.info("Done.")
+
+
+@click.command("finish-run")
+@click.option("--api-key", help="Argus API key for authorization", required=True)
+@click.option("--base-url", default="https://argus.scylladb.com", help="Base URL for argus instance")
+@click.option("--id", "run_id", required=True, help="UUID (v4 or v1) unique to the job")
+@click.option("--status", required=True, help="Resulting job status")
+def finish_driver_matrix_run(api_key: str, base_url: str, run_id: str, status: str):
+    client = ArgusDriverMatrixClient(run_id=run_id, auth_token=api_key, base_url=base_url)
+    client.finalize_run(run_type=ArgusDriverMatrixClient.test_type, run_id=run_id, body={"status": TestStatus(status)})
+
+
+cli.add_command(submit_driver_matrix_run)
+cli.add_command(submit_driver_result)
+cli.add_command(submit_or_fail_driver)
+cli.add_command(submit_driver_failure)
+cli.add_command(submit_driver_env)
+cli.add_command(finish_driver_matrix_run)
+
+
+if __name__ == "__main__":
+    cli()