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