/** * Check if template is special 'Blank' template or its version. * <p>Blank template is recognized by id being {@link org.ovirt.engine.core.compat.Guid#Empty}</p> * @return true if this is Blank template, false otherwise */ public boolean isBlank() { return Guid.Empty.equals(getBaseTemplateId()); } }
protected String createSearchPattern(Collection<VmTemplate> templates) { String vmt_guidKey = "_VMT_ID ="; //$NON-NLS-1$ String orKey = " or "; //$NON-NLS-1$ StringBuilder searchPattern = new StringBuilder(); searchPattern.append("Template: "); //$NON-NLS-1$ for (VmTemplate template : templates) { searchPattern.append(vmt_guidKey); searchPattern.append(template.getId().toString()); searchPattern.append(orKey); searchPattern.append(vmt_guidKey); searchPattern.append(template.getBaseTemplateId().toString()); searchPattern.append(orKey); } return searchPattern.substring(0, searchPattern.length() - orKey.length()); }
/** * It has to hold {@code baseTemplate.getId().equals(templateVersion.getBaseTemplateId())} * @param baseTemplate base template, required non-null * @param templateVersion template version of {@code baseTemplate}, required non-null */ public TemplateWithVersion(VmTemplate baseTemplate, VmTemplate templateVersion) { if (baseTemplate == null || templateVersion == null || !baseTemplate.getId().equals(templateVersion.getBaseTemplateId())) { throw new IllegalArgumentException("Arguments of TemplateWithVersion constructor has to be non-null, " + //$NON-NLS-1$ "templateVersion has to be version of baseTemplate."); //$NON-NLS-1$ } this.baseTemplate = baseTemplate; this.templateVersion = templateVersion; }
private void genVersionToBaseTemplate(Iterable<VmTemplate> items) { if (items == null) { templateIdToBaseTemplateName = null; return; } Map<Guid, VmTemplate> templateIdToTemplate = new HashMap<>(); for (VmTemplate template : items) { templateIdToTemplate.put(template.getId(), template); } templateIdToBaseTemplateName = new HashMap<>(); for (VmTemplate template : items) { VmTemplate baseTemplate = templateIdToTemplate.get(template.getBaseTemplateId()); templateIdToBaseTemplateName.put(template.getId(), baseTemplate != null ? baseTemplate.getName() : ""); //$NON-NLS-1$ } }
/** * Check if template is base template or version of a template * @return true if template is a base template, and false if its a version of a template */ public boolean isBaseTemplate() { return getId().equals(getBaseTemplateId()); }
for (VmTemplate template : templates) { if (baseIdToLastVersionMap.get(template.getBaseTemplateId()).getTemplateVersionNumber() < template.getTemplateVersionNumber()) { baseIdToLastVersionMap.put(template.getBaseTemplateId(), template); final VmTemplate baseTemplate = baseIdToBaseTemplateMap.get(template.getBaseTemplateId()); result.add(new TemplateWithVersion(baseTemplate, template));
static VmTemplate setUpEntityExpectations(VmTemplate entity, int index) { when(entity.getId()).thenReturn(GUIDS[index]); when(entity.getClusterId()).thenReturn(GUIDS[2]); when(entity.getName()).thenReturn(NAMES[index]); when(entity.getDescription()).thenReturn(DESCRIPTIONS[index]); when(entity.getNumOfCpus()).thenReturn(8); when(entity.getNumOfSockets()).thenReturn(2); when(entity.getThreadsPerCpu()).thenReturn(1); when(entity.getCpuPerSocket()).thenReturn(4); if(index == 2) { when(entity.getTemplateVersionName()).thenReturn(VERSION_NAME); when(entity.getTemplateVersionNumber()).thenReturn(2); when(entity.getBaseTemplateId()).thenReturn(GUIDS[1]); when(entity.isBaseTemplate()).thenReturn(false); } else { when(entity.getTemplateVersionNumber()).thenReturn(1); // same base template id as the template itself when(entity.getBaseTemplateId()).thenReturn(GUIDS[index]); when(entity.isBaseTemplate()).thenReturn(true); } when(entity.getSmallIconId()).thenReturn(GUIDS[2]); when(entity.getLargeIconId()).thenReturn(GUIDS[3]); return entity; }
@Override public void onSuccess(QueryReturnValue returnValue) { UIConstants constants = ConstantsManager.getInstance().getConstants(); List<VmTemplate> vmtList = returnValue.getReturnValue(); List<ImportTemplateData> templateDataList = new ArrayList<>(); for (VmTemplate template : externalTemplates) { ImportTemplateData templateData = new ImportTemplateData(template); boolean templateExistsInSystem = vmtList.contains(template); templateData.setExistsInSystem(templateExistsInSystem); if (templateExistsInSystem) { templateData.enforceClone(constants.importTemplateThatExistsInSystemMustClone()); } else if (!template.isBaseTemplate() && findAnyVmTemplateById(vmtList, template.getBaseTemplateId()) == null) { templateData.enforceClone(constants.importTemplateWithoutBaseMustClone()); } templateDataList.add(templateData); } setItems(templateDataList); withDataCenterLoaded(storageDomainId, r -> doInit()); }
private void postGetTemplatesNotPresentOnExportDomain(StoragePool storagePool) { ExportVmModel model = (ExportVmModel) getWindow(); Guid storageDomainId = model.getStorage().getSelectedItem().getId(); if (storagePool != null) { AsyncDataProvider.getInstance().getAllTemplatesFromExportDomain(new AsyncQuery<>( templatesDiskSet -> { ArrayList<String> verTempMissingBase = new ArrayList<>(); // check if relevant templates are already there for (Object selectedItem : getSelectedItems()) { VmTemplate template = (VmTemplate) selectedItem; // only relevant for template versions if (!template.isBaseTemplate()) { boolean hasMatch = false; for (VmTemplate a : templatesDiskSet.keySet()) { if (template.getBaseTemplateId().equals(a.getId())) { hasMatch = true; break; } } if (!template.getBaseTemplateId().equals(Guid.Empty) && !hasMatch) { verTempMissingBase.add(template.getName()); } } } postExportGetMissingTemplates(verTempMissingBase); }), storagePool.getId(), storageDomainId); } }
templateData.enforceClone(constants.importTemplateThatExistsInSystemMustClone()); } else if (!template.isBaseTemplate() && vmtList.stream().anyMatch(t -> t.getId().equals(template.getBaseTemplateId()))) { templateData.enforceClone(constants.importTemplateWithoutBaseMustClone());
@Override protected void writeGeneralData() { super.writeGeneralData(); _writer.writeElement(TEMPLATE_ID, template.getId().toString()); OriginType originType = template.getOrigin(); _writer.writeElement(ORIGIN, originType == null ? "" : String.valueOf(originType.getValue())); _writer.writeElement(VM_DEFAULT_DISPLAY_TYPE, String.valueOf(template.getDefaultDisplayType().getValue())); _writer.writeElement(IS_DISABLED, String.valueOf(template.isDisabled())); _writer.writeElement(TRUSTED_SERVICE, String.valueOf(template.isTrustedService())); _writer.writeElement(TEMPLATE_TYPE, template.getTemplateType().name()); _writer.writeElement(BASE_TEMPLATE_ID, template.getBaseTemplateId().toString()); _writer.writeElement(TEMPLATE_VERSION_NUMBER, String.valueOf(template.getTemplateVersionNumber())); _writer.writeElement(TEMPLATE_VERSION_NAME, template.getTemplateVersionName()); }
@Override protected void writeGeneralData() { super.writeGeneralData(); _writer.writeElement(TEMPLATE_ID, vmTemplate.getId().toString()); OriginType originType = vmTemplate.getOrigin(); _writer.writeElement(ORIGIN, originType == null ? "" : String.valueOf(originType.getValue())); _writer.writeElement(TEMPLATE_DEFAULT_DISPLAY_TYPE, String.valueOf(vmTemplate.getDefaultDisplayType().getValue())); _writer.writeElement(IS_DISABLED, String.valueOf(vmTemplate.isDisabled())); _writer.writeElement(TRUSTED_SERVICE, String.valueOf(vmTemplate.isTrustedService())); _writer.writeElement(TEMPLATE_TYPE, vmTemplate.getTemplateType().name()); _writer.writeElement(BASE_TEMPLATE_ID, vmTemplate.getBaseTemplateId().toString()); _writer.writeElement(TEMPLATE_VERSION_NUMBER, String.valueOf(vmTemplate.getTemplateVersionNumber())); _writer.writeElement(TEMPLATE_VERSION_NAME, vmTemplate.getTemplateVersionName()); }
public VmTemplate(VmTemplate template) { super(template); diskTemplateMap = new HashMap<>(); diskImageMap = new HashMap<>(); setChildCount(template.getChildCount()); setStatus(template.getStatus()); setTemplateType(template.getTemplateType()); setBaseTemplateId(template.getBaseTemplateId()); setTemplateVersionName(template.getTemplateVersionName()); setTemplateVersionNumber(template.getTemplateVersionNumber()); setDisabled(template.isDisabled()); setDescription(this.getDescription()); }
baseTemplate = selectedTemplate; Guid baseTemplateId = selectedTemplate.getBaseTemplateId(); if (template.getBaseTemplateId().equals(baseTemplateId)) { if (template.getClusterId() == null || template.getClusterId().equals(clusterId)) { relatedTemplates.add(template);
for (VmTemplate template : properArchitectureTemplates) { final boolean isBlankOrVersionOfBlank = template.getId().equals(Guid.Empty) || template.getBaseTemplateId().equals(Guid.Empty); if (!isBlankOrVersionOfBlank) { templatesWithoutBlank.add(template);
@Override protected MapSqlParameterSource createFullParametersMapper(VmTemplate template) { return createBaseParametersMapper(template) .addValue("child_count", template.getChildCount()) .addValue("name", template.getName()) .addValue("status", template.getStatus()) .addValue("is_disabled", template.isDisabled()) .addValue("template_type", template.getTemplateType().name()) .addValue("base_template_id", template.getBaseTemplateId()) .addValue("template_version_name", template.getTemplateVersionName()); }
@Override public SafeHtml getName(VmTemplate item) { SafeHtmlBuilder builder = new SafeHtmlBuilder(); builder.append(super.getName(item)); if (!item.getId().equals(item.getBaseTemplateId())) { if (item.getTemplateVersionName() != null) { builder.appendEscaped("/"); // $NON-NLS-1$ builder.appendEscaped(item.getTemplateVersionName()); } builder.appendEscaped(" ("); // $NON-NLS-1$ builder.append(item.getTemplateVersionNumber()); builder.appendEscaped(")"); // $NON-NLS-1$ } return builder.toSafeHtml(); } }
new AsyncQuery<>(templatesChain -> initTemplateWithVersion(templatesChain, templateId, useLatest)), rawTemplate.getBaseTemplateId()); } else { final VmTemplate template = useLatest setReadOnlyTemplateWithVersion(templateCouple); }), template.getBaseTemplateId());
private void postInitTemplate(List<VmTemplate> templates) { List<VmTemplate> baseWithoutBlank = filterOutBlank(keepBaseTemplates(templates)); getModel().getIsSubTemplate().setEntity(false); if (baseWithoutBlank.isEmpty()) { // it is not allowed to create sub-templates of Blank template getModel().getIsSubTemplate().setIsChangeable(false, constants.someNonDefaultTemplateHasToExistFirst()); return; } getModel().getIsSubTemplate().setIsChangeable(true); VmTemplate currentTemplate = Linq.firstOrNull(templates, new Linq.IdPredicate<>(vm.getVmtGuid())); getModel().getBaseTemplate().setItems(baseWithoutBlank); getModel().getBaseTemplate().setSelectedItem(Linq.firstOrNull(baseWithoutBlank, new Linq.IdPredicate<>(currentTemplate.getBaseTemplateId()))); }
version.setVersionNumber(entity.getTemplateVersionNumber()); Template baseTemplate = new Template(); baseTemplate.setId(entity.getBaseTemplateId().toString()); version.setBaseTemplate(baseTemplate); model.setVersion(version);