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 org.apache.commons.collections4.CollectionUtils;
  20 import org.apache.commons.collections4.MapUtils;
  21 import org.apache.commons.lang3.StringUtils;
  22 import org.openecomp.core.utilities.file.FileUtils;
  23 import org.openecomp.sdc.common.errors.CoreException;
  24 import org.openecomp.sdc.datatypes.configuration.ImplementationConfiguration;
  25 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
  26 import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes;
  27 import org.openecomp.sdc.heat.datatypes.model.Resource;
  28 import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
  29 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
  30 import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
  31 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
  32 import org.openecomp.sdc.tosca.services.DataModelUtil;
  33 import org.openecomp.sdc.tosca.services.ToscaUtil;
  34 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
  35 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
  36 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeConsolidationData;
  37 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData;
  38 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ConsolidationData;
  39 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.EntityConsolidationData;
  40 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FileComputeConsolidationData;
  41 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FileNestedConsolidationData;
  42 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FilePortConsolidationData;
  43 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.GetAttrFuncData;
  44 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedConsolidationData;
  45 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedTemplateConsolidationData;
  46 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortConsolidationData;
  47 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData;
  48 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.RequirementAssignmentData;
  49 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.SubInterfaceTemplateConsolidationData;
  50 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.TypeComputeConsolidationData;
  51 import org.openecomp.sdc.translator.services.heattotosca.errors.DuplicateResourceIdsInDifferentFilesErrorBuilder;
  52
  53 import java.util.ArrayList;
  54 import java.util.HashMap;
  55 import java.util.Iterator;
  56 import java.util.List;
  57 import java.util.Map;
  58 import java.util.Objects;
  59 import java.util.Optional;
  60
  61
  62 /**
  63  * Utility class for consolidation data collection helper methods.
  64  */
  65 public class ConsolidationDataUtil {
  66
  67   private static final String UNDERSCORE = "_";
  68   private static final String DIGIT_REGEX = "\\d+";
  69
  70   private ConsolidationDataUtil() {
  71   }
  72
  73   /**
  74    * Gets compute template consolidation data.
  75    *
  76    * @param context               the translation context
  77    * @param serviceTemplate       the service template
  78    * @param computeNodeType       the compute node type
  79    * @param computeNodeTemplateId the compute node template id
  80    * @return the compute template consolidation data
  81    */
  82   public static ComputeTemplateConsolidationData getComputeTemplateConsolidationData(
  83       TranslationContext context,
  84       ServiceTemplate serviceTemplate,
  85       String computeNodeType,
  86       String computeNodeTemplateId) {
  87
  88     ConsolidationData consolidationData = context.getConsolidationData();
  89     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
  90
  91     ComputeConsolidationData computeConsolidationData = consolidationData
  92         .getComputeConsolidationData();
  93
  94     FileComputeConsolidationData fileComputeConsolidationData = computeConsolidationData
  95         .getFileComputeConsolidationData(serviceTemplateFileName);
  96
  97     if (fileComputeConsolidationData == null) {
  98       fileComputeConsolidationData = new FileComputeConsolidationData();
  99       computeConsolidationData.setFileComputeConsolidationData(serviceTemplateFileName,
 100           fileComputeConsolidationData);
 101     }
 102
 103     TypeComputeConsolidationData typeComputeConsolidationData = fileComputeConsolidationData
 104         .getTypeComputeConsolidationData(computeNodeType);
 105     if (typeComputeConsolidationData == null) {
 106       typeComputeConsolidationData = new TypeComputeConsolidationData();
 107       fileComputeConsolidationData.setTypeComputeConsolidationData(computeNodeType,
 108           typeComputeConsolidationData);
 109     }
 110
 111     ComputeTemplateConsolidationData computeTemplateConsolidationData =
 112         typeComputeConsolidationData.getComputeTemplateConsolidationData(computeNodeTemplateId);
 113     if (computeTemplateConsolidationData == null) {
 114       computeTemplateConsolidationData = new ComputeTemplateConsolidationData();
 115       computeTemplateConsolidationData.setNodeTemplateId(computeNodeTemplateId);
 116       typeComputeConsolidationData.setComputeTemplateConsolidationData(computeNodeTemplateId,
 117           computeTemplateConsolidationData);
 118     }
 119
 120     return computeTemplateConsolidationData;
 121   }
 122
 123
 124   /**
 125    * Gets port template consolidation data.
 126    *
 127    * @param context            the context
 128    * @param serviceTemplate    the service template
 129    * @param portNodeTemplateId the port node template id
 130    * @return the port template consolidation data
 131    */
 132   public static PortTemplateConsolidationData getPortTemplateConsolidationData(TranslationContext context,
 133                                                                                ServiceTemplate serviceTemplate,
 134                                                                                String portResourceId,
 135                                                                                String portResourceType,
 136                                                                                String portNodeTemplateId) {
 137
 138     ConsolidationData consolidationData = context.getConsolidationData();
 139     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 140
 141     PortConsolidationData portConsolidationData = consolidationData.getPortConsolidationData();
 142
 143     FilePortConsolidationData filePortConsolidationData = portConsolidationData
 144         .getFilePortConsolidationData(serviceTemplateFileName);
 145
 146     if (filePortConsolidationData == null) {
 147       filePortConsolidationData = new FilePortConsolidationData();
 148       portConsolidationData.setFilePortConsolidationData(serviceTemplateFileName,
 149           filePortConsolidationData);
 150     }
 151
 152     PortTemplateConsolidationData portTemplateConsolidationData =
 153         filePortConsolidationData.getPortTemplateConsolidationData(portNodeTemplateId);
 154     if (portTemplateConsolidationData == null) {
 155       portTemplateConsolidationData = getInitPortTemplateConsolidationData(portNodeTemplateId,
 156           portResourceId, portResourceType);
 157       filePortConsolidationData.setPortTemplateConsolidationData(portNodeTemplateId, portTemplateConsolidationData);
 158     }
 159
 160     return portTemplateConsolidationData;
 161   }
 162
 163   private static PortTemplateConsolidationData getInitPortTemplateConsolidationData(String portNodeTemplateId,
 164                                                                              String portResourceId,
 165                                                                              String portResourceType) {
 166     PortTemplateConsolidationData portTemplateConsolidationData = new PortTemplateConsolidationData();
 167     portTemplateConsolidationData.setNodeTemplateId(portNodeTemplateId);
 168     Optional<String> portNetworkRole = HeatToToscaUtil.evaluateNetworkRoleFromResourceId(portResourceId,
 169         portResourceType);
 170     portNetworkRole.ifPresent(portTemplateConsolidationData::setNetworkRole);
 171     return portTemplateConsolidationData;
 172   }
 173
 174   public static Optional<SubInterfaceTemplateConsolidationData> getSubInterfaceTemplateConsolidationData(
 175       TranslateTo subInterfaceTo,
 176       String subInterfaceNodeTemplateId) {
 177     Optional<String> parentPortNodeTemplateId =
 178         HeatToToscaUtil.getSubInterfaceParentPortNodeTemplateId(subInterfaceTo);
 179     if (parentPortNodeTemplateId.isPresent()) {
 180       return Optional.ofNullable(getSubInterfaceTemplateConsolidationData(subInterfaceTo,
 181          parentPortNodeTemplateId.get(), subInterfaceNodeTemplateId));
 182     }
 183     return Optional.empty();
 184   }
 185
 186   private static SubInterfaceTemplateConsolidationData getSubInterfaceTemplateConsolidationData(
 187       TranslateTo subInterfaceTo,
 188       String parentPortNodeTemplateId,
 189       String subInterfaceNodeTemplateId) {
 190
 191     ConsolidationData consolidationData = subInterfaceTo.getContext().getConsolidationData();
 192     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(subInterfaceTo.getServiceTemplate());
 193
 194     PortConsolidationData portConsolidationData = consolidationData.getPortConsolidationData();
 195
 196     FilePortConsolidationData filePortConsolidationData = portConsolidationData
 197         .getFilePortConsolidationData(serviceTemplateFileName);
 198
 199     if (filePortConsolidationData == null) {
 200       filePortConsolidationData = new FilePortConsolidationData();
 201       portConsolidationData.setFilePortConsolidationData(serviceTemplateFileName,
 202           filePortConsolidationData);
 203     }
 204
 205     PortTemplateConsolidationData portTemplateConsolidationData =
 206         filePortConsolidationData.getPortTemplateConsolidationData(parentPortNodeTemplateId);
 207     if (portTemplateConsolidationData == null) {
 208       portTemplateConsolidationData = new PortTemplateConsolidationData();
 209       portTemplateConsolidationData.setNodeTemplateId(parentPortNodeTemplateId);
 210       filePortConsolidationData.setPortTemplateConsolidationData(parentPortNodeTemplateId,
 211           portTemplateConsolidationData);
 212     }
 213
 214     return getSubInterfaceResourceTemplateConsolidationData(subInterfaceTo.getResource(), portTemplateConsolidationData,
 215         subInterfaceNodeTemplateId, parentPortNodeTemplateId);
 216   }
 217
 218   private static SubInterfaceTemplateConsolidationData getSubInterfaceResourceTemplateConsolidationData(
 219       Resource resource,
 220       PortTemplateConsolidationData portTemplateConsolidationData,
 221       String subInterfaceNodeTemplateId,
 222       String parentPortNodeTemplateId) {
 223     String subInterfaceType = ToscaNodeType.VLAN_SUB_INTERFACE_RESOURCE_TYPE_PREFIX
 224         + FileUtils.getFileWithoutExtention(HeatToToscaUtil.getSubInterfaceResourceType(resource));
 225     SubInterfaceTemplateConsolidationData data = new SubInterfaceTemplateConsolidationData();
 226     data.setNodeTemplateId(subInterfaceNodeTemplateId);
 227     data.setParentPortNodeTemplateId(parentPortNodeTemplateId);
 228     if (CollectionUtils.isNotEmpty(portTemplateConsolidationData.getSubInterfaceConsolidationData(subInterfaceType))) {
 229       boolean isNewSubInterface = true;
 230       List<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationDataList =
 231           portTemplateConsolidationData.getSubInterfaceConsolidationData(subInterfaceType);
 232       for (SubInterfaceTemplateConsolidationData subInterfaceTemplateConsolidationData :
 233           subInterfaceTemplateConsolidationDataList) {
 234         if (subInterfaceNodeTemplateId.equals(subInterfaceTemplateConsolidationData.getNodeTemplateId())) {
 235           data = subInterfaceTemplateConsolidationData;
 236           isNewSubInterface = false;
 237         }
 238       }
 239       if (isNewSubInterface) {
 240         portTemplateConsolidationData.addSubInterfaceConsolidationData(subInterfaceType, data);
 241       }
 242     } else {
 243       portTemplateConsolidationData.addSubInterfaceConsolidationData(subInterfaceType, data);
 244     }
 245     return data;
 246   }
 247
 248   /**
 249    * Gets nested template consolidation data.
 250    *
 251    * @param context              the context
 252    * @param serviceTemplate      the service template
 253    * @param nestedNodeTemplateId the nested node template id  @return the nested template
 254    *                             consolidation data
 255    */
 256   public static NestedTemplateConsolidationData getNestedTemplateConsolidationData(
 257       TranslationContext context,
 258       ServiceTemplate serviceTemplate,
 259       String nestedHeatFileName, String nestedNodeTemplateId) {
 260
 261     if (isNestedResourceIdOccuresInDifferentNestedFiles(context, nestedHeatFileName,
 262         nestedNodeTemplateId)) {
 263       throw new CoreException(
 264           new DuplicateResourceIdsInDifferentFilesErrorBuilder(nestedNodeTemplateId).build());
 265     }
 266
 267     if (isNodeTemplatePointsToServiceTemplateWithoutNodeTemplates(
 268         nestedNodeTemplateId, nestedHeatFileName, context)) {
 269       return null;
 270     }
 271
 272     ConsolidationData consolidationData = context.getConsolidationData();
 273     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 274
 275     NestedConsolidationData nestedConsolidationData = consolidationData
 276         .getNestedConsolidationData();
 277
 278     FileNestedConsolidationData fileNestedConsolidationData = nestedConsolidationData
 279         .getFileNestedConsolidationData(serviceTemplateFileName);
 280
 281     if (fileNestedConsolidationData == null) {
 282       fileNestedConsolidationData = new FileNestedConsolidationData();
 283       nestedConsolidationData.setFileNestedConsolidationData(serviceTemplateFileName,
 284           fileNestedConsolidationData);
 285     }
 286
 287     NestedTemplateConsolidationData nestedTemplateConsolidationData =
 288         fileNestedConsolidationData.getNestedTemplateConsolidationData(nestedNodeTemplateId);
 289     if (nestedTemplateConsolidationData == null) {
 290       nestedTemplateConsolidationData = new NestedTemplateConsolidationData();
 291       nestedTemplateConsolidationData.setNodeTemplateId(nestedNodeTemplateId);
 292       fileNestedConsolidationData.setNestedTemplateConsolidationData(nestedNodeTemplateId,
 293           nestedTemplateConsolidationData);
 294     }
 295
 296     return nestedTemplateConsolidationData;
 297   }
 298
 299   public static boolean isNodeTemplatePointsToServiceTemplateWithoutNodeTemplates(String
 300                                                                                       nestedNodeTemplateId,
 301                                                                                   String nestedHeatFileName,
 302                                                                                   TranslationContext context) {
 303
 304     return context.isServiceTemplateWithoutNodeTemplatesSection(
 305         FileUtils.getFileWithoutExtention(nestedHeatFileName))
 306         || context.isNodeTemplateIdPointsToStWithoutNodeTemplates(nestedNodeTemplateId);
 307   }
 308
 309   private static boolean isNestedResourceIdOccuresInDifferentNestedFiles(TranslationContext context,
 310                                                                          String nestedHeatFileName,
 311                                                                          String nestedNodeTemplateId) {
 312     return Objects.nonNull(nestedHeatFileName)
 313         && context.getAllTranslatedResourceIdsFromDiffNestedFiles(nestedHeatFileName)
 314         .contains(nestedNodeTemplateId);
 315   }
 316
 317   /**
 318    * Update group id information in consolidation data.
 319    *
 320    * @param entityConsolidationData Entity consolidation data (Port/Compute)
 321    * @param translatedGroupId       Group id of which compute node is a part
 322    */
 323   public static void updateGroupIdInConsolidationData(EntityConsolidationData
 324                                                           entityConsolidationData,
 325                                                       String translatedGroupId) {
 326     if (entityConsolidationData.getGroupIds() == null) {
 327       entityConsolidationData.setGroupIds(new ArrayList<>());
 328     }
 329     entityConsolidationData.getGroupIds().add(translatedGroupId);
 330   }
 331
 332   /**
 333    * Update volume information in consolidation data.
 334    *
 335    * @param translateTo           {@link TranslateTo} object
 336    * @param computeType           Local type of the compute node
 337    * @param computeNodeTemplateId Node template id of the compute node
 338    * @param requirementAssignment RequirementAssignment object
 339    */
 340   public static void updateComputeConsolidationDataVolumes(TranslateTo translateTo,
 341                                                            String computeType,
 342                                                            String computeNodeTemplateId,
 343                                                            String requirementId,
 344                                                            RequirementAssignment
 345                                                                requirementAssignment) {
 346     TranslationContext translationContext = translateTo.getContext();
 347     ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 348     ComputeTemplateConsolidationData computeTemplateConsolidationData =
 349         getComputeTemplateConsolidationData(translationContext, serviceTemplate, computeType,
 350             computeNodeTemplateId);
 351     computeTemplateConsolidationData.addVolume(requirementId, requirementAssignment);
 352   }
 353
 354
 355   /**
 356    * Update port in consolidation data.
 357    *
 358    * @param translateTo        the translate to
 359    * @param computeNodeType    the compute node type
 360    * @param portResourceId     the port resource id
 361    * @param portNodeTemplateId the port node template id
 362    */
 363   public static void updatePortInConsolidationData(TranslateTo translateTo,
 364                                                    String computeNodeType,
 365                                                    String portResourceId,
 366                                                    String portResourceType,
 367                                                    String portNodeTemplateId) {
 368     TranslationContext translationContext = translateTo.getContext();
 369     ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 370     ComputeTemplateConsolidationData computeTemplateConsolidationData =
 371         getComputeTemplateConsolidationData(translationContext, serviceTemplate, computeNodeType,
 372             translateTo.getTranslatedId());
 373     computeTemplateConsolidationData.addPort(getPortType(portNodeTemplateId), portNodeTemplateId);
 374     // create port in consolidation data
 375     getPortTemplateConsolidationData(translationContext, serviceTemplate, portResourceId,
 376         portResourceType, portNodeTemplateId);
 377   }
 378
 379   /**
 380    * Update nodes connected in and out for Depends on and connectivity in consolidation data.
 381    *
 382    * @param translateTo           the translate to
 383    * @param targetResourceId      the target resource id
 384    * @param nodeTemplateId        the source node template id
 385    * @param requirementAssignment the requirement assignment
 386    */
 387   public static void updateNodesConnectedData(TranslateTo translateTo, String targetResourceId,
 388                                               Resource targetResource, Resource sourceResource,
 389                                               String nodeTemplateId, String requirementId,
 390                                               RequirementAssignment requirementAssignment) {
 391     ConsolidationEntityType consolidationEntityType = ConsolidationEntityType.OTHER;
 392     consolidationEntityType.setEntityType(sourceResource, targetResource, translateTo.getContext());
 393     // Add resource dependency information in nodesConnectedIn if the target node
 394     // is a consolidation entity
 395     if (isConsolidationEntity(consolidationEntityType.getTargetEntityType())) {
 396       ConsolidationDataUtil.updateNodesConnectedIn(translateTo,
 397           nodeTemplateId, consolidationEntityType.getTargetEntityType(), targetResourceId,
 398           requirementId, requirementAssignment);
 399     }
 400
 401     //Add resource dependency information in nodesConnectedOut if the source node
 402     //is a consolidation entity
 403     if (isConsolidationEntity(consolidationEntityType.getSourceEntityType())) {
 404       ConsolidationDataUtil.updateNodesConnectedOut(translateTo,
 405           requirementAssignment.getNode(), consolidationEntityType.getSourceEntityType(),
 406           requirementId, requirementAssignment);
 407
 408     }
 409   }
 410
 411
 412   private static boolean isConsolidationEntity(ConsolidationEntityType consolidationEntityType) {
 413     return ConsolidationEntityType.getSupportedConsolidationEntities().contains(consolidationEntityType);
 414   }
 415
 416   /**
 417    * Update nodes connected from this node in consolidation data.
 418    *
 419    * @param translateTo             the translate to
 420    * @param nodeTemplateId          the node template id of the target node
 421    * @param consolidationEntityType the entity type (compute or port)
 422    * @param requirementId           the requirement id
 423    * @param requirementAssignment   the requirement assignment
 424    */
 425   public static void updateNodesConnectedOut(TranslateTo translateTo,
 426                                              String nodeTemplateId,
 427                                              ConsolidationEntityType consolidationEntityType,
 428                                              String requirementId,
 429                                              RequirementAssignment requirementAssignment) {
 430     EntityConsolidationData entityConsolidationData = null;
 431     TranslationContext translationContext = translateTo.getContext();
 432     ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 433
 434     translationContext.updateRequirementAssignmentIdIndex(ToscaUtil.getServiceTemplateFileName
 435         (translateTo.getServiceTemplate()), translateTo.getResourceId(), requirementId);
 436
 437     RequirementAssignmentData requirementAssignmentData = new RequirementAssignmentData(
 438         requirementId, requirementAssignment);
 439
 440     if (consolidationEntityType == ConsolidationEntityType.COMPUTE) {
 441       String nodeType = DataModelUtil.getNodeTemplate(serviceTemplate, translateTo
 442           .getTranslatedId()).getType();
 443       entityConsolidationData = getComputeTemplateConsolidationData(translationContext,
 444           serviceTemplate, nodeType, translateTo.getTranslatedId());
 445     } else if (consolidationEntityType == ConsolidationEntityType.PORT) {
 446       entityConsolidationData = getPortTemplateConsolidationData(translationContext, serviceTemplate,
 447           translateTo.getResourceId(), translateTo.getResource().getType(), translateTo
 448           .getTranslatedId());
 449     } else if (consolidationEntityType == ConsolidationEntityType.SUB_INTERFACE
 450         && Objects.nonNull(serviceTemplate.getTopology_template().getNode_templates()
 451         .get(translateTo.getTranslatedId()))) {
 452       Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData =
 453           getSubInterfaceTemplateConsolidationData(translateTo, translateTo.getTranslatedId());
 454       if (subInterfaceTemplateConsolidationData.isPresent()) {
 455         entityConsolidationData = subInterfaceTemplateConsolidationData.get();
 456       }
 457     } else if (consolidationEntityType == ConsolidationEntityType.VFC_NESTED
 458         || consolidationEntityType == ConsolidationEntityType.NESTED) {
 459       entityConsolidationData =
 460           getNestedTemplateConsolidationData(translationContext, serviceTemplate,
 461               translateTo.getHeatFileName(),
 462               translateTo.getTranslatedId());
 463     }
 464
 465     if (Objects.nonNull(entityConsolidationData)) {
 466       if (Objects.isNull(entityConsolidationData.getNodesConnectedOut())) {
 467         entityConsolidationData.setNodesConnectedOut(new HashMap<>());
 468       }
 469
 470       entityConsolidationData.getNodesConnectedOut()
 471           .computeIfAbsent(nodeTemplateId, k -> new ArrayList<>())
 472           .add(requirementAssignmentData);
 473     }
 474   }
 475
 476   /**
 477    * Update nodes connected from this node in consolidation data.
 478    *
 479    * @param translateTo             the translate to
 480    * @param sourceNodeTemplateId    the node template id of the source node
 481    * @param consolidationEntityType Entity type (compute or port)
 482    * @param requirementId           Requirement Id
 483    * @param requirementAssignment   the requirement assignment
 484    */
 485   public static void updateNodesConnectedIn(TranslateTo translateTo, String sourceNodeTemplateId,
 486                                             ConsolidationEntityType consolidationEntityType,
 487                                             String targetResourceId,
 488                                             String requirementId,
 489                                             RequirementAssignment requirementAssignment) {
 490     EntityConsolidationData entityConsolidationData = null;
 491     TranslationContext translationContext = translateTo.getContext();
 492     ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 493     RequirementAssignmentData requirementAssignmentData = new RequirementAssignmentData(
 494         requirementId, requirementAssignment);
 495     String dependentNodeTemplateId = requirementAssignment.getNode();
 496     if (consolidationEntityType == ConsolidationEntityType.COMPUTE) {
 497       NodeTemplate computeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
 498           dependentNodeTemplateId);
 499       String nodeType;
 500       if (Objects.isNull(computeNodeTemplate)) {
 501         Resource targetResource =
 502             translateTo.getHeatOrchestrationTemplate().getResources().get(targetResourceId);
 503         NameExtractor nodeTypeNameExtractor =
 504             TranslationContext.getNameExtractorImpl(targetResource.getType());
 505         nodeType =
 506             nodeTypeNameExtractor.extractNodeTypeName(translateTo.getHeatOrchestrationTemplate()
 507                     .getResources().get(dependentNodeTemplateId),
 508                 dependentNodeTemplateId, dependentNodeTemplateId);
 509       } else {
 510         nodeType = computeNodeTemplate.getType();
 511       }
 512
 513       entityConsolidationData = getComputeTemplateConsolidationData(translationContext,
 514           serviceTemplate, nodeType, dependentNodeTemplateId);
 515     } else if (consolidationEntityType == ConsolidationEntityType.PORT) {
 516       entityConsolidationData = getPortTemplateConsolidationData(translationContext, serviceTemplate,
 517           translateTo.getResourceId(), translateTo.getResource().getType(), dependentNodeTemplateId);
 518     }  else if (consolidationEntityType == ConsolidationEntityType.SUB_INTERFACE) {
 519       Resource targetResource =
 520           translateTo.getHeatOrchestrationTemplate().getResources().get(targetResourceId);
 521       TranslateTo subInterfaceTo = new TranslateTo(translateTo.getHeatFileName(), serviceTemplate, translateTo
 522           .getHeatOrchestrationTemplate(), targetResource, targetResourceId, null, translationContext);
 523       Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData =
 524           getSubInterfaceTemplateConsolidationData(subInterfaceTo, targetResourceId);
 525       if (subInterfaceTemplateConsolidationData.isPresent()) {
 526         entityConsolidationData = subInterfaceTemplateConsolidationData.get();
 527       }
 528     } else if (consolidationEntityType == ConsolidationEntityType.NESTED
 529         || consolidationEntityType == ConsolidationEntityType.VFC_NESTED) {
 530       entityConsolidationData = getNestedTemplateConsolidationData(translationContext,
 531           serviceTemplate, translateTo.getHeatFileName(), dependentNodeTemplateId);
 532     }
 533
 534     if (entityConsolidationData != null) {
 535       if (entityConsolidationData.getNodesConnectedIn() == null) {
 536         entityConsolidationData.setNodesConnectedIn(new HashMap<>());
 537       }
 538
 539       entityConsolidationData.getNodesConnectedIn()
 540           .computeIfAbsent(sourceNodeTemplateId, k -> new ArrayList<>())
 541           .add(requirementAssignmentData);
 542
 543     }
 544   }
 545
 546   /**
 547    * Checks if the current HEAT resource if of type compute.
 548    *
 549    * @param heatOrchestrationTemplate the heat orchestration template
 550    * @param resourceId                the resource id
 551    * @return true if the resource is of compute type and false otherwise
 552    */
 553   public static boolean isComputeResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
 554                                           String resourceId) {
 555     String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
 556     Map<String, ImplementationConfiguration> supportedComputeResources = TranslationContext
 557         .getSupportedConsolidationComputeResources();
 558     if (supportedComputeResources.containsKey(resourceType)) {
 559       return supportedComputeResources.get(resourceType).isEnable();
 560     }
 561     return false;
 562   }
 563
 564   /**
 565    * Checks if the current HEAT resource if of type compute.
 566    *
 567    * @param resource the resource
 568    * @return true if the resource is of compute type and false otherwise
 569    */
 570   public static boolean isComputeResource(Resource resource) {
 571     String resourceType = resource.getType();
 572     Map<String, ImplementationConfiguration> supportedComputeResources = TranslationContext
 573         .getSupportedConsolidationComputeResources();
 574     if (supportedComputeResources.containsKey(resourceType)) {
 575       return supportedComputeResources.get(resourceType).isEnable();
 576     }
 577     return false;
 578   }
 579
 580   /**
 581    * Checks if the current HEAT resource if of type port.
 582    *
 583    * @param heatOrchestrationTemplate the heat orchestration template
 584    * @param resourceId                the resource id
 585    * @return true if the resource is of port type and false otherwise
 586    */
 587   public static boolean isPortResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
 588                                        String resourceId) {
 589     String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
 590     Map<String, ImplementationConfiguration> supportedPortResources = TranslationContext
 591         .getSupportedConsolidationPortResources();
 592     if (supportedPortResources.containsKey(resourceType)) {
 593       return supportedPortResources.get(resourceType).isEnable();
 594     }
 595     return false;
 596   }
 597
 598   /**
 599    * Checks if the current HEAT resource if of type port.
 600    *
 601    * @param resource the resource
 602    * @return true if the resource is of port type and false otherwise
 603    */
 604   public static boolean isPortResource(Resource resource) {
 605     String resourceType = resource.getType();
 606     Map<String, ImplementationConfiguration> supportedPortResources = TranslationContext
 607         .getSupportedConsolidationPortResources();
 608     if (supportedPortResources.containsKey(resourceType)) {
 609       return supportedPortResources.get(resourceType).isEnable();
 610     }
 611     return false;
 612   }
 613
 614   /**
 615    * Checks if the current HEAT resource if of type volume.
 616    *
 617    * @param heatOrchestrationTemplate the heat orchestration template
 618    * @param resourceId                the resource id
 619    * @return true if the resource is of volume type and false otherwise
 620    */
 621   public static boolean isVolumeResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
 622                                          String resourceId) {
 623     String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
 624     return resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource())
 625         || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE
 626         .getHeatResource());
 627   }
 628
 629   /**
 630    * Checks if the current HEAT resource if of type volume.
 631    *
 632    * @param resource the resource
 633    * @return true if the resource is of volume type and false otherwise
 634    */
 635   public static boolean isVolumeResource(Resource resource) {
 636     String resourceType = resource.getType();
 637     return resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource())
 638         || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE
 639         .getHeatResource());
 640   }
 641
 642   /**
 643    * Gets port type.
 644    *
 645    * @param portNodeTemplateId the port node template id
 646    * @return the port type
 647    */
 648   public static String getPortType(String portNodeTemplateId) {
 649
 650     if (StringUtils.isBlank(portNodeTemplateId)) {
 651       return portNodeTemplateId;
 652     }
 653
 654     String formattedName = portNodeTemplateId.replaceAll(DIGIT_REGEX + "$", "");
 655
 656     StringBuilder sb = new StringBuilder();
 657     int count = 0;
 658     for (String token : formattedName.split(UNDERSCORE)) {
 659
 660       if (StringUtils.isNotBlank(token)) {
 661         count++;
 662       }
 663
 664       if (count != 2 || !token.matches(DIGIT_REGEX)) {
 665         sb.append(token).append(UNDERSCORE);
 666       }
 667     }
 668
 669     return portNodeTemplateId.endsWith(UNDERSCORE) ? sb.toString() : sb.substring(0, sb.length() - 1);
 670   }
 671
 672   /**
 673    * Update node template id for the nested node templates in the consolidation data.
 674    *
 675    * @param translateTo the translate to
 676    */
 677   public static void updateNestedNodeTemplateId(TranslateTo translateTo) {
 678     TranslationContext context = translateTo.getContext();
 679     ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 680     getNestedTemplateConsolidationData(
 681         context, serviceTemplate, translateTo.getHeatFileName(), translateTo.getTranslatedId());
 682   }
 683
 684   public static void removeSharedResource(ServiceTemplate serviceTemplate,
 685                                           HeatOrchestrationTemplate heatOrchestrationTemplate,
 686                                           TranslationContext context,
 687                                           String paramName,
 688                                           String contrailSharedResourceId,
 689                                           String sharedTranslatedResourceId) {
 690     if (ConsolidationDataUtil.isComputeResource(heatOrchestrationTemplate,
 691         contrailSharedResourceId)) {
 692       NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
 693           sharedTranslatedResourceId);
 694       EntityConsolidationData entityConsolidationData = getComputeTemplateConsolidationData(
 695           context, serviceTemplate, nodeTemplate.getType(), sharedTranslatedResourceId);
 696       List<GetAttrFuncData> getAttrFuncDataList = entityConsolidationData
 697           .getOutputParametersGetAttrIn();
 698       removeParamNameFromAttrFuncList(paramName, getAttrFuncDataList);
 699     }
 700     if (ConsolidationDataUtil.isPortResource(heatOrchestrationTemplate,
 701         contrailSharedResourceId)) {
 702       Resource resource = heatOrchestrationTemplate.getResources().get(contrailSharedResourceId);
 703       EntityConsolidationData entityConsolidationData = getPortTemplateConsolidationData(context, serviceTemplate,
 704           contrailSharedResourceId, resource.getType(), sharedTranslatedResourceId);
 705       List<GetAttrFuncData> getAttrFuncDataList = entityConsolidationData
 706           .getOutputParametersGetAttrIn();
 707       removeParamNameFromAttrFuncList(paramName, getAttrFuncDataList);
 708     }
 709   }
 710
 711   private static void removeParamNameFromAttrFuncList(String paramName,
 712                                                       List<GetAttrFuncData> getAttrFuncDataList) {
 713     Iterator<GetAttrFuncData> itr = getAttrFuncDataList.iterator();
 714     while (itr.hasNext()) {
 715       GetAttrFuncData getAttrFuncData = itr.next();
 716       if (paramName.equals(getAttrFuncData.getFieldName())) {
 717         itr.remove();
 718       }
 719     }
 720   }
 721
 722   public static void updateNodeGetAttributeIn(EntityConsolidationData entityConsolidationData,
 723                                               String nodeTemplateId, String propertyName,
 724                                               String attributeName) {
 725     GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
 726     getAttrFuncData.setFieldName(propertyName);
 727     getAttrFuncData.setAttributeName(attributeName);
 728     entityConsolidationData.addNodesGetAttrIn(nodeTemplateId, getAttrFuncData);
 729
 730   }
 731
 732   public static void updateNodeGetAttributeOut(EntityConsolidationData entityConsolidationData,
 733                                                String nodeTemplateId, String propertyName,
 734                                                String attributeName) {
 735     GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
 736     getAttrFuncData.setFieldName(propertyName);
 737     getAttrFuncData.setAttributeName(attributeName);
 738     entityConsolidationData.addNodesGetAttrOut(nodeTemplateId, getAttrFuncData);
 739
 740   }
 741
 742   public static void updateOutputGetAttributeInConsolidationData(EntityConsolidationData
 743                                                                      entityConsolidationData,
 744                                                                  String outputParameterName,
 745                                                                  String attributeName) {
 746
 747
 748     GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
 749     getAttrFuncData.setFieldName(outputParameterName);
 750     getAttrFuncData.setAttributeName(attributeName);
 751     entityConsolidationData.addOutputParamGetAttrIn(getAttrFuncData);
 752
 753   }
 754
 755   public static boolean isComputeReferenceToPortId(ComputeTemplateConsolidationData compute,
 756                                                    String portId) {
 757     if (MapUtils.isEmpty(compute.getPorts())) {
 758       return false;
 759     }
 760     for (List<String> portIdsPerType : compute.getPorts().values()) {
 761       if (portIdsPerType.contains(portId)) {
 762         return true;
 763       }
 764     }
 765     return false;
 766   }
 767
 768 }