24a344ae922ce23f10b6b05c9ec847650b6be1d0
[sdc.git] /
1 /*
2  * Copyright © 2016-2017 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.generator.core.services;
18
19 import org.apache.commons.collections4.CollectionUtils;
20 import org.apache.commons.collections4.MapUtils;
21 import org.openecomp.sdc.generator.core.utils.GeneratorUtils;
22 import org.openecomp.sdc.generator.datatypes.tosca.MultiFlavorVfcImage;
23 import org.openecomp.sdc.generator.datatypes.tosca.VspModelInfo;
24 import org.openecomp.sdc.generator.util.GeneratorConstants;
25 import org.openecomp.core.utilities.orchestration.OnboardingTypesEnum;
26 import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
27 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
28 import org.onap.sdc.tosca.datatypes.model.Import;
29 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
30 import org.onap.sdc.tosca.datatypes.model.NodeType;
31 import org.onap.sdc.tosca.datatypes.model.PropertyDefinition;
32 import org.onap.sdc.tosca.datatypes.model.PropertyType;
33 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
34 import org.onap.sdc.tosca.datatypes.model.TopologyTemplate;
35 import org.openecomp.sdc.tosca.services.DataModelUtil;
36 import org.openecomp.sdc.tosca.services.ToscaAnalyzerService;
37 import org.openecomp.sdc.tosca.services.ToscaConstants;
38 import org.openecomp.sdc.tosca.services.ToscaUtil;
39 import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
40 import org.openecomp.sdc.translator.services.heattotosca.Constants;
41 import org.openecomp.sdc.translator.services.heattotosca.globaltypes.GlobalTypesGenerator;
42 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.NetworkType;
43 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Nic;
44
45 import java.util.ArrayList;
46 import java.util.HashMap;
47 import java.util.LinkedHashMap;
48 import java.util.List;
49 import java.util.Map;
50 import java.util.Objects;
51 import java.util.Optional;
52
53 /**
54  * The type Manual vsp tosca generator.
55  */
56 public class ManualVspToscaGenerationService {
57
58   //Map of the abstract node template id and substitution node type
59   private Map<String, String> abstractSubstitutionIdTypes = new HashMap<>();
60   //Map of service template name and service template for the generated service templates
61   private Map<String, ServiceTemplate> generatedServiceTemplates = new HashMap<>();
62
63
64   /**
65    * Create manual vsp tosca service model tosca service model.
66    *
67    * @param vspModelInfo the vsp model info
68    * @return the tosca service model
69    */
70   public ToscaServiceModel createManualVspToscaServiceModel(VspModelInfo vspModelInfo) {
71     ToscaServiceModel toscaServiceModel = new ToscaServiceModel();
72     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
73     Map<String, ServiceTemplate> serviceTemplates = new HashMap<>(GlobalTypesGenerator
74         .getGlobalTypesServiceTemplate(OnboardingTypesEnum.MANUAL));
75     toscaServiceModel.setServiceTemplates(serviceTemplates);
76     toscaServiceModel.setEntryDefinitionServiceTemplate(Constants.MAIN_TEMPLATE_NAME
77         + GeneratorConstants.TOSCA_SERVICE_TEMPLATE_FILE_NAME_SUFFIX);
78     createToscaFromVspData(vspModelInfo, toscaServiceModel);
79     for (Map.Entry<String, ServiceTemplate> serviceTemplateEntry :
80         generatedServiceTemplates.entrySet()) {
81       ToscaUtil.addServiceTemplateToMapWithKeyFileName(serviceTemplates, serviceTemplateEntry
82           .getValue());
83     }
84     return toscaServiceModel;
85   }
86
87   private void createToscaFromVspData(VspModelInfo vspModelInfo,
88                                         ToscaServiceModel toscaServiceModel) {
89     List<ServiceTemplate> serviceTemplates = new ArrayList<>();
90     //Only one component supported
91     Optional<String> componentName = getComponentNameFromVspModel(vspModelInfo);
92     if (componentName.isPresent()) {
93       //Create main service template
94       ServiceTemplate mainServiceTemplate = createMainServiceTemplate(vspModelInfo);
95       generatedServiceTemplates.put(Constants.MAIN_TEMPLATE_NAME, mainServiceTemplate);
96       //Create substitution service template
97       for (Map.Entry<String, String> entry : abstractSubstitutionIdTypes.entrySet()) {
98         ServiceTemplate substitutionServiceTemplate =
99             createSubstitutionServiceTemplate(componentName.get(), entry.getValue(), vspModelInfo,
100                 toscaServiceModel);
101         generatedServiceTemplates.put(componentName.get(), substitutionServiceTemplate);
102       }
103     }
104
105   }
106
107   private Optional<String> getComponentNameFromVspModel(VspModelInfo vspModelInfo) {
108     String componentName = null;
109     if (MapUtils.isNotEmpty(vspModelInfo.getComponents())) {
110       //supported for single component only
111       componentName = vspModelInfo.getComponents().entrySet().iterator().next().getValue();
112     }
113     return Optional.ofNullable(componentName);
114   }
115
116   private ServiceTemplate createMainServiceTemplate(VspModelInfo vspModelInfo) {
117     ServiceTemplate mainServiceTemplate = createInitMainServiceTemplate(vspModelInfo
118         .getReleaseVendor());
119     Map<String, String> components = vspModelInfo.getComponents();
120     if (MapUtils.isNotEmpty(components)) {
121       //Currently since only one component is supported we can fetch the component in this manner.
122       // May be need to revisited for supporting multiple components
123       String componentId = components.entrySet().iterator().next().getKey();
124       createVnfConfigurationNodeTemplate(mainServiceTemplate, vspModelInfo);
125       createVnfNodeTemplate(mainServiceTemplate, vspModelInfo, componentId);
126     }
127     return mainServiceTemplate;
128   }
129
130   private void createVnfConfigurationNodeTemplate(ServiceTemplate mainServiceTemplate,
131                                                   VspModelInfo vspModelInfo) {
132     Optional<String> componentName = getComponentNameFromVspModel(vspModelInfo);
133     if (componentName.isPresent()) {
134       NodeTemplate vnfConfigurationNodeTemplate = new NodeTemplate();
135       vnfConfigurationNodeTemplate.setType(ToscaNodeType.VNF_CONFIG_NODE_TYPE);
136       if (Objects.nonNull(vspModelInfo.getAllowedFlavors())) {
137         Map<String, Object> properties = new LinkedHashMap<>();
138         properties.put(GeneratorConstants.ALLOWED_FLAVORS_PROPERTY, vspModelInfo.getAllowedFlavors());
139         vnfConfigurationNodeTemplate.setProperties(properties);
140       }
141       String nodeTemplateId = componentName.get() + GeneratorConstants.VNF_CONFIG_NODE_TEMPLATE_ID_SUFFIX;
142       DataModelUtil.addNodeTemplate(mainServiceTemplate, nodeTemplateId,
143           vnfConfigurationNodeTemplate);
144     }
145   }
146
147   private void createVnfNodeTemplate(ServiceTemplate mainServiceTemplate,
148                                      VspModelInfo vspModelInfo, String componentId) {
149     Optional<String> componentName = getComponentNameFromVspModel(vspModelInfo);
150     if (componentName.isPresent()) {
151       NodeTemplate vnfNodeTemplate = new NodeTemplate();
152       vnfNodeTemplate.setType(ToscaNodeType.MULTIDEPLOYMENTFLAVOR_NODE_TYPE);
153       List<String> directiveList = new ArrayList<>();
154       directiveList.add(ToscaConstants.NODE_TEMPLATE_DIRECTIVE_SUBSTITUTABLE);
155       vnfNodeTemplate.setDirectives(directiveList);
156       vnfNodeTemplate.setProperties(getVnfNodeTemplateProperties(vspModelInfo, componentId));
157       DataModelUtil
158           .addSubstitutionFilteringProperty(getSubstitutionServiceTemplateFileName(componentName
159                   .get()), vnfNodeTemplate, 1);
160       //Enable below if we need "abstract_" as prefix like we have in Unified model
161       //String nodeTemplateId =
162       // Constants.ABSTRACT_NODE_TEMPLATE_ID_PREFIX + componentName + "VNF_NODE_TEMPLATE_ID_SUFFIX";
163       String nodeTemplateId = componentName.get() + GeneratorConstants.VNF_NODE_TEMPLATE_ID_SUFFIX;
164       DataModelUtil.addNodeTemplate(mainServiceTemplate, nodeTemplateId,
165           vnfNodeTemplate);
166       abstractSubstitutionIdTypes.put(componentName.get(), ToscaNodeType
167           .MULTIDEPLOYMENTFLAVOR_NODE_TYPE);
168     }
169   }
170
171   private Map<String, Object> getVnfNodeTemplateProperties(VspModelInfo vspModelInfo,
172                                                            String componentId) {
173     Map<String, Object> properties = new LinkedHashMap<>();
174     if (MapUtils.isNotEmpty(vspModelInfo.getMultiFlavorVfcImages())) {
175       List<MultiFlavorVfcImage> componentImages =
176           vspModelInfo.getMultiFlavorVfcImages().get(componentId);
177       if (Objects.nonNull(componentImages)) {
178         Map<String, MultiFlavorVfcImage> vfcImages = new HashMap<>();
179         componentImages.stream()
180             .forEach(multiFlavorVfcImage ->
181                 vfcImages.put(multiFlavorVfcImage.getSoftware_version(), multiFlavorVfcImage));
182         properties.put(GeneratorConstants.IMAGES_PROPERTY, vfcImages);
183       }
184     }
185     return properties;
186   }
187
188   private String getSubstitutionServiceTemplateFileName(String componentName) {
189     return componentName + GeneratorConstants.TOSCA_SERVICE_TEMPLATE_FILE_NAME_SUFFIX;
190   }
191
192   private ServiceTemplate createInitMainServiceTemplate(String releaseVendor) {
193     ServiceTemplate mainServiceTemplate = new ServiceTemplate();
194     Map<String, String> templateMetadata = new HashMap<>();
195     templateMetadata.put(ToscaConstants.ST_METADATA_TEMPLATE_NAME, Constants.MAIN_TEMPLATE_NAME);
196     if (Objects.nonNull(releaseVendor)) {
197       templateMetadata.put(GeneratorConstants.RELEASE_VENDOR, releaseVendor);
198     }
199     mainServiceTemplate.setTosca_definitions_version(ToscaConstants.TOSCA_DEFINITIONS_VERSION);
200     mainServiceTemplate.setMetadata(templateMetadata);
201     mainServiceTemplate.setTopology_template(new TopologyTemplate());
202     mainServiceTemplate.setImports(getImports());
203     return mainServiceTemplate;
204   }
205
206   private List<Map<String, Import>> getImports() {
207     Map<String, Import> globalSubstitutionTypeImportMap = new HashMap<>();
208     Import globalSubstitutionTypeImport = new Import();
209     globalSubstitutionTypeImport.setFile(ToscaUtil.getServiceTemplateFileName(Constants
210         .GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME));
211     globalSubstitutionTypeImportMap.put(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
212         globalSubstitutionTypeImport);
213     Map<String, Import> globalImports = new HashMap<>();
214     List<Map<String, Import>> manualVspGlobalTypesImportList = GlobalTypesGenerator
215         .getManualVspGlobalTypesImportList();
216     manualVspGlobalTypesImportList.add(globalSubstitutionTypeImportMap);
217     return manualVspGlobalTypesImportList;
218   }
219
220   private ServiceTemplate createSubstitutionServiceTemplate(String serviceTemplateName,
221                                                             String substitutionNodeTypeId,
222                                                             VspModelInfo vspModelInfo,
223                                                             ToscaServiceModel toscaServiceModel) {
224     ServiceTemplate substitutionServiceTemplate =
225         createInitSubstitutionServiceTemplate(serviceTemplateName);
226     createSubstitutionServiceTemplateComponents(substitutionServiceTemplate, vspModelInfo,
227         toscaServiceModel);
228     createSubstitutionServiceTemplateNics(substitutionServiceTemplate, vspModelInfo,
229         toscaServiceModel);
230     handleSubstitutionMapping(substitutionServiceTemplate, toscaServiceModel,
231         substitutionNodeTypeId, serviceTemplateName);
232     return substitutionServiceTemplate;
233   }
234
235   private void createSubstitutionServiceTemplateComponents(ServiceTemplate
236                                                                substitutionServiceTemplate,
237                                                            VspModelInfo vspModelInfo,
238                                                            ToscaServiceModel toscaServiceModel) {
239     Map<String, String> components = vspModelInfo.getComponents();
240     if (MapUtils.isNotEmpty(components)) {
241       for (String componentId : components.keySet()) {
242         String componentName = components.get(componentId);
243         String localNodeTypeId =
244             createComponentDefinitionNodeTemplate(substitutionServiceTemplate, componentName);
245         createLocalNodeType(substitutionServiceTemplate, localNodeTypeId);
246       }
247     }
248   }
249
250   private void createSubstitutionServiceTemplateNics(ServiceTemplate substitutionServiceTemplate,
251                                                      VspModelInfo vspModelInfo,
252                                                      ToscaServiceModel toscaServiceModel) {
253     Map<String, List<Nic>> nics = vspModelInfo.getNics();
254     if (MapUtils.isNotEmpty(nics)) {
255       for (Map.Entry<String, List<Nic>> entry : nics.entrySet()) {
256         String componentId = entry.getKey();
257         String componentNodeTemplateId = getSubstitutionComponentNodeTemplateId(
258             vspModelInfo.getComponents().get(componentId));
259         List<Nic> nicList = entry.getValue();
260         if (CollectionUtils.isNotEmpty(nicList)) {
261           for (Nic nic : nicList) {
262             NodeTemplate nicNodeTemplate = new NodeTemplate();
263             nicNodeTemplate.setType(ToscaNodeType.NETWORK_PORT);
264             DataModelUtil.addBindingReqFromPortToCompute(componentNodeTemplateId, nicNodeTemplate);
265             DataModelUtil.addNodeTemplate(substitutionServiceTemplate,
266                 getNicNodeTemplateId(nic.getName(), nic.getNetworkType()), nicNodeTemplate);
267           }
268         }
269       }
270     }
271   }
272
273   private String getSubstitutionComponentNodeTemplateId(String componentName) {
274     //TODO: Confirm if anything else is needed here
275     return componentName;
276   }
277
278   private String getNicNodeTemplateId(String nicName, NetworkType nicNetworkType) {
279     StringBuilder builder = new StringBuilder();
280     builder.append(nicName);
281     if (nicNetworkType == NetworkType.External) {
282       builder.append(GeneratorConstants.PORT_TYPE_EXTERNAL_NODE_TEMPLATE_SUFFIX);
283     } else if (nicNetworkType == NetworkType.Internal) {
284       builder.append(GeneratorConstants.PORT_TYPE_INTERNAL_NODE_TEMPLATE_SUFFIX);
285     }
286     builder.append(GeneratorConstants.PORT_NODE_TEMPLATE_ID_SUFFIX);
287     return builder.toString();
288   }
289
290   private String createComponentDefinitionNodeTemplate(ServiceTemplate substitutionServiceTemplate,
291                                                        String componentName) {
292     NodeTemplate nodeTemplate = new NodeTemplate();
293     String localNodeTypeId = getLocalNodeTypeId(componentName);
294     nodeTemplate.setType(localNodeTypeId);
295     DataModelUtil.addNodeTemplate(substitutionServiceTemplate, componentName, nodeTemplate);
296     return localNodeTypeId;
297   }
298
299   private void createLocalNodeType(ServiceTemplate substitutionServiceTemplate,
300                                    String localNodeTypeId) {
301     NodeType localNodeType = new NodeType();
302     localNodeType.setDerived_from(ToscaNodeType.COMPUTE);
303     DataModelUtil.addNodeType(substitutionServiceTemplate, localNodeTypeId, localNodeType );
304   }
305
306   private String getLocalNodeTypeId(String componentName) {
307     return ToscaNodeType.VFC_NODE_TYPE_PREFIX + componentName;
308   }
309
310   private ServiceTemplate createInitSubstitutionServiceTemplate(String serviceTemplateName) {
311     ServiceTemplate substitutionServiceTemplate = new ServiceTemplate();
312     Map<String, String> templateMetadata = new HashMap<>();
313     substitutionServiceTemplate.setTosca_definitions_version(ToscaConstants
314         .TOSCA_DEFINITIONS_VERSION);
315     templateMetadata.put(ToscaConstants.ST_METADATA_TEMPLATE_NAME, serviceTemplateName);
316     substitutionServiceTemplate.setMetadata(templateMetadata);
317     substitutionServiceTemplate.setTopology_template(new TopologyTemplate());
318     substitutionServiceTemplate.setImports(getImports());
319     return substitutionServiceTemplate;
320   }
321
322   private void handleSubstitutionMapping(ServiceTemplate substitutionServiceTemplate,
323                                          ToscaServiceModel toscaServiceModel,
324                                          String substitutionNodeTypeId,
325                                          String componentName) {
326     ServiceTemplate globalSubstitutionServiceTemplate = fetchGlobalSubstitutionServiceTemplate();
327     NodeType substitutionNodeType =
328         createGlobalSubstitutionNodeType(substitutionServiceTemplate, componentName);
329     DataModelUtil.addNodeType(globalSubstitutionServiceTemplate, substitutionNodeTypeId,
330         substitutionNodeType);
331     Map<String, Map<String, List<String>>> substitutionMapping =
332         GeneratorUtils.getSubstitutionNodeTypeExposedConnectionPoints(substitutionNodeType,
333             substitutionServiceTemplate, toscaServiceModel);
334     if (Objects.nonNull(substitutionMapping)) {
335       //add substitution mapping after capability and requirement expose calculation
336       substitutionServiceTemplate.getTopology_template().setSubstitution_mappings(
337           DataModelUtil.createSubstitutionTemplateSubMapping(substitutionNodeTypeId,
338               substitutionNodeType, substitutionMapping));
339     }
340   }
341
342   //*************** CREATE GLOBAL SUBSTITUTION SERVICE TEMPLATE **********************
343
344   private ServiceTemplate createInitGlobalSubstitutionServiceTemplate() {
345     ServiceTemplate globalSubstitutionServiceTemplate = new ServiceTemplate();
346     Map<String, String> templateMetadata = new HashMap<>();
347     globalSubstitutionServiceTemplate.setTosca_definitions_version(ToscaConstants
348         .TOSCA_DEFINITIONS_VERSION);
349     templateMetadata.put(ToscaConstants.ST_METADATA_TEMPLATE_NAME,
350         Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME);
351     globalSubstitutionServiceTemplate.setMetadata(templateMetadata);
352     globalSubstitutionServiceTemplate.setImports(getImports());
353     return globalSubstitutionServiceTemplate;
354   }
355
356   private NodeType createGlobalSubstitutionNodeType(ServiceTemplate substitutionServiceTemplate,
357                                                 String componentName) {
358     NodeType substitutionNodeType = new ToscaAnalyzerServiceImpl()
359         .createInitSubstitutionNodeType(substitutionServiceTemplate,
360             ToscaNodeType.MULTIFLAVOR_VFC_NODE_TYPE);
361     substitutionNodeType.setProperties(
362         getManualVspSubstitutionNodeTypeProperties(substitutionNodeType, componentName));
363     return substitutionNodeType;
364   }
365
366   private Map<String, PropertyDefinition> getManualVspSubstitutionNodeTypeProperties(
367       NodeType substitutionNodeType, String componentName) {
368     //Create num_cpus property
369     PropertyDefinition numCpus = new PropertyDefinition();
370     numCpus.setType(PropertyType.INTEGER.getDisplayName());
371     numCpus.setDescription(GeneratorConstants.NUM_CPUS_PROP_DESC_PREFIX + componentName);
372     numCpus.setRequired(true);
373     //Create disk_size property
374     PropertyDefinition diskSize = new PropertyDefinition();
375     diskSize.setType(PropertyType.SCALAR_UNIT_SIZE.getDisplayName());
376     diskSize.setDescription(GeneratorConstants.DISK_SIZE_PROP_DESC_PREFIX + componentName);
377     diskSize.setRequired(true);
378     //Create mem_size property
379     PropertyDefinition memSize = new PropertyDefinition();
380     memSize.setType(PropertyType.SCALAR_UNIT_SIZE.getDisplayName());
381     memSize.setDescription(GeneratorConstants.MEM_SIZE_PROP_DESC_PREFIX + componentName);
382     memSize.setRequired(true);
383
384     Map<String, PropertyDefinition> manualVspProperties = new LinkedHashMap<>();
385     manualVspProperties.put(GeneratorConstants.NUM_CPUS, numCpus);
386     manualVspProperties.put(GeneratorConstants.DISK_SIZE, diskSize);
387     manualVspProperties.put(GeneratorConstants.MEM_SIZE, memSize);
388
389     return manualVspProperties;
390   }
391
392   private String getSubstitutionNodeTypeId(String componentName) {
393     return ToscaNodeType.MULTIDEPLOYMENTFLAVOR_NODE_TYPE + "." + componentName;
394   }
395
396   /**
397    * Fetch global substitution service template service template.
398    *
399    * @return the global substitution service template
400    */
401   private ServiceTemplate fetchGlobalSubstitutionServiceTemplate() {
402     ServiceTemplate globalSubstitutionServiceTemplate =
403         generatedServiceTemplates.get(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME);
404     if (Objects.isNull(globalSubstitutionServiceTemplate)) {
405       globalSubstitutionServiceTemplate = createInitGlobalSubstitutionServiceTemplate();
406       generatedServiceTemplates.put(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
407               globalSubstitutionServiceTemplate);
408     }
409     return globalSubstitutionServiceTemplate;
410   }
411 }