openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationNestedImpl.java

   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.impl.resourcetranslation;
  18
  19 import org.apache.commons.collections4.CollectionUtils;
  20 import org.apache.commons.lang3.StringUtils;
  21 import org.openecomp.core.utilities.file.FileUtils;
  22 import org.openecomp.sdc.heat.datatypes.manifest.FileData;
  23 import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes;
  24 import org.openecomp.sdc.heat.datatypes.model.Resource;
  25 import org.openecomp.sdc.heat.services.HeatConstants;
  26 import org.openecomp.sdc.logging.api.Logger;
  27 import org.openecomp.sdc.logging.api.LoggerFactory;
  28 import org.openecomp.sdc.tosca.datatypes.ToscaCapabilityType;
  29 import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
  30 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
  31 import org.onap.sdc.tosca.datatypes.model.NodeType;
  32 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
  33 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  34 import org.openecomp.sdc.tosca.services.DataModelUtil;
  35 import org.openecomp.sdc.tosca.services.ToscaUtil;
  36 import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
  37 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
  38 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
  39 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.SubInterfaceTemplateConsolidationData;
  40 import org.openecomp.sdc.translator.services.heattotosca.ConsolidationDataUtil;
  41 import org.openecomp.sdc.translator.services.heattotosca.Constants;
  42 import org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil;
  43 import org.openecomp.sdc.translator.services.heattotosca.TranslationService;
  44
  45 import java.util.Map;
  46 import java.util.Objects;
  47 import java.util.Optional;
  48
  49 public class ResourceTranslationNestedImpl extends ResourceTranslationBase {
  50
  51   private static final String SUB_INTERFACE_COUNT = "count";
  52   protected static Logger log = LoggerFactory.getLogger(ResourceTranslationNestedImpl.class);
  53
  54   @Override
  55   public void translate(TranslateTo translateTo) {
  56     TranslationContext context = translateTo.getContext();
  57     FileData nestedFileData =
  58         HeatToToscaUtil.getFileData(translateTo.getResource().getType(), context);
  59     if (nestedFileData == null) {
  60       log.warn("Nested File '" + translateTo.getResource().getType()
  61           + "' is not exist, therefore, the nested resource with the ID '"
  62           + translateTo.getResourceId() + "' will be ignored in TOSCA translation");
  63       return;
  64     }
  65     String templateName = FileUtils.getFileWithoutExtention(translateTo.getResource().getType());
  66     String substitutionNodeTypeKey = HeatToToscaUtil.getNestedResourceTypePrefix(translateTo)
  67         + templateName;
  68
  69     if (!context.getTranslatedServiceTemplates()
  70         .containsKey(translateTo.getResource().getType())) {
  71
  72       //substitution service template
  73       ServiceTemplate nestedSubstitutionServiceTemplate =
  74           createSubstitutionServiceTemplate(translateTo, nestedFileData, templateName);
  75
  76       //global substitution service template
  77       ServiceTemplate globalSubstitutionServiceTemplate = HeatToToscaUtil
  78           .fetchGlobalSubstitutionServiceTemplate(translateTo.getServiceTemplate(),
  79               context);
  80
  81       //substitution node type
  82       NodeType substitutionNodeType = new ToscaAnalyzerServiceImpl()
  83           .createInitSubstitutionNodeType(nestedSubstitutionServiceTemplate,
  84               ToscaNodeType.ABSTRACT_SUBSTITUTE);
  85       DataModelUtil.addNodeType(globalSubstitutionServiceTemplate, substitutionNodeTypeKey,
  86           substitutionNodeType);
  87       //substitution mapping
  88       HeatToToscaUtil
  89           .handleSubstitutionMapping(context, substitutionNodeTypeKey,
  90               nestedSubstitutionServiceTemplate, substitutionNodeType);
  91
  92       //add new nested service template
  93       context.getTranslatedServiceTemplates()
  94           .put(translateTo.getResource().getType(), nestedSubstitutionServiceTemplate);
  95     }
  96
  97     ServiceTemplate substitutionServiceTemplate = context.getTranslatedServiceTemplates()
  98         .get(translateTo.getResource().getType());
  99
 100     if (DataModelUtil.isNodeTemplateSectionMissingFromServiceTemplate(substitutionServiceTemplate)) {
 101       handleSubstitutionServiceTemplateWithoutNodeTemplates(
 102           templateName, translateTo);
 103       return;
 104     }
 105     NodeTemplate substitutionNodeTemplate =
 106         HeatToToscaUtil.createAbstractSubstitutionNodeTemplate(translateTo, templateName,
 107             substitutionNodeTypeKey);
 108     manageSubstitutionNodeTemplateConnectionPoint(translateTo, nestedFileData,
 109         substitutionNodeTemplate, substitutionNodeTypeKey);
 110     DataModelUtil.addNodeTemplate(translateTo.getServiceTemplate(), translateTo.getTranslatedId(),
 111         substitutionNodeTemplate);
 112
 113     //Add nested node template id to consolidation data
 114     ConsolidationDataUtil.updateNestedNodeTemplateId(translateTo);
 115
 116     //Gather consolidation data if the resource group represents a sub interface
 117     if (StringUtils.isNotBlank(substitutionNodeTypeKey)
 118           && substitutionNodeTypeKey.contains(ToscaNodeType
 119         .VLAN_SUB_INTERFACE_RESOURCE_TYPE_PREFIX)) {
 120       populateSubInterfaceTemplateConsolidationData(translateTo, substitutionNodeTemplate);
 121     }
 122   }
 123
 124   private void populateSubInterfaceTemplateConsolidationData(TranslateTo translateTo,
 125                                                             NodeTemplate nodeTemplate) {
 126
 127     Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData =
 128         ConsolidationDataUtil.getSubInterfaceTemplateConsolidationData(translateTo, translateTo
 129                 .getTranslatedId());
 130     if (!subInterfaceTemplateConsolidationData.isPresent()) {
 131       return;
 132     }
 133     Optional<String> subInterfaceNetworkRole =
 134         HeatToToscaUtil.getNetworkRoleFromSubInterfaceId(translateTo.getResource(), translateTo.getContext());
 135     subInterfaceNetworkRole.ifPresent(subInterfaceTemplateConsolidationData.get()::setNetworkRole);
 136     Object count = getSubInterfaceCountFromResourceProperties(translateTo);
 137     subInterfaceTemplateConsolidationData.get().setResourceGroupCount(count);
 138
 139     if (CollectionUtils.isNotEmpty(nodeTemplate.getRequirements())) {
 140       //Add connectivity to network in consolidation data based on resource group link requirements
 141       nodeTemplate.getRequirements().forEach((Map<String, RequirementAssignment> requirementMap) ->
 142           requirementMap.entrySet().stream()
 143               .filter(requirementAssignmentEntry -> ToscaCapabilityType.NATIVE_NETWORK_LINKABLE
 144                   .equals(requirementAssignmentEntry.getValue().getCapability()))
 145               .forEach(requirementAssignmentEntry -> subInterfaceTemplateConsolidationData.get()
 146                   .addNodesConnectedOut(requirementAssignmentEntry.getValue().getNode(),
 147                       requirementAssignmentEntry.getKey(),
 148                       requirementAssignmentEntry.getValue())
 149               )
 150       );
 151     }
 152   }
 153
 154   private Object getSubInterfaceCountFromResourceProperties(TranslateTo translateTo) {
 155     if (Objects.nonNull(translateTo.getHeatOrchestrationTemplate().getResources().get(translateTo
 156         .getResourceId()))) {
 157       Resource resource = translateTo.getHeatOrchestrationTemplate().getResources().get(translateTo
 158           .getResourceId());
 159       if(HeatResourcesTypes.RESOURCE_GROUP_RESOURCE_TYPE.getHeatResource().equals(resource.getType())) {
 160         return resource.getProperties().get(SUB_INTERFACE_COUNT);
 161       } else if (HeatToToscaUtil.isYamlFile(resource.getType())) {
 162         return HeatConstants.DEFAULT_NESTED_HEAT_RESOURCE_COUNT;
 163       }
 164     }
 165     return null;
 166   }
 167
 168   private void handleSubstitutionServiceTemplateWithoutNodeTemplates(String templateName,
 169                                                                      TranslateTo translateTo) {
 170     translateTo.getContext().addServiceTemplateWithoutNodeTemplates(templateName);
 171     translateTo.getContext()
 172         .addNestedNodeTemplateIdPointsToStWithoutNodeTemplates(translateTo.getTranslatedId());
 173     translateTo.getContext().getTranslatedServiceTemplates().remove(translateTo.getResource().getType());
 174   }
 175
 176   private ServiceTemplate createSubstitutionServiceTemplate(TranslateTo translateTo,
 177                                                             FileData nestedFileData,
 178                                                             String templateName) {
 179     ServiceTemplate nestedSubstitutionServiceTemplate =
 180         HeatToToscaUtil.createInitSubstitutionServiceTemplate(templateName);
 181     translateTo.getContext()
 182         .addNestedHeatFileName(ToscaUtil.getServiceTemplateFileName(templateName),
 183             translateTo.getResource().getType());
 184     new TranslationService().translateHeatFile(nestedSubstitutionServiceTemplate,
 185             nestedFileData, translateTo.getContext());
 186     return nestedSubstitutionServiceTemplate;
 187   }
 188
 189
 190   private void manageSubstitutionNodeTemplateConnectionPoint(TranslateTo translateTo,
 191                                                              FileData nestedFileData,
 192                                                              NodeTemplate substitutionNodeTemplate,
 193                                                              String substitutionNodeTypeId) {
 194     ServiceTemplate globalSubstitutionTemplate =
 195         translateTo.getContext().getTranslatedServiceTemplates()
 196             .get(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME);
 197     NodeType nodeType = globalSubstitutionTemplate.getNode_types().get(substitutionNodeTypeId);
 198     handlePortToNetConnections(translateTo, nestedFileData, substitutionNodeTemplate, nodeType);
 199     handleSecurityRulesToPortConnections(translateTo, nestedFileData, substitutionNodeTemplate,
 200         nodeType);
 201     handleNovaToVolConnection(translateTo, nestedFileData, substitutionNodeTemplate, nodeType);
 202     handleContrailV2VmInterfaceToNetworkConnection(translateTo, nestedFileData,
 203         substitutionNodeTemplate, nodeType);
 204     handleContrailPortToNetConnections(translateTo, nestedFileData, substitutionNodeTemplate,
 205         nodeType);
 206     handleVlanSubInterfaceToInterfaceConnections(translateTo, nestedFileData,
 207         substitutionNodeTemplate, nodeType);
 208   }
 209
 210   private void handleVlanSubInterfaceToInterfaceConnections(TranslateTo translateTo,
 211                                                             FileData nestedFileData,
 212                                                             NodeTemplate substitutionNodeTemplate,
 213                                                             NodeType nodeType) {
 214     ContrailV2VlanToInterfaceResourceConnection linker =
 215         new ContrailV2VlanToInterfaceResourceConnection(this, translateTo, nestedFileData,
 216             substitutionNodeTemplate, nodeType);
 217     linker.connect();
 218   }
 219
 220
 221   private void handleContrailV2VmInterfaceToNetworkConnection(TranslateTo translateTo,
 222                                                               FileData nestedFileData,
 223                                                               NodeTemplate substitutionNodeTemplate,
 224                                                               NodeType nodeType) {
 225     ContrailV2VmInterfaceToNetResourceConnection linker =
 226         new ContrailV2VmInterfaceToNetResourceConnection(this, translateTo, nestedFileData,
 227             substitutionNodeTemplate, nodeType);
 228     linker.connect();
 229   }
 230
 231   private void handleNovaToVolConnection(TranslateTo translateTo, FileData nestedFileData,
 232                                          NodeTemplate substitutionNodeTemplate, NodeType nodeType) {
 233     NovaToVolResourceConnection linker =
 234         new NovaToVolResourceConnection(this, translateTo, nestedFileData, substitutionNodeTemplate,
 235             nodeType);
 236     linker.connect();
 237   }
 238
 239   private void handleSecurityRulesToPortConnections(TranslateTo translateTo,
 240                                                     FileData nestedFileData,
 241                                                     NodeTemplate substitutionNodeTemplate,
 242                                                     NodeType nodeType) {
 243     SecurityRulesToPortResourceConnection linker =
 244         new SecurityRulesToPortResourceConnection(this, translateTo, nestedFileData,
 245             substitutionNodeTemplate, nodeType);
 246     linker.connect();
 247   }
 248
 249   private void handlePortToNetConnections(TranslateTo translateTo, FileData nestedFileData,
 250                                           NodeTemplate substitutionNodeTemplate,
 251                                           NodeType nodeType) {
 252     PortToNetResourceConnection linker =
 253         new PortToNetResourceConnection(this, translateTo, nestedFileData, substitutionNodeTemplate,
 254             nodeType);
 255     linker.connect();
 256   }
 257
 258   private void handleContrailPortToNetConnections(TranslateTo translateTo, FileData nestedFileData,
 259                                                   NodeTemplate substitutionNodeTemplate,
 260                                                   NodeType nodeType) {
 261     ContrailPortToNetResourceConnection linker =
 262         new ContrailPortToNetResourceConnection(this, translateTo, nestedFileData,
 263             substitutionNodeTemplate, nodeType);
 264     linker.connect();
 265   }
 266
 267 }