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