openecomp-be/lib/openecomp-tosca-converter-lib/openecomp-tosca-converter-core/src/main/java/org/openecomp/core/impl/VnfTopologyTemplateConverter.java

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