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

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