| // 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 com.cloud.vm.snapshot; | |
| import java.util.ArrayList; | |
| import java.util.Date; | |
| import java.util.HashMap; | |
| import java.util.List; | |
| import java.util.Map; | |
| import javax.ejb.Local; | |
| import javax.inject.Inject; | |
| import javax.naming.ConfigurationException; | |
| import org.apache.cloudstack.api.command.user.vmsnapshot.ListVMSnapshotCmd; | |
| import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreManager; | |
| import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao; | |
| import org.apache.cloudstack.storage.datastore.db.StoragePoolVO; | |
| import org.apache.log4j.Logger; | |
| import org.springframework.stereotype.Component; | |
| import com.cloud.agent.AgentManager; | |
| import com.cloud.agent.api.Answer; | |
| import com.cloud.agent.api.Command; | |
| import com.cloud.agent.api.CreateVMSnapshotAnswer; | |
| import com.cloud.agent.api.CreateVMSnapshotCommand; | |
| import com.cloud.agent.api.DeleteVMSnapshotAnswer; | |
| import com.cloud.agent.api.DeleteVMSnapshotCommand; | |
| import com.cloud.agent.api.RevertToVMSnapshotAnswer; | |
| import com.cloud.agent.api.RevertToVMSnapshotCommand; | |
| import com.cloud.agent.api.VMSnapshotTO; | |
| import com.cloud.agent.api.to.VolumeTO; | |
| import com.cloud.configuration.dao.ConfigurationDao; | |
| import com.cloud.event.ActionEvent; | |
| import com.cloud.event.EventTypes; | |
| import com.cloud.exception.AgentUnavailableException; | |
| import com.cloud.exception.ConcurrentOperationException; | |
| import com.cloud.exception.InsufficientCapacityException; | |
| import com.cloud.exception.InvalidParameterValueException; | |
| import com.cloud.exception.OperationTimedoutException; | |
| import com.cloud.exception.ResourceAllocationException; | |
| import com.cloud.exception.ResourceUnavailableException; | |
| import com.cloud.host.Host; | |
| import com.cloud.host.HostVO; | |
| import com.cloud.host.dao.HostDao; | |
| import com.cloud.hypervisor.Hypervisor.HypervisorType; | |
| import com.cloud.hypervisor.dao.HypervisorCapabilitiesDao; | |
| import com.cloud.hypervisor.HypervisorGuruManager; | |
| import com.cloud.projects.Project.ListProjectResourcesCriteria; | |
| import com.cloud.storage.GuestOSVO; | |
| import com.cloud.storage.Snapshot; | |
| import com.cloud.storage.SnapshotVO; | |
| import com.cloud.storage.StoragePool; | |
| import com.cloud.storage.VolumeVO; | |
| import com.cloud.storage.dao.GuestOSDao; | |
| import com.cloud.storage.dao.SnapshotDao; | |
| import com.cloud.storage.dao.VolumeDao; | |
| import com.cloud.user.Account; | |
| import com.cloud.user.AccountManager; | |
| import com.cloud.user.UserContext; | |
| import com.cloud.user.UserVO; | |
| import com.cloud.user.dao.AccountDao; | |
| import com.cloud.user.dao.UserDao; | |
| import com.cloud.uservm.UserVm; | |
| import com.cloud.utils.DateUtil; | |
| import com.cloud.utils.NumbersUtil; | |
| import com.cloud.utils.Ternary; | |
| import com.cloud.utils.component.ManagerBase; | |
| import com.cloud.utils.db.DB; | |
| import com.cloud.utils.db.Filter; | |
| import com.cloud.utils.db.SearchBuilder; | |
| import com.cloud.utils.db.SearchCriteria; | |
| import com.cloud.utils.db.Transaction; | |
| import com.cloud.utils.exception.CloudRuntimeException; | |
| import com.cloud.utils.fsm.NoTransitionException; | |
| import com.cloud.utils.fsm.StateMachine2; | |
| import com.cloud.vm.UserVmVO; | |
| import com.cloud.vm.VMInstanceVO; | |
| import com.cloud.vm.VirtualMachine; | |
| import com.cloud.vm.VirtualMachine.State; | |
| import com.cloud.vm.VirtualMachineManager; | |
| import com.cloud.vm.VirtualMachineProfile; | |
| import com.cloud.vm.dao.UserVmDao; | |
| import com.cloud.vm.dao.VMInstanceDao; | |
| import com.cloud.vm.snapshot.dao.VMSnapshotDao; | |
| @Component | |
| @Local(value = { VMSnapshotManager.class, VMSnapshotService.class }) | |
| public class VMSnapshotManagerImpl extends ManagerBase implements VMSnapshotManager, VMSnapshotService { | |
| private static final Logger s_logger = Logger.getLogger(VMSnapshotManagerImpl.class); | |
| String _name; | |
| @Inject VMSnapshotDao _vmSnapshotDao; | |
| @Inject VolumeDao _volumeDao; | |
| @Inject AccountDao _accountDao; | |
| @Inject VMInstanceDao _vmInstanceDao; | |
| @Inject UserVmDao _userVMDao; | |
| @Inject HostDao _hostDao; | |
| @Inject UserDao _userDao; | |
| @Inject AgentManager _agentMgr; | |
| @Inject HypervisorGuruManager _hvGuruMgr; | |
| @Inject AccountManager _accountMgr; | |
| @Inject GuestOSDao _guestOSDao; | |
| @Inject PrimaryDataStoreDao _storagePoolDao; | |
| @Inject SnapshotDao _snapshotDao; | |
| @Inject VirtualMachineManager _itMgr; | |
| @Inject DataStoreManager dataStoreMgr; | |
| @Inject ConfigurationDao _configDao; | |
| @Inject HypervisorCapabilitiesDao _hypervisorCapabilitiesDao; | |
| int _vmSnapshotMax; | |
| int _wait; | |
| StateMachine2<VMSnapshot.State, VMSnapshot.Event, VMSnapshot> _vmSnapshottateMachine ; | |
| @Override | |
| public boolean configure(String name, Map<String, Object> params) throws ConfigurationException { | |
| _name = name; | |
| if (_configDao == null) { | |
| throw new ConfigurationException( | |
| "Unable to get the configuration dao."); | |
| } | |
| _vmSnapshotMax = NumbersUtil.parseInt(_configDao.getValue("vmsnapshot.max"), VMSNAPSHOTMAX); | |
| String value = _configDao.getValue("vmsnapshot.create.wait"); | |
| _wait = NumbersUtil.parseInt(value, 1800); | |
| _vmSnapshottateMachine = VMSnapshot.State.getStateMachine(); | |
| return true; | |
| } | |
| @Override | |
| public boolean start() { | |
| return true; | |
| } | |
| @Override | |
| public boolean stop() { | |
| return true; | |
| } | |
| @Override | |
| public List<VMSnapshotVO> listVMSnapshots(ListVMSnapshotCmd cmd) { | |
| Account caller = getCaller(); | |
| List<Long> permittedAccounts = new ArrayList<Long>(); | |
| boolean listAll = cmd.listAll(); | |
| Long id = cmd.getId(); | |
| Long vmId = cmd.getVmId(); | |
| String state = cmd.getState(); | |
| String keyword = cmd.getKeyword(); | |
| String name = cmd.getVmSnapshotName(); | |
| String accountName = cmd.getAccountName(); | |
| Ternary<Long, Boolean, ListProjectResourcesCriteria> domainIdRecursiveListProject = new Ternary<Long, Boolean, ListProjectResourcesCriteria>( | |
| cmd.getDomainId(), cmd.isRecursive(), null); | |
| _accountMgr.buildACLSearchParameters(caller, id, cmd.getAccountName(), cmd.getProjectId(), permittedAccounts, domainIdRecursiveListProject, listAll, | |
| false); | |
| Long domainId = domainIdRecursiveListProject.first(); | |
| Boolean isRecursive = domainIdRecursiveListProject.second(); | |
| ListProjectResourcesCriteria listProjectResourcesCriteria = domainIdRecursiveListProject.third(); | |
| Filter searchFilter = new Filter(VMSnapshotVO.class, "created", false, cmd.getStartIndex(), cmd.getPageSizeVal()); | |
| SearchBuilder<VMSnapshotVO> sb = _vmSnapshotDao.createSearchBuilder(); | |
| _accountMgr.buildACLSearchBuilder(sb, domainId, isRecursive, permittedAccounts, listProjectResourcesCriteria); | |
| sb.and("vm_id", sb.entity().getVmId(), SearchCriteria.Op.EQ); | |
| sb.and("domain_id", sb.entity().getDomainId(), SearchCriteria.Op.EQ); | |
| sb.and("status", sb.entity().getState(), SearchCriteria.Op.IN); | |
| sb.and("state", sb.entity().getState(), SearchCriteria.Op.EQ); | |
| sb.and("id", sb.entity().getId(), SearchCriteria.Op.EQ); | |
| sb.and("display_name", sb.entity().getDisplayName(), SearchCriteria.Op.EQ); | |
| sb.and("account_id", sb.entity().getAccountId(), SearchCriteria.Op.EQ); | |
| sb.done(); | |
| SearchCriteria<VMSnapshotVO> sc = sb.create(); | |
| _accountMgr.buildACLSearchCriteria(sc, domainId, isRecursive, permittedAccounts, listProjectResourcesCriteria); | |
| if (accountName != null && cmd.getDomainId() != null) { | |
| Account account = _accountMgr.getActiveAccountByName(accountName, cmd.getDomainId()); | |
| sc.setParameters("account_id", account.getId()); | |
| } | |
| if (vmId != null) { | |
| sc.setParameters("vm_id", vmId); | |
| } | |
| if (domainId != null) { | |
| sc.setParameters("domain_id", domainId); | |
| } | |
| if (state == null) { | |
| VMSnapshot.State[] status = { VMSnapshot.State.Ready, VMSnapshot.State.Creating, VMSnapshot.State.Allocated, | |
| VMSnapshot.State.Error, VMSnapshot.State.Expunging, VMSnapshot.State.Reverting }; | |
| sc.setParameters("status", (Object[]) status); | |
| } else { | |
| sc.setParameters("state", state); | |
| } | |
| if (name != null) { | |
| sc.setParameters("display_name", name); | |
| } | |
| if (keyword != null) { | |
| SearchCriteria<VMSnapshotVO> ssc = _vmSnapshotDao.createSearchCriteria(); | |
| ssc.addOr("name", SearchCriteria.Op.LIKE, "%" + keyword + "%"); | |
| ssc.addOr("display_name", SearchCriteria.Op.LIKE, "%" + keyword + "%"); | |
| ssc.addOr("description", SearchCriteria.Op.LIKE, "%" + keyword + "%"); | |
| sc.addAnd("name", SearchCriteria.Op.SC, ssc); | |
| } | |
| if (id != null) { | |
| sc.setParameters("id", id); | |
| } | |
| return _vmSnapshotDao.search(sc, searchFilter); | |
| } | |
| protected Account getCaller(){ | |
| return UserContext.current().getCaller(); | |
| } | |
| @Override | |
| public VMSnapshot allocVMSnapshot(Long vmId, String vsDisplayName, String vsDescription, Boolean snapshotMemory) | |
| throws ResourceAllocationException { | |
| Account caller = getCaller(); | |
| // check if VM exists | |
| UserVmVO userVmVo = _userVMDao.findById(vmId); | |
| if (userVmVo == null) { | |
| throw new InvalidParameterValueException("Creating VM snapshot failed due to VM:" + vmId + " is a system VM or does not exist"); | |
| } | |
| // check hypervisor capabilities | |
| if(!_hypervisorCapabilitiesDao.isVmSnapshotEnabled(userVmVo.getHypervisorType(), "default")) | |
| throw new InvalidParameterValueException("VM snapshot is not enabled for hypervisor type: " + userVmVo.getHypervisorType()); | |
| // parameter length check | |
| if(vsDisplayName != null && vsDisplayName.length()>255) | |
| throw new InvalidParameterValueException("Creating VM snapshot failed due to length of VM snapshot vsDisplayName should not exceed 255"); | |
| if(vsDescription != null && vsDescription.length()>255) | |
| throw new InvalidParameterValueException("Creating VM snapshot failed due to length of VM snapshot vsDescription should not exceed 255"); | |
| // VM snapshot display name must be unique for a VM | |
| String timeString = DateUtil.getDateDisplayString(DateUtil.GMT_TIMEZONE, new Date(), DateUtil.YYYYMMDD_FORMAT); | |
| String vmSnapshotName = userVmVo.getInstanceName() + "_VS_" + timeString; | |
| if (vsDisplayName == null) { | |
| vsDisplayName = vmSnapshotName; | |
| } | |
| if(_vmSnapshotDao.findByName(vmId,vsDisplayName) != null){ | |
| throw new InvalidParameterValueException("Creating VM snapshot failed due to VM snapshot with name" + vsDisplayName + " already exists"); | |
| } | |
| // check VM state | |
| if (userVmVo.getState() != VirtualMachine.State.Running && userVmVo.getState() != VirtualMachine.State.Stopped) { | |
| throw new InvalidParameterValueException("Creating vm snapshot failed due to VM:" + vmId + " is not in the running or Stopped state"); | |
| } | |
| if(snapshotMemory && userVmVo.getState() == VirtualMachine.State.Stopped){ | |
| throw new InvalidParameterValueException("Can not snapshot memory when VM is in stopped state"); | |
| } | |
| // for KVM, only allow snapshot with memory when VM is in running state | |
| if(userVmVo.getHypervisorType() == HypervisorType.KVM && userVmVo.getState() == State.Running && !snapshotMemory){ | |
| throw new InvalidParameterValueException("KVM VM does not allow to take a disk-only snapshot when VM is in running state"); | |
| } | |
| // check access | |
| _accountMgr.checkAccess(caller, null, true, userVmVo); | |
| // check max snapshot limit for per VM | |
| if (_vmSnapshotDao.findByVm(vmId).size() >= _vmSnapshotMax) { | |
| throw new CloudRuntimeException("Creating vm snapshot failed due to a VM can just have : " + _vmSnapshotMax | |
| + " VM snapshots. Please delete old ones"); | |
| } | |
| // check if there are active volume snapshots tasks | |
| List<VolumeVO> listVolumes = _volumeDao.findByInstance(vmId); | |
| for (VolumeVO volume : listVolumes) { | |
| List<SnapshotVO> activeSnapshots = _snapshotDao.listByInstanceId(volume.getInstanceId(), Snapshot.State.Creating, | |
| Snapshot.State.CreatedOnPrimary, Snapshot.State.BackingUp); | |
| if (activeSnapshots.size() > 0) { | |
| throw new CloudRuntimeException( | |
| "There is other active volume snapshot tasks on the instance to which the volume is attached, please try again later."); | |
| } | |
| } | |
| // check if there are other active VM snapshot tasks | |
| if (hasActiveVMSnapshotTasks(vmId)) { | |
| throw new CloudRuntimeException("There is other active vm snapshot tasks on the instance, please try again later"); | |
| } | |
| VMSnapshot.Type vmSnapshotType = VMSnapshot.Type.Disk; | |
| if(snapshotMemory && userVmVo.getState() == VirtualMachine.State.Running) | |
| vmSnapshotType = VMSnapshot.Type.DiskAndMemory; | |
| try { | |
| VMSnapshotVO vmSnapshotVo = new VMSnapshotVO(userVmVo.getAccountId(), userVmVo.getDomainId(), vmId, vsDescription, vmSnapshotName, | |
| vsDisplayName, userVmVo.getServiceOfferingId(), vmSnapshotType, null); | |
| VMSnapshot vmSnapshot = _vmSnapshotDao.persist(vmSnapshotVo); | |
| if (vmSnapshot == null) { | |
| throw new CloudRuntimeException("Failed to create snapshot for vm: " + vmId); | |
| } | |
| return vmSnapshot; | |
| } catch (Exception e) { | |
| String msg = e.getMessage(); | |
| s_logger.error("Create vm snapshot record failed for vm: " + vmId + " due to: " + msg); | |
| } | |
| return null; | |
| } | |
| @Override | |
| public String getName() { | |
| return _name; | |
| } | |
| @Override | |
| @ActionEvent(eventType = EventTypes.EVENT_VM_SNAPSHOT_CREATE, eventDescription = "creating VM snapshot", async = true) | |
| public VMSnapshot creatVMSnapshot(Long vmId, Long vmSnapshotId) { | |
| UserVmVO userVm = _userVMDao.findById(vmId); | |
| if (userVm == null) { | |
| throw new InvalidParameterValueException("Create vm to snapshot failed due to vm: " + vmId + " is not found"); | |
| } | |
| VMSnapshotVO vmSnapshot = _vmSnapshotDao.findById(vmSnapshotId); | |
| if(vmSnapshot == null){ | |
| throw new CloudRuntimeException("VM snapshot id: " + vmSnapshotId + " can not be found"); | |
| } | |
| Long hostId = pickRunningHost(vmId); | |
| try { | |
| vmSnapshotStateTransitTo(vmSnapshot, VMSnapshot.Event.CreateRequested); | |
| } catch (NoTransitionException e) { | |
| throw new CloudRuntimeException(e.getMessage()); | |
| } | |
| return createVmSnapshotInternal(userVm, vmSnapshot, hostId); | |
| } | |
| protected VMSnapshot createVmSnapshotInternal(UserVmVO userVm, VMSnapshotVO vmSnapshot, Long hostId) { | |
| try { | |
| CreateVMSnapshotAnswer answer = null; | |
| GuestOSVO guestOS = _guestOSDao.findById(userVm.getGuestOSId()); | |
| // prepare snapshotVolumeTos | |
| List<VolumeTO> volumeTOs = getVolumeTOList(userVm.getId()); | |
| // prepare target snapshotTO and its parent snapshot (current snapshot) | |
| VMSnapshotTO current = null; | |
| VMSnapshotVO currentSnapshot = _vmSnapshotDao.findCurrentSnapshotByVmId(userVm.getId()); | |
| if (currentSnapshot != null) | |
| current = getSnapshotWithParents(currentSnapshot); | |
| VMSnapshotTO target = new VMSnapshotTO(vmSnapshot.getId(), vmSnapshot.getName(), vmSnapshot.getType(), null, vmSnapshot.getDescription(), false, | |
| current); | |
| if (current == null) | |
| vmSnapshot.setParent(null); | |
| else | |
| vmSnapshot.setParent(current.getId()); | |
| CreateVMSnapshotCommand ccmd = new CreateVMSnapshotCommand(userVm.getInstanceName(),target ,volumeTOs, guestOS.getDisplayName(),userVm.getState()); | |
| ccmd.setWait(_wait); | |
| answer = (CreateVMSnapshotAnswer) sendToPool(hostId, ccmd); | |
| if (answer != null && answer.getResult()) { | |
| processAnswer(vmSnapshot, userVm, answer, hostId); | |
| s_logger.debug("Create vm snapshot " + vmSnapshot.getName() + " succeeded for vm: " + userVm.getInstanceName()); | |
| }else{ | |
| String errMsg = "Creating VM snapshot: " + vmSnapshot.getName() + " failed"; | |
| if(answer != null && answer.getDetails() != null) | |
| errMsg = errMsg + " due to " + answer.getDetails(); | |
| s_logger.error(errMsg); | |
| vmSnapshotStateTransitTo(vmSnapshot, VMSnapshot.Event.OperationFailed); | |
| throw new CloudRuntimeException(errMsg); | |
| } | |
| return vmSnapshot; | |
| } catch (Exception e) { | |
| if(e instanceof AgentUnavailableException){ | |
| try { | |
| vmSnapshotStateTransitTo(vmSnapshot, VMSnapshot.Event.OperationFailed); | |
| } catch (NoTransitionException e1) { | |
| s_logger.error("Cannot set vm snapshot state due to: " + e1.getMessage()); | |
| } | |
| } | |
| String msg = e.getMessage(); | |
| s_logger.error("Create vm snapshot " + vmSnapshot.getName() + " failed for vm: " + userVm.getInstanceName() + " due to " + msg); | |
| throw new CloudRuntimeException(msg); | |
| } finally{ | |
| if(vmSnapshot.getState() == VMSnapshot.State.Allocated){ | |
| s_logger.warn("Create vm snapshot " + vmSnapshot.getName() + " failed for vm: " + userVm.getInstanceName()); | |
| _vmSnapshotDao.remove(vmSnapshot.getId()); | |
| } | |
| } | |
| } | |
| protected List<VolumeTO> getVolumeTOList(Long vmId) { | |
| List<VolumeTO> volumeTOs = new ArrayList<VolumeTO>(); | |
| List<VolumeVO> volumeVos = _volumeDao.findByInstance(vmId); | |
| for (VolumeVO volume : volumeVos) { | |
| StoragePool pool = (StoragePool)this.dataStoreMgr.getPrimaryDataStore(volume.getPoolId()); | |
| VolumeTO volumeTO = new VolumeTO(volume, pool); | |
| volumeTOs.add(volumeTO); | |
| } | |
| return volumeTOs; | |
| } | |
| // get snapshot and its parents recursively | |
| private VMSnapshotTO getSnapshotWithParents(VMSnapshotVO snapshot) { | |
| Map<Long, VMSnapshotVO> snapshotMap = new HashMap<Long, VMSnapshotVO>(); | |
| List<VMSnapshotVO> allSnapshots = _vmSnapshotDao.findByVm(snapshot.getVmId()); | |
| for (VMSnapshotVO vmSnapshotVO : allSnapshots) { | |
| snapshotMap.put(vmSnapshotVO.getId(), vmSnapshotVO); | |
| } | |
| VMSnapshotTO currentTO = convert2VMSnapshotTO(snapshot); | |
| VMSnapshotTO result = currentTO; | |
| VMSnapshotVO current = snapshot; | |
| while (current.getParent() != null) { | |
| VMSnapshotVO parent = snapshotMap.get(current.getParent()); | |
| currentTO.setParent(convert2VMSnapshotTO(parent)); | |
| current = snapshotMap.get(current.getParent()); | |
| currentTO = currentTO.getParent(); | |
| } | |
| return result; | |
| } | |
| private VMSnapshotTO convert2VMSnapshotTO(VMSnapshotVO vo) { | |
| return new VMSnapshotTO(vo.getId(), vo.getName(), vo.getType(), vo.getCreated().getTime(), vo.getDescription(), | |
| vo.getCurrent(), null); | |
| } | |
| protected boolean vmSnapshotStateTransitTo(VMSnapshotVO vsnp, VMSnapshot.Event event) throws NoTransitionException { | |
| return _vmSnapshottateMachine.transitTo(vsnp, event, null, _vmSnapshotDao); | |
| } | |
| @DB | |
| protected void processAnswer(VMSnapshotVO vmSnapshot, UserVmVO userVm, Answer as, Long hostId) { | |
| final Transaction txn = Transaction.currentTxn(); | |
| try { | |
| txn.start(); | |
| if (as instanceof CreateVMSnapshotAnswer) { | |
| CreateVMSnapshotAnswer answer = (CreateVMSnapshotAnswer) as; | |
| finalizeCreate(vmSnapshot, answer.getVolumeTOs()); | |
| vmSnapshotStateTransitTo(vmSnapshot, VMSnapshot.Event.OperationSucceeded); | |
| } else if (as instanceof RevertToVMSnapshotAnswer) { | |
| RevertToVMSnapshotAnswer answer = (RevertToVMSnapshotAnswer) as; | |
| finalizeRevert(vmSnapshot, answer.getVolumeTOs()); | |
| vmSnapshotStateTransitTo(vmSnapshot, VMSnapshot.Event.OperationSucceeded); | |
| } else if (as instanceof DeleteVMSnapshotAnswer) { | |
| DeleteVMSnapshotAnswer answer = (DeleteVMSnapshotAnswer) as; | |
| finalizeDelete(vmSnapshot, answer.getVolumeTOs()); | |
| _vmSnapshotDao.remove(vmSnapshot.getId()); | |
| } | |
| txn.commit(); | |
| } catch (Exception e) { | |
| String errMsg = "Error while process answer: " + as.getClass() + " due to " + e.getMessage(); | |
| s_logger.error(errMsg, e); | |
| txn.rollback(); | |
| throw new CloudRuntimeException(errMsg); | |
| } finally { | |
| txn.close(); | |
| } | |
| } | |
| protected void finalizeDelete(VMSnapshotVO vmSnapshot, List<VolumeTO> VolumeTOs) { | |
| // update volumes path | |
| updateVolumePath(VolumeTOs); | |
| // update children's parent snapshots | |
| List<VMSnapshotVO> children= _vmSnapshotDao.listByParent(vmSnapshot.getId()); | |
| for (VMSnapshotVO child : children) { | |
| child.setParent(vmSnapshot.getParent()); | |
| _vmSnapshotDao.persist(child); | |
| } | |
| // update current snapshot | |
| VMSnapshotVO current = _vmSnapshotDao.findCurrentSnapshotByVmId(vmSnapshot.getVmId()); | |
| if(current != null && current.getId() == vmSnapshot.getId() && vmSnapshot.getParent() != null){ | |
| VMSnapshotVO parent = _vmSnapshotDao.findById(vmSnapshot.getParent()); | |
| parent.setCurrent(true); | |
| _vmSnapshotDao.persist(parent); | |
| } | |
| vmSnapshot.setCurrent(false); | |
| _vmSnapshotDao.persist(vmSnapshot); | |
| } | |
| protected void finalizeCreate(VMSnapshotVO vmSnapshot, List<VolumeTO> VolumeTOs) { | |
| // update volumes path | |
| updateVolumePath(VolumeTOs); | |
| vmSnapshot.setCurrent(true); | |
| // change current snapshot | |
| if (vmSnapshot.getParent() != null) { | |
| VMSnapshotVO previousCurrent = _vmSnapshotDao.findById(vmSnapshot.getParent()); | |
| previousCurrent.setCurrent(false); | |
| _vmSnapshotDao.persist(previousCurrent); | |
| } | |
| _vmSnapshotDao.persist(vmSnapshot); | |
| } | |
| protected void finalizeRevert(VMSnapshotVO vmSnapshot, List<VolumeTO> volumeToList) { | |
| // update volumes path | |
| updateVolumePath(volumeToList); | |
| // update current snapshot, current snapshot is the one reverted to | |
| VMSnapshotVO previousCurrent = _vmSnapshotDao.findCurrentSnapshotByVmId(vmSnapshot.getVmId()); | |
| if(previousCurrent != null){ | |
| previousCurrent.setCurrent(false); | |
| _vmSnapshotDao.persist(previousCurrent); | |
| } | |
| vmSnapshot.setCurrent(true); | |
| _vmSnapshotDao.persist(vmSnapshot); | |
| } | |
| private void updateVolumePath(List<VolumeTO> volumeTOs) { | |
| for (VolumeTO volume : volumeTOs) { | |
| if (volume.getPath() != null) { | |
| VolumeVO volumeVO = _volumeDao.findById(volume.getId()); | |
| volumeVO.setPath(volume.getPath()); | |
| _volumeDao.persist(volumeVO); | |
| } | |
| } | |
| } | |
| public VMSnapshotManagerImpl() { | |
| } | |
| protected Answer sendToPool(Long hostId, Command cmd) throws AgentUnavailableException, OperationTimedoutException { | |
| long targetHostId = _hvGuruMgr.getGuruProcessedCommandTargetHost(hostId, cmd); | |
| Answer answer = _agentMgr.send(targetHostId, cmd); | |
| return answer; | |
| } | |
| @Override | |
| public boolean hasActiveVMSnapshotTasks(Long vmId){ | |
| List<VMSnapshotVO> activeVMSnapshots = _vmSnapshotDao.listByInstanceId(vmId, | |
| VMSnapshot.State.Creating, VMSnapshot.State.Expunging,VMSnapshot.State.Reverting,VMSnapshot.State.Allocated); | |
| return activeVMSnapshots.size() > 0; | |
| } | |
| @Override | |
| @ActionEvent(eventType = EventTypes.EVENT_VM_SNAPSHOT_DELETE, eventDescription = "delete vm snapshots", async=true) | |
| public boolean deleteVMSnapshot(Long vmSnapshotId) { | |
| Account caller = getCaller(); | |
| VMSnapshotVO vmSnapshot = _vmSnapshotDao.findById(vmSnapshotId); | |
| if (vmSnapshot == null) { | |
| throw new InvalidParameterValueException("unable to find the vm snapshot with id " + vmSnapshotId); | |
| } | |
| _accountMgr.checkAccess(caller, null, true, vmSnapshot); | |
| // check VM snapshot states, only allow to delete vm snapshots in created and error state | |
| if (VMSnapshot.State.Ready != vmSnapshot.getState() && VMSnapshot.State.Expunging != vmSnapshot.getState() && VMSnapshot.State.Error != vmSnapshot.getState()) { | |
| throw new InvalidParameterValueException("Can't delete the vm snapshotshot " + vmSnapshotId + " due to it is not in Created or Error, or Expunging State"); | |
| } | |
| // check if there are other active VM snapshot tasks | |
| if (hasActiveVMSnapshotTasks(vmSnapshot.getVmId())) { | |
| List<VMSnapshotVO> expungingSnapshots = _vmSnapshotDao.listByInstanceId(vmSnapshot.getVmId(), VMSnapshot.State.Expunging); | |
| if(expungingSnapshots.size() > 0 && expungingSnapshots.get(0).getId() == vmSnapshot.getId()) | |
| s_logger.debug("Target VM snapshot already in expunging state, go on deleting it: " + vmSnapshot.getDisplayName()); | |
| else | |
| throw new InvalidParameterValueException("There is other active vm snapshot tasks on the instance, please try again later"); | |
| } | |
| if(vmSnapshot.getState() == VMSnapshot.State.Allocated){ | |
| return _vmSnapshotDao.remove(vmSnapshot.getId()); | |
| }else{ | |
| return deleteSnapshotInternal(vmSnapshot); | |
| } | |
| } | |
| @DB | |
| protected boolean deleteSnapshotInternal(VMSnapshotVO vmSnapshot) { | |
| UserVmVO userVm = _userVMDao.findById(vmSnapshot.getVmId()); | |
| try { | |
| vmSnapshotStateTransitTo(vmSnapshot,VMSnapshot.Event.ExpungeRequested); | |
| Long hostId = pickRunningHost(vmSnapshot.getVmId()); | |
| // prepare snapshotVolumeTos | |
| List<VolumeTO> volumeTOs = getVolumeTOList(vmSnapshot.getVmId()); | |
| // prepare DeleteVMSnapshotCommand | |
| String vmInstanceName = userVm.getInstanceName(); | |
| VMSnapshotTO parent = getSnapshotWithParents(vmSnapshot).getParent(); | |
| VMSnapshotTO vmSnapshotTO = new VMSnapshotTO(vmSnapshot.getId(), vmSnapshot.getName(), vmSnapshot.getType(), | |
| vmSnapshot.getCreated().getTime(), vmSnapshot.getDescription(), vmSnapshot.getCurrent(), parent); | |
| GuestOSVO guestOS = _guestOSDao.findById(userVm.getGuestOSId()); | |
| DeleteVMSnapshotCommand deleteSnapshotCommand = new DeleteVMSnapshotCommand(vmInstanceName, vmSnapshotTO, volumeTOs,guestOS.getDisplayName()); | |
| DeleteVMSnapshotAnswer answer = (DeleteVMSnapshotAnswer) sendToPool(hostId, deleteSnapshotCommand); | |
| if (answer != null && answer.getResult()) { | |
| processAnswer(vmSnapshot, userVm, answer, hostId); | |
| s_logger.debug("Delete VM snapshot " + vmSnapshot.getName() + " succeeded for vm: " + userVm.getInstanceName()); | |
| return true; | |
| } else { | |
| s_logger.error("Delete vm snapshot " + vmSnapshot.getName() + " of vm " + userVm.getInstanceName() + " failed due to " + answer.getDetails()); | |
| return false; | |
| } | |
| } catch (Exception e) { | |
| String msg = "Delete vm snapshot " + vmSnapshot.getName() + " of vm " + userVm.getInstanceName() + " failed due to " + e.getMessage(); | |
| s_logger.error(msg , e); | |
| throw new CloudRuntimeException(e.getMessage()); | |
| } | |
| } | |
| @Override | |
| @ActionEvent(eventType = EventTypes.EVENT_VM_SNAPSHOT_REVERT, eventDescription = "revert to VM snapshot", async = true) | |
| public UserVm revertToSnapshot(Long vmSnapshotId) throws InsufficientCapacityException, ResourceUnavailableException, ConcurrentOperationException { | |
| // check if VM snapshot exists in DB | |
| VMSnapshotVO vmSnapshotVo = _vmSnapshotDao.findById(vmSnapshotId); | |
| if (vmSnapshotVo == null) { | |
| throw new InvalidParameterValueException( | |
| "unable to find the vm snapshot with id " + vmSnapshotId); | |
| } | |
| Long vmId = vmSnapshotVo.getVmId(); | |
| UserVmVO userVm = _userVMDao.findById(vmId); | |
| // check if VM exists | |
| if (userVm == null) { | |
| throw new InvalidParameterValueException("Revert vm to snapshot: " | |
| + vmSnapshotId + " failed due to vm: " + vmId | |
| + " is not found"); | |
| } | |
| // check if there are other active VM snapshot tasks | |
| if (hasActiveVMSnapshotTasks(vmId)) { | |
| throw new InvalidParameterValueException("There is other active vm snapshot tasks on the instance, please try again later"); | |
| } | |
| Account caller = getCaller(); | |
| _accountMgr.checkAccess(caller, null, true, vmSnapshotVo); | |
| // VM should be in running or stopped states | |
| if (userVm.getState() != VirtualMachine.State.Running | |
| && userVm.getState() != VirtualMachine.State.Stopped) { | |
| throw new InvalidParameterValueException( | |
| "VM Snapshot reverting failed due to vm is not in the state of Running or Stopped."); | |
| } | |
| // if snapshot is not created, error out | |
| if (vmSnapshotVo.getState() != VMSnapshot.State.Ready) { | |
| throw new InvalidParameterValueException( | |
| "VM Snapshot reverting failed due to vm snapshot is not in the state of Created."); | |
| } | |
| UserVO callerUser = _userDao.findById(UserContext.current().getCallerUserId()); | |
| UserVmVO vm = null; | |
| Long hostId = null; | |
| Account owner = _accountDao.findById(vmSnapshotVo.getAccountId()); | |
| // start or stop VM first, if revert from stopped state to running state, or from running to stopped | |
| if(userVm.getState() == VirtualMachine.State.Stopped && vmSnapshotVo.getType() == VMSnapshot.Type.DiskAndMemory){ | |
| try { | |
| vm = _itMgr.advanceStart(userVm, new HashMap<VirtualMachineProfile.Param, Object>(), callerUser, owner); | |
| hostId = vm.getHostId(); | |
| } catch (Exception e) { | |
| s_logger.error("Start VM " + userVm.getInstanceName() + " before reverting failed due to " + e.getMessage()); | |
| throw new CloudRuntimeException(e.getMessage()); | |
| } | |
| }else { | |
| if(userVm.getState() == VirtualMachine.State.Running && vmSnapshotVo.getType() == VMSnapshot.Type.Disk){ | |
| try { | |
| _itMgr.advanceStop(userVm, true, callerUser, owner); | |
| } catch (Exception e) { | |
| s_logger.error("Stop VM " + userVm.getInstanceName() + " before reverting failed due to " + e.getMessage()); | |
| throw new CloudRuntimeException(e.getMessage()); | |
| } | |
| } | |
| hostId = pickRunningHost(userVm.getId()); | |
| } | |
| if(hostId == null) | |
| throw new CloudRuntimeException("Can not find any host to revert snapshot " + vmSnapshotVo.getName()); | |
| // check if there are other active VM snapshot tasks | |
| if (hasActiveVMSnapshotTasks(userVm.getId())) { | |
| throw new InvalidParameterValueException("There is other active vm snapshot tasks on the instance, please try again later"); | |
| } | |
| userVm = _userVMDao.findById(userVm.getId()); | |
| try { | |
| vmSnapshotStateTransitTo(vmSnapshotVo, VMSnapshot.Event.RevertRequested); | |
| } catch (NoTransitionException e) { | |
| throw new CloudRuntimeException(e.getMessage()); | |
| } | |
| return revertInternal(userVm, vmSnapshotVo, hostId); | |
| } | |
| private UserVm revertInternal(UserVmVO userVm, VMSnapshotVO vmSnapshotVo, Long hostId) { | |
| try { | |
| VMSnapshotVO snapshot = _vmSnapshotDao.findById(vmSnapshotVo.getId()); | |
| // prepare RevertToSnapshotCommand | |
| List<VolumeTO> volumeTOs = getVolumeTOList(userVm.getId()); | |
| String vmInstanceName = userVm.getInstanceName(); | |
| VMSnapshotTO parent = getSnapshotWithParents(snapshot).getParent(); | |
| VMSnapshotTO vmSnapshotTO = new VMSnapshotTO(snapshot.getId(), snapshot.getName(), snapshot.getType(), | |
| snapshot.getCreated().getTime(), snapshot.getDescription(), snapshot.getCurrent(), parent); | |
| GuestOSVO guestOS = _guestOSDao.findById(userVm.getGuestOSId()); | |
| RevertToVMSnapshotCommand revertToSnapshotCommand = new RevertToVMSnapshotCommand(vmInstanceName, vmSnapshotTO, volumeTOs, guestOS.getDisplayName()); | |
| RevertToVMSnapshotAnswer answer = (RevertToVMSnapshotAnswer) sendToPool(hostId, revertToSnapshotCommand); | |
| if (answer != null && answer.getResult()) { | |
| processAnswer(vmSnapshotVo, userVm, answer, hostId); | |
| s_logger.debug("RevertTo " + vmSnapshotVo.getName() + " succeeded for vm: " + userVm.getInstanceName()); | |
| } else { | |
| String errMsg = "Revert VM: " + userVm.getInstanceName() + " to snapshot: "+ vmSnapshotVo.getName() + " failed"; | |
| if(answer != null && answer.getDetails() != null) | |
| errMsg = errMsg + " due to " + answer.getDetails(); | |
| s_logger.error(errMsg); | |
| // agent report revert operation fails | |
| vmSnapshotStateTransitTo(vmSnapshotVo, VMSnapshot.Event.OperationFailed); | |
| throw new CloudRuntimeException(errMsg); | |
| } | |
| } catch (Exception e) { | |
| if(e instanceof AgentUnavailableException){ | |
| try { | |
| vmSnapshotStateTransitTo(vmSnapshotVo, VMSnapshot.Event.OperationFailed); | |
| } catch (NoTransitionException e1) { | |
| s_logger.error("Cannot set vm snapshot state due to: " + e1.getMessage()); | |
| } | |
| } | |
| // for other exceptions, do not change VM snapshot state, leave it for snapshotSync | |
| String errMsg = "revert vm: " + userVm.getInstanceName() + " to snapshot " + vmSnapshotVo.getName() + " failed due to " + e.getMessage(); | |
| s_logger.error(errMsg); | |
| throw new CloudRuntimeException(e.getMessage()); | |
| } | |
| return userVm; | |
| } | |
| @Override | |
| public VMSnapshot getVMSnapshotById(Long id) { | |
| VMSnapshotVO vmSnapshot = _vmSnapshotDao.findById(id); | |
| return vmSnapshot; | |
| } | |
| protected Long pickRunningHost(Long vmId) { | |
| UserVmVO vm = _userVMDao.findById(vmId); | |
| // use VM's host if VM is running | |
| if(vm.getState() == State.Running) | |
| return vm.getHostId(); | |
| // check if lastHostId is available | |
| if(vm.getLastHostId() != null){ | |
| HostVO lastHost = _hostDao.findById(vm.getLastHostId()); | |
| if(lastHost.getStatus() == com.cloud.host.Status.Up && !lastHost.isInMaintenanceStates()) | |
| return lastHost.getId(); | |
| } | |
| List<VolumeVO> listVolumes = _volumeDao.findByInstance(vmId); | |
| if (listVolumes == null || listVolumes.size() == 0) { | |
| throw new InvalidParameterValueException("vmInstance has no volumes"); | |
| } | |
| VolumeVO volume = listVolumes.get(0); | |
| Long poolId = volume.getPoolId(); | |
| if (poolId == null) { | |
| throw new InvalidParameterValueException("pool id is not found"); | |
| } | |
| StoragePoolVO storagePool = _storagePoolDao.findById(poolId); | |
| if (storagePool == null) { | |
| throw new InvalidParameterValueException("storage pool is not found"); | |
| } | |
| List<HostVO> listHost = _hostDao.listAllUpAndEnabledNonHAHosts(Host.Type.Routing, storagePool.getClusterId(), storagePool.getPodId(), | |
| storagePool.getDataCenterId(), null); | |
| if (listHost == null || listHost.size() == 0) { | |
| throw new InvalidParameterValueException("no host in up state is found"); | |
| } | |
| return listHost.get(0).getId(); | |
| } | |
| @Override | |
| public VirtualMachine getVMBySnapshotId(Long id) { | |
| VMSnapshotVO vmSnapshot = _vmSnapshotDao.findById(id); | |
| if(vmSnapshot == null){ | |
| throw new InvalidParameterValueException("unable to find the vm snapshot with id " + id); | |
| } | |
| Long vmId = vmSnapshot.getVmId(); | |
| UserVmVO vm = _userVMDao.findById(vmId); | |
| return vm; | |
| } | |
| @Override | |
| public boolean deleteAllVMSnapshots(long vmId, VMSnapshot.Type type) { | |
| boolean result = true; | |
| List<VMSnapshotVO> listVmSnapshots = _vmSnapshotDao.findByVm(vmId); | |
| if (listVmSnapshots == null || listVmSnapshots.isEmpty()) { | |
| return true; | |
| } | |
| for (VMSnapshotVO snapshot : listVmSnapshots) { | |
| VMSnapshotVO target = _vmSnapshotDao.findById(snapshot.getId()); | |
| if(type != null && target.getType() != type) | |
| continue; | |
| if (!deleteSnapshotInternal(target)) { | |
| result = false; | |
| break; | |
| } | |
| } | |
| return result; | |
| } | |
| @Override | |
| public boolean syncVMSnapshot(VMInstanceVO vm, Long hostId) { | |
| try{ | |
| UserVmVO userVm = _userVMDao.findById(vm.getId()); | |
| if(userVm == null) | |
| return false; | |
| List<VMSnapshotVO> vmSnapshotsInExpungingStates = _vmSnapshotDao.listByInstanceId(vm.getId(), VMSnapshot.State.Expunging, VMSnapshot.State.Reverting, VMSnapshot.State.Creating); | |
| for (VMSnapshotVO vmSnapshotVO : vmSnapshotsInExpungingStates) { | |
| if(vmSnapshotVO.getState() == VMSnapshot.State.Expunging){ | |
| return deleteSnapshotInternal(vmSnapshotVO); | |
| }else if(vmSnapshotVO.getState() == VMSnapshot.State.Creating){ | |
| return createVmSnapshotInternal(userVm, vmSnapshotVO, hostId) != null; | |
| }else if(vmSnapshotVO.getState() == VMSnapshot.State.Reverting){ | |
| return revertInternal(userVm, vmSnapshotVO, hostId) != null; | |
| } | |
| } | |
| }catch (Exception e) { | |
| s_logger.error(e.getMessage(),e); | |
| if(_vmSnapshotDao.listByInstanceId(vm.getId(), VMSnapshot.State.Expunging).size() == 0) | |
| return true; | |
| else | |
| return false; | |
| } | |
| return false; | |
| } | |
| } |