Merge pull request #1 from cmaster11/freeform-rules

Freeform rules

Author: cmaster11

.gitignore

@@ -1,2 +1 @@
-.idea
-config.yaml
+.idea

README.md

@@ -0,0 +1,60 @@
+# k8s-event-watcher
+
+This library lets you watch for Kubernetes events, and triggers a callback whenever one matching the criteria is found.
+
+An example of configuration is:
+
+```yaml
+sinceNow: true
+filters:
+- rules:
+    involvedObject.kind: Job
+    involvedObject.name: "^*.fail"
+    reason: BackoffLimitExceeded
+```
+
+This would match a `Job`-failed `Event`:
+
+```yaml
+apiVersion: v1
+kind: Event
+...
+involvedObject:
+  apiVersion: batch/v1
+  kind: Job
+  name: job-fail
+  ...
+lastTimestamp: "2019-10-14T07:11:45Z"
+message: Job has reached the specified backoff limit
+metadata:
+  ...
+reason: BackoffLimitExceeded
+...
+type: Warning
+```
+
+## Configuration
+
+Configurable keys:
+
+* `sinceNow`: if `true`, only processes events generated after the program starts.
+* `filters`: a list of `rules`. Each `rules` object is evaluated **independently**, in an `OR` fashion. Any event is
+    evaluated on all sets of `rules`. The first matching filter will cause the trigger of the callback. 
+* `filters.[*].rules`: a map of regular expressions. Each regular expression is evaluated against the provided object key.
+    If **all** the regular expressions match, then the event will be sent to the callback. 
+
+## Local test
+
+You can test the execution of this library by running the example program:
+
+```bash
+go run ./example --kubeconfig PATH_TO_A_KUBECONFIG_FILE --config ./example/config.yaml
+```
+
+While the example program is running, you can then start a failing job with:
+
+```bash
+kubectl apply -f ./example/job-fail-k8s.yaml
+```
+
+The example program will then pick up the failure and show the matching event.

config.go

@@ -3,7 +3,6 @@ package k8seventwatcher
 import (
 	"errors"
 	"gopkg.in/yaml.v2"
-	"k8s.io/api/core/v1"
 	"log"
 )
 
@@ -28,14 +27,18 @@ func (c *Config) Validate() error {
 	return nil
 }
 
-func (c *Config) MatchingEventFilter(event *v1.Event) *EventFilter {
+func (c *Config) MatchingEventFilter(event map[string]interface{}) (*EventFilter, error) {
 	for _, filter := range c.Filters {
-		if filter.Matches(event) {
-			return filter
+		matches, err := filter.Matches(event)
+		if err != nil {
+			return nil, errorf("error matching filter: %s", err)
+		}
+		if matches {
+			return filter, nil
 		}
 	}
 
-	return nil
+	return nil, nil
 }
 
 func (c *Config) Dump() string {

config.yaml

@@ -0,0 +1,6 @@
+sinceNow: true
+filters:
+- rules:
+    involvedObject.kind: Job
+    involvedObject.name: "^*.fail"
+    reason: BackoffLimitExceeded

example/config.yaml

@@ -0,0 +1,17 @@
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: job-fail
+spec:
+  backoffLimit: 0
+  template:
+    spec:
+      containers:
+        - command:
+            - sh
+            - exit
+            - "1"
+          image: alpine
+          name: main
+      restartPolicy: Never
+      terminationGracePeriodSeconds: 30

example/job-fail-k8s.yaml

@@ -12,8 +12,8 @@ import (
 )
 
 func main() {
-	kubeConfigPath := flag.String("kubeconfig", "", "path of k8s k8sConfig file to use")
-	configPath := flag.String("config", "config.yaml", "path of k8sConfig file to use")
+	kubeConfigPath := flag.String("kubeconfig", "", "path of kubeconfig file to use")
+	configPath := flag.String("config", "config.yaml", "path of event watcher config file to use")
 
 	flag.Parse()
 

example/main.go

@@ -3,106 +3,44 @@ package k8seventwatcher
 import (
 	"errors"
 	"fmt"
+	"github.com/cmaster11/k8s-event-watcher/lookup"
 	"gopkg.in/yaml.v2"
-	"k8s.io/api/core/v1"
 	"strings"
 )
 
 type EventFilter struct {
-	ObjectNamespace *Regexp `yaml:"objectNamespace,omitempty"`
-	ObjectKind      *Regexp `yaml:"objectKind,omitempty"`
-	ObjectName      *Regexp `yaml:"objectName,omitempty"`
-	EventType       *Regexp `yaml:"eventType,omitempty"`
-	EventReason     *Regexp `yaml:"eventReason,omitempty"`
+	Rules map[string]*Regexp `yaml:"rules"`
 }
 
 func (f *EventFilter) Validate() error {
 	// At least one filter must exist
-	if f.ObjectNamespace != nil {
+	if len(f.Rules) > 0 {
 		return nil
 	}
-	if f.ObjectKind != nil {
-		return nil
-	}
-	if f.ObjectName != nil {
-		return nil
-	}
-	if f.EventType != nil {
-		return nil
-	}
-	if f.EventReason != nil {
-		return nil
-	}
-	return errors.New("no filter attributes provided")
+	return errors.New("no rules provided")
 }
 
-func (f *EventFilter) Matches(event *v1.Event) bool {
-	if f.ObjectNamespace != nil {
-		if !f.ObjectNamespace.MatchString(event.InvolvedObject.Namespace) {
-			return false
+func (f *EventFilter) Matches(event map[string]interface{}) (bool, error) {
+	for path, regex := range f.Rules {
+		value, err := lookup.LookupString(event, path)
+		if err != nil {
+			return false, errorf("lookup error: %s", err)
 		}
-	}
-	if f.ObjectKind != nil {
-		if !f.ObjectKind.MatchString(event.InvolvedObject.Kind) {
-			return false
-		}
-	}
-	if f.ObjectName != nil {
-		if !f.ObjectName.MatchString(event.InvolvedObject.Name) {
-			return false
-		}
-	}
-	if f.EventType != nil {
-		if !f.EventType.MatchString(event.Type) {
-			return false
-		}
-	}
-	if f.EventReason != nil {
-		if !f.EventReason.MatchString(event.Reason) {
-			return false
+
+		valueStr := fmt.Sprintf("%v", value.Interface())
+		if !regex.MatchString(valueStr) {
+			return false, nil
 		}
 	}
 
-	return true
+	return true, nil
 }
 
 func (f *EventFilter) String() string {
 	var elements []string
-	if f.EventReason != nil {
-		elements = append(elements, fmt.Sprintf("eventReason=%s", f.EventReason.String()))
-	}
-	if f.EventType != nil {
-		elements = append(elements, fmt.Sprintf("eventType=%s", f.EventType.String()))
-	}
-	if f.ObjectNamespace != nil {
-		elements = append(elements, fmt.Sprintf("objectNamespace=%s", f.ObjectNamespace.String()))
-	}
-	if f.ObjectKind != nil {
-		elements = append(elements, fmt.Sprintf("objectKind=%s", f.ObjectKind.String()))
-	}
-	if f.ObjectName != nil {
-		elements = append(elements, fmt.Sprintf("objectName=%s", f.ObjectName.String()))
-	}
-
-	return strings.Join(elements, ",")
-}
 
-func (f *EventFilter) StringShort() string {
-	var elements []string
-	if f.EventReason != nil {
-		elements = append(elements, fmt.Sprintf("reason=%s", f.EventReason.String()))
-	}
-	if f.EventType != nil {
-		elements = append(elements, fmt.Sprintf("evtType=%s", f.EventType.String()))
-	}
-	if f.ObjectNamespace != nil {
-		elements = append(elements, fmt.Sprintf("objNS=%s", f.ObjectNamespace.String()))
-	}
-	if f.ObjectKind != nil {
-		elements = append(elements, fmt.Sprintf("objKind=%s", f.ObjectKind.String()))
-	}
-	if f.ObjectName != nil {
-		elements = append(elements, fmt.Sprintf("objName=%s", f.ObjectName.String()))
+	for path, regex := range f.Rules {
+		elements = append(elements, fmt.Sprintf("%s=%s", path, regex.String()))
 	}
 
 	return strings.Join(elements, ",")

filter.go

@@ -8,11 +8,12 @@ import (
 
 func TestEventFilter(t *testing.T) {
 	input := `
-objectKind: Job
-objectNamespace: default
-objectName: test.*
-eventType: Warning
-eventReason: BackoffLimitExceeded
+rules:
+  involvedObject.kind: Job
+  involvedObject.namespace: default
+  involvedObject.name: test.*
+  type: Warning
+  reason: BackoffLimitExceeded
 `
 
 	filter := &EventFilter{}
@@ -21,6 +22,10 @@ eventReason: BackoffLimitExceeded
 		t.Fatal(err)
 	}
 
+	if err := filter.Validate(); err != nil {
+		t.Fatalf("invalid rules: %s", err)
+	}
+
 	evt := v1.Event{}
 	evt.InvolvedObject = v1.ObjectReference{
 		Kind:      "Job",
@@ -30,8 +35,18 @@ eventReason: BackoffLimitExceeded
 	evt.Type = "Warning"
 	evt.Reason = "BackoffLimitExceeded"
 
-	if !filter.Matches(&evt) {
-		t.Fatal("expected match")
+	// Marshal to JSON
+	obj, err := eventToMap(&evt)
+	if err != nil {
+		t.Fatalf("failed to cast event to map: %s", err)
+	}
+
+	match, err := filter.Matches(obj)
+	if err != nil {
+		t.Fatalf("match error: %s", err)
+	}
+	if !match {
+		t.Fatalf("no match")
 	}
 
 	output := filter.ToYAML()
@@ -43,19 +58,19 @@ eventReason: BackoffLimitExceeded
 		t.Fatal(err)
 	}
 
-	if filter2.EventReason.String() != filter.EventReason.String() {
-		t.Fatal("wrong EventReason")
-	}
-	if filter2.EventType.String() != filter.EventType.String() {
-		t.Fatal("wrong EventType")
-	}
-	if filter2.ObjectKind.String() != filter.ObjectKind.String() {
-		t.Fatal("wrong ObjectKind")
-	}
-	if filter2.ObjectName.String() != filter.ObjectName.String() {
-		t.Fatal("wrong ObjectName")
-	}
-	if filter2.ObjectNamespace.String() != filter.ObjectNamespace.String() {
-		t.Fatal("wrong ObjectNamespace")
+	// Test marshal to string
+	for path, regex := range filter.Rules {
+		found := false
+		for path2, regex2 := range filter2.Rules {
+			if path == path2 {
+				found = true
+				if regex.String() != regex2.String() {
+					t.Fatalf("wrong regex for %s", path)
+				}
+			}
+		}
+		if !found {
+			t.Fatalf("path %s not found", path)
+		}
 	}
 }

filter_test.go

@@ -3,6 +3,8 @@ module github.com/cmaster11/k8s-event-watcher
 go 1.13
 
 require (
+	github.com/mitchellh/mapstructure v1.1.2
+	gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405
 	gopkg.in/yaml.v2 v2.2.4
 	k8s.io/api v0.0.0-20190620084959-7cf5895f2711
 	k8s.io/apimachinery v0.0.0-20190612205821-1799e75a0719