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
  25 import org.apache.commons.collections4.MapUtils;
  26 import org.apache.commons.lang3.StringUtils;
  27 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
  28 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  29 import org.openecomp.core.utilities.file.FileUtils;
  30 import org.openecomp.sdc.common.errors.CoreException;
  31 import org.openecomp.sdc.datatypes.configuration.ImplementationConfiguration;
  32 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
  33 import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes;
  34 import org.openecomp.sdc.heat.datatypes.model.Resource;
  35 import org.openecomp.sdc.tosca.services.ToscaUtil;
  36 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
  37 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
  38 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeConsolidationData;
  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 group id information in consolidation data.
 287      *
 288      * @param entityConsolidationData Entity consolidation data (Port/Compute)
 289      * @param translatedGroupId       Group id of which compute node is a part
 290      */
 291     public static void updateGroupIdInConsolidationData(EntityConsolidationData
 292                                                                 entityConsolidationData,
 293                                                                String translatedGroupId) {
 294         if (entityConsolidationData.getGroupIds() == null) {
 295             entityConsolidationData.setGroupIds(new ArrayList<>());
 296         }
 297         entityConsolidationData.getGroupIds().add(translatedGroupId);
 298     }
 299
 300     /**
 301      * Update volume information in consolidation data.
 302      *
 303      * @param translateTo           {@link TranslateTo} object
 304      * @param computeType           Local type of the compute node
 305      * @param computeNodeTemplateId Node template id of the compute node
 306      * @param requirementAssignment RequirementAssignment object
 307      */
 308     public static void updateComputeConsolidationDataVolumes(TranslateTo translateTo,
 309                                                                     String computeType,
 310                                                                     String computeNodeTemplateId,
 311                                                                     String requirementId,
 312                                                                     RequirementAssignment
 313                                                                             requirementAssignment) {
 314         TranslationContext translationContext = translateTo.getContext();
 315         ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 316         ComputeTemplateConsolidationData computeTemplateConsolidationData =
 317                 getComputeTemplateConsolidationData(translationContext, serviceTemplate, computeType,
 318                         computeNodeTemplateId);
 319         computeTemplateConsolidationData.addVolume(requirementId, requirementAssignment);
 320     }
 321
 322
 323     /**
 324      * Update port in consolidation data.
 325      *
 326      * @param translateTo        the translate to
 327      * @param computeNodeType    the compute node type
 328      * @param portResourceId     the port resource id
 329      * @param portNodeTemplateId the port node template id
 330      */
 331     public static void updatePortInConsolidationData(TranslateTo translateTo,
 332                                                             String computeNodeType,
 333                                                             String portResourceId,
 334                                                             String portResourceType,
 335                                                             String portNodeTemplateId) {
 336         TranslationContext translationContext = translateTo.getContext();
 337         String computeNodeTemplateId = translateTo.getTranslatedId();
 338         String portType = getPortType(portNodeTemplateId);
 339
 340         translationContext.getComputeConsolidationDataHandler().addPortToConsolidationData(
 341                 translateTo, computeNodeType, computeNodeTemplateId, portType, portNodeTemplateId);
 342
 343         ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 344         String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 345         translationContext.getPortConsolidationDataHandler().addConsolidationData(
 346                 serviceTemplateFileName, portResourceId, portResourceType, portNodeTemplateId);
 347     }
 348
 349     /**
 350      * Update nodes connected in and out for Depends on and connectivity in consolidation data.
 351      *
 352      * @param translateTo           the translate to
 353      * @param targetResourceId      the target resource id
 354      * @param nodeTemplateId        the source node template id
 355      * @param requirementAssignment the requirement assignment
 356      */
 357     public static void updateNodesConnectedData(TranslateTo translateTo, String targetResourceId,
 358                                                        Resource targetResource, Resource sourceResource,
 359                                                        String nodeTemplateId, String requirementId,
 360                                                        RequirementAssignment requirementAssignment) {
 361         ConsolidationEntityType consolidationEntityType = ConsolidationEntityType.OTHER;
 362         consolidationEntityType.setEntityType(sourceResource, targetResource, translateTo.getContext());
 363         // Add resource dependency information in nodesConnectedIn if the target node
 364         // is a consolidation entity
 365         if (isConsolidationEntity(consolidationEntityType.getTargetEntityType())) {
 366             ConsolidationDataUtil.updateNodesConnectedIn(translateTo,
 367                     nodeTemplateId, consolidationEntityType.getTargetEntityType(), targetResourceId,
 368                     requirementId, requirementAssignment);
 369         }
 370
 371         //Add resource dependency information in nodesConnectedOut if the source node
 372         //is a consolidation entity
 373         if (isConsolidationEntity(consolidationEntityType.getSourceEntityType())) {
 374             ConsolidationDataUtil.updateNodesConnectedOut(translateTo,
 375                     requirementAssignment.getNode(), consolidationEntityType.getSourceEntityType(),
 376                     requirementId, requirementAssignment);
 377
 378         }
 379     }
 380
 381
 382     private static boolean isConsolidationEntity(ConsolidationEntityType consolidationEntityType) {
 383         return ConsolidationEntityType.getSupportedConsolidationEntities().contains(consolidationEntityType);
 384     }
 385
 386     /**
 387      * Update nodes connected from this node in consolidation data.
 388      *
 389      * @param translateTo             the translate to
 390      * @param nodeTemplateId          the node template id of the target node
 391      * @param consolidationEntityType the entity type (compute or port)
 392      * @param requirementId           the requirement id
 393      * @param requirementAssignment   the requirement assignment
 394      */
 395     public static void updateNodesConnectedOut(TranslateTo translateTo,
 396                                                       String nodeTemplateId,
 397                                                       ConsolidationEntityType consolidationEntityType,
 398                                                       String requirementId,
 399                                                       RequirementAssignment requirementAssignment) {
 400         TranslationContext translationContext = translateTo.getContext();
 401         translationContext.updateRequirementAssignmentIdIndex(
 402                 ToscaUtil.getServiceTemplateFileName(translateTo.getServiceTemplate()), translateTo.getResourceId(),
 403                 requirementId);
 404
 405         Optional<ConsolidationDataHandler> consolidationDataHandler =
 406                 translationContext.getConsolidationDataHandler(consolidationEntityType);
 407         consolidationDataHandler.ifPresent(handler -> handler.addNodesConnectedOut(
 408                 translateTo, nodeTemplateId, requirementId, requirementAssignment));
 409
 410     }
 411
 412     /**
 413      * Update nodes connected from this node in consolidation data.
 414      *
 415      * @param translateTo             the translate to
 416      * @param sourceNodeTemplateId    the node template id of the source node
 417      * @param consolidationEntityType Entity type (compute or port)
 418      * @param targetResourceId        Target Resource Id
 419      * @param requirementId           Requirement Id
 420      * @param requirementAssignment   the requirement assignment
 421      */
 422     public static void updateNodesConnectedIn(TranslateTo translateTo, String sourceNodeTemplateId,
 423                                                      ConsolidationEntityType consolidationEntityType,
 424                                                      String targetResourceId,
 425                                                      String requirementId,
 426                                                      RequirementAssignment requirementAssignment) {
 427
 428
 429         TranslationContext translationContext = translateTo.getContext();
 430         Optional<ConsolidationDataHandler> consolidationDataHandler =
 431                 translationContext.getConsolidationDataHandler(consolidationEntityType);
 432         String dependentNodeTemplateId = requirementAssignment.getNode();
 433         consolidationDataHandler.ifPresent(
 434                 handler -> handler.addNodesConnectedIn(translateTo, sourceNodeTemplateId, dependentNodeTemplateId,
 435                         targetResourceId, requirementId, requirementAssignment));
 436
 437     }
 438
 439     /**
 440      * Checks if the current HEAT resource if of type compute.
 441      *
 442      * @param heatOrchestrationTemplate the heat orchestration template
 443      * @param resourceId                the resource id
 444      * @return true if the resource is of compute type and false otherwise
 445      */
 446     public static boolean isComputeResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
 447                                                    String resourceId) {
 448         String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
 449         Map<String, ImplementationConfiguration> supportedComputeResources =
 450                 TranslationContext.getSupportedConsolidationComputeResources();
 451         if (supportedComputeResources.containsKey(resourceType)) {
 452             return supportedComputeResources.get(resourceType).isEnable();
 453         }
 454         return false;
 455     }
 456
 457     /**
 458      * Checks if the current HEAT resource if of type compute.
 459      *
 460      * @param resource the resource
 461      * @return true if the resource is of compute type and false otherwise
 462      */
 463     public static boolean isComputeResource(Resource resource) {
 464         String resourceType = resource.getType();
 465         Map<String, ImplementationConfiguration> supportedComputeResources =
 466                 TranslationContext.getSupportedConsolidationComputeResources();
 467         if (supportedComputeResources.containsKey(resourceType)) {
 468             return supportedComputeResources.get(resourceType).isEnable();
 469         }
 470         return false;
 471     }
 472
 473     /**
 474      * Checks if the current HEAT resource if of type port.
 475      *
 476      * @param heatOrchestrationTemplate the heat orchestration template
 477      * @param resourceId                the resource id
 478      * @return true if the resource is of port type and false otherwise
 479      */
 480     public static boolean isPortResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
 481                                                 String resourceId) {
 482         String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
 483         Map<String, ImplementationConfiguration> supportedPortResources =
 484                 TranslationContext.getSupportedConsolidationPortResources();
 485         if (supportedPortResources.containsKey(resourceType)) {
 486             return supportedPortResources.get(resourceType).isEnable();
 487         }
 488         return false;
 489     }
 490
 491     /**
 492      * Checks if the current HEAT resource if of type port.
 493      *
 494      * @param resource the resource
 495      * @return true if the resource is of port type and false otherwise
 496      */
 497     public static boolean isPortResource(Resource resource) {
 498         String resourceType = resource.getType();
 499         Map<String, ImplementationConfiguration> supportedPortResources =
 500                 TranslationContext.getSupportedConsolidationPortResources();
 501         if (supportedPortResources.containsKey(resourceType)) {
 502             return supportedPortResources.get(resourceType).isEnable();
 503         }
 504         return false;
 505     }
 506
 507     /**
 508      * Checks if the current HEAT resource if of type volume.
 509      *
 510      * @param heatOrchestrationTemplate the heat orchestration template
 511      * @param resourceId                the resource id
 512      * @return true if the resource is of volume type and false otherwise
 513      */
 514     public static boolean isVolumeResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
 515                                                   String resourceId) {
 516         String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).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      * Checks if the current HEAT resource if of type volume.
 524      *
 525      * @param resource the resource
 526      * @return true if the resource is of volume type and false otherwise
 527      */
 528     public static boolean isVolumeResource(Resource resource) {
 529         String resourceType = resource.getType();
 530         return resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource())
 531                        || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE
 532                                                       .getHeatResource());
 533     }
 534
 535     /**
 536      * Gets port type.
 537      *
 538      * @param portNodeTemplateId the port node template id
 539      * @return the port type
 540      */
 541     public static String getPortType(String portNodeTemplateId) {
 542
 543         if (StringUtils.isBlank(portNodeTemplateId)) {
 544             return portNodeTemplateId;
 545         }
 546
 547         String formattedName = portNodeTemplateId.replaceAll(UNDERSCORE + DIGIT_REGEX + "$", "");
 548
 549         StringBuilder sb = new StringBuilder();
 550         int count = 0;
 551         for (String token : formattedName.split(UNDERSCORE)) {
 552
 553             if (StringUtils.isNotBlank(token)) {
 554                 count++;
 555             }
 556
 557             if (count != 2 || (!StringUtils.isBlank(token) && !token.matches(DIGIT_REGEX))) {
 558                 sb.append(token).append(UNDERSCORE);
 559             }
 560         }
 561
 562         return portNodeTemplateId.endsWith(UNDERSCORE) ? sb.toString() : sb.substring(0, sb.length() - 1);
 563     }
 564
 565     /**
 566      * Update node template id for the nested node templates in the consolidation data.
 567      *
 568      * @param translateTo the translate to
 569      */
 570     public static void updateNestedNodeTemplateId(TranslateTo translateTo) {
 571         TranslationContext context = translateTo.getContext();
 572         ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 573         String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 574         // create nested in consolidation data
 575         context.getNestedConsolidationDataHandler()
 576                 .addConsolidationData(serviceTemplateFileName, context,
 577                   translateTo.getHeatFileName(), translateTo.getTranslatedId());
 578
 579     }
 580
 581     public static void removeSharedResource(ServiceTemplate serviceTemplate,
 582                                                    HeatOrchestrationTemplate heatOrchestrationTemplate,
 583                                                    TranslationContext context,
 584                                                    String paramName,
 585                                                    String contrailSharedResourceId,
 586                                                    String sharedTranslatedResourceId) {
 587         Optional<ConsolidationDataHandler> consolidationDataHandler =
 588                 ConsolidationDataUtil.getConsolidationDataHandler(heatOrchestrationTemplate, context,
 589                         contrailSharedResourceId);
 590
 591         consolidationDataHandler.ifPresent(
 592                 handler -> handler.removeParamNameFromAttrFuncList(serviceTemplate, heatOrchestrationTemplate,
 593                         paramName, contrailSharedResourceId, sharedTranslatedResourceId));
 594     }
 595
 596
 597     private static Optional<ConsolidationDataHandler> getConsolidationDataHandler(
 598             HeatOrchestrationTemplate heatOrchestrationTemplate, TranslationContext context,
 599             String contrailSharedResourceId) {
 600         Resource resource = heatOrchestrationTemplate.getResources().get(contrailSharedResourceId);
 601         ConsolidationEntityType consolidationEntityType = ConsolidationEntityType.OTHER;
 602         consolidationEntityType.setEntityType(resource, resource, context);
 603         return context.getConsolidationDataHandler(consolidationEntityType.getSourceEntityType());
 604     }
 605
 606     public static void updateNodeGetAttributeIn(EntityConsolidationData entityConsolidationData,
 607                                                        String nodeTemplateId, String propertyName,
 608                                                        String attributeName) {
 609         GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
 610         getAttrFuncData.setFieldName(propertyName);
 611         getAttrFuncData.setAttributeName(attributeName);
 612         entityConsolidationData.addNodesGetAttrIn(nodeTemplateId, getAttrFuncData);
 613
 614     }
 615
 616     public static void updateNodeGetAttributeOut(EntityConsolidationData entityConsolidationData,
 617                                                         String nodeTemplateId, String propertyName,
 618                                                         String attributeName) {
 619
 620         GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
 621         getAttrFuncData.setFieldName(propertyName);
 622         getAttrFuncData.setAttributeName(attributeName);
 623         entityConsolidationData.addNodesGetAttrOut(nodeTemplateId, getAttrFuncData);
 624
 625     }
 626
 627     public static void updateOutputGetAttributeInConsolidationData(EntityConsolidationData
 628                                                                            entityConsolidationData,
 629                                                                           String outputParameterName,
 630                                                                           String attributeName) {
 631
 632         GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
 633         getAttrFuncData.setFieldName(outputParameterName);
 634         getAttrFuncData.setAttributeName(attributeName);
 635         entityConsolidationData.addOutputParamGetAttrIn(getAttrFuncData);
 636
 637     }
 638
 639     public static boolean isComputeReferenceToPortId(ComputeTemplateConsolidationData compute,
 640                                                             String portId) {
 641         if (MapUtils.isEmpty(compute.getPorts())) {
 642             return false;
 643         }
 644         for (List<String> portIdsPerType : compute.getPorts().values()) {
 645             if (portIdsPerType.contains(portId)) {
 646                 return true;
 647             }
 648         }
 649         return false;
 650     }
 651
 652 }