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