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

argus/backend/util/common.py

@@ -1,8 +1,11 @@
+from itertools import islice
 import logging
-from typing import Callable
+from typing import Callable, Iterable
 from uuid import UUID
 
-from flask import Request, Response
+from flask import Request, Response, g
+
+from argus.backend.models.web import User
 
 
 LOGGER = logging.getLogger(__name__)
@@ -20,6 +23,11 @@ def first(iterable, value, key: Callable = None, predicate: Callable = None):
     return None
 
 
+def chunk(iterable: Iterable, slice_size = 90):
+    it = iter(iterable)
+    return iter(lambda: list(islice(it, slice_size)), [])
+
+
 def check_scheduled_test(test, group, testname):
     return testname in (f"{group}/{test}", test)
 
@@ -43,6 +51,10 @@ def get_payload(client_request: Request) -> dict:
     return request_payload
 
 
+def current_user() -> User:
+    return g.user
+
+
 def get_build_number(build_job_url: str) -> int | None:
     build_number = build_job_url.rstrip("/").split("/")[-1] if build_job_url else -1
     if build_number:

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["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()

argus/client/driver_matrix_tests/client.py

@@ -1,216 +1,79 @@
-from functools import reduce
-from datetime import datetime
-from typing import TypedDict, Literal
-import re
-import logging
 from uuid import UUID
-from pathlib import Path
-from pprint import pformat
-from glob import glob
-from xml.etree import ElementTree
-
 from argus.backend.util.enums import TestStatus
 from argus.client.base import ArgusClient
-from argus.backend.plugins.driver_matrix_tests.raw_types import RawMatrixTestResult, RawMatrixTestCase
-
-
-LOGGER = logging.getLogger(__name__)
-
-TestTypeType = Literal['java', 'cpp', 'python', 'gocql']
-
-class AdaptedXUnitData(TypedDict):
-    timestamp: str
-
-
-def python_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
-    testsuites = list(xml.getroot().iter("testsuite"))
-
-    return {
-        "timestamp": testsuites[0].attrib.get("timestamp"),
-    }
-
-
-def java_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
-    testsuites = xml.getroot()
-    ts_now = datetime.utcnow().timestamp()
-    try:
-        time_taken = float(testsuites.attrib.get("time"))
-    except ValueError:
-        time_taken = 0.0
-
-    timestamp = datetime.utcfromtimestamp(ts_now - time_taken).isoformat()
-
-    return {
-        "timestamp": timestamp,
-    }
-
-
-def cpp_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
-    testsuites = xml.getroot()
-
-    return {
-        "timestamp": testsuites.attrib.get("timestamp"),
-    }
-
-
-def gocql_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
-    testsuites = list(xml.getroot().iter("testsuite"))
-
-    return {
-        "timestamp": testsuites[0].attrib.get("timestamp"),
-    }
-
-
-def generic_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
-    return {
-        "timestamp": datetime.utcnow().isoformat()
-    }
 
 
 class ArgusDriverMatrixClient(ArgusClient):
     test_type = "driver-matrix-tests"
-    schema_version: None = "v1"
+    schema_version: None = "v2"
 
-    TEST_ADAPTERS = {
-        "java": java_driver_matrix_adapter,
-        "cpp": cpp_driver_matrix_adapter,
-        "python": python_driver_matrix_adapter,
-        "gocql": gocql_driver_matrix_adapter,
-    }
+    class Routes(ArgusClient.Routes):
+        SUBMIT_DRIVER_RESULT = "/driver_matrix/result/submit"
+        SUBMIT_DRIVER_FAILURE = "/driver_matrix/result/fail"
+        SUBMIT_ENV = "/driver_matrix/env/submit"
 
     def __init__(self, run_id: UUID, auth_token: str, base_url: str, api_version="v1") -> None:
         super().__init__(auth_token, base_url, api_version)
         self.run_id = run_id
 
-    def parse_build_environment(self, env_path: str) -> dict[str, str]:
-        with open(Path(env_path), mode="rt", encoding="utf-8") as env_file:
-            raw_env = env_file.read()
-
-        result = {}
-        for line in raw_env.split("\n"):
-            if not line:
-                continue
-            LOGGER.debug("ENV: %s", line)
-            key, val = line.split(": ")
-            result[key] = val.strip()
-
-        return result
-
-    def get_test_cases(self, cases: list[ElementTree.Element]) -> list[RawMatrixTestCase]:
-        raw_cases = []
-        for case in cases:
-            children = list(case.findall("./*"))
-            if len(children) > 0:
-                status = children[0].tag
-                message = f"{children[0].attrib.get('message', 'no-message')} ({children[0].attrib.get('type', 'no-type')})"
-            else:
-                status = "passed"
-                message = ""
-
-            raw_cases.append({
-                "name": case.attrib["name"],
-                "status": status,
-                "time": float(case.attrib.get("time", 0.0)),
-                "classname": case.attrib.get("classname", ""),
-                "message": message,
-            })
-
-        return raw_cases
-
-    def get_driver_info(self, xml_name: str, test_type: TestTypeType) -> dict[str, str]:
-        if test_type == "cpp":
-            filename_re = r"TEST-(?P<driver_name>[\w]*)-(?P<version>[\d\.]*)\.xml"
-        else:
-            filename_re = r"(?P<name>[\w]*)\.(?P<driver_name>[\w]*)\.(?P<proto>v\d)\.(?P<version>[\d\.]*)\.xml"
-
-        match = re.match(filename_re, xml_name)
-
-        return match.groupdict() if match else {}
-
-    def get_passed_count(self, suite_attribs: dict[str, str]) -> int:
-        if (pass_count := suite_attribs.get("passed")):
-            return int(pass_count)
-        total = int(suite_attribs.get("tests", 0))
-        errors = int(suite_attribs.get("errors", 0))
-        skipped = int(suite_attribs.get("skipped", 0))
-        failures = int(suite_attribs.get("failures", 0))
-
-        return total - errors - skipped - failures
-
-    def parse_result_xml(self, 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, test_type)
-        test_collection = {
-            "timestamp": adapted_data["timestamp"],
-            "name": xml_path.stem,
-            "driver_name": driver_info.get("driver_name"),
-            "tests": 0,
-            "failures": 0,
-            "errors": 0,
-            "disabled": 0,
-            "skipped": 0,
-            "passed": 0,
-            "time": 0.0,
-        }
-        all_suites = []
-        for suite in testsuites.iter("testsuite"):
-            raw_suite = {
-                "name": suite.attrib["name"],
-                "tests": int(suite.attrib.get("tests", 0)),
-                "failures": int(suite.attrib.get("failures", 0)),
-                "disabled": int(0),
-                "passed": self.get_passed_count(suite.attrib),
-                "skipped": int(suite.attrib.get("skipped", 0)),
-                "errors": int(suite.attrib.get("errors", 0)),
-                "time": float(suite.attrib["time"]),
-                "cases": self.get_test_cases(list(suite.iter("testcase")))
-            }
-            all_suites.append(raw_suite)
-            test_collection["tests"] += raw_suite["tests"]
-            test_collection["failures"] += raw_suite["failures"]
-            test_collection["errors"] += raw_suite["errors"]
-            test_collection["disabled"] += raw_suite["disabled"]
-            test_collection["skipped"] += raw_suite["skipped"]
-            test_collection["passed"] += raw_suite["passed"]
-            test_collection["time"] += raw_suite["time"]
-
-        return {
-            **test_collection,
-            "suites": all_suites
-        }
-
-    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 = []
-        for xml in xmls:
-            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: TestTypeType):
-        env = self.parse_build_environment(env_path)
-        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)
-
-    def submit_driver_matrix_run(self, job_name: str, job_url: str,
-                                 results: list[RawMatrixTestResult], test_environment: dict[str, str]) -> None:
+    def submit_driver_matrix_run(self, job_name: str, job_url: str) -> None:
         response = super().submit_run(run_type=self.test_type, run_body={
             "run_id": str(self.run_id),
             "job_name": job_name,
-            "job_url": job_url,
-            "test_environment": test_environment,
-            "matrix_results": results
+            "job_url": job_url
         })
 
         self.check_response(response)
 
+    def submit_driver_result(self, driver_name: str, driver_type: str, raw_junit_data: bytes):
+        """
+            Submit results of a single driver run
+        """
+        response = self.post(
+            endpoint=self.Routes.SUBMIT_DRIVER_RESULT,
+            location_params={},
+            body={
+                **self.generic_body,
+                "run_id": str(self.run_id),
+                "driver_name": driver_name,
+                "driver_type": driver_type,
+                "raw_xml": str(raw_junit_data, encoding="utf-8"),
+            }
+        )
+        self.check_response(response)
+
+    def submit_driver_failure(self, driver_name: str, driver_type: str, failure_reason: str):
+        """
+            Submit a failure to run of a specific driver test
+        """
+        response = self.post(
+            endpoint=self.Routes.SUBMIT_DRIVER_FAILURE,
+            location_params={},
+            body={
+                **self.generic_body,
+                "run_id": str(self.run_id),
+                "driver_name": driver_name,
+                "driver_type": driver_type,
+                "failure_reason": failure_reason,
+            }
+        )
+        self.check_response(response)
+
+    def submit_env(self, env_info: str):
+        """
+            Submit env-info file (Build-00.txt)
+        """
+        response = self.post(
+            endpoint=self.Routes.SUBMIT_ENV,
+            location_params={},
+            body={
+                **self.generic_body,
+                "run_id": str(self.run_id),
+                "raw_env": env_info,
+            }
+        )
+        self.check_response(response)
+
     def set_matrix_status(self, status: TestStatus):
         response = super().set_status(run_type=self.test_type, run_id=self.run_id, new_status=status)
         self.check_response(response)

argus/client/sct/client.py

@@ -1,3 +1,5 @@
+import base64
+from typing import Any
 from uuid import UUID
 from dataclasses import asdict
 from argus.backend.plugins.sct.types import GeminiResultsRequest, PerformanceResultsRequest
@@ -15,6 +17,7 @@ class ArgusSCTClient(ArgusClient):
         SUBMIT_SCREENSHOTS = "/sct/$id/screenshots/submit"
         CREATE_RESOURCE = "/sct/$id/resource/create"
         TERMINATE_RESOURCE = "/sct/$id/resource/$name/terminate"
+        UPDATE_RESOURCE = "/sct/$id/resource/$name/update"
         SET_SCT_RUNNER  = "/sct/$id/sct_runner/set"
         UPDATE_SHARDS_FOR_RESOURCE = "/sct/$id/resource/$name/shards"
         SUBMIT_NEMESIS = "/sct/$id/nemesis/submit"
@@ -22,6 +25,7 @@ class ArgusSCTClient(ArgusClient):
         SUBMIT_PERFORMANCE_RESULTS = "/sct/$id/performance/submit"
         FINALIZE_NEMESIS = "/sct/$id/nemesis/finalize"
         SUBMIT_EVENTS = "/sct/$id/events/submit"
+        SUBMIT_JUNIT_REPORT = "/sct/$id/junit/submit"
 
     def __init__(self, run_id: UUID, auth_token: str, base_url: str, api_version="v1") -> None:
         super().__init__(auth_token, base_url, api_version)
@@ -204,6 +208,22 @@ class ArgusSCTClient(ArgusClient):
         )
         self.check_response(response)
 
+
+    def update_resource(self, name: str, update_data: dict[str, Any]) -> None:
+        """
+            Update fields of the resource.
+        """
+        response = self.post(
+            endpoint=self.Routes.UPDATE_RESOURCE,
+            location_params={"id": str(self.run_id), "name": name},
+            body={
+                **self.generic_body,
+                "update_data": update_data,
+            }
+        )
+        self.check_response(response)
+
+
     def submit_nemesis(self, name: str, class_name: str, start_time: int,
                        target_name: str, target_ip: str, target_shards: int) -> None:
         """
@@ -265,3 +285,17 @@ class ArgusSCTClient(ArgusClient):
             Updates a heartbeat field for an already existing test.
         """
         super().heartbeat(run_type=self.test_type, run_id=self.run_id)
+
+    def sct_submit_junit_report(self, file_name: str, raw_content: str) -> None:
+        """
+            Submits a JUnit-formatted XML report to argus
+        """
+        response = self.post(
+            endpoint=self.Routes.SUBMIT_JUNIT_REPORT,
+            location_params={"id": str(self.run_id)},
+            body={
+                **self.generic_body,
+                "file_name": file_name,
+                "content": str(base64.encodebytes(bytes(raw_content, encoding="utf-8")), encoding="utf-8")
+            }
+        )

argus_alm-0.12.4b1.dist-info/METADATA

@@ -0,0 +1,129 @@
+Metadata-Version: 2.1
+Name: argus-alm
+Version: 0.12.4b1
+Summary: Argus
+Home-page: https://github.com/scylladb/argus
+License: Apache-2.0
+Author: Alexey Kartashov
+Author-email: alexey.kartashov@scylladb.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: click (>=8.1.3,<9.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
+
+## Description
+
+Argus 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.
+
+## Installation notes
+
+### Development
+
+For development setup instructions, see [dev-setup.md](./docs/dev-setup.md).
+
+### Prerequisites
+
+- Python >=3.10.0 (system-wide or pyenv)
+
+- NodeJS >=16 (with npm)
+
+- Yarn (can be installed globally with `npm -g install yarn`)
+
+- nginx
+
+- poetry >=1.2.0b1
+
+### From source
+
+#### Production
+
+Perform the following steps:
+
+Create a user that will be used by uwsgi:
+
+```bash
+useradd -m -s /bin/bash argus
+sudo -iu argus
+```
+
+(Optional) Install pyenv and create a virtualenv for this user:
+
+```bash
+pyenv install 3.10.0
+pyenv virtualenv argus
+pyenv activate argus
+```
+
+Clone the project into a directory somewhere where user has full write permissions
+
+```bash
+git clone https://github.com/scylladb/argus ~/app
+cd ~/app
+```
+
+Install project dependencies:
+
+```bash
+poetry install --with default,dev,web-backend,docker-image
+yarn install
+```
+
+Compile frontend files from `/frontend` into `/public/dist`
+
+```bash
+yarn webpack
+```
+
+Create 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.
+
+```bash
+cp argus_web.example.yaml argus_web.yaml
+cp argus.yaml argus.local.yaml
+```
+
+Open `argus.local.yaml` and add the database connection information (contact_points, user, password and keyspace name).
+
+Open `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.
+
+Copy nginx configuration file from `docs/configs/argus.nginx.conf` to nginx virtual hosts directory:
+
+Ubuntu:
+
+```bash
+sudo cp docs/configs/argus.nginx.conf /etc/nginx/sites-available/argus
+sudo ln -s /etc/nginx/sites-enabled/argus /etc/nginx/sites-available/argus
+```
+
+RHEL/Centos/Alma/Fedora:
+
+```bash
+sudo cp docs/configs/argus.nginx.conf /etc/nginx/conf.d/argus.conf
+```
+
+Adjust the webhost settings in that file as necessary, particularly `listen` and `server_name` directives.
+
+Copy systemd service file from `docs/config/argus.service` to `/etc/systemd/system` directory:
+
+```bash
+sudo cp docs/config/argus.service /etc/systemd/system
+```
+
+Open 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.
+
+WARNING: `start_argus.sh` assumes pyenv is installed into `~/.pyenv`
+
+```bash
+sudo systemctl daemon-reload
+sudo systemctl enable --now argus.service
+```
+
+
+