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