diff options
Diffstat (limited to 'openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main')
3 files changed, 344 insertions, 89 deletions
diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationService.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationService.java index 607dc36c4b..9566e222ff 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationService.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationService.java @@ -11,6 +11,7 @@ import org.openecomp.sdc.tosca.services.ToscaConstants; import org.openecomp.sdc.tosca.services.ToscaUtil; import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext; import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionData; +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.consolidation.ComputeTemplateConsolidationData; import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ConsolidationData; @@ -72,7 +73,7 @@ public class ConsolidationService { if (preConditionResult) { boolean consolidationRuleCheckResult = checkConsolidationRules(serviceTemplate, typeComputeConsolidationData, - consolidationData); + consolidationData, translationContext); unifiedCompositionService.createUnifiedComposition( serviceTemplate, null, unifiedCompositionDataList, @@ -123,9 +124,11 @@ public class ConsolidationService { private boolean checkConsolidationRules(ServiceTemplate serviceTemplate, TypeComputeConsolidationData typeComputeConsolidationData, - ConsolidationData consolidationData) { + ConsolidationData consolidationData, + TranslationContext context) { return checkComputeConsolidation(serviceTemplate, typeComputeConsolidationData) - && checkPortConsolidation(serviceTemplate, typeComputeConsolidationData, consolidationData) + && checkPortConsolidation(serviceTemplate, typeComputeConsolidationData, + consolidationData, context) && !checkGetAttrBetweenEntityConsolidationOfTheSameType(serviceTemplate, typeComputeConsolidationData, consolidationData); } @@ -443,7 +446,7 @@ public class ConsolidationService { TypeComputeConsolidationData typeComputeConsolidationData) { List<String> computeNodeTemplateIds = new ArrayList(typeComputeConsolidationData.getAllComputeNodeTemplateIds()); - List<String> propertiesWithIdenticalVal = getPropertiesWithIdenticalVal(); + List<String> propertiesWithIdenticalVal = getComputePropertiesWithIdenticalVal(); return arePropertiesSimilarBetweenComputeNodeTemplates( serviceTemplate, computeNodeTemplateIds, propertiesWithIdenticalVal) @@ -534,25 +537,27 @@ public class ConsolidationService { private boolean checkPortConsolidation(ServiceTemplate serviceTemplate, TypeComputeConsolidationData typeComputeConsolidationData, - ConsolidationData consolidationData) { + ConsolidationData consolidationData, + TranslationContext context) { return isWantedPortPropertiesUsageIsSimilarInAllPorts(serviceTemplate, - typeComputeConsolidationData) + typeComputeConsolidationData, context) && checkPortRelations(ToscaUtil.getServiceTemplateFileName(serviceTemplate), typeComputeConsolidationData, consolidationData); } private boolean isWantedPortPropertiesUsageIsSimilarInAllPorts(ServiceTemplate serviceTemplate, - TypeComputeConsolidationData typeComputeConsolidationData) { + TypeComputeConsolidationData typeComputeConsolidationData, + TranslationContext context) { Collection<ComputeTemplateConsolidationData> computeTemplateConsolidationDataCollection = typeComputeConsolidationData.getAllComputeTemplateConsolidationData(); - List<String> propertiesThatNeedHaveUsage = getPropertiesThatNeedHaveUsage(); + List<String> propertiesThatNeedHaveUsage = getPortPropertiesWithIdenticalVal(context); Map<String, Set<String>> portTypeToIds = UnifiedCompositionUtil .collectAllPortsFromEachTypesFromComputes(computeTemplateConsolidationDataCollection); for (Set<String> portsIds : portTypeToIds.values()) { - if (!areAllPortsFromSameTypeHaveTheSameUsageForProperties( + if (!areAllPortsFromSameTypeHaveIdenticalValForProperties( serviceTemplate, portsIds, propertiesThatNeedHaveUsage)) { return false; } @@ -603,7 +608,7 @@ public class ConsolidationService { return portTemplateConsolidationDataList; } - private boolean areAllPortsFromSameTypeHaveTheSameUsageForProperties( + private boolean areAllPortsFromSameTypeHaveIdenticalValForProperties( ServiceTemplate serviceTemplate, Set<String> portNodeTemplateIds, List<String> propertiesThatNeedToHaveUsage) { @@ -611,7 +616,7 @@ public class ConsolidationService { serviceTemplate.getTopology_template().getNode_templates(); for (String property : propertiesThatNeedToHaveUsage) { - if (!areAllPortsContainWantedProperty(property, portNodeTemplateIds, nodeTemplates)) { + if (!areAllPortsHaveIdenticalValForProperties(property, portNodeTemplateIds, nodeTemplates)) { return false; } } @@ -619,7 +624,7 @@ public class ConsolidationService { return true; } - private boolean areAllPortsContainWantedProperty( + private boolean areAllPortsHaveIdenticalValForProperties( String propertyToCheck, Set<String> portNodeTemplateIds, Map<String, NodeTemplate> nodeTemplates) { @@ -634,9 +639,6 @@ public class ConsolidationService { .build()); } - boolean startingUsageCondition = - startingPortNodeTemplate.getProperties().containsKey(propertyToCheck); - for (int i = 1; i < portNodeTemplateIdList.size(); i++) { NodeTemplate portNodeTemplate = nodeTemplates.get(portNodeTemplateIdList.get(i)); @@ -647,8 +649,7 @@ public class ConsolidationService { + "files").build()); } - Map<String, Object> properties = portNodeTemplate.getProperties(); - if (!(properties.containsKey(propertyToCheck) == startingUsageCondition)) { + if (!isPropertySimilarBetweenNodeTemplates(propertyToCheck, portNodeTemplateIdList, nodeTemplates)) { return false; } } @@ -666,7 +667,7 @@ public class ConsolidationService { serviceTemplate.getTopology_template().getNode_templates(); for (String property : propertiesThatNeedToBeSimilar) { - if (!isPropertySimilarBetweenComputeNodeTemplates(property, computeNodeTemplateIds, + if (!isPropertySimilarBetweenNodeTemplates(property, computeNodeTemplateIds, idToNodeTemplate)) { return false; } @@ -674,17 +675,28 @@ public class ConsolidationService { return true; } - private boolean isPropertySimilarBetweenComputeNodeTemplates( + private boolean isPropertySimilarBetweenNodeTemplates( String propertyToCheck, - List<String> computeNodeTemplateIds, + List<String> entityNodeTemplateIds, Map<String, NodeTemplate> idToNodeTemplate) { + + NodeTemplate startingNodeTemplate = idToNodeTemplate.get(entityNodeTemplateIds.get(0)); + boolean propertyExistCondition = + isPropertyExistInNodeTemplate(propertyToCheck, startingNodeTemplate); + Set<Object> propertiesValues = new HashSet<>(); - for (String computeNodeId : computeNodeTemplateIds) { - NodeTemplate currentNodeTemplate = idToNodeTemplate.get(computeNodeId); + propertiesValues + .add(startingNodeTemplate.getProperties().get(propertyToCheck)); + + for (int i = 1; i < entityNodeTemplateIds.size(); i++) { + NodeTemplate currentNodeTemplate = idToNodeTemplate.get(entityNodeTemplateIds.get(i)); if (Objects.isNull(currentNodeTemplate)) { throw new CoreException((new ErrorCode.ErrorCodeBuilder()) .withMessage("Resource with id " - + computeNodeId + " occures more than once in different addOn files").build()); + + entityNodeTemplateIds.get(i) + " occures more than once in different addOn files").build()); + } + if(propertyExistCondition != isPropertyExistInNodeTemplate(propertyToCheck, currentNodeTemplate)){ + return false; } propertiesValues .add(currentNodeTemplate.getProperties().get(propertyToCheck)); @@ -693,6 +705,10 @@ public class ConsolidationService { return propertiesValues.size() == 1; } + private boolean isPropertyExistInNodeTemplate(String propertyToCheck, NodeTemplate nodeTemplate){ + return !(nodeTemplate.getProperties() == null || nodeTemplate.getProperties().get(propertyToCheck) == null); + } + public void substitutionServiceTemplateConsolidation(String substituteNodeTemplateId, ServiceTemplate mainServiceTemplate, ServiceTemplate substitutionServiceTemplate, @@ -918,19 +934,38 @@ public class ConsolidationService { .getPorts().keySet(); } - List<String> getPropertiesWithIdenticalVal() { + public List<String> getPropertiesWithIdenticalVal(UnifiedCompositionEntity entity, + TranslationContext context){ + switch (entity){ + case Compute: + return getComputePropertiesWithIdenticalVal(); + + case Other: + return getComputePropertiesWithIdenticalVal(); + + case Port: + return getPortPropertiesWithIdenticalVal(context); + + default: + return new ArrayList<>(); + } + } + + private List<String> getComputePropertiesWithIdenticalVal() { List<String> propertyWithIdenticalValue = new ArrayList<>(); propertyWithIdenticalValue.add(ToscaConstants.COMPUTE_IMAGE); propertyWithIdenticalValue.add(ToscaConstants.COMPUTE_FLAVOR); return propertyWithIdenticalValue; } - private List<String> getPropertiesThatNeedHaveUsage() { + private List<String> getPortPropertiesWithIdenticalVal(TranslationContext context) { List<String> propertiesThatNeedToHaveUsage = new ArrayList<>(); propertiesThatNeedToHaveUsage.add(ToscaConstants.PORT_FIXED_IPS); propertiesThatNeedToHaveUsage.add(ToscaConstants.PORT_ALLOWED_ADDRESS_PAIRS); propertiesThatNeedToHaveUsage.add(ToscaConstants.MAC_ADDRESS); + propertiesThatNeedToHaveUsage.addAll(context.getEnrichPortResourceProperties()); + return propertiesThatNeedToHaveUsage; } } diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/Constants.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/Constants.java index e5d752798b..63990862ba 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/Constants.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/Constants.java @@ -64,8 +64,9 @@ public class Constants { public static final String SERVICE_INSTANCE_PORT_PREFIX = "port_"; public static final String SERVICE_INSTANCE_LINK_PREFIX = "link_"; //Unified model - public static final String IDENTICAL_VALUE_PROPERTY_PREFIX = "vm_"; - public static final String IDENTICAL_VALUE_PROPERTY_SUFFIX = "_name"; + public static final String COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX = "vm_"; + public static final String COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX = "_name"; + public static final String PORT_IDENTICAL_VALUE_PROPERTY_PREFIX = "port_"; public static final String ABSTRACT_NODE_TEMPLATE_ID_PREFIX = "abstract_"; private Constants() { diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/UnifiedCompositionService.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/UnifiedCompositionService.java index 336d56a77f..6523a92a6c 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/UnifiedCompositionService.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/UnifiedCompositionService.java @@ -93,8 +93,9 @@ import java.util.Set; import java.util.regex.Pattern; import static org.openecomp.sdc.translator.services.heattotosca.Constants.ABSTRACT_NODE_TEMPLATE_ID_PREFIX; -import static org.openecomp.sdc.translator.services.heattotosca.Constants.IDENTICAL_VALUE_PROPERTY_PREFIX; -import static org.openecomp.sdc.translator.services.heattotosca.Constants.IDENTICAL_VALUE_PROPERTY_SUFFIX; +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; public class UnifiedCompositionService { @@ -229,7 +230,7 @@ public class UnifiedCompositionService { substitutionNodeTemplate.setType(substituteNodeTemplateType); Optional<Map<String, Object>> abstractSubstitutionProperties = createAbstractSubstitutionProperties(serviceTemplate, - substitutionServiceTemplate, unifiedCompositionDataList); + substitutionServiceTemplate, unifiedCompositionDataList, context); abstractSubstitutionProperties.ifPresent(substitutionNodeTemplate::setProperties); //Add substitution filtering property @@ -1527,9 +1528,10 @@ public class UnifiedCompositionService { portTemplateConsolidationData.getNodeTemplateId(), serviceTemplate, context).clone(); removeConnectivityOut(portTemplateConsolidationData, newPortNodeTemplate); - handleProperties(serviceTemplate, newPortNodeTemplate, substitutionServiceTemplate, - UnifiedCompositionEntity.Port, portTemplateConsolidationDataList, - computeTemplateConsolidationData, unifiedCompositionDataList, context); + handleProperties(serviceTemplate, newPortNodeTemplate, + substitutionServiceTemplate, UnifiedCompositionEntity.Port, + portTemplateConsolidationDataList, computeTemplateConsolidationData, + unifiedCompositionDataList, context); String newPortNodeTemplateId = getNewPortNodeTemplateId(portTemplateConsolidationData @@ -1604,9 +1606,10 @@ public class UnifiedCompositionService { List<EntityConsolidationData> computeConsoliadtionDataList = getComputeConsolidationDataList(unifiedCompositionDataList); - handleProperties(serviceTemplate, newComputeNodeTemplate, substitutionServiceTemplate, - UnifiedCompositionEntity.Compute, computeConsoliadtionDataList, - computeTemplateConsolidationData, unifiedCompositionDataList, context); + handleProperties(serviceTemplate, newComputeNodeTemplate, + substitutionServiceTemplate, UnifiedCompositionEntity.Compute, + computeConsoliadtionDataList, computeTemplateConsolidationData, unifiedCompositionDataList, + context); String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate, computeTemplateConsolidationData.getNodeTemplateId()); @@ -1635,7 +1638,8 @@ public class UnifiedCompositionService { } - private void handleProperties(ServiceTemplate serviceTemplate, NodeTemplate nodeTemplate, + private void handleProperties(ServiceTemplate serviceTemplate, + NodeTemplate nodeTemplate, ServiceTemplate substitutionServiceTemplate, UnifiedCompositionEntity unifiedCompositionEntity, List<EntityConsolidationData> entityConsolidationDataList, @@ -1664,7 +1668,9 @@ public class UnifiedCompositionService { computeTemplateConsolidationData, List<UnifiedCompositionData> unifiedCompositionDataList, TranslationContext context) { - List<String> propertiesWithIdenticalVal = consolidationService.getPropertiesWithIdenticalVal(); + List<String> propertiesWithIdenticalVal = + consolidationService.getPropertiesWithIdenticalVal(unifiedCompositionEntity, context); + for (EntityConsolidationData entityConsolidationData : entityConsolidationDataList) { String nodeTemplateId = entityConsolidationData.getNodeTemplateId(); Map<String, Object> properties = @@ -1674,9 +1680,22 @@ public class UnifiedCompositionService { } for (Map.Entry<String, Object> propertyEntry : properties.entrySet()) { + NodeType nodeTypeWithFlatHierarchy = + HeatToToscaUtil.getNodeTypeWithFlatHierarchy(nodeTemplate.getType(), serviceTemplate, + context); + PropertyDefinition propertyDefinition = + nodeTypeWithFlatHierarchy.getProperties().get(propertyEntry.getKey()); + String propertyType = propertyDefinition.getType(); + if (propertiesWithIdenticalVal.contains(propertyEntry.getKey())) { - String parameterId = updateIdenticalProperty(nodeTemplate, propertyEntry.getKey()); - addInputParameter(parameterId, PropertyType.STRING.getDisplayName(), null, + String parameterId = + updateIdenticalProperty(nodeTemplateId, propertyEntry.getKey(), nodeTemplate, + unifiedCompositionEntity, unifiedCompositionDataList); + + addInputParameter( + parameterId, propertyType, + propertyType.equals(PropertyType.LIST.getDisplayName()) ? propertyDefinition + .getEntry_schema() : null, substitutionServiceTemplate); } else { Optional<String> parameterId = @@ -1685,12 +1704,6 @@ public class UnifiedCompositionService { unifiedCompositionDataList, context); //todo - define list of type which will match the node property type (instead of string) - NodeType nodeTypeWithFlatHierarchy = - HeatToToscaUtil.getNodeTypeWithFlatHierarchy(nodeTemplate.getType(), serviceTemplate, - context); - String propertyType = - nodeTypeWithFlatHierarchy.getProperties().get(propertyEntry.getKey()) - .getType(); addPropertyInputParameter(propertyType, substitutionServiceTemplate, parameterId); } } @@ -1830,16 +1843,61 @@ public class UnifiedCompositionService { (String) value)); } - private String updateIdenticalProperty(NodeTemplate nodeTemplate, String propertyId) { - Map<String, String> propertyVal = new HashMap<>(); - String inputParamId = IDENTICAL_VALUE_PROPERTY_PREFIX + propertyId - + IDENTICAL_VALUE_PROPERTY_SUFFIX; - propertyVal.put(ToscaFunctions.GET_INPUT.getDisplayName(), inputParamId); - nodeTemplate.getProperties().put(propertyId, propertyVal); + private String updateIdenticalProperty(String nodeTemplateId, String propertyId, + NodeTemplate nodeTemplate, + UnifiedCompositionEntity unifiedCompositionEntity, + List<UnifiedCompositionData> unifiedCompositionDataList) { + + String inputParamId; + Map<String, Object> propertyVal = new HashMap<>(); + + switch (unifiedCompositionEntity) { + case Compute: + inputParamId = COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX + propertyId + + COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX; + + propertyVal.put(ToscaFunctions.GET_INPUT.getDisplayName(), inputParamId); + nodeTemplate.getProperties().put(propertyId, propertyVal); + + return inputParamId; + + case Port: + String portType = ConsolidationDataUtil.getPortType(nodeTemplateId); + ComputeTemplateConsolidationData computeTemplateConsolidationData = + getConnectedComputeConsolidationData(unifiedCompositionDataList, nodeTemplateId); + inputParamId = getInputParamIdForPort(nodeTemplateId, propertyId, portType, + computeTemplateConsolidationData); + + propertyVal.put(ToscaFunctions.GET_INPUT.getDisplayName(), inputParamId); + nodeTemplate.getProperties().put(propertyId, propertyVal); + + return inputParamId; + + default: + return null; + } + } + + private String getInputParamIdForPort(String nodeTemplateId, String propertyId, String portType, + ComputeTemplateConsolidationData computeTemplateConsolidationData) { + String inputParamId; + if (Objects.isNull(computeTemplateConsolidationData) + || computeTemplateConsolidationData.getPorts().get(portType).size() > 1) { + inputParamId = + UnifiedCompositionEntity.Port.name().toLowerCase() + "_" + nodeTemplateId + "_" + + propertyId; + + } else { + inputParamId = + UnifiedCompositionEntity.Port.name().toLowerCase() + "_" + portType + "_" + + propertyId; + } return inputParamId; } - private void addInputParameter(String parameterId, String parameterType, EntrySchema entrySchema, + private void addInputParameter(String parameterId, + String parameterType, + EntrySchema entrySchema, ServiceTemplate serviceTemplate) { ParameterDefinition parameterDefinition = @@ -1948,7 +2006,7 @@ public class UnifiedCompositionService { return getNewComputeNodeTemplateId(serviceTemplate, nodeTemplateId); case Port: ComputeTemplateConsolidationData connectedComputeConsolidationData = - getConnectedComputeConsolidationData(serviceTemplate, + getConnectedComputeConsolidationData( unifiedCompositionDataList, nodeTemplateId); NodeTemplate connectedComputeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, @@ -1968,10 +2026,10 @@ public class UnifiedCompositionService { if (isIdIsOfExpectedType(origNodeTemplateId, UnifiedCompositionEntity.Port, serviceTemplateFileName, - consolidationData, context)) { + context)) { return handleIdOfPort(origNodeTemplateId, serviceTemplateFileName, consolidationData); } else if (isIdIsOfExpectedType(origNodeTemplateId, UnifiedCompositionEntity.Compute, - serviceTemplateFileName, consolidationData, context)) { + serviceTemplateFileName, context)) { NodeTemplate nodeTemplate = getComputeNodeTemplate(origNodeTemplateId, serviceTemplate, context); return getComputeTypeSuffix(nodeTemplate.getType()); @@ -1981,18 +2039,20 @@ public class UnifiedCompositionService { } private ComputeTemplateConsolidationData getConnectedComputeConsolidationData( - ServiceTemplate serviceTemplate, List<UnifiedCompositionData> unifiedCompositionDataList, String portNodeTemplateId) { for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) { Collection<List<String>> portsCollection = unifiedCompositionData.getComputeTemplateConsolidationData().getPorts().values(); for (List<String> portIdList : portsCollection) { - for (String portId : portIdList) { - if (portId.equals(portNodeTemplateId)) { - return unifiedCompositionData.getComputeTemplateConsolidationData(); - } + if (portIdList.contains(portNodeTemplateId)) { + return unifiedCompositionData.getComputeTemplateConsolidationData(); } +// for (String portId : portIdList) { +// if (portId.equals(portNodeTemplateId)) { +// return unifiedCompositionData.getComputeTemplateConsolidationData(); +// } +// } } } return null; @@ -2098,7 +2158,8 @@ public class UnifiedCompositionService { private Optional<Map<String, Object>> createAbstractSubstitutionProperties( ServiceTemplate serviceTemplate, ServiceTemplate substitutionServiceTemplate, - List<UnifiedCompositionData> unifiedCompositionDataList) { + List<UnifiedCompositionData> unifiedCompositionDataList, + TranslationContext context) { Map<String, Object> abstractSubstituteProperties = new LinkedHashMap<>(); Map<String, ParameterDefinition> substitutionTemplateInputs = DataModelUtil .getInputParameters(substitutionServiceTemplate); @@ -2114,20 +2175,27 @@ public class UnifiedCompositionService { String substitutionTemplateInputName = input.getKey(); ParameterDefinition inputParameterDefinition = input.getValue(); String inputType = inputParameterDefinition.getType(); + UnifiedCompositionEntity inputUnifiedCompositionEntity = + getInputCompositionEntity(substitutionTemplateInputName); + if (!inputType.equalsIgnoreCase(PropertyType.LIST.getDisplayName())) { - if (isIdenticalValueProperty(substitutionTemplateInputName)) { + if (isIdenticalValueProperty( + substitutionTemplateInputName, inputUnifiedCompositionEntity, context)) { //Handle identical value properties - Object abstractPropertyValue = getPropertyValueFromNodeTemplate( - getIdenticalValuePropertyName(substitutionTemplateInputName), - firstComputeNodeTemplate); - abstractSubstituteProperties.put(substitutionTemplateInputName, abstractPropertyValue); + Optional<String> identicalValuePropertyName = + getIdenticalValuePropertyName(substitutionTemplateInputName, + inputUnifiedCompositionEntity, context); + + if (identicalValuePropertyName.isPresent()) { + updateIdenticalPropertyValue(identicalValuePropertyName.get(), + substitutionTemplateInputName, computeType, inputUnifiedCompositionEntity, + unifiedCompositionDataList.get(0), serviceTemplate, abstractSubstituteProperties); + } } continue; } //Check if the input is of type compute or port - UnifiedCompositionEntity inputUnifiedCompositionEntity = getInputCompositionEntity( - substitutionTemplateInputName); List<Object> abstractPropertyValue = new ArrayList<>(); Object propertyValue = null; switch (inputUnifiedCompositionEntity) { @@ -2144,8 +2212,6 @@ public class UnifiedCompositionService { break; case Port: for (UnifiedCompositionData compositionData : unifiedCompositionDataList) { - ComputeTemplateConsolidationData computeTemplateConsolidationData = compositionData - .getComputeTemplateConsolidationData(); List<PortTemplateConsolidationData> portTemplateConsolidationDataList = getPortTemplateConsolidationDataList(compositionData); //Get the input type for this input whether it is of type @@ -2157,7 +2223,7 @@ public class UnifiedCompositionService { //Get the port property value String portNodeTemplateId = portTemplateConsolidationData.getNodeTemplateId(); propertyValue = getPortPropertyValue(substitutionTemplateInputName, - computeType, portInputType, serviceTemplate, computeTemplateConsolidationData, + computeType, portInputType, serviceTemplate, portNodeTemplateId); //If the value object is Optional.empty it implies that the property name was not // found in the input name @@ -2181,6 +2247,70 @@ public class UnifiedCompositionService { return Optional.ofNullable(abstractSubstituteProperties); } + private void updateIdenticalPropertyValue(String identicalValuePropertyName, + String substitutionTemplateInputName, + String computeType, + UnifiedCompositionEntity entity, + UnifiedCompositionData unifiedCompositionData, + ServiceTemplate serviceTemplate, + Map<String, Object> abstractSubstituteProperties){ + Optional<Object> identicalPropertyValueByType = + getIdenticalPropertyValueByType(identicalValuePropertyName, substitutionTemplateInputName, + computeType, entity, unifiedCompositionData, serviceTemplate); + + if(identicalPropertyValueByType.isPresent()){ + abstractSubstituteProperties + .put(substitutionTemplateInputName, identicalPropertyValueByType.get()); + + } + + + } + + private Optional<Object> getIdenticalPropertyValueByType(String identicalValuePropertyName, + String substitutionTemplateInputName, + String computeType, + UnifiedCompositionEntity entity, + UnifiedCompositionData unifiedCompositionData, + ServiceTemplate serviceTemplate) { + + ComputeTemplateConsolidationData computeTemplateConsolidationData = + unifiedCompositionData.getComputeTemplateConsolidationData(); + + Optional<Object> computeIdenticalPropertyValue; + switch (entity) { + case Compute: + computeIdenticalPropertyValue = + getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate, + entity, computeTemplateConsolidationData); + return computeIdenticalPropertyValue.isPresent() ? Optional.of( + computeIdenticalPropertyValue.get()) : Optional.empty(); + + case Other: + computeIdenticalPropertyValue = + getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate, + entity, computeTemplateConsolidationData); + 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); + } + } + } + + return Optional.empty(); + + } + + private PortInputType getPortInputType(String inputName, UnifiedCompositionData unifiedCompositionData) { String portInputPrefix = UnifiedCompositionEntity.Port.name().toLowerCase() + "_"; @@ -2291,7 +2421,6 @@ public class UnifiedCompositionService { String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate); Optional<String> nestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(serviceTemplateFileName, entity.getNodeTemplateId()); - if (nestedNodeTemplateId.isPresent()) { for (Map.Entry<String, GroupDefinition> groupEntry : groups.entrySet()) { GroupDefinition groupDefinition = groupEntry.getValue(); @@ -2514,7 +2643,6 @@ public class UnifiedCompositionService { private boolean isIdIsOfExpectedType(String id, UnifiedCompositionEntity expectedUnifiedCompositionEntity, String serviceTemplateFileName, - ConsolidationData consolidationData, TranslationContext context) { UnifiedSubstitutionData unifiedSubstitutionData = context.getUnifiedSubstitutionData().get(serviceTemplateFileName); @@ -2537,11 +2665,9 @@ public class UnifiedCompositionService { String computeType, PortInputType portInputType, ServiceTemplate serviceTemplate, - ComputeTemplateConsolidationData - computeTemplateConsolidationData, String portNodeTemplateId) { //Get the input prefix to extract the property name from the input name - String portInputPrefix = getPortInputPrefix(computeTemplateConsolidationData, + String portInputPrefix = getPortInputPrefix( portNodeTemplateId, portInputType); //Get the property name from the input Optional<String> propertyName = getPropertyNameFromInput(inputName, @@ -2593,6 +2719,20 @@ public class UnifiedCompositionService { return Optional.empty(); } + private Optional<Object> getIdenticalPropertyValue(String identicalValuePropertyName, + ServiceTemplate serviceTemplate, + UnifiedCompositionEntity unifiedCompositionEntity, + EntityConsolidationData entity){ + NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, + entity.getNodeTemplateId()); + + Object propertyValueFromNodeTemplate = + getPropertyValueFromNodeTemplate(identicalValuePropertyName, nodeTemplate); + + return Objects.isNull(propertyValueFromNodeTemplate) ? Optional.empty() + :Optional.of(propertyValueFromNodeTemplate); + } + private UnifiedCompositionEntity getInputCompositionEntity(String inputName) { UnifiedCompositionEntity inputCompositionEntity = UnifiedCompositionEntity.Other; String inputType = inputName.substring(0, inputName.indexOf('_')); @@ -2626,7 +2766,6 @@ public class UnifiedCompositionService { } private String getPortInputPrefix( - ComputeTemplateConsolidationData computeTemplateConsolidationData, String portNodeTemplateId, PortInputType portInputType) { String portInputPrefix = UnifiedCompositionEntity.Port.name().toLowerCase() + "_"; @@ -2639,21 +2778,101 @@ public class UnifiedCompositionService { return portInputPrefix; } - private boolean isIdenticalValueProperty(String inputName) { - StringBuilder builder = new StringBuilder(IDENTICAL_VALUE_PROPERTY_PREFIX); - builder.append("[a-z]+"); - builder.append(IDENTICAL_VALUE_PROPERTY_SUFFIX); + private boolean isIdenticalValueProperty(String inputName, + UnifiedCompositionEntity unifiedCompositionEntity, + TranslationContext context) { + + List<String> identicalValuePropertyList = + consolidationService.getPropertiesWithIdenticalVal(unifiedCompositionEntity, context); + + StringBuilder builder = getPropertyValueStringBuilder(unifiedCompositionEntity); + boolean isMatchingProperty = Pattern.matches(builder.toString(), inputName); - List<String> identicalValuePropertyList = consolidationService.getPropertiesWithIdenticalVal(); - if (isMatchingProperty - && identicalValuePropertyList.contains(getIdenticalValuePropertyName(inputName))) { - return true; + return (isMatchingProperty + && isPropertyFromIdenticalValuesList(inputName, unifiedCompositionEntity, + identicalValuePropertyList)); + } + + private boolean isPropertyFromIdenticalValuesList(String inputName, + UnifiedCompositionEntity unifiedCompositionEntity, + List<String> identicalValuePropertyList) { + switch (unifiedCompositionEntity) { + case Compute: + return identicalValuePropertyList.contains(getIdenticalValuePropertyName(inputName, + unifiedCompositionEntity, null).get()); + + case Other: + return identicalValuePropertyList.contains(getIdenticalValuePropertyName(inputName, + unifiedCompositionEntity, null).get()); + + case Port: + return getPortPropertyNameFromInput(inputName, identicalValuePropertyList).isPresent(); + + default: + return false; } - return false; } - private String getIdenticalValuePropertyName(String input) { - return input.split("_")[1]; + private Optional<String> getPortPropertyNameFromInput(String inputName, + List<String> identicalValuePropertyList) { + for (String identicalProperty : identicalValuePropertyList) { + if (inputName.contains(identicalProperty)) { + return Optional.of(identicalProperty); + } + } + return Optional.empty(); + } + + private StringBuilder getPropertyValueStringBuilder( + UnifiedCompositionEntity unifiedCompositionEntity) { + + switch (unifiedCompositionEntity) { + case Compute: + return getComputePropertyValueStringBuilder(); + + case Other: + return getComputePropertyValueStringBuilder(); + + case Port: + return getPortPropertyValueStringBuilder(); + + default: + return null; + } + } + + private StringBuilder getPortPropertyValueStringBuilder() { + StringBuilder builder; + builder = new StringBuilder(PORT_IDENTICAL_VALUE_PROPERTY_PREFIX); + builder.append(".+"); + return builder; + } + + private StringBuilder getComputePropertyValueStringBuilder() { + StringBuilder builder; + builder = new StringBuilder(COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX); + builder.append("[a-z]+"); + builder.append(COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX); + return builder; + } + + private Optional<String> getIdenticalValuePropertyName(String input, + UnifiedCompositionEntity unifiedCompositionEntity, + TranslationContext context) { + switch (unifiedCompositionEntity) { + case Compute: + return Optional.of(input.split("_")[1]); + + case Other: + return Optional.of(input.split("_")[1]); + + case Port: + return getPortPropertyNameFromInput(input, consolidationService + .getPropertiesWithIdenticalVal(unifiedCompositionEntity, context)); + + default: + return Optional.empty(); + } } private Object getPropertyValueFromNodeTemplate(String propertyName, NodeTemplate nodeTemplate) { |