Pilot commit for NAS support

Srivastava, Piyush · Srivastava, Piyush · commit 63e0f2f64318 · 2025-10-22T23:32:37.000+05:30
diff --git a/plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/feign/client/SvmFeignClient.java b/plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/feign/client/SvmFeignClient.java
@@ -23,9 +23,7 @@
 import org.apache.cloudstack.storage.feign.model.Svm;
 import org.apache.cloudstack.storage.feign.model.response.OntapResponse;
 import org.springframework.cloud.openfeign.FeignClient;
-import org.springframework.web.bind.annotation.RequestHeader;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.*;
 
 import java.net.URI;
 
@@ -37,6 +35,9 @@ public interface SvmFeignClient {
     OntapResponse<Svm> getSvms(URI baseURL, @RequestHeader("Authorization") String header);
 
     @RequestMapping(method = RequestMethod.GET, value = "/{uuid}")
-    Svm getSvmByUUID(URI baseURL, @RequestHeader("Authorization") String header);
+    Svm getSvmByUUID(URI baseURL, @RequestHeader("Authorization") String header, @PathVariable("uuid") String uuid);
+
+    @RequestMapping(method = RequestMethod.PATCH, value = "/{uuid}")
+    Svm updateSVM(URI baseURL, @RequestHeader("Authorization") String header, @RequestBody Svm svm);
 
 }
diff --git a/plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/lifecycle/OntapPrimaryDatastoreLifecycle.java b/plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/lifecycle/OntapPrimaryDatastoreLifecycle.java
@@ -66,6 +66,7 @@ public class OntapPrimaryDatastoreLifecycle extends BasePrimaryDataStoreLifeCycl
      */
     @Override
     public DataStore initialize(Map<String, Object> dsInfos) {
+        s_logger.info("initialize {}", dsInfos);
         if (dsInfos == null) {
             throw new CloudRuntimeException("Datastore info map is null, cannot create primary storage");
         }
@@ -94,7 +95,7 @@ public DataStore initialize(Map<String, Object> dsInfos) {
             return null;
         }
 
-        if (podId == null && clusterId == null) {
+        if (podId == null) {
             if (zoneId != null) {
                 s_logger.info("Both Pod Id and Cluster Id are null, Primary storage pool will be associated with a Zone");
             } else {
@@ -115,7 +116,7 @@ public DataStore initialize(Map<String, Object> dsInfos) {
             ClusterVO clusterVO = _clusterDao.findById(clusterId);
             Preconditions.checkNotNull(clusterVO, "Unable to locate the specified cluster");
             if (clusterVO.getHypervisorType() != Hypervisor.HypervisorType.KVM) {
-                throw new CloudRuntimeException("ONTAP primary storage is not supported for KVM hypervisor");
+                throw new CloudRuntimeException("ONTAP primary storage does not support" + clusterVO.getHypervisorType() + "hypervisor currently");
             }
             parameters.setHypervisorType(clusterVO.getHypervisorType());
         }
@@ -144,8 +145,7 @@ public DataStore initialize(Map<String, Object> dsInfos) {
         OntapStorage ontapStorage = new OntapStorage(details.get(Constants.USERNAME), details.get(Constants.PASSWORD),
                 details.get(Constants.MANAGEMENTLIF), details.get(Constants.SVMNAME), details.get(Constants.PROTOCOL),
                 Boolean.parseBoolean(details.get(Constants.ISDISAGGREGATED)));
-        StorageProviderFactory storageProviderManager = new StorageProviderFactory(ontapStorage);
-        StorageStrategy storageStrategy = storageProviderManager.getStrategy();
+        StorageStrategy storageStrategy = StorageProviderFactory.createStrategy(ontapStorage);
         boolean isValid = storageStrategy.connect();
         if (isValid) {
 //            String volumeName = storagePoolName + "_vol"; //TODO: Figure out a better naming convention
@@ -154,6 +154,7 @@ public DataStore initialize(Map<String, Object> dsInfos) {
             throw new CloudRuntimeException("ONTAP details validation failed, cannot create primary storage");
         }
 
+        String storagePath = url + ":/" + storagePoolName;
         parameters.setTags(tags);
         parameters.setIsTagARule(isTagARule);
         parameters.setDetails(details);
@@ -164,6 +165,7 @@ public DataStore initialize(Map<String, Object> dsInfos) {
         parameters.setName(storagePoolName);
         parameters.setProviderName(providerName);
         parameters.setManaged(true);
+        parameters.setPath(storagePath);
 
         return _dataStoreHelper.createPrimaryDataStore(parameters);
     }
diff --git a/plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/provider/StorageProviderFactory.java b/plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/provider/StorageProviderFactory.java
@@ -29,36 +29,29 @@
 import org.apache.logging.log4j.Logger;
 import org.springframework.stereotype.Component;
 
-@Component
 public class StorageProviderFactory {
-    private final StorageStrategy storageStrategy;
     private static final Logger s_logger = (Logger) LogManager.getLogger(StorageProviderFactory.class);
 
-    public StorageProviderFactory(OntapStorage ontapStorage) {
+    public static StorageStrategy createStrategy(OntapStorage ontapStorage) {
         String protocol = ontapStorage.getProtocol();
         s_logger.info("Initializing StorageProviderFactory with protocol: " + protocol);
         switch (protocol.toLowerCase()) {
             case Constants.NFS:
                 if(!ontapStorage.getIsDisaggregated()) {
-                    this.storageStrategy = new UnifiedNASStrategy(ontapStorage);
+                    return new UnifiedNASStrategy(ontapStorage);
                 } else {
                     throw new CloudRuntimeException("Unsupported configuration: Disaggregated ONTAP is not supported.");
                 }
-                break;
             case Constants.ISCSI:
                 if (!ontapStorage.getIsDisaggregated()) {
-                    this.storageStrategy = new UnifiedSANStrategy(ontapStorage);
+                   return new UnifiedSANStrategy(ontapStorage);
                 } else {
                     throw new CloudRuntimeException("Unsupported configuration: Disaggregated ONTAP is not supported.");
                 }
-                break;
             default:
-                this.storageStrategy = null;
+
                 throw new CloudRuntimeException("Unsupported protocol: " + protocol);
         }
     }
 
-    public StorageStrategy getStrategy() {
-        return storageStrategy;
-    }
 }
diff --git a/plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/service/NASStrategy.java b/plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/service/NASStrategy.java
@@ -27,6 +27,9 @@ public NASStrategy(OntapStorage ontapStorage) {
     }
 
     public abstract String createExportPolicy(String svmName, String policyName);
+    public abstract boolean deleteExportPolicy(String svmName, String policyName);
+    public abstract boolean exportPolicyExists(String svmName, String policyName);
+
     public abstract String addExportRule(String policyName, String clientMatch, String[] protocols, String[] roRule, String[] rwRule);
     public abstract String assignExportPolicyToVolume(String volumeUuid, String policyName);
     public abstract String enableNFS(String svmUuid);
diff --git a/plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/service/UnifiedNASStrategy.java b/plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/service/UnifiedNASStrategy.java
@@ -19,16 +19,126 @@
 
 package org.apache.cloudstack.storage.service;
 
-import org.apache.cloudstack.storage.feign.model.OntapStorage;
+import com.cloud.utils.exception.CloudRuntimeException;
+import feign.FeignException;
+import org.apache.cloudstack.storage.feign.client.NASFeignClient;
+import org.apache.cloudstack.storage.feign.client.SvmFeignClient;
+import org.apache.cloudstack.storage.feign.client.VolumeFeignClient;
+import org.apache.cloudstack.storage.feign.model.*;
+import org.apache.cloudstack.storage.feign.model.response.OntapResponse;
+import org.apache.cloudstack.storage.utils.Constants;
+import org.apache.cloudstack.storage.utils.Utility;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import javax.inject.Inject;
+import java.net.URI;
 
 public class UnifiedNASStrategy extends NASStrategy{
+
+    @Inject
+    private Utility utils;
+
+    @Inject
+    private NASFeignClient nasFeignClient;
+
+    @Inject
+    private SvmFeignClient svmFeignClient;
+
+    @Inject
+    private VolumeFeignClient volumeFeignClient;
+
+    private static final Logger s_logger = LogManager.getLogger(NASStrategy.class);
     public UnifiedNASStrategy(OntapStorage ontapStorage) {
         super(ontapStorage);
     }
 
     @Override
     public String createExportPolicy(String svmName, String policyName) {
-        return "";
+        s_logger.info("Creating export policy: {} for SVM: {}", policyName, svmName);
+
+        try {
+            // Get AuthHeader
+            String authHeader = utils.generateAuthHeader(OntapStorage.Username, OntapStorage.Password); // TODO change these once ontapStorage is made singleton
+
+            // Create ExportPolicy object
+            ExportPolicy exportPolicy = new ExportPolicy();
+            exportPolicy.setName(policyName);
+
+            // Set SVM
+            Svm svm = new Svm();
+            svm.setName(svmName);
+            exportPolicy.setSvm(svm);
+
+            // Create URI for export policy creation
+            URI url = URI.create(Constants.HTTPS + OntapStorage.ManagementLIF + "/api/protocols/nfs/export-policies"); // TODO move this to constants ?
+
+            // Create export policy
+            ExportPolicy createdPolicy = nasFeignClient.createExportPolicy(url, authHeader, true, exportPolicy);
+
+            if (createdPolicy != null && createdPolicy.getId() != null) {
+                s_logger.info("Export policy created successfully with ID: {}", createdPolicy.getId());
+                return createdPolicy.getId().toString();
+            } else {
+                throw new CloudRuntimeException("Failed to create export policy: " + policyName);
+            }
+
+        } catch (FeignException e) {
+            s_logger.error("Failed to create export policy: {}", policyName, e);
+            throw new CloudRuntimeException("Failed to create export policy: " + e.getMessage());
+        } catch (Exception e) {
+            s_logger.error("Exception while creating export policy: {}", policyName, e);
+            throw new CloudRuntimeException("Failed to create export policy: " + e.getMessage());
+        }
+    }
+
+    @Override
+    public boolean deleteExportPolicy(String svmName, String policyName) {
+        try {
+            String authHeader = utils.generateAuthHeader(OntapStorage.Username, OntapStorage.Password);
+
+            // Get policy ID first
+            URI getUrl = URI.create(Constants.HTTPS + OntapStorage.ManagementLIF +
+                    "/api/protocols/nfs/export-policies?name=" + policyName + "&svm.name=" + svmName); // TODO move this to constants and how to dynamic pass params later ?
+
+            OntapResponse<ExportPolicy> policiesResponse = nasFeignClient.getExportPolicyResponse(getUrl, authHeader);
+
+            if (policiesResponse.getRecords() == null || policiesResponse.getRecords().isEmpty()) {
+                s_logger.warn("Export policy not found for deletion: {}", policyName);
+                return false;
+            }
+
+            String policyId = policiesResponse.getRecords().get(0).getId().toString();
+
+            // Delete the policy
+            URI deleteUrl = URI.create(Constants.HTTPS + OntapStorage.ManagementLIF +
+                    "/api/protocols/nfs/export-policies/" + policyId);
+
+            nasFeignClient.deleteExportPolicyById(deleteUrl, authHeader, policyId);
+
+            s_logger.info("Export policy deleted successfully: {}", policyName);
+            return true;
+
+        } catch (Exception e) {
+            s_logger.error("Failed to delete export policy: {}", policyName, e);
+            return false;
+        }
+    }
+
+    @Override
+    public boolean exportPolicyExists(String svmName, String policyName) {
+        try {
+            String authHeader = utils.generateAuthHeader(OntapStorage.Username, OntapStorage.Password);
+            URI url = URI.create(Constants.HTTPS + OntapStorage.ManagementLIF +
+                    "/api/protocols/nfs/export-policies?name=" + policyName + "&svm.name=" + svmName);
+
+            OntapResponse<ExportPolicy> response = nasFeignClient.getExportPolicyResponse(url, authHeader);
+            return response.getRecords() != null && !response.getRecords().isEmpty();
+
+        } catch (Exception e) {
+            s_logger.warn("Error checking export policy existence: {}", e.getMessage());
+            return false;
+        }
     }
 
     @Override
@@ -38,11 +148,75 @@ public String addExportRule(String policyName, String clientMatch, String[] prot
 
     @Override
     public String assignExportPolicyToVolume(String volumeUuid, String policyName) {
-        return "";
+        s_logger.info("Assigning export policy: {} to volume: {}", policyName, volumeUuid);
+
+        try {
+            // Get AuthHeader
+            String authHeader = utils.generateAuthHeader(OntapStorage.Username, OntapStorage.Password);
+
+            // First, get the export policy by name
+            URI getPolicyUrl = URI.create(Constants.HTTPS + OntapStorage.ManagementLIF +
+                    "/api/protocols/nfs/export-policies?name=" + policyName + "&svm.name=" + OntapStorage.Svm);
+
+            OntapResponse<ExportPolicy> policiesResponse = nasFeignClient.getExportPolicyResponse(getPolicyUrl, authHeader);
+
+            if (policiesResponse.getRecords() == null || policiesResponse.getRecords().isEmpty()) {
+                throw new CloudRuntimeException("Export policy not found: " + policyName);
+            }
+
+            ExportPolicy exportPolicy = policiesResponse.getRecords().get(0);
+
+            // Create Volume update object with NAS configuration
+            Volume volumeUpdate = new Volume();
+            Nas nas = new Nas();
+            nas.setExportPolicy(exportPolicy);
+            volumeUpdate.setNas(nas);
+
+            // Update the volume
+            URI updateVolumeUrl = URI.create(Constants.HTTPS + OntapStorage.ManagementLIF +
+                    "/api/storage/volumes/" + volumeUuid);
+
+            volumeFeignClient.updateVolumeRebalancing(updateVolumeUrl, authHeader, volumeUuid, volumeUpdate);
+
+            s_logger.info("Export policy successfully assigned to volume: {}", volumeUuid);
+            return "Export policy " + policyName + " assigned to volume " + volumeUuid;
+
+        } catch (FeignException e) {
+            s_logger.error("Failed to assign export policy to volume: {}", volumeUuid, e);
+            throw new CloudRuntimeException("Failed to assign export policy: " + e.getMessage());
+        } catch (Exception e) {
+            s_logger.error("Exception while assigning export policy to volume: {}", volumeUuid, e);
+            throw new CloudRuntimeException("Failed to assign export policy: " + e.getMessage());
+        }
     }
 
     @Override
     public String enableNFS(String svmUuid) {
-        return "";
+        s_logger.info("Enabling NFS on SVM: {}", svmUuid);
+
+        try {
+            // Get AuthHeader
+            String authHeader = utils.generateAuthHeader(OntapStorage.Username, OntapStorage.Password);
+
+            // Create SVM update object to enable NFS
+            Svm svmUpdate = new Svm();
+            svmUpdate.setNfsEnabled(true);
+
+            // Update the SVM to enable NFS
+            URI updateSvmUrl = URI.create(Constants.HTTPS + OntapStorage.ManagementLIF +
+                    "/api/svm/svms/" + svmUuid);
+
+            svmFeignClient.updateSVM(updateSvmUrl, authHeader, svmUpdate);
+
+            s_logger.info("NFS successfully enabled on SVM: {}", svmUuid);
+            return "NFS enabled on SVM: " + svmUuid;
+
+        } catch (FeignException e) {
+            s_logger.error("Failed to enable NFS on SVM: {}", svmUuid, e);
+            throw new CloudRuntimeException("Failed to enable NFS: " + e.getMessage());
+        } catch (Exception e) {
+            s_logger.error("Exception while enabling NFS on SVM: {}", svmUuid, e);
+            throw new CloudRuntimeException("Failed to enable NFS: " + e.getMessage());
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,9 @@ public NASStrategy(OntapStorage ontapStorage) {`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`public abstract String createExportPolicy(String svmName, String policyName);`
	`30`	`+ public abstract boolean deleteExportPolicy(String svmName, String policyName);`
	`31`	`+ public abstract boolean exportPolicyExists(String svmName, String policyName);`
	`32`	`+`
`30`	`33`	`public abstract String addExportRule(String policyName, String clientMatch, String[] protocols, String[] roRule, String[] rwRule);`
`31`	`34`	`public abstract String assignExportPolicyToVolume(String volumeUuid, String policyName);`
`32`	`35`	`public abstract String enableNFS(String svmUuid);`