management: add CRD support and create alert rule API

Add AlertingRule, AlertRelabelConfig, and
RelabeledRules CRD interfaces with the
management client, router, server wiring,
and POST /api/v1/alerting/rules endpoint.

Signed-off-by: Shirly Radco <sradco@redhat.com>
Signed-off-by: João Vilaça <jvilaca@redhat.com>
Signed-off-by: Aviv Litman <alitman@redhat.com>
Co-authored-by: AI Assistant <noreply@cursor.com>

Author: sradco

Makefile

@@ -41,7 +41,7 @@ lint-frontend:
 lint-backend:
 	go mod tidy
 	go fmt ./cmd/
-	go fmt ./pkg/
+	go fmt ./pkg/... ./internal/...
 
 .PHONY: install-backend
 install-backend:
@@ -57,7 +57,11 @@ start-backend:
 
 .PHONY: test-backend
 test-backend:
-	go test ./pkg/... -v
+	go test ./pkg/... ./internal/... -v
+
+.PHONY: test-e2e
+test-e2e:
+	PLUGIN_URL=http://localhost:9001 go test -v -timeout=150m -count=1 ./test/e2e
 
 .PHONY: build-image
 build-image:

internal/managementrouter/create_alert_rule.go

@@ -0,0 +1,54 @@
+package managementrouter
+
+import (
+	"encoding/json"
+	"net/http"
+
+	monitoringv1 "github.com/prometheus-operator/prometheus-operator/pkg/apis/monitoring/v1"
+
+	"github.com/openshift/monitoring-plugin/pkg/management"
+)
+
+type CreateAlertRuleRequest struct {
+	AlertingRule   *monitoringv1.Rule                `json:"alertingRule,omitempty"`
+	PrometheusRule *management.PrometheusRuleOptions `json:"prometheusRule,omitempty"`
+}
+
+type CreateAlertRuleResponse struct {
+	Id string `json:"id"`
+}
+
+func (hr *httpRouter) CreateAlertRule(w http.ResponseWriter, req *http.Request) {
+	var payload CreateAlertRuleRequest
+	if err := json.NewDecoder(req.Body).Decode(&payload); err != nil {
+		writeError(w, http.StatusBadRequest, "invalid request body")
+		return
+	}
+
+	if payload.AlertingRule == nil {
+		writeError(w, http.StatusBadRequest, "alertingRule is required")
+		return
+	}
+
+	alertRule := *payload.AlertingRule
+
+	var (
+		id  string
+		err error
+	)
+
+	if payload.PrometheusRule != nil {
+		id, err = hr.managementClient.CreateUserDefinedAlertRule(req.Context(), alertRule, *payload.PrometheusRule)
+	} else {
+		id, err = hr.managementClient.CreatePlatformAlertRule(req.Context(), alertRule)
+	}
+
+	if err != nil {
+		handleError(w, err)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusCreated)
+	_ = json.NewEncoder(w).Encode(CreateAlertRuleResponse{Id: id})
+}

internal/managementrouter/create_alert_rule_test.go

@@ -0,0 +1,212 @@
+package managementrouter_test
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+
+	monitoringv1 "github.com/prometheus-operator/prometheus-operator/pkg/apis/monitoring/v1"
+
+	"github.com/openshift/monitoring-plugin/internal/managementrouter"
+	"github.com/openshift/monitoring-plugin/pkg/k8s"
+	"github.com/openshift/monitoring-plugin/pkg/management"
+	"github.com/openshift/monitoring-plugin/pkg/management/testutils"
+)
+
+var _ = Describe("CreateAlertRule", func() {
+	var (
+		router       http.Handler
+		mockK8sRules *testutils.MockPrometheusRuleInterface
+		mockARules   *testutils.MockAlertingRuleInterface
+		mockK8s      *testutils.MockClient
+	)
+
+	BeforeEach(func() {
+		mockK8sRules = &testutils.MockPrometheusRuleInterface{}
+		mockARules = &testutils.MockAlertingRuleInterface{}
+		mockK8s = &testutils.MockClient{
+			PrometheusRulesFunc: func() k8s.PrometheusRuleInterface {
+				return mockK8sRules
+			},
+			AlertingRulesFunc: func() k8s.AlertingRuleInterface {
+				return mockARules
+			},
+			NamespaceFunc: func() k8s.NamespaceInterface {
+				return &testutils.MockNamespaceInterface{
+					IsClusterMonitoringNamespaceFunc: func(name string) bool {
+						return false
+					},
+				}
+			},
+		}
+	})
+
+	Context("create new user defined alert rule", func() {
+		It("creates a new rule", func() {
+			mgmt := management.New(context.Background(), mockK8s)
+			router = managementrouter.New(mgmt)
+
+			body := map[string]interface{}{
+				"alertingRule": map[string]interface{}{
+					"alert":       "cpuHigh",
+					"expr":        "vector(1)",
+					"for":         "5m",
+					"labels":      map[string]string{"severity": "warning"},
+					"annotations": map[string]string{"summary": "cpu high"},
+				},
+				"prometheusRule": map[string]interface{}{
+					"prometheusRuleName":      "user-pr",
+					"prometheusRuleNamespace": "default",
+				},
+			}
+			buf, _ := json.Marshal(body)
+
+			req := httptest.NewRequest(http.MethodPost, "/api/v1/alerting/rules", bytes.NewReader(buf))
+			req.Header.Set("Content-Type", "application/json")
+			w := httptest.NewRecorder()
+			router.ServeHTTP(w, req)
+
+			Expect(w.Code).To(Equal(http.StatusCreated))
+			var resp struct {
+				Id string `json:"id"`
+			}
+			Expect(json.NewDecoder(w.Body).Decode(&resp)).To(Succeed())
+			Expect(resp.Id).NotTo(BeEmpty())
+
+			pr, found, err := mockK8sRules.Get(context.Background(), "default", "user-pr")
+			Expect(err).NotTo(HaveOccurred())
+			Expect(found).To(BeTrue())
+			allAlerts := []string{}
+			for _, g := range pr.Spec.Groups {
+				for _, r := range g.Rules {
+					allAlerts = append(allAlerts, r.Alert)
+				}
+			}
+			Expect(allAlerts).To(ContainElement("cpuHigh"))
+		})
+
+		It("creates a new rule into a non-default group when groupName is provided", func() {
+			mgmt := management.New(context.Background(), mockK8s)
+			router = managementrouter.New(mgmt)
+
+			body := map[string]interface{}{
+				"alertingRule": map[string]interface{}{
+					"alert": "cpuCustomGroup",
+					"expr":  "vector(1)",
+				},
+				"prometheusRule": map[string]interface{}{
+					"prometheusRuleName":      "user-pr",
+					"prometheusRuleNamespace": "default",
+					"groupName":               "custom-group",
+				},
+			}
+			buf, _ := json.Marshal(body)
+
+			req := httptest.NewRequest(http.MethodPost, "/api/v1/alerting/rules", bytes.NewReader(buf))
+			req.Header.Set("Content-Type", "application/json")
+			w := httptest.NewRecorder()
+			router.ServeHTTP(w, req)
+
+			Expect(w.Code).To(Equal(http.StatusCreated))
+
+			pr, found, err := mockK8sRules.Get(context.Background(), "default", "user-pr")
+			Expect(err).NotTo(HaveOccurred())
+			Expect(found).To(BeTrue())
+
+			var grp *monitoringv1.RuleGroup
+			for i := range pr.Spec.Groups {
+				if pr.Spec.Groups[i].Name == "custom-group" {
+					grp = &pr.Spec.Groups[i]
+					break
+				}
+			}
+			Expect(grp).NotTo(BeNil())
+			alerts := []string{}
+			for _, r := range grp.Rules {
+				alerts = append(alerts, r.Alert)
+			}
+			Expect(alerts).To(ContainElement("cpuCustomGroup"))
+		})
+	})
+
+	Context("invalid JSON body", func() {
+		It("fails for invalid JSON", func() {
+			mgmt := management.New(context.Background(), mockK8s)
+			router = managementrouter.New(mgmt)
+
+			req := httptest.NewRequest(http.MethodPost, "/api/v1/alerting/rules", bytes.NewBufferString("{"))
+			req.Header.Set("Content-Type", "application/json")
+			w := httptest.NewRecorder()
+			router.ServeHTTP(w, req)
+
+			Expect(w.Code).To(Equal(http.StatusBadRequest))
+			Expect(w.Body.String()).To(ContainSubstring("invalid request body"))
+		})
+	})
+
+	Context("missing target PrometheusRule (name/namespace)", func() {
+		It("fails for missing target PR", func() {
+			mgmt := management.New(context.Background(), mockK8s)
+			router = managementrouter.New(mgmt)
+
+			body := map[string]interface{}{
+				"alertingRule": map[string]interface{}{
+					"alert": "x",
+					"expr":  "vector(1)",
+				},
+				"prometheusRule": map[string]interface{}{
+					// missing PR name/namespace
+				},
+			}
+			buf, _ := json.Marshal(body)
+
+			req := httptest.NewRequest(http.MethodPost, "/api/v1/alerting/rules", bytes.NewReader(buf))
+			req.Header.Set("Content-Type", "application/json")
+			w := httptest.NewRecorder()
+			router.ServeHTTP(w, req)
+
+			Expect(w.Code).To(Equal(http.StatusBadRequest))
+			Expect(w.Body.String()).To(ContainSubstring("PrometheusRule Name and Namespace must be specified"))
+		})
+	})
+
+	Context("target is platform-managed PR", func() {
+		It("rejects with MethodNotAllowed", func() {
+			mockNamespace := &testutils.MockNamespaceInterface{
+				IsClusterMonitoringNamespaceFunc: func(name string) bool {
+					return name == "openshift-monitoring"
+				},
+			}
+			mockK8s.NamespaceFunc = func() k8s.NamespaceInterface {
+				return mockNamespace
+			}
+			mgmt := management.New(context.Background(), mockK8s)
+			router = managementrouter.New(mgmt)
+
+			body := map[string]interface{}{
+				"alertingRule": map[string]interface{}{
+					"alert": "x",
+					"expr":  "vector(1)",
+				},
+				"prometheusRule": map[string]interface{}{
+					"prometheusRuleName":      "platform-pr",
+					"prometheusRuleNamespace": "openshift-monitoring",
+				},
+			}
+			buf, _ := json.Marshal(body)
+
+			req := httptest.NewRequest(http.MethodPost, "/api/v1/alerting/rules", bytes.NewReader(buf))
+			req.Header.Set("Content-Type", "application/json")
+			w := httptest.NewRecorder()
+			router.ServeHTTP(w, req)
+
+			Expect(w.Code).To(Equal(http.StatusMethodNotAllowed))
+			Expect(w.Body.String()).To(ContainSubstring("cannot add user-defined alert rule to a platform-managed PrometheusRule"))
+		})
+	})
+})

internal/managementrouter/managementrouter_suite_test.go

@@ -0,0 +1,13 @@
+package managementrouter_test
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestHTTPRouter(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "HTTPRouter Suite")
+}

internal/managementrouter/query_filters.go

@@ -0,0 +1,35 @@
+package managementrouter
+
+import (
+	"fmt"
+	"net/url"
+	"strings"
+)
+
+var validStates = map[string]bool{
+	"":         true,
+	"pending":  true,
+	"firing":   true,
+	"silenced": true,
+}
+
+// parseStateAndLabels returns the optional state filter and label matches.
+// Any query param other than "state" is treated as a label match.
+// Returns an error if the state value is not one of the known states.
+func parseStateAndLabels(q url.Values) (string, map[string]string, error) {
+	state := strings.ToLower(strings.TrimSpace(q.Get("state")))
+	if !validStates[state] {
+		return "", nil, fmt.Errorf("invalid state filter %q: must be one of pending, firing, silenced", q.Get("state"))
+	}
+
+	labels := make(map[string]string)
+	for key, vals := range q {
+		if key == "state" {
+			continue
+		}
+		if len(vals) > 0 && strings.TrimSpace(vals[0]) != "" {
+			labels[strings.TrimSpace(key)] = strings.TrimSpace(vals[0])
+		}
+	}
+	return state, labels, nil
+}