/*
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
+ * Copyright © 2016-2018 European Support Limited
+ *
* 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.translator.services.heattotosca;
+import static org.openecomp.sdc.tosca.services.DataModelUtil.getClonedObject;
+import static org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionEntity.COMPUTE;
+import static org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionEntity.PORT;
+import static org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionEntity.SUB_INTERFACE;
+import static org.openecomp.sdc.translator.services.heattotosca.Constants.ABSTRACT_NODE_TEMPLATE_ID_PREFIX;
+import static org.openecomp.sdc.translator.services.heattotosca.Constants.COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX;
+import static org.openecomp.sdc.translator.services.heattotosca.Constants.COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX;
+import static org.openecomp.sdc.translator.services.heattotosca.Constants.PORT_IDENTICAL_VALUE_PROPERTY_PREFIX;
+import static org.openecomp.sdc.translator.services.heattotosca.Constants.SUB_INTERFACE_PROPERTY_VALUE_PREFIX;
+import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getComputeTypeSuffix;
+import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getConnectedComputeConsolidationData;
+import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getNewComputeNodeTemplateId;
+import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getNewPortNodeTemplateId;
+import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getNewSubInterfaceNodeTemplateId;
+import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getSubInterfacePortTemplateConsolidationData;
+import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getSubInterfaceTemplateConsolidationDataList;
+import static org.openecomp.sdc.translator.services.heattotosca.UnifiedCompositionUtil.getSubInterfaceTypeSuffix;
+
+import com.google.common.collect.ListMultimap;
import org.apache.commons.collections.map.HashedMap;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.openecomp.core.utilities.CommonMethods;
import org.openecomp.sdc.datatypes.configuration.ImplementationConfiguration;
import org.openecomp.sdc.heat.services.HeatConstants;
-import org.openecomp.sdc.logging.api.Logger;
-import org.openecomp.sdc.logging.api.LoggerFactory;
-import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
import org.openecomp.sdc.tosca.datatypes.ToscaFunctions;
import org.openecomp.sdc.tosca.datatypes.ToscaGroupType;
import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
import org.openecomp.sdc.tosca.datatypes.model.PropertyType;
import org.openecomp.sdc.tosca.datatypes.model.RelationshipTemplate;
import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
-import org.openecomp.sdc.tosca.datatypes.model.RequirementDefinition;
import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
import org.openecomp.sdc.tosca.datatypes.model.SubstitutionMapping;
+import org.openecomp.sdc.tosca.datatypes.model.heatextend.ParameterDefinitionExt;
import org.openecomp.sdc.tosca.datatypes.model.heatextend.PropertyTypeExt;
import org.openecomp.sdc.tosca.services.DataModelUtil;
import org.openecomp.sdc.tosca.services.ToscaAnalyzerService;
import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionEntity;
import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionMode;
import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedSubstitutionData;
+import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.commands.CommandImplNames;
+import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.commands.UnifiedSubstitutionNodeTemplateIdGenerator;
+import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.to.UnifiedCompositionTo;
import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData;
import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ConsolidationData;
import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.EntityConsolidationData;
import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedTemplateConsolidationData;
import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData;
import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.RequirementAssignmentData;
+import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.SubInterfaceTemplateConsolidationData;
import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.TypeComputeConsolidationData;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.Collection;
+import java.util.EnumMap;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Optional;
import java.util.Set;
import java.util.regex.Pattern;
-
-import static org.openecomp.sdc.tosca.services.DataModelUtil.getClonedObject;
-import static org.openecomp.sdc.translator.services.heattotosca.Constants.ABSTRACT_NODE_TEMPLATE_ID_PREFIX;
-import static org.openecomp.sdc.translator.services.heattotosca.Constants.COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX;
-import static org.openecomp.sdc.translator.services.heattotosca.Constants.COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX;
-import static org.openecomp.sdc.translator.services.heattotosca.Constants.PORT_IDENTICAL_VALUE_PROPERTY_PREFIX;
+import java.util.stream.Collectors;
public class UnifiedCompositionService {
- protected static Logger logger =
- (Logger) LoggerFactory.getLogger(UnifiedCompositionService.class);
- protected static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
- private static Map<String, ImplementationConfiguration> unifiedCompositionImplMap;
+ private static final Map<String, ImplementationConfiguration> unifiedCompositionImplMap;
+
+ private static final EnumMap<UnifiedCompositionEntity, String> unifiedSubstitutionNodeTemplateIdGeneratorImplMap;
static {
Configuration config = ConfigurationManager.lookup();
unifiedCompositionImplMap =
- config.populateMap(ConfigConstants.MANDATORY_UNIFIED_MODEL_NAMESPACE,
- ConfigConstants.UNIFIED_COMPOSITION_IMPL_KEY, ImplementationConfiguration.class);
+ config.populateMap(ConfigConstants.MANDATORY_UNIFIED_MODEL_NAMESPACE,
+ ConfigConstants.UNIFIED_COMPOSITION_IMPL_KEY, ImplementationConfiguration.class);
+ unifiedSubstitutionNodeTemplateIdGeneratorImplMap = new EnumMap<>(UnifiedCompositionEntity.class);
+ initNodeTemplateIdGeneratorImplMap();
+ }
+ private static void initNodeTemplateIdGeneratorImplMap() {
+ unifiedSubstitutionNodeTemplateIdGeneratorImplMap.put(COMPUTE, CommandImplNames
+ .COMPUTE_NEW_NODE_TEMPLATE_ID_GENERATOR_IMPL);
+ unifiedSubstitutionNodeTemplateIdGeneratorImplMap.put(PORT, CommandImplNames
+ .PORT_NEW_NODE_TEMPLATE_ID_GENERATOR_IMPL);
+ unifiedSubstitutionNodeTemplateIdGeneratorImplMap.put(SUB_INTERFACE, CommandImplNames
+ .SUB_INTERFACE_NEW_NODE_TEMPLATE_ID_GENERATOR_IMPL);
}
- private ConsolidationService consolidationService = new ConsolidationService();
+ private final ConsolidationService consolidationService = new ConsolidationService();
private static List<EntityConsolidationData> getPortConsolidationDataList(
- Set<String> portIds,
- List<UnifiedCompositionData> unifiedCompositionDataList) {
- List<EntityConsolidationData> portConsolidationDataList = new ArrayList<>();
- for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
- for (PortTemplateConsolidationData portTemplateConsolidationData : unifiedCompositionData
- .getPortTemplateConsolidationDataList()) {
- if (portIds.contains(portTemplateConsolidationData.getNodeTemplateId())) {
- portConsolidationDataList.add(portTemplateConsolidationData);
- }
- }
- }
- return portConsolidationDataList;
+ List<String> portIds,
+ List<UnifiedCompositionData> unifiedCompositionDataList) {
+ return unifiedCompositionDataList.stream()
+ .flatMap(unifiedCompositionData -> unifiedCompositionData.getPortTemplateConsolidationDataList().stream())
+ .filter(portTemplateConsolidationData -> portIds.contains(portTemplateConsolidationData.getNodeTemplateId()))
+ .collect(Collectors.toList());
}
/**
ServiceTemplate nestedServiceTemplate,
List<UnifiedCompositionData> unifiedCompositionDataList,
UnifiedCompositionMode mode, TranslationContext context) {
- mdcDataDebugMessage.debugEntryMessage(null, null);
Optional<UnifiedComposition> unifiedCompositionInstance = getUnifiedCompositionInstance(mode);
if (!unifiedCompositionInstance.isPresent()) {
return;
}
unifiedCompositionInstance.get()
- .createUnifiedComposition(serviceTemplate, nestedServiceTemplate,
- unifiedCompositionDataList, context);
- mdcDataDebugMessage.debugExitMessage(null, null);
+ .createUnifiedComposition(serviceTemplate, nestedServiceTemplate,
+ unifiedCompositionDataList, context);
}
/**
* @return the substitution service template
*/
public Optional<ServiceTemplate> createUnifiedSubstitutionServiceTemplate(
- ServiceTemplate serviceTemplate,
- List<UnifiedCompositionData> unifiedCompositionDataList,
- TranslationContext context,
- String substitutionNodeTypeId,
- Integer index) {
+ ServiceTemplate serviceTemplate,
+ List<UnifiedCompositionData> unifiedCompositionDataList,
+ TranslationContext context,
+ String substitutionNodeTypeId,
+ Integer index) {
if (CollectionUtils.isEmpty(unifiedCompositionDataList)) {
return Optional.empty();
}
- UnifiedCompositionData unifiedCompositionData = unifiedCompositionDataList.get(0);
- String templateName =
- getTemplateName(serviceTemplate, unifiedCompositionData, substitutionNodeTypeId, index);
+ String templateName = getTemplateName(substitutionNodeTypeId, index);
ServiceTemplate substitutionServiceTemplate =
- HeatToToscaUtil.createInitSubstitutionServiceTemplate(templateName);
+ HeatToToscaUtil.createInitSubstitutionServiceTemplate(templateName);
createIndexInputParameter(substitutionServiceTemplate);
String computeNodeType =
- handleCompute(serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList,
- context);
+ handleCompute(serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList,
+ context);
handlePorts(serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList,
- computeNodeType, context);
- createOutputParameters(serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList,
- computeNodeType, context);
+ computeNodeType, context);
+
+ UnifiedCompositionTo unifiedCompositionTo = new UnifiedCompositionTo(serviceTemplate,
+ substitutionServiceTemplate, unifiedCompositionDataList, context);
+ handleSubInterfaces(unifiedCompositionTo);
+ createOutputParameters(unifiedCompositionTo, computeNodeType);
NodeType substitutionGlobalNodeType =
- handleSubstitutionGlobalNodeType(serviceTemplate, substitutionServiceTemplate,
- context, unifiedCompositionData, substitutionNodeTypeId, index);
+ handleSubstitutionGlobalNodeType(serviceTemplate, substitutionServiceTemplate,
+ context, substitutionNodeTypeId);
HeatToToscaUtil.handleSubstitutionMapping(context,
- substitutionNodeTypeId,
- substitutionServiceTemplate, substitutionGlobalNodeType);
+ substitutionNodeTypeId,
+ substitutionServiceTemplate, substitutionGlobalNodeType);
context.getTranslatedServiceTemplates().put(templateName, substitutionServiceTemplate);
return Optional.of(substitutionServiceTemplate);
* @return the abstract substitute node template id
*/
public String createAbstractSubstituteNodeTemplate(
- ServiceTemplate serviceTemplate,
- ServiceTemplate substitutionServiceTemplate,
- List<UnifiedCompositionData> unifiedCompositionDataList,
- String substituteNodeTypeId,
- TranslationContext context,
- Integer index) {
+ ServiceTemplate serviceTemplate,
+ ServiceTemplate substitutionServiceTemplate,
+ List<UnifiedCompositionData> unifiedCompositionDataList,
+ String substituteNodeTypeId,
+ TranslationContext context,
+ Integer index) {
NodeTemplate substitutionNodeTemplate = new NodeTemplate();
List<String> directiveList = new ArrayList<>();
directiveList.add(ToscaConstants.NODE_TEMPLATE_DIRECTIVE_SUBSTITUTABLE);
substitutionNodeTemplate.setDirectives(directiveList);
substitutionNodeTemplate.setType(substituteNodeTypeId);
- Optional<Map<String, Object>> abstractSubstitutionProperties =
- createAbstractSubstitutionProperties(serviceTemplate,
- substitutionServiceTemplate, unifiedCompositionDataList, context);
+ Map<String, ParameterDefinition> substitutionTemplateInputs = DataModelUtil
+ .getInputParameters(substitutionServiceTemplate);
+ Optional<Map<String, Object>> abstractSubstitutionProperties = Optional.empty();
+ if (Objects.nonNull(substitutionTemplateInputs)) {
+ abstractSubstitutionProperties = createAbstractSubstitutionProperties(serviceTemplate,
+ substitutionTemplateInputs, unifiedCompositionDataList, context);
+ }
abstractSubstitutionProperties.ifPresent(substitutionNodeTemplate::setProperties);
//Add substitution filtering property
String substitutionServiceTemplateName = ToscaUtil.getServiceTemplateFileName(
- substitutionServiceTemplate);
+ substitutionServiceTemplate);
int count = unifiedCompositionDataList.size();
DataModelUtil.addSubstitutionFilteringProperty(substitutionServiceTemplateName,
- substitutionNodeTemplate, count);
+ substitutionNodeTemplate, count);
//Add index_value property
addIndexValueProperty(substitutionNodeTemplate);
- String substituteNodeTemplateId =
- getSubstituteNodeTemplateId(serviceTemplate, unifiedCompositionDataList.get(0),
- substituteNodeTypeId, index);
+ String substituteNodeTemplateId = getSubstituteNodeTemplateId(substituteNodeTypeId, index);
//Add node template id and related abstract node template id in context
addUnifiedSubstitionData(context, serviceTemplate, unifiedCompositionDataList,
- substituteNodeTemplateId);
+ substituteNodeTemplateId);
DataModelUtil
- .addNodeTemplate(serviceTemplate, substituteNodeTemplateId, substitutionNodeTemplate);
+ .addNodeTemplate(serviceTemplate, substituteNodeTemplateId, substitutionNodeTemplate);
return substituteNodeTemplateId;
}
* @param context the translation context
*/
public void cleanUnifiedCompositionEntities(
- ServiceTemplate serviceTemplate,
- List<UnifiedCompositionData> unifiedCompositionDataList,
- TranslationContext context) {
+ ServiceTemplate serviceTemplate,
+ List<UnifiedCompositionData> unifiedCompositionDataList,
+ TranslationContext context) {
for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
+ //Clean compute node template data from top level service template
ComputeTemplateConsolidationData computeTemplateConsolidationData =
- unifiedCompositionData.getComputeTemplateConsolidationData();
+ unifiedCompositionData.getComputeTemplateConsolidationData();
cleanServiceTemplate(serviceTemplate, computeTemplateConsolidationData, context);
+ //Clean port node template data from top level service template
List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
- getPortTemplateConsolidationDataList(unifiedCompositionData);
+ getPortTemplateConsolidationDataList(unifiedCompositionData);
for (PortTemplateConsolidationData portTemplateConsolidationData :
- portTemplateConsolidationDataList) {
+ portTemplateConsolidationDataList) {
cleanServiceTemplate(serviceTemplate, portTemplateConsolidationData, context);
}
- }
+ //Clean sub-interface node template data from top level service template
+ List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
+ getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+ for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
+ subInterfaceTemplateConsolidationDataList) {
+ cleanServiceTemplate(serviceTemplate, subInterfaceTemplateConsolidationData, context);
+ }
+ }
}
/**
TranslationContext context) {
for (UnifiedCompositionData unifiedData : unifiedCompositionDataList) {
removeCleanedNodeType(
- unifiedData.getComputeTemplateConsolidationData().getNodeTemplateId(), serviceTemplate,
- context);
+ unifiedData.getComputeTemplateConsolidationData().getNodeTemplateId(), serviceTemplate,
+ context);
}
if (MapUtils.isEmpty(serviceTemplate.getNode_types())) {
serviceTemplate.setNode_types(null);
}
}
- public void updateSubstitutionNodeTypePrefix(ServiceTemplate substitutionServiceTemplate){
- Map<String, NodeTemplate> node_templates =
- substitutionServiceTemplate.getTopology_template().getNode_templates();
+ public void updateSubstitutionNodeTypePrefix(ServiceTemplate substitutionServiceTemplate) {
+ Map<String, NodeTemplate> nodeTemplates =
+ substitutionServiceTemplate.getTopology_template().getNode_templates();
- for(Map.Entry<String,NodeTemplate> nodeTemplateEntry : node_templates.entrySet()){
+ for (Map.Entry<String, NodeTemplate> nodeTemplateEntry : nodeTemplates.entrySet()) {
String nodeTypeId = nodeTemplateEntry.getValue().getType();
NodeType origNodeType = substitutionServiceTemplate.getNode_types().get(nodeTypeId);
- if(Objects.nonNull(origNodeType)
- && nodeTypeId.startsWith(ToscaNodeType.VFC_TYPE_PREFIX)
- && origNodeType.getDerived_from().equals(ToscaNodeType.NOVA_SERVER)){
+ if (Objects.nonNull(origNodeType)
+ && nodeTypeId.startsWith(ToscaNodeType.VFC_TYPE_PREFIX)
+ && origNodeType.getDerived_from().equals(ToscaNodeType.NOVA_SERVER)) {
substitutionServiceTemplate.getNode_types().remove(nodeTypeId);
String newNodeTypeId =
- nodeTypeId.replace(ToscaNodeType.VFC_TYPE_PREFIX, ToscaNodeType.COMPUTE_TYPE_PREFIX);
+ nodeTypeId.replace(ToscaNodeType.VFC_TYPE_PREFIX, ToscaNodeType.COMPUTE_TYPE_PREFIX);
nodeTemplateEntry.getValue().setType(newNodeTypeId);
DataModelUtil
- .addNodeTemplate(substitutionServiceTemplate, nodeTemplateEntry.getKey(), nodeTemplateEntry.getValue());
+ .addNodeTemplate(substitutionServiceTemplate, nodeTemplateEntry.getKey(),
+ nodeTemplateEntry.getValue());
substitutionServiceTemplate.getNode_types().put(newNodeTypeId, origNodeType);
}
}
String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
UnifiedSubstitutionData unifiedSubstitutionData = context.getUnifiedSubstitutionData()
- .get(serviceTemplateFileName);
+ .get(serviceTemplateFileName);
if (Objects.nonNull(unifiedSubstitutionData)) {
//Handle get attribute in connectivity for abstarct node to abstract node templates
Set<String> abstractNodeIds =
- new HashSet<>(unifiedSubstitutionData.getAllRelatedAbstractNodeIds());
+ new HashSet<>(unifiedSubstitutionData.getAllRelatedAbstractNodeIds());
handleGetAttrInConnectivity(serviceTemplate, abstractNodeIds, context);
//Handle get attribute in connectivity for abstract node templates to nested node template
Set<String> nestedNodeIds =
- new HashSet<>(unifiedSubstitutionData.getAllUnifiedNestedNodeTemplateIds());
+ new HashSet<>(unifiedSubstitutionData.getAllUnifiedNestedNodeTemplateIds());
handleGetAttrInConnectivity(serviceTemplate, nestedNodeIds, context);
}
}
TranslationContext context) {
handleUnifiedNestedNodeType(mainServiceTemplate, nestedServiceTemplate, context);
updateUnifiedNestedTemplates(mainServiceTemplate, nestedServiceTemplate,
- unifiedCompositionData, context);
+ unifiedCompositionData, context);
}
private void handleGetAttrInConnectivity(ServiceTemplate serviceTemplate,
Set<String> unifiedNodeIds,
TranslationContext context) {
Map<String, NodeTemplate> nodeTemplates =
- serviceTemplate.getTopology_template().getNode_templates();
+ serviceTemplate.getTopology_template().getNode_templates();
String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
for (String unifiedNodeId : unifiedNodeIds) {
NodeTemplate nodeTemplate = nodeTemplates.get(unifiedNodeId);
handleGetAttrInAbstractNodeTemplate(serviceTemplate, context, serviceTemplateFileName,
- nodeTemplate);
+ nodeTemplate);
}
}
SubstitutionMapping substitutionMappings =
- nestedServiceTemplate.getTopology_template().getSubstitution_mappings();
+ nestedServiceTemplate.getTopology_template().getSubstitution_mappings();
String nodeTypeId = substitutionMappings.getNode_type();
- Optional<String> newNestedNodeTypeId =
- getNewNestedNodeTypeId(mainServiceTemplate, nestedServiceTemplate, context);
+ Optional<String> newNestedNodeTypeId = getNewNestedNodeTypeId(nestedServiceTemplate, context);
ServiceTemplate globalSubstitutionServiceTemplate =
- context.getGlobalSubstitutionServiceTemplate();
+ context.getGlobalSubstitutionServiceTemplate();
if (isNestedServiceTemplateWasHandled(globalSubstitutionServiceTemplate, nestedServiceTemplate,
- context,
- newNestedNodeTypeId)) {
+ context,
+ newNestedNodeTypeId)) {
context
- .updateHandledComputeType(ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
- newNestedNodeTypeId.get(),
- ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
+ .updateHandledComputeType(ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
+ newNestedNodeTypeId.get(),
+ ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
return;
}
newNestedNodeTypeId.ifPresent(
- newNestedNodeTypeIdVal -> handleNestedNodeType(nodeTypeId, newNestedNodeTypeIdVal,
- nestedServiceTemplate, mainServiceTemplate, globalSubstitutionServiceTemplate,
- context));
+ newNestedNodeTypeIdVal -> handleNestedNodeType(nodeTypeId, newNestedNodeTypeIdVal,
+ nestedServiceTemplate, mainServiceTemplate, globalSubstitutionServiceTemplate,
+ context));
}
TranslationContext context,
Optional<String> newNestedNodeTypeId) {
return newNestedNodeTypeId.isPresent()
- && context.isNestedServiceTemplateWasHandled(
- ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
- ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
+ && context.isNestedServiceTemplateWasHandled(
+ ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
+ ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
}
private void handleNestedNodeType(String nodeTypeId, String newNestedNodeTypeId,
TranslationContext context) {
updateNestedServiceTemplate(nestedServiceTemplate, context);
updateNestedNodeType(nodeTypeId, newNestedNodeTypeId, nestedServiceTemplate,
- mainServiceTemplate,
- globalSubstitutionServiceTemplate, context);
+ mainServiceTemplate,
+ globalSubstitutionServiceTemplate, context);
}
private void enrichPortProperties(ServiceTemplate nestedServiceTemplate,
TranslationContext context) {
String nestedServiceTemplateFileName =
- ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate);
+ ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate);
FilePortConsolidationData filePortConsolidationData =
- context.getConsolidationData().getPortConsolidationData().getFilePortConsolidationData
- (nestedServiceTemplateFileName);
+ context.getConsolidationData().getPortConsolidationData().getFilePortConsolidationData
+ (nestedServiceTemplateFileName);
if (Objects.nonNull(filePortConsolidationData)) {
Set<String> portNodeTemplateIds = filePortConsolidationData.getAllPortNodeTemplateIds();
if (Objects.nonNull(portNodeTemplateIds)) {
for (String portNodeTemplateId : portNodeTemplateIds) {
NodeTemplate portNodeTemplate = DataModelUtil.getNodeTemplate(nestedServiceTemplate,
- portNodeTemplateId);
+ portNodeTemplateId);
List<EntityConsolidationData> portEntityConsolidationDataList = new ArrayList<>();
portEntityConsolidationDataList.add(filePortConsolidationData
- .getPortTemplateConsolidationData(portNodeTemplateId));
+ .getPortTemplateConsolidationData(portNodeTemplateId));
handleNodeTypeProperties(nestedServiceTemplate,
- portEntityConsolidationDataList, portNodeTemplate, UnifiedCompositionEntity.Port,
- null, context);
+ portEntityConsolidationDataList, portNodeTemplate, UnifiedCompositionEntity.PORT,
+ null, context);
}
}
}
ServiceTemplate globalSubstitutionServiceTemplate,
TranslationContext context) {
String indexedNewNestedNodeTypeId =
- updateNodeTypeId(nodeTypeId, newNestedNodeTypeId, nestedServiceTemplate,
- mainServiceTemplate,
- globalSubstitutionServiceTemplate, context);
+ updateNodeTypeId(nodeTypeId, newNestedNodeTypeId, nestedServiceTemplate,
+ mainServiceTemplate,
+ globalSubstitutionServiceTemplate, context);
updateNodeTypeProperties(nestedServiceTemplate, globalSubstitutionServiceTemplate,
- indexedNewNestedNodeTypeId);
- //addComputeNodeTypeToGlobalST();
-
+ indexedNewNestedNodeTypeId);
}
private void updateNodeTypeProperties(ServiceTemplate nestedServiceTemplate,
String nodeTypeId) {
ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
Map<String, PropertyDefinition> nodeTypePropertiesDefinition =
- toscaAnalyzerService.manageSubstitutionNodeTypeProperties(nestedServiceTemplate);
+ toscaAnalyzerService.manageSubstitutionNodeTypeProperties(nestedServiceTemplate);
NodeType nestedNodeType =
- DataModelUtil.getNodeType(globalSubstitutionServiceTemplate, nodeTypeId);
+ DataModelUtil.getNodeType(globalSubstitutionServiceTemplate, nodeTypeId);
nestedNodeType.setProperties(nodeTypePropertiesDefinition);
}
ServiceTemplate globalSubstitutionServiceTemplate,
TranslationContext context) {
String indexedNewNestedNodeTypeId =
- handleNestedNodeTypeInGlobalSubstitutionTemplate(nodeTypeId, newNestedNodeTypeId,
- globalSubstitutionServiceTemplate, context);
+ handleNestedNodeTypeInGlobalSubstitutionTemplate(nodeTypeId, newNestedNodeTypeId,
+ globalSubstitutionServiceTemplate, context);
handleSubstitutionMappingInNestedServiceTemplate(indexedNewNestedNodeTypeId,
- nestedServiceTemplate, context);
+ nestedServiceTemplate, context);
context
- .updateHandledComputeType(
- ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
- ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate),
- newNestedNodeTypeId);
+ .updateHandledComputeType(
+ ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
+ ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate),
+ newNestedNodeTypeId);
return indexedNewNestedNodeTypeId;
}
ServiceTemplate globalSubstitutionServiceTemplate,
TranslationContext context) {
String indexedNodeType =
- getIndexedGlobalNodeTypeId(newNestedNodeTypeId, context);
+ getIndexedGlobalNodeTypeId(newNestedNodeTypeId, context);
context.updateUsedTimesForNestedComputeNodeType(
- ToscaUtil.getServiceTemplateFileName(globalSubstitutionServiceTemplate),
- newNestedNodeTypeId);
+ ToscaUtil.getServiceTemplateFileName(globalSubstitutionServiceTemplate),
+ newNestedNodeTypeId);
handleNestedNodeTypesInGlobalSubstituteServiceTemplate(nodeTypeId, indexedNodeType,
- globalSubstitutionServiceTemplate, context);
+ globalSubstitutionServiceTemplate, context);
return indexedNodeType;
}
private String getIndexedGlobalNodeTypeId(String newNestedNodeTypeId,
TranslationContext context) {
int globalNodeTypeIndex =
- context.getGlobalNodeTypeIndex(
- ToscaUtil.getServiceTemplateFileName(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME),
- newNestedNodeTypeId);
+ context.getGlobalNodeTypeIndex(
+ ToscaUtil.getServiceTemplateFileName(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME),
+ newNestedNodeTypeId);
return globalNodeTypeIndex > 0 ? newNestedNodeTypeId + "_"
- + String.valueOf(globalNodeTypeIndex) : newNestedNodeTypeId;
+ + globalNodeTypeIndex : newNestedNodeTypeId;
}
private void updateUnifiedNestedTemplates(ServiceTemplate mainServiceTemplate,
TranslationContext context) {
NestedTemplateConsolidationData nestedTemplateConsolidationData =
- unifiedCompositionData.getNestedTemplateConsolidationData();
+ unifiedCompositionData.getNestedTemplateConsolidationData();
if (Objects.isNull(nestedTemplateConsolidationData)) {
return;
}
handleNestedNodeTemplateInMainServiceTemplate(
- nestedTemplateConsolidationData.getNodeTemplateId(), mainServiceTemplate,
- nestedServiceTemplate, context);
+ nestedTemplateConsolidationData.getNodeTemplateId(), mainServiceTemplate,
+ nestedServiceTemplate, context);
}
TranslationContext context) {
updNestedCompositionNodesConnectedInConnectivity(serviceTemplate, unifiedCompositionData,
- context);
+ context);
updNestedCompositionNodesConnectedOutConnectivity(serviceTemplate, nestedServiceTemplate,
- unifiedCompositionData, context);
+ unifiedCompositionData, context);
updNestedCompositionNodesGetAttrInConnectivity(serviceTemplate, unifiedCompositionData,
- context);
+ context);
updNestedCompositionOutputParamGetAttrInConnectivity(serviceTemplate,
- unifiedCompositionData, context);
+ unifiedCompositionData, context);
}
UnifiedCompositionData unifiedCompositionData,
TranslationContext context) {
EntityConsolidationData entityConsolidationData =
- unifiedCompositionData.getNestedTemplateConsolidationData();
+ unifiedCompositionData.getNestedTemplateConsolidationData();
updateHeatStackGroupNestedComposition(serviceTemplate, entityConsolidationData, context);
}
public void handleComplexVfcType(ServiceTemplate serviceTemplate, TranslationContext context) {
- SubstitutionMapping substitution_mappings =
- serviceTemplate.getTopology_template().getSubstitution_mappings();
+ SubstitutionMapping substitutionMapping =
+ serviceTemplate.getTopology_template().getSubstitution_mappings();
- if (Objects.isNull(substitution_mappings)) {
+ if (Objects.isNull(substitutionMapping)) {
return;
}
ServiceTemplate globalSubstitutionServiceTemplate =
- context.getGlobalSubstitutionServiceTemplate();
+ context.getGlobalSubstitutionServiceTemplate();
- String substitutionNT = substitution_mappings.getNode_type();
+ String substitutionNT = substitutionMapping.getNode_type();
if (globalSubstitutionServiceTemplate.getNode_types().containsKey(substitutionNT)) {
- //todo - remove comment after integration with AT&T
-// globalSubstitutionServiceTemplate.getNode_types().get(substitutionNT).setDerived_from
-// (ToscaNodeType.COMPLEX_VFC_NODE_TYPE);
+ //This needs to be done when catalog is ready for complex VFC
}
}
protected void updNodesConnectedOutConnectivity(ServiceTemplate serviceTemplate,
List<UnifiedCompositionData>
- unifiedCompositionDataList,
+ unifiedCompositionDataList,
TranslationContext context) {
for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
- .getComputeTemplateConsolidationData();
+ .getComputeTemplateConsolidationData();
//Add requirements in the abstract node template for nodes connected out for computes
String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
- computeTemplateConsolidationData.getNodeTemplateId());
+ computeTemplateConsolidationData.getNodeTemplateId());
Map<String, List<RequirementAssignmentData>> computeNodesConnectedOut =
- computeTemplateConsolidationData.getNodesConnectedOut();
+ computeTemplateConsolidationData.getNodesConnectedOut();
if (computeNodesConnectedOut != null) {
updateRequirementInAbstractNodeTemplate(serviceTemplate, computeTemplateConsolidationData,
- newComputeNodeTemplateId, computeNodesConnectedOut, context);
+ newComputeNodeTemplateId, computeNodesConnectedOut, context);
}
String computeType = getComputeTypeSuffix(serviceTemplate, computeTemplateConsolidationData
- .getNodeTemplateId());
+ .getNodeTemplateId());
//Add requirements in the abstract node template for nodes connected out for ports
List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
- getPortTemplateConsolidationDataList(unifiedCompositionData);
+ getPortTemplateConsolidationDataList(unifiedCompositionData);
for (PortTemplateConsolidationData portTemplateConsolidationData :
- portTemplateConsolidationDataList) {
+ portTemplateConsolidationDataList) {
String newPortNodeTemplateId = getNewPortNodeTemplateId(portTemplateConsolidationData
- .getNodeTemplateId(), computeType, computeTemplateConsolidationData);
+ .getNodeTemplateId(), computeType, computeTemplateConsolidationData);
Map<String, List<RequirementAssignmentData>> portNodesConnectedOut =
- portTemplateConsolidationData.getNodesConnectedOut();
+ portTemplateConsolidationData.getNodesConnectedOut();
if (portNodesConnectedOut != null) {
updateRequirementInAbstractNodeTemplate(serviceTemplate, portTemplateConsolidationData,
- newPortNodeTemplateId, portNodesConnectedOut, context);
+ newPortNodeTemplateId, portNodesConnectedOut, context);
}
}
+ //For sub-interface
+ //Add requirements in the abstract node template for nodes connected out for ports
+ updateSubInterfaceNodesConnectedOut(serviceTemplate, unifiedCompositionData,
+ computeTemplateConsolidationData, computeType, context);
+ }
+ }
+
+ private void updateSubInterfaceNodesConnectedOut(ServiceTemplate serviceTemplate,
+ UnifiedCompositionData unifiedCompositionData,
+ ComputeTemplateConsolidationData computeTemplateConsolidationData,
+ String computeType,
+ TranslationContext context) {
+ List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
+ getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+ for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
+ subInterfaceTemplateConsolidationDataList) {
+ String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(serviceTemplate, computeType,
+ computeTemplateConsolidationData, subInterfaceTemplateConsolidationData, context);
+ Map<String, List<RequirementAssignmentData>> subInterfaceNodesConnectedOut =
+ subInterfaceTemplateConsolidationData.getNodesConnectedOut();
+ if (subInterfaceNodesConnectedOut != null) {
+ updateRequirementInAbstractNodeTemplate(serviceTemplate, subInterfaceTemplateConsolidationData,
+ newSubInterfaceNodeTemplateId, subInterfaceNodesConnectedOut, context);
+ }
}
}
ServiceTemplate nestedServiceTemplate,
UnifiedCompositionData unifiedCompositionData,
TranslationContext context) {
- NestedTemplateConsolidationData nestedTemplateConsolidationData = unifiedCompositionData.getNestedTemplateConsolidationData();
+ NestedTemplateConsolidationData nestedTemplateConsolidationData =
+ unifiedCompositionData.getNestedTemplateConsolidationData();
Map<String, List<RequirementAssignmentData>> nodesConnectedOut =
- Objects.isNull(nestedTemplateConsolidationData) ? new HashMap<>()
- : nestedTemplateConsolidationData.getNodesConnectedOut();
+ Objects.isNull(nestedTemplateConsolidationData) ? new HashMap<>()
+ : nestedTemplateConsolidationData.getNodesConnectedOut();
FileComputeConsolidationData nestedFileComputeConsolidationData =
- context.getConsolidationData().getComputeConsolidationData().getFileComputeConsolidationData
- (ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
+ context.getConsolidationData().getComputeConsolidationData().getFileComputeConsolidationData
+ (ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
- if(Objects.isNull(nestedFileComputeConsolidationData)){
+ if (Objects.isNull(nestedFileComputeConsolidationData)) {
return;
}
TypeComputeConsolidationData computeType =
- nestedFileComputeConsolidationData.getAllTypeComputeConsolidationData().iterator().next();
- if(Objects.isNull(computeType)){
+ nestedFileComputeConsolidationData.getAllTypeComputeConsolidationData().iterator().next();
+ if (Objects.isNull(computeType)) {
return;
}
String singleComputeId = computeType.getAllComputeNodeTemplateIds().iterator().next();
- if(Objects.nonNull(singleComputeId)) {
+ if (Objects.nonNull(singleComputeId) && (Objects.nonNull(nestedTemplateConsolidationData))) {
updateRequirementInNestedNodeTemplate(serviceTemplate, nestedTemplateConsolidationData,
- singleComputeId, nodesConnectedOut);
+ singleComputeId, nodesConnectedOut);
}
}
- protected void updNodesConnectedInConnectivity(ServiceTemplate serviceTemplate,
- List<UnifiedCompositionData>
- unifiedCompositionDataList,
- TranslationContext context) {
+ private void updNodesConnectedInConnectivity(ServiceTemplate serviceTemplate,
+ List<UnifiedCompositionData>
+ unifiedCompositionDataList,
+ TranslationContext context) {
for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
- .getComputeTemplateConsolidationData();
+ .getComputeTemplateConsolidationData();
//Update requirements in the node template which pointing to the computes
String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
- computeTemplateConsolidationData.getNodeTemplateId());
+ computeTemplateConsolidationData.getNodeTemplateId());
updNodesConnectedInConnectivity(serviceTemplate, computeTemplateConsolidationData,
- newComputeNodeTemplateId, context, false);
+ newComputeNodeTemplateId, context, false);
String computeType = getComputeTypeSuffix(serviceTemplate, computeTemplateConsolidationData
- .getNodeTemplateId());
+ .getNodeTemplateId());
//Update requirements in the node template which pointing to the ports
List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
- getPortTemplateConsolidationDataList(unifiedCompositionData);
+ getPortTemplateConsolidationDataList(unifiedCompositionData);
for (PortTemplateConsolidationData portTemplateConsolidationData :
- portTemplateConsolidationDataList) {
+ portTemplateConsolidationDataList) {
String newPortNodeTemplateId = getNewPortNodeTemplateId(portTemplateConsolidationData
- .getNodeTemplateId(), computeType, computeTemplateConsolidationData);
+ .getNodeTemplateId(), computeType, computeTemplateConsolidationData);
updNodesConnectedInConnectivity(serviceTemplate, portTemplateConsolidationData,
- newPortNodeTemplateId, context, false);
+ newPortNodeTemplateId, context, false);
}
+
+ //Update requirements in the node template which pointing to the sub-interface
+ updateSubInterfaceNodesConnectedIn(serviceTemplate, unifiedCompositionData,
+ computeTemplateConsolidationData, computeType, context);
}
}
TranslationContext context,
boolean isNested) {
Map<String, List<RequirementAssignmentData>> nodesConnectedIn =
- entityConsolidationData.getNodesConnectedIn();
+ entityConsolidationData.getNodesConnectedIn();
if (nodesConnectedIn == null) {
//No nodes connected in info
return;
}
for (Map.Entry<String, List<RequirementAssignmentData>> entry : nodesConnectedIn
- .entrySet()) {
+ .entrySet()) {
List<RequirementAssignmentData> requirementAssignmentDataList = entry.getValue();
for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
RequirementAssignment requirementAssignment = requirementAssignmentData
- .getRequirementAssignment();
+ .getRequirementAssignment();
if (!requirementAssignment.getNode().equals(entityConsolidationData
- .getNodeTemplateId())) {
+ .getNodeTemplateId())) {
//The requirement assignment target node should be the one which we are handling in the
//consolidation object
continue;
//Update the requirement assignment object in the original node template
if (isNested) {
updateRequirementForNestedCompositionNodesConnectedIn(serviceTemplate,
- requirementAssignmentData, entityConsolidationData, newNodeTemplateId, context);
+ requirementAssignmentData, newNodeTemplateId);
} else {
updateRequirementForNodesConnectedIn(serviceTemplate, requirementAssignmentData,
- entityConsolidationData, entry.getKey(), newNodeTemplateId, context);
+ entityConsolidationData, entry.getKey(), newNodeTemplateId, context);
}
}
}
}
+ private void updateSubInterfaceNodesConnectedIn(ServiceTemplate serviceTemplate,
+ UnifiedCompositionData unifiedCompositionData,
+ ComputeTemplateConsolidationData computeTemplateConsolidationData,
+ String computeType,
+ TranslationContext context) {
+ List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
+ getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+ for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
+ subInterfaceTemplateConsolidationDataList) {
+ String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(serviceTemplate, computeType,
+ computeTemplateConsolidationData, subInterfaceTemplateConsolidationData, context);
+ updNodesConnectedInConnectivity(serviceTemplate, subInterfaceTemplateConsolidationData,
+ newSubInterfaceNodeTemplateId, context, false);
+ }
+ }
+
protected void updNestedCompositionNodesConnectedInConnectivity(
- ServiceTemplate serviceTemplate,
- UnifiedCompositionData unifiedCompositionData,
- TranslationContext context) {
+ ServiceTemplate serviceTemplate,
+ UnifiedCompositionData unifiedCompositionData,
+ TranslationContext context) {
NestedTemplateConsolidationData nestedTemplateConsolidationData = unifiedCompositionData
- .getNestedTemplateConsolidationData();
+ .getNestedTemplateConsolidationData();
//Update requirements in the node template which pointing to the nested nodes
String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
Optional<String> newNestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(
- serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
+ serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
newNestedNodeTemplateId.ifPresent(
- newNestedNodeTemplateIdVal -> updNodesConnectedInConnectivity(serviceTemplate,
- nestedTemplateConsolidationData,
- newNestedNodeTemplateIdVal, context, true));
-
- }
-
-// protected void updNestedCompositionNodesConnectedOutConnectivity(
-// ServiceTemplate serviceTemplate,
-// UnifiedCompositionData unifiedCompositionData,
-// TranslationContext context) {
-// NestedTemplateConsolidationData nestedTemplateConsolidationData = unifiedCompositionData
-// .getNestedTemplateConsolidationData();
-// //Update requirements in the node template which pointing to the nested nodes
-// String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
-// Optional<String> newNestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(
-// serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
-// newNestedNodeTemplateId.ifPresent(
-// newNestedNodeTemplateIdVal -> updNodesConnectedOutConnectivity(serviceTemplate,
-// nestedTemplateConsolidationData,
-// newNestedNodeTemplateIdVal, context, true));
-//
-// }
-
- protected void updVolumeConnectivity(ServiceTemplate serviceTemplate,
- List<UnifiedCompositionData>
- unifiedCompositionDataList,
- TranslationContext context) {
+ newNestedNodeTemplateIdVal -> updNodesConnectedInConnectivity(serviceTemplate,
+ nestedTemplateConsolidationData,
+ newNestedNodeTemplateIdVal, context, true));
+
+ }
+
+ private void updVolumeConnectivity(ServiceTemplate serviceTemplate,
+ List<UnifiedCompositionData>
+ unifiedCompositionDataList,
+ TranslationContext context) {
for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
- .getComputeTemplateConsolidationData();
+ .getComputeTemplateConsolidationData();
//Add requirements in the abstract node template for compute volumes
String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
- computeTemplateConsolidationData.getNodeTemplateId());
+ computeTemplateConsolidationData.getNodeTemplateId());
Map<String, List<RequirementAssignmentData>> computeVolumes =
- computeTemplateConsolidationData.getVolumes();
+ computeTemplateConsolidationData.getVolumes();
if (computeVolumes != null) {
updateRequirementInAbstractNodeTemplate(serviceTemplate, computeTemplateConsolidationData,
- newComputeNodeTemplateId, computeVolumes, context);
+ newComputeNodeTemplateId, computeVolumes, context);
}
}
}
- protected void updGroupsConnectivity(ServiceTemplate serviceTemplate,
- List<UnifiedCompositionData>
- unifiedCompositionDataList,
- TranslationContext context) {
+ private void updGroupsConnectivity(ServiceTemplate serviceTemplate,
+ List<UnifiedCompositionData>
+ unifiedCompositionDataList,
+ TranslationContext context) {
for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
- .getComputeTemplateConsolidationData();
+ .getComputeTemplateConsolidationData();
//Add requirements in the abstract node template for nodes connected in for computes
- String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
- computeTemplateConsolidationData.getNodeTemplateId());
updGroupsConnectivity(serviceTemplate, computeTemplateConsolidationData, context);
- String computeType = getComputeTypeSuffix(serviceTemplate, computeTemplateConsolidationData
- .getNodeTemplateId());
//Add requirements in the abstract node template for nodes connected in for ports
List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
- getPortTemplateConsolidationDataList(unifiedCompositionData);
+ getPortTemplateConsolidationDataList(unifiedCompositionData);
for (PortTemplateConsolidationData portTemplateConsolidationData :
- portTemplateConsolidationDataList) {
- String newPortNodeTemplateId = getNewPortNodeTemplateId(portTemplateConsolidationData
- .getNodeTemplateId(), computeType, computeTemplateConsolidationData);
+ portTemplateConsolidationDataList) {
updGroupsConnectivity(serviceTemplate, portTemplateConsolidationData, context);
}
+
+ //Add requirements in the abstract node template for nodes connected in for subInterface
+ List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
+ getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+ for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
+ subInterfaceTemplateConsolidationDataList) {
+ updGroupsConnectivity(serviceTemplate, subInterfaceTemplateConsolidationData, context);
+ }
}
}
private void updGroupsConnectivity(ServiceTemplate serviceTemplate, EntityConsolidationData
- entityConsolidationData, TranslationContext context) {
+ entityConsolidationData, TranslationContext context) {
List<String> groupIds = entityConsolidationData.getGroupIds();
if (groupIds == null) {
return;
}
String oldNodeTemplateId = entityConsolidationData.getNodeTemplateId();
String abstractNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(
- serviceTemplate, entityConsolidationData.getNodeTemplateId());
+ serviceTemplate, entityConsolidationData.getNodeTemplateId());
Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template().getGroups();
- if (groups != null) {
- for (String groupId : groupIds) {
- GroupDefinition groupDefinition = groups.get(groupId);
- if (groupDefinition != null) {
- List<String> groupMembers = groupDefinition.getMembers();
- if (groupMembers.contains(oldNodeTemplateId)) {
- //Replace the old node template id
- groupMembers.remove(oldNodeTemplateId);
- if (!groupMembers.contains(abstractNodeTemplateId)) {
- //Add the abstract node template id if not already present
- groupMembers.add(abstractNodeTemplateId);
- }
- }
+ if (groups == null) {
+ return;
+ }
+ for (String groupId : groupIds) {
+ GroupDefinition groupDefinition = groups.get(groupId);
+ if (groupDefinition == null) {
+ continue;
+ }
+ List<String> groupMembers = groupDefinition.getMembers();
+ if (groupMembers.contains(oldNodeTemplateId)) {
+ //Replace the old node template id
+ groupMembers.remove(oldNodeTemplateId);
+ if (!groupMembers.contains(abstractNodeTemplateId)) {
+ //Add the abstract node template id if not already present
+ groupMembers.add(abstractNodeTemplateId);
}
}
}
}
- protected void updOutputParamGetAttrInConnectivity(
- ServiceTemplate serviceTemplate, List<UnifiedCompositionData> unifiedComposotionDataList,
- TranslationContext context) {
+ private void updOutputParamGetAttrInConnectivity(
+ ServiceTemplate serviceTemplate, List<UnifiedCompositionData> unifiedComposotionDataList,
+ TranslationContext context) {
for (UnifiedCompositionData unifiedCompositionData : unifiedComposotionDataList) {
ComputeTemplateConsolidationData computeTemplateConsolidationData =
- unifiedCompositionData.getComputeTemplateConsolidationData();
+ unifiedCompositionData.getComputeTemplateConsolidationData();
String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
- computeTemplateConsolidationData.getNodeTemplateId());
+ computeTemplateConsolidationData.getNodeTemplateId());
updOutputParamGetAttrInConnectivity(serviceTemplate, computeTemplateConsolidationData,
- computeTemplateConsolidationData.getNodeTemplateId(), newComputeNodeTemplateId,
- context, false);
+ computeTemplateConsolidationData.getNodeTemplateId(), newComputeNodeTemplateId,
+ context, false);
String computeType =
- getComputeTypeSuffix(serviceTemplate,
- computeTemplateConsolidationData.getNodeTemplateId());
+ getComputeTypeSuffix(serviceTemplate,
+ computeTemplateConsolidationData.getNodeTemplateId());
List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
- getPortTemplateConsolidationDataList(unifiedCompositionData);
+ getPortTemplateConsolidationDataList(unifiedCompositionData);
for (PortTemplateConsolidationData portTemplateConsolidationData :
- portTemplateConsolidationDataList) {
+ portTemplateConsolidationDataList) {
String newPortNodeTemplateId =
- getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(), computeType,
- computeTemplateConsolidationData);
+ getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(), computeType,
+ computeTemplateConsolidationData);
updOutputParamGetAttrInConnectivity(serviceTemplate, portTemplateConsolidationData,
- portTemplateConsolidationData.getNodeTemplateId(), newPortNodeTemplateId, context,
- false);
+ portTemplateConsolidationData.getNodeTemplateId(), newPortNodeTemplateId, context,
+ false);
}
+
+ updateSubInterfaceOutputParamGetAttrIn(serviceTemplate, unifiedCompositionData,
+ computeTemplateConsolidationData, computeType, context);
}
}
- protected void updNodesGetAttrInConnectivity(
- ServiceTemplate serviceTemplate,
- List<UnifiedCompositionData> unifiedComposotionDataList,
- TranslationContext context) {
+ private void updateSubInterfaceOutputParamGetAttrIn(ServiceTemplate serviceTemplate,
+ UnifiedCompositionData unifiedCompositionData,
+ ComputeTemplateConsolidationData computeTemplateConsolidationData,
+ String computeType,
+ TranslationContext context) {
+ List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
+ getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+ for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
+ subInterfaceTemplateConsolidationDataList) {
+ String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(serviceTemplate, computeType,
+ computeTemplateConsolidationData, subInterfaceTemplateConsolidationData, context);
+ updOutputParamGetAttrInConnectivity(serviceTemplate, subInterfaceTemplateConsolidationData,
+ subInterfaceTemplateConsolidationData.getNodeTemplateId(), newSubInterfaceNodeTemplateId, context,
+ false);
+ }
+ }
+
+ private void updNodesGetAttrInConnectivity(
+ ServiceTemplate serviceTemplate,
+ List<UnifiedCompositionData> unifiedComposotionDataList,
+ TranslationContext context) {
Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType =
- getAllConsolidationNodeTemplateIdAndType(unifiedComposotionDataList);
+ getAllConsolidationNodeTemplateIdAndType(unifiedComposotionDataList);
for (UnifiedCompositionData unifiedCompositionData : unifiedComposotionDataList) {
ComputeTemplateConsolidationData computeTemplateConsolidationData =
- unifiedCompositionData.getComputeTemplateConsolidationData();
+ unifiedCompositionData.getComputeTemplateConsolidationData();
String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
- computeTemplateConsolidationData.getNodeTemplateId());
+ computeTemplateConsolidationData.getNodeTemplateId());
updNodeGetAttrInConnectivity(serviceTemplate, computeTemplateConsolidationData,
- computeTemplateConsolidationData.getNodeTemplateId(),
- newComputeNodeTemplateId, context, consolidationNodeTemplateIdAndType, false);
+ computeTemplateConsolidationData.getNodeTemplateId(),
+ newComputeNodeTemplateId, context, consolidationNodeTemplateIdAndType, false);
String computeType =
- getComputeTypeSuffix(serviceTemplate,
- computeTemplateConsolidationData.getNodeTemplateId());
+ getComputeTypeSuffix(serviceTemplate,
+ computeTemplateConsolidationData.getNodeTemplateId());
List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
- getPortTemplateConsolidationDataList(unifiedCompositionData);
+ getPortTemplateConsolidationDataList(unifiedCompositionData);
for (PortTemplateConsolidationData portTemplateConsolidationData :
- portTemplateConsolidationDataList) {
+ portTemplateConsolidationDataList) {
String newPotNodeTemplateId =
- getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(), computeType,
- computeTemplateConsolidationData);
+ getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(), computeType,
+ computeTemplateConsolidationData);
updNodeGetAttrInConnectivity(serviceTemplate, portTemplateConsolidationData,
- portTemplateConsolidationData.getNodeTemplateId(),
- newPotNodeTemplateId, context, consolidationNodeTemplateIdAndType, false);
+ portTemplateConsolidationData.getNodeTemplateId(),
+ newPotNodeTemplateId, context, consolidationNodeTemplateIdAndType, false);
}
+
+ updateSubInterfaceNodesGetAttrIn(serviceTemplate, unifiedCompositionData,
+ computeTemplateConsolidationData, computeType, consolidationNodeTemplateIdAndType, context);
+ }
+ }
+
+ private void updateSubInterfaceNodesGetAttrIn(ServiceTemplate serviceTemplate,
+ UnifiedCompositionData unifiedCompositionData,
+ ComputeTemplateConsolidationData computeTemplateConsolidationData,
+ String computeType,
+ Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType,
+ TranslationContext context) {
+ List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
+ getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+ for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
+ subInterfaceTemplateConsolidationDataList) {
+ String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(serviceTemplate, computeType,
+ computeTemplateConsolidationData, subInterfaceTemplateConsolidationData, context);
+ updNodeGetAttrInConnectivity(serviceTemplate, subInterfaceTemplateConsolidationData,
+ subInterfaceTemplateConsolidationData.getNodeTemplateId(),
+ newSubInterfaceNodeTemplateId, context,
+ consolidationNodeTemplateIdAndType, false);
}
}
protected void updNestedCompositionOutputParamGetAttrInConnectivity(
- ServiceTemplate serviceTemplate, UnifiedCompositionData unifiedCompositionData,
- TranslationContext context) {
+ ServiceTemplate serviceTemplate, UnifiedCompositionData unifiedCompositionData,
+ TranslationContext context) {
NestedTemplateConsolidationData nestedTemplateConsolidationData =
- unifiedCompositionData.getNestedTemplateConsolidationData();
+ unifiedCompositionData.getNestedTemplateConsolidationData();
if (Objects.isNull(nestedTemplateConsolidationData)) {
return;
}
String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
Optional<String> newNestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(
- serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
+ serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
newNestedNodeTemplateId.ifPresent(
- newNestedNodeTemplateIdVal -> updOutputParamGetAttrInConnectivity(serviceTemplate,
- nestedTemplateConsolidationData, nestedTemplateConsolidationData.getNodeTemplateId(),
- newNestedNodeTemplateIdVal, context, true));
+ newNestedNodeTemplateIdVal -> updOutputParamGetAttrInConnectivity(serviceTemplate,
+ nestedTemplateConsolidationData, nestedTemplateConsolidationData.getNodeTemplateId(),
+ newNestedNodeTemplateIdVal, context, true));
}
protected void updNestedCompositionNodesGetAttrInConnectivity(
- ServiceTemplate serviceTemplate,
- UnifiedCompositionData unifiedCompositionData,
- TranslationContext context) {
+ ServiceTemplate serviceTemplate,
+ UnifiedCompositionData unifiedCompositionData,
+ TranslationContext context) {
NestedTemplateConsolidationData nestedTemplateConsolidationData =
- unifiedCompositionData.getNestedTemplateConsolidationData();
+ unifiedCompositionData.getNestedTemplateConsolidationData();
if (Objects.isNull(nestedTemplateConsolidationData)) {
return;
}
String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
Optional<String> newNestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(
- serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
+ serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
newNestedNodeTemplateId.ifPresent(
- newNestedNodeTemplateIdVal -> updNodeGetAttrInConnectivity(serviceTemplate,
- nestedTemplateConsolidationData, nestedTemplateConsolidationData.getNodeTemplateId(),
- newNestedNodeTemplateIdVal, context, null, true));
+ newNestedNodeTemplateIdVal -> updNodeGetAttrInConnectivity(serviceTemplate,
+ nestedTemplateConsolidationData, nestedTemplateConsolidationData.getNodeTemplateId(),
+ newNestedNodeTemplateIdVal, context, null, true));
}
private void updateRequirementForNodesConnectedIn(
- ServiceTemplate serviceTemplate,
- RequirementAssignmentData requirementAssignmentData,
- EntityConsolidationData entityConsolidationData,
- String originalNodeTemplateId,
- String newNodeTemplateId,
- TranslationContext context) {
+ ServiceTemplate serviceTemplate,
+ RequirementAssignmentData requirementAssignmentData,
+ EntityConsolidationData entityConsolidationData,
+ String originalNodeTemplateId,
+ String newNodeTemplateId,
+ TranslationContext context) {
ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
RequirementAssignment requirementAssignment = requirementAssignmentData
- .getRequirementAssignment();
+ .getRequirementAssignment();
String newAbstractUnifiedNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(
- serviceTemplate, entityConsolidationData.getNodeTemplateId());
+ serviceTemplate, entityConsolidationData.getNodeTemplateId());
NodeTemplate abstractUnifiedNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
- newAbstractUnifiedNodeTemplateId);
+ newAbstractUnifiedNodeTemplateId);
Optional<String> newCapabilityId = getNewCapabilityForNodesConnectedIn(serviceTemplate,
- abstractUnifiedNodeTemplate, requirementAssignment, newNodeTemplateId, context);
+ abstractUnifiedNodeTemplate, requirementAssignment, newNodeTemplateId, context);
if (newCapabilityId.isPresent()) {
//Creating a copy of the requirement object and checking if it already exists in the
// original node template
RequirementAssignment requirementAssignmentCopy = (RequirementAssignment) getClonedObject(
- requirementAssignmentData.getRequirementAssignment(), RequirementAssignment.class);
+ requirementAssignmentData.getRequirementAssignment(), RequirementAssignment.class);
NodeTemplate originalNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
- originalNodeTemplateId);
+ originalNodeTemplateId);
requirementAssignmentCopy.setCapability(newCapabilityId.get());
requirementAssignmentCopy.setNode(newAbstractUnifiedNodeTemplateId);
if (!toscaAnalyzerService.isRequirementExistInNodeTemplate(originalNodeTemplate,
- requirementAssignmentData.getRequirementId(), requirementAssignmentCopy)) {
+ requirementAssignmentData.getRequirementId(), requirementAssignmentCopy)) {
//Update the existing requirement
requirementAssignmentData.getRequirementAssignment().setCapability(newCapabilityId
- .get());
+ .get());
requirementAssignmentData.getRequirementAssignment()
- .setNode(newAbstractUnifiedNodeTemplateId);
+ .setNode(newAbstractUnifiedNodeTemplateId);
} else {
//The updated requirement already exists in the node template so simply remove the
// current one
DataModelUtil.removeRequirementAssignment(originalNodeTemplate, requirementAssignmentData
- .getRequirementId(), requirementAssignmentData.getRequirementAssignment());
+ .getRequirementId(), requirementAssignmentData.getRequirementAssignment());
}
}
}
private void updateRequirementForNestedCompositionNodesConnectedIn(
- ServiceTemplate serviceTemplate,
- RequirementAssignmentData requirementAssignmentData,
- EntityConsolidationData entityConsolidationData,
- String newNodeTemplateId,
- TranslationContext context) {
+ ServiceTemplate serviceTemplate,
+ RequirementAssignmentData requirementAssignmentData,
+ String newNodeTemplateId) {
ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
String newAbstractUnifiedNodeTemplateId = newNodeTemplateId;
RequirementAssignment requirementAssignment = requirementAssignmentData
- .getRequirementAssignment();
+ .getRequirementAssignment();
//Creating a copy of the requirement object and checking if it already exists in the
// original node template
RequirementAssignment requirementAssignmentCopy = (RequirementAssignment) getClonedObject(
- requirementAssignmentData.getRequirementAssignment(), RequirementAssignment.class);
+ requirementAssignmentData.getRequirementAssignment(), RequirementAssignment.class);
NodeTemplate unifiedAbstractNestedNodeTemplate = DataModelUtil
- .getNodeTemplate(serviceTemplate, newAbstractUnifiedNodeTemplateId);
+ .getNodeTemplate(serviceTemplate, newAbstractUnifiedNodeTemplateId);
requirementAssignmentCopy.setCapability(requirementAssignment.getCapability());
requirementAssignmentCopy.setNode(newAbstractUnifiedNodeTemplateId);
if (!toscaAnalyzerService.isRequirementExistInNodeTemplate(unifiedAbstractNestedNodeTemplate,
- requirementAssignmentData.getRequirementId(), requirementAssignmentCopy)) {
+ requirementAssignmentData.getRequirementId(), requirementAssignmentCopy)) {
//Update the existing requirement
requirementAssignmentData.getRequirementAssignment()
- .setNode(newAbstractUnifiedNodeTemplateId);
+ .setNode(newAbstractUnifiedNodeTemplateId);
} else {
//The updated requirement already exists in the node template so simply remove the
// current one
DataModelUtil.removeRequirementAssignment(unifiedAbstractNestedNodeTemplate,
- requirementAssignmentData.getRequirementId(), requirementAssignmentData
- .getRequirementAssignment());
+ requirementAssignmentData.getRequirementId(), requirementAssignmentData
+ .getRequirementAssignment());
}
}
private Optional<String> getNewCapabilityForNodesConnectedIn(ServiceTemplate serviceTemplate,
NodeTemplate unifiedNodeTemplate,
RequirementAssignment
- requirementAssignment,
+ requirementAssignment,
String newNodeTemplateId,
TranslationContext context) {
ServiceTemplate globalSubstitutionServiceTemplate =
- HeatToToscaUtil.fetchGlobalSubstitutionServiceTemplate(serviceTemplate, context);
+ HeatToToscaUtil.fetchGlobalSubstitutionServiceTemplate(serviceTemplate, context);
Map<String, NodeType> nodeTypes = globalSubstitutionServiceTemplate.getNode_types();
String unifiedNodeTemplateType = unifiedNodeTemplate.getType();
NodeType unifiedNodeType = nodeTypes.get(unifiedNodeTemplateType);
Map<String, CapabilityDefinition> abstractNodeTypeCapabilities = unifiedNodeType
- .getCapabilities();
+ .getCapabilities();
for (Map.Entry<String, CapabilityDefinition> entry : abstractNodeTypeCapabilities.entrySet()) {
String capabilityId = entry.getKey();
CapabilityDefinition capabilityDefinition = entry.getValue();
String capabilityType = capabilityDefinition.getType();
- if (capabilityType.equals(requirementAssignment.getCapability())) {
+ if (capabilityType.equals(requirementAssignment.getCapability())
+ && capabilityId.endsWith(newNodeTemplateId)) {
//Matching capability type found..Check if the id ends with new node template id
- if (capabilityId.endsWith(newNodeTemplateId)) {
- return Optional.ofNullable(capabilityId);
- }
+ return Optional.ofNullable(capabilityId);
}
}
return Optional.empty();
private void updateRequirementInAbstractNodeTemplate(ServiceTemplate serviceTemplate,
EntityConsolidationData
- entityConsolidationData,
+ entityConsolidationData,
String newNodeTemplateId,
Map<String, List<RequirementAssignmentData>>
- requirementAssignmentDataMap,
+ requirementAssignmentDataMap,
TranslationContext context) {
ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
for (Map.Entry<String, List<RequirementAssignmentData>> entry : requirementAssignmentDataMap
- .entrySet()) {
+ .entrySet()) {
String abstractNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(
- serviceTemplate, entityConsolidationData.getNodeTemplateId());
+ serviceTemplate, entityConsolidationData.getNodeTemplateId());
NodeTemplate abstractNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
- abstractNodeTemplateId);
+ abstractNodeTemplateId);
if (abstractNodeTemplate == null) {
//The abstract node template is not found from id in the context
return;
for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
String oldRequirementId = requirementAssignmentData.getRequirementId();
RequirementAssignment abstractRequirementAssignment = (RequirementAssignment)
- getClonedObject(requirementAssignmentData.getRequirementAssignment(),
- RequirementAssignment.class);
+ getClonedObject(requirementAssignmentData.getRequirementAssignment(),
+ RequirementAssignment.class);
String newRequirementId = oldRequirementId + "_" + newNodeTemplateId;
//Check if the requirement is not already present in the list of requirements of the
// abstract node template
if (!toscaAnalyzerService.isRequirementExistInNodeTemplate(abstractNodeTemplate,
- newRequirementId, abstractRequirementAssignment)) {
+ newRequirementId, abstractRequirementAssignment)) {
DataModelUtil.addRequirementAssignment(abstractNodeTemplate, newRequirementId,
- abstractRequirementAssignment);
+ abstractRequirementAssignment);
//Update the volume relationship template if required
updateVolumeRelationshipTemplate(serviceTemplate, abstractRequirementAssignment
- .getRelationship(), context);
+ .getRelationship(), context);
}
}
}
private void updateRequirementInNestedNodeTemplate(ServiceTemplate serviceTemplate,
EntityConsolidationData
- entityConsolidationData,
+ entityConsolidationData,
String newNodeTemplateId,
Map<String, List<RequirementAssignmentData>>
- requirementAssignmentDataMap) {
+ requirementAssignmentDataMap) {
ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
- if(MapUtils.isEmpty(requirementAssignmentDataMap)){
+ if (MapUtils.isEmpty(requirementAssignmentDataMap)) {
return;
}
for (Map.Entry<String, List<RequirementAssignmentData>> entry : requirementAssignmentDataMap
- .entrySet()) {
+ .entrySet()) {
String nodeTemplateId = entityConsolidationData.getNodeTemplateId();
NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, nodeTemplateId);
if (nodeTemplate == null) {
for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
String oldRequirementId = requirementAssignmentData.getRequirementId();
RequirementAssignment clonedRequirementAssignment = (RequirementAssignment)
- getClonedObject(requirementAssignmentData.getRequirementAssignment(),
- RequirementAssignment.class);
+ getClonedObject(requirementAssignmentData.getRequirementAssignment(),
+ RequirementAssignment.class);
String newRequirementId = oldRequirementId + "_" + newNodeTemplateId;
//Check if the requirement is not already present in the list of requirements of the
// node template
if (!toscaAnalyzerService.isRequirementExistInNodeTemplate(nodeTemplate,
- newRequirementId, clonedRequirementAssignment)) {
+ newRequirementId, clonedRequirementAssignment)) {
DataModelUtil.removeRequirementAssignment(nodeTemplate, oldRequirementId,
- requirementAssignmentData.getRequirementAssignment());
+ requirementAssignmentData.getRequirementAssignment());
DataModelUtil.addRequirementAssignment(nodeTemplate, newRequirementId,
- clonedRequirementAssignment);
+ clonedRequirementAssignment);
}
}
}
}
- private NodeTemplate getAbstractNodeTemplate(
- ServiceTemplate serviceTemplate,
- UnifiedCompositionEntity unifiedCompositionEntity,
- ComputeTemplateConsolidationData computeTemplateConsolidationData,
- PortTemplateConsolidationData portTemplateConsolidationData,
- TranslationContext context) {
- String abstractNodeTemplateId =
- getAbstractNodeTemplateId(serviceTemplate, unifiedCompositionEntity,
- computeTemplateConsolidationData, portTemplateConsolidationData, context);
-
- return DataModelUtil.getNodeTemplate(serviceTemplate,
- abstractNodeTemplateId);
- }
-
- private String getAbstractNodeTemplateId(
- ServiceTemplate serviceTemplate,
- UnifiedCompositionEntity unifiedCompositionEntity,
- ComputeTemplateConsolidationData computeTemplateConsolidationData,
- PortTemplateConsolidationData portTemplateConsolidationData,
- TranslationContext context) {
- switch (unifiedCompositionEntity) {
- case Compute:
- return context.getUnifiedAbstractNodeTemplateId(serviceTemplate,
- computeTemplateConsolidationData.getNodeTemplateId());
- case Port:
- return context.getUnifiedAbstractNodeTemplateId(serviceTemplate,
- portTemplateConsolidationData.getNodeTemplateId());
- default:
- return null;
- }
- }
-
private void updNodeGetAttrInConnectivity(
- ServiceTemplate serviceTemplate,
- EntityConsolidationData entityConsolidationData,
- String oldNodeTemplateId, String newNodeTemplateId,
- TranslationContext context,
- Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType,
- boolean isNested) {
+ ServiceTemplate serviceTemplate,
+ EntityConsolidationData entityConsolidationData,
+ String oldNodeTemplateId, String newNodeTemplateId,
+ TranslationContext context,
+ Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType,
+ boolean isNested) {
Map<String, List<GetAttrFuncData>> nodesGetAttrIn = entityConsolidationData.getNodesGetAttrIn();
if (MapUtils.isEmpty(nodesGetAttrIn)) {
return;
}
- for (String sourceNodeTemplateId : nodesGetAttrIn.keySet()) {
+ for (Map.Entry<String, List<GetAttrFuncData>> nodesGetAttrInEntry : nodesGetAttrIn.entrySet()) {
+ String sourceNodeTemplateId = nodesGetAttrInEntry.getKey();
NodeTemplate sourceNodeTemplate =
- DataModelUtil.getNodeTemplate(serviceTemplate, sourceNodeTemplateId);
+ DataModelUtil.getNodeTemplate(serviceTemplate, sourceNodeTemplateId);
if (!isNested && consolidationNodeTemplateIdAndType.keySet().contains(sourceNodeTemplateId)) {
continue;
}
- List<GetAttrFuncData> getAttrFuncDataList = nodesGetAttrIn.get(sourceNodeTemplateId);
+ List<GetAttrFuncData> getAttrFuncDataList = nodesGetAttrInEntry.getValue();
for (GetAttrFuncData getAttrFuncData : getAttrFuncDataList) {
Object propertyValue =
- DataModelUtil.getPropertyValue(sourceNodeTemplate, getAttrFuncData.getFieldName());
+ DataModelUtil.getPropertyValue(sourceNodeTemplate, getAttrFuncData.getFieldName());
String newAttrName = null;
String newGetAttrAbstractNodeTemplateId = newNodeTemplateId;
if (!isNested) {
newGetAttrAbstractNodeTemplateId =
- context.getUnifiedAbstractNodeTemplateId(serviceTemplate, oldNodeTemplateId);
+ context.getUnifiedAbstractNodeTemplateId(serviceTemplate, oldNodeTemplateId);
newAttrName = getNewSubstitutionOutputParameterId(newNodeTemplateId, getAttrFuncData
- .getAttributeName());
+ .getAttributeName());
}
List<List<Object>> getAttrFuncValueList = extractGetAttrFunction(propertyValue);
updateGetAttrValue(oldNodeTemplateId, getAttrFuncData, newGetAttrAbstractNodeTemplateId,
- newAttrName, getAttrFuncValueList, isNested);
+ newAttrName, getAttrFuncValueList, isNested);
}
}
}
List<List<Object>> getAttrFuncValueList, boolean isNested) {
for (List<Object> getAttrFuncValue : getAttrFuncValueList) {
if (oldNodeTemplateId.equals(getAttrFuncValue.get(0))
- && getAttrFuncData.getAttributeName().equals(getAttrFuncValue.get(1))) {
+ && getAttrFuncData.getAttributeName().equals(getAttrFuncValue.get(1))) {
getAttrFuncValue.set(0, newNodeTemplateId);
if (!isNested) {
getAttrFuncValue.set(1, newAttrName);
}
}
- private String getTemplateName(ServiceTemplate serviceTemplate,
- UnifiedCompositionData unifiedCompositionData,
- String nodeTypeId,
+ private String getTemplateName(String nodeTypeId,
Integer index) {
- ComputeTemplateConsolidationData computeTemplateConsolidationData =
- unifiedCompositionData.getComputeTemplateConsolidationData();
String computeType = getComputeTypeSuffix(nodeTypeId);
String templateName = "Nested_" + computeType;
if (Objects.nonNull(index)) {
return templateName;
}
- private String getComputeTypeSuffix(ServiceTemplate serviceTemplate,
- String computeNodeTemplateId) {
- NodeTemplate computeNodeTemplate =
- DataModelUtil.getNodeTemplate(serviceTemplate, computeNodeTemplateId);
- return getComputeTypeSuffix(computeNodeTemplate.getType());
- }
-
- /**
- * Gets compute type.
- *
- * @param computeType the compute node type abc.def.vFSB
- * @return the compute type e.g.:vFSB
- */
- private String getComputeTypeSuffix(String computeType) {
- return DataModelUtil.getNamespaceSuffix(computeType);
- }
-
private void updOutputParamGetAttrInConnectivity(ServiceTemplate serviceTemplate,
EntityConsolidationData entityConsolidationData,
String oldNodeTemplateId,
TranslationContext context,
boolean isNested) {
List<GetAttrFuncData> outputParametersGetAttrIn =
- entityConsolidationData.getOutputParametersGetAttrIn();
+ entityConsolidationData.getOutputParametersGetAttrIn();
if (CollectionUtils.isEmpty(outputParametersGetAttrIn)) {
return;
}
for (GetAttrFuncData getAttrFuncData : outputParametersGetAttrIn) {
Object outputParamValue =
- DataModelUtil.getOuputParameter(serviceTemplate, getAttrFuncData.getFieldName())
- .getValue();
+ DataModelUtil.getOuputParameter(serviceTemplate, getAttrFuncData.getFieldName())
+ .getValue();
String newAttrName = null;
String newGetAttrAbstractNodeTemplateId = newNodeTemplateId;
if (!isNested) {
newGetAttrAbstractNodeTemplateId =
- context.getUnifiedAbstractNodeTemplateId(serviceTemplate, oldNodeTemplateId);
+ context.getUnifiedAbstractNodeTemplateId(serviceTemplate, oldNodeTemplateId);
newAttrName = getNewSubstitutionOutputParameterId(newNodeTemplateId, getAttrFuncData
- .getAttributeName());
+ .getAttributeName());
}
List<List<Object>> getAttrFuncValueList = extractGetAttrFunction(outputParamValue);
updateGetAttrValue(oldNodeTemplateId, getAttrFuncData, newGetAttrAbstractNodeTemplateId,
- newAttrName,
- getAttrFuncValueList, isNested);
+ newAttrName,
+ getAttrFuncValueList, isNested);
}
}
if (valueObject instanceof Map) {
if (((Map) valueObject).containsKey(ToscaFunctions.GET_ATTRIBUTE.getDisplayName())) {
getAttrValueList.add(
- (List<Object>) ((Map) valueObject).get(ToscaFunctions.GET_ATTRIBUTE.getDisplayName()));
+ (List<Object>) ((Map) valueObject).get(ToscaFunctions.GET_ATTRIBUTE.getDisplayName()));
}
for (Object key : ((Map) valueObject).keySet()) {
}
Set<Map.Entry<String, Object>> entries = ((Map<String, Object>) valueObject).entrySet();
- for(Map.Entry<String, Object> valueObjectEntry : entries){
- if(isIncludeToscaFunc(valueObjectEntry.getValue(), toscaFunction)){
+ for (Map.Entry<String, Object> valueObjectEntry : entries) {
+ if (isIncludeToscaFunc(valueObjectEntry.getValue(), toscaFunction)) {
return true;
}
}
-// Map.Entry<String, Object> functionMapEntry =
-// (Map.Entry<String, Object>) ((Map) valueObject).entrySet().iterator().next();
-// return isIncludeToscaFunc(functionMapEntry.getValue(), toscaFunction);
-
} else if (valueObject instanceof List) {
for (Object valueEntity : (List) valueObject) {
- if (isIncludeToscaFunc(valueEntity, toscaFunction) == true) {
+ if (isIncludeToscaFunc(valueEntity, toscaFunction)) {
return true;
}
}
return false;
}
- private void createOutputParameters(ServiceTemplate serviceTemplate,
- ServiceTemplate substitutionServiceTemplate,
- List<UnifiedCompositionData> unifiedCompositionDataList,
- String computeNodeType, TranslationContext context) {
+ private void createOutputParameters(UnifiedCompositionTo unifiedCompositionTo,
+ String computeNodeType) {
- createOutputParametersForCompute(serviceTemplate, substitutionServiceTemplate,
- unifiedCompositionDataList, context);
- createOutputParameterForPorts(serviceTemplate, substitutionServiceTemplate,
- unifiedCompositionDataList, computeNodeType, context);
+ createOutputParametersForCompute(unifiedCompositionTo.getServiceTemplate(),
+ unifiedCompositionTo.getSubstitutionServiceTemplate(), unifiedCompositionTo.getUnifiedCompositionDataList(),
+ unifiedCompositionTo.getContext());
+ createOutputParameterForPorts(unifiedCompositionTo.getSubstitutionServiceTemplate(),
+ unifiedCompositionTo.getUnifiedCompositionDataList(), computeNodeType, unifiedCompositionTo.getContext());
+ createOutputParameterForSubInterfaces(unifiedCompositionTo, computeNodeType);
}
private void createOutputParameterForPorts(
- ServiceTemplate serviceTemplate,
- ServiceTemplate substitutionServiceTemplate,
- List<UnifiedCompositionData> unifiedCompositionDataList,
- String connectedComputeNodeType,
- TranslationContext context) {
+ ServiceTemplate substitutionServiceTemplate,
+ List<UnifiedCompositionData> unifiedCompositionDataList,
+ String connectedComputeNodeType,
+ TranslationContext context) {
for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
- getPortTemplateConsolidationDataList(unifiedCompositionData);
+ getPortTemplateConsolidationDataList(unifiedCompositionData);
if (CollectionUtils.isEmpty(portTemplateConsolidationDataList)) {
return;
}
for (PortTemplateConsolidationData portTemplateConsolidationData :
- portTemplateConsolidationDataList) {
+ portTemplateConsolidationDataList) {
String newPortNodeTemplateId =
- getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(),
- connectedComputeNodeType,
- unifiedCompositionData.getComputeTemplateConsolidationData());
+ getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(),
+ connectedComputeNodeType,
+ unifiedCompositionData.getComputeTemplateConsolidationData());
addOutputParameters(portTemplateConsolidationData, newPortNodeTemplateId,
- serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList, context);
+ substitutionServiceTemplate, unifiedCompositionDataList, context);
}
}
}
- //The ID should be <vm_type>_<port_type> or <vm_type>_<portNodeTemplateId>
- private String getNewPortNodeTemplateId(
- String portNodeTemplateId,
- String connectedComputeNodeType,
- ComputeTemplateConsolidationData computeTemplateConsolidationData) {
+ private void createOutputParameterForSubInterfaces(UnifiedCompositionTo unifiedCompositionTo,
+ String connectedComputeNodeType) {
+ for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionTo.getUnifiedCompositionDataList()) {
+ List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
+ getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+ if (CollectionUtils.isEmpty(subInterfaceTemplateConsolidationDataList)) {
+ return;
+ }
- StringBuilder newPortNodeTemplateId = new StringBuilder();
- String portType = ConsolidationDataUtil.getPortType(portNodeTemplateId);
- newPortNodeTemplateId.append(DataModelUtil.getNamespaceSuffix(connectedComputeNodeType));
- if (computeTemplateConsolidationData.getPorts().get(portType).size() > 1) {
- //single port
- newPortNodeTemplateId.append("_").append(portNodeTemplateId);
- } else {
- //consolidation port
- newPortNodeTemplateId.append("_").append(portType);
+ for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
+ subInterfaceTemplateConsolidationDataList) {
+ String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(unifiedCompositionTo
+ .getServiceTemplate(), connectedComputeNodeType, unifiedCompositionData
+ .getComputeTemplateConsolidationData(), subInterfaceTemplateConsolidationData,
+ unifiedCompositionTo.getContext());
+ addOutputParameters(subInterfaceTemplateConsolidationData, newSubInterfaceNodeTemplateId,
+ unifiedCompositionTo.getSubstitutionServiceTemplate(), unifiedCompositionTo.getUnifiedCompositionDataList(),
+ unifiedCompositionTo.getContext());
+ }
}
- return newPortNodeTemplateId.toString();
}
private void createOutputParametersForCompute(
- ServiceTemplate serviceTemplate,
- ServiceTemplate substitutionServiceTemplate,
- List<UnifiedCompositionData>
- unifiedCompositionDataList,
- TranslationContext context) {
+ ServiceTemplate serviceTemplate,
+ ServiceTemplate substitutionServiceTemplate,
+ List<UnifiedCompositionData>
+ unifiedCompositionDataList,
+ TranslationContext context) {
List<EntityConsolidationData> computeConsolidationDataList =
- getComputeConsolidationDataList(unifiedCompositionDataList);
+ getComputeConsolidationDataList(unifiedCompositionDataList);
for (EntityConsolidationData computeTemplateConsolidationData : computeConsolidationDataList) {
String newComputeNodeTemplateId =
- getNewComputeNodeTemplateId(serviceTemplate,
- computeTemplateConsolidationData.getNodeTemplateId());
+ getNewComputeNodeTemplateId(serviceTemplate,
+ computeTemplateConsolidationData.getNodeTemplateId());
addOutputParameters(computeTemplateConsolidationData, newComputeNodeTemplateId,
- serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList, context);
+ substitutionServiceTemplate, unifiedCompositionDataList, context);
}
}
private void addOutputParameters(EntityConsolidationData entityConsolidationData,
String newNodeTemplateId,
- ServiceTemplate serviceTemplate,
ServiceTemplate substitutionServiceTemplate,
List<UnifiedCompositionData> unifiedCompositionDataList,
TranslationContext context) {
- handleNodesGetAttrIn(entityConsolidationData, newNodeTemplateId, serviceTemplate,
- substitutionServiceTemplate, unifiedCompositionDataList, context);
+ handleNodesGetAttrIn(entityConsolidationData, newNodeTemplateId, substitutionServiceTemplate,
+ unifiedCompositionDataList, context);
- handleOutputParamGetAttrIn(entityConsolidationData, newNodeTemplateId, serviceTemplate,
- substitutionServiceTemplate, context);
+ handleOutputParamGetAttrIn(entityConsolidationData, newNodeTemplateId,
+ substitutionServiceTemplate, context);
}
private void handleOutputParamGetAttrIn(EntityConsolidationData entityConsolidationData,
String newNodeTemplateId,
- ServiceTemplate serviceTemplate,
ServiceTemplate substitutionServiceTemplate,
TranslationContext context) {
List<GetAttrFuncData> outputParametersGetAttrIn =
- entityConsolidationData.getOutputParametersGetAttrIn();
+ entityConsolidationData.getOutputParametersGetAttrIn();
if (!CollectionUtils.isEmpty(outputParametersGetAttrIn)) {
for (GetAttrFuncData getAttrFuncData : outputParametersGetAttrIn) {
- createAndAddOutputParameter(entityConsolidationData, newNodeTemplateId,
- substitutionServiceTemplate, getAttrFuncData, context);
+ createAndAddOutputParameter(newNodeTemplateId,
+ substitutionServiceTemplate, getAttrFuncData, context);
}
}
}
private void handleNodesGetAttrIn(EntityConsolidationData entityConsolidationData,
String newNodeTemplateId,
- ServiceTemplate serviceTemplate,
ServiceTemplate substitutionServiceTemplate,
List<UnifiedCompositionData> unifiedCompositionDataList,
TranslationContext context) {
Map<String, List<GetAttrFuncData>> getAttrIn = entityConsolidationData.getNodesGetAttrIn();
-
- if (!MapUtils.isEmpty(getAttrIn)) {
- Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType =
- getAllConsolidationNodeTemplateIdAndType(unifiedCompositionDataList);
- for (String sourceNodeTemplateId : getAttrIn.keySet()) {
- if (!consolidationNodeTemplateIdAndType.keySet().contains(sourceNodeTemplateId)) {
- List<GetAttrFuncData> getAttrFuncDataList = getAttrIn.get(sourceNodeTemplateId);
- for (GetAttrFuncData getAttrFuncData : getAttrFuncDataList) {
- createAndAddOutputParameter(entityConsolidationData, newNodeTemplateId,
- substitutionServiceTemplate, getAttrFuncData, context);
- }
+ if (MapUtils.isEmpty(getAttrIn)) {
+ return;
+ }
+ Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType =
+ getAllConsolidationNodeTemplateIdAndType(unifiedCompositionDataList);
+ for (Map.Entry<String, List<GetAttrFuncData>> getAttrInEntry : getAttrIn.entrySet()) {
+ String sourceNodeTemplateId = getAttrInEntry.getKey();
+ if (!consolidationNodeTemplateIdAndType.keySet().contains(sourceNodeTemplateId)) {
+ List<GetAttrFuncData> getAttrFuncDataList = getAttrInEntry.getValue();
+ for (GetAttrFuncData getAttrFuncData : getAttrFuncDataList) {
+ createAndAddOutputParameter(newNodeTemplateId,
+ substitutionServiceTemplate, getAttrFuncData, context);
}
}
}
}
- private void createAndAddOutputParameter(EntityConsolidationData entityConsolidationData,
- String newNodeTemplateId,
+ private void createAndAddOutputParameter(String newNodeTemplateId,
ServiceTemplate substitutionServiceTemplate,
GetAttrFuncData getAttrFuncData,
TranslationContext context) {
ParameterDefinition outputParameter = new ParameterDefinition();
outputParameter.setValue(parameterValue);
setOutputParameterType(substitutionServiceTemplate, newNodeTemplateId, getAttrFuncData
- .getAttributeName(), outputParameter, context);
+ .getAttributeName(), outputParameter, context);
DataModelUtil.addOutputParameterToTopologyTemplate(substitutionServiceTemplate,
- getNewSubstitutionOutputParameterId(newNodeTemplateId, getAttrFuncData.getAttributeName()),
- outputParameter);
+ getNewSubstitutionOutputParameterId(newNodeTemplateId, getAttrFuncData.getAttributeName()),
+ outputParameter);
}
private void setOutputParameterType(ServiceTemplate substitutionServiceTemplate,
ParameterDefinition outputParameter,
TranslationContext context) {
NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(substitutionServiceTemplate,
- newNodeTemplateId);
+ newNodeTemplateId);
//Get the type and entry schema of the output parameter from the node type flat hierarchy
- String outputParameterType = null;
- EntrySchema outputParameterEntrySchema = null;
+ String outputParameterType;
+ EntrySchema outputParameterEntrySchema;
NodeType nodeTypeWithFlatHierarchy =
- HeatToToscaUtil.getNodeTypeWithFlatHierarchy(nodeTemplate.getType(),
- substitutionServiceTemplate, context);
+ HeatToToscaUtil.getNodeTypeWithFlatHierarchy(nodeTemplate.getType(),
+ substitutionServiceTemplate, context);
//Check if the parameter is present in the attributes
AttributeDefinition outputParameterDefinitionFromAttributes =
- getOutputParameterDefinitionFromAttributes(nodeTypeWithFlatHierarchy, outputParameterName);
+ getOutputParameterDefinitionFromAttributes(nodeTypeWithFlatHierarchy, outputParameterName);
if (Objects.nonNull(outputParameterDefinitionFromAttributes)) {
outputParameterType = outputParameterDefinitionFromAttributes.getType();
outputParameterEntrySchema = outputParameterDefinitionFromAttributes.getEntry_schema();
// properties and global types are in sync. Ideally the parameter should be found in either
// properties or attributes collected from global types
PropertyDefinition outputParameterDefinitionFromProperties =
- nodeTypeWithFlatHierarchy.getProperties().get(outputParameterName);
+ nodeTypeWithFlatHierarchy.getProperties().get(outputParameterName);
outputParameterType = outputParameterDefinitionFromProperties.getType();
outputParameterEntrySchema = outputParameterDefinitionFromProperties.getEntry_schema();
}
outputParameter.setEntry_schema(outputParameterEntrySchema);
}
- private String getNewInputParameterType(NodeTemplate nodeTemplate,
- ServiceTemplate serviceTemplate,
- String inputParameterName,
- TranslationContext context) {
- NodeType nodeTypeWithFlatHierarchy =
- HeatToToscaUtil.getNodeTypeWithFlatHierarchy(nodeTemplate.getType(),
- serviceTemplate, context);
- String parameterType = nodeTypeWithFlatHierarchy.getProperties()
- .get(inputParameterName).getType();
- return getUnifiedInputParameterType(parameterType);
- }
-
private AttributeDefinition getOutputParameterDefinitionFromAttributes(NodeType
- nodeTypeWithFlatHierarchy,
+ nodeTypeWithFlatHierarchy,
String outputParameterName) {
AttributeDefinition outputParameterDefinition = null;
if ((Objects.nonNull(nodeTypeWithFlatHierarchy.getAttributes()))
- && (nodeTypeWithFlatHierarchy.getAttributes().containsKey(outputParameterName))) {
+ && (nodeTypeWithFlatHierarchy.getAttributes().containsKey(outputParameterName))) {
outputParameterDefinition =
- nodeTypeWithFlatHierarchy.getAttributes().get(outputParameterName);
+ nodeTypeWithFlatHierarchy.getAttributes().get(outputParameterName);
}
return outputParameterDefinition;
}
- private String getUnifiedInputParameterType(String parameterType) {
- String unifiedInputParameterType = null;
- if (Objects.nonNull(parameterType)) {
- if (parameterType.equalsIgnoreCase(PropertyType.STRING.getDisplayName())
- || parameterType.equalsIgnoreCase(PropertyType.INTEGER.getDisplayName())
- || parameterType.equalsIgnoreCase(PropertyType.FLOAT.getDisplayName())
- || parameterType.equalsIgnoreCase(PropertyType.BOOLEAN.getDisplayName())
- || parameterType.equalsIgnoreCase(PropertyType.TIMESTAMP.getDisplayName())
- || parameterType.equalsIgnoreCase(PropertyType.NULL.getDisplayName())
- || parameterType.equalsIgnoreCase(PropertyType.SCALAR_UNIT_SIZE.getDisplayName())
- || parameterType.equalsIgnoreCase(PropertyType.SCALAR_UNIT_FREQUENCY.getDisplayName())) {
- unifiedInputParameterType = parameterType.toLowerCase();
- } else if (parameterType.equalsIgnoreCase(PropertyType.MAP.getDisplayName())
- || parameterType.equalsIgnoreCase(PropertyType.LIST.getDisplayName())
- || parameterType.equalsIgnoreCase(PropertyTypeExt.JSON.getDisplayName())) {
- unifiedInputParameterType = PropertyTypeExt.JSON.getDisplayName();
- } else {
- unifiedInputParameterType = parameterType;
- }
- }
- return unifiedInputParameterType;
- }
-
private String getNewSubstitutionOutputParameterId(String newNodeTemplateId,
String attributeName) {
return newNodeTemplateId + "_" + attributeName;
}
private void addUnifiedSubstitionData(TranslationContext context, ServiceTemplate
- serviceTemplate, List<UnifiedCompositionData> unifiedCompositionDataList, String
- substituteNodeTemplateId) {
+ serviceTemplate, List<UnifiedCompositionData> unifiedCompositionDataList, String
+ substituteNodeTemplateId) {
String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
//Add compute node template mapping information
ComputeTemplateConsolidationData computeTemplateConsolidationData =
- unifiedCompositionData.getComputeTemplateConsolidationData();
+ unifiedCompositionData.getComputeTemplateConsolidationData();
String computeNodeTemplateId = computeTemplateConsolidationData.getNodeTemplateId();
context.addUnifiedSubstitutionData(serviceTemplateFileName, computeNodeTemplateId,
- substituteNodeTemplateId);
+ substituteNodeTemplateId);
//Add Port template mapping information
List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
- getPortTemplateConsolidationDataList(unifiedCompositionData);
+ getPortTemplateConsolidationDataList(unifiedCompositionData);
if (CollectionUtils.isNotEmpty(portTemplateConsolidationDataList)) {
for (PortTemplateConsolidationData portTemplateConsolidationData :
- portTemplateConsolidationDataList) {
+ portTemplateConsolidationDataList) {
String oldPortNodeTemplateId = portTemplateConsolidationData.getNodeTemplateId();
context.addUnifiedSubstitutionData(serviceTemplateFileName, oldPortNodeTemplateId,
- substituteNodeTemplateId);
+ substituteNodeTemplateId);
+ }
+ }
+ //Add Sub-interface template mapping information
+ List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
+ getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+ if (CollectionUtils.isNotEmpty(subInterfaceTemplateConsolidationDataList)) {
+ for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
+ subInterfaceTemplateConsolidationDataList) {
+ context.addUnifiedSubstitutionData(serviceTemplateFileName,
+ subInterfaceTemplateConsolidationData.getNodeTemplateId(), substituteNodeTemplateId);
}
}
}
Map<String, Object> indexPropertyValue = new HashMap<>();
Map<String, Object> properties = nodeTemplate.getProperties();
indexPropertyValue.put(ToscaFunctions.GET_PROPERTY.getDisplayName(),
- indexValueGetPropertyValue);
+ indexValueGetPropertyValue);
properties.put(ToscaConstants.INDEX_VALUE_PROPERTY_NAME,
- indexPropertyValue);
+ indexPropertyValue);
nodeTemplate.setProperties(properties);
}
- private String getSubstituteNodeTemplateId(ServiceTemplate serviceTemplate,
- UnifiedCompositionData unifiedCompositionData,
- String nodeTypeId,
+ private String getSubstituteNodeTemplateId(String nodeTypeId,
Integer index) {
- String computeNodeTemplateId =
- unifiedCompositionData.getComputeTemplateConsolidationData().getNodeTemplateId();
- NodeTemplate computeNodeTemplate =
- DataModelUtil.getNodeTemplate(serviceTemplate, computeNodeTemplateId);
String nodeTemplateId = ABSTRACT_NODE_TEMPLATE_ID_PREFIX + DataModelUtil
- .getNamespaceSuffix(nodeTypeId);
+ .getNamespaceSuffix(nodeTypeId);
if (Objects.nonNull(index)) {
nodeTemplateId = nodeTemplateId + "_" + index.toString();
}
Integer index,
TranslationContext context) {
String computeNodeTemplateId =
- unifiedCompositionData.getComputeTemplateConsolidationData().getNodeTemplateId();
+ unifiedCompositionData.getComputeTemplateConsolidationData().getNodeTemplateId();
NodeTemplate computeNodeTemplate =
- DataModelUtil.getNodeTemplate(serviceTemplate, computeNodeTemplateId);
+ DataModelUtil.getNodeTemplate(serviceTemplate, computeNodeTemplateId);
String computeType = computeNodeTemplate.getType();
String globalSTName = ToscaUtil.getServiceTemplateFileName(Constants
- .GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME);
+ .GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME);
String nodeTypeId = ToscaNodeType.ABSTRACT_NODE_TYPE_PREFIX
- + DataModelUtil.getNamespaceSuffix(getIndexedGlobalNodeTypeId(computeType, context));
+ + DataModelUtil.getNamespaceSuffix(getIndexedGlobalNodeTypeId(computeType, context));
context.updateUsedTimesForNestedComputeNodeType(globalSTName, computeType);
return nodeTypeId;
}
- private String getNewComputeNodeTemplateId(
- ServiceTemplate serviceTemplate,
- String computeNodeTemplateId) {
- return getComputeTypeSuffix(serviceTemplate, computeNodeTemplateId);
- }
-
private NodeType handleSubstitutionGlobalNodeType(ServiceTemplate serviceTemplate,
ServiceTemplate substitutionServiceTemplate,
TranslationContext context,
- UnifiedCompositionData unifiedCompositionData,
- String substitutionNodeTypeId,
- Integer index) {
+ String substitutionNodeTypeId) {
NodeType substitutionNodeType = new ToscaAnalyzerServiceImpl()
- .createInitSubstitutionNodeType(substitutionServiceTemplate,
- ToscaNodeType.VFC_ABSTRACT_SUBSTITUTE);
+ .createInitSubstitutionNodeType(substitutionServiceTemplate,
+ ToscaNodeType.VFC_ABSTRACT_SUBSTITUTE);
ServiceTemplate globalSubstitutionServiceTemplate =
- HeatToToscaUtil.fetchGlobalSubstitutionServiceTemplate(serviceTemplate, context);
+ HeatToToscaUtil.fetchGlobalSubstitutionServiceTemplate(serviceTemplate, context);
DataModelUtil.addNodeType(globalSubstitutionServiceTemplate, substitutionNodeTypeId,
- substitutionNodeType);
+ substitutionNodeType);
return substitutionNodeType;
}
if (unifiedCompositionDataList.size() > 1) {
handleConsolidationPorts(serviceTemplate, substitutionServiceTemplate,
- unifiedCompositionDataList, connectedComputeNodeType, context);
+ unifiedCompositionDataList, connectedComputeNodeType, context);
} else {
handleSinglePorts(serviceTemplate, substitutionServiceTemplate, connectedComputeNodeType,
- unifiedCompositionDataList, context);
+ unifiedCompositionDataList, context);
}
}
TranslationContext context) {
UnifiedCompositionData unifiedCompositionData = unifiedCompositionDataList.get(0);
List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
- getPortTemplateConsolidationDataList(unifiedCompositionData);
+ getPortTemplateConsolidationDataList(unifiedCompositionData);
if (CollectionUtils.isEmpty(portTemplateConsolidationDataList)) {
return;
}
for (PortTemplateConsolidationData portTemplateConsolidationData :
- portTemplateConsolidationDataList) {
+ portTemplateConsolidationDataList) {
List<EntityConsolidationData> portConsolidationDataList = new ArrayList<>();
portConsolidationDataList.add(portTemplateConsolidationData);
handlePortNodeTemplate(serviceTemplate, substitutionServiceTemplate,
- portConsolidationDataList, connectedComputeNodeType,
- unifiedCompositionData.getComputeTemplateConsolidationData(),
- unifiedCompositionDataList, context);
+ portConsolidationDataList, connectedComputeNodeType,
+ unifiedCompositionData.getComputeTemplateConsolidationData(),
+ unifiedCompositionDataList, context);
}
}
String connectedComputeNodeType,
TranslationContext context) {
Collection<ComputeTemplateConsolidationData> computeConsolidationDataList =
- (Collection) getComputeConsolidationDataList(unifiedCompositionDataList);
+ (Collection) getComputeConsolidationDataList(unifiedCompositionDataList);
- Map<String, Set<String>> portIdsPerPortType = UnifiedCompositionUtil
- .collectAllPortsFromEachTypesFromComputes(computeConsolidationDataList);
+ Map<String, List<String>> portIdsPerPortType = UnifiedCompositionUtil
+ .collectAllPortsFromEachTypesFromComputes(computeConsolidationDataList);
- for (String portType : portIdsPerPortType.keySet()) {
+ for (Map.Entry<String, List<String>> portIdsPerPortTypeEntry : portIdsPerPortType.entrySet()) {
List<EntityConsolidationData> portTemplateConsolidationDataList =
- getPortConsolidationDataList(portIdsPerPortType.get(portType),
- unifiedCompositionDataList);
+ getPortConsolidationDataList(portIdsPerPortTypeEntry.getValue(),
+ unifiedCompositionDataList);
if (CollectionUtils.isEmpty(portTemplateConsolidationDataList)) {
continue;
}
handlePortNodeTemplate(serviceTemplate, substitutionServiceTemplate,
- portTemplateConsolidationDataList, connectedComputeNodeType,
- unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData(),
- unifiedCompositionDataList, context);
+ portTemplateConsolidationDataList, connectedComputeNodeType,
+ unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData(),
+ unifiedCompositionDataList, context);
}
}
private void handlePortNodeTemplate(
- ServiceTemplate serviceTemplate,
- ServiceTemplate substitutionServiceTemplate,
- List<EntityConsolidationData> portTemplateConsolidationDataList,
- String connectedComputeNodeType,
- ComputeTemplateConsolidationData computeTemplateConsolidationData,
- List<UnifiedCompositionData> unifiedCompositionDataList,
- TranslationContext context) {
+ ServiceTemplate serviceTemplate,
+ ServiceTemplate substitutionServiceTemplate,
+ List<EntityConsolidationData> portTemplateConsolidationDataList,
+ String connectedComputeNodeType,
+ ComputeTemplateConsolidationData computeTemplateConsolidationData,
+ List<UnifiedCompositionData> unifiedCompositionDataList,
+ TranslationContext context) {
EntityConsolidationData portTemplateConsolidationData =
- portTemplateConsolidationDataList.get(0);
+ portTemplateConsolidationDataList.get(0);
NodeTemplate newPortNodeTemplate = getNodeTemplate(
- portTemplateConsolidationData.getNodeTemplateId(), serviceTemplate, context).clone();
+ portTemplateConsolidationData.getNodeTemplateId(), serviceTemplate, context).clone();
removeConnectivityOut(portTemplateConsolidationData, newPortNodeTemplate);
handleProperties(serviceTemplate, newPortNodeTemplate,
- substitutionServiceTemplate, UnifiedCompositionEntity.Port,
- portTemplateConsolidationDataList, computeTemplateConsolidationData,
- unifiedCompositionDataList, context);
+ substitutionServiceTemplate, UnifiedCompositionEntity.PORT,
+ portTemplateConsolidationDataList, computeTemplateConsolidationData,
+ unifiedCompositionDataList, context);
String newPortNodeTemplateId =
- getNewPortNodeTemplateId(portTemplateConsolidationData
- .getNodeTemplateId(), connectedComputeNodeType,
- computeTemplateConsolidationData);
+ getNewPortNodeTemplateId(portTemplateConsolidationData
+ .getNodeTemplateId(), connectedComputeNodeType,
+ computeTemplateConsolidationData);
//Update requirements for relationships between the consolidation entities
- handleConsolidationEntitiesRequirementConnectivity(newPortNodeTemplateId, newPortNodeTemplate,
- serviceTemplate, context);
+ handleConsolidationEntitiesRequirementConnectivity(newPortNodeTemplate,
+ serviceTemplate, context);
DataModelUtil.addNodeTemplate(substitutionServiceTemplate, newPortNodeTemplateId,
- newPortNodeTemplate);
+ newPortNodeTemplate);
//Add the node template mapping in the context for handling requirement updation
for (EntityConsolidationData data : portTemplateConsolidationDataList) {
String newPortTemplateId = getNewPortNodeTemplateId(data.getNodeTemplateId(),
- connectedComputeNodeType, computeTemplateConsolidationData);
+ connectedComputeNodeType, computeTemplateConsolidationData);
context.addSubstitutionServiceTemplateUnifiedSubstitutionData(ToscaUtil
- .getServiceTemplateFileName(serviceTemplate), data.getNodeTemplateId(),
- newPortTemplateId);
+ .getServiceTemplateFileName(serviceTemplate), data.getNodeTemplateId(),
+ newPortTemplateId);
}
}
+ private void handleSubInterfaces(UnifiedCompositionTo unifiedCompositionTo) {
+ if (unifiedCompositionTo.getUnifiedCompositionDataList().size() > 1) {
+ handleConsolidationSubInterfaces(unifiedCompositionTo);
+ } else {
+ handleSingleSubInterfaces(unifiedCompositionTo);
+ }
+ }
+
+ private void handleSingleSubInterfaces(UnifiedCompositionTo unifiedCompositionTo) {
+ UnifiedCompositionData unifiedCompositionData = unifiedCompositionTo.getUnifiedCompositionDataList().get(0);
+ List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
+ getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+ for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
+ subInterfaceTemplateConsolidationDataList) {
+ List<SubInterfaceTemplateConsolidationData> subInterfaceDataList = new ArrayList<>();
+ subInterfaceDataList.add(subInterfaceTemplateConsolidationData);
+ createSubInterfaceSubstitutionNodeTemplate(unifiedCompositionTo, subInterfaceDataList);
+ }
+ }
+
+ private void handleConsolidationSubInterfaces(UnifiedCompositionTo unifiedCompositionTo) {
+ Collection<ComputeTemplateConsolidationData> computeConsolidationDataList =
+ (Collection) getComputeConsolidationDataList(unifiedCompositionTo.getUnifiedCompositionDataList());
+
+ Map<String, List<String>> portIdsPerPortType = UnifiedCompositionUtil
+ .collectAllPortsFromEachTypesFromComputes(computeConsolidationDataList);
+
+ for (Map.Entry<String, List<String>> portIdsPerPortTypeEntry : portIdsPerPortType.entrySet()) {
+ List<EntityConsolidationData> portEntityConsolidationDataList =
+ getPortConsolidationDataList(portIdsPerPortTypeEntry.getValue(),
+ unifiedCompositionTo.getUnifiedCompositionDataList());
+ if (CollectionUtils.isEmpty(portEntityConsolidationDataList)) {
+ continue;
+ }
+
+ List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
+ portEntityConsolidationDataList.stream()
+ .map(data -> (PortTemplateConsolidationData) data)
+ .collect(Collectors.toList());
+
+ ListMultimap<String, SubInterfaceTemplateConsolidationData> subInterfacesByType = UnifiedCompositionUtil
+ .collectAllSubInterfacesOfEachTypesFromPorts(portTemplateConsolidationDataList);
+ Set<String> subInterfaceTypes = subInterfacesByType.keySet();
+ for (String subInterfaceType: subInterfaceTypes) {
+ List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
+ subInterfacesByType.get(subInterfaceType);
+ createSubInterfaceSubstitutionNodeTemplate(unifiedCompositionTo, subInterfaceTemplateConsolidationDataList);
+ }
+ }
+ }
+
+ private void createSubInterfaceSubstitutionNodeTemplate(UnifiedCompositionTo unifiedCompositionTo,
+ List<SubInterfaceTemplateConsolidationData>
+ subInterfaceTemplateConsolidationDataList) {
+ SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData =
+ subInterfaceTemplateConsolidationDataList.get(0);
+ PortTemplateConsolidationData portTemplateConsolidationData =
+ getSubInterfacePortTemplateConsolidationData(unifiedCompositionTo.getServiceTemplate(),
+ subInterfaceTemplateConsolidationData, unifiedCompositionTo.getContext());
+
+ if (Objects.isNull(portTemplateConsolidationData)) {
+ return;
+ }
+
+ String originalSubInterfaceNodeTemplateId = subInterfaceTemplateConsolidationDataList.get(0)
+ .getNodeTemplateId();
+ NodeTemplate originalSubInterfaceNodeTemplate =
+ DataModelUtil.getNodeTemplate(unifiedCompositionTo.getServiceTemplate(), originalSubInterfaceNodeTemplateId);
+ if (Objects.isNull(originalSubInterfaceNodeTemplate)) {
+ return;
+ }
+ NodeTemplate newSubInterfaceNodeTemplate = originalSubInterfaceNodeTemplate.clone();
+ ComputeTemplateConsolidationData connectedComputeConsolidationData =
+ getConnectedComputeConsolidationData(unifiedCompositionTo.getUnifiedCompositionDataList(),
+ portTemplateConsolidationData.getNodeTemplateId());
+ if (Objects.nonNull(connectedComputeConsolidationData)) {
+ NodeTemplate connectedComputeNodeTemplate = DataModelUtil.getNodeTemplate(unifiedCompositionTo
+ .getServiceTemplate(), connectedComputeConsolidationData.getNodeTemplateId());
+ String newSubInterfaceNodeTemplateId = getNewSubInterfaceNodeTemplateId(unifiedCompositionTo
+ .getServiceTemplate(), connectedComputeNodeTemplate.getType(), connectedComputeConsolidationData,
+ subInterfaceTemplateConsolidationData, unifiedCompositionTo.getContext());
+ DataModelUtil.addNodeTemplate(unifiedCompositionTo.getSubstitutionServiceTemplate(),
+ newSubInterfaceNodeTemplateId, newSubInterfaceNodeTemplate);
+ List<EntityConsolidationData> entityConsolidationDataList =
+ new ArrayList<>(subInterfaceTemplateConsolidationDataList);
+ //Remove all the existing properties as we are going to create new based on the
+ // naming convention for the substitution
+ handleSubInterfaceProperties(unifiedCompositionTo, newSubInterfaceNodeTemplate, entityConsolidationDataList,
+ portTemplateConsolidationData);
+ //Update requirements for relationships between the consolidation entities
+ handleConsolidationEntitiesRequirementConnectivity(newSubInterfaceNodeTemplate, unifiedCompositionTo
+ .getServiceTemplate(), unifiedCompositionTo.getContext());
+ removeConnectivityOut(subInterfaceTemplateConsolidationData,newSubInterfaceNodeTemplate);
+ }
+ }
+
+ private void handleSubInterfaceProperties(UnifiedCompositionTo unifiedCompositionTo,
+ NodeTemplate newSubInterfaceNodeTemplate,
+ List<EntityConsolidationData>
+ entityConsolidationDataList,
+ PortTemplateConsolidationData
+ portTemplateConsolidationData) {
+ UnifiedCompositionData unifiedCompositionData = unifiedCompositionTo.getUnifiedCompositionDataList().get(0);
+ ServiceTemplate serviceTemplate = unifiedCompositionTo.getServiceTemplate();
+ TranslationContext context = unifiedCompositionTo.getContext();
+ newSubInterfaceNodeTemplate.setProperties(new HashMap<>());
+ for (EntityConsolidationData entityConsolidationData : entityConsolidationDataList) {
+ String nodeTemplateId = entityConsolidationData.getNodeTemplateId();
+ Optional<List<String>> indexVarProperties =
+ context.getIndexVarProperties(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
+ nodeTemplateId);
+ Map<String, Object> properties =
+ DataModelUtil.getNodeTemplateProperties(serviceTemplate, nodeTemplateId);
+ if (MapUtils.isEmpty(properties)) {
+ continue;
+ }
+
+ for (Map.Entry<String, Object> propertyEntry : properties.entrySet()) {
+ NodeType nodeTypeWithFlatHierarchy =
+ HeatToToscaUtil.getNodeTypeWithFlatHierarchy(newSubInterfaceNodeTemplate.getType(),
+ serviceTemplate, context);
+ PropertyDefinition propertyDefinition =
+ nodeTypeWithFlatHierarchy.getProperties().get(propertyEntry.getKey());
+ String propertyType = propertyDefinition.getType();
+ //Handle service_template_filter property for subinterface as we should not create inputs
+ // for this property
+ if (propertyEntry.getKey().equals(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME)) {
+ handleSubInterfaceServiceTemplateFilterProperty(newSubInterfaceNodeTemplate,
+ propertyEntry.getKey(), propertyEntry.getValue(), serviceTemplate,
+ unifiedCompositionTo.getSubstitutionServiceTemplate());
+ } else if (indexVarProperties.isPresent()
+ && indexVarProperties.get().contains(propertyEntry.getKey())) {
+ //Handle index property
+ handleIndexVarProperty(propertyEntry.getKey(), propertyEntry.getValue(),
+ newSubInterfaceNodeTemplate);
+ } else {
+ Optional<String> parameterId =
+ updateProperty(serviceTemplate, nodeTemplateId, newSubInterfaceNodeTemplate,
+ propertyEntry, UnifiedCompositionEntity.SUB_INTERFACE, unifiedCompositionData
+ .getComputeTemplateConsolidationData(), portTemplateConsolidationData,
+ unifiedCompositionTo.getUnifiedCompositionDataList(), context);
+ parameterId.ifPresent(
+ parameterIdValue -> addPropertyInputParameter(propertyType,
+ unifiedCompositionTo.getSubstitutionServiceTemplate(),
+ propertyDefinition.getEntry_schema(), parameterIdValue));
+ }
+ }
+ }
+ }
+
private NodeTemplate getNodeTemplate(String nodeTemplateId, ServiceTemplate serviceTemplate,
TranslationContext context) {
if (Objects.isNull(nodeTemplate)) {
nodeTemplate = context
- .getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
- nodeTemplateId);
+ .getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
+ nodeTemplateId);
}
return nodeTemplate;
List<UnifiedCompositionData> unifiedCompositionDataList,
TranslationContext context) {
ComputeTemplateConsolidationData computeTemplateConsolidationData =
- unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData();
+ unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData();
handleComputeNodeTemplate(serviceTemplate, substitutionServiceTemplate,
- unifiedCompositionDataList, context);
- ServiceTemplate globalSubstitutionServiceTemplate =
- HeatToToscaUtil.fetchGlobalSubstitutionServiceTemplate(serviceTemplate, context);
+ unifiedCompositionDataList, context);
return handleComputeNodeType(serviceTemplate, substitutionServiceTemplate,
- computeTemplateConsolidationData);
+ computeTemplateConsolidationData);
}
private String handleComputeNodeType(
- ServiceTemplate serviceTemplate,
- ServiceTemplate substitutionServiceTemplate,
- ComputeTemplateConsolidationData computeTemplateConsolidationData) {
+ ServiceTemplate serviceTemplate,
+ ServiceTemplate substitutionServiceTemplate,
+ ComputeTemplateConsolidationData computeTemplateConsolidationData) {
NodeTemplate computeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
- computeTemplateConsolidationData.getNodeTemplateId());
+ computeTemplateConsolidationData.getNodeTemplateId());
String computeNodeTypeId = computeNodeTemplate.getType();
NodeType computeNodeType =
- DataModelUtil.getNodeType(serviceTemplate, computeNodeTypeId);
+ DataModelUtil.getNodeType(serviceTemplate, computeNodeTypeId);
DataModelUtil
- .addNodeType(substitutionServiceTemplate, computeNodeTypeId, computeNodeType);
+ .addNodeType(substitutionServiceTemplate, computeNodeTypeId, computeNodeType);
return computeNodeTypeId;
}
- private String getComputeNodeType(String nodeType){
- String computeTypeSuffix = getComputeTypeSuffix(nodeType);
- return ToscaNodeType.COMPUTE_TYPE_PREFIX + "." + computeTypeSuffix;
- }
-
private void handleComputeNodeTemplate(ServiceTemplate serviceTemplate,
ServiceTemplate substitutionServiceTemplate,
List<UnifiedCompositionData> unifiedCompositionDataList,
TranslationContext context) {
ComputeTemplateConsolidationData computeTemplateConsolidationData =
- unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData();
+ unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData();
NodeTemplate newComputeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
- computeTemplateConsolidationData.getNodeTemplateId()).clone();
+ computeTemplateConsolidationData.getNodeTemplateId()).clone();
removeConnectivityOut(computeTemplateConsolidationData, newComputeNodeTemplate);
removeVolumeConnectivity(computeTemplateConsolidationData, newComputeNodeTemplate);
- List<EntityConsolidationData> computeConsoliadtionDataList =
- getComputeConsolidationDataList(unifiedCompositionDataList);
+ List<EntityConsolidationData> computeConsolidationDataList =
+ getComputeConsolidationDataList(unifiedCompositionDataList);
handleProperties(serviceTemplate, newComputeNodeTemplate,
- substitutionServiceTemplate, UnifiedCompositionEntity.Compute,
- computeConsoliadtionDataList, computeTemplateConsolidationData, unifiedCompositionDataList,
- context);
+ substitutionServiceTemplate, COMPUTE,
+ computeConsolidationDataList, computeTemplateConsolidationData, unifiedCompositionDataList,
+ context);
String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
- computeTemplateConsolidationData.getNodeTemplateId());
+ computeTemplateConsolidationData.getNodeTemplateId());
//Update requirements for relationships between the consolidation entities
- handleConsolidationEntitiesRequirementConnectivity(newComputeNodeTemplateId,
- newComputeNodeTemplate,
- serviceTemplate, context);
+ handleConsolidationEntitiesRequirementConnectivity(
+ newComputeNodeTemplate,
+ serviceTemplate, context);
DataModelUtil
- .addNodeTemplate(substitutionServiceTemplate,
- newComputeNodeTemplateId, newComputeNodeTemplate);
+ .addNodeTemplate(substitutionServiceTemplate,
+ newComputeNodeTemplateId, newComputeNodeTemplate);
//Add the node template mapping in the context for handling requirement updation
- for (EntityConsolidationData data : computeConsoliadtionDataList) {
+ for (EntityConsolidationData data : computeConsolidationDataList) {
String newComputeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
- computeTemplateConsolidationData.getNodeTemplateId());
+ computeTemplateConsolidationData.getNodeTemplateId());
context.addSubstitutionServiceTemplateUnifiedSubstitutionData(ToscaUtil
- .getServiceTemplateFileName(serviceTemplate), data.getNodeTemplateId(),
- newComputeTemplateId);
+ .getServiceTemplateFileName(serviceTemplate), data.getNodeTemplateId(),
+ newComputeTemplateId);
}
}
- private void updateComputeNodeType(ServiceTemplate serviceTemplate,
- String nodeTemplateId,
- NodeTemplate newComputeNodeTemplate) {
- String computeNodeType = getComputeNodeType(newComputeNodeTemplate.getType());
- NodeType origNodeType = serviceTemplate.getNode_types().get(newComputeNodeTemplate.getType());
- DataModelUtil.removeNodeType(serviceTemplate, newComputeNodeTemplate.getType());
- DataModelUtil.addNodeType(serviceTemplate, computeNodeType, origNodeType);
- newComputeNodeTemplate.setType(computeNodeType);
- DataModelUtil.addNodeTemplate(serviceTemplate, nodeTemplateId, newComputeNodeTemplate);
- }
-
private List<EntityConsolidationData> getComputeConsolidationDataList(
- List<UnifiedCompositionData> unifiedCompositionDataList) {
- List<EntityConsolidationData> computeConsolidationDataList = new ArrayList<>();
- for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
- computeConsolidationDataList
- .add(unifiedCompositionData.getComputeTemplateConsolidationData());
- }
- return computeConsolidationDataList;
+ List<UnifiedCompositionData> unifiedCompositionDataList) {
+ return unifiedCompositionDataList.stream()
+ .map(UnifiedCompositionData::getComputeTemplateConsolidationData)
+ .collect(Collectors.toList());
}
ComputeTemplateConsolidationData computeTemplateConsolidationData,
List<UnifiedCompositionData> unifiedCompositionDataList,
TranslationContext context) {
- List<String> propertiesWithIdenticalVal =
- consolidationService.getPropertiesWithIdenticalVal(unifiedCompositionEntity, context);
nodeTemplate.setProperties(new HashedMap());
handleNodeTemplateProperties(serviceTemplate, nodeTemplate, substitutionServiceTemplate,
- unifiedCompositionEntity, entityConsolidationDataList, computeTemplateConsolidationData,
- unifiedCompositionDataList, context);
+ unifiedCompositionEntity, entityConsolidationDataList, computeTemplateConsolidationData,
+ unifiedCompositionDataList, context);
//Add enrich properties from openecomp node type as input to global and substitution ST
handleNodeTypeProperties(substitutionServiceTemplate,
- entityConsolidationDataList, nodeTemplate, unifiedCompositionEntity,
- computeTemplateConsolidationData, context);
+ entityConsolidationDataList, nodeTemplate, unifiedCompositionEntity,
+ computeTemplateConsolidationData, context);
}
ServiceTemplate substitutionServiceTemplate,
UnifiedCompositionEntity unifiedCompositionEntity,
List<EntityConsolidationData>
- entityConsolidationDataList,
+ entityConsolidationDataList,
ComputeTemplateConsolidationData
- computeTemplateConsolidationData,
+ computeTemplateConsolidationData,
List<UnifiedCompositionData> unifiedCompositionDataList,
TranslationContext context) {
List<String> propertiesWithIdenticalVal =
- consolidationService.getPropertiesWithIdenticalVal(unifiedCompositionEntity, context);
+ consolidationService.getPropertiesWithIdenticalVal(unifiedCompositionEntity);
for (EntityConsolidationData entityConsolidationData : entityConsolidationDataList) {
String nodeTemplateId = entityConsolidationData.getNodeTemplateId();
+ Optional<List<String>> indexVarProperties =
+ context.getIndexVarProperties(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
+ nodeTemplateId);
Map<String, Object> properties =
- DataModelUtil.getNodeTemplateProperties(serviceTemplate, nodeTemplateId);
+ DataModelUtil.getNodeTemplateProperties(serviceTemplate, nodeTemplateId);
if (MapUtils.isEmpty(properties)) {
continue;
}
for (Map.Entry<String, Object> propertyEntry : properties.entrySet()) {
NodeType nodeTypeWithFlatHierarchy =
- HeatToToscaUtil.getNodeTypeWithFlatHierarchy(nodeTemplate.getType(), serviceTemplate,
- context);
+ HeatToToscaUtil.getNodeTypeWithFlatHierarchy(nodeTemplate.getType(), serviceTemplate,
+ context);
PropertyDefinition propertyDefinition =
- nodeTypeWithFlatHierarchy.getProperties().get(propertyEntry.getKey());
+ nodeTypeWithFlatHierarchy.getProperties().get(propertyEntry.getKey());
String propertyType = propertyDefinition.getType();
if (propertiesWithIdenticalVal.contains(propertyEntry.getKey())) {
String parameterId =
- updateIdenticalProperty(nodeTemplateId, propertyEntry.getKey(), nodeTemplate,
- unifiedCompositionEntity, unifiedCompositionDataList);
+ updateIdenticalProperty(nodeTemplateId, propertyEntry.getKey(), nodeTemplate,
+ unifiedCompositionEntity, unifiedCompositionDataList);
addInputParameter(
- parameterId, propertyType,
- propertyType.equals(PropertyType.LIST.getDisplayName()) ? propertyDefinition
- .getEntry_schema() : null,
- substitutionServiceTemplate);
+ parameterId, propertyType,
+ propertyType.equals(PropertyType.LIST.getDisplayName()) ? propertyDefinition
+ .getEntry_schema() : null,
+ substitutionServiceTemplate);
+ } else if (indexVarProperties.isPresent()
+ && indexVarProperties.get().contains(propertyEntry.getKey())) {
+ //Handle index property
+ handleIndexVarProperty(propertyEntry.getKey(), propertyEntry.getValue(), nodeTemplate);
} else {
Optional<String> parameterId =
- updateProperty(serviceTemplate, nodeTemplateId, nodeTemplate, propertyEntry,
- unifiedCompositionEntity, computeTemplateConsolidationData,
- unifiedCompositionDataList,
- context);
- //todo - define list of type which will match the node property type (instead of string)
- addPropertyInputParameter(propertyType, substitutionServiceTemplate, propertyDefinition
- .getEntry_schema(),
- parameterId, unifiedCompositionEntity, context);
+ updateProperty(serviceTemplate, nodeTemplateId, nodeTemplate, propertyEntry,
+ unifiedCompositionEntity, computeTemplateConsolidationData, null,
+ unifiedCompositionDataList,
+ context);
+ parameterId.ifPresent(
+ parameterIdValue -> addPropertyInputParameter(propertyType,
+ substitutionServiceTemplate,
+ propertyDefinition.getEntry_schema(), parameterIdValue));
+ }
+ }
+ }
+ }
+
+ private void handleIndexVarProperty(String propertyKey, Object propertyValue,
+ NodeTemplate nodeTemplate) {
+ //Retain properties translated from %index% value in heat
+ nodeTemplate.getProperties().put(propertyKey, propertyValue);
+ }
+
+ private void handleSubInterfaceServiceTemplateFilterProperty(NodeTemplate nodeTemplate,
+ String propertyKey,
+ Object propertyValue,
+ ServiceTemplate serviceTemplate,
+ ServiceTemplate substitutionServiceTemplate) {
+ //Retain service_template_filter (Can be present in a sub-interface resource-def)
+ nodeTemplate.getProperties().put(propertyKey, propertyValue);
+ Object serviceTemplateFilterProperty =
+ nodeTemplate.getProperties().get(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME);
+ if (!(serviceTemplateFilterProperty instanceof Map)) {
+ return;
+ }
+ Map<String, Object> serviceTemplatePropertyMap = (Map<String, Object>)
+ serviceTemplateFilterProperty;
+ Object countPropertyVal = serviceTemplatePropertyMap.get(ToscaConstants.COUNT_PROPERTY_NAME);
+ //Check if the value of the count property is a tosca function
+ if (!isPropertyContainsToscaFunction(countPropertyVal)) {
+ return;
+ }
+ Map<String, Object> countPropertyValMap = (Map<String, Object>) countPropertyVal;
+ //If the value is in the form of get_input add an input parameter in current service
+ // template
+ if (countPropertyValMap.keySet().contains(ToscaFunctions.GET_INPUT.getDisplayName())) {
+ String countPropertyInputName = countPropertyValMap.get(ToscaFunctions.GET_INPUT
+ .getDisplayName()).toString();
+ //Get the input parameter definition from top level where the resource group was present
+ ParameterDefinitionExt parameterDefinition = (ParameterDefinitionExt)
+ DataModelUtil.getInputParameters(serviceTemplate).get(countPropertyInputName);
+ if (Objects.nonNull(parameterDefinition)) {
+ //Remove annotations if any for the nested service template
+ parameterDefinition.setAnnotations(null);
+ DataModelUtil.getInputParameters(substitutionServiceTemplate)
+ .put(countPropertyInputName, parameterDefinition);
+ if (Objects.nonNull(countPropertyInputName)) {
+ //Remove the input from top level
+ DataModelUtil.getInputParameters(serviceTemplate).remove(countPropertyInputName);
}
}
}
NodeTemplate nodeTemplate,
UnifiedCompositionEntity compositionEntity,
ComputeTemplateConsolidationData
- computeTemplateConsolidationData,
+ computeTemplateConsolidationData,
TranslationContext context) {
ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
Optional<NodeType> enrichNodeType;
List<String> enrichProperties;
- if (compositionEntity.equals(UnifiedCompositionEntity.Port)) {
+ if (compositionEntity.equals(UnifiedCompositionEntity.PORT)) {
enrichNodeType =
- toscaAnalyzerService.fetchNodeType(ToscaNodeType.NETWORK_PORT,
- context.getGlobalServiceTemplates().values());
- enrichProperties = context.getEnrichPortResourceProperties();
+ toscaAnalyzerService.fetchNodeType(ToscaNodeType.NETWORK_PORT,
+ context.getGlobalServiceTemplates().values());
+ enrichProperties = TranslationContext.getEnrichPortResourceProperties();
if (!enrichNodeType.isPresent() || Objects.isNull(enrichProperties)) {
return;
}
if (Objects.nonNull(enrichNodeTypeProperties)) {
for (String enrichPropertyName : enrichProperties) {
handleEntityConsolidationDataNodeTypeProperties(
- enrichPropertyName, substitutionServiceTemplate,
- enrichNodeType.get(), nodeTemplate, compositionEntity, computeTemplateConsolidationData,
- entityConsolidationDataList, nodeTemplateProperties, context);
+ enrichPropertyName, substitutionServiceTemplate,
+ enrichNodeType.get(), nodeTemplate, compositionEntity, computeTemplateConsolidationData,
+ entityConsolidationDataList, nodeTemplateProperties, context);
}
}
}
String nodeTemplateId = entityConsolidationData.getNodeTemplateId();
String inputParamId =
- getParameterId(nodeTemplateId, nodeTemplate, enrichPropertyName,
- compositionEntity, computeTemplateConsolidationData);
+ getParameterId(nodeTemplateId, nodeTemplate, enrichPropertyName,
+ compositionEntity, computeTemplateConsolidationData, null);
Map<String, String> propertyValMap = new HashMap<>();
context
- .addNewPropertyIdToNodeTemplate(
- ToscaUtil.getServiceTemplateFileName(substitutionServiceTemplate),
- inputParamId, nodeTemplateProperties.get(enrichPropertyName));
+ .addNewPropertyIdToNodeTemplate(
+ ToscaUtil.getServiceTemplateFileName(substitutionServiceTemplate),
+ inputParamId, nodeTemplateProperties.get(enrichPropertyName));
if (nodeTemplateProperties.containsKey(enrichPropertyName)) {
handleExistingEnrichedProperty(enrichPropertyName, nodeTemplateProperties, inputParamId);
nodeTemplate.getProperties().put(enrichPropertyName, propertyValMap);
}
propertyType =
- enrichNodeType.getProperties().get(enrichPropertyName).getType();
+ enrichNodeType.getProperties().get(enrichPropertyName).getType();
addPropertyInputParameter(propertyType, substitutionServiceTemplate, enrichNodeType
- .getProperties().get(enrichPropertyName).getEntry_schema(),
- Optional.of(inputParamId), compositionEntity, context);
+ .getProperties().get(enrichPropertyName).getEntry_schema(),
+ inputParamId);
}
}
private void addPropertyInputParameter(String propertyType,
ServiceTemplate substitutionServiceTemplate,
- EntrySchema entrySchema, Optional<String> parameterId,
- UnifiedCompositionEntity unifiedCompositionEntity,
- TranslationContext context) {
- if (parameterId.isPresent() &&
- isParameterBelongsToEnrichedPortProperties(parameterId.get(), context)) {
- addInputParameter(parameterId.get(),
- propertyType,
- propertyType.equals(PropertyType.LIST.getDisplayName()) ? entrySchema : null,
- substitutionServiceTemplate);
+ EntrySchema entrySchema, String parameterId) {
+ if (Objects.isNull(propertyType)) {
+ return;
+ }
+ if (isParameterBelongsToEnrichedPortProperties(parameterId)) {
+ addInputParameter(parameterId,
+ propertyType,
+ propertyType.equals(PropertyType.LIST.getDisplayName()) ? entrySchema : null,
+ substitutionServiceTemplate);
} else if (isPropertySimpleType(propertyType)) {
- parameterId
- .ifPresent(parameterIdValue -> addInputParameter(parameterIdValue,
- PropertyType.LIST.getDisplayName(),
- DataModelUtil
- .createEntrySchema(propertyType.toLowerCase(), null, null),
- substitutionServiceTemplate));
+ addInputParameter(parameterId, PropertyType.LIST.getDisplayName(),
+ DataModelUtil.createEntrySchema(propertyType.toLowerCase(), null, null),
+ substitutionServiceTemplate);
} else if (propertyType.equals(PropertyTypeExt.JSON.getDisplayName()) ||
- (Objects.nonNull(entrySchema) && isPropertySimpleType(entrySchema.getType()))) {
- parameterId
- .ifPresent(parameterIdValue -> addInputParameter(parameterIdValue,
- PropertyType.LIST.getDisplayName(),
- DataModelUtil
- .createEntrySchema(PropertyTypeExt.JSON.getDisplayName(), null, null),
- substitutionServiceTemplate));
+ (Objects.nonNull(entrySchema) && isPropertySimpleType(entrySchema.getType()))) {
+ addInputParameter(parameterId, PropertyType.LIST.getDisplayName(),
+ DataModelUtil.createEntrySchema(PropertyTypeExt.JSON.getDisplayName(), null, null),
+ substitutionServiceTemplate);
} else {
- parameterId
- .ifPresent(parameterIdValue -> addInputParameter(parameterIdValue,
- analyzeParameterType(propertyType),
- DataModelUtil
- .createEntrySchema(analyzeEntrySchemaType(propertyType, entrySchema),
- null, null),
- substitutionServiceTemplate));
+ addInputParameter(parameterId, analyzeParameterType(propertyType), DataModelUtil
+ .createEntrySchema(analyzeEntrySchemaType(propertyType, entrySchema), null, null),
+ substitutionServiceTemplate);
}
}
- private boolean isParameterBelongsToEnrichedPortProperties(String parameterId,
- TranslationContext context) {
- List enrichPortResourceProperties = context.getEnrichPortResourceProperties();
+ private boolean isParameterBelongsToEnrichedPortProperties(String parameterId) {
+ List enrichPortResourceProperties = TranslationContext.getEnrichPortResourceProperties();
for (int i = 0; i < enrichPortResourceProperties.size(); i++) {
if (parameterId.contains((CharSequence) enrichPortResourceProperties.get(i))) {
}
private boolean isPropertySimpleType(String propertyType) {
- return !Objects.isNull(propertyType) &&
- (propertyType.equalsIgnoreCase(PropertyType.STRING.getDisplayName())
- || propertyType.equalsIgnoreCase(PropertyType.INTEGER.getDisplayName())
- || propertyType.equalsIgnoreCase(PropertyType.FLOAT.getDisplayName())
- || propertyType.equalsIgnoreCase(PropertyType.BOOLEAN.getDisplayName()));
+ return !Objects.isNull(propertyType)
+ && (PropertyType.getSimplePropertyTypes().contains(propertyType.toLowerCase()));
}
private String analyzeParameterType(String propertyType) {
return propertyType.equalsIgnoreCase(PropertyType.LIST.getDisplayName()) ? PropertyType.LIST
- .getDisplayName() : propertyType;
+ .getDisplayName() : propertyType;
}
private String analyzeEntrySchemaType(String propertyType, EntrySchema entrySchema) {
- return propertyType.equalsIgnoreCase(PropertyType.LIST.getDisplayName()) ?
- entrySchema.getType() : null;
+ return propertyType.equalsIgnoreCase(PropertyType.LIST.getDisplayName()) && entrySchema != null ?
+ entrySchema.getType() : null;
}
- private void handleConsolidationEntitiesRequirementConnectivity(String nodeTemplateId,
- NodeTemplate nodeTemplate,
+ private void handleConsolidationEntitiesRequirementConnectivity(NodeTemplate nodeTemplate,
ServiceTemplate serviceTemplate,
TranslationContext context) {
- Map<String, RequirementAssignment> updatedNodeTemplateRequirements = new HashMap<>();
List<Map<String, RequirementAssignment>> nodeTemplateRequirements = DataModelUtil
- .getNodeTemplateRequirementList(nodeTemplate);
+ .getNodeTemplateRequirementList(nodeTemplate);
if (CollectionUtils.isEmpty(nodeTemplateRequirements)) {
return;
}
RequirementAssignment requirementAssignment = entry.getValue();
String requirementNode = requirementAssignment.getNode();
String unifiedNodeTemplateId =
- context.getUnifiedSubstitutionNodeTemplateId(serviceTemplate,
- requirementNode);
+ context.getUnifiedSubstitutionNodeTemplateId(serviceTemplate,
+ requirementNode);
if (unifiedNodeTemplateId != null) {
//Update the node id in the requirement
requirementAssignment.setNode(unifiedNodeTemplateId);
String relationshipId,
TranslationContext context) {
Map<String, RelationshipTemplate> relationshipTemplates = DataModelUtil
- .getRelationshipTemplates(serviceTemplate);
+ .getRelationshipTemplates(serviceTemplate);
if (relationshipTemplates != null) {
RelationshipTemplate relationshipTemplate = relationshipTemplates.get(relationshipId);
if (relationshipTemplate != null) {
String relationshipTemplateType = relationshipTemplate.getType();
if (relationshipTemplateType.equals(ToscaRelationshipType.CINDER_VOLUME_ATTACHES_TO)) {
handleCinderVolumeAttachmentRelationshipTemplate(serviceTemplate,
- relationshipTemplate, context);
+ relationshipTemplate, context);
}
}
}
private void handleCinderVolumeAttachmentRelationshipTemplate(ServiceTemplate
- substitutionServiceTemplate,
+ substitutionServiceTemplate,
RelationshipTemplate
- relationshipTemplate,
+ relationshipTemplate,
TranslationContext context) {
Map<String, Object> properties = relationshipTemplate.getProperties();
properties.computeIfPresent(HeatConstants.INSTANCE_UUID_PROPERTY_NAME, (key, value) ->
- context.getUnifiedAbstractNodeTemplateId(substitutionServiceTemplate,
- (String) value));
+ context.getUnifiedAbstractNodeTemplateId(substitutionServiceTemplate,
+ (String) value));
}
private String updateIdenticalProperty(String nodeTemplateId, String propertyId,
UnifiedCompositionEntity unifiedCompositionEntity,
List<UnifiedCompositionData> unifiedCompositionDataList) {
- String inputParamId;
+ String inputParamId = null;
Map<String, Object> propertyVal = new HashMap<>();
switch (unifiedCompositionEntity) {
- case Compute:
+ case COMPUTE:
inputParamId = COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX + propertyId
- + COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX;
-
+ + COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX;
propertyVal.put(ToscaFunctions.GET_INPUT.getDisplayName(), inputParamId);
nodeTemplate.getProperties().put(propertyId, propertyVal);
-
- return inputParamId;
-
- case Port:
+ break;
+ case PORT:
String portType = ConsolidationDataUtil.getPortType(nodeTemplateId);
ComputeTemplateConsolidationData computeTemplateConsolidationData =
- getConnectedComputeConsolidationData(unifiedCompositionDataList, nodeTemplateId);
- inputParamId = getInputParamIdForPort(nodeTemplateId, propertyId, portType,
- computeTemplateConsolidationData);
-
+ getConnectedComputeConsolidationData(unifiedCompositionDataList, nodeTemplateId);
+ inputParamId = getInputParamIdForPort(nodeTemplateId, propertyId, portType, computeTemplateConsolidationData);
propertyVal.put(ToscaFunctions.GET_INPUT.getDisplayName(), inputParamId);
nodeTemplate.getProperties().put(propertyId, propertyVal);
-
- return inputParamId;
-
+ break;
default:
- return null;
+ break;
}
+ return inputParamId;
}
private String getInputParamIdForPort(String nodeTemplateId, String propertyId, String portType,
ComputeTemplateConsolidationData computeTemplateConsolidationData) {
String inputParamId;
if (Objects.isNull(computeTemplateConsolidationData)
- || computeTemplateConsolidationData.getPorts().get(portType).size() > 1) {
+ || computeTemplateConsolidationData.getPorts().get(portType).size() > 1) {
inputParamId =
- UnifiedCompositionEntity.Port.name().toLowerCase() + "_" + nodeTemplateId + "_" +
- propertyId;
+ UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_" + nodeTemplateId + "_" +
+ propertyId;
} else {
inputParamId =
- UnifiedCompositionEntity.Port.name().toLowerCase() + "_" + portType + "_"
- + propertyId;
+ UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_" + portType + "_"
+ + propertyId;
}
return inputParamId;
}
ServiceTemplate serviceTemplate) {
ParameterDefinition parameterDefinition = DataModelUtil.createParameterDefinition
- (parameterType, null, null,
- true, null, null,
- entrySchema, null);
+ (parameterType, null, null,
+ true, null, null,
+ entrySchema, null);
DataModelUtil
- .addInputParameterToTopologyTemplate(serviceTemplate, parameterId, parameterDefinition);
+ .addInputParameterToTopologyTemplate(serviceTemplate, parameterId, parameterDefinition);
}
// Return the input parameter Id which is used in the new property value if there is one
private Optional<String> updateProperty(
- ServiceTemplate serviceTemplate,
- String nodeTemplateId, NodeTemplate nodeTemplate,
- Map.Entry<String, Object> propertyEntry,
- UnifiedCompositionEntity compositionEntity,
- ComputeTemplateConsolidationData computeTemplateConsolidationData,
- List<UnifiedCompositionData> unifiedCompositionDataList,
- TranslationContext context) {
+ ServiceTemplate serviceTemplate,
+ String nodeTemplateId, NodeTemplate nodeTemplate,
+ Map.Entry<String, Object> propertyEntry,
+ UnifiedCompositionEntity compositionEntity,
+ ComputeTemplateConsolidationData computeTemplateConsolidationData,
+ PortTemplateConsolidationData portTemplateConsolidationData,
+ List<UnifiedCompositionData> unifiedCompositionDataList,
+ TranslationContext context) {
if (handleGetAttrFromConsolidationNodes(serviceTemplate, nodeTemplateId, nodeTemplate,
- propertyEntry, unifiedCompositionDataList, context)) {
+ propertyEntry, unifiedCompositionDataList, context)) {
return Optional.empty();
}
String inputParamId =
- getParameterId(nodeTemplateId, nodeTemplate, propertyEntry.getKey(), compositionEntity,
- computeTemplateConsolidationData);
- Map<String, List<String>> propertyVal = getPropertyValueInputParam(nodeTemplateId,
- nodeTemplate, inputParamId);
+ getParameterId(nodeTemplateId, nodeTemplate, propertyEntry.getKey(), compositionEntity,
+ computeTemplateConsolidationData, portTemplateConsolidationData);
+ Map<String, List<String>> propertyVal = getPropertyValueInputParam(inputParamId);
nodeTemplate.getProperties().put(propertyEntry.getKey(), propertyVal);
return Optional.of(inputParamId);
}
- private Map<String, List<String>> getPropertyValueInputParam(String nodeTemplateId,
- NodeTemplate nodeTemplate,
- String inputParamId) {
+ private Map<String, List<String>> getPropertyValueInputParam(String inputParamId) {
Map<String, List<String>> propertyVal = new HashMap<>();
List<String> getInputFuncParams = new ArrayList<>();
getInputFuncParams.add(inputParamId);
}
private boolean handleGetAttrFromConsolidationNodes(
- ServiceTemplate serviceTemplate,
- String nodeTemplateId, NodeTemplate nodeTemplate,
- Map.Entry<String, Object> propertyEntry,
- List<UnifiedCompositionData> unifiedCompositionDataList,
- TranslationContext context) {
+ ServiceTemplate serviceTemplate,
+ String nodeTemplateId, NodeTemplate nodeTemplate,
+ Map.Entry<String, Object> propertyEntry,
+ List<UnifiedCompositionData> unifiedCompositionDataList,
+ TranslationContext context) {
Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType =
- getAllConsolidationNodeTemplateIdAndType(unifiedCompositionDataList);
+ getAllConsolidationNodeTemplateIdAndType(unifiedCompositionDataList);
Set<String> consolidationNodeTemplateIds = consolidationNodeTemplateIdAndType.keySet();
Map<String, String> entityIdToType = ConsolidationService.getConsolidationEntityIdToType(
- serviceTemplate, context.getConsolidationData());
+ serviceTemplate, context.getConsolidationData());
boolean includeGetAttrFromConsolidationNodes = false;
boolean includeGetAttrFromOutsideNodes = false;
boolean isGetAttrFromConsolidationIsFromSameType = false;
}
}
if ((includeGetAttrFromConsolidationNodes && includeGetAttrFromOutsideNodes)
- ||
- (includeGetAttrFromConsolidationNodes && isIncludeToscaFunc(propertyEntry.getValue(),
- ToscaFunctions.GET_INPUT))) {
+ ||
+ (includeGetAttrFromConsolidationNodes && isIncludeToscaFunc(propertyEntry.getValue(),
+ ToscaFunctions.GET_INPUT))) {
//This case is currently not supported - this property will be ignored
return true;
} else if (includeGetAttrFromConsolidationNodes && !isGetAttrFromConsolidationIsFromSameType) {
for (List<Object> getAttrFunc : clonedGetAttrFuncList) {
String targetNodeTemplateId = (String) getAttrFunc.get(0);
if (consolidationNodeTemplateIds.contains(targetNodeTemplateId)) {
- updatePropertyGetAttrFunc(serviceTemplate, unifiedCompositionDataList, context,
- consolidationNodeTemplateIdAndType, targetNodeTemplateId, getAttrFunc);
+ updatePropertyGetAttrFunc(serviceTemplate, unifiedCompositionDataList,
+ consolidationNodeTemplateIdAndType, targetNodeTemplateId, getAttrFunc, context);
}
}
nodeTemplate.getProperties().put(propertyEntry.getKey(), clonedPropertyValue);
return false;
}
- private boolean isGetAttrFromConsolidationNodesIsFromSameType(String sourceNodeTemplateId,
- Set<String> nodeTemplateIdsFromConsolidation,
- Map<String, String>
- nodeTemplateIdToType) {
- for (String idFromConsolidation : nodeTemplateIdsFromConsolidation) {
- if (isGetAttrNodeTemplateFromSameType(sourceNodeTemplateId, idFromConsolidation,
- nodeTemplateIdToType)) {
- return true;
- }
- }
- return false;
- }
-
private boolean isGetAttrNodeTemplateFromSameType(String sourceNodeTemplateId,
String targetNodeTemplateId,
Map<String, String> nodeTemplateIdToType) {
if (Objects.isNull(nodeTemplateIdToType.get(sourceNodeTemplateId))
- || Objects.isNull(nodeTemplateIdToType.get(targetNodeTemplateId))) {
+ || Objects.isNull(nodeTemplateIdToType.get(targetNodeTemplateId))) {
return false;
}
return nodeTemplateIdToType.get(sourceNodeTemplateId).equals(nodeTemplateIdToType
- .get(targetNodeTemplateId));
+ .get(targetNodeTemplateId));
}
private void updatePropertyGetAttrFunc(
- ServiceTemplate serviceTemplate,
- List<UnifiedCompositionData> unifiedCompositionDataList,
- TranslationContext context,
- Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType,
- String targetNodeTemplateId,
- List<Object> getAttrFunc) {
+ ServiceTemplate serviceTemplate,
+ List<UnifiedCompositionData> unifiedCompositionDataList,
+ Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType,
+ String targetNodeTemplateId,
+ List<Object> getAttrFunc, TranslationContext context) {
UnifiedCompositionEntity targetCompositionEntity =
- consolidationNodeTemplateIdAndType.get(targetNodeTemplateId);
+ consolidationNodeTemplateIdAndType.get(targetNodeTemplateId);
String targetNewNodeTemplateId =
- getNewNodeTemplateId(serviceTemplate, unifiedCompositionDataList, targetNodeTemplateId,
- targetCompositionEntity);
+ getNewNodeTemplateId(serviceTemplate, unifiedCompositionDataList, targetNodeTemplateId,
+ targetCompositionEntity, context);
getAttrFunc.set(0, targetNewNodeTemplateId);
}
private String getNewNodeTemplateId(ServiceTemplate serviceTemplate,
List<UnifiedCompositionData> unifiedCompositionDataList,
String nodeTemplateId,
- UnifiedCompositionEntity compositionEntity) {
- switch (compositionEntity) {
- case Compute:
- return getNewComputeNodeTemplateId(serviceTemplate, nodeTemplateId);
- case Port:
- ComputeTemplateConsolidationData connectedComputeConsolidationData =
- getConnectedComputeConsolidationData(
- unifiedCompositionDataList, nodeTemplateId);
- NodeTemplate connectedComputeNodeTemplate =
- DataModelUtil.getNodeTemplate(serviceTemplate,
- connectedComputeConsolidationData.getNodeTemplateId());
- return getNewPortNodeTemplateId(nodeTemplateId, connectedComputeNodeTemplate.getType(),
- connectedComputeConsolidationData);
- default:
- return null;
+ UnifiedCompositionEntity compositionEntity,
+ TranslationContext context) {
+ String newNodeTemplateId = nodeTemplateId;
+ String nodeTemplateIdGeneratorImpl = unifiedSubstitutionNodeTemplateIdGeneratorImplMap.get(compositionEntity);
+ UnifiedSubstitutionNodeTemplateIdGenerator nodeTemplateIdGenerator =
+ CommonMethods.newInstance(nodeTemplateIdGeneratorImpl, UnifiedSubstitutionNodeTemplateIdGenerator.class);
+ UnifiedCompositionTo unifiedCompositionTo = new UnifiedCompositionTo(serviceTemplate, null,
+ unifiedCompositionDataList, context);
+ Optional<String> generatedNodeTemplateId = nodeTemplateIdGenerator.generate(unifiedCompositionTo, nodeTemplateId);
+ if (generatedNodeTemplateId.isPresent()) {
+ newNodeTemplateId = generatedNodeTemplateId.get();
}
+ return newNodeTemplateId;
}
private String getNewNodeTemplateId(String origNodeTemplateId,
TranslationContext context) {
ConsolidationData consolidationData = context.getConsolidationData();
- if (isIdIsOfExpectedType(origNodeTemplateId, UnifiedCompositionEntity.Port,
- serviceTemplateFileName,
- context)) {
+ if (isIdIsOfExpectedType(origNodeTemplateId, UnifiedCompositionEntity.PORT,
+ serviceTemplateFileName,
+ context)) {
return handleIdOfPort(origNodeTemplateId, serviceTemplateFileName, consolidationData);
- } else if (isIdIsOfExpectedType(origNodeTemplateId, UnifiedCompositionEntity.Compute,
- serviceTemplateFileName, context)) {
+ } else if (isIdIsOfExpectedType(origNodeTemplateId, COMPUTE,
+ serviceTemplateFileName, context)) {
NodeTemplate nodeTemplate =
- getComputeNodeTemplate(origNodeTemplateId, serviceTemplate, context);
+ getComputeNodeTemplate(origNodeTemplateId, serviceTemplate, context);
return getComputeTypeSuffix(nodeTemplate.getType());
}
return null;
}
- private ComputeTemplateConsolidationData getConnectedComputeConsolidationData(
- List<UnifiedCompositionData> unifiedCompositionDataList,
- String portNodeTemplateId) {
- for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
- Collection<List<String>> portsCollection =
- unifiedCompositionData.getComputeTemplateConsolidationData().getPorts().values();
- for (List<String> portIdList : portsCollection) {
- if (portIdList.contains(portNodeTemplateId)) {
- return unifiedCompositionData.getComputeTemplateConsolidationData();
- }
- }
- }
- return null;
- }
-
private Object getClonedPropertyValue(Map.Entry<String, Object> propertyEntry) {
if (propertyEntry.getValue() instanceof Map) {
return getClonedObject(propertyEntry.getValue(), Map.class);
private String getParameterId(String nodeTemplateId, NodeTemplate nodeTemplate, String propertyId,
UnifiedCompositionEntity unifiedCompositionEntity,
- ComputeTemplateConsolidationData computeTemplateConsolidationData) {
+ ComputeTemplateConsolidationData
+ computeTemplateConsolidationData,
+ PortTemplateConsolidationData portTemplateConsolidationData) {
+ String paramterId = propertyId;
switch (unifiedCompositionEntity) {
- case Compute:
- return UnifiedCompositionEntity.Compute.name().toLowerCase() + "_"
- + getComputeTypeSuffix(nodeTemplate.getType()) + "_" + propertyId;
- case Port:
+ case COMPUTE:
+ paramterId = COMPUTE.getDisplayName().toLowerCase() + "_"
+ + getComputeTypeSuffix(nodeTemplate.getType()) + "_" + propertyId;
+ break;
+ case PORT:
String portType = ConsolidationDataUtil.getPortType(nodeTemplateId);
if (Objects.isNull(computeTemplateConsolidationData)
- || computeTemplateConsolidationData.getPorts().get(portType).size() > 1) {
- return UnifiedCompositionEntity.Port.name().toLowerCase() + "_" + nodeTemplateId + "_"
- + propertyId;
+ || computeTemplateConsolidationData.getPorts().get(portType).size() > 1) {
+ paramterId = UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_"
+ + nodeTemplateId + "_" + propertyId;
+ } else {
+ paramterId = UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_" + portType + "_"
+ + propertyId;
+ }
+ break;
+ case SUB_INTERFACE:
+ String subInterfaceType = getSubInterfaceTypeSuffix(nodeTemplate.getType());
+ if (Objects.isNull(portTemplateConsolidationData)
+ || isSubInterfaceNodeTemplateIdParameter(portTemplateConsolidationData, nodeTemplate)) {
+ paramterId = UnifiedCompositionEntity.SUB_INTERFACE.getDisplayName().toLowerCase() + "_"
+ + nodeTemplateId + "_" + propertyId;
+ } else {
+ paramterId = UnifiedCompositionEntity.SUB_INTERFACE.getDisplayName().toLowerCase() + "_"
+ + subInterfaceType + "_" + propertyId;
}
- return UnifiedCompositionEntity.Port.name().toLowerCase() + "_" + portType + "_"
- + propertyId;
+ break;
default:
- return propertyId;
+ break;
}
+ return paramterId;
+ }
+
+ private boolean isSubInterfaceNodeTemplateIdParameter(PortTemplateConsolidationData portTemplateConsolidationData,
+ NodeTemplate nodeTemplate) {
+ List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
+ portTemplateConsolidationData.getSubInterfaceConsolidationData(nodeTemplate.getType());
+ return (Objects.nonNull(subInterfaceTemplateConsolidationDataList)
+ && subInterfaceTemplateConsolidationDataList.size() > 1) ;
}
private void removeConnectivityOut(EntityConsolidationData entityConsolidationData,
}
for (List<RequirementAssignmentData> requirementAssignmentDataList : entityConsolidationData
- .getNodesConnectedOut().values()) {
+ .getNodesConnectedOut().values()) {
for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
DataModelUtil.removeRequirementsAssignment(nodeTemplate.getRequirements(),
- requirementAssignmentData.getRequirementId());
+ requirementAssignmentData.getRequirementId());
}
if (nodeTemplate.getRequirements().isEmpty()) {
nodeTemplate.setRequirements(null);
}
private void removeVolumeConnectivity(
- ComputeTemplateConsolidationData computeTemplateConsolidationData,
- NodeTemplate computeNodeTemplate) {
+ ComputeTemplateConsolidationData computeTemplateConsolidationData,
+ NodeTemplate computeNodeTemplate) {
if (MapUtils.isEmpty(computeTemplateConsolidationData.getVolumes())) {
return;
}
Collection<List<RequirementAssignmentData>> volumeCollection =
- computeTemplateConsolidationData.getVolumes().values();
+ computeTemplateConsolidationData.getVolumes().values();
for (List<RequirementAssignmentData> requirementAssignmentDataList : volumeCollection) {
for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
DataModelUtil.removeRequirementsAssignment(computeNodeTemplate.getRequirements(),
- requirementAssignmentData.getRequirementId());
+ requirementAssignmentData.getRequirementId());
}
}
if (computeNodeTemplate.getRequirements().isEmpty()) {
private void createIndexInputParameter(ServiceTemplate substitutionServiceTemplate) {
ParameterDefinition indexParameterDefinition =
- DataModelUtil.createParameterDefinition(PropertyType.INTEGER.getDisplayName(),
- "Index value of this substitution service template runtime instance", null,
- false, createIndexValueConstraint(), null, null, 0);
+ DataModelUtil.createParameterDefinition(PropertyType.INTEGER.getDisplayName(),
+ "Index value of this substitution service template runtime instance", null,
+ false, createIndexValueConstraint(), null, null, 0);
DataModelUtil.addInputParameterToTopologyTemplate(substitutionServiceTemplate,
- ToscaConstants.INDEX_VALUE_PROPERTY_NAME, indexParameterDefinition);
+ ToscaConstants.INDEX_VALUE_PROPERTY_NAME, indexParameterDefinition);
}
private Optional<UnifiedComposition> getUnifiedCompositionInstance(UnifiedCompositionMode mode) {
String unifiedCompositionImplClassName =
- unifiedCompositionImplMap.get(mode.name()).getImplementationClass();
+ unifiedCompositionImplMap.get(mode.name()).getImplementationClass();
if (StringUtils.isEmpty(unifiedCompositionImplClassName)) {
return Optional.empty();
}
return Optional
- .of(CommonMethods.newInstance(unifiedCompositionImplClassName, UnifiedComposition.class));
+ .of(CommonMethods.newInstance(unifiedCompositionImplClassName, UnifiedComposition.class));
}
private Optional<Map<String, Object>> createAbstractSubstitutionProperties(
- ServiceTemplate serviceTemplate,
- ServiceTemplate substitutionServiceTemplate,
- List<UnifiedCompositionData> unifiedCompositionDataList,
- TranslationContext context) {
+ ServiceTemplate serviceTemplate,
+ Map<String, ParameterDefinition> substitutionTemplateInputs,
+ List<UnifiedCompositionData> unifiedCompositionDataList,
+ TranslationContext context) {
Map<String, Object> abstractSubstituteProperties = new LinkedHashMap<>();
- Map<String, ParameterDefinition> substitutionTemplateInputs = DataModelUtil
- .getInputParameters(substitutionServiceTemplate);
- if (substitutionTemplateInputs == null) {
- return Optional.empty();
- }
//Since all the computes have the same type fetching the type from the first entry
NodeTemplate firstComputeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
- unifiedCompositionDataList.get(0)
- .getComputeTemplateConsolidationData().getNodeTemplateId());
+ unifiedCompositionDataList.get(0)
+ .getComputeTemplateConsolidationData().getNodeTemplateId());
String computeType = getComputeTypeSuffix(firstComputeNodeTemplate.getType());
for (Map.Entry<String, ParameterDefinition> input : substitutionTemplateInputs.entrySet()) {
String substitutionTemplateInputName = input.getKey();
ParameterDefinition inputParameterDefinition = input.getValue();
String inputType = inputParameterDefinition.getType();
UnifiedCompositionEntity inputUnifiedCompositionEntity =
- getInputCompositionEntity(substitutionTemplateInputName);
+ getInputCompositionEntity(substitutionTemplateInputName);
if (!inputType.equalsIgnoreCase(PropertyType.LIST.getDisplayName())) {
if (isIdenticalValueProperty(
- substitutionTemplateInputName, inputUnifiedCompositionEntity, context)) {
+ substitutionTemplateInputName, inputUnifiedCompositionEntity)) {
//Handle identical value properties
Optional<String> identicalValuePropertyName =
- getIdenticalValuePropertyName(substitutionTemplateInputName,
- inputUnifiedCompositionEntity, context);
-
- if (identicalValuePropertyName.isPresent()) {
- updateIdenticalPropertyValue(identicalValuePropertyName.get(),
- substitutionTemplateInputName, computeType, inputUnifiedCompositionEntity,
- unifiedCompositionDataList.get(0), serviceTemplate, abstractSubstituteProperties,
- context);
- }
+ getIdenticalValuePropertyName(substitutionTemplateInputName,
+ inputUnifiedCompositionEntity);
+
+ identicalValuePropertyName.ifPresent(propertyName -> updateIdenticalPropertyValue(propertyName,
+ substitutionTemplateInputName, inputUnifiedCompositionEntity,
+ unifiedCompositionDataList.get(0), serviceTemplate, abstractSubstituteProperties,
+ context));
}
continue;
}
//Check if the input is of type compute or port
List<Object> abstractPropertyValue = new ArrayList<>();
- Object propertyValue = null;
switch (inputUnifiedCompositionEntity) {
- case Compute:
- for (UnifiedCompositionData compositionData : unifiedCompositionDataList) {
- ComputeTemplateConsolidationData computeTemplateConsolidationData =
- compositionData.getComputeTemplateConsolidationData();
- propertyValue = getComputePropertyValue(substitutionTemplateInputName,
- serviceTemplate, computeTemplateConsolidationData);
- if (!(propertyValue instanceof Optional)) {
- abstractPropertyValue.add(propertyValue);
- }
- }
+ case COMPUTE:
+ createAbstractComputeProperties(unifiedCompositionDataList,
+ substitutionTemplateInputName, serviceTemplate, abstractPropertyValue);
break;
- case Port:
- for (UnifiedCompositionData compositionData : unifiedCompositionDataList) {
- List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
- getPortTemplateConsolidationDataList(compositionData);
- //Get the input type for this input whether it is of type
- // port_<port_node_template_id>_<property_name> or port_<port_type>_<property_name>
- PortInputType portInputType = getPortInputType(substitutionTemplateInputName,
- compositionData);
- for (PortTemplateConsolidationData portTemplateConsolidationData :
- portTemplateConsolidationDataList) {
- //Get the port property value
- String portNodeTemplateId = portTemplateConsolidationData.getNodeTemplateId();
- propertyValue = getPortPropertyValue(substitutionTemplateInputName,
- computeType, portInputType, serviceTemplate,
- portNodeTemplateId);
- //If the value object is Optional.empty it implies that the property name was not
- // found in the input name
- if (!(propertyValue instanceof Optional)) {
- if (!abstractPropertyValue.contains(propertyValue)) {
- abstractPropertyValue.add(propertyValue);
- }
- }
- }
- }
+ case PORT:
+ createAbstractPortProperties(unifiedCompositionDataList, substitutionTemplateInputName,
+ computeType, serviceTemplate, abstractPropertyValue);
+ break;
+ case SUB_INTERFACE:
+ createAbstractSubInterfaceProperties(unifiedCompositionDataList,
+ substitutionTemplateInputName, serviceTemplate, abstractPropertyValue);
break;
default:
break;
}
//Add the property only if it has at least one non-null value
- for (Object val : abstractPropertyValue) {
- if (Objects.nonNull(val)) {
- updateAbstractPropertyValue(substitutionTemplateInputName, inputParameterDefinition,
- abstractPropertyValue, abstractSubstituteProperties);
- break;
- }
+ if (abstractPropertyValue.stream().anyMatch(Objects::nonNull)) {
+ updateAbstractPropertyValue(substitutionTemplateInputName, inputParameterDefinition,
+ abstractPropertyValue, abstractSubstituteProperties);
}
}
return Optional.ofNullable(abstractSubstituteProperties);
}
+ private void createAbstractComputeProperties(List<UnifiedCompositionData>
+ unifiedCompositionDataList,
+ String substitutionTemplateInputName,
+ ServiceTemplate serviceTemplate,
+ List<Object> abstractPropertyValue) {
+ for (UnifiedCompositionData compositionData : unifiedCompositionDataList) {
+ ComputeTemplateConsolidationData computeTemplateConsolidationData =
+ compositionData.getComputeTemplateConsolidationData();
+ Object propertyValue = getComputePropertyValue(substitutionTemplateInputName,
+ serviceTemplate, computeTemplateConsolidationData);
+ if (!(propertyValue instanceof Optional)) {
+ abstractPropertyValue.add(propertyValue);
+ }
+ }
+ }
+
+ private void createAbstractPortProperties(List<UnifiedCompositionData>
+ unifiedCompositionDataList,
+ String substitutionTemplateInputName,
+ String computeType,
+ ServiceTemplate serviceTemplate,
+ List<Object> abstractPropertyValue) {
+ for (UnifiedCompositionData compositionData : unifiedCompositionDataList) {
+ List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
+ getPortTemplateConsolidationDataList(compositionData);
+ //Get the input type for this input whether it is of type
+ // port_<port_node_template_id>_<property_name> or port_<port_type>_<property_name>
+ PropertyInputType portInputType = getPortInputType(substitutionTemplateInputName,
+ compositionData);
+ for (PortTemplateConsolidationData portTemplateConsolidationData :
+ portTemplateConsolidationDataList) {
+ //Get the port property value
+ String portNodeTemplateId = portTemplateConsolidationData.getNodeTemplateId();
+ Object propertyValue = getPortPropertyValue(substitutionTemplateInputName,
+ computeType, portInputType, serviceTemplate,
+ portNodeTemplateId);
+ //If the value object is Optional.empty it implies that the property name was not
+ // found in the input name
+ if (!(propertyValue instanceof Optional)) {
+ abstractPropertyValue.add(propertyValue);
+ }
+ }
+ }
+ }
+
+ private void createAbstractSubInterfaceProperties(List<UnifiedCompositionData>
+ unifiedCompositionDataList,
+ String substitutionTemplateInputName,
+ ServiceTemplate serviceTemplate,
+ List<Object> abstractPropertyValue) {
+ for (UnifiedCompositionData compositionData : unifiedCompositionDataList) {
+ List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
+ getSubInterfaceTemplateConsolidationDataList(compositionData);
+ //Get the input type for this input whether it is of type
+ // subInterface_<subinterface_node_template_id>_<property_name> or
+ // subInterface_<subinterface_type>_<property_name>
+ PropertyInputType subInterfaceInputType =
+ getSubInterfaceInputType(substitutionTemplateInputName, compositionData);
+ for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
+ subInterfaceTemplateConsolidationDataList) {
+ //Get the subInterface property value
+ String subInterfaceNodeTemplateId = subInterfaceTemplateConsolidationData
+ .getNodeTemplateId();
+ NodeTemplate subInterfaceNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
+ subInterfaceNodeTemplateId);
+ String subInterfaceType = getSubInterfaceTypeSuffix(subInterfaceNodeTemplate
+ .getType());
+ Object propertyValue = getSubInterfacePropertyValue(substitutionTemplateInputName,
+ subInterfaceType, subInterfaceInputType, serviceTemplate,
+ subInterfaceNodeTemplateId);
+ //If the value object is Optional.empty it implies that the property name was not
+ // found in the input name
+ if (!(propertyValue instanceof Optional)) {
+ abstractPropertyValue.add(propertyValue);
+ }
+ }
+ }
+ }
+
private void updateAbstractPropertyValue(String substitutionTemplateInputName,
ParameterDefinition parameterDefinition,
List<Object> abstractPropertyValue,
} else {
Object propertyValue = abstractPropertyValue.get(0);
String entrySchemaType = parameterDefinition.getEntry_schema().getType();
- if (entrySchemaType.equalsIgnoreCase(PropertyType.STRING.getDisplayName())
- || entrySchemaType.equalsIgnoreCase(PropertyType.INTEGER.getDisplayName())
- || entrySchemaType.equalsIgnoreCase(PropertyType.FLOAT.getDisplayName())
- || entrySchemaType.equalsIgnoreCase(PropertyType.BOOLEAN.getDisplayName())
- || entrySchemaType.equals(PropertyTypeExt.JSON.getDisplayName())) {
+ if (PropertyType.getSimplePropertyTypes().contains(entrySchemaType.toLowerCase())
+ || entrySchemaType.equals(PropertyTypeExt.JSON.getDisplayName())) {
abstractSubstituteProperties.put(substitutionTemplateInputName, abstractPropertyValue);
} else {
abstractSubstituteProperties.put(substitutionTemplateInputName, propertyValue);
private void updateIdenticalPropertyValue(String identicalValuePropertyName,
String substitutionTemplateInputName,
- String computeType,
UnifiedCompositionEntity entity,
UnifiedCompositionData unifiedCompositionData,
ServiceTemplate serviceTemplate,
Map<String, Object> abstractSubstituteProperties,
TranslationContext context) {
Optional<Object> identicalPropertyValueByType =
- getIdenticalPropertyValueByType(identicalValuePropertyName, substitutionTemplateInputName,
- entity, unifiedCompositionData, serviceTemplate, context);
+ getIdenticalPropertyValueByType(identicalValuePropertyName, substitutionTemplateInputName,
+ entity, unifiedCompositionData, serviceTemplate, context);
if (identicalPropertyValueByType.isPresent()) {
abstractSubstituteProperties
- .put(substitutionTemplateInputName, identicalPropertyValueByType.get());
+ .put(substitutionTemplateInputName, identicalPropertyValueByType.get());
}
private Optional<Object> getIdenticalPropertyValueByType(String identicalValuePropertyName,
String substitutionTemplateInputName,
UnifiedCompositionEntity entity,
- UnifiedCompositionData unifiedCompositionData,
+ UnifiedCompositionData
+ unifiedCompositionData,
ServiceTemplate serviceTemplate,
TranslationContext context) {
ComputeTemplateConsolidationData computeTemplateConsolidationData =
- unifiedCompositionData.getComputeTemplateConsolidationData();
+ unifiedCompositionData.getComputeTemplateConsolidationData();
- Optional<Object> computeIdenticalPropertyValue;
+ Optional<Object> identicalPropertyValue = Optional.empty();
switch (entity) {
- case Compute:
- computeIdenticalPropertyValue =
- getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate,
- entity, computeTemplateConsolidationData, context);
- return computeIdenticalPropertyValue.isPresent() ? Optional.of(
- computeIdenticalPropertyValue.get()) : Optional.empty();
-
- case Other:
- computeIdenticalPropertyValue =
- getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate,
- entity, computeTemplateConsolidationData, context);
- return computeIdenticalPropertyValue.isPresent() ? Optional.of(
- computeIdenticalPropertyValue.get()) : Optional.empty();
-
- case Port:
- List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
- unifiedCompositionData.getPortTemplateConsolidationDataList();
- for (PortTemplateConsolidationData portTemplateConsolidationData : portTemplateConsolidationDataList) {
- String portType =
- ConsolidationDataUtil.getPortType(portTemplateConsolidationData.getNodeTemplateId());
- if (substitutionTemplateInputName.contains(portType)) {
- return getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate,
- entity, portTemplateConsolidationData, context);
- }
+ case COMPUTE:
+ identicalPropertyValue =
+ getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate,
+ computeTemplateConsolidationData, context);
+ break;
+ case OTHER:
+ identicalPropertyValue =
+ getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate,
+ computeTemplateConsolidationData, context);
+ break;
+ case PORT:
+ PropertyInputType portInputType = getPortInputType(substitutionTemplateInputName,
+ unifiedCompositionData);
+ Optional <PortTemplateConsolidationData> portTemplateConsolidationData =
+ unifiedCompositionData.getPortTemplateConsolidationDataList()
+ .stream()
+ .filter(s -> substitutionTemplateInputName.
+ contains(getPropertyInputPrefix(s.getNodeTemplateId(),
+ ConsolidationDataUtil.getPortType(s.getNodeTemplateId()),
+ portInputType, UnifiedCompositionEntity.PORT)))
+ .findFirst();
+
+ if(portTemplateConsolidationData.isPresent()) {
+ return getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate,
+ portTemplateConsolidationData.get(), context);
}
+ break;
+ default:
+ break;
}
-
- return Optional.empty();
-
+ return identicalPropertyValue;
}
- private PortInputType getPortInputType(String inputName,
- UnifiedCompositionData unifiedCompositionData) {
- String portInputPrefix = UnifiedCompositionEntity.Port.name().toLowerCase() + "_";
+ private PropertyInputType getPortInputType(String inputName,
+ UnifiedCompositionData unifiedCompositionData) {
+ String portInputPrefix = UnifiedCompositionEntity.PORT.getDisplayName().toLowerCase() + "_";
ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
- .getComputeTemplateConsolidationData();
+ .getComputeTemplateConsolidationData();
List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
- getPortTemplateConsolidationDataList(unifiedCompositionData);
+ getPortTemplateConsolidationDataList(unifiedCompositionData);
//Scan the available port node template ids to check if the input is of the form
// "port_<port_node_template_id>_<property_name>"
- for (PortTemplateConsolidationData portTemplateConsolidationData :
- portTemplateConsolidationDataList) {
- String portNodeTemplateId = portTemplateConsolidationData.getNodeTemplateId();
- String portNodeTemplateIdPrefix = portInputPrefix + portNodeTemplateId;
- if (inputName.startsWith(portNodeTemplateIdPrefix)) {
- return PortInputType.NodeTemplateId;
- }
+ if (portTemplateConsolidationDataList.stream().map(EntityConsolidationData::getNodeTemplateId)
+ .map(portNodeTemplateId -> portInputPrefix + portNodeTemplateId).anyMatch(inputName::startsWith)) {
+ return PropertyInputType.NODE_TEMPLATE_ID;
}
//Check whether the input is of the form "port_<port_type>_<property_name>"
Set<String> portTypes = computeTemplateConsolidationData.getPorts().keySet();
- for (String portType : portTypes) {
- String expectedPortTypeSusbtring = portInputPrefix + portType + "_";
- if (inputName.startsWith(expectedPortTypeSusbtring)) {
- return PortInputType.PortType;
- }
+ if (portTypes.stream().map(portType -> portInputPrefix + portType + "_").anyMatch(inputName::startsWith)) {
+ return PropertyInputType.TYPE;
+ }
+ return PropertyInputType.OTHER;
+ }
+
+ private PropertyInputType getSubInterfaceInputType(String inputName,
+ UnifiedCompositionData unifiedCompositionData) {
+ String subInterfaceInputPrefix = UnifiedCompositionEntity.SUB_INTERFACE.getDisplayName().toLowerCase()
+ + "_";
+ List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
+ getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+ //Scan the available port node template ids to check if the input is of the form
+ // "subinterface_<subinterface_node_template_id>_<property_name>"
+ if (subInterfaceTemplateConsolidationDataList.stream().map(EntityConsolidationData::getNodeTemplateId)
+ .map(subInterfaceNodeTemplateId -> subInterfaceInputPrefix
+ + subInterfaceNodeTemplateId)
+ .anyMatch(inputName::startsWith)) {
+ return PropertyInputType.NODE_TEMPLATE_ID;
+ }
+ //Check whether the input is of the form "subinterface_<subinterface_type>_<property_name>"
+ Set<String> subInterfaceTypes = new HashSet<>();
+ List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
+ getPortTemplateConsolidationDataList(unifiedCompositionData);
+ for (PortTemplateConsolidationData portTemplateConsolidationData :
+ portTemplateConsolidationDataList) {
+ subInterfaceTypes.addAll(portTemplateConsolidationData.getAllSubInterfaceNodeTypes());
}
- return PortInputType.Other;
+
+ if (subInterfaceTypes.stream().map(UnifiedCompositionUtil::getSubInterfaceTypeSuffix)
+ .map(subInterfaceTypeSuffix -> subInterfaceInputPrefix + subInterfaceTypeSuffix + "_")
+ .anyMatch(inputName::startsWith)) {
+ return PropertyInputType.TYPE;
+ }
+ return PropertyInputType.OTHER;
}
private void cleanServiceTemplate(ServiceTemplate serviceTemplate,
TranslationContext context) {
String nodeTemplateIdToRemove = entity.getNodeTemplateId();
Map<String, NodeTemplate> nodeTemplates =
- serviceTemplate.getTopology_template().getNode_templates();
+ serviceTemplate.getTopology_template().getNode_templates();
NodeTemplate nodeTemplateToRemove =
- nodeTemplates.get(nodeTemplateIdToRemove);
+ nodeTemplates.get(nodeTemplateIdToRemove);
nodeTemplates.remove(nodeTemplateIdToRemove);
context.addCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
- nodeTemplateIdToRemove,
- entity.getClass() == ComputeTemplateConsolidationData.class
- ? UnifiedCompositionEntity.Compute
- : UnifiedCompositionEntity.Port,
- nodeTemplateToRemove);
+ nodeTemplateIdToRemove,
+ entity.getClass() == ComputeTemplateConsolidationData.class
+ ? COMPUTE
+ : UnifiedCompositionEntity.PORT,
+ nodeTemplateToRemove);
}
ServiceTemplate serviceTemplate,
TranslationContext context) {
NodeTemplate cleanedNodeTemplate =
- context
- .getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
- cleanedNodeTemplateId);
+ context
+ .getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
+ cleanedNodeTemplateId);
String typeToRemove = cleanedNodeTemplate.getType();
if (Objects.nonNull(typeToRemove)
- && serviceTemplate.getNode_types().containsKey(typeToRemove)) {
+ && serviceTemplate.getNode_types().containsKey(typeToRemove)) {
serviceTemplate.getNode_types().remove(typeToRemove);
}
}
EntityConsolidationData entity,
TranslationContext context) {
Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template()
- .getGroups() == null ? new HashMap<>()
- : serviceTemplate.getTopology_template().getGroups();
- String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
+ .getGroups() == null ? new HashMap<>()
+ : serviceTemplate.getTopology_template().getGroups();
String nodeRelatedAbstractNodeId =
- context.getUnifiedAbstractNodeTemplateId(serviceTemplate, entity.getNodeTemplateId());
+ context.getUnifiedAbstractNodeTemplateId(serviceTemplate, entity.getNodeTemplateId());
for (Map.Entry<String, GroupDefinition> groupEntry : groups.entrySet()) {
GroupDefinition groupDefinition = groupEntry.getValue();
if (isHeatStackGroup(groupDefinition.getType())) {
updateGroupMembersWithNewUnifiedNodeTemplateId(entity, nodeRelatedAbstractNodeId,
- groupEntry);
+ groupEntry);
}
}
}
private void updateGroupMembersWithNewUnifiedNodeTemplateId(
- EntityConsolidationData entity,
- String newNodetemplateId,
- Map.Entry<String, GroupDefinition> groupEntry) {
+ EntityConsolidationData entity,
+ String newNodetemplateId,
+ Map.Entry<String, GroupDefinition> groupEntry) {
List<String> members = groupEntry.getValue().getMembers();
if (members.contains(entity.getNodeTemplateId())) {
members.remove(entity.getNodeTemplateId());
groupEntry.getValue().setMembers(members);
}
- private void updateSubstitutableNodeTemplateRequirements(ServiceTemplate serviceTemplate,
- ServiceTemplate substitutionServiceTemplate){
- if(Objects.isNull(substitutionServiceTemplate.getTopology_template())){
- return;
- }
-
- SubstitutionMapping substitution_mappings =
- substitutionServiceTemplate.getTopology_template().getSubstitution_mappings();
-
- if(Objects.isNull(substitution_mappings)){
- return;
- }
-
- String node_type = substitution_mappings.getNode_type();
- Map<String, List<String>> requirements = substitution_mappings.getRequirements();
-
-
- }
-
private void updateSubstitutionMapping(ServiceTemplate serviceTemplate,
TranslationContext context) {
SubstitutionMapping substitutionMappings =
- DataModelUtil.getSubstitutionMappings(serviceTemplate);
+ DataModelUtil.getSubstitutionMappings(serviceTemplate);
if (Objects.nonNull(substitutionMappings)) {
if (Objects.nonNull(substitutionMappings.getRequirements())) {
updateSubstitutionMappingRequirements(substitutionMappings.getRequirements(),
- serviceTemplate, context);
+ serviceTemplate, context);
}
if (Objects.nonNull(substitutionMappings.getCapabilities())) {
updateSubstitutionMappingCapabilities(substitutionMappings.getCapabilities(),
- serviceTemplate, context);
+ serviceTemplate, context);
}
}
}
private void updateSubstitutionMappingRequirements(Map<String, List<String>>
- substitutionMappingRequirements,
+ substitutionMappingRequirements,
ServiceTemplate serviceTemplate,
TranslationContext context) {
for (Map.Entry<String, List<String>> entry : substitutionMappingRequirements.entrySet()) {
List<String> requirement = entry.getValue();
String oldNodeTemplateId = requirement.get(0);
String newAbstractNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(serviceTemplate,
- requirement.get(0));
+ requirement.get(0));
String newSubstitutionNodeTemplateId = context.getUnifiedSubstitutionNodeTemplateId(
- serviceTemplate, oldNodeTemplateId);
+ serviceTemplate, oldNodeTemplateId);
if (Objects.nonNull(newAbstractNodeTemplateId)
- && Objects.nonNull(newSubstitutionNodeTemplateId)) {
+ && Objects.nonNull(newSubstitutionNodeTemplateId)) {
requirement.set(0, newAbstractNodeTemplateId);
String newRequirementValue = requirement.get(1) + "_" + newSubstitutionNodeTemplateId;
requirement.set(1, newRequirementValue);
}
private void updateSubstitutionMappingCapabilities(Map<String, List<String>>
- substitutionMappingCapabilities,
+ substitutionMappingCapabilities,
ServiceTemplate serviceTemplate,
TranslationContext context) {
for (Map.Entry<String, List<String>> entry : substitutionMappingCapabilities.entrySet()) {
List<String> capability = entry.getValue();
String oldNodeTemplateId = capability.get(0);
String newAbstractNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(serviceTemplate,
- capability.get(0));
+ capability.get(0));
String newSubstitutionNodeTemplateId = context.getUnifiedSubstitutionNodeTemplateId(
- serviceTemplate, oldNodeTemplateId);
+ serviceTemplate, oldNodeTemplateId);
if (Objects.nonNull(newAbstractNodeTemplateId)
- && Objects.nonNull(newSubstitutionNodeTemplateId)) {
+ && Objects.nonNull(newSubstitutionNodeTemplateId)) {
capability.set(0, newAbstractNodeTemplateId);
String newRequirementValue = capability.get(1) + "_" + newSubstitutionNodeTemplateId;
capability.set(1, newRequirementValue);
EntityConsolidationData entity,
TranslationContext context) {
Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template()
- .getGroups() == null ? new HashMap<>() : serviceTemplate.getTopology_template().getGroups();
+ .getGroups() == null ? new HashMap<>() : serviceTemplate.getTopology_template().getGroups();
String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
Optional<String> nestedNodeTemplateId =
- context.getUnifiedNestedNodeTemplateId(serviceTemplateFileName, entity.getNodeTemplateId());
+ context.getUnifiedNestedNodeTemplateId(serviceTemplateFileName, entity.getNodeTemplateId());
if (nestedNodeTemplateId.isPresent()) {
for (Map.Entry<String, GroupDefinition> groupEntry : groups.entrySet()) {
GroupDefinition groupDefinition = groupEntry.getValue();
if (isHeatStackGroup(groupDefinition.getType())) {
updateGroupMembersWithNewUnifiedNodeTemplateId(entity, nestedNodeTemplateId.get(),
- groupEntry);
+ groupEntry);
}
}
}
ServiceTemplate nestedServiceTemplate,
TranslationContext context) {
NodeTemplate nestedNodeTemplate = DataModelUtil.getNodeTemplate(mainServiceTemplate,
- nestedNodeTemplateId);
+ nestedNodeTemplateId);
if (Objects.isNull(nestedNodeTemplate)) {
return;
}
updateNestedNodeTemplateProperties(nestedServiceTemplate, nestedNodeTemplate, context);
Optional<String> unifiedNestedNodeTypeId = context
- .getUnifiedNestedNodeTypeId(
- ToscaUtil.getServiceTemplateFileName(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME),
- nestedNodeTemplate.getType());
+ .getUnifiedNestedNodeTypeId(
+ ToscaUtil.getServiceTemplateFileName(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME),
+ nestedNodeTemplate.getType());
unifiedNestedNodeTypeId
- .ifPresent(unifiedNestedNodeTypeIdVal -> updateNestedNodeTemplate(
- unifiedNestedNodeTypeIdVal, nestedNodeTemplateId, nestedNodeTemplate,
- mainServiceTemplate, context));
-
- //updateNestedNodeTemplateRequirement(nestedNodeTemplateId, mainServiceTemplate,
- //nestedServiceTemplate, context);
-
- //updateNodeTemplateRequirements(nestedNodeTemplateId, mainServiceTemplate,
- //nestedServiceTemplate, context);
-
- //updateNodeDependencyRequirement(mainServiceTemplate, context, nestedNodeTemplate);
- }
-
- private void updateNestedNodeTemplateRequirement(String nestedNodeTemplateId,
- ServiceTemplate mainServiceTemplate,
- ServiceTemplate nestedServiceTemplate,
- TranslationContext context){
- NestedTemplateConsolidationData nestedTemplateConsolidationData =
- ConsolidationDataUtil
- .getNestedTemplateConsolidationData(context, mainServiceTemplate, null, nestedNodeTemplateId);
-
- FileComputeConsolidationData fileComputeConsolidationData =
- context.getConsolidationData().getComputeConsolidationData().getFileComputeConsolidationData
- (ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
-
-
- TypeComputeConsolidationData compute =
- fileComputeConsolidationData.getAllTypeComputeConsolidationData().iterator().next();
-
- if(Objects.isNull(nestedTemplateConsolidationData)){
- return;
- }
-
- Map<String, List<RequirementAssignmentData>> nodesConnectedOut =
- nestedTemplateConsolidationData.getNodesConnectedOut();
-
- if(MapUtils.isEmpty(nodesConnectedOut)){
- return;
- }
-
- updateRequirements(nestedNodeTemplateId, mainServiceTemplate, nestedServiceTemplate, compute,
- nodesConnectedOut);
- }
-
- private void updateRequirements(String nestedNodeTemplateId, ServiceTemplate mainServiceTemplate,
- ServiceTemplate nestedServiceTemplate,
- TypeComputeConsolidationData compute,
- Map<String, List<RequirementAssignmentData>> nodesConnectedOut) {
- NodeTemplate nodeTemplate =
- DataModelUtil.getNodeTemplate(mainServiceTemplate, nestedNodeTemplateId);
-
- for(List<RequirementAssignmentData> requirementAssignmentDataList : nodesConnectedOut.values()){
- for(RequirementAssignmentData data : requirementAssignmentDataList){
- if(!data.getRequirementId().equals("dependency")){
- DataModelUtil.addRequirementAssignment(nodeTemplate, data.getRequirementId(),
- cloneRequirementAssignment(data.getRequirementAssignment()));
- updateRequirementInSubMapping(nestedServiceTemplate, compute, data);
-
- }
- }
- }
-
- removeUneccessaryRequirements(nodeTemplate);
- }
-
- private void updateRequirementInSubMapping(ServiceTemplate nestedServiceTemplate,
- TypeComputeConsolidationData compute,
- RequirementAssignmentData data) {
- List<String> subMappingRequirement =
- Arrays.asList(compute.getAllComputeNodeTemplateIds().iterator().next(), "dependency");
- DataModelUtil.addSubstitutionMappingReq(nestedServiceTemplate, data.getRequirementId(),
- subMappingRequirement);
- }
-
-
- private RequirementAssignment cloneRequirementAssignment(RequirementAssignment reqToClone){
- RequirementAssignment requirementAssignment = new RequirementAssignment();
-
- requirementAssignment.setRelationship(reqToClone.getRelationship());
- requirementAssignment.setNode(reqToClone.getNode());
- requirementAssignment.setCapability(reqToClone.getCapability());
-
- return requirementAssignment;
- }
-
- private void removeUneccessaryRequirements(NodeTemplate nodeTemplate) {
- List<Map<String, RequirementAssignment>> reqsToRemove = new ArrayList<>();
- for(Map<String, RequirementAssignment> requirementDefinitionMap : nodeTemplate.getRequirements()) {
- if (requirementDefinitionMap.containsKey("dependency")) {
- reqsToRemove.add(requirementDefinitionMap);
- }
- }
-
- nodeTemplate.getRequirements().removeAll(reqsToRemove);
- }
-
- private RequirementAssignment getRequirementAssignmentFromDefinition(
- Map.Entry<String, RequirementDefinition> requirementDefinitionEntry) {
-
- RequirementAssignment requirementAssignment = new RequirementAssignment();
- if(requirementDefinitionEntry.getValue() instanceof RequirementDefinition) {
- requirementAssignment.setCapability(requirementDefinitionEntry.getValue().getCapability());
- requirementAssignment.setNode(requirementDefinitionEntry.getValue().getNode());
- requirementAssignment.setRelationship(requirementDefinitionEntry.getValue().getRelationship());
- }
- else if(requirementDefinitionEntry.getValue() instanceof Map){
- Map<String, Object> reqAsMap = (Map<String, Object>) requirementDefinitionEntry.getValue();
- requirementAssignment.setCapability((String) reqAsMap.get("capability"));
- requirementAssignment.setNode((String) reqAsMap.get("node"));
- requirementAssignment.setRelationship((String) reqAsMap.get("relationship"));
- }
- return requirementAssignment;
+ .ifPresent(unifiedNestedNodeTypeIdVal -> updateNestedNodeTemplate(
+ unifiedNestedNodeTypeIdVal, nestedNodeTemplateId, nestedNodeTemplate,
+ mainServiceTemplate, context));
}
private void updateNestedNodeTemplateProperties(ServiceTemplate nestedServiceTemplate,
TranslationContext context) {
Map<String, Object> newPropertyInputParamIds =
- context.getAllNewPropertyInputParamIdsPerNodeTenplateId(ToscaUtil
- .getServiceTemplateFileName(nestedServiceTemplate));
+ context.getAllNewPropertyInputParamIdsPerNodeTenplateId(ToscaUtil
+ .getServiceTemplateFileName(nestedServiceTemplate));
for (Map.Entry<String, Object> entry : newPropertyInputParamIds.entrySet()) {
if (Objects.nonNull(entry.getValue())) {
}
String subNodeType =
- nestedServiceTemplate.getTopology_template().getSubstitution_mappings().getNode_type();
+ nestedServiceTemplate.getTopology_template().getSubstitution_mappings().getNode_type();
nestedNodeTemplate.setType(subNodeType);
}
private void handleSubstitutionMappingInNestedServiceTemplate(
- String newNestedNodeType,
- ServiceTemplate nestedServiceTemplate,
- TranslationContext context) {
+ String newNestedNodeType,
+ ServiceTemplate nestedServiceTemplate,
+ TranslationContext context) {
if (Objects.isNull(newNestedNodeType)) {
return;
}
Set<String> relatedNestedNodeTypeIds =
- context.getAllRelatedNestedNodeTypeIds();
+ context.getAllRelatedNestedNodeTypeIds();
SubstitutionMapping substitutionMappings =
- nestedServiceTemplate.getTopology_template().getSubstitution_mappings();
- if(!relatedNestedNodeTypeIds.contains(substitutionMappings.getNode_type())) {
+ nestedServiceTemplate.getTopology_template().getSubstitution_mappings();
+ if (!relatedNestedNodeTypeIds.contains(substitutionMappings.getNode_type())) {
substitutionMappings.setNode_type(newNestedNodeType);
}
}
TranslationContext context) {
String mainSTName = ToscaUtil.getServiceTemplateFileName(mainServiceTemplate);
String globalSTName =
- ToscaUtil.getServiceTemplateFileName(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME);
+ ToscaUtil.getServiceTemplateFileName(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME);
int index =
- context.getHandledNestedComputeNodeTemplateIndex(globalSTName, newNestedNodeTypeId);
+ context.getHandledNestedComputeNodeTemplateIndex(globalSTName, newNestedNodeTypeId);
String newNodeTemplateId =
- Constants.ABSTRACT_NODE_TEMPLATE_ID_PREFIX + getComputeTypeSuffix(newNestedNodeTypeId)
- + "_" + index;
+ Constants.ABSTRACT_NODE_TEMPLATE_ID_PREFIX + getComputeTypeSuffix(newNestedNodeTypeId)
+ + "_" + index;
nestedNodeTemplate.setType(newNestedNodeTypeId);
mainServiceTemplate.getTopology_template().getNode_templates().remove(nestedNodeTemplateId);
mainServiceTemplate.getTopology_template().getNode_templates()
- .put(newNodeTemplateId, nestedNodeTemplate);
+ .put(newNodeTemplateId, nestedNodeTemplate);
context.addUnifiedNestedNodeTemplateId(mainSTName, nestedNodeTemplateId, newNodeTemplateId);
}
private void handleNestedNodeTypesInGlobalSubstituteServiceTemplate(
- String origNestedNodeTypeId,
- String newNestedNodeTypeId,
- ServiceTemplate globalSubstitutionServiceTemplate,
- TranslationContext context) {
+ String origNestedNodeTypeId,
+ String newNestedNodeTypeId,
+ ServiceTemplate globalSubstitutionServiceTemplate,
+ TranslationContext context) {
Set<String> relatedNestedNodeTypeIds =
- context.getAllRelatedNestedNodeTypeIds();
+ context.getAllRelatedNestedNodeTypeIds();
Map<String, NodeType> nodeTypes = globalSubstitutionServiceTemplate.getNode_types();
if (!relatedNestedNodeTypeIds.contains(origNestedNodeTypeId)) {
NodeType nested = DataModelUtil.getNodeType(globalSubstitutionServiceTemplate,
- origNestedNodeTypeId);
+ origNestedNodeTypeId);
setNewValuesForNestedNodeType(origNestedNodeTypeId, newNestedNodeTypeId, nested, nodeTypes);
} else {
NodeType nested =
- (NodeType) DataModelUtil.getClonedObject(
- DataModelUtil.getNodeType(globalSubstitutionServiceTemplate, origNestedNodeTypeId));
+ (NodeType) DataModelUtil.getClonedObject(
+ DataModelUtil.getNodeType(globalSubstitutionServiceTemplate, origNestedNodeTypeId));
nested.setDerived_from(ToscaNodeType.VFC_ABSTRACT_SUBSTITUTE);
nodeTypes.put(newNestedNodeTypeId, nested);
}
context.addUnifiedNestedNodeTypeId(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
- origNestedNodeTypeId, newNestedNodeTypeId);
+ origNestedNodeTypeId, newNestedNodeTypeId);
}
private void setNewValuesForNestedNodeType(String origNestedNodeType,
}
}
- private Optional<String> getNewNestedNodeTypeId(ServiceTemplate mainServiceTemplate,
- ServiceTemplate nestedServiceTemplate,
+ private Optional<String> getNewNestedNodeTypeId(ServiceTemplate nestedServiceTemplate,
TranslationContext context) {
FileComputeConsolidationData fileComputeConsolidationData =
- context.getConsolidationData().getComputeConsolidationData()
- .getFileComputeConsolidationData(
- ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
+ context.getConsolidationData().getComputeConsolidationData()
+ .getFileComputeConsolidationData(
+ ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
if (Objects.nonNull(fileComputeConsolidationData)) {
String nestedNodeTypePrefix = ToscaNodeType.ABSTRACT_NODE_TYPE_PREFIX + "heat.";
return Optional
- .of(nestedNodeTypePrefix + getComputeTypeInNestedFile(fileComputeConsolidationData));
+ .of(nestedNodeTypePrefix + getComputeTypeInNestedFile(fileComputeConsolidationData));
}
return Optional.empty();
}
private String getComputeTypeInNestedFile(
- FileComputeConsolidationData fileComputeConsolidationData) {
+ FileComputeConsolidationData fileComputeConsolidationData) {
List<TypeComputeConsolidationData> typeComputeConsolidationDatas =
- new ArrayList<>(fileComputeConsolidationData.getAllTypeComputeConsolidationData());
- if (typeComputeConsolidationDatas.size() == 0) {
+ new ArrayList<>(fileComputeConsolidationData.getAllTypeComputeConsolidationData());
+ if (typeComputeConsolidationDatas.isEmpty()) {
return null;
} else {
String computeNodeType = fileComputeConsolidationData.getAllComputeTypes().iterator().next();
String serviceTemplateFileName,
NodeTemplate abstractNodeTemplate) {
Map<String, Object> properties =
- abstractNodeTemplate == null || abstractNodeTemplate.getProperties() == null
- ? new HashMap<>()
- : abstractNodeTemplate.getProperties();
+ abstractNodeTemplate == null || abstractNodeTemplate.getProperties() == null
+ ? new HashMap<>()
+ : abstractNodeTemplate.getProperties();
for (Object propertyValue : properties.values()) {
List<List<Object>> getAttrList = extractGetAttrFunction(propertyValue);
for (List<Object> getAttrFuncValue : getAttrList) {
String origNodeTemplateId = (String) getAttrFuncValue.get(0);
Optional<String> nestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(ToscaUtil
- .getServiceTemplateFileName(serviceTemplate), origNodeTemplateId);
+ .getServiceTemplateFileName(serviceTemplate), origNodeTemplateId);
if (nestedNodeTemplateId.isPresent()) {
getAttrFuncValue.set(0, nestedNodeTemplateId.get());
} else {
replaceGetAttrNodeIdAndAttrName(serviceTemplate, context, serviceTemplateFileName,
- getAttrFuncValue);
+ getAttrFuncValue);
}
}
}
String attributeName = (String) getAttrFuncValue.get(1);
String unifiedAbstractNodeTemplateId =
- context.getUnifiedAbstractNodeTemplateId(serviceTemplate, origNodeTemplateId);
+ context.getUnifiedAbstractNodeTemplateId(serviceTemplate, origNodeTemplateId);
if (Objects.isNull(unifiedAbstractNodeTemplateId)) {
return;
}
String newNodeTemplateId =
- getNewNodeTemplateId(origNodeTemplateId, serviceTemplateFileName, serviceTemplate, context);
+ getNewNodeTemplateId(origNodeTemplateId, serviceTemplateFileName, serviceTemplate, context);
String newSubstitutionOutputParameterId =
- getNewSubstitutionOutputParameterId(newNodeTemplateId, attributeName);
+ getNewSubstitutionOutputParameterId(newNodeTemplateId, attributeName);
getAttrFuncValue.set(0, unifiedAbstractNodeTemplateId);
getAttrFuncValue.set(1, newSubstitutionOutputParameterId);
ServiceTemplate serviceTemplate,
TranslationContext context) {
NodeTemplate computeNodeTemplate =
- DataModelUtil.getNodeTemplate(serviceTemplate, origNodeTemplateId);
+ DataModelUtil.getNodeTemplate(serviceTemplate, origNodeTemplateId);
if (computeNodeTemplate == null) {
computeNodeTemplate =
- context.getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
- origNodeTemplateId);
+ context.getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
+ origNodeTemplateId);
}
return computeNodeTemplate;
}
private String handleIdOfPort(String origNodeTemplateId, String serviceTemplateFileName,
ConsolidationData consolidationData) {
Optional<Pair<String, ComputeTemplateConsolidationData>>
- computeTypeAndComputeTemplateByPortId =
- getComputeTypeAndComputeTemplateByPortId(origNodeTemplateId, serviceTemplateFileName,
- consolidationData);
+ computeTypeAndComputeTemplateByPortId =
+ getComputeTypeAndComputeTemplateByPortId(origNodeTemplateId, serviceTemplateFileName,
+ consolidationData);
if (computeTypeAndComputeTemplateByPortId.isPresent()) {
Pair<String, ComputeTemplateConsolidationData> computeIdToComputeData =
- computeTypeAndComputeTemplateByPortId.get();
+ computeTypeAndComputeTemplateByPortId.get();
return getNewPortNodeTemplateId(origNodeTemplateId, computeIdToComputeData.getKey(),
- computeIdToComputeData.getValue());
+ computeIdToComputeData.getValue());
}
return null;
getComputeTypeAndComputeTemplateByPortId(String portId, String serviceTemplateFileName,
ConsolidationData consolidationData) {
FileComputeConsolidationData fileComputeConsolidationData =
- consolidationData.getComputeConsolidationData()
- .getFileComputeConsolidationData(serviceTemplateFileName);
+ consolidationData.getComputeConsolidationData()
+ .getFileComputeConsolidationData(serviceTemplateFileName);
Set<String> computeTypes =
- fileComputeConsolidationData.getAllComputeTypes();
+ fileComputeConsolidationData.getAllComputeTypes();
for (String computeType : computeTypes) {
Collection<ComputeTemplateConsolidationData> computeTemplateConsolidationDatas =
- fileComputeConsolidationData.getTypeComputeConsolidationData(computeType)
- .getAllComputeTemplateConsolidationData();
+ fileComputeConsolidationData.getTypeComputeConsolidationData(computeType)
+ .getAllComputeTemplateConsolidationData();
for (ComputeTemplateConsolidationData compute : computeTemplateConsolidationDatas) {
if (ConsolidationDataUtil.isComputeReferenceToPortId(compute, portId)) {
String serviceTemplateFileName,
TranslationContext context) {
UnifiedSubstitutionData unifiedSubstitutionData =
- context.getUnifiedSubstitutionData().get(serviceTemplateFileName);
+ context.getUnifiedSubstitutionData().get(serviceTemplateFileName);
if (Objects.isNull(unifiedSubstitutionData)) {
return false;
}
UnifiedCompositionEntity actualUnifiedCompositionEntity =
- unifiedSubstitutionData.getCleanedNodeTemplateCompositionEntity(id);
+ unifiedSubstitutionData.getCleanedNodeTemplateCompositionEntity(id);
return actualUnifiedCompositionEntity == null ? false
- : actualUnifiedCompositionEntity.equals(expectedUnifiedCompositionEntity);
+ : actualUnifiedCompositionEntity.equals(expectedUnifiedCompositionEntity);
}
private boolean isHeatStackGroup(String groupType) {
private Object getPortPropertyValue(String inputName,
String computeType,
- PortInputType portInputType,
+ PropertyInputType portInputType,
ServiceTemplate serviceTemplate,
String portNodeTemplateId) {
//Get the input prefix to extract the property name from the input name
- String portInputPrefix = getPortInputPrefix(
- portNodeTemplateId, portInputType);
+ String portType = ConsolidationDataUtil.getPortType(portNodeTemplateId);
+ String portInputPrefix = getPropertyInputPrefix(
+ portNodeTemplateId, portType, portInputType, UnifiedCompositionEntity.PORT);
//Get the property name from the input
Optional<String> propertyName = getPropertyNameFromInput(inputName,
- UnifiedCompositionEntity.Port, computeType, portInputPrefix);
+ UnifiedCompositionEntity.PORT, computeType, portInputPrefix);
//Get the property value from the node template
if (propertyName.isPresent()) {
NodeTemplate portNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
- portNodeTemplateId);
+ portNodeTemplateId);
if (Objects.nonNull(portNodeTemplate)) {
return getPropertyValueFromNodeTemplate(propertyName.get(), portNodeTemplate);
}
return Optional.empty();
}
- private Optional<String> getPortTypeFromInput(
- String inputName,
- String portNodeTemplateId,
- ComputeTemplateConsolidationData computeTemplateConsolidationData) {
- String portTypeFromInput = null;
- String portInputPrefix = UnifiedCompositionEntity.Port.name().toLowerCase() + "_";
- String portNodeTemplateIdPrefix = portInputPrefix + portNodeTemplateId;
- if (inputName.startsWith(portNodeTemplateIdPrefix)) {
- return Optional.empty();
- }
- Set<String> portTypes = computeTemplateConsolidationData.getPorts().keySet();
- for (String portType : portTypes) {
- String expectedPortTypeSusbtring = "_" + portType + "_";
- if (inputName.contains(expectedPortTypeSusbtring)) {
- portTypeFromInput = portType;
- break;
- }
- }
- return Optional.ofNullable(portTypeFromInput);
- }
-
private Object getComputePropertyValue(
- String inputName,
- ServiceTemplate serviceTemplate,
- ComputeTemplateConsolidationData computeTemplateConsolidationData) {
+ String inputName,
+ ServiceTemplate serviceTemplate,
+ ComputeTemplateConsolidationData computeTemplateConsolidationData) {
NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
- computeTemplateConsolidationData.getNodeTemplateId());
+ computeTemplateConsolidationData.getNodeTemplateId());
String nodeType = getComputeTypeSuffix(nodeTemplate.getType());
Optional<String> propertyName =
- getPropertyNameFromInput(inputName, UnifiedCompositionEntity.Compute, nodeType, null);
+ getPropertyNameFromInput(inputName, COMPUTE, nodeType, null);
if (propertyName.isPresent()) {
return getPropertyValueFromNodeTemplate(propertyName.get(), nodeTemplate);
}
return Optional.empty();
}
+ private Object getSubInterfacePropertyValue(String inputName,
+ String subInterfaceTypeSuffix,
+ PropertyInputType propertyInputType,
+ ServiceTemplate serviceTemplate,
+ String subInterfaceNodeTemplateId) {
+ //Get the input prefix to extract the property name from the input name
+ String propertyInputPrefix = getPropertyInputPrefix(subInterfaceNodeTemplateId,
+ subInterfaceTypeSuffix, propertyInputType, UnifiedCompositionEntity.SUB_INTERFACE);
+ //Get the property name from the input
+ Optional<String> propertyName = getPropertyNameFromInput(inputName,
+ UnifiedCompositionEntity.SUB_INTERFACE, null, propertyInputPrefix);
+ //Get the property value from the node template
+ if (propertyName.isPresent()) {
+ NodeTemplate subInterfaceNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
+ subInterfaceNodeTemplateId);
+ if (Objects.nonNull(subInterfaceNodeTemplate)) {
+ return getPropertyValueFromNodeTemplate(propertyName.get(), subInterfaceNodeTemplate);
+ }
+ }
+ return Optional.empty();
+ }
+
private Optional<Object> getIdenticalPropertyValue(String identicalValuePropertyName,
ServiceTemplate serviceTemplate,
- UnifiedCompositionEntity unifiedCompositionEntity,
EntityConsolidationData entity,
TranslationContext context) {
NodeTemplate nodeTemplate =
- getNodeTemplate(entity.getNodeTemplateId(), serviceTemplate, context);
+ getNodeTemplate(entity.getNodeTemplateId(), serviceTemplate, context);
Object propertyValueFromNodeTemplate =
- getPropertyValueFromNodeTemplate(identicalValuePropertyName, nodeTemplate);
+ getPropertyValueFromNodeTemplate(identicalValuePropertyName, nodeTemplate);
return Objects.isNull(propertyValueFromNodeTemplate) ? Optional.empty()
- : Optional.of(propertyValueFromNodeTemplate);
+ : Optional.of(propertyValueFromNodeTemplate);
}
private UnifiedCompositionEntity getInputCompositionEntity(String inputName) {
- UnifiedCompositionEntity inputCompositionEntity = UnifiedCompositionEntity.Other;
- String inputType = inputName.substring(0, inputName.indexOf('_'));
- if (inputType.equals(UnifiedCompositionEntity.Compute.name().toLowerCase())) {
- inputCompositionEntity = UnifiedCompositionEntity.Compute;
- } else if (inputType.equals(UnifiedCompositionEntity.Port.name().toLowerCase())) {
- inputCompositionEntity = UnifiedCompositionEntity.Port;
+ UnifiedCompositionEntity inputCompositionEntity = UnifiedCompositionEntity.OTHER;
+ if (inputName.indexOf('_') != -1) {
+ String inputType = inputName.substring(0, inputName.indexOf('_'));
+ if (inputType.equalsIgnoreCase(COMPUTE.getDisplayName())) {
+ inputCompositionEntity = COMPUTE;
+ } else if (inputType.equalsIgnoreCase(UnifiedCompositionEntity.PORT.getDisplayName())) {
+ inputCompositionEntity = UnifiedCompositionEntity.PORT;
+ } else if (inputType.equalsIgnoreCase(UnifiedCompositionEntity.SUB_INTERFACE
+ .getDisplayName())) {
+ inputCompositionEntity = UnifiedCompositionEntity.SUB_INTERFACE;
+ }
}
return inputCompositionEntity;
}
private Optional<String> getPropertyNameFromInput(
- String inputName,
- UnifiedCompositionEntity compositionEntity,
- String computeType, String portInputPrefix) {
+ String inputName,
+ UnifiedCompositionEntity compositionEntity,
+ String entityType, String propertyInputPrefix) {
String propertyName = null;
switch (compositionEntity) {
- case Compute:
- propertyName = inputName.substring(inputName.lastIndexOf(computeType)
- + computeType.length() + 1);
+ case COMPUTE:
+ propertyName = inputName.substring(inputName.lastIndexOf(entityType)
+ + entityType.length() + 1);
break;
- case Port:
- if (inputName.startsWith(portInputPrefix)) {
- propertyName = inputName.split(portInputPrefix)[1];
+ case PORT:
+ case SUB_INTERFACE:
+ if (inputName.startsWith(propertyInputPrefix)) {
+ propertyName = inputName.split(propertyInputPrefix)[1];
}
break;
default:
return Optional.ofNullable(propertyName);
}
- private String getPortInputPrefix(
- String portNodeTemplateId,
- PortInputType portInputType) {
- String portInputPrefix = UnifiedCompositionEntity.Port.name().toLowerCase() + "_";
- String portType = ConsolidationDataUtil.getPortType(portNodeTemplateId);
- if (portInputType == PortInputType.NodeTemplateId) {
- portInputPrefix += portNodeTemplateId + "_";
- } else if (portInputType == PortInputType.PortType) {
- portInputPrefix += portType + "_";
+ private String getPropertyInputPrefix(String nodeTemplateId,
+ String propertyEntityType,
+ PropertyInputType propertyInputType,
+ UnifiedCompositionEntity unifiedCompositionEntity) {
+ String propertyInputPrefix = unifiedCompositionEntity.getDisplayName().toLowerCase() + "_";
+ if (propertyInputType == PropertyInputType.NODE_TEMPLATE_ID) {
+ propertyInputPrefix += nodeTemplateId + "_";
+ } else if (propertyInputType == PropertyInputType.TYPE) {
+ propertyInputPrefix += propertyEntityType + "_";
}
- return portInputPrefix;
+ return propertyInputPrefix;
}
private boolean isIdenticalValueProperty(String inputName,
- UnifiedCompositionEntity unifiedCompositionEntity,
- TranslationContext context) {
+ UnifiedCompositionEntity unifiedCompositionEntity) {
List<String> identicalValuePropertyList =
- consolidationService.getPropertiesWithIdenticalVal(unifiedCompositionEntity, context);
+ consolidationService.getPropertiesWithIdenticalVal(unifiedCompositionEntity);
StringBuilder builder = getPropertyValueStringBuilder(unifiedCompositionEntity);
+ if (Objects.isNull(builder)) {
+ return false;
+ }
boolean isMatchingProperty = Pattern.matches(builder.toString(), inputName);
- return (isMatchingProperty
- && isPropertyFromIdenticalValuesList(inputName, unifiedCompositionEntity,
- identicalValuePropertyList));
+ return isMatchingProperty
+ && isPropertyFromIdenticalValuesList(inputName, unifiedCompositionEntity,
+ identicalValuePropertyList);
}
private boolean isPropertyFromIdenticalValuesList(String inputName,
UnifiedCompositionEntity unifiedCompositionEntity,
List<String> identicalValuePropertyList) {
switch (unifiedCompositionEntity) {
- case Compute:
+ case COMPUTE:
return identicalValuePropertyList.contains(getIdenticalValuePropertyName(inputName,
- unifiedCompositionEntity, null).get());
+ unifiedCompositionEntity).get());
- case Other:
+ case OTHER:
return identicalValuePropertyList.contains(getIdenticalValuePropertyName(inputName,
- unifiedCompositionEntity, null).get());
+ unifiedCompositionEntity).get());
- case Port:
+ case PORT:
return getPortPropertyNameFromInput(inputName, identicalValuePropertyList).isPresent();
default:
}
private StringBuilder getPropertyValueStringBuilder(
- UnifiedCompositionEntity unifiedCompositionEntity) {
+ UnifiedCompositionEntity unifiedCompositionEntity) {
switch (unifiedCompositionEntity) {
- case Compute:
+ case COMPUTE:
return getComputePropertyValueStringBuilder();
- case Other:
+ case OTHER:
return getComputePropertyValueStringBuilder();
- case Port:
+ case PORT:
return getPortPropertyValueStringBuilder();
+ case SUB_INTERFACE:
+ return getSubInterfacePropertyValueStringBuilder();
+
default:
return null;
}
return builder;
}
+ private StringBuilder getSubInterfacePropertyValueStringBuilder() {
+ StringBuilder builder;
+ builder = new StringBuilder(SUB_INTERFACE_PROPERTY_VALUE_PREFIX);
+ builder.append(".+");
+ return builder;
+ }
+
private Optional<String> getIdenticalValuePropertyName(String input,
- UnifiedCompositionEntity unifiedCompositionEntity,
- TranslationContext context) {
+ UnifiedCompositionEntity
+ unifiedCompositionEntity) {
switch (unifiedCompositionEntity) {
- case Compute:
+ case COMPUTE:
return Optional.of(input.split("_")[1]);
- case Other:
+ case OTHER:
return Optional.of(input.split("_")[1]);
- case Port:
+ case PORT:
return getPortPropertyNameFromInput(input, consolidationService
- .getPropertiesWithIdenticalVal(unifiedCompositionEntity, context));
+ .getPropertiesWithIdenticalVal(unifiedCompositionEntity));
default:
return Optional.empty();
}
private Map<String, UnifiedCompositionEntity> getAllConsolidationNodeTemplateIdAndType(
- List<UnifiedCompositionData> unifiedCompositionDataList) {
+ List<UnifiedCompositionData> unifiedCompositionDataList) {
Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType = new HashMap<>();
for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
ComputeTemplateConsolidationData computeTemplateConsolidationData =
- unifiedCompositionData.getComputeTemplateConsolidationData();
+ unifiedCompositionData.getComputeTemplateConsolidationData();
if (Objects.nonNull(computeTemplateConsolidationData)) {
consolidationNodeTemplateIdAndType
- .put(computeTemplateConsolidationData.getNodeTemplateId(),
- UnifiedCompositionEntity.Compute);
+ .put(computeTemplateConsolidationData.getNodeTemplateId(),
+ COMPUTE);
+ }
+ List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
+ getSubInterfaceTemplateConsolidationDataList(unifiedCompositionData);
+ for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
+ subInterfaceTemplateConsolidationDataList) {
+ consolidationNodeTemplateIdAndType.put(subInterfaceTemplateConsolidationData.getNodeTemplateId(),
+ UnifiedCompositionEntity.SUB_INTERFACE);
}
List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
- getPortTemplateConsolidationDataList(unifiedCompositionData);
+ getPortTemplateConsolidationDataList(unifiedCompositionData);
for (PortTemplateConsolidationData portTemplateConsolidationData :
- portTemplateConsolidationDataList) {
+ portTemplateConsolidationDataList) {
consolidationNodeTemplateIdAndType.put(portTemplateConsolidationData.getNodeTemplateId(),
- UnifiedCompositionEntity.Port);
+ UnifiedCompositionEntity.PORT);
}
NestedTemplateConsolidationData nestedTemplateConsolidationData =
- unifiedCompositionData.getNestedTemplateConsolidationData();
+ unifiedCompositionData.getNestedTemplateConsolidationData();
if (Objects.nonNull(nestedTemplateConsolidationData)) {
consolidationNodeTemplateIdAndType
- .put(nestedTemplateConsolidationData.getNodeTemplateId(),
- UnifiedCompositionEntity.Nested);
+ .put(nestedTemplateConsolidationData.getNodeTemplateId(),
+ UnifiedCompositionEntity.NESTED);
}
}
return consolidationNodeTemplateIdAndType;
}
private List<PortTemplateConsolidationData> getPortTemplateConsolidationDataList(
- UnifiedCompositionData unifiedCompositionData) {
+ UnifiedCompositionData unifiedCompositionData) {
return unifiedCompositionData.getPortTemplateConsolidationDataList() == null ? new
- ArrayList<>() : unifiedCompositionData.getPortTemplateConsolidationDataList();
+ ArrayList<>() : unifiedCompositionData.getPortTemplateConsolidationDataList();
}
- private enum PortInputType {
- NodeTemplateId,
- PortType,
- Other;
+ private enum PropertyInputType {
+ NODE_TEMPLATE_ID,
+ TYPE,
+ OTHER
}
}
Code Review / sdc.git / blobdiff