Skip to content

Commit b44f303

Browse files
drivebyerdrivebyer
authored
refactor: add common controller util (#977)
* refactor: add common controller util Signed-off-by: drivebyer <yang.wu@daocloud.io> * fix lint Signed-off-by: drivebyer <wuyangmuc@gmail.com> --------- Signed-off-by: drivebyer <yang.wu@daocloud.io> Signed-off-by: drivebyer <wuyangmuc@gmail.com>
1 parent ae814ec commit b44f303

File tree

5 files changed

+101
-88
lines changed

5 files changed

+101
-88
lines changed

‎controllers/redis_controller.go‎

Lines changed: 9 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -22,8 +22,8 @@ import (
2222

2323
redisv1beta2 "github.com/OT-CONTAINER-KIT/redis-operator/api/v1beta2"
2424
"github.com/OT-CONTAINER-KIT/redis-operator/k8sutils"
25+
intctrlutil "github.com/OT-CONTAINER-KIT/redis-operator/pkg/controllerutil"
2526
"github.com/go-logr/logr"
26-
"k8s.io/apimachinery/pkg/api/errors"
2727
"k8s.io/apimachinery/pkg/runtime"
2828
"k8s.io/client-go/dynamic"
2929
"k8s.io/client-go/kubernetes"
@@ -47,36 +47,29 @@ func (r *RedisReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl
4747

4848
err := r.Client.Get(context.TODO(), req.NamespacedName, instance)
4949
if err != nil {
50-
if errors.IsNotFound(err) {
51-
return ctrl.Result{}, nil
52-
}
53-
return ctrl.Result{}, err
50+
return intctrlutil.RequeueWithErrorChecking(err, reqLogger, "failed to get redis instance")
5451
}
5552
if instance.ObjectMeta.GetDeletionTimestamp() != nil {
5653
if err = k8sutils.HandleRedisFinalizer(r.Client, r.K8sClient, r.Log, instance); err != nil {
57-
return ctrl.Result{}, err
54+
return intctrlutil.RequeueWithError(err, reqLogger, "failed to handle redis finalizer")
5855
}
59-
return ctrl.Result{}, nil
56+
return intctrlutil.Reconciled()
6057
}
6158
if _, found := instance.ObjectMeta.GetAnnotations()["redis.opstreelabs.in/skip-reconcile"]; found {
62-
reqLogger.Info("Found annotations redis.opstreelabs.in/skip-reconcile, so skipping reconcile")
63-
return ctrl.Result{RequeueAfter: time.Second * 10}, nil
59+
return intctrlutil.RequeueAfter(reqLogger, time.Second*10, "found skip reconcile annotation")
6460
}
6561
if err = k8sutils.AddFinalizer(instance, k8sutils.RedisFinalizer, r.Client); err != nil {
66-
return ctrl.Result{}, err
62+
return intctrlutil.RequeueWithError(err, reqLogger, "failed to add finalizer")
6763
}
68-
6964
err = k8sutils.CreateStandaloneRedis(instance, r.K8sClient)
7065
if err != nil {
71-
return ctrl.Result{}, err
66+
return intctrlutil.RequeueWithError(err, reqLogger, "failed to create redis")
7267
}
7368
err = k8sutils.CreateStandaloneService(instance, r.K8sClient)
7469
if err != nil {
75-
return ctrl.Result{}, err
70+
return intctrlutil.RequeueWithError(err, reqLogger, "failed to create service")
7671
}
77-
78-
reqLogger.Info("Will reconcile redis operator in again 10 seconds")
79-
return ctrl.Result{RequeueAfter: time.Second * 10}, nil
72+
return intctrlutil.RequeueAfter(reqLogger, time.Second*10, "requeue after 10 seconds")
8073
}
8174

8275
// SetupWithManager sets up the controller with the Manager.

‎controllers/rediscluster_controller.go‎

Lines changed: 27 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,7 @@ import (
2424
"github.com/OT-CONTAINER-KIT/redis-operator/api/status"
2525
redisv1beta2 "github.com/OT-CONTAINER-KIT/redis-operator/api/v1beta2"
2626
"github.com/OT-CONTAINER-KIT/redis-operator/k8sutils"
27+
intctrlutil "github.com/OT-CONTAINER-KIT/redis-operator/pkg/controllerutil"
2728
"github.com/go-logr/logr"
2829
"k8s.io/apimachinery/pkg/api/errors"
2930
"k8s.io/apimachinery/pkg/runtime"
@@ -50,20 +51,16 @@ func (r *RedisClusterReconciler) Reconcile(ctx context.Context, req ctrl.Request
5051

5152
err := r.Client.Get(context.TODO(), req.NamespacedName, instance)
5253
if err != nil {
53-
if errors.IsNotFound(err) {
54-
return ctrl.Result{}, nil
55-
}
56-
return ctrl.Result{}, err
54+
return intctrlutil.RequeueWithErrorChecking(err, reqLogger, "failed to get redis cluster instance")
5755
}
5856
if instance.ObjectMeta.GetDeletionTimestamp() != nil {
5957
if err = k8sutils.HandleRedisClusterFinalizer(r.Client, r.K8sClient, r.Log, instance); err != nil {
60-
return ctrl.Result{}, err
58+
return intctrlutil.RequeueWithError(err, reqLogger, "failed to handle redis cluster finalizer")
6159
}
62-
return ctrl.Result{}, nil
60+
return intctrlutil.Reconciled()
6361
}
6462
if _, found := instance.ObjectMeta.GetAnnotations()["rediscluster.opstreelabs.in/skip-reconcile"]; found {
65-
reqLogger.Info("Found annotations rediscluster.opstreelabs.in/skip-reconcile, so skipping reconcile")
66-
return ctrl.Result{RequeueAfter: time.Second * 10}, nil
63+
return intctrlutil.RequeueAfter(reqLogger, time.Second*10, "found skip reconcile annotation")
6764
}
6865
instance.SetDefault()
6966

@@ -72,7 +69,7 @@ func (r *RedisClusterReconciler) Reconcile(ctx context.Context, req ctrl.Request
7269
totalReplicas := leaderReplicas + followerReplicas
7370

7471
if err = k8sutils.AddFinalizer(instance, k8sutils.RedisClusterFinalizer, r.Client); err != nil {
75-
return ctrl.Result{}, err
72+
return intctrlutil.RequeueWithError(err, reqLogger, "failed to add finalizer")
7673
}
7774

7875
// Check if the cluster is downscaled
@@ -98,41 +95,41 @@ func (r *RedisClusterReconciler) Reconcile(ctx context.Context, req ctrl.Request
9895
// Step 3 Rebalance the cluster
9996
k8sutils.RebalanceRedisCluster(r.K8sClient, r.Log, instance)
10097
reqLogger.Info("Redis cluster is downscaled... Rebalancing the cluster is done")
101-
return ctrl.Result{RequeueAfter: time.Second * 10}, nil
98+
return intctrlutil.RequeueAfter(reqLogger, time.Second*10, "")
10299
}
103100

104101
// Mark the cluster status as initializing if there are no leader or follower nodes
105102
if (instance.Status.ReadyLeaderReplicas == 0 && instance.Status.ReadyFollowerReplicas == 0) ||
106103
instance.Status.ReadyLeaderReplicas != leaderReplicas {
107104
err = k8sutils.UpdateRedisClusterStatus(instance, status.RedisClusterInitializing, status.InitializingClusterLeaderReason, instance.Status.ReadyLeaderReplicas, instance.Status.ReadyFollowerReplicas, r.Dk8sClient)
108105
if err != nil {
109-
return ctrl.Result{}, err
106+
return intctrlutil.RequeueWithError(err, reqLogger, "")
110107
}
111108
}
112109

113110
if leaderReplicas != 0 {
114111
err = k8sutils.CreateRedisLeaderService(instance, r.K8sClient)
115112
if err != nil {
116-
return ctrl.Result{}, err
113+
return intctrlutil.RequeueWithError(err, reqLogger, "")
117114
}
118115
}
119116
err = k8sutils.CreateRedisLeader(instance, r.K8sClient)
120117
if err != nil {
121-
return ctrl.Result{}, err
118+
return intctrlutil.RequeueWithError(err, reqLogger, "")
122119
}
123120

124121
err = k8sutils.ReconcileRedisPodDisruptionBudget(instance, "leader", instance.Spec.RedisLeader.PodDisruptionBudget, r.K8sClient)
125122
if err != nil {
126-
return ctrl.Result{}, err
123+
return intctrlutil.RequeueWithError(err, reqLogger, "")
127124
}
128125

129126
// todo: remove me after watch statefulset in controller
130127
redisLeaderInfo, err := k8sutils.GetStatefulSet(r.K8sClient, r.Log, instance.GetNamespace(), instance.GetName()+"-leader")
131128
if err != nil {
132129
if errors.IsNotFound(err) {
133-
return ctrl.Result{RequeueAfter: time.Second * 60}, nil
130+
return intctrlutil.RequeueAfter(reqLogger, time.Second*60, "")
134131
}
135-
return ctrl.Result{}, err
132+
return intctrlutil.RequeueWithError(err, reqLogger, "")
136133
}
137134

138135
if r.IsStatefulSetReady(ctx, instance.Namespace, instance.Name+"-leader") {
@@ -141,54 +138,52 @@ func (r *RedisClusterReconciler) Reconcile(ctx context.Context, req ctrl.Request
141138
instance.Status.ReadyFollowerReplicas != followerReplicas {
142139
err = k8sutils.UpdateRedisClusterStatus(instance, status.RedisClusterInitializing, status.InitializingClusterFollowerReason, leaderReplicas, instance.Status.ReadyFollowerReplicas, r.Dk8sClient)
143140
if err != nil {
144-
return ctrl.Result{}, err
141+
return intctrlutil.RequeueWithError(err, reqLogger, "")
145142
}
146143
}
147144
// if we have followers create their service.
148145
if followerReplicas != 0 {
149146
err = k8sutils.CreateRedisFollowerService(instance, r.K8sClient)
150147
if err != nil {
151-
return ctrl.Result{}, err
148+
return intctrlutil.RequeueWithError(err, reqLogger, "")
152149
}
153150
}
154151
err = k8sutils.CreateRedisFollower(instance, r.K8sClient)
155152
if err != nil {
156-
return ctrl.Result{}, err
153+
return intctrlutil.RequeueWithError(err, reqLogger, "")
157154
}
158155
err = k8sutils.ReconcileRedisPodDisruptionBudget(instance, "follower", instance.Spec.RedisFollower.PodDisruptionBudget, r.K8sClient)
159156
if err != nil {
160-
return ctrl.Result{}, err
157+
return intctrlutil.RequeueWithError(err, reqLogger, "")
161158
}
162159
}
163160
// todo: remove me after watch statefulset in controller
164161
redisFollowerInfo, err := k8sutils.GetStatefulSet(r.K8sClient, r.Log, instance.GetNamespace(), instance.GetName()+"-follower")
165162
if err != nil {
166163
if errors.IsNotFound(err) {
167-
return ctrl.Result{RequeueAfter: time.Second * 60}, nil
164+
return intctrlutil.RequeueAfter(reqLogger, time.Second*60, "")
168165
}
169-
return ctrl.Result{}, err
166+
return intctrlutil.RequeueWithError(err, reqLogger, "")
170167
}
171168

172169
if leaderReplicas == 0 {
173-
reqLogger.Info("Redis leaders Cannot be 0", "Ready.Replicas", strconv.Itoa(int(redisLeaderInfo.Status.ReadyReplicas)), "Expected.Replicas", leaderReplicas)
174-
return ctrl.Result{RequeueAfter: time.Second * 60}, nil
170+
return intctrlutil.RequeueAfter(reqLogger, time.Second*60, "Redis leaders Cannot be 0", "Ready.Replicas", strconv.Itoa(int(redisLeaderInfo.Status.ReadyReplicas)), "Expected.Replicas", leaderReplicas)
175171
}
176172

177173
if !(r.IsStatefulSetReady(ctx, instance.Namespace, instance.Name+"-leader") && r.IsStatefulSetReady(ctx, instance.Namespace, instance.Name+"-follower")) {
178-
reqLogger.Info("Redis leader and follower nodes are not ready yet")
179-
return ctrl.Result{RequeueAfter: time.Second * 30}, nil
174+
return intctrlutil.RequeueAfter(reqLogger, time.Second*60, "Redis leader and follower nodes are not ready yet")
180175
}
181176

182177
// Mark the cluster status as bootstrapping if all the leader and follower nodes are ready
183178
if !(instance.Status.ReadyLeaderReplicas == leaderReplicas && instance.Status.ReadyFollowerReplicas == followerReplicas) {
184179
err = k8sutils.UpdateRedisClusterStatus(instance, status.RedisClusterBootstrap, status.BootstrapClusterReason, leaderReplicas, followerReplicas, r.Dk8sClient)
185180
if err != nil {
186-
return ctrl.Result{}, err
181+
return intctrlutil.RequeueWithError(err, reqLogger, "")
187182
}
188183
}
189184

190185
if nc := k8sutils.CheckRedisNodeCount(ctx, r.K8sClient, r.Log, instance, ""); nc != totalReplicas {
191-
reqLogger.Info("Creating redis cluster by executing cluster creation commands", "Leaders.Ready", strconv.Itoa(int(redisLeaderInfo.Status.ReadyReplicas)), "Followers.Ready", strconv.Itoa(int(redisFollowerInfo.Status.ReadyReplicas)))
186+
reqLogger.Info("Creating redis cluster by executing cluster creation commands", "Leaders.Ready", redisLeaderInfo.Status.ReadyReplicas, "Followers.Ready", redisFollowerInfo.Status.ReadyReplicas)
192187
leaderCount := k8sutils.CheckRedisNodeCount(ctx, r.K8sClient, r.Log, instance, "leader")
193188
if leaderCount != leaderReplicas {
194189
reqLogger.Info("Not all leader are part of the cluster...", "Leaders.Count", leaderCount, "Instance.Size", leaderReplicas)
@@ -211,16 +206,15 @@ func (r *RedisClusterReconciler) Reconcile(ctx context.Context, req ctrl.Request
211206
reqLogger.Info("no follower/replicas configured, skipping replication configuration", "Leaders.Count", leaderCount, "Leader.Size", leaderReplicas, "Follower.Replicas", followerReplicas)
212207
}
213208
}
214-
reqLogger.Info("Redis cluster count is not desired", "Current.Count", nc, "Desired.Count", totalReplicas)
215-
return ctrl.Result{RequeueAfter: time.Second * 60}, nil
209+
return intctrlutil.RequeueAfter(reqLogger, time.Second*60, "Redis cluster count is not desired", "Current.Count", nc, "Desired.Count", totalReplicas)
216210
}
217211

218212
reqLogger.Info("Redis cluster count is desired")
219213
if int(totalReplicas) > 1 && k8sutils.CheckRedisClusterState(ctx, r.K8sClient, r.Log, instance) >= int(totalReplicas)-1 {
220214
reqLogger.Info("Redis leader is not desired, executing failover operation")
221215
err = k8sutils.ExecuteFailoverOperation(ctx, r.K8sClient, r.Log, instance)
222216
if err != nil {
223-
return ctrl.Result{}, err
217+
return intctrlutil.RequeueWithError(err, reqLogger, "")
224218
}
225219
}
226220

@@ -234,12 +228,11 @@ func (r *RedisClusterReconciler) Reconcile(ctx context.Context, req ctrl.Request
234228
if k8sutils.RedisClusterStatusHealth(ctx, r.K8sClient, r.Log, instance) {
235229
err = k8sutils.UpdateRedisClusterStatus(instance, status.RedisClusterReady, status.ReadyClusterReason, leaderReplicas, followerReplicas, r.Dk8sClient)
236230
if err != nil {
237-
return ctrl.Result{}, err
231+
return intctrlutil.RequeueWithError(err, reqLogger, "")
238232
}
239233
}
240234
}
241-
reqLogger.Info("Will reconcile redis cluster operator in again 10 seconds")
242-
return ctrl.Result{RequeueAfter: time.Second * 10}, nil
235+
return intctrlutil.RequeueAfter(reqLogger, time.Second*10, "")
243236
}
244237

245238
// SetupWithManager sets up the controller with the Manager.

‎controllers/redisreplication_controller.go‎

Lines changed: 14 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -7,9 +7,9 @@ import (
77

88
redisv1beta2 "github.com/OT-CONTAINER-KIT/redis-operator/api/v1beta2"
99
"github.com/OT-CONTAINER-KIT/redis-operator/k8sutils"
10+
intctrlutil "github.com/OT-CONTAINER-KIT/redis-operator/pkg/controllerutil"
1011
"github.com/go-logr/logr"
1112
corev1 "k8s.io/api/core/v1"
12-
"k8s.io/apimachinery/pkg/api/errors"
1313
"k8s.io/apimachinery/pkg/runtime"
1414
"k8s.io/client-go/dynamic"
1515
"k8s.io/client-go/kubernetes"
@@ -34,50 +34,45 @@ func (r *RedisReplicationReconciler) Reconcile(ctx context.Context, req ctrl.Req
3434

3535
err := r.Client.Get(context.TODO(), req.NamespacedName, instance)
3636
if err != nil {
37-
if errors.IsNotFound(err) {
38-
return ctrl.Result{}, nil
39-
}
40-
return ctrl.Result{}, err
37+
return intctrlutil.RequeueWithErrorChecking(err, reqLogger, "")
4138
}
4239
if instance.ObjectMeta.GetDeletionTimestamp() != nil {
4340
if err = k8sutils.HandleRedisReplicationFinalizer(r.Client, r.K8sClient, r.Log, instance); err != nil {
44-
return ctrl.Result{}, err
41+
return intctrlutil.RequeueWithError(err, reqLogger, "")
4542
}
46-
return ctrl.Result{}, nil
43+
return intctrlutil.Reconciled()
4744
}
4845
if _, found := instance.ObjectMeta.GetAnnotations()["redisreplication.opstreelabs.in/skip-reconcile"]; found {
49-
reqLogger.Info("Found annotations redisreplication.opstreelabs.in/skip-reconcile, so skipping reconcile")
50-
return ctrl.Result{RequeueAfter: time.Second * 10}, nil
46+
return intctrlutil.RequeueAfter(reqLogger, time.Second*10, "found skip reconcile annotation")
5147
}
5248

5349
leaderReplicas := int32(1)
5450
followerReplicas := instance.Spec.GetReplicationCounts("replication") - leaderReplicas
5551
totalReplicas := leaderReplicas + followerReplicas
5652

5753
if err = k8sutils.AddFinalizer(instance, k8sutils.RedisReplicationFinalizer, r.Client); err != nil {
58-
return ctrl.Result{}, err
54+
return intctrlutil.RequeueWithError(err, reqLogger, "")
5955
}
6056

6157
err = k8sutils.CreateReplicationRedis(instance, r.K8sClient)
6258
if err != nil {
63-
return ctrl.Result{}, err
59+
return intctrlutil.RequeueWithError(err, reqLogger, "")
6460
}
6561
err = k8sutils.CreateReplicationService(instance, r.K8sClient)
6662
if err != nil {
67-
return ctrl.Result{}, err
63+
return intctrlutil.RequeueWithError(err, reqLogger, "")
6864
}
6965

7066
// Set Pod distruptiuon Budget Later
7167

7268
redisReplicationInfo, err := k8sutils.GetStatefulSet(r.K8sClient, r.Log, instance.GetNamespace(), instance.GetName())
7369
if err != nil {
74-
return ctrl.Result{RequeueAfter: time.Second * 60}, err
70+
return intctrlutil.RequeueAfter(reqLogger, time.Second*60, "")
7571
}
7672

7773
// Check that the Leader and Follower are ready in redis replication
7874
if redisReplicationInfo.Status.ReadyReplicas != totalReplicas {
79-
reqLogger.Info("Redis replication nodes are not ready yet", "Ready.Replicas", strconv.Itoa(int(redisReplicationInfo.Status.ReadyReplicas)), "Expected.Replicas", totalReplicas)
80-
return ctrl.Result{RequeueAfter: time.Second * 60}, nil
75+
return intctrlutil.RequeueAfter(reqLogger, time.Second*60, "Redis replication nodes are not ready yet", "Ready.Replicas", redisReplicationInfo.Status.ReadyReplicas, "Expected.Replicas", totalReplicas)
8176
}
8277

8378
var realMaster string
@@ -90,18 +85,17 @@ func (r *RedisReplicationReconciler) Reconcile(ctx context.Context, req ctrl.Req
9085
realMaster = masterNodes[0]
9186
}
9287
if err = k8sutils.CreateMasterSlaveReplication(ctx, r.K8sClient, r.Log, instance, masterNodes, realMaster); err != nil {
93-
return ctrl.Result{RequeueAfter: time.Second * 60}, err
88+
return intctrlutil.RequeueAfter(reqLogger, time.Second*60, "")
9489
}
9590
}
9691
realMaster = k8sutils.GetRedisReplicationRealMaster(ctx, r.K8sClient, r.Log, instance, masterNodes)
9792
if err = r.UpdateRedisReplicationMaster(ctx, instance, realMaster); err != nil {
98-
return ctrl.Result{}, err
93+
return intctrlutil.RequeueWithError(err, reqLogger, "")
9994
}
10095
if err = r.UpdateRedisPodRoleLabel(ctx, instance, realMaster); err != nil {
101-
return ctrl.Result{}, err
96+
return intctrlutil.RequeueWithError(err, reqLogger, "")
10297
}
103-
reqLogger.Info("Will reconcile redis operator in again 10 seconds")
104-
return ctrl.Result{RequeueAfter: time.Second * 10}, nil
98+
return intctrlutil.RequeueAfter(reqLogger, time.Second*10, "")
10599
}
106100

107101
func (r *RedisReplicationReconciler) UpdateRedisReplicationMaster(ctx context.Context, instance *redisv1beta2.RedisReplication, masterNode string) error {

0 commit comments

Comments
 (0)