private void ensureDestinationImageMap() {
if (MapUtils.isEmpty(getParameters().getDiskInfoDestinationMap())) {
diskInfoDestinationMap = new HashMap<>();
if (getVmTemplate() == null) {
return;
}
if (!Guid.isNullOrEmpty(getParameters().getStorageDomainId())) {
Guid storageId = getParameters().getStorageDomainId();
ArrayList<Guid> storageIds = new ArrayList<>();
storageIds.add(storageId);
for (DiskImage image : getVmTemplate().getDiskTemplateMap().values()) {
image.setStorageIds(storageIds);
diskInfoDestinationMap.put(image.getId(), image);
}
} else {
ImagesHandler.fillImagesMapBasedOnTemplate(
getVmTemplate(), diskInfoDestinationMap, destStorages);
}
} else {
diskInfoDestinationMap = getParameters().getDiskInfoDestinationMap();
}
storageToDisksMap =
ImagesHandler.buildStorageToDiskMap(
getVmTemplate().getDiskTemplateMap().values(), diskInfoDestinationMap);
}
/**
* @param images The images to get the storage domain IDs for
* @return A unique {@link Set} of all the storage domain IDs relevant to all the given images
*/
public static Set<Guid> getAllStorageIdsForImageIds(Collection<DiskImage> images) {
Set<Guid> domainsIds = new HashSet<>();
for (DiskImage image : images) {
domainsIds.addAll(image.getStorageIds());
}
return domainsIds;
}
private void setDefaultBootDevice() {
// In the time of disk creation the VM ID is an empty Guid, this is changed to the real ID only
// after the reading
// of the OS properties which comes after the disks creation so the disk VM elements are set to
// the wrong VM ID
// this part sets them to the correct VM ID
for (DiskImage disk : _images) {
disk.getDiskVmElements()
.stream()
.forEach(dve -> dve.setId(new VmDeviceId(disk.getId(), vmBase.getId())));
disk.setDiskVmElements(disk.getDiskVmElements());
}
boolean hasBootDevice =
vmBase
.getManagedDeviceMap()
.values()
.stream()
.anyMatch(device -> device.getBootOrder() > 0);
if (hasBootDevice) {
return;
}
AtomicInteger order =
new AtomicInteger(1); // regular non-final variable cannot be used in lambda expression
_images
.stream()
.filter(d -> d.getDiskVmElementForVm(vmBase.getId()).isBoot())
.map(image -> vmBase.getManagedDeviceMap().get(image.getId()))
.filter(Objects::nonNull)
.forEachOrdered(device -> device.setBootOrder(order.getAndIncrement()));
}
private void onChangeQuota() {
ChangeQuotaModel model = (ChangeQuotaModel) getWindow();
ArrayList<VdcActionParametersBase> paramerterList = new ArrayList<VdcActionParametersBase>();
for (Object item : model.getItems()) {
ChangeQuotaItemModel itemModel = (ChangeQuotaItemModel) item;
DiskImage disk = itemModel.getEntity();
VdcActionParametersBase parameters =
new ChangeQuotaParameters(
itemModel.getQuota().getSelectedItem().getId(),
disk.getId(),
itemModel.getStorageDomainId(),
disk.getStoragePoolId());
paramerterList.add(parameters);
}
model.startProgress();
Frontend.getInstance()
.runMultipleAction(
VdcActionType.ChangeQuotaForDisk,
paramerterList,
new IFrontendMultipleActionAsyncCallback() {
@Override
public void executed(FrontendMultipleActionAsyncResult result) {
cancel();
}
},
this);
}
private void canDoActionMakeDiskBootableOnOtherVm(boolean boot) {
UpdateVmDiskParameters parameters = createParameters();
Disk newDisk = parameters.getDiskInfo();
newDisk.setBoot(true);
Guid otherVmId = Guid.newGuid();
VM otherVm = new VM();
otherVm.setId(otherVmId);
DiskImage otherDisk = new DiskImage();
otherDisk.setId(Guid.newGuid());
otherDisk.setActive(true);
otherDisk.setBoot(boot);
if (boot) {
when(diskDao.getVmBootActiveDisk(otherVmId)).thenReturn(otherDisk);
}
when(diskDao.get(diskImageGuid)).thenReturn(createDiskImage());
initializeCommand(parameters, Arrays.asList(createVmStatusDown(), otherVm));
mockInterfaceList();
// The command should only succeed if there is no other bootable disk
assertEquals(!boot, command.canDoAction());
}
/** The following method will create a Shareable DiskImage with a specified format */
private DiskImage createShareableDisk(VolumeFormat volumeFormat) {
DiskImage disk = createDiskImage();
disk.setvolumeFormat(volumeFormat);
disk.setShareable(true);
disk.setDiskInterface(DiskInterface.VirtIO);
return disk;
}
private void onRemove() {
RemoveDiskModel model = (RemoveDiskModel) getWindow();
ArrayList<VdcActionParametersBase> paramerterList = new ArrayList<>();
for (Object item : getSelectedItems()) {
DiskImage disk = (DiskImage) item;
VdcActionParametersBase parameters =
new RemoveDiskParameters(disk.getId(), getEntity().getId());
paramerterList.add(parameters);
}
model.startProgress();
Frontend.getInstance()
.runMultipleAction(
VdcActionType.RemoveDisk,
paramerterList,
new IFrontendMultipleActionAsyncCallback() {
@Override
public void executed(FrontendMultipleActionAsyncResult result) {
StorageDiskListModel localModel = (StorageDiskListModel) result.getState();
localModel.stopProgress();
cancel();
}
},
this);
}
public boolean checkDestDomains() {
List<Guid> validDomains = new ArrayList<>();
for (DiskImage diskImage : diskInfoDestinationMap.values()) {
Guid domainId = diskImage.getStorageIds().get(0);
if (validDomains.contains(domainId)) {
continue;
}
StorageDomain domain = destStorages.get(domainId);
if (domain == null) {
domain =
getStorageDomainDao().getForStoragePool(domainId, getVmTemplate().getStoragePoolId());
destStorages.put(domainId, domain);
}
if (storageToDisksMap.containsKey(domainId)) {
int numOfDisksOnDomain = storageToDisksMap.get(domainId).size();
if (numOfDisksOnDomain > 0
&& (domain.getStorageDomainType() == StorageDomainType.ImportExport)) {
return failCanDoAction(EngineMessage.ACTION_TYPE_FAILED_STORAGE_DOMAIN_TYPE_ILLEGAL);
}
}
validDomains.add(domainId);
}
return validateSpaceRequirements();
}
private void syncDbRecordsMergeFailure() {
DiskImage curr = getDestinationDiskImage();
while (!curr.getImageId().equals(getDiskImage().getImageId())) {
curr = getDbFacade().getDiskImageDao().getSnapshotById(curr.getParentId());
getImageDao().updateStatus(curr.getImageId(), ImageStatus.ILLEGAL);
}
}
private static DiskImage createPreallocDiskImage() {
DiskImage image = new DiskImage();
image.setVolumeType(VolumeType.Preallocated);
image.setDiskInterface(DiskInterface.IDE);
image.setSizeInGigabytes(5);
return image;
}
private static DiskImage createDiskImageTemplate() {
DiskImage i = new DiskImage();
i.setSizeInGigabytes(USED_SPACE_GB + AVAILABLE_SPACE_GB);
i.setActualSizeInBytes(REQUIRED_DISK_SIZE_GB * 1024L * 1024L * 1024L);
i.setImageId(Guid.newGuid());
i.setStorageIds(new ArrayList<>(Collections.singletonList(STORAGE_DOMAIN_ID_1)));
return i;
}
private static DiskImage getDiskImageById(Guid id, Iterable<DiskImage> diskImages) {
for (DiskImage diskImage : diskImages) {
if (diskImage.getId().equals(id)) {
return diskImage;
}
}
return null;
}
public static void fillImagesBySnapshots(VM vm) {
for (Disk disk : vm.getDiskMap().values()) {
if (disk.getDiskStorageType().isInternal()) {
DiskImage diskImage = (DiskImage) disk;
diskImage.getSnapshots().addAll(getAllImageSnapshots(diskImage.getImageId()));
}
}
}
/**
* Returns a list of image IDs for the specified DiskImages collection.
*
* @param diskImages collection of DiskImages
* @return list of image IDs ordered by the order of the retrieved list.
*/
public static List<Guid> getDiskImageIds(List<DiskImage> diskImages) {
List<Guid> result = new ArrayList<>();
if (diskImages != null) {
for (DiskImage diskImage : diskImages) {
result.add(diskImage.getImageId());
}
}
return result;
}
/**
* Gets a map of DiskImage IDs to DiskImage objects
*
* @param diskImages collection of DiskImage objects to create the map for
* @return map object is the collection is not null
*/
public static Map<Guid, DiskImage> getDiskImagesByIdMap(Collection<DiskImage> diskImages) {
Map<Guid, DiskImage> result = new HashMap<>();
if (diskImages != null) {
for (DiskImage diskImage : diskImages) {
result.put(diskImage.getImageId(), diskImage);
}
}
return result;
}
/**
* Adds a disk image (Adds image, disk, and relevant entities , but not VmDevice) This may be
* useful for Clone VMs, where besides adding images it is required to copy all vm devices
* (VmDeviceUtils.copyVmDevices) from the source VM.
*/
public static void addDiskImageWithNoVmDevice(DiskImage image) {
addDiskImageWithNoVmDevice(
image,
image.getActive(),
new ImageStorageDomainMap(
image.getImageId(),
image.getStorageIds().get(0),
image.getQuotaId(),
image.getDiskProfileId()));
}
/**
* Returns the subtraction set of the specified image lists (based on images' IDs)
*
* @param images full list
* @param imagesToSubtract images to subtract list
* @return the subtraction set
*/
public static List<DiskImage> imagesSubtract(
Iterable<DiskImage> images, Iterable<DiskImage> imagesToSubtract) {
List<DiskImage> subtract = new ArrayList<>();
for (DiskImage image : images) {
if (getDiskImageById(image.getId(), imagesToSubtract) == null) {
subtract.add(image);
}
}
return subtract;
}
/**
* Returns the intersection set of the specified image lists (based on images' IDs)
*
* @param images1 1st list
* @param images2 2nd list
* @return the intersection set
*/
public static List<DiskImage> imagesIntersection(
Iterable<DiskImage> images1, Iterable<DiskImage> images2) {
List<DiskImage> intersection = new ArrayList<>();
for (DiskImage image : images1) {
if (getDiskImageById(image.getId(), images2) != null) {
intersection.add(image);
}
}
return intersection;
}
@Override
public String getVolumeStringRepresentation() {
return MemoryUtils.createMemoryStateString(
storageDomainId,
storagePool.getId(),
memoryDisk.getId(),
memoryDisk.getImageId(),
metadataDisk.getId(),
metadataDisk.getImageId());
}
@Before
public void setUp() {
vmId = Guid.newGuid();
diskId = Guid.newGuid();
poolId = Guid.newGuid();
storageDomainId = Guid.newGuid();
groupId = Guid.newGuid();
vdsId = Guid.newGuid();
disk = new DiskImage();
disk.setId(diskId);
disk.setVmEntityType(VmEntityType.VM);
disk.setImageStatus(ImageStatus.OK);
disk.setStorageIds(new ArrayList<>(Arrays.asList(storageDomainId)));
vm = new VM();
vm.setId(vmId);
vm.setStatus(VMStatus.Down);
vm.setStoragePoolId(poolId);
vm.setClusterId(groupId);
VmDeviceId vmDeviceId = new VmDeviceId(diskId, vmId);
vmDevice = new VmDevice();
vmDevice.setId(vmDeviceId);
cluster = new Cluster();
cluster.setId(groupId);
vds = new VDS();
vds.setId(vdsId);
storagePool = new StoragePool();
storagePool.setStatus(StoragePoolStatus.Up);
storageDomain = new StorageDomain();
storageDomain.setStorageType(StorageType.ISCSI);
when(vmDao.getVmsListForDisk(diskId, Boolean.FALSE)).thenReturn(Collections.singletonList(vm));
when(vmDeviceDao.get(vmDeviceId)).thenReturn(vmDevice);
when(vdsDao.getAllForClusterWithStatus(groupId, VDSStatus.Up))
.thenReturn(Collections.singletonList(vds));
when(spDao.get(poolId)).thenReturn(storagePool);
when(clusterDao.get(groupId)).thenReturn(cluster);
when(storageDomainStaticDao.get(storageDomainId))
.thenReturn(storageDomain.getStorageStaticData());
cmd = spy(new GetDiskAlignmentCommand<>(new GetDiskAlignmentParameters(diskId), null));
doReturn(disk).when(cmd).getDisk();
doReturn(vdsDao).when(cmd).getVdsDao();
doReturn(vmDao).when(cmd).getVmDao();
doReturn(spDao).when(cmd).getStoragePoolDao();
doReturn(clusterDao).when(cmd).getClusterDao();
doReturn(storageDomainStaticDao).when(cmd).getStorageDomainStaticDao();
}
private void buildImageReference() {
XmlNodeList list = selectNodes(_document, "//*/File", _xmlNS);
for (XmlNode node : list) {
// If the disk storage type is Cinder then override the disk image with Cinder object,
// otherwise use the disk image.
DiskImage disk = new DiskImage();
// If the OVF is old and does not contain any storage type reference then we assume we can
// only have disk image.
if (node.attributes.get("ovf:disk_storage_type") != null) {
String diskStorageType = node.attributes.get("ovf:disk_storage_type").getValue();
if (diskStorageType != null && diskStorageType.equals(DiskStorageType.CINDER.name())) {
disk = new CinderDisk();
if (node.attributes.get("ovf:cinder_volume_type") != null) {
String cinderVolumeType = node.attributes.get("ovf:cinder_volume_type").getValue();
disk.setCinderVolumeType(cinderVolumeType);
}
}
}
disk.setImageId(new Guid(node.attributes.get("ovf:id").getValue()));
disk.setId(
OvfParser.getImageGroupIdFromImageFile(node.attributes.get("ovf:href").getValue()));
// Default values:
disk.setActive(true);
disk.setImageStatus(ImageStatus.OK);
disk.setDescription(node.attributes.get("ovf:description").getValue());
disk.setDiskVmElements(
Collections.singletonList(new DiskVmElement(disk.getId(), vmBase.getId())));
_images.add(disk);
}
}
private boolean isRemoveCommandAvailable(ArrayList<DiskImage> disks) {
for (DiskImage disk : disks) {
boolean isImageLocked = disk.getImageStatus() == ImageStatus.LOCKED;
if (isImageLocked) {
return false;
}
}
return true;
}
@Test
public void testResize() {
DiskImage oldDisk = createDiskImage();
when(diskDao.get(diskImageGuid)).thenReturn(oldDisk);
UpdateVmDiskParameters parameters = createParameters();
((DiskImage) parameters.getDiskInfo()).setSize(oldDisk.getSize() * 2);
initializeCommand(parameters);
assertTrue(command.validateCanResizeDisk());
}
private void canDoActionUpdateDescription(VMStatus status) {
DiskImage disk = createDiskImage();
disk.setReadOnly(false);
when(diskDao.get(diskImageGuid)).thenReturn(disk);
UpdateVmDiskParameters parameters = createParameters();
parameters.getDiskInfo().setReadOnly(false);
disk.setDescription(RandomUtils.instance().nextString(10));
initializeCommand(parameters, Collections.singletonList(createVm(status)));
CanDoActionTestUtils.runAndAssertCanDoActionSuccess(command);
}
/**
* This method is used for storage allocation validations, where the disks are the template's,
* which could have another volume type/format than the target disk volume type/format, which is
* not yet created. "Real" override for these values is done in CreateSnapshotCommand, when
* creating the new DiskImages.
*/
public static List<DiskImage> getDisksDummiesForStorageAllocations(
Collection<DiskImage> originalDisks) {
List<DiskImage> diskDummies = new ArrayList<>(originalDisks.size());
for (DiskImage diskImage : originalDisks) {
DiskImage clone = DiskImage.copyOf(diskImage);
clone.setVolumeType(VolumeType.Sparse);
clone.setvolumeFormat(VolumeFormat.COW);
diskDummies.add(clone);
}
return diskDummies;
}
/**
* Adds a disk image (Adds image with active flag according to the value in image, using the first
* storage domain in the storage id as entry to the storage domain map)
*
* @param image DiskImage to add
*/
public static void addDiskImage(DiskImage image, Guid vmId) {
addDiskImage(
image,
image.getActive(),
new ImageStorageDomainMap(
image.getImageId(),
image.getStorageIds().get(0),
image.getQuotaId(),
image.getDiskProfileId()),
vmId);
}
// the last image in each list is the leaf
public static Map<Guid, List<DiskImage>> getImagesLeaf(List<DiskImage> images) {
Map<Guid, List<DiskImage>> retVal = new HashMap<>();
for (DiskImage image : images) {
MultiValueMapUtils.addToMap(image.getId(), image, retVal);
}
for (List<DiskImage> list : retVal.values()) {
sortImageList(list);
}
return retVal;
}
private void updateDiskVmSnapshotId() {
Guid snapshotId = getSnapshotDao().getId(getVmId(), SnapshotType.ACTIVE);
if (disk.getDiskStorageType().isInternal()) {
DiskImage diskImage = ((DiskImage) disk);
getImageDao().updateImageVmSnapshotId(diskImage.getImageId(), snapshotId);
} else {
throw new EngineException(
EngineError.StorageException,
"update of snapshot id was initiated for unsupported disk type");
}
}
/**
* Add image and related entities to DB (Adds image, disk image dynamic and image storage domain
* map)
*
* @param image the image to add
* @param active if true the image will be active
* @param imageStorageDomainMap entry of mapping between the storage domain and the image
*/
public static void addImage(
DiskImage image, boolean active, ImageStorageDomainMap imageStorageDomainMap) {
image.setActive(active);
DbFacade.getInstance().getImageDao().save(image.getImage());
DiskImageDynamic diskDynamic = new DiskImageDynamic();
diskDynamic.setId(image.getImageId());
diskDynamic.setActualSize(image.getActualSizeInBytes());
DbFacade.getInstance().getDiskImageDynamicDao().save(diskDynamic);
if (imageStorageDomainMap != null) {
DbFacade.getInstance().getImageStorageDomainMapDao().save(imageStorageDomainMap);
}
}
protected boolean setAndValidateDiskProfiles() {
if (diskInfoDestinationMap != null && !diskInfoDestinationMap.isEmpty()) {
Map<DiskImage, Guid> map = new HashMap<>();
for (DiskImage diskImage : diskInfoDestinationMap.values()) {
map.put(diskImage, diskImage.getStorageIds().get(0));
}
return validate(
DiskProfileHelper.setAndValidateDiskProfiles(
map, getStoragePool().getCompatibilityVersion(), getCurrentUser()));
}
return true;
}
