refactor: add run to cluster reconciler and optimize log msg (zncdata…

…dev#175)

pkg/reconciler/cluster.go

@@ -18,6 +18,9 @@ type ClusterReconciler interface {
  GetResources() []Reconciler
  AddResource(resource Reconciler)
  RegisterResources(ctx context.Context) error
+ IsStopped() bool
+
+ Run(ctx context.Context) (ctrl.Result, error)
 }
 
 var _ ClusterReconciler = &BaseCluster[AnySpec]{}
@@ -61,12 +64,16 @@ func (r *BaseCluster[T]) AddResource(resource Reconciler) {
  r.resources = append(r.resources, resource)
 }
 
+func (r *BaseCluster[T]) IsStopped() bool {
+ return r.ClusterOperation != nil && r.ClusterOperation.Stopped
+}
+
 func (r *BaseCluster[T]) RegisterResources(ctx context.Context) error {
 
  panic("unimplemented")
 }
 
-func (r *BaseCluster[T]) Paused(ctx context.Context) bool {
+func (r *BaseCluster[T]) IsPaused(ctx context.Context) bool {
  if r.ClusterOperation != nil && r.ClusterOperation.ReconciliationPaused {
  logger.Info("Reconciliation paused", "cluster", r.GetName(), "namespace", r.GetNamespace(), "paused", "true")
  return true
@@ -75,32 +82,41 @@ func (r *BaseCluster[T]) Paused(ctx context.Context) bool {
 }
 
 func (r *BaseCluster[T]) Ready(ctx context.Context) (ctrl.Result, error) {
- if r.Paused(ctx) {
- logger.Info("Reconciliation paused, skip ready check", "cluster", r.GetName(), "namespace", r.GetNamespace())
- return ctrl.Result{}, nil
- }
+ logger.V(5).Info("Checking readiness of cluster", "namespace", r.GetNamespace(), "cluster", r.GetName())
  for _, resource := range r.resources {
- logger.Info("Checking resource ready", "cluster", r.GetName(), "namespace", r.GetNamespace(), "resource", resource.GetName())
  if result, err := resource.Ready(ctx); !result.IsZero() || err != nil {
  return result, err
  }
- logger.Info("Resource is ready", "cluster", r.GetName(), "namespace", r.GetNamespace(), "resource", resource.GetName())
  }
+ logger.V(5).Info("Cluster is ready", "namespace", r.GetNamespace(), "cluster", r.GetName())
  return ctrl.Result{}, nil
 }
 
 func (r *BaseCluster[T]) Reconcile(ctx context.Context) (ctrl.Result, error) {
- if r.Paused(ctx) {
- logger.Info("Reconciliation paused, skip reconcile", "cluster", r.GetName(), "namespace", r.GetNamespace())
- return ctrl.Result{}, nil
- }
-
+ logger.V(5).Info("Reconciling cluster", "namespace", r.GetNamespace(), "cluster", r.GetName())
  for _, resource := range r.resources {
- logger.Info("Reconciling resource", "cluster", r.GetName(), "namespace", r.GetNamespace(), "resource", resource.GetName())
  if result, err := resource.Reconcile(ctx); !result.IsZero() || err != nil {
  return result, err
  }
- logger.Info("Reconciled resource", "cluster", r.GetName(), "namespace", r.GetNamespace(), "resource", resource.GetName())
  }
+ logger.V(5).Info("Reconciled cluster", "namespace", r.GetNamespace(), "cluster", r.GetName())
+ return ctrl.Result{}, nil
+}
+
+func (r *BaseCluster[T]) Run(ctx context.Context) (ctrl.Result, error) {
+ if r.IsPaused(ctx) {
+ logger.Info("Reconciliation paused, skip reconcile", "cluster", r.GetName(), "namespace", r.GetNamespace())
+ return ctrl.Result{}, nil
+ }
+
+ if result, err := r.Reconcile(ctx); !result.IsZero() || err != nil {
+ return result, err
+ }
+
+ if result, err := r.Ready(ctx); !result.IsZero() || err != nil {
+ return result, err
+ }
+
+ logger.Info("Reconciliation completed, all resources are ready", "cluster", r.GetName(), "namespace", r.GetNamespace())
  return ctrl.Result{}, nil
 }

pkg/reconciler/cluster_test.go

@@ -68,12 +68,12 @@ func (r *ClusterReconciler) RegisterResources(ctx context.Context) error {
 
  role := NewRoleReconciler(
  r.GetClient(),
+ r.ClusterConfig,
+ r.ClusterOperation.Stopped,
  reconciler.RoleInfo{
  ClusterInfo: r.ClusterInfo,
  RoleName: "coordinator",
  },
- r.ClusterOperation,
- r.ClusterConfig,
  *r.Spec.Coordinator,
  )
 

pkg/reconciler/resource.go

@@ -64,7 +64,8 @@ func (r *GenericResourceReconciler[B]) GetBuilder() B {
 //
 // Most of the time you should not call this method directly, but call the r.Reconcile() method instead.
 func (r *GenericResourceReconciler[B]) ResourceReconcile(ctx context.Context, resource ctrlclient.Object) (ctrl.Result, error) {
- logExtraValues := []interface{}{
+ logger.V(5).Info("Reconciling resource", "namespace", r.GetNamespace(), "cluster", r.GetName(), "name", resource.GetName())
+ logExtraValues := []any{
  "name", resource.GetName(),
  "namespace", resource.GetNamespace(),
  "cluster", r.GetName(),
@@ -81,6 +82,7 @@ func (r *GenericResourceReconciler[B]) ResourceReconcile(ctx context.Context, re
 }
 
 func (r *GenericResourceReconciler[B]) Reconcile(ctx context.Context) (ctrl.Result, error) {
+ logger.V(5).Info("Building resource", "namespace", r.GetNamespace(), "cluster", r.GetName(), "name", r.GetName())
  resource, err := r.GetBuilder().Build(ctx)
 
  if err != nil {

pkg/reconciler/role.go

@@ -5,19 +5,23 @@ import (
  "errors"
  "reflect"
 
- apiv1alpha1 "github.com/zncdatadev/operator-go/pkg/apis/commons/v1alpha1"
  "github.com/zncdatadev/operator-go/pkg/client"
+ ctrl "sigs.k8s.io/controller-runtime"
 )
 
 var (
  ErrRoleSpecNotPointer = errors.New("role spec must be a pointer")
 )
 
 type RoleReconciler interface {
- ClusterReconciler
+ Reconciler
+ GetResources() []Reconciler
+ AddResource(resource Reconciler)
+ RegisterResources(ctx context.Context) error
+ IsStopped() bool
+
  // Get the full name of the role, formatted as `<clusterName>-<roleName>`
  GetFullName() string
- // Register resources based on roleGroup
 }
 
 type RoleGroupResourceReconcilersGetter interface {
@@ -27,24 +31,27 @@ type RoleGroupResourceReconcilersGetter interface {
 var _ RoleReconciler = &BaseRoleReconciler[AnySpec]{}
 
 type BaseRoleReconciler[T AnySpec] struct {
- BaseCluster[T]
- RoleInfo RoleInfo
+ BaseReconciler[T]
+ ClusterStopped bool
+ ClusterInfo ClusterInfo
+ resources []Reconciler
+ RoleInfo RoleInfo
 }
 
 func NewBaseRoleReconciler[T AnySpec](
  client *client.Client,
+ clusterStopped bool,
  roleInfo RoleInfo,
- clusterOperation *apiv1alpha1.ClusterOperationSpec,
  spec T, // spec of the role
 ) *BaseRoleReconciler[T] {
  return &BaseRoleReconciler[T]{
- BaseCluster: *NewBaseCluster[T](
- client,
- roleInfo.ClusterInfo,
-  clusterOperation,
-  spec,
- ),
- RoleInfo: roleInfo,
+ BaseReconciler: BaseReconciler[T]{
+ Client: client,
+ Spec: spec,
+ },
+ ClusterStopped: clusterStopped,
+ ClusterInfo: roleInfo.ClusterInfo,
+ RoleInfo:  roleInfo,
  }
 }
 
@@ -87,6 +94,40 @@ func (r *BaseRoleReconciler[T]) GetRoleGroups() (map[string]AnySpec, error) {
 
 }
 
+func (r *BaseRoleReconciler[T]) AddResource(resource Reconciler) {
+ r.resources = append(r.resources, resource)
+}
+
+func (r *BaseRoleReconciler[T]) GetResources() []Reconciler {
+ return r.resources
+}
+
+func (r *BaseRoleReconciler[T]) IsStopped() bool {
+ return r.ClusterStopped
+}
+
+func (r *BaseRoleReconciler[T]) Reconcile(ctx context.Context) (ctrl.Result, error) {
+ logger.V(5).Info("Reconciling role", "namespace", r.GetNamespace(), "cluster", r.ClusterInfo.GetClusterName(), "role", r.GetName())
+ for _, resource := range r.resources {
+ if res, err := resource.Reconcile(ctx); !res.IsZero() || err != nil {
+ return res, err
+ }
+ }
+ logger.V(5).Info("Reconciled role", "namespace", r.GetNamespace(), "cluster", r.ClusterInfo.GetClusterName(), "role", r.GetName())
+ return ctrl.Result{}, nil
+}
+
+func (r *BaseRoleReconciler[T]) Ready(ctx context.Context) (ctrl.Result, error) {
+ logger.V(5).Info("Checking readiness of role", "namespace", r.GetNamespace(), "cluster", r.ClusterInfo.GetClusterName(), "role", r.GetName())
+ for _, resource := range r.resources {
+ if res, err := resource.Ready(ctx); !res.IsZero() || err != nil {
+ return res, err
+ }
+ }
+ logger.V(5).Info("Role is ready", "namespace", r.GetNamespace(), "cluster", r.ClusterInfo.GetClusterName(), "role", r.GetName())
+ return ctrl.Result{}, nil
+}
+
 func (r *BaseRoleReconciler[T]) RegisterResources(ctx context.Context) error {
  panic("unimplemented")
 }

pkg/reconciler/role_test.go

@@ -35,16 +35,16 @@ type RoleReconciler struct {
 
 func NewRoleReconciler(
  client *client.Client,
- roleInfo reconciler.RoleInfo,
- clusterOperation *commonsv1alpha1.ClusterOperationSpec,
  clusterConfig *ClusterConfigSpec,
+ clusterStopped bool,
+ roleInfo reconciler.RoleInfo,
  spec CoordinatorSpec,
 ) *RoleReconciler {
  return &RoleReconciler{
  BaseRoleReconciler: *reconciler.NewBaseRoleReconciler[CoordinatorSpec](
  client,
+ clusterStopped,
  roleInfo,
- clusterOperation,
  spec,
  ),
  ClusterConfig: clusterConfig,
@@ -136,7 +136,7 @@ func (r *RoleReconciler) getDeployment(info reconciler.RoleGroupInfo, roleGroup
  ),
  }
  // Create a deployment reconciler
- return reconciler.NewDeployment(r.Client, info.GetFullName(), deploymentBuilder, r.ClusterOperation.Stopped), nil
+ return reconciler.NewDeployment(r.Client, info.GetFullName(), deploymentBuilder, r.ClusterStopped), nil
 }
 
 func (r *RoleReconciler) getServiceReconciler(info reconciler.RoleGroupInfo) reconciler.Reconciler {
@@ -227,9 +227,9 @@ var _ = Describe("Role reconciler", func() {
  By("creating a role reconciler")
  roleReconciler := NewRoleReconciler(
  resourceClient,
- roleInfo,
- clusterOperation,
  &ClusterConfigSpec{},
+ clusterOperation.Stopped,
+ roleInfo,
  coordinatorRole,
  )
  Expect(roleReconciler).ToNot(BeNil())
@@ -305,9 +305,9 @@ var _ = Describe("Role reconciler", func() {
  By("creating a role reconciler")
  roleReconciler := NewRoleReconciler(
  resourceClient,
- roleInfo,
- clusterOperation,
  &ClusterConfigSpec{},
+ clusterOperation.Stopped,
+ roleInfo,
  *role,
  )
  Expect(roleReconciler).ToNot(BeNil())
@@ -381,9 +381,9 @@ var _ = Describe("Role reconciler", func() {
  By("creating a role reconciler")
  roleReconciler := NewRoleReconciler(
  resourceClient,
- roleInfo,
- &commonsv1alpha1.ClusterOperationSpec{},
  &ClusterConfigSpec{},
+ false,
+ roleInfo,
  *role,
  )
  Expect(roleReconciler).ToNot(BeNil())
@@ -410,9 +410,9 @@ var _ = Describe("Role reconciler", func() {
  By("creating a role reconciler")
  roleReconciler := NewRoleReconciler(
  resourceClient,
- roleInfo,
- clusterOperation,
  &ClusterConfigSpec{},
+ clusterOperation.Stopped,
+ roleInfo,
  *role,
  )
  Expect(roleReconciler).ToNot(BeNil())
@@ -439,9 +439,9 @@ var _ = Describe("Role reconciler", func() {
  By("creating a role reconciler")
  roleReconciler := NewRoleReconciler(
  resourceClient,
- roleInfo,
- clusterOperation,
  &ClusterConfigSpec{},
+ clusterOperation.Stopped,
+ roleInfo,
  *role,
  )