Merge pull request #1124 from savirg/nfs-options

Add mount options support in the createVolume method

Author: k8s-ci-robot

pkg/csi_driver/controller.go

@@ -75,6 +75,7 @@ const (
 	attrVolume             = "volume"
 	attrSupportLockRelease = "supportLockRelease"
 	attrFileProtocol       = "fileProtocol"
+	attrMountOptions       = "mountOptions"
 )
 
 // CreateVolume parameters
@@ -91,6 +92,7 @@ const (
 	ParamNfsExportOptions          = "nfs-export-options-on-create"
 	paramMaxVolumeSize             = "max-volume-size"
 	paramFileProtocol              = "protocol"
+	paramMountOptions              = "mount-options"
 
 	// Keys for PV and PVC parameters as reported by external-provisioner
 	ParameterKeyPVCName      = "csi.storage.k8s.io/pvc/name"
@@ -338,6 +340,12 @@ func (s *controllerServer) CreateVolume(ctx context.Context, req *csi.CreateVolu
 		return nil, status.Error(codes.Unavailable, err.Error())
 	}
 	resp := &csi.CreateVolumeResponse{Volume: s.fileInstanceToCSIVolume(filer, modeInstance)}
+	if mountOptions, ok := req.GetParameters()[paramMountOptions]; ok && mountOptions != "" {
+		if resp.Volume.VolumeContext == nil {
+			resp.Volume.VolumeContext = make(map[string]string)
+		}
+		resp.Volume.VolumeContext[attrMountOptions] = mountOptions
+	}
 
 	klog.Infof("CreateVolume succeeded: %+v", resp)
 	return resp, nil
@@ -679,7 +687,7 @@ func (s *controllerServer) generateNewFileInstance(name string, capBytes int64,
 			if s.config.features.FeatureNFSv4Support.Enabled {
 				fileProtocol = v
 			}
-		case ParameterKeyLabels, ParameterKeyPVCName, ParameterKeyPVCNamespace, ParameterKeyPVName:
+		case ParameterKeyLabels, ParameterKeyPVCName, ParameterKeyPVCNamespace, ParameterKeyPVName, paramMountOptions:
 		case "csiprovisionersecretname", "csiprovisionersecretnamespace":
 		default:
 			return nil, fmt.Errorf("invalid parameter %q", k)

pkg/csi_driver/controller_test.go

@@ -711,6 +711,40 @@ func TestCreateVolume(t *testing.T) {
 				},
 			},
 		},
+		{
+			name: "create volume with mount options",
+			req: &csi.CreateVolumeRequest{
+				Name: testCSIVolume,
+				VolumeCapabilities: []*csi.VolumeCapability{
+					{
+						AccessType: &csi.VolumeCapability_Mount{
+							Mount: &csi.VolumeCapability_MountVolume{},
+						},
+						AccessMode: &csi.VolumeCapability_AccessMode{
+							Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
+						},
+					},
+				},
+				Parameters: map[string]string{
+					"tier":          zonalTier,
+					"protocol":      v4_1FileProtocol,
+					"mount-options": "noatime,nodiratime",
+				},
+			},
+			resp: &csi.CreateVolumeResponse{
+				Volume: &csi.Volume{
+					CapacityBytes: 1 * util.Tb,
+					VolumeId:      testVolumeID,
+					VolumeContext: map[string]string{
+						attrIP:           testIP,
+						attrVolume:       newInstanceVolume,
+						attrFileProtocol: v4_1FileProtocol,
+						attrMountOptions: "noatime,nodiratime",
+					},
+				},
+			},
+			features: features,
+		},
 	}
 
 	for _, test := range cases {

pkg/csi_driver/node.go

@@ -95,6 +95,7 @@ func (s *nodeServer) NodePublishVolume(ctx context.Context, req *csi.NodePublish
 	readOnly := req.GetReadonly()
 	targetPath := req.GetTargetPath()
 	stagingTargetPath := req.GetStagingTargetPath()
+	volumeContext := req.GetVolumeContext()
 	if len(targetPath) == 0 {
 		return nil, status.Error(codes.InvalidArgument, "NodePublishVolume target path must be provided")
 	}
@@ -159,6 +160,10 @@ func (s *nodeServer) NodePublishVolume(ctx context.Context, req *csi.NodePublish
 		options = append(options, capMount.GetMountFlags()...)
 	}
 
+	if mountOptions := volumeContext[attrMountOptions]; mountOptions != "" {
+		options = append(options, mountOptions)
+	}
+
 	err = s.mounter.Mount(stagingTargetPath, targetPath, fstype, options)
 	if err != nil {
 		klog.Errorf("Mount %q failed on node %s, cleaning up", targetPath, s.driver.config.NodeName)
@@ -334,6 +339,10 @@ func (s *nodeServer) NodeStageVolume(ctx context.Context, req *csi.NodeStageVolu
 		}
 	}
 
+	if mountOptions := attr[attrMountOptions]; mountOptions != "" {
+		options = append(options, mountOptions)
+	}
+
 	err = s.mounter.Mount(source, stagingTargetPath, fstype, options)
 	if err != nil {
 		klog.Errorf("Mount %q failed on node %s, cleaning up", stagingTargetPath, s.driver.config.NodeName)

pkg/csi_driver/node_test.go

@@ -333,6 +333,22 @@ func TestNodePublishVolume(t *testing.T) {
 			},
 			expectErr: true,
 		},
+		{
+			name: "valid request with mountOptions in VolumeContext",
+			req: &csi.NodePublishVolumeRequest{
+				VolumeId:          testVolumeID,
+				StagingTargetPath: stagingTargetPath,
+				TargetPath:        testTargetPath,
+				VolumeCapability:  testVolumeCapability,
+				VolumeContext: map[string]string{
+					attrIP:           "1.1.1.1",
+					attrVolume:       "test-volume",
+					attrMountOptions: "noatime,nodiratime",
+				},
+			},
+			actions:       []mount.FakeAction{{Action: mount.FakeActionMount}},
+			expectedMount: &mount.MountPoint{Device: stagingTargetPath, Path: testTargetPath, Type: "nfs", Opts: []string{"bind", "noatime,nodiratime"}},
+		},
 		// TODO: Revisit this (https://github.com/kubernetes-sigs/gcp-filestore-csi-driver/issues/47).
 		// {
 		// 	name: "target path doesn't exist",
@@ -1038,6 +1054,50 @@ func TestNodeStageVolumeUpdateLockInfo(t *testing.T) {
 	}
 }
 
+func TestNodeStageVolume_AppendsMountOptions(t *testing.T) {
+	testEnv := initTestNodeServer(t)
+	attr := map[string]string{
+		attrIP:           "10.0.0.1",
+		attrVolume:       "vol1",
+		attrMountOptions: "hard,intr",
+	}
+	req := &csi.NodeStageVolumeRequest{
+		VolumeId:          "vol-test",
+		StagingTargetPath: "/tmp/stage",
+		VolumeCapability: &csi.VolumeCapability{
+			AccessType: &csi.VolumeCapability_Mount{
+				Mount: &csi.VolumeCapability_MountVolume{},
+			},
+			AccessMode: &csi.VolumeCapability_AccessMode{
+				Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
+			},
+		},
+		VolumeContext: attr,
+	}
+
+	_, err := testEnv.ns.NodeStageVolume(context.Background(), req)
+	if err != nil {
+		t.Fatalf("NodeStageVolume failed: %v", err)
+	}
+
+	fm := testEnv.fm
+	if len(fm.MountPoints) == 0 {
+		t.Fatalf("expected a mount call")
+	}
+	found := false
+	for _, mp := range fm.MountPoints {
+		for _, opt := range mp.Opts {
+			if opt == "hard,intr" {
+				found = true
+				break
+			}
+		}
+	}
+	if !found {
+		t.Errorf("expected mount options 'hard,intr' to be present in mount call")
+	}
+}
+
 func TestNodeUnstageVolumeUpdateLockInfo(t *testing.T) {
 	basePath, err := ioutil.TempDir("", "node-publish-")
 	if err != nil {