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.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
 172         return parentPortNodeTemplateId.map(s -> getSubInterfaceTemplateConsolidationData(subInterfaceTo,
 173                 s, subInterfaceNodeTemplateId));
 174
 175     }
 176
 177     private static SubInterfaceTemplateConsolidationData getSubInterfaceTemplateConsolidationData(
 178             TranslateTo subInterfaceTo, String parentPortNodeTemplateId, String subInterfaceNodeTemplateId) {
 179
 180         ConsolidationData consolidationData = subInterfaceTo.getContext().getConsolidationData();
 181         String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(subInterfaceTo.getServiceTemplate());
 182
 183         PortConsolidationData portConsolidationData = consolidationData.getPortConsolidationData();
 184
 185         FilePortConsolidationData filePortConsolidationData =
 186                 portConsolidationData.getFilePortConsolidationData(serviceTemplateFileName);
 187
 188         if (filePortConsolidationData == null) {
 189             filePortConsolidationData = new FilePortConsolidationData();
 190             portConsolidationData.setFilePortConsolidationData(serviceTemplateFileName,
 191                     filePortConsolidationData);
 192         }
 193
 194         PortTemplateConsolidationData portTemplateConsolidationData =
 195                 filePortConsolidationData.getPortTemplateConsolidationData(parentPortNodeTemplateId);
 196         if (portTemplateConsolidationData == null) {
 197             portTemplateConsolidationData = new PortTemplateConsolidationData();
 198             portTemplateConsolidationData.setNodeTemplateId(parentPortNodeTemplateId);
 199             filePortConsolidationData.setPortTemplateConsolidationData(parentPortNodeTemplateId,
 200                     portTemplateConsolidationData);
 201         }
 202
 203         return portTemplateConsolidationData.addSubInterfaceTemplateConsolidationData(
 204                 subInterfaceTo.getResource(), subInterfaceNodeTemplateId, parentPortNodeTemplateId);
 205     }
 206
 207     /**
 208      * Gets nested template consolidation data.
 209      *
 210      * @param context              the context
 211      * @param serviceTemplate      the service template
 212      * @param nestedNodeTemplateId the nested node template id  @return the nested template
 213      *                             consolidation data
 214      */
 215     public static NestedTemplateConsolidationData getNestedTemplateConsolidationData(TranslationContext context,
 216             ServiceTemplate serviceTemplate, String nestedHeatFileName, String nestedNodeTemplateId) {
 217
 218         if (isNestedResourceIdOccursInDifferentNestedFiles(context, nestedHeatFileName,
 219                 nestedNodeTemplateId)) {
 220             throw new CoreException(new DuplicateResourceIdsInDifferentFilesErrorBuilder(nestedNodeTemplateId).build());
 221         }
 222
 223         if (isNodeTemplatePointsToServiceTemplateWithoutNodeTemplates(
 224                 nestedNodeTemplateId, nestedHeatFileName, context)) {
 225             return null;
 226         }
 227
 228         ConsolidationData consolidationData = context.getConsolidationData();
 229         String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 230
 231         NestedConsolidationData nestedConsolidationData = consolidationData
 232                                                                   .getNestedConsolidationData();
 233
 234         FileNestedConsolidationData fileNestedConsolidationData =
 235                 nestedConsolidationData.getFileNestedConsolidationData(serviceTemplateFileName);
 236
 237         if (fileNestedConsolidationData == null) {
 238             fileNestedConsolidationData = new FileNestedConsolidationData();
 239             nestedConsolidationData.setFileNestedConsolidationData(serviceTemplateFileName,
 240                     fileNestedConsolidationData);
 241         }
 242
 243         NestedTemplateConsolidationData nestedTemplateConsolidationData =
 244                 fileNestedConsolidationData.getNestedTemplateConsolidationData(nestedNodeTemplateId);
 245         if (nestedTemplateConsolidationData == null) {
 246             nestedTemplateConsolidationData = new NestedTemplateConsolidationData();
 247             nestedTemplateConsolidationData.setNodeTemplateId(nestedNodeTemplateId);
 248             fileNestedConsolidationData.setNestedTemplateConsolidationData(nestedNodeTemplateId,
 249                     nestedTemplateConsolidationData);
 250         }
 251
 252         return nestedTemplateConsolidationData;
 253     }
 254
 255     public static boolean isNodeTemplatePointsToServiceTemplateWithoutNodeTemplates(String
 256                                                                                             nestedNodeTemplateId,
 257                                                                                            String nestedHeatFileName,
 258                                                                                            TranslationContext context) {
 259
 260         return context.isServiceTemplateWithoutNodeTemplatesSection(
 261                 FileUtils.getFileWithoutExtention(nestedHeatFileName))
 262                        || context.isNodeTemplateIdPointsToStWithoutNodeTemplates(nestedNodeTemplateId);
 263     }
 264
 265     private static boolean isNestedResourceIdOccursInDifferentNestedFiles(TranslationContext context,
 266                                                                                   String nestedHeatFileName,
 267                                                                                   String nestedNodeTemplateId) {
 268         return Objects.nonNull(nestedHeatFileName)
 269                        && context.getAllTranslatedResourceIdsFromDiffNestedFiles(nestedHeatFileName)
 270                                  .contains(nestedNodeTemplateId);
 271     }
 272
 273     /**
 274      * Update group id information in consolidation data.
 275      *
 276      * @param entityConsolidationData Entity consolidation data (Port/Compute)
 277      * @param translatedGroupId       Group id of which compute node is a part
 278      */
 279     public static void updateGroupIdInConsolidationData(EntityConsolidationData
 280                                                                 entityConsolidationData,
 281                                                                String translatedGroupId) {
 282         if (entityConsolidationData.getGroupIds() == null) {
 283             entityConsolidationData.setGroupIds(new ArrayList<>());
 284         }
 285         entityConsolidationData.getGroupIds().add(translatedGroupId);
 286     }
 287
 288     /**
 289      * Update volume information in consolidation data.
 290      *
 291      * @param translateTo           {@link TranslateTo} object
 292      * @param computeType           Local type of the compute node
 293      * @param computeNodeTemplateId Node template id of the compute node
 294      * @param requirementAssignment RequirementAssignment object
 295      */
 296     public static void updateComputeConsolidationDataVolumes(TranslateTo translateTo,
 297                                                                     String computeType,
 298                                                                     String computeNodeTemplateId,
 299                                                                     String requirementId,
 300                                                                     RequirementAssignment
 301                                                                             requirementAssignment) {
 302         TranslationContext translationContext = translateTo.getContext();
 303         ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 304         ComputeTemplateConsolidationData computeTemplateConsolidationData =
 305                 getComputeTemplateConsolidationData(translationContext, serviceTemplate, computeType,
 306                         computeNodeTemplateId);
 307         computeTemplateConsolidationData.addVolume(requirementId, requirementAssignment);
 308     }
 309
 310
 311     /**
 312      * Update port in consolidation data.
 313      *
 314      * @param translateTo        the translate to
 315      * @param computeNodeType    the compute node type
 316      * @param portResourceId     the port resource id
 317      * @param portNodeTemplateId the port node template id
 318      */
 319     public static void updatePortInConsolidationData(TranslateTo translateTo,
 320                                                             String computeNodeType,
 321                                                             String portResourceId,
 322                                                             String portResourceType,
 323                                                             String portNodeTemplateId) {
 324         TranslationContext translationContext = translateTo.getContext();
 325         String computeNodeTemplateId = translateTo.getTranslatedId();
 326         String portType = getPortType(portNodeTemplateId);
 327
 328         translationContext.getComputeConsolidationDataHandler().addPortToConsolidationData(
 329                 translateTo, computeNodeType, computeNodeTemplateId, portType, portNodeTemplateId);
 330
 331         ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 332         String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 333         translationContext.getPortConsolidationDataHandler().addConsolidationData(
 334                 serviceTemplateFileName, portResourceId, portResourceType, portNodeTemplateId);
 335     }
 336
 337     /**
 338      * Update nodes connected in and out for Depends on and connectivity in consolidation data.
 339      *
 340      * @param translateTo           the translate to
 341      * @param targetResourceId      the target resource id
 342      * @param nodeTemplateId        the source node template id
 343      * @param requirementAssignment the requirement assignment
 344      */
 345     public static void updateNodesConnectedData(TranslateTo translateTo, String targetResourceId,
 346                                                        Resource targetResource, Resource sourceResource,
 347                                                        String nodeTemplateId, String requirementId,
 348                                                        RequirementAssignment requirementAssignment) {
 349         ConsolidationEntityType consolidationEntityType = ConsolidationEntityType.OTHER;
 350         consolidationEntityType.setEntityType(sourceResource, targetResource, translateTo.getContext());
 351         // Add resource dependency information in nodesConnectedIn if the target node
 352         // is a consolidation entity
 353         if (isConsolidationEntity(consolidationEntityType.getTargetEntityType())) {
 354             ConsolidationDataUtil.updateNodesConnectedIn(translateTo,
 355                     nodeTemplateId, consolidationEntityType.getTargetEntityType(), targetResourceId,
 356                     requirementId, requirementAssignment);
 357         }
 358
 359         //Add resource dependency information in nodesConnectedOut if the source node
 360         //is a consolidation entity
 361         if (isConsolidationEntity(consolidationEntityType.getSourceEntityType())) {
 362             ConsolidationDataUtil.updateNodesConnectedOut(translateTo,
 363                     requirementAssignment.getNode(), consolidationEntityType.getSourceEntityType(),
 364                     requirementId, requirementAssignment);
 365
 366         }
 367     }
 368
 369
 370     private static boolean isConsolidationEntity(ConsolidationEntityType consolidationEntityType) {
 371         return ConsolidationEntityType.getSupportedConsolidationEntities().contains(consolidationEntityType);
 372     }
 373
 374     /**
 375      * Update nodes connected from this node in consolidation data.
 376      *
 377      * @param translateTo             the translate to
 378      * @param nodeTemplateId          the node template id of the target node
 379      * @param consolidationEntityType the entity type (compute or port)
 380      * @param requirementId           the requirement id
 381      * @param requirementAssignment   the requirement assignment
 382      */
 383     public static void updateNodesConnectedOut(TranslateTo translateTo,
 384                                                       String nodeTemplateId,
 385                                                       ConsolidationEntityType consolidationEntityType,
 386                                                       String requirementId,
 387                                                       RequirementAssignment requirementAssignment) {
 388         TranslationContext translationContext = translateTo.getContext();
 389         translationContext.updateRequirementAssignmentIdIndex(
 390                 ToscaUtil.getServiceTemplateFileName(translateTo.getServiceTemplate()), translateTo.getResourceId(),
 391                 requirementId);
 392
 393         Optional<ConsolidationDataHandler> consolidationDataHandler =
 394                 translationContext.getConsolidationDataHandler(consolidationEntityType);
 395         consolidationDataHandler.ifPresent(handler -> handler.addNodesConnectedOut(
 396                 translateTo, nodeTemplateId, requirementId, requirementAssignment));
 397
 398     }
 399
 400     /**
 401      * Update nodes connected from this node in consolidation data.
 402      *
 403      * @param translateTo             the translate to
 404      * @param sourceNodeTemplateId    the node template id of the source node
 405      * @param consolidationEntityType Entity type (compute or port)
 406      * @param targetResourceId        Target Resource Id
 407      * @param requirementId           Requirement Id
 408      * @param requirementAssignment   the requirement assignment
 409      */
 410     public static void updateNodesConnectedIn(TranslateTo translateTo, String sourceNodeTemplateId,
 411                                                      ConsolidationEntityType consolidationEntityType,
 412                                                      String targetResourceId,
 413                                                      String requirementId,
 414                                                      RequirementAssignment requirementAssignment) {
 415
 416
 417         TranslationContext translationContext = translateTo.getContext();
 418         Optional<ConsolidationDataHandler> consolidationDataHandler =
 419                 translationContext.getConsolidationDataHandler(consolidationEntityType);
 420         String dependentNodeTemplateId = requirementAssignment.getNode();
 421         consolidationDataHandler.ifPresent(
 422                 handler -> handler.addNodesConnectedIn(translateTo, sourceNodeTemplateId, dependentNodeTemplateId,
 423                         targetResourceId, requirementId, requirementAssignment));
 424
 425     }
 426
 427     /**
 428      * Checks if the current HEAT resource if of type compute.
 429      *
 430      * @param heatOrchestrationTemplate the heat orchestration template
 431      * @param resourceId                the resource id
 432      * @return true if the resource is of compute type and false otherwise
 433      */
 434     public static boolean isComputeResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
 435                                                    String resourceId) {
 436         String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
 437         Map<String, ImplementationConfiguration> supportedComputeResources =
 438                 TranslationContext.getSupportedConsolidationComputeResources();
 439         if (supportedComputeResources.containsKey(resourceType)) {
 440             return supportedComputeResources.get(resourceType).isEnable();
 441         }
 442         return false;
 443     }
 444
 445     /**
 446      * Checks if the current HEAT resource if of type compute.
 447      *
 448      * @param resource the resource
 449      * @return true if the resource is of compute type and false otherwise
 450      */
 451     public static boolean isComputeResource(Resource resource) {
 452         String resourceType = resource.getType();
 453         Map<String, ImplementationConfiguration> supportedComputeResources =
 454                 TranslationContext.getSupportedConsolidationComputeResources();
 455         if (supportedComputeResources.containsKey(resourceType)) {
 456             return supportedComputeResources.get(resourceType).isEnable();
 457         }
 458         return false;
 459     }
 460
 461     /**
 462      * Checks if the current HEAT resource if of type port.
 463      *
 464      * @param heatOrchestrationTemplate the heat orchestration template
 465      * @param resourceId                the resource id
 466      * @return true if the resource is of port type and false otherwise
 467      */
 468     public static boolean isPortResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
 469                                                 String resourceId) {
 470         String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
 471         Map<String, ImplementationConfiguration> supportedPortResources =
 472                 TranslationContext.getSupportedConsolidationPortResources();
 473         if (supportedPortResources.containsKey(resourceType)) {
 474             return supportedPortResources.get(resourceType).isEnable();
 475         }
 476         return false;
 477     }
 478
 479     /**
 480      * Checks if the current HEAT resource if of type port.
 481      *
 482      * @param resource the resource
 483      * @return true if the resource is of port type and false otherwise
 484      */
 485     public static boolean isPortResource(Resource resource) {
 486         String resourceType = resource.getType();
 487         Map<String, ImplementationConfiguration> supportedPortResources =
 488                 TranslationContext.getSupportedConsolidationPortResources();
 489         if (supportedPortResources.containsKey(resourceType)) {
 490             return supportedPortResources.get(resourceType).isEnable();
 491         }
 492         return false;
 493     }
 494
 495     /**
 496      * Checks if the current HEAT resource if of type volume.
 497      *
 498      * @param heatOrchestrationTemplate the heat orchestration template
 499      * @param resourceId                the resource id
 500      * @return true if the resource is of volume type and false otherwise
 501      */
 502     public static boolean isVolumeResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
 503                                                   String resourceId) {
 504         String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
 505         return resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource())
 506                        || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE
 507                                                       .getHeatResource());
 508     }
 509
 510     /**
 511      * Checks if the current HEAT resource if of type volume.
 512      *
 513      * @param resource the resource
 514      * @return true if the resource is of volume type and false otherwise
 515      */
 516     public static boolean isVolumeResource(Resource resource) {
 517         String resourceType = resource.getType();
 518         return resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource())
 519                        || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE
 520                                                       .getHeatResource());
 521     }
 522
 523     /**
 524      * Gets port type.
 525      *
 526      * @param portNodeTemplateId the port node template id
 527      * @return the port type
 528      */
 529     public static String getPortType(String portNodeTemplateId) {
 530
 531         if (StringUtils.isBlank(portNodeTemplateId)) {
 532             return portNodeTemplateId;
 533         }
 534
 535         String formattedName = portNodeTemplateId.replaceAll(UNDERSCORE + DIGIT_REGEX + "$", "");
 536
 537         StringBuilder sb = new StringBuilder();
 538         int count = 0;
 539         for (String token : formattedName.split(UNDERSCORE)) {
 540
 541             if (StringUtils.isNotBlank(token)) {
 542                 count++;
 543             }
 544
 545             if (count != 2 || (!StringUtils.isBlank(token) && !token.matches(DIGIT_REGEX))) {
 546                 sb.append(token).append(UNDERSCORE);
 547             }
 548         }
 549
 550         return portNodeTemplateId.endsWith(UNDERSCORE) ? sb.toString() : sb.substring(0, sb.length() - 1);
 551     }
 552
 553     /**
 554      * Update node template id for the nested node templates in the consolidation data.
 555      *
 556      * @param translateTo the translate to
 557      */
 558     public static void updateNestedNodeTemplateId(TranslateTo translateTo) {
 559         TranslationContext context = translateTo.getContext();
 560         ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 561         String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 562         // create nested in consolidation data
 563         context.getNestedConsolidationDataHandler()
 564                 .addConsolidationData(serviceTemplateFileName, context,
 565                   translateTo.getHeatFileName(), translateTo.getTranslatedId());
 566
 567     }
 568
 569     public static void removeSharedResource(ServiceTemplate serviceTemplate,
 570                                                    HeatOrchestrationTemplate heatOrchestrationTemplate,
 571                                                    TranslationContext context,
 572                                                    String paramName,
 573                                                    String contrailSharedResourceId,
 574                                                    String sharedTranslatedResourceId) {
 575         Optional<ConsolidationDataHandler> consolidationDataHandler =
 576                 ConsolidationDataUtil.getConsolidationDataHandler(heatOrchestrationTemplate, context,
 577                         contrailSharedResourceId);
 578
 579         consolidationDataHandler.ifPresent(
 580                 handler -> handler.removeParamNameFromAttrFuncList(serviceTemplate, heatOrchestrationTemplate,
 581                         paramName, contrailSharedResourceId, sharedTranslatedResourceId));
 582     }
 583
 584
 585     private static Optional<ConsolidationDataHandler> getConsolidationDataHandler(
 586             HeatOrchestrationTemplate heatOrchestrationTemplate, TranslationContext context,
 587             String contrailSharedResourceId) {
 588         Resource resource = heatOrchestrationTemplate.getResources().get(contrailSharedResourceId);
 589         ConsolidationEntityType consolidationEntityType = ConsolidationEntityType.OTHER;
 590         consolidationEntityType.setEntityType(resource, resource, context);
 591         return context.getConsolidationDataHandler(consolidationEntityType.getSourceEntityType());
 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
 608         GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
 609         getAttrFuncData.setFieldName(propertyName);
 610         getAttrFuncData.setAttributeName(attributeName);
 611         entityConsolidationData.addNodesGetAttrOut(nodeTemplateId, getAttrFuncData);
 612
 613     }
 614
 615     public static void updateOutputGetAttributeInConsolidationData(EntityConsolidationData
 616                                                                            entityConsolidationData,
 617                                                                           String outputParameterName,
 618                                                                           String attributeName) {
 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 }