gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.translator.services.heattotosca;
  18
  19 import com.google.common.collect.ArrayListMultimap;
  20 import com.google.common.collect.ListMultimap;
  21 import org.apache.commons.collections4.CollectionUtils;
  22 import org.apache.commons.collections4.MapUtils;
  23 import org.apache.commons.lang3.StringUtils;
  24 import org.openecomp.sdc.common.errors.CoreException;
  25 import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
  26 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
  27 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
  28 import org.openecomp.sdc.tosca.services.DataModelUtil;
  29 import org.openecomp.sdc.tosca.services.ToscaAnalyzerService;
  30 import org.openecomp.sdc.tosca.services.ToscaConstants;
  31 import org.openecomp.sdc.tosca.services.ToscaUtil;
  32 import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
  33 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
  34 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionData;
  35 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionEntity;
  36 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionMode;
  37 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData;
  38 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ConsolidationData;
  39 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.EntityConsolidationData;
  40 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FileComputeConsolidationData;
  41 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FileNestedConsolidationData;
  42 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FilePortConsolidationData;
  43 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.GetAttrFuncData;
  44 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedConsolidationData;
  45 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedTemplateConsolidationData;
  46 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData;
  47 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.RequirementAssignmentData;
  48 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.SubInterfaceTemplateConsolidationData;
  49 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.TypeComputeConsolidationData;
  50 import org.openecomp.sdc.translator.services.heattotosca.errors.DuplicateResourceIdsInDifferentFilesErrorBuilder;
  51
  52 import java.util.ArrayList;
  53 import java.util.Collection;
  54 import java.util.Collections;
  55 import java.util.HashMap;
  56 import java.util.HashSet;
  57 import java.util.Iterator;
  58 import java.util.List;
  59 import java.util.Map;
  60 import java.util.Objects;
  61 import java.util.Set;
  62 import java.util.function.Function;
  63 import java.util.function.Predicate;
  64 import java.util.stream.Collectors;
  65
  66 public class ConsolidationService {
  67
  68   private UnifiedCompositionService unifiedCompositionService;
  69
  70   public ConsolidationService(UnifiedCompositionService unifiedCompositionService) {
  71     this.unifiedCompositionService = unifiedCompositionService;
  72   }
  73
  74   ConsolidationService() {
  75
  76   }
  77
  78   void serviceTemplateConsolidation(ServiceTemplate serviceTemplate,
  79                                     TranslationContext translationContext) {
  80
  81     ConsolidationData consolidationData = translationContext.getConsolidationData();
  82
  83     FileComputeConsolidationData fileComputeConsolidationData =
  84         consolidationData.getComputeConsolidationData()
  85             .getFileComputeConsolidationData(ToscaUtil.getServiceTemplateFileName(serviceTemplate));
  86
  87     if (Objects.isNull(fileComputeConsolidationData)) {
  88       return;
  89     }
  90     for (TypeComputeConsolidationData typeComputeConsolidationData :
  91         fileComputeConsolidationData.getAllTypeComputeConsolidationData()) {
  92       boolean preConditionResult =
  93           consolidationPreCondition(
  94               serviceTemplate, consolidationData, typeComputeConsolidationData);
  95
  96       List<UnifiedCompositionData> unifiedCompositionDataList =
  97           createUnifiedCompositionDataList(
  98               serviceTemplate, consolidationData, typeComputeConsolidationData);
  99
 100       if (preConditionResult) {
 101         boolean consolidationRuleCheckResult =
 102             checkConsolidationRules(serviceTemplate, typeComputeConsolidationData,
 103                 consolidationData);
 104
 105         unifiedCompositionService.createUnifiedComposition(
 106             serviceTemplate, null, unifiedCompositionDataList,
 107             consolidationRuleCheckResult ? UnifiedCompositionMode.ScalingInstances
 108                 : UnifiedCompositionMode.CatalogInstance,
 109             translationContext);
 110       } else {
 111         unifiedCompositionService.createUnifiedComposition(
 112             serviceTemplate, null, unifiedCompositionDataList, UnifiedCompositionMode
 113                 .SingleSubstitution,
 114             translationContext);
 115       }
 116     }
 117
 118   }
 119
 120   static Map<String, String> getConsolidationEntityIdToType(ServiceTemplate serviceTemplate,
 121                                                             ConsolidationData consolidationData) {
 122     Map<String, String> consolidationEntityIdToType = new HashMap<>();
 123
 124     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 125     FileComputeConsolidationData fileComputeConsolidationData =
 126         consolidationData.getComputeConsolidationData()
 127             .getFileComputeConsolidationData(serviceTemplateFileName);
 128     FilePortConsolidationData filePortConsolidationData =
 129         consolidationData.getPortConsolidationData()
 130             .getFilePortConsolidationData(serviceTemplateFileName);
 131     if (Objects.nonNull(fileComputeConsolidationData)) {
 132       for (String computeType : fileComputeConsolidationData.getAllComputeTypes()) {
 133         TypeComputeConsolidationData typeComputeConsolidationData =
 134             fileComputeConsolidationData.getTypeComputeConsolidationData(computeType);
 135         Collection<String> computeNodeTemplateIds =
 136             typeComputeConsolidationData.getAllComputeNodeTemplateIds();
 137         for (String computeNodeTemplateId : computeNodeTemplateIds) {
 138           consolidationEntityIdToType.put(computeNodeTemplateId, computeType);
 139         }
 140       }
 141     }
 142
 143     if (Objects.nonNull(filePortConsolidationData)) {
 144       Set<String> portNodeTemplateIds = filePortConsolidationData.getAllPortNodeTemplateIds();
 145       for (String portNodeTemplateId : portNodeTemplateIds) {
 146         consolidationEntityIdToType
 147             .put(portNodeTemplateId, ConsolidationDataUtil.getPortType(portNodeTemplateId));
 148       }
 149     }
 150
 151     return consolidationEntityIdToType;
 152   }
 153
 154
 155   private boolean checkConsolidationRules(ServiceTemplate serviceTemplate,
 156                                           TypeComputeConsolidationData typeComputeConsolidationData,
 157                                           ConsolidationData consolidationData) {
 158     return checkComputeConsolidation(serviceTemplate, typeComputeConsolidationData)
 159         && checkPortConsolidation(serviceTemplate, typeComputeConsolidationData,
 160         consolidationData)
 161         && !checkGetAttrBetweenEntityConsolidationOfTheSameType(serviceTemplate,
 162         typeComputeConsolidationData, consolidationData);
 163   }
 164
 165   private boolean checkGetAttrBetweenConsolidationDataEntitiesNotFromSameType(
 166       ServiceTemplate serviceTemplate,
 167       TypeComputeConsolidationData typeComputeConsolidationData,
 168       ConsolidationData consolidationData) {
 169     Collection<ComputeTemplateConsolidationData> computeTemplateConsolidationDataList =
 170         typeComputeConsolidationData.getAllComputeTemplateConsolidationData();
 171
 172     Collection<String> computeNodeTemplateIds =
 173         typeComputeConsolidationData.getAllComputeNodeTemplateIds();
 174
 175     Map<String, List<String>> portTypeToIds = UnifiedCompositionUtil
 176         .collectAllPortsFromEachTypesFromComputes(computeTemplateConsolidationDataList);
 177
 178     return
 179         checkGetAttrOutFromEntityToPortIsLegal(computeTemplateConsolidationDataList, portTypeToIds)
 180             && checkGetAttrOutFromPortLegal(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
 181             computeNodeTemplateIds, portTypeToIds, consolidationData);
 182
 183   }
 184
 185   private boolean checkGetAttrOutFromPortLegal(String serviceTemplateName,
 186                                                Collection<String> computeNodeTemplateIds,
 187                                                Map<String, List<String>> portTypeToIds,
 188                                                ConsolidationData consolidationData) {
 189     for (List<String> portIdsFromSameType : portTypeToIds.values()) {
 190       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
 191           collectAllPortsTemplateConsolidationData(portIdsFromSameType, serviceTemplateName,
 192               consolidationData);
 193
 194       if (!(checkGetAttrOutFromEntityToPortIsLegal(portTemplateConsolidationDataList, portTypeToIds)
 195           && checkGetAttrOutFromConsolidationEntityToEntityNotFromSameTypeIsLegal(
 196           portTemplateConsolidationDataList,
 197           computeNodeTemplateIds))) {
 198         return false;
 199       }
 200     }
 201
 202     return true;
 203   }
 204
 205   private boolean checkGetAttrOutFromEntityToPortIsLegal(Collection entities,
 206                                                          Map<String, List<String>> portTypeToIds) {
 207
 208     for (String portType : portTypeToIds.keySet()) {
 209       if (CollectionUtils.isEmpty(entities)) {
 210         continue;
 211       }
 212       Set<GetAttrFuncData> startingGetAttrFunc =
 213           getEntityGetAttrFuncAsSet(portType,
 214               (EntityConsolidationData) entities.iterator().next());
 215       for (Object entity : entities) {
 216         EntityConsolidationData currentEntity = (EntityConsolidationData) entity;
 217         Set<GetAttrFuncData> currentGetAttrFuncData =
 218             getEntityGetAttrFuncAsSet(portType, currentEntity);
 219         if (!(startingGetAttrFunc.equals(currentGetAttrFuncData))) {
 220           return false;
 221         }
 222       }
 223     }
 224
 225     return true;
 226   }
 227
 228   private boolean checkGetAttrOutFromConsolidationEntityToEntityNotFromSameTypeIsLegal(
 229       List entityConsolidationDataList,
 230       Collection<String> consolidationEntityNodeTemplateIds) {
 231     if (CollectionUtils.isEmpty(entityConsolidationDataList)) {
 232       return true;
 233     }
 234     EntityConsolidationData startingEntityTemplate =
 235         (EntityConsolidationData) entityConsolidationDataList.get(0);
 236     Map<String, Set<GetAttrFuncData>> startingGetAttrOutFuncData =
 237         getConsolidationEntityGetAttrOutFuncData(startingEntityTemplate.getNodesGetAttrOut(),
 238             consolidationEntityNodeTemplateIds);
 239
 240     for (int i = 1; i < entityConsolidationDataList.size(); i++) {
 241       EntityConsolidationData currentEntityTemplate =
 242           (EntityConsolidationData) entityConsolidationDataList.get(i);
 243       Map<String, Set<GetAttrFuncData>> currentGetAttrOutFuncData =
 244           getConsolidationEntityGetAttrOutFuncData(currentEntityTemplate.getNodesGetAttrOut(),
 245               consolidationEntityNodeTemplateIds);
 246
 247       if (!isGetAttrRelationToEntitySimilarBetweenEntities(startingGetAttrOutFuncData,
 248           currentGetAttrOutFuncData)) {
 249         return false;
 250       }
 251     }
 252
 253     return true;
 254   }
 255
 256   private boolean isGetAttrRelationToEntitySimilarBetweenEntities(
 257       Map<String, Set<GetAttrFuncData>> firstMap,
 258       Map<String, Set<GetAttrFuncData>> secondMap) {
 259     if (MapUtils.isEmpty(firstMap) != MapUtils.isEmpty(secondMap)) {
 260       return false;
 261     }
 262
 263     return (MapUtils.isEmpty(firstMap) && MapUtils.isEmpty(secondMap)) ||
 264         (new ArrayList<>(firstMap.values()).equals(new ArrayList<>(secondMap.values())));
 265
 266   }
 267
 268   private boolean checkSubInterfaceConsolidationPreCondition(ServiceTemplate serviceTemplate,
 269                                                              ConsolidationData consolidationData,
 270                                                              TypeComputeConsolidationData typeComputeConsolidationData) {
 271     FilePortConsolidationData filePortConsolidationData =
 272         consolidationData.getPortConsolidationData()
 273             .getFilePortConsolidationData(ToscaUtil.getServiceTemplateFileName(serviceTemplate));
 274
 275     if (Objects.isNull(filePortConsolidationData)) {
 276       return true;
 277     }
 278
 279     Map<String, List<String>> portTypeToPortIds = UnifiedCompositionUtil
 280         .collectAllPortsFromEachTypesFromComputes(
 281             typeComputeConsolidationData.getAllComputeTemplateConsolidationData());
 282
 283     Collection<String> computeNodeTemplateIds =
 284         typeComputeConsolidationData.getAllComputeNodeTemplateIds();
 285
 286     for (List<String> portIdsFromSameType : portTypeToPortIds.values()) {
 287       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
 288           getAllPortTemplateConsolidationData(portIdsFromSameType, filePortConsolidationData);
 289
 290       if (!areSubInterfacePreConditionRulesValid(portTypeToPortIds, computeNodeTemplateIds,
 291           portTemplateConsolidationDataList, portTemplateConsolidationDataList.get(0))) {
 292         return false;
 293       }
 294     }
 295     return true;
 296   }
 297
 298   private boolean areSubInterfacePreConditionRulesValid(Map<String, List<String>> portTypeToPortIds,
 299                                                         Collection<String> computeNodeTemplateIds,
 300                                                         List<PortTemplateConsolidationData> portTemplateConsolidationDataList,
 301                                                          PortTemplateConsolidationData subInterfaceConsolidationData) {
 302     return areSubInterfaceTypesSimilarBetweenPorts(portTemplateConsolidationDataList,
 303         subInterfaceConsolidationData)
 304         && isNumberOfSubInterfacesPerTypeSimilar(portTemplateConsolidationDataList,
 305         subInterfaceConsolidationData)
 306         && isGetAttrFromSubInterfaceToOtherEntitiesLegal(computeNodeTemplateIds,
 307         portTypeToPortIds, portTemplateConsolidationDataList);
 308   }
 309
 310   private boolean isGetAttrFromSubInterfaceToOtherEntitiesLegal(
 311       Collection<String> computeNodeTemplateIds,
 312       Map<String, List<String>> portTypeToPortIds,
 313       List<PortTemplateConsolidationData> portTemplateConsolidationDataList) {
 314
 315     ListMultimap<String, SubInterfaceTemplateConsolidationData> subInterfacesFromSameTypeFromPorts =
 316         collectAllSubInterfacesFromSameTypeFromPorts(portTemplateConsolidationDataList);
 317
 318     List<SubInterfaceTemplateConsolidationData> subInterfaceList = new ArrayList<>(subInterfacesFromSameTypeFromPorts
 319         .values());
 320     return areGetAttrRelationshipsBetweenSubInterfaceToConsolidationEntitiesValid(
 321         computeNodeTemplateIds, portTypeToPortIds, portTemplateConsolidationDataList, subInterfaceList);
 322   }
 323
 324   private boolean areGetAttrRelationshipsBetweenSubInterfaceToConsolidationEntitiesValid(
 325       Collection<String> computeNodeTemplateIds, Map<String, List<String>> portTypeToPortIds,
 326       List<PortTemplateConsolidationData> portTemplateConsolidationDataList,
 327       List<SubInterfaceTemplateConsolidationData> subInterfaceList) {
 328     return checkGetAttrOutFromEntityToPortIsLegal(subInterfaceList, portTypeToPortIds)
 329         && checkGetAttrOutFromConsolidationEntityToEntityNotFromSameTypeIsLegal(
 330         portTemplateConsolidationDataList, getSubInterfaceIdsFromSameType(subInterfaceList))
 331         && checkGetAttrOutFromConsolidationEntityToEntityNotFromSameTypeIsLegal(
 332         subInterfaceList, computeNodeTemplateIds);
 333   }
 334
 335   private boolean areSubInterfaceTypesSimilarBetweenPorts(
 336       List<PortTemplateConsolidationData> portTemplateConsolidationDataList,
 337       PortTemplateConsolidationData subInterfaceConsolidationData) {
 338
 339     return portTemplateConsolidationDataList.stream().allMatch(
 340         element -> element.hasSameSubInterfaceTypes(subInterfaceConsolidationData));
 341   }
 342
 343   private boolean isNumberOfSubInterfacesPerTypeSimilar(
 344       List<PortTemplateConsolidationData> portTemplateConsolidationDataList,
 345       PortTemplateConsolidationData subInterfaceConsolidationData) {
 346
 347     return portTemplateConsolidationDataList.stream()
 348         .allMatch(element -> element.isNumberOfSubInterfacesPerTypeSimilar(subInterfaceConsolidationData));
 349   }
 350
 351
 352   private Set<GetAttrFuncData> getEntityGetAttrFuncAsSet(
 353       String portType,
 354       EntityConsolidationData entityConsolidationData) {
 355
 356     Set<GetAttrFuncData> getAttrFuncDataFromPortsWithSameType = new HashSet<>();
 357     Map<String, List<GetAttrFuncData>> nodesGetAttrOut =
 358         entityConsolidationData.getNodesGetAttrOut();
 359
 360     if (MapUtils.isEmpty(nodesGetAttrOut)) {
 361       return getAttrFuncDataFromPortsWithSameType;
 362     }
 363
 364     for (Map.Entry<String, List<GetAttrFuncData>> entry : nodesGetAttrOut.entrySet()) {
 365       if (portType.equals(ConsolidationDataUtil.getPortType(entry.getKey()))) {
 366         getAttrFuncDataFromPortsWithSameType.addAll(entry.getValue());
 367       }
 368     }
 369
 370     return getAttrFuncDataFromPortsWithSameType;
 371   }
 372
 373   private Map<String, Set<GetAttrFuncData>> getConsolidationEntityGetAttrOutFuncData(
 374       Map<String, List<GetAttrFuncData>> nodesGetAttrOut,
 375       Collection<String> computeNodeTemplateIds) {
 376     Map<String, Set<GetAttrFuncData>> computeGetAttrFuncData = new HashMap<>();
 377
 378     if (MapUtils.isEmpty(nodesGetAttrOut)) {
 379       return computeGetAttrFuncData;
 380     }
 381
 382     for (Map.Entry<String, List<GetAttrFuncData>> getAttrFuncEntry : nodesGetAttrOut.entrySet()) {
 383       if (computeNodeTemplateIds.contains(getAttrFuncEntry.getKey())) {
 384         computeGetAttrFuncData.put(getAttrFuncEntry.getKey(), new HashSet<>(getAttrFuncEntry
 385             .getValue()));
 386       }
 387     }
 388
 389     return computeGetAttrFuncData;
 390   }
 391
 392   private boolean checkGetAttrBetweenEntityConsolidationOfTheSameType(
 393       ServiceTemplate serviceTemplate,
 394       TypeComputeConsolidationData typeComputeConsolidationData,
 395       ConsolidationData consolidationData) {
 396     return areThereGetAttrRelationsBetweenComputesOfSameType(typeComputeConsolidationData)
 397         || areThereGetAttrRelationsBetweenPortsOfTheSameType(serviceTemplate,
 398         typeComputeConsolidationData, consolidationData);
 399
 400   }
 401
 402   private boolean areThereGetAttrRelationsBetweenComputesOfSameType(
 403       TypeComputeConsolidationData typeComputeConsolidationData) {
 404
 405     Collection<ComputeTemplateConsolidationData> computeTemplateConsolidationEntities =
 406         typeComputeConsolidationData.getAllComputeTemplateConsolidationData();
 407     Collection<String> computeNodeTemplateIds =
 408         typeComputeConsolidationData.getAllComputeNodeTemplateIds();
 409
 410     return checkGetAttrRelationsForEntityConsolidationData(
 411         computeTemplateConsolidationEntities, computeNodeTemplateIds,
 412         EntityConsolidationData::getNodesGetAttrIn);
 413   }
 414
 415   private boolean areThereGetAttrRelationsBetweenPortsOfTheSameType(
 416       ServiceTemplate serviceTemplate,
 417       TypeComputeConsolidationData typeComputeConsolidationData,
 418       ConsolidationData consolidationData) {
 419
 420     Collection<ComputeTemplateConsolidationData> computeTemplateConsolidationEntities =
 421         typeComputeConsolidationData.getAllComputeTemplateConsolidationData();
 422     Map<String, List<String>> portTypeToPortIds = UnifiedCompositionUtil
 423         .collectAllPortsFromEachTypesFromComputes(computeTemplateConsolidationEntities);
 424
 425     FilePortConsolidationData filePortConsolidationData =
 426         consolidationData.getPortConsolidationData().getFilePortConsolidationData(ToscaUtil
 427             .getServiceTemplateFileName(serviceTemplate));
 428
 429     for (List<String> portsOfTheSameTypeIds : portTypeToPortIds.values()) {
 430       List<PortTemplateConsolidationData> portTemplateConsolidationDataOfSameType =
 431           getAllPortTemplateConsolidationData(portsOfTheSameTypeIds, filePortConsolidationData);
 432       if (!checkGetAttrRelationsForEntityConsolidationData(portTemplateConsolidationDataOfSameType,
 433           portsOfTheSameTypeIds, EntityConsolidationData::getNodesGetAttrIn)) {
 434         return false;
 435       }
 436     }
 437
 438     return true;
 439   }
 440
 441   private boolean areThereGetAttrRelationsBetweenSubInterfacesOfSameType(
 442       List<String> subInterfacesIdsFromSameType,
 443       List<SubInterfaceTemplateConsolidationData> subInterfaceList) {
 444
 445     return checkGetAttrRelationsForEntityConsolidationData(subInterfaceList,
 446         subInterfacesIdsFromSameType, EntityConsolidationData::getNodesGetAttrIn)
 447         || checkGetAttrRelationsForEntityConsolidationData(subInterfaceList,
 448         subInterfacesIdsFromSameType, EntityConsolidationData::getNodesGetAttrOut);
 449
 450   }
 451
 452   private List<PortTemplateConsolidationData> getAllPortTemplateConsolidationData(
 453       List<String> portsIds,
 454       FilePortConsolidationData filePortConsolidationData) {
 455     List<PortTemplateConsolidationData> portTemplateConsolidationDataOfSameType = new ArrayList<>();
 456
 457     for (String portId : portsIds) {
 458       PortTemplateConsolidationData portTemplateConsolidationData =
 459           filePortConsolidationData.getPortTemplateConsolidationData(portId);
 460       if (Objects.nonNull(portTemplateConsolidationData)) {
 461         portTemplateConsolidationDataOfSameType.add(portTemplateConsolidationData);
 462       }
 463     }
 464
 465     return portTemplateConsolidationDataOfSameType;
 466   }
 467
 468   private boolean checkGetAttrRelationsForEntityConsolidationData(Collection entities,
 469                                                                   Collection<String> nodeTemplateIdsOfTheSameType,
 470                                                                   Function<EntityConsolidationData, Map<String, List<GetAttrFuncData>>> getAttrValuesMethod) {
 471     for (Object entity : entities) {
 472       Map<String, List<GetAttrFuncData>> getAttrValue =
 473           getAttrValuesMethod.apply((EntityConsolidationData) entity);
 474       Set<String> getAttrNodeIds =
 475           getAttrValue == null ? new HashSet<>()
 476               : getAttrValue.keySet();
 477       if (getAttrNodeIds.stream().anyMatch(nodeTemplateIdsOfTheSameType::contains)) {
 478         return true;
 479       }
 480     }
 481     return false;
 482   }
 483
 484
 485   private boolean checkComputeConsolidation(
 486       ServiceTemplate serviceTemplate,
 487       TypeComputeConsolidationData typeComputeConsolidationData) {
 488     Collection<String> computeNodeTemplateIds =
 489         typeComputeConsolidationData.getAllComputeNodeTemplateIds();
 490     List<String> propertiesWithIdenticalVal = getComputePropertiesWithIdenticalVal();
 491
 492     return arePropertiesSimilarBetweenComputeNodeTemplates(serviceTemplate, computeNodeTemplateIds,
 493         propertiesWithIdenticalVal)
 494         && checkComputeRelations(
 495         typeComputeConsolidationData.getAllComputeTemplateConsolidationData());
 496   }
 497
 498
 499   private boolean checkComputeRelations(
 500       Collection<ComputeTemplateConsolidationData> computeTemplateConsolidationEntities) {
 501
 502     return checkEntityConsolidationDataRelations(computeTemplateConsolidationEntities)
 503         && checkComputesRelationsToVolume(computeTemplateConsolidationEntities);
 504   }
 505
 506   private boolean checkEntityConsolidationDataRelations(Collection entities) {
 507     EntityConsolidationData startingEntity = (EntityConsolidationData) entities.iterator().next();
 508
 509     for (Object entity : entities) {
 510       EntityConsolidationData currentEntity = (EntityConsolidationData) entity;
 511       if (!(checkNodesConnectedInRelations(startingEntity, currentEntity)
 512           && (checkNodesConnectedOutRelations(startingEntity, currentEntity))
 513           && (checkGroupIdsRelations(startingEntity, currentEntity)))) {
 514         return false;
 515       }
 516     }
 517     return true;
 518   }
 519
 520   private boolean checkNodesConnectedInRelations(EntityConsolidationData firstEntity,
 521                                                  EntityConsolidationData secondEntity) {
 522     return compareNodeConnectivity(firstEntity.getNodesConnectedIn(),
 523         secondEntity.getNodesConnectedIn());
 524   }
 525
 526   private boolean checkNodesConnectedOutRelations(EntityConsolidationData firstEntity,
 527                                                   EntityConsolidationData secondEntity) {
 528     return compareNodeConnectivity(firstEntity.getNodesConnectedOut(),
 529         secondEntity.getNodesConnectedOut());
 530   }
 531
 532   private boolean compareNodeConnectivity(
 533       Map<String, List<RequirementAssignmentData>> firstEntityMap,
 534       Map<String, List<RequirementAssignmentData>> secondEntityMap) {
 535
 536     if (MapUtils.isEmpty(firstEntityMap)
 537         && MapUtils.isEmpty(secondEntityMap)) {
 538       return true;
 539     }
 540     return !MapUtils.isEmpty(firstEntityMap) && !MapUtils.isEmpty(secondEntityMap)
 541         && firstEntityMap.keySet().equals(secondEntityMap.keySet());
 542   }
 543
 544   private boolean checkGroupIdsRelations(EntityConsolidationData startingEntity,
 545                                          EntityConsolidationData currentEntity) {
 546     return CollectionUtils.isEmpty(startingEntity.getGroupIds())
 547         && CollectionUtils.isEmpty(currentEntity.getGroupIds())
 548         || startingEntity.getGroupIds().equals(currentEntity.getGroupIds());
 549
 550   }
 551
 552   private boolean checkComputesRelationsToVolume(
 553       Collection<ComputeTemplateConsolidationData> computeTemplateConsolidationEntities) {
 554     Iterator<ComputeTemplateConsolidationData> iterator =
 555         computeTemplateConsolidationEntities.iterator();
 556
 557     Map<String, List<RequirementAssignmentData>> startingVolumes =
 558         iterator.next().getVolumes();
 559
 560     for (ComputeTemplateConsolidationData compute : computeTemplateConsolidationEntities) {
 561       Map<String, List<RequirementAssignmentData>> currentVolumes =
 562           compute.getVolumes();
 563       if (!compareNodeConnectivity(startingVolumes, currentVolumes)) {
 564         return false;
 565       }
 566     }
 567     return true;
 568   }
 569
 570
 571   private boolean checkPortConsolidation(ServiceTemplate serviceTemplate,
 572                                          TypeComputeConsolidationData typeComputeConsolidationData,
 573                                          ConsolidationData consolidationData) {
 574     return validateWantedPortProperties(serviceTemplate,
 575         typeComputeConsolidationData)
 576         && checkPortRelations(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
 577         typeComputeConsolidationData, consolidationData);
 578   }
 579
 580
 581   private boolean validateWantedPortProperties(ServiceTemplate serviceTemplate,
 582                                                TypeComputeConsolidationData typeComputeConsolidationData) {
 583
 584     Collection<ComputeTemplateConsolidationData> computeTemplateConsolidationDataCollection =
 585         typeComputeConsolidationData.getAllComputeTemplateConsolidationData();
 586     Map<String, List<String>> portTypeToIds = UnifiedCompositionUtil
 587         .collectAllPortsFromEachTypesFromComputes(computeTemplateConsolidationDataCollection);
 588     List<String> propertiesWithIdenticalVal = getPortPropertiesWithIdenticalVal();
 589     List<String> propertiesThatNeedToHaveSameUsage =
 590         getPortPropertiesThatNeedToHaveSameUsage();
 591
 592     for (List<String> portsIds : portTypeToIds.values()) {
 593       if (!arePortPropertiesValid(serviceTemplate, propertiesWithIdenticalVal,
 594           propertiesThatNeedToHaveSameUsage, portsIds)) {
 595         return false;
 596       }
 597     }
 598
 599     return true;
 600   }
 601
 602   private boolean arePortPropertiesValid(ServiceTemplate serviceTemplate,
 603                                          List<String> propertiesWithIdenticalVal,
 604                                          List<String> propertiesThatNeedToHaveSameUsage,
 605                                          List<String> portsIds) {
 606     Map<String, NodeTemplate> nodeTemplates =
 607         serviceTemplate.getTopology_template().getNode_templates();
 608
 609     Predicate<String> similar = property ->
 610         isPropertyValueSimilarBetweenNodeTemplates(property,
 611             portsIds, nodeTemplates);
 612
 613     Predicate<String> exists = property ->
 614         isPropertyUsageSimilarBetweenAllNodeTemplates(property,
 615             portsIds, nodeTemplates);
 616
 617     return areWantedPortPropertiesValid(
 618         propertiesWithIdenticalVal, similar)
 619         && areWantedPortPropertiesValid(
 620         propertiesThatNeedToHaveSameUsage, exists);
 621   }
 622
 623   private boolean checkPortRelations(String serviceTemplateName,
 624                                      TypeComputeConsolidationData typeComputeConsolidationData,
 625                                      ConsolidationData consolidationData) {
 626     Collection<ComputeTemplateConsolidationData> computeTemplateConsolidationDataCollection =
 627         typeComputeConsolidationData.getAllComputeTemplateConsolidationData();
 628     Map<String, List<String>> portTypeToIds = UnifiedCompositionUtil
 629         .collectAllPortsFromEachTypesFromComputes(computeTemplateConsolidationDataCollection);
 630
 631     for (List<String> portIds : portTypeToIds.values()) {
 632       List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
 633           collectAllPortsTemplateConsolidationData(
 634               portIds, serviceTemplateName, consolidationData);
 635
 636       if (!checkEntityConsolidationDataRelations(portTemplateConsolidationDataList)
 637           || !checkSubInterfaceRules(portTemplateConsolidationDataList)) {
 638         return false;
 639       }
 640     }
 641
 642     return true;
 643   }
 644
 645   private boolean checkSubInterfaceRules(List<PortTemplateConsolidationData>
 646                                              portTemplateConsolidationDataList) {
 647     ListMultimap<String, SubInterfaceTemplateConsolidationData> subInterfaceTypeToEntity =
 648         collectAllSubInterfacesFromSameTypeFromPorts(portTemplateConsolidationDataList);
 649     List<SubInterfaceTemplateConsolidationData> subInterfaceList = new ArrayList<>(subInterfaceTypeToEntity.values());
 650     return areSubInterfacePropertiesAndRelationsValid(subInterfaceList);
 651   }
 652
 653   private boolean areSubInterfacePropertiesAndRelationsValid(
 654       List<SubInterfaceTemplateConsolidationData> subInterfaceList) {
 655     return isResourceGroupPropertiesSimilarBetweenSubPorts(subInterfaceList)
 656         && checkSubInterfaceRelations(subInterfaceList)
 657         && !areThereGetAttrRelationsBetweenSubInterfacesOfSameType(
 658         getSubInterfaceIdsFromSameType(subInterfaceList), subInterfaceList);
 659   }
 660
 661   private boolean checkSubInterfaceRelations(List<SubInterfaceTemplateConsolidationData>
 662                                                  subInterfaceList) {
 663     return CollectionUtils.isEmpty(subInterfaceList)
 664         || checkEntityConsolidationDataRelations(subInterfaceList);
 665   }
 666
 667   private boolean isResourceGroupPropertiesSimilarBetweenSubPorts(
 668       List<SubInterfaceTemplateConsolidationData> subInterfaceList) {
 669     if (CollectionUtils.isEmpty(subInterfaceList)) {
 670       return true;
 671     }
 672
 673     SubInterfaceTemplateConsolidationData startingSubInterface = subInterfaceList.get(0);
 674     for (SubInterfaceTemplateConsolidationData subInterface : subInterfaceList) {
 675       if (!startingSubInterface.getResourceGroupCount().equals(subInterface.getResourceGroupCount())
 676           || !StringUtils.equals(startingSubInterface.getNetworkRole(), subInterface.getNetworkRole())) {
 677         return false;
 678       }
 679     }
 680
 681     return true;
 682   }
 683
 684   private List<String> getSubInterfaceIdsFromSameType(List<SubInterfaceTemplateConsolidationData>
 685                                                           subInterfaceList) {
 686     if (CollectionUtils.isEmpty(subInterfaceList)) {
 687       return new ArrayList<>();
 688     }
 689
 690     return subInterfaceList.stream().map(SubInterfaceTemplateConsolidationData::getNodeTemplateId)
 691         .collect(Collectors.toList());
 692   }
 693
 694   private ListMultimap<String, SubInterfaceTemplateConsolidationData> collectAllSubInterfacesFromSameTypeFromPorts(
 695       List<PortTemplateConsolidationData> portTemplateConsolidationDataList) {
 696     ListMultimap<String, SubInterfaceTemplateConsolidationData>  subInterfaceTypeToEntity = ArrayListMultimap.create();
 697     for (PortTemplateConsolidationData portTemplateConsolidationData : portTemplateConsolidationDataList) {
 698       portTemplateConsolidationData.copyMappedInto(subInterfaceTypeToEntity);
 699     }
 700
 701     return subInterfaceTypeToEntity;
 702   }
 703
 704   private List<PortTemplateConsolidationData> collectAllPortsTemplateConsolidationData(List<String> portIds,
 705                                                                                        String serviceTemplateName,
 706                                                                                        ConsolidationData consolidationData) {
 707
 708     FilePortConsolidationData filePortConsolidationData =
 709         consolidationData.getPortConsolidationData()
 710             .getFilePortConsolidationData(serviceTemplateName);
 711     List<PortTemplateConsolidationData> portTemplateConsolidationDataList = new ArrayList<>();
 712
 713     for (String portId : portIds) {
 714       PortTemplateConsolidationData portTemplateConsolidationData = filePortConsolidationData
 715           .getPortTemplateConsolidationData(portId);
 716       if (Objects.nonNull(portTemplateConsolidationData)) {
 717         portTemplateConsolidationDataList.add(portTemplateConsolidationData);
 718       }
 719     }
 720
 721     return portTemplateConsolidationDataList;
 722   }
 723
 724   private boolean areWantedPortPropertiesValid(List<String> propertiesToCheck,
 725                                                Predicate<String> condition) {
 726
 727     return propertiesToCheck.stream().allMatch(condition);
 728   }
 729
 730
 731   private boolean arePropertiesSimilarBetweenComputeNodeTemplates(
 732       ServiceTemplate serviceTemplate,
 733       Collection<String> computeNodeTemplateIds,
 734       List<String> propertiesThatNeedToBeSimilar) {
 735
 736     Map<String, NodeTemplate> idToNodeTemplate =
 737         serviceTemplate.getTopology_template().getNode_templates();
 738
 739     for (String property : propertiesThatNeedToBeSimilar) {
 740       if (!isPropertyValueSimilarBetweenNodeTemplates(property, computeNodeTemplateIds,
 741           idToNodeTemplate)) {
 742         return false;
 743       }
 744     }
 745     return true;
 746   }
 747
 748   private boolean isPropertyUsageSimilarBetweenAllNodeTemplates(String propertyToCheck,
 749                                                                 List<String> entityNodeTemplateIds,
 750                                                                 Map<String, NodeTemplate> idToNodeTemplate) {
 751     NodeTemplate startingNodeTemplate = idToNodeTemplate.get(entityNodeTemplateIds.get(0));
 752     if (Objects.isNull(startingNodeTemplate)) {
 753       throw new CoreException(
 754           new DuplicateResourceIdsInDifferentFilesErrorBuilder(entityNodeTemplateIds.get(0))
 755               .build());
 756     }
 757
 758     boolean propertyExistCondition =
 759         isPropertyExistInNodeTemplate(propertyToCheck, startingNodeTemplate);
 760
 761     for (int i = 1; i < entityNodeTemplateIds.size(); i++) {
 762       NodeTemplate currentNodeTemplate = idToNodeTemplate.get(entityNodeTemplateIds.get(i));
 763       if (Objects.isNull(currentNodeTemplate)) {
 764         throw new CoreException(
 765             new DuplicateResourceIdsInDifferentFilesErrorBuilder(entityNodeTemplateIds.get(i))
 766                 .build());
 767       }
 768       if (propertyExistCondition != isPropertyExistInNodeTemplate(propertyToCheck, currentNodeTemplate)) {
 769         return false;
 770       }
 771     }
 772
 773     return true;
 774
 775   }
 776
 777   private boolean isPropertyValueSimilarBetweenNodeTemplates(String propertyToCheck,
 778                                                              Collection<String> entityNodeTemplateIds,
 779                                                              Map<String, NodeTemplate> idToNodeTemplate) {
 780
 781     Set<Object> propertiesValues = new HashSet<>();
 782     Iterator<String> iterator = entityNodeTemplateIds.iterator();
 783
 784     handlePropertyValue(propertyToCheck, idToNodeTemplate, propertiesValues, iterator.next());
 785
 786     while (iterator.hasNext()) {
 787       handlePropertyValue(propertyToCheck, idToNodeTemplate, propertiesValues, iterator.next());
 788     }
 789
 790     return propertiesValues.size() == 1;
 791   }
 792
 793   private void handlePropertyValue(String propertyToCheck,
 794                                    Map<String, NodeTemplate> idToNodeTemplate,
 795                                    Set<Object> propertiesValues, String nodeId) {
 796     NodeTemplate startingNodeTemplate = idToNodeTemplate.get(nodeId);
 797     if (Objects.isNull(startingNodeTemplate)) {
 798       throw new CoreException(
 799           new DuplicateResourceIdsInDifferentFilesErrorBuilder(nodeId)
 800               .build());
 801     }
 802
 803     addPropertyValue(propertyToCheck, startingNodeTemplate, propertiesValues);
 804   }
 805
 806   private void addPropertyValue(String property,
 807                                 NodeTemplate nodeTemplate,
 808                                 Set<Object> propertiesValues) {
 809     propertiesValues.add(
 810         isPropertyExistInNodeTemplate(property, nodeTemplate) ? nodeTemplate.getProperties()
 811             .get(property) : "");
 812   }
 813
 814   private boolean isPropertyExistInNodeTemplate(String propertyToCheck, NodeTemplate nodeTemplate) {
 815     return !(nodeTemplate.getProperties() == null
 816        || nodeTemplate.getProperties().get(propertyToCheck) == null);
 817   }
 818
 819   void substitutionServiceTemplateConsolidation(String substituteNodeTemplateId,
 820                                                 ServiceTemplate serviceTemplate,
 821                                                 ServiceTemplate substitutionServiceTemplate,
 822                                                 TranslationContext translationContext) {
 823
 824     ConsolidationData consolidationData = translationContext.getConsolidationData();
 825
 826     FileComputeConsolidationData fileComputeConsolidationData =
 827         translationContext.getConsolidationData().getComputeConsolidationData()
 828             .getFileComputeConsolidationData(
 829                 ToscaUtil.getServiceTemplateFileName(substitutionServiceTemplate));
 830     boolean substitutionConsolidationRuleResult =
 831         substitutionServiceTemplateConsolidationRule(substitutionServiceTemplate,
 832             fileComputeConsolidationData, translationContext);
 833
 834     if (substitutionConsolidationRuleResult) {
 835       List<UnifiedCompositionData> unifiedCompositionDataList =
 836           createSubstitutionUnifiedCompositionDataList(substituteNodeTemplateId,
 837               serviceTemplate, substitutionServiceTemplate, consolidationData);
 838       unifiedCompositionService
 839           .createUnifiedComposition(serviceTemplate, substitutionServiceTemplate,
 840               unifiedCompositionDataList, UnifiedCompositionMode.NestedSingleCompute,
 841               translationContext);
 842     } else {
 843       //The node template does not represent unified VFC but complexVFC
 844       //Adding the id in the context for fixing connectivity from/to nested non-unified nodes
 845       translationContext.addUnifiedNestedNodeTemplateId(ToscaUtil
 846               .getServiceTemplateFileName(serviceTemplate),
 847           substituteNodeTemplateId, substituteNodeTemplateId);
 848
 849       if (!translationContext.isUnifiedHandledServiceTemplate(substitutionServiceTemplate)) {
 850         serviceTemplateConsolidation(substitutionServiceTemplate, translationContext);
 851       }
 852     }
 853   }
 854
 855   private boolean substitutionServiceTemplateConsolidationRule(
 856       ServiceTemplate nestedServiceTemplate,
 857       FileComputeConsolidationData fileComputeConsolidationData,
 858       TranslationContext context) {
 859
 860     return Objects.nonNull(fileComputeConsolidationData)
 861         && isNumberOfComputeTypesLegal(fileComputeConsolidationData)
 862         && isNumberOfComputeConsolidationDataPerTypeLegal(
 863         fileComputeConsolidationData.getAllTypeComputeConsolidationData().iterator().next())
 864         && !isThereMoreThanOneNestedLevel(nestedServiceTemplate, context);
 865   }
 866
 867   private boolean isNumberOfComputeTypesLegal(
 868       FileComputeConsolidationData fileComputeConsolidationData) {
 869     return fileComputeConsolidationData.getAllTypeComputeConsolidationData().size() == 1;
 870   }
 871
 872   private boolean isNumberOfComputeConsolidationDataPerTypeLegal(
 873       TypeComputeConsolidationData typeComputeConsolidationData) {
 874     return typeComputeConsolidationData.getAllComputeTemplateConsolidationData().size() == 1;
 875   }
 876
 877   private boolean isThereMoreThanOneNestedLevel(ServiceTemplate nestedServiceTemplate,
 878                                                 TranslationContext context) {
 879     FileNestedConsolidationData fileNestedConsolidationData = null;
 880     String nestedServiceTemplateName = ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate);
 881     if (Objects.isNull(nestedServiceTemplateName)) {
 882       return false;
 883     }
 884
 885     NestedConsolidationData nestedConsolidationData = context.getConsolidationData()
 886                                                                 .getNestedConsolidationData();
 887     if (Objects.nonNull(nestedConsolidationData)) {
 888       fileNestedConsolidationData =
 889           nestedConsolidationData.getFileNestedConsolidationData(nestedServiceTemplateName);
 890     }
 891
 892     //Condition to check if there is nested file and if file contains only sub interfaces then
 893     // return false
 894     return Objects.nonNull(fileNestedConsolidationData)
 895         && !ifNestedFileContainsOnlySubInterface(nestedServiceTemplate, context);
 896   }
 897
 898   private boolean ifNestedFileContainsOnlySubInterface(ServiceTemplate serviceTemplate,
 899                                                        TranslationContext context) {
 900     Map<String, NodeTemplate> nestedNodeTemplateMap =
 901         DataModelUtil.getNodeTemplates(serviceTemplate);
 902
 903     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
 904     Set<Object> nestedHeatFileNames = nestedNodeTemplateMap.entrySet().stream()
 905         .filter(entry -> toscaAnalyzerService.isSubstitutableNodeTemplate(entry.getValue())
 906         && toscaAnalyzerService
 907             .getSubstituteServiceTemplateName(entry.getKey(), entry.getValue()).isPresent())
 908         .map(entry -> toscaAnalyzerService
 909             .getSubstituteServiceTemplateName(entry.getKey(), entry.getValue()).get())
 910         .collect(Collectors.toSet());
 911
 912     if (CollectionUtils.isNotEmpty(nestedHeatFileNames)) {
 913       for (Object fileName : nestedHeatFileNames) {
 914         String heatFileName = context.getNestedHeatFileName().get(String.valueOf(fileName));
 915
 916         if (Objects.nonNull(heatFileName)
 917               && !ifAllResourceAreSubInterface(context.getTranslatedServiceTemplates()
 918                     .get(heatFileName).getTopology_template().getNode_templates().values())) {
 919           return false;
 920         }
 921       }
 922     }
 923
 924     return true;
 925   }
 926
 927   // Method returns true if all of the resource are sub interface
 928   private boolean ifAllResourceAreSubInterface(Collection<NodeTemplate> nodeTemplates) {
 929     return nodeTemplates.stream().allMatch(nodeTemplate ->
 930         ToscaNodeType.CONTRAILV2_VLAN_SUB_INTERFACE.equals(nodeTemplate.getType()));
 931   }
 932
 933   private List<UnifiedCompositionData> createUnifiedCompositionDataList(
 934       ServiceTemplate serviceTemplate,
 935       ConsolidationData consolidationData,
 936       TypeComputeConsolidationData typeComputeConsolidationData) {
 937
 938     List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 939
 940     for (ComputeTemplateConsolidationData computeTemplateConsolidationData : typeComputeConsolidationData
 941         .getAllComputeTemplateConsolidationData()) {
 942       UnifiedCompositionData unifiedCompositionData = new UnifiedCompositionData();
 943       unifiedCompositionData.setComputeTemplateConsolidationData(computeTemplateConsolidationData);
 944       FilePortConsolidationData filePortConsolidationData =
 945           consolidationData.getPortConsolidationData().getFilePortConsolidationData(ToscaUtil
 946               .getServiceTemplateFileName(serviceTemplate));
 947       setUnifiedCompositionDataWithPortTemplateData(computeTemplateConsolidationData, filePortConsolidationData,
 948           unifiedCompositionData);
 949       unifiedCompositionDataList.add(unifiedCompositionData);
 950     }
 951     return unifiedCompositionDataList;
 952   }
 953
 954   private void setPortTemplateConsolidationData(FilePortConsolidationData filePortConsolidationData,
 955                                                 String portId,
 956                                                 UnifiedCompositionData unifiedCompositionData,
 957                                                 List<SubInterfaceTemplateConsolidationData>
 958                                                                  subInterfaceTemplateConsolidationDataList) {
 959     if (Objects.isNull(filePortConsolidationData)) {
 960       return;
 961     }
 962     PortTemplateConsolidationData portTemplateConsolidationData =
 963         filePortConsolidationData.getPortTemplateConsolidationData(portId);
 964     unifiedCompositionData.addPortTemplateConsolidationData(portTemplateConsolidationData);
 965     if (portTemplateConsolidationData != null) {
 966       portTemplateConsolidationData.copyFlatInto(subInterfaceTemplateConsolidationDataList);
 967     }
 968   }
 969
 970   private List<UnifiedCompositionData> createSubstitutionUnifiedCompositionDataList(
 971       String substituteNodeTemplateId,
 972       ServiceTemplate serviceTemplate,
 973       ServiceTemplate substitutionServiceTemplate,
 974       ConsolidationData consolidationData) {
 975     List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 976     FileNestedConsolidationData fileNestedConsolidationData =
 977         consolidationData.getNestedConsolidationData()
 978             .getFileNestedConsolidationData(ToscaUtil.getServiceTemplateFileName(serviceTemplate));
 979
 980     if (Objects.nonNull(fileNestedConsolidationData)) {
 981       NestedTemplateConsolidationData nestedTemplateConsolidationData =
 982           fileNestedConsolidationData.getNestedTemplateConsolidationData(substituteNodeTemplateId);
 983       UnifiedCompositionData unifiedCompositionData = new UnifiedCompositionData();
 984       unifiedCompositionData.setNestedTemplateConsolidationData(nestedTemplateConsolidationData);
 985       unifiedCompositionDataList.add(unifiedCompositionData);
 986       addSubInterfaceDataToNestedCompositionData(substitutionServiceTemplate, consolidationData,
 987           unifiedCompositionData);
 988     }
 989
 990     return unifiedCompositionDataList;
 991   }
 992
 993   private void addSubInterfaceDataToNestedCompositionData(ServiceTemplate substitutionServiceTemplate,
 994                                                           ConsolidationData consolidationData,
 995                                                           UnifiedCompositionData unifiedCompositionData) {
 996     FileComputeConsolidationData nestedFileComputeConsolidationData = consolidationData.getComputeConsolidationData()
 997         .getFileComputeConsolidationData(ToscaUtil.getServiceTemplateFileName(substitutionServiceTemplate));
 998     FilePortConsolidationData nestedFilePortConsolidationData = consolidationData.getPortConsolidationData()
 999         .getFilePortConsolidationData(ToscaUtil.getServiceTemplateFileName(substitutionServiceTemplate));
1000     if (Objects.isNull(nestedFileComputeConsolidationData)
1001         || Objects.isNull(nestedFilePortConsolidationData)) {
1002       return;
1003     }
1004     TypeComputeConsolidationData computeType =
1005         nestedFileComputeConsolidationData.getAllTypeComputeConsolidationData().iterator().next();
1006     if (Objects.isNull(computeType)) {
1007       return;
1008     }
1009     ComputeTemplateConsolidationData computeTemplateConsolidationData =
1010         computeType.getAllComputeTemplateConsolidationData().iterator().next();
1011     setUnifiedCompositionDataWithPortTemplateData(computeTemplateConsolidationData, nestedFilePortConsolidationData,
1012         unifiedCompositionData);
1013   }
1014
1015   private void setUnifiedCompositionDataWithPortTemplateData(ComputeTemplateConsolidationData
1016                                                                  computeTemplateConsolidationData,
1017                                                              FilePortConsolidationData filePortConsolidationData,
1018                                                              UnifiedCompositionData unifiedCompositionData) {
1019     Collection<List<String>> portCollection =
1020         computeTemplateConsolidationData.getPorts() == null ? Collections.emptyList()
1021             : computeTemplateConsolidationData.getPorts().values();
1022     List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList = new ArrayList<>();
1023     portCollection.stream()
1024         .flatMap(Collection::stream)
1025         .forEach(portId -> setPortTemplateConsolidationData(filePortConsolidationData, portId,
1026             unifiedCompositionData, subInterfaceTemplateConsolidationDataList));
1027     unifiedCompositionData.setSubInterfaceTemplateConsolidationDataList(
1028         subInterfaceTemplateConsolidationDataList);
1029   }
1030
1031   private boolean consolidationPreCondition(
1032       ServiceTemplate serviceTemplate,
1033       ConsolidationData consolidationData,
1034       TypeComputeConsolidationData typeComputeConsolidationData) {
1035
1036     return (isThereMoreThanOneComputeTypeInstance(typeComputeConsolidationData)
1037         && isNumberOfPortsEqualsBetweenComputeNodes(typeComputeConsolidationData)
1038         && isNumberOfPortFromEachTypeLegal(typeComputeConsolidationData)
1039         && isPortTypesEqualsBetweenComputeNodes(typeComputeConsolidationData)
1040         && checkGetAttrBetweenConsolidationDataEntitiesNotFromSameType(serviceTemplate,
1041         typeComputeConsolidationData, consolidationData)
1042         && checkSubInterfaceConsolidationPreCondition(serviceTemplate, consolidationData,
1043         typeComputeConsolidationData));
1044
1045   }
1046
1047   private boolean isThereMoreThanOneComputeTypeInstance(
1048       TypeComputeConsolidationData typeComputeConsolidationData) {
1049     return typeComputeConsolidationData.getAllComputeNodeTemplateIds().size() > 1;
1050   }
1051
1052   private boolean isNumberOfPortsEqualsBetweenComputeNodes(
1053       TypeComputeConsolidationData typeComputeConsolidationData) {
1054     int startingNumberOfPorts =
1055         getNumberOfPortsPerCompute(typeComputeConsolidationData
1056             .getAllComputeTemplateConsolidationData().iterator().next());
1057
1058     for (ComputeTemplateConsolidationData compute : typeComputeConsolidationData
1059         .getAllComputeTemplateConsolidationData()) {
1060       if (getNumberOfPortsPerCompute(compute) != startingNumberOfPorts) {
1061         return false;
1062       }
1063     }
1064
1065     return true;
1066   }
1067
1068
1069   private boolean isNumberOfPortFromEachTypeLegal(
1070       TypeComputeConsolidationData typeComputeConsolidationData) {
1071
1072     Collection<ComputeTemplateConsolidationData> computeTemplateConsolidationDataList =
1073         typeComputeConsolidationData.getAllComputeTemplateConsolidationData();
1074
1075     for (ComputeTemplateConsolidationData computeTemplate : computeTemplateConsolidationDataList) {
1076       Map<String, List<String>> currPortsMap = computeTemplate.getPorts();
1077       if (MapUtils.isEmpty(currPortsMap)) {
1078         return true;
1079       }
1080       for (List<String> portList : currPortsMap.values()) {
1081         if (portList.size() > 1) {
1082           return false;
1083         }
1084       }
1085     }
1086
1087     return true;
1088   }
1089
1090   private boolean isPortTypesEqualsBetweenComputeNodes(
1091       TypeComputeConsolidationData typeComputeConsolidationData) {
1092     Set<String> staringPortIds = getPortsIds(
1093         typeComputeConsolidationData.getAllComputeTemplateConsolidationData().iterator().next());
1094
1095     for (ComputeTemplateConsolidationData compute : typeComputeConsolidationData
1096         .getAllComputeTemplateConsolidationData()) {
1097       Set<String> currentPortIds = getPortsIds(compute);
1098       if (!currentPortIds.equals(staringPortIds)) {
1099         return false;
1100       }
1101     }
1102     return true;
1103   }
1104
1105   private int getNumberOfPortsPerCompute(
1106       ComputeTemplateConsolidationData computeTemplateConsolidationData) {
1107     return getPortsIds(computeTemplateConsolidationData).size();
1108   }
1109
1110   private Set<String> getPortsIds(
1111       ComputeTemplateConsolidationData computeTemplateConsolidationData) {
1112     return MapUtils.isEmpty(computeTemplateConsolidationData.getPorts()) ? new HashSet<>()
1113         : computeTemplateConsolidationData.getPorts().keySet();
1114   }
1115
1116   List<String> getPropertiesWithIdenticalVal(UnifiedCompositionEntity entity) {
1117     switch (entity) {
1118       case COMPUTE:
1119         return getComputePropertiesWithIdenticalVal();
1120
1121       case OTHER:
1122         return getComputePropertiesWithIdenticalVal();
1123
1124       case PORT:
1125         return getPortPropertiesWithIdenticalVal();
1126
1127       default:
1128         return new ArrayList<>();
1129     }
1130   }
1131
1132   private List<String> getComputePropertiesWithIdenticalVal() {
1133     List<String> propertyWithIdenticalValue = new ArrayList<>();
1134     propertyWithIdenticalValue.add(ToscaConstants.COMPUTE_IMAGE);
1135     propertyWithIdenticalValue.add(ToscaConstants.COMPUTE_FLAVOR);
1136     return propertyWithIdenticalValue;
1137   }
1138
1139   private List<String> getPortPropertiesWithIdenticalVal() {
1140     List<String> propertiesThatNeedToHaveIdenticalVal = new ArrayList<>();
1141     propertiesThatNeedToHaveIdenticalVal.add(ToscaConstants.PORT_ALLOWED_ADDRESS_PAIRS);
1142     propertiesThatNeedToHaveIdenticalVal.add(ToscaConstants.MAC_ADDRESS);
1143
1144     propertiesThatNeedToHaveIdenticalVal
1145         .addAll(TranslationContext.getEnrichPortResourceProperties());
1146
1147     return propertiesThatNeedToHaveIdenticalVal;
1148   }
1149
1150   private List<String> getPortPropertiesThatNeedToHaveSameUsage() {
1151     List<String> propertiesThatNeedToHaveSameUsage = new ArrayList<>();
1152     propertiesThatNeedToHaveSameUsage.add(ToscaConstants.PORT_FIXED_IPS);
1153     propertiesThatNeedToHaveSameUsage.add(ToscaConstants.PORT_ALLOWED_ADDRESS_PAIRS);
1154     propertiesThatNeedToHaveSameUsage.add(ToscaConstants.MAC_ADDRESS);
1155
1156     propertiesThatNeedToHaveSameUsage.addAll(TranslationContext.getEnrichPortResourceProperties());
1157
1158     return propertiesThatNeedToHaveSameUsage;
1159   }
1160
1161 }
1162