openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationDataUtil.java

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