gerrit.onap Code Review - sdc.git/blob

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