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

argus/backend/cli.py

@@ -22,7 +22,7 @@ def sync_models_command():
         LOGGER.info("Synchronizing plugin type %s...", user_type.__name__)
         sync_type(ks_name=cluster.config["SCYLLA_KEYSPACE_NAME"], type_model=user_type)
     LOGGER.info("Synchronizing plugin models...")
-    for model in all_plugin_models():
+    for model in all_plugin_models(True):
         LOGGER.info("Synchronizing plugin model %s...", model.__name__)
         sync_table(model=model, keyspaces=[cluster.config["SCYLLA_KEYSPACE_NAME"]])
 

argus/backend/controller/admin_api.py

@@ -261,3 +261,29 @@ def get_tests_for_group():
         "status": "ok",
         "response": tests
     }
+
+
+@bp.route("/release/test/state/toggle", methods=["POST"])
+@check_roles(UserRoles.Admin)
+@api_login_required
+def quick_toggle_test_enabled():
+    
+    payload = get_payload(request)
+    res = ReleaseManagerService().toggle_test_enabled(test_id=payload["entityId"], new_state=payload["state"])
+    return {
+        "status": "ok",
+        "response": res
+    }
+
+
+@bp.route("/release/group/state/toggle", methods=["POST"])
+@check_roles(UserRoles.Admin)
+@api_login_required
+def quick_toggle_group_enabled():
+    
+    payload = get_payload(request)
+    res = ReleaseManagerService().toggle_group_enabled(group_id=payload["entityId"], new_state=payload["state"])
+    return {
+        "status": "ok",
+        "response": res
+    }

argus/backend/controller/api.py

@@ -12,7 +12,8 @@ from argus.backend.controller.notification_api import bp as notifications_bp
 from argus.backend.controller.client_api import bp as client_bp
 from argus.backend.controller.testrun_api import bp as testrun_bp
 from argus.backend.controller.team import bp as team_bp
-from argus.backend.service.argus_service import ArgusService
+from argus.backend.controller.view_api import bp as view_bp
+from argus.backend.service.argus_service import ArgusService, ScheduleUpdateRequest
 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
@@ -23,6 +24,7 @@ bp.register_blueprint(notifications_bp)
 bp.register_blueprint(client_bp)
 bp.register_blueprint(testrun_bp)
 bp.register_blueprint(team_bp)
+bp.register_blueprint(view_bp)
 bp.register_error_handler(Exception, handle_api_exception)
 LOGGER = logging.getLogger(__name__)
 
@@ -227,6 +229,8 @@ def release_schedules_submit():
         groups=payload["groups"],
         assignees=payload["assignees"],
         tag=payload["tag"],
+        comments=payload.get("comments"),
+        group_ids=payload.get("groupIds"),
     )
 
     return jsonify({
@@ -251,6 +255,27 @@ def release_schedules_delete():
     })
 
 
+@bp.route("/release/schedules/update", methods=["POST"])
+@api_login_required
+def release_schedule_update():
+    payload = get_payload(request)
+    req = ScheduleUpdateRequest(**payload)
+    service = ArgusService()
+    update_result = service.update_schedule(
+        release_id=req.release_id,
+        schedule_id=req.schedule_id,
+        old_tests=req.old_tests,
+        new_tests=req.new_tests,
+        comments=req.comments,
+        assignee=req.assignee
+    )
+
+    return jsonify({
+        "status": "ok",
+        "response": update_result
+    })
+
+
 @bp.route("/groups", methods=["GET"])
 @api_login_required
 def argus_groups():

argus/backend/controller/main.py

@@ -1,3 +1,5 @@
+import datetime
+import json
 import logging
 from uuid import UUID
 from flask import (
@@ -8,6 +10,7 @@ from argus.backend.controller.team_ui import bp as teams_bp
 from argus.backend.service.argus_service import ArgusService
 from argus.backend.models.web import WebFileStorage
 from argus.backend.service.user import UserService, login_required
+from argus.backend.service.views import UserViewService
 
 LOGGER = logging.getLogger(__name__)
 
@@ -55,6 +58,24 @@ def releases():
     return render_template("releases.html.j2", releases=all_releases)
 
 
+@bp.route("/views")
+@login_required
+def views():
+    service = UserViewService()
+    all_views = service.get_all_views()
+    return render_template("views.html.j2", views=sorted(all_views, key=lambda view: view.created or datetime.datetime.fromtimestamp(0), reverse=True))
+
+
+@bp.route("/view/<string:view_name>")
+@login_required
+def view_dashboard(view_name: str):
+    service = UserViewService()
+    view = service.get_view_by_name(view_name=view_name)
+    data_json = view
+    view["widget_settings"] = json.loads(view["widget_settings"])
+    return render_template("view_dashboard.html.j2", data=data_json)
+
+
 @bp.route("/alert_debug")
 @login_required
 def alert_debug():

argus/backend/controller/testrun_api.py

@@ -6,6 +6,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.testrun import TestRunService
 from argus.backend.service.user import api_login_required
@@ -288,6 +289,22 @@ def ignore_jobs():
     }
 
 
+@bp.route("/get_runs_by_test_id_run_id", methods=["POST"])
+@api_login_required
+def get_runs_by_test_id_run_id():
+    payload: list[tuple[UUID, UUID]] = get_payload(request)
+    service = TestRunService()
+
+    result = service.resolve_run_build_id_and_number_multiple(payload)
+
+    return {
+        "status": "ok",
+        "response": {
+            "runs": result
+        }
+    }
+
+
 @bp.route("/jenkins/params", methods=["POST"])
 @api_login_required
 def get_jenkins_job_params():
@@ -336,4 +353,118 @@ def get_queue_info():
         "response": {
             "queueItem": result
         }
-    }
+    }
+
+
+@bp.route("/jenkins/clone/targets")
+@api_login_required
+def get_clone_targets():
+    test_id = request.args.get("testId")
+    if not test_id:
+        raise Exception("No testId provided")
+    service = JenkinsService()
+    result = service.get_releases_for_clone(test_id)
+
+    return {
+        "status": "ok",
+        "response": {
+            "targets": result
+        }
+    }
+
+
+@bp.route("/jenkins/clone/groups")
+@api_login_required
+def get_groups_for_target():
+    target_id = request.args.get("targetId")
+    if not target_id:
+        raise Exception("No targetId provided")
+    service = JenkinsService()
+    result = service.get_groups_for_release(target_id)
+
+    return {
+        "status": "ok",
+        "response": {
+            "groups": result
+        }
+    }
+
+
+@bp.route("/jenkins/clone/create", methods=["POST"])
+@api_login_required
+def clone_jenkins_job():
+
+    payload = get_payload(request)
+    service = JenkinsService()
+
+    result = service.clone_job(
+        current_test_id=payload["currentTestId"],
+        new_name=payload["newName"],
+        target=payload["target"],
+        group=payload["group"],
+        advanced_settings=payload["advancedSettings"],
+    )
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/jenkins/clone/build", methods=["POST"])
+@api_login_required
+def clone_build_jenkins_job():
+
+    payload = get_payload(request)
+    service = JenkinsService()
+
+    result = service.clone_build_job(build_id=payload["buildId"], params=payload["parameters"])
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/jenkins/clone/settings")
+@api_login_required
+def get_clone_job_advanced_settings():
+    build_id = request.args.get("buildId")
+    if not build_id:
+        raise Exception("No testId provided")
+    service = JenkinsService()
+    result = service.get_advanced_settings(build_id)
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/jenkins/clone/settings/change", methods=["POST"])
+@api_login_required
+def set_job_settings():
+    payload = get_payload(request)
+    service = JenkinsService()
+    test = ArgusTest.get(build_system_id=payload["buildId"])
+    result = service.adjust_job_settings(build_id=test.build_system_id, plugin_name=test.plugin_name, settings=payload["settings"])
+
+    return {
+        "status": "ok",
+        "response": result
+    }
+
+
+@bp.route("/jenkins/clone/settings/validate", methods=["POST"])
+@api_login_required
+def clone_validate_new_settings():
+
+    payload = get_payload(request)
+    service = JenkinsService()
+
+    result = service.verify_job_settings(build_id=payload["buildId"], new_settings=payload["newSettings"])
+
+    return {
+        "status": "ok",
+        "response": result
+    }

argus/backend/controller/view_api.py

@@ -0,0 +1,162 @@
+import logging
+from uuid import UUID
+from flask import (
+    Blueprint,
+    jsonify,
+    request,
+)
+from argus.backend.error_handlers import handle_api_exception
+from argus.backend.models.web import User
+from argus.backend.service.stats import ViewStatsCollector
+from argus.backend.service.user import api_login_required
+from argus.backend.service.views import UserViewService
+from argus.backend.util.common import get_payload
+
+bp = Blueprint('view_api', __name__, url_prefix='/views')
+LOGGER = logging.getLogger(__name__)
+bp.register_error_handler(Exception, handle_api_exception)
+
+
+class ViewApiException(Exception):
+    pass
+
+
+@bp.route("/", methods=["GET"])
+@api_login_required
+def index():
+    return {
+        "status": "ok",
+        "response": {
+            "version": "v1",
+        }
+    }
+
+
+@bp.route("/create", methods=["POST"])
+@api_login_required
+def create_view():
+    payload = get_payload(request)
+    service = UserViewService()
+    view = service.create_view(
+        name=payload["name"], 
+        items=payload["items"],
+        widget_settings=payload["settings"],
+        description=payload.get("description"),
+        display_name=payload.get("displayName")
+    )
+    return {
+        "status": "ok",
+        "response": view
+    }
+
+
+@bp.route("/get", methods=["GET"])
+@api_login_required
+def get_view():
+    view_id = request.args.get("viewId")
+    if not view_id:
+        raise ViewApiException("No viewId provided.")
+    service = UserViewService()
+    view = service.get_view(UUID(view_id))
+    return {
+        "status": "ok",
+        "response": view
+    }
+
+
+@bp.route("/all", methods=["GET"])
+@api_login_required
+def get_all_views():
+    user_id = request.args.get("userId")
+    if user_id:
+        user = User.get(id=user_id)
+    else:
+        user = None
+    service = UserViewService()
+    views = service.get_all_views(user)
+    return {
+        "status": "ok",
+        "response": views
+    }
+
+
+@bp.route("/update", methods=["POST"])
+@api_login_required
+def update_view():
+    payload = get_payload(request)
+    service = UserViewService()
+    res = service.update_view(view_id=payload["viewId"], update_data=payload["updateData"])
+    return {
+        "status": "ok",
+        "response": res
+    }
+
+
+@bp.route("/delete", methods=["POST"])
+@api_login_required
+def delete_view():
+    payload = get_payload(request)
+    service = UserViewService()
+    res = service.delete_view(payload["viewId"])
+    return {
+        "status": "ok",
+        "response": res
+    }
+
+
+@bp.route("/search", methods=["GET"])
+@api_login_required
+def search_tests():
+    query = request.args.get("query")
+    service = UserViewService()
+    if query:
+        res = service.test_lookup(query)
+    else:
+        res = []
+    return {
+        "status": "ok",
+        "response": {
+            "hits": res,
+            "total": len(res)
+        }
+    }
+
+@bp.route("/stats", methods=["GET"])
+@api_login_required
+def view_stats():
+    view_id = request.args.get("viewId")
+    if not view_id:
+        raise ViewApiException("No view id provided.")
+    limited = bool(int(request.args.get("limited", 0)))
+    version = request.args.get("productVersion", None)
+    include_no_version = bool(int(request.args.get("includeNoVersion", True)))
+    force = bool(int(request.args.get("force",  0)))
+    collector = ViewStatsCollector(view_id=view_id, filter=version)
+    stats = collector.collect(limited=limited, force=force, include_no_version=include_no_version)
+
+    res = jsonify({
+        "status": "ok",
+        "response": stats
+    })
+    res.cache_control.max_age = 300
+    return res
+
+@bp.route("/<string:view_id>/versions", methods=["GET"])
+@api_login_required
+def view_versions(view_id: str):
+    service = UserViewService()
+    res = service.get_versions_for_view(view_id)
+    return {
+        "status": "ok",
+        "response": res
+    }
+
+@bp.route("/<string:view_id>/resolve", methods=["GET"])
+@api_login_required
+def view_resolve(view_id: str):
+    service = UserViewService()
+    res = service.resolve_view_for_edit(view_id)
+    return {
+        "status": "ok",
+        "response": res
+    }

argus/backend/models/web.py

@@ -146,6 +146,20 @@ class ArgusGroup(Model):
             return super().__eq__(other)
 
 
+class ArgusUserView(Model):
+    id = columns.UUID(primary_key=True, partition_key=True, default=uuid4)
+    name = columns.Text(required=True, index=True)
+    display_name = columns.Text()
+    description = columns.Text()
+    user_id = columns.UUID(required=True, index=True)
+    tests = columns.List(value_type=columns.UUID, default=lambda: [])
+    release_ids = columns.List(value_type=columns.UUID, default=lambda: [])
+    group_ids = columns.List(value_type=columns.UUID, default=lambda: [])
+    created = columns.DateTime(default=datetime.utcnow)
+    last_updated = columns.DateTime(default=datetime.utcnow)
+    widget_settings = columns.Text(required=True)
+
+
 class ArgusTest(Model):
     __table_name__ = "argus_test_v2"
     id = columns.UUID(primary_key=True, default=uuid4)
@@ -180,6 +194,7 @@ class ArgusTestRunComment(Model):
     test_run_id = columns.UUID(required=True, index=True)
     user_id = columns.UUID(required=True, index=True)
     release_id = columns.UUID(required=True, index=True)
+    test_id = columns.UUID(required=True, index=True)
     posted_at = columns.Integer(
         required=True, clustering_order="desc", primary_key=True)
     message = columns.Text(min_length=1, max_length=65535)
@@ -350,6 +365,7 @@ USED_MODELS: list[Model] = [
     Team,
     WebFileStorage,
     ArgusRelease,
+    ArgusUserView,
     ArgusGroup,
     ArgusTest,
     ArgusTestRunComment,

argus/backend/plugins/core.py

@@ -1,5 +1,6 @@
 import logging
 from datetime import datetime
+from math import ceil
 from uuid import UUID
 from time import time
 
@@ -16,8 +17,10 @@ from argus.backend.models.web import (
     ArgusSchedule,
     ArgusScheduleTest,
     ArgusScheduleAssignee,
+    ArgusUserView,
     User
 )
+from argus.backend.util.common import chunk
 from argus.backend.util.enums import TestInvestigationStatus, TestStatus
 
 LOGGER = logging.getLogger(__name__)
@@ -27,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)
@@ -132,13 +135,18 @@ class PluginModelBase(Model):
         return bound_query
 
     @classmethod
-    def get_stats_for_release(cls, release: ArgusRelease):
+    def get_stats_for_release(cls, release: ArgusRelease, build_ids=list[str]):
         cluster = ScyllaCluster.get()
         query = cluster.prepare(cls._stats_query())
-        rows = cluster.session.execute(query=query, parameters=(release.id,))
+        futures = []
+        step_size = 90
 
-        return list(rows)
+        for step in range(0, ceil(len(build_ids) / step_size)):
+            start_pos = step*step_size
+            next_slice = build_ids[start_pos:start_pos+step_size]
+            futures.append(cluster.session.execute_async(query=query, parameters=(next_slice,)))
 
+        return futures
     @classmethod
     def get_run_meta_by_build_id(cls, build_id: str, limit: int = 10):
         cluster = ScyllaCluster.get()
@@ -169,6 +177,21 @@ class PluginModelBase(Model):
     def get_distinct_product_versions(cls, release: ArgusRelease) -> list[str]:
         raise NotImplementedError()
 
+    @classmethod
+    def get_distinct_versions_for_view(cls, tests: list[ArgusTest]) -> list[str]:
+        cluster = ScyllaCluster.get()
+        statement = cluster.prepare(f"SELECT scylla_version FROM {cls.table_name()} WHERE build_id IN ?")
+        futures = []
+        for batch in chunk(tests):
+            futures.append(cluster.session.execute_async(query=statement, parameters=([t.build_system_id for t in batch],)))
+        
+        rows = []
+        for future in futures:
+            rows.extend(future.result())
+        unique_versions = {r["scylla_version"] for r in rows if r["scylla_version"]}
+
+        return sorted(list(unique_versions), reverse=True)
+
     def update_heartbeat(self):
         self.heartbeat = int(time())
 
@@ -181,7 +204,7 @@ class PluginModelBase(Model):
     def submit_product_version(self, version: str):
         raise NotImplementedError()
 
-    def set_product_version(self, version: str):
+    def set_full_version(self, version: str):
         self.product_version = version
 
     def submit_logs(self, logs: list[dict]):

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
+    }