openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationService.java

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