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

argus/backend/plugins/sct/testrun.py

@@ -6,7 +6,7 @@ from typing import Optional
 from uuid import UUID
 
 from cassandra.cqlengine import columns
-from cassandra.cqlengine.models import _DoesNotExist
+from cassandra.cqlengine.models import _DoesNotExist, Model
 from argus.backend.db import ScyllaCluster
 from argus.backend.models.web import ArgusRelease
 from argus.backend.plugins.core import PluginModelBase
@@ -113,7 +113,7 @@ class SCTTestRun(PluginModelBase):
     @classmethod
     def _stats_query(cls) -> str:
         return ("SELECT id, test_id, group_id, release_id, status, start_time, build_job_url, build_id, "
-                f"assignee, end_time, investigation_status, heartbeat, scylla_version FROM {cls.table_name()} WHERE release_id = ?")
+                f"assignee, end_time, investigation_status, heartbeat, scylla_version FROM {cls.table_name()} WHERE build_id IN ? PER PARTITION LIMIT 15")
 
     @classmethod
     def load_test_run(cls, run_id: UUID) -> 'SCTTestRun':
@@ -248,3 +248,9 @@ class SCTTestRun(PluginModelBase):
             self._add_new_event_type(event)
 
         self._collect_event_message(event, event_message)
+
+
+class SCTJunitReports(Model):
+    test_id = columns.UUID(primary_key=True, partition_key=True, required=True)
+    file_name = columns.Text(primary_key=True, required=True)
+    report = columns.Text(required=True)

argus/backend/plugins/sct/types.py

@@ -36,3 +36,21 @@ class PerformanceResultsRequest(TypedDict):
     perf_total_errors: str
 
     histograms: list[dict[str, RawHDRHistogram]] | None
+
+
+class InstanceInfoUpdateRequest(TypedDict):
+    provider: str
+    region: str
+    public_ip: str
+    private_ip: str
+    dc_name: str
+    rack_name: str
+    creation_time: int
+    termination_time: int
+    termination_reason: str
+    shards_amount: int
+
+
+class ResourceUpdateRequest(TypedDict):
+    state: str
+    instance_info: InstanceInfoUpdateRequest

argus/backend/plugins/sct/udt.py

@@ -14,6 +14,12 @@ class PackageVersion(UserType):
     build_id = columns.Text()
 
 
+    def __eq__(self, other):
+        if isinstance(other, PackageVersion):
+            return all(getattr(self, a) == getattr(other, a) for a in ["name", "version", "date", "revision_id", "build_id"])
+        return super().__eq__(other)
+
+
 class CloudInstanceDetails(UserType):
     __type_name__ = "CloudInstanceDetails_v3"
     provider = columns.Text()

argus/backend/plugins/sirenada/model.py

@@ -47,7 +47,7 @@ class SirenadaRun(PluginModelBase):
     @classmethod
     def _stats_query(cls) -> str:
         return ("SELECT id, test_id, group_id, release_id, status, start_time, build_job_url, build_id, "
-                f"assignee, end_time, investigation_status, heartbeat, scylla_version FROM {cls.table_name()} WHERE release_id = ?")
+                f"assignee, end_time, investigation_status, heartbeat, scylla_version FROM {cls.table_name()} WHERE build_id IN ? PER PARTITION LIMIT 15")
 
     @classmethod
     def get_distinct_product_versions(cls, release: ArgusRelease, cluster: ScyllaCluster = None) -> list[str]:

argus/backend/service/argus_service.py

@@ -1,3 +1,5 @@
+from math import ceil
+from dataclasses import dataclass
 import subprocess
 import json
 import logging
@@ -25,9 +27,20 @@ from argus.backend.models.web import (
 )
 from argus.backend.events.event_processors import EVENT_PROCESSORS
 from argus.backend.service.testrun import TestRunService
+from argus.backend.util.common import chunk
 
 LOGGER = logging.getLogger(__name__)
 
+@dataclass(init=True, frozen=True)
+class ScheduleUpdateRequest:
+    release_id: UUID
+    schedule_id: UUID
+    assignee: UUID
+    new_tests: list[UUID]
+    old_tests: list[UUID]
+    comments: dict[UUID, str]
+
+
 
 class ArgusService:
     # pylint: disable=no-self-use,too-many-arguments,too-many-instance-attributes,too-many-locals, too-many-public-methods
@@ -233,7 +246,7 @@ class ArgusService:
                 row.save()
 
     def submit_new_schedule(self, release: str | UUID, start_time: str, end_time: str, tests: list[str | UUID],
-                            groups: list[str | UUID], assignees: list[str | UUID], tag: str) -> dict:
+                            groups: list[str | UUID], assignees: list[str | UUID], tag: str, comments: dict[str, str] | None, group_ids: dict[str, str] | None) -> dict:
         release = UUID(release) if isinstance(release, str) else release
         if len(assignees) == 0:
             raise Exception("Assignees not specified in the new schedule")
@@ -283,6 +296,19 @@ class ArgusService:
             assignee_entity.save()
             response["assignees"].append(assignee_id)
 
+        if comments:
+            for test_id, new_comment in comments.items():
+                try:
+                    comment = ReleasePlannerComment.get(release=release, group=group_ids[test_id], test=test_id)
+                except ReleasePlannerComment.DoesNotExist:
+                    comment = ReleasePlannerComment()
+                    comment.release = release
+                    comment.group = group_ids[test_id]
+                    comment.test = test_id
+
+                comment.comment = new_comment
+                comment.save()
+
         return response
 
     def get_schedules_for_release(self, release_id: str | UUID) -> dict:
@@ -397,11 +423,52 @@ class ArgusService:
             "newComment": new_comment,
         }
 
+    def update_schedule(self, release_id: UUID | str, schedule_id: UUID | str, old_tests: list[UUID | str], new_tests: list[UUID | str], comments: dict[str, str], assignee: UUID | str):
+        schedule: ArgusSchedule = ArgusSchedule.get(release_id=release_id, id=schedule_id)
+        new_tests: set[UUID] = {UUID(id) for id in new_tests}
+        old_tests: set[UUID] = {UUID(id) for id in old_tests}
+
+        all_test_ids = old_tests.union(new_tests)
+        tests = []
+        for batch in chunk(all_test_ids):
+            tests.extend(ArgusTest.filter(id__in=batch).all())
+        tests_by_id: dict[UUID, ArgusTest] = { test.id: test for test in tests }
+
+        all_scheduled_tests: list[ArgusScheduleTest] = list(ArgusScheduleTest.filter(schedule_id=schedule_id).all())
+        tests_to_remove = all_test_ids.difference(new_tests)
+        for scheduled_test in all_scheduled_tests:
+            if scheduled_test.test_id in tests_to_remove:
+                test = tests_by_id.get(scheduled_test.test_id)
+                scheduled_test.delete()
+                if test:
+                    self.update_schedule_comment({"newComment": "", "releaseId": test.release_id, "groupId": test.group_id, "testId": test.id})
+
+        tests_to_add = new_tests.difference(old_tests)
+        for test_id in tests_to_add:
+            entity = ArgusScheduleTest()
+            entity.id = uuid_from_time(schedule.period_start)
+            entity.schedule_id = schedule.id
+            entity.test_id = UUID(test_id) if isinstance(test_id, str) else test_id
+            entity.release_id = release_id
+            entity.save()
+            self.assign_runs_for_scheduled_test(schedule, entity.test_id, assignee)
+
+        for test_id, comment in comments.items():
+            test = tests_by_id.get(UUID(test_id))
+            if test:
+                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()
+        return True
+
     def delete_schedule(self, payload: dict) -> dict:
         """
         {
             "release": hex-uuid,
-            "schedule_id": uuid1
+            "schedule_id": uuid1,
+            "deleteComments": bool
         }
         """
         release_id = payload.get("releaseId")
@@ -412,6 +479,8 @@ class ArgusService:
         if not schedule_id:
             raise Exception("Schedule id not specified in the request")
 
+        delete_comments = payload.get("deleteComments", False)
+
         release = ArgusRelease.get(id=release_id)
         schedule = ArgusSchedule.get(release_id=release.id, id=schedule_id)
         tests = ArgusScheduleTest.filter(schedule_id=schedule.id).all()
@@ -441,6 +510,15 @@ class ArgusService:
                 entity.delete()
 
         schedule.delete()
+
+        if delete_comments:
+            tests = []
+            for batch in chunk(full_schedule["tests"]):
+                tests.extend(ArgusTest.filter(id__in=batch).all())
+
+            for test in tests:
+                self.update_schedule_comment({"newComment": "", "releaseId": test.release_id, "groupId": test.group_id, "testId": test.id})
+
         return {
             "releaseId": release.id,
             "scheduleId": schedule_id,
@@ -480,6 +558,15 @@ class ArgusService:
 
         return response
 
+    def _batch_get_schedules_from_ids(self, release_id: UUID, schedule_ids: list[UUID]) -> list[ArgusSchedule]:
+        schedules = []
+        step_size = 90
+        for step in range(0, ceil(len(schedule_ids) / step_size)):
+            start_pos = step*step_size
+            next_slice = schedule_ids[start_pos:start_pos+step_size]
+            schedules.extend(ArgusSchedule.filter(release_id=release_id, id__in=next_slice).all())
+        return schedules
+
     def get_groups_assignees(self, release_id: UUID | str):
         release_id = UUID(release_id) if isinstance(release_id, str) else release_id
         release = ArgusRelease.get(id=release_id)
@@ -487,10 +574,19 @@ class ArgusService:
         groups = ArgusGroup.filter(release_id=release_id).all()
         group_ids = [group.id for group in groups if group.enabled]
 
-        scheduled_groups = ArgusScheduleGroup.filter(release_id=release.id, group_id__in=group_ids).all()
-        schedule_ids = {schedule.schedule_id for schedule in scheduled_groups}
+        schedule_ids = set()
+        group_schedules =[]
+        step_size = 90
 
-        schedules = ArgusSchedule.filter(release_id=release.id, id__in=tuple(schedule_ids)).all()
+        for step in range(0, ceil(len(group_ids) / step_size)):
+            start_pos = step*step_size
+            next_slice = group_ids[start_pos:start_pos+step_size]
+            group_batch = list(ArgusScheduleGroup.filter(release_id=release.id, group_id__in=next_slice).all())
+            group_schedules.extend(group_batch)
+            batch_ids = {schedule.schedule_id for schedule in group_batch}
+            schedule_ids = schedule_ids.union(batch_ids)
+
+        schedules = self._batch_get_schedules_from_ids(release.id, list(schedule_ids))
 
         valid_schedules = schedules
         if release.perpetual:
@@ -501,7 +597,7 @@ class ArgusService:
         for schedule in valid_schedules:
             assignees = ArgusScheduleAssignee.filter(schedule_id=schedule.id).all()
             assignees_uuids = [assignee.assignee for assignee in assignees]
-            schedule_groups = filter(lambda g: g.schedule_id == schedule.id, scheduled_groups)
+            schedule_groups = filter(lambda g: g.schedule_id == schedule.id, group_schedules)
             groups = {str(group.group_id): assignees_uuids for group in schedule_groups}
             response = {**groups, **response}
 
@@ -516,10 +612,19 @@ class ArgusService:
 
         test_ids = [test.id for test in tests if test.enabled]
 
-        scheduled_tests = ArgusScheduleTest.filter(release_id=release.id, test_id__in=tuple(test_ids)).all()
-        schedule_ids = {test.schedule_id for test in scheduled_tests}
-        schedules: list[ArgusSchedule] = list(ArgusSchedule.filter(
-            release_id=release.id, id__in=tuple(schedule_ids)).all())
+        schedule_ids = set()
+        test_schedules = []
+        step_size = 90
+
+        for step in range(0, ceil(len(test_ids) / step_size)):
+            start_pos = step*step_size
+            next_slice = test_ids[start_pos:start_pos+step_size]
+            test_batch = ArgusScheduleTest.filter(release_id=release.id, test_id__in=next_slice).all()
+            test_schedules.extend(test_batch)
+            batch_ids = {schedule.schedule_id for schedule in test_batch}
+            schedule_ids = schedule_ids.union(batch_ids)
+
+        schedules = self._batch_get_schedules_from_ids(release.id, list(schedule_ids))
 
         if release.perpetual:
             today = datetime.datetime.utcnow()
@@ -529,7 +634,7 @@ class ArgusService:
         for schedule in schedules:
             assignees = ArgusScheduleAssignee.filter(schedule_id=schedule.id).all()
             assignees_uuids = [assignee.assignee for assignee in assignees]
-            schedule_tests = filter(lambda t: t.schedule_id == schedule.id, scheduled_tests)
+            schedule_tests = filter(lambda t: t.schedule_id == schedule.id, test_schedules)
             tests = {str(test.test_id): assignees_uuids for test in schedule_tests}
             response = {**tests, **response}
 

argus/backend/service/build_system_monitor.py

@@ -2,23 +2,28 @@ import logging
 from abc import ABC, abstractmethod
 import jenkins
 import click
+import re
 from flask import current_app
 from flask.cli import with_appcontext
 
 from argus.backend.db import ScyllaCluster
-from argus.backend.models.web import ArgusRelease, ArgusGroup, ArgusTest
+from argus.backend.models.web import ArgusRelease, ArgusGroup, ArgusTest, ArgusTestException
 from argus.backend.service.release_manager import ReleaseManagerService
 
 LOGGER = logging.getLogger(__name__)
 
 
 class ArgusTestsMonitor(ABC):
+    BUILD_SYSTEM_FILTERED_PREFIXES = [
+
+    ]
+
     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._filtered_groups: list[str] = current_app.config["BUILD_SYSTEM_FILTERED_PREFIXES"]
+        self._filtered_groups: list[str] = self.BUILD_SYSTEM_FILTERED_PREFIXES
 
     def create_release(self, release_name):
         # pylint: disable=no-self-use
@@ -68,17 +73,39 @@ class ArgusTestsMonitor(ABC):
 
 
 class JenkinsMonitor(ArgusTestsMonitor):
+
+    BUILD_SYSTEM_FILTERED_PREFIXES = [
+        "releng",
+    ]
+
+    JENKINS_MONITORED_RELEASES = [
+        r"^scylla-master$",
+        r"^scylla-staging$",
+        r"^scylla-\d+\.\d+$",
+        r"^manager-3.\d+$",
+        r"^scylla-operator/operator-master$",
+        r"^scylla-operator/operator-\d+.\d+$",
+        r"^scylla-enterprise$",
+        r"^enterprise-20\d{2}\.\d+$",
+        r"^siren-tests$",
+    ]
+
     def __init__(self) -> None:
         super().__init__()
         self._jenkins = jenkins.Jenkins(url=current_app.config["JENKINS_URL"],
                                         username=current_app.config["JENKINS_USER"],
                                         password=current_app.config["JENKINS_API_TOKEN"])
-        self._monitored_releases = current_app.config["JENKINS_MONITORED_RELEASES"]
+        self._monitored_releases = self.JENKINS_MONITORED_RELEASES
+
+    def _check_release_name(self, release_name: str):
+        return any(re.match(pattern, release_name, re.IGNORECASE) for pattern in self._monitored_releases)
 
     def collect(self):
         click.echo("Collecting new tests from jenkins")
         all_jobs = self._jenkins.get_all_jobs()
-        all_monitored_folders = [job for job in all_jobs if job["fullname"] in self._monitored_releases]
+        all_monitored_folders = [job for job in all_jobs if self._check_release_name(job["fullname"])]
+        LOGGER.info("Will collect %s", [f["fullname"] for f in all_monitored_folders])
+
         for release in all_monitored_folders:
             LOGGER.info("Processing release %s", release["name"])
             try:
@@ -143,9 +170,12 @@ class JenkinsMonitor(ArgusTestsMonitor):
                         except StopIteration:
                             LOGGER.warning("Test %s for release %s (group %s) doesn't exist, creating...",
                                            job["name"], saved_release.name, saved_group.name)
-                            saved_test = self.create_test(
-                                saved_release, saved_group, job["name"], job["fullname"], job["url"])
-                            self._existing_tests.append(saved_test)
+                            try:
+                                saved_test = self.create_test(
+                                    saved_release, saved_group, job["name"], job["fullname"], job["url"])
+                                self._existing_tests.append(saved_test)
+                            except ArgusTestException:
+                                LOGGER.error("Unable to create test for build_id %s", job["fullname"], exc_info=True)
 
     def collect_groups_for_release(self, jobs):
         # pylint: disable=no-self-use

argus/backend/service/jenkins_service.py

@@ -1,12 +1,17 @@
+import re
+import requests
 from typing import Any, TypedDict
+from uuid import UUID
 import xml.etree.ElementTree as ET
 import jenkins
 import logging
 
 from flask import current_app, g
 
-LOGGER = logging.getLogger(__name__)
+from argus.backend.models.web import ArgusGroup, ArgusRelease, ArgusTest, UserOauthToken
 
+LOGGER = logging.getLogger(__name__)
+GITHUB_REPO_RE = r"(?P<http>^https?:\/\/(www\.)?github\.com\/(?P<user>[\w\d\-]+)\/(?P<repo>[\w\d\-]+)(\.git)?$)|(?P<ssh>git@github\.com:(?P<ssh_user>[\w\d\-]+)\/(?P<ssh_repo>[\w\d\-]+)(\.git)?)"
 
 class Parameter(TypedDict):
     _class: str
@@ -15,9 +20,31 @@ class Parameter(TypedDict):
     value: Any
 
 
+class JenkinsServiceError(Exception):
+    pass
+
+
 class JenkinsService:
     RESERVED_PARAMETER_NAME = "requested_by_user"
 
+    SETTINGS_CONFIG_MAP = {
+        "scylla-cluster-tests": {
+            "gitRepo": "*//scm/userRemoteConfigs/hudson.plugins.git.UserRemoteConfig/url",
+            "gitBranch": "*//scm/branches/hudson.plugins.git.BranchSpec/name",
+            "pipelineFile": "*//scriptPath",
+        },
+        "driver-matrix-tests": {
+            "gitRepo": "*//scm/userRemoteConfigs/hudson.plugins.git.UserRemoteConfig/url",
+            "gitBranch": "*//scm/branches/hudson.plugins.git.BranchSpec/name",
+            "pipelineFile": "*//scriptPath",
+        },
+        "sirenada": {
+            "gitRepo": "*//scm/userRemoteConfigs/hudson.plugins.git.UserRemoteConfig/url",
+            "gitBranch": "*//scm/branches/hudson.plugins.git.BranchSpec/name",
+            "pipelineFile": "*//scriptPath",
+        }
+    }
+
     def __init__(self) -> None:
         self._jenkins = jenkins.Jenkins(url=current_app.config["JENKINS_URL"],
                                         username=current_app.config["JENKINS_USER"],
@@ -42,6 +69,154 @@ class JenkinsService:
 
         return params
 
+    def get_releases_for_clone(self, test_id: str):
+        test_id = UUID(test_id)
+        # TODO: Filtering based on origin location / user preferences
+        _: ArgusTest = ArgusTest.get(id=test_id)
+
+        releases = list(ArgusRelease.all())
+
+        return sorted(releases, key=lambda r: r.pretty_name if r.pretty_name else r.name)
+
+    def get_groups_for_release(self, release_id: str):
+        groups = list(ArgusGroup.filter(release_id=release_id).all())
+
+        return sorted(groups, key=lambda g: g.pretty_name if g.pretty_name else g.name)
+
+    def _verify_sct_settings(self, new_settings: dict[str, str]) -> tuple[bool, str]:
+        if not (match := re.match(GITHUB_REPO_RE, new_settings["gitRepo"])):
+            return (False, "Repository doesn't conform to GitHub schema")
+
+        git_info = match.groupdict()
+        if git_info.get("ssh"):
+            repo = git_info["ssh_repo"]
+            user = git_info["ssh_user"]
+        else:
+            repo = git_info["repo"]
+            user = git_info["user"]
+
+        user_tokens = UserOauthToken.filter(user_id=g.user.id).all()
+        token = None
+        for tok in user_tokens:
+            if tok.kind == "github":
+                token = tok.token
+                break
+        if not token:
+            raise JenkinsServiceError("Github token not found")
+
+        response = requests.get(
+            url=f"https://api.github.com/repos/{user}/{repo}/contents/{new_settings['pipelineFile']}?ref={new_settings['gitBranch']}",
+            headers={
+                "Accept": "application/vnd.github+json",
+                "Authorization": f"Bearer {token}",
+            }
+            )
+        
+        if response.status_code == 404:
+            return (False, f"Pipeline file not found in the <a href=\"https://github.com/{user}/{repo}/tree/{new_settings['gitBranch']}\"> target repository</a>, please check the repository before continuing")
+
+        if response.status_code == 403:
+            return (True, "No access to this repository using your token. The pipeline file cannot be verified.")
+
+        if response.status_code == 200:
+            return (True, "")
+
+        return (False, "Generic Error")
+
+    def verify_job_settings(self, build_id: str, new_settings: dict[str, str]) -> tuple[bool, str]:
+        PLUGIN_MAP = {
+            "scylla-cluster-tests": self._verify_sct_settings,
+            # for now they match
+            "sirenada": self._verify_sct_settings,
+            "driver-matrix-tests": self._verify_sct_settings,
+        }
+        test: ArgusTest = ArgusTest.get(build_system_id=build_id)
+        plugin_name = test.plugin_name
+
+        validated, message = PLUGIN_MAP.get(plugin_name, lambda _: (True, ""))(new_settings)
+
+        return {
+            "validated": validated,
+            "message": message,
+        }
+
+    def get_advanced_settings(self, build_id: str):
+        test: ArgusTest = ArgusTest.get(build_system_id=build_id)
+        plugin_name = test.plugin_name
+
+        if not (plugin_settings := self.SETTINGS_CONFIG_MAP.get(plugin_name)):
+            return {}
+
+        settings = {}
+        raw_config = self._jenkins.get_job_config(name=build_id)
+        config = ET.fromstring(raw_config)
+
+        for setting, xpath in plugin_settings.items():
+            value = config.find(xpath)
+            settings[setting] = value.text
+
+        return settings
+
+    def adjust_job_settings(self, build_id: str, plugin_name: str, settings: dict[str, str]):
+        xpath_map = self.SETTINGS_CONFIG_MAP.get(plugin_name)
+        if not xpath_map:
+            return
+        
+        config = self._jenkins.get_job_config(name=build_id)
+        xml = ET.fromstring(config)
+        for setting, value in settings.items():
+            element = xml.find(xpath_map[setting])
+            element.text = value
+
+        adjusted_config = ET.tostring(xml, encoding="unicode")
+        self._jenkins.reconfig_job(name=build_id, config_xml=adjusted_config)
+
+    def clone_job(self, current_test_id: str, new_name: str, target: str, group: str, advanced_settings: bool | dict[str, str]):
+        cloned_test: ArgusTest = ArgusTest.get(id=current_test_id)
+        target_release: ArgusRelease = ArgusRelease.get(id=target)
+        target_group: ArgusGroup = ArgusGroup.get(id=group)
+
+        if target_group.id == cloned_test.id and new_name == cloned_test.name:
+            raise JenkinsServiceError("Unable to clone: source and destination are the same")
+
+        if not target_group.build_system_id:
+            raise JenkinsServiceError("Unable to clone: target group is missing jenkins folder path")
+
+        jenkins_new_build_id = f"{target_group.build_system_id}/{new_name}"
+
+        new_test = ArgusTest()
+        new_test.name = new_name
+        new_test.build_system_id = jenkins_new_build_id
+        new_test.group_id = target_group.id
+        new_test.release_id = target_release.id
+        new_test.plugin_name = cloned_test.plugin_name
+
+        old_config = self._jenkins.get_job_config(name=cloned_test.build_system_id)
+        LOGGER.info(old_config)
+        xml = ET.fromstring(old_config)
+        display_name = xml.find("displayName")
+        if display_name:
+            display_name.text = new_name
+        new_config = ET.tostring(xml, encoding="unicode")
+        self._jenkins.create_job(name=jenkins_new_build_id, config_xml=new_config)
+        new_job_info = self._jenkins.get_job_info(name=jenkins_new_build_id)
+        new_test.build_system_url = new_job_info["url"]
+        new_test.save()
+
+        if advanced_settings:
+            self.adjust_job_settings(build_id=jenkins_new_build_id, plugin_name=new_test.plugin_name, settings=advanced_settings)
+
+        return {
+            "new_job": new_job_info,
+            "new_entity": new_test,
+        }
+
+    def clone_build_job(self, build_id: str, params: dict[str, str]):
+        queue_item = self.build_job(build_id=build_id, params=params)
+        return {
+            "queueItem": queue_item,
+        }
+
     def build_job(self, build_id: str, params: dict, user_override: str = None):
         queue_number = self._jenkins.build_job(build_id, {
             **params,

argus/backend/service/release_manager.py

@@ -44,6 +44,20 @@ class ReleaseManagerService:
     def get_tests(self, group_id: UUID) -> list[ArgusTest]:
         return list(ArgusTest.filter(group_id=group_id).all())
 
+    def toggle_test_enabled(self, test_id: UUID, new_state: bool) -> bool:
+        test: ArgusTest = ArgusTest.get(id=test_id)
+        test.enabled = new_state
+        test.save()
+
+        return test
+
+    def toggle_group_enabled(self, group_id: UUID, new_state: bool) -> bool:
+        test: ArgusGroup = ArgusGroup.get(id=group_id)
+        test.enabled = new_state
+        test.save()
+
+        return test
+
     def create_release(self, release_name: str, pretty_name: str, perpetual: bool) -> ArgusRelease:
         try:
             release = ArgusRelease.get(name=release_name)