feat: add svc export trackability

pkg/controllers/workapplier/availability_tracker.go

@@ -14,12 +14,16 @@ import (
 	policyv1 "k8s.io/api/policy/v1"
 	apiextensionshelpers "k8s.io/apiextensions-apiserver/pkg/apihelpers"
 	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/component-helpers/apps/poddisruptionbudget"
 	"k8s.io/klog/v2"
 
+	fleetnetworkingv1alpha1 "go.goms.io/fleet-networking/api/v1alpha1"
+	"go.goms.io/fleet-networking/pkg/common/objectmeta"
 	"go.goms.io/fleet/pkg/utils"
 	"go.goms.io/fleet/pkg/utils/controller"
 )
@@ -83,6 +87,8 @@ func trackInMemberClusterObjAvailabilityByGVR(
 		return trackCRDAvailability(inMemberClusterObj)
 	case utils.PodDisruptionBudgetGVR:
 		return trackPDBAvailability(inMemberClusterObj)
+	case utils.ServiceExportGVR:
+		return trackServiceExportAvailability(inMemberClusterObj)
 	default:
 		if isDataResource(*gvr) {
 			klog.V(2).InfoS("The object from the member cluster is a data object, consider it to be immediately available",
@@ -247,6 +253,30 @@ func trackPDBAvailability(curObj *unstructured.Unstructured) (ManifestProcessing
 	return ManifestProcessingAvailabilityResultTypeNotYetAvailable, nil
 }
 
+// trackServiceExportAvailability tracks the availability of a service export in the member cluster.
+// It is available if it has a weight annotation and the ServiceExportValid condition is True.
+func trackServiceExportAvailability(curObj *unstructured.Unstructured) (ManifestProcessingAvailabilityResultType, error) {
+	var svcExport fleetnetworkingv1alpha1.ServiceExport
+	if err := runtime.DefaultUnstructuredConverter.FromUnstructured(curObj.Object, &svcExport); err != nil {
+		return ManifestProcessingAvailabilityResultTypeFailed, controller.NewUnexpectedBehaviorError(err)
+	}
+
+	weight, hasAnnotation := svcExport.Annotations[objectmeta.ServiceExportAnnotationWeight]
+	validCond := meta.FindStatusCondition(svcExport.Status.Conditions, string(fleetnetworkingv1alpha1.ServiceExportValid))
+	conflictCond := meta.FindStatusCondition(svcExport.Status.Conditions, string(fleetnetworkingv1alpha1.ServiceExportConflict))
+
+	isValid := validCond != nil && validCond.Status == metav1.ConditionTrue
+	hasNoConflict := conflictCond != nil && conflictCond.Status == metav1.ConditionFalse
+
+	if hasAnnotation && ((weight == "0" && isValid) || (isValid && hasNoConflict)) {
+		klog.V(2).InfoS("ServiceExport is available", "serviceExport", klog.KObj(curObj))
+		return ManifestProcessingAvailabilityResultTypeAvailable, nil
+	}
+
+	klog.V(2).InfoS("Still need to wait for ServiceExport to be available", "serviceExport", klog.KObj(curObj))
+	return ManifestProcessingAvailabilityResultTypeNotYetAvailable, nil
+}
+
 // isDataResource checks if the resource is a data resource; such resources are
 // available immediately after creation.
 func isDataResource(gvr schema.GroupVersionResource) bool {

pkg/controllers/workapplier/availability_tracker_test.go

@@ -26,6 +26,8 @@ import (
 	"k8s.io/klog/v2"
 	"k8s.io/utils/ptr"
 
+	fleetnetworkingv1alpha1 "go.goms.io/fleet-networking/api/v1alpha1"
+	"go.goms.io/fleet-networking/pkg/common/objectmeta"
 	fleetv1beta1 "go.goms.io/fleet/apis/placement/v1beta1"
 	"go.goms.io/fleet/pkg/utils"
 	"go.goms.io/fleet/pkg/utils/parallelizer"
@@ -157,6 +159,16 @@ var (
 			MinAvailable: &minAvailable,
 		},
 	}
+
+	svcExportTemplate = &fleetnetworkingv1alpha1.ServiceExport{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "test-svcExport",
+			Namespace: nsName,
+			Annotations: map[string]string{
+				objectmeta.ServiceExportAnnotationWeight: "0",
+			},
+		},
+	}
 )
 
 // TestTrackDeploymentAvailability tests the trackDeploymentAvailability function.
@@ -983,6 +995,125 @@ func TestTrackInMemberClusterObjAvailabilityByGVR(t *testing.T) {
 	}
 }
 
+func TestServiceExportAvailability(t *testing.T) {
+	availableValidSvcExport := svcExportTemplate.DeepCopy()
+	availableValidSvcExport.Status = fleetnetworkingv1alpha1.ServiceExportStatus{
+		Conditions: []metav1.Condition{
+			{
+				Type:   string(fleetnetworkingv1alpha1.ServiceExportValid),
+				Status: metav1.ConditionTrue,
+				Reason: "ServiceIsValid",
+			},
+		},
+	}
+
+	unavailableInvalidSvcExport := svcExportTemplate.DeepCopy()
+	unavailableInvalidSvcExport.Status = fleetnetworkingv1alpha1.ServiceExportStatus{
+		Conditions: []metav1.Condition{
+			{
+				Type:   string(fleetnetworkingv1alpha1.ServiceExportValid),
+				Status: metav1.ConditionFalse,
+				Reason: "ServiceNotFound",
+			},
+		},
+	}
+
+	availableNoConflictSvcExport := svcExportTemplate.DeepCopy()
+	availableNoConflictSvcExport.Annotations["networking.fleet.azure.com/weight"] = "1"
+	availableNoConflictSvcExport.Status = fleetnetworkingv1alpha1.ServiceExportStatus{
+		Conditions: []metav1.Condition{
+			{
+				Type:   string(fleetnetworkingv1alpha1.ServiceExportValid),
+				Status: metav1.ConditionTrue,
+				Reason: "ServiceIsValid",
+			},
+			{
+				Type:   string(fleetnetworkingv1alpha1.ServiceExportConflict),
+				Status: metav1.ConditionFalse,
+				Reason: "NoConflictFound",
+			},
+		},
+	}
+
+	unavailableHasConflictSvcExport := svcExportTemplate.DeepCopy()
+	unavailableHasConflictSvcExport.Annotations["networking.fleet.azure.com/weight"] = "1"
+	unavailableHasConflictSvcExport.Status = fleetnetworkingv1alpha1.ServiceExportStatus{
+		Conditions: []metav1.Condition{
+			{
+				Type:   string(fleetnetworkingv1alpha1.ServiceExportValid),
+				Status: metav1.ConditionTrue,
+				Reason: "ServiceIsValid",
+			},
+			{
+				Type:   string(fleetnetworkingv1alpha1.ServiceExportConflict),
+				Status: metav1.ConditionTrue,
+				Reason: "ConflictFound",
+			},
+		},
+	}
+
+	unavailableInvalidNoConflictSvcExport := svcExportTemplate.DeepCopy()
+	unavailableInvalidNoConflictSvcExport.Annotations["networking.fleet.azure.com/weight"] = "1"
+	unavailableInvalidNoConflictSvcExport.Status = fleetnetworkingv1alpha1.ServiceExportStatus{
+		Conditions: []metav1.Condition{
+			{
+				Type:   string(fleetnetworkingv1alpha1.ServiceExportValid),
+				Status: metav1.ConditionFalse,
+				Reason: "ServiceIneligible",
+			},
+			{
+				Type:   string(fleetnetworkingv1alpha1.ServiceExportConflict),
+				Status: metav1.ConditionTrue,
+				Reason: "ConflictFound",
+			},
+		},
+	}
+
+	testCases := []struct {
+		name                                         string
+		svcExport                                    *fleetnetworkingv1alpha1.ServiceExport
+		wantManifestProcessingAvailabilityResultType ManifestProcessingAvailabilityResultType
+	}{
+		{
+			name:      "available svcExport (annotation weight is 0)",
+			svcExport: availableValidSvcExport,
+			wantManifestProcessingAvailabilityResultType: ManifestProcessingAvailabilityResultTypeAvailable,
+		},
+		{
+			name:      "available svcExport (annotation weight is 1)",
+			svcExport: availableNoConflictSvcExport,
+			wantManifestProcessingAvailabilityResultType: ManifestProcessingAvailabilityResultTypeAvailable,
+		},
+		{
+			name:      "unavailable svcExport (annotation weight is 0)",
+			svcExport: unavailableInvalidSvcExport,
+			wantManifestProcessingAvailabilityResultType: ManifestProcessingAvailabilityResultTypeNotYetAvailable,
+		},
+		{
+			name:      "unavailable svcExport with conflict (annotation weight is 1)",
+			svcExport: unavailableHasConflictSvcExport,
+			wantManifestProcessingAvailabilityResultType: ManifestProcessingAvailabilityResultTypeNotYetAvailable,
+		},
+		{
+			name:      "unavailable invalid svcExport (annotation weight is 1)",
+			svcExport: unavailableInvalidNoConflictSvcExport,
+			wantManifestProcessingAvailabilityResultType: ManifestProcessingAvailabilityResultTypeNotYetAvailable,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			gotResTyp, err := trackServiceExportAvailability(toUnstructured(t, tc.svcExport))
+			if err != nil {
+				t.Fatalf("trackServiceExportAvailability() = %v, want no error", err)
+			}
+			if gotResTyp != tc.wantManifestProcessingAvailabilityResultType {
+				t.Errorf("manifestProcessingAvailabilityResultType = %v, want %v", gotResTyp, tc.wantManifestProcessingAvailabilityResultType)
+			}
+		})
+	}
+}
+
 // TestTrackInMemberClusterObjAvailability tests the trackInMemberClusterObjAvailability method.
 func TestTrackInMemberClusterObjAvailability(t *testing.T) {
 	ctx := context.Background()

pkg/utils/common.go

@@ -358,6 +358,12 @@ var (
 		Resource: "serviceaccounts",
 	}
 
+	ServiceExportGVR = schema.GroupVersionResource{
+		Group:    fleetnetworkingv1alpha1.GroupVersion.Group,
+		Version:  fleetnetworkingv1alpha1.GroupVersion.Version,
+		Resource: "serviceexports",
+	}
+
 	StorageClassGVR = schema.GroupVersionResource{
 		Group:    storagev1.SchemeGroupVersion.Group,
 		Version:  storagev1.SchemeGroupVersion.Version,