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.PolicyDefinition;
  32 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
  33 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  34 import org.onap.sdc.tosca.datatypes.model.SubstitutionMapping;
  35 import org.onap.sdc.tosca.datatypes.model.Trigger;
  36 import org.openecomp.core.converter.ServiceTemplateReaderService;
  37 import org.openecomp.core.converter.datatypes.Constants;
  38 import org.openecomp.core.converter.errors.SubstitutionMappingsConverterErrorBuilder;
  39 import org.openecomp.sdc.common.errors.CoreException;
  40 import org.openecomp.sdc.tosca.services.DataModelUtil;
  41
  42 import java.util.HashMap;
  43 import java.util.List;
  44 import java.util.Map;
  45 import java.util.Objects;
  46 import java.util.Optional;
  47
  48 import static org.openecomp.core.converter.datatypes.Constants.CAPABILITIES;
  49 import static org.openecomp.core.converter.datatypes.Constants.INPUTS;
  50 import static org.openecomp.core.converter.datatypes.Constants.NODE_FILTER;
  51 import static org.openecomp.core.converter.datatypes.Constants.NODE_TYPE;
  52 import static org.openecomp.core.converter.datatypes.Constants.OUTPUTS;
  53 import static org.openecomp.core.converter.datatypes.Constants.REQUIREMENTS;
  54
  55 public class VnfTopologyTemplateConverter {
  56
  57     public void convertTopologyTemplate(ServiceTemplate serviceTemplate, ServiceTemplateReaderService readerService) {
  58         convertInputs(serviceTemplate, readerService);
  59         convertNodeTemplates(serviceTemplate, readerService);
  60         convertOutputs(serviceTemplate, readerService);
  61         convertSubstitutionMappings(serviceTemplate, readerService);
  62         convertPolicies(serviceTemplate, readerService);
  63     }
  64
  65     private void convertInputs(ServiceTemplate serviceTemplate, ServiceTemplateReaderService readerService) {
  66         Map<String, Object> inputs = readerService.getInputs();
  67         addInputsOrOutputsToServiceTemplate(serviceTemplate, inputs, Constants.INPUTS);
  68     }
  69
  70     private void convertOutputs(ServiceTemplate serviceTemplate, ServiceTemplateReaderService readerService) {
  71         Map<String, Object> outputs = readerService.getOutputs();
  72         addInputsOrOutputsToServiceTemplate(serviceTemplate, outputs, Constants.OUTPUTS);
  73     }
  74
  75     private void addInputsOrOutputsToServiceTemplate(ServiceTemplate serviceTemplate, Map<String, Object> mapToConvert,
  76             String inputsOrOutputs) {
  77         if (MapUtils.isEmpty(mapToConvert)) {
  78             return;
  79         }
  80
  81         for (Map.Entry<String, Object> entry : mapToConvert.entrySet()) {
  82             Optional<ParameterDefinition> parameterDefinition = ToscaConverterUtil.createObjectFromClass(entry.getKey(),
  83                     entry.getValue(), ParameterDefinition.class);
  84
  85             parameterDefinition.ifPresent(parameterDefinitionValue -> {
  86                 Optional<Object> defaultValue =
  87                         ToscaConverterUtil.getDefaultValue(entry.getValue(), parameterDefinition.get());
  88                 defaultValue.ifPresent(parameterDefinitionValue::set_default);
  89                 addToServiceTemplateAccordingToSection(serviceTemplate, inputsOrOutputs, entry.getKey(),
  90                         parameterDefinition.get());
  91             });
  92         }
  93     }
  94
  95     private void addToServiceTemplateAccordingToSection(ServiceTemplate serviceTemplate, String inputsOrOutputs,
  96             String parameterId, ParameterDefinition parameterDefinition) {
  97         if (inputsOrOutputs.equals(INPUTS)) {
  98             DataModelUtil.addInputParameterToTopologyTemplate(serviceTemplate, parameterId, parameterDefinition);
  99         } else if (inputsOrOutputs.equals(OUTPUTS)) {
 100             DataModelUtil.addOutputParameterToTopologyTemplate(serviceTemplate, parameterId, parameterDefinition);
 101         }
 102     }
 103
 104     private void convertNodeTemplates(ServiceTemplate serviceTemplate, ServiceTemplateReaderService readerService) {
 105         Map<String, Object> nodeTemplates = readerService.getNodeTemplates();
 106         if (MapUtils.isEmpty(nodeTemplates)) {
 107             return;
 108         }
 109
 110         for (Map.Entry<String, Object> nodeTemplateEntry : nodeTemplates.entrySet()) {
 111             NodeTemplate nodeTemplate = convertNodeTemplate(nodeTemplateEntry.getValue());
 112             DataModelUtil.addNodeTemplate(serviceTemplate, nodeTemplateEntry.getKey(), nodeTemplate);
 113         }
 114     }
 115
 116     private NodeTemplate convertNodeTemplate(Object candidateNodeTemplate) {
 117         NodeTemplate nodeTemplate = new NodeTemplate();
 118
 119         Map<String, Object> nodeTemplateAsMap = (Map<String, Object>) candidateNodeTemplate;
 120         nodeTemplate.setArtifacts((Map<String, ArtifactDefinition>) nodeTemplateAsMap.get("artifacts"));
 121         nodeTemplate.setAttributes((Map<String, Object>) nodeTemplateAsMap.get("attributes"));
 122         nodeTemplate.setCopy((String) nodeTemplateAsMap.get("copy"));
 123         nodeTemplate.setDescription((String) nodeTemplateAsMap.get("description"));
 124         nodeTemplate.setDirectives((List<String>) nodeTemplateAsMap.get("directives"));
 125         nodeTemplate.setInterfaces((Map<String, Object>) nodeTemplateAsMap.get("interfaces"));
 126         nodeTemplate.setNode_filter((NodeFilter) nodeTemplateAsMap.get(NODE_FILTER));
 127         nodeTemplate.setProperties((Map<String, Object>) nodeTemplateAsMap.get("properties"));
 128         nodeTemplate.setRequirements((List<Map<String, RequirementAssignment>>) nodeTemplateAsMap.get("requirements"));
 129         nodeTemplate.setType((String) nodeTemplateAsMap.get("type"));
 130         nodeTemplate.setCapabilities(convertCapabilities((Map<String, Object>) nodeTemplateAsMap.get("capabilities")));
 131
 132         return nodeTemplate;
 133     }
 134
 135     private Map<String, CapabilityAssignment> convertCapabilities(Map<String, Object> capabilities) {
 136         if (MapUtils.isEmpty(capabilities)) {
 137             return null;
 138         }
 139
 140         Map<String, CapabilityAssignment> convertedCapabilities = new HashMap<>();
 141         for (Map.Entry<String, Object> capabilityAssignmentEntry : capabilities.entrySet()) {
 142             Optional<CapabilityAssignment> capabilityAssignment = ToscaConverterUtil.createObjectFromClass(
 143                     capabilityAssignmentEntry.getKey(), capabilityAssignmentEntry.getValue(),
 144                     CapabilityAssignment.class);
 145
 146             capabilityAssignment.ifPresent(capabilityAssignmentValue -> convertedCapabilities
 147                                                                                 .put(capabilityAssignmentEntry.getKey(),
 148                                                                                         capabilityAssignmentValue));
 149
 150         }
 151         return convertedCapabilities;
 152     }
 153
 154     private void convertSubstitutionMappings(ServiceTemplate serviceTemplate,
 155             ServiceTemplateReaderService readerService) {
 156         Map<String, Object> substitutionMappings = readerService.getSubstitutionMappings();
 157         if (MapUtils.isEmpty(substitutionMappings)) {
 158             return;
 159         }
 160         SubstitutionMapping substitutionMapping = convertSubstitutionMappings(substitutionMappings);
 161         DataModelUtil.addSubstitutionMapping(serviceTemplate, substitutionMapping);
 162     }
 163
 164     private SubstitutionMapping convertSubstitutionMappings(Map<String, Object> substitutionMappings) {
 165         SubstitutionMapping substitutionMapping = new SubstitutionMapping();
 166
 167         substitutionMapping.setNode_type((String) substitutionMappings.get(NODE_TYPE));
 168         substitutionMapping.setCapabilities(
 169                 convertSubstitutionMappingsSections(CAPABILITIES, substitutionMappings.get(CAPABILITIES)));
 170         substitutionMapping.setRequirements(
 171                 convertSubstitutionMappingsSections(REQUIREMENTS, substitutionMappings.get(REQUIREMENTS)));
 172         substitutionMapping.setSubstitution_filter((NodeFilter) substitutionMappings.get(NODE_FILTER));
 173
 174         return substitutionMapping;
 175     }
 176
 177     private Map<String, List<String>> convertSubstitutionMappingsSections(String sectionName, Object sectionToConvert) {
 178
 179         if (Objects.isNull(sectionToConvert)) {
 180             return null;
 181         }
 182
 183         if (!(sectionToConvert instanceof Map)) {
 184             throw new CoreException(new SubstitutionMappingsConverterErrorBuilder(sectionName,
 185                     sectionToConvert.getClass().getSimpleName()).build());
 186         }
 187
 188         return convertSection(sectionToConvert);
 189     }
 190
 191     private Map<String, List<String>> convertSection(Object sectionToConvert) {
 192
 193         Map<String, Object> sectionAsMap = (Map<String, Object>) sectionToConvert;
 194         Map<String, List<String>> convertedSection = new HashMap<>();
 195
 196         if (MapUtils.isEmpty(sectionAsMap)) {
 197             return null;
 198         }
 199
 200         for (Map.Entry<String, Object> entry : sectionAsMap.entrySet()) {
 201             if (entry.getValue() instanceof List) {
 202                 convertedSection.put(entry.getKey(), (List<String>) entry.getValue());
 203             }
 204         }
 205
 206         return convertedSection;
 207     }
 208
 209     private void convertPolicies(ServiceTemplate serviceTemplate, ServiceTemplateReaderService readerService) {
 210         Map<String, Object> policiesAsMap = readerService.getPolicies();
 211         for (Map.Entry<String, Object> policy : policiesAsMap.entrySet()) {
 212             PolicyDefinition policyDefinition = convertPolicy(policy.getValue());
 213             DataModelUtil.addPolicyDefinition(serviceTemplate, policy.getKey(), policyDefinition);
 214         }
 215     }
 216
 217     private PolicyDefinition convertPolicy(Object policyCandidate) {
 218         PolicyDefinition policyDefinition = new PolicyDefinition();
 219         Map<String, Object> policy = (Map<String, Object>) policyCandidate;
 220         policyDefinition.setDescription((String) policy.get("description"));
 221         policyDefinition.setType((String) policy.get("type"));
 222         policyDefinition.setMetadata((Map<String, String>) policy.get("metadata"));
 223         policyDefinition.setProperties((Map<String, Object>) policy.get("properties"));
 224         policyDefinition.setTargets((List<String>) policy.get("targets"));
 225         policyDefinition.setTriggers((Map<String, Trigger>) policy.get("triggers"));
 226
 227         return policyDefinition;
 228     }
 229 }