feat: delete registry syncer HCP

Author: dkoshkin

pkg/handlers/generic/lifecycle/registry/cncfdistribution/handler.go

@@ -155,6 +155,26 @@ func (n *CNCFDistribution) Apply(
 	return nil
 }
 
+func (n *CNCFDistribution) Cleanup(
+	ctx context.Context,
+	_ v1alpha1.RegistryAddon,
+	cluster *clusterv1.Cluster,
+	log logr.Logger,
+) error {
+	// Delete any registry syncer artifacts.
+	registrySyncer := syncer.New(
+		n.client,
+		&syncer.Config{GlobalOptions: n.config.GlobalOptions},
+		n.helmChartInfoGetter,
+	)
+	err := registrySyncer.Cleanup(ctx, cluster, log)
+	if err != nil {
+		return fmt.Errorf("failed to clean up CNCF Distribution registry syncer: %w", err)
+	}
+
+	return nil
+}
+
 func templateValues(cluster *clusterv1.Cluster, text string) (string, error) {
 	valuesTemplate, err := template.New("").Parse(text)
 	if err != nil {

pkg/handlers/generic/lifecycle/registry/handler.go

@@ -32,6 +32,12 @@ type RegistryProvider interface {
 		cluster *clusterv1.Cluster,
 		log logr.Logger,
 	) error
+	Cleanup(
+		ctx context.Context,
+		registryVar v1alpha1.RegistryAddon,
+		cluster *clusterv1.Cluster,
+		log logr.Logger,
+	) error
 }
 
 type RegistryHandler struct {
@@ -266,3 +272,84 @@ func (r *RegistryHandler) apply(
 		),
 	)
 }
+
+func (r *RegistryHandler) BeforeClusterDelete(
+	ctx context.Context,
+	req *runtimehooksv1.BeforeClusterDeleteRequest,
+	resp *runtimehooksv1.BeforeClusterDeleteResponse,
+) {
+	cluster := &req.Cluster
+
+	clusterKey := ctrlclient.ObjectKeyFromObject(cluster)
+
+	log := ctrl.LoggerFrom(ctx).WithValues(
+		"cluster",
+		clusterKey,
+	)
+
+	varMap := variables.ClusterVariablesToVariablesMap(cluster.Spec.Topology.Variables)
+	registryVar, err := variables.Get[v1alpha1.RegistryAddon](
+		varMap,
+		r.variableName,
+		r.variablePath...)
+	if err != nil {
+		if variables.IsNotFoundError(err) {
+			log.V(5).
+				Info(
+					"Skipping RegistryAddon, field is not specified",
+					"error",
+					err,
+				)
+			return
+		}
+		log.Error(
+			err,
+			"failed to read RegistryAddon provider from cluster definition",
+		)
+		resp.SetStatus(runtimehooksv1.ResponseStatusFailure)
+		resp.SetMessage(
+			fmt.Sprintf("failed to read RegistryAddon provider from cluster definition: %v",
+				err,
+			),
+		)
+		return
+	}
+
+	handler, ok := r.ProviderHandler[registryVar.Provider]
+	if !ok {
+		err = fmt.Errorf("unknown RegistryAddon Provider")
+		log.Error(err, "provider", registryVar.Provider)
+		resp.SetStatus(runtimehooksv1.ResponseStatusFailure)
+		resp.SetMessage(
+			fmt.Sprintf("%s %s", err, registryVar.Provider),
+		)
+		return
+	}
+
+	log.Info(fmt.Sprintf("Clean up RegistryAddon provider %s", registryVar.Provider))
+	err = handler.Cleanup(
+		ctx,
+		registryVar,
+		cluster,
+		log,
+	)
+	if err != nil {
+		log.Error(
+			err,
+			fmt.Sprintf(
+				"failed to clean up RegistryAddon provider %s",
+				registryVar.Provider,
+			),
+		)
+		resp.SetStatus(runtimehooksv1.ResponseStatusFailure)
+		resp.SetMessage(
+			fmt.Sprintf(
+				"failed to clean up RegistryAddon provider: %v",
+				err,
+			),
+		)
+		return
+	}
+
+	resp.SetStatus(runtimehooksv1.ResponseStatusSuccess)
+}

pkg/handlers/generic/lifecycle/registry/syncer/applier.go renamed to pkg/handlers/generic/lifecycle/registry/syncer/syncer.go

@@ -10,9 +10,11 @@ import (
 	"text/template"
 
 	"github.com/go-logr/logr"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
 	ctrlclient "sigs.k8s.io/controller-runtime/pkg/client"
 
+	caaphv1 "github.com/nutanix-cloud-native/cluster-api-runtime-extensions-nutanix/api/external/sigs.k8s.io/cluster-api-addon-provider-helm/api/v1alpha1"
 	_ "github.com/nutanix-cloud-native/cluster-api-runtime-extensions-nutanix/api/v1alpha1"
 	carenv1 "github.com/nutanix-cloud-native/cluster-api-runtime-extensions-nutanix/api/v1alpha1"
 	"github.com/nutanix-cloud-native/cluster-api-runtime-extensions-nutanix/api/variables"
@@ -102,6 +104,47 @@ func (n *RegistrySyncer) Apply(
 	return nil
 }
 
+// Cleanup cleans up the HCP on the management cluster for the cluster.
+// The syncer is applied against the management cluster can be in a different namespace from cluster.
+// Since cross-namespace owner references are not allowed, we need to delete the HelmChartProxy directly.
+func (n *RegistrySyncer) Cleanup(
+	ctx context.Context,
+	cluster *clusterv1.Cluster,
+	log logr.Logger,
+) error {
+	log.Info("Checking if registry syncer needs to be cleaned up")
+	managementCluster, err := capiutils.ManagementCluster(ctx, n.client)
+	if err != nil {
+		return fmt.Errorf("failed to get management cluster: %w", err)
+	}
+	shouldApply, err := shouldApplyRegistrySyncer(cluster, managementCluster)
+	if err != nil {
+		return fmt.Errorf("failed to check if registry syncer should be cleaned up: %w", err)
+	}
+	if !shouldApply {
+		log.Info("Skipping registry syncer cleanup as it is not required")
+		return nil
+	}
+
+	log.Info("Cleaning up registry syncer for cluster")
+	hcp := &caaphv1.HelmChartProxy{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      addonResourceNameForCluster(cluster),
+			Namespace: managementCluster.Namespace,
+		},
+	}
+
+	err = ctrlclient.IgnoreNotFound(n.client.Delete(ctx, hcp))
+	if err != nil {
+		return fmt.Errorf(
+			"failed to delete regystry syncer installation HelmChartProxy: %w",
+			err,
+		)
+	}
+
+	return nil
+}
+
 // shouldApply returns false if:
 // - the management cluster is nil, ie. this cluster will become the management cluster
 // - the management cluster name and namespace matches the workload cluster

pkg/handlers/generic/lifecycle/registry/syncer/applier_integration_test.go renamed to pkg/handlers/generic/lifecycle/registry/syncer/syncer_integration_test.go

@@ -10,6 +10,7 @@ import (
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	corev1 "k8s.io/api/core/v1"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
@@ -27,13 +28,13 @@ import (
 	"github.com/nutanix-cloud-native/cluster-api-runtime-extensions-nutanix/test/helpers"
 )
 
-var _ = Describe("Test Syncer Apply", func() {
+var _ = Describe("Test Syncer", func() {
 	clientScheme := runtime.NewScheme()
 	utilruntime.Must(clientgoscheme.AddToScheme(clientScheme))
 	utilruntime.Must(clusterv1.AddToScheme(clientScheme))
 	utilruntime.Must(caaphv1.AddToScheme(clientScheme))
 
-	It("Should create HelmChartProxy", func(ctx SpecContext) {
+	It("Should create HelmChartProxy and then delete it", func(ctx SpecContext) {
 		t := GinkgoT()
 		featuregatetesting.SetFeatureGateDuringTest(
 			t,
@@ -101,6 +102,14 @@ var _ = Describe("Test Syncer Apply", func() {
 
 		expectedMatchLabels := map[string]string{clusterv1.ClusterNameLabel: managementCluster.Name}
 		Expect(registrySyncerHelmChartProxy.Spec.ClusterSelector.MatchLabels).To(Equal(expectedMatchLabels))
+
+		// Run the cleanup and verify that the HelmChartProxy is deleted.
+		err = syncer.Cleanup(ctx, workloadCluster, logr.Discard())
+		Expect(err).To(BeNil())
+
+		err = c.Get(ctx, registrySyncerHelmChartProxyKey, registrySyncerHelmChartProxy)
+		Expect(err).ToNot(BeNil())
+		Expect(apierrors.IsNotFound(err)).To(BeTrue())
 	})
 	AfterEach(func(ctx SpecContext) {
 		c, err := helpers.TestEnv.GetK8sClientWithScheme(clientScheme)