Add a e2e test for controller and node expand volume

Author: davidz627

test/e2e/tests/single_zone_e2e_test.go

@@ -17,13 +17,16 @@ package tests
 import (
 	"context"
 	"fmt"
+	"path/filepath"
 	"strings"
 	"time"
 
 	"k8s.io/apimachinery/pkg/util/uuid"
 	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/klog"
 	"sigs.k8s.io/gcp-compute-persistent-disk-csi-driver/pkg/common"
 	gce "sigs.k8s.io/gcp-compute-persistent-disk-csi-driver/pkg/gce-cloud-provider/compute"
+	testutils "sigs.k8s.io/gcp-compute-persistent-disk-csi-driver/test/e2e/utils"
 
 	csi "github.com/container-storage-interface/spec/lib/go/csi"
 	. "github.com/onsi/ginkgo"
@@ -98,6 +101,114 @@ var _ = Describe("GCE PD CSI Driver", func() {
 
 	})
 
+	It("Should resize controller and node", func() {
+		testContext := getRandomTestContext()
+
+		p, z, _ := testContext.Instance.GetIdentity()
+		client := testContext.Client
+		instance := testContext.Instance
+
+		// Create Disk
+		volName := testNamePrefix + string(uuid.NewUUID())
+		volID, err := client.CreateVolume(volName, nil, defaultSizeGb,
+			&csi.TopologyRequirement{
+				Requisite: []*csi.Topology{
+					{
+						Segments: map[string]string{common.TopologyKeyZone: z},
+					},
+				},
+			})
+		Expect(err).To(BeNil(), "CreateVolume failed with error: %v", err)
+
+		// Validate Disk Created
+		cloudDisk, err := computeService.Disks.Get(p, z, volName).Do()
+		Expect(err).To(BeNil(), "Could not get disk from cloud directly")
+		Expect(cloudDisk.Type).To(ContainSubstring(standardDiskType))
+		Expect(cloudDisk.Status).To(Equal(readyState))
+		Expect(cloudDisk.SizeGb).To(Equal(defaultSizeGb))
+		Expect(cloudDisk.Name).To(Equal(volName))
+
+		defer func() {
+			// Delete Disk
+			client.DeleteVolume(volID)
+			Expect(err).To(BeNil(), "DeleteVolume failed")
+
+			// Validate Disk Deleted
+			_, err = computeService.Disks.Get(p, z, volName).Do()
+			Expect(gce.IsGCEError(err, "notFound")).To(BeTrue(), "Expected disk to not be found")
+		}()
+
+		// Attach Disk
+		err = client.ControllerPublishVolume(volID, instance.GetNodeID())
+		Expect(err).To(BeNil(), "Controller publish volume failed")
+
+		defer func() {
+			// Detach Disk
+			err = client.ControllerUnpublishVolume(volID, instance.GetNodeID())
+			if err != nil {
+				klog.Errorf("Failed to detach disk: %v", err)
+			}
+
+		}()
+
+		// Stage Disk
+		stageDir := filepath.Join("/tmp/", volName, "stage")
+		err = client.NodeStageVolume(volID, stageDir)
+		Expect(err).To(BeNil(), "Node Stage volume failed")
+
+		defer func() {
+			// Unstage Disk
+			err = client.NodeUnstageVolume(volID, stageDir)
+			if err != nil {
+				klog.Errorf("Failed to unstage volume: %v", err)
+			}
+			fp := filepath.Join("/tmp/", volName)
+			err = testutils.RmAll(instance, fp)
+			if err != nil {
+				klog.Errorf("Failed to rm file path %s: %v", fp, err)
+			}
+		}()
+
+		// Mount Disk
+		publishDir := filepath.Join("/tmp/", volName, "mount")
+		err = client.NodePublishVolume(volID, stageDir, publishDir)
+		Expect(err).To(BeNil(), "Node publish volume failed")
+
+		defer func() {
+			// Unmount Disk
+			err = client.NodeUnpublishVolume(volID, publishDir)
+			if err != nil {
+				klog.Errorf("NodeUnpublishVolume failed with error: %v", err)
+			}
+		}()
+
+		// 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 controller
+		var newSizeGb int64 = 10
+		err = client.ControllerExpandVolume(volID, newSizeGb)
+
+		Expect(err).To(BeNil(), "Controller expand volume failed")
+
+		// Verify cloud size
+		cloudDisk, err = computeService.Disks.Get(p, z, volName).Do()
+		Expect(err).To(BeNil(), "Get cloud disk failed")
+		Expect(cloudDisk.SizeGb).To(Equal(newSizeGb))
+
+		// 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)
+		Expect(err).To(BeNil(), "Failed to get FSSize in GB")
+		Expect(sizeGb).To(Equal(newSizeGb))
+
+	})
+
 	It("Should create disks in correct zones when topology is specified", func() {
 		Expect(testContexts).ToNot(BeEmpty())
 		testContext := getRandomTestContext()

test/e2e/utils/utils.go

@@ -20,6 +20,8 @@ import (
 	"math/rand"
 	"os"
 	"path"
+	"strconv"
+	"strings"
 	"time"
 
 	"golang.org/x/oauth2/google"
@@ -167,6 +169,19 @@ func ReadFile(instance *remote.InstanceInfo, filePath string) (string, error) {
 	return output, nil
 }
 
+func GetFSSizeInGb(instance *remote.InstanceInfo, path string) (int64, error) {
+	output, err := instance.SSHNoSudo("df", "--output=size", "-BG", path, "|", "awk", "'NR==2'")
+	if err != nil {
+		return -1, fmt.Errorf("failed to get size of path %s. Output: %v, error: %v", path, output, err)
+	}
+	output = strings.TrimSuffix(strings.TrimSpace(output), "G")
+	n, err := strconv.ParseInt(output, 10, 64)
+	if err != nil {
+		return -1, fmt.Errorf("failed to parse size %s into int", output)
+	}
+	return n, nil
+}
+
 func RmAll(instance *remote.InstanceInfo, filePath string) error {
 	output, err := instance.SSH("rm", "-rf", filePath)
 	if err != nil {

test/remote/client-wrappers.go

@@ -179,6 +179,29 @@ func (c *CsiClient) NodePublishVolume(volumeId, stageDir, publishDir string) err
 	return err
 }
 
+func (c *CsiClient) ControllerExpandVolume(volumeId string, sizeGb int64) error {
+	controllerExpandReq := &csipb.ControllerExpandVolumeRequest{
+		VolumeId: volumeId,
+		CapacityRange: &csipb.CapacityRange{
+			RequiredBytes: common.GbToBytes(sizeGb),
+		},
+	}
+	_, err := c.ctrlClient.ControllerExpandVolume(context.Background(), controllerExpandReq)
+	return err
+}
+
+func (c *CsiClient) NodeExpandVolume(volumeId, volumePath string, sizeGb int64) error {
+	nodeExpandReq := &csipb.NodeExpandVolumeRequest{
+		VolumeId:   volumeId,
+		VolumePath: volumePath,
+		CapacityRange: &csipb.CapacityRange{
+			RequiredBytes: common.GbToBytes(sizeGb),
+		},
+	}
+	_, err := c.nodeClient.NodeExpandVolume(context.Background(), nodeExpandReq)
+	return err
+}
+
 func (c *CsiClient) NodeGetInfo() (*csipb.NodeGetInfoResponse, error) {
 	resp, err := c.nodeClient.NodeGetInfo(context.Background(), &csipb.NodeGetInfoRequest{})
 	return resp, err

test/remote/ssh.go

@@ -108,5 +108,6 @@ func runSSHCommand(cmd string, args ...string) (string, error) {
 	if err != nil {
 		return string(output), fmt.Errorf("command [%s %s] failed with error: %v", cmd, strings.Join(args, " "), err)
 	}
+	klog.V(4).Infof("SSH command: %v had output: %s", cmd, string(output))
 	return string(output), nil
 }