argus-alm 0.12.5__tar.gz → 0.12.8__tar.gz

{argus_alm-0.12.5 → argus_alm-0.12.8}/PKG-INFO

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

{argus_alm-0.12.5 → argus_alm-0.12.8}/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_alm-0.12.5 → argus_alm-0.12.8}/argus/backend/controller/api.py

@@ -4,7 +4,7 @@ import requests
 from flask import (
     Blueprint,
     g,
-    request
+    request, Response
 )
 from flask.json import jsonify
 from argus.backend.error_handlers import handle_api_exception
@@ -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,22 @@ def test_info():
         "response": info
     }
 
+@bp.route("/test-results", methods=["GET", "HEAD"])
+@api_login_required
+def test_results():
+    test_id = request.args.get("testId")
+    if not test_id:
+        raise Exception("No testId provided")
+    service = ResultsService()
+    if request.method == 'HEAD':
+        exists = service.is_results_exist(test_id=UUID(test_id))
+        return Response(status=200 if exists else 404)
+    graphs, ticks = service.get_test_graphs(test_id=UUID(test_id))
+
+    return {
+        "status": "ok",
+        "response": {"graphs": graphs, "ticks": ticks}
+    }
 
 @bp.route("/test_run/comment/get", methods=["GET"])  # TODO: remove
 @api_login_required

{argus_alm-0.12.5 → argus_alm-0.12.8}/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_alm-0.12.5 → argus_alm-0.12.8}/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
@@ -96,8 +105,4 @@ def run_finalize(run_type: str, run_id: str):
 @api_login_required
 def submit_results(run_type: str, run_id: str):
     payload = get_payload(request)
-    result = ClientService().submit_results(run_type=run_type, run_id=run_id, results=payload)
-    return {
-        "status": "ok",
-        "response": result
-    }
+    return ClientService().submit_results(run_type=run_type, run_id=run_id, results=payload)

{argus_alm-0.12.5 → argus_alm-0.12.8}/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_alm-0.12.5 → argus_alm-0.12.8}/argus/backend/controller/testrun_api.py

@@ -8,6 +8,7 @@ from flask import (
 from argus.backend.error_handlers import handle_api_exception
 from argus.backend.models.web import ArgusTest
 from argus.backend.service.jenkins_service import JenkinsService
+from argus.backend.service.results_service import ResultsService
 from argus.backend.service.testrun import TestRunService
 from argus.backend.service.user import api_login_required
 from argus.backend.util.common import get_payload
@@ -67,7 +68,7 @@ def test_run_activity(run_id: str):
 @bp.route("/run/<string:test_id>/<string:run_id>/fetch_results", methods=["GET"])
 @api_login_required
 def fetch_results(test_id: str, run_id: str):
-    tables = TestRunService().fetch_results(test_id=UUID(test_id), run_id=UUID(run_id))
+    tables = ResultsService().get_run_results(test_id=UUID(test_id), run_id=UUID(run_id))
     return {
         "status": "ok",
         "tables": tables

argus_alm-0.12.8/argus/backend/models/result.py

@@ -0,0 +1,75 @@
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine.usertype import UserType
+
+class BestResult(UserType):
+    date = columns.DateTime()
+    value = columns.Double()
+    run_id = columns.UUID()
+
+class ValidationRules(UserType):
+    higher_is_better = columns.Boolean()
+    margin_percent = columns.Double()
+    margin_value = columns.Double()
+    limit = columns.Double()
+
+class ColumnMetadata(UserType):
+    name = columns.Ascii()
+    unit = columns.Text()
+    type = columns.Ascii()
+
+
+class ArgusGenericResultMetadata(Model):
+    __table_name__ = "generic_result_metadata_v1"
+    test_id = columns.UUID(partition_key=True)
+    name = columns.Text(required=True, primary_key=True)
+    description = columns.Text()
+    columns_meta = columns.List(value_type=columns.UserDefinedType(ColumnMetadata))
+    validation_rules = columns.Map(key_type=columns.Ascii(), value_type=columns.List(value_type=columns.UserDefinedType(ValidationRules)))
+    best_results = columns.Map(key_type=columns.Ascii(), value_type=columns.UserDefinedType(BestResult))
+    rows_meta = columns.List(value_type=columns.Ascii())
+
+    def __init__(self, **kwargs):
+        kwargs["columns_meta"] = [ColumnMetadata(**col) for col in kwargs.pop('columns_meta', [])]
+        kwargs["best_results"] = {k: [BestResult(**z) for z in v] for k, v in kwargs.pop('best_results', {}).items()}
+        kwargs["validation_rules"] = {k: ValidationRules(**v) for k, v in kwargs.pop('validation_rules', {}).items()}
+        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
+            elif field == "best_results":
+                value = {k: [BestResult(**z) for z in v] for k, v in value.items()}
+            elif field == "validation_rules":
+                value = {k: ValidationRules(**v) for k, v in value.items()}
+            if getattr(self, field) != value:
+                setattr(self, field, value)
+                updated = True
+
+        if updated:
+            self.save()
+
+class ArgusGenericResultData(Model):
+    __table_name__ = "generic_result_data_v1"
+    test_id = columns.UUID(partition_key=True)
+    name = columns.Text(partition_key=True)
+    run_id = columns.UUID(primary_key=True)
+    column = columns.Ascii(primary_key=True, index=True)
+    row = columns.Ascii(primary_key=True, index=True)
+    sut_timestamp = columns.DateTime()  # for sorting
+    value = columns.Double()
+    value_text = columns.Text()
+    status = columns.Ascii()

{argus_alm-0.12.5 → argus_alm-0.12.8}/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_alm-0.12.8/argus/backend/plugins/driver_matrix_tests/controller.py

@@ -0,0 +1,63 @@
+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)
+
+
+@bp.route("/test_report", methods=["GET"])
+@api_login_required
+def driver_matrix_test_report():
+
+    build_id = request.args.get("buildId")
+    if not build_id:
+        raise Exception("No build id provided")
+    
+
+    result = DriverMatrixService().tested_versions_report(build_id=build_id)
+    return {
+        "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
+    }