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.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.HashMap;
  37 import java.util.Iterator;
  38 import java.util.List;
  39 import java.util.Map;
  40 import java.util.Objects;
  41
  42
  43 /**
  44  * Utility class for consolidation data collection helper methods.
  45  */
  46 public class ConsolidationDataUtil {
  47
  48   protected static Logger logger = (Logger) LoggerFactory.getLogger(ConsolidationDataUtil.class);
  49
  50   /**
  51    * Gets compute template consolidation data.
  52    *
  53    * @param context               the translation context
  54    * @param serviceTemplate       the service template
  55    * @param computeNodeType       the compute node type
  56    * @param computeNodeTemplateId the compute node template id
  57    * @return the compute template consolidation data
  58    */
  59   public static ComputeTemplateConsolidationData getComputeTemplateConsolidationData(
  60           TranslationContext context,
  61           ServiceTemplate serviceTemplate,
  62           String computeNodeType,
  63           String computeNodeTemplateId) {
  64
  65     ConsolidationData consolidationData = context.getConsolidationData();
  66     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
  67
  68     ComputeConsolidationData computeConsolidationData = consolidationData
  69             .getComputeConsolidationData();
  70
  71     FileComputeConsolidationData fileComputeConsolidationData = computeConsolidationData
  72             .getFileComputeConsolidationData(serviceTemplateFileName);
  73
  74     if (fileComputeConsolidationData == null) {
  75       fileComputeConsolidationData = new FileComputeConsolidationData();
  76       computeConsolidationData.setFileComputeConsolidationData(serviceTemplateFileName,
  77               fileComputeConsolidationData);
  78     }
  79
  80     TypeComputeConsolidationData typeComputeConsolidationData = fileComputeConsolidationData
  81             .getTypeComputeConsolidationData(computeNodeType);
  82     if (typeComputeConsolidationData == null) {
  83       typeComputeConsolidationData = new TypeComputeConsolidationData();
  84       fileComputeConsolidationData.setTypeComputeConsolidationData(computeNodeType,
  85               typeComputeConsolidationData);
  86     }
  87
  88     ComputeTemplateConsolidationData computeTemplateConsolidationData =
  89             typeComputeConsolidationData.getComputeTemplateConsolidationData(computeNodeTemplateId);
  90     if (computeTemplateConsolidationData == null) {
  91       computeTemplateConsolidationData = new ComputeTemplateConsolidationData();
  92       computeTemplateConsolidationData.setNodeTemplateId(computeNodeTemplateId);
  93       typeComputeConsolidationData.setComputeTemplateConsolidationData(computeNodeTemplateId,
  94               computeTemplateConsolidationData);
  95     }
  96
  97     return computeTemplateConsolidationData;
  98   }
  99
 100
 101   /**
 102    * Gets port template consolidation data.
 103    *
 104    * @param context            the context
 105    * @param serviceTemplate    the service template
 106    * @param portNodeTemplateId the port node template id
 107    * @return the port template consolidation data
 108    */
 109   public static PortTemplateConsolidationData getPortTemplateConsolidationData(
 110           TranslationContext context,
 111           ServiceTemplate serviceTemplate,
 112           String portNodeTemplateId) {
 113
 114     ConsolidationData consolidationData = context.getConsolidationData();
 115     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 116
 117     PortConsolidationData portConsolidationData = consolidationData.getPortConsolidationData();
 118
 119     FilePortConsolidationData filePortConsolidationData = portConsolidationData
 120             .getFilePortConsolidationData(serviceTemplateFileName);
 121
 122     if (filePortConsolidationData == null) {
 123       filePortConsolidationData = new FilePortConsolidationData();
 124       portConsolidationData.setFilePortConsolidationData(serviceTemplateFileName,
 125               filePortConsolidationData);
 126     }
 127
 128     PortTemplateConsolidationData portTemplateConsolidationData =
 129             filePortConsolidationData.getPortTemplateConsolidationData(portNodeTemplateId);
 130     if (portTemplateConsolidationData == null) {
 131       portTemplateConsolidationData = new PortTemplateConsolidationData();
 132       portTemplateConsolidationData.setNodeTemplateId(portNodeTemplateId);
 133       filePortConsolidationData.setPortTemplateConsolidationData(portNodeTemplateId,
 134               portTemplateConsolidationData);
 135     }
 136
 137     return portTemplateConsolidationData;
 138   }
 139
 140
 141   /**
 142    * Gets nested template consolidation data.
 143    *
 144    * @param context              the context
 145    * @param serviceTemplate      the service template
 146    * @param nestedHeatFileName
 147    *@param nestedNodeTemplateId the nested node template id  @return the nested template consolidation data
 148    */
 149   public static NestedTemplateConsolidationData getNestedTemplateConsolidationData(
 150           TranslationContext context,
 151           ServiceTemplate serviceTemplate,
 152           String nestedHeatFileName, String nestedNodeTemplateId) {
 153
 154     if(isNestedResourceIdOccuresInDifferentNestedFiles(context, nestedHeatFileName,
 155             nestedNodeTemplateId)){
 156       throw new CoreException((new ErrorCode.ErrorCodeBuilder())
 157               .withMessage("Resource with id "
 158                       + nestedNodeTemplateId + " occures more than once in different addOn "
 159                       + "files").build());
 160     }
 161
 162     ConsolidationData consolidationData = context.getConsolidationData();
 163     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 164
 165     NestedConsolidationData nestedConsolidationData = consolidationData
 166             .getNestedConsolidationData();
 167
 168     FileNestedConsolidationData fileNestedConsolidationData = nestedConsolidationData
 169             .getFileNestedConsolidationData(serviceTemplateFileName);
 170
 171     if (fileNestedConsolidationData == null) {
 172       fileNestedConsolidationData = new FileNestedConsolidationData();
 173       nestedConsolidationData.setFileNestedConsolidationData(serviceTemplateFileName,
 174               fileNestedConsolidationData);
 175     }
 176
 177     NestedTemplateConsolidationData nestedTemplateConsolidationData =
 178             fileNestedConsolidationData.getNestedTemplateConsolidationData(nestedNodeTemplateId);
 179     if (nestedTemplateConsolidationData == null) {
 180       nestedTemplateConsolidationData = new NestedTemplateConsolidationData();
 181       nestedTemplateConsolidationData.setNodeTemplateId(nestedNodeTemplateId);
 182       fileNestedConsolidationData.setNestedTemplateConsolidationData(nestedNodeTemplateId,
 183               nestedTemplateConsolidationData);
 184     }
 185
 186     return nestedTemplateConsolidationData;
 187   }
 188
 189   private static boolean isNestedResourceIdOccuresInDifferentNestedFiles(TranslationContext context,
 190                                                                          String nestedHeatFileName,
 191                                                                          String nestedNodeTemplateId) {
 192     return 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       ConsolidationDataUtil.updateNodesConnectedOut(translateTo,
 287               requirementAssignment.getNode(), consolidationEntityType.getSourceEntityType(),
 288               requirementId + "_" + nodeTemplateId, requirementAssignment);
 289
 290       translationContext.addSubMappingReqAssignment(ToscaUtil.getServiceTemplateFileName
 291                       (translateTo.getServiceTemplate()),
 292               requirementAssignment, requirementId + "_" + nodeTemplateId);
 293
 294     }
 295   }
 296
 297
 298   private static boolean isConsolidationEntity(ConsolidationEntityType consolidationEntityType) {
 299     return (consolidationEntityType == ConsolidationEntityType.COMPUTE
 300             || consolidationEntityType == ConsolidationEntityType.PORT
 301             || consolidationEntityType == ConsolidationEntityType.NESTED
 302             || consolidationEntityType == ConsolidationEntityType.VFC_NESTED);
 303   }
 304
 305   /**
 306    * Update nodes connected from this node in consolidation data.
 307    *
 308    * @param translateTo             the translate to
 309    * @param nodeTemplateId          the node template id of the target node
 310    * @param consolidationEntityType the entity type (compute or port)
 311    * @param requirementId           the requirement id
 312    * @param requirementAssignment   the requirement assignment
 313    */
 314   public static void updateNodesConnectedOut(TranslateTo translateTo,
 315                                              String nodeTemplateId,
 316                                              ConsolidationEntityType consolidationEntityType,
 317                                              String requirementId,
 318                                              RequirementAssignment requirementAssignment) {
 319     EntityConsolidationData entityConsolidationData = null;
 320     TranslationContext translationContext = translateTo.getContext();
 321     ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 322     RequirementAssignmentData requirementAssignmentData = new RequirementAssignmentData(
 323             requirementId, requirementAssignment);
 324
 325     if (consolidationEntityType == ConsolidationEntityType.COMPUTE) {
 326       String nodeType = DataModelUtil.getNodeTemplate(serviceTemplate, translateTo
 327               .getTranslatedId()).getType();
 328       entityConsolidationData = getComputeTemplateConsolidationData(translationContext,
 329               serviceTemplate, nodeType, translateTo.getTranslatedId());
 330     } else if (consolidationEntityType == ConsolidationEntityType.PORT) {
 331       entityConsolidationData = getPortTemplateConsolidationData(translationContext,
 332               serviceTemplate, translateTo.getTranslatedId());
 333     } else if (consolidationEntityType == ConsolidationEntityType.VFC_NESTED
 334             || consolidationEntityType == ConsolidationEntityType.NESTED) {
 335       //ConnectedOut data for nested is not updated
 336       return;
 337     }
 338
 339     if (entityConsolidationData.getNodesConnectedOut() == null) {
 340       entityConsolidationData.setNodesConnectedOut(new HashMap<>());
 341     }
 342
 343     entityConsolidationData.getNodesConnectedOut()
 344             .computeIfAbsent(nodeTemplateId, k -> new ArrayList<>())
 345             .add(requirementAssignmentData);
 346   }
 347
 348   /**
 349    * Update nodes connected from this node in consolidation data.
 350    *
 351    * @param translateTo             the translate to
 352    * @param sourceNodeTemplateId    the node template id of the source node
 353    * @param consolidationEntityType Entity type (compute or port)
 354    * @param requirementId           Requirement Id
 355    * @param requirementAssignment   the requirement assignment
 356    */
 357   public static void updateNodesConnectedIn(TranslateTo translateTo, String sourceNodeTemplateId,
 358                                             ConsolidationEntityType consolidationEntityType,
 359                                             String targetResourceId,
 360                                             String requirementId,
 361                                             RequirementAssignment requirementAssignment) {
 362     EntityConsolidationData entityConsolidationData = null;
 363     TranslationContext translationContext = translateTo.getContext();
 364     ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 365     RequirementAssignmentData requirementAssignmentData = new RequirementAssignmentData(
 366             requirementId, requirementAssignment);
 367     String dependentNodeTemplateId = requirementAssignment.getNode();
 368     if (consolidationEntityType == ConsolidationEntityType.COMPUTE) {
 369       NodeTemplate computeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
 370               dependentNodeTemplateId);
 371       String nodeType = null;
 372       if (Objects.isNull(computeNodeTemplate)) {
 373         Resource targetResource =
 374                 translateTo.getHeatOrchestrationTemplate().getResources().get(targetResourceId);
 375         NameExtractor nodeTypeNameExtractor =
 376                 translateTo.getContext().getNameExtractorImpl(targetResource.getType());
 377         nodeType =
 378                 nodeTypeNameExtractor.extractNodeTypeName(translateTo.getHeatOrchestrationTemplate()
 379                                 .getResources().get(dependentNodeTemplateId),
 380                         dependentNodeTemplateId, dependentNodeTemplateId);
 381       } else {
 382         nodeType = computeNodeTemplate.getType();
 383       }
 384
 385       entityConsolidationData = getComputeTemplateConsolidationData(translationContext,
 386               serviceTemplate, nodeType, dependentNodeTemplateId);
 387     } else if (consolidationEntityType == ConsolidationEntityType.PORT) {
 388       entityConsolidationData = getPortTemplateConsolidationData(translationContext,
 389               serviceTemplate, dependentNodeTemplateId);
 390     } else if (consolidationEntityType == ConsolidationEntityType.NESTED
 391             || consolidationEntityType == ConsolidationEntityType.VFC_NESTED) {
 392       entityConsolidationData = getNestedTemplateConsolidationData(translationContext,
 393               serviceTemplate, translateTo.getHeatFileName(), dependentNodeTemplateId);
 394     }
 395
 396     if (entityConsolidationData.getNodesConnectedIn() == null) {
 397       entityConsolidationData.setNodesConnectedIn(new HashMap<>());
 398     }
 399
 400     entityConsolidationData.getNodesConnectedIn()
 401             .computeIfAbsent(sourceNodeTemplateId, k -> new ArrayList<>())
 402             .add(requirementAssignmentData);
 403
 404   }
 405
 406   /**
 407    * Checks if the current HEAT resource if of type compute.
 408    *
 409    * @param heatOrchestrationTemplate the heat orchestration template
 410    * @param resourceId                the resource id
 411    * @return true if the resource is of compute type and false otherwise
 412    */
 413   public static boolean isComputeResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
 414                                           String resourceId) {
 415     String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
 416     Map<String, ImplementationConfiguration> supportedComputeResources = TranslationContext
 417             .getSupportedConsolidationComputeResources();
 418     if (supportedComputeResources.containsKey(resourceType)) {
 419       if (supportedComputeResources.get(resourceType).isEnable()) {
 420         return true;
 421       }
 422       return false;
 423     }
 424     return false;
 425   }
 426
 427   /**
 428    * Checks if the current HEAT resource if of type compute.
 429    *
 430    * @param resource                the resource
 431    * @return true if the resource is of compute type and false otherwise
 432    */
 433   public static boolean isComputeResource(Resource resource) {
 434     String resourceType = resource.getType();
 435     Map<String, ImplementationConfiguration> supportedComputeResources = TranslationContext
 436             .getSupportedConsolidationComputeResources();
 437     if (supportedComputeResources.containsKey(resourceType)) {
 438       if (supportedComputeResources.get(resourceType).isEnable()) {
 439         return true;
 440       }
 441       return false;
 442     }
 443     return false;
 444   }
 445
 446   /**
 447    * Checks if the current HEAT resource if of type port.
 448    *
 449    * @param heatOrchestrationTemplate the heat orchestration template
 450    * @param resourceId                the resource id
 451    * @return true if the resource is of port type and false otherwise
 452    */
 453   public static boolean isPortResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
 454                                        String resourceId) {
 455     String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
 456     Map<String, ImplementationConfiguration> supportedPortResources = TranslationContext
 457             .getSupportedConsolidationPortResources();
 458     if (supportedPortResources.containsKey(resourceType)) {
 459       if (supportedPortResources.get(resourceType).isEnable()) {
 460         return true;
 461       }
 462       return false;
 463     }
 464     return false;
 465   }
 466
 467   /**
 468    * Checks if the current HEAT resource if of type port.
 469    *
 470    * @param resource                the resource
 471    * @return true if the resource is of port type and false otherwise
 472    */
 473   public static boolean isPortResource(Resource resource) {
 474     String resourceType = resource.getType();
 475     Map<String, ImplementationConfiguration> supportedPortResources = TranslationContext
 476             .getSupportedConsolidationPortResources();
 477     if (supportedPortResources.containsKey(resourceType)) {
 478       if (supportedPortResources.get(resourceType).isEnable()) {
 479         return true;
 480       }
 481       return false;
 482     }
 483     return false;
 484   }
 485
 486   /**
 487    * Checks if the current HEAT resource if of type volume.
 488    *
 489    * @param heatOrchestrationTemplate the heat orchestration template
 490    * @param resourceId                the resource id
 491    * @return true if the resource is of volume type and false otherwise
 492    */
 493   public static boolean isVolumeResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
 494                                          String resourceId) {
 495     String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
 496     return (resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource())
 497             || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE
 498             .getHeatResource()));
 499   }
 500
 501   /**
 502    * Checks if the current HEAT resource if of type volume.
 503    *
 504    * @param resource                the resource
 505    * @return true if the resource is of volume type and false otherwise
 506    */
 507   public static boolean isVolumeResource(Resource resource) {
 508     String resourceType = resource.getType();
 509     return (resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource())
 510             || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE
 511             .getHeatResource()));
 512   }
 513
 514   /**
 515    * Gets port type.
 516    *
 517    * @param portNodeTemplateId the port node template id
 518    * @return the port type
 519    */
 520   public static String getPortType(String portNodeTemplateId) {
 521     String[] portSplitArr = portNodeTemplateId.split("(?<=\\D)(?=\\d)|(?<=\\d)(?=\\D)");
 522     String finalValue = "";
 523     if (NumberUtils.isNumber(portSplitArr[portSplitArr.length - 1])) {
 524       for (String id : portSplitArr) {
 525         finalValue = finalValue + id;
 526       }
 527       while (finalValue.length() > 0) {
 528         if (Character.isLetter(finalValue.charAt(finalValue.length() - 1))) {
 529           break;
 530         }
 531         finalValue = finalValue.substring(0, finalValue.length() - 1);
 532       }
 533     } else {
 534       for (String id : portSplitArr) {
 535         if (!NumberUtils.isNumber(id)) {
 536           finalValue = finalValue + id;
 537         }
 538       }
 539     }
 540     return finalValue;
 541   }
 542
 543   /**
 544    * Update node template id for the nested node templates in the consolidation data.
 545    *
 546    * @param translateTo the translate to
 547    */
 548   public static void updateNestedNodeTemplateId(TranslateTo translateTo) {
 549     TranslationContext context = translateTo.getContext();
 550     ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 551     getNestedTemplateConsolidationData(
 552             context, serviceTemplate, translateTo.getHeatFileName(), translateTo.getTranslatedId());
 553   }
 554
 555   public static void removeSharedResource(ServiceTemplate serviceTemplate,
 556                                           HeatOrchestrationTemplate heatOrchestrationTemplate,
 557                                           TranslationContext context,
 558                                           String paramName,
 559                                           String contrailSharedResourceId,
 560                                           String sharedTranslatedResourceId) {
 561     if (ConsolidationDataUtil.isComputeResource(heatOrchestrationTemplate,
 562             contrailSharedResourceId)) {
 563       NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
 564               sharedTranslatedResourceId);
 565       EntityConsolidationData entityConsolidationData = getComputeTemplateConsolidationData(
 566               context, serviceTemplate, nodeTemplate.getType(), sharedTranslatedResourceId);
 567       List<GetAttrFuncData> getAttrFuncDataList = entityConsolidationData
 568               .getOutputParametersGetAttrIn();
 569       removeParamNameFromAttrFuncList(paramName, getAttrFuncDataList);
 570     }
 571     if (ConsolidationDataUtil.isPortResource(heatOrchestrationTemplate,
 572             contrailSharedResourceId)) {
 573       NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
 574               sharedTranslatedResourceId);
 575       EntityConsolidationData entityConsolidationData = getPortTemplateConsolidationData(context,
 576               serviceTemplate, sharedTranslatedResourceId);
 577       List<GetAttrFuncData> getAttrFuncDataList = entityConsolidationData
 578               .getOutputParametersGetAttrIn();
 579       removeParamNameFromAttrFuncList(paramName, getAttrFuncDataList);
 580     }
 581   }
 582
 583   private static void removeParamNameFromAttrFuncList(String paramName,
 584                                                       List<GetAttrFuncData> getAttrFuncDataList) {
 585     Iterator<GetAttrFuncData> itr = getAttrFuncDataList.iterator();
 586     while (itr.hasNext()) {
 587       GetAttrFuncData getAttrFuncData = itr.next();
 588       if (paramName.equals(getAttrFuncData.getFieldName())) {
 589         itr.remove();
 590       }
 591     }
 592   }
 593
 594   public static void updateNodeGetAttributeIn(EntityConsolidationData entityConsolidationData,
 595                                               String nodeTemplateId, String propertyName,
 596                                               String attributeName) {
 597     GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
 598     getAttrFuncData.setFieldName(propertyName);
 599     getAttrFuncData.setAttributeName(attributeName);
 600     entityConsolidationData.addNodesGetAttrIn(nodeTemplateId, getAttrFuncData);
 601
 602   }
 603
 604   public static void updateNodeGetAttributeOut(EntityConsolidationData entityConsolidationData,
 605                                                String nodeTemplateId, String propertyName,
 606                                                String attributeName) {
 607     GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
 608     getAttrFuncData.setFieldName(propertyName);
 609     getAttrFuncData.setAttributeName(attributeName);
 610     entityConsolidationData.addNodesGetAttrOut(nodeTemplateId, getAttrFuncData);
 611
 612   }
 613
 614   public static void updateOutputGetAttributeInConsolidationData(EntityConsolidationData
 615                                                                          entityConsolidationData,
 616                                                                  String outputParameterName,
 617                                                                  String attributeName) {
 618
 619
 620     GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
 621     getAttrFuncData.setFieldName(outputParameterName);
 622     getAttrFuncData.setAttributeName(attributeName);
 623     entityConsolidationData.addOutputParamGetAttrIn(getAttrFuncData);
 624
 625   }
 626
 627   public static boolean isComputeReferenceToPortId(ComputeTemplateConsolidationData compute,
 628                                                    String portId) {
 629     if (MapUtils.isEmpty(compute.getPorts())) {
 630       return false;
 631     }
 632     for (List<String> portIdsPerType : compute.getPorts().values()) {
 633       if (portIdsPerType.contains(portId)) {
 634         return true;
 635       }
 636     }
 637     return false;
 638   }
 639
 640 }