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

argus/backend/controller/admin_api.py

@@ -7,8 +7,8 @@ from flask import (
 )
 from argus.backend.error_handlers import handle_api_exception
 from argus.backend.service.release_manager import ReleaseEditPayload, ReleaseManagerService
-from argus.backend.service.user import api_login_required, check_roles
-from argus.backend.models.web import UserRoles
+from argus.backend.service.user import UserService, api_login_required, check_roles
+from argus.backend.models.web import User, UserRoles
 
 bp = Blueprint('admin_api', __name__, url_prefix='/api/v1')
 LOGGER = logging.getLogger(__name__)
@@ -287,3 +287,68 @@ def quick_toggle_group_enabled():
         "status": "ok",
         "response": res
     }
+
+
+@bp.route("/users", methods=["GET"])
+@check_roles(UserRoles.Admin)
+@api_login_required
+def user_info():
+    result = UserService().get_users_privileged()
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/user/<string:user_id>/email/set", methods=["POST"])
+@check_roles(UserRoles.Admin)
+@api_login_required
+def user_change_email(user_id: str):
+    payload = get_payload(request)
+
+    user = User.get(id=user_id)
+    result = UserService().update_email(user=user, new_email=payload["newEmail"])
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/user/<string:user_id>/delete", methods=["POST"])
+@check_roles(UserRoles.Admin)
+@api_login_required
+def user_delete(user_id: str):
+    result = UserService().delete_user(user_id=user_id)
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/user/<string:user_id>/password/set", methods=["POST"])
+@check_roles(UserRoles.Admin)
+@api_login_required
+def user_change_password(user_id: str):
+    payload = get_payload(request)
+
+    user = User.get(id=user_id)
+    result = UserService().update_password(user=user, old_password="", new_password=payload["newPassword"], force=True)
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+@bp.route("/user/<string:user_id>/admin/toggle", methods=["POST"])
+@check_roles(UserRoles.Admin)
+@api_login_required
+def user_toggle_admin(user_id: str):
+    result = UserService().toggle_admin(user_id=user_id)
+
+    return {
+        "status": "ok",
+        "response": result
+    }

argus/backend/controller/api.py

@@ -14,6 +14,7 @@ from argus.backend.controller.testrun_api import bp as testrun_bp
 from argus.backend.controller.team import bp as team_bp
 from argus.backend.controller.view_api import bp as view_bp
 from argus.backend.service.argus_service import ArgusService, ScheduleUpdateRequest
+from argus.backend.service.results_service import ResultsService
 from argus.backend.service.user import UserService, api_login_required
 from argus.backend.service.stats import ReleaseStatsCollector
 from argus.backend.models.web import ArgusRelease, ArgusGroup, ArgusTest, User, UserOauthToken
@@ -381,6 +382,19 @@ def test_info():
         "response": info
     }
 
+@bp.route("/test-results", methods=["GET"])
+@api_login_required
+def test_results():
+    test_id = request.args.get("testId")
+    if not test_id:
+        raise Exception("No testId provided")
+    service = ResultsService()
+    info = service.get_results(test_id=UUID(test_id))
+
+    return {
+        "status": "ok",
+        "response": info
+    }
 
 @bp.route("/test_run/comment/get", methods=["GET"])  # TODO: remove
 @api_login_required

argus/backend/controller/auth.py

@@ -5,7 +5,7 @@ from flask import (
 )
 from werkzeug.security import check_password_hash
 from argus.backend.models.web import User
-from argus.backend.service.user import UserService, load_logged_in_user, login_required
+from argus.backend.service.user import UserService, UserServiceException, load_logged_in_user, login_required
 
 bp = Blueprint('auth', __name__, url_prefix='/auth')
 
@@ -21,24 +21,26 @@ def login():
     session["csrf_token"] = token
 
     if request.method == 'POST':
-        username = request.form["username"]
-        password = request.form["password"]
-        error = None
         try:
-            user = User.get(username=username)
-        except User.DoesNotExist:
-            user = None
+            if "password" not in current_app.config.get("LOGIN_METHODS", []):
+                raise UserServiceException("Password Login is disabled")
+            username = request.form["username"]
+            password = request.form["password"]
 
-        if not user:
-            error = "User not found"
-        elif not check_password_hash(user.password, password):
-            error = "Incorrect Password"
+            try:
+                user: User = User.get(username=username)
+            except User.DoesNotExist:
+                raise UserServiceException("User not found")
+
+            if not check_password_hash(user.password, password):
+                raise UserServiceException("Incorrect Password")
 
-        if not error:
             session.clear()
             session["user_id"] = str(user.id)
             session["csrf_token"] = token
-        flash(error, category="error")
+        except UserServiceException as exc:
+            flash(next(iter(exc.args), "No message"), category="error")
+        
         return redirect(url_for('main.home'))
 
     return render_template('auth/login.html.j2',

argus/backend/controller/client_api.py

@@ -23,6 +23,15 @@ def submit_run(run_type: str):
         "response": result
     }
 
+@bp.route("/testrun/<string:run_type>/<string:run_id>/get", methods=["GET"])
+@api_login_required
+def get_run(run_type: str, run_id: str):
+    result = ClientService().get_run(run_type=run_type, run_id=run_id)
+    return {
+        "status": "ok",
+        "response": result
+    }
+
 
 @bp.route("/testrun/<string:run_type>/<string:run_id>/heartbeat", methods=["POST"])
 @api_login_required

argus/backend/controller/main.py

@@ -152,6 +152,7 @@ def profile_oauth_github_callback():
     try:
         first_run_info = service.github_callback(req_code)
     except Exception as exc:  # pylint: disable=broad-except
+        LOGGER.error("An error occured in callback", exc_info=True)
         flash(message=exc.args[0], category="error")
         return redirect(url_for("main.error", type=403))
     if first_run_info:

argus/backend/models/result.py

@@ -28,6 +28,28 @@ class ArgusGenericResultMetadata(Model):
         kwargs["columns_meta"] = [ColumnMetadata(**col) for col in kwargs.pop('columns_meta', [])]
         super().__init__(**kwargs)
 
+    def update_if_changed(self, new_data: dict) -> None:
+        """
+        Updates table metadata if changed column/description or new rows were added.
+        See that rows can only be added, not removed once was sent.
+        Columns may be removed, but data in results table persists.
+        """
+        updated = False
+        for field, value in new_data.items():
+            if field == "columns_meta":
+                value = [ColumnMetadata(**col) for col in value]
+            elif field == "rows_meta":
+                added_rows = []
+                for row in value:
+                    if row not in self.rows_meta:
+                        added_rows.append(row)
+                value = self.rows_meta + added_rows
+            if getattr(self, field) != value:
+                setattr(self, field, value)
+                updated = True
+
+        if updated:
+            self.save()
 
 class ArgusGenericResultData(Model):
     __table_name__ = "generic_result_data_v1"

argus/backend/plugins/core.py

@@ -30,7 +30,7 @@ class PluginModelBase(Model):
     _plugin_name = "unknown"
     # Metadata
     build_id = columns.Text(required=True, partition_key=True)
-    start_time = columns.DateTime(required=True, primary_key=True, clustering_order="DESC", default=datetime.now, custom_index=True)
+    start_time = columns.DateTime(required=True, primary_key=True, clustering_order="DESC", default=datetime.utcnow, custom_index=True)
     id = columns.UUID(index=True, required=True)
     release_id = columns.UUID(index=True)
     group_id = columns.UUID(index=True)
@@ -110,11 +110,11 @@ class PluginModelBase(Model):
         return assignees_uuids[0] if len(assignees_uuids) > 0 else None
 
     @classmethod
-    def get_jobs_assigned_to_user(cls, user: User):
+    def get_jobs_assigned_to_user(cls, user_id: str | UUID):
         cluster = ScyllaCluster.get()
         query = cluster.prepare("SELECT build_id, start_time, release_id, group_id, assignee, "
                                 f"test_id, id, status, investigation_status, build_job_url, scylla_version FROM {cls.table_name()} WHERE assignee = ?")
-        rows = cluster.session.execute(query=query, parameters=(user.id,))
+        rows = cluster.session.execute(query=query, parameters=(user_id,))
 
         return list(rows)
 

argus/backend/plugins/driver_matrix_tests/controller.py

@@ -1,8 +1,10 @@
 from flask import Blueprint, request
 
 from argus.backend.error_handlers import handle_api_exception
+from argus.backend.plugins.driver_matrix_tests.raw_types import DriverMatrixSubmitEnvRequest, DriverMatrixSubmitFailureRequest, DriverMatrixSubmitResultRequest
 from argus.backend.service.user import api_login_required
 from argus.backend.plugins.driver_matrix_tests.service import DriverMatrixService
+from argus.backend.util.common import get_payload
 
 bp = Blueprint("driver_matrix_api", __name__, url_prefix="/driver_matrix")
 bp.register_error_handler(Exception, handle_api_exception)
@@ -22,3 +24,40 @@ def driver_matrix_test_report():
         "status": "ok",
         "response": result
     }
+
+@bp.route("/result/submit", methods=["POST"])
+@api_login_required
+def submit_result():
+    payload = get_payload(request)
+    request_data = DriverMatrixSubmitResultRequest(**payload)
+
+    result = DriverMatrixService().submit_driver_result(driver_name=request_data.driver_name, driver_type=request_data.driver_type, run_id=request_data.run_id, raw_xml=request_data.raw_xml)
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/result/fail", methods=["POST"])
+@api_login_required
+def submit_failure():
+    payload = get_payload(request)
+    request_data = DriverMatrixSubmitFailureRequest(**payload)
+
+    result = DriverMatrixService().submit_driver_failure(driver_name=request_data.driver_name, driver_type=request_data.driver_type, run_id=request_data.run_id, failure_reason=request_data.failure_reason)
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+@bp.route("/env/submit", methods=["POST"])
+@api_login_required
+def submit_env():
+    payload = get_payload(request)
+    request_data = DriverMatrixSubmitEnvRequest(**payload)
+
+    result = DriverMatrixService().submit_env_info(run_id=request_data.run_id, raw_env=request_data.raw_env)
+    return {
+        "status": "ok",
+        "response": result
+    }

argus/backend/plugins/driver_matrix_tests/model.py

@@ -1,8 +1,12 @@
 from dataclasses import dataclass
 from datetime import datetime
 from functools import reduce
+import logging
+from pprint import pformat
 import re
+from typing import Literal, TypedDict
 from uuid import UUID
+from xml.etree import ElementTree
 from cassandra.cqlengine import columns
 from argus.backend.db import ScyllaCluster
 from argus.backend.models.web import ArgusRelease
@@ -12,6 +16,8 @@ from argus.backend.plugins.driver_matrix_tests.raw_types import RawMatrixTestRes
 from argus.backend.util.enums import TestStatus
 
 
+LOGGER = logging.getLogger(__name__)
+
 class DriverMatrixPluginError(Exception):
     pass
 
@@ -26,6 +32,65 @@ class DriverMatrixRunSubmissionRequest():
     matrix_results: list[RawMatrixTestResult]
 
 
+@dataclass(init=True, repr=True, frozen=True)
+class DriverMatrixRunSubmissionRequestV2():
+    schema_version: str
+    run_id: str
+    job_name: str
+    job_url: str
+
+
+TestTypeType = Literal['java', 'cpp', 'python', 'gocql']
+
+
+class AdaptedXUnitData(TypedDict):
+    timestamp: str
+
+
+def python_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
+    testsuites = list(xml.getroot().iter("testsuite"))
+
+    return {
+        "timestamp": testsuites[0].attrib.get("timestamp"),
+    }
+
+
+def java_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
+    testsuites = xml.getroot()
+    ts_now = datetime.utcnow().timestamp()
+    try:
+        time_taken = float(testsuites.attrib.get("time"))
+    except ValueError:
+        time_taken = 0.0
+
+    timestamp = datetime.utcfromtimestamp(ts_now - time_taken).isoformat()
+
+    return {
+        "timestamp": timestamp,
+    }
+
+
+def cpp_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
+    testsuites = xml.getroot()
+
+    return {
+        "timestamp": testsuites.attrib.get("timestamp"),
+    }
+
+
+def gocql_driver_matrix_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
+    testsuites = list(xml.getroot().iter("testsuite"))
+
+    return {
+        "timestamp": testsuites[0].attrib.get("timestamp"),
+    }
+
+
+def generic_adapter(xml: ElementTree.ElementTree) -> AdaptedXUnitData:
+    return {
+        "timestamp": datetime.utcnow().isoformat()
+    }
+
 class DriverTestRun(PluginModelBase):
     _plugin_name = "driver-matrix-tests"
     __table_name__ = "driver_test_run"
@@ -35,6 +100,14 @@ class DriverTestRun(PluginModelBase):
 
     _no_upstream = ["rust"]
 
+    _TEST_ADAPTERS = {
+        "java": java_driver_matrix_adapter,
+        "cpp": cpp_driver_matrix_adapter,
+        "python": python_driver_matrix_adapter,
+        "gocql": gocql_driver_matrix_adapter,
+    }
+
+
     _artifact_fnames = {
         "cpp": r"TEST-(?P<driver_name>[\w]*)-(?P<version>[\d\.-]*)",
         "gocql": r"xunit\.(?P<driver_name>[\w]*)\.(?P<proto>v\d)\.(?P<version>[v\d\.]*)",
@@ -78,6 +151,173 @@ class DriverTestRun(PluginModelBase):
 
     @classmethod
     def submit_run(cls, request_data: dict) -> 'DriverTestRun':
+        if request_data["schema_version"] == "v2":
+            req = DriverMatrixRunSubmissionRequestV2(**request_data)
+        else:
+            return cls.submit_matrix_run(request_data)
+
+        run = cls()
+        run.id = req.run_id
+        run.build_id = req.job_name
+        run.build_job_url = req.job_url
+        run.start_time = datetime.utcnow()
+        run.assign_categories()
+        try:
+            run.assignee = run.get_scheduled_assignee()
+        except Exception:  # pylint: disable=broad-except
+            run.assignee = None
+
+        run.status = TestStatus.CREATED.value
+        run.save()
+        return run
+
+    @classmethod
+    def submit_driver_result(cls, run_id: UUID, driver_name: str, driver_type: TestTypeType, xml_data: str):
+        run: DriverTestRun = cls.get(id=run_id)
+
+        collection = run.parse_result_xml(driver_name, xml_data, driver_type)
+        run.test_collection.append(collection)
+
+        if run.status == TestStatus.CREATED:
+            run.status = TestStatus.RUNNING.value
+
+        run.save()
+        return run
+
+
+    @classmethod
+    def submit_driver_failure(cls, run_id: UUID, driver_name: str, driver_type: TestTypeType, fail_message: str):
+        run: DriverTestRun = cls.get(id=run_id)
+
+        collection = TestCollection()
+        collection.failures = 1
+        collection.failure_message = fail_message
+        collection.name = driver_name
+        driver_info = run.get_driver_info(driver_name, driver_type)
+        collection.driver = driver_info.get("driver_name")
+        collection.tests_total = 1
+        run.test_collection.append(collection)
+
+        if run.status == TestStatus.CREATED:
+            run.status = TestStatus.RUNNING.value
+
+        run.save()
+        return run
+
+    @classmethod
+    def submit_env_info(cls, run_id: UUID, env_data: str):
+        run: DriverTestRun = cls.get(id=run_id)
+        env = run.parse_build_environment(env_data)
+
+        for key, value in env.items():
+            env_info = EnvironmentInfo()
+            env_info.key = key
+            env_info.value = value
+            run.environment_info.append(env_info)
+
+        run.scylla_version = env.get("scylla-version")
+
+        run.save()
+        return run
+
+    def parse_build_environment(self, raw_env: str) -> dict[str, str]:
+        result = {}
+        for line in raw_env.split("\n"):
+            if not line:
+                continue
+            LOGGER.debug("ENV: %s", line)
+            key, val = line.split(": ")
+            result[key] = val.strip()
+
+        return result
+
+    def get_test_cases(self, cases: list[ElementTree.Element]) -> list[TestCase]:
+        result = []
+        for raw_case in cases:
+            children = list(raw_case.findall("./*"))
+            if len(children) > 0:
+                status = children[0].tag
+                message = f"{children[0].attrib.get('message', 'no-message')} ({children[0].attrib.get('type', 'no-type')})"
+            else:
+                status = "passed"
+                message = ""
+
+            case = TestCase()
+            case.name = raw_case.attrib["name"]
+            case.status = status
+            case.time = float(raw_case.attrib.get("time", 0.0))
+            case.classname = raw_case.attrib.get("classname", "")
+            case.message = message
+            result.append(case)
+
+        return result
+
+    def get_driver_info(self, xml_name: str, test_type: TestTypeType) -> dict[str, str]:
+        if test_type == "cpp":
+            filename_re = r"TEST-(?P<driver_name>[\w]*)-(?P<version>[\d\.]*)(\.xml)?"
+        else:
+            filename_re = r"(?P<name>[\w]*)\.(?P<driver_name>[\w]*)\.(?P<proto>v\d)\.(?P<version>[\d\.]*)(\.xml)?"
+
+        match = re.match(filename_re, xml_name)
+
+        return match.groupdict() if match else {}
+
+    def get_passed_count(self, suite_attribs: dict[str, str]) -> int:
+        if (pass_count := suite_attribs.get("passed")):
+            return int(pass_count)
+        total = int(suite_attribs.get("tests", 0))
+        errors = int(suite_attribs.get("errors", 0))
+        skipped = int(suite_attribs.get("skipped", 0))
+        failures = int(suite_attribs.get("failures", 0))
+
+        return total - errors - skipped - failures
+
+    def parse_result_xml(self, name: str, xml_data: str, test_type: TestTypeType) -> TestCollection:
+        xml: ElementTree.ElementTree = ElementTree.ElementTree(ElementTree.fromstring(xml_data))
+        LOGGER.debug("%s", pformat(xml))
+        testsuites = xml.getroot()
+        adapted_data = self._TEST_ADAPTERS.get(test_type, generic_adapter)(xml)
+
+        driver_info = self.get_driver_info(name, test_type)
+        test_collection = TestCollection()
+        test_collection.timestamp = datetime.fromisoformat(adapted_data["timestamp"][0:-1] if adapted_data["timestamp"][-1] == "Z" else adapted_data["timestamp"])
+        test_collection.name = name
+        test_collection.driver = driver_info.get("driver_name")
+        test_collection.tests_total = 0
+        test_collection.failures = 0
+        test_collection.errors = 0
+        test_collection.disabled = 0
+        test_collection.skipped = 0
+        test_collection.passed = 0
+        test_collection.time = 0.0
+        test_collection.suites = []
+
+        for xml_suite in testsuites.iter("testsuite"):
+            suite = TestSuite()
+            suite.name = xml_suite.attrib["name"]
+            suite.tests_total = int(xml_suite.attrib.get("tests", 0))
+            suite.failures = int(xml_suite.attrib.get("failures", 0))
+            suite.disabled = int(0)
+            suite.passed = self.get_passed_count(xml_suite.attrib)
+            suite.skipped = int(xml_suite.attrib.get("skipped", 0))
+            suite.errors = int(xml_suite.attrib.get("errors", 0))
+            suite.time = float(xml_suite.attrib["time"])
+            suite.cases = self.get_test_cases(xml_suite.findall("testcase"))
+
+            test_collection.suites.append(suite)
+            test_collection.tests_total += suite.tests_total
+            test_collection.failures += suite.failures
+            test_collection.errors += suite.errors
+            test_collection.disabled += suite.disabled
+            test_collection.skipped += suite.skipped
+            test_collection.passed += suite.passed
+            test_collection.time += suite.time
+
+        return test_collection
+
+    @classmethod
+    def submit_matrix_run(cls, request_data):
+        # Legacy method
         req = DriverMatrixRunSubmissionRequest(**request_data)
         run = cls()
         run.id = req.run_id  # pylint: disable=invalid-name
@@ -146,6 +386,11 @@ class DriverTestRun(PluginModelBase):
         return []
 
     def _determine_run_status(self):
+        for collection in self.test_collection:
+            # patch failure
+            if collection.failure_message:
+                return TestStatus.FAILED
+
         if len(self.test_collection) < 2:
             return TestStatus.FAILED
 
@@ -153,14 +398,14 @@ class DriverTestRun(PluginModelBase):
         if len(driver_types) <= 1 and not any(driver for driver in self._no_upstream if driver in driver_types):
             return TestStatus.FAILED
 
-        failure_count = reduce(lambda acc, val: acc + (val.failures + val.errors), self.test_collection, 0)
+        failure_count = reduce(lambda acc, val: acc + (val.failures or 0 + val.errors or 0), self.test_collection, 0)
         if failure_count > 0:
             return TestStatus.FAILED
 
         return TestStatus.PASSED
 
     def change_status(self, new_status: TestStatus):
-        raise DriverMatrixPluginError("This method is obsolete. Status is now determined on submission.")
+        self.status = new_status
 
     def get_events(self) -> list:
         return []
@@ -170,6 +415,7 @@ class DriverTestRun(PluginModelBase):
 
     def finish_run(self, payload: dict = None):
         self.end_time = datetime.utcnow()
+        self.status = self._determine_run_status().value
 
     def submit_logs(self, logs: list[dict]):
         pass

argus/backend/plugins/driver_matrix_tests/raw_types.py

@@ -1,4 +1,6 @@
+from dataclasses import dataclass
 from typing import TypedDict
+from uuid import UUID
 
 
 class RawMatrixTestCase(TypedDict):
@@ -33,3 +35,28 @@ class RawMatrixTestResult(TypedDict):
     time: float
     timestamp: str
     suites: list[RawMatrixTestSuite]
+
+
+@dataclass(init=True, frozen=True)
+class DriverMatrixSubmitResultRequest():
+    schema_version: str
+    run_id: UUID
+    driver_type: str
+    driver_name: str
+    raw_xml: str
+
+
+@dataclass(init=True, frozen=True)
+class DriverMatrixSubmitFailureRequest():
+    schema_version: str
+    run_id: UUID
+    driver_type: str
+    driver_name: str
+    failure_reason: str
+
+
+@dataclass(init=True, frozen=True)
+class DriverMatrixSubmitEnvRequest():
+    schema_version: str
+    run_id: UUID
+    raw_env: str

argus/backend/plugins/driver_matrix_tests/service.py

@@ -1,8 +1,13 @@
+import base64
+import logging
+from uuid import UUID
 from argus.backend.db import ScyllaCluster
 from argus.backend.models.web import ArgusRelease, ArgusTest
 from argus.backend.plugins.driver_matrix_tests.model import DriverTestRun
 
 
+LOGGER = logging.getLogger(__name__)
+
 class DriverMatrixService:
     def tested_versions_report(self, build_id: str) -> dict:
         db = ScyllaCluster.get()
@@ -40,3 +45,16 @@ class DriverMatrixService:
             "versions": version_map,
         }
         return response
+
+    def submit_driver_result(self, run_id: UUID | str, driver_name: str, driver_type: str, raw_xml: str) -> bool:
+        xml_data = base64.decodebytes(bytes(raw_xml, encoding="utf-8"))
+        DriverTestRun.submit_driver_result(UUID(run_id), driver_name, driver_type, xml_data)
+        return True
+
+    def submit_driver_failure(self, run_id: UUID | str, driver_name: str, driver_type: str, failure_reason: str) -> bool:
+        DriverTestRun.submit_driver_failure(UUID(run_id), driver_name, driver_type, failure_reason)
+        return True
+
+    def submit_env_info(self, run_id: UUID | str, raw_env: str) -> bool:
+        DriverTestRun.submit_env_info(UUID(run_id), raw_env)
+        return True