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

   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 org.apache.commons.collections4.MapUtils;
  20 import org.apache.commons.lang3.StringUtils;
  21 import org.openecomp.core.utilities.file.FileUtils;
  22 import org.openecomp.sdc.common.errors.CoreException;
  23 import org.openecomp.sdc.datatypes.configuration.ImplementationConfiguration;
  24 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
  25 import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes;
  26 import org.openecomp.sdc.heat.datatypes.model.Resource;
  27 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
  28 import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
  29 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
  30 import org.openecomp.sdc.tosca.services.DataModelUtil;
  31 import org.openecomp.sdc.tosca.services.ToscaUtil;
  32 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
  33 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
  34 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeConsolidationData;
  35 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData;
  36 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ConsolidationData;
  37 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.EntityConsolidationData;
  38 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FileComputeConsolidationData;
  39 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FileNestedConsolidationData;
  40 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FilePortConsolidationData;
  41 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.GetAttrFuncData;
  42 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedConsolidationData;
  43 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedTemplateConsolidationData;
  44 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortConsolidationData;
  45 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData;
  46 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.RequirementAssignmentData;
  47 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.SubInterfaceTemplateConsolidationData;
  48 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.TypeComputeConsolidationData;
  49 import org.openecomp.sdc.translator.services.heattotosca.errors.DuplicateResourceIdsInDifferentFilesErrorBuilder;
  50
  51 import java.util.ArrayList;
  52 import java.util.HashMap;
  53 import java.util.Iterator;
  54 import java.util.List;
  55 import java.util.Map;
  56 import java.util.Objects;
  57 import java.util.Optional;
  58
  59
  60 /**
  61  * Utility class for consolidation data collection helper methods.
  62  */
  63 public class ConsolidationDataUtil {
  64
  65   private static final String UNDERSCORE = "_";
  66   private static final String DIGIT_REGEX = "\\d+";
  67
  68   private ConsolidationDataUtil() {
  69   }
  70
  71   /**
  72    * Gets compute template consolidation data.
  73    *
  74    * @param context               the translation context
  75    * @param serviceTemplate       the service template
  76    * @param computeNodeType       the compute node type
  77    * @param computeNodeTemplateId the compute node template id
  78    * @return the compute template consolidation data
  79    */
  80   public static ComputeTemplateConsolidationData getComputeTemplateConsolidationData(
  81       TranslationContext context,
  82       ServiceTemplate serviceTemplate,
  83       String computeNodeType,
  84       String computeNodeTemplateId) {
  85
  86     ConsolidationData consolidationData = context.getConsolidationData();
  87     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
  88
  89     ComputeConsolidationData computeConsolidationData = consolidationData
  90         .getComputeConsolidationData();
  91
  92     FileComputeConsolidationData fileComputeConsolidationData = computeConsolidationData
  93         .getFileComputeConsolidationData(serviceTemplateFileName);
  94
  95     if (fileComputeConsolidationData == null) {
  96       fileComputeConsolidationData = new FileComputeConsolidationData();
  97       computeConsolidationData.setFileComputeConsolidationData(serviceTemplateFileName,
  98           fileComputeConsolidationData);
  99     }
 100
 101     TypeComputeConsolidationData typeComputeConsolidationData = fileComputeConsolidationData
 102         .getTypeComputeConsolidationData(computeNodeType);
 103     if (typeComputeConsolidationData == null) {
 104       typeComputeConsolidationData = new TypeComputeConsolidationData();
 105       fileComputeConsolidationData.setTypeComputeConsolidationData(computeNodeType,
 106           typeComputeConsolidationData);
 107     }
 108
 109     ComputeTemplateConsolidationData computeTemplateConsolidationData =
 110         typeComputeConsolidationData.getComputeTemplateConsolidationData(computeNodeTemplateId);
 111     if (computeTemplateConsolidationData == null) {
 112       computeTemplateConsolidationData = new ComputeTemplateConsolidationData();
 113       computeTemplateConsolidationData.setNodeTemplateId(computeNodeTemplateId);
 114       typeComputeConsolidationData.setComputeTemplateConsolidationData(computeNodeTemplateId,
 115           computeTemplateConsolidationData);
 116     }
 117
 118     return computeTemplateConsolidationData;
 119   }
 120
 121
 122   /**
 123    * Gets port template consolidation data.
 124    *
 125    * @param context            the context
 126    * @param serviceTemplate    the service template
 127    * @param portNodeTemplateId the port node template id
 128    * @return the port template consolidation data
 129    */
 130   public static PortTemplateConsolidationData getPortTemplateConsolidationData(TranslationContext context,
 131                                                                                ServiceTemplate serviceTemplate,
 132                                                                                String portResourceId,
 133                                                                                String portResourceType,
 134                                                                                String portNodeTemplateId) {
 135
 136     ConsolidationData consolidationData = context.getConsolidationData();
 137     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 138
 139     PortConsolidationData portConsolidationData = consolidationData.getPortConsolidationData();
 140
 141     FilePortConsolidationData filePortConsolidationData = portConsolidationData
 142         .getFilePortConsolidationData(serviceTemplateFileName);
 143
 144     if (filePortConsolidationData == null) {
 145       filePortConsolidationData = new FilePortConsolidationData();
 146       portConsolidationData.setFilePortConsolidationData(serviceTemplateFileName,
 147           filePortConsolidationData);
 148     }
 149
 150     PortTemplateConsolidationData portTemplateConsolidationData =
 151         filePortConsolidationData.getPortTemplateConsolidationData(portNodeTemplateId);
 152     if (portTemplateConsolidationData == null) {
 153       portTemplateConsolidationData = getInitPortTemplateConsolidationData(portNodeTemplateId,
 154           portResourceId, portResourceType);
 155       filePortConsolidationData.setPortTemplateConsolidationData(portNodeTemplateId, portTemplateConsolidationData);
 156     }
 157
 158     return portTemplateConsolidationData;
 159   }
 160
 161   private static PortTemplateConsolidationData getInitPortTemplateConsolidationData(String portNodeTemplateId,
 162                                                                              String portResourceId,
 163                                                                              String portResourceType) {
 164     PortTemplateConsolidationData portTemplateConsolidationData = new PortTemplateConsolidationData();
 165     portTemplateConsolidationData.setNodeTemplateId(portNodeTemplateId);
 166     Optional<String> portNetworkRole = HeatToToscaUtil.evaluateNetworkRoleFromResourceId(portResourceId,
 167         portResourceType);
 168     portNetworkRole.ifPresent(portTemplateConsolidationData::setNetworkRole);
 169     return portTemplateConsolidationData;
 170   }
 171
 172   public static Optional<SubInterfaceTemplateConsolidationData> getSubInterfaceTemplateConsolidationData(
 173       TranslateTo subInterfaceTo,
 174       String subInterfaceNodeTemplateId) {
 175     Optional<String> parentPortNodeTemplateId =
 176         HeatToToscaUtil.getSubInterfaceParentPortNodeTemplateId(subInterfaceTo);
 177     if (parentPortNodeTemplateId.isPresent()) {
 178       return Optional.ofNullable(getSubInterfaceTemplateConsolidationData(subInterfaceTo,
 179          parentPortNodeTemplateId.get(), subInterfaceNodeTemplateId));
 180     }
 181     return Optional.empty();
 182   }
 183
 184   private static SubInterfaceTemplateConsolidationData getSubInterfaceTemplateConsolidationData(
 185       TranslateTo subInterfaceTo,
 186       String parentPortNodeTemplateId,
 187       String subInterfaceNodeTemplateId) {
 188
 189     ConsolidationData consolidationData = subInterfaceTo.getContext().getConsolidationData();
 190     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(subInterfaceTo.getServiceTemplate());
 191
 192     PortConsolidationData portConsolidationData = consolidationData.getPortConsolidationData();
 193
 194     FilePortConsolidationData filePortConsolidationData = portConsolidationData
 195         .getFilePortConsolidationData(serviceTemplateFileName);
 196
 197     if (filePortConsolidationData == null) {
 198       filePortConsolidationData = new FilePortConsolidationData();
 199       portConsolidationData.setFilePortConsolidationData(serviceTemplateFileName,
 200           filePortConsolidationData);
 201     }
 202
 203     PortTemplateConsolidationData portTemplateConsolidationData =
 204         filePortConsolidationData.getPortTemplateConsolidationData(parentPortNodeTemplateId);
 205     if (portTemplateConsolidationData == null) {
 206       portTemplateConsolidationData = new PortTemplateConsolidationData();
 207       portTemplateConsolidationData.setNodeTemplateId(parentPortNodeTemplateId);
 208       filePortConsolidationData.setPortTemplateConsolidationData(parentPortNodeTemplateId,
 209           portTemplateConsolidationData);
 210     }
 211
 212     return portTemplateConsolidationData.getSubInterfaceResourceTemplateConsolidationData(subInterfaceTo.getResource(),
 213         subInterfaceNodeTemplateId, parentPortNodeTemplateId);
 214   }
 215
 216   /**
 217    * Gets nested template consolidation data.
 218    *
 219    * @param context              the context
 220    * @param serviceTemplate      the service template
 221    * @param nestedNodeTemplateId the nested node template id  @return the nested template
 222    *                             consolidation data
 223    */
 224   public static NestedTemplateConsolidationData getNestedTemplateConsolidationData(
 225       TranslationContext context,
 226       ServiceTemplate serviceTemplate,
 227       String nestedHeatFileName, String nestedNodeTemplateId) {
 228
 229     if (isNestedResourceIdOccuresInDifferentNestedFiles(context, nestedHeatFileName,
 230         nestedNodeTemplateId)) {
 231       throw new CoreException(
 232           new DuplicateResourceIdsInDifferentFilesErrorBuilder(nestedNodeTemplateId).build());
 233     }
 234
 235     if (isNodeTemplatePointsToServiceTemplateWithoutNodeTemplates(
 236         nestedNodeTemplateId, nestedHeatFileName, context)) {
 237       return null;
 238     }
 239
 240     ConsolidationData consolidationData = context.getConsolidationData();
 241     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 242
 243     NestedConsolidationData nestedConsolidationData = consolidationData
 244         .getNestedConsolidationData();
 245
 246     FileNestedConsolidationData fileNestedConsolidationData = nestedConsolidationData
 247         .getFileNestedConsolidationData(serviceTemplateFileName);
 248
 249     if (fileNestedConsolidationData == null) {
 250       fileNestedConsolidationData = new FileNestedConsolidationData();
 251       nestedConsolidationData.setFileNestedConsolidationData(serviceTemplateFileName,
 252           fileNestedConsolidationData);
 253     }
 254
 255     NestedTemplateConsolidationData nestedTemplateConsolidationData =
 256         fileNestedConsolidationData.getNestedTemplateConsolidationData(nestedNodeTemplateId);
 257     if (nestedTemplateConsolidationData == null) {
 258       nestedTemplateConsolidationData = new NestedTemplateConsolidationData();
 259       nestedTemplateConsolidationData.setNodeTemplateId(nestedNodeTemplateId);
 260       fileNestedConsolidationData.setNestedTemplateConsolidationData(nestedNodeTemplateId,
 261           nestedTemplateConsolidationData);
 262     }
 263
 264     return nestedTemplateConsolidationData;
 265   }
 266
 267   public static boolean isNodeTemplatePointsToServiceTemplateWithoutNodeTemplates(String
 268                                                                                       nestedNodeTemplateId,
 269                                                                                   String nestedHeatFileName,
 270                                                                                   TranslationContext context) {
 271
 272     return context.isServiceTemplateWithoutNodeTemplatesSection(
 273         FileUtils.getFileWithoutExtention(nestedHeatFileName))
 274         || context.isNodeTemplateIdPointsToStWithoutNodeTemplates(nestedNodeTemplateId);
 275   }
 276
 277   private static boolean isNestedResourceIdOccuresInDifferentNestedFiles(TranslationContext context,
 278                                                                          String nestedHeatFileName,
 279                                                                          String nestedNodeTemplateId) {
 280     return Objects.nonNull(nestedHeatFileName)
 281         && context.getAllTranslatedResourceIdsFromDiffNestedFiles(nestedHeatFileName)
 282         .contains(nestedNodeTemplateId);
 283   }
 284
 285   /**
 286    * Update group id information in consolidation data.
 287    *
 288    * @param entityConsolidationData Entity consolidation data (Port/Compute)
 289    * @param translatedGroupId       Group id of which compute node is a part
 290    */
 291   public static void updateGroupIdInConsolidationData(EntityConsolidationData
 292                                                           entityConsolidationData,
 293                                                       String translatedGroupId) {
 294     if (entityConsolidationData.getGroupIds() == null) {
 295       entityConsolidationData.setGroupIds(new ArrayList<>());
 296     }
 297     entityConsolidationData.getGroupIds().add(translatedGroupId);
 298   }
 299
 300   /**
 301    * Update volume information in consolidation data.
 302    *
 303    * @param translateTo           {@link TranslateTo} object
 304    * @param computeType           Local type of the compute node
 305    * @param computeNodeTemplateId Node template id of the compute node
 306    * @param requirementAssignment RequirementAssignment object
 307    */
 308   public static void updateComputeConsolidationDataVolumes(TranslateTo translateTo,
 309                                                            String computeType,
 310                                                            String computeNodeTemplateId,
 311                                                            String requirementId,
 312                                                            RequirementAssignment
 313                                                                requirementAssignment) {
 314     TranslationContext translationContext = translateTo.getContext();
 315     ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 316     ComputeTemplateConsolidationData computeTemplateConsolidationData =
 317         getComputeTemplateConsolidationData(translationContext, serviceTemplate, computeType,
 318             computeNodeTemplateId);
 319     computeTemplateConsolidationData.addVolume(requirementId, requirementAssignment);
 320   }
 321
 322
 323   /**
 324    * Update port in consolidation data.
 325    *
 326    * @param translateTo        the translate to
 327    * @param computeNodeType    the compute node type
 328    * @param portResourceId     the port resource id
 329    * @param portNodeTemplateId the port node template id
 330    */
 331   public static void updatePortInConsolidationData(TranslateTo translateTo,
 332                                                    String computeNodeType,
 333                                                    String portResourceId,
 334                                                    String portResourceType,
 335                                                    String portNodeTemplateId) {
 336     TranslationContext translationContext = translateTo.getContext();
 337     ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 338     ComputeTemplateConsolidationData computeTemplateConsolidationData =
 339         getComputeTemplateConsolidationData(translationContext, serviceTemplate, computeNodeType,
 340             translateTo.getTranslatedId());
 341     computeTemplateConsolidationData.addPort(getPortType(portNodeTemplateId), portNodeTemplateId);
 342     // create port in consolidation data
 343     getPortTemplateConsolidationData(translationContext, serviceTemplate, portResourceId,
 344         portResourceType, portNodeTemplateId);
 345   }
 346
 347   /**
 348    * Update nodes connected in and out for Depends on and connectivity in consolidation data.
 349    *
 350    * @param translateTo           the translate to
 351    * @param targetResourceId      the target resource id
 352    * @param nodeTemplateId        the source node template id
 353    * @param requirementAssignment the requirement assignment
 354    */
 355   public static void updateNodesConnectedData(TranslateTo translateTo, String targetResourceId,
 356                                               Resource targetResource, Resource sourceResource,
 357                                               String nodeTemplateId, String requirementId,
 358                                               RequirementAssignment requirementAssignment) {
 359     ConsolidationEntityType consolidationEntityType = ConsolidationEntityType.OTHER;
 360     consolidationEntityType.setEntityType(sourceResource, targetResource, translateTo.getContext());
 361     // Add resource dependency information in nodesConnectedIn if the target node
 362     // is a consolidation entity
 363     if (isConsolidationEntity(consolidationEntityType.getTargetEntityType())) {
 364       ConsolidationDataUtil.updateNodesConnectedIn(translateTo,
 365           nodeTemplateId, consolidationEntityType.getTargetEntityType(), targetResourceId,
 366           requirementId, requirementAssignment);
 367     }
 368
 369     //Add resource dependency information in nodesConnectedOut if the source node
 370     //is a consolidation entity
 371     if (isConsolidationEntity(consolidationEntityType.getSourceEntityType())) {
 372       ConsolidationDataUtil.updateNodesConnectedOut(translateTo,
 373           requirementAssignment.getNode(), consolidationEntityType.getSourceEntityType(),
 374           requirementId, requirementAssignment);
 375
 376     }
 377   }
 378
 379
 380   private static boolean isConsolidationEntity(ConsolidationEntityType consolidationEntityType) {
 381     return ConsolidationEntityType.getSupportedConsolidationEntities().contains(consolidationEntityType);
 382   }
 383
 384   /**
 385    * Update nodes connected from this node in consolidation data.
 386    *
 387    * @param translateTo             the translate to
 388    * @param nodeTemplateId          the node template id of the target node
 389    * @param consolidationEntityType the entity type (compute or port)
 390    * @param requirementId           the requirement id
 391    * @param requirementAssignment   the requirement assignment
 392    */
 393   public static void updateNodesConnectedOut(TranslateTo translateTo,
 394                                              String nodeTemplateId,
 395                                              ConsolidationEntityType consolidationEntityType,
 396                                              String requirementId,
 397                                              RequirementAssignment requirementAssignment) {
 398     EntityConsolidationData entityConsolidationData = null;
 399     TranslationContext translationContext = translateTo.getContext();
 400     ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 401
 402     translationContext.updateRequirementAssignmentIdIndex(ToscaUtil.getServiceTemplateFileName
 403         (translateTo.getServiceTemplate()), translateTo.getResourceId(), requirementId);
 404
 405     RequirementAssignmentData requirementAssignmentData = new RequirementAssignmentData(
 406         requirementId, requirementAssignment);
 407
 408     if (consolidationEntityType == ConsolidationEntityType.COMPUTE) {
 409       String nodeType = DataModelUtil.getNodeTemplate(serviceTemplate, translateTo
 410           .getTranslatedId()).getType();
 411       entityConsolidationData = getComputeTemplateConsolidationData(translationContext,
 412           serviceTemplate, nodeType, translateTo.getTranslatedId());
 413     } else if (consolidationEntityType == ConsolidationEntityType.PORT) {
 414       entityConsolidationData = getPortTemplateConsolidationData(translationContext, serviceTemplate,
 415           translateTo.getResourceId(), translateTo.getResource().getType(), translateTo
 416           .getTranslatedId());
 417     } else if (consolidationEntityType == ConsolidationEntityType.SUB_INTERFACE
 418         && Objects.nonNull(serviceTemplate.getTopology_template().getNode_templates()
 419         .get(translateTo.getTranslatedId()))) {
 420       Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData =
 421           getSubInterfaceTemplateConsolidationData(translateTo, translateTo.getTranslatedId());
 422       if (subInterfaceTemplateConsolidationData.isPresent()) {
 423         entityConsolidationData = subInterfaceTemplateConsolidationData.get();
 424       }
 425     } else if (consolidationEntityType == ConsolidationEntityType.VFC_NESTED
 426         || consolidationEntityType == ConsolidationEntityType.NESTED) {
 427       entityConsolidationData =
 428           getNestedTemplateConsolidationData(translationContext, serviceTemplate,
 429               translateTo.getHeatFileName(),
 430               translateTo.getTranslatedId());
 431     }
 432
 433     if (Objects.nonNull(entityConsolidationData)) {
 434       if (Objects.isNull(entityConsolidationData.getNodesConnectedOut())) {
 435         entityConsolidationData.setNodesConnectedOut(new HashMap<>());
 436       }
 437
 438       entityConsolidationData.getNodesConnectedOut()
 439           .computeIfAbsent(nodeTemplateId, k -> new ArrayList<>())
 440           .add(requirementAssignmentData);
 441     }
 442   }
 443
 444   /**
 445    * Update nodes connected from this node in consolidation data.
 446    *
 447    * @param translateTo             the translate to
 448    * @param sourceNodeTemplateId    the node template id of the source node
 449    * @param consolidationEntityType Entity type (compute or port)
 450    * @param requirementId           Requirement Id
 451    * @param requirementAssignment   the requirement assignment
 452    */
 453   public static void updateNodesConnectedIn(TranslateTo translateTo, String sourceNodeTemplateId,
 454                                             ConsolidationEntityType consolidationEntityType,
 455                                             String targetResourceId,
 456                                             String requirementId,
 457                                             RequirementAssignment requirementAssignment) {
 458     EntityConsolidationData entityConsolidationData = null;
 459     TranslationContext translationContext = translateTo.getContext();
 460     ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 461     RequirementAssignmentData requirementAssignmentData = new RequirementAssignmentData(
 462         requirementId, requirementAssignment);
 463     String dependentNodeTemplateId = requirementAssignment.getNode();
 464     if (consolidationEntityType == ConsolidationEntityType.COMPUTE) {
 465       NodeTemplate computeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
 466           dependentNodeTemplateId);
 467       String nodeType;
 468       if (Objects.isNull(computeNodeTemplate)) {
 469         Resource targetResource =
 470             translateTo.getHeatOrchestrationTemplate().getResources().get(targetResourceId);
 471         NameExtractor nodeTypeNameExtractor =
 472             TranslationContext.getNameExtractorImpl(targetResource.getType());
 473         nodeType =
 474             nodeTypeNameExtractor.extractNodeTypeName(translateTo.getHeatOrchestrationTemplate()
 475                     .getResources().get(dependentNodeTemplateId),
 476                 dependentNodeTemplateId, dependentNodeTemplateId);
 477       } else {
 478         nodeType = computeNodeTemplate.getType();
 479       }
 480
 481       entityConsolidationData = getComputeTemplateConsolidationData(translationContext,
 482           serviceTemplate, nodeType, dependentNodeTemplateId);
 483     } else if (consolidationEntityType == ConsolidationEntityType.PORT) {
 484       entityConsolidationData = getPortTemplateConsolidationData(translationContext, serviceTemplate,
 485           translateTo.getResourceId(), translateTo.getResource().getType(), dependentNodeTemplateId);
 486     }  else if (consolidationEntityType == ConsolidationEntityType.SUB_INTERFACE) {
 487       Resource targetResource =
 488           translateTo.getHeatOrchestrationTemplate().getResources().get(targetResourceId);
 489       TranslateTo subInterfaceTo = new TranslateTo(translateTo.getHeatFileName(), serviceTemplate, translateTo
 490           .getHeatOrchestrationTemplate(), targetResource, targetResourceId, null, translationContext);
 491       Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData =
 492           getSubInterfaceTemplateConsolidationData(subInterfaceTo, targetResourceId);
 493       if (subInterfaceTemplateConsolidationData.isPresent()) {
 494         entityConsolidationData = subInterfaceTemplateConsolidationData.get();
 495       }
 496     } else if (consolidationEntityType == ConsolidationEntityType.NESTED
 497         || consolidationEntityType == ConsolidationEntityType.VFC_NESTED) {
 498       entityConsolidationData = getNestedTemplateConsolidationData(translationContext,
 499           serviceTemplate, translateTo.getHeatFileName(), dependentNodeTemplateId);
 500     }
 501
 502     if (entityConsolidationData != null) {
 503       if (entityConsolidationData.getNodesConnectedIn() == null) {
 504         entityConsolidationData.setNodesConnectedIn(new HashMap<>());
 505       }
 506
 507       entityConsolidationData.getNodesConnectedIn()
 508           .computeIfAbsent(sourceNodeTemplateId, k -> new ArrayList<>())
 509           .add(requirementAssignmentData);
 510
 511     }
 512   }
 513
 514   /**
 515    * Checks if the current HEAT resource if of type compute.
 516    *
 517    * @param heatOrchestrationTemplate the heat orchestration template
 518    * @param resourceId                the resource id
 519    * @return true if the resource is of compute type and false otherwise
 520    */
 521   public static boolean isComputeResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
 522                                           String resourceId) {
 523     String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
 524     Map<String, ImplementationConfiguration> supportedComputeResources = TranslationContext
 525         .getSupportedConsolidationComputeResources();
 526     if (supportedComputeResources.containsKey(resourceType)) {
 527       return supportedComputeResources.get(resourceType).isEnable();
 528     }
 529     return false;
 530   }
 531
 532   /**
 533    * Checks if the current HEAT resource if of type compute.
 534    *
 535    * @param resource the resource
 536    * @return true if the resource is of compute type and false otherwise
 537    */
 538   public static boolean isComputeResource(Resource resource) {
 539     String resourceType = resource.getType();
 540     Map<String, ImplementationConfiguration> supportedComputeResources = TranslationContext
 541         .getSupportedConsolidationComputeResources();
 542     if (supportedComputeResources.containsKey(resourceType)) {
 543       return supportedComputeResources.get(resourceType).isEnable();
 544     }
 545     return false;
 546   }
 547
 548   /**
 549    * Checks if the current HEAT resource if of type port.
 550    *
 551    * @param heatOrchestrationTemplate the heat orchestration template
 552    * @param resourceId                the resource id
 553    * @return true if the resource is of port type and false otherwise
 554    */
 555   public static boolean isPortResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
 556                                        String resourceId) {
 557     String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
 558     Map<String, ImplementationConfiguration> supportedPortResources = TranslationContext
 559         .getSupportedConsolidationPortResources();
 560     if (supportedPortResources.containsKey(resourceType)) {
 561       return supportedPortResources.get(resourceType).isEnable();
 562     }
 563     return false;
 564   }
 565
 566   /**
 567    * Checks if the current HEAT resource if of type port.
 568    *
 569    * @param resource the resource
 570    * @return true if the resource is of port type and false otherwise
 571    */
 572   public static boolean isPortResource(Resource resource) {
 573     String resourceType = resource.getType();
 574     Map<String, ImplementationConfiguration> supportedPortResources = TranslationContext
 575         .getSupportedConsolidationPortResources();
 576     if (supportedPortResources.containsKey(resourceType)) {
 577       return supportedPortResources.get(resourceType).isEnable();
 578     }
 579     return false;
 580   }
 581
 582   /**
 583    * Checks if the current HEAT resource if of type volume.
 584    *
 585    * @param heatOrchestrationTemplate the heat orchestration template
 586    * @param resourceId                the resource id
 587    * @return true if the resource is of volume type and false otherwise
 588    */
 589   public static boolean isVolumeResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
 590                                          String resourceId) {
 591     String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
 592     return resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource())
 593         || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE
 594         .getHeatResource());
 595   }
 596
 597   /**
 598    * Checks if the current HEAT resource if of type volume.
 599    *
 600    * @param resource the resource
 601    * @return true if the resource is of volume type and false otherwise
 602    */
 603   public static boolean isVolumeResource(Resource resource) {
 604     String resourceType = resource.getType();
 605     return resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource())
 606         || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE
 607         .getHeatResource());
 608   }
 609
 610   /**
 611    * Gets port type.
 612    *
 613    * @param portNodeTemplateId the port node template id
 614    * @return the port type
 615    */
 616   public static String getPortType(String portNodeTemplateId) {
 617
 618     if (StringUtils.isBlank(portNodeTemplateId)) {
 619       return portNodeTemplateId;
 620     }
 621
 622     String formattedName = portNodeTemplateId.replaceAll(UNDERSCORE + DIGIT_REGEX + "$", "");
 623
 624     StringBuilder sb = new StringBuilder();
 625     int count = 0;
 626     for (String token : formattedName.split(UNDERSCORE)) {
 627
 628       if (StringUtils.isNotBlank(token)) {
 629         count++;
 630       }
 631
 632       if (count != 2 || !token.matches(DIGIT_REGEX)) {
 633         sb.append(token).append(UNDERSCORE);
 634       }
 635     }
 636
 637     return portNodeTemplateId.endsWith(UNDERSCORE) ? sb.toString() : sb.substring(0, sb.length() - 1);
 638   }
 639
 640   /**
 641    * Update node template id for the nested node templates in the consolidation data.
 642    *
 643    * @param translateTo the translate to
 644    */
 645   public static void updateNestedNodeTemplateId(TranslateTo translateTo) {
 646     TranslationContext context = translateTo.getContext();
 647     ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 648     getNestedTemplateConsolidationData(
 649         context, serviceTemplate, translateTo.getHeatFileName(), translateTo.getTranslatedId());
 650   }
 651
 652   public static void removeSharedResource(ServiceTemplate serviceTemplate,
 653                                           HeatOrchestrationTemplate heatOrchestrationTemplate,
 654                                           TranslationContext context,
 655                                           String paramName,
 656                                           String contrailSharedResourceId,
 657                                           String sharedTranslatedResourceId) {
 658     if (ConsolidationDataUtil.isComputeResource(heatOrchestrationTemplate,
 659         contrailSharedResourceId)) {
 660       NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
 661           sharedTranslatedResourceId);
 662       EntityConsolidationData entityConsolidationData = getComputeTemplateConsolidationData(
 663           context, serviceTemplate, nodeTemplate.getType(), sharedTranslatedResourceId);
 664       List<GetAttrFuncData> getAttrFuncDataList = entityConsolidationData
 665           .getOutputParametersGetAttrIn();
 666       removeParamNameFromAttrFuncList(paramName, getAttrFuncDataList);
 667     }
 668     if (ConsolidationDataUtil.isPortResource(heatOrchestrationTemplate,
 669         contrailSharedResourceId)) {
 670       Resource resource = heatOrchestrationTemplate.getResources().get(contrailSharedResourceId);
 671       EntityConsolidationData entityConsolidationData = getPortTemplateConsolidationData(context, serviceTemplate,
 672           contrailSharedResourceId, resource.getType(), sharedTranslatedResourceId);
 673       List<GetAttrFuncData> getAttrFuncDataList = entityConsolidationData
 674           .getOutputParametersGetAttrIn();
 675       removeParamNameFromAttrFuncList(paramName, getAttrFuncDataList);
 676     }
 677   }
 678
 679   private static void removeParamNameFromAttrFuncList(String paramName,
 680                                                       List<GetAttrFuncData> getAttrFuncDataList) {
 681     Iterator<GetAttrFuncData> itr = getAttrFuncDataList.iterator();
 682     while (itr.hasNext()) {
 683       GetAttrFuncData getAttrFuncData = itr.next();
 684       if (paramName.equals(getAttrFuncData.getFieldName())) {
 685         itr.remove();
 686       }
 687     }
 688   }
 689
 690   public static void updateNodeGetAttributeIn(EntityConsolidationData entityConsolidationData,
 691                                               String nodeTemplateId, String propertyName,
 692                                               String attributeName) {
 693     GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
 694     getAttrFuncData.setFieldName(propertyName);
 695     getAttrFuncData.setAttributeName(attributeName);
 696     entityConsolidationData.addNodesGetAttrIn(nodeTemplateId, getAttrFuncData);
 697
 698   }
 699
 700   public static void updateNodeGetAttributeOut(EntityConsolidationData entityConsolidationData,
 701                                                String nodeTemplateId, String propertyName,
 702                                                String attributeName) {
 703     GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
 704     getAttrFuncData.setFieldName(propertyName);
 705     getAttrFuncData.setAttributeName(attributeName);
 706     entityConsolidationData.addNodesGetAttrOut(nodeTemplateId, getAttrFuncData);
 707
 708   }
 709
 710   public static void updateOutputGetAttributeInConsolidationData(EntityConsolidationData
 711                                                                      entityConsolidationData,
 712                                                                  String outputParameterName,
 713                                                                  String attributeName) {
 714
 715
 716     GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
 717     getAttrFuncData.setFieldName(outputParameterName);
 718     getAttrFuncData.setAttributeName(attributeName);
 719     entityConsolidationData.addOutputParamGetAttrIn(getAttrFuncData);
 720
 721   }
 722
 723   public static boolean isComputeReferenceToPortId(ComputeTemplateConsolidationData compute,
 724                                                    String portId) {
 725     if (MapUtils.isEmpty(compute.getPorts())) {
 726       return false;
 727     }
 728     for (List<String> portIdsPerType : compute.getPorts().values()) {
 729       if (portIdsPerType.contains(portId)) {
 730         return true;
 731       }
 732     }
 733     return false;
 734   }
 735
 736 }