gerrit.onap Code Review - sdc.git/blob

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