From 499680a7bed6f02cfabc2e8ff8076c03bd1fafb9 Mon Sep 17 00:00:00 2001 From: Matthew Barnes Date: Thu, 2 Nov 2023 10:38:55 -0400 Subject: [PATCH] operator: Add reconcile methods to AROReconciler interface This introduces two new methods in AROReconciler: ReconcileEnabled(ctx, request, cluster) -> (result, error) ReconcileDisabled(ctx, request, cluster) -> (result, error) One or the other method will be called based on the controller's "enabled" operator flag. AROController itself now implements the Reconcile method in order to consistently handle disabled controllers. Subtypes need only implement the ReconcileEnabled method, called when the controller is enabled. The Reconcile method uses the "template method" design pattern from object-oriented programming. This warrants some explanation since the pattern looks a little odd in Golang. Some background reading: https://golangbyexample.com/template-method-design-pattern-golang/ AROController provides ReconcileDisabled but leaves ReconcileEnabled unimplemented, so ReconcileEnabled is effectively an abstract method. Therefore AROController itself is not an AROReconciler according to Golang's interface semantics, but its subtypes are. Because AROController's Reconcile method calls ReconcileEnabled, which is abstract, it needs a way to cast itself to an AROReconciler. This is the purpose of the Reconciler field in AROController. The field is set during subtype instantiation: r := ExampleReconciler{ AROController: base.AROController { Log: ... Client: ... Name: ... EnabledFlag: ... } } r.Reconciler = r return r The Reconciler field is essentially a virtual method table like those inherent in polymorphic languages like C++ and Python. It allows AROController to call abstract AROReconciler methods that are implemented by a subtype. --- .../controllers/base/aro_controller.go | 26 +++++++++++++++++++ .../cloudproviderconfig_controller.go | 17 +++--------- .../controllers/dnsmasq/cluster_controller.go | 17 ++++-------- .../dnsmasq/machineconfig_controller.go | 18 +++++-------- .../dnsmasq/machineconfigpool_controller.go | 18 +++++-------- .../genevalogging/genevalogging_controller.go | 20 ++++---------- .../imageconfig/image_controller.go | 17 ++++-------- .../controllers/ingress/ingress_controller.go | 17 ++++-------- .../machinehealthcheck_controller.go | 20 +++++--------- .../machineset/machineset_controller.go | 19 +++++--------- .../monitoring/monitoring_controller.go | 17 +++--------- .../controllers/node/node_controller.go | 19 +++++--------- 12 files changed, 84 insertions(+), 141 deletions(-) diff --git a/pkg/operator/controllers/base/aro_controller.go b/pkg/operator/controllers/base/aro_controller.go index 0e96c448c7a..5a7a3c1ccce 100644 --- a/pkg/operator/controllers/base/aro_controller.go +++ b/pkg/operator/controllers/base/aro_controller.go @@ -13,16 +13,21 @@ import ( "k8s.io/apimachinery/pkg/types" ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/reconcile" arov1alpha1 "github.com/Azure/ARO-RP/pkg/operator/apis/aro.openshift.io/v1alpha1" ) type AROReconciler interface { + reconcile.Reconciler GetName() string SetupWithManager(ctrl.Manager) error + ReconcileEnabled(context.Context, ctrl.Request, *arov1alpha1.Cluster) (ctrl.Result, error) + ReconcileDisabled(context.Context, ctrl.Request, *arov1alpha1.Cluster) (ctrl.Result, error) } type AROController struct { + Reconciler AROReconciler // virtual method table Log *logrus.Entry Client client.Client Name string @@ -33,6 +38,27 @@ func (c *AROController) GetName() string { return c.Name } +func (c *AROController) Reconcile(ctx context.Context, request ctrl.Request) (ctrl.Result, error) { + cluster, err := c.GetCluster(ctx) + if err != nil { + return reconcile.Result{}, err + } + + // Controller can be disabled if it defines an "enabled" operator flag. + if c.EnabledFlag != "" && !cluster.Spec.OperatorFlags.GetSimpleBoolean(c.EnabledFlag) { + c.Log.Debug("controller is disabled") + return c.Reconciler.ReconcileDisabled(ctx, request, cluster) + } + + c.Log.Debug("running") + return c.Reconciler.ReconcileEnabled(ctx, request, cluster) +} + +func (c *AROController) ReconcileDisabled(ctx context.Context, request ctrl.Request, cluster *arov1alpha1.Cluster) (ctrl.Result, error) { + c.ClearConditions(ctx) + return reconcile.Result{}, nil +} + func (c *AROController) SetConditions(ctx context.Context, cnds ...*operatorv1.OperatorCondition) { cluster, err := c.GetCluster(ctx) if err != nil { diff --git a/pkg/operator/controllers/cloudproviderconfig/cloudproviderconfig_controller.go b/pkg/operator/controllers/cloudproviderconfig/cloudproviderconfig_controller.go index fe85c1cabbb..cf9ea5bd071 100644 --- a/pkg/operator/controllers/cloudproviderconfig/cloudproviderconfig_controller.go +++ b/pkg/operator/controllers/cloudproviderconfig/cloudproviderconfig_controller.go @@ -133,7 +133,7 @@ type CloudProviderConfigReconciler struct { } func NewReconciler(log *logrus.Entry, client client.Client) *CloudProviderConfigReconciler { - return &CloudProviderConfigReconciler{ + r := &CloudProviderConfigReconciler{ AROController: base.AROController{ Log: log.WithField("controller", controllerName), Client: client, @@ -141,23 +141,14 @@ func NewReconciler(log *logrus.Entry, client client.Client) *CloudProviderConfig EnabledFlag: controllerEnabled, }, } + r.Reconciler = r + return r } // Reconcile makes sure that the cloud-provider-config is healthy -func (r *CloudProviderConfigReconciler) Reconcile(ctx context.Context, request ctrl.Request) (ctrl.Result, error) { +func (r *CloudProviderConfigReconciler) ReconcileEnabled(ctx context.Context, request ctrl.Request, instance *arov1alpha1.Cluster) (ctrl.Result, error) { r.Log.Debug("reconcile ConfigMap openshift-config/cloud-provider-config") - instance, err := r.GetCluster(ctx) - if err != nil { - return reconcile.Result{}, err - } - - if !instance.Spec.OperatorFlags.GetSimpleBoolean(r.EnabledFlag) { - r.Log.Debug("controller is disabled") - return reconcile.Result{}, nil - } - - r.Log.Debug("running") return reconcile.Result{}, r.updateCloudProviderConfig(ctx) } diff --git a/pkg/operator/controllers/dnsmasq/cluster_controller.go b/pkg/operator/controllers/dnsmasq/cluster_controller.go index 8e4c32d1901..815c58cb8ba 100644 --- a/pkg/operator/controllers/dnsmasq/cluster_controller.go +++ b/pkg/operator/controllers/dnsmasq/cluster_controller.go @@ -33,7 +33,7 @@ type ClusterReconciler struct { } func NewClusterReconciler(log *logrus.Entry, client client.Client, dh dynamichelper.Interface) *ClusterReconciler { - return &ClusterReconciler{ + r := &ClusterReconciler{ AROController: base.AROController{ Log: log.WithField("controller", clusterControllerName), Client: client, @@ -42,27 +42,20 @@ func NewClusterReconciler(log *logrus.Entry, client client.Client, dh dynamichel }, dh: dh, } + r.Reconciler = r + return r } // Reconcile watches the ARO object, and if it changes, reconciles all the // 99-%s-aro-dns machineconfigs -func (r *ClusterReconciler) Reconcile(ctx context.Context, request ctrl.Request) (ctrl.Result, error) { - instance, err := r.GetCluster(ctx) - if err != nil { - return reconcile.Result{}, err - } - - if !instance.Spec.OperatorFlags.GetSimpleBoolean(r.EnabledFlag) { - r.Log.Debug("controller is disabled") - return reconcile.Result{}, nil - } +func (r *ClusterReconciler) ReconcileEnabled(ctx context.Context, request ctrl.Request, instance *arov1alpha1.Cluster) (ctrl.Result, error) { + var err error restartDnsmasq := instance.Spec.OperatorFlags.GetSimpleBoolean(restartDnsmasqEnabled) if restartDnsmasq { r.Log.Debug("restartDnsmasq is enabled") } - r.Log.Debug("running") mcps := &mcv1.MachineConfigPoolList{} err = r.Client.List(ctx, mcps) if err != nil { diff --git a/pkg/operator/controllers/dnsmasq/machineconfig_controller.go b/pkg/operator/controllers/dnsmasq/machineconfig_controller.go index 4106c6a2368..8b60077d8f6 100644 --- a/pkg/operator/controllers/dnsmasq/machineconfig_controller.go +++ b/pkg/operator/controllers/dnsmasq/machineconfig_controller.go @@ -15,6 +15,7 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/reconcile" + arov1alpha1 "github.com/Azure/ARO-RP/pkg/operator/apis/aro.openshift.io/v1alpha1" "github.com/Azure/ARO-RP/pkg/operator/controllers/base" "github.com/Azure/ARO-RP/pkg/util/dynamichelper" ) @@ -32,7 +33,7 @@ type MachineConfigReconciler struct { var rxARODNS = regexp.MustCompile("^99-(.*)-aro-dns$") func NewMachineConfigReconciler(log *logrus.Entry, client client.Client, dh dynamichelper.Interface) *MachineConfigReconciler { - return &MachineConfigReconciler{ + r := &MachineConfigReconciler{ AROController: base.AROController{ Log: log.WithField("controller", machineConfigControllerName), Client: client, @@ -41,26 +42,19 @@ func NewMachineConfigReconciler(log *logrus.Entry, client client.Client, dh dyna }, dh: dh, } + r.Reconciler = r + return r } // Reconcile watches ARO DNS MachineConfig objects, and if any changes, // reconciles it -func (r *MachineConfigReconciler) Reconcile(ctx context.Context, request ctrl.Request) (ctrl.Result, error) { - instance, err := r.GetCluster(ctx) - if err != nil { - return reconcile.Result{}, err - } - - if !instance.Spec.OperatorFlags.GetSimpleBoolean(r.EnabledFlag) { - r.Log.Debug("controller is disabled") - return reconcile.Result{}, nil - } +func (r *MachineConfigReconciler) ReconcileEnabled(ctx context.Context, request ctrl.Request, instance *arov1alpha1.Cluster) (ctrl.Result, error) { + var err error if instance.Spec.OperatorFlags.GetSimpleBoolean(restartDnsmasqEnabled) { r.Log.Debug("restart dnsmasq machineconfig enabled") } - r.Log.Debug("running") m := rxARODNS.FindStringSubmatch(request.Name) if m == nil { return reconcile.Result{}, nil diff --git a/pkg/operator/controllers/dnsmasq/machineconfigpool_controller.go b/pkg/operator/controllers/dnsmasq/machineconfigpool_controller.go index 07f60899eb1..12d6d2acbda 100644 --- a/pkg/operator/controllers/dnsmasq/machineconfigpool_controller.go +++ b/pkg/operator/controllers/dnsmasq/machineconfigpool_controller.go @@ -14,6 +14,7 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/reconcile" + arov1alpha1 "github.com/Azure/ARO-RP/pkg/operator/apis/aro.openshift.io/v1alpha1" "github.com/Azure/ARO-RP/pkg/operator/controllers/base" "github.com/Azure/ARO-RP/pkg/util/dynamichelper" ) @@ -29,7 +30,7 @@ type MachineConfigPoolReconciler struct { } func NewMachineConfigPoolReconciler(log *logrus.Entry, client client.Client, dh dynamichelper.Interface) *MachineConfigPoolReconciler { - return &MachineConfigPoolReconciler{ + r := &MachineConfigPoolReconciler{ AROController: base.AROController{ Log: log.WithField("controller", machineConfigPoolControllerName), Client: client, @@ -38,27 +39,20 @@ func NewMachineConfigPoolReconciler(log *logrus.Entry, client client.Client, dh }, dh: dh, } + r.Reconciler = r + return r } // Reconcile watches MachineConfigPool objects, and if any changes, // reconciles the associated ARO DNS MachineConfig object -func (r *MachineConfigPoolReconciler) Reconcile(ctx context.Context, request ctrl.Request) (ctrl.Result, error) { - instance, err := r.GetCluster(ctx) - if err != nil { - return reconcile.Result{}, err - } - - if !instance.Spec.OperatorFlags.GetSimpleBoolean(r.EnabledFlag) { - r.Log.Debug("controller is disabled") - return reconcile.Result{}, nil - } +func (r *MachineConfigPoolReconciler) ReconcileEnabled(ctx context.Context, request ctrl.Request, instance *arov1alpha1.Cluster) (ctrl.Result, error) { + var err error restartDnsmasq := instance.Spec.OperatorFlags.GetSimpleBoolean(restartDnsmasqEnabled) if restartDnsmasq { r.Log.Debug("restart dnsmasq machineconfig enabled") } - r.Log.Debug("running") mcp := &mcv1.MachineConfigPool{} err = r.Client.Get(ctx, types.NamespacedName{Name: request.Name}, mcp) if kerrors.IsNotFound(err) { diff --git a/pkg/operator/controllers/genevalogging/genevalogging_controller.go b/pkg/operator/controllers/genevalogging/genevalogging_controller.go index a9055e8e493..4bd03b1f108 100644 --- a/pkg/operator/controllers/genevalogging/genevalogging_controller.go +++ b/pkg/operator/controllers/genevalogging/genevalogging_controller.go @@ -40,7 +40,7 @@ type Reconciler struct { } func NewReconciler(log *logrus.Entry, client client.Client, dh dynamichelper.Interface) *Reconciler { - return &Reconciler{ + r := &Reconciler{ AROController: base.AROController{ Log: log.WithField("controller", controllerName), Client: client, @@ -49,6 +49,8 @@ func NewReconciler(log *logrus.Entry, client client.Client, dh dynamichelper.Int }, dh: dh, } + r.Reconciler = r + return r } func (r *Reconciler) ensureResources(ctx context.Context, instance *arov1alpha1.Cluster) error { @@ -86,20 +88,8 @@ func (r *Reconciler) ensureResources(ctx context.Context, instance *arov1alpha1. } // Reconcile the genevalogging deployment. -func (r *Reconciler) Reconcile(ctx context.Context, request ctrl.Request) (ctrl.Result, error) { - instance, err := r.GetCluster(ctx) - if err != nil { - r.Log.Error(err) - return reconcile.Result{}, err - } - - if !instance.Spec.OperatorFlags.GetSimpleBoolean(r.EnabledFlag) { - r.Log.Debug("controller is disabled") - return reconcile.Result{}, nil - } - - r.Log.Debug("running") - err = r.ensureResources(ctx, instance) +func (r *Reconciler) ReconcileEnabled(ctx context.Context, request ctrl.Request, instance *arov1alpha1.Cluster) (ctrl.Result, error) { + err := r.ensureResources(ctx, instance) if err != nil { r.Log.Error(err) r.SetDegraded(ctx, err) diff --git a/pkg/operator/controllers/imageconfig/image_controller.go b/pkg/operator/controllers/imageconfig/image_controller.go index a79d72defd4..1e06ca4a9b7 100644 --- a/pkg/operator/controllers/imageconfig/image_controller.go +++ b/pkg/operator/controllers/imageconfig/image_controller.go @@ -37,7 +37,7 @@ type Reconciler struct { } func NewReconciler(log *logrus.Entry, client client.Client) *Reconciler { - return &Reconciler{ + r := &Reconciler{ AROController: base.AROController{ Log: log.WithField("controller", controllerName), Client: client, @@ -45,24 +45,17 @@ func NewReconciler(log *logrus.Entry, client client.Client) *Reconciler { EnabledFlag: controllerEnabled, }, } + r.Reconciler = r + return r } // watches the ARO object for changes and reconciles image.config.openshift.io/cluster object. // - If blockedRegistries is not nil, makes sure required registries are not added // - If AllowedRegistries is not nil, makes sure required registries are added // - Fails fast if both are not nil, unsupported -func (r *Reconciler) Reconcile(ctx context.Context, request ctrl.Request) (ctrl.Result, error) { - instance, err := r.GetCluster(ctx) - if err != nil { - return reconcile.Result{}, err - } - - if !instance.Spec.OperatorFlags.GetSimpleBoolean(r.EnabledFlag) { - r.Log.Debug("controller is disabled") - return reconcile.Result{}, nil - } +func (r *Reconciler) ReconcileEnabled(ctx context.Context, request ctrl.Request, instance *arov1alpha1.Cluster) (ctrl.Result, error) { + var err error - r.Log.Debug("running") requiredRegistries, err := GetCloudAwareRegistries(instance) if err != nil { // Not returning error as it will requeue again diff --git a/pkg/operator/controllers/ingress/ingress_controller.go b/pkg/operator/controllers/ingress/ingress_controller.go index ce3707b5ce7..ce61a7a0dd1 100644 --- a/pkg/operator/controllers/ingress/ingress_controller.go +++ b/pkg/operator/controllers/ingress/ingress_controller.go @@ -35,7 +35,7 @@ type Reconciler struct { } func NewReconciler(log *logrus.Entry, client client.Client) *Reconciler { - return &Reconciler{ + r := &Reconciler{ AROController: base.AROController{ Log: log.WithField("controller", controllerName), Client: client, @@ -43,20 +43,13 @@ func NewReconciler(log *logrus.Entry, client client.Client) *Reconciler { EnabledFlag: controllerEnabled, }, } + r.Reconciler = r + return r } -func (r *Reconciler) Reconcile(ctx context.Context, request ctrl.Request) (ctrl.Result, error) { - instance, err := r.GetCluster(ctx) - if err != nil { - return reconcile.Result{}, err - } - - if !instance.Spec.OperatorFlags.GetSimpleBoolean(r.EnabledFlag) { - r.Log.Debug("controller is disabled") - return reconcile.Result{}, nil - } +func (r *Reconciler) ReconcileEnabled(ctx context.Context, request ctrl.Request, instance *arov1alpha1.Cluster) (ctrl.Result, error) { + var err error - r.Log.Debug("running") ingress := &operatorv1.IngressController{} err = r.Client.Get(ctx, types.NamespacedName{Namespace: openshiftIngressControllerNamespace, Name: openshiftIngressControllerName}, ingress) if err != nil { diff --git a/pkg/operator/controllers/machinehealthcheck/machinehealthcheck_controller.go b/pkg/operator/controllers/machinehealthcheck/machinehealthcheck_controller.go index 2244ffa80e4..9e43469910b 100644 --- a/pkg/operator/controllers/machinehealthcheck/machinehealthcheck_controller.go +++ b/pkg/operator/controllers/machinehealthcheck/machinehealthcheck_controller.go @@ -49,7 +49,7 @@ type Reconciler struct { } func NewReconciler(log *logrus.Entry, client client.Client, dh dynamichelper.Interface) *Reconciler { - return &Reconciler{ + r := &Reconciler{ AROController: base.AROController{ Log: log.WithField("controller", controllerName), Client: client, @@ -58,25 +58,17 @@ func NewReconciler(log *logrus.Entry, client client.Client, dh dynamichelper.Int }, dh: dh, } + r.Reconciler = r + return r } // Reconcile watches MachineHealthCheck objects, and if any changes, // reconciles the associated ARO MachineHealthCheck object -func (r *Reconciler) Reconcile(ctx context.Context, request ctrl.Request) (ctrl.Result, error) { - instance, err := r.GetCluster(ctx) +func (r *Reconciler) ReconcileEnabled(ctx context.Context, request ctrl.Request, instance *arov1alpha1.Cluster) (ctrl.Result, error) { + var err error - if err != nil { - return reconcile.Result{}, err - } - - if !instance.Spec.OperatorFlags.GetSimpleBoolean(r.EnabledFlag) { - r.Log.Debug("controller is disabled") - return reconcile.Result{}, nil - } - - r.Log.Debug("running") if !instance.Spec.OperatorFlags.GetSimpleBoolean(controllerManaged) { - err := r.dh.EnsureDeleted(ctx, "MachineHealthCheck", "openshift-machine-api", "aro-machinehealthcheck") + err = r.dh.EnsureDeleted(ctx, "MachineHealthCheck", "openshift-machine-api", "aro-machinehealthcheck") if err != nil { r.Log.Error(err) r.SetDegraded(ctx, err) diff --git a/pkg/operator/controllers/machineset/machineset_controller.go b/pkg/operator/controllers/machineset/machineset_controller.go index c17c5e4c161..de980266864 100644 --- a/pkg/operator/controllers/machineset/machineset_controller.go +++ b/pkg/operator/controllers/machineset/machineset_controller.go @@ -18,6 +18,7 @@ import ( "sigs.k8s.io/controller-runtime/pkg/predicate" "sigs.k8s.io/controller-runtime/pkg/reconcile" + arov1alpha1 "github.com/Azure/ARO-RP/pkg/operator/apis/aro.openshift.io/v1alpha1" "github.com/Azure/ARO-RP/pkg/operator/controllers/base" ) @@ -32,7 +33,7 @@ type Reconciler struct { // MachineSet reconciler watches MachineSet objects for changes, evaluates total worker replica count, and reverts changes if needed. func NewReconciler(log *logrus.Entry, client client.Client) *Reconciler { - return &Reconciler{ + r := &Reconciler{ AROController: base.AROController{ Log: log.WithField("controller", controllerName), Client: client, @@ -40,20 +41,12 @@ func NewReconciler(log *logrus.Entry, client client.Client) *Reconciler { EnabledFlag: controllerEnabled, }, } + r.Reconciler = r + return r } -func (r *Reconciler) Reconcile(ctx context.Context, request ctrl.Request) (ctrl.Result, error) { - instance, err := r.GetCluster(ctx) - if err != nil { - return reconcile.Result{}, err - } - - if !instance.Spec.OperatorFlags.GetSimpleBoolean(r.EnabledFlag) { - r.Log.Debug("controller is disabled") - return reconcile.Result{}, nil - } - - r.Log.Debug("running") +func (r *Reconciler) ReconcileEnabled(ctx context.Context, request ctrl.Request, instance *arov1alpha1.Cluster) (ctrl.Result, error) { + var err error modifiedMachineset := &machinev1beta1.MachineSet{} err = r.Client.Get(ctx, types.NamespacedName{Name: request.Name, Namespace: machineSetsNamespace}, modifiedMachineset) diff --git a/pkg/operator/controllers/monitoring/monitoring_controller.go b/pkg/operator/controllers/monitoring/monitoring_controller.go index f190252a684..7799e3723b5 100644 --- a/pkg/operator/controllers/monitoring/monitoring_controller.go +++ b/pkg/operator/controllers/monitoring/monitoring_controller.go @@ -61,7 +61,7 @@ type MonitoringReconciler struct { } func NewReconciler(log *logrus.Entry, client client.Client) *MonitoringReconciler { - return &MonitoringReconciler{ + r := &MonitoringReconciler{ AROController: base.AROController{ Log: log.WithField("controller", controllerName), Client: client, @@ -70,20 +70,11 @@ func NewReconciler(log *logrus.Entry, client client.Client) *MonitoringReconcile }, jsonHandle: new(codec.JsonHandle), } + r.Reconciler = r + return r } -func (r *MonitoringReconciler) Reconcile(ctx context.Context, request ctrl.Request) (ctrl.Result, error) { - instance, err := r.GetCluster(ctx) - if err != nil { - return reconcile.Result{}, err - } - - if !instance.Spec.OperatorFlags.GetSimpleBoolean(r.EnabledFlag) { - r.Log.Debug("controller is disabled") - return reconcile.Result{}, nil - } - - r.Log.Debug("running") +func (r *MonitoringReconciler) ReconcileEnabled(ctx context.Context, request ctrl.Request, instance *arov1alpha1.Cluster) (ctrl.Result, error) { for _, f := range []func(context.Context) (ctrl.Result, error){ r.reconcileConfiguration, r.reconcilePVC, // TODO(mj): This should be removed once we don't have PVC anymore diff --git a/pkg/operator/controllers/node/node_controller.go b/pkg/operator/controllers/node/node_controller.go index 5eda6054578..f9f0b2645cb 100644 --- a/pkg/operator/controllers/node/node_controller.go +++ b/pkg/operator/controllers/node/node_controller.go @@ -19,6 +19,7 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/reconcile" + arov1alpha1 "github.com/Azure/ARO-RP/pkg/operator/apis/aro.openshift.io/v1alpha1" "github.com/Azure/ARO-RP/pkg/operator/controllers/base" "github.com/Azure/ARO-RP/pkg/util/ready" ) @@ -37,7 +38,7 @@ type Reconciler struct { } func NewReconciler(log *logrus.Entry, client client.Client, kubernetescli kubernetes.Interface) *Reconciler { - return &Reconciler{ + r := &Reconciler{ AROController: base.AROController{ Log: log.WithField("controller", controllerName), Client: client, @@ -47,20 +48,12 @@ func NewReconciler(log *logrus.Entry, client client.Client, kubernetescli kubern kubernetescli: kubernetescli, } + r.Reconciler = r + return r } -func (r *Reconciler) Reconcile(ctx context.Context, request ctrl.Request) (ctrl.Result, error) { - instance, err := r.GetCluster(ctx) - if err != nil { - return reconcile.Result{}, err - } - - if !instance.Spec.OperatorFlags.GetSimpleBoolean(r.EnabledFlag) { - r.Log.Debug("controller is disabled") - return reconcile.Result{}, nil - } - - r.Log.Debug("running") +func (r *Reconciler) ReconcileEnabled(ctx context.Context, request ctrl.Request, instance *arov1alpha1.Cluster) (ctrl.Result, error) { + var err error node := &corev1.Node{} err = r.Client.Get(ctx, types.NamespacedName{Name: request.Name}, node)