Repository: kubernetes-sigs/gcp-compute-persistent-disk-csi-driver
Pull request #1072 (2022-11-07 08:53:52)

Add udevadm binary to container image
<!--  Thanks for sending a pull request!  Here are some tips for you:

1. If this is your first time, please read our contributor guidelines: https://git.k8s.io/community/contributors/guide#your-first-contribution and developer guide https://git.k8s.io/community/contributors/devel/development.md#development-guide
2. Follow the instructions for writing a release note: https://git.k8s.io/community/contributors/guide/release-notes.md
3. If the PR is unfinished, see how to mark it: https://git.k8s.io/community/contributors/guide/pull-requests.md#marking-unfinished-pull-requests
-->

**What type of PR is this?**

/kind bug

**What this PR does / why we need it**:

Address the error message
```console
udevadmChangeToDrive: udevadm trigger failed for drive "/dev/sdh" with output : exec: "udevadm": executable file not found in $PATH.
```

**Which issue(s) this PR fixes**:
<!--
*Automatically closes linked issue when PR is merged.
Usage: `Fixes #<issue number>`, or `Fixes (paste link of issue)`.
_If PR is about `failing-tests or flakes`, please post the related issues/tests in a comment and do not use `Fixes`_*
-->
Fixes #

**Special notes for your reviewer**:

The udevadm binary does not exist in the container image.

**Does this PR introduce a user-facing change?**:
<!--
If no, just write "NONE" in the release-note block below.
If yes, a release note is required:
Enter your extended release note in the block below. If the PR requires additional action from users switching to the new release, include the string "action required".
-->
```release-note
Add udevadm binary in the container image.
```



Patch:
diff --git a/Dockerfile b/Dockerfile
index 23792e0a..ebd89825 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -71,6 +71,7 @@ COPY --from=debian /bin/date /bin/date
 COPY --from=debian /bin/grep /bin/grep
 COPY --from=debian /bin/sed /bin/sed
 COPY --from=debian /bin/ln /bin/ln
+COPY --from=debian /bin/udevadm /bin/udevadm
 
 # Copy shared libraries into distroless base.
 COPY --from=debian /lib/${LIB_DIR_PREFIX}-linux-gnu/libblkid.so.1 \
@@ -79,6 +80,7 @@ COPY --from=debian /lib/${LIB_DIR_PREFIX}-linux-gnu/libblkid.so.1 \
                    /lib/${LIB_DIR_PREFIX}-linux-gnu/libe2p.so.2 \
                    /lib/${LIB_DIR_PREFIX}-linux-gnu/libext2fs.so.2 \
                    /lib/${LIB_DIR_PREFIX}-linux-gnu/libgcc_s.so.1 \
+                   /lib/${LIB_DIR_PREFIX}-linux-gnu/liblzma.so.5 \
                    /lib/${LIB_DIR_PREFIX}-linux-gnu/libmount.so.1 \
                    /lib/${LIB_DIR_PREFIX}-linux-gnu/libpcre.so.3 \
                    /lib/${LIB_DIR_PREFIX}-linux-gnu/libreadline.so.5 \
@@ -93,6 +95,7 @@ COPY --from=debian /usr/lib/${LIB_DIR_PREFIX}-linux-gnu/libacl.so.1 \
                    /usr/lib/${LIB_DIR_PREFIX}-linux-gnu/libicudata.so.63 \
                    /usr/lib/${LIB_DIR_PREFIX}-linux-gnu/libicui18n.so.63 \
                    /usr/lib/${LIB_DIR_PREFIX}-linux-gnu/libicuuc.so.63 \
+                   /usr/lib/${LIB_DIR_PREFIX}-linux-gnu/libkmod.so.2 \
                    /usr/lib/${LIB_DIR_PREFIX}-linux-gnu/libstdc++.so.6 /usr/lib/${LIB_DIR_PREFIX}-linux-gnu/
 
 # Copy NVME support required script and rules into distroless base.
diff --git a/pkg/gce-cloud-provider/compute/fake-gce.go b/pkg/gce-cloud-provider/compute/fake-gce.go
index 0f51640e..42e4d41d 100644
--- a/pkg/gce-cloud-provider/compute/fake-gce.go
+++ b/pkg/gce-cloud-provider/compute/fake-gce.go
@@ -424,7 +424,6 @@ func (cloud *FakeCloudProvider) CreateImage(ctx context.Context, project string,
 		SourceType:        "RAW",
 		Status:            "PENDING",
 		StorageLocations:  snapshotParams.StorageLocations,
-		Labels:            snapshotParams.Labels,
 	}
 
 	switch volKey.Type() {
diff --git a/pkg/gce-cloud-provider/compute/gce-compute.go b/pkg/gce-cloud-provider/compute/gce-compute.go
index 8f251280..1c14e600 100644
--- a/pkg/gce-cloud-provider/compute/gce-compute.go
+++ b/pkg/gce-cloud-provider/compute/gce-compute.go
@@ -924,7 +924,6 @@ func (cloud *CloudProvider) CreateImage(ctx context.Context, project string, vol
 		Name:             imageName,
 		StorageLocations: snapshotParams.StorageLocations,
 		Description:      description,
-		Labels:           snapshotParams.Labels,
 	}
 
 	_, err = cloud.service.Images.Insert(project, image).Context(ctx).ForceCreate(true).Do()
diff --git a/pkg/gce-pd-csi-driver/node.go b/pkg/gce-pd-csi-driver/node.go
index 8b9a5654..b37cba9e 100644
--- a/pkg/gce-pd-csi-driver/node.go
+++ b/pkg/gce-pd-csi-driver/node.go
@@ -340,15 +340,6 @@ func (ns *GCENodeServer) NodeStageVolume(ctx context.Context, req *csi.NodeStage
 				devicePath, stagingTargetPath, fstype, options, err))
 	}
 
-	// Part 4: Resize filesystem.
-	// https://github.com/kubernetes/kubernetes/issues/94929
-	resizer := resizefs.NewResizeFs(ns.Mounter)
-	_, err = resizer.Resize(devicePath, stagingTargetPath)
-	if err != nil {
-		return nil, status.Error(codes.Internal, fmt.Sprintf("error when resizing volume %s: %v", volumeID, err))
-
-	}
-
 	klog.V(4).Infof("NodeStageVolume succeeded on %v to %s", volumeID, stagingTargetPath)
 	return &csi.NodeStageVolumeResponse{}, nil
 }
diff --git a/pkg/resizefs/resizefs_linux.go b/pkg/resizefs/resizefs_linux.go
index da7f5411..674b785c 100644
--- a/pkg/resizefs/resizefs_linux.go
+++ b/pkg/resizefs/resizefs_linux.go
@@ -19,8 +19,7 @@ limitations under the License.
 package resizefs
 
 import (
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
+	"fmt"
 
 	"k8s.io/klog"
 	"k8s.io/mount-utils"
@@ -39,22 +38,51 @@ func NewResizeFs(mounter *mount.SafeFormatAndMount) *resizeFs {
 }
 
 // Resize perform resize of file system
-func (resizefs *resizeFs) Resize(devicePath, deviceMountPath string) (needResize bool, err error) {
-	resizer := mount.NewResizeFs(resizefs.mounter.Exec)
+func (resizefs *resizeFs) Resize(devicePath, deviceMountPath string) (bool, error) {
+	format, err := resizefs.mounter.GetDiskFormat(devicePath)
 
-	klog.V(4).Infof("Checking if filesystem needs to be resized. Device: %s Mountpoint: %s", devicePath, deviceMountPath)
-	if needResize, err = resizer.NeedResize(devicePath, deviceMountPath); err != nil {
-		err = status.Errorf(codes.Internal, "Could not determine if filesystem %q needs to be resized: %v", deviceMountPath, err)
-		return
+	if err != nil {
+		formatErr := fmt.Errorf("ResizeFS.Resize - error checking format for device %s: %v", devicePath, err)
+		return false, formatErr
 	}
 
-	if needResize {
-		klog.V(4).Infof("Resizing filesystem. Device: %s Mountpoint: %s", devicePath, deviceMountPath)
-		if _, err = resizer.Resize(devicePath, deviceMountPath); err != nil {
-			err = status.Errorf(codes.Internal, "Failed to resize filesystem %q: %v", deviceMountPath, err)
-			return
-		}
+	// If disk has no format, there is no need to resize the disk because mkfs.*
+	// by default will use whole disk anyways.
+	if format == "" {
+		return false, nil
 	}
 
-	return
+	klog.V(3).Infof("ResizeFS.Resize - Expanding mounted volume %s", devicePath)
+	switch format {
+	case "ext3", "ext4":
+		return resizefs.extResize(devicePath)
+	case "xfs":
+		return resizefs.xfsResize(deviceMountPath)
+	}
+	return false, fmt.Errorf("ResizeFS.Resize - resize of format %s is not supported for device %s mounted at %s", format, devicePath, deviceMountPath)
+}
+
+func (resizefs *resizeFs) extResize(devicePath string) (bool, error) {
+	output, err := resizefs.mounter.Exec.Command("resize2fs", devicePath).CombinedOutput()
+	if err == nil {
+		klog.V(2).Infof("Device %s resized successfully", devicePath)
+		return true, nil
+	}
+
+	resizeError := fmt.Errorf("resize of device %s failed: %v. resize2fs output: %s", devicePath, err, string(output))
+	return false, resizeError
+
+}
+
+func (resizefs *resizeFs) xfsResize(deviceMountPath string) (bool, error) {
+	args := []string{"-d", deviceMountPath}
+	output, err := resizefs.mounter.Exec.Command("xfs_growfs", args...).CombinedOutput()
+
+	if err == nil {
+		klog.V(2).Infof("Device %s resized successfully", deviceMountPath)
+		return true, nil
+	}
+
+	resizeError := fmt.Errorf("resize of device %s failed: %v. xfs_growfs output: %s", deviceMountPath, err, string(output))
+	return false, resizeError
 }
diff --git a/release-tools/filter-junit.go b/release-tools/filter-junit.go
index 5454092b..cf1cb4ab 100644
--- a/release-tools/filter-junit.go
+++ b/release-tools/filter-junit.go
@@ -35,18 +35,10 @@ var (
 )
 
 /*
- * TestResults represents a JUnit file. Due to how encoding/xml works, we have
+ * TestSuite represents a JUnit file. Due to how encoding/xml works, we have
  * represent all fields that we want to be passed through. It's therefore
  * not a complete solution, but good enough for Ginkgo + Spyglass.
- *
- * Before Kubernetes 1.25 and ginkgo v2, we directly had <testsuite> in the
- * JUnit file. Now we get <testsuites> and inside it the <testsuite>.
  */
-type TestResults struct {
-	XMLName   string    `xml:"testsuites"`
-	TestSuite TestSuite `xml:"testsuite"`
-}
-
 type TestSuite struct {
 	XMLName   string     `xml:"testsuite"`
 	TestCases []TestCase `xml:"testcase"`
@@ -101,15 +93,7 @@ func main() {
 			}
 		}
 		if err := xml.Unmarshal(data, &junit); err != nil {
-			if err.Error() != "expected element type <testsuite> but have <testsuites>" {
-				panic(err)
-			}
-			// Fall back to Ginkgo v2 format.
-			var junitv2 TestResults
-			if err := xml.Unmarshal(data, &junitv2); err != nil {
-				panic(err)
-			}
-			junit = junitv2.TestSuite
+			panic(err)
 		}
 	}
 
diff --git a/release-tools/go-get-kubernetes.sh b/release-tools/go-get-kubernetes.sh
index 2b46c187..0a960c47 100755
--- a/release-tools/go-get-kubernetes.sh
+++ b/release-tools/go-get-kubernetes.sh
@@ -13,7 +13,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
+#
 # This script can be used while converting a repo from "dep" to "go mod"
 # by calling it after "go mod init" or to update the Kubernetes packages
 # in a repo that has already been converted. Only packages that are
diff --git a/release-tools/prow.sh b/release-tools/prow.sh
index ba64d719..74cc017a 100755
--- a/release-tools/prow.sh
+++ b/release-tools/prow.sh
@@ -93,10 +93,7 @@ configvar CSI_PROW_GO_VERSION_KIND "${CSI_PROW_GO_VERSION_BUILD}" "Go version fo
 configvar CSI_PROW_GO_VERSION_GINKGO "${CSI_PROW_GO_VERSION_BUILD}" "Go version for building ginkgo" # depends on CSI_PROW_GINKGO_VERSION below
 
 # ginkgo test runner version to use. If the pre-installed version is
-# different, the desired version is built from source. For Kubernetes,
-# the version built via "make WHAT=vendor/github.com/onsi/ginkgo/ginkgo" is
-# used, which is guaranteed to match what the Kubernetes e2e.test binary
-# needs.
+# different, the desired version is built from source.
 configvar CSI_PROW_GINKGO_VERSION v1.7.0 "Ginkgo"
 
 # Ginkgo runs the E2E test in parallel. The default is based on the number
@@ -121,7 +118,7 @@ configvar CSI_PROW_BUILD_JOB true "building code in repo enabled"
 # use the same settings as for "latest" Kubernetes. This works
 # as long as there are no breaking changes in Kubernetes, like
 # deprecating or changing the implementation of an alpha feature.
-configvar CSI_PROW_KUBERNETES_VERSION 1.22.0 "Kubernetes"
+configvar CSI_PROW_KUBERNETES_VERSION 1.17.0 "Kubernetes"
 
 # CSI_PROW_KUBERNETES_VERSION reduced to first two version numbers and
 # with underscore (1_13 instead of 1.13.3) and in uppercase (LATEST
@@ -199,7 +196,7 @@ kindest/node:v1.14.10@sha256:f8a66ef82822ab4f7569e91a5bccaf27bceee135c1457c512e5
 # If the deployment script is called with CSI_PROW_TEST_DRIVER=<file name> as
 # environment variable, then it must write a suitable test driver configuration
 # into that file in addition to installing the driver.
-configvar CSI_PROW_DRIVER_VERSION "v1.8.0" "CSI driver version"
+configvar CSI_PROW_DRIVER_VERSION "v1.3.0" "CSI driver version"
 configvar CSI_PROW_DRIVER_REPO https://github.com/kubernetes-csi/csi-driver-host-path "CSI driver repo"
 configvar CSI_PROW_DEPLOYMENT "" "deployment"
 configvar CSI_PROW_DEPLOYMENT_SUFFIX "" "additional suffix in kubernetes-x.yy[suffix].yaml files"
@@ -237,7 +234,7 @@ configvar CSI_PROW_E2E_IMPORT_PATH "k8s.io/kubernetes" "E2E package"
 # of the cluster. The alternative would have been to (cross-)compile csi-sanity
 # and install it inside the cluster, which is not necessarily easier.
 configvar CSI_PROW_SANITY_REPO https://github.com/kubernetes-csi/csi-test "csi-test repo"
-configvar CSI_PROW_SANITY_VERSION v5.0.0 "csi-test version"
+configvar CSI_PROW_SANITY_VERSION v4.3.0 "csi-test version"
 configvar CSI_PROW_SANITY_PACKAGE_PATH github.com/kubernetes-csi/csi-test "csi-test package"
 configvar CSI_PROW_SANITY_SERVICE "hostpath-service" "Kubernetes TCP service name that exposes csi.sock"
 configvar CSI_PROW_SANITY_POD "csi-hostpathplugin-0" "Kubernetes pod with CSI driver"
@@ -349,12 +346,9 @@ configvar CSI_PROW_E2E_ALPHA "$(get_versioned_variable CSI_PROW_E2E_ALPHA "${csi
 # kubernetes-csi components must be updated, either by disabling
 # the failing test for "latest" or by updating the test and not running
 # it anymore for older releases.
-configvar CSI_PROW_E2E_ALPHA_GATES_LATEST '' "alpha feature gates for latest Kubernetes"
+configvar CSI_PROW_E2E_ALPHA_GATES_LATEST 'GenericEphemeralVolume=true,CSIStorageCapacity=true' "alpha feature gates for latest Kubernetes"
 configvar CSI_PROW_E2E_ALPHA_GATES "$(get_versioned_variable CSI_PROW_E2E_ALPHA_GATES "${csi_prow_kubernetes_version_suffix}")" "alpha E2E feature gates"
 
-configvar CSI_PROW_E2E_GATES_LATEST '' "non alpha feature gates for latest Kubernetes"
-configvar CSI_PROW_E2E_GATES "$(get_versioned_variable CSI_PROW_E2E_GATES "${csi_prow_kubernetes_version_suffix}")" "non alpha E2E feature gates"
-
 # Which external-snapshotter tag to use for the snapshotter CRD and snapshot-controller deployment
 default_csi_snapshotter_version () {
 	if [ "${CSI_PROW_KUBERNETES_VERSION}" = "latest" ] || [ "${CSI_PROW_DRIVER_CANARY}" = "canary" ]; then
@@ -443,10 +437,6 @@ install_kind () {
 
 # Ensure that we have the desired version of the ginkgo test runner.
 install_ginkgo () {
-    if [ -e "${CSI_PROW_BIN}/ginkgo" ]; then
-        return
-    fi
-
     # CSI_PROW_GINKGO_VERSION contains the tag with v prefix, the command line output does not.
     if [ "v$(ginkgo version 2>/dev/null | sed -e 's/.* //')" = "${CSI_PROW_GINKGO_VERSION}" ]; then
         return
@@ -950,9 +940,7 @@ install_e2e () {
         patch_kubernetes "${GOPATH}/src/${CSI_PROW_E2E_IMPORT_PATH}" "${CSI_PROW_WORK}" &&
         go_version="${CSI_PROW_GO_VERSION_E2E:-$(go_version_for_kubernetes "${GOPATH}/src/${CSI_PROW_E2E_IMPORT_PATH}" "${CSI_PROW_E2E_VERSION}")}" &&
         run_with_go "$go_version" make WHAT=test/e2e/e2e.test "-C${GOPATH}/src/${CSI_PROW_E2E_IMPORT_PATH}" &&
-        ln -s "${GOPATH}/src/${CSI_PROW_E2E_IMPORT_PATH}/_output/bin/e2e.test" "${CSI_PROW_WORK}" &&
-        run_with_go "$go_version" make WHAT=vendor/github.com/onsi/ginkgo/ginkgo "-C${GOPATH}/src/${CSI_PROW_E2E_IMPORT_PATH}" &&
-        ln -s "${GOPATH}/src/${CSI_PROW_E2E_IMPORT_PATH}/_output/bin/ginkgo" "${CSI_PROW_BIN}"
+        ln -s "${GOPATH}/src/${CSI_PROW_E2E_IMPORT_PATH}/_output/bin/e2e.test" "${CSI_PROW_WORK}"
     else
         run_with_go "${CSI_PROW_GO_VERSION_E2E}" go test -c -o "${CSI_PROW_WORK}/e2e.test" "${CSI_PROW_E2E_IMPORT_PATH}/test/e2e"
     fi
@@ -1266,8 +1254,7 @@ main () {
         fi
 
         if tests_need_non_alpha_cluster; then
-            # Need to (re)create the cluster.
-            start_cluster "${CSI_PROW_E2E_GATES}" || die "starting the non-alpha cluster failed"
+            start_cluster || die "starting the non-alpha cluster failed"
 
             # Install necessary snapshot CRDs and snapshot controller
             install_snapshot_crds
@@ -1317,11 +1304,7 @@ main () {
             delete_cluster_inside_prow_job non-alpha
         fi
 
-        # If the cluster for alpha tests doesn't need any feature gates, then we
-        # could reuse the same cluster as for the other tests. But that would make
-        # the flow in this script harder and wouldn't help in practice because
-        # we have separate Prow jobs for alpha and non-alpha tests.
-        if tests_need_alpha_cluster; then
+        if tests_need_alpha_cluster && [ "${CSI_PROW_E2E_ALPHA_GATES}" ]; then
             # Need to (re)create the cluster.
             start_cluster "${CSI_PROW_E2E_ALPHA_GATES}" || die "starting alpha cluster failed"
 


Test patch:
diff --git a/pkg/gce-pd-csi-driver/node_test.go b/pkg/gce-pd-csi-driver/node_test.go
index 14f68667..f064a4b1 100644
--- a/pkg/gce-pd-csi-driver/node_test.go
+++ b/pkg/gce-pd-csi-driver/node_test.go
@@ -17,10 +17,7 @@ package gceGCEDriver
 
 import (
 	"context"
-	"fmt"
 	"io/ioutil"
-	"k8s.io/utils/exec"
-	testingexec "k8s.io/utils/exec/testing"
 	"os"
 	"path/filepath"
 	"testing"
@@ -66,15 +63,6 @@ func getTestBlockingGCEDriver(t *testing.T, readyToExecute chan chan struct{}) *
 	return gceDriver
 }
 
-func makeFakeCmd(fakeCmd *testingexec.FakeCmd, cmd string, args ...string) testingexec.FakeCommandAction {
-	c := cmd
-	a := args
-	return func(cmd string, args ...string) exec.Cmd {
-		command := testingexec.InitFakeCmd(fakeCmd, c, a...)
-		return command
-	}
-}
-
 func TestNodeGetVolumeStats(t *testing.T) {
 	gceDriver := getTestGCEDriver(t)
 	ns := gceDriver.ns
@@ -363,6 +351,8 @@ func TestNodeUnpublishVolume(t *testing.T) {
 }
 
 func TestNodeStageVolume(t *testing.T) {
+	gceDriver := getTestGCEDriver(t)
+	ns := gceDriver.ns
 	volumeID := "project/test001/zones/c1/disks/testDisk"
 	blockCap := &csi.VolumeCapability_Block{
 		Block: &csi.VolumeCapability_BlockVolume{},
@@ -446,61 +436,6 @@ func TestNodeStageVolume(t *testing.T) {
 	}
 	for _, tc := range testCases {
 		t.Logf("Test case: %s", tc.name)
-		actionList := []testingexec.FakeCommandAction{
-			makeFakeCmd(
-				&testingexec.FakeCmd{
-					CombinedOutputScript: []testingexec.FakeAction{
-						func() ([]byte, []byte, error) {
-							return []byte(fmt.Sprintf("DEVNAME=/dev/sdb\nTYPE=ext4")), nil, nil
-						},
-					},
-				},
-				"blkid",
-			),
-			makeFakeCmd(
-				&testingexec.FakeCmd{
-					CombinedOutputScript: []testingexec.FakeAction{
-						func() ([]byte, []byte, error) {
-							return []byte("1"), nil, nil
-						},
-					},
-				},
-				"blockdev",
-			),
-			makeFakeCmd(
-				&testingexec.FakeCmd{
-					CombinedOutputScript: []testingexec.FakeAction{
-						func() ([]byte, []byte, error) {
-							return []byte("1"), nil, nil
-						},
-					},
-				},
-				"blockdev",
-			),
-			makeFakeCmd(
-				&testingexec.FakeCmd{
-					CombinedOutputScript: []testingexec.FakeAction{
-						func() ([]byte, []byte, error) {
-							return []byte(fmt.Sprintf("DEVNAME=/dev/sdb\nTYPE=ext4")), nil, nil
-						},
-					},
-				},
-				"blkid",
-			),
-			makeFakeCmd(
-				&testingexec.FakeCmd{
-					CombinedOutputScript: []testingexec.FakeAction{
-						func() ([]byte, []byte, error) {
-							return []byte(fmt.Sprintf("block size: 1\nblock count: 1")), nil, nil
-						},
-					},
-				},
-				"dumpe2fs",
-			),
-		}
-		mounter := mountmanager.NewFakeSafeMounterWithCustomExec(&testingexec.FakeExec{CommandScript: actionList})
-		gceDriver := getTestGCEDriverWithCustomMounter(t, mounter)
-		ns := gceDriver.ns
 		_, err := ns.NodeStageVolume(context.Background(), tc.req)
 		if err != nil {
 			serverError, ok := status.FromError(err)
diff --git a/test/e2e/tests/resize_e2e_test.go b/test/e2e/tests/resize_e2e_test.go
index 47f98313..48241267 100644
--- a/test/e2e/tests/resize_e2e_test.go
+++ b/test/e2e/tests/resize_e2e_test.go
@@ -232,12 +232,17 @@ var _ = Describe("GCE PD CSI Driver", func() {
 			}
 		}()
 
+		// Verify pre-resize fs size
+		sizeGb, err := testutils.GetFSSizeInGb(instance, publishDir)
+		Expect(err).To(BeNil(), "Failed to get FSSize in GB")
+		Expect(sizeGb).To(Equal(defaultSizeGb))
+
 		// Resize node
 		_, err = client.NodeExpandVolume(volID, publishDir, newSizeGb)
 		Expect(err).To(BeNil(), "Node expand volume failed")
 
 		// Verify disk size
-		sizeGb, err := testutils.GetFSSizeInGb(instance, publishDir)
+		sizeGb, err = testutils.GetFSSizeInGb(instance, publishDir)
 		Expect(err).To(BeNil(), "Failed to get FSSize in GB")
 		Expect(sizeGb).To(Equal(newSizeGb))
 
diff --git a/test/k8s-integration/config/image-volumesnapshotclass.yaml b/test/k8s-integration/config/image-volumesnapshotclass.yaml
index fe704885..ee62f215 100644
--- a/test/k8s-integration/config/image-volumesnapshotclass.yaml
+++ b/test/k8s-integration/config/image-volumesnapshotclass.yaml
@@ -7,5 +7,3 @@ deletionPolicy: Delete
 parameters:
   snapshot-type: images
   image-family: integration-test
-  # Add labels for testing.
-  labels: key1=value1,key2=value2
diff --git a/test/k8s-integration/config/pd-volumesnapshotclass.yaml b/test/k8s-integration/config/pd-volumesnapshotclass.yaml
index 427d4ebc..bff9c3cd 100644
--- a/test/k8s-integration/config/pd-volumesnapshotclass.yaml
+++ b/test/k8s-integration/config/pd-volumesnapshotclass.yaml
@@ -4,6 +4,3 @@ metadata:
   name: csi-gce-pd-snapshot-class
 driver: pd.csi.storage.gke.io
 deletionPolicy: Delete
-parameters:
-  # Add labels for testing.
-  labels: key1=value1,key2=value2
diff --git a/test/k8s-integration/main.go b/test/k8s-integration/main.go
index 52c03c0b..444d2209 100644
--- a/test/k8s-integration/main.go
+++ b/test/k8s-integration/main.go
@@ -638,14 +638,6 @@ func generateGKETestSkip(testParams *testParameters) string {
 		skipString = skipString + "|volumes.should.store.data|provisioning.should.provision.storage.with.snapshot.data.source"
 	}
 
-	// Starting in 1.24, the storage framework has a new test case:
-	// https://github.com/kubernetes/kubernetes/commit/4a076578451aa27e8ac60beec1fd3f23918c5331,
-	// which breaks the node skew tests when the node version
-	// is less than 1.24.
-	if nodeVer != nil && nodeVer.lessThan(mustParseVersion("1.24.0")) {
-		skipString = skipString + "|provisioning.should.mount.multiple.PV.pointing.to.the.same.storage.on.the.same.node"
-	}
-
 	return skipString
 }