Add pending test for multi-writer attach. Updated for minimum multi-writer PD size of 200GB.

Author: Stephen Schmitt

examples/kubernetes/demo-pod-shared-pd.yaml

@@ -9,7 +9,7 @@ spec:
   storageClassName: csi-gce-pd
   resources:
     requests:
-      storage: 6Gi
+      storage: 200Gi
 
 ---
 

pkg/gce-cloud-provider/compute/gce-compute.go

@@ -335,11 +335,15 @@ func (cloud *CloudProvider) insertRegionalDisk(ctx context.Context, volKey *meta
 		alphaDiskToCreate := convertV1DiskToAlphaDisk(diskToCreate)
 		alphaDiskToCreate.MultiWriter = multiWriter
 		insertOp, err = cloud.alphaService.RegionDisks.Insert(cloud.project, volKey.Region, alphaDiskToCreate).Context(ctx).Do()
-		opName = insertOp.Name
+		if err == nil {
+			opName = insertOp.Name
+		}
 	} else {
 		var insertOp *computev1.Operation
 		insertOp, err = cloud.service.RegionDisks.Insert(cloud.project, volKey.Region, diskToCreate).Context(ctx).Do()
-		opName = insertOp.Name
+		if err == nil {
+			opName = insertOp.Name
+		}
 	}
 	if err != nil {
 		if IsGCEError(err, "alreadyExists") {
@@ -415,11 +419,15 @@ func (cloud *CloudProvider) insertZonalDisk(ctx context.Context, volKey *meta.Ke
 		alphaDiskToCreate := convertV1DiskToAlphaDisk(diskToCreate)
 		alphaDiskToCreate.MultiWriter = multiWriter
 		insertOp, err = cloud.alphaService.Disks.Insert(cloud.project, volKey.Zone, alphaDiskToCreate).Context(ctx).Do()
-		opName = insertOp.Name
+		if err == nil {
+			opName = insertOp.Name
+		}
 	} else {
 		var insertOp *computev1.Operation
 		insertOp, err = cloud.service.Disks.Insert(cloud.project, volKey.Zone, diskToCreate).Context(ctx).Do()
-		opName = insertOp.Name
+		if err == nil {
+			opName = insertOp.Name
+		}
 	}
 
 	if err != nil {

test/e2e/tests/multi_zone_e2e_test.go

@@ -256,7 +256,11 @@ func testLifecycleWithVerify(volID string, volName string, instance *remote.Inst
 	if secondMountVerify != nil {
 		// Mount disk somewhere else
 		secondPublishDir := filepath.Join("/tmp/", volName, "secondmount")
-		err = client.NodePublishVolume(volID, stageDir, secondPublishDir)
+		if useBlock {
+			err = client.NodePublishBlockVolume(volID, stageDir, secondPublishDir)
+		} else {
+			err = client.NodePublishVolume(volID, stageDir, secondPublishDir)
+		}
 		if err != nil {
 			return fmt.Errorf("NodePublishVolume failed with error: %v", err)
 		}
@@ -268,7 +272,10 @@ func testLifecycleWithVerify(volID string, volName string, instance *remote.Inst
 		b := verifyArgs{
 			publishDir: secondPublishDir,
 		}
-		secondMountVerify(b)
+		err = secondMountVerify(b)
+		if err != nil {
+			return fmt.Errorf("failed to verify after second mount to %s: %v", publishDir, err)
+		}
 
 		// Unmount Disk
 		err = client.NodeUnpublishVolume(volID, secondPublishDir)

test/e2e/tests/single_zone_e2e_test.go

@@ -33,13 +33,15 @@ import (
 	"google.golang.org/api/iterator"
 	kmspb "google.golang.org/genproto/googleapis/cloud/kms/v1"
 	fieldmask "google.golang.org/genproto/protobuf/field_mask"
+	testutils "sigs.k8s.io/gcp-compute-persistent-disk-csi-driver/test/e2e/utils"
 )
 
 const (
 	testNamePrefix = "gcepd-csi-e2e-"
 
 	defaultSizeGb      int64 = 5
 	defaultRepdSizeGb  int64 = 200
+	defaultMwSizeGb    int64 = 200
 	readyState               = "READY"
 	standardDiskType         = "pd-standard"
 	ssdDiskType              = "pd-ssd"
@@ -582,48 +584,63 @@ var _ = Describe("GCE PD CSI Driver", func() {
 		// Hardcode to us-east1-a while feature is in alpha
 		zone := "us-east1-a"
 
-		// Create Disk
-		volName := testNamePrefix + string(uuid.NewUUID())
-		volID, err := client.CreateVolumeWithCaps(volName, nil, defaultSizeGb,
-			&csi.TopologyRequirement{
-				Requisite: []*csi.Topology{
-					{
-						Segments: map[string]string{common.TopologyKeyZone: zone},
-					},
-				},
-			},
-			[]*csi.VolumeCapability{
-				{
-					AccessType: &csi.VolumeCapability_Block{
-						Block: &csi.VolumeCapability_BlockVolume{},
-					},
-					AccessMode: &csi.VolumeCapability_AccessMode{
-						Mode: csi.VolumeCapability_AccessMode_MULTI_NODE_MULTI_WRITER,
-					},
-				},
-			},
-		)
-		Expect(err).To(BeNil(), "CreateVolume failed with error: %v", err)
-
-		// Validate Disk Created
-		cloudDisk, err := computeAlphaService.Disks.Get(p, zone, 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))
-		Expect(cloudDisk.MultiWriter).To(Equal(true))
+		// Create and Validate Disk
+		volName, volID := createAndValidateUniqueZonalMultiWriterDisk(client, p, zone)
 
 		defer func() {
 			// Delete Disk
-			client.DeleteVolume(volID)
+			err := client.DeleteVolume(volID)
 			Expect(err).To(BeNil(), "DeleteVolume failed")
 
 			// Validate Disk Deleted
 			_, err = computeAlphaService.Disks.Get(p, zone, volName).Do()
 			Expect(gce.IsGCEError(err, "notFound")).To(BeTrue(), "Expected disk to not be found")
 		}()
 	})
+
+	// Pending while multi-writer feature is in Alpha
+	PIt("Should complete entire disk lifecycle with multi-writer disk", func() {
+		testContext := getRandomTestContext()
+
+		p, z, _ := testContext.Instance.GetIdentity()
+		client := testContext.Client
+		instance := testContext.Instance
+
+		// Create and Validate Disk
+		volName, volID := createAndValidateUniqueZonalMultiWriterDisk(client, p, z)
+
+		defer func() {
+			// Delete Disk
+			err := 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
+		testFileContents := "test"
+		writeFunc := func(a verifyArgs) error {
+			err := testutils.WriteBlock(instance, a.publishDir, testFileContents)
+			if err != nil {
+				return fmt.Errorf("Failed to write file: %v", err)
+			}
+			return nil
+		}
+		verifyReadFunc := func(a verifyArgs) error {
+			readContents, err := testutils.ReadBlock(instance, a.publishDir, len(testFileContents))
+			if err != nil {
+				return fmt.Errorf("ReadFile failed with error: %v", err)
+			}
+			if strings.TrimSpace(string(readContents)) != testFileContents {
+				return fmt.Errorf("wanted test file content: %s, got content: %s", testFileContents, readContents)
+			}
+			return nil
+		}
+		err := testLifecycleWithVerify(volID, volName, instance, client, false /* readOnly */, true /* block */, writeFunc, verifyReadFunc)
+		Expect(err).To(BeNil(), "Failed to go through volume lifecycle")
+	})
 })
 
 func equalWithinEpsilon(a, b, epsiolon int64) bool {
@@ -656,3 +673,38 @@ func createAndValidateUniqueZonalDisk(client *remote.CsiClient, project, zone st
 
 	return volName, volID
 }
+
+func createAndValidateUniqueZonalMultiWriterDisk(client *remote.CsiClient, project, zone string) (string, string) {
+	// Create Disk
+	volName := testNamePrefix + string(uuid.NewUUID())
+	volID, err := client.CreateVolumeWithCaps(volName, nil, defaultMwSizeGb,
+		&csi.TopologyRequirement{
+			Requisite: []*csi.Topology{
+				{
+					Segments: map[string]string{common.TopologyKeyZone: zone},
+				},
+			},
+		},
+		[]*csi.VolumeCapability{
+			{
+				AccessType: &csi.VolumeCapability_Block{
+					Block: &csi.VolumeCapability_BlockVolume{},
+				},
+				AccessMode: &csi.VolumeCapability_AccessMode{
+					Mode: csi.VolumeCapability_AccessMode_MULTI_NODE_MULTI_WRITER,
+				},
+			},
+		})
+	Expect(err).To(BeNil(), "CreateVolume failed with error: %v", err)
+
+	// Validate Disk Created
+	cloudDisk, err := computeAlphaService.Disks.Get(project, zone, 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(defaultMwSizeGb))
+	Expect(cloudDisk.Name).To(Equal(volName))
+	Expect(cloudDisk.MultiWriter).To(Equal(true))
+
+	return volName, volID
+}

test/e2e/utils/utils.go

@@ -170,6 +170,23 @@ func ReadFile(instance *remote.InstanceInfo, filePath string) (string, error) {
 	return output, nil
 }
 
+func WriteBlock(instance *remote.InstanceInfo, path, fileContents string) error {
+	output, err := instance.SSHNoSudo("echo", fileContents, "|", "dd", "of="+path)
+	if err != nil {
+		return fmt.Errorf("failed to write test file %s. Output: %v, errror: %v", path, output, err)
+	}
+	return nil
+}
+
+func ReadBlock(instance *remote.InstanceInfo, path string, length int) (string, error) {
+	lengthStr := strconv.Itoa(length)
+	output, err := instance.SSHNoSudo("dd", "if="+path, "bs="+lengthStr, "count=1", "2>", "/dev/null")
+	if err != nil {
+		return "", fmt.Errorf("failed to read test file %s. Output: %v, errror: %v", path, output, err)
+	}
+	return output, nil
+}
+
 func GetFSSizeInGb(instance *remote.InstanceInfo, mountPath string) (int64, error) {
 	output, err := instance.SSHNoSudo("df", "--output=size", "-BG", mountPath, "|", "awk", "'NR==2'")
 	if err != nil {