GCSFuse Testing: Cache the gcsfuse version in a config map

Author: chrisThePattyEater

pkg/csi_driver/node.go

@@ -40,7 +40,7 @@ import (
 )
 
 const (
-	UmountTimeout = time.Second * 5
+	UmountTimeout = 5 * time.Microsecond
 	// GCSFuseKernelParamsFilePollInterval is the interval at which the GCSFuse kernel
 	// parameters file is polled and any changes to kernel parameter files are applied.
 	GCSFuseKernelParamsFilePollInterval = time.Second * 5

test/e2e/e2e_test.go

@@ -25,13 +25,20 @@ import (
 	"strings"
 	"testing"
 
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	"local/test/e2e/specs"
 	"local/test/e2e/testsuites"
+	"local/test/e2e/utils"
+
+	"context"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/googlecloudplatform/gcs-fuse-csi-driver/pkg/cloud_provider/clientset"
 	"github.com/googlecloudplatform/gcs-fuse-csi-driver/pkg/cloud_provider/metadata"
 	"github.com/onsi/ginkgo/v2"
 	"github.com/onsi/gomega"
+	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/tools/clientcmd"
 	"k8s.io/klog/v2"
 	"k8s.io/kubernetes/test/e2e/framework"
@@ -87,8 +94,30 @@ var _ = func() bool {
 	return true
 }()
 
+func maybeDeleteGCSFuseVersionConfigMap() {
+	config, err := clientcmd.BuildConfigFromFlags("", framework.TestContext.KubeConfig)
+	if err != nil {
+		klog.Errorf("Failed to build kube config while deleting gcsfuse version configmap: %v", err)
+		return
+	}
+
+	standardClient, err := kubernetes.NewForConfig(config)
+	if err != nil {
+		klog.Errorf("Failed to create client while deleting gcsfuse version configmap: %v", err)
+		return
+	}
+	err = standardClient.CoreV1().ConfigMaps(utils.DefaultNamespace).Delete(context.Background(), specs.GcsfuseVersionConfigMapName, metav1.DeleteOptions{})
+	if err != nil && !apierrors.IsNotFound(err) {
+		klog.Errorf("Failed to delete gcsfuse version configmap: %v", err)
+	}
+}
+
 func TestE2E(t *testing.T) {
+	// Try to delete the gcsfuse version configmap before running the tests. This is to handle the case where the previous test run is interrupted and the configmap is not deleted, which can cause issues for the current test run.
+	maybeDeleteGCSFuseVersionConfigMap()
 	t.Parallel()
+	// Delete the gcsfuse version configmap after the test finishes.
+	defer maybeDeleteGCSFuseVersionConfigMap()
 	gomega.RegisterFailHandler(framework.Fail)
 	if framework.TestContext.ReportDir != "" {
 		if err := os.MkdirAll(framework.TestContext.ReportDir, 0o755); err != nil {

test/e2e/specs/specs.go

@@ -38,6 +38,7 @@ import (
 	"k8s.io/apimachinery/pkg/fields"
 	"k8s.io/apimachinery/pkg/util/version"
 	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/klog/v2"
 
 	clientset "k8s.io/client-go/kubernetes"
 	"k8s.io/kubernetes/pkg/kubelet/events"
@@ -118,6 +119,9 @@ const (
 	driverDaemonsetLabel   = "k8s-app=gcs-fuse-csi-driver"
 
 	IsOSSEnvVar = "IS_OSS"
+
+	GcsfuseVersionConfigMapName = "gcsfuse-version-config"
+	gcsfuseVersionConfigMapKey  = "gcsfuse-version"
 )
 
 // Note to developers adding new testing methods - Please check the code path of newly added methods and ensure that those requiring
@@ -1073,6 +1077,15 @@ func (t *TestJob) Cleanup(ctx context.Context) {
 }
 
 func GetGCSFuseVersion(ctx context.Context, f *framework.Framework) string {
+	versionData, err := utils.ReadConfigMap(ctx, f.ClientSet, utils.DefaultNamespace, GcsfuseVersionConfigMapName)
+	if err != nil {
+		klog.Errorf("Failed to read GCS Fuse version configmap %s: %v, will retrieve it manually", GcsfuseVersionConfigMapName, err)
+	}
+
+	if versionData != nil && versionData[gcsfuseVersionConfigMapKey] != "" {
+		return versionData[gcsfuseVersionConfigMapKey]
+	}
+
 	client := f.ClientSet
 	configMaps, err := client.CoreV1().ConfigMaps("").List(ctx, metav1.ListOptions{
 		FieldSelector: "metadata.name=gcsfusecsi-image-config",
@@ -1121,7 +1134,14 @@ func GetGCSFuseVersion(ctx context.Context, f *framework.Framework) string {
 		// Versioning package (https://semver.org/#spec-item-9) treats `-gke.V` as pre release packages which can lead to comparison erros like v3.1.0 > v3.1.0-gke.0 (not considered same)
 		framework.Logf("Received GCS Fuse version %s does not follow to x.y.z-gke.v format which might lead to unprecedented test skips, continuing with %s", l[2])
 	}
-	return l[2]
+	gcsfuseVersion := l[2]
+	err = utils.UpsertConfigMap(ctx, f.ClientSet, utils.DefaultNamespace, GcsfuseVersionConfigMapName, map[string]string{
+		gcsfuseVersionConfigMapKey: gcsfuseVersion,
+	})
+	if err != nil {
+		klog.Errorf("Failed to upsert GCS Fuse version %s to configmap %s: %v, continuing...", gcsfuseVersion, GcsfuseVersionConfigMapName, err)
+	}
+	return gcsfuseVersion
 }
 
 func GCSFuseVersionAndBranch(ctx context.Context, f *framework.Framework) (*version.Version, string) {

test/e2e/utils/utils.go

@@ -18,23 +18,39 @@ limitations under the License.
 package utils
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"os/exec"
 	"strings"
+	"time"
 
+	corev1 "k8s.io/api/core/v1"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/version"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/client-go/kubernetes"
 	"k8s.io/klog/v2"
 )
 
-const MinGCSFuseKernelParamsVersion = "v3.7.0-gke.0"
+const (
+	DefaultNamespace              = "default"
+	MinGCSFuseKernelParamsVersion = "v3.7.0-gke.0"
+)
 
 var (
 	MasterBranchName = "master"
 
 	// Use release branch for corresponding gcsfuse version. This ensures we
 	// can pick up test fixes without requiring a new gcsfuse release.
 	gcsfuseReleaseBranchFormat = "v%v.%v.%v_release"
+	configMapBackoff           = wait.Backoff{
+		Duration: 200 * time.Millisecond,
+		Factor:   2.0,
+		Jitter:   0.1,
+		Steps:    5,
+	}
 )
 
 func EnsureVariable(v *string, set bool, msgOnError string) {
@@ -76,3 +92,68 @@ func GCSFuseBranch(gcsfuseVersionStr string) (*version.Version, string) {
 
 	return v, fmt.Sprintf(gcsfuseReleaseBranchFormat, v.Major(), v.Minor(), v.Patch())
 }
+
+func ReadConfigMap(
+	ctx context.Context,
+	client kubernetes.Interface,
+	namespace, name string,
+) (map[string]string, error) {
+
+	cm, err := client.CoreV1().
+		ConfigMaps(namespace).
+		Get(ctx, name, metav1.GetOptions{})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return cm.Data, nil
+}
+
+func UpsertConfigMap(
+	ctx context.Context,
+	client kubernetes.Interface,
+	namespace, name string,
+	data map[string]string,
+) error {
+
+	cmClient := client.CoreV1().ConfigMaps(namespace)
+
+	// First try create
+	_, err := cmClient.Create(ctx, &corev1.ConfigMap{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: name,
+		},
+		Data: data,
+	}, metav1.CreateOptions{})
+
+	if err == nil {
+		return nil
+	}
+
+	if !apierrors.IsAlreadyExists(err) {
+		return err
+	}
+
+	// Exists → update with retry on conflict
+	return wait.ExponentialBackoffWithContext(ctx, configMapBackoff, func(ctx context.Context) (bool, error) {
+		existing, err := cmClient.Get(ctx, name, metav1.GetOptions{})
+		if err != nil {
+			return false, err
+		}
+
+		if existing.Data == nil {
+			existing.Data = make(map[string]string)
+		}
+		for k, v := range data {
+			existing.Data[k] = v
+		}
+
+		_, err = cmClient.Update(ctx, existing, metav1.UpdateOptions{})
+		if apierrors.IsConflict(err) {
+			return false, nil
+		}
+
+		return true, err
+	})
+}