Skip to content
This repository was archived by the owner on Dec 6, 2024. It is now read-only.

Commit 9a139ce

Browse files
mukhoakashmukhoakash
committed
Improving logs and fixing a delete scenario
1 parent 8cb88ab commit 9a139ce

File tree

2 files changed

+67
-23
lines changed

2 files changed

+67
-23
lines changed

‎pkg/bucket/bucket_controller.go

+40-9
Original file line numberDiff line numberDiff line change
@@ -102,7 +102,7 @@ func (b *BucketListener) Add(ctx context.Context, inputBucket *v1alpha1.Bucket)
102102
rsp, err := b.provisionerClient.DriverCreateBucket(ctx, req)
103103
if err != nil {
104104
if status.Code(err) != codes.AlreadyExists {
105-
klog.ErrorS(err, "Failed to create bucket",
105+
klog.V(3).ErrorS(err, "Driver failed to create bucket",
106106
"bucket", bucket.ObjectMeta.Name)
107107
return errors.Wrap(err, "Failed to create bucket")
108108
}
@@ -111,14 +111,17 @@ func (b *BucketListener) Add(ctx context.Context, inputBucket *v1alpha1.Bucket)
111111

112112
if rsp == nil {
113113
err = errors.New("DriverCreateBucket returned a nil response")
114-
klog.ErrorS(err, "Internal Error")
114+
klog.V(3).ErrorS(err, "Internal Error from driver",
115+
"bucket", bucket.ObjectMeta.Name)
115116
return err
116117
}
117118

118119
if rsp.BucketId != "" {
119120
bucketID = rsp.BucketId
120121
bucketReady = true
121122
} else {
123+
klog.V(3).ErrorS(err, "DriverCreateBucket returned an empty bucketID",
124+
"bucket", bucket.ObjectMeta.Name)
122125
err = errors.New("DriverCreateBucket returned an empty bucketID")
123126
return err
124127
}
@@ -128,39 +131,48 @@ func (b *BucketListener) Add(ctx context.Context, inputBucket *v1alpha1.Bucket)
128131
ref := bucket.Spec.BucketClaim
129132
bucketClaim, err := b.bucketClaims(ref.Namespace).Get(ctx, ref.Name, metav1.GetOptions{})
130133
if err != nil {
131-
klog.ErrorS(err, "Failed to get bucketClaim",
134+
klog.V(3).ErrorS(err, "Failed to get bucketClaim",
132135
"bucketClaim", ref.Name,
133136
"bucket", bucket.ObjectMeta.Name)
134137
return err
135138
}
136139

137140
bucketClaim.Status.BucketReady = true
138141
if _, err = b.bucketClaims(bucketClaim.Namespace).UpdateStatus(ctx, bucketClaim, metav1.UpdateOptions{}); err != nil {
139-
klog.ErrorS(err, "Failed to update bucketClaim",
142+
klog.V(3).ErrorS(err, "Failed to update bucketClaim",
140143
"bucketClaim", ref.Name,
141144
"bucket", bucket.ObjectMeta.Name)
142145
return err
143146
}
147+
148+
klog.V(5).Infof("Successfully updated status of bucketClaim: %s, bucket: %s", bucketClaim.ObjectMeta.Name, bucket.ObjectMeta.Name)
144149
}
145150
}
146151

147152
controllerutil.AddFinalizer(bucket, consts.BucketFinalizer)
148153
if bucket, err = b.buckets().Update(ctx, bucket, metav1.UpdateOptions{}); err != nil {
149-
klog.ErrorS(err, "Failed to update bucket finalizers", "bucket", bucket.ObjectMeta.Name)
154+
klog.V(3).ErrorS(err, "Failed to update bucket finalizers", "bucket", bucket.ObjectMeta.Name)
150155
return errors.Wrap(err, "Failed to update bucket finalizers")
151156
}
152157

158+
klog.V(5).Infof("Successfully added finalizer to bucket: %s", bucket.ObjectMeta.Name)
159+
153160
// Setting the status here so that the updated object is used
154161
bucket.Status.BucketReady = bucketReady
155162
bucket.Status.BucketID = bucketID
156163

157164
// if this step fails, then controller will retry with backoff
158165
if _, err = b.buckets().UpdateStatus(ctx, bucket, metav1.UpdateOptions{}); err != nil {
159-
klog.ErrorS(err, "Failed to update bucket status",
166+
klog.V(3).ErrorS(err, "Failed to update bucket status",
160167
"bucket", bucket.ObjectMeta.Name)
161168
return errors.Wrap(err, "Failed to update bucket status")
162169
}
163170

171+
klog.V(3).InfoS("Add Bucket success",
172+
"bucket", bucket.ObjectMeta.Name,
173+
"bucketID", bucketID,
174+
"ns", bucket.ObjectMeta.Namespace)
175+
164176
return nil
165177
}
166178

@@ -186,12 +198,18 @@ func (b *BucketListener) Update(ctx context.Context, old, new *v1alpha1.Bucket)
186198
if strings.EqualFold(bucketAccess.Spec.BucketClaimName, bucketClaimName) {
187199
err = b.bucketAccesses(bucketClaimNs).Delete(ctx, bucketAccess.Name, metav1.DeleteOptions{})
188200
if err != nil {
201+
klog.V(3).ErrorS(err, "Error deleting BucketAccess",
202+
"name", bucketAccess.Name,
203+
"bucket", bucket.ObjectMeta.Name)
189204
return err
190205
}
191206
}
192207
}
193208

209+
klog.V(5).Infof("Successfully deleted dependent bucketAccess of bucket:%s", bucket.ObjectMeta.Name)
210+
194211
controllerutil.RemoveFinalizer(bucket, consts.BABucketFinalizer)
212+
klog.V(5).Infof("Successfully removed finalizer: %s of bucket: %s", consts.BABucketFinalizer, bucket.ObjectMeta.Name)
195213
}
196214

197215
if controllerutil.ContainsFinalizer(bucket, consts.BucketFinalizer) {
@@ -202,6 +220,9 @@ func (b *BucketListener) Update(ctx context.Context, old, new *v1alpha1.Bucket)
202220
}
203221
}
204222

223+
klog.V(3).InfoS("Update Bucket success",
224+
"name", bucket.ObjectMeta.Name,
225+
"ns", bucket.ObjectMeta.Namespace)
205226
return nil
206227
}
207228

@@ -225,7 +246,7 @@ func (b *BucketListener) InitializeKubeClient(k kube.Interface) {
225246

226247
serverVersion, err := k.Discovery().ServerVersion()
227248
if err != nil {
228-
klog.ErrorS(err, "Cannot determine server version")
249+
klog.V(3).ErrorS(err, "Cannot determine server version")
229250
} else {
230251
b.kubeVersion = utilversion.MustParseSemantic(serverVersion.GitVersion)
231252
}
@@ -238,7 +259,7 @@ func (b *BucketListener) InitializeBucketClient(bc buckets.Interface) {
238259

239260
func (b *BucketListener) deleteBucketOp(ctx context.Context, bucket *v1alpha1.Bucket) error {
240261
if !strings.EqualFold(bucket.Spec.DriverName, b.driverName) {
241-
klog.V(5).InfoS("Skipping bucket for provisiner",
262+
klog.V(5).InfoS("Skipping bucket for provisioner",
242263
"bucket", bucket.ObjectMeta.Name,
243264
"driver", bucket.Spec.DriverName,
244265
)
@@ -254,26 +275,36 @@ func (b *BucketListener) deleteBucketOp(ctx context.Context, bucket *v1alpha1.Bu
254275

255276
if _, err := b.provisionerClient.DriverDeleteBucket(ctx, req); err != nil {
256277
if status.Code(err) != codes.NotFound {
257-
klog.ErrorS(err, "Failed to delete bucket",
278+
klog.V(3).ErrorS(err, "Failed to delete bucket",
258279
"bucket", bucket.ObjectMeta.Name,
259280
)
260281
return err
261282
}
262283
}
284+
285+
klog.V(5).Infof("Successfully deleted bucketID: %s from the object storage for bucket: %s", bucket.Status.BucketID, bucket.ObjectMeta.Name)
263286
}
264287

265288
if bucket.Spec.BucketClaim != nil {
266289
ref := bucket.Spec.BucketClaim
267290
bucketClaim, err := b.bucketClaims(ref.Namespace).Get(ctx, ref.Name, metav1.GetOptions{})
268291
if err != nil {
292+
klog.V(3).ErrorS(err, "Error fetching bucketClaim",
293+
"bucketClaim", ref.Name,
294+
"bucket", bucket.ObjectMeta.Name)
269295
return err
270296
}
271297

272298
if controllerutil.RemoveFinalizer(bucketClaim, consts.BCFinalizer) {
273299
if _, err := b.bucketClaims(bucketClaim.ObjectMeta.Namespace).Update(ctx, bucketClaim, metav1.UpdateOptions{}); err != nil {
300+
klog.V(3).ErrorS(err, "Error removing finalizer from bucketClaim",
301+
"bucketClaim", bucketClaim.ObjectMeta.Name,
302+
"bucket", bucket.ObjectMeta.Name)
274303
return err
275304
}
276305
}
306+
307+
klog.V(5).Infof("Successfully removed finalizer: %s from bucketClaim: %s for bucket: %s", consts.BCFinalizer, bucketClaim.ObjectMeta.Name, bucket.ObjectMeta.Name)
277308
}
278309

279310
return nil

‎pkg/bucketaccess/bucketaccess_controller.go

+27-14
Original file line numberDiff line numberDiff line change
@@ -107,13 +107,13 @@ func (bal *BucketAccessListener) Add(ctx context.Context, inputBucketAccess *v1a
107107
namespace := bucketAccess.ObjectMeta.Namespace
108108
bucketClaim, err := bal.bucketClaims(namespace).Get(ctx, bucketClaimName, metav1.GetOptions{})
109109
if err != nil {
110-
klog.ErrorS(err, "Failed to fetch bucketClaim", "bucketClaim", bucketClaimName)
110+
klog.V(3).ErrorS(err, "Failed to fetch bucketClaim", "bucketClaim", bucketClaimName)
111111
return errors.Wrap(err, "Failed to fetch bucketClaim")
112112
}
113113

114114
if bucketClaim.Status.BucketName == "" || bucketClaim.Status.BucketReady != true {
115115
err := errors.New("BucketName cannot be empty or BucketNotReady in bucketClaim")
116-
klog.ErrorS(err,
116+
klog.V(3).ErrorS(err,
117117
"Invalid arguments",
118118
"bucketClaim", bucketClaim.Name,
119119
"bucketAccess", bucketAccess.ObjectMeta.Name,
@@ -142,7 +142,7 @@ func (bal *BucketAccessListener) Add(ctx context.Context, inputBucketAccess *v1a
142142

143143
bucket, err := bal.buckets().Get(ctx, bucketClaim.Status.BucketName, metav1.GetOptions{})
144144
if err != nil {
145-
klog.ErrorS(err, "Failed to fetch bucket", "bucket", bucketClaim.Status.BucketName)
145+
klog.V(3).ErrorS(err, "Failed to fetch bucket", "bucket", bucketClaim.Status.BucketName)
146146
return errors.Wrap(err, "Failed to fetch bucket")
147147
}
148148

@@ -163,7 +163,7 @@ func (bal *BucketAccessListener) Add(ctx context.Context, inputBucketAccess *v1a
163163
rsp, err := bal.provisionerClient.DriverGrantBucketAccess(ctx, req)
164164
if err != nil {
165165
if status.Code(err) != codes.AlreadyExists {
166-
klog.ErrorS(err,
166+
klog.V(3).ErrorS(err,
167167
"Failed to grant access",
168168
"bucketAccess", bucketAccess.ObjectMeta.Name,
169169
"bucketClaim", bucketClaimName,
@@ -175,14 +175,14 @@ func (bal *BucketAccessListener) Add(ctx context.Context, inputBucketAccess *v1a
175175

176176
if rsp.AccountId == "" {
177177
err = errors.New("AccountId not defined in DriverGrantBucketAccess")
178-
klog.ErrorS(err, "BucketAccess", bucketAccess.ObjectMeta.Name)
178+
klog.V(3).ErrorS(err, "BucketAccess", bucketAccess.ObjectMeta.Name)
179179
return errors.Wrap(err, fmt.Sprintf("BucketAccess %s", bucketAccess.ObjectMeta.Name))
180180
}
181181

182182
credentials := rsp.Credentials
183183
if len(credentials) != 1 {
184184
err = errors.New("Credentials returned in DriverGrantBucketAccessResponse should be of length 1")
185-
klog.ErrorS(err, "BucketAccess", bucketAccess.ObjectMeta.Name)
185+
klog.V(3).ErrorS(err, "BucketAccess", bucketAccess.ObjectMeta.Name)
186186
return errors.Wrap(err, fmt.Sprintf("BucketAccess %s", bucketAccess.ObjectMeta.Name))
187187
}
188188

@@ -230,7 +230,7 @@ func (bal *BucketAccessListener) Add(ctx context.Context, inputBucketAccess *v1a
230230

231231
if _, err := bal.secrets(namespace).Get(ctx, secretCredName, metav1.GetOptions{}); err != nil {
232232
if !kubeerrors.IsNotFound(err) {
233-
klog.ErrorS(err,
233+
klog.V(3).ErrorS(err,
234234
"Failed to create secrets",
235235
"bucketAccess", bucketAccess.ObjectMeta.Name,
236236
"bucket", bucket.ObjectMeta.Name)
@@ -249,7 +249,7 @@ func (bal *BucketAccessListener) Add(ctx context.Context, inputBucketAccess *v1a
249249
Type: corev1.SecretTypeOpaque,
250250
}, metav1.CreateOptions{}); err != nil {
251251
if !kubeerrors.IsAlreadyExists(err) {
252-
klog.ErrorS(err,
252+
klog.V(3).ErrorS(err,
253253
"Failed to create minted secret",
254254
"bucketAccess", bucketAccess.ObjectMeta.Name,
255255
"bucket", bucket.ObjectMeta.Name)
@@ -268,7 +268,7 @@ func (bal *BucketAccessListener) Add(ctx context.Context, inputBucketAccess *v1a
268268
if controllerutil.AddFinalizer(bucketAccess, consts.BAFinalizer) {
269269
bucketAccess, err = bal.bucketAccesses(bucketAccess.ObjectMeta.Namespace).Update(ctx, bucketAccess, metav1.UpdateOptions{})
270270
if err != nil {
271-
klog.ErrorS(err, "Failed to update BucketAccess finalizer",
271+
klog.V(3).ErrorS(err, "Failed to update BucketAccess finalizer",
272272
"bucketAccess", bucketAccess.ObjectMeta.Name,
273273
"bucket", bucket.ObjectMeta.Name)
274274
return errors.Wrap(err, fmt.Sprintf("Failed to update BucketAccess finalizer. BucketAccess: %s", bucketAccess.ObjectMeta.Name))
@@ -280,7 +280,7 @@ func (bal *BucketAccessListener) Add(ctx context.Context, inputBucketAccess *v1a
280280

281281
// if this step fails, then controller will retry with backoff
282282
if _, err := bal.bucketAccesses(bucketAccess.ObjectMeta.Namespace).UpdateStatus(ctx, bucketAccess, metav1.UpdateOptions{}); err != nil {
283-
klog.ErrorS(err, "Failed to update BucketAccess Status",
283+
klog.V(3).ErrorS(err, "Failed to update BucketAccess Status",
284284
"bucketAccess", bucketAccess.ObjectMeta.Name,
285285
"bucket", bucket.ObjectMeta.Name)
286286
return errors.Wrap(err, fmt.Sprintf("Failed to update BucketAccess Status. BucketAccess: %s", bucketAccess.ObjectMeta.Name))
@@ -298,11 +298,15 @@ func (bal *BucketAccessListener) Update(ctx context.Context, old, new *v1alpha1.
298298
"name", old.ObjectMeta.Name)
299299

300300
bucketAccess := new.DeepCopy()
301-
err := bal.deleteBucketAccessOp(ctx, bucketAccess)
302-
if err != nil {
303-
return err
301+
if !bucketAccess.GetDeletionTimestamp().IsZero() {
302+
err := bal.deleteBucketAccessOp(ctx, bucketAccess)
303+
if err != nil {
304+
return err
305+
}
304306
}
305307

308+
klog.V(3).InfoS("Update BucketAccess success",
309+
"name", old.ObjectMeta.Name)
306310
return nil
307311
}
308312

@@ -329,15 +333,24 @@ func (bal *BucketAccessListener) deleteBucketAccessOp(ctx context.Context, bucke
329333
if controllerutil.RemoveFinalizer(secret, consts.SecretFinalizer) {
330334
_, err = bal.secrets(bucketAccess.ObjectMeta.Namespace).Update(ctx, secret, metav1.UpdateOptions{})
331335
if err != nil {
336+
klog.V(3).ErrorS(err, "Error removing finalizer from secret",
337+
"secret", secret.ObjectMeta.Name,
338+
"bucketAccess", bucketAccess.ObjectMeta.Name)
332339
return err
333340
}
341+
342+
klog.V(5).Infof("Successfully removed finalizer from secret: %s, bucketAccess: %s", secret.ObjectMeta.Name, bucketAccess.ObjectMeta.Name)
334343
}
335344

336345
if controllerutil.RemoveFinalizer(bucketAccess, consts.BAFinalizer) {
337346
_, err = bal.bucketAccesses(bucketAccess.ObjectMeta.Namespace).Update(ctx, bucketAccess, metav1.UpdateOptions{})
338347
if err != nil {
348+
klog.V(3).ErrorS(err, "Error removing finalizer from bucketAccess",
349+
"bucketAccess", bucketAccess.ObjectMeta.Name)
339350
return err
340351
}
352+
353+
klog.V(5).Infof("Successfully removed finalizer from bucketAccess: %s", bucketAccess.ObjectMeta.Name)
341354
}
342355

343356
return nil
@@ -384,7 +397,7 @@ func (bal *BucketAccessListener) InitializeKubeClient(k kube.Interface) {
384397

385398
serverVersion, err := k.Discovery().ServerVersion()
386399
if err != nil {
387-
klog.ErrorS(err, "Cannot determine server version")
400+
klog.V(3).ErrorS(err, "Cannot determine server version")
388401
} else {
389402
bal.kubeVersion = utilversion.MustParseSemantic(serverVersion.GitVersion)
390403
}

0 commit comments

Comments
 (0)