fix: report event on application metadata changes (v2 reporter) (#314)

* reporter v2: event reporting on application metadata changes

* reporter v2 / ShouldSendApplicationEvent: moved some logic to dedicated func applicationMetadataChanged

Author: oleksandr-codefresh

changelog/CHANGELOG.md

@@ -0,0 +1,2 @@
+### Fix
+-  fix(event-reporter v2): report event on application metadata changes

event_reporter/reporter/application_event_reporter.go

@@ -467,9 +467,38 @@ func (s *applicationEventReporter) ShouldSendApplicationEvent(ae *appv1.Applicat
 		return true, false
 	}
 
+	metadataChanged := applicationMetadataChanged(ae, cachedApp)
+
+	if metadataChanged {
+		logCtx.Info("application metadata changed")
+		return true, false
+	}
+
 	return false, false
 }
 
+func applicationMetadataChanged(ae *appv1.ApplicationWatchEvent, cachedApp *appv1.Application) (changed bool) {
+	if ae.Type != watch.Modified {
+		return false
+	}
+
+	cachedAppMeta := cachedApp.ObjectMeta.DeepCopy()
+	newEventAppMeta := ae.Application.ObjectMeta.DeepCopy()
+
+	if newEventAppMeta.Annotations != nil {
+		delete(newEventAppMeta.Annotations, "kubectl.kubernetes.io/last-applied-configuration")
+		delete(cachedAppMeta.Annotations, "kubectl.kubernetes.io/last-applied-configuration")
+	}
+
+	cachedAppMeta.ResourceVersion = newEventAppMeta.ResourceVersion // ignore those in the diff
+	cachedAppMeta.Generation = newEventAppMeta.Generation           // ignore those in the diff
+	cachedAppMeta.GenerateName = newEventAppMeta.GenerateName       // ignore those in the diff
+	newEventAppMeta.ManagedFields = nil                             // ignore those in the diff
+	cachedAppMeta.ManagedFields = nil                               // ignore those in the diff
+
+	return !reflect.DeepEqual(newEventAppMeta, cachedAppMeta)
+}
+
 func isApp(rs appv1.ResourceStatus) bool {
 	return rs.GroupVersionKind().String() == appv1.ApplicationSchemaGroupVersionKind.String()
 }

event_reporter/reporter/application_event_reporter_test.go

@@ -3,6 +3,7 @@ package reporter
 import (
 	"context"
 	"encoding/json"
+	"k8s.io/apimachinery/pkg/watch"
 	"net/http"
 	"testing"
 	"time"
@@ -536,3 +537,112 @@ func TestGetParentAppIdentityWithinControllerNs(t *testing.T) {
 	assert.Equal(t, expectedName, res.name)
 	assert.Equal(t, expectedNamespace, res.namespace)
 }
+
+func TestShouldSendApplicationEvent(t *testing.T) {
+	eventReporter := fakeReporter()
+
+	t.Run("should send because cache is missing", func(t *testing.T) {
+		app := v1alpha1.Application{
+			ObjectMeta: metav1.ObjectMeta{
+				Labels: map[string]string{
+					"sdsds": "sdsd",
+				},
+			},
+		}
+
+		shouldSend, _ := eventReporter.ShouldSendApplicationEvent(&v1alpha1.ApplicationWatchEvent{
+			Type:        watch.Modified,
+			Application: app,
+		})
+		assert.True(t, shouldSend)
+	})
+
+	t.Run("should send because labels changed", func(t *testing.T) {
+		appCache := v1alpha1.Application{
+			ObjectMeta: metav1.ObjectMeta{
+				Labels: map[string]string{
+					"data": "old value",
+				},
+			},
+		}
+
+		err := eventReporter.cache.SetLastApplicationEvent(&appCache, time.Second*5)
+		assert.NoError(t, err)
+
+		app := v1alpha1.Application{
+			ObjectMeta: metav1.ObjectMeta{
+				Labels: map[string]string{
+					"data": "new value",
+				},
+			},
+		}
+
+		shouldSend, _ := eventReporter.ShouldSendApplicationEvent(&v1alpha1.ApplicationWatchEvent{
+			Type:        watch.Modified,
+			Application: app,
+		})
+		assert.True(t, shouldSend)
+	})
+
+	t.Run("should send because annotations changed", func(t *testing.T) {
+		appCache := v1alpha1.Application{
+			ObjectMeta: metav1.ObjectMeta{
+				Annotations: map[string]string{
+					"data": "old value",
+				},
+			},
+		}
+
+		err := eventReporter.cache.SetLastApplicationEvent(&appCache, time.Second*5)
+		assert.NoError(t, err)
+
+		app := v1alpha1.Application{
+			ObjectMeta: metav1.ObjectMeta{
+				Annotations: map[string]string{
+					"data": "new value",
+				},
+			},
+		}
+
+		shouldSend, _ := eventReporter.ShouldSendApplicationEvent(&v1alpha1.ApplicationWatchEvent{
+			Type:        watch.Modified,
+			Application: app,
+		})
+		assert.True(t, shouldSend)
+	})
+
+	t.Run("should ignore some changed metadata fields", func(t *testing.T) {
+		appCache := v1alpha1.Application{
+			ObjectMeta: metav1.ObjectMeta{
+				ResourceVersion: "1",
+				Generation:      1,
+				GenerateName:    "first",
+				ManagedFields:   []metav1.ManagedFieldsEntry{},
+				Annotations: map[string]string{
+					"kubectl.kubernetes.io/last-applied-configuration": "first",
+				},
+			},
+		}
+
+		err := eventReporter.cache.SetLastApplicationEvent(&appCache, time.Second*5)
+		assert.NoError(t, err)
+
+		app := v1alpha1.Application{
+			ObjectMeta: metav1.ObjectMeta{
+				ResourceVersion: "2",
+				Generation:      2,
+				GenerateName:    "changed",
+				ManagedFields:   []metav1.ManagedFieldsEntry{{Manager: "changed"}},
+				Annotations: map[string]string{
+					"kubectl.kubernetes.io/last-applied-configuration": "changed",
+				},
+			},
+		}
+
+		shouldSend, _ := eventReporter.ShouldSendApplicationEvent(&v1alpha1.ApplicationWatchEvent{
+			Type:        watch.Modified,
+			Application: app,
+		})
+		assert.False(t, shouldSend)
+	})
+}