vm instance creation test1

Srivastava, Piyush · Srivastava, Piyush · commit 75e3a3137675 · 2025-11-20T21:28:17.000+05:30
diff --git a/plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/driver/OntapPrimaryDatastoreDriver.java b/plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/driver/OntapPrimaryDatastoreDriver.java
@@ -27,6 +27,7 @@
 import com.cloud.storage.Storage;
 import com.cloud.storage.StoragePool;
 import com.cloud.storage.Volume;
+import com.cloud.storage.VolumeVO;
 import com.cloud.utils.Pair;
 import com.cloud.utils.exception.CloudRuntimeException;
 import org.apache.cloudstack.engine.subsystem.api.storage.ChapInfo;
@@ -64,13 +65,14 @@ public class OntapPrimaryDatastoreDriver implements PrimaryDataStoreDriver {
 
     @Inject private StoragePoolDetailsDao storagePoolDetailsDao;
     @Inject private PrimaryDataStoreDao storagePoolDao;
+    @Inject private com.cloud.storage.dao.VolumeDao volumeDao;
     @Override
     public Map<String, String> getCapabilities() {
         s_logger.trace("OntapPrimaryDatastoreDriver: getCapabilities: Called");
         Map<String, String> mapCapabilities = new HashMap<>();
-
-        mapCapabilities.put(DataStoreCapabilities.STORAGE_SYSTEM_SNAPSHOT.toString(), Boolean.TRUE.toString());
-        mapCapabilities.put(DataStoreCapabilities.CAN_CREATE_VOLUME_FROM_SNAPSHOT.toString(), Boolean.TRUE.toString());
+        // RAW managed initial implementation: snapshot features not yet supported
+        mapCapabilities.put(DataStoreCapabilities.STORAGE_SYSTEM_SNAPSHOT.toString(), Boolean.FALSE.toString());
+        mapCapabilities.put(DataStoreCapabilities.CAN_CREATE_VOLUME_FROM_SNAPSHOT.toString(), Boolean.FALSE.toString());
 
         return mapCapabilities;
     }
@@ -116,36 +118,176 @@ public void createAsync(DataStore dataStore, DataObject dataObject, AsyncComplet
             createCmdResult = new CreateCmdResult(null, new Answer(null, false, errMsg));
             createCmdResult.setResult(e.toString());
         } finally {
-            s_logger.info("Volume creation successfully completed");
+            if (createCmdResult != null && createCmdResult.isSuccess()) {
+                s_logger.info("createAsync: Volume metadata created successfully. Path: {}", path);
+            }
             callback.complete(createCmdResult);
         }
     }
 
+    /**
+     * Creates CloudStack volume based on storage protocol type (NFS or iSCSI).
+     *
+     * For Managed NFS (Option 2 Implementation):
+     * - Returns only UUID without creating qcow2 file
+     * - KVM hypervisor creates qcow2 file automatically during VM deployment
+     * - ONTAP volume provides the backing NFS storage
+     *
+     * For iSCSI/Block Storage:
+     * - Creates LUN via ONTAP REST API
+     * - Returns LUN path for direct attachment
+     */
     private String createCloudStackVolumeForTypeVolume(DataStore dataStore, DataObject dataObject) {
         StoragePoolVO storagePool = storagePoolDao.findById(dataStore.getId());
         if(storagePool == null) {
-            s_logger.error("createCloudStackVolume : Storage Pool not found for id: " + dataStore.getId());
-            throw new CloudRuntimeException("createCloudStackVolume : Storage Pool not found for id: " + dataStore.getId());
+            s_logger.error("createCloudStackVolumeForTypeVolume: Storage Pool not found for id: {}", dataStore.getId());
+            throw new CloudRuntimeException("createCloudStackVolumeForTypeVolume: Storage Pool not found for id: " + dataStore.getId());
         }
+
         Map<String, String> details = storagePoolDetailsDao.listDetailsKeyPairs(dataStore.getId());
+        String protocol = details.get(Constants.PROTOCOL);
+
+        if (ProtocolType.NFS.name().equalsIgnoreCase(protocol)) {
+            return createManagedNfsVolume(dataStore, dataObject, storagePool);
+        } else if (ProtocolType.ISCSI.name().equalsIgnoreCase(protocol)) {
+            return createManagedBlockVolume(dataStore, dataObject, storagePool, details);
+        } else {
+            String errMsg = String.format("createCloudStackVolumeForTypeVolume: Unsupported protocol [%s]", protocol);
+            s_logger.error(errMsg);
+            throw new CloudRuntimeException(errMsg);
+        }
+    }
+
+    /**
+     * Creates Managed NFS Volume with ONTAP backing storage.
+     *
+     * Architecture: 1 CloudStack Storage Pool = 1 ONTAP Volume (shared by all volumes)
+     *
+     * Flow:
+     * 1. createAsync() stores volume metadata and NFS mount point
+     * 2. Volume attach triggers ManagedNfsStorageAdaptor.connectPhysicalDisk()
+     * 3. KVM mounts: nfs://nfsServer/junctionPath to /mnt/volumeUuid
+     * 4. Libvirt creates qcow2 file via storageVolCreateXML()
+     * 5. File created at: /vol/ontap_volume/volumeUuid (on ONTAP)
+     *
+     * Key Details:
+     * - All volumes in same pool share the same ONTAP volume NFS export
+     * - Each volume gets separate libvirt mount point: /mnt/<volumeUuid>
+     * - All qcow2 files stored in same ONTAP volume: /vol/<pool_volume_name>/
+     * - volume._iScsiName stores the NFS junction path (pool.path)
+     *
+     * @param dataStore CloudStack data store (storage pool)
+     * @param dataObject Volume data object
+     * @param storagePool Storage pool VO
+     * @return Volume UUID (used as filename for qcow2 file)
+     */
+    private String createManagedNfsVolume(DataStore dataStore, DataObject dataObject, StoragePoolVO storagePool) {
+        VolumeInfo volumeInfo = (VolumeInfo) dataObject;
+        VolumeVO volume = volumeDao.findById(volumeInfo.getId());
+        String volumeUuid = volumeInfo.getUuid();
+
+        // Get the NFS junction path from storage pool
+        // This is the path that was set during pool creation (e.g., "/my_pool_volume")
+        String junctionPath = storagePool.getPath();
+
+        // Update volume metadata in CloudStack database
+        volume.setPoolType(Storage.StoragePoolType.ManagedNFS);
+        volume.setPoolId(dataStore.getId());
+        volume.setPath(volumeUuid);  // Filename for qcow2 file
+
+        // CRITICAL: Store junction path in _iScsiName field
+        // CloudStack will use this in AttachCommand as DiskTO.MOUNT_POINT
+        // ManagedNfsStorageAdaptor will mount: nfs://hostAddress/junctionPath to /mnt/volumeUuid
+        volume.set_iScsiName(junctionPath);
+
+        volumeDao.update(volume.getId(), volume);
+
+        s_logger.info("ONTAP Managed NFS Volume Created: uuid={}, path={}, junctionPath={}, format=QCOW2, " +
+                      "pool={}, size={}GB. Libvirt will create qcow2 file at mount time.",
+                      volumeUuid, volumeUuid, junctionPath, storagePool.getName(),
+                      volumeInfo.getSize() / (1024 * 1024 * 1024));
+
+        // Optional: Prepare ONTAP volume for optimal qcow2 storage (future enhancement)
+        // prepareOntapVolumeForQcow2Storage(dataStore, volumeInfo);
+
+        return volumeUuid;
+    }
+
+    /**
+     * Creates iSCSI/Block volume by calling ONTAP REST API to create a LUN.
+     *
+     * For block storage (iSCSI), the storage provider must create the LUN
+     * before CloudStack can use it. This is different from NFS where the
+     * hypervisor creates the file.
+     *
+     * @param dataStore CloudStack data store
+     * @param dataObject Volume data object
+     * @param storagePool Storage pool VO
+     * @param details Storage pool details containing ONTAP connection info
+     * @return LUN path/name for iSCSI attachment
+     */
+    private String createManagedBlockVolume(DataStore dataStore, DataObject dataObject,
+                                           StoragePoolVO storagePool, Map<String, String> details) {
         StorageStrategy storageStrategy = getStrategyByStoragePoolDetails(details);
-        s_logger.info("createCloudStackVolumeForTypeVolume: Connection to Ontap SVM [{}] successful, preparing CloudStackVolumeRequest", details.get(Constants.SVM_NAME));
+
+        s_logger.info("createManagedBlockVolume: Creating iSCSI LUN on ONTAP SVM [{}]", details.get(Constants.SVM_NAME));
+
         CloudStackVolume cloudStackVolumeRequest = Utility.createCloudStackVolumeRequestByProtocol(storagePool, details, (VolumeInfo) dataObject);
+
         CloudStackVolume cloudStackVolume = storageStrategy.createCloudStackVolume(cloudStackVolumeRequest);
-        if (ProtocolType.ISCSI.name().equalsIgnoreCase(details.get(Constants.PROTOCOL)) && cloudStackVolume.getLun() != null && cloudStackVolume.getLun().getName() != null) {
-            return cloudStackVolume.getLun().getName();
-        } else if (ProtocolType.NFS.name().equalsIgnoreCase(details.get(Constants.PROTOCOL))) {
-            return cloudStackVolume.getFile().getName();
+
+        if (cloudStackVolume.getLun() != null && cloudStackVolume.getLun().getName() != null) {
+            String lunPath = cloudStackVolume.getLun().getName();
+            s_logger.info("createManagedBlockVolume: iSCSI LUN created successfully: {}", lunPath);
+            return lunPath;
         } else {
-            String errMsg = "createCloudStackVolumeForTypeVolume: Volume creation failed. Lun or Lun Path is null for dataObject: " + dataObject;
+            String errMsg = String.format("createManagedBlockVolume: LUN creation failed for volume [%s]. " +
+                                        "LUN or LUN path is null.", dataObject.getUuid());
             s_logger.error(errMsg);
             throw new CloudRuntimeException(errMsg);
         }
     }
 
+    /**
+     * Optional: Prepares ONTAP volume for optimal qcow2 file storage.
+     *
+     * Future enhancements can include:
+     * - Enable compression for qcow2 files
+     * - Set QoS policies
+     * - Enable deduplication
+     * - Configure snapshot policies
+     *
+     * This is a placeholder for ONTAP-specific optimizations.
+     */
+    private void prepareOntapVolumeForQcow2Storage(DataStore dataStore, VolumeInfo volumeInfo) {
+        // TODO: Implement ONTAP volume optimizations
+        // Examples:
+        // - storageStrategy.enableCompression(volumePath)
+        // - storageStrategy.setQosPolicy(volumePath, iops)
+        // - storageStrategy.enableDeduplication(volumePath)
+        s_logger.debug("prepareOntapVolumeForQcow2Storage: Placeholder for future ONTAP optimizations");
+    }
+
     @Override
     public void deleteAsync(DataStore store, DataObject data, AsyncCompletionCallback<CommandResult> callback) {
-
+        CommandResult commandResult = new CommandResult();
+        try {
+            if (store == null || data == null) {
+                throw new CloudRuntimeException("deleteAsync: store or data is null");
+            }
+            if (data.getType() == DataObjectType.VOLUME) {
+                StoragePoolVO storagePool = storagePoolDao.findById(store.getId());
+                Map<String, String> details = storagePoolDetailsDao.listDetailsKeyPairs(store.getId());
+                if (ProtocolType.NFS.name().equalsIgnoreCase(details.get(Constants.PROTOCOL))) {
+                    // ManagedNFS qcow2 backing file deletion handled by KVM host/libvirt; nothing to do via ONTAP REST.
+                    s_logger.info("deleteAsync: ManagedNFS volume {} no-op ONTAP deletion", data.getId());
+                }
+            }
+        } catch (Exception e) {
+            commandResult.setResult(e.getMessage());
+        } finally {
+            callback.complete(commandResult);
+        }
     }
 
     @Override
@@ -219,7 +361,7 @@ public void handleQualityOfServiceForVolumeMigration(VolumeInfo volumeInfo, Qual
 
     @Override
     public boolean canProvideStorageStats() {
-        return true;
+        return false;
     }
 
     @Override
@@ -229,7 +371,7 @@ public Pair<Long, Long> getStorageStats(StoragePool storagePool) {
 
     @Override
     public boolean canProvideVolumeStats() {
-        return true;
+        return false; // Not yet implemented for RAW managed NFS
     }
 
     @Override
@@ -291,4 +433,4 @@ private StorageStrategy getStrategyByStoragePoolDetails(Map<String, String> deta
             throw new CloudRuntimeException("getStrategyByStoragePoolDetails: Connection to Ontap SVM [" + details.get(Constants.SVM_NAME) + "] failed");
         }
     }
-}
+}
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
@@ -192,7 +192,7 @@ public DataStore initialize(Map<String, Object> dsInfos) {
         ProtocolType protocol = ProtocolType.valueOf(details.get(Constants.PROTOCOL));
         switch (protocol) {
             case NFS:
-                parameters.setType(Storage.StoragePoolType.NetworkFilesystem);
+                parameters.setType(Storage.StoragePoolType.ManagedNFS);
                 // Path should be just the NFS export path (junction path), NOT host:path
                 // CloudStack will construct the full mount path as: hostAddress + ":" + path
                 path = "/" + storagePoolName;
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
@@ -77,15 +77,22 @@ public void setOntapStorage(OntapStorage ontapStorage) {
     @Override
     public CloudStackVolume createCloudStackVolume(CloudStackVolume cloudstackVolume) {
         s_logger.info("createCloudStackVolume: Create cloudstack volume " + cloudstackVolume);
-        try {
-            createFile(cloudstackVolume.getVolume().getUuid(),cloudstackVolume.getCloudstackVolName(), cloudstackVolume.getFile());
-            s_logger.debug("Successfully created file in ONTAP under volume with path {} or name {}  ", cloudstackVolume.getVolume().getUuid(), cloudstackVolume.getCloudstackVolName());
-            FileInfo responseFile = cloudstackVolume.getFile();
-            responseFile.setPath(cloudstackVolume.getCloudstackVolName());
-        }catch (Exception e) {
-            s_logger.error("Exception occurred while creating file or dir: {}. Exception: {}", cloudstackVolume.getCloudstackVolName(), e.getMessage());
-            throw new CloudRuntimeException("Failed to create file: " + e.getMessage());
-        }
+        // Skip ontap file creation for now
+//        try {
+//            boolean created = createFile(cloudstackVolume.getVolume().getUuid(),cloudstackVolume.getCloudstackVolName(), cloudstackVolume.getFile());
+//            if(created){
+//                s_logger.debug("Successfully created file in ONTAP under volume with path {} or name {}  ", cloudstackVolume.getVolume().getUuid(), cloudstackVolume.getCloudstackVolName());
+//                FileInfo responseFile = cloudstackVolume.getFile();
+//                responseFile.setPath(cloudstackVolume.getCloudstackVolName());
+//            }else {
+//                s_logger.error("File not created for volume  {}",  cloudstackVolume.getVolume().getUuid());
+//                throw new CloudRuntimeException("File not created");
+//            }
+//
+//        }catch (Exception e) {
+//            s_logger.error("Exception occurred while creating file or dir: {}. Exception: {}", cloudstackVolume.getCloudstackVolName(), e.getMessage());
+//            throw new CloudRuntimeException("Failed to create file: " + e.getMessage());
+//        }
         return cloudstackVolume;
     }
 
diff --git a/plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/utils/Utility.java b/plugins/storage/volume/ontap/src/main/java/org/apache/cloudstack/storage/utils/Utility.java
@@ -58,22 +58,38 @@ public static String generateAuthHeader (String username, String password) {
         return BASIC + StringUtils.SPACE + new String(encodedBytes);
     }
 
+    /**
+     * Creates CloudStackVolume request object for ONTAP REST API calls.
+     *
+     * IMPORTANT: For Managed NFS (Option 2 Implementation):
+     * - The NFS case below is DEPRECATED and NOT USED
+     * - OntapPrimaryDatastoreDriver.createManagedNfsVolume() handles NFS volumes
+     * - It returns UUID only without creating files (KVM creates qcow2 automatically)
+     * - This method is ONLY used for iSCSI/block storage volumes
+     *
+     * @param storagePool Storage pool information
+     * @param details Storage pool details with ONTAP connection info
+     * @param volumeObject Volume information
+     * @return CloudStackVolume request for ONTAP REST API
+     */
     public static CloudStackVolume createCloudStackVolumeRequestByProtocol(StoragePoolVO storagePool, Map<String, String> details, VolumeInfo volumeObject) {
         CloudStackVolume cloudStackVolumeRequest = null;
 
         String protocol = details.get(Constants.PROTOCOL);
         ProtocolType protocolType = ProtocolType.valueOf(protocol);
         switch (protocolType) {
             case NFS:
-                // TODO add logic for NFS file creation
+                // DEPRECATED: This NFS case is NOT USED in Option 2 Implementation
+                // For Managed NFS, OntapPrimaryDatastoreDriver.createManagedNfsVolume()
+                // returns UUID only and lets KVM create qcow2 files automatically.
+                // This legacy code remains for reference but is bypassed in current implementation.
+                s_logger.warn("createCloudStackVolumeRequestByProtocol: NFS case should not be called. " +
+                            "Use OntapPrimaryDatastoreDriver.createManagedNfsVolume() instead.");
                 cloudStackVolumeRequest = new CloudStackVolume();
                 FileInfo file = new FileInfo();
-                //file.setName("test1"); // to be replaced with volume name // this should not be passed for dir
-                //file.setName(volumeObject.getName()); // to check whether this needs to be sent or not
-                file.setSize(Long.parseLong("10000"));
                 file.setSize(volumeObject.getSize());
-                file.setUnixPermissions(755); // check if it is needed only for dir ? it is needed for dir
-                file.setType(FileInfo.TypeEnum.DIRECTORY); // We are creating file for a cloudstack volume . Should it be dir ? // TODO change once multipart is done
+                file.setUnixPermissions(755);
+                file.setType(FileInfo.TypeEnum.FILE);
 
                 Volume poolVolume = new Volume();
                 poolVolume.setName(details.get(Constants.VOLUME_NAME));
