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