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