Fix multiple secondary storages for a single zone

JoaoJandre · JoaoJandre · commit 885d2a48440f · 2024-11-07T16:54:01.000-03:00
diff --git a/core/src/main/java/org/apache/cloudstack/storage/to/SnapshotObjectTO.java b/core/src/main/java/org/apache/cloudstack/storage/to/SnapshotObjectTO.java
@@ -43,6 +43,7 @@ public class SnapshotObjectTO extends DownloadableObjectTO implements DataTO {
     private long id;
     private boolean quiescevm;
     private String[] parents;
+    private DataStoreTO parentStore;
     private String checkpointPath;
     private Long physicalSize = (long) 0;
     private long accountId;
@@ -211,6 +212,14 @@ public void setAccountId(long accountId) {
         this.accountId = accountId;
     }
 
+    public DataStoreTO getParentStore() {
+        return parentStore;
+    }
+
+    public void setParentStore(DataStoreTO parentStore) {
+        this.parentStore = parentStore;
+    }
+
     @Override
     public String toString() {
         return new StringBuilder("SnapshotTO[datastore=").append(dataStore).append("|volume=").append(volume).append("|path").append(path).append("]").toString();
diff --git a/engine/orchestration/src/main/java/com/cloud/vm/VirtualMachineManagerImpl.java b/engine/orchestration/src/main/java/com/cloud/vm/VirtualMachineManagerImpl.java
@@ -3412,6 +3412,7 @@ protected List<VolumeObjectTO> getVmVolumesWithCheckpointsToRecreate(VMInstanceV
             VolumeObjectTO volumeTo = new VolumeObjectTO();
             volumeTo.setCheckpointPaths(volumeCheckpointPathsAndImageStoreUrls.first());
             volumeTo.setCheckpointImageStoreUrls(volumeCheckpointPathsAndImageStoreUrls.second());
+            volumeTo.setPath(volume.getPath());
             volumes.add(volumeTo);
         }
         return volumes;
diff --git a/engine/schema/src/main/java/org/apache/cloudstack/storage/datastore/db/SnapshotDataStoreDaoImpl.java b/engine/schema/src/main/java/org/apache/cloudstack/storage/datastore/db/SnapshotDataStoreDaoImpl.java
@@ -72,15 +72,19 @@ public class SnapshotDataStoreDaoImpl extends GenericDaoBase<SnapshotDataStoreVO
     private SearchBuilder<SnapshotDataStoreVO> dataStoreAndInstallPathSearch;
     private SearchBuilder<SnapshotDataStoreVO> storeAndSnapshotIdsSearch;
     private SearchBuilder<SnapshotDataStoreVO> storeSnapshotDownloadStatusSearch;
-    private SearchBuilder<SnapshotDataStoreVO> searchFilteringVolumeIdEqAndStateEqAndKVMCheckpointPathNotNull;
+    private SearchBuilder<SnapshotDataStoreVO> searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEqKVMCheckpointNotNull;
     private SearchBuilder<SnapshotDataStoreVO> searchFilterStateAndDownloadUrlNotNullAndDownloadUrlCreatedBefore;
+    private SearchBuilder<SnapshotDataStoreVO> searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEq;
 
 
     protected static final List<Hypervisor.HypervisorType> HYPERVISORS_SUPPORTING_SNAPSHOTS_CHAINING = List.of(Hypervisor.HypervisorType.XenServer);
 
     @Inject
     protected SnapshotDao snapshotDao;
 
+    @Inject
+    protected ImageStoreDao imageStoreDao;
+
     private static final String FIND_OLDEST_OR_LATEST_SNAPSHOT = "select store_id, store_role, snapshot_id from cloud.snapshot_store_ref where " +
             " store_role = ? and volume_id = ? and state = 'Ready'" +
             " order by created %s " +
@@ -163,18 +167,26 @@ public boolean configure(String name, Map<String, Object> params) throws Configu
         storeSnapshotDownloadStatusSearch.and("downloadState", storeSnapshotDownloadStatusSearch.entity().getDownloadState(), SearchCriteria.Op.IN);
         storeSnapshotDownloadStatusSearch.done();
 
-        searchFilteringVolumeIdEqAndStateEqAndKVMCheckpointPathNotNull = createSearchBuilder();
-        searchFilteringVolumeIdEqAndStateEqAndKVMCheckpointPathNotNull.and(VOLUME_ID, searchFilteringVolumeIdEqAndStateEqAndKVMCheckpointPathNotNull.entity().getVolumeId(), SearchCriteria.Op.EQ);
-        searchFilteringVolumeIdEqAndStateEqAndKVMCheckpointPathNotNull.and(STATE, searchFilteringVolumeIdEqAndStateEqAndKVMCheckpointPathNotNull.entity().getState(), SearchCriteria.Op.EQ);
-        searchFilteringVolumeIdEqAndStateEqAndKVMCheckpointPathNotNull.and(KVM_CHECKPOINT_PATH, searchFilteringVolumeIdEqAndStateEqAndKVMCheckpointPathNotNull.entity().getKvmCheckpointPath(), SearchCriteria.Op.NNULL);
-        searchFilteringVolumeIdEqAndStateEqAndKVMCheckpointPathNotNull.done();
+        searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEqKVMCheckpointNotNull = createSearchBuilder();
+        searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEqKVMCheckpointNotNull.and(VOLUME_ID, searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEqKVMCheckpointNotNull.entity().getVolumeId(), SearchCriteria.Op.EQ);
+        searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEqKVMCheckpointNotNull.and(STATE, searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEqKVMCheckpointNotNull.entity().getState(), SearchCriteria.Op.EQ);
+        searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEqKVMCheckpointNotNull.and(STORE_ROLE, searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEqKVMCheckpointNotNull.entity().getRole(), SearchCriteria.Op.EQ);
+        searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEqKVMCheckpointNotNull.and(KVM_CHECKPOINT_PATH, searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEqKVMCheckpointNotNull.entity().getKvmCheckpointPath(), SearchCriteria.Op.NNULL);
+        searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEqKVMCheckpointNotNull.and(STORE_ID, searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEqKVMCheckpointNotNull.entity().getDataStoreId(), SearchCriteria.Op.IN);
+        searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEqKVMCheckpointNotNull.done();
 
         searchFilterStateAndDownloadUrlNotNullAndDownloadUrlCreatedBefore = createSearchBuilder();
         searchFilterStateAndDownloadUrlNotNullAndDownloadUrlCreatedBefore.and(STATE, searchFilterStateAndDownloadUrlNotNullAndDownloadUrlCreatedBefore.entity().getState(), SearchCriteria.Op.EQ);
         searchFilterStateAndDownloadUrlNotNullAndDownloadUrlCreatedBefore.and(DOWNLOAD_URL, searchFilterStateAndDownloadUrlNotNullAndDownloadUrlCreatedBefore.entity().getExtractUrl(), SearchCriteria.Op.NNULL);
         searchFilterStateAndDownloadUrlNotNullAndDownloadUrlCreatedBefore.and(URL_CREATED_BEFORE, searchFilterStateAndDownloadUrlNotNullAndDownloadUrlCreatedBefore.entity().getExtractUrlCreated(), SearchCriteria.Op.LT);
         searchFilterStateAndDownloadUrlNotNullAndDownloadUrlCreatedBefore.done();
 
+        searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEq = createSearchBuilder();
+        searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEq.and(STATE, searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEq.entity().getState(), SearchCriteria.Op.EQ);
+        searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEq.and(VOLUME_ID, searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEq.entity().getVolumeId(), SearchCriteria.Op.EQ);
+        searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEq.and(STORE_ROLE, searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEq.entity().getRole(), SearchCriteria.Op.EQ);
+        searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEq.and(STORE_ID, searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEq.entity().getDataStoreId(), SearchCriteria.Op.IN);
+
         return true;
     }
 
@@ -318,12 +330,23 @@ public SnapshotDataStoreVO findParent(DataStoreRole role, Long storeId, Long zon
             return null;
         }
 
-        SearchCriteria<SnapshotDataStoreVO> sc = searchFilteringStoreIdEqStateEqStoreRoleEqIdEqUpdateCountEqSnapshotIdEqVolumeIdEq.create();
+        SearchCriteria<SnapshotDataStoreVO> sc;
+        if (kvmIncrementalSnapshot && Hypervisor.HypervisorType.KVM.equals(hypervisorType)) {
+            sc = searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEqKVMCheckpointNotNull.create();
+        } else {
+            sc = searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEq.create();
+        }
+
         sc.setParameters(VOLUME_ID, volumeId);
         sc.setParameters(STORE_ROLE, role.toString());
         sc.setParameters(STATE, ObjectInDataStoreStateMachine.State.Ready.name());
-        sc.setParametersIfNotNull(STORE_ID, storeId);
-        sc.setParametersIfNotNull();
+        if (storeId != null) {
+            sc.setParameters(STORE_ID, (Object) new Long[]{storeId});
+        } else if (zoneId != null) {
+            List<ImageStoreVO> imageStores = imageStoreDao.listStoresByZoneId(zoneId);
+            Object[] imageStoreIds = imageStores.stream().map(ImageStoreVO::getId).toArray();
+            sc.setParameters(STORE_ID, imageStoreIds);
+        }
 
         List<SnapshotDataStoreVO> snapshotList = listBy(sc, new Filter(SnapshotDataStoreVO.class, CREATED, false, null, null));
         if (CollectionUtils.isEmpty(snapshotList)) {
@@ -580,7 +603,7 @@ protected boolean isSnapshotChainingRequired(long volumeId, boolean kvmIncrement
 
     @Override
     public List<SnapshotDataStoreVO> listReadyByVolumeIdAndCheckpointPathNotNull(long volumeId) {
-        SearchCriteria<SnapshotDataStoreVO> sc = searchFilteringVolumeIdEqAndStateEqAndKVMCheckpointPathNotNull.create();
+        SearchCriteria<SnapshotDataStoreVO> sc = searchFilteringStoreIdInVolumeIdEqStoreRoleEqStateEqKVMCheckpointNotNull.create();
         sc.setParameters(VOLUME_ID, volumeId);
         sc.setParameters(STATE, State.Ready);
         return listBy(sc);
diff --git a/engine/storage/snapshot/src/main/java/org/apache/cloudstack/storage/snapshot/DefaultSnapshotStrategy.java b/engine/storage/snapshot/src/main/java/org/apache/cloudstack/storage/snapshot/DefaultSnapshotStrategy.java
@@ -189,13 +189,13 @@ public SnapshotInfo backupSnapshot(SnapshotInfo snapshot) {
 
     protected boolean deleteSnapshotChain(SnapshotInfo snapshot, String storageToString) {
         long rootSnapshotId = getRootSnapshotId(snapshot);
-        snapshotDao.acquireInLockTable(rootSnapshotId);
         DataTO snapshotTo = snapshot.getTO();
         logger.debug(String.format("Deleting %s chain of snapshots.", snapshotTo));
 
         boolean result = false;
         boolean resultIsSet = false;
         try {
+            snapshotDao.acquireInLockTable(rootSnapshotId);
             do {
                 SnapshotInfo child = snapshot.getChild();
 
@@ -243,15 +243,18 @@ protected boolean deleteSnapshotChain(SnapshotInfo snapshot, String storageToStr
                         }
                     } catch (Exception e) {
                         logger.error(String.format("Failed to delete snapshot [%s] on storage [%s] due to [%s].", snapshotTo, storageToString, e.getMessage()), e);
+                        throw e;
                     }
                 }
 
                 snapshot = parent;
             } while (snapshot != null && snapshotStatesAbleToDeleteSnapshot.contains(snapshot.getState()));
         } catch (Exception e) {
             logger.error(String.format("Failed to delete snapshot [%s] on storage [%s] due to [%s].", snapshotTo, storageToString, e.getMessage()), e);
+            throw new CloudRuntimeException("Failed to delete snapshot chain.");
+        } finally {
+            snapshotDao.releaseFromLockTable(rootSnapshotId);
         }
-        snapshotDao.releaseFromLockTable(rootSnapshotId);
         return result;
     }
 
diff --git a/engine/storage/src/main/java/org/apache/cloudstack/storage/datastore/ObjectInDataStoreManagerImpl.java b/engine/storage/src/main/java/org/apache/cloudstack/storage/datastore/ObjectInDataStoreManagerImpl.java
@@ -20,7 +20,9 @@
 
 import com.cloud.host.dao.HostDao;
 import com.cloud.hypervisor.Hypervisor;
+import com.cloud.storage.ImageStore;
 import com.cloud.storage.snapshot.SnapshotManager;
+import org.apache.cloudstack.engine.subsystem.api.storage.PrimaryDataStore;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.LogManager;
 import org.springframework.stereotype.Component;
@@ -193,7 +195,7 @@ public DataObject create(DataObject obj, DataStore dataStore) {
                     ss.setSize(snapshot.getSize());
                     ss.setVolumeId(snapshot.getVolumeId());
                     Long clusterId = hostDao.findClusterIdByVolumeInfo(snapshot.getBaseVolume());
-                    SnapshotDataStoreVO snapshotDataStoreVO = snapshotDataStoreDao.findParent(dataStore.getRole(), dataStore.getId(), null, snapshot.getVolumeId(), SnapshotManager.kvmIncrementalSnapshot.valueIn(clusterId), snapshot.getHypervisorType());
+                    SnapshotDataStoreVO snapshotDataStoreVO = snapshotDataStoreDao.findParent(dataStore.getRole(), null, ((ImageStore)dataStore).getDataCenterId(), snapshot.getVolumeId(), SnapshotManager.kvmIncrementalSnapshot.valueIn(clusterId), snapshot.getHypervisorType());
                     if (snapshotDataStoreVO != null && !snapshotDataStoreVO.isEndOfChain()) {
                         ss.setParentSnapshotId(snapshotDataStoreVO.getSnapshotId());
                     } else {
@@ -220,7 +222,7 @@ public DataObject create(DataObject obj, DataStore dataStore) {
     private SnapshotDataStoreVO tryToGetSnapshotOnSecondaryIfNotOnPrimaryAndIsKVM(DataStore dataStore, SnapshotInfo snapshotInfo, SnapshotDataStoreVO snapshotDataStoreVO,
                                                                                   boolean kvmIncrementalSnapshot, Hypervisor.HypervisorType hypervisorType) {
         if (snapshotDataStoreVO == null && Hypervisor.HypervisorType.KVM.equals(snapshotInfo.getHypervisorType()) && DataStoreRole.Primary.equals(dataStore.getRole())) {
-            snapshotDataStoreVO = snapshotDataStoreDao.findParent(DataStoreRole.Image, snapshotInfo.getImageStore().getId(), null, snapshotInfo.getVolumeId(), kvmIncrementalSnapshot, hypervisorType);
+            snapshotDataStoreVO = snapshotDataStoreDao.findParent(DataStoreRole.Image, null, ((PrimaryDataStore)dataStore).getDataCenterId(), snapshotInfo.getVolumeId(), kvmIncrementalSnapshot, hypervisorType);
         }
         return snapshotDataStoreVO;
     }
diff --git a/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/LibvirtComputingResource.java b/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/LibvirtComputingResource.java
@@ -4691,6 +4691,7 @@ public boolean recreateCheckpointsOnVm(List<VolumeObjectTO> volumes, String vmNa
             }
             connectToAllVolumeSnapshotSecondaryStorages(volume);
             recreateCheckpointsOfDisk(vmName, volume, mapDiskToDiskDef);
+            disconnectAllVolumeSnapshotSecondaryStorages(volume);
         }
         logger.debug("Successfully recreated all checkpoints on VM [{}].", vmName);
         return true;
@@ -4700,6 +4701,13 @@ public void connectToAllVolumeSnapshotSecondaryStorages(VolumeObjectTO volumeObj
         volumeObjectTO.getCheckpointImageStoreUrls().forEach(uri -> getStoragePoolMgr().getStoragePoolByURI(uri));
     }
 
+    public void disconnectAllVolumeSnapshotSecondaryStorages(VolumeObjectTO volumeObjectTO) {
+        volumeObjectTO.getCheckpointImageStoreUrls().forEach(uri -> {
+            KVMStoragePool storage = getStoragePoolMgr().getStoragePoolByURI(uri);
+            getStoragePoolMgr().deleteStoragePool(storage.getType(), storage.getUuid());
+        });
+    }
+
 
     protected void recreateCheckpointsOfDisk(String vmName, VolumeObjectTO volume, Map<VolumeObjectTO, DiskDef> mapDiskToDiskDef) {
         for (String path : volume.getCheckpointPaths()) {
diff --git a/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtConvertSnapshotCommandWrapper.java b/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtConvertSnapshotCommandWrapper.java
@@ -91,6 +91,8 @@ public Answer execute(ConvertSnapshotCommand command, LibvirtComputingResource s
         } catch (LibvirtException | QemuImgException ex) {
             logger.error(String.format("Failed to convert snapshot [%s] due to %s.", snapshotObjectTO, ex.getMessage()), ex);
             return new Answer(command, ex);
+        } finally {
+            serverResource.disconnectAllVolumeSnapshotSecondaryStorages(snapshotObjectTO.getVolume());
         }
     }
 }
diff --git a/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtRevertSnapshotCommandWrapper.java b/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/wrapper/LibvirtRevertSnapshotCommandWrapper.java
@@ -176,6 +176,10 @@ protected void revertVolumeToSnapshot(KVMStoragePool kvmStoragePoolSecondary, Sn
             logger.debug(String.format("Successfully reverted volume [%s] to snapshot [%s].", volumeObjectTo, snapshotToPrint));
         } catch (LibvirtException | QemuImgException ex) {
             throw new CloudRuntimeException(String.format("Unable to revert volume [%s] to snapshot [%s] due to [%s].", volumeObjectTo, snapshotToPrint, ex.getMessage()), ex);
+        } finally {
+            if (kvmStoragePoolSecondary != null) {
+                resource.disconnectAllVolumeSnapshotSecondaryStorages(volumeObjectTo);
+            }
         }
     }
 
diff --git a/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/storage/KVMStorageProcessor.java b/plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/storage/KVMStorageProcessor.java
diff --git a/plugins/storage/volume/default/src/main/java/org/apache/cloudstack/storage/datastore/driver/CloudStackPrimaryDataStoreDriverImpl.java b/plugins/storage/volume/default/src/main/java/org/apache/cloudstack/storage/datastore/driver/CloudStackPrimaryDataStoreDriverImpl.java

Original file line number	Diff line number	Diff line change
`@@ -3412,6 +3412,7 @@ protected List<VolumeObjectTO> getVmVolumesWithCheckpointsToRecreate(VMInstanceV`
`3412`	`3412`	`VolumeObjectTO volumeTo = new VolumeObjectTO();`
`3413`	`3413`	`volumeTo.setCheckpointPaths(volumeCheckpointPathsAndImageStoreUrls.first());`
`3414`	`3414`	`volumeTo.setCheckpointImageStoreUrls(volumeCheckpointPathsAndImageStoreUrls.second());`
	`3415`	`+ volumeTo.setPath(volume.getPath());`
`3415`	`3416`	`volumes.add(volumeTo);`
`3416`	`3417`	`}`
`3417`	`3418`	`return volumes;`
Original file line number	Diff line number	Diff line change
`@@ -189,13 +189,13 @@ public SnapshotInfo backupSnapshot(SnapshotInfo snapshot) {`
`189`	`189`
`190`	`190`	`protected boolean deleteSnapshotChain(SnapshotInfo snapshot, String storageToString) {`
`191`	`191`	`long rootSnapshotId = getRootSnapshotId(snapshot);`
`192`		`- snapshotDao.acquireInLockTable(rootSnapshotId);`
`193`	`192`	`DataTO snapshotTo = snapshot.getTO();`
`194`	`193`	`logger.debug(String.format("Deleting %s chain of snapshots.", snapshotTo));`
`195`	`194`
`196`	`195`	`boolean result = false;`
`197`	`196`	`boolean resultIsSet = false;`
`198`	`197`	`try {`
	`198`	`+ snapshotDao.acquireInLockTable(rootSnapshotId);`
`199`	`199`	`do {`
`200`	`200`	`SnapshotInfo child = snapshot.getChild();`
`201`	`201`
`@@ -243,15 +243,18 @@ protected boolean deleteSnapshotChain(SnapshotInfo snapshot, String storageToStr`
`243`	`243`	`}`
`244`	`244`	`} catch (Exception e) {`
`245`	`245`	`logger.error(String.format("Failed to delete snapshot [%s] on storage [%s] due to [%s].", snapshotTo, storageToString, e.getMessage()), e);`
	`246`	`+ throw e;`
`246`	`247`	`}`
`247`	`248`	`}`
`248`	`249`
`249`	`250`	`snapshot = parent;`
`250`	`251`	`} while (snapshot != null && snapshotStatesAbleToDeleteSnapshot.contains(snapshot.getState()));`
`251`	`252`	`} catch (Exception e) {`
`252`	`253`	`logger.error(String.format("Failed to delete snapshot [%s] on storage [%s] due to [%s].", snapshotTo, storageToString, e.getMessage()), e);`
	`254`	`+ throw new CloudRuntimeException("Failed to delete snapshot chain.");`
	`255`	`+ } finally {`
	`256`	`+ snapshotDao.releaseFromLockTable(rootSnapshotId);`
`253`	`257`	`}`
`254`		`- snapshotDao.releaseFromLockTable(rootSnapshotId);`
`255`	`258`	`return result;`
`256`	`259`	`}`
`257`	`260`
Original file line number	Diff line number	Diff line change
`@@ -4691,6 +4691,7 @@ public boolean recreateCheckpointsOnVm(List<VolumeObjectTO> volumes, String vmNa`
`4691`	`4691`	`}`
`4692`	`4692`	`connectToAllVolumeSnapshotSecondaryStorages(volume);`
`4693`	`4693`	`recreateCheckpointsOfDisk(vmName, volume, mapDiskToDiskDef);`
	`4694`	`+ disconnectAllVolumeSnapshotSecondaryStorages(volume);`
`4694`	`4695`	`}`
`4695`	`4696`	`logger.debug("Successfully recreated all checkpoints on VM [{}].", vmName);`
`4696`	`4697`	`return true;`
`@@ -4700,6 +4701,13 @@ public void connectToAllVolumeSnapshotSecondaryStorages(VolumeObjectTO volumeObj`
`4700`	`4701`	`volumeObjectTO.getCheckpointImageStoreUrls().forEach(uri -> getStoragePoolMgr().getStoragePoolByURI(uri));`
`4701`	`4702`	`}`
`4702`	`4703`
	`4704`	`+ public void disconnectAllVolumeSnapshotSecondaryStorages(VolumeObjectTO volumeObjectTO) {`
	`4705`	`+ volumeObjectTO.getCheckpointImageStoreUrls().forEach(uri -> {`
	`4706`	`+ KVMStoragePool storage = getStoragePoolMgr().getStoragePoolByURI(uri);`
	`4707`	`+ getStoragePoolMgr().deleteStoragePool(storage.getType(), storage.getUuid());`
	`4708`	`+ });`
	`4709`	`+ }`
	`4710`	`+`
`4703`	`4711`
`4704`	`4712`	`protected void recreateCheckpointsOfDisk(String vmName, VolumeObjectTO volume, Map<VolumeObjectTO, DiskDef> mapDiskToDiskDef) {`
`4705`	`4713`	`for (String path : volume.getCheckpointPaths()) {`
Original file line number	Diff line number	Diff line change
`@@ -91,6 +91,8 @@ public Answer execute(ConvertSnapshotCommand command, LibvirtComputingResource s`
`91`	`91`	`} catch (LibvirtException \| QemuImgException ex) {`
`92`	`92`	`logger.error(String.format("Failed to convert snapshot [%s] due to %s.", snapshotObjectTO, ex.getMessage()), ex);`
`93`	`93`	`return new Answer(command, ex);`
	`94`	`+ } finally {`
	`95`	`+ serverResource.disconnectAllVolumeSnapshotSecondaryStorages(snapshotObjectTO.getVolume());`
`94`	`96`	`}`
`95`	`97`	`}`
`96`	`98`	`}`
Original file line number	Diff line number	Diff line change
`@@ -176,6 +176,10 @@ protected void revertVolumeToSnapshot(KVMStoragePool kvmStoragePoolSecondary, Sn`
`176`	`176`	`logger.debug(String.format("Successfully reverted volume [%s] to snapshot [%s].", volumeObjectTo, snapshotToPrint));`
`177`	`177`	`} catch (LibvirtException \| QemuImgException ex) {`
`178`	`178`	`throw new CloudRuntimeException(String.format("Unable to revert volume [%s] to snapshot [%s] due to [%s].", volumeObjectTo, snapshotToPrint, ex.getMessage()), ex);`
	`179`	`+ } finally {`
	`180`	`+ if (kvmStoragePoolSecondary != null) {`
	`181`	`+ resource.disconnectAllVolumeSnapshotSecondaryStorages(volumeObjectTo);`
	`182`	`+ }`
`179`	`183`	`}`
`180`	`184`	`}`
`181`	`185`