Merge pull request #126 from NetApp/mount-options

Support mount options

Author: k8s-ci-robot

pkg/controller/controller.go

@@ -110,9 +110,6 @@ const (
 var _ controller.Provisioner = &csiProvisioner{}
 
 var (
-	accessType = &csi.VolumeCapability_Mount{
-		Mount: &csi.VolumeCapability_MountVolume{},
-	}
 	// Each provisioner have a identify string to distinguish with others. This
 	// identify string will be added in PV annoations under this key.
 	provisionerIDKey = "storage.kubernetes.io/csiProvisionerIdentity"
@@ -364,9 +361,27 @@ func (p *csiProvisioner) Provision(options controller.VolumeOptions) (*v1.Persis
 		return nil, err
 	}
 
+	fsType := ""
+	for k, v := range options.Parameters {
+		switch strings.ToLower(k) {
+		case "fstype":
+			fsType = v
+		}
+	}
+	if len(fsType) == 0 {
+		fsType = defaultFSType
+	}
+
 	capacity := options.PVC.Spec.Resources.Requests[v1.ResourceName(v1.ResourceStorage)]
 	volSizeBytes := capacity.Value()
 
+	accessType := &csi.VolumeCapability_Mount{
+		Mount: &csi.VolumeCapability_MountVolume{
+			FsType:     fsType,
+			MountFlags: options.MountOptions,
+		},
+	}
+
 	// Get access mode
 	volumeCaps := make([]*csi.VolumeCapability, 0)
 	for _, cap := range options.PVC.Spec.AccessModes {
@@ -506,24 +521,14 @@ func (p *csiProvisioner) Provision(options controller.VolumeOptions) (*v1.Persis
 		return nil, capErr
 	}
 
-	fsType := ""
-	for k, v := range options.Parameters {
-		switch strings.ToLower(k) {
-		case "fstype":
-			fsType = v
-		}
-	}
-	if len(fsType) == 0 {
-		fsType = defaultFSType
-	}
-
 	pv := &v1.PersistentVolume{
 		ObjectMeta: metav1.ObjectMeta{
 			Name: pvName,
 		},
 		Spec: v1.PersistentVolumeSpec{
 			PersistentVolumeReclaimPolicy: options.PersistentVolumeReclaimPolicy,
 			AccessModes:                   options.PVC.Spec.AccessModes,
+			MountOptions:                  options.MountOptions,
 			Capacity: v1.ResourceList{
 				v1.ResourceName(v1.ResourceStorage): bytesToGiQuantity(respCap),
 			},

pkg/controller/controller_test.go

@@ -1039,6 +1039,62 @@ func TestProvision(t *testing.T) {
 			volWithLessCap: true,
 			expectErr:      true,
 		},
+		"provision with mount options": {
+			volOpts: controller.VolumeOptions{
+				PersistentVolumeReclaimPolicy: v1.PersistentVolumeReclaimDelete,
+				PVName: "test-name",
+				PVC: &v1.PersistentVolumeClaim{
+					ObjectMeta: metav1.ObjectMeta{
+						UID: "testid",
+					},
+					Spec: v1.PersistentVolumeClaimSpec{
+						Selector: nil,
+						Resources: v1.ResourceRequirements{
+							Requests: v1.ResourceList{
+								v1.ResourceName(v1.ResourceStorage): resource.MustParse(strconv.FormatInt(requestedBytes, 10)),
+							},
+						},
+						AccessModes: []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce},
+					},
+				},
+				MountOptions: []string{"foo=bar", "baz=qux"},
+				Parameters:   map[string]string{},
+			},
+			expectedPVSpec: &pvSpec{
+				Name:          "test-testi",
+				ReclaimPolicy: v1.PersistentVolumeReclaimDelete,
+				AccessModes:   []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce},
+				Capacity: v1.ResourceList{
+					v1.ResourceName(v1.ResourceStorage): bytesToGiQuantity(requestedBytes),
+				},
+				CSIPVS: &v1.CSIPersistentVolumeSource{
+					Driver:       "test-driver",
+					VolumeHandle: "test-volume-id",
+					FSType:       "ext4",
+					VolumeAttributes: map[string]string{
+						"storage.kubernetes.io/csiProvisionerIdentity": "test-provisioner",
+					},
+				},
+			},
+			expectCreateVolDo: func(ctx context.Context, req *csi.CreateVolumeRequest) {
+				if len(req.GetVolumeCapabilities()) != 1 {
+					t.Errorf("Incorrect length in volume capabilities")
+				}
+				cap := req.GetVolumeCapabilities()[0]
+				if cap.GetAccessMode() == nil {
+					t.Errorf("Expected access mode to be set")
+				}
+				if cap.GetAccessMode().GetMode() != csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER {
+					t.Errorf("Expected multi reade only")
+				}
+				if cap.GetMount() == nil {
+					t.Errorf("Expected access type to be mount")
+				}
+				if !reflect.DeepEqual(cap.GetMount().MountFlags, []string{"foo=bar", "baz=qux"}) {
+					t.Errorf("Expected 2 mount options")
+				}
+			},
+		},
 	}
 
 	mockController, driver, identityServer, controllerServer, csiConn, err := createMockServer(t)
@@ -1570,3 +1626,41 @@ func TestProvisionWithTopology(t *testing.T) {
 		t.Errorf("expected node affinity %v; got: %v", expectedNodeAffinity, pv.Spec.NodeAffinity)
 	}
 }
+
+// TestProvisionWithMountOptions is a test of provisioner integration with mount options.
+func TestProvisionWithMountOptions(t *testing.T) {
+	expectedOptions := []string{"foo=bar", "baz=qux"}
+	const requestBytes = 100
+	mockController, driver, identityServer, controllerServer, csiConn, err := createMockServer(t)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer mockController.Finish()
+	defer driver.Stop()
+
+	clientSet := fakeclientset.NewSimpleClientset()
+	csiClientSet := fakecsiclientset.NewSimpleClientset()
+	csiProvisioner := NewCSIProvisioner(clientSet, csiClientSet, driver.Address(), 5*time.Second, "test-provisioner", "test", 5, csiConn.conn, nil)
+
+	out := &csi.CreateVolumeResponse{
+		Volume: &csi.Volume{
+			CapacityBytes: requestBytes,
+			Id:            "test-volume-id",
+		},
+	}
+
+	provisionWithTopologyMockServerSetupExpectations(identityServer, controllerServer)
+	controllerServer.EXPECT().CreateVolume(gomock.Any(), gomock.Any()).Return(out, nil).Times(1)
+
+	pv, err := csiProvisioner.Provision(controller.VolumeOptions{
+		PVC:          createFakePVC(requestBytes), // dummy PVC
+		MountOptions: expectedOptions,
+	})
+	if err != nil {
+		t.Errorf("got error from Provision call: %v", err)
+	}
+
+	if !reflect.DeepEqual(pv.Spec.MountOptions, expectedOptions) {
+		t.Errorf("expected mount options %v; got: %v", expectedOptions, pv.Spec.MountOptions)
+	}
+}