argus-alm 0.12.4b2__tar.gz → 0.12.7__tar.gz

{argus_alm-0.12.4b2 → argus_alm-0.12.7}/PKG-INFO

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

{argus_alm-0.12.4b2 → argus_alm-0.12.7}/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.4b2 → argus_alm-0.12.7}/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_alm-0.12.4b2 → argus_alm-0.12.7}/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.4b2 → argus_alm-0.12.7}/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
@@ -90,3 +99,14 @@ def run_finalize(run_type: str, run_id: str):
         "status": "ok",
         "response": result
     }
+
+
+@bp.route("/testrun/<string:run_type>/<string:run_id>/submit_results", methods=["POST"])
+@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
+    }

{argus_alm-0.12.4b2 → argus_alm-0.12.7}/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.4b2 → argus_alm-0.12.7}/argus/backend/controller/testrun_api.py

@@ -63,6 +63,17 @@ 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))
+    return {
+        "status": "ok",
+        "tables": tables
+    }
+
+
 @bp.route("/test/<string:test_id>/run/<string:run_id>/status/set", methods=["POST"])
 @api_login_required
 def set_testrun_status(test_id: str, run_id: str):

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

@@ -0,0 +1,63 @@
+from cassandra.cqlengine import columns
+from cassandra.cqlengine.models import Model
+from cassandra.cqlengine.usertype import UserType
+from enum import Enum
+
+
+class Status(Enum):
+    PASS = 0
+    WARNING = 1
+    ERROR = 2
+
+
+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))
+    rows_meta = columns.List(value_type=columns.Ascii())
+
+    def __init__(self, **kwargs):
+        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"
+    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()
+    status = columns.Ascii()

{argus_alm-0.12.4b2 → argus_alm-0.12.7}/argus/backend/models/web.py

@@ -6,6 +6,8 @@ from cassandra.cqlengine.usertype import UserType
 from cassandra.cqlengine import columns
 from cassandra.util import uuid_from_time, unix_time_from_uuid1  # pylint: disable=no-name-in-module
 
+from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData
+
 
 def uuid_now():
     return uuid_from_time(datetime.utcnow())
@@ -377,6 +379,8 @@ USED_MODELS: list[Model] = [
     ArgusScheduleAssignee,
     ArgusScheduleGroup,
     ArgusScheduleTest,
+    ArgusGenericResultMetadata,
+    ArgusGenericResultData,
 ]
 
 USED_TYPES: list[UserType] = [

{argus_alm-0.12.4b2 → argus_alm-0.12.7}/argus/backend/plugins/core.py

@@ -105,16 +105,16 @@ class PluginModelBase(Model):
             assignees = ArgusScheduleAssignee.filter(
                 schedule_id=schedule.id
             ).all()
-            assignees_uuids.append(*[assignee.assignee for assignee in assignees])
+            assignees_uuids.extend([assignee.assignee for assignee in assignees])
 
         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)
 
@@ -213,6 +213,8 @@ class PluginModelBase(Model):
     def finish_run(self, payload: dict = None):
         raise NotImplementedError()
 
+    def sut_timestamp(self) -> float:
+        raise NotImplementedError()
 
 class PluginInfoBase:
     # pylint: disable=too-few-public-methods

{argus_alm-0.12.4b2 → argus_alm-0.12.7}/argus/backend/plugins/sct/testrun.py

@@ -109,6 +109,7 @@ class SCTTestRun(PluginModelBase):
     stress_cmd = columns.Text()
 
     histograms = columns.List(value_type=columns.Map(key_type=columns.Text(), value_type=columns.UserDefinedType(user_type=PerformanceHDRHistogram)))
+    test_method = columns.Ascii()
 
     @classmethod
     def _stats_query(cls) -> str:
@@ -199,6 +200,7 @@ class SCTTestRun(PluginModelBase):
 
             run.config_files = req.sct_config.get("config_files")
             run.region_name = regions
+            run.test_method = req.sct_config.get("test_method")
             run.save()
 
         return run
@@ -249,6 +251,13 @@ class SCTTestRun(PluginModelBase):
 
         self._collect_event_message(event, event_message)
 
+    def sut_timestamp(self) -> float:
+        """converts scylla-server date to timestamp and adds revision in subseconds precision to diffirentiate
+        scylla versions from the same day. It's not perfect, but we don't know exact version time."""
+        scylla_package = [package for package in self.packages if package.name == "scylla-server"][0]
+        return (datetime.strptime(scylla_package.date, '%Y%m%d').timestamp()
+                + int(scylla_package.revision_id, 16) % 1000000 / 1000000)
+
 
 class SCTJunitReports(Model):
     test_id = columns.UUID(primary_key=True, partition_key=True, required=True)

{argus_alm-0.12.4b2 → argus_alm-0.12.7}/argus/backend/service/argus_service.py

@@ -459,8 +459,13 @@ class ArgusService:
                 self.update_schedule_comment({"newComment": comment, "releaseId": test.release_id, "groupId": test.group_id, "testId": test.id})
 
         schedule_assignee: ArgusScheduleAssignee = ArgusScheduleAssignee.get(schedule_id=schedule_id)
-        schedule_assignee.assignee = assignee
-        schedule_assignee.save()
+        new_assignee = ArgusScheduleAssignee()
+        new_assignee.assignee = assignee
+        new_assignee.release_id = schedule_assignee.release_id
+        new_assignee.schedule_id = schedule_assignee.schedule_id
+        new_assignee.save()
+        schedule_assignee.delete()
+
         return True
 
     def delete_schedule(self, payload: dict) -> dict:
@@ -493,11 +498,16 @@ class ArgusService:
         full_schedule["assignees"] = [assignee.assignee for assignee in assignees]
 
         if len(assignees) > 0:
-            schedule_user = User.get(id=assignees[0].assignee)
+            try:
+                schedule_user = User.get(id=assignees[0].assignee)
+            except User.DoesNotExist:
+                schedule_user = User()
+                schedule_user.id = assignees[0].assignee
+                LOGGER.warning("Deleting orphaned user assignments")
             service = TestRunService()
 
             for model in all_plugin_models():
-                for run in model.get_jobs_assigned_to_user(schedule_user):
+                for run in model.get_jobs_assigned_to_user(schedule_user.id):
                     if run["release_id"] != release.id:
                         continue
                     if run["test_id"] not in full_schedule["tests"]:
@@ -644,7 +654,7 @@ class ArgusService:
         today = datetime.datetime.now()
         validity_period = today - datetime.timedelta(days=current_app.config.get("JOB_VALIDITY_PERIOD_DAYS", 30))
         for plugin in all_plugin_models():
-            for run in plugin.get_jobs_assigned_to_user(user=user):
+            for run in plugin.get_jobs_assigned_to_user(user_id=user.id):
                 if run["start_time"] >= validity_period:
                     yield run
 

{argus_alm-0.12.4b2 → argus_alm-0.12.7}/argus/backend/service/build_system_monitor.py

@@ -20,9 +20,9 @@ class ArgusTestsMonitor(ABC):
 
     def __init__(self) -> None:
         self._cluster = ScyllaCluster.get()
-        self._existing_releases = list(ArgusRelease.all())
-        self._existing_groups = list(ArgusGroup.all())
-        self._existing_tests = list(ArgusTest.all())
+        self._existing_releases = list(ArgusRelease.objects().limit(None))
+        self._existing_groups = list(ArgusGroup.objects().limit(None))
+        self._existing_tests = list(ArgusTest.objects().limit(None))
         self._filtered_groups: list[str] = self.BUILD_SYSTEM_FILTERED_PREFIXES
 
     def create_release(self, release_name):

{argus_alm-0.12.4b2 → argus_alm-0.12.7}/argus/backend/service/client_service.py

@@ -1,5 +1,6 @@
 from uuid import UUID
 from argus.backend.db import ScyllaCluster
+from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData
 from argus.backend.plugins.core import PluginModelBase
 from argus.backend.plugins.loader import AVAILABLE_PLUGINS
 from argus.backend.util.enums import TestStatus
@@ -25,6 +26,14 @@ class ClientService:
         model = self.get_model(run_type)
         model.submit_run(request_data=request_data)
         return "Created"
+    
+    def get_run(self, run_type: str, run_id: str):
+        model = self.get_model(run_type)
+        try:
+            run = model.get(id=run_id)
+        except model.DoesNotExist:
+            return None
+        return run
 
     def heartbeat(self, run_type: str, run_id: str) -> int:
         model = self.get_model(run_type)
@@ -69,3 +78,24 @@ class ClientService:
         run.save()
 
         return "Finalized"
+
+    def submit_results(self, run_type: str, run_id: str, results: dict) -> str:
+        model = self.get_model(run_type)
+        run = model.load_test_run(UUID(run_id))
+        existing_table = ArgusGenericResultMetadata.objects(test_id=run.test_id, name=results["meta"]["name"]).first()
+        if existing_table:
+            existing_table.update_if_changed(results["meta"])
+        else:
+            ArgusGenericResultMetadata(test_id=run.test_id, **results["meta"]).save()
+        if results.get("sut_timestamp", 0) == 0:
+            results["sut_timestamp"] = run.sut_timestamp()  # automatic sut_timestamp
+        table_name = results["meta"]["name"]
+        sut_timestamp = results["sut_timestamp"]
+        for cell in results["results"]:
+            ArgusGenericResultData(test_id=run.test_id,
+                                   run_id=run.id,
+                                   name=table_name,
+                                   sut_timestamp=sut_timestamp,
+                                   **cell
+                                   ).save()
+        return "Submitted"

{argus_alm-0.12.4b2 → argus_alm-0.12.7}/argus/backend/service/jenkins_service.py

@@ -220,7 +220,9 @@ class JenkinsService:
     def build_job(self, build_id: str, params: dict, user_override: str = None):
         queue_number = self._jenkins.build_job(build_id, {
             **params,
-            self.RESERVED_PARAMETER_NAME: g.user.username if not user_override else user_override
+            # use the user's email as the default value for the requested by user parameter,
+            # so it would align with how SCT default works, on runs not trigger by argus
+            self.RESERVED_PARAMETER_NAME: g.user.email.split('@')[0] if not user_override else user_override
         })
         return queue_number
 

argus_alm-0.12.7/argus/backend/service/results_service.py

@@ -0,0 +1,140 @@
+import copy
+import logging
+import math
+from typing import List, Dict, Any
+from uuid import UUID
+
+from argus.backend.db import ScyllaCluster
+from argus.backend.models.result import ArgusGenericResultMetadata, ArgusGenericResultData
+
+LOGGER = logging.getLogger(__name__)
+
+default_options = {
+    "scales": {
+        "y": {
+            "beginAtZero": True,
+            "title": {
+                "display": True,
+                "text": ''
+            }
+        },
+        "x": {
+            "type": "time",
+            "time": {
+                "unit": "day",
+                "displayFormats": {
+                    "day": "yyyy-MM-dd",
+                },
+            },
+            "title": {
+                "display": True,
+                "text": 'SUT Date'
+            }
+        },
+    },
+    "elements": {
+        "line": {
+            "tension": .1,
+        }
+    },
+    "plugins": {
+        "legend": {
+            "position": 'top',
+        },
+        "title": {
+            "display": True,
+            "text": ''
+        }
+    }
+}
+
+colors = [
+    'rgba(255, 0, 0, 1.0)',  # Red
+    'rgba(0, 255, 0, 1.0)',  # Green
+    'rgba(0, 0, 255, 1.0)',  # Blue
+    'rgba(0, 255, 255, 1.0)',  # Cyan
+    'rgba(255, 0, 255, 1.0)',  # Magenta
+    'rgba(255, 255, 0, 1.0)',  # Yellow
+    'rgba(255, 165, 0, 1.0)',  # Orange
+    'rgba(128, 0, 128, 1.0)',  # Purple
+    'rgba(50, 205, 50, 1.0)',  # Lime
+    'rgba(255, 192, 203, 1.0)',  # Pink
+    'rgba(0, 128, 128, 1.0)',  # Teal
+    'rgba(165, 42, 42, 1.0)',  # Brown
+    'rgba(0, 0, 128, 1.0)',  # Navy
+    'rgba(128, 128, 0, 1.0)',  # Olive
+    'rgba(255, 127, 80, 1.0)'  # Coral
+]
+
+
+def get_sorted_data_for_column_and_row(data: List[Dict[str, Any]], column: str, row: str) -> List[Dict[str, Any]]:
+    return sorted([{"x": entry.sut_timestamp.strftime('%Y-%m-%dT%H:%M:%SZ'),
+                    "y": entry.value,
+                    "id": entry.run_id}
+                   for entry in data if entry['column'] == column and entry['row'] == row],
+                  key=lambda x: x['x'])
+
+
+def get_min_max_y(datasets: List[Dict[str, Any]]) -> (float, float):
+    """0.5 - 1.5 of min/max of 50% results"""
+    y = [entry['y'] for dataset in datasets for entry in dataset['data']]
+    if not y:
+        return 0, 0
+    sorted_y = sorted(y)
+    lower_percentile_index = int(0.25 * len(sorted_y))
+    upper_percentile_index = int(0.75 * len(sorted_y)) - 1
+    y_min = sorted_y[lower_percentile_index]
+    y_max = sorted_y[upper_percentile_index]
+    return math.floor(0.5 * y_min), math.ceil(1.5 * y_max)
+
+
+def round_datasets_to_min_max(datasets: List[Dict[str, Any]], min_y: float, max_y: float) -> List[Dict[str, Any]]:
+    """Round values to min/max and provide original value for tooltip"""
+    for dataset in datasets:
+        for entry in dataset['data']:
+            val = entry['y']
+            if val > max_y:
+                entry['y'] = max_y
+                entry['ori'] = val
+            elif val < min_y:
+                entry['y'] = min_y
+                entry['ori'] = val
+    return datasets
+
+
+def create_chartjs(table, data):
+    graphs = []
+    for column in table.columns_meta:
+        datasets = [
+            {"label": row,
+             "borderColor": colors[idx % len(colors)],
+             "borderWidth": 3,
+             "showLine": True,
+             "data": get_sorted_data_for_column_and_row(data, column.name, row)} for idx, row in enumerate(table.rows_meta)]
+        min_y, max_y = get_min_max_y(datasets)
+        datasets = round_datasets_to_min_max(datasets, min_y, max_y)
+        if not min_y + max_y:
+            # filter out those without data
+            continue
+        options = copy.deepcopy(default_options)
+        options["plugins"]["title"]["text"] = f"{table.name} - {column.name}"
+        options["scales"]["y"]["title"]["text"] = f"[{column.unit}]"
+        options["scales"]["y"]["min"] = min_y
+        options["scales"]["y"]["max"] = max_y
+        graphs.append({"options": options, "data":
+            {"datasets": datasets}})
+    return graphs
+
+
+class ResultsService:
+
+    def __init__(self, database_session=None):
+        self.session = database_session if database_session else ScyllaCluster.get_session()
+
+    def get_results(self, test_id: UUID):
+        graphs = []
+        res = ArgusGenericResultMetadata.objects(test_id=test_id).all()
+        for table in res:
+            data = ArgusGenericResultData.objects(test_id=test_id, name=table.name).all()
+            graphs.extend(create_chartjs(table, data))
+        return graphs

{argus_alm-0.12.4b2 → argus_alm-0.12.7}/argus/backend/service/testrun.py

@@ -13,6 +13,7 @@ from flask import g
 from cassandra.query import BatchStatement, ConsistencyLevel
 from cassandra.cqlengine.query import BatchQuery
 from argus.backend.db import ScyllaCluster
+from argus.backend.models.result import ArgusGenericResultMetadata
 
 from argus.backend.models.web import (
     ArgusEvent,
@@ -222,7 +223,7 @@ class TestRunService:
         mentions = set(mentions)
         for potential_mention in re.findall(self.RE_MENTION, message_stripped):
             if user := User.exists_by_name(potential_mention.lstrip("@")):
-                mentions.add(user)
+                mentions.add(user) if user.id != g.user.id else None
 
         test: ArgusTest = ArgusTest.get(id=test_id)
         plugin = self.get_plugin(test.plugin_name)
@@ -306,6 +307,29 @@ class TestRunService:
         }
         return response
 
+    def fetch_results(self, test_id: UUID, run_id: UUID) -> list[dict]:
+        cluster = ScyllaCluster.get()
+        query_fields = ["column", "row", "value", "status"]
+        raw_query = (f"SELECT {','.join(query_fields)},WRITETIME(value) as ordering "
+                     f"FROM generic_result_data_v1 WHERE test_id = ? AND run_id = ? AND name = ?")
+        query = cluster.prepare(raw_query)
+        tables_meta = ArgusGenericResultMetadata.filter(test_id=test_id)
+        tables = []
+        for table in tables_meta:
+            cells = cluster.session.execute(query=query, parameters=(test_id, run_id, table.name))
+            if not cells:
+                continue
+            cells = [dict(cell.items()) for cell in cells]
+            tables.append({'meta': {
+                'name': table.name,
+                'description': table.description,
+                'columns_meta': table.columns_meta,
+                'rows_meta': table.rows_meta,
+            },
+                'cells': [{k: v for k, v in cell.items() if k in query_fields} for cell in cells],
+                'order': min([cell['ordering'] for cell in cells] or [0])})
+        return sorted(tables, key=lambda x: x['order'])
+
     def submit_github_issue(self, issue_url: str, test_id: UUID, run_id: UUID):
         user_tokens = UserOauthToken.filter(user_id=g.user.id).all()
         token = None