argus-alm 0.15.2__py3-none-any.whl → 0.15.3__py3-none-any.whl

argus/backend/controller/view_api.py

@@ -1,188 +0,0 @@
-import logging
-from uuid import UUID
-from flask import (
-    Blueprint,
-    jsonify,
-    request,
-)
-from argus.backend.controller.views_widgets.highlights import bp as highlights_bp
-from argus.backend.controller.views_widgets.summary import bp as summary_bp
-from argus.backend.controller.views_widgets.graphs import bp as graphs_bp
-from argus.backend.controller.views_widgets.nemesis_stats import bp as nemesis_stats_bp
-from argus.backend.controller.views_widgets.graphed_stats import bp as graphed_stats_bp
-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_blueprint(highlights_bp)
-bp.register_blueprint(summary_bp)
-bp.register_blueprint(graphs_bp)
-bp.register_blueprint(graphed_stats_bp)
-bp.register_blueprint(nemesis_stats_bp)
-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)))
-    widget_id = request.args.get("widgetId", None)
-    if widget_id:
-        widget_id = int(widget_id)
-    collector = ViewStatsCollector(view_id=view_id, filter=version)
-    stats = collector.collect(limited=limited, force=force, include_no_version=include_no_version, widget_id=widget_id)
-
-    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
-    }
-
-@bp.route("/<string:view_id>/resolve/tests", methods=["GET"])
-@api_login_required
-def view_resolve_tests(view_id: str):
-    service = UserViewService()
-    res = service.resolve_view_tests(view_id)
-    return {
-        "status": "ok",
-        "response": res
-    }

argus/backend/controller/views_widgets/graphed_stats.py

@@ -1,54 +0,0 @@
-from uuid import UUID
-
-from argus.backend.util.common import get_payload
-from flask import Blueprint, request
-
-from argus.backend.models.web import ArgusUserView
-from argus.backend.service.views_widgets.graphed_stats import GraphedStatsService
-from argus.backend.service.user import api_login_required
-
-bp = Blueprint("graphed_stats", __name__, url_prefix="/widgets")
-
-
-@bp.route("/graphed_stats", methods=["GET"])
-@api_login_required
-def get_graphed_stats():
-    view_id = UUID(request.args.get("view_id"))
-    view: ArgusUserView = ArgusUserView.get(id=view_id)
-    service = GraphedStatsService()
-    response_data = {
-        "test_runs": [],
-        "nemesis_data": []
-    }
-
-    filters = request.args.get("filters")
-
-    for test_id in view.tests:
-        data = service.get_graphed_stats(test_id, filters)
-        response_data["test_runs"].extend(data["test_runs"])
-        response_data["nemesis_data"].extend(data["nemesis_data"])
-    return {
-        "status": "ok",
-        "response": response_data
-    }
-
-
-@bp.route("/runs_details", methods=["POST"])
-@api_login_required
-def get_runs_details():
-    """Get detailed information for provided test runs including assignee and attached issues."""
-    data = get_payload(request)
-    if not data or "run_ids" not in data:
-        raise ValueError("Missing run_ids parameter")
-
-    run_ids = data["run_ids"]
-    if not isinstance(run_ids, list):
-        raise ValueError("run_ids must be a list")
-
-    service = GraphedStatsService()
-    result = service.get_runs_details(run_ids)
-
-    return {
-        "status": "ok",
-        "response": result
-    }

argus/backend/controller/views_widgets/graphs.py

@@ -1,68 +0,0 @@
-from uuid import UUID
-from datetime import datetime, timezone
-
-from flask import Blueprint, request
-
-from argus.backend.models.web import ArgusUserView, ArgusTest
-from argus.backend.service.results_service import ResultsService
-from argus.backend.service.user import api_login_required
-bp = Blueprint("graphs", __name__, url_prefix="/widgets")
-
-
-@bp.route("/graphs/graph_views", methods=["GET"])
-@api_login_required
-def get_graph_views():
-    view_id = UUID(request.args.get("view_id"))
-    view: ArgusUserView = ArgusUserView.get(id=view_id)
-    start_date = request.args.get("start_date")
-    end_date = request.args.get("end_date")
-    service = ResultsService()
-    response = {}
-    tests_details = {}
-
-    for test_id in view.tests:
-        test_uuid = test_id
-        graph_views = service.get_argus_graph_views(test_uuid)
-        if graph_views:
-            test_name = ArgusTest.get(id=test_uuid).name
-            tests_details[str(test_id)] = {"name": test_name}
-        view_data = []
-
-        for graph_view in graph_views:
-            # Get unique table names from all graphs in the view
-            table_names = set()
-            for graph_name in graph_view.graphs.keys():
-                table_name = graph_name.rsplit(" - ", 1)[0]
-                table_names.add(table_name)
-
-            # Get graphs data for these tables
-            start_dt = datetime.fromisoformat(start_date).astimezone(timezone.utc) if start_date else None
-            end_dt = datetime.fromisoformat(end_date).astimezone(timezone.utc) if end_date else None
-            graphs, ticks, releases_filters = service.get_test_graphs(
-                test_id=test_uuid,
-                start_date=start_dt,
-                end_date=end_dt,
-                table_names=list(table_names)
-            )
-
-            # filter out graphs that are not in the graph views
-            graphs = [graph for graph in graphs if graph["options"]
-                      ["plugins"]["title"]["text"] in graph_view.graphs.keys()]
-
-            if graphs:
-                view_data.append({
-                    "id": str(graph_view.id),
-                    "name": graph_view.name,
-                    "description": graph_view.description,
-                    "graphs": graphs,
-                    "ticks": ticks,
-                    "releases_filters": releases_filters
-                })
-
-        response[str(test_id)] = view_data
-
-    return {
-        "status": "ok",
-        "response": response,
-        "tests_details": tests_details
-    }

argus/backend/controller/views_widgets/highlights.py

@@ -1,135 +0,0 @@
-from dataclasses import asdict
-from uuid import UUID
-
-from flask import Blueprint, request, g
-
-from argus.backend.service.user import api_login_required
-from argus.backend.service.views_widgets.highlights import (
-    HighlightCreate,
-    HighlightsService,
-    HighlightArchive,
-    HighlightUpdate,
-    HighlightSetAssignee,
-    HighlightSetCompleted,
-    CommentUpdate,
-    CommentDelete,
-    CommentCreate,
-)
-from argus.backend.util.common import get_payload
-
-bp = Blueprint("view_widgets", __name__, url_prefix="/widgets")
-
-
-@bp.route("/highlights/create", methods=["POST"])
-@api_login_required
-def create_highlight():
-    creator_id = g.user.id
-    payload = HighlightCreate(**get_payload(request))
-    service = HighlightsService()
-    highlight = service.create(creator_id, payload)
-    return {"status": "ok", "response": asdict(highlight)}
-
-
-@bp.route("/highlights", methods=["GET"])
-@api_login_required
-def get_highlights():
-    view_id = UUID(request.args.get("view_id"))
-    index = int(request.args.get("index"))
-    service = HighlightsService()
-    highlights, action_items = service.get_highlights(view_id, index)
-    return {
-        "status": "ok",
-        "response": {
-            "highlights": [asdict(h) for h in highlights],
-            "action_items": [asdict(a) for a in action_items],
-        },
-    }
-
-
-@bp.route("/highlights/archive", methods=["POST"])
-@api_login_required
-def archive_highlight():
-    payload = HighlightArchive(**get_payload(request))
-    service = HighlightsService()
-    service.archive_highlight(payload)
-    return {"status": "ok"}
-
-
-@bp.route("/highlights/unarchive", methods=["POST"])
-@api_login_required
-def unarchive_highlight():
-    payload = HighlightArchive(**get_payload(request))
-    service = HighlightsService()
-    service.unarchive_highlight(payload)
-    return {"status": "ok"}
-
-
-@bp.route("/highlights/update", methods=["POST"])
-@api_login_required
-def update_highlight():
-    payload = HighlightUpdate(**get_payload(request))
-    service = HighlightsService()
-    updated_highlight = service.update_highlight(g.user.id, payload)
-    return {"status": "ok", "response": asdict(updated_highlight)}
-
-
-@bp.route("/highlights/set_assignee", methods=["POST"])
-@api_login_required
-def set_assignee():
-    payload = HighlightSetAssignee(**get_payload(request))
-    service = HighlightsService()
-    updated_action_item = service.set_assignee(payload)
-    if payload.assignee_id:
-        service.send_action_notification(sender_id=g.user.id, username=g.user.username, view_id=payload.view_id,
-                                         assignee_id=payload.assignee_id, action=updated_action_item.content)
-    return {"status": "ok", "response": asdict(updated_action_item)}
-
-
-@bp.route("/highlights/set_completed", methods=["POST"])
-@api_login_required
-def set_completed():
-    payload = HighlightSetCompleted(**get_payload(request))
-    service = HighlightsService()
-    updated_action_item = service.set_completed(payload)
-    return {"status": "ok", "response": asdict(updated_action_item)}
-
-
-@bp.route("/highlights/comments/create", methods=["POST"])
-@api_login_required
-def create_comment():
-    creator_id = g.user.id
-    payload = CommentCreate(**get_payload(request))
-    service = HighlightsService()
-    comment = service.create_comment(creator_id, payload)
-    return {"status": "ok", "response": asdict(comment)}
-
-
-@bp.route("/highlights/comments/update", methods=["POST"])
-@api_login_required
-def update_comment():
-    user_id = g.user.id
-    payload = CommentUpdate(**get_payload(request))
-    service = HighlightsService()
-    updated_comment = service.update_comment(user_id, payload)
-    return {"status": "ok", "response": asdict(updated_comment)}
-
-
-@bp.route("/highlights/comments/delete", methods=["POST"])
-@api_login_required
-def delete_comment():
-    user_id = g.user.id
-    payload = CommentDelete(**get_payload(request))
-    service = HighlightsService()
-    service.delete_comment(user_id, payload)
-    return {"status": "ok"}
-
-
-@bp.route("/highlights/comments", methods=["GET"])
-@api_login_required
-def get_comments():
-    view_id = UUID(request.args.get("view_id"))
-    index = int(request.args.get("index"))
-    highlight_created_at = float(request.args.get("created_at"))
-    service = HighlightsService()
-    comments = service.get_comments(view_id, index, highlight_created_at)
-    return {"status": "ok", "response": [asdict(c) for c in comments]}

argus/backend/controller/views_widgets/nemesis_stats.py

@@ -1,26 +0,0 @@
-from uuid import UUID
-
-from flask import Blueprint, request
-
-from argus.backend.models.web import ArgusUserView
-from argus.backend.service.views_widgets.nemesis_stats import NemesisStatsService
-from argus.backend.service.user import api_login_required
-
-
-bp = Blueprint("nemesis_stats", __name__, url_prefix="/widgets")
-
-
-@bp.route("/nemesis_data", methods=["GET"])
-@api_login_required
-def get_nemesis_data():
-    view_id = UUID(request.args.get("view_id"))
-    view: ArgusUserView = ArgusUserView.get(id=view_id)
-    service = NemesisStatsService()
-    nemesis_data = []
-    for test_id in view.tests:
-        data = service.get_nemesis_data(test_id)
-        nemesis_data.extend(data)
-    return {
-        "status": "ok",
-        "response": {"nemesis_data": nemesis_data},
-    }

argus/backend/controller/views_widgets/summary.py

@@ -1,43 +0,0 @@
-from uuid import UUID
-
-from flask import Blueprint, request, g
-
-from argus.backend.models.web import ArgusUserView
-from argus.backend.service.results_service import ResultsService
-from argus.backend.service.user import api_login_required
-from argus.backend.util.common import get_payload
-
-bp = Blueprint("summary", __name__, url_prefix="/widgets")
-
-
-@bp.route("/summary/versioned_runs", methods=["GET"])
-@api_login_required
-def get_versioned_runs():
-    view_id = UUID(request.args.get("view_id"))
-    view: ArgusUserView = ArgusUserView.get(id=view_id)
-    service = ResultsService()
-    versioned_runs = service.get_tests_by_version("scylla-server", view.tests)
-    return {
-        "status": "ok",
-        "response": versioned_runs,
-    }
-
-
-@bp.route("/summary/runs_results", methods=["POST"])
-@api_login_required
-def get_runs_results():
-    versioned_runs = get_payload(request)
-    service = ResultsService()
-    response = {}
-    for test_id, test_methods in versioned_runs.items():
-        response[test_id] = {}
-        for method, run in test_methods.items():
-            response[test_id][method] = {}
-            run_id = run['run_id']
-            response[test_id][method][run_id] = service.get_run_results(UUID(test_id), UUID(run_id), key_metrics=[
-                "P99 read", "P99 write", "duration", "Throughput write", "Throughput read", "allocs_per_op",
-                "cpu_cycles_per_op", "instructions_per_op", "logallocs_per_op"])
-    return {
-        "status": "ok",
-        "response": response,
-    }

argus/backend/db.py

@@ -1,98 +0,0 @@
-from functools import cached_property
-import logging
-from typing import Optional
-from flask import g, Flask
-from cassandra.policies import WhiteListRoundRobinPolicy
-from cassandra import ConsistencyLevel
-from cassandra.cluster import ExecutionProfile, EXEC_PROFILE_DEFAULT, Cluster
-from cassandra.cluster import PreparedStatement
-from cassandra.cqlengine.management import sync_table, sync_type
-from cassandra.cqlengine import connection
-from cassandra.query import dict_factory
-from cassandra.auth import PlainTextAuthProvider
-from argus.backend.util.config import Config
-
-from argus.backend.models.web import USED_MODELS, USED_TYPES
-
-LOGGER = logging.getLogger(__name__)
-
-
-class ScyllaCluster:
-    APP_INSTANCE: Optional['ScyllaCluster'] = None
-
-    def __init__(self, config=None):
-        if not config:
-            config = Config.load_yaml_config()
-        self.config = config
-        self.auth_provider = PlainTextAuthProvider(
-            username=config["SCYLLA_USERNAME"], password=config["SCYLLA_PASSWORD"])
-        self.lb_policy = WhiteListRoundRobinPolicy(hosts=config["SCYLLA_CONTACT_POINTS"])
-        self.execution_profile = ExecutionProfile(
-            load_balancing_policy=self.lb_policy, consistency_level=ConsistencyLevel.QUORUM)
-        connection.setup(hosts=config["SCYLLA_CONTACT_POINTS"], default_keyspace=config["SCYLLA_KEYSPACE_NAME"],
-                         auth_provider=self.auth_provider,
-                         protocol_version=4,
-                         execution_profiles={EXEC_PROFILE_DEFAULT: self.execution_profile})
-        self.cluster: Cluster = connection.get_cluster(connection='default')
-        self.prepared_statements = {}
-        self.read_exec_profile = ExecutionProfile(
-            consistency_level=ConsistencyLevel.ONE,
-            row_factory=dict_factory,
-            load_balancing_policy=self.lb_policy
-        )
-        self.read_named_tuple_exec_profile = ExecutionProfile(
-            consistency_level=ConsistencyLevel.ONE,
-            load_balancing_policy=self.lb_policy
-        )
-        self.cluster.add_execution_profile("read_fast", self.read_exec_profile)
-        self.cluster.add_execution_profile("read_fast_named_tuple", self.read_named_tuple_exec_profile)
-
-    @cached_property
-    def session(self):
-        return self.cluster.connect(keyspace=self.config["SCYLLA_KEYSPACE_NAME"])
-
-    @classmethod
-    def get(cls, config: Config = None) -> 'ScyllaCluster':
-        if cls.APP_INSTANCE:
-            return cls.APP_INSTANCE
-
-        cls.APP_INSTANCE = cls(config)
-        return cls.APP_INSTANCE
-
-    @classmethod
-    def shutdown(cls):
-        if cls.APP_INSTANCE:
-            cls.APP_INSTANCE.cluster.shutdown()
-            cls.APP_INSTANCE = None
-
-    def prepare(self, query: str) -> PreparedStatement:
-        if not (statement := self.prepared_statements.get(query)):
-            LOGGER.info("Unprepared statement %s, preparing...", query)
-            statement = self.session.prepare(query=query)
-            self.prepared_statements[query] = statement
-        return statement
-
-    def sync_core_tables(self):
-        for udt in USED_TYPES:
-            LOGGER.info("Syncing type: %s..", udt.__name__)
-            sync_type(ks_name=self.config["SCYLLA_KEYSPACE_NAME"], type_model=udt)
-        LOGGER.info("Core Types synchronized.")
-        for model in USED_MODELS:
-            LOGGER.info("Syncing model: %s..", model.__name__)
-            sync_table(model, keyspaces=[self.config["SCYLLA_KEYSPACE_NAME"]])
-        LOGGER.info("Core Models synchronized.")
-
-    @classmethod
-    def get_session(cls):
-        cluster = cls.get()
-        if 'scylla_session' not in g:
-            g.scylla_session = cluster.session
-        return g.scylla_session
-
-    @classmethod
-    def close_session(cls, error=None):
-        g.pop("scylla_session", None)
-
-    @classmethod
-    def attach_to_app(cls, app: Flask):
-        app.teardown_appcontext(cls.close_session)

argus/backend/error_handlers.py

@@ -1,41 +0,0 @@
-import base64
-from hashlib import sha256
-import logging
-import os
-from traceback import format_exception
-from flask import request
-
-LOGGER = logging.getLogger(__name__)
-
-
-class APIException(Exception):
-    pass
-
-
-class DataValidationError(APIException):
-    pass
-
-
-def handle_api_exception(exception: Exception):
-    trace_id = base64.encodebytes(sha256(os.urandom(64)).digest()).decode(encoding="utf-8").strip()
-    if issubclass(exception.__class__, APIException):
-        LOGGER.info("[TraceId: %s] Endpoint %s responded with error %s: %s", trace_id,
-                    request.endpoint, exception.__class__.__name__, str(exception))
-        LOGGER.info("[TraceId: %s] Headers\n%s", trace_id, request.headers)
-        LOGGER.info("[TraceId: %s] Request Data Start\n%s\nRequest Data End", trace_id,
-                    request.json if request.is_json else request.get_data(as_text=True))
-    else:
-        LOGGER.error("[TraceId: %s] Exception in %s\n%s", trace_id,
-                     request.endpoint, "".join(format_exception(exception)))
-        LOGGER.error("[TraceId: %s] Headers\n%s", trace_id, request.headers)
-        LOGGER.error("[TraceId: %s] Request Data Start\n%s\nRequest Data End", trace_id,
-                     request.json if request.is_json else request.get_data(as_text=True))
-
-    return {
-        "status": "error",
-        "response": {
-            "trace_id": trace_id,
-            "exception": exception.__class__.__name__,
-            "arguments": exception.args
-        }
-    }

argus/backend/events/event_processors.py

@@ -1,34 +0,0 @@
-from argus.backend.models.web import ArgusEventTypes
-
-
-def event_process_posted_comment(event: dict) -> dict:
-    return event["message"].format(**event)
-
-
-def event_process_status_changed(event: dict) -> dict:
-    return event["message"].format(**event)
-
-
-def event_process_investigation_status_changed(event: dict) -> dict:
-    return event["message"].format(**event)
-
-
-def event_process_assignee_changed(event: dict) -> dict:
-    return event["message"].format(**event)
-
-
-def event_process_issue_added(event: dict) -> dict:
-    return event["message"].format(**event)
-
-
-EVENT_PROCESSORS = {
-    ArgusEventTypes.AssigneeChanged: event_process_assignee_changed,
-    ArgusEventTypes.TestRunStatusChanged: event_process_status_changed,
-    ArgusEventTypes.TestRunCommentPosted: event_process_posted_comment,
-    ArgusEventTypes.TestRunCommentUpdated: event_process_posted_comment,
-    ArgusEventTypes.TestRunCommentDeleted: event_process_posted_comment,
-    ArgusEventTypes.TestRunIssueAdded: event_process_issue_added,
-    ArgusEventTypes.TestRunIssueRemoved: event_process_issue_added,
-    ArgusEventTypes.TestRunInvestigationStatusChanged: event_process_investigation_status_changed,
-    ArgusEventTypes.TestRunBatchInvestigationStatusChange: event_process_investigation_status_changed,
-}