gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * -
   3  *  * ============LICENSE_START=======================================================
   4  *  *  Copyright (C) 2019 Nordix Foundation.
   5  *  * ================================================================================
   6  *  * Licensed under the Apache License, Version 2.0 (the "License");
   7  *  * you may not use this file except in compliance with the License.
   8  *  * You may obtain a copy of the License at
   9  *  *
  10  *  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *  *
  12  *  * Unless required by applicable law or agreed to in writing, software
  13  *  * distributed under the License is distributed on an "AS IS" BASIS,
  14  *  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  * See the License for the specific language governing permissions and
  16  *  * limitations under the License.
  17  *  *
  18  *  * SPDX-License-Identifier: Apache-2.0
  19  *  * ============LICENSE_END=========================================================
  20  *
  21  */
  22
  23 package org.openecomp.core.impl;
  24
  25 import org.apache.commons.collections.MapUtils;
  26 import org.onap.sdc.tosca.datatypes.model.ArtifactDefinition;
  27 import org.onap.sdc.tosca.datatypes.model.CapabilityAssignment;
  28 import org.onap.sdc.tosca.datatypes.model.NodeFilter;
  29 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
  30 import org.onap.sdc.tosca.datatypes.model.ParameterDefinition;
  31 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
  32 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  33 import org.onap.sdc.tosca.datatypes.model.SubstitutionMapping;
  34 import org.openecomp.core.converter.ServiceTemplateReaderService;
  35 import org.openecomp.core.converter.datatypes.Constants;
  36 import org.openecomp.core.converter.errors.SubstitutionMappingsConverterErrorBuilder;
  37 import org.openecomp.sdc.common.errors.CoreException;
  38 import org.openecomp.sdc.tosca.services.DataModelUtil;
  39
  40 import java.util.HashMap;
  41 import java.util.List;
  42 import java.util.Map;
  43 import java.util.Objects;
  44 import java.util.Optional;
  45
  46 import static org.openecomp.core.converter.datatypes.Constants.capabilities;
  47 import static org.openecomp.core.converter.datatypes.Constants.inputs;
  48 import static org.openecomp.core.converter.datatypes.Constants.nodeType;
  49 import static org.openecomp.core.converter.datatypes.Constants.outputs;
  50 import static org.openecomp.core.converter.datatypes.Constants.requirements;
  51
  52 public class VnfTopologyTemplateConverter {
  53
  54     public void convertTopologyTemplate(ServiceTemplate serviceTemplate,
  55                                          ServiceTemplateReaderService readerService) {
  56
  57         convertInputs(serviceTemplate, readerService);
  58         convertNodeTemplates(serviceTemplate, readerService);
  59         convertOutputs(serviceTemplate, readerService);
  60         convertSubstitutionMappings(serviceTemplate, readerService);
  61     }
  62
  63     private void convertInputs(ServiceTemplate serviceTemplate,
  64                                ServiceTemplateReaderService readerService) {
  65         Map<String, Object> inputs = readerService.getInputs();
  66         addInputsOrOutputsToServiceTemplate(serviceTemplate, inputs, Constants.inputs);
  67     }
  68
  69     private void convertOutputs(ServiceTemplate serviceTemplate,
  70                                 ServiceTemplateReaderService readerService) {
  71         Map<String, Object> outputs = readerService.getOutputs();
  72         addInputsOrOutputsToServiceTemplate(serviceTemplate, outputs, Constants.outputs);
  73     }
  74
  75     private void addInputsOrOutputsToServiceTemplate(ServiceTemplate serviceTemplate,
  76                                                      Map<String, Object> mapToConvert,
  77                                                      String inputsOrOutputs) {
  78         if (MapUtils.isEmpty(mapToConvert)) {
  79             return;
  80         }
  81
  82         for (Map.Entry<String, Object> entry : mapToConvert.entrySet()) {
  83             Optional<ParameterDefinition> parameterDefinition =
  84                     ToscaConverterUtil.createObjectFromClass(
  85                             entry.getKey(), entry.getValue(), ParameterDefinition.class);
  86
  87             parameterDefinition.ifPresent(parameterDefinitionValue -> {
  88                 Optional<Object> defaultValue =
  89                         ToscaConverterUtil.getDefaultValue(entry.getValue(), parameterDefinition.get());
  90                 defaultValue.ifPresent(parameterDefinitionValue::set_default);
  91                 addToServiceTemplateAccordingToSection(
  92                         serviceTemplate, inputsOrOutputs, entry.getKey(), parameterDefinition.get());
  93             });
  94         }
  95     }
  96
  97     private void addToServiceTemplateAccordingToSection(ServiceTemplate serviceTemplate,
  98                                                         String inputsOrOutputs,
  99                                                         String parameterId,
 100                                                         ParameterDefinition parameterDefinition) {
 101         if (inputsOrOutputs.equals(inputs)) {
 102             DataModelUtil
 103                     .addInputParameterToTopologyTemplate(serviceTemplate, parameterId, parameterDefinition);
 104         } else if (inputsOrOutputs.equals(outputs)) {
 105             DataModelUtil
 106                     .addOutputParameterToTopologyTemplate(serviceTemplate, parameterId, parameterDefinition);
 107         }
 108     }
 109
 110     private void convertNodeTemplates(ServiceTemplate serviceTemplate,
 111                                       ServiceTemplateReaderService readerService) {
 112         Map<String, Object> nodeTemplates = readerService.getNodeTemplates();
 113         if (MapUtils.isEmpty(nodeTemplates)) {
 114             return;
 115         }
 116
 117         for (Map.Entry<String, Object> nodeTemplateEntry : nodeTemplates.entrySet()) {
 118             NodeTemplate nodeTemplate = convertNodeTemplate(nodeTemplateEntry.getValue());
 119             DataModelUtil.addNodeTemplate(serviceTemplate, nodeTemplateEntry.getKey(), nodeTemplate);
 120         }
 121     }
 122
 123     private NodeTemplate convertNodeTemplate(Object candidateNodeTemplate) {
 124         NodeTemplate nodeTemplate = new NodeTemplate();
 125
 126         Map<String, Object> nodeTemplateAsMap = (Map<String, Object>) candidateNodeTemplate;
 127         nodeTemplate.setArtifacts((Map<String, ArtifactDefinition>) nodeTemplateAsMap.get("artifacts"));
 128         nodeTemplate.setAttributes((Map<String, Object>) nodeTemplateAsMap.get("attributes"));
 129         nodeTemplate.setCopy((String) nodeTemplateAsMap.get("copy"));
 130         nodeTemplate.setDescription((String) nodeTemplateAsMap.get("description"));
 131         nodeTemplate.setDirectives((List<String>) nodeTemplateAsMap.get("directives"));
 132         nodeTemplate.setInterfaces(
 133                 (Map<String, Object>) nodeTemplateAsMap.get("interfaces"));
 134         nodeTemplate.setNode_filter((NodeFilter) nodeTemplateAsMap.get("node_filter"));
 135         nodeTemplate.setProperties((Map<String, Object>) nodeTemplateAsMap.get("properties"));
 136         nodeTemplate.setRequirements(
 137                 (List<Map<String, RequirementAssignment>>) nodeTemplateAsMap.get("requirements"));
 138         nodeTemplate.setType((String) nodeTemplateAsMap.get("type"));
 139         nodeTemplate.setCapabilities(
 140                 convertCapabilities((Map<String, Object>) nodeTemplateAsMap.get("capabilities")));
 141
 142         return nodeTemplate;
 143     }
 144
 145     private Map<String, CapabilityAssignment> convertCapabilities(Map<String, Object> capabilities) {
 146         if (MapUtils.isEmpty(capabilities)) {
 147             return null;
 148         }
 149
 150         Map<String, CapabilityAssignment> convertedCapabilities = new HashMap<>();
 151         for (Map.Entry<String, Object> capabilityAssignmentEntry : capabilities.entrySet()) {
 152             Optional<CapabilityAssignment> capabilityAssignment = ToscaConverterUtil.createObjectFromClass
 153                     (capabilityAssignmentEntry.getKey(), capabilityAssignmentEntry.getValue(),
 154                             CapabilityAssignment.class);
 155
 156             capabilityAssignment.ifPresent(capabilityAssignmentValue ->
 157                     convertedCapabilities.put(capabilityAssignmentEntry.getKey(), capabilityAssignmentValue));
 158
 159         }
 160         return convertedCapabilities;
 161     }
 162
 163     private void convertSubstitutionMappings(ServiceTemplate serviceTemplate,
 164                                              ServiceTemplateReaderService readerService) {
 165         Map<String, Object> substitutionMappings = readerService.getSubstitutionMappings();
 166         if (MapUtils.isEmpty(substitutionMappings)) {
 167             return;
 168         }
 169         SubstitutionMapping substitutionMapping = convertSubstitutionMappings(substitutionMappings);
 170         DataModelUtil.addSubstitutionMapping(serviceTemplate, substitutionMapping);
 171     }
 172
 173     private SubstitutionMapping convertSubstitutionMappings(
 174             Map<String, Object> substitutionMappings) {
 175         SubstitutionMapping substitutionMapping = new SubstitutionMapping();
 176
 177         substitutionMapping.setNode_type((String) substitutionMappings.get(nodeType));
 178         substitutionMapping.setCapabilities(
 179                 convertSubstitutionMappingsSections(capabilities, substitutionMappings.get(capabilities)));
 180         substitutionMapping.setRequirements(
 181                 convertSubstitutionMappingsSections(requirements, substitutionMappings.get(requirements)));
 182
 183         return substitutionMapping;
 184     }
 185
 186     private Map<String, List<String>> convertSubstitutionMappingsSections(String sectionName,
 187                                                                           Object sectionToConvert) {
 188
 189         if (Objects.isNull(sectionToConvert)) {
 190             return null;
 191         }
 192
 193         if (!(sectionToConvert instanceof Map)) {
 194             throw new CoreException(
 195                     new SubstitutionMappingsConverterErrorBuilder(
 196                             sectionName, sectionToConvert.getClass().getSimpleName()).build());
 197         }
 198
 199         return convertSection(sectionToConvert);
 200     }
 201
 202     private Map<String, List<String>> convertSection(Object sectionToConvert) {
 203
 204         Map<String, Object> sectionAsMap = (Map<String, Object>) sectionToConvert;
 205         Map<String, List<String>> convertedSection = new HashMap<>();
 206
 207         if (MapUtils.isEmpty(sectionAsMap)) {
 208             return null;
 209         }
 210
 211         for (Map.Entry<String, Object> entry : sectionAsMap.entrySet()) {
 212             if (entry.getValue() instanceof List) {
 213                 convertedSection.put(entry.getKey(), (List<String>) entry.getValue());
 214             }
 215         }
 216
 217         return convertedSection;
 218     }
 219
 220 }