Merge pull request #1515 from iltyty/nas-filesystem-id

Support specifying NAS filesystem ID

Author: k8s-ci-robot

pkg/nas/cloud/nas_client_v2.go

@@ -156,6 +156,13 @@ func (c *NasClientV2) DescribeAccesspoint(filesystemId, accessPointId string) (*
 	})
 }
 
+func (c *NasClientV2) DescribeFileSystems(filesystemID string) (*sdk.DescribeFileSystemsResponse, error) {
+	c.limiter.Take()
+	return c.client.DescribeFileSystems(&sdk.DescribeFileSystemsRequest{
+		FileSystemId: &filesystemID,
+	})
+}
+
 func IsAccessPointNotFoundError(err error) bool {
 	if err == nil {
 		return false

pkg/nas/filesystem_controller.go

@@ -43,7 +43,6 @@ import (
 
 const (
 	ProtocolType    = "protocolType"
-	FileSystemType  = "fileSystemType"
 	EncryptType     = "encryptType"
 	SnapshotID      = "snapshotID"
 	StorageType     = "storageType"
@@ -164,7 +163,8 @@ func (cs *filesystemController) CreateVolume(ctx context.Context, req *csi.Creat
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "init nas client: %v", err)
 	}
-	fileSystemID := ""
+	var fileSystemID string
+	fileSystemType := nasVol.FileSystemType
 	// if the pvc mapped fileSystem is already create, skip creating a filesystem
 	if value, ok := cs.pvcFileSystemIDMap.Load(pvName); ok && value != "" {
 		klog.Warningf("CreateVolume: Nfs Volume(%s)'s filesystem %s has Created Already, try to create mountTarget", pvName, value)
@@ -193,6 +193,7 @@ func (cs *filesystemController) CreateVolume(ctx context.Context, req *csi.Creat
 			return nil, status.Error(codes.Internal, errMsg)
 		}
 		fileSystemID = createFileSystemsResponse.FileSystemId
+		fileSystemType = createFileSystemsRequest.FileSystemType
 		cs.pvcFileSystemIDMap.Store(pvName, fileSystemID)
 		klog.Infof("CreateVolume: Volume: %s, Successful Create Nas filesystem with ID: %s, with requestID: %s", pvName, fileSystemID, createFileSystemsResponse.RequestId)
 
@@ -295,7 +296,8 @@ func (cs *filesystemController) CreateVolume(ctx context.Context, req *csi.Creat
 		time.Sleep(time.Duration(2) * time.Second)
 	}
 
-	volumeContext["fileSystemId"] = fileSystemID
+	volumeContext[filesystemIDKey] = fileSystemID
+	volumeContext[filesystemTypeKey] = fileSystemType
 	volumeContext["server"] = mountTargetDomain
 	volumeContext["path"] = filepath.Join("/")
 	if nasVol.FileSystemType == "extreme" {
@@ -322,7 +324,7 @@ func (cs *filesystemController) getNasVolumeOptions(req *csi.CreateVolumeRequest
 	nasVolArgs := &nasVolumeArgs{}
 	volOptions := req.GetParameters()
 
-	if nasVolArgs.FileSystemType, ok = volOptions[FileSystemType]; !ok {
+	if nasVolArgs.FileSystemType, ok = volOptions[filesystemTypeKey]; !ok {
 		nasVolArgs.ProtocolType = "standard"
 	} else if nasVolArgs.FileSystemType != "standard" && nasVolArgs.FileSystemType != "extreme" {
 		return nil, fmt.Errorf("Required parameter [parameter.fileSystemType] must be [standard, extreme]")

pkg/nas/filesystem_controller_test.go

@@ -138,10 +138,11 @@ func TestCreateVolume(t *testing.T) {
 				CapacityBytes: 0,
 				VolumeId:      "",
 				VolumeContext: map[string]string{
-					"deleteVolume": "false",
-					"fileSystemId": "file-system-id",
-					"path":         "/",
-					"server":       "",
+					"deleteVolume":   "false",
+					"fileSystemId":   "file-system-id",
+					"fileSystemType": "",
+					"path":           "/",
+					"server":         "",
 				},
 				ContentSource:      nil,
 				AccessibleTopology: nil,
@@ -172,10 +173,11 @@ func TestCreateVolume(t *testing.T) {
 				CapacityBytes: 0,
 				VolumeId:      "",
 				VolumeContext: map[string]string{
-					"deleteVolume": "false",
-					"fileSystemId": "file-system-id",
-					"path":         "/",
-					"server":       "",
+					"deleteVolume":   "false",
+					"fileSystemId":   "file-system-id",
+					"fileSystemType": "",
+					"path":           "/",
+					"server":         "",
 				},
 				ContentSource:      nil,
 				AccessibleTopology: nil,
@@ -192,10 +194,11 @@ func TestCreateVolume(t *testing.T) {
 				CapacityBytes: 0,
 				VolumeId:      "",
 				VolumeContext: map[string]string{
-					"deleteVolume": "false",
-					"fileSystemId": "file-system-id",
-					"path":         "/",
-					"server":       "",
+					"deleteVolume":   "false",
+					"fileSystemId":   "file-system-id",
+					"fileSystemType": "",
+					"path":           "/",
+					"server":         "",
 				},
 				ContentSource:      nil,
 				AccessibleTopology: nil,
@@ -212,11 +215,12 @@ func TestCreateVolume(t *testing.T) {
 				CapacityBytes: 100 * 1024 * 1024 * 1024,
 				VolumeId:      "",
 				VolumeContext: map[string]string{
-					"deleteVolume": "false",
-					"fileSystemId": "file-system-id",
-					"path":         "/share",
-					"server":       "test.mount.target.domain",
-					"vers":         "3",
+					"deleteVolume":   "false",
+					"fileSystemId":   "file-system-id",
+					"fileSystemType": "extreme",
+					"path":           "/share",
+					"server":         "test.mount.target.domain",
+					"vers":           "3",
 				},
 				ContentSource:      nil,
 				AccessibleTopology: nil,
@@ -279,9 +283,9 @@ func createExtremeFileSystemRequest() *csi.CreateVolumeRequest {
 			RequiredBytes: 100 * 1024 * 1024 * 1024,
 		},
 		Parameters: map[string]string{
-			FileSystemType: "extreme",
-			VpcID:          "vpc-id",
-			VSwitchID:      "vswitch-id",
+			filesystemTypeKey: "extreme",
+			VpcID:             "vpc-id",
+			VSwitchID:         "vswitch-id",
 		},
 	}
 }
@@ -857,7 +861,7 @@ func TestGetNasVolumeOptions(t *testing.T) {
 			name: "Invalid file system type",
 			args: &csi.CreateVolumeRequest{
 				Parameters: map[string]string{
-					FileSystemType: "InvalidFileSystemType",
+					filesystemTypeKey: "InvalidFileSystemType",
 				},
 			},
 			expected: nil,
@@ -870,7 +874,7 @@ func TestGetNasVolumeOptions(t *testing.T) {
 					RequiredBytes: 1024,
 				},
 				Parameters: map[string]string{
-					FileSystemType: "extreme",
+					filesystemTypeKey: "extreme",
 				},
 			},
 			expected: nil,
@@ -911,8 +915,8 @@ func TestGetNasVolumeOptions(t *testing.T) {
 					RequiredBytes: 100 * 1024 * 1024 * 1024,
 				},
 				Parameters: map[string]string{
-					FileSystemType: "extreme",
-					StorageType:    "InvalidStorageType",
+					filesystemTypeKey: "extreme",
+					StorageType:       "InvalidStorageType",
 				},
 			},
 			expected: nil,
@@ -925,8 +929,8 @@ func TestGetNasVolumeOptions(t *testing.T) {
 					RequiredBytes: 100 * 1024 * 1024 * 1024,
 				},
 				Parameters: map[string]string{
-					FileSystemType: "extreme",
-					EncryptType:    "InvalidEncryptType",
+					filesystemTypeKey: "extreme",
+					EncryptType:       "InvalidEncryptType",
 				},
 			},
 			expected: nil,

pkg/nas/interfaces/nas_client_v2_interface.go

@@ -10,4 +10,5 @@ type NasClientV2Interface interface {
 	CreateAccesspoint(req *sdk.CreateAccessPointRequest) (*sdk.CreateAccessPointResponse, error)
 	DeleteAccesspoint(filesystemId, accessPointId string) error
 	DescribeAccesspoint(filesystemId, accessPointId string) (*sdk.DescribeAccessPointResponse, error)
+	DescribeFileSystems(filesystemID string) (*sdk.DescribeFileSystemsResponse, error)
 }

pkg/nas/interfaces/nas_client_v2_mock.go

@@ -52,3 +52,9 @@ func (n *MockNasClientV2Interface) DescribeAccesspoint(filesystemId, accessPoint
 		FileSystemId:  &filesystemId,
 	})
 }
+
+func (n *MockNasClientV2Interface) DescribeFileSystems(filesystemID string) (*sdk.DescribeFileSystemsResponse, error) {
+	return n.client.DescribeFileSystems(&sdk.DescribeFileSystemsRequest{
+		FileSystemId: &filesystemID,
+	})
+}

pkg/nas/interfaces/nas_v2_interface.go

@@ -8,6 +8,7 @@ type NasV2Interface interface {
 	CreateDir(request *nas.CreateDirRequest) (*nas.CreateDirResponse, error)
 	DeleteAccessPoint(request *nas.DeleteAccessPointRequest) (*nas.DeleteAccessPointResponse, error)
 	DescribeAccessPoint(request *nas.DescribeAccessPointRequest) (*nas.DescribeAccessPointResponse, error)
+	DescribeFileSystems(request *nas.DescribeFileSystemsRequest) (*nas.DescribeFileSystemsResponse, error)
 	GetRecycleBinAttribute(request *nas.GetRecycleBinAttributeRequest) (*nas.GetRecycleBinAttributeResponse, error)
 	SetDirQuota(request *nas.SetDirQuotaRequest) (*nas.SetDirQuotaResponse, error)
 }

pkg/nas/interfaces/nas_v2_mock.go

@@ -138,7 +138,6 @@ const (
 	cnfsAlwaysFallbackEventTmpl                 = "CNFS automatically switched from %s to %s."
 	cnfsIfConnectFailedFallbackEventTmpl        = "Due to network issues, CNFS automatically switched from %s to %s."
 	cnfsIfMountTargetUnhealthyFallbackEventTmpl = "Due to mount target inactive, CNFS automatically switched from %s to %s."
-	cpfsServerSuffix                            = "cpfs.aliyuncs.com"
 )
 
 func validateNodePublishVolumeRequest(req *csi.NodePublishVolumeRequest) error {
@@ -207,12 +206,14 @@ func (ns *nodeServer) NodePublishVolume(ctx context.Context, req *csi.NodePublis
 	var cnfsName string
 	for key, value := range req.VolumeContext {
 		switch strings.ToLower(key) {
+		case "filesystemtype":
+			opt.FSType = value
 		case "useclient": // only VK will fetch this parameter from CNFS and add it to VolumeContext
 			opt.ClientType = strings.ToLower(value)
 			if opt.ClientType == EFCClient {
 				opt.MountProtocol = MountProtocolEFC
 			}
-			if strings.HasSuffix(req.VolumeContext["server"], cpfsServerSuffix) {
+			if isCPFS(req.VolumeContext[filesystemTypeKey], req.VolumeContext["server"]) {
 				opt.FSType = "cpfs"
 			} else {
 				opt.FSType = "standard"
@@ -334,7 +335,7 @@ func (ns *nodeServer) NodePublishVolume(ctx context.Context, req *csi.NodePublis
 		opt.Vers = "4.0"
 	}
 
-	if strings.Contains(opt.Server, "extreme.nas.aliyuncs.com") {
+	if isExtrameNAS(opt.FSType, opt.Server) {
 		if opt.Vers != "3" {
 			return nil, errors.New("Extreme nas only support nfs v3 " + opt.Server)
 		}
@@ -438,12 +439,12 @@ func (ns *nodeServer) NodePublishVolume(ctx context.Context, req *csi.NodePublis
 	}
 	if opt.MountProtocol == "efc" {
 		if strings.Contains(opt.Server, ".nas.aliyuncs.com") {
-			fsID := GetFsIDByNasServer(opt.Server)
+			fsID := getNASIDFromMapOrServer(req.VolumeContext, opt.Server)
 			if len(fsID) != 0 {
 				utils.WriteMetricsInfo(metricsPathPrefix, req, "10", "efc", "nas", fsID)
 			}
 		} else {
-			fsID := GetFsIDByCpfsServer(opt.Server)
+			fsID := getCPFSIDFromMapOrServer(req.VolumeContext, opt.Server)
 			if len(fsID) != 0 {
 				utils.WriteMetricsInfo(metricsPathPrefix, req, "10", "efc", "cpfs", fsID)
 			}

pkg/nas/nodeserver.go

@@ -18,28 +18,44 @@ package nas
 
 import (
 	"context"
+	"fmt"
 	"path/filepath"
 
 	"github.com/container-storage-interface/spec/lib/go/csi"
+	"github.com/kubernetes-sigs/alibaba-cloud-csi-driver/pkg/cloud/metadata"
 	"github.com/kubernetes-sigs/alibaba-cloud-csi-driver/pkg/common"
+	"github.com/kubernetes-sigs/alibaba-cloud-csi-driver/pkg/nas/interfaces"
 	"github.com/kubernetes-sigs/alibaba-cloud-csi-driver/pkg/nas/internal"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/klog/v2"
 )
 
-type sharepathController struct{}
+type sharepathController struct {
+	nasClient interfaces.NasClientV2Interface
+}
 
-func newSharepathController(_ *internal.ControllerConfig) (internal.Controller, error) {
-	return &sharepathController{}, nil
+func newSharepathController(config *internal.ControllerConfig) (internal.Controller, error) {
+	region, err := config.Metadata.Get(metadata.RegionID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get region ID: %w", err)
+	}
+	nasClient, err := config.NasClientFactory.V2(region)
+	if err != nil {
+		return nil, err
+	}
+	return &sharepathController{
+		nasClient: nasClient,
+	}, nil
 }
 
 func (cs *sharepathController) VolumeAs() string {
 	return "sharepath"
 }
 
 func (cs *sharepathController) CreateVolume(ctx context.Context, req *csi.CreateVolumeRequest) (*csi.CreateVolumeResponse, error) {
+	var server, path string
 	parameters := req.Parameters
 	reclaimPolicy, ok := parameters[common.CsiAlibabaCloudPrefix+"/"+"reclaimPolicy"]
 	if ok && reclaimPolicy != string(corev1.PersistentVolumeReclaimRetain) {
@@ -48,7 +64,7 @@ func (cs *sharepathController) CreateVolume(ctx context.Context, req *csi.Create
 	volumeContext := map[string]string{}
 	// using cnfs or not
 	if cnfsName := parameters["containerNetworkFileSystem"]; cnfsName != "" {
-		path := parameters["path"]
+		path = parameters["path"]
 		if path == "" {
 			path = "/"
 		} else {
@@ -57,7 +73,7 @@ func (cs *sharepathController) CreateVolume(ctx context.Context, req *csi.Create
 		volumeContext["containerNetworkFileSystem"] = cnfsName
 		volumeContext["path"] = path
 	} else {
-		server, path := muxServerSelector.SelectNfsServer(parameters["server"])
+		server, path = muxServerSelector.SelectNfsServer(parameters["server"])
 		if server == "" {
 			return nil, status.Error(codes.InvalidArgument, "invalid nas server")
 		}
@@ -68,6 +84,9 @@ func (cs *sharepathController) CreateVolume(ctx context.Context, req *csi.Create
 		volumeContext["path"] = path
 	}
 
+	volumeContext[filesystemIDKey] = getNASIDFromMapOrServer(parameters, server)
+	volumeContext[filesystemTypeKey] = getFilesystemTypeFromAPIOrServer(volumeContext[filesystemIDKey], server, cs.nasClient)
+
 	// fill volumeContext
 	if mountType := parameters["mountType"]; mountType != "" {
 		volumeContext["mountType"] = mountType

pkg/nas/sharepath_controller.go

@@ -104,11 +104,11 @@ func (cs *subpathController) CreateVolume(ctx context.Context, req *csi.CreateVo
 	} else {
 		var server string
 		server, path = muxServerSelector.SelectNfsServer(parameters["server"])
-		filesystemId, _, _ = strings.Cut(server, "-")
+		filesystemId = getNASIDFromMapOrServer(parameters, server)
 		if server == "" || filesystemId == "" {
 			return nil, status.Error(codes.InvalidArgument, "invalid nas server")
 		}
-		filesystemType = cloud.GetFilesystemTypeByMountTargetDomain(server)
+		filesystemType = getFilesystemTypeFromAPIOrServer(filesystemId, server, cs.nasClient)
 		// set volumeContext
 		if protocol := parameters["mountProtocol"]; protocol != "" {
 			volumeContext["mountProtocol"] = protocol
@@ -118,6 +118,8 @@ func (cs *subpathController) CreateVolume(ctx context.Context, req *csi.CreateVo
 	// fill volumeContext
 	path = filepath.Join(path, req.Name)
 	volumeContext["path"] = path
+	volumeContext[filesystemIDKey] = filesystemId
+	volumeContext[filesystemTypeKey] = filesystemType
 	if mountType := parameters["mountType"]; mountType != "" {
 		if mountType == "losetup" {
 			volumeContext["loopImageSize"] = strconv.FormatInt(capacity, 10)
@@ -191,8 +193,8 @@ func (cs *subpathController) DeleteVolume(ctx context.Context, req *csi.DeleteVo
 		recycleBinEnabled, _ = strconv.ParseBool(cnfs.Status.FsAttributes.EnableTrashCan)
 	} else {
 		server := attributes["server"]
-		filesystemId, _, _ = strings.Cut(server, "-")
-		filesystemType := cloud.GetFilesystemTypeByMountTargetDomain(server)
+		filesystemId = getNASIDFromMapOrServer(attributes, server)
+		filesystemType := getFilesystemTypeFromAPIOrServer(filesystemId, server, cs.nasClient)
 		if filesystemType == cloud.FilesystemTypeStandard {
 			var err error
 			recycleBinEnabled, err = cs.isRecycleBinEnabled(filesystemId)
@@ -274,7 +276,7 @@ func (cs *subpathController) ControllerExpandVolume(ctx context.Context, req *cs
 		filesystemId = cnfs.Status.FsAttributes.FilesystemID
 	} else {
 		server := attributes["server"]
-		filesystemId, _, _ = strings.Cut(server, "-")
+		filesystemId = getNASIDFromMapOrServer(pv.Spec.CSI.VolumeAttributes, server)
 	}
 	if filesystemId == "" {
 		return nil, status.Error(codes.InvalidArgument, "empty filesystemId")