From d299e8af2e9dfa79e53f7cf9e79977bab3474919 Mon Sep 17 00:00:00 2001 From: ojasdubey Date: Mon, 5 Feb 2018 19:48:23 +0530 Subject: VLAN tagging - Added Consolidation Rules 1. Added rules for subinterface consolidation 2. Added new data types for supporting subinterface consolidation 3. Added unit tests 4. Updated license text 5. Updated code based on review comments Change-Id: I7c0d7a4747029c15212c3474280dd8fc6d623ccc Issue-ID: SDC-998 Signed-off-by: ojasdubey Signed-off-by: vempo --- .../PortTemplateConsolidationData.java | 71 ++++- .../SubInterfaceTemplateConsolidationData.java | 51 ++++ .../services/heattotosca/ConsolidationService.java | 316 +++++++++++++++++---- 3 files changed, 360 insertions(+), 78 deletions(-) create mode 100644 openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/SubInterfaceTemplateConsolidationData.java (limited to 'openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp') diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/PortTemplateConsolidationData.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/PortTemplateConsolidationData.java index c9b59f99db..0eacd4de3c 100644 --- a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/PortTemplateConsolidationData.java +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/PortTemplateConsolidationData.java @@ -1,5 +1,24 @@ +/* + * 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. + */ + package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation; +import com.google.common.collect.ArrayListMultimap; +import com.google.common.collect.ListMultimap; +import com.google.common.collect.Multimaps; import java.util.List; @@ -8,23 +27,45 @@ import java.util.List; */ public class PortTemplateConsolidationData extends EntityConsolidationData { - private List subPortIds; //sub ports which point to this port + // key - subport type - for ResourceGroup it is the nested file name + // value - List of subports of that type in the port + private final ListMultimap subInterfaceConsolidationData = + Multimaps.synchronizedListMultimap(ArrayListMultimap.create()); + + public void addSubInterfaceConsolidationData(String subPortType, + SubInterfaceTemplateConsolidationData + subInterfaceTemplateConsolidationData) { + this.subInterfaceConsolidationData.put(subPortType, subInterfaceTemplateConsolidationData); + } + + public boolean hasSameSubInterfaceTypes(PortTemplateConsolidationData other) { + return other != null && this.subInterfaceConsolidationData.keySet().equals( + other.subInterfaceConsolidationData.keySet()); + } + + public void copyMappedInto(ListMultimap subInterfaceTypeToEntity) { + subInterfaceTypeToEntity.putAll(this.subInterfaceConsolidationData); + } + + public void copyFlatInto(List subInterfaceTemplateConsolidationDataList) { + subInterfaceTemplateConsolidationDataList.addAll(subInterfaceConsolidationData.values()); + } + + public boolean isNumberOfSubInterfacesPerTypeSimilar(PortTemplateConsolidationData other) { + + if (this.subInterfaceConsolidationData.isEmpty() && + other.subInterfaceConsolidationData.isEmpty()) { + return true; + } - /** - * Gets sub port ids. - * - * @return the sub port ids - */ - public List getSubPortIds() { - return subPortIds; + return !this.subInterfaceConsolidationData.isEmpty() + && !other.subInterfaceConsolidationData.isEmpty() + && this.subInterfaceConsolidationData.keySet().stream().allMatch(subInterfaceType -> + calculateSize(other.subInterfaceConsolidationData.get(subInterfaceType)) == + calculateSize(this.subInterfaceConsolidationData.get(subInterfaceType))); } - /** - * Sets sub port ids. - * - * @param subPortIds the sub port ids - */ - public void setSubPortIds(List subPortIds) { - this.subPortIds = subPortIds; + private int calculateSize(List subInterfaces) { + return subInterfaces == null ? 0 : subInterfaces.size(); } } \ No newline at end of file diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/SubInterfaceTemplateConsolidationData.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/SubInterfaceTemplateConsolidationData.java new file mode 100644 index 0000000000..9a6826d644 --- /dev/null +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/SubInterfaceTemplateConsolidationData.java @@ -0,0 +1,51 @@ +/* + * 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. + */ + +package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation; + +public class SubInterfaceTemplateConsolidationData extends EntityConsolidationData { + + //Value of the property count in the resource group representing the sub-interface + private Object resourceGroupCount; + //Network role of the sub-interface + private String networkRole; + //Parent port node template id + private String parentPortNodeTemplateId; + + public Object getResourceGroupCount() { + return resourceGroupCount; + } + + public void setResourceGroupCount(Object resourceGroupCount) { + this.resourceGroupCount = resourceGroupCount; + } + + public String getNetworkRole() { + return networkRole; + } + + public void setNetworkRole(String networkRole) { + this.networkRole = networkRole; + } + + public String getParentPortNodeTemplateId() { + return parentPortNodeTemplateId; + } + + public void setParentPortNodeTemplateId(String parentPortNodeTemplateId) { + this.parentPortNodeTemplateId = parentPortNodeTemplateId; + } +} 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 3fef3f91a1..bc5a3c7e3a 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 @@ -1,7 +1,26 @@ +/* + * 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. + */ + package org.openecomp.sdc.translator.services.heattotosca; +import com.google.common.collect.ArrayListMultimap; +import com.google.common.collect.ListMultimap; import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.collections4.MapUtils; +import org.apache.commons.lang3.StringUtils; import org.openecomp.sdc.common.errors.CoreException; import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate; import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate; @@ -21,6 +40,7 @@ import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolida 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 org.openecomp.sdc.translator.services.heattotosca.errors.DuplicateResourceIdsInDifferentFilesErrorBuilder; @@ -34,7 +54,9 @@ import java.util.List; import java.util.Map; import java.util.Objects; import java.util.Set; +import java.util.function.Function; import java.util.function.Predicate; +import java.util.stream.Collectors; public class ConsolidationService { @@ -165,7 +187,8 @@ public class ConsolidationService { consolidationData); if (!(checkGetAttrOutFromEntityToPortIsLegal(portTemplateConsolidationDataList, portTypeToIds) - && checkGetAttrOutFromPortToComputeIsLegal(portTemplateConsolidationDataList, + && checkGetAttrOutFromConsolidationEntityToEntityNotFromSameTypeIsLegal( + portTemplateConsolidationDataList, computeNodeTemplateIds))) { return false; } @@ -178,6 +201,9 @@ public class ConsolidationService { Map> portTypeToIds) { for (String portType : portTypeToIds.keySet()) { + if (CollectionUtils.isEmpty(entities)) { + continue; + } Set startingGetAttrFunc = getEntityGetAttrFuncAsSet(portType, (EntityConsolidationData) entities.iterator().next()); @@ -194,24 +220,27 @@ public class ConsolidationService { return true; } - private boolean checkGetAttrOutFromPortToComputeIsLegal( - List portTemplateConsolidationDataList, - Collection computeNodeTemplateIds) { - PortTemplateConsolidationData startingPortTemplate = - portTemplateConsolidationDataList.get(0); - Map> startingComputeGetAttrOutFuncData = - getComputeGetAttrOutFuncData(startingPortTemplate.getNodesGetAttrOut(), - computeNodeTemplateIds); - - for (int i = 1; i < portTemplateConsolidationDataList.size(); i++) { - PortTemplateConsolidationData currentPortTemplate = - portTemplateConsolidationDataList.get(i); - Map> currentComputeGetAttrOutFuncData = - getComputeGetAttrOutFuncData(currentPortTemplate.getNodesGetAttrOut(), - computeNodeTemplateIds); - - if (!isGetAttrRelationToComputeSimilarBetweenEntities(startingComputeGetAttrOutFuncData, - currentComputeGetAttrOutFuncData)) { + private boolean checkGetAttrOutFromConsolidationEntityToEntityNotFromSameTypeIsLegal( + List entityConsolidationDataList, + Collection consolidationEntityNodeTemplateIds) { + if (CollectionUtils.isEmpty(entityConsolidationDataList)) { + return true; + } + EntityConsolidationData startingEntityTemplate = + (EntityConsolidationData) entityConsolidationDataList.get(0); + Map> startingGetAttrOutFuncData = + getConsolidationEntityGetAttrOutFuncData(startingEntityTemplate.getNodesGetAttrOut(), + consolidationEntityNodeTemplateIds); + + for (int i = 1; i < entityConsolidationDataList.size(); i++) { + EntityConsolidationData currentEntityTemplate = + (EntityConsolidationData) entityConsolidationDataList.get(i); + Map> currentGetAttrOutFuncData = + getConsolidationEntityGetAttrOutFuncData(currentEntityTemplate.getNodesGetAttrOut(), + consolidationEntityNodeTemplateIds); + + if (!isGetAttrRelationToEntitySimilarBetweenEntities(startingGetAttrOutFuncData, + currentGetAttrOutFuncData)) { return false; } } @@ -219,7 +248,7 @@ public class ConsolidationService { return true; } - private boolean isGetAttrRelationToComputeSimilarBetweenEntities( + private boolean isGetAttrRelationToEntitySimilarBetweenEntities( Map> firstMap, Map> secondMap) { if (MapUtils.isEmpty(firstMap) != MapUtils.isEmpty(secondMap)) { @@ -231,6 +260,90 @@ public class ConsolidationService { } + private boolean checkSubInterfaceConsolidationPreCondition(ServiceTemplate serviceTemplate, + ConsolidationData consolidationData, + TypeComputeConsolidationData typeComputeConsolidationData) { + FilePortConsolidationData filePortConsolidationData = + consolidationData.getPortConsolidationData() + .getFilePortConsolidationData(ToscaUtil.getServiceTemplateFileName(serviceTemplate)); + + if (Objects.isNull(filePortConsolidationData)) { + return true; + } + + Map> portTypeToPortIds = UnifiedCompositionUtil + .collectAllPortsFromEachTypesFromComputes( + typeComputeConsolidationData.getAllComputeTemplateConsolidationData()); + + Collection computeNodeTemplateIds = + typeComputeConsolidationData.getAllComputeNodeTemplateIds(); + + for (List portIdsFromSameType : portTypeToPortIds.values()) { + List portTemplateConsolidationDataList = + getAllPortTemplateConsolidationData(portIdsFromSameType, filePortConsolidationData); + + if (!areSubInterfacePreConditionRulesValid(portTypeToPortIds, computeNodeTemplateIds, + portTemplateConsolidationDataList, portTemplateConsolidationDataList.get(0))) { + return false; + } + } + return true; + } + + private boolean areSubInterfacePreConditionRulesValid(Map> portTypeToPortIds, + Collection computeNodeTemplateIds, + List portTemplateConsolidationDataList, + PortTemplateConsolidationData subInterfaceConsolidationData) { + return areSubInterfaceTypesSimilarBetweenPorts(portTemplateConsolidationDataList, + subInterfaceConsolidationData) + && isNumberOfSubInterfacesPerTypeSimilar(portTemplateConsolidationDataList, + subInterfaceConsolidationData) + && isGetAttrFromSubInterfaceToOtherEntitiesLegal(computeNodeTemplateIds, + portTypeToPortIds, portTemplateConsolidationDataList); + } + + private boolean isGetAttrFromSubInterfaceToOtherEntitiesLegal( + Collection computeNodeTemplateIds, + Map> portTypeToPortIds, + List portTemplateConsolidationDataList) { + + ListMultimap subInterfacesFromSameTypeFromPorts = + collectAllSubInterfacesFromSameTypeFromPorts(portTemplateConsolidationDataList); + + List subInterfaceList = new ArrayList<>(subInterfacesFromSameTypeFromPorts + .values()); + return areGetAttrRelationshipsBetweenSubInterfaceToConsolidationEntitiesValid( + computeNodeTemplateIds, portTypeToPortIds, portTemplateConsolidationDataList, subInterfaceList); + } + + private boolean areGetAttrRelationshipsBetweenSubInterfaceToConsolidationEntitiesValid( + Collection computeNodeTemplateIds, Map> portTypeToPortIds, + List portTemplateConsolidationDataList, + List subInterfaceList) { + return checkGetAttrOutFromEntityToPortIsLegal(subInterfaceList, portTypeToPortIds) + && checkGetAttrOutFromConsolidationEntityToEntityNotFromSameTypeIsLegal( + portTemplateConsolidationDataList, getSubInterfaceIdsFromSameType(subInterfaceList)) + && checkGetAttrOutFromConsolidationEntityToEntityNotFromSameTypeIsLegal( + subInterfaceList, computeNodeTemplateIds); + } + + private boolean areSubInterfaceTypesSimilarBetweenPorts( + List portTemplateConsolidationDataList, + PortTemplateConsolidationData subInterfaceConsolidationData) { + + return portTemplateConsolidationDataList.stream().allMatch( + element -> element.hasSameSubInterfaceTypes(subInterfaceConsolidationData)); + } + + private boolean isNumberOfSubInterfacesPerTypeSimilar( + List portTemplateConsolidationDataList, + PortTemplateConsolidationData subInterfaceConsolidationData) { + + return portTemplateConsolidationDataList.stream() + .allMatch(element -> element.isNumberOfSubInterfacesPerTypeSimilar(subInterfaceConsolidationData)); + } + + private Set getEntityGetAttrFuncAsSet( String portType, EntityConsolidationData entityConsolidationData) { @@ -252,7 +365,7 @@ public class ConsolidationService { return getAttrFuncDataFromPortsWithSameType; } - private Map> getComputeGetAttrOutFuncData( + private Map> getConsolidationEntityGetAttrOutFuncData( Map> nodesGetAttrOut, Collection computeNodeTemplateIds) { Map> computeGetAttrFuncData = new HashMap<>(); @@ -275,13 +388,13 @@ public class ConsolidationService { ServiceTemplate serviceTemplate, TypeComputeConsolidationData typeComputeConsolidationData, ConsolidationData consolidationData) { - return checkGetAttrRelationsBetweenComputesOfSameType(typeComputeConsolidationData) - || checkGetAttrRelationsBetweenPortsOfTheSameType(serviceTemplate, + return areThereGetAttrRelationsBetweenComputesOfSameType(typeComputeConsolidationData) + || areThereGetAttrRelationsBetweenPortsOfTheSameType(serviceTemplate, typeComputeConsolidationData, consolidationData); } - private boolean checkGetAttrRelationsBetweenComputesOfSameType( + private boolean areThereGetAttrRelationsBetweenComputesOfSameType( TypeComputeConsolidationData typeComputeConsolidationData) { Collection computeTemplateConsolidationEntities = @@ -290,10 +403,11 @@ public class ConsolidationService { typeComputeConsolidationData.getAllComputeNodeTemplateIds(); return checkGetAttrRelationsForEntityConsolidationData( - computeTemplateConsolidationEntities, computeNodeTemplateIds); + computeTemplateConsolidationEntities, computeNodeTemplateIds, + EntityConsolidationData::getNodesGetAttrIn); } - private boolean checkGetAttrRelationsBetweenPortsOfTheSameType( + private boolean areThereGetAttrRelationsBetweenPortsOfTheSameType( ServiceTemplate serviceTemplate, TypeComputeConsolidationData typeComputeConsolidationData, ConsolidationData consolidationData) { @@ -311,7 +425,7 @@ public class ConsolidationService { List portTemplateConsolidationDataOfSameType = getAllPortTemplateConsolidationData(portsOfTheSameTypeIds, filePortConsolidationData); if (!checkGetAttrRelationsForEntityConsolidationData(portTemplateConsolidationDataOfSameType, - portsOfTheSameTypeIds)) { + portsOfTheSameTypeIds, EntityConsolidationData::getNodesGetAttrIn)) { return false; } } @@ -319,6 +433,17 @@ public class ConsolidationService { return true; } + private boolean areThereGetAttrRelationsBetweenSubInterfacesOfSameType( + List subInterfacesIdsFromSameType, + List subInterfaceList) { + + return checkGetAttrRelationsForEntityConsolidationData(subInterfaceList, + subInterfacesIdsFromSameType, EntityConsolidationData::getNodesGetAttrIn) + || checkGetAttrRelationsForEntityConsolidationData(subInterfaceList, + subInterfacesIdsFromSameType, EntityConsolidationData::getNodesGetAttrOut); + + } + private List getAllPortTemplateConsolidationData( List portsIds, FilePortConsolidationData filePortConsolidationData) { @@ -335,21 +460,19 @@ public class ConsolidationService { return portTemplateConsolidationDataOfSameType; } - private boolean checkGetAttrRelationsForEntityConsolidationData( - Collection entities, - Collection nodeTemplateIdsOfTheSameType) { + private boolean checkGetAttrRelationsForEntityConsolidationData(Collection entities, + Collection nodeTemplateIdsOfTheSameType, + Function>> getAttrValuesMethod) { for (Object entity : entities) { - EntityConsolidationData currentEntity = (EntityConsolidationData) entity; - Set getAttrInNodeIds = - currentEntity.getNodesGetAttrIn() == null ? new HashSet<>() - : currentEntity.getNodesGetAttrIn().keySet(); - for (String nodeId : getAttrInNodeIds) { - if (nodeTemplateIdsOfTheSameType.contains(nodeId)) { - return true; - } + Map> getAttrValue = + getAttrValuesMethod.apply((EntityConsolidationData) entity); + Set getAttrNodeIds = + getAttrValue == null ? new HashSet<>() + : getAttrValue.keySet(); + if (getAttrNodeIds.stream().anyMatch(nodeTemplateIdsOfTheSameType::contains)) { + return true; } } - return false; } @@ -404,22 +527,20 @@ public class ConsolidationService { private boolean compareNodeConnectivity( Map> firstEntityMap, Map> secondEntityMap) { + if (MapUtils.isEmpty(firstEntityMap) && MapUtils.isEmpty(secondEntityMap)) { return true; } - if (!MapUtils.isEmpty(firstEntityMap) - && !MapUtils.isEmpty(secondEntityMap)) { - return firstEntityMap.keySet().equals(secondEntityMap.keySet()); - } - return false; + return !MapUtils.isEmpty(firstEntityMap) && !MapUtils.isEmpty(secondEntityMap) + && firstEntityMap.keySet().equals(secondEntityMap.keySet()); } private boolean checkGroupIdsRelations(EntityConsolidationData startingEntity, EntityConsolidationData currentEntity) { - return CollectionUtils.isEmpty(startingEntity.getGroupIds()) && - CollectionUtils.isEmpty(currentEntity.getGroupIds()) || - startingEntity.getGroupIds().equals(currentEntity.getGroupIds()); + return CollectionUtils.isEmpty(startingEntity.getGroupIds()) + && CollectionUtils.isEmpty(currentEntity.getGroupIds()) + || startingEntity.getGroupIds().equals(currentEntity.getGroupIds()); } @@ -507,7 +628,8 @@ public class ConsolidationService { collectAllPortsTemplateConsolidationData( portIds, serviceTemplateName, consolidationData); - if (!checkEntityConsolidationDataRelations(portTemplateConsolidationDataList)) { + if (!checkEntityConsolidationDataRelations(portTemplateConsolidationDataList) + || !checkSubInterfaceRules(portTemplateConsolidationDataList)) { return false; } } @@ -515,10 +637,68 @@ public class ConsolidationService { return true; } - private List - collectAllPortsTemplateConsolidationData(List portIds, - String serviceTemplateName, - ConsolidationData consolidationData) { + private boolean checkSubInterfaceRules(List + portTemplateConsolidationDataList) { + ListMultimap subInterfaceTypeToEntity = + collectAllSubInterfacesFromSameTypeFromPorts(portTemplateConsolidationDataList); + List subInterfaceList = new ArrayList<>(subInterfaceTypeToEntity.values()); + return areSubInterfacePropertiesAndRelationsValid(subInterfaceList); + } + + private boolean areSubInterfacePropertiesAndRelationsValid( + List subInterfaceList) { + return isResourceGroupPropertiesSimilarBetweenSubPorts(subInterfaceList) + && checkSubInterfaceRelations(subInterfaceList) + && !areThereGetAttrRelationsBetweenSubInterfacesOfSameType( + getSubInterfaceIdsFromSameType(subInterfaceList), subInterfaceList); + } + + private boolean checkSubInterfaceRelations(List + subInterfaceList) { + return CollectionUtils.isEmpty(subInterfaceList) + || checkEntityConsolidationDataRelations(subInterfaceList); + } + + private boolean isResourceGroupPropertiesSimilarBetweenSubPorts( + List subInterfaceList) { + if (CollectionUtils.isEmpty(subInterfaceList)) { + return true; + } + + SubInterfaceTemplateConsolidationData startingSubInterface = subInterfaceList.get(0); + for (SubInterfaceTemplateConsolidationData subInterface : subInterfaceList) { + if (!startingSubInterface.getResourceGroupCount().equals(subInterface.getResourceGroupCount()) + || !StringUtils.equals(startingSubInterface.getNetworkRole(), subInterface.getNetworkRole())) { + return false; + } + } + + return true; + } + + private List getSubInterfaceIdsFromSameType(List + subInterfaceList) { + if (CollectionUtils.isEmpty(subInterfaceList)) { + return new ArrayList<>(); + } + + return subInterfaceList.stream().map(SubInterfaceTemplateConsolidationData::getNodeTemplateId) + .collect(Collectors.toList()); + } + + private ListMultimap collectAllSubInterfacesFromSameTypeFromPorts( + List portTemplateConsolidationDataList) { + ListMultimap subInterfaceTypeToEntity = ArrayListMultimap.create(); + for (PortTemplateConsolidationData portTemplateConsolidationData : portTemplateConsolidationDataList) { + portTemplateConsolidationData.copyMappedInto(subInterfaceTypeToEntity); + } + + return subInterfaceTypeToEntity; + } + + private List collectAllPortsTemplateConsolidationData(List portIds, + String serviceTemplateName, + ConsolidationData consolidationData) { FilePortConsolidationData filePortConsolidationData = consolidationData.getPortConsolidationData() @@ -580,8 +760,7 @@ public class ConsolidationService { new DuplicateResourceIdsInDifferentFilesErrorBuilder(entityNodeTemplateIds.get(i)) .build()); } - if (propertyExistCondition != - isPropertyExistInNodeTemplate(propertyToCheck, currentNodeTemplate)) { + if (propertyExistCondition != isPropertyExistInNodeTemplate(propertyToCheck, currentNodeTemplate)) { return false; } } @@ -628,8 +807,8 @@ public class ConsolidationService { } private boolean isPropertyExistInNodeTemplate(String propertyToCheck, NodeTemplate nodeTemplate) { - return !(nodeTemplate.getProperties() == null || - nodeTemplate.getProperties().get(propertyToCheck) == null); + return !(nodeTemplate.getProperties() == null + || nodeTemplate.getProperties().get(propertyToCheck) == null); } void substitutionServiceTemplateConsolidation(String substituteNodeTemplateId, @@ -727,12 +906,17 @@ public class ConsolidationService { FilePortConsolidationData filePortConsolidationData = consolidationData.getPortConsolidationData().getFilePortConsolidationData(ToscaUtil .getServiceTemplateFileName(serviceTemplate)); - + List subInterfaceTemplateConsolidationDataList = + new ArrayList<>(); for (List portList : portCollection) { for (String portId : portList) { if (!Objects.isNull(filePortConsolidationData)) { - unifiedCompositionData.addPortTemplateConsolidationData( - (filePortConsolidationData.getPortTemplateConsolidationData(portId))); + PortTemplateConsolidationData portTemplateConsolidationData = + filePortConsolidationData.getPortTemplateConsolidationData(portId); + unifiedCompositionData.addPortTemplateConsolidationData(portTemplateConsolidationData); + if (portTemplateConsolidationData != null) { + portTemplateConsolidationData.copyFlatInto(subInterfaceTemplateConsolidationDataList); + } } } } @@ -773,7 +957,9 @@ public class ConsolidationService { && isNumberOfPortFromEachTypeLegal(typeComputeConsolidationData) && isPortTypesEqualsBetweenComputeNodes(typeComputeConsolidationData) && checkGetAttrBetweenConsolidationDataEntitiesNotFromSameType(serviceTemplate, - typeComputeConsolidationData, consolidationData)); + typeComputeConsolidationData, consolidationData) + && checkSubInterfaceConsolidationPreCondition(serviceTemplate, consolidationData, + typeComputeConsolidationData)); } @@ -788,7 +974,8 @@ public class ConsolidationService { getNumberOfPortsPerCompute(typeComputeConsolidationData .getAllComputeTemplateConsolidationData().iterator().next()); - for (ComputeTemplateConsolidationData compute : typeComputeConsolidationData.getAllComputeTemplateConsolidationData()) { + for (ComputeTemplateConsolidationData compute : typeComputeConsolidationData + .getAllComputeTemplateConsolidationData()) { if (getNumberOfPortsPerCompute(compute) != startingNumberOfPorts) { return false; } @@ -821,9 +1008,11 @@ public class ConsolidationService { private boolean isPortTypesEqualsBetweenComputeNodes( TypeComputeConsolidationData typeComputeConsolidationData) { - Set staringPortIds = getPortsIds(typeComputeConsolidationData.getAllComputeTemplateConsolidationData().iterator().next()); + Set staringPortIds = getPortsIds( + typeComputeConsolidationData.getAllComputeTemplateConsolidationData().iterator().next()); - for (ComputeTemplateConsolidationData compute : typeComputeConsolidationData.getAllComputeTemplateConsolidationData()) { + for (ComputeTemplateConsolidationData compute : typeComputeConsolidationData + .getAllComputeTemplateConsolidationData()) { Set currentPortIds = getPortsIds(compute); if (!currentPortIds.equals(staringPortIds)) { return false; @@ -887,5 +1076,6 @@ public class ConsolidationService { return propertiesThatNeedToHaveSameUsage; } + } -- cgit 1.2.3-korg