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

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

argus/backend/plugins/driver_matrix_tests/udt.py

@@ -12,12 +12,12 @@ class TestCase(UserType):
 
 class TestSuite(UserType):
     name = columns.Text()
-    tests_total = columns.Integer()
-    failures = columns.Integer()
-    disabled = columns.Integer()
-    skipped = columns.Integer()
-    passed = columns.Integer()
-    errors = columns.Integer()
+    tests_total = columns.Integer(default=lambda: 0)
+    failures = columns.Integer(default=lambda: 0)
+    disabled = columns.Integer(default=lambda: 0)
+    skipped = columns.Integer(default=lambda: 0)
+    passed = columns.Integer(default=lambda: 0)
+    errors = columns.Integer(default=lambda: 0)
     time = columns.Float()
     cases = columns.List(value_type=columns.UserDefinedType(user_type=TestCase))
 
@@ -25,14 +25,15 @@ class TestSuite(UserType):
 class TestCollection(UserType):
     name = columns.Text()
     driver = columns.Text()
-    tests_total = columns.Integer()
-    failures = columns.Integer()
-    disabled = columns.Integer()
-    skipped = columns.Integer()
-    passed = columns.Integer()
-    errors = columns.Integer()
+    tests_total = columns.Integer(default=lambda: 0)
+    failure_message = columns.Text()
+    failures = columns.Integer(default=lambda: 0)
+    disabled = columns.Integer(default=lambda: 0)
+    skipped = columns.Integer(default=lambda: 0)
+    passed = columns.Integer(default=lambda: 0)
+    errors = columns.Integer(default=lambda: 0)
     timestamp = columns.DateTime()
-    time = columns.Float()
+    time = columns.Float(default=lambda: 0.0)
     suites = columns.List(value_type=columns.UserDefinedType(user_type=TestSuite))
 
 

argus/backend/plugins/sct/testrun.py

@@ -1,6 +1,6 @@
 from enum import Enum
 import logging
-from datetime import datetime
+from datetime import datetime, timezone
 from dataclasses import dataclass, field
 from typing import Optional
 from uuid import UUID
@@ -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
@@ -252,8 +254,12 @@ class SCTTestRun(PluginModelBase):
     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()
+        try:
+            scylla_package_upgraded = [package for package in self.packages if package.name == "scylla-server-upgraded"][0]
+        except IndexError:
+            scylla_package_upgraded = None
+        scylla_package = scylla_package_upgraded or [package for package in self.packages if package.name == "scylla-server"][0]
+        return (datetime.strptime(scylla_package.date, '%Y%m%d').replace(tzinfo=timezone.utc).timestamp()
                 + int(scylla_package.revision_id, 16) % 1000000 / 1000000)
 
 

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/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/backend/service/client_service.py

@@ -26,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)
@@ -71,10 +79,20 @@ class ClientService:
 
         return "Finalized"
 
-    def submit_results(self, run_type: str, run_id: str, results: dict) -> str:
+    def submit_results(self, run_type: str, run_id: str, results: dict) -> dict[str, str]:
         model = self.get_model(run_type)
-        run = model.load_test_run(UUID(run_id))
-        ArgusGenericResultMetadata(test_id=run.test_id, **results["meta"]).save()
+        try:
+            run = model.load_test_run(UUID(run_id))
+        except model.DoesNotExist:
+            return {"status": "error", "response": {
+            "exception": "DoesNotExist",
+            "arguments": [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"]
@@ -86,4 +104,4 @@ class ClientService:
                                    sut_timestamp=sut_timestamp,
                                    **cell
                                    ).save()
-        return "Submitted"
+        return {"status": "ok", "message": "Results submitted"}

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/backend/service/results_service.py

@@ -0,0 +1,201 @@
+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[ArgusGenericResultData], 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 point: point["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:
+        if column.type == "TEXT":
+            # skip text columns
+            continue
+        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}]" if column.unit else ""
+        options["scales"]["y"]["min"] = min_y
+        options["scales"]["y"]["max"] = max_y
+        graphs.append({"options": options, "data":
+            {"datasets": datasets}})
+    return graphs
+
+
+def calculate_graph_ticks(graphs: List[Dict]) -> dict[str, str]:
+    min_x, max_x = None, None
+
+    for graph in graphs:
+        for dataset in graph["data"]["datasets"]:
+            if not dataset["data"]:
+                continue
+            first_x = dataset["data"][0]["x"]
+            last_x = dataset["data"][-1]["x"]
+            if min_x is None or first_x < min_x:
+                min_x = first_x
+            if max_x is None or last_x > max_x:
+                max_x = last_x
+    return {"min": min_x[:10], "max": max_x[:10]}
+
+
+class ResultsService:
+    
+    def __init__(self):
+        self.cluster = ScyllaCluster.get()
+    
+    def _get_tables_metadata(self, test_id: UUID) -> list[ArgusGenericResultMetadata]:
+        query_fields = ["name", "description", "columns_meta", "rows_meta"]
+        raw_query = (f"SELECT {','.join(query_fields)}"
+                     f" FROM generic_result_metadata_v1 WHERE test_id = ?")
+        query = self.cluster.prepare(raw_query)
+        tables_meta = self.cluster.session.execute(query=query, parameters=(test_id,))
+        return [ArgusGenericResultMetadata(**table) for table in tables_meta]
+
+    def get_run_results(self, test_id: UUID, run_id: UUID) -> list[dict]:
+        query_fields = ["column", "row", "value", "value_text", "status"]
+        raw_query = (f"SELECT {','.join(query_fields)},WRITETIME(status) as ordering"
+                     f" FROM generic_result_data_v1 WHERE test_id = ? AND run_id = ? AND name = ?")
+        query = self.cluster.prepare(raw_query)
+        tables_meta = self._get_tables_metadata(test_id=test_id)
+        tables = []
+        for table in tables_meta:
+            cells = self.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 get_test_graphs(self, test_id: UUID):
+        query_fields = ["run_id", "column", "row", "value", "status", "sut_timestamp"]
+        raw_query = (f"SELECT {','.join(query_fields)}"
+                     f" FROM generic_result_data_v1 WHERE test_id = ? AND name = ? LIMIT 2147483647")
+        query = self.cluster.prepare(raw_query)
+        tables_meta = self._get_tables_metadata(test_id=test_id)
+        graphs = []
+        for table in tables_meta:
+            data = self.cluster.session.execute(query=query, parameters=(test_id, table.name))
+            data = [ArgusGenericResultData(**cell) for cell in data]
+            if not data:
+                continue
+            graphs.extend(create_chartjs(table, data))
+        ticks = calculate_graph_ticks(graphs)
+        return graphs, ticks
+
+    def is_results_exist(self, test_id: UUID):
+        """Verify if results for given test id exist at all."""
+        return bool(ArgusGenericResultMetadata.objects(test_id=test_id).only(["name"]).limit(1))

argus/backend/service/testrun.py

@@ -13,7 +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, ArgusGenericResultData
+from argus.backend.models.result import ArgusGenericResultMetadata
 
 from argus.backend.models.web import (
     ArgusEvent,
@@ -223,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)
@@ -307,23 +307,6 @@ class TestRunService:
         }
         return response
 
-    def fetch_results(self, test_id: UUID, run_id: UUID) -> dict:
-        query_fields = ["column", "row", "value", "status"]
-        tables_meta = ArgusGenericResultMetadata.filter(test_id=test_id)
-        tables = []
-        for table in tables_meta:
-            cells = ArgusGenericResultData.objects.filter(test_id=test_id, run_id=run_id, name=table.name).only(query_fields)
-            if not cells:
-                continue
-            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]})
-
-        return tables
 
     def submit_github_issue(self, issue_url: str, test_id: UUID, run_id: UUID):
         user_tokens = UserOauthToken.filter(user_id=g.user.id).all()

argus/backend/service/user.py

@@ -17,6 +17,9 @@ from argus.backend.models.web import User, UserOauthToken, UserRoles, WebFileSto
 from argus.backend.util.common import FlaskView
 
 
+class UserServiceException(Exception):
+    pass
+
 class GithubOrganizationMissingError(Exception):
     pass
 
@@ -29,6 +32,8 @@ class UserService:
 
     @staticmethod
     def check_roles(roles: list[UserRoles] | UserRoles, user: User) -> bool:
+        if not user:
+            return False
         if isinstance(roles, str):
             return roles in user.roles
         elif isinstance(roles, list):
@@ -38,6 +43,8 @@ class UserService:
         return False
 
     def github_callback(self, req_code: str) -> dict | None:
+        if "gh" not in current_app.config.get("LOGIN_METHODS", []):
+            raise UserServiceException("Github Login is disabled")
         # pylint: disable=too-many-locals
         oauth_response = requests.post(
             "https://github.com/login/oauth/access_token",
@@ -90,7 +97,10 @@ class UserService:
         except User.DoesNotExist:
             user = User()
             user.username = user_info.get("login")
-            user.email = email_info[-1].get("email")
+            # pick only scylladb.com emails
+            scylla_email = next(iter([email.get("email") for email in email_info if email.get("email").endswith("@scylladb.com")]), None)
+            primary_email = next(iter([email.get("email") for email in email_info if email.get("primary") and email.get("verified")]), None)
+            user.email = scylla_email or primary_email
             user.full_name = user_info.get("name", user_info.get("login"))
             user.registration_date = datetime.utcnow()
             user.roles = ["ROLE_USER"]
@@ -137,6 +147,15 @@ class UserService:
     def get_users(self) -> dict:
         users = User.all()
         return {str(user.id): user.to_json() for user in users}
+    
+    def get_users_privileged(self) -> dict:
+        users = User.all()
+        users = {str(user.id): dict(user.items()) for user in users}
+        for user in users.values():
+            user.pop("password")
+            user.pop("api_token")
+
+        return users
 
     def generate_token(self, user: User):
         token_digest = f"{user.username}-{int(time())}-{base64.encodebytes(os.urandom(128)).decode(encoding='utf-8')}"
@@ -150,13 +169,51 @@ class UserService:
         user.email = new_email
         user.save()
 
-    def update_password(self, user: User, old_password: str, new_password: str):
-        if check_password_hash(user.password, old_password):
-            raise Exception("Incorrect old password")
+        return True
+
+    def toggle_admin(self, user_id: str):
+        user: User = User.get(id=user_id)
+
+        if user.id == g.user.id:
+            raise UserServiceException("Cannot toggle admin role from yourself.")
+
+        is_admin = UserService.check_roles(UserRoles.Admin, user)
+
+        if is_admin:
+            user.roles.remove(UserRoles.Admin)
+        else:
+            user.set_as_admin()
+
+        user.save()
+        return True
+
+    def delete_user(self, user_id: str):
+        user: User = User.get(id=user_id)
+        if user.id == g.user.id:
+            raise UserServiceException("Cannot delete user that you are logged in as.")
+
+        if user.is_admin():
+            raise UserServiceException("Cannot delete admin users. Unset admin flag before deleting")
+
+        user.delete()
+
+        return True
+
+    def update_password(self, user: User, old_password: str, new_password: str, force = False):
+        if not check_password_hash(user.password, old_password) and not force:
+            raise UserServiceException("Incorrect old password")
+
+        if not new_password:
+            raise UserServiceException("Empty new password")
+
+        if len(new_password) < 5:
+            raise UserServiceException("New password is too short")
 
         user.password = generate_password_hash(new_password)
         user.save()
 
+        return True
+
     def update_name(self, user: User, new_name: str):
         user.full_name = new_name
         user.save()

argus/backend/service/views.py

@@ -110,9 +110,9 @@ class UserViewService:
                 search_func = facet_wrapper(query_func=search_func, facet_query=value, facet_type=facet)
 
 
-        all_tests = ArgusTest.all()
-        all_releases = ArgusRelease.all()
-        all_groups = ArgusGroup.all()
+        all_tests = ArgusTest.objects().limit(None)
+        all_releases = ArgusRelease.objects().limit(None)
+        all_groups = ArgusGroup.objects().limit(None)
         release_by_id = {release.id: partial(self.index_mapper, type="release")(release) for release in all_releases}
         group_by_id = {group.id: partial(self.index_mapper, type="group")(group) for group in all_groups}
         index = [self.index_mapper(t) for t in all_tests]

argus/backend/util/config.py

@@ -10,8 +10,10 @@ LOGGER = logging.getLogger(__name__)
 class Config:
     CONFIG = None
     CONFIG_PATHS = [
-        Path("./config/argus_web.yaml"),
+        Path(__file__).parents[3] / "config" / "argus_web.yaml",
         Path("argus_web.yaml"),
+        Path("../config/argus_web.yaml"),
+
     ]
 
     @classmethod

argus/backend/util/encoders.py

@@ -3,6 +3,7 @@ import logging
 from json.encoder import JSONEncoder
 from uuid import UUID
 
+from flask.json.provider import DefaultJSONProvider
 import cassandra.cqlengine.usertype as ut
 import cassandra.cqlengine.models as m
 
@@ -22,3 +23,19 @@ class ArgusJSONEncoder(JSONEncoder):
                 return o.strftime("%Y-%m-%dT%H:%M:%SZ")
             case _:
                 return super().default(o)
+
+
+class ArgusJSONProvider(DefaultJSONProvider):
+
+    def default(self, o):
+        match o:
+            case UUID():
+                return str(o)
+            case ut.UserType():
+                return dict(o.items())
+            case m.Model():
+                return dict(o.items())
+            case datetime():
+                return o.strftime("%Y-%m-%dT%H:%M:%SZ")
+            case _:
+                return super().default(o)