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                 && firstEntityMap.keySet().equals(secondEntityMap.keySet());
 498     }
 499
 500   private boolean checkGroupIdsRelations(EntityConsolidationData startingEntity,
 501                                          EntityConsolidationData currentEntity) {
 502     return CollectionUtils.isEmpty(startingEntity.getGroupIds())
 503         && CollectionUtils.isEmpty(currentEntity.getGroupIds())
 504         || startingEntity.getGroupIds().equals(currentEntity.getGroupIds());
 505
 506   }
 507
 508     private boolean checkComputesRelationsToVolume(
 509             Collection<ComputeTemplateConsolidationData> computeTemplateConsolidationEntities) {
 510         Iterator<ComputeTemplateConsolidationData> iterator =
 511                 computeTemplateConsolidationEntities.iterator();
 512
 513         Multimap<String, RequirementAssignmentData> startingVolumes =
 514                 iterator.next().getVolumes();
 515
 516         for (ComputeTemplateConsolidationData compute : computeTemplateConsolidationEntities) {
 517             Multimap<String, RequirementAssignmentData> currentVolumes =
 518                     compute.getVolumes();
 519             if (!compareNodeConnectivity(startingVolumes, currentVolumes)) {
 520                 return false;
 521             }
 522         }
 523         return true;
 524     }
 525
 526
 527   private boolean checkPortConsolidation(ServiceTemplate serviceTemplate,
 528                                          TypeComputeConsolidationData typeComputeConsolidationData,
 529                                          ConsolidationData consolidationData) {
 530     return validateWantedPortProperties(serviceTemplate,
 531         typeComputeConsolidationData)
 532         && checkPortRelations(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
 533         typeComputeConsolidationData, consolidationData);
 534   }
 535
 536
 537     private boolean validateWantedPortProperties(ServiceTemplate serviceTemplate,
 538                                                         TypeComputeConsolidationData typeComputeConsolidationData) {
 539         Map<String, List<String>> portTypeToIds =
 540                 typeComputeConsolidationData.collectAllPortsOfEachTypeFromComputes();
 541
 542         List<String> propertiesWithIdenticalVal = getPortPropertiesWithIdenticalVal();
 543         List<String> propertiesThatNeedToHaveSameUsage = getPortPropertiesThatNeedToHaveSameUsage();
 544
 545         for (List<String> portsIds : portTypeToIds.values()) {
 546             if (!arePortPropertiesValid(
 547                     serviceTemplate, propertiesWithIdenticalVal, propertiesThatNeedToHaveSameUsage,  portsIds)) {
 548                 return false;
 549             }
 550         }
 551
 552         return true;
 553     }
 554
 555   private boolean arePortPropertiesValid(ServiceTemplate serviceTemplate,
 556                                          List<String> propertiesWithIdenticalVal,
 557                                          List<String> propertiesThatNeedToHaveSameUsage,
 558                                          List<String> portsIds) {
 559     Map<String, NodeTemplate> nodeTemplates =
 560         serviceTemplate.getTopology_template().getNode_templates();
 561
 562     Predicate<String> similar = property ->
 563         isPropertyValueSimilarBetweenNodeTemplates(property,
 564             portsIds, nodeTemplates);
 565
 566     Predicate<String> exists = property ->
 567         isPropertyUsageSimilarBetweenAllNodeTemplates(property,
 568             portsIds, nodeTemplates);
 569
 570     return areWantedPortPropertiesValid(
 571         propertiesWithIdenticalVal, similar)
 572         && areWantedPortPropertiesValid(
 573         propertiesThatNeedToHaveSameUsage, exists);
 574   }
 575
 576     private boolean checkPortRelations(String serviceTemplateName,
 577                                               TypeComputeConsolidationData typeComputeConsolidationData,
 578                                               ConsolidationData consolidationData) {
 579         Map<String, List<String>> portTypeToIds =
 580                 typeComputeConsolidationData.collectAllPortsOfEachTypeFromComputes();
 581
 582         for (List<String> portIds : portTypeToIds.values()) {
 583             List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
 584                     collectAllPortsTemplateConsolidationData(portIds, serviceTemplateName, consolidationData);
 585
 586             if (!checkEntityConsolidationDataRelations(portTemplateConsolidationDataList) || !checkSubInterfaceRules(
 587                     portTemplateConsolidationDataList)) {
 588                 return false;
 589             }
 590         }
 591
 592         return true;
 593     }
 594
 595   private boolean checkSubInterfaceRules(List<PortTemplateConsolidationData>
 596                                              portTemplateConsolidationDataList) {
 597     ListMultimap<String, SubInterfaceTemplateConsolidationData> subInterfaceTypeToEntity =
 598         collectAllSubInterfacesFromSameTypeFromPorts(portTemplateConsolidationDataList);
 599     List<SubInterfaceTemplateConsolidationData> subInterfaceList = new ArrayList<>(subInterfaceTypeToEntity.values());
 600     return areSubInterfacePropertiesAndRelationsValid(subInterfaceList);
 601   }
 602
 603   private boolean areSubInterfacePropertiesAndRelationsValid(
 604       List<SubInterfaceTemplateConsolidationData> subInterfaceList) {
 605     return isResourceGroupPropertiesSimilarBetweenSubPorts(subInterfaceList)
 606         && checkSubInterfaceRelations(subInterfaceList)
 607         && !areThereGetAttrRelationsBetweenSubInterfacesOfSameType(
 608         getSubInterfaceIdsFromSameType(subInterfaceList), subInterfaceList);
 609   }
 610
 611   private boolean checkSubInterfaceRelations(List<SubInterfaceTemplateConsolidationData>
 612                                                  subInterfaceList) {
 613     return CollectionUtils.isEmpty(subInterfaceList)
 614         || checkEntityConsolidationDataRelations(subInterfaceList);
 615   }
 616
 617   private boolean isResourceGroupPropertiesSimilarBetweenSubPorts(
 618       List<SubInterfaceTemplateConsolidationData> subInterfaceList) {
 619     if (CollectionUtils.isEmpty(subInterfaceList)) {
 620       return true;
 621     }
 622
 623     SubInterfaceTemplateConsolidationData startingSubInterface = subInterfaceList.get(0);
 624     for (SubInterfaceTemplateConsolidationData subInterface : subInterfaceList) {
 625       if (!startingSubInterface.getResourceGroupCount().equals(subInterface.getResourceGroupCount())
 626           || !StringUtils.equals(startingSubInterface.getNetworkRole(), subInterface.getNetworkRole())) {
 627         return false;
 628       }
 629     }
 630
 631     return true;
 632   }
 633
 634   private List<String> getSubInterfaceIdsFromSameType(List<SubInterfaceTemplateConsolidationData>
 635                                                           subInterfaceList) {
 636     if (CollectionUtils.isEmpty(subInterfaceList)) {
 637       return new ArrayList<>();
 638     }
 639
 640     return subInterfaceList.stream().map(SubInterfaceTemplateConsolidationData::getNodeTemplateId)
 641         .collect(Collectors.toList());
 642   }
 643
 644   private ListMultimap<String, SubInterfaceTemplateConsolidationData> collectAllSubInterfacesFromSameTypeFromPorts(
 645       List<PortTemplateConsolidationData> portTemplateConsolidationDataList) {
 646     ListMultimap<String, SubInterfaceTemplateConsolidationData>  subInterfaceTypeToEntity = ArrayListMultimap.create();
 647     for (PortTemplateConsolidationData portTemplateConsolidationData : portTemplateConsolidationDataList) {
 648       portTemplateConsolidationData.copyMappedInto(subInterfaceTypeToEntity);
 649     }
 650
 651     return subInterfaceTypeToEntity;
 652   }
 653
 654   private List<PortTemplateConsolidationData> collectAllPortsTemplateConsolidationData(List<String> portIds,
 655                                                                                        String serviceTemplateName,
 656                                                                                        ConsolidationData consolidationData) {
 657
 658     FilePortConsolidationData filePortConsolidationData =
 659         consolidationData.getPortConsolidationData()
 660             .getFilePortConsolidationData(serviceTemplateName);
 661     List<PortTemplateConsolidationData> portTemplateConsolidationDataList = new ArrayList<>();
 662
 663     for (String portId : portIds) {
 664       PortTemplateConsolidationData portTemplateConsolidationData = filePortConsolidationData
 665           .getPortTemplateConsolidationData(portId);
 666       if (Objects.nonNull(portTemplateConsolidationData)) {
 667         portTemplateConsolidationDataList.add(portTemplateConsolidationData);
 668       }
 669     }
 670
 671     return portTemplateConsolidationDataList;
 672   }
 673
 674   private boolean areWantedPortPropertiesValid(List<String> propertiesToCheck,
 675                                                Predicate<String> condition) {
 676
 677     return propertiesToCheck.stream().allMatch(condition);
 678   }
 679
 680
 681   private boolean arePropertiesSimilarBetweenComputeNodeTemplates(
 682       ServiceTemplate serviceTemplate,
 683       Collection<String> computeNodeTemplateIds,
 684       List<String> propertiesThatNeedToBeSimilar) {
 685
 686     Map<String, NodeTemplate> idToNodeTemplate =
 687         serviceTemplate.getTopology_template().getNode_templates();
 688
 689     for (String property : propertiesThatNeedToBeSimilar) {
 690       if (!isPropertyValueSimilarBetweenNodeTemplates(property, computeNodeTemplateIds,
 691           idToNodeTemplate)) {
 692         return false;
 693       }
 694     }
 695     return true;
 696   }
 697
 698   private boolean isPropertyUsageSimilarBetweenAllNodeTemplates(String propertyToCheck,
 699                                                                 List<String> entityNodeTemplateIds,
 700                                                                 Map<String, NodeTemplate> idToNodeTemplate) {
 701     NodeTemplate startingNodeTemplate = idToNodeTemplate.get(entityNodeTemplateIds.get(0));
 702     if (Objects.isNull(startingNodeTemplate)) {
 703       throw new CoreException(
 704           new DuplicateResourceIdsInDifferentFilesErrorBuilder(entityNodeTemplateIds.get(0))
 705               .build());
 706     }
 707
 708     boolean propertyExistCondition =
 709         isPropertyExistInNodeTemplate(propertyToCheck, startingNodeTemplate);
 710
 711     for (int i = 1; i < entityNodeTemplateIds.size(); i++) {
 712       NodeTemplate currentNodeTemplate = idToNodeTemplate.get(entityNodeTemplateIds.get(i));
 713       if (Objects.isNull(currentNodeTemplate)) {
 714         throw new CoreException(
 715             new DuplicateResourceIdsInDifferentFilesErrorBuilder(entityNodeTemplateIds.get(i))
 716                 .build());
 717       }
 718       if (propertyExistCondition != isPropertyExistInNodeTemplate(propertyToCheck, currentNodeTemplate)) {
 719         return false;
 720       }
 721     }
 722
 723     return true;
 724
 725   }
 726
 727   private boolean isPropertyValueSimilarBetweenNodeTemplates(String propertyToCheck,
 728                                                              Collection<String> entityNodeTemplateIds,
 729                                                              Map<String, NodeTemplate> idToNodeTemplate) {
 730
 731     Set<Object> propertiesValues = new HashSet<>();
 732     Iterator<String> iterator = entityNodeTemplateIds.iterator();
 733
 734     handlePropertyValue(propertyToCheck, idToNodeTemplate, propertiesValues, iterator.next());
 735
 736     while (iterator.hasNext()) {
 737       handlePropertyValue(propertyToCheck, idToNodeTemplate, propertiesValues, iterator.next());
 738     }
 739
 740     return propertiesValues.size() == 1;
 741   }
 742
 743   private void handlePropertyValue(String propertyToCheck,
 744                                    Map<String, NodeTemplate> idToNodeTemplate,
 745                                    Set<Object> propertiesValues, String nodeId) {
 746     NodeTemplate startingNodeTemplate = idToNodeTemplate.get(nodeId);
 747     if (Objects.isNull(startingNodeTemplate)) {
 748       throw new CoreException(
 749           new DuplicateResourceIdsInDifferentFilesErrorBuilder(nodeId)
 750               .build());
 751     }
 752
 753     addPropertyValue(propertyToCheck, startingNodeTemplate, propertiesValues);
 754   }
 755
 756   private void addPropertyValue(String property,
 757                                 NodeTemplate nodeTemplate,
 758                                 Set<Object> propertiesValues) {
 759     propertiesValues.add(
 760         isPropertyExistInNodeTemplate(property, nodeTemplate) ? nodeTemplate.getProperties()
 761             .get(property) : "");
 762   }
 763
 764   private boolean isPropertyExistInNodeTemplate(String propertyToCheck, NodeTemplate nodeTemplate) {
 765     return !(nodeTemplate.getProperties() == null
 766        || nodeTemplate.getProperties().get(propertyToCheck) == null);
 767   }
 768
 769     void substitutionServiceTemplateConsolidation(String substituteNodeTemplateId,
 770                                                          ServiceTemplate serviceTemplate,
 771                                                          ServiceTemplate substitutionServiceTemplate,
 772                                                          TranslationContext translationContext) {
 773
 774         ConsolidationData consolidationData = translationContext.getConsolidationData();
 775
 776         boolean substitutionConsolidationRuleResult =
 777                 substitutionServiceTemplateConsolidationRule(substitutionServiceTemplate, translationContext);
 778
 779         if (substitutionConsolidationRuleResult) {
 780             List<UnifiedCompositionData> unifiedCompositionDataList =
 781                     createSubstitutionUnifiedCompositionDataList(substituteNodeTemplateId, serviceTemplate,
 782                             substitutionServiceTemplate, consolidationData);
 783             unifiedCompositionService
 784                     .createUnifiedComposition(serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList,
 785                             UnifiedCompositionMode.NestedSingleCompute, translationContext);
 786         } else {
 787             //The node template does not represent unified VFC but complexVFC
 788             //Adding the id in the context for fixing connectivity from/to nested non-unified nodes
 789             translationContext.addUnifiedNestedNodeTemplateId(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
 790                     substituteNodeTemplateId, substituteNodeTemplateId);
 791
 792             if (!translationContext.isUnifiedHandledServiceTemplate(substitutionServiceTemplate)) {
 793                 serviceTemplateConsolidation(substitutionServiceTemplate, translationContext);
 794             }
 795         }
 796     }
 797
 798     private boolean substitutionServiceTemplateConsolidationRule(ServiceTemplate nestedServiceTemplate,
 799                                                                         TranslationContext context) {
 800         ConsolidationData consolidationData = context.getConsolidationData();
 801
 802         return consolidationData.getComputeConsolidationDataHandler().isNumberOfComputeTypesLegal(
 803                 ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate))
 804                        && !isThereMoreThanOneNestedLevel(nestedServiceTemplate, context);
 805     }
 806
 807     private boolean isThereMoreThanOneNestedLevel(ServiceTemplate nestedServiceTemplate,
 808                                                          TranslationContext context) {
 809         String nestedServiceTemplateName = ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate);
 810         if (Objects.isNull(nestedServiceTemplateName)) {
 811             return false;
 812         }
 813
 814         NestedConsolidationDataHandler nestedConsolidationDataHandler = context.getNestedConsolidationDataHandler();
 815
 816         //Condition to check if there is nested file and if file contains only sub interfaces then
 817         // return false
 818         return nestedConsolidationDataHandler.isNestedConsolidationDataExist(nestedServiceTemplateName)
 819                        && !ifNestedFileContainsOnlySubInterface(nestedServiceTemplate, context);
 820     }
 821
 822     private boolean ifNestedFileContainsOnlySubInterface(ServiceTemplate serviceTemplate, TranslationContext context) {
 823         Map<String, NodeTemplate> nestedNodeTemplateMap = DataModelUtil.getNodeTemplates(serviceTemplate);
 824
 825         Set<String> nestedHeatFileNames = getNestedHeatFileNames(nestedNodeTemplateMap);
 826
 827         return ifAllResourceAreSubInterface(nestedHeatFileNames, context);
 828     }
 829
 830     private Set<String> getNestedHeatFileNames(Map<String, NodeTemplate> nestedNodeTemplateMap) {
 831         ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
 832
 833         return nestedNodeTemplateMap.entrySet().stream()
 834                                     .filter(entry -> toscaAnalyzerService.isSubstitutableNodeTemplate(entry.getValue())
 835                                                            && toscaAnalyzerService.getSubstituteServiceTemplateName(
 836                                                                       entry.getKey(), entry.getValue()).isPresent())
 837                                     .map(entry -> toscaAnalyzerService.getSubstituteServiceTemplateName(
 838                                                                     entry.getKey(), entry.getValue()).get())
 839                                     .collect(Collectors.toSet());
 840     }
 841
 842     // Method returns true if all of the resource are sub interface
 843     private boolean ifAllResourceAreSubInterface(Set<String> nestedHeatFileNames,
 844                                                       TranslationContext context) {
 845         if (nestedHeatFileNames.isEmpty()) {
 846           return true;
 847         }
 848
 849         for (String fileName : nestedHeatFileNames) {
 850             String heatFileName = context.getNestedHeatFileName().get(fileName);
 851
 852             if (Objects.nonNull(heatFileName)
 853                         && !context.getTranslatedServiceTemplates().get(heatFileName).getTopology_template()
 854                                 .getNode_templates().values().stream()
 855                                     .allMatch(nodeTemplate -> ToscaNodeType.CONTRAILV2_VLAN_SUB_INTERFACE
 856                                                                       .equals(nodeTemplate.getType()))) {
 857                 return false;
 858             }
 859         }
 860
 861         return true;
 862     }
 863
 864   private List<UnifiedCompositionData> createUnifiedCompositionDataList(
 865       ServiceTemplate serviceTemplate,
 866       ConsolidationData consolidationData,
 867       TypeComputeConsolidationData typeComputeConsolidationData) {
 868
 869     List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 870
 871     for (ComputeTemplateConsolidationData computeTemplateConsolidationData : typeComputeConsolidationData
 872         .getAllComputeTemplateConsolidationData()) {
 873       UnifiedCompositionData unifiedCompositionData = new UnifiedCompositionData();
 874       unifiedCompositionData.setComputeTemplateConsolidationData(computeTemplateConsolidationData);
 875       FilePortConsolidationData filePortConsolidationData =
 876           consolidationData.getPortConsolidationData().getFilePortConsolidationData(ToscaUtil
 877               .getServiceTemplateFileName(serviceTemplate));
 878       setUnifiedCompositionDataWithPortTemplateData(computeTemplateConsolidationData, filePortConsolidationData,
 879           unifiedCompositionData);
 880       unifiedCompositionDataList.add(unifiedCompositionData);
 881     }
 882     return unifiedCompositionDataList;
 883   }
 884
 885   private void setPortTemplateConsolidationData(FilePortConsolidationData filePortConsolidationData,
 886                                                 String portId,
 887                                                 UnifiedCompositionData unifiedCompositionData,
 888                                                 List<SubInterfaceTemplateConsolidationData>
 889                                                                  subInterfaceTemplateConsolidationDataList) {
 890     if (Objects.isNull(filePortConsolidationData)) {
 891       return;
 892     }
 893     PortTemplateConsolidationData portTemplateConsolidationData =
 894         filePortConsolidationData.getPortTemplateConsolidationData(portId);
 895     unifiedCompositionData.addPortTemplateConsolidationData(portTemplateConsolidationData);
 896     if (portTemplateConsolidationData != null) {
 897       portTemplateConsolidationData.copyFlatInto(subInterfaceTemplateConsolidationDataList);
 898     }
 899   }
 900
 901   private List<UnifiedCompositionData> createSubstitutionUnifiedCompositionDataList(
 902       String substituteNodeTemplateId,
 903       ServiceTemplate serviceTemplate,
 904       ServiceTemplate substitutionServiceTemplate,
 905       ConsolidationData consolidationData) {
 906     List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 907     FileNestedConsolidationData fileNestedConsolidationData =
 908         consolidationData.getNestedConsolidationData()
 909             .getFileNestedConsolidationData(ToscaUtil.getServiceTemplateFileName(serviceTemplate));
 910
 911     if (Objects.nonNull(fileNestedConsolidationData)) {
 912       NestedTemplateConsolidationData nestedTemplateConsolidationData =
 913           fileNestedConsolidationData.getNestedTemplateConsolidationData(substituteNodeTemplateId);
 914       UnifiedCompositionData unifiedCompositionData = new UnifiedCompositionData();
 915       unifiedCompositionData.setNestedTemplateConsolidationData(nestedTemplateConsolidationData);
 916       unifiedCompositionDataList.add(unifiedCompositionData);
 917       addSubInterfaceDataToNestedCompositionData(substitutionServiceTemplate, consolidationData,
 918           unifiedCompositionData);
 919     }
 920
 921     return unifiedCompositionDataList;
 922   }
 923
 924   private void addSubInterfaceDataToNestedCompositionData(ServiceTemplate substitutionServiceTemplate,
 925                                                           ConsolidationData consolidationData,
 926                                                           UnifiedCompositionData unifiedCompositionData) {
 927     FileComputeConsolidationData nestedFileComputeConsolidationData = consolidationData.getComputeConsolidationData()
 928         .getFileComputeConsolidationData(ToscaUtil.getServiceTemplateFileName(substitutionServiceTemplate));
 929     FilePortConsolidationData nestedFilePortConsolidationData = consolidationData.getPortConsolidationData()
 930         .getFilePortConsolidationData(ToscaUtil.getServiceTemplateFileName(substitutionServiceTemplate));
 931     if (Objects.isNull(nestedFileComputeConsolidationData)
 932         || Objects.isNull(nestedFilePortConsolidationData)) {
 933       return;
 934     }
 935     TypeComputeConsolidationData computeType =
 936         nestedFileComputeConsolidationData.getAllTypeComputeConsolidationData().iterator().next();
 937     if (Objects.isNull(computeType)) {
 938       return;
 939     }
 940     ComputeTemplateConsolidationData computeTemplateConsolidationData =
 941         computeType.getAllComputeTemplateConsolidationData().iterator().next();
 942     setUnifiedCompositionDataWithPortTemplateData(computeTemplateConsolidationData, nestedFilePortConsolidationData,
 943         unifiedCompositionData);
 944   }
 945
 946   private void setUnifiedCompositionDataWithPortTemplateData(ComputeTemplateConsolidationData
 947                                                                  computeTemplateConsolidationData,
 948                                                              FilePortConsolidationData filePortConsolidationData,
 949                                                              UnifiedCompositionData unifiedCompositionData) {
 950     Collection<List<String>> portCollection =
 951         computeTemplateConsolidationData.getPorts() == null ? Collections.emptyList()
 952             : computeTemplateConsolidationData.getPorts().values();
 953     List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList = new ArrayList<>();
 954     portCollection.stream()
 955         .flatMap(Collection::stream)
 956         .forEach(portId -> setPortTemplateConsolidationData(filePortConsolidationData, portId,
 957             unifiedCompositionData, subInterfaceTemplateConsolidationDataList));
 958     unifiedCompositionData.setSubInterfaceTemplateConsolidationDataList(
 959         subInterfaceTemplateConsolidationDataList);
 960   }
 961
 962   private boolean consolidationPreCondition(
 963       ServiceTemplate serviceTemplate,
 964       ConsolidationData consolidationData,
 965       TypeComputeConsolidationData typeComputeConsolidationData) {
 966
 967     return (typeComputeConsolidationData.isThereMoreThanOneComputeTypeInstance()
 968         && typeComputeConsolidationData.isNumberOfPortsEqualsBetweenComputeNodes()
 969         && typeComputeConsolidationData.isNumberOfPortFromEachTypeLegal()
 970         && typeComputeConsolidationData.isPortTypesEqualsBetweenComputeNodes()
 971         && checkGetAttrBetweenConsolidationDataEntitiesNotFromSameType(serviceTemplate,
 972         typeComputeConsolidationData, consolidationData)
 973         && checkSubInterfaceConsolidationPreCondition(serviceTemplate, consolidationData,
 974         typeComputeConsolidationData));
 975
 976   }
 977
 978   List<String> getPropertiesWithIdenticalVal(UnifiedCompositionEntity entity) {
 979     switch (entity) {
 980       case COMPUTE:
 981         return getComputePropertiesWithIdenticalVal();
 982
 983       case OTHER:
 984         return getComputePropertiesWithIdenticalVal();
 985
 986       case PORT:
 987         return getPortPropertiesWithIdenticalVal();
 988
 989       default:
 990         return new ArrayList<>();
 991     }
 992   }
 993
 994   private List<String> getComputePropertiesWithIdenticalVal() {
 995     List<String> propertyWithIdenticalValue = new ArrayList<>();
 996     propertyWithIdenticalValue.add(ToscaConstants.COMPUTE_IMAGE);
 997     propertyWithIdenticalValue.add(ToscaConstants.COMPUTE_FLAVOR);
 998     return propertyWithIdenticalValue;
 999   }
1000
1001   private List<String> getPortPropertiesWithIdenticalVal() {
1002     List<String> propertiesThatNeedToHaveIdenticalVal = new ArrayList<>();
1003     propertiesThatNeedToHaveIdenticalVal.add(ToscaConstants.PORT_ALLOWED_ADDRESS_PAIRS);
1004     propertiesThatNeedToHaveIdenticalVal.add(ToscaConstants.MAC_ADDRESS);
1005
1006     propertiesThatNeedToHaveIdenticalVal
1007         .addAll(TranslationContext.getEnrichPortResourceProperties());
1008
1009     return propertiesThatNeedToHaveIdenticalVal;
1010   }
1011
1012   private List<String> getPortPropertiesThatNeedToHaveSameUsage() {
1013     List<String> propertiesThatNeedToHaveSameUsage = new ArrayList<>();
1014     propertiesThatNeedToHaveSameUsage.add(ToscaConstants.PORT_FIXED_IPS);
1015     propertiesThatNeedToHaveSameUsage.add(ToscaConstants.PORT_ALLOWED_ADDRESS_PAIRS);
1016     propertiesThatNeedToHaveSameUsage.add(ToscaConstants.MAC_ADDRESS);
1017
1018     propertiesThatNeedToHaveSameUsage.addAll(TranslationContext.getEnrichPortResourceProperties());
1019
1020     return propertiesThatNeedToHaveSameUsage;
1021   }
1022
1023 }
1024