Support restore from NAS backup to Ceph storage pool(s)

Author: sureshanaparti

api/src/main/java/org/apache/cloudstack/backup/BackupManager.java

@@ -55,7 +55,7 @@ public interface BackupManager extends BackupService, Configurable, PluggableSer
     ConfigKey<String> BackupProviderPlugin = new ConfigKey<>("Advanced", String.class,
             "backup.framework.provider.plugin",
             "dummy",
-            "The backup and recovery provider plugin.", true, ConfigKey.Scope.Zone, BackupFrameworkEnabled.key());
+            "The backup and recovery provider plugin. Valid plugin values: dummy, veeam, networker and nas", true, ConfigKey.Scope.Zone, BackupFrameworkEnabled.key());
 
     ConfigKey<Long> BackupSyncPollingInterval = new ConfigKey<>("Advanced", Long.class,
             "backup.framework.sync.interval",

core/src/main/java/org/apache/cloudstack/backup/RestoreBackupCommand.java

@@ -22,6 +22,7 @@
 import com.cloud.agent.api.Command;
 import com.cloud.agent.api.LogLevel;
 import com.cloud.vm.VirtualMachine;
+import org.apache.cloudstack.storage.to.PrimaryDataStoreTO;
 
 import java.util.List;
 
@@ -31,6 +32,7 @@ public class RestoreBackupCommand extends Command  {
     private String backupRepoType;
     private String backupRepoAddress;
     private List<String> backupVolumesUUIDs;
+    private List<PrimaryDataStoreTO> restoreVolumePools;
     private List<String> restoreVolumePaths;
     private String diskType;
     private Boolean vmExists;
@@ -73,6 +75,14 @@ public void setBackupRepoAddress(String backupRepoAddress) {
         this.backupRepoAddress = backupRepoAddress;
     }
 
+    public List<PrimaryDataStoreTO> getRestoreVolumePools() {
+        return restoreVolumePools;
+    }
+
+    public void setRestoreVolumePools(List<PrimaryDataStoreTO> restoreVolumePools) {
+        this.restoreVolumePools = restoreVolumePools;
+    }
+
     public List<String> getRestoreVolumePaths() {
         return restoreVolumePaths;
     }

plugins/backup/nas/src/main/java/org/apache/cloudstack/backup/NASBackupProvider.java

@@ -26,6 +26,7 @@
 import com.cloud.hypervisor.Hypervisor;
 import com.cloud.offering.DiskOffering;
 import com.cloud.resource.ResourceManager;
+import com.cloud.storage.DataStoreRole;
 import com.cloud.storage.ScopeType;
 import com.cloud.storage.Storage;
 import com.cloud.storage.StoragePoolHostVO;
@@ -49,10 +50,13 @@
 
 import org.apache.cloudstack.backup.dao.BackupDao;
 import org.apache.cloudstack.backup.dao.BackupRepositoryDao;
+import org.apache.cloudstack.engine.subsystem.api.storage.DataStore;
+import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreManager;
 import org.apache.cloudstack.framework.config.ConfigKey;
 import org.apache.cloudstack.framework.config.Configurable;
 import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
 import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
+import org.apache.cloudstack.storage.to.PrimaryDataStoreTO;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.LogManager;
 
@@ -97,6 +101,9 @@ public class NASBackupProvider extends AdapterBase implements BackupProvider, Co
     @Inject
     private PrimaryDataStoreDao primaryDataStoreDao;
 
+    @Inject
+    DataStoreManager dataStoreMgr;
+
     @Inject
     private AgentManager agentManager;
 
@@ -179,7 +186,8 @@ public Pair<Boolean, Backup> takeBackup(final VirtualMachine vm, Boolean quiesce
         if (VirtualMachine.State.Stopped.equals(vm.getState())) {
             List<VolumeVO> vmVolumes = volumeDao.findByInstance(vm.getId());
             vmVolumes.sort(Comparator.comparing(Volume::getDeviceId));
-            List<String> volumePaths = getVolumePaths(vmVolumes);
+            Pair<List<PrimaryDataStoreTO>, List<String>> volumePoolsAndPaths = getVolumePoolsAndPaths(vmVolumes);
+            List<String> volumePaths = volumePoolsAndPaths.second();
             command.setVolumePaths(volumePaths);
         }
 
@@ -279,7 +287,9 @@ private boolean restoreVMBackup(VirtualMachine vm, Backup backup) {
         restoreCommand.setMountOptions(backupRepository.getMountOptions());
         restoreCommand.setVmName(vm.getName());
         restoreCommand.setBackupVolumesUUIDs(backedVolumesUUIDs);
-        restoreCommand.setRestoreVolumePaths(getVolumePaths(restoreVolumes));
+        Pair<List<PrimaryDataStoreTO>, List<String>> volumePoolsAndPaths = getVolumePoolsAndPaths(restoreVolumes);
+        restoreCommand.setRestoreVolumePools(volumePoolsAndPaths.first());
+        restoreCommand.setRestoreVolumePaths(volumePoolsAndPaths.second());
         restoreCommand.setVmExists(vm.getRemoved() == null);
         restoreCommand.setVmState(vm.getState());
 
@@ -294,32 +304,42 @@ private boolean restoreVMBackup(VirtualMachine vm, Backup backup) {
         return answer.getResult();
     }
 
-    private List<String> getVolumePaths(List<VolumeVO> volumes) {
+    private Pair<List<PrimaryDataStoreTO>, List<String>> getVolumePoolsAndPaths(List<VolumeVO> volumes) {
+        List<PrimaryDataStoreTO> volumePools = new ArrayList<>();
         List<String> volumePaths = new ArrayList<>();
         for (VolumeVO volume : volumes) {
             StoragePoolVO storagePool = primaryDataStoreDao.findById(volume.getPoolId());
             if (Objects.isNull(storagePool)) {
                 throw new CloudRuntimeException("Unable to find storage pool associated to the volume");
             }
-            String volumePathPrefix;
-            if (ScopeType.HOST.equals(storagePool.getScope())) {
-                volumePathPrefix = storagePool.getPath();
-            } else if (Storage.StoragePoolType.SharedMountPoint.equals(storagePool.getPoolType())) {
-                volumePathPrefix = storagePool.getPath();
-            } else {
-                volumePathPrefix = String.format("/mnt/%s", storagePool.getUuid());
-            }
+            String volumePathPrefix = getVolumePathPrefix(storagePool);
+            DataStore dataStore = dataStoreMgr.getDataStore(storagePool.getId(), DataStoreRole.Primary);
+            volumePools.add(dataStore != null ? (PrimaryDataStoreTO)dataStore.getTO() : null);
             volumePaths.add(String.format("%s/%s", volumePathPrefix, volume.getPath()));
         }
-        return volumePaths;
+        return new Pair<>(volumePools, volumePaths);
+    }
+
+    private String getVolumePathPrefix(StoragePoolVO storagePool) {
+        String volumePathPrefix;
+        if (ScopeType.HOST.equals(storagePool.getScope()) ||
+                Storage.StoragePoolType.SharedMountPoint.equals(storagePool.getPoolType()) ||
+                Storage.StoragePoolType.RBD.equals(storagePool.getPoolType())) {
+            volumePathPrefix = storagePool.getPath();
+        } else {
+            // Should be Storage.StoragePoolType.NetworkFilesystem
+            volumePathPrefix = String.format("/mnt/%s", storagePool.getUuid());
+        }
+        return volumePathPrefix;
     }
 
     @Override
     public Pair<Boolean, String> restoreBackedUpVolume(Backup backup, Backup.VolumeInfo backupVolumeInfo, String hostIp, String dataStoreUuid, Pair<String, VirtualMachine.State> vmNameAndState) {
         final VolumeVO volume = volumeDao.findByUuid(backupVolumeInfo.getUuid());
         final DiskOffering diskOffering = diskOfferingDao.findByUuid(backupVolumeInfo.getDiskOfferingId());
-        final StoragePoolHostVO dataStore = storagePoolHostDao.findByUuid(dataStoreUuid);
+        final StoragePoolVO pool = primaryDataStoreDao.findByUuid(dataStoreUuid);
         final HostVO hostVO = hostDao.findByIp(hostIp);
+        final StoragePoolHostVO dataStore = storagePoolHostDao.findByPoolHost(pool.getId(), hostVO.getId());
 
         LOG.debug("Restoring vm volume {} from backup {} on the NAS Backup Provider", backupVolumeInfo, backup);
         BackupRepository backupRepository = getBackupRepository(backup);
@@ -335,10 +355,14 @@ public Pair<Boolean, String> restoreBackedUpVolume(Backup backup, Backup.VolumeI
         restoredVolume.setUuid(volumeUUID);
         restoredVolume.setRemoved(null);
         restoredVolume.setDisplayVolume(true);
-        restoredVolume.setPoolId(dataStore.getPoolId());
+        restoredVolume.setPoolId(pool.getId());
+        restoredVolume.setPoolType(pool.getPoolType());
         restoredVolume.setPath(restoredVolume.getUuid());
         restoredVolume.setState(Volume.State.Copying);
         restoredVolume.setFormat(Storage.ImageFormat.QCOW2);
+        if (pool.getPoolType() == Storage.StoragePoolType.RBD) {
+            restoredVolume.setFormat(Storage.ImageFormat.RAW);
+        }
         restoredVolume.setSize(backupVolumeInfo.getSize());
         restoredVolume.setDiskOfferingId(diskOffering.getId());