feat: Add providers startup flag

Add a new flag to the controller startup that determines what providers
are enabled, if none are specified the list of registered default
providers is used.

The provider factory is updated to take a list of providers that are
enabled and ensures that only providers in this list can be loaded via
the factory methods. Providers themselves optionally register themselves
as "default" providers, in the case where no providers are specified
these providers are enabled in the factory.

Note: `inmemory` provider is temporarily being registered as a default
to allow time for compatibility changes to be made to the kuadrant
operator and will be updated after this is complete to ensure it is not
enabled by default but only in local dev/test environments.

cmd/main.go

@@ -18,6 +18,7 @@ package main
 
 import (
 	"flag"
+	"fmt"
 	"os"
 	"strings"
 	"time"
@@ -67,6 +68,8 @@ func main() {
 	var minRequeueTime time.Duration
 	var validFor time.Duration
 	var maxRequeueTime time.Duration
+	var providers stringSliceFlags
+
 	flag.StringVar(&metricsAddr, "metrics-bind-address", ":8080", "The address the metric endpoint binds to.")
 	flag.StringVar(&probeAddr, "health-probe-bind-address", ":8081", "The address the probe endpoint binds to.")
 	flag.BoolVar(&enableLeaderElection, "leader-elect", false,
@@ -81,13 +84,14 @@ func main() {
 	flag.DurationVar(&minRequeueTime, "min-requeue-time", DefaultValidationDuration,
 		"The minimal timeout between calls to the DNS Provider"+
 			"Controls if we commit to the full reconcile loop")
+	flag.Var(&providers, "provider", "DNS Provider(s) to enable. Can be passed multiple times e.g. --provider aws --provider google, or as a comma separated list e.g. --provider aws,gcp")
 	opts := zap.Options{
 		Development: true,
 	}
 	opts.BindFlags(flag.CommandLine)
 	flag.Parse()
-	logger := zap.New(zap.UseFlagOptions(&opts))
-	ctrl.SetLogger(logger)
+
+	ctrl.SetLogger(zap.New(zap.UseFlagOptions(&opts)))
 
 	var watchNamespaces = "WATCH_NAMESPACES"
 	defaultOptions := ctrl.Options{
@@ -101,15 +105,14 @@ func main() {
 
 	if watch := os.Getenv(watchNamespaces); watch != "" {
 		namespaces := strings.Split(watch, ",")
-		logger.Info("watching namespaces set ", watchNamespaces, namespaces)
+		setupLog.Info("watching namespaces set ", watchNamespaces, namespaces)
 		cacheOpts := cache.Options{
 			DefaultNamespaces: map[string]cache.Config{},
 		}
 		for _, ns := range namespaces {
 			cacheOpts.DefaultNamespaces[ns] = cache.Config{}
 		}
 		defaultOptions.Cache = cacheOpts
-
 	}
 
 	mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), defaultOptions)
@@ -118,7 +121,21 @@ func main() {
 		os.Exit(1)
 	}
 
-	providerFactory := provider.NewFactory(mgr.GetClient())
+	if len(providers) == 0 {
+		defaultProviders := provider.RegisteredDefaultProviders()
+		if defaultProviders == nil {
+			setupLog.Error(fmt.Errorf("no default providers registered"), "unable to set providers")
+			os.Exit(1)
+		}
+		providers = defaultProviders
+	}
+
+	setupLog.Info("init provider factory", "providers", providers)
+	providerFactory, err := provider.NewFactory(mgr.GetClient(), providers)
+	if err != nil {
+		setupLog.Error(err, "unable to create provider factory")
+		os.Exit(1)
+	}
 
 	if err = (&controller.ManagedZoneReconciler{
 		Client:          mgr.GetClient(),
@@ -154,3 +171,24 @@ func main() {
 		os.Exit(1)
 	}
 }
+
+type stringSliceFlags []string
+
+func (n *stringSliceFlags) String() string {
+	return strings.Join(*n, ",")
+}
+
+func (n *stringSliceFlags) Set(s string) error {
+	if len(s) == 0 {
+		return fmt.Errorf("cannot be empty")
+	}
+	for _, strVal := range strings.Split(s, ",") {
+		for _, v := range *n {
+			if v == strVal {
+				return nil
+			}
+		}
+		*n = append(*n, strVal)
+	}
+	return nil
+}

go.mod

@@ -15,6 +15,7 @@ require (
 	github.com/rs/xid v1.5.0
 	github.com/sirupsen/logrus v1.9.3
 	github.com/stretchr/testify v1.8.4
+	golang.org/x/exp v0.0.0-20231006140011-7918f672742d
 	google.golang.org/api v0.134.0
 	k8s.io/api v0.28.3
 	k8s.io/apimachinery v0.28.3
@@ -78,7 +79,6 @@ require (
 	go.uber.org/multierr v1.11.0 // indirect
 	go.uber.org/zap v1.26.0 // indirect
 	golang.org/x/crypto v0.21.0 // indirect
-	golang.org/x/exp v0.0.0-20231006140011-7918f672742d // indirect
 	golang.org/x/net v0.23.0 // indirect
 	golang.org/x/oauth2 v0.13.0 // indirect
 	golang.org/x/sys v0.18.0 // indirect

internal/controller/suite_test.go

@@ -99,7 +99,8 @@ var _ = BeforeSuite(func() {
 	})
 	Expect(err).ToNot(HaveOccurred())
 
-	providerFactory := provider.NewFactory(mgr.GetClient())
+	providerFactory, err := provider.NewFactory(mgr.GetClient(), []string{"inmemory"})
+	Expect(err).ToNot(HaveOccurred())
 
 	err = (&ManagedZoneReconciler{
 		Client:          mgr.GetClient(),

internal/provider/aws/aws.go

@@ -264,5 +264,5 @@ func (*Route53DNSProvider) ProviderSpecific() provider.ProviderSpecificLabels {
 
 // Register this Provider with the provider factory
 func init() {
-	provider.RegisterProvider("aws", NewProviderFromSecret)
+	provider.RegisterProvider("aws", NewProviderFromSecret, true)
 }

internal/provider/factory.go

@@ -2,9 +2,13 @@ package provider
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"slices"
 	"sync"
 
+	"golang.org/x/exp/maps"
+
 	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"sigs.k8s.io/controller-runtime/pkg/client"
@@ -23,14 +27,23 @@ type ProviderConstructor func(context.Context, *v1.Secret, Config) (Provider, er
 var (
 	constructors     = make(map[string]ProviderConstructor)
 	constructorsLock sync.RWMutex
+	defaultProviders []string
 )
 
 // RegisterProvider will register a provider constructor, so it can be used within the application.
-// 'name' should be unique, and should be used to identify this provider.
-func RegisterProvider(name string, c ProviderConstructor) {
+// 'name' should be unique, and should be used to identify this provider
+// `asDefault` indicates if the provider should be added as a default provider and included in the default providers list.
+func RegisterProvider(name string, c ProviderConstructor, asDefault bool) {
 	constructorsLock.Lock()
 	defer constructorsLock.Unlock()
 	constructors[name] = c
+	if asDefault {
+		defaultProviders = append(defaultProviders, name)
+	}
+}
+
+func RegisteredDefaultProviders() []string {
+	return defaultProviders
 }
 
 // Factory is an interface that can be used to obtain Provider implementations.
@@ -42,11 +55,20 @@ type Factory interface {
 // factory is the default Factory implementation
 type factory struct {
 	client.Client
+	providers []string
 }
 
-// NewFactory returns a new provider factory with the given client.
-func NewFactory(c client.Client) Factory {
-	return &factory{Client: c}
+// NewFactory returns a new provider factory with the given client and given providers enabled.
+// Will return an error if any given provider has no registered provider implementation.
+func NewFactory(c client.Client, p []string) (Factory, error) {
+	var err error
+	registeredProviders := maps.Keys(constructors)
+	for _, provider := range p {
+		if !slices.Contains(registeredProviders, provider) {
+			err = errors.Join(err, fmt.Errorf("provider '%s' not registered", provider))
+		}
+	}
+	return &factory{Client: c, providers: p}, err
 }
 
 // ProviderFor will return a Provider interface for the given ProviderAccessor secret.
@@ -62,18 +84,21 @@ func (f *factory) ProviderFor(ctx context.Context, pa v1alpha1.ProviderAccessor,
 		return nil, err
 	}
 
-	providerType, err := nameForProviderSecret(providerSecret)
+	provider, err := nameForProviderSecret(providerSecret)
 	if err != nil {
 		return nil, err
 	}
 
 	constructorsLock.RLock()
 	defer constructorsLock.RUnlock()
-	if constructor, ok := constructors[providerType]; ok {
+	if constructor, ok := constructors[provider]; ok {
+		if !slices.Contains(f.providers, provider) {
+			return nil, fmt.Errorf("provider '%s' not enabled", provider)
+		}
 		return constructor(ctx, providerSecret, c)
 	}
 
-	return nil, fmt.Errorf("provider '%s' not registered", providerType)
+	return nil, fmt.Errorf("provider '%s' not registered", provider)
 }
 
 func nameForProviderSecret(secret *v1.Secret) (string, error) {

internal/provider/google/google.go

@@ -719,5 +719,5 @@ func (p *GoogleDNSProvider) getResourceRecordSets(ctx context.Context, zoneID st
 
 // Register this Provider with the provider factory
 func init() {
-	provider.RegisterProvider("google", NewProviderFromSecret)
+	provider.RegisterProvider("google", NewProviderFromSecret, true)
 }

internal/provider/inmemory/inmemory.go

@@ -91,5 +91,7 @@ func (i InMemoryDNSProvider) ProviderSpecific() provider.ProviderSpecificLabels
 // Register this Provider with the provider factory
 func init() {
 	client = inmemory.NewInMemoryClient()
-	provider.RegisterProvider("inmemory", NewProviderFromSecret)
+	//ToDo mnairn: This is temporarily being registered as a default to allow time for compatibility changes to be made
+	// to the kuadrant operator dev/test deployment.
+	provider.RegisterProvider("inmemory", NewProviderFromSecret, true)
 }

test/e2e/suite_test.go

@@ -168,7 +168,11 @@ func EndpointsForHost(ctx context.Context, provider provider.Provider, host stri
 }
 
 func providerForManagedZone(ctx context.Context, mz *v1alpha1.ManagedZone) (provider.Provider, error) {
-	providerFactory := provider.NewFactory(k8sClient)
+	//ToDo mnairn: We have a mismatch in naming GCP vs Google, we need to make this consistent one way or the other
+	providerFactory, err := provider.NewFactory(k8sClient, []string{"aws", "google"})
+	if err != nil {
+		return nil, err
+	}
 	providerConfig := provider.Config{
 		DomainFilter:   externaldnsendpoint.NewDomainFilter([]string{mz.Spec.DomainName}),
 		ZoneTypeFilter: externaldnsprovider.NewZoneTypeFilter(""),