[WIP] (rebasing) ✨ Introduce generics to providers

cmd/main.go

@@ -48,6 +48,8 @@
 	operatorv1 "sigs.k8s.io/cluster-api-operator/api/v1alpha2"
 	providercontroller "sigs.k8s.io/cluster-api-operator/internal/controller"
 	healtchcheckcontroller "sigs.k8s.io/cluster-api-operator/internal/controller/healthcheck"
+	"sigs.k8s.io/cluster-api-operator/internal/controller/phases"
+	"sigs.k8s.io/cluster-api-operator/internal/controller/providers"
 )
 
 var (
@@ -134,7 +136,9 @@
 	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
 	pflag.Parse()
 
-	ctrl.SetLogger(textlogger.NewLogger(textlogger.NewConfig()))
+	loggerConfig := textlogger.NewConfig([]textlogger.ConfigOption{}...)
+	ctrl.SetLogger(textlogger.NewLogger(loggerConfig))
+
 	restConfig := ctrl.GetConfigOrDie()
 
 	tlsOptions, metricsOptions, err := flags.GetManagerOptions(managerOptions)
@@ -220,79 +224,65 @@
 }
 
 func setupReconcilers(ctx context.Context, mgr ctrl.Manager, watchConfigSecretChanges bool) {
-	if err := (&providercontroller.GenericProviderReconciler{
-		Provider:                 &operatorv1.CoreProvider{},
-		ProviderList:             &operatorv1.CoreProviderList{},
-		Client:                   mgr.GetClient(),
-		Config:                   mgr.GetConfig(),
-		WatchConfigSecretChanges: watchConfigSecretChanges,
-	}).SetupWithManager(ctx, mgr, concurrency(concurrencyNumber)); err != nil {
+	if err := providercontroller.NewProviderControllerWrapper(
+		providers.NewCoreProviderReconciler(mgr),
+		phases.NewPhase,
+		watchConfigSecretChanges,
+	).SetupWithManager(ctx, mgr, concurrency(concurrencyNumber)); err != nil {
 		setupLog.Error(err, "unable to create controller", "controller", "CoreProvider")
 		os.Exit(1)
 	}
 
-	if err := (&providercontroller.GenericProviderReconciler{
-		Provider:                 &operatorv1.InfrastructureProvider{},
-		ProviderList:             &operatorv1.InfrastructureProviderList{},
-		Client:                   mgr.GetClient(),
-		Config:                   mgr.GetConfig(),
-		WatchConfigSecretChanges: watchConfigSecretChanges,
-	}).SetupWithManager(ctx, mgr, concurrency(concurrencyNumber)); err != nil {
+	if err := providercontroller.NewProviderControllerWrapper(
+		providers.NewInfrastructureProviderReconciler(mgr),
+		phases.NewPhase,
+		watchConfigSecretChanges,
+	).SetupWithManager(ctx, mgr, concurrency(concurrencyNumber)); err != nil {
 		setupLog.Error(err, "unable to create controller", "controller", "InfrastructureProvider")
 		os.Exit(1)
 	}
 
-	if err := (&providercontroller.GenericProviderReconciler{
-		Provider:                 &operatorv1.BootstrapProvider{},
-		ProviderList:             &operatorv1.BootstrapProviderList{},
-		Client:                   mgr.GetClient(),
-		Config:                   mgr.GetConfig(),
-		WatchConfigSecretChanges: watchConfigSecretChanges,
-	}).SetupWithManager(ctx, mgr, concurrency(concurrencyNumber)); err != nil {
+	if err := providercontroller.NewProviderControllerWrapper(
+		providers.NewBootstrapProviderReconciler(mgr),
+		phases.NewPhase,
+		watchConfigSecretChanges,
+	).SetupWithManager(ctx, mgr, concurrency(concurrencyNumber)); err != nil {
 		setupLog.Error(err, "unable to create controller", "controller", "BootstrapProvider")
 		os.Exit(1)
 	}
 
-	if err := (&providercontroller.GenericProviderReconciler{
-		Provider:                 &operatorv1.ControlPlaneProvider{},
-		ProviderList:             &operatorv1.ControlPlaneProviderList{},
-		Client:                   mgr.GetClient(),
-		Config:                   mgr.GetConfig(),
-		WatchConfigSecretChanges: watchConfigSecretChanges,
-	}).SetupWithManager(ctx, mgr, concurrency(concurrencyNumber)); err != nil {
+	if err := providercontroller.NewProviderControllerWrapper(
+		providers.NewControlPlaneProviderReconciler(mgr),
+		phases.NewPhase,
+		watchConfigSecretChanges,
+	).SetupWithManager(ctx, mgr, concurrency(concurrencyNumber)); err != nil {
 		setupLog.Error(err, "unable to create controller", "controller", "ControlPlaneProvider")
 		os.Exit(1)
 	}
 
-	if err := (&providercontroller.GenericProviderReconciler{
-		Provider:                 &operatorv1.AddonProvider{},
-		ProviderList:             &operatorv1.AddonProviderList{},
-		Client:                   mgr.GetClient(),
-		Config:                   mgr.GetConfig(),
-		WatchConfigSecretChanges: watchConfigSecretChanges,
-	}).SetupWithManager(ctx, mgr, concurrency(concurrencyNumber)); err != nil {
+	if err := providercontroller.NewProviderControllerWrapper(
+		providers.NewAddonProviderReconciler(mgr),
+		phases.NewPhase,
+		watchConfigSecretChanges,
+	).SetupWithManager(ctx, mgr, concurrency(concurrencyNumber)); err != nil {
 		setupLog.Error(err, "unable to create controller", "controller", "AddonProvider")
 		os.Exit(1)
 	}
 
-	if err := (&providercontroller.GenericProviderReconciler{
-		Provider:                 &operatorv1.IPAMProvider{},
-		ProviderList:             &operatorv1.IPAMProviderList{},
-		Client:                   mgr.GetClient(),
-		Config:                   mgr.GetConfig(),
-		WatchConfigSecretChanges: watchConfigSecretChanges,
-	}).SetupWithManager(ctx, mgr, concurrency(concurrencyNumber)); err != nil {
+	if err := providercontroller.NewProviderControllerWrapper(
+		providers.NewIPAMProviderReconciler(mgr),
+		phases.NewPhase,
+		watchConfigSecretChanges,
+	).SetupWithManager(ctx, mgr, concurrency(concurrencyNumber)); err != nil {
 		setupLog.Error(err, "unable to create controller", "controller", "IPAMProvider")
 		os.Exit(1)
 	}
 
-	if err := (&providercontroller.GenericProviderReconciler{
-		Provider:                 &operatorv1.RuntimeExtensionProvider{},
-		ProviderList:             &operatorv1.RuntimeExtensionProviderList{},
-		Client:                   mgr.GetClient(),
-		Config:                   mgr.GetConfig(),
-		WatchConfigSecretChanges: watchConfigSecretChanges,
-	}).SetupWithManager(ctx, mgr, concurrency(concurrencyNumber)); err != nil {
+	if err := providercontroller.NewProviderControllerWrapper(
+		providers.NewRuntimeExtensionProviderReconciler(mgr),
+		phases.NewPhase,
+		watchConfigSecretChanges,
+	).SetupWithManager(ctx, mgr, concurrency(concurrencyNumber)); err != nil {
 		setupLog.Error(err, "unable to create controller", "controller", "RuntimeExtensionProvider")
 		os.Exit(1)
 	}

cmd/plugin/cmd/delete.go

@@ -28,16 +28,18 @@ import (
 	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/fields"
-	kerrors "k8s.io/apimachinery/pkg/util/errors"
 	"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/klog/v2/textlogger"
+
+	kerrors "k8s.io/apimachinery/pkg/util/errors"
 	ctrl "sigs.k8s.io/controller-runtime"
 
 	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	ctrlclient "sigs.k8s.io/controller-runtime/pkg/client"
 
 	operatorv1 "sigs.k8s.io/cluster-api-operator/api/v1alpha2"
+	"sigs.k8s.io/cluster-api-operator/internal/controller/generic"
 )
 
 type deleteOptions struct {
@@ -139,7 +141,8 @@ func init() {
 func runDelete() error {
 	ctx := context.Background()
 
-	ctrl.SetLogger(textlogger.NewLogger(textlogger.NewConfig()))
+	loggerConfig := textlogger.NewConfig([]textlogger.ConfigOption{}...)
+	ctrl.SetLogger(textlogger.NewLogger(loggerConfig))
 
 	hasProviderNames := deleteOpts.coreProvider ||
 		(len(deleteOpts.bootstrapProviders) > 0) ||
@@ -168,7 +171,7 @@ func runDelete() error {
 
 	group := &DeleteGroup{
 		selectors: []fields.Set{},
-		providers: []genericProviderList{},
+		providers: []generic.ProviderList{},
 	}
 	errors := append([]error{},
 		group.delete(&operatorv1.BootstrapProviderList{}, deleteOpts.bootstrapProviders...),
@@ -195,10 +198,10 @@ func runDelete() error {
 
 type DeleteGroup struct {
 	selectors []fields.Set
-	providers []genericProviderList
+	providers []generic.ProviderList
 }
 
-func (d *DeleteGroup) delete(providerType genericProviderList, names ...string) error {
+func (d *DeleteGroup) delete(providerType generic.ProviderList, names ...string) error {
 	for _, provider := range names {
 		selector, err := selectorFromProvider(provider)
 		if err != nil {
@@ -214,7 +217,7 @@ func (d *DeleteGroup) delete(providerType genericProviderList, names ...string)
 
 func (d *DeleteGroup) deleteAll() {
 	for _, list := range operatorv1.ProviderLists {
-		providerList, ok := list.(genericProviderList)
+		providerList, ok := list.(generic.ProviderList)
 		if !ok {
 			log.V(5).Info("Expected to get GenericProviderList")
 			continue
@@ -282,9 +285,9 @@ func selectorFromProvider(provider string) (fields.Set, error) {
 	return selector, nil
 }
 
-func deleteProviders(ctx context.Context, client ctrlclient.Client, providerList genericProviderList, selector ctrlclient.MatchingFieldsSelector) (bool, error) {
+func deleteProviders(ctx context.Context, client ctrlclient.Client, providerList generic.ProviderList, selector ctrlclient.MatchingFieldsSelector) (bool, error) {
 	//nolint:forcetypeassert
-	providerList = providerList.DeepCopyObject().(genericProviderList)
+	providerList = providerList.DeepCopyObject().(generic.ProviderList)
 	ready := true
 
 	gvks, _, err := scheme.ObjectKinds(providerList)
@@ -305,12 +308,6 @@ func deleteProviders(ctx context.Context, client ctrlclient.Client, providerList
 	for _, provider := range providerList.GetItems() {
 		log.Info(fmt.Sprintf("Deleting %s %s/%s", provider.GetType(), provider.GetName(), provider.GetNamespace()))
 
-		provider, ok := provider.(genericProvider)
-		if !ok {
-			log.Info(fmt.Sprintf("Expected to get GenericProvider for %s", gvk))
-			continue
-		}
-
 		if err := client.DeleteAllOf(ctx, provider, ctrlclient.InNamespace(provider.GetNamespace())); err != nil {
 			return false, fmt.Errorf("unable to issue delete for %s: %w", gvk, err)
 		}

cmd/plugin/cmd/delete_test.go

@@ -24,6 +24,7 @@ import (
 	"k8s.io/apimachinery/pkg/fields"
 
 	operatorv1 "sigs.k8s.io/cluster-api-operator/api/v1alpha2"
+	"sigs.k8s.io/cluster-api-operator/internal/controller/generic"
 	ctrlclient "sigs.k8s.io/controller-runtime/pkg/client"
 )
 
@@ -79,13 +80,13 @@ func TestSelectorFromProvider(t *testing.T) {
 func TestDeleteProviders(t *testing.T) {
 	tests := []struct {
 		name      string
-		list      genericProviderList
-		providers []genericProvider
+		list      generic.ProviderList
+		providers []generic.Provider
 		selector  fields.Set
 	}{{
 		name: "Delete providers",
 		list: &operatorv1.AddonProviderList{},
-		providers: []genericProvider{&operatorv1.AddonProvider{
+		providers: []generic.Provider{&operatorv1.AddonProvider{
 			ObjectMeta: metav1.ObjectMeta{
 				Name:      "addon",
 				Namespace: "default",

cmd/plugin/cmd/init.go

@@ -28,16 +28,16 @@ import (
 	corev1 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/util/wait"
+	operatorv1 "sigs.k8s.io/cluster-api-operator/api/v1alpha2"
+	"sigs.k8s.io/cluster-api-operator/internal/controller/generic"
+	"sigs.k8s.io/cluster-api-operator/util"
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
 	clusterctlv1 "sigs.k8s.io/cluster-api/cmd/clusterctl/api/v1alpha3"
 	"sigs.k8s.io/cluster-api/cmd/clusterctl/client/cluster"
 	configclient "sigs.k8s.io/cluster-api/cmd/clusterctl/client/config"
 	"sigs.k8s.io/cluster-api/cmd/clusterctl/client/repository"
 	"sigs.k8s.io/cluster-api/cmd/clusterctl/client/yamlprocessor"
 	ctrlclient "sigs.k8s.io/controller-runtime/pkg/client"
-
-	operatorv1 "sigs.k8s.io/cluster-api-operator/api/v1alpha2"
-	"sigs.k8s.io/cluster-api-operator/util"
 )
 
 type initOptions struct {
@@ -482,7 +482,8 @@ func templateGenericProvider(providerType clusterctlv1.ProviderType, providerInp
 		return nil, fmt.Errorf("provider name can't be empty")
 	}
 
-	provider := NewGenericProvider(providerType)
+	rec := generic.ProviderReconcilers[providerType]
+	provider := rec.GenericProvider()
 
 	// Set name and namespace
 	provider.SetName(name)