gerrit.onap Code Review - sdc.git/blob

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