use of org.ovirt.engine.core.bll.validator.storage.StorageDomainValidator in project ovirt-engine by oVirt.
the class AddVmCommand method validateSpaceRequirements.
/**
* Check if destination storage has enough space
*/
protected boolean validateSpaceRequirements() {
for (Map.Entry<Guid, List<DiskImage>> sdImageEntry : storageToDisksMap.entrySet()) {
StorageDomain destStorageDomain = destStorages.get(sdImageEntry.getKey());
List<DiskImage> disksList = sdImageEntry.getValue();
StorageDomainValidator storageDomainValidator = createStorageDomainValidator(destStorageDomain);
if (!validateDomainsThreshold(storageDomainValidator) || !validateFreeSpace(storageDomainValidator, disksList)) {
return false;
}
}
return true;
}
use of org.ovirt.engine.core.bll.validator.storage.StorageDomainValidator in project ovirt-engine by oVirt.
the class ImportVmTemplateCommand method validate.
@Override
protected boolean validate() {
if (getVmTemplate() == null) {
return failValidation(EngineMessage.ACTION_TYPE_FAILED_VM_NOT_FOUND);
}
if (getCluster() == null) {
return failValidation(EngineMessage.ACTION_TYPE_FAILED_CLUSTER_CAN_NOT_BE_EMPTY);
}
if (!getCluster().getStoragePoolId().equals(getStoragePoolId())) {
return failValidation(EngineMessage.ACTION_TYPE_FAILED_CLUSTER_IS_NOT_VALID);
}
setDescription(getVmTemplateName());
// check that the storage pool is valid
if (!validate(createStoragePoolValidator().existsAndUp()) || !validateTemplateArchitecture() || !isClusterCompatible()) {
return false;
}
// set the source domain and check that it is ImportExport type and active
setSourceDomainId(getParameters().getSourceDomainId());
StorageDomainValidator sourceDomainValidator = new StorageDomainValidator(getSourceDomain());
if (!validate(sourceDomainValidator.isDomainExistAndActive())) {
return false;
}
if ((getSourceDomain().getStorageDomainType() != StorageDomainType.ImportExport) && !getParameters().isImagesExistOnTargetStorageDomain()) {
return failValidation(EngineMessage.ACTION_TYPE_FAILED_STORAGE_DOMAIN_TYPE_ILLEGAL);
}
if (!getParameters().isImagesExistOnTargetStorageDomain()) {
// Set the template images from the Export domain and change each image id storage is to the import domain
GetAllFromExportDomainQueryParameters tempVar = new GetAllFromExportDomainQueryParameters(getParameters().getStoragePoolId(), getParameters().getSourceDomainId());
QueryReturnValue qretVal = runInternalQuery(QueryType.GetTemplatesFromExportDomain, tempVar);
if (!qretVal.getSucceeded()) {
return false;
}
Map<VmTemplate, List<DiskImage>> templates = qretVal.getReturnValue();
ArrayList<DiskImage> images = new ArrayList<>();
for (Map.Entry<VmTemplate, List<DiskImage>> entry : templates.entrySet()) {
if (entry.getKey().getId().equals(getVmTemplate().getId())) {
images = new ArrayList<>(entry.getValue());
getVmTemplate().setInterfaces(entry.getKey().getInterfaces());
getVmTemplate().setOvfVersion(entry.getKey().getOvfVersion());
break;
}
}
getParameters().setImages(images);
getVmTemplate().setImages(images);
ensureDomainMap(getImages(), getParameters().getDestDomainId());
HashMap<Guid, DiskImage> imageMap = new HashMap<>();
for (DiskImage image : images) {
if (Guid.Empty.equals(image.getVmSnapshotId())) {
return failValidation(EngineMessage.ACTION_TYPE_FAILED_CORRUPTED_VM_SNAPSHOT_ID);
}
StorageDomain storageDomain = getStorageDomain(imageToDestinationDomainMap.get(image.getId()));
StorageDomainValidator validator = new StorageDomainValidator(storageDomain);
if (!validate(validator.isDomainExistAndActive()) || !validate(validator.domainIsValidDestination())) {
return false;
}
StorageDomainStatic targetDomain = storageDomain.getStorageStaticData();
changeRawToCowIfSparseOnBlockDevice(targetDomain.getStorageType(), image);
if (!ImagesHandler.checkImageConfiguration(targetDomain, image, getReturnValue().getValidationMessages())) {
return false;
}
image.setStoragePoolId(getParameters().getStoragePoolId());
image.setStorageIds(new ArrayList<>(Collections.singletonList(storageDomain.getId())));
imageMap.put(image.getImageId(), image);
}
getVmTemplate().setDiskImageMap(imageMap);
}
sourceTemplateId = getVmTemplateId();
if (getParameters().isImportAsNewEntity()) {
initImportClonedTemplate();
}
VmTemplate duplicateTemplate = vmTemplateDao.get(getParameters().getVmTemplate().getId());
// check that the template does not exists in the target domain
if (duplicateTemplate != null) {
return failValidation(EngineMessage.VMT_CANNOT_IMPORT_TEMPLATE_EXISTS, String.format("$TemplateName %1$s", duplicateTemplate.getName()));
}
if (getVmTemplate().isBaseTemplate() && isVmTemplateWithSameNameExist()) {
return failValidation(EngineMessage.VM_CANNOT_IMPORT_TEMPLATE_NAME_EXISTS);
}
if (!validateNoDuplicateDiskImages(getImages())) {
return false;
}
if (getImages() != null && !getImages().isEmpty() && !getParameters().isImagesExistOnTargetStorageDomain()) {
if (!validateSpaceRequirements(getImages())) {
return false;
}
}
List<VmNetworkInterface> vmNetworkInterfaces = getVmTemplate().getInterfaces();
vmNicMacsUtils.replaceInvalidEmptyStringMacAddressesWithNull(vmNetworkInterfaces);
if (!validate(vmNicMacsUtils.validateMacAddress(vmNetworkInterfaces))) {
return false;
}
// if this is a template version, check base template exist
if (!getVmTemplate().isBaseTemplate()) {
VmTemplate baseTemplate = vmTemplateDao.get(getVmTemplate().getBaseTemplateId());
if (baseTemplate == null) {
return failValidation(EngineMessage.VMT_CANNOT_IMPORT_TEMPLATE_VERSION_MISSING_BASE);
}
}
if (!setAndValidateDiskProfiles()) {
return false;
}
if (!setAndValidateCpuProfile()) {
return false;
}
if (!validate(vmHandler.validateMaxMemorySize(getVmTemplate(), getEffectiveCompatibilityVersion()))) {
return false;
}
List<EngineMessage> msgs = openStackMetadataAdapter.validate(getVmTemplate().getVmInit());
if (!CollectionUtils.isEmpty(msgs)) {
return failValidation(msgs);
}
return true;
}
use of org.ovirt.engine.core.bll.validator.storage.StorageDomainValidator in project ovirt-engine by oVirt.
the class ImportVmTemplateFromConfigurationCommand method validateUnregisteredEntity.
private boolean validateUnregisteredEntity(VmTemplate entityFromConfiguration, OvfEntityData ovfEntityData) {
if (ovfEntityData == null && !getParameters().isImportAsNewEntity()) {
return failValidation(EngineMessage.ACTION_TYPE_FAILED_UNSUPPORTED_OVF);
}
if (entityFromConfiguration == null) {
return failValidation(EngineMessage.ACTION_TYPE_FAILED_OVF_CONFIGURATION_NOT_SUPPORTED);
}
ImportValidator importValidator = new ImportValidator(getParameters());
if (!validate(importValidator.validateDiskNotAlreadyExistOnDB(getImages(), getParameters().isAllowPartialImport(), imageToDestinationDomainMap, failedDisksToImportForAuditLog))) {
return false;
}
for (DiskImage image : new ArrayList<>(getImages())) {
DiskImage fromIrs = null;
Guid storageDomainId = image.getStorageIds().get(0);
Guid imageGroupId = image.getId() != null ? image.getId() : Guid.Empty;
try {
fromIrs = (DiskImage) runVdsCommand(VDSCommandType.GetImageInfo, new GetImageInfoVDSCommandParameters(getStoragePool().getId(), storageDomainId, imageGroupId, image.getImageId())).getReturnValue();
} catch (Exception e) {
log.debug("Unable to get image info from storage", e);
}
if (fromIrs == null) {
if (!getParameters().isAllowPartialImport()) {
return failValidation(EngineMessage.TEMPLATE_IMAGE_NOT_EXIST);
}
log.warn("Disk image '{}/{}' doesn't exist on storage domain '{}'. Ignoring since force flag in on", imageGroupId, image.getImageId(), storageDomainId);
getImages().remove(image);
failedDisksToImportForAuditLog.putIfAbsent(image.getId(), image.getDiskAlias());
}
}
for (DiskImage image : getImages()) {
StorageDomain sd = storageDomainDao.getForStoragePool(image.getStorageIds().get(0), getStoragePool().getId());
ValidationResult result = new StorageDomainValidator(sd).isDomainExistAndActive();
if (!result.isValid()) {
if (!getParameters().isAllowPartialImport()) {
return validate(result);
} else {
log.warn("storage domain '{}' does not exists. Ignoring since force flag in on", image.getStorageIds().get(0));
getImages().remove(image);
failedDisksToImportForAuditLog.putIfAbsent(image.getId(), image.getDiskAlias());
}
}
}
if (!getStorageDomain().getStorageDomainType().isDataDomain()) {
return failValidation(EngineMessage.ACTION_TYPE_FAILED_STORAGE_DOMAIN_TYPE_UNSUPPORTED, String.format("$domainId %1$s", getParameters().getStorageDomainId()), String.format("$domainType %1$s", getStorageDomain().getStorageDomainType()));
}
return true;
}
use of org.ovirt.engine.core.bll.validator.storage.StorageDomainValidator in project ovirt-engine by oVirt.
the class RemoveVmTemplateFromImportExportCommand method validate.
@Override
protected boolean validate() {
if (!validate(templateExists())) {
return false;
}
List<DiskImage> images = templatesFromExport.get(templatesFromExport.keySet().stream().filter(t -> t.getId().equals(getParameters().getVmTemplateId())).findFirst().orElse(null));
if (images != null) {
getParameters().setImages(images);
} else {
return failValidation(EngineMessage.ACTION_TYPE_FAILED_TEMPLATE_DOES_NOT_EXIST);
}
StorageDomainValidator validator = new StorageDomainValidator(getStorageDomain());
if (!validate(validator.isDomainExistAndActive())) {
return false;
}
if (getStorageDomain().getStorageDomainType() != StorageDomainType.ImportExport) {
return failValidation(EngineMessage.ACTION_TYPE_FAILED_STORAGE_DOMAIN_TYPE_ILLEGAL);
}
// We fetch from DB instead of using the VmTemplate property because
// it's the one from the export domain and not from database
VmTemplate tmpl = vmTemplateDao.get(getVmTemplateId());
if (tmpl != null) {
if (tmpl.getStatus() == VmTemplateStatus.Locked) {
return failValidation(EngineMessage.VM_TEMPLATE_IMAGE_IS_LOCKED);
}
}
return true;
}
use of org.ovirt.engine.core.bll.validator.storage.StorageDomainValidator in project ovirt-engine by oVirt.
the class LiveMigrateDiskCommand method validateDestDomainsSpaceRequirements.
protected boolean validateDestDomainsSpaceRequirements() {
if (!isStorageDomainWithinThresholds(getDstStorageDomain())) {
return false;
}
DiskImage diskImage = getDiskImageByImageId(getParameters().getImageId());
List<DiskImage> allImageSnapshots = diskImageDao.getAllSnapshotsForLeaf(diskImage.getImageId());
diskImage.getSnapshots().addAll(allImageSnapshots);
StorageDomainValidator storageDomainValidator = createStorageDomainValidator(getDstStorageDomain());
if (!validate(storageDomainValidator.hasSpaceForClonedDisks(Collections.singleton(diskImage)))) {
return false;
}
return true;
}
Aggregations