Merge branch 'release-2.12' of github.com:codefresh-io/argo-cd into CR-23668-multisource-details-reporting

# Conflicts:
#	changelog/CHANGELOG.md

Author: oleksandr-codefresh

VERSION

@@ -1 +1 @@
-2.12.3-2024.10.28-20100fc54
+2.12.3-2024.11.14-d7a4c4e7e

changelog/CHANGELOG-2.12.3-2024.11.14-d7a4c4e7e.md

@@ -0,0 +1,2 @@
+### Changes
+-  fix(event-reporter): fixed issue when if managed resource in degraded state and all of it child nodes in non-degraded state no error reported

event_reporter/reporter/application_errors_parser.go

@@ -135,31 +135,44 @@ func parseAggregativeHealthErrors(rs *appv1.ResourceStatus, apptree *appv1.Appli
 	childNodes := n.GetAllChildNodes(apptree, "")
 
 	for _, cn := range childNodes {
-		if cn.Health != nil && cn.Health.Status == health.HealthStatusDegraded {
-			newErr := events.ObjectError{
-				Type:     "health",
-				Level:    "error",
-				Message:  cn.Health.Message,
-				LastSeen: *cn.CreatedAt,
-			}
-
-			if addReference {
-				newErr.SourceReference = &events.ErrorSourceReference{
-					Group:     rs.Group,
-					Version:   rs.Version,
-					Kind:      rs.Kind,
-					Namespace: rs.Namespace,
-					Name:      rs.Name,
-				}
-			}
+		if newErr := getNodeHealthError(cn, rs, addReference); newErr != nil {
+			errs = append(errs, newErr)
+		}
+	}
 
-			errs = append(errs, &newErr)
+	if len(errs) == 0 {
+		if newErr := getNodeHealthError(*n, rs, addReference); newErr != nil {
+			errs = append(errs, newErr)
 		}
 	}
 
 	return errs
 }
 
+func getNodeHealthError(node appv1.ResourceNode, managedResource *appv1.ResourceStatus, addReference bool) *events.ObjectError {
+	if node.Health == nil || node.Health.Status != health.HealthStatusDegraded {
+		return nil
+	}
+
+	newErr := &events.ObjectError{
+		Type:     "health",
+		Level:    "error",
+		Message:  node.Health.Message,
+		LastSeen: *node.CreatedAt,
+	}
+
+	if addReference {
+		newErr.SourceReference = &events.ErrorSourceReference{
+			Group:     managedResource.Group,
+			Version:   managedResource.Version,
+			Kind:      managedResource.Kind,
+			Namespace: managedResource.Namespace,
+			Name:      managedResource.Name,
+		}
+	}
+	return newErr
+}
+
 func parseAggregativeResourcesSyncErrors(resourceResults appv1.ResourceResults) []*events.ObjectError {
 	var errs []*events.ObjectError
 

event_reporter/reporter/applications_errors_parser_test.go

@@ -336,4 +336,81 @@ func TestParseAggregativeHealthErrors(t *testing.T) {
 		assert.NotNil(t, errs[0].SourceReference)
 		assert.Equal(t, deployRef.Name, errs[0].SourceReference.Name)
 	})
+
+	t.Run("should build error from root node if it's degraded while no one of child in degraded health state", func(t *testing.T) {
+		rsName := "test-deployment"
+		ns := "test"
+		errMessage := "backoff pulling image test/test:0.1"
+		replicaSetRef := v1alpha1.ResourceRef{
+			Group:     "g",
+			Version:   "v",
+			Kind:      "ReplicaSet",
+			Name:      rsName + "1",
+			Namespace: ns,
+		}
+
+		deploymentRef := v1alpha1.ResourceRef{
+			Group:     "g",
+			Version:   "v",
+			Kind:      "Deployment",
+			Name:      rsName,
+			Namespace: ns,
+		}
+
+		appTree := v1alpha1.ApplicationTree{
+			Nodes: []v1alpha1.ResourceNode{
+				{ // Pod
+					ResourceRef: v1alpha1.ResourceRef{
+						Group:     "g",
+						Version:   "v",
+						Kind:      "Pod",
+						Name:      rsName + "1-3n235j5",
+						Namespace: ns,
+					},
+					Health: &v1alpha1.HealthStatus{
+						Status:  health.HealthStatusProgressing,
+						Message: "some error of pod",
+					},
+					ParentRefs: []v1alpha1.ResourceRef{replicaSetRef},
+					CreatedAt: &metav1.Time{
+						Time: time.Now(),
+					},
+				},
+				{ // ReplicaSet
+					ResourceRef: replicaSetRef,
+					Health: &v1alpha1.HealthStatus{
+						Status:  health.HealthStatusProgressing,
+						Message: "",
+					},
+					ParentRefs: []v1alpha1.ResourceRef{deploymentRef},
+					CreatedAt: &metav1.Time{
+						Time: time.Now(),
+					},
+				},
+				{ // Deployment
+					ResourceRef: deploymentRef,
+					Health: &v1alpha1.HealthStatus{
+						Status:  health.HealthStatusDegraded,
+						Message: errMessage,
+					},
+					ParentRefs: []v1alpha1.ResourceRef{},
+					CreatedAt: &metav1.Time{
+						Time: time.Now(),
+					},
+				},
+			},
+		}
+
+		errs := parseAggregativeHealthErrors(&v1alpha1.ResourceStatus{
+			Group:     deploymentRef.Group,
+			Version:   deploymentRef.Version,
+			Kind:      deploymentRef.Kind,
+			Name:      deploymentRef.Name,
+			Namespace: deploymentRef.Namespace,
+		}, &appTree, true)
+		assert.Len(t, errs, 1)
+		assert.Equal(t, errMessage, errs[0].Message)
+		assert.NotNil(t, errs[0].SourceReference)
+		assert.Equal(t, deploymentRef.Name, errs[0].SourceReference.Name)
+	})
 }

reposerver/repository/repository.go

@@ -1812,21 +1812,18 @@ var manifestFile = regexp.MustCompile(`^.*\.(yaml|yml|json|jsonnet)$`)
 
 // findManifests looks at all yaml files in a directory and unmarshals them into a list of unstructured objects
 func findManifests(logCtx *log.Entry, appPath string, repoRoot string, env *v1alpha1.Env, directory v1alpha1.ApplicationSourceDirectory, enabledManifestGeneration map[string]bool, maxCombinedManifestQuantity resource.Quantity) ([]manifest, error) {
-	absRepoRoot, err := filepath.Abs(repoRoot)
-	if err != nil {
-		return nil, err
-	}
-
-	var manifests []manifest
-
 	// Validate the directory before loading any manifests to save memory.
 	potentiallyValidManifests, err := getPotentiallyValidManifests(logCtx, appPath, repoRoot, directory.Recurse, directory.Include, directory.Exclude, maxCombinedManifestQuantity)
 	if err != nil {
 		logCtx.Errorf("failed to get potentially valid manifests: %s", err)
 		return nil, fmt.Errorf("failed to get potentially valid manifests: %w", err)
 	}
 
-	var objs []*unstructured.Unstructured
+	absRepoRoot, err := filepath.Abs(repoRoot)
+	if err != nil {
+		return nil, err
+	}
+	var manifests []manifest
 	for _, potentiallyValidManifest := range potentiallyValidManifests {
 		manifestPath := potentiallyValidManifest.path
 		manifestFileInfo := potentiallyValidManifest.fileInfo
@@ -1836,6 +1833,7 @@ func findManifests(logCtx *log.Entry, appPath string, repoRoot string, env *v1al
 		repoRelPath, _ := filepath.Rel(absRepoRoot, absPath)
 
 		if strings.HasSuffix(manifestFileInfo.Name(), ".jsonnet") {
+			var objs []*unstructured.Unstructured
 			if !discovery.IsManifestGenerationEnabled(v1alpha1.ApplicationSourceTypeDirectory, enabledManifestGeneration) {
 				continue
 			}
@@ -1875,6 +1873,7 @@ func findManifests(logCtx *log.Entry, appPath string, repoRoot string, env *v1al
 				})
 			}
 		} else {
+			var objs []*unstructured.Unstructured
 			err := getObjsFromYAMLOrJson(logCtx, manifestPath, manifestFileInfo.Name(), &objs)
 			if err != nil {
 				return nil, err

reposerver/repository/repository_test.go

@@ -661,7 +661,7 @@ func TestGenerateManifestsUseExactRevision(t *testing.T) {
 
 	res1, err := service.GenerateManifest(context.Background(), &q)
 	require.NoError(t, err)
-	assert.Len(t, res1.Manifests, 6)
+	assert.Len(t, res1.Manifests, 4)
 	assert.Equal(t, "abc", gitClient.Calls[0].Arguments[0])
 }
 
@@ -677,7 +677,7 @@ func TestRecurseManifestsInDir(t *testing.T) {
 
 	res1, err := service.GenerateManifest(context.Background(), &q)
 	require.NoError(t, err)
-	assert.Len(t, res1.Manifests, 6)
+	assert.Len(t, res1.Manifests, 4)
 }
 
 func TestInvalidManifestsInDir(t *testing.T) {
@@ -2199,7 +2199,7 @@ func TestFindResources(t *testing.T) {
 	}, {
 		name:          "Include Everything",
 		include:       "*.yaml",
-		expectedNames: []string{"nginx-deployment", "nginx-deployment", "nginx-deployment-sub"},
+		expectedNames: []string{"nginx-deployment", "nginx-deployment-sub"},
 	}, {
 		name:          "Include Subdirectory",
 		include:       "**/*.yaml",
@@ -2254,10 +2254,10 @@ func TestFindManifests_Exclude_NothingMatches(t *testing.T) {
 	}, map[string]bool{}, resource.MustParse("0"))
 
 	require.NoError(t, err)
-	require.Len(t, objs, 3)
+	require.Len(t, objs, 2)
 
 	assert.ElementsMatch(t,
-		[]string{"nginx-deployment", "nginx-deployment-sub"}, []string{objs[0].obj.GetName(), objs[2].obj.GetName()})
+		[]string{"nginx-deployment", "nginx-deployment-sub"}, []string{objs[0].obj.GetName(), objs[1].obj.GetName()})
 }
 
 func tempDir(t *testing.T) string {
@@ -2606,7 +2606,7 @@ func Test_findManifests(t *testing.T) {
 	t.Run("recursion when recursion is enabled", func(t *testing.T) {
 		recurse := argoappv1.ApplicationSourceDirectory{Recurse: true}
 		manifests, err := findManifests(logCtx, "./testdata/recurse", "./testdata/recurse", nil, recurse, nil, resource.MustParse("0"))
-		assert.Len(t, manifests, 6)
+		assert.Len(t, manifests, 4)
 		require.NoError(t, err)
 	})
 
@@ -2665,7 +2665,7 @@ func Test_findManifests(t *testing.T) {
 	t.Run("group of files should be limited at precisely the sum of their size", func(t *testing.T) {
 		// There is a total of 10 files, each file being 10 bytes.
 		manifests, err := findManifests(logCtx, "./testdata/several-files", "./testdata/several-files", nil, noRecurse, nil, resource.MustParse("365"))
-		assert.Len(t, manifests, 55)
+		assert.Len(t, manifests, 10)
 		require.NoError(t, err)
 
 		manifests, err = findManifests(logCtx, "./testdata/several-files", "./testdata/several-files", nil, noRecurse, nil, resource.MustParse("364"))
@@ -2676,7 +2676,7 @@ func Test_findManifests(t *testing.T) {
 	t.Run("jsonnet isn't counted against size limit", func(t *testing.T) {
 		// Each file is 36 bytes. Only the 36-byte json file should be counted against the limit.
 		manifests, err := findManifests(logCtx, "./testdata/jsonnet-and-json", "./testdata/jsonnet-and-json", nil, noRecurse, nil, resource.MustParse("36"))
-		assert.Len(t, manifests, 3)
+		assert.Len(t, manifests, 2)
 		require.NoError(t, err)
 
 		manifests, err = findManifests(logCtx, "./testdata/jsonnet-and-json", "./testdata/jsonnet-and-json", nil, noRecurse, nil, resource.MustParse("35"))