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