etan39
/
cloudstack
mirror of https://github.com/apache/cloudstack.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fix compile

This commit is contained in:
Edison Su 2013-10-14 18:05:06 -07:00
parent 5552a575d8
commit 77fca0c953
12 changed files with 209 additions and 334 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
client/tomcatconf/applicationContext.xml.in
View File

@ -882,8 +882,17 @@
<bean id="ApplicationLoadBalancerService" class="org.apache.cloudstack.network.lb.ApplicationLoadBalancerManagerImpl" />
<bean id="InternalLoadBalancerVMManager" class="org.apache.cloudstack.network.lb.InternalLoadBalancerVMManagerImpl" />
<bean id="vMSnapshotManagerImpl" class="com.cloud.vm.snapshot.VMSnapshotManagerImpl" />
<!--VM snapshot Strategies-->
<bean id='vmSnapshotHelper' class="org.apache.cloudstack.storage.vmsnapshot.VMSnapshotHelperImpl" />
<bean id='defaultVMSnapshotStrategy' class="org.apache.cloudstack.storage.vmsnapshot.DefaultVMSnapshotStrategy"/>
<bean id="vMSnapshotManagerImpl" class="com.cloud.vm.snapshot.VMSnapshotManagerImpl">
<property name="vmSnapshotStrategies">
<list>
<ref local="defaultVMSnapshotStrategy"/>
</list>
</property>
</bean>
<!--=======================================================================================================-->
<!-- -->

12
core/src/com/cloud/agent/api/CreateVMSnapshotAnswer.java
View File

@ -17,21 +17,21 @@
package com.cloud.agent.api;
import java.util.List;
import org.apache.cloudstack.storage.to.VolumeObjectTO;
import com.cloud.agent.api.to.VolumeTO;
import java.util.List;
public class CreateVMSnapshotAnswer extends Answer {
private List<VolumeTO> volumeTOs;
private List<VolumeObjectTO> volumeTOs;
private VMSnapshotTO vmSnapshotTo;
public List<VolumeTO> getVolumeTOs() {
public List<VolumeObjectTO> getVolumeTOs() {
return volumeTOs;
}
public void setVolumeTOs(List<VolumeTO> volumeTOs) {
public void setVolumeTOs(List<VolumeObjectTO> volumeTOs) {
this.volumeTOs = volumeTOs;
}
@ -53,7 +53,7 @@ public class CreateVMSnapshotAnswer extends Answer {
}
public CreateVMSnapshotAnswer(CreateVMSnapshotCommand cmd,
VMSnapshotTO vmSnapshotTo, List<VolumeTO> volumeTOs) {
VMSnapshotTO vmSnapshotTo, List<VolumeObjectTO> volumeTOs) {
super(cmd, true, "");
this.vmSnapshotTo = vmSnapshotTo;
this.volumeTOs = volumeTOs;

12
core/src/com/cloud/agent/api/DeleteVMSnapshotAnswer.java
View File

@ -16,12 +16,12 @@
// under the License.
package com.cloud.agent.api;
import org.apache.cloudstack.storage.to.VolumeObjectTO;
import java.util.List;
import com.cloud.agent.api.to.VolumeTO;
public class DeleteVMSnapshotAnswer extends Answer {
private List<VolumeTO> volumeTOs;
private List<VolumeObjectTO> volumeTOs;
public DeleteVMSnapshotAnswer() {
}
@ -32,16 +32,16 @@ public class DeleteVMSnapshotAnswer extends Answer {
}
public DeleteVMSnapshotAnswer(DeleteVMSnapshotCommand cmd,
List<VolumeTO> volumeTOs) {
List<VolumeObjectTO> volumeTOs) {
super(cmd, true, "");
this.volumeTOs = volumeTOs;
}
public List<VolumeTO> getVolumeTOs() {
public List<VolumeObjectTO> getVolumeTOs() {
return volumeTOs;
}
public void setVolumeTOs(List<VolumeTO> volumeTOs) {
public void setVolumeTOs(List<VolumeObjectTO> volumeTOs) {
this.volumeTOs = volumeTOs;
}

14
core/src/com/cloud/agent/api/RevertToVMSnapshotAnswer.java
View File

@ -17,14 +17,14 @@
package com.cloud.agent.api;
import java.util.List;
import com.cloud.agent.api.to.VolumeTO;
import com.cloud.vm.VirtualMachine;
import org.apache.cloudstack.storage.to.VolumeObjectTO;
import java.util.List;
public class RevertToVMSnapshotAnswer extends Answer {
private List<VolumeTO> volumeTOs;
private List<VolumeObjectTO> volumeTOs;
private VirtualMachine.State vmState;
public RevertToVMSnapshotAnswer(RevertToVMSnapshotCommand cmd, boolean result,
@ -37,7 +37,7 @@ public class RevertToVMSnapshotAnswer extends Answer {
}
public RevertToVMSnapshotAnswer(RevertToVMSnapshotCommand cmd,
List<VolumeTO> volumeTOs,
List<VolumeObjectTO> volumeTOs,
VirtualMachine.State vmState) {
super(cmd, true, "");
this.volumeTOs = volumeTOs;
@ -48,11 +48,11 @@ public class RevertToVMSnapshotAnswer extends Answer {
return vmState;
}
public List<VolumeTO> getVolumeTOs() {
public List<VolumeObjectTO> getVolumeTOs() {
return volumeTOs;
}
public void setVolumeTOs(List<VolumeTO> volumeTOs) {
public void setVolumeTOs(List<VolumeObjectTO> volumeTOs) {
this.volumeTOs = volumeTOs;
}

3
core/src/com/cloud/agent/api/RevertToVMSnapshotCommand.java
View File

@ -19,10 +19,11 @@ package com.cloud.agent.api;
import java.util.List;
import com.cloud.agent.api.to.VolumeTO;
import org.apache.cloudstack.storage.to.VolumeObjectTO;
public class RevertToVMSnapshotCommand extends VMSnapshotBaseCommand {
public RevertToVMSnapshotCommand(String vmName, VMSnapshotTO snapshot, List<VolumeTO> volumeTOs, String guestOSType) {
public RevertToVMSnapshotCommand(String vmName, VMSnapshotTO snapshot, List<VolumeObjectTO> volumeTOs, String guestOSType) {
super(vmName, snapshot, volumeTOs, guestOSType);
}

12
core/src/org/apache/cloudstack/storage/to/VolumeObjectTO.java
View File

@ -38,6 +38,8 @@ public class VolumeObjectTO implements DataTO {
private String chainInfo;
private Storage.ImageFormat format;
private long id;
private Long deviceId;
private Long bytesReadRate;
private Long bytesWriteRate;
private Long iopsReadRate;
@ -70,6 +72,7 @@ public class VolumeObjectTO implements DataTO {
this.iopsReadRate = volume.getIopsReadRate();
this.iopsWriteRate = volume.getIopsWriteRate();
this.hypervisorType = volume.getHypervisorType();
setDeviceId(volume.getDeviceId());
}
public String getUuid() {
@ -220,4 +223,13 @@ public class VolumeObjectTO implements DataTO {
return iopsWriteRate;
}
public Long getDeviceId() {
return deviceId;
}
public void setDeviceId(Long deviceId) {
this.deviceId = deviceId;
}
}

150
engine/storage/snapshot/src/org/apache/cloudstack/storage/vmsnapshot/DefaultVMSnapshotStrategy.java
View File

@ -27,18 +27,16 @@ 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.DataTO;
import com.cloud.agent.api.to.VolumeTO;
import com.cloud.event.EventTypes;
import com.cloud.event.UsageEventUtils;
import com.cloud.exception.AgentUnavailableException;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.host.Host;
import com.cloud.host.HostVO;
import com.cloud.exception.OperationTimedoutException;
import com.cloud.storage.DiskOfferingVO;
import com.cloud.storage.GuestOSVO;
import com.cloud.storage.VolumeVO;
import com.cloud.storage.dao.DiskOfferingDao;
import com.cloud.storage.dao.GuestOSDao;
import com.cloud.storage.dao.VolumeDao;
import com.cloud.uservm.UserVm;
import com.cloud.utils.NumbersUtil;
import com.cloud.utils.component.ManagerBase;
@ -47,14 +45,12 @@ import com.cloud.utils.db.Transaction;
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.dao.UserVmDao;
import com.cloud.vm.snapshot.VMSnapshot;
import com.cloud.vm.snapshot.VMSnapshotVO;
import com.cloud.vm.snapshot.dao.VMSnapshotDao;
import org.apache.cloudstack.engine.subsystem.api.storage.VMSnapshotStrategy;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
import org.apache.cloudstack.storage.to.VolumeObjectTO;
import org.apache.log4j.Logger;
@ -78,6 +74,10 @@ public class DefaultVMSnapshotStrategy extends ManagerBase implements VMSnapshot
ConfigurationDao configurationDao;
@Inject
AgentManager agentMgr;
@Inject
VolumeDao volumeDao;
@Inject
DiskOfferingDao diskOfferingDao;
@Override
public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
String value = configurationDao.getValue("vmsnapshot.create.wait");
@ -96,13 +96,12 @@ public class DefaultVMSnapshotStrategy extends ManagerBase implements VMSnapshot
}
CreateVMSnapshotAnswer answer = null;
boolean result = false;
try {
GuestOSVO guestOS = guestOSDao.findById(userVm.getGuestOSId());
// prepare snapshotVolumeTos
List<VolumeObjectTO> volumeTOs = vmSnapshotHelper.getVolumeTOList(userVm.getId());
// prepare target snapshotTO and its parent snapshot (current snapshot)
VMSnapshotTO current = null;
VMSnapshotVO currentSnapshot = vmSnapshotDao.findCurrentSnapshotByVmId(userVm.getId());
if (currentSnapshot != null)
@ -121,36 +120,33 @@ public class DefaultVMSnapshotStrategy extends ManagerBase implements VMSnapshot
if (answer != null && answer.getResult()) {
processAnswer(vmSnapshotVO, userVm, answer, hostId);
s_logger.debug("Create vm snapshot " + vmSnapshot.getName() + " succeeded for vm: " + userVm.getInstanceName());
}else{
result = true;
for (VolumeObjectTO volumeTo : answer.getVolumeTOs()){
publishUsageEvent(EventTypes.EVENT_VM_SNAPSHOT_CREATE,vmSnapshot,userVm,volumeTo);
}
return vmSnapshot;
} 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);
vmSnapshotHelper.vmSnapshotStateTransitTo(vmSnapshot, VMSnapshot.Event.OperationFailed);
throw new CloudRuntimeException(errMsg);
}
return vmSnapshot;
} catch (Exception e) {
if(e instanceof AgentUnavailableException){
} catch (OperationTimedoutException e) {
s_logger.debug("Creating VM snapshot: " + vmSnapshot.getName() + " failed: " + e.toString());
throw new CloudRuntimeException("Creating VM snapshot: " + vmSnapshot.getName() + " failed: " + e.toString());
} catch (AgentUnavailableException e) {
s_logger.debug("Creating VM snapshot: " + vmSnapshot.getName() + " failed", e);
throw new CloudRuntimeException("Creating VM snapshot: " + vmSnapshot.getName() + " failed: " + e.toString());
} finally{
if (!result) {
try {
vmSnapshotHelper.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());
}
if(vmSnapshot.getState() == VMSnapshot.State.Ready && answer != null){
for (VolumeTO volumeTo : answer.getVolumeTOs()){
publishUsageEvent(EventTypes.EVENT_VM_SNAPSHOT_CREATE,vmSnapshot,userVm,volumeTo);
}
}
}
}
@ -158,15 +154,18 @@ public class DefaultVMSnapshotStrategy extends ManagerBase implements VMSnapshot
public boolean deleteVMSnapshot(VMSnapshot vmSnapshot) {
UserVmVO userVm = userVmDao.findById(vmSnapshot.getVmId());
VMSnapshotVO vmSnapshotVO = (VMSnapshotVO)vmSnapshot;
DeleteVMSnapshotAnswer answer = null;
try {
vmSnapshotHelper.vmSnapshotStateTransitTo(vmSnapshot,VMSnapshot.Event.ExpungeRequested);
} catch (NoTransitionException e) {
s_logger.debug("Failed to change vm snapshot state with event ExpungeRequested");
throw new CloudRuntimeException("Failed to change vm snapshot state with event ExpungeRequested: " + e.getMessage());
}
try {
Long hostId = vmSnapshotHelper.pickRunningHost(vmSnapshot.getVmId());
// prepare snapshotVolumeTos
List<VolumeObjectTO> volumeTOs = vmSnapshotHelper.getVolumeTOList(vmSnapshot.getVmId());
// prepare DeleteVMSnapshotCommand
String vmInstanceName = userVm.getInstanceName();
VMSnapshotTO parent = vmSnapshotHelper.getSnapshotWithParents(vmSnapshotVO).getParent();
VMSnapshotTO vmSnapshotTO = new VMSnapshotTO(vmSnapshot.getId(), vmSnapshot.getName(), vmSnapshot.getType(),
@ -174,26 +173,24 @@ public class DefaultVMSnapshotStrategy extends ManagerBase implements VMSnapshot
GuestOSVO guestOS = guestOSDao.findById(userVm.getGuestOSId());
DeleteVMSnapshotCommand deleteSnapshotCommand = new DeleteVMSnapshotCommand(vmInstanceName, vmSnapshotTO, volumeTOs,guestOS.getDisplayName());
answer = (DeleteVMSnapshotAnswer) agentMgr.send(hostId, deleteSnapshotCommand);
Answer answer = agentMgr.send(hostId, deleteSnapshotCommand);
if (answer != null && answer.getResult()) {
DeleteVMSnapshotAnswer deleteVMSnapshotAnswer = (DeleteVMSnapshotAnswer)answer;
processAnswer(vmSnapshotVO, 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());
} finally{
if(answer != null && answer.getResult()){
for (VolumeTO volumeTo : answer.getVolumeTOs()){
for (VolumeObjectTO volumeTo : deleteVMSnapshotAnswer.getVolumeTOs()){
publishUsageEvent(EventTypes.EVENT_VM_SNAPSHOT_DELETE,vmSnapshot,userVm,volumeTo);
}
return true;
} else {
String errMsg = (answer == null) ? null : answer.getDetails();
s_logger.error("Delete vm snapshot " + vmSnapshot.getName() + " of vm " + userVm.getInstanceName() + " failed due to " + errMsg);
throw new CloudRuntimeException("Delete vm snapshot " + vmSnapshot.getName() + " of vm " + userVm.getInstanceName() + " failed due to " + errMsg);
}
} catch (OperationTimedoutException e) {
throw new CloudRuntimeException("Delete vm snapshot " + vmSnapshot.getName() + " of vm " + userVm.getInstanceName() + " failed due to " + e.getMessage());
} catch (AgentUnavailableException e) {
throw new CloudRuntimeException("Delete vm snapshot " + vmSnapshot.getName() + " of vm " + userVm.getInstanceName() + " failed due to " + e.getMessage());
}
}
@ -226,7 +223,7 @@ public class DefaultVMSnapshotStrategy extends ManagerBase implements VMSnapshot
}
}
protected void finalizeDelete(VMSnapshotVO vmSnapshot, List<VolumeTO> VolumeTOs) {
protected void finalizeDelete(VMSnapshotVO vmSnapshot, List<VolumeObjectTO> VolumeTOs) {
// update volumes path
updateVolumePath(VolumeTOs);
@ -248,7 +245,7 @@ public class DefaultVMSnapshotStrategy extends ManagerBase implements VMSnapshot
vmSnapshotDao.persist(vmSnapshot);
}
protected void finalizeCreate(VMSnapshotVO vmSnapshot, List<VolumeTO> VolumeTOs) {
protected void finalizeCreate(VMSnapshotVO vmSnapshot, List<VolumeObjectTO> VolumeTOs) {
// update volumes path
updateVolumePath(VolumeTOs);
@ -263,7 +260,7 @@ public class DefaultVMSnapshotStrategy extends ManagerBase implements VMSnapshot
vmSnapshotDao.persist(vmSnapshot);
}
protected void finalizeRevert(VMSnapshotVO vmSnapshot, List<VolumeTO> volumeToList) {
protected void finalizeRevert(VMSnapshotVO vmSnapshot, List<VolumeObjectTO> volumeToList) {
// update volumes path
updateVolumePath(volumeToList);
@ -277,23 +274,23 @@ public class DefaultVMSnapshotStrategy extends ManagerBase implements VMSnapshot
vmSnapshotDao.persist(vmSnapshot);
}
private void updateVolumePath(List<VolumeTO> volumeTOs) {
for (VolumeTO volume : volumeTOs) {
private void updateVolumePath(List<VolumeObjectTO> volumeTOs) {
for (VolumeObjectTO volume : volumeTOs) {
if (volume.getPath() != null) {
VolumeVO volumeVO = volumeDao.findById(volume.getId());
volumeVO.setPath(volume.getPath());
volumeVO.setVmSnapshotChainSize(volume.getChainSize());
volumeVO.setVmSnapshotChainSize(volume.getSize());
volumeDao.persist(volumeVO);
}
}
}
private void publishUsageEvent(String type, VMSnapshot vmSnapshot, UserVm userVm, VolumeTO volumeTo){
VolumeVO volume = _volumeDao.findById(volumeTo.getId());
private void publishUsageEvent(String type, VMSnapshot vmSnapshot, UserVm userVm, VolumeObjectTO volumeTo){
VolumeVO volume = volumeDao.findById(volumeTo.getId());
Long diskOfferingId = volume.getDiskOfferingId();
Long offeringId = null;
if (diskOfferingId != null) {
DiskOfferingVO offering = _diskOfferingDao.findById(diskOfferingId);
DiskOfferingVO offering = diskOfferingDao.findById(diskOfferingId);
if (offering != null
&& (offering.getType() == DiskOfferingVO.Type.Disk)) {
offeringId = offering.getId();
@ -307,58 +304,59 @@ public class DefaultVMSnapshotStrategy extends ManagerBase implements VMSnapshot
vmSnapshot.getName(),
offeringId,
volume.getId(), // save volume's id into templateId field
volumeTo.getChainSize(),
volumeTo.getSize(),
VMSnapshot.class.getName(), vmSnapshot.getUuid());
}
@Override
public boolean revertVMSnapshot(VMSnapshot vmSnapshot) {
userVm = _userVMDao.findById(userVm.getId());
VMSnapshotVO vmSnapshotVO = (VMSnapshotVO)vmSnapshot;
UserVmVO userVm = userVmDao.findById(vmSnapshot.getVmId());
try {
vmSnapshotStateTransitTo(vmSnapshotVo, VMSnapshot.Event.RevertRequested);
vmSnapshotHelper.vmSnapshotStateTransitTo(vmSnapshotVO, VMSnapshot.Event.RevertRequested);
} catch (NoTransitionException e) {
throw new CloudRuntimeException(e.getMessage());
}
boolean result = false;
try {
VMSnapshotVO snapshot = _vmSnapshotDao.findById(vmSnapshotVo.getId());
// prepare RevertToSnapshotCommand
List<VolumeTO> volumeTOs = getVolumeTOList(userVm.getId());
VMSnapshotVO snapshot = vmSnapshotDao.findById(vmSnapshotVO.getId());
List<VolumeObjectTO> volumeTOs = vmSnapshotHelper.getVolumeTOList(userVm.getId());
String vmInstanceName = userVm.getInstanceName();
VMSnapshotTO parent = getSnapshotWithParents(snapshot).getParent();
VMSnapshotTO parent = vmSnapshotHelper.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());
Long hostId = vmSnapshotHelper.pickRunningHost(vmSnapshot.getVmId());
GuestOSVO guestOS = guestOSDao.findById(userVm.getGuestOSId());
RevertToVMSnapshotCommand revertToSnapshotCommand = new RevertToVMSnapshotCommand(vmInstanceName, vmSnapshotTO, volumeTOs, guestOS.getDisplayName());
RevertToVMSnapshotAnswer answer = (RevertToVMSnapshotAnswer) sendToPool(hostId, revertToSnapshotCommand);
RevertToVMSnapshotAnswer answer = (RevertToVMSnapshotAnswer) agentMgr.send(hostId, revertToSnapshotCommand);
if (answer != null && answer.getResult()) {
processAnswer(vmSnapshotVo, userVm, answer, hostId);
s_logger.debug("RevertTo " + vmSnapshotVo.getName() + " succeeded for vm: " + userVm.getInstanceName());
processAnswer(vmSnapshotVO, userVm, answer, hostId);
result = true;
} else {
String errMsg = "Revert VM: " + userVm.getInstanceName() + " to snapshot: "+ vmSnapshotVo.getName() + " failed";
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){
} catch (OperationTimedoutException e) {
s_logger.debug("Failed to revert vm snapshot", e);
throw new CloudRuntimeException(e.getMessage());
} catch (AgentUnavailableException e) {
s_logger.debug("Failed to revert vm snapshot", e);
throw new CloudRuntimeException(e.getMessage());
} finally {
if (!result) {
try {
vmSnapshotStateTransitTo(vmSnapshotVo, VMSnapshot.Event.OperationFailed);
vmSnapshotHelper.vmSnapshotStateTransitTo(vmSnapshot, 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;
return result;
}
@Override

87
plugins/hypervisors/vmware/src/com/cloud/hypervisor/vmware/manager/VmwareStorageManagerImpl.java
View File

@ -16,39 +16,6 @@
// under the License.
package com.cloud.hypervisor.vmware.manager;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.UUID;
import org.apache.log4j.Logger;
import com.vmware.vim25.FileInfo;
import com.vmware.vim25.FileQueryFlags;
import com.vmware.vim25.HostDatastoreBrowserSearchResults;
import com.vmware.vim25.HostDatastoreBrowserSearchSpec;
import com.vmware.vim25.ManagedObjectReference;
import com.vmware.vim25.TaskInfo;
import com.vmware.vim25.VirtualDeviceConfigSpec;
import com.vmware.vim25.VirtualDeviceConfigSpecOperation;
import com.vmware.vim25.VirtualDisk;
import com.vmware.vim25.VirtualLsiLogicController;
import com.vmware.vim25.VirtualMachineConfigSpec;
import com.vmware.vim25.VirtualMachineFileInfo;
import com.vmware.vim25.VirtualMachineGuestOsIdentifier;
import com.vmware.vim25.VirtualSCSISharing;
import org.apache.cloudstack.storage.to.TemplateObjectTO;
import org.apache.cloudstack.storage.to.VolumeObjectTO;
import com.cloud.agent.api.Answer;
import com.cloud.agent.api.BackupSnapshotAnswer;
import com.cloud.agent.api.BackupSnapshotCommand;
@ -73,7 +40,6 @@ import com.cloud.agent.api.to.DataStoreTO;
import com.cloud.agent.api.to.DataTO;
import com.cloud.agent.api.to.NfsTO;
import com.cloud.agent.api.to.StorageFilerTO;
import com.cloud.agent.api.to.VolumeTO;
import com.cloud.hypervisor.vmware.mo.CustomFieldConstants;
import com.cloud.hypervisor.vmware.mo.DatacenterMO;
import com.cloud.hypervisor.vmware.mo.DatastoreMO;
@ -97,6 +63,29 @@ import com.cloud.utils.exception.CloudRuntimeException;
import com.cloud.utils.script.Script;
import com.cloud.vm.VirtualMachine;
import com.cloud.vm.snapshot.VMSnapshot;
import com.vmware.vim25.FileInfo;
import com.vmware.vim25.FileQueryFlags;
import com.vmware.vim25.HostDatastoreBrowserSearchResults;
import com.vmware.vim25.HostDatastoreBrowserSearchSpec;
import com.vmware.vim25.ManagedObjectReference;
import com.vmware.vim25.TaskInfo;
import com.vmware.vim25.VirtualDisk;
import org.apache.cloudstack.storage.to.TemplateObjectTO;
import org.apache.cloudstack.storage.to.VolumeObjectTO;
import org.apache.log4j.Logger;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.UUID;
public class VmwareStorageManagerImpl implements VmwareStorageManager {
@Override
@ -1280,7 +1269,7 @@ public class VmwareStorageManagerImpl implements VmwareStorageManager {
@Override
public CreateVMSnapshotAnswer execute(VmwareHostService hostService, CreateVMSnapshotCommand cmd) {
List<VolumeTO> volumeTOs = cmd.getVolumeTOs();
List<VolumeObjectTO> volumeTOs = cmd.getVolumeTOs();
String vmName = cmd.getVmName();
String vmSnapshotName = cmd.getTarget().getSnapshotName();
String vmSnapshotDesc = cmd.getTarget().getDescription();
@ -1330,19 +1319,20 @@ public class VmwareStorageManagerImpl implements VmwareStorageManager {
mapNewDisk.put(baseName, vmdkName);
}
}
for (VolumeTO volumeTO : volumeTOs) {
for (VolumeObjectTO volumeTO : volumeTOs) {
String baseName = extractSnapshotBaseFileName(volumeTO.getPath());
String newPath = mapNewDisk.get(baseName);
// get volume's chain size for this VM snapshot, exclude current volume vdisk
DataStoreTO store = volumeTO.getDataStore();
long size = getVMSnapshotChainSize(context,hyperHost,baseName + "*.vmdk",
volumeTO.getPoolUuid(), newPath);
store.getUuid(), newPath);
if(volumeTO.getType()== Volume.Type.ROOT){
if(volumeTO.getVolumeType()== Volume.Type.ROOT){
// add memory snapshot size
size = size + getVMSnapshotChainSize(context,hyperHost,cmd.getVmName()+"*.vmsn",volumeTO.getPoolUuid(),null);
size = size + getVMSnapshotChainSize(context,hyperHost,cmd.getVmName()+"*.vmsn",store.getUuid(),null);
}
volumeTO.setChainSize(size);
volumeTO.setSize(size);
volumeTO.setPath(newPath);
}
return new CreateVMSnapshotAnswer(cmd, cmd.getTarget(), volumeTOs);
@ -1362,7 +1352,7 @@ public class VmwareStorageManagerImpl implements VmwareStorageManager {
@Override
public DeleteVMSnapshotAnswer execute(VmwareHostService hostService, DeleteVMSnapshotCommand cmd) {
List<VolumeTO> listVolumeTo = cmd.getVolumeTOs();
List<VolumeObjectTO> listVolumeTo = cmd.getVolumeTOs();
VirtualMachineMO vmMo = null;
VmwareContext context = hostService.getServiceContext(cmd);
Map<String, String> mapNewDisk = new HashMap<String, String>();
@ -1403,16 +1393,17 @@ public class VmwareStorageManagerImpl implements VmwareStorageManager {
mapNewDisk.put(baseName, vmdkName);
}
}
for (VolumeTO volumeTo : listVolumeTo) {
for (VolumeObjectTO volumeTo : listVolumeTo) {
String baseName = extractSnapshotBaseFileName(volumeTo.getPath());
String newPath = mapNewDisk.get(baseName);
DataStoreTO store = volumeTo.getDataStore();
long size = getVMSnapshotChainSize(context,hyperHost,
baseName + "*.vmdk", volumeTo.getPoolUuid(), newPath);
if(volumeTo.getType()== Volume.Type.ROOT){
baseName + "*.vmdk", store.getUuid(), newPath);
if(volumeTo.getVolumeType()== Volume.Type.ROOT){
// add memory snapshot size
size = size + getVMSnapshotChainSize(context,hyperHost,cmd.getVmName()+"*.vmsn",volumeTo.getPoolUuid(),null);
size = size + getVMSnapshotChainSize(context,hyperHost,cmd.getVmName()+"*.vmsn",volumeTo.getUuid(),null);
}
volumeTo.setChainSize(size);
volumeTo.setSize(size);
volumeTo.setPath(newPath);
}
return new DeleteVMSnapshotAnswer(cmd, listVolumeTo);
@ -1429,7 +1420,7 @@ public class VmwareStorageManagerImpl implements VmwareStorageManager {
String snapshotName = cmd.getTarget().getSnapshotName();
String vmName = cmd.getVmName();
Boolean snapshotMemory = cmd.getTarget().getType() == VMSnapshot.Type.DiskAndMemory;
List<VolumeTO> listVolumeTo = cmd.getVolumeTOs();
List<VolumeObjectTO> listVolumeTo = cmd.getVolumeTOs();
VirtualMachine.State vmState = VirtualMachine.State.Running;
VirtualMachineMO vmMo = null;
VmwareContext context = hostService.getServiceContext(cmd);
@ -1483,7 +1474,7 @@ public class VmwareStorageManagerImpl implements VmwareStorageManager {
}
}
String key = null;
for (VolumeTO volumeTo : listVolumeTo) {
for (VolumeObjectTO volumeTo : listVolumeTo) {
String parentUUID = volumeTo.getPath();
String[] s = parentUUID.split("-");
key = s[0];

28
plugins/hypervisors/xen/src/com/cloud/hypervisor/xen/resource/CitrixResourceBase.java
View File

@ -734,7 +734,7 @@ public abstract class CitrixResourceBase implements ServerResource, HypervisorRe
private Answer execute(RevertToVMSnapshotCommand cmd) {
String vmName = cmd.getVmName();
List<VolumeTO> listVolumeTo = cmd.getVolumeTOs();
List<VolumeObjectTO> listVolumeTo = cmd.getVolumeTOs();
VMSnapshot.Type vmSnapshotType = cmd.getTarget().getType();
Boolean snapshotMemory = vmSnapshotType == VMSnapshot.Type.DiskAndMemory;
Connection conn = getConnection();
@ -786,7 +786,7 @@ public abstract class CitrixResourceBase implements ServerResource, HypervisorRe
}
// after revert, VM's volumes path have been changed, need to report to manager
for (VolumeTO volumeTo : listVolumeTo) {
for (VolumeObjectTO volumeTo : listVolumeTo) {
Long deviceId = volumeTo.getDeviceId();
VDI vdi = vdiMap.get(deviceId.toString());
volumeTo.setPath(vdi.getUuid(conn));
@ -6637,7 +6637,7 @@ public abstract class CitrixResourceBase implements ServerResource, HypervisorRe
}
private long getVMSnapshotChainSize(Connection conn, VolumeTO volumeTo, String vmName)
private long getVMSnapshotChainSize(Connection conn, VolumeObjectTO volumeTo, String vmName)
throws BadServerResponse, XenAPIException, XmlRpcException {
Set<VDI> allvolumeVDIs = VDI.getByNameLabel(conn, volumeTo.getName());
long size = 0;
@ -6661,7 +6661,7 @@ public abstract class CitrixResourceBase implements ServerResource, HypervisorRe
continue;
}
}
if (volumeTo.getType() == Volume.Type.ROOT) {
if (volumeTo.getVolumeType() == Volume.Type.ROOT) {
Map<VM, VM.Record> allVMs = VM.getAllRecords(conn);
// add size of memory snapshot vdi
if (allVMs.size() > 0) {
@ -6694,7 +6694,7 @@ public abstract class CitrixResourceBase implements ServerResource, HypervisorRe
protected Answer execute(final CreateVMSnapshotCommand cmd) {
String vmName = cmd.getVmName();
String vmSnapshotName = cmd.getTarget().getSnapshotName();
List<VolumeTO> listVolumeTo = cmd.getVolumeTOs();
List<VolumeObjectTO> listVolumeTo = cmd.getVolumeTOs();
VirtualMachine.State vmState = cmd.getVmState();
String guestOSType = cmd.getGuestOSType();
@ -6774,9 +6774,9 @@ public abstract class CitrixResourceBase implements ServerResource, HypervisorRe
}
// calculate used capacity for this VM snapshot
for (VolumeTO volumeTo : cmd.getVolumeTOs()){
for (VolumeObjectTO volumeTo : cmd.getVolumeTOs()){
long size = getVMSnapshotChainSize(conn,volumeTo,cmd.getVmName());
volumeTo.setChainSize(size);
volumeTo.setSize(size);
}
success = true;
@ -6825,7 +6825,7 @@ public abstract class CitrixResourceBase implements ServerResource, HypervisorRe
}
private VM createWorkingVM(Connection conn, String vmName,
String guestOSType, List<VolumeTO> listVolumeTo)
String guestOSType, List<VolumeObjectTO> listVolumeTo)
throws BadServerResponse, VmBadPowerState, SrFull,
OperationNotAllowed, XenAPIException, XmlRpcException {
String guestOsTypeName = getGuestOsType(guestOSType, false);
@ -6839,8 +6839,8 @@ public abstract class CitrixResourceBase implements ServerResource, HypervisorRe
VM template = getVM(conn, guestOsTypeName);
VM vm = template.createClone(conn, vmName);
vm.setIsATemplate(conn, false);
Map<VDI, VolumeTO> vdiMap = new HashMap<VDI, VolumeTO>();
for (VolumeTO volume : listVolumeTo) {
Map<VDI, VolumeObjectTO> vdiMap = new HashMap<VDI, VolumeObjectTO>();
for (VolumeObjectTO volume : listVolumeTo) {
String vdiUuid = volume.getPath();
try {
VDI vdi = VDI.getByUuid(conn, vdiUuid);
@ -6851,11 +6851,11 @@ public abstract class CitrixResourceBase implements ServerResource, HypervisorRe
}
}
for (VDI vdi : vdiMap.keySet()) {
VolumeTO volumeTO = vdiMap.get(vdi);
VolumeObjectTO volumeTO = vdiMap.get(vdi);
VBD.Record vbdr = new VBD.Record();
vbdr.VM = vm;
vbdr.VDI = vdi;
if (volumeTO.getType() == Volume.Type.ROOT) {
if (volumeTO.getVolumeType() == Volume.Type.ROOT) {
vbdr.bootable = true;
vbdr.unpluggable = false;
} else {
@ -6902,9 +6902,9 @@ public abstract class CitrixResourceBase implements ServerResource, HypervisorRe
}
// re-calculate used capacify for this VM snapshot
for (VolumeTO volumeTo : cmd.getVolumeTOs()){
for (VolumeObjectTO volumeTo : cmd.getVolumeTOs()){
long size = getVMSnapshotChainSize(conn,volumeTo,cmd.getVmName());
volumeTo.setChainSize(size);
volumeTo.setSize(size);
}
return new DeleteVMSnapshotAnswer(cmd, cmd.getVolumeTOs());

97
server/src/com/cloud/storage/snapshot/SnapshotManagerImpl.java
View File

@ -342,8 +342,6 @@ public class SnapshotManagerImpl extends ManagerBase implements SnapshotManager,
return snapshot;
}
@Override
public Snapshot backupSnapshot(Long snapshotId) {
SnapshotInfo snapshot = snapshotFactory.getSnapshot(snapshotId, DataStoreRole.Image);
@ -354,97 +352,6 @@ public class SnapshotManagerImpl extends ManagerBase implements SnapshotManager,
return snapshotSrv.backupSnapshot(snapshot);
}
/*
@Override
public void downloadSnapshotsFromSwift(SnapshotVO ss) {
long volumeId = ss.getVolumeId();
VolumeVO volume = _volsDao.findById(volumeId);
Long dcId = volume.getDataCenterId();
Long accountId = volume.getAccountId();
DataStore secStore = this.dataStoreMgr.getImageStore(dcId);
Long swiftId = ss.getSwiftId();
SwiftTO swift = _swiftMgr.getSwiftTO(swiftId);
SnapshotVO tss = ss;
List<String> BackupUuids = new ArrayList<String>(30);
while (true) {
BackupUuids.add(0, tss.getBackupSnapshotId());
if (tss.getPrevSnapshotId() == 0)
break;
Long id = tss.getPrevSnapshotId();
tss = _snapshotDao.findById(id);
assert tss != null : " can not find snapshot " + id;
}
String parent = null;
try {
for (String backupUuid : BackupUuids) {
<<<<<<< HEAD
downloadSnapshotFromSwiftCommand cmd = new downloadSnapshotFromSwiftCommand(swift, secStore.getUri(), dcId, accountId, volumeId, parent, backupUuid, _backupsnapshotwait);
=======
DownloadSnapshotFromSwiftCommand cmd = new DownloadSnapshotFromSwiftCommand(swift, secondaryStoragePoolUrl, dcId, accountId, volumeId, parent, backupUuid, _backupsnapshotwait);
>>>>>>> master
Answer answer = _agentMgr.sendToSSVM(dcId, cmd);
if ((answer == null) || !answer.getResult()) {
throw new CloudRuntimeException("downloadSnapshotsFromSwift failed ");
}
parent = backupUuid;
}
} catch (Exception e) {
throw new CloudRuntimeException("downloadSnapshotsFromSwift failed due to " + e.toString());
}
}
private List<String> determineBackupUuids(final SnapshotVO snapshot) {
final List<String> backupUuids = new ArrayList<String>();
backupUuids.add(0, snapshot.getBackupSnapshotId());
SnapshotVO tempSnapshot = snapshot;
while (tempSnapshot.getPrevSnapshotId() != 0) {
tempSnapshot = _snapshotDao.findById(tempSnapshot
.getPrevSnapshotId());
backupUuids.add(0, tempSnapshot.getBackupSnapshotId());
}
return Collections.unmodifiableList(backupUuids);
}
@Override
public void downloadSnapshotsFromS3(final SnapshotVO snapshot) {
final VolumeVO volume = _volsDao.findById(snapshot.getVolumeId());
final Long zoneId = volume.getDataCenterId();
final DataStore secStore = this.dataStoreMgr.getImageStore(zoneId);
final S3TO s3 = _s3Mgr.getS3TO(snapshot.getS3Id());
final List<String> backupUuids = determineBackupUuids(snapshot);
try {
String parent = null;
for (final String backupUuid : backupUuids) {
final DownloadSnapshotFromS3Command cmd = new DownloadSnapshotFromS3Command(
s3, parent, secStore.getUri(), zoneId,
volume.getAccountId(), volume.getId(), backupUuid,
_backupsnapshotwait);
final Answer answer = _agentMgr.sendToSSVM(zoneId, cmd);
if ((answer == null) || !answer.getResult()) {
throw new CloudRuntimeException(String.format(
"S3 snapshot download failed due to %1$s.",
answer != null ? answer.getDetails()
: "unspecified error"));
}
parent = backupUuid;
}
} catch (Exception e) {
throw new CloudRuntimeException(
"Snapshot download from S3 failed due to " + e.toString(),
e);
}
}*/
@Override
public SnapshotVO getParentSnapshot(VolumeInfo volume) {
long preId = _snapshotDao.getLastSnapshot(volume.getId(), DataStoreRole.Primary);
@ -546,7 +453,6 @@ public class SnapshotManagerImpl extends ManagerBase implements SnapshotManager,
}
}
@Override
public String getSecondaryStorageURL(SnapshotVO snapshot) {
SnapshotDataStoreVO snapshotStore = _snapshotStoreDao.findBySnapshot(snapshot.getId(), DataStoreRole.Image);
@ -672,7 +578,6 @@ public class SnapshotManagerImpl extends ManagerBase implements SnapshotManager,
return new Pair<List<? extends Snapshot>, Integer>(result.first(), result.second());
}
@Override
public boolean deleteSnapshotDirsForAccount(long accountId) {
@ -942,8 +847,6 @@ public class SnapshotManagerImpl extends ManagerBase implements SnapshotManager,
return null;
}
private boolean hostSupportSnapsthotForVolume(HostVO host, VolumeInfo volume) {
if (host.getHypervisorType() != HypervisorType.KVM) {
return true;

110
server/src/com/cloud/vm/snapshot/VMSnapshotManagerImpl.java
View File

@ -17,83 +17,34 @@
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.engine.subsystem.api.storage.VMSnapshotStrategy;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Component;
import org.apache.cloudstack.api.command.user.vmsnapshot.ListVMSnapshotCmd;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreManager;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
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.event.ActionEvent;
import com.cloud.event.EventTypes;
import com.cloud.event.UsageEventUtils;
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.HypervisorGuruManager;
import com.cloud.hypervisor.dao.HypervisorCapabilitiesDao;
import com.cloud.projects.Project.ListProjectResourcesCriteria;
import com.cloud.service.dao.ServiceOfferingDao;
import com.cloud.storage.DiskOfferingVO;
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.DiskOfferingDao;
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.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;
@ -101,8 +52,22 @@ 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;
import org.apache.cloudstack.api.command.user.vmsnapshot.ListVMSnapshotCmd;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.subsystem.api.storage.VMSnapshotStrategy;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Component;
import javax.ejb.Local;
import javax.inject.Inject;
import javax.naming.ConfigurationException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Component
@Local(value = { VMSnapshotManager.class, VMSnapshotService.class })
@ -112,22 +77,13 @@ public class VMSnapshotManagerImpl extends ManagerBase implements VMSnapshotMana
@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;
@Inject DiskOfferingDao _diskOfferingDao;
@Inject ServiceOfferingDao _serviceOfferingDao;
@Inject List<VMSnapshotStrategy> vmSnapshotStrategies;
public List<VMSnapshotStrategy> getVmSnapshotStrategies() {
@ -375,14 +331,16 @@ public class VMSnapshotManagerImpl extends ManagerBase implements VMSnapshotMana
throw new CloudRuntimeException("VM snapshot id: " + vmSnapshotId + " can not be found");
}
VMSnapshotStrategy strategy = findVMSnapshotStrategy(vmSnapshot);
VMSnapshot snapshot = strategy.takeVMSnapshot(vmSnapshot);
return snapshot;
try {
VMSnapshotStrategy strategy = findVMSnapshotStrategy(vmSnapshot);
VMSnapshot snapshot = strategy.takeVMSnapshot(vmSnapshot);
return snapshot;
} catch (Exception e) {
s_logger.debug("Failed to create vm snapshot: " + vmSnapshotId ,e);
return null;
}
}
public VMSnapshotManagerImpl() {
}
@ -423,8 +381,13 @@ public class VMSnapshotManagerImpl extends ManagerBase implements VMSnapshotMana
if(vmSnapshot.getState() == VMSnapshot.State.Allocated){
return _vmSnapshotDao.remove(vmSnapshot.getId());
} else{
VMSnapshotStrategy strategy = findVMSnapshotStrategy(vmSnapshot);
return strategy.deleteVMSnapshot(vmSnapshot);
try {
VMSnapshotStrategy strategy = findVMSnapshotStrategy(vmSnapshot);
return strategy.deleteVMSnapshot(vmSnapshot);
} catch (Exception e) {
s_logger.debug("Failed to delete vm snapshot: " + vmSnapshotId, e);
return false;
}
}
}
@ -496,10 +459,15 @@ public class VMSnapshotManagerImpl extends ManagerBase implements VMSnapshotMana
if (hasActiveVMSnapshotTasks(userVm.getId())) {
throw new InvalidParameterValueException("There is other active vm snapshot tasks on the instance, please try again later");
}
VMSnapshotStrategy strategy = findVMSnapshotStrategy(vmSnapshotVo);
strategy.revertVMSnapshot(vmSnapshotVo);
return userVm;
try {
VMSnapshotStrategy strategy = findVMSnapshotStrategy(vmSnapshotVo);
strategy.revertVMSnapshot(vmSnapshotVo);
return userVm;
} catch (Exception e) {
s_logger.debug("Failed to revert vmsnapshot: " + vmSnapshotId, e);
return null;
}
}
@Override

7
server/test/com/cloud/vm/snapshot/VMSnapshotManagerTest.java
View File

@ -192,13 +192,6 @@ public class VMSnapshotManagerTest {
when(vmMock.getState()).thenReturn(State.Running);
_vmSnapshotMgr.allocVMSnapshot(TEST_VM_ID,"","",true);
when(_vmSnapshotDao.findCurrentSnapshotByVmId(anyLong())).thenReturn(null);
doReturn(new ArrayList<VolumeTO>()).when(_vmSnapshotMgr).getVolumeTOList(anyLong());
doReturn(new CreateVMSnapshotAnswer(null,true,"")).when(_vmSnapshotMgr).sendToPool(anyLong(), any(CreateVMSnapshotCommand.class));
doNothing().when(_vmSnapshotMgr).processAnswer(any(VMSnapshotVO.class),
any(UserVmVO.class), any(Answer.class), anyLong());
doReturn(true).when(_vmSnapshotMgr).vmSnapshotStateTransitTo(any(VMSnapshotVO.class),any(VMSnapshot.Event.class));
_vmSnapshotMgr.createVmSnapshotInternal(vmMock, mock(VMSnapshotVO.class), 5L);
}
}