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