private void syncVolumeVolumeSize(final ReturnValueCompletion<VolumeSize> completion) {
SyncVolumeSizeOnPrimaryStorageMsg smsg = new SyncVolumeSizeOnPrimaryStorageMsg();
smsg.setPrimaryStorageUuid(self.getPrimaryStorageUuid());
smsg.setVolumeUuid(self.getUuid());
smsg.setInstallPath(self.getInstallPath());
bus.makeTargetServiceIdByResourceUuid(
smsg, PrimaryStorageConstant.SERVICE_ID, self.getPrimaryStorageUuid());
bus.send(
smsg,
new CloudBusCallBack(completion) {
@Override
public void run(MessageReply reply) {
if (!reply.isSuccess()) {
completion.fail(reply.getError());
return;
}
SyncVolumeSizeOnPrimaryStorageReply r = reply.castReply();
self.setActualSize(r.getActualSize());
self.setSize(r.getSize());
self = dbf.updateAndRefresh(self);
VolumeSize size = new VolumeSize();
size.actualSize = r.getActualSize();
size.size = r.getSize();
completion.success(size);
}
});
}
private void handle(APIChangeVolumeStateMsg msg) {
VolumeStateEvent sevt = VolumeStateEvent.valueOf(msg.getStateEvent());
if (sevt == VolumeStateEvent.enable) {
self.setState(VolumeState.Enabled);
} else {
self.setState(VolumeState.Disabled);
}
self = dbf.updateAndRefresh(self);
VolumeInventory inv = VolumeInventory.valueOf(self);
APIChangeVolumeStateEvent evt = new APIChangeVolumeStateEvent(msg.getId());
evt.setInventory(inv);
bus.publish(evt);
}
private void handle(final APIAttachDataVolumeToVmMsg msg) {
self.setVmInstanceUuid(msg.getVmInstanceUuid());
self = dbf.updateAndRefresh(self);
AttachDataVolumeToVmMsg amsg = new AttachDataVolumeToVmMsg();
amsg.setVolume(getSelfInventory());
amsg.setVmInstanceUuid(msg.getVmInstanceUuid());
bus.makeTargetServiceIdByResourceUuid(
amsg, VmInstanceConstant.SERVICE_ID, amsg.getVmInstanceUuid());
bus.send(
amsg,
new CloudBusCallBack(msg) {
@Override
public void run(MessageReply reply) {
final APIAttachDataVolumeToVmEvent evt = new APIAttachDataVolumeToVmEvent(msg.getId());
self = dbf.reload(self);
if (reply.isSuccess()) {
AttachDataVolumeToVmReply ar = reply.castReply();
self.setVmInstanceUuid(msg.getVmInstanceUuid());
self.setFormat(
VolumeFormat.getVolumeFormatByMasterHypervisorType(ar.getHypervisorType())
.toString());
self = dbf.updateAndRefresh(self);
evt.setInventory(getSelfInventory());
} else {
self.setVmInstanceUuid(null);
dbf.update(self);
evt.setErrorCode(reply.getError());
}
bus.publish(evt);
}
});
}
private void handle(final CreateDataVolumeTemplateFromDataVolumeMsg msg) {
final CreateTemplateFromVolumeOnPrimaryStorageMsg cmsg =
new CreateTemplateFromVolumeOnPrimaryStorageMsg();
cmsg.setBackupStorageUuid(msg.getBackupStorageUuid());
cmsg.setImageInventory(
ImageInventory.valueOf(dbf.findByUuid(msg.getImageUuid(), ImageVO.class)));
cmsg.setVolumeInventory(getSelfInventory());
bus.makeTargetServiceIdByResourceUuid(
cmsg, PrimaryStorageConstant.SERVICE_ID, self.getPrimaryStorageUuid());
bus.send(
cmsg,
new CloudBusCallBack(msg) {
@Override
public void run(MessageReply r) {
CreateDataVolumeTemplateFromDataVolumeReply reply =
new CreateDataVolumeTemplateFromDataVolumeReply();
if (!r.isSuccess()) {
reply.setError(r.getError());
} else {
CreateTemplateFromVolumeOnPrimaryStorageReply creply = r.castReply();
String backupStorageInstallPath = creply.getTemplateBackupStorageInstallPath();
reply.setFormat(creply.getFormat());
reply.setInstallPath(backupStorageInstallPath);
reply.setMd5sum(null);
reply.setBackupStorageUuid(msg.getBackupStorageUuid());
}
bus.reply(msg, reply);
}
});
}
private void fullSnapshot(VolumeSnapshotInventory inv, int distance) {
Assert.assertEquals(VolumeSnapshotState.Enabled.toString(), inv.getState());
Assert.assertEquals(VolumeSnapshotStatus.Ready.toString(), inv.getStatus());
VolumeVO vol = dbf.findByUuid(inv.getVolumeUuid(), VolumeVO.class);
VolumeSnapshotVO svo = dbf.findByUuid(inv.getUuid(), VolumeSnapshotVO.class);
Assert.assertNotNull(svo);
Assert.assertTrue(svo.isFullSnapshot());
Assert.assertTrue(svo.isLatest());
Assert.assertNull(svo.getParentUuid());
Assert.assertEquals(distance, svo.getDistance());
Assert.assertEquals(vol.getPrimaryStorageUuid(), svo.getPrimaryStorageUuid());
Assert.assertNotNull(svo.getPrimaryStorageInstallPath());
VolumeSnapshotTreeVO cvo = dbf.findByUuid(svo.getTreeUuid(), VolumeSnapshotTreeVO.class);
Assert.assertNotNull(cvo);
Assert.assertTrue(cvo.isCurrent());
}
private void handle(APIUpdateVolumeMsg msg) {
boolean update = false;
if (msg.getName() != null) {
self.setName(msg.getName());
update = true;
}
if (msg.getDescription() != null) {
self.setDescription(msg.getDescription());
update = true;
}
if (update) {
self = dbf.updateAndRefresh(self);
}
APIUpdateVolumeEvent evt = new APIUpdateVolumeEvent(msg.getId());
evt.setInventory(getSelfInventory());
bus.publish(evt);
}
@Test
public void test() throws ApiSenderException {
VmInstanceInventory vm = deployer.vms.get("TestVm");
api.stopVmInstance(vm.getUuid());
String rootVolumeUuid = vm.getRootVolumeUuid();
VolumeVO vol = dbf.findByUuid(rootVolumeUuid, VolumeVO.class);
BackupStorageInventory sftp = deployer.backupStorages.get("sftp");
ImageInventory image =
api.createTemplateFromRootVolume("testImage", rootVolumeUuid, (List) null);
Assert.assertEquals(sftp.getUuid(), image.getBackupStorageRefs().get(0).getBackupStorageUuid());
Assert.assertEquals(ImageStatus.Ready.toString(), image.getStatus());
Assert.assertEquals(vol.getSize(), image.getSize());
Assert.assertEquals(String.format("volume://%s", vol.getUuid()), image.getUrl());
ImageVO ivo = dbf.findByUuid(image.getUuid(), ImageVO.class);
Assert.assertNotNull(ivo);
}
protected void recoverVolume(Completion completion) {
final VolumeInventory vol = getSelfInventory();
List<RecoverDataVolumeExtensionPoint> exts =
pluginRgty.getExtensionList(RecoverDataVolumeExtensionPoint.class);
for (RecoverDataVolumeExtensionPoint ext : exts) {
ext.preRecoverDataVolume(vol);
}
CollectionUtils.safeForEach(
exts,
new ForEachFunction<RecoverDataVolumeExtensionPoint>() {
@Override
public void run(RecoverDataVolumeExtensionPoint ext) {
ext.beforeRecoverDataVolume(vol);
}
});
VolumeStatus oldStatus = self.getStatus();
if (self.getInstallPath() != null) {
self.setStatus(VolumeStatus.Ready);
} else {
self.setStatus(VolumeStatus.NotInstantiated);
}
self = dbf.updateAndRefresh(self);
new FireVolumeCanonicalEvent().fireVolumeStatusChangedEvent(oldStatus, getSelfInventory());
CollectionUtils.safeForEach(
exts,
new ForEachFunction<RecoverDataVolumeExtensionPoint>() {
@Override
public void run(RecoverDataVolumeExtensionPoint ext) {
ext.afterRecoverDataVolume(vol);
}
});
completion.success();
}
private void handle(APISyncVolumeSizeMsg msg) {
final APISyncVolumeSizeEvent evt = new APISyncVolumeSizeEvent(msg.getId());
if (self.getStatus() != VolumeStatus.Ready) {
evt.setInventory(getSelfInventory());
bus.publish(evt);
return;
}
syncVolumeVolumeSize(
new ReturnValueCompletion<VolumeSize>(msg) {
@Override
public void success(VolumeSize ret) {
evt.setInventory(getSelfInventory());
bus.publish(evt);
}
@Override
public void fail(ErrorCode errorCode) {
evt.setErrorCode(errorCode);
bus.publish(evt);
}
});
}
private void delete(
boolean forceDelete, boolean detachBeforeDeleting, final Completion completion) {
final String issuer = VolumeVO.class.getSimpleName();
VolumeDeletionStruct struct = new VolumeDeletionStruct();
struct.setInventory(getSelfInventory());
struct.setDetachBeforeDeleting(detachBeforeDeleting);
struct.setDeletionPolicy(deletionPolicyMgr.getDeletionPolicy(self.getUuid()).toString());
final List<VolumeDeletionStruct> ctx = list(struct);
FlowChain chain = FlowChainBuilder.newSimpleFlowChain();
chain.setName("delete-data-volume");
if (!forceDelete) {
chain
.then(
new NoRollbackFlow() {
@Override
public void run(final FlowTrigger trigger, Map data) {
casf.asyncCascade(
CascadeConstant.DELETION_CHECK_CODE,
issuer,
ctx,
new Completion(trigger) {
@Override
public void success() {
trigger.next();
}
@Override
public void fail(ErrorCode errorCode) {
trigger.fail(errorCode);
}
});
}
})
.then(
new NoRollbackFlow() {
@Override
public void run(final FlowTrigger trigger, Map data) {
casf.asyncCascade(
CascadeConstant.DELETION_DELETE_CODE,
issuer,
ctx,
new Completion(trigger) {
@Override
public void success() {
trigger.next();
}
@Override
public void fail(ErrorCode errorCode) {
trigger.fail(errorCode);
}
});
}
});
} else {
chain.then(
new NoRollbackFlow() {
@Override
public void run(final FlowTrigger trigger, Map data) {
casf.asyncCascade(
CascadeConstant.DELETION_FORCE_DELETE_CODE,
issuer,
ctx,
new Completion(trigger) {
@Override
public void success() {
trigger.next();
}
@Override
public void fail(ErrorCode errorCode) {
trigger.fail(errorCode);
}
});
}
});
}
chain
.done(
new FlowDoneHandler(completion) {
@Override
public void handle(Map data) {
casf.asyncCascadeFull(
CascadeConstant.DELETION_CLEANUP_CODE, issuer, ctx, new NopeCompletion());
completion.success();
}
})
.error(
new FlowErrorHandler(completion) {
@Override
public void handle(ErrorCode errCode, Map data) {
completion.fail(errCode);
}
})
.start();
}
@Transactional(readOnly = true)
private List<VmInstanceVO> getCandidateVmForAttaching(String accountUuid) {
List<String> vmUuids =
acntMgr.getResourceUuidsCanAccessByAccount(accountUuid, VmInstanceVO.class);
if (vmUuids != null && vmUuids.isEmpty()) {
return new ArrayList<VmInstanceVO>();
}
TypedQuery<VmInstanceVO> q = null;
String sql;
if (vmUuids == null) {
// all vms
if (self.getStatus() == VolumeStatus.Ready) {
sql =
"select vm from VmInstanceVO vm, PrimaryStorageClusterRefVO ref, VolumeVO vol where vm.state in (:vmStates) and vol.uuid = :volUuid and vm.hypervisorType in (:hvTypes) and vm.clusterUuid = ref.clusterUuid and ref.primaryStorageUuid = vol.primaryStorageUuid group by vm.uuid";
q = dbf.getEntityManager().createQuery(sql, VmInstanceVO.class);
q.setParameter("volUuid", self.getUuid());
List<String> hvTypes =
VolumeFormat.valueOf(self.getFormat())
.getHypervisorTypesSupportingThisVolumeFormatInString();
q.setParameter("hvTypes", hvTypes);
} else if (self.getStatus() == VolumeStatus.NotInstantiated) {
sql = "select vm from VmInstanceVO vm where vm.state in (:vmStates) group by vm.uuid";
q = dbf.getEntityManager().createQuery(sql, VmInstanceVO.class);
} else {
DebugUtils.Assert(
false, String.format("should not reach here, volume[uuid:%s]", self.getUuid()));
}
} else {
if (self.getStatus() == VolumeStatus.Ready) {
sql =
"select vm from VmInstanceVO vm, PrimaryStorageClusterRefVO ref, VolumeVO vol where vm.uuid in (:vmUuids) and vm.state in (:vmStates) and vol.uuid = :volUuid and vm.hypervisorType in (:hvTypes) and vm.clusterUuid = ref.clusterUuid and ref.primaryStorageUuid = vol.primaryStorageUuid group by vm.uuid";
q = dbf.getEntityManager().createQuery(sql, VmInstanceVO.class);
q.setParameter("volUuid", self.getUuid());
List<String> hvTypes =
VolumeFormat.valueOf(self.getFormat())
.getHypervisorTypesSupportingThisVolumeFormatInString();
q.setParameter("hvTypes", hvTypes);
} else if (self.getStatus() == VolumeStatus.NotInstantiated) {
sql =
"select vm from VmInstanceVO vm where vm.uuid in (:vmUuids) and vm.state in (:vmStates) group by vm.uuid";
q = dbf.getEntityManager().createQuery(sql, VmInstanceVO.class);
} else {
DebugUtils.Assert(
false, String.format("should not reach here, volume[uuid:%s]", self.getUuid()));
}
q.setParameter("vmUuids", vmUuids);
}
q.setParameter("vmStates", Arrays.asList(VmInstanceState.Running, VmInstanceState.Stopped));
List<VmInstanceVO> vms = q.getResultList();
if (vms.isEmpty()) {
return vms;
}
VolumeInventory vol = getSelfInventory();
for (VolumeGetAttachableVmExtensionPoint ext :
pluginRgty.getExtensionList(VolumeGetAttachableVmExtensionPoint.class)) {
vms = ext.returnAttachableVms(vol, vms);
}
return vms;
}
private void deleteVolume(final VolumeDeletionMsg msg, final NoErrorCompletion completion) {
final VolumeDeletionReply reply = new VolumeDeletionReply();
for (VolumeDeletionExtensionPoint extp :
pluginRgty.getExtensionList(VolumeDeletionExtensionPoint.class)) {
extp.preDeleteVolume(getSelfInventory());
}
CollectionUtils.safeForEach(
pluginRgty.getExtensionList(VolumeDeletionExtensionPoint.class),
new ForEachFunction<VolumeDeletionExtensionPoint>() {
@Override
public void run(VolumeDeletionExtensionPoint arg) {
arg.beforeDeleteVolume(getSelfInventory());
}
});
FlowChain chain = FlowChainBuilder.newShareFlowChain();
chain.setName(String.format("delete-volume-%s", self.getUuid()));
// for NotInstantiated Volume, no flow to execute
chain.allowEmptyFlow();
chain
.then(
new ShareFlow() {
VolumeDeletionPolicy deletionPolicy;
{
if (msg.getDeletionPolicy() == null) {
deletionPolicy = deletionPolicyMgr.getDeletionPolicy(self.getUuid());
} else {
deletionPolicy = VolumeDeletionPolicy.valueOf(msg.getDeletionPolicy());
}
}
@Override
public void setup() {
if (self.getVmInstanceUuid() != null
&& self.getType() == VolumeType.Data
&& msg.isDetachBeforeDeleting()) {
flow(
new NoRollbackFlow() {
String __name__ = "detach-volume-from-vm";
public void run(final FlowTrigger trigger, Map data) {
DetachDataVolumeFromVmMsg dmsg = new DetachDataVolumeFromVmMsg();
dmsg.setVolume(getSelfInventory());
bus.makeTargetServiceIdByResourceUuid(
dmsg, VmInstanceConstant.SERVICE_ID, dmsg.getVmInstanceUuid());
bus.send(
dmsg,
new CloudBusCallBack(trigger) {
@Override
public void run(MessageReply reply) {
self.setVmInstanceUuid(null);
self = dbf.updateAndRefresh(self);
trigger.next();
}
});
}
});
}
if (deletionPolicy == VolumeDeletionPolicy.Direct) {
flow(
new NoRollbackFlow() {
String __name__ = "delete-data-volume-from-primary-storage";
@Override
public void run(final FlowTrigger trigger, Map data) {
if (self.getStatus() == VolumeStatus.Ready) {
DeleteVolumeOnPrimaryStorageMsg dmsg =
new DeleteVolumeOnPrimaryStorageMsg();
dmsg.setVolume(getSelfInventory());
dmsg.setUuid(self.getPrimaryStorageUuid());
bus.makeTargetServiceIdByResourceUuid(
dmsg,
PrimaryStorageConstant.SERVICE_ID,
self.getPrimaryStorageUuid());
logger.debug(
String.format(
"Asking primary storage[uuid:%s] to remove data volume[uuid:%s]",
self.getPrimaryStorageUuid(), self.getUuid()));
bus.send(
dmsg,
new CloudBusCallBack(trigger) {
@Override
public void run(MessageReply reply) {
if (!reply.isSuccess()) {
logger.warn(
String.format(
"failed to delete volume[uuid:%s, name:%s], %s",
self.getUuid(), self.getName(), reply.getError()));
}
trigger.next();
}
});
} else {
trigger.next();
}
}
});
}
if (self.getPrimaryStorageUuid() != null
&& deletionPolicy == VolumeDeletionPolicy.Direct) {
flow(
new NoRollbackFlow() {
String __name__ = "return-primary-storage-capacity";
@Override
public void run(FlowTrigger trigger, Map data) {
ReturnPrimaryStorageCapacityMsg rmsg =
new ReturnPrimaryStorageCapacityMsg();
rmsg.setPrimaryStorageUuid(self.getPrimaryStorageUuid());
rmsg.setDiskSize(self.getSize());
bus.makeTargetServiceIdByResourceUuid(
rmsg,
PrimaryStorageConstant.SERVICE_ID,
self.getPrimaryStorageUuid());
bus.send(rmsg);
trigger.next();
}
});
}
done(
new FlowDoneHandler(msg) {
@Override
public void handle(Map data) {
VolumeStatus oldStatus = self.getStatus();
if (deletionPolicy == VolumeDeletionPolicy.Direct) {
dbf.remove(self);
} else if (deletionPolicy == VolumeDeletionPolicy.Delay) {
self.setStatus(VolumeStatus.Deleted);
self = dbf.updateAndRefresh(self);
} else if (deletionPolicy == VolumeDeletionPolicy.Never) {
self.setStatus(VolumeStatus.Deleted);
self = dbf.updateAndRefresh(self);
}
new FireVolumeCanonicalEvent()
.fireVolumeStatusChangedEvent(oldStatus, getSelfInventory());
CollectionUtils.safeForEach(
pluginRgty.getExtensionList(VolumeDeletionExtensionPoint.class),
new ForEachFunction<VolumeDeletionExtensionPoint>() {
@Override
public void run(VolumeDeletionExtensionPoint arg) {
arg.afterDeleteVolume(getSelfInventory());
}
});
bus.reply(msg, reply);
}
});
error(
new FlowErrorHandler(msg) {
@Override
public void handle(final ErrorCode errCode, Map data) {
CollectionUtils.safeForEach(
pluginRgty.getExtensionList(VolumeDeletionExtensionPoint.class),
new ForEachFunction<VolumeDeletionExtensionPoint>() {
@Override
public void run(VolumeDeletionExtensionPoint arg) {
arg.failedToDeleteVolume(getSelfInventory(), errCode);
}
});
reply.setError(errCode);
bus.reply(msg, reply);
}
});
Finally(
new FlowFinallyHandler() {
@Override
public void Finally() {
completion.done();
}
});
}
})
.start();
}
private void expunge(final Completion completion) {
if (self.getStatus() != VolumeStatus.Deleted) {
throw new OperationFailureException(
errf.stringToOperationError(
String.format(
"the volume[uuid:%s, name:%s] is not deleted yet, can't expunge it",
self.getUuid(), self.getName())));
}
final VolumeInventory inv = getSelfInventory();
CollectionUtils.safeForEach(
pluginRgty.getExtensionList(VolumeBeforeExpungeExtensionPoint.class),
new ForEachFunction<VolumeBeforeExpungeExtensionPoint>() {
@Override
public void run(VolumeBeforeExpungeExtensionPoint arg) {
arg.volumeBeforeExpunge(inv);
}
});
if (self.getPrimaryStorageUuid() != null) {
DeleteVolumeOnPrimaryStorageMsg dmsg = new DeleteVolumeOnPrimaryStorageMsg();
dmsg.setVolume(getSelfInventory());
dmsg.setUuid(self.getPrimaryStorageUuid());
bus.makeTargetServiceIdByResourceUuid(
dmsg, PrimaryStorageConstant.SERVICE_ID, self.getPrimaryStorageUuid());
bus.send(
dmsg,
new CloudBusCallBack(completion) {
@Override
public void run(MessageReply r) {
if (!r.isSuccess()) {
completion.fail(r.getError());
} else {
ReturnPrimaryStorageCapacityMsg msg = new ReturnPrimaryStorageCapacityMsg();
msg.setPrimaryStorageUuid(self.getPrimaryStorageUuid());
msg.setDiskSize(self.getSize());
bus.makeTargetServiceIdByResourceUuid(
msg, PrimaryStorageConstant.SERVICE_ID, self.getPrimaryStorageUuid());
bus.send(msg);
CollectionUtils.safeForEach(
pluginRgty.getExtensionList(VolumeAfterExpungeExtensionPoint.class),
new ForEachFunction<VolumeAfterExpungeExtensionPoint>() {
@Override
public void run(VolumeAfterExpungeExtensionPoint arg) {
arg.volumeAfterExpunge(inv);
}
});
dbf.remove(self);
completion.success();
}
}
});
} else {
CollectionUtils.safeForEach(
pluginRgty.getExtensionList(VolumeAfterExpungeExtensionPoint.class),
new ForEachFunction<VolumeAfterExpungeExtensionPoint>() {
@Override
public void run(VolumeAfterExpungeExtensionPoint arg) {
arg.volumeAfterExpunge(inv);
}
});
dbf.remove(self);
completion.success();
}
}
@Test
public void test() throws ApiSenderException, InterruptedException {
HostInventory host2 = deployer.hosts.get("host2");
HostInventory host1 = deployer.hosts.get("host1");
VmInstanceInventory vm = deployer.vms.get("TestVm");
PrimaryStorageInventory local = deployer.primaryStorages.get("local");
List<VolumeVO> vols = dbf.listAll(VolumeVO.class);
List<VolumeVO> volumesOnLocal = new ArrayList<VolumeVO>();
ImageCacheVO cacheVO = dbf.listAll(ImageCacheVO.class).get(0);
long imageSize = cacheVO.getSize();
long usedVolumeSize = 0;
for (VolumeVO vol : vols) {
if (vol.getPrimaryStorageUuid().equals(local.getUuid())) {
volumesOnLocal.add(vol);
usedVolumeSize += ratioMgr.calculateByRatio(vol.getPrimaryStorageUuid(), vol.getSize());
}
}
config.createEmptyVolumeCmds.clear();
config.deleteBitsCmds.clear();
vm = api.migrateVmInstance(vm.getUuid(), host2.getUuid());
TimeUnit.SECONDS.sleep(5);
LocalStorageHostRefVO ref1 = dbf.findByUuid(host1.getUuid(), LocalStorageHostRefVO.class);
Assert.assertEquals(ref1.getTotalCapacity() - imageSize, ref1.getAvailableCapacity());
LocalStorageHostRefVO ref2 = dbf.findByUuid(host2.getUuid(), LocalStorageHostRefVO.class);
Assert.assertEquals(
ref2.getTotalCapacity() - imageSize - usedVolumeSize, ref2.getAvailableCapacity());
Assert.assertEquals(volumesOnLocal.size(), config.createEmptyVolumeCmds.size());
for (final VolumeVO vol : volumesOnLocal) {
// volumes are created on dst host
CreateEmptyVolumeCmd cmd =
CollectionUtils.find(
config.createEmptyVolumeCmds,
new Function<CreateEmptyVolumeCmd, CreateEmptyVolumeCmd>() {
@Override
public CreateEmptyVolumeCmd call(CreateEmptyVolumeCmd arg) {
return arg.getVolumeUuid().equals(vol.getUuid()) ? arg : null;
}
});
Assert.assertNotNull(cmd);
Assert.assertEquals(vol.getInstallPath(), cmd.getInstallUrl());
LocalStorageResourceRefVO r = dbf.findByUuid(vol.getUuid(), LocalStorageResourceRefVO.class);
Assert.assertEquals(host2.getUuid(), r.getHostUuid());
// volumes are deleted on src host
DeleteBitsCmd dcmd =
CollectionUtils.find(
config.deleteBitsCmds,
new Function<DeleteBitsCmd, DeleteBitsCmd>() {
@Override
public DeleteBitsCmd call(DeleteBitsCmd arg) {
return arg.getPath().equals(vol.getInstallPath()) ? arg : null;
}
});
Assert.assertNotNull(
String.format(
"no delete command for volume[uuid:%s, path:%s]",
vol.getUuid(), vol.getInstallPath()),
dcmd);
}
Assert.assertFalse(kconfig.migrateVmCmds.isEmpty());
MigrateVmCmd mcmd = kconfig.migrateVmCmds.get(0);
Assert.assertEquals(host2.getManagementIp(), mcmd.getDestHostIp());
Assert.assertEquals(vm.getUuid(), mcmd.getVmUuid());
Assert.assertEquals(
StorageMigrationPolicy.IncCopy.toString(), mcmd.getStorageMigrationPolicy());
}