Fixing a bunch of issues

Author: mukhoakash

go.mod

@@ -3,30 +3,18 @@ module sigs.k8s.io/container-object-storage-interface-provisioner-sidecar
 go 1.15
 
 require (
-	github.com/google/go-cmp v0.5.2 // indirect
 	github.com/google/uuid v1.2.0 // indirect
-	github.com/kr/text v0.2.0 // indirect
-	github.com/mailru/easyjson v0.7.6 // indirect
-	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
 	github.com/pkg/errors v0.9.1
-	github.com/smartystreets/assertions v1.1.1 // indirect
-	github.com/spf13/cobra v1.1.3
+	github.com/spf13/cobra v1.4.0
 	github.com/spf13/pflag v1.0.5
-	github.com/spf13/viper v1.7.0
-	github.com/stretchr/testify v1.6.1 // indirect
-	golang.org/x/crypto v0.0.0-20201124201722-c8d3bf9c5392 // indirect
-	golang.org/x/net v0.0.0-20201216054612-986b41b23924 // indirect
-	golang.org/x/time v0.0.0-20201208040808-7e3f01d25324 // indirect
-	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
-	google.golang.org/grpc v1.35.0
+	github.com/spf13/viper v1.12.0
+	google.golang.org/grpc v1.46.2
 	gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b // indirect
-	gopkg.in/ini.v1 v1.57.0 // indirect
-	gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776 // indirect
-	k8s.io/api v0.19.4
-	k8s.io/apimachinery v0.19.4
-	k8s.io/client-go v0.19.4
-	k8s.io/klog/v2 v2.2.0
-	sigs.k8s.io/container-object-storage-interface-api v0.0.0-20210507174303-fac7c5076c3d
-	sigs.k8s.io/container-object-storage-interface-spec v0.0.0-20210507203703-a97f2e98ac90
-	sigs.k8s.io/controller-runtime v0.6.3
+	k8s.io/api v0.24.2
+	k8s.io/apimachinery v0.24.2
+	k8s.io/client-go v0.24.2
+	k8s.io/klog/v2 v2.70.1
+	sigs.k8s.io/container-object-storage-interface-api v0.0.0-20220727205553-02ff3dd25b5e
+	sigs.k8s.io/container-object-storage-interface-spec v0.0.0-20220804173401-3154aa8927e3
+	sigs.k8s.io/controller-runtime v0.12.3
 )

go.sum

@@ -24,10 +24,10 @@ import (
 	kube "k8s.io/client-go/kubernetes"
 	"k8s.io/klog/v2"
 
-	"sigs.k8s.io/container-object-storage-interface-api/apis/objectstorage.k8s.io/v1alpha1"
-	buckets "sigs.k8s.io/container-object-storage-interface-api/clientset"
-	bucketapi "sigs.k8s.io/container-object-storage-interface-api/clientset/typed/objectstorage.k8s.io/v1alpha1"
-	"sigs.k8s.io/container-object-storage-interface-provisioner-sidecar/pkg/const"
+	"sigs.k8s.io/container-object-storage-interface-api/apis/objectstorage/v1alpha1"
+	buckets "sigs.k8s.io/container-object-storage-interface-api/client/clientset/versioned"
+	bucketapi "sigs.k8s.io/container-object-storage-interface-api/client/clientset/versioned/typed/objectstorage/v1alpha1"
+	"sigs.k8s.io/container-object-storage-interface-provisioner-sidecar/pkg/consts"
 	cosi "sigs.k8s.io/container-object-storage-interface-spec"
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
 
@@ -63,6 +63,8 @@ func NewBucketListener(driverName string, client cosi.ProvisionerClient) *Bucket
 func (b *BucketListener) Add(ctx context.Context, inputBucket *v1alpha1.Bucket) error {
 	bucket := inputBucket.DeepCopy()
 
+	var err error
+
 	klog.V(3).InfoS("Add Bucket",
 		"name", bucket.ObjectMeta.Name,
 		"bucketclass", bucket.Spec.BucketClassName,
@@ -85,9 +87,10 @@ func (b *BucketListener) Add(ctx context.Context, inputBucket *v1alpha1.Bucket)
 		return nil
 	}
 
-	if bucket.Spec.ExistingBucketID != nil {
+	if bucket.Spec.ExistingBucketID != "" {
 		bucket.Status.BucketReady = true
 		bucket.Status.BucketID = bucket.Spec.ExistingBucketID
+
 	} else {
 		req := &cosi.DriverCreateBucketRequest{
 			Parameters: bucket.Spec.Parameters,
@@ -122,20 +125,26 @@ func (b *BucketListener) Add(ctx context.Context, inputBucket *v1alpha1.Bucket)
 		// Now we update the BucketReady status of BucketClaim
 		if bucket.Spec.BucketClaim != nil {
 			ref := bucket.Spec.BucketClaim
-			bucketClaim, err := b.BucketClaims(ref.Namespace).Get(ctx, ref.Name, metav1.GetOptions{})
+			bucketClaim, err := b.bucketClaims(ref.Namespace).Get(ctx, ref.Name, metav1.GetOptions{})
 			if err != nil {
 				return err
 			}
 
 			bucketClaim.Status.BucketReady = true
-			if _, err = b.BucketClaims(bucketClaim.Namespace).Update(ctx, bucketClaim, metav1.UpdateOptions{}); err != nil {
+			if _, err = b.bucketClaims(bucketClaim.Namespace).Update(ctx, bucketClaim, metav1.UpdateOptions{}); err != nil {
 				return err
 			}
 		}
 	}
 
+	controllerutil.AddFinalizer(bucket, consts.BucketFinalizer)
+	if _, err = b.buckets().Update(ctx, bucket, metav1.UpdateOptions{}); err != nil {
+		klog.ErrorS(err, "Failed to update bucket finalizers", "bucket", bucket.ObjectMeta.Name)
+		return errors.Wrap(err, "Failed to update bucket finalizers")
+	}
+
 	// if this step fails, then controller will retry with backoff
-	if _, err = b.Buckets().UpdateStatus(ctx, bucket, metav1.UpdateOptions{}); err != nil {
+	if _, err = b.buckets().UpdateStatus(ctx, bucket, metav1.UpdateOptions{}); err != nil {
 		klog.ErrorS(err, "Failed to update bucket status",
 			"bucket", bucket.ObjectMeta.Name)
 		return errors.Wrap(err, "Failed to update bucket status")
@@ -152,20 +161,33 @@ func (b *BucketListener) Update(ctx context.Context, old, new *v1alpha1.Bucket)
 	klog.V(3).InfoS("Update Bucket",
 		"name", old.Name)
 
-	if !new.GetDeletionTimestamp().IsZero() {
-		if len(new.ObjectMeta.Finalizers) > 0 {
-			bucketClaimNs := new.Spec.BucketClaim.Namespace
-			bucketClaimName := new.Spec.BucketClaim.Name
-			bucketAccessList, err := b.BucketAccesses(bucketClaimNs).List(ctx, ListOptions{})
+	bucket := new.DeepCopy()
+
+	var err error
+
+	if !bucket.GetDeletionTimestamp().IsZero() {
+		if controllerutil.ContainsFinalizer(bucket, consts.BABucketFinalizer) {
+			bucketClaimNs := bucket.Spec.BucketClaim.Namespace
+			bucketClaimName := bucket.Spec.BucketClaim.Name
+			bucketAccessList, err := b.bucketAccesses(bucketClaimNs).List(ctx, metav1.ListOptions{})
 
 			for _, bucketAccess := range bucketAccessList.Items {
 				if strings.EqualFold(bucketAccess.Spec.BucketClaimName, bucketClaimName) {
-					err = b.BucketAccesses(bucketClaimNs).Delete(ctx, bucketAccess.Name, metav1.DeleteOptions{})
+					err = b.bucketAccesses(bucketClaimNs).Delete(ctx, bucketAccess.Name, metav1.DeleteOptions{})
 					if err != nil {
 						return err
 					}
 				}
 			}
+
+			controllerutil.RemoveFinalizer(bucket, consts.BABucketFinalizer)
+		}
+
+		if controllerutil.ContainsFinalizer(bucket, consts.BucketFinalizer) {
+			err = b.deleteBucketOp(ctx, bucket)
+			if err != nil {
+				return err
+			}
 		}
 	}
 
@@ -177,13 +199,33 @@ func (b *BucketListener) Update(ctx context.Context, old, new *v1alpha1.Bucket)
 //    nil - Bucket successfully deleted
 //    non-nil err - Internal error                                [requeue'd with exponential backoff]
 func (b *BucketListener) Delete(ctx context.Context, inputBucket *v1alpha1.Bucket) error {
-	bucket := inputBucket.DeepCopy()
-
 	klog.V(3).InfoS("Delete Bucket",
-		"name", bucket.ObjectMeta.Name,
-		"bucketclass", bucket.Spec.BucketClassName,
+		"name", inputBucket.ObjectMeta.Name,
+		"bucketclass", inputBucket.Spec.BucketClassName,
 	)
 
+	return nil
+
+}
+
+// InitializeKubeClient initializes the kubernetes client
+func (b *BucketListener) InitializeKubeClient(k kube.Interface) {
+	b.kubeClient = k
+
+	serverVersion, err := k.Discovery().ServerVersion()
+	if err != nil {
+		klog.ErrorS(err, "Cannot determine server version")
+	} else {
+		b.kubeVersion = utilversion.MustParseSemantic(serverVersion.GitVersion)
+	}
+}
+
+// InitializeBucketClient initializes the object storage bucket client
+func (b *BucketListener) InitializeBucketClient(bc buckets.Interface) {
+	b.bucketClient = bc
+}
+
+func (b *BucketListener) deleteBucketOp(ctx context.Context, bucket *v1alpha1.Bucket) error {
 	if !strings.EqualFold(bucket.Spec.DriverName, b.driverName) {
 		klog.V(5).InfoS("Skipping bucket for provisiner",
 			"bucket", bucket.ObjectMeta.Name,
@@ -194,7 +236,7 @@ func (b *BucketListener) Delete(ctx context.Context, inputBucket *v1alpha1.Bucke
 
 	// We ask the driver to clean up the bucket from the storage provider
 	// only when the retain policy is set to Delete
-	if bucket.Spec.DeletionPolicy == bucketapi.DeletionPolicyDelete {
+	if bucket.Spec.DeletionPolicy == v1alpha1.DeletionPolicyDelete {
 		req := &cosi.DriverDeleteBucketRequest{
 			BucketId: bucket.Status.BucketID,
 		}
@@ -211,13 +253,13 @@ func (b *BucketListener) Delete(ctx context.Context, inputBucket *v1alpha1.Bucke
 
 	if bucket.Spec.BucketClaim != nil {
 		ref := bucket.Spec.BucketClaim
-		bucketClaim, err := b.BucketClaims(ref.Namespace).Get(ctx, ref.Name, metav1.GetOptions{})
+		bucketClaim, err := b.bucketClaims(ref.ObjectMeta.Namespace).Get(ctx, ref.ObjectMeta.Name, metav1.GetOptions{})
 		if err != nil {
 			return err
 		}
 
-		if controllerutil.RemoveFinalizer(bucketClaim, const.BcFinalizer) {
-			if _, err := b.BucketClaims(bucketClaim.Namespace).Update(ctx, bucketClaim, metav1.UpdateOptions{}); err != nil {
+		if controllerutil.RemoveFinalizer(bucketClaim, consts.BCFinalizer) {
+			if _, err := b.bucketClaims(bucketClaim.ObjectMeta.Namespace).Update(ctx, bucketClaim, metav1.UpdateOptions{}); err != nil {
 				return err
 			}
 		}
@@ -226,14 +268,14 @@ func (b *BucketListener) Delete(ctx context.Context, inputBucket *v1alpha1.Bucke
 	return nil
 }
 
-func (b *BucketListener) Buckets() bucketapi.BucketInterface {
+func (b *BucketListener) buckets() bucketapi.BucketInterface {
 	if b.bucketClient != nil {
 		return b.bucketClient.ObjectstorageV1alpha1().Buckets()
 	}
 	panic("uninitialized listener")
 }
 
-func (b *BucketListener) BucketClaims(namespace string) bucketapi.BucketClaimInterface {
+func (b *BucketListener) bucketClaims(namespace string) bucketapi.BucketClaimInterface {
 	if b.bucketClient != nil {
 		return b.bucketClient.ObjectstorageV1alpha1().BucketClaims(namespace)
 	}
@@ -242,26 +284,10 @@ func (b *BucketListener) BucketClaims(namespace string) bucketapi.BucketClaimInt
 }
 
 
-func (b *BucketListener) BucketAccesses(namespace string) bucketapi.BucketAccessInterface {
+func (b *BucketListener) bucketAccesses(namespace string) bucketapi.BucketAccessInterface {
 	if b.bucketClient != nil {
 		return b.bucketClient.ObjectstorageV1alpha1().BucketAccesses(namespace)
 	}
 	panic("uninitialized listener")
 }
 
-// InitializeKubeClient initializes the kubernetes client
-func (b *BucketListener) InitializeKubeClient(k kube.Interface) {
-	b.kubeClient = k
-
-	serverVersion, err := k.Discovery().ServerVersion()
-	if err != nil {
-		klog.ErrorS(err, "Cannot determine server version")
-	} else {
-		b.kubeVersion = utilversion.MustParseSemantic(serverVersion.GitVersion)
-	}
-}
-
-// InitializeBucketClient initializes the object storage bucket client
-func (b *BucketListener) InitializeBucketClient(bc buckets.Interface) {
-	b.bucketClient = bc
-}

pkg/bucket/bucket_controller.go

@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"testing"
 
-	"sigs.k8s.io/container-object-storage-interface-api/apis/objectstorage.k8s.io/v1alpha1"
-	fakebucketclientset "sigs.k8s.io/container-object-storage-interface-api/clientset/fake"
+	"sigs.k8s.io/container-object-storage-interface-api/apis/objectstorage/v1alpha1"
+	fakebucketclientset "sigs.k8s.io/container-object-storage-interface-api/client/clientset/versioned/fake"
 	cosi "sigs.k8s.io/container-object-storage-interface-spec"
 	fakespec "sigs.k8s.io/container-object-storage-interface-spec/fake"