Merge pull request #95 from grafana/alexweav/policies

Alerting: Add support for Unified Alerting notification policies

Author: alexweav

alerting_notification_policy.go

@@ -0,0 +1,120 @@
+package gapi
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// Represents a notification routing tree in Grafana Alerting.
+type NotificationPolicy struct {
+	Receiver       string           `json:"receiver,omitempty"`
+	GroupBy        []string         `json:"group_by,omitempty"`
+	Routes         []SpecificPolicy `json:"routes,omitempty"`
+	GroupWait      string           `json:"group_wait,omitempty"`
+	GroupInterval  string           `json:"group_interval,omitempty"`
+	RepeatInterval string           `json:"repeat_interval,omitempty"`
+	Provenance     string           `json:"provenance,omitempty"`
+}
+
+// Represents a non-root node in a notification routing tree.
+type SpecificPolicy struct {
+	Receiver          string           `json:"receiver,omitempty"`
+	GroupBy           []string         `json:"group_by,omitempty"`
+	ObjectMatchers    Matchers         `json:"object_matchers,omitempty"`
+	MuteTimeIntervals []string         `json:"mute_time_intervals,omitempty"`
+	Continue          bool             `json:"continue"`
+	Routes            []SpecificPolicy `json:"routes,omitempty"`
+	GroupWait         string           `json:"group_wait,omitempty"`
+	GroupInterval     string           `json:"group_interval,omitempty"`
+	RepeatInterval    string           `json:"repeat_interval,omitempty"`
+}
+
+type Matchers []Matcher
+
+type Matcher struct {
+	Type  MatchType
+	Name  string
+	Value string
+}
+
+type MatchType int
+
+const (
+	MatchEqual MatchType = iota
+	MatchNotEqual
+	MatchRegexp
+	MatchNotRegexp
+)
+
+func (m MatchType) String() string {
+	typeToStr := map[MatchType]string{
+		MatchEqual:     "=",
+		MatchNotEqual:  "!=",
+		MatchRegexp:    "=~",
+		MatchNotRegexp: "!~",
+	}
+	if str, ok := typeToStr[m]; ok {
+		return str
+	}
+	panic("unknown match type")
+}
+
+// UnmarshalJSON implements the json.Unmarshaler interface for Matchers.
+func (m *Matchers) UnmarshalJSON(data []byte) error {
+	var rawMatchers [][3]string
+	if err := json.Unmarshal(data, &rawMatchers); err != nil {
+		return err
+	}
+	for _, rawMatcher := range rawMatchers {
+		var matchType MatchType
+		switch rawMatcher[1] {
+		case "=":
+			matchType = MatchEqual
+		case "!=":
+			matchType = MatchNotEqual
+		case "=~":
+			matchType = MatchRegexp
+		case "!~":
+			matchType = MatchNotRegexp
+		default:
+			return fmt.Errorf("unsupported match type %q in matcher", rawMatcher[1])
+		}
+
+		matcher := Matcher{
+			Type:  matchType,
+			Name:  rawMatcher[0],
+			Value: rawMatcher[2],
+		}
+		*m = append(*m, matcher)
+	}
+	return nil
+}
+
+// MarshalJSON implements the json.Marshaler interface for Matchers.
+func (m Matchers) MarshalJSON() ([]byte, error) {
+	if len(m) == 0 {
+		return nil, nil
+	}
+	result := make([][3]string, len(m))
+	for i, matcher := range m {
+		result[i] = [3]string{matcher.Name, matcher.Type.String(), matcher.Value}
+	}
+	return json.Marshal(result)
+}
+
+// NotificationPolicy fetches the notification policy tree.
+func (c *Client) NotificationPolicy() (NotificationPolicy, error) {
+	np := NotificationPolicy{}
+	err := c.request("GET", "/api/v1/provisioning/policies", nil, nil, &np)
+	return np, err
+}
+
+// SetNotificationPolicy sets the notification policy tree.
+func (c *Client) SetNotificationPolicy(np *NotificationPolicy) error {
+	req, err := json.Marshal(np)
+	if err != nil {
+		return err
+	}
+	return c.request("PUT", "/api/v1/provisioning/policies", nil, bytes.NewBuffer(req), nil)
+}

alerting_notification_policy_test.go

@@ -0,0 +1,101 @@
+package gapi
+
+import (
+	"testing"
+
+	"github.com/gobs/pretty"
+)
+
+func TestNotificationPolicies(t *testing.T) {
+	t.Run("get policy tree succeeds", func(t *testing.T) {
+		server, client := gapiTestTools(t, 200, notificationPolicyJSON)
+		defer server.Close()
+
+		np, err := client.NotificationPolicy()
+
+		if err != nil {
+			t.Error(err)
+		}
+		t.Log(pretty.PrettyFormat(np))
+		if np.Receiver != "grafana-default-email" {
+			t.Errorf("wrong receiver, got %#v", np.Receiver)
+		}
+		if len(np.Routes) != 1 {
+			t.Errorf("wrong number of routes returned, got %#v", np)
+		}
+	})
+
+	t.Run("set policy tree succeeds", func(t *testing.T) {
+		server, client := gapiTestTools(t, 202, `{"message":"created"}`)
+		defer server.Close()
+		np := createNotificationPolicy()
+
+		err := client.SetNotificationPolicy(&np)
+
+		if err != nil {
+			t.Error(err)
+		}
+	})
+}
+
+func createNotificationPolicy() NotificationPolicy {
+	return NotificationPolicy{
+		Receiver: "grafana-default-email",
+		GroupBy:  []string{"asdfasdf", "alertname"},
+		Routes: []SpecificPolicy{
+			{
+				Receiver: "grafana-default-email",
+				ObjectMatchers: Matchers{
+					{
+						Type:  MatchNotEqual,
+						Name:  "abc",
+						Value: "def",
+					},
+				},
+				Continue: true,
+			},
+			{
+				Receiver: "grafana-default-email",
+				ObjectMatchers: Matchers{
+					{
+						Type:  MatchRegexp,
+						Name:  "jkl",
+						Value: "something.*",
+					},
+				},
+				Continue: false,
+			},
+		},
+		GroupWait:      "10s",
+		GroupInterval:  "5m",
+		RepeatInterval: "4h",
+	}
+}
+
+const notificationPolicyJSON = `
+{
+	"receiver": "grafana-default-email",
+	"group_by": [
+		"..."
+	],
+	"routes": [
+		{
+			"receiver": "grafana-default-email",
+			"object_matchers": [
+				[
+					"a",
+					"=",
+					"b"
+				],
+				[
+					"asdf",
+					"!=",
+					"jk"
+				]
+			]
+		}
+	],
+	"group_wait": "5s",
+	"group_interval": "1m",
+	"repeat_interval": "1h"
+}`