Add DependencyPolicyConflictResolved event

Signed-off-by: Kexin2000 <3299133282@qq.com>

Author: Kexin2000

pkg/dependenciesdistributor/dependencies_distributor.go

@@ -49,6 +49,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/source"
 
 	configv1alpha1 "github.com/karmada-io/karmada/pkg/apis/config/v1alpha1"
+	policyv1alpha1 "github.com/karmada-io/karmada/pkg/apis/policy/v1alpha1"
 	workv1alpha2 "github.com/karmada-io/karmada/pkg/apis/work/v1alpha2"
 	"github.com/karmada-io/karmada/pkg/events"
 	"github.com/karmada-io/karmada/pkg/resourceinterpreter"
@@ -585,16 +586,37 @@ func (d *DependenciesDistributor) createOrUpdateAttachedBinding(attachedBinding
 				"try again later after binding is garbage collected, see https://github.com/karmada-io/karmada/issues/6034", bindingKey)
 		}
 
+		oldConflictResolution := effectiveConflictResolution(existBinding.Spec.ConflictResolution)
+		oldPreserve := ptr.Deref(existBinding.Spec.PreserveResourcesOnDeletion, false)
+		oldRequiredByLen := len(existBinding.Spec.RequiredBy)
+
+		mergedRequiredBy := mergeBindingSnapshot(existBinding.Spec.RequiredBy, attachedBinding.Spec.RequiredBy)
+
+		newConflictResolution := effectiveConflictResolution(attachedBinding.Spec.ConflictResolution)
+		newPreserve := ptr.Deref(attachedBinding.Spec.PreserveResourcesOnDeletion, false)
+
+		conflictDetected := false
+
 		// If the spec.Placement is nil, this means that existBinding is generated by the dependency mechanism.
 		// If the spec.Placement is not nil, then it must be generated by PropagationPolicy.
 		if existBinding.Spec.Placement == nil {
+			if oldRequiredByLen > 0 && (oldConflictResolution != newConflictResolution || oldPreserve != newPreserve) {
+				conflictDetected = true
+			}
 			existBinding.Spec.ConflictResolution = attachedBinding.Spec.ConflictResolution
 		}
-		existBinding.Spec.RequiredBy = mergeBindingSnapshot(existBinding.Spec.RequiredBy, attachedBinding.Spec.RequiredBy)
+
+		existBinding.Spec.RequiredBy = mergedRequiredBy
 		existBinding.Labels = util.DedupeAndMergeLabels(existBinding.Labels, attachedBinding.Labels)
 		existBinding.Spec.Resource = attachedBinding.Spec.Resource
 		existBinding.Spec.PreserveResourcesOnDeletion = attachedBinding.Spec.PreserveResourcesOnDeletion
 
+		if conflictDetected && d.EventRecorder != nil {
+			// Emit a warning event indicating conflict was detected and auto-resolved by default rules.
+			message := "Dependency policy conflict detected and resolved by default rules."
+			d.EventRecorder.Eventf(existBinding, corev1.EventTypeWarning, events.EventReasonDependencyPolicyConflictResolved, message)
+		}
+
 		if err := d.Client.Update(context.TODO(), existBinding); err != nil {
 			klog.Errorf("Failed to update resourceBinding(%s): %v", bindingKey, err)
 			return err
@@ -684,6 +706,14 @@ func (d *DependenciesDistributor) SetupWithManager(mgr controllerruntime.Manager
 	})
 }
 
+func effectiveConflictResolution(value policyv1alpha1.ConflictResolution) policyv1alpha1.ConflictResolution {
+	if value == "" {
+		return policyv1alpha1.ConflictAbort
+	}
+
+	return value
+}
+
 func generateBindingDependedLabels(bindingID, bindingNamespace, bindingName string) map[string]string {
 	labelKey := generateBindingDependedLabelKey(bindingNamespace, bindingName)
 	return map[string]string{labelKey: bindingID}

pkg/dependenciesdistributor/dependencies_distributor_test.go

@@ -20,6 +20,7 @@ import (
 	"context"
 	"fmt"
 	"reflect"
+	"strings"
 	"testing"
 	"time"
 
@@ -34,6 +35,7 @@ import (
 	"k8s.io/client-go/dynamic"
 	dynamicfake "k8s.io/client-go/dynamic/fake"
 	"k8s.io/client-go/kubernetes/scheme"
+	"k8s.io/client-go/tools/record"
 	"k8s.io/utils/ptr"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/client/fake"
@@ -42,6 +44,7 @@ import (
 	configv1alpha1 "github.com/karmada-io/karmada/pkg/apis/config/v1alpha1"
 	policyv1alpha1 "github.com/karmada-io/karmada/pkg/apis/policy/v1alpha1"
 	workv1alpha2 "github.com/karmada-io/karmada/pkg/apis/work/v1alpha2"
+	"github.com/karmada-io/karmada/pkg/events"
 	"github.com/karmada-io/karmada/pkg/util"
 	"github.com/karmada-io/karmada/pkg/util/fedinformer/genericmanager"
 	"github.com/karmada-io/karmada/pkg/util/fedinformer/keys"
@@ -3432,3 +3435,136 @@ func Test_deleteBindingFromSnapshot(t *testing.T) {
 		})
 	}
 }
+
+type dependencyPolicyTestEnv struct {
+	distributor *DependenciesDistributor
+	client      client.Client
+	recorder    *record.FakeRecorder
+	existing    *workv1alpha2.ResourceBinding
+	dependent   *unstructured.Unstructured
+}
+
+func newDependencyPolicyTestEnv(t *testing.T) *dependencyPolicyTestEnv {
+	t.Helper()
+
+	scheme := runtime.NewScheme()
+	utilruntime.Must(workv1alpha2.Install(scheme))
+
+	dependent := &unstructured.Unstructured{}
+	dependent.SetAPIVersion("v1")
+	dependent.SetKind("ConfigMap")
+	dependent.SetNamespace("default")
+	dependent.SetName("app-config")
+	dependent.SetUID(types.UID("cm-uid"))
+
+	parentOne := &workv1alpha2.ResourceBinding{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "workload-a",
+			Namespace: "default",
+			Labels: map[string]string{
+				workv1alpha2.ResourceBindingPermanentIDLabel: "rb-uid-a",
+			},
+		},
+		Spec: workv1alpha2.ResourceBindingSpec{
+			Clusters:                    []workv1alpha2.TargetCluster{{Name: "member1"}},
+			ConflictResolution:          policyv1alpha1.ConflictOverwrite,
+			PreserveResourcesOnDeletion: ptr.To(true),
+		},
+	}
+
+	attachedFromParentOne := buildAttachedBinding(parentOne, dependent)
+	existing := attachedFromParentOne.DeepCopy()
+
+	fakeClient := fake.NewClientBuilder().WithScheme(scheme).WithObjects(existing).Build()
+	recorder := record.NewFakeRecorder(10)
+
+	distributor := &DependenciesDistributor{
+		Client:        fakeClient,
+		EventRecorder: recorder,
+	}
+
+	return &dependencyPolicyTestEnv{
+		distributor: distributor,
+		client:      fakeClient,
+		recorder:    recorder,
+		existing:    existing,
+		dependent:   dependent,
+	}
+}
+
+func waitForEvents(t *testing.T, recorder *record.FakeRecorder, want int, timeout time.Duration) []string {
+	t.Helper()
+
+	eventList := make([]string, 0, want)
+	timeoutCh := time.After(timeout)
+	for len(eventList) < want {
+		select {
+		case evt := <-recorder.Events:
+			eventList = append(eventList, evt)
+		case <-timeoutCh:
+			t.Fatalf("timed out waiting for %d events, got %v", want, eventList)
+		}
+	}
+	return eventList
+}
+
+func findEventByReason(t *testing.T, eventList []string, reason string) string {
+	t.Helper()
+
+	for _, evt := range eventList {
+		if strings.Contains(evt, reason) {
+			return evt
+		}
+	}
+	t.Fatalf("expected event reason %s in %v", reason, eventList)
+	return ""
+}
+
+func assertEventMessageContains(t *testing.T, event string, substrings ...string) {
+	t.Helper()
+
+	for _, substring := range substrings {
+		if !strings.Contains(event, substring) {
+			t.Errorf("event %q missing substring %q", event, substring)
+		}
+	}
+}
+
+func TestCreateOrUpdateAttachedBinding_RecordsConflictEvent(t *testing.T) {
+	env := newDependencyPolicyTestEnv(t)
+
+	parentTwo := &workv1alpha2.ResourceBinding{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "workload-b",
+			Namespace: "default",
+			Labels: map[string]string{
+				workv1alpha2.ResourceBindingPermanentIDLabel: "rb-uid-b",
+			},
+		},
+		Spec: workv1alpha2.ResourceBindingSpec{
+			Clusters:                    []workv1alpha2.TargetCluster{{Name: "member2"}},
+			ConflictResolution:          policyv1alpha1.ConflictAbort,
+			PreserveResourcesOnDeletion: ptr.To(false),
+		},
+	}
+	attachedFromParentTwo := buildAttachedBinding(parentTwo, env.dependent)
+
+	if err := env.distributor.createOrUpdateAttachedBinding(attachedFromParentTwo); err != nil {
+		t.Fatalf("createOrUpdateAttachedBinding() error = %v", err)
+	}
+
+	updated := &workv1alpha2.ResourceBinding{}
+	if err := env.client.Get(context.TODO(), client.ObjectKeyFromObject(env.existing), updated); err != nil {
+		t.Fatalf("failed to fetch updated binding: %v", err)
+	}
+	if len(updated.Spec.RequiredBy) != 2 {
+		t.Fatalf("expected 2 parents after aggregation, got %d", len(updated.Spec.RequiredBy))
+	}
+
+	eventList := waitForEvents(t, env.recorder, 1, time.Second)
+
+	conflictEvent := findEventByReason(t, eventList, events.EventReasonDependencyPolicyConflictResolved)
+	assertEventMessageContains(t, conflictEvent,
+		"Dependency policy conflict detected and resolved by default rules.",
+	)
+}

pkg/events/events.go

@@ -66,6 +66,9 @@ const (
 	EventReasonSyncScheduleResultToDependenciesSucceed = "SyncScheduleResultToDependenciesSucceed"
 	// EventReasonSyncScheduleResultToDependenciesFailed indicates sync schedule result to attached bindings failed.
 	EventReasonSyncScheduleResultToDependenciesFailed = "SyncScheduleResultToDependenciesFailed"
+	// EventReasonDependencyPolicyConflictResolved indicates a dependency policy conflict was detected
+	// and has been resolved automatically by default rules.
+	EventReasonDependencyPolicyConflictResolved = "DependencyPolicyConflictResolved"
 )
 
 // Define events for ResourceBinding, ClusterResourceBinding objects and their associated resources.