slavkap commented on code in PR #10632:
URL: https://github.com/apache/cloudstack/pull/10632#discussion_r2204502992
##########
engine/storage/snapshot/src/main/java/org/apache/cloudstack/storage/snapshot/DefaultSnapshotStrategy.java:
##########
@@ -626,6 +646,30 @@ public StrategyPriority canHandle(Snapshot snapshot, Long
zoneId, SnapshotOperat
return StrategyPriority.DEFAULT;
}
+ private StrategyPriority validateVmSnapshot(Snapshot snapshot) {
+ VolumeVO volumeVO = volumeDao.findById(snapshot.getVolumeId());
+ Long instanceId = volumeVO.getInstanceId();
+ if (instanceId == null) {
+ return StrategyPriority.DEFAULT;
+ }
+
+ VMInstanceVO vm = vmInstanceDao.findById(instanceId);
+ if (vm == null) {
+ return StrategyPriority.DEFAULT;
+ }
+
+ for (VMSnapshotVO vmSnapshotVO :
vmSnapshotDao.findByVmAndByType(vm.getId(), VMSnapshot.Type.Disk)) {
+ List<VMSnapshotDetailsVO> vmSnapshotDetails =
vmSnapshotDetailsDao.listDetails(vmSnapshotVO.getId());
+ if (vmSnapshotDetails.stream().anyMatch(vmSnapshotDetailsVO ->
vmSnapshotDetailsVO.getName().equals(VolumeApiServiceImpl.KVM_FILE_BASED_STORAGE_SNAPSHOT)))
{
Review Comment:
```suggestion
if (vmSnapshotDetails.stream().anyMatch(vmSnapshotDetailsVO ->
VolumeApiServiceImpl.KVM_FILE_BASED_STORAGE_SNAPSHOT.equals(vmSnapshotDetailsVO.getName())))
{
```
##########
server/src/main/java/com/cloud/storage/VolumeApiServiceImpl.java:
##########
@@ -4043,6 +4069,10 @@ public Snapshot allocSnapshotForVm(Long vmId, Long
volumeId, String snapshotName
throw new InvalidParameterValueException("Cannot perform this
operation, unsupported on storage pool type " + storagePool.getPoolType());
}
+ if
(vmSnapshotDetailsDao.listDetails(vmSnapshotId).stream().anyMatch(vmSnapshotDetailsVO
-> vmSnapshotDetailsVO.getName().equals(KVM_FILE_BASED_STORAGE_SNAPSHOT))) {
Review Comment:
```suggestion
if
(vmSnapshotDetailsDao.listDetails(vmSnapshotId).stream().anyMatch(vmSnapshotDetailsVO
-> KVM_FILE_BASED_STORAGE_SNAPSHOT.equals(vmSnapshotDetailsVO.getName()))) {
```
##########
server/src/main/java/com/cloud/storage/VolumeApiServiceImpl.java:
##########
@@ -1399,6 +1407,29 @@ public VolumeVO resizeVolume(ResizeVolumeCmd cmd) throws
ResourceAllocationExcep
shrinkOk);
}
+ protected void validateNoVmSnapshots(VolumeVO volume) {
+ if (volume.getInstanceId() != null) {
+ if
(vmHasVmSnapshotsExceptKvmDiskOnlySnapshots(volume.getInstanceId())) {
+ throw new InvalidParameterValueException("The volume is
attached to a VM with memory&disk VM snapshots; therefore, it cannot be
resized.");
+ }
+ }
+ }
+
+ protected boolean vmHasVmSnapshotsExceptKvmDiskOnlySnapshots(long
instanceId) {
+ for (VMSnapshotVO vmSnapshotVO : _vmSnapshotDao.findByVm(instanceId)) {
+ if (VMSnapshot.Type.DiskAndMemory.equals(vmSnapshotVO.getType())) {
+ return true;
+ }
+ List<VMSnapshotDetailsVO> vmSnapshotDetails =
vmSnapshotDetailsDao.listDetails(vmSnapshotVO.getId());
+ if (vmSnapshotDetails.stream().
+ noneMatch(vmSnapshotDetailsVO ->
vmSnapshotDetailsVO.getName().equals(KVM_FILE_BASED_STORAGE_SNAPSHOT))) {
Review Comment:
```suggestion
noneMatch(vmSnapshotDetailsVO ->
KVM_FILE_BASED_STORAGE_SNAPSHOT.equals(vmSnapshotDetailsVO.getName()))) {
```
##########
engine/storage/snapshot/src/main/java/org/apache/cloudstack/storage/vmsnapshot/KvmFileBasedStorageVmSnapshotStrategy.java:
##########
@@ -0,0 +1,689 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.cloudstack.storage.vmsnapshot;
+
+import com.cloud.agent.api.Answer;
+import com.cloud.agent.api.VMSnapshotTO;
+import com.cloud.agent.api.storage.CreateDiskOnlyVmSnapshotAnswer;
+import com.cloud.agent.api.storage.CreateDiskOnlyVmSnapshotCommand;
+import com.cloud.agent.api.storage.DeleteDiskOnlyVmSnapshotCommand;
+import com.cloud.agent.api.storage.MergeDiskOnlyVmSnapshotCommand;
+import com.cloud.agent.api.storage.RevertDiskOnlyVmSnapshotAnswer;
+import com.cloud.agent.api.storage.RevertDiskOnlyVmSnapshotCommand;
+import com.cloud.agent.api.storage.SnapshotMergeTreeTO;
+import com.cloud.agent.api.to.DataTO;
+import com.cloud.configuration.Resource;
+import com.cloud.event.EventTypes;
+import com.cloud.event.UsageEventUtils;
+import com.cloud.hypervisor.Hypervisor;
+import com.cloud.storage.DataStoreRole;
+import com.cloud.storage.Snapshot;
+import com.cloud.storage.SnapshotVO;
+import com.cloud.storage.Storage;
+import com.cloud.storage.Volume;
+import com.cloud.storage.VolumeVO;
+import com.cloud.user.ResourceLimitService;
+import com.cloud.uservm.UserVm;
+import com.cloud.utils.DateUtil;
+import com.cloud.utils.Pair;
+import com.cloud.utils.exception.CloudRuntimeException;
+import com.cloud.utils.fsm.NoTransitionException;
+import com.cloud.vm.UserVmVO;
+import com.cloud.vm.VirtualMachine;
+import com.cloud.vm.snapshot.VMSnapshot;
+import com.cloud.vm.snapshot.VMSnapshotDetailsVO;
+import com.cloud.vm.snapshot.VMSnapshotVO;
+import org.apache.cloudstack.backup.BackupOfferingVO;
+import org.apache.cloudstack.backup.dao.BackupOfferingDao;
+import
org.apache.cloudstack.engine.subsystem.api.storage.ObjectInDataStoreStateMachine;
+import org.apache.cloudstack.engine.subsystem.api.storage.SnapshotInfo;
+import org.apache.cloudstack.engine.subsystem.api.storage.StrategyPriority;
+import org.apache.cloudstack.engine.subsystem.api.storage.VMSnapshotOptions;
+import org.apache.cloudstack.engine.subsystem.api.storage.VolumeInfo;
+import org.apache.cloudstack.storage.datastore.db.SnapshotDataStoreDao;
+import org.apache.cloudstack.storage.datastore.db.SnapshotDataStoreVO;
+import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
+import org.apache.cloudstack.storage.snapshot.SnapshotObject;
+import org.apache.cloudstack.storage.to.SnapshotObjectTO;
+import org.apache.cloudstack.storage.to.VolumeObjectTO;
+import org.apache.commons.collections.CollectionUtils;
+
+import javax.inject.Inject;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class KvmFileBasedStorageVmSnapshotStrategy extends
StorageVMSnapshotStrategy {
+
+ private static final List<Storage.StoragePoolType>
supportedStoragePoolTypes = List.of(Storage.StoragePoolType.Filesystem,
Storage.StoragePoolType.NetworkFilesystem,
Storage.StoragePoolType.SharedMountPoint);
+
+ @Inject
+ protected SnapshotDataStoreDao snapshotDataStoreDao;
+
+ @Inject
+ protected ResourceLimitService resourceLimitManager;
+
+ @Inject
+ protected BackupOfferingDao backupOfferingDao;
+
+ @Override
+ public VMSnapshot takeVMSnapshot(VMSnapshot vmSnapshot) {
+ Map<VolumeInfo, SnapshotObject> volumeInfoToSnapshotObjectMap = new
HashMap<>();
+ try {
+ return takeVmSnapshotInternal(vmSnapshot,
volumeInfoToSnapshotObjectMap);
+ } catch (CloudRuntimeException | NullPointerException |
NoTransitionException ex) {
+ for (VolumeInfo volumeInfo :
volumeInfoToSnapshotObjectMap.keySet()) {
+ volumeInfo.stateTransit(Volume.Event.OperationFailed);
+ SnapshotObject snapshot =
volumeInfoToSnapshotObjectMap.get(volumeInfo);
+ try {
+ snapshot.processEvent(Snapshot.Event.OperationFailed);
+ } catch (NoTransitionException e) {
+ logger.error("Failed to change snapshot [{}] state due to
[{}].", snapshot.getUuid(), e.getMessage(), e);
+ }
+
snapshot.processEvent(ObjectInDataStoreStateMachine.Event.OperationFailed);
+ }
+ try {
+ vmSnapshotHelper.vmSnapshotStateTransitTo(vmSnapshot,
VMSnapshot.Event.OperationFailed);
+ } catch (NoTransitionException e) {
+ throw new CloudRuntimeException(e);
+ }
+ throw new CloudRuntimeException(ex);
+ }
+ }
+
+ @Override
+ public boolean deleteVMSnapshot(VMSnapshot vmSnapshot) {
+ logger.info("Starting VM snapshot delete process for snapshot [{}].",
vmSnapshot.getUuid());
+ UserVmVO userVm = userVmDao.findById(vmSnapshot.getVmId());
+ VMSnapshotVO vmSnapshotBeingDeleted = (VMSnapshotVO) vmSnapshot;
+ Long hostId =
vmSnapshotHelper.pickRunningHost(vmSnapshotBeingDeleted.getVmId());
+ long virtualSize = 0;
+ boolean isCurrent = vmSnapshotBeingDeleted.getCurrent();
+
+ transitStateWithoutThrow(vmSnapshotBeingDeleted,
VMSnapshot.Event.ExpungeRequested);
+
+ List<VolumeObjectTO> volumeTOs =
vmSnapshotHelper.getVolumeTOList(vmSnapshotBeingDeleted.getVmId());
+ List<VMSnapshotVO> snapshotChildren =
vmSnapshotDao.listByParentAndStateIn(vmSnapshotBeingDeleted.getId(),
VMSnapshot.State.Ready, VMSnapshot.State.Hidden);
+
+ long realSize = getVMSnapshotRealSize(vmSnapshotBeingDeleted);
+ int numberOfChildren = snapshotChildren.size();
+
+ List<SnapshotVO> volumeSnapshotVos = new ArrayList<>();
+ if (isCurrent && numberOfChildren == 0) {
+ volumeSnapshotVos =
mergeCurrentDeltaOnSnapshot(vmSnapshotBeingDeleted, userVm, hostId, volumeTOs);
+ } else if (numberOfChildren == 0) {
+ logger.debug("Deleting VM snapshot [{}] as no snapshots/volumes
depend on it.", vmSnapshot.getUuid());
+ volumeSnapshotVos = deleteSnapshot(vmSnapshotBeingDeleted, hostId);
+
mergeOldSiblingWithOldParentIfOldParentIsDead(vmSnapshotDao.findByIdIncludingRemoved(vmSnapshotBeingDeleted.getParent()),
userVm, hostId, volumeTOs);
+ } else if (!isCurrent && numberOfChildren == 1) {
+ VMSnapshotVO childSnapshot = snapshotChildren.get(0);
+ volumeSnapshotVos = mergeSnapshots(vmSnapshotBeingDeleted,
childSnapshot, userVm, volumeTOs, hostId);
+ }
+
+ for (SnapshotVO snapshotVO : volumeSnapshotVos) {
+ snapshotVO.setState(Snapshot.State.Destroyed);
+ snapshotDao.update(snapshotVO.getId(), snapshotVO);
+ }
+
+ for (VolumeObjectTO volumeTo : volumeTOs) {
+ publishUsageEvent(EventTypes.EVENT_VM_SNAPSHOT_DELETE,
vmSnapshotBeingDeleted, userVm, volumeTo);
+ virtualSize += volumeTo.getSize();
+ }
+
+ publishUsageEvent(EventTypes.EVENT_VM_SNAPSHOT_OFF_PRIMARY,
vmSnapshotBeingDeleted, userVm, realSize, virtualSize);
+
+ if (numberOfChildren > 1 || (isCurrent && numberOfChildren == 1)) {
+ transitStateWithoutThrow(vmSnapshotBeingDeleted,
VMSnapshot.Event.Hide);
+ return true;
+ }
+
+ transitStateWithoutThrow(vmSnapshotBeingDeleted,
VMSnapshot.Event.OperationSucceeded);
+
+ vmSnapshotDetailsDao.removeDetails(vmSnapshotBeingDeleted.getId());
+
+ vmSnapshotBeingDeleted.setRemoved(DateUtil.now());
+ vmSnapshotDao.update(vmSnapshotBeingDeleted.getId(),
vmSnapshotBeingDeleted);
+
+ return true;
+ }
+
+ @Override
+ public boolean revertVMSnapshot(VMSnapshot vmSnapshot) {
+ UserVmVO userVm = userVmDao.findById(vmSnapshot.getVmId());
+ if (!userVm.getState().equals(VirtualMachine.State.Stopped)) {
Review Comment:
```suggestion
if (!VirtualMachine.State.Stopped.equals(userVm.getState())) {
```
##########
plugins/backup/nas/src/main/java/org/apache/cloudstack/backup/NASBackupProvider.java:
##########
@@ -400,6 +413,14 @@ public Backup
createNewBackupEntryForRestorePoint(Backup.RestorePoint restorePoi
@Override
public boolean assignVMToBackupOffering(VirtualMachine vm, BackupOffering
backupOffering) {
+ for (VMSnapshotVO vmSnapshotVO :
vmSnapshotDao.findByVmAndByType(vm.getId(), VMSnapshot.Type.Disk)) {
+ List<VMSnapshotDetailsVO> vmSnapshotDetails =
vmSnapshotDetailsDao.listDetails(vmSnapshotVO.getId());
+ if (vmSnapshotDetails.stream().anyMatch(vmSnapshotDetailsVO ->
vmSnapshotDetailsVO.getName().equals(VolumeApiServiceImpl.KVM_FILE_BASED_STORAGE_SNAPSHOT)))
{
Review Comment:
```suggestion
if (vmSnapshotDetails.stream().anyMatch(vmSnapshotDetailsVO ->
VolumeApiServiceImpl.KVM_FILE_BASED_STORAGE_SNAPSHOT.equals(vmSnapshotDetailsVO.getName())))
{
```
##########
engine/storage/snapshot/src/main/java/org/apache/cloudstack/storage/vmsnapshot/KvmFileBasedStorageVmSnapshotStrategy.java:
##########
@@ -0,0 +1,689 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.cloudstack.storage.vmsnapshot;
+
+import com.cloud.agent.api.Answer;
+import com.cloud.agent.api.VMSnapshotTO;
+import com.cloud.agent.api.storage.CreateDiskOnlyVmSnapshotAnswer;
+import com.cloud.agent.api.storage.CreateDiskOnlyVmSnapshotCommand;
+import com.cloud.agent.api.storage.DeleteDiskOnlyVmSnapshotCommand;
+import com.cloud.agent.api.storage.MergeDiskOnlyVmSnapshotCommand;
+import com.cloud.agent.api.storage.RevertDiskOnlyVmSnapshotAnswer;
+import com.cloud.agent.api.storage.RevertDiskOnlyVmSnapshotCommand;
+import com.cloud.agent.api.storage.SnapshotMergeTreeTO;
+import com.cloud.agent.api.to.DataTO;
+import com.cloud.configuration.Resource;
+import com.cloud.event.EventTypes;
+import com.cloud.event.UsageEventUtils;
+import com.cloud.hypervisor.Hypervisor;
+import com.cloud.storage.DataStoreRole;
+import com.cloud.storage.Snapshot;
+import com.cloud.storage.SnapshotVO;
+import com.cloud.storage.Storage;
+import com.cloud.storage.Volume;
+import com.cloud.storage.VolumeVO;
+import com.cloud.user.ResourceLimitService;
+import com.cloud.uservm.UserVm;
+import com.cloud.utils.DateUtil;
+import com.cloud.utils.Pair;
+import com.cloud.utils.exception.CloudRuntimeException;
+import com.cloud.utils.fsm.NoTransitionException;
+import com.cloud.vm.UserVmVO;
+import com.cloud.vm.VirtualMachine;
+import com.cloud.vm.snapshot.VMSnapshot;
+import com.cloud.vm.snapshot.VMSnapshotDetailsVO;
+import com.cloud.vm.snapshot.VMSnapshotVO;
+import org.apache.cloudstack.backup.BackupOfferingVO;
+import org.apache.cloudstack.backup.dao.BackupOfferingDao;
+import
org.apache.cloudstack.engine.subsystem.api.storage.ObjectInDataStoreStateMachine;
+import org.apache.cloudstack.engine.subsystem.api.storage.SnapshotInfo;
+import org.apache.cloudstack.engine.subsystem.api.storage.StrategyPriority;
+import org.apache.cloudstack.engine.subsystem.api.storage.VMSnapshotOptions;
+import org.apache.cloudstack.engine.subsystem.api.storage.VolumeInfo;
+import org.apache.cloudstack.storage.datastore.db.SnapshotDataStoreDao;
+import org.apache.cloudstack.storage.datastore.db.SnapshotDataStoreVO;
+import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
+import org.apache.cloudstack.storage.snapshot.SnapshotObject;
+import org.apache.cloudstack.storage.to.SnapshotObjectTO;
+import org.apache.cloudstack.storage.to.VolumeObjectTO;
+import org.apache.commons.collections.CollectionUtils;
+
+import javax.inject.Inject;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class KvmFileBasedStorageVmSnapshotStrategy extends
StorageVMSnapshotStrategy {
+
+ private static final List<Storage.StoragePoolType>
supportedStoragePoolTypes = List.of(Storage.StoragePoolType.Filesystem,
Storage.StoragePoolType.NetworkFilesystem,
Storage.StoragePoolType.SharedMountPoint);
+
+ @Inject
+ protected SnapshotDataStoreDao snapshotDataStoreDao;
+
+ @Inject
+ protected ResourceLimitService resourceLimitManager;
+
+ @Inject
+ protected BackupOfferingDao backupOfferingDao;
+
+ @Override
+ public VMSnapshot takeVMSnapshot(VMSnapshot vmSnapshot) {
+ Map<VolumeInfo, SnapshotObject> volumeInfoToSnapshotObjectMap = new
HashMap<>();
+ try {
+ return takeVmSnapshotInternal(vmSnapshot,
volumeInfoToSnapshotObjectMap);
+ } catch (CloudRuntimeException | NullPointerException |
NoTransitionException ex) {
+ for (VolumeInfo volumeInfo :
volumeInfoToSnapshotObjectMap.keySet()) {
+ volumeInfo.stateTransit(Volume.Event.OperationFailed);
+ SnapshotObject snapshot =
volumeInfoToSnapshotObjectMap.get(volumeInfo);
+ try {
+ snapshot.processEvent(Snapshot.Event.OperationFailed);
+ } catch (NoTransitionException e) {
+ logger.error("Failed to change snapshot [{}] state due to
[{}].", snapshot.getUuid(), e.getMessage(), e);
+ }
+
snapshot.processEvent(ObjectInDataStoreStateMachine.Event.OperationFailed);
+ }
+ try {
+ vmSnapshotHelper.vmSnapshotStateTransitTo(vmSnapshot,
VMSnapshot.Event.OperationFailed);
+ } catch (NoTransitionException e) {
+ throw new CloudRuntimeException(e);
+ }
+ throw new CloudRuntimeException(ex);
+ }
+ }
+
+ @Override
+ public boolean deleteVMSnapshot(VMSnapshot vmSnapshot) {
+ logger.info("Starting VM snapshot delete process for snapshot [{}].",
vmSnapshot.getUuid());
+ UserVmVO userVm = userVmDao.findById(vmSnapshot.getVmId());
+ VMSnapshotVO vmSnapshotBeingDeleted = (VMSnapshotVO) vmSnapshot;
+ Long hostId =
vmSnapshotHelper.pickRunningHost(vmSnapshotBeingDeleted.getVmId());
+ long virtualSize = 0;
+ boolean isCurrent = vmSnapshotBeingDeleted.getCurrent();
+
+ transitStateWithoutThrow(vmSnapshotBeingDeleted,
VMSnapshot.Event.ExpungeRequested);
+
+ List<VolumeObjectTO> volumeTOs =
vmSnapshotHelper.getVolumeTOList(vmSnapshotBeingDeleted.getVmId());
+ List<VMSnapshotVO> snapshotChildren =
vmSnapshotDao.listByParentAndStateIn(vmSnapshotBeingDeleted.getId(),
VMSnapshot.State.Ready, VMSnapshot.State.Hidden);
+
+ long realSize = getVMSnapshotRealSize(vmSnapshotBeingDeleted);
+ int numberOfChildren = snapshotChildren.size();
+
+ List<SnapshotVO> volumeSnapshotVos = new ArrayList<>();
+ if (isCurrent && numberOfChildren == 0) {
+ volumeSnapshotVos =
mergeCurrentDeltaOnSnapshot(vmSnapshotBeingDeleted, userVm, hostId, volumeTOs);
+ } else if (numberOfChildren == 0) {
+ logger.debug("Deleting VM snapshot [{}] as no snapshots/volumes
depend on it.", vmSnapshot.getUuid());
+ volumeSnapshotVos = deleteSnapshot(vmSnapshotBeingDeleted, hostId);
+
mergeOldSiblingWithOldParentIfOldParentIsDead(vmSnapshotDao.findByIdIncludingRemoved(vmSnapshotBeingDeleted.getParent()),
userVm, hostId, volumeTOs);
+ } else if (!isCurrent && numberOfChildren == 1) {
+ VMSnapshotVO childSnapshot = snapshotChildren.get(0);
+ volumeSnapshotVos = mergeSnapshots(vmSnapshotBeingDeleted,
childSnapshot, userVm, volumeTOs, hostId);
+ }
+
+ for (SnapshotVO snapshotVO : volumeSnapshotVos) {
+ snapshotVO.setState(Snapshot.State.Destroyed);
+ snapshotDao.update(snapshotVO.getId(), snapshotVO);
+ }
+
+ for (VolumeObjectTO volumeTo : volumeTOs) {
+ publishUsageEvent(EventTypes.EVENT_VM_SNAPSHOT_DELETE,
vmSnapshotBeingDeleted, userVm, volumeTo);
+ virtualSize += volumeTo.getSize();
+ }
+
+ publishUsageEvent(EventTypes.EVENT_VM_SNAPSHOT_OFF_PRIMARY,
vmSnapshotBeingDeleted, userVm, realSize, virtualSize);
+
+ if (numberOfChildren > 1 || (isCurrent && numberOfChildren == 1)) {
+ transitStateWithoutThrow(vmSnapshotBeingDeleted,
VMSnapshot.Event.Hide);
+ return true;
+ }
+
+ transitStateWithoutThrow(vmSnapshotBeingDeleted,
VMSnapshot.Event.OperationSucceeded);
+
+ vmSnapshotDetailsDao.removeDetails(vmSnapshotBeingDeleted.getId());
+
+ vmSnapshotBeingDeleted.setRemoved(DateUtil.now());
+ vmSnapshotDao.update(vmSnapshotBeingDeleted.getId(),
vmSnapshotBeingDeleted);
+
+ return true;
+ }
+
+ @Override
+ public boolean revertVMSnapshot(VMSnapshot vmSnapshot) {
+ UserVmVO userVm = userVmDao.findById(vmSnapshot.getVmId());
+ if (!userVm.getState().equals(VirtualMachine.State.Stopped)) {
+ throw new CloudRuntimeException("VM must be stopped to revert
disk-only VM snapshot.");
+ }
+
+ VMSnapshotVO vmSnapshotBeingReverted = (VMSnapshotVO) vmSnapshot;
+ Long hostId =
vmSnapshotHelper.pickRunningHost(vmSnapshotBeingReverted.getVmId());
+
+ transitStateWithoutThrow(vmSnapshotBeingReverted,
VMSnapshot.Event.RevertRequested);
+
+ List<SnapshotDataStoreVO> volumeSnapshots =
getVolumeSnapshotsAssociatedWithVmSnapshot(vmSnapshotBeingReverted);
+ List<SnapshotObjectTO> volumeSnapshotTos = volumeSnapshots.stream()
+ .map(snapshot -> (SnapshotObjectTO)
snapshotDataFactory.getSnapshot(snapshot.getSnapshotId(),
snapshot.getDataStoreId(), DataStoreRole.Primary).getTO())
+ .collect(Collectors.toList());
+
+ RevertDiskOnlyVmSnapshotCommand revertDiskOnlyVMSnapshotCommand = new
RevertDiskOnlyVmSnapshotCommand(volumeSnapshotTos, userVm.getName());
+ Answer answer = agentMgr.easySend(hostId,
revertDiskOnlyVMSnapshotCommand);
+
+ if (answer == null || !answer.getResult()) {
+ transitStateWithoutThrow(vmSnapshotBeingReverted,
VMSnapshot.Event.OperationFailed);
+ logger.error(answer != null ? answer.getDetails() :
String.format("Communication failure with host [%s].", hostId));
+ throw new CloudRuntimeException(String.format("Error reverting VM
snapshot [%s].", vmSnapshot.getUuid()));
+ }
+
+ RevertDiskOnlyVmSnapshotAnswer revertDiskOnlyVMSnapshotAnswer =
(RevertDiskOnlyVmSnapshotAnswer) answer;
+
+ for (VolumeObjectTO volumeObjectTo :
revertDiskOnlyVMSnapshotAnswer.getVolumeObjectTos()) {
+ VolumeVO volumeVO =
volumeDao.findById(volumeObjectTo.getVolumeId());
+ volumeVO.setPath(volumeObjectTo.getPath());
+ updateSizeIfNeeded(volumeSnapshots, volumeVO, volumeObjectTo);
+
+ volumeDao.update(volumeVO.getId(), volumeVO);
+ publishUsageEvent(EventTypes.EVENT_VM_SNAPSHOT_REVERT,
vmSnapshotBeingReverted, userVm, volumeObjectTo);
+ }
+
+ transitStateWithoutThrow(vmSnapshotBeingReverted,
VMSnapshot.Event.OperationSucceeded);
+
+ VMSnapshotVO currentVmSnapshot =
vmSnapshotDao.findCurrentSnapshotByVmId(userVm.getId());
+ currentVmSnapshot.setCurrent(false);
+ vmSnapshotBeingReverted.setCurrent(true);
+
+ vmSnapshotDao.update(currentVmSnapshot.getId(), currentVmSnapshot);
+ vmSnapshotDao.update(vmSnapshotBeingReverted.getId(),
vmSnapshotBeingReverted);
+
+ mergeOldSiblingWithOldParentIfOldParentIsDead(currentVmSnapshot,
userVm, hostId, vmSnapshotHelper.getVolumeTOList(userVm.getId()));
+ return true;
+ }
+
+ /**
+ * Updates the volume size if it changed due to the snapshot reversion.
+ * */
+ private void updateSizeIfNeeded(List<SnapshotDataStoreVO> volumeSnapshots,
VolumeVO volumeVO, VolumeObjectTO volumeObjectTO) {
+ SnapshotDataStoreVO snapshotRef =
volumeSnapshots.stream().filter(snapshotDataStoreVO ->
snapshotDataStoreVO.getVolumeId() == volumeVO.getId()).
+ findFirst().
+ orElseThrow(() -> new
CloudRuntimeException(String.format("Unable to map any snapshot to volume
[%s].", volumeVO)));
+
+ if (volumeVO.getSize() == snapshotRef.getSize()) {
+ logger.debug("No need to update the volume size and launch a
resize event as the snapshot [{}] and volume [{}] size are equal.",
snapshotRef.getSnapshotId(), volumeVO.getUuid());
+ return;
+ }
+
+ long delta = volumeVO.getSize() - snapshotRef.getSize();
+ if (delta < 0) {
+
resourceLimitManager.incrementResourceCount(volumeVO.getAccountId(),
Resource.ResourceType.primary_storage, -delta);
+ } else {
+
resourceLimitManager.decrementResourceCount(volumeVO.getAccountId(),
Resource.ResourceType.primary_storage, delta);
+ }
+ volumeVO.setSize(snapshotRef.getSize());
+ volumeObjectTO.setSize(snapshotRef.getSize());
+ volumeDao.update(volumeVO.getId(), volumeVO);
+ UsageEventUtils.publishUsageEvent(EventTypes.EVENT_VOLUME_RESIZE,
volumeVO.getAccountId(), volumeVO.getDataCenterId(), volumeVO.getId(),
volumeVO.getName(),
+ volumeVO.getDiskOfferingId(), volumeVO.getTemplateId(),
volumeVO.getSize(), Volume.class.getName(), volumeVO.getUuid());
+ }
+
+ private void mergeOldSiblingWithOldParentIfOldParentIsDead(VMSnapshotVO
oldParent, UserVmVO userVm, Long hostId, List<VolumeObjectTO> volumeTOs) {
+ if (oldParent == null || oldParent.getRemoved() != null ||
!VMSnapshot.State.Hidden.equals(oldParent.getState())) {
+ return;
+ }
+
+ List<SnapshotVO> snapshotVos;
+
+ if (oldParent.getCurrent()) {
+ snapshotVos = mergeCurrentDeltaOnSnapshot(oldParent, userVm,
hostId, volumeTOs);
+ } else {
+ List<VMSnapshotVO> oldSiblings =
vmSnapshotDao.listByParentAndStateIn(oldParent.getId(), VMSnapshot.State.Ready,
VMSnapshot.State.Hidden);
+
+ if (oldSiblings.size() > 1) {
+ logger.debug("The old snapshot [{}] is dead and still has more
than one live child snapshot. We will keep it on storage still.",
oldParent.getUuid());
+ return;
+ }
+
+ if (oldSiblings.isEmpty()) {
+ logger.warn("The old snapshot [{}] is dead, but it only had
one child. This is an inconsistency and should be analysed/reported.",
oldParent.getUuid());
+ return;
+ }
+
+ VMSnapshotVO oldSibling = oldSiblings.get(0);
+ logger.debug("Merging VM snapshot [{}] with [{}] as the former was
hidden and only the latter depends on it.", oldParent.getUuid(),
oldSibling.getUuid());
+
+ snapshotVos = mergeSnapshots(oldParent, oldSibling, userVm,
volumeTOs, hostId);
+ }
+
+ for (SnapshotVO snapshotVO : snapshotVos) {
+ snapshotVO.setState(Snapshot.State.Destroyed);
+ snapshotDao.update(snapshotVO.getId(), snapshotVO);
+ }
+
+ vmSnapshotDetailsDao.removeDetails(oldParent.getId());
+
+ oldParent.setRemoved(DateUtil.now());
+ vmSnapshotDao.update(oldParent.getId(), oldParent);
+
+ transitStateWithoutThrow(oldParent, VMSnapshot.Event.ExpungeRequested);
+ transitStateWithoutThrow(oldParent,
VMSnapshot.Event.OperationSucceeded);
+ }
+
+ @Override
+ public StrategyPriority canHandle(VMSnapshot vmSnapshot) {
+ if (!VMSnapshot.State.Allocated.equals(vmSnapshot.getState())) {
+ List<VMSnapshotDetailsVO> vmSnapshotDetails =
vmSnapshotDetailsDao.findDetails(vmSnapshot.getId(),
KVM_FILE_BASED_STORAGE_SNAPSHOT);
+ if (CollectionUtils.isEmpty(vmSnapshotDetails)) {
+ logger.debug("KVM file based storage VM snapshot strategy
cannot handle [{}] as it is not a KVM file based storage VM snapshot.",
+ vmSnapshot.getUuid());
+ return StrategyPriority.CANT_HANDLE;
+ }
+ return StrategyPriority.HIGHEST;
+ }
+
+ long vmId = vmSnapshot.getVmId();
+ boolean memorySnapshot =
VMSnapshot.Type.DiskAndMemory.equals(vmSnapshot.getType());
+ return canHandle(vmId, null, memorySnapshot);
+ }
+
+ @Override
+ public StrategyPriority canHandle(Long vmId, Long rootPoolId, boolean
snapshotMemory) {
+ VirtualMachine vm = userVmDao.findById(vmId);
+
+ String cantHandleLog = String.format("KVM file based storage VM
snapshot strategy cannot handle VM snapshot for [%s]", vm);
+ if (snapshotMemory) {
+ logger.debug("{} as a snapshot with memory was requested.",
cantHandleLog);
+ return StrategyPriority.CANT_HANDLE;
+ }
+
+ if (!Hypervisor.HypervisorType.KVM.equals(vm.getHypervisorType())) {
+ logger.debug("{} as the hypervisor is not KVM.", cantHandleLog);
+ return StrategyPriority.CANT_HANDLE;
+ }
+
+ if (CollectionUtils.isNotEmpty(vmSnapshotDao.findByVmAndByType(vmId,
VMSnapshot.Type.DiskAndMemory))) {
+ logger.debug("{} as there is already a VM snapshot with disk and
memory.", cantHandleLog);
+ return StrategyPriority.CANT_HANDLE;
+ }
+
+ List<VolumeVO> volumes = volumeDao.findByInstance(vmId);
+ for (VolumeVO volume : volumes) {
+ StoragePoolVO storagePoolVO =
storagePool.findById(volume.getPoolId());
+ if
(!supportedStoragePoolTypes.contains(storagePoolVO.getPoolType())) {
+ logger.debug(String.format("%s as the VM has a volume that is
in a storage with unsupported type [%s].", cantHandleLog,
storagePoolVO.getPoolType()));
+ return StrategyPriority.CANT_HANDLE;
+ }
+ List<SnapshotVO> snapshots =
snapshotDao.listByVolumeIdAndTypeNotInAndStateNotRemoved(volume.getId(),
Snapshot.Type.GROUP);
+ if (CollectionUtils.isNotEmpty(snapshots)) {
+ logger.debug("{} as VM has a volume with snapshots {}. Volume
snapshots and KvmFileBasedStorageVmSnapshotStrategy are not compatible, as
restoring volume snapshots will erase VM " +
+ "snapshots and cause data loss.", cantHandleLog,
snapshots);
+ return StrategyPriority.CANT_HANDLE;
+ }
+ }
+
+ BackupOfferingVO backupOffering =
backupOfferingDao.findById(vm.getBackupOfferingId());
+ if (backupOffering != null) {
+ logger.debug("{} as the VM has a backup offering. This strategy
does not support snapshots on VMs with current backup providers.",
cantHandleLog);
+ return StrategyPriority.CANT_HANDLE;
+ }
+
+ return StrategyPriority.HIGHEST;
+ }
+
+ private List<SnapshotVO> deleteSnapshot(VMSnapshotVO vmSnapshotVO, Long
hostId) {
+ List<SnapshotDataStoreVO> volumeSnapshots =
getVolumeSnapshotsAssociatedWithVmSnapshot(vmSnapshotVO);
+ List<DataTO> volumeSnapshotTOList = volumeSnapshots.stream()
+ .map(snapshotDataStoreVO ->
snapshotDataFactory.getSnapshot(snapshotDataStoreVO.getSnapshotId(),
snapshotDataStoreVO.getDataStoreId(), DataStoreRole.Primary).getTO())
+ .collect(Collectors.toList());
+
+ DeleteDiskOnlyVmSnapshotCommand deleteSnapshotCommand = new
DeleteDiskOnlyVmSnapshotCommand(volumeSnapshotTOList);
+ Answer answer = agentMgr.easySend(hostId, deleteSnapshotCommand);
+ if (answer == null || !answer.getResult()) {
+ logger.error("Failed to delete VM snapshot [{}] due to {}.",
vmSnapshotVO.getUuid(), answer != null ? answer.getDetails() : "Communication
failure");
+ throw new CloudRuntimeException(String.format("Failed to delete VM
snapshot [%s].", vmSnapshotVO.getUuid()));
+ }
+
+ logger.debug("Updating metadata of VM snapshot [{}].",
vmSnapshotVO.getUuid());
+ List<SnapshotVO> snapshotVOList = new ArrayList<>();
+ for (SnapshotDataStoreVO snapshotDataStoreVO : volumeSnapshots) {
+ snapshotDataStoreDao.remove(snapshotDataStoreVO.getId());
+
snapshotVOList.add(snapshotDao.findById(snapshotDataStoreVO.getSnapshotId()));
+ }
+ return snapshotVOList;
+ }
+
+ private List<SnapshotVO> mergeSnapshots(VMSnapshotVO vmSnapshotVO,
VMSnapshotVO childSnapshot, UserVmVO userVm, List<VolumeObjectTO>
volumeObjectTOS, Long hostId) {
+ logger.debug("Merging VM snapshot [{}] with its child [{}].",
vmSnapshotVO.getUuid(), childSnapshot.getUuid());
+
+ List<VMSnapshotVO> snapshotGrandChildren =
vmSnapshotDao.listByParentAndStateIn(childSnapshot.getId(),
VMSnapshot.State.Ready, VMSnapshot.State.Hidden);
+
+ if (userVm.getState().equals(VirtualMachine.State.Running) &&
!snapshotGrandChildren.isEmpty()) {
+ logger.debug("Removing VM snapshots that are part of the VM's [{}]
current backing chain from the list of snapshots to be rebased.",
userVm.getUuid());
+
removeCurrentBackingChainSnapshotFromVmSnapshotList(snapshotGrandChildren,
userVm);
+ }
+
+ List<SnapshotMergeTreeTO> snapshotMergeTreeToList =
generateSnapshotMergeTrees(vmSnapshotVO, childSnapshot, snapshotGrandChildren);
+
+ if (childSnapshot.getCurrent() &&
!userVm.getState().equals(VirtualMachine.State.Running)) {
Review Comment:
```suggestion
if (childSnapshot.getCurrent() &&
!VirtualMachine.State.Running.equals(userVm.getState()) {
```
##########
engine/storage/snapshot/src/main/java/org/apache/cloudstack/storage/vmsnapshot/KvmFileBasedStorageVmSnapshotStrategy.java:
##########
@@ -0,0 +1,689 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.cloudstack.storage.vmsnapshot;
+
+import com.cloud.agent.api.Answer;
+import com.cloud.agent.api.VMSnapshotTO;
+import com.cloud.agent.api.storage.CreateDiskOnlyVmSnapshotAnswer;
+import com.cloud.agent.api.storage.CreateDiskOnlyVmSnapshotCommand;
+import com.cloud.agent.api.storage.DeleteDiskOnlyVmSnapshotCommand;
+import com.cloud.agent.api.storage.MergeDiskOnlyVmSnapshotCommand;
+import com.cloud.agent.api.storage.RevertDiskOnlyVmSnapshotAnswer;
+import com.cloud.agent.api.storage.RevertDiskOnlyVmSnapshotCommand;
+import com.cloud.agent.api.storage.SnapshotMergeTreeTO;
+import com.cloud.agent.api.to.DataTO;
+import com.cloud.configuration.Resource;
+import com.cloud.event.EventTypes;
+import com.cloud.event.UsageEventUtils;
+import com.cloud.hypervisor.Hypervisor;
+import com.cloud.storage.DataStoreRole;
+import com.cloud.storage.Snapshot;
+import com.cloud.storage.SnapshotVO;
+import com.cloud.storage.Storage;
+import com.cloud.storage.Volume;
+import com.cloud.storage.VolumeVO;
+import com.cloud.user.ResourceLimitService;
+import com.cloud.uservm.UserVm;
+import com.cloud.utils.DateUtil;
+import com.cloud.utils.Pair;
+import com.cloud.utils.exception.CloudRuntimeException;
+import com.cloud.utils.fsm.NoTransitionException;
+import com.cloud.vm.UserVmVO;
+import com.cloud.vm.VirtualMachine;
+import com.cloud.vm.snapshot.VMSnapshot;
+import com.cloud.vm.snapshot.VMSnapshotDetailsVO;
+import com.cloud.vm.snapshot.VMSnapshotVO;
+import org.apache.cloudstack.backup.BackupOfferingVO;
+import org.apache.cloudstack.backup.dao.BackupOfferingDao;
+import
org.apache.cloudstack.engine.subsystem.api.storage.ObjectInDataStoreStateMachine;
+import org.apache.cloudstack.engine.subsystem.api.storage.SnapshotInfo;
+import org.apache.cloudstack.engine.subsystem.api.storage.StrategyPriority;
+import org.apache.cloudstack.engine.subsystem.api.storage.VMSnapshotOptions;
+import org.apache.cloudstack.engine.subsystem.api.storage.VolumeInfo;
+import org.apache.cloudstack.storage.datastore.db.SnapshotDataStoreDao;
+import org.apache.cloudstack.storage.datastore.db.SnapshotDataStoreVO;
+import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
+import org.apache.cloudstack.storage.snapshot.SnapshotObject;
+import org.apache.cloudstack.storage.to.SnapshotObjectTO;
+import org.apache.cloudstack.storage.to.VolumeObjectTO;
+import org.apache.commons.collections.CollectionUtils;
+
+import javax.inject.Inject;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class KvmFileBasedStorageVmSnapshotStrategy extends
StorageVMSnapshotStrategy {
+
+ private static final List<Storage.StoragePoolType>
supportedStoragePoolTypes = List.of(Storage.StoragePoolType.Filesystem,
Storage.StoragePoolType.NetworkFilesystem,
Storage.StoragePoolType.SharedMountPoint);
+
+ @Inject
+ protected SnapshotDataStoreDao snapshotDataStoreDao;
+
+ @Inject
+ protected ResourceLimitService resourceLimitManager;
+
+ @Inject
+ protected BackupOfferingDao backupOfferingDao;
+
+ @Override
+ public VMSnapshot takeVMSnapshot(VMSnapshot vmSnapshot) {
+ Map<VolumeInfo, SnapshotObject> volumeInfoToSnapshotObjectMap = new
HashMap<>();
+ try {
+ return takeVmSnapshotInternal(vmSnapshot,
volumeInfoToSnapshotObjectMap);
+ } catch (CloudRuntimeException | NullPointerException |
NoTransitionException ex) {
+ for (VolumeInfo volumeInfo :
volumeInfoToSnapshotObjectMap.keySet()) {
+ volumeInfo.stateTransit(Volume.Event.OperationFailed);
+ SnapshotObject snapshot =
volumeInfoToSnapshotObjectMap.get(volumeInfo);
+ try {
+ snapshot.processEvent(Snapshot.Event.OperationFailed);
+ } catch (NoTransitionException e) {
+ logger.error("Failed to change snapshot [{}] state due to
[{}].", snapshot.getUuid(), e.getMessage(), e);
+ }
+
snapshot.processEvent(ObjectInDataStoreStateMachine.Event.OperationFailed);
+ }
+ try {
+ vmSnapshotHelper.vmSnapshotStateTransitTo(vmSnapshot,
VMSnapshot.Event.OperationFailed);
+ } catch (NoTransitionException e) {
+ throw new CloudRuntimeException(e);
+ }
+ throw new CloudRuntimeException(ex);
+ }
+ }
+
+ @Override
+ public boolean deleteVMSnapshot(VMSnapshot vmSnapshot) {
+ logger.info("Starting VM snapshot delete process for snapshot [{}].",
vmSnapshot.getUuid());
+ UserVmVO userVm = userVmDao.findById(vmSnapshot.getVmId());
+ VMSnapshotVO vmSnapshotBeingDeleted = (VMSnapshotVO) vmSnapshot;
+ Long hostId =
vmSnapshotHelper.pickRunningHost(vmSnapshotBeingDeleted.getVmId());
+ long virtualSize = 0;
+ boolean isCurrent = vmSnapshotBeingDeleted.getCurrent();
+
+ transitStateWithoutThrow(vmSnapshotBeingDeleted,
VMSnapshot.Event.ExpungeRequested);
+
+ List<VolumeObjectTO> volumeTOs =
vmSnapshotHelper.getVolumeTOList(vmSnapshotBeingDeleted.getVmId());
+ List<VMSnapshotVO> snapshotChildren =
vmSnapshotDao.listByParentAndStateIn(vmSnapshotBeingDeleted.getId(),
VMSnapshot.State.Ready, VMSnapshot.State.Hidden);
+
+ long realSize = getVMSnapshotRealSize(vmSnapshotBeingDeleted);
+ int numberOfChildren = snapshotChildren.size();
+
+ List<SnapshotVO> volumeSnapshotVos = new ArrayList<>();
+ if (isCurrent && numberOfChildren == 0) {
+ volumeSnapshotVos =
mergeCurrentDeltaOnSnapshot(vmSnapshotBeingDeleted, userVm, hostId, volumeTOs);
+ } else if (numberOfChildren == 0) {
+ logger.debug("Deleting VM snapshot [{}] as no snapshots/volumes
depend on it.", vmSnapshot.getUuid());
+ volumeSnapshotVos = deleteSnapshot(vmSnapshotBeingDeleted, hostId);
+
mergeOldSiblingWithOldParentIfOldParentIsDead(vmSnapshotDao.findByIdIncludingRemoved(vmSnapshotBeingDeleted.getParent()),
userVm, hostId, volumeTOs);
+ } else if (!isCurrent && numberOfChildren == 1) {
+ VMSnapshotVO childSnapshot = snapshotChildren.get(0);
+ volumeSnapshotVos = mergeSnapshots(vmSnapshotBeingDeleted,
childSnapshot, userVm, volumeTOs, hostId);
+ }
+
+ for (SnapshotVO snapshotVO : volumeSnapshotVos) {
+ snapshotVO.setState(Snapshot.State.Destroyed);
+ snapshotDao.update(snapshotVO.getId(), snapshotVO);
+ }
+
+ for (VolumeObjectTO volumeTo : volumeTOs) {
+ publishUsageEvent(EventTypes.EVENT_VM_SNAPSHOT_DELETE,
vmSnapshotBeingDeleted, userVm, volumeTo);
+ virtualSize += volumeTo.getSize();
+ }
+
+ publishUsageEvent(EventTypes.EVENT_VM_SNAPSHOT_OFF_PRIMARY,
vmSnapshotBeingDeleted, userVm, realSize, virtualSize);
+
+ if (numberOfChildren > 1 || (isCurrent && numberOfChildren == 1)) {
+ transitStateWithoutThrow(vmSnapshotBeingDeleted,
VMSnapshot.Event.Hide);
+ return true;
+ }
+
+ transitStateWithoutThrow(vmSnapshotBeingDeleted,
VMSnapshot.Event.OperationSucceeded);
+
+ vmSnapshotDetailsDao.removeDetails(vmSnapshotBeingDeleted.getId());
+
+ vmSnapshotBeingDeleted.setRemoved(DateUtil.now());
+ vmSnapshotDao.update(vmSnapshotBeingDeleted.getId(),
vmSnapshotBeingDeleted);
+
+ return true;
+ }
+
+ @Override
+ public boolean revertVMSnapshot(VMSnapshot vmSnapshot) {
+ UserVmVO userVm = userVmDao.findById(vmSnapshot.getVmId());
+ if (!userVm.getState().equals(VirtualMachine.State.Stopped)) {
+ throw new CloudRuntimeException("VM must be stopped to revert
disk-only VM snapshot.");
+ }
+
+ VMSnapshotVO vmSnapshotBeingReverted = (VMSnapshotVO) vmSnapshot;
+ Long hostId =
vmSnapshotHelper.pickRunningHost(vmSnapshotBeingReverted.getVmId());
+
+ transitStateWithoutThrow(vmSnapshotBeingReverted,
VMSnapshot.Event.RevertRequested);
+
+ List<SnapshotDataStoreVO> volumeSnapshots =
getVolumeSnapshotsAssociatedWithVmSnapshot(vmSnapshotBeingReverted);
+ List<SnapshotObjectTO> volumeSnapshotTos = volumeSnapshots.stream()
+ .map(snapshot -> (SnapshotObjectTO)
snapshotDataFactory.getSnapshot(snapshot.getSnapshotId(),
snapshot.getDataStoreId(), DataStoreRole.Primary).getTO())
+ .collect(Collectors.toList());
+
+ RevertDiskOnlyVmSnapshotCommand revertDiskOnlyVMSnapshotCommand = new
RevertDiskOnlyVmSnapshotCommand(volumeSnapshotTos, userVm.getName());
+ Answer answer = agentMgr.easySend(hostId,
revertDiskOnlyVMSnapshotCommand);
+
+ if (answer == null || !answer.getResult()) {
+ transitStateWithoutThrow(vmSnapshotBeingReverted,
VMSnapshot.Event.OperationFailed);
+ logger.error(answer != null ? answer.getDetails() :
String.format("Communication failure with host [%s].", hostId));
+ throw new CloudRuntimeException(String.format("Error reverting VM
snapshot [%s].", vmSnapshot.getUuid()));
+ }
+
+ RevertDiskOnlyVmSnapshotAnswer revertDiskOnlyVMSnapshotAnswer =
(RevertDiskOnlyVmSnapshotAnswer) answer;
+
+ for (VolumeObjectTO volumeObjectTo :
revertDiskOnlyVMSnapshotAnswer.getVolumeObjectTos()) {
+ VolumeVO volumeVO =
volumeDao.findById(volumeObjectTo.getVolumeId());
+ volumeVO.setPath(volumeObjectTo.getPath());
+ updateSizeIfNeeded(volumeSnapshots, volumeVO, volumeObjectTo);
+
+ volumeDao.update(volumeVO.getId(), volumeVO);
+ publishUsageEvent(EventTypes.EVENT_VM_SNAPSHOT_REVERT,
vmSnapshotBeingReverted, userVm, volumeObjectTo);
+ }
+
+ transitStateWithoutThrow(vmSnapshotBeingReverted,
VMSnapshot.Event.OperationSucceeded);
+
+ VMSnapshotVO currentVmSnapshot =
vmSnapshotDao.findCurrentSnapshotByVmId(userVm.getId());
+ currentVmSnapshot.setCurrent(false);
+ vmSnapshotBeingReverted.setCurrent(true);
+
+ vmSnapshotDao.update(currentVmSnapshot.getId(), currentVmSnapshot);
+ vmSnapshotDao.update(vmSnapshotBeingReverted.getId(),
vmSnapshotBeingReverted);
+
+ mergeOldSiblingWithOldParentIfOldParentIsDead(currentVmSnapshot,
userVm, hostId, vmSnapshotHelper.getVolumeTOList(userVm.getId()));
+ return true;
+ }
+
+ /**
+ * Updates the volume size if it changed due to the snapshot reversion.
+ * */
+ private void updateSizeIfNeeded(List<SnapshotDataStoreVO> volumeSnapshots,
VolumeVO volumeVO, VolumeObjectTO volumeObjectTO) {
+ SnapshotDataStoreVO snapshotRef =
volumeSnapshots.stream().filter(snapshotDataStoreVO ->
snapshotDataStoreVO.getVolumeId() == volumeVO.getId()).
+ findFirst().
+ orElseThrow(() -> new
CloudRuntimeException(String.format("Unable to map any snapshot to volume
[%s].", volumeVO)));
+
+ if (volumeVO.getSize() == snapshotRef.getSize()) {
+ logger.debug("No need to update the volume size and launch a
resize event as the snapshot [{}] and volume [{}] size are equal.",
snapshotRef.getSnapshotId(), volumeVO.getUuid());
+ return;
+ }
+
+ long delta = volumeVO.getSize() - snapshotRef.getSize();
+ if (delta < 0) {
+
resourceLimitManager.incrementResourceCount(volumeVO.getAccountId(),
Resource.ResourceType.primary_storage, -delta);
+ } else {
+
resourceLimitManager.decrementResourceCount(volumeVO.getAccountId(),
Resource.ResourceType.primary_storage, delta);
+ }
+ volumeVO.setSize(snapshotRef.getSize());
+ volumeObjectTO.setSize(snapshotRef.getSize());
+ volumeDao.update(volumeVO.getId(), volumeVO);
+ UsageEventUtils.publishUsageEvent(EventTypes.EVENT_VOLUME_RESIZE,
volumeVO.getAccountId(), volumeVO.getDataCenterId(), volumeVO.getId(),
volumeVO.getName(),
+ volumeVO.getDiskOfferingId(), volumeVO.getTemplateId(),
volumeVO.getSize(), Volume.class.getName(), volumeVO.getUuid());
+ }
+
+ private void mergeOldSiblingWithOldParentIfOldParentIsDead(VMSnapshotVO
oldParent, UserVmVO userVm, Long hostId, List<VolumeObjectTO> volumeTOs) {
+ if (oldParent == null || oldParent.getRemoved() != null ||
!VMSnapshot.State.Hidden.equals(oldParent.getState())) {
+ return;
+ }
+
+ List<SnapshotVO> snapshotVos;
+
+ if (oldParent.getCurrent()) {
+ snapshotVos = mergeCurrentDeltaOnSnapshot(oldParent, userVm,
hostId, volumeTOs);
+ } else {
+ List<VMSnapshotVO> oldSiblings =
vmSnapshotDao.listByParentAndStateIn(oldParent.getId(), VMSnapshot.State.Ready,
VMSnapshot.State.Hidden);
+
+ if (oldSiblings.size() > 1) {
+ logger.debug("The old snapshot [{}] is dead and still has more
than one live child snapshot. We will keep it on storage still.",
oldParent.getUuid());
+ return;
+ }
+
+ if (oldSiblings.isEmpty()) {
+ logger.warn("The old snapshot [{}] is dead, but it only had
one child. This is an inconsistency and should be analysed/reported.",
oldParent.getUuid());
+ return;
+ }
+
+ VMSnapshotVO oldSibling = oldSiblings.get(0);
+ logger.debug("Merging VM snapshot [{}] with [{}] as the former was
hidden and only the latter depends on it.", oldParent.getUuid(),
oldSibling.getUuid());
+
+ snapshotVos = mergeSnapshots(oldParent, oldSibling, userVm,
volumeTOs, hostId);
+ }
+
+ for (SnapshotVO snapshotVO : snapshotVos) {
+ snapshotVO.setState(Snapshot.State.Destroyed);
+ snapshotDao.update(snapshotVO.getId(), snapshotVO);
+ }
+
+ vmSnapshotDetailsDao.removeDetails(oldParent.getId());
+
+ oldParent.setRemoved(DateUtil.now());
+ vmSnapshotDao.update(oldParent.getId(), oldParent);
+
+ transitStateWithoutThrow(oldParent, VMSnapshot.Event.ExpungeRequested);
+ transitStateWithoutThrow(oldParent,
VMSnapshot.Event.OperationSucceeded);
+ }
+
+ @Override
+ public StrategyPriority canHandle(VMSnapshot vmSnapshot) {
+ if (!VMSnapshot.State.Allocated.equals(vmSnapshot.getState())) {
+ List<VMSnapshotDetailsVO> vmSnapshotDetails =
vmSnapshotDetailsDao.findDetails(vmSnapshot.getId(),
KVM_FILE_BASED_STORAGE_SNAPSHOT);
+ if (CollectionUtils.isEmpty(vmSnapshotDetails)) {
+ logger.debug("KVM file based storage VM snapshot strategy
cannot handle [{}] as it is not a KVM file based storage VM snapshot.",
+ vmSnapshot.getUuid());
+ return StrategyPriority.CANT_HANDLE;
+ }
+ return StrategyPriority.HIGHEST;
+ }
+
+ long vmId = vmSnapshot.getVmId();
+ boolean memorySnapshot =
VMSnapshot.Type.DiskAndMemory.equals(vmSnapshot.getType());
+ return canHandle(vmId, null, memorySnapshot);
+ }
+
+ @Override
+ public StrategyPriority canHandle(Long vmId, Long rootPoolId, boolean
snapshotMemory) {
+ VirtualMachine vm = userVmDao.findById(vmId);
+
+ String cantHandleLog = String.format("KVM file based storage VM
snapshot strategy cannot handle VM snapshot for [%s]", vm);
+ if (snapshotMemory) {
+ logger.debug("{} as a snapshot with memory was requested.",
cantHandleLog);
+ return StrategyPriority.CANT_HANDLE;
+ }
+
+ if (!Hypervisor.HypervisorType.KVM.equals(vm.getHypervisorType())) {
+ logger.debug("{} as the hypervisor is not KVM.", cantHandleLog);
+ return StrategyPriority.CANT_HANDLE;
+ }
+
+ if (CollectionUtils.isNotEmpty(vmSnapshotDao.findByVmAndByType(vmId,
VMSnapshot.Type.DiskAndMemory))) {
+ logger.debug("{} as there is already a VM snapshot with disk and
memory.", cantHandleLog);
+ return StrategyPriority.CANT_HANDLE;
+ }
+
+ List<VolumeVO> volumes = volumeDao.findByInstance(vmId);
+ for (VolumeVO volume : volumes) {
+ StoragePoolVO storagePoolVO =
storagePool.findById(volume.getPoolId());
+ if
(!supportedStoragePoolTypes.contains(storagePoolVO.getPoolType())) {
+ logger.debug(String.format("%s as the VM has a volume that is
in a storage with unsupported type [%s].", cantHandleLog,
storagePoolVO.getPoolType()));
+ return StrategyPriority.CANT_HANDLE;
+ }
+ List<SnapshotVO> snapshots =
snapshotDao.listByVolumeIdAndTypeNotInAndStateNotRemoved(volume.getId(),
Snapshot.Type.GROUP);
+ if (CollectionUtils.isNotEmpty(snapshots)) {
+ logger.debug("{} as VM has a volume with snapshots {}. Volume
snapshots and KvmFileBasedStorageVmSnapshotStrategy are not compatible, as
restoring volume snapshots will erase VM " +
+ "snapshots and cause data loss.", cantHandleLog,
snapshots);
+ return StrategyPriority.CANT_HANDLE;
+ }
+ }
+
+ BackupOfferingVO backupOffering =
backupOfferingDao.findById(vm.getBackupOfferingId());
+ if (backupOffering != null) {
+ logger.debug("{} as the VM has a backup offering. This strategy
does not support snapshots on VMs with current backup providers.",
cantHandleLog);
+ return StrategyPriority.CANT_HANDLE;
+ }
+
+ return StrategyPriority.HIGHEST;
+ }
+
+ private List<SnapshotVO> deleteSnapshot(VMSnapshotVO vmSnapshotVO, Long
hostId) {
+ List<SnapshotDataStoreVO> volumeSnapshots =
getVolumeSnapshotsAssociatedWithVmSnapshot(vmSnapshotVO);
+ List<DataTO> volumeSnapshotTOList = volumeSnapshots.stream()
+ .map(snapshotDataStoreVO ->
snapshotDataFactory.getSnapshot(snapshotDataStoreVO.getSnapshotId(),
snapshotDataStoreVO.getDataStoreId(), DataStoreRole.Primary).getTO())
+ .collect(Collectors.toList());
+
+ DeleteDiskOnlyVmSnapshotCommand deleteSnapshotCommand = new
DeleteDiskOnlyVmSnapshotCommand(volumeSnapshotTOList);
+ Answer answer = agentMgr.easySend(hostId, deleteSnapshotCommand);
+ if (answer == null || !answer.getResult()) {
+ logger.error("Failed to delete VM snapshot [{}] due to {}.",
vmSnapshotVO.getUuid(), answer != null ? answer.getDetails() : "Communication
failure");
+ throw new CloudRuntimeException(String.format("Failed to delete VM
snapshot [%s].", vmSnapshotVO.getUuid()));
+ }
+
+ logger.debug("Updating metadata of VM snapshot [{}].",
vmSnapshotVO.getUuid());
+ List<SnapshotVO> snapshotVOList = new ArrayList<>();
+ for (SnapshotDataStoreVO snapshotDataStoreVO : volumeSnapshots) {
+ snapshotDataStoreDao.remove(snapshotDataStoreVO.getId());
+
snapshotVOList.add(snapshotDao.findById(snapshotDataStoreVO.getSnapshotId()));
+ }
+ return snapshotVOList;
+ }
+
+ private List<SnapshotVO> mergeSnapshots(VMSnapshotVO vmSnapshotVO,
VMSnapshotVO childSnapshot, UserVmVO userVm, List<VolumeObjectTO>
volumeObjectTOS, Long hostId) {
+ logger.debug("Merging VM snapshot [{}] with its child [{}].",
vmSnapshotVO.getUuid(), childSnapshot.getUuid());
+
+ List<VMSnapshotVO> snapshotGrandChildren =
vmSnapshotDao.listByParentAndStateIn(childSnapshot.getId(),
VMSnapshot.State.Ready, VMSnapshot.State.Hidden);
+
+ if (userVm.getState().equals(VirtualMachine.State.Running) &&
!snapshotGrandChildren.isEmpty()) {
Review Comment:
```suggestion
if (VirtualMachine.State.Running.equals(userVm.getState()) &&
!snapshotGrandChildren.isEmpty()) {
```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
