use DNS for ICAT datacenters

Author: Abby Deng

internal/crusoe/nfs_flag.go

@@ -9,29 +9,31 @@ import (
 	"net/http"
 )
 
-const nfsFlagRouteTemplate = "%s/projects/%s/storage/nfs/is-using-nfs"
+const (
+	nfsFlagRouteTemplate                     = "%s/projects/%s/storage/nfs/is-using-nfs"
+	vastUseSecondaryClusterFlagRouteTemplate = "%s/projects/%s/storage/nfs/vast-use-secondary-cluster"
+)
 
 var (
-	errCreateNfsFlagRequest = errors.New("failed to create NFS flag request")
-	errGetNfsFlag           = errors.New("failed to get NFS flag")
-	errReadNfsResponse      = errors.New("failed to read NFS flag response")
-	errUnmarshalNfsFlag     = errors.New("failed to unmarshal NFS flag response")
+	errCreateFlagRequest = errors.New("failed to create flag request")
+	errGetFlag           = errors.New("failed to get flag")
+	errReadFlagResponse  = errors.New("failed to read flag response")
+	errUnmarshalFlag     = errors.New("failed to unmarshal flag response")
 )
 
 type NfsFlagResponse struct {
 	Status bool `json:"status"`
 }
 
-// GetNFSFlag returns true if the project has NFS enabled.
-func GetNFSFlag(ctx context.Context, crusoeHTTPClient *http.Client, apiEndpoint, projectID string) (bool, error) {
-	nfsFlagRoute := fmt.Sprintf(nfsFlagRouteTemplate, apiEndpoint, projectID)
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, nfsFlagRoute, http.NoBody)
+// getFlag is a helper function to fetch a boolean flag from the API.
+func getFlag(ctx context.Context, crusoeHTTPClient *http.Client, flagRoute string) (bool, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, flagRoute, http.NoBody)
 	if err != nil {
-		return false, fmt.Errorf("%w: %w", errCreateNfsFlagRequest, err)
+		return false, fmt.Errorf("%w: %w", errCreateFlagRequest, err)
 	}
 	resp, err := crusoeHTTPClient.Do(req)
 	if err != nil {
-		return false, fmt.Errorf("%w: %w", errGetNfsFlag, err)
+		return false, fmt.Errorf("%w: %w", errGetFlag, err)
 	}
 
 	if resp != nil && resp.Body != nil {
@@ -40,15 +42,33 @@ func GetNFSFlag(ctx context.Context, crusoeHTTPClient *http.Client, apiEndpoint,
 
 	bodyBytes, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return false, fmt.Errorf("%w: %w", errReadNfsResponse, err)
+		return false, fmt.Errorf("%w: %w", errReadFlagResponse, err)
 	}
 
-	var nfsFlag NfsFlagResponse
+	var flagResponse NfsFlagResponse
 
-	unmarshalErr := json.Unmarshal(bodyBytes, &nfsFlag)
+	unmarshalErr := json.Unmarshal(bodyBytes, &flagResponse)
 	if unmarshalErr != nil {
-		return false, fmt.Errorf("%w: %w", errUnmarshalNfsFlag, unmarshalErr)
+		return false, fmt.Errorf("%w: %w", errUnmarshalFlag, unmarshalErr)
 	}
 
-	return nfsFlag.Status, nil
+	return flagResponse.Status, nil
+}
+
+// GetNFSFlag returns true if the project has NFS enabled.
+func GetNFSFlag(ctx context.Context, crusoeHTTPClient *http.Client, apiEndpoint, projectID string) (bool, error) {
+	nfsFlagRoute := fmt.Sprintf(nfsFlagRouteTemplate, apiEndpoint, projectID)
+
+	return getFlag(ctx, crusoeHTTPClient, nfsFlagRoute)
+}
+
+// GetVastUseSecondaryClusterFlag returns true if the project has the vast-use-secondary-cluster flag enabled.
+func GetVastUseSecondaryClusterFlag(
+	ctx context.Context,
+	crusoeHTTPClient *http.Client,
+	apiEndpoint, projectID string,
+) (bool, error) {
+	flagRoute := fmt.Sprintf(vastUseSecondaryClusterFlagRouteTemplate, apiEndpoint, projectID)
+
+	return getFlag(ctx, crusoeHTTPClient, flagRoute)
 }

internal/node/fs/fs_node.go

@@ -16,6 +16,12 @@ import (
 	"k8s.io/mount-utils"
 )
 
+const (
+	crusoeCloudDNSNFSHost = "nfs.crusoecloudcompute.com"
+	icatLocation          = "icat-m"
+	dnsRemotePorts        = "dns"
+)
+
 type Node struct {
 	csi.UnimplementedNodeServer
 	CrusoeClient      *crusoeapi.APIClient
@@ -65,14 +71,32 @@ func (d *Node) NodePublishVolume(ctx context.Context, request *csi.NodePublishVo
 	}
 	klog.Infof("NFS enabled: %v", nfsEnabled)
 
+	vastUseSecondaryCluster, err := crusoe.GetVastUseSecondaryClusterFlag(
+		ctx, d.CrusoeHTTPClient, d.CrusoeAPIEndpoint, d.HostInstance.ProjectId,
+	)
+	if err != nil {
+		klog.Errorf("failed to fetch vast-use-secondary-cluster flag: %s", err)
+
+		return nil, status.Errorf(codes.Internal, "failed to fetch vast-use-secondary-cluster flag: %s", err)
+	}
+	klog.Infof("vast-use-secondary-cluster enabled: %v", vastUseSecondaryCluster)
+
 	var mountOpts []string
 
 	if request.GetReadonly() {
 		// Read-only volumes cannot be written to in any way
 		mountOpts = append(mountOpts, node.ReadOnlyMountOption)
 	}
 
-	err = nodePublishVolume(d.Mounter, d.Resizer, mountOpts, nfsEnabled, d.NFSRemotePorts, d.NFSHost, request)
+	// Use DNS for ICAT locations instead of IP-based NFSHost if feature flag is enabled
+	nfsHost := d.NFSHost
+	nfsRemotePorts := d.NFSRemotePorts
+	if vastUseSecondaryCluster && d.HostInstance.Location == icatLocation {
+		nfsHost = crusoeCloudDNSNFSHost
+		nfsRemotePorts = dnsRemotePorts
+	}
+
+	err = nodePublishVolume(d.Mounter, d.Resizer, mountOpts, nfsEnabled, nfsRemotePorts, nfsHost, request)
 	if err != nil {
 		klog.Errorf("failed to publish volume %s: %s", request.GetVolumeId(), err.Error())
 

internal/node/fs/util.go

@@ -17,13 +17,19 @@ const (
 )
 
 func getNFSMountOpts(nfsRemotePorts string) []string {
-	return []string{
+	opts := []string{
 		"vers=3",
 		"nconnect=16",
 		"spread_reads",
 		"spread_writes",
-		fmt.Sprintf("remoteports=%s", nfsRemotePorts),
 	}
+
+	// Only add remoteports if specified
+	if nfsRemotePorts != "" {
+		opts = append(opts, fmt.Sprintf("remoteports=%s", nfsRemotePorts))
+	}
+
+	return opts
 }
 
 func supportsFS(instance *crusoeapi.InstanceV1Alpha5) bool {