Expose GenericProvider reconciliation with phases

Implement a phase-based framework for reconciling generic providers.
This refactors the main reconciliation loop into a sequence of distinct, ordered phases (e.g., download, install, delete).
Introduce `PhaseFn` and `phaseReconciler` types to manage phase execution.
Move existing reconciliation logic into dedicated phase functions.
Update the external `controller` package to epose aliases pointing to the refactored internal types for external import.

Signed-off-by: Danil-Grigorev <[email protected]>

Author: Danil-Grigorev

controller/alias.go

@@ -21,45 +21,21 @@ to allow external users to interact with the core controller logic.
 package controller
 
 import (
-	"context"
-
-	"k8s.io/client-go/rest"
-	internalcontroller "sigs.k8s.io/cluster-api-operator/internal/controller"
-	"sigs.k8s.io/cluster-api-operator/internal/controller/genericprovider"
+	providercontroller "sigs.k8s.io/cluster-api-operator/internal/controller"
 	internalhealthcheck "sigs.k8s.io/cluster-api-operator/internal/controller/healthcheck"
-	ctrl "sigs.k8s.io/controller-runtime"
-	"sigs.k8s.io/controller-runtime/pkg/client"
-	"sigs.k8s.io/controller-runtime/pkg/controller"
 )
 
 // GenericProviderReconciler wraps the internal GenericProviderReconciler.
-type GenericProviderReconciler struct {
-	Provider                 genericprovider.GenericProvider
-	ProviderList             genericprovider.GenericProviderList
-	Client                   client.Client
-	Config                   *rest.Config
-	WatchConfigSecretChanges bool
-}
+type GenericProviderReconciler = providercontroller.GenericProviderReconciler
+
+// GenericProviderHealthCheckReconciler wraps the internal GenericProviderHealthCheckReconciler.
+type GenericProviderHealthCheckReconciler = internalhealthcheck.GenericProviderHealthCheckReconciler
 
-// SetupWithManager sets up the GenericProviderReconciler with the Manager.
-func (r *GenericProviderReconciler) SetupWithManager(ctx context.Context, mgr ctrl.Manager, options controller.Options) error {
-	return (&internalcontroller.GenericProviderReconciler{
-		Provider:                 r.Provider,
-		ProviderList:             r.ProviderList,
-		Client:                   r.Client,
-		Config:                   r.Config,
-		WatchConfigSecretChanges: r.WatchConfigSecretChanges,
-	}).SetupWithManager(ctx, mgr, options)
-}
+// PhaseFn is an alias for the internal PhaseFn type.
+type PhaseFn = providercontroller.PhaseFn
 
-// ProviderHealthCheckReconciler wraps the internal ProviderHealthCheckReconciler.
-type ProviderHealthCheckReconciler struct {
-	Client client.Client
-}
+// Result is an alias for the internal Result type.
+type Result = providercontroller.Result
 
-// SetupWithManager sets up the health check controllers with the Manager.
-func (r *ProviderHealthCheckReconciler) SetupWithManager(ctx context.Context, mgr ctrl.Manager, options controller.Options) error {
-	return (&internalhealthcheck.ProviderHealthCheckReconciler{
-		Client: r.Client,
-	}).SetupWithManager(mgr, options)
-}
+// NewPhaseReconciler is an alias for the internal NewPhaseReconciler function.
+var NewPhaseReconciler = providercontroller.NewPhaseReconciler

internal/controller/genericprovider_controller.go

@@ -49,6 +49,9 @@ type GenericProviderReconciler struct {
 	Client                   client.Client
 	Config                   *rest.Config
 	WatchConfigSecretChanges bool
+
+	DeletePhases    []PhaseFn
+	ReconcilePhases []PhaseFn
 }
 
 const (
@@ -82,6 +85,23 @@ func (r *GenericProviderReconciler) SetupWithManager(ctx context.Context, mgr ct
 		)
 	}
 
+	reconciler := NewPhaseReconciler(*r, r.Provider, r.ProviderList)
+
+	r.ReconcilePhases = []PhaseFn{
+		reconciler.PreflightChecks,
+		reconciler.InitializePhaseReconciler,
+		reconciler.DownloadManifests,
+		reconciler.Load,
+		reconciler.Fetch,
+		reconciler.Upgrade,
+		reconciler.Install,
+		reconciler.ReportStatus,
+	}
+
+	r.DeletePhases = []PhaseFn{
+		reconciler.Delete,
+	}
+
 	return builder.WithOptions(options).
 		Complete(r)
 }
@@ -150,7 +170,7 @@ func (r *GenericProviderReconciler) Reconcile(ctx context.Context, req reconcile
 		return ctrl.Result{}, nil
 	}
 
-	res, err := r.reconcile(ctx, r.Provider, r.ProviderList)
+	res, err := r.reconcile(ctx)
 
 	annotations := r.Provider.GetAnnotations()
 	if annotations == nil {
@@ -189,27 +209,15 @@ func patchProvider(ctx context.Context, provider operatorv1.GenericProvider, pat
 	return patchHelper.Patch(ctx, provider, options...)
 }
 
-func (r *GenericProviderReconciler) reconcile(ctx context.Context, provider genericprovider.GenericProvider, genericProviderList genericprovider.GenericProviderList) (*Result, error) {
-	reconciler := NewPhaseReconciler(*r, provider, genericProviderList)
-	phases := []PhaseFn{
-		reconciler.preflightChecks,
-		reconciler.initializePhaseReconciler,
-		reconciler.downloadManifests,
-		reconciler.load,
-		reconciler.fetch,
-		reconciler.upgrade,
-		reconciler.install,
-		reconciler.reportStatus,
-	}
-
+func (r *GenericProviderReconciler) reconcile(ctx context.Context) (*Result, error) {
 	var res Result
 
-	for _, phase := range phases {
+	for _, phase := range r.ReconcilePhases {
 		res, err := phase(ctx)
 		if err != nil {
 			var pe *PhaseError
 			if errors.As(err, &pe) {
-				conditions.Set(provider, conditions.FalseCondition(pe.Type, pe.Reason, pe.Severity, "%s", err.Error()))
+				conditions.Set(r.Provider, conditions.FalseCondition(pe.Type, pe.Reason, pe.Severity, "%s", err.Error()))
 			}
 		}
 
@@ -232,14 +240,9 @@ func (r *GenericProviderReconciler) reconcileDelete(ctx context.Context, provide
 
 	log.Info("Deleting provider resources")
 
-	reconciler := NewPhaseReconciler(*r, provider, nil)
-	phases := []PhaseFn{
-		reconciler.delete,
-	}
-
 	var res Result
 
-	for _, phase := range phases {
+	for _, phase := range r.DeletePhases {
 		res, err := phase(ctx)
 		if err != nil {
 			var pe *PhaseError

internal/controller/manifests_downloader.go

@@ -45,8 +45,8 @@ const (
 	ociSource        = "oci"
 )
 
-// downloadManifests downloads CAPI manifests from a url.
-func (p *PhaseReconciler) downloadManifests(ctx context.Context) (*Result, error) {
+// DownloadManifests downloads CAPI manifests from a url.
+func (p *PhaseReconciler) DownloadManifests(ctx context.Context) (*Result, error) {
 	log := ctrl.LoggerFrom(ctx)
 
 	// Return immediately if a custom config map is used instead of a url.

internal/controller/manifests_downloader_test.go

@@ -51,10 +51,10 @@ func TestManifestsDownloader(t *testing.T) {
 		},
 	}
 
-	_, err := p.initializePhaseReconciler(ctx)
+	_, err := p.InitializePhaseReconciler(ctx)
 	g.Expect(err).ToNot(HaveOccurred())
 
-	_, err = p.downloadManifests(ctx)
+	_, err = p.DownloadManifests(ctx)
 	g.Expect(err).ToNot(HaveOccurred())
 
 	// Ensure that config map was created
@@ -94,16 +94,16 @@ func TestProviderDownloadWithOverrides(t *testing.T) {
 		overridesClient: overridesClient,
 	}
 
-	_, err = p.initializePhaseReconciler(ctx)
+	_, err = p.InitializePhaseReconciler(ctx)
 	g.Expect(err).ToNot(HaveOccurred())
 
-	_, err = p.downloadManifests(ctx)
+	_, err = p.DownloadManifests(ctx)
 	g.Expect(err).ToNot(HaveOccurred())
 
-	_, err = p.load(ctx)
+	_, err = p.Load(ctx)
 	g.Expect(err).ToNot(HaveOccurred())
 
-	_, err = p.fetch(ctx)
+	_, err = p.Fetch(ctx)
 	g.Expect(err).ToNot(HaveOccurred())
 
 	g.Expect(p.components.Images()).To(HaveExactElements([]string{"registry.k8s.io/cluster-api/cluster-api-controller:v1.4.3"}))

internal/controller/phases.go

@@ -160,13 +160,13 @@ func (i InNamespace) ApplyToConfigMapRepository(settings *ConfigMapRepositorySet
 	settings.namespace = string(i)
 }
 
-// preflightChecks a wrapper around the preflight checks.
-func (p *PhaseReconciler) preflightChecks(ctx context.Context) (*Result, error) {
+// PreflightChecks a wrapper around the preflight checks.
+func (p *PhaseReconciler) PreflightChecks(ctx context.Context) (*Result, error) {
 	return &Result{}, preflightChecks(ctx, p.ctrlClient, p.provider, p.providerList)
 }
 
-// initializePhaseReconciler initializes phase reconciler.
-func (p *PhaseReconciler) initializePhaseReconciler(ctx context.Context) (*Result, error) {
+// InitializePhaseReconciler initializes phase reconciler.
+func (p *PhaseReconciler) InitializePhaseReconciler(ctx context.Context) (*Result, error) {
 	path := configPath
 	if _, err := os.Stat(configPath); os.IsNotExist(err) {
 		path = ""
@@ -227,8 +227,8 @@ func (p *PhaseReconciler) initializePhaseReconciler(ctx context.Context) (*Resul
 	return &Result{}, nil
 }
 
-// load provider specific configuration into phaseReconciler object.
-func (p *PhaseReconciler) load(ctx context.Context) (*Result, error) {
+// Load provider specific configuration into phaseReconciler object.
+func (p *PhaseReconciler) Load(ctx context.Context) (*Result, error) {
 	log := ctrl.LoggerFrom(ctx)
 
 	log.Info("Loading provider")
@@ -511,8 +511,8 @@ func (p *PhaseReconciler) validateRepoCAPIVersion(ctx context.Context) error {
 	return nil
 }
 
-// fetch fetches the provider components from the repository and processes all yaml manifests.
-func (p *PhaseReconciler) fetch(ctx context.Context) (*Result, error) {
+// Fetch fetches the provider components from the repository and processes all yaml manifests.
+func (p *PhaseReconciler) Fetch(ctx context.Context) (*Result, error) {
 	log := ctrl.LoggerFrom(ctx)
 	log.Info("Fetching provider")
 
@@ -559,9 +559,9 @@ func (p *PhaseReconciler) fetch(ctx context.Context) (*Result, error) {
 	return &Result{}, nil
 }
 
-// upgrade ensure all the clusterctl CRDs are available before installing the provider,
+// Upgrade ensure all the clusterctl CRDs are available before installing the provider,
 // and update existing components if required.
-func (p *PhaseReconciler) upgrade(ctx context.Context) (*Result, error) {
+func (p *PhaseReconciler) Upgrade(ctx context.Context) (*Result, error) {
 	log := ctrl.LoggerFrom(ctx)
 
 	// Nothing to do if it's a fresh installation.
@@ -589,8 +589,8 @@ func (p *PhaseReconciler) upgrade(ctx context.Context) (*Result, error) {
 	return &Result{}, nil
 }
 
-// install installs the provider components using clusterctl library.
-func (p *PhaseReconciler) install(ctx context.Context) (*Result, error) {
+// Install installs the provider components using clusterctl library.
+func (p *PhaseReconciler) Install(ctx context.Context) (*Result, error) {
 	log := ctrl.LoggerFrom(ctx)
 
 	// Provider was upgraded, nothing to do
@@ -617,7 +617,7 @@ func (p *PhaseReconciler) install(ctx context.Context) (*Result, error) {
 	return &Result{}, nil
 }
 
-func (p *PhaseReconciler) reportStatus(_ context.Context) (*Result, error) {
+func (p *PhaseReconciler) ReportStatus(_ context.Context) (*Result, error) {
 	status := p.provider.GetStatus()
 	status.Contract = &p.contract
 	installedVersion := p.components.Version()
@@ -665,8 +665,8 @@ func loadCustomProviders(providers []operatorv1.GenericProvider, reader configcl
 	return mr, nil
 }
 
-// delete deletes the provider components using clusterctl library.
-func (p *PhaseReconciler) delete(ctx context.Context) (*Result, error) {
+// Delete deletes the provider components using clusterctl library.
+func (p *PhaseReconciler) Delete(ctx context.Context) (*Result, error) {
 	log := ctrl.LoggerFrom(ctx)
 	log.Info("Deleting provider")