Java tutorial
/*- * ============LICENSE_START======================================================= * SDC * ================================================================================ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. * ================================================================================ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * ============LICENSE_END========================================================= */ package org.openecomp.sdc.tosca.services.impl; import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.collections4.MapUtils; import org.openecomp.core.utilities.CommonMethods; import org.openecomp.sdc.common.errors.CoreException; import org.openecomp.sdc.tosca.datatypes.ToscaCapabilityType; import org.openecomp.sdc.tosca.datatypes.ToscaElementTypes; import org.openecomp.sdc.tosca.datatypes.ToscaNodeType; import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel; import org.openecomp.sdc.tosca.datatypes.model.CapabilityType; import org.openecomp.sdc.tosca.datatypes.model.Import; import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate; import org.openecomp.sdc.tosca.datatypes.model.NodeType; import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment; import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate; import org.openecomp.sdc.tosca.errors.ToscaInvalidEntryNotFoundErrorBuilder; import org.openecomp.sdc.tosca.errors.ToscaInvalidSubstituteNodeTemplatePropertiesErrorBuilder; import org.openecomp.sdc.tosca.errors.ToscaInvalidSubstitutionServiceTemplateErrorBuilder; import org.openecomp.sdc.tosca.errors.ToscaNodeTypeNotFoundErrorBuilder; import org.openecomp.sdc.tosca.services.ToscaAnalyzerService; import org.openecomp.sdc.tosca.services.ToscaConstants; import org.openecomp.sdc.tosca.services.yamlutil.ToscaExtensionYamlUtil; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Objects; import java.util.Optional; import java.util.Set; public class ToscaAnalyzerServiceImpl implements ToscaAnalyzerService { /* node template with type equal to node type or derived from node type. */ @Override public Map<String, NodeTemplate> getNodeTemplatesByType(ServiceTemplate serviceTemplate, String nodeType, ToscaServiceModel toscaServiceModel) { Map<String, NodeTemplate> nodeTemplates = new HashMap<>(); if (Objects.nonNull(serviceTemplate.getTopology_template()) && MapUtils.isNotEmpty(serviceTemplate.getTopology_template().getNode_templates())) { for (Map.Entry<String, NodeTemplate> nodeTemplateEntry : serviceTemplate.getTopology_template() .getNode_templates().entrySet()) { if (isTypeOf(nodeTemplateEntry.getValue(), nodeType, serviceTemplate, toscaServiceModel)) { nodeTemplates.put(nodeTemplateEntry.getKey(), nodeTemplateEntry.getValue()); } } } return nodeTemplates; } @Override public boolean isTypeOf(NodeTemplate nodeTemplate, String nodeType, ServiceTemplate serviceTemplate, ToscaServiceModel toscaServiceModel) { if (nodeTemplate == null) { return false; } if (isNodeTemplateOfTypeNodeType(nodeTemplate, nodeType)) { return true; } Optional<Boolean> nodeTypeExistInServiceTemplateHierarchy = isNodeTypeExistInServiceTemplateHierarchy( nodeType, nodeTemplate.getType(), serviceTemplate, toscaServiceModel, null); return nodeTypeExistInServiceTemplateHierarchy.orElseThrow( () -> new CoreException(new ToscaNodeTypeNotFoundErrorBuilder(nodeTemplate.getType()).build())); } private Optional<Boolean> isNodeTypeExistInServiceTemplateHierarchy(String nodeTypeToMatch, String nodeTypeToSearch, ServiceTemplate serviceTemplate, ToscaServiceModel toscaServiceModel, Set<String> analyzedImportFiles) { Map<String, NodeType> searchableNodeTypes = serviceTemplate.getNode_types(); if (!MapUtils.isEmpty(searchableNodeTypes)) { NodeType nodeType = searchableNodeTypes.get(nodeTypeToSearch); if (Objects.nonNull(nodeType)) { if (Objects.equals(nodeType.getDerived_from(), nodeTypeToMatch)) { return Optional.of(true); } else if (isNodeTypeIsToscaRoot(nodeType)) { return Optional.of(false); } else { return isNodeTypeExistInServiceTemplateHierarchy(nodeTypeToMatch, nodeType.getDerived_from(), serviceTemplate, toscaServiceModel, null); } } else { return isNodeTypeExistInImports(nodeTypeToMatch, nodeTypeToSearch, serviceTemplate, toscaServiceModel, analyzedImportFiles); } } return isNodeTypeExistInImports(nodeTypeToMatch, nodeTypeToSearch, serviceTemplate, toscaServiceModel, analyzedImportFiles); } private Optional<Boolean> isNodeTypeExistInImports(String nodeTypeToMatch, String nodeTypeToSearch, ServiceTemplate serviceTemplate, ToscaServiceModel toscaServiceModel, Set<String> analyzedImportFiles) { Map<String, Import> imports = serviceTemplate.getImports(); if (imports == null) { return Optional.empty(); } analyzedImportFiles = createAnalyzedImportFilesSet(analyzedImportFiles); for (Import anImport : imports.values()) { if (Objects.isNull(anImport) || Objects.isNull(anImport.getFile())) { throw new RuntimeException("import without file entry"); } String importFile = anImport.getFile(); if (analyzedImportFiles.contains(importFile)) { continue; } addImportFileToAnalyzedImportFilesSet(analyzedImportFiles, importFile); ServiceTemplate template = toscaServiceModel.getServiceTemplates().get(importFile); Optional<Boolean> nodeTypeExistInServiceTemplateHierarchy = isNodeTypeExistInServiceTemplateHierarchy( nodeTypeToMatch, nodeTypeToSearch, template, toscaServiceModel, analyzedImportFiles); if (nodeTypeExistInServiceTemplateHierarchy.isPresent()) { if (nodeTypeExistInServiceTemplateHierarchy.get()) { return Optional.of(true); } } } return Optional.of(false); } private Set<String> addImportFileToAnalyzedImportFilesSet(Set<String> analyzedImportFiles, String importFile) { analyzedImportFiles.add(importFile); return analyzedImportFiles; } private Set<String> createAnalyzedImportFilesSet(Set<String> analyzedImportFiles) { if (Objects.isNull(analyzedImportFiles)) { analyzedImportFiles = new HashSet<>(); } return analyzedImportFiles; } private boolean isNodeTypeIsToscaRoot(NodeType stNodeType) { return Objects.equals(stNodeType.getDerived_from(), ToscaNodeType.ROOT.getDisplayName()); } private boolean isNodeTemplateOfTypeNodeType(NodeTemplate nodeTemplate, String nodeType) { return Objects.equals(nodeTemplate.getType(), nodeType); } @Override public List<RequirementAssignment> getRequirements(NodeTemplate nodeTemplate, String requirementId) { List<RequirementAssignment> requirements = new ArrayList<>(); List<Map<String, RequirementAssignment>> requirementList = nodeTemplate.getRequirements(); if (requirementList != null) { requirementList.stream().filter(reqMap -> reqMap.get(requirementId) != null).forEach(reqMap -> { ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil(); RequirementAssignment reqAssignment = toscaExtensionYamlUtil.yamlToObject( toscaExtensionYamlUtil.objectToYaml(reqMap.get(requirementId)), RequirementAssignment.class); requirements.add(reqAssignment); }); } return requirements; } @Override public Optional<NodeTemplate> getNodeTemplateById(ServiceTemplate serviceTemplate, String nodeTemplateId) { if ((serviceTemplate.getTopology_template() != null) && (serviceTemplate.getTopology_template().getNode_templates() != null) && (serviceTemplate.getTopology_template().getNode_templates().get(nodeTemplateId) != null)) { return Optional.of(serviceTemplate.getTopology_template().getNode_templates().get(nodeTemplateId)); } return Optional.empty(); } @Override public Optional<String> getSubstituteServiceTemplateName(String substituteNodeTemplateId, NodeTemplate substitutableNodeTemplate) { if (!isSubstitutableNodeTemplate(substitutableNodeTemplate)) { return Optional.empty(); } if (substitutableNodeTemplate.getProperties() != null && substitutableNodeTemplate.getProperties() .get(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME) != null) { Object serviceTemplateFilter = substitutableNodeTemplate.getProperties() .get(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME); if (serviceTemplateFilter != null && serviceTemplateFilter instanceof Map) { Object substituteServiceTemplate = ((Map) serviceTemplateFilter) .get(ToscaConstants.SUBSTITUTE_SERVICE_TEMPLATE_PROPERTY_NAME); if (substituteServiceTemplate == null) { throw new CoreException( new ToscaInvalidSubstituteNodeTemplatePropertiesErrorBuilder(substituteNodeTemplateId) .build()); } return Optional.of(substituteServiceTemplate.toString()); } } throw new CoreException( new ToscaInvalidSubstituteNodeTemplatePropertiesErrorBuilder(substituteNodeTemplateId).build()); } @Override public Map<String, NodeTemplate> getSubstitutableNodeTemplates(ServiceTemplate serviceTemplate) { Map<String, NodeTemplate> substitutableNodeTemplates = new HashMap<>(); if (serviceTemplate == null || serviceTemplate.getTopology_template() == null || serviceTemplate.getTopology_template().getNode_templates() == null) { return substitutableNodeTemplates; } Map<String, NodeTemplate> nodeTemplates = serviceTemplate.getTopology_template().getNode_templates(); for (String nodeTemplateId : nodeTemplates.keySet()) { NodeTemplate nodeTemplate = nodeTemplates.get(nodeTemplateId); if (isSubstitutableNodeTemplate(nodeTemplate)) { substitutableNodeTemplates.put(nodeTemplateId, nodeTemplate); } } return substitutableNodeTemplates; } private boolean isSubstitutableNodeTemplate(NodeTemplate nodeTemplate) { return nodeTemplate.getDirectives() != null && nodeTemplate.getDirectives().contains(ToscaConstants.NODE_TEMPLATE_DIRECTIVE_SUBSTITUTABLE); } private boolean isSubstitutionServiceTemplate(String substituteServiceTemplateFileName, ServiceTemplate substituteServiceTemplate) { if (substituteServiceTemplate != null && substituteServiceTemplate.getTopology_template() != null && substituteServiceTemplate.getTopology_template().getSubstitution_mappings() != null) { if (substituteServiceTemplate.getTopology_template().getSubstitution_mappings() .getNode_type() == null) { throw new CoreException( new ToscaInvalidSubstitutionServiceTemplateErrorBuilder(substituteServiceTemplateFileName) .build()); } return true; } return false; } @Override public Optional<Map.Entry<String, NodeTemplate>> getSubstitutionMappedNodeTemplateByExposedReq( String substituteServiceTemplateFileName, ServiceTemplate substituteServiceTemplate, String requirementId) { if (isSubstitutionServiceTemplate(substituteServiceTemplateFileName, substituteServiceTemplate)) { Map<String, List<String>> substitutionMappingRequirements = substituteServiceTemplate .getTopology_template().getSubstitution_mappings().getRequirements(); if (substitutionMappingRequirements != null) { List<String> requirementMapping = substitutionMappingRequirements.get(requirementId); if (requirementMapping != null && !requirementMapping.isEmpty()) { String mappedNodeTemplateId = requirementMapping.get(0); Optional<NodeTemplate> mappedNodeTemplate = getNodeTemplateById(substituteServiceTemplate, mappedNodeTemplateId); mappedNodeTemplate.orElseThrow(() -> new CoreException( new ToscaInvalidEntryNotFoundErrorBuilder("Node Template", mappedNodeTemplateId) .build())); Map.Entry<String, NodeTemplate> mappedNodeTemplateEntry = new Map.Entry<String, NodeTemplate>() { @Override public String getKey() { return mappedNodeTemplateId; } @Override public NodeTemplate getValue() { return mappedNodeTemplate.get(); } @Override public NodeTemplate setValue(NodeTemplate value) { return null; } }; return Optional.of(mappedNodeTemplateEntry); } } } return Optional.empty(); } /* match only for the input which is not null */ @Override public boolean isDesiredRequirementAssignment(RequirementAssignment requirementAssignment, String capability, String node, String relationship) { if (capability != null) { if (requirementAssignment.getCapability() == null || !requirementAssignment.getCapability().equals(capability)) { return false; } } if (node != null) { if (requirementAssignment.getNode() == null || !requirementAssignment.getNode().equals(node)) { return false; } } if (relationship != null) { if (requirementAssignment.getRelationship() == null || !requirementAssignment.getRelationship().equals(relationship)) { return false; } } return !(capability == null && node == null && relationship == null); } @Override public Object getFlatEntity(ToscaElementTypes elementType, String typeId, ServiceTemplate serviceTemplate, ToscaServiceModel toscaModel) { Object returnEntity; switch (elementType) { case CAPABILITY_TYPE: returnEntity = new CapabilityType(); break; default: throw new RuntimeException("Entity[" + elementType + "] id[" + typeId + "] flat not supported"); } scanAnFlatEntity(elementType, typeId, returnEntity, serviceTemplate, toscaModel); return returnEntity; } private void scanAnFlatEntity(ToscaElementTypes elementType, String typeId, Object entity, ServiceTemplate serviceTemplate, ToscaServiceModel toscaModel) { boolean entityFound = enrichEntityFromCurrentServiceTemplate(elementType, typeId, entity, serviceTemplate, toscaModel); if (!entityFound) { Map<String, Import> imports = serviceTemplate.getImports(); if (MapUtils.isEmpty(imports)) { return; } for (Import importServiceTemplate : imports.values()) { ServiceTemplate template = toscaModel.getServiceTemplates().get(importServiceTemplate.getFile()); scanAnFlatEntity(elementType, typeId, entity, template, toscaModel); } } } private boolean enrichEntityFromCurrentServiceTemplate(ToscaElementTypes elementType, String typeId, Object entity, ServiceTemplate serviceTemplate, ToscaServiceModel toscaModel) { String derivedFrom; switch (elementType) { case CAPABILITY_TYPE: if (serviceTemplate.getCapability_types() != null && serviceTemplate.getCapability_types().containsKey(typeId)) { CapabilityType targetCapabilityType = ((CapabilityType) entity); CapabilityType sourceCapabilityType = serviceTemplate.getCapability_types().get(typeId); derivedFrom = sourceCapabilityType.getDerived_from(); if (derivedFrom != null && !ToscaCapabilityType.NFV_METRIC.getDisplayName().equals(derivedFrom)) { scanAnFlatEntity(elementType, derivedFrom, entity, serviceTemplate, toscaModel); } combineCapabilityTypeInfo(sourceCapabilityType, targetCapabilityType); } else { return false; } break; default: throw new RuntimeException("Entity[" + elementType + "] id[" + typeId + "] flat not supported"); } return true; } private void combineCapabilityTypeInfo(CapabilityType sourceCapabilityType, CapabilityType targetCapabilityType) { if (MapUtils.isNotEmpty(sourceCapabilityType.getAttributes())) { if (targetCapabilityType.getAttributes() == null) { targetCapabilityType.setAttributes(new HashMap<>()); } targetCapabilityType.getAttributes().putAll(sourceCapabilityType.getAttributes()); } if (MapUtils.isNotEmpty(sourceCapabilityType.getProperties())) { if (targetCapabilityType.getProperties() == null) { targetCapabilityType.setProperties(new HashMap<>()); } targetCapabilityType.getProperties().putAll(sourceCapabilityType.getProperties()); } if (CollectionUtils.isNotEmpty(sourceCapabilityType.getValid_source_types())) { if (targetCapabilityType.getValid_source_types() == null) { targetCapabilityType.setValid_source_types(new ArrayList<>()); } targetCapabilityType.getValid_source_types().addAll(sourceCapabilityType.getValid_source_types()); } if (CommonMethods.isEmpty(sourceCapabilityType.getDerived_from())) { targetCapabilityType.setDerived_from(sourceCapabilityType.getDerived_from()); } if (CommonMethods.isEmpty(sourceCapabilityType.getDescription())) { targetCapabilityType.setDescription(sourceCapabilityType.getDescription()); } if (CommonMethods.isEmpty(sourceCapabilityType.getVersion())) { targetCapabilityType.setVersion(sourceCapabilityType.getVersion()); } } }