2 * ============LICENSE_START=======================================================
3 * Copyright (C) 2020 Nordix Foundation
4 * ================================================================================
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 * SPDX-License-Identifier: Apache-2.0
17 * ============LICENSE_END=========================================================
19 package org.openecomp.sdc.be.components.impl;
21 import static org.openecomp.sdc.be.components.impl.ImportUtils.Constants.QUOTE;
22 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DEFAULT;
23 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DESCRIPTION;
24 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.IMPLEMENTATION;
25 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.INPUTS;
26 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.NOTIFICATIONS;
27 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.OPERATIONS;
28 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.REQUIRED;
29 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.STATUS;
30 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.TYPE;
32 import com.google.gson.Gson;
33 import fj.data.Either;
34 import java.util.Arrays;
35 import java.util.Collections;
36 import java.util.LinkedHashMap;
37 import java.util.List;
39 import java.util.Map.Entry;
40 import java.util.Optional;
41 import java.util.UUID;
42 import java.util.stream.Collectors;
43 import org.apache.commons.collections.MapUtils;
44 import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
45 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
46 import org.openecomp.sdc.be.dao.api.ActionStatus;
47 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
48 import org.openecomp.sdc.be.datatypes.elements.InputDataDefinition;
49 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
50 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
51 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
52 import org.openecomp.sdc.be.model.InputDefinition;
53 import org.openecomp.sdc.be.model.InterfaceDefinition;
54 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
55 import org.openecomp.sdc.be.tosca.utils.OperationArtifactUtil;
56 import org.openecomp.sdc.exception.ResponseFormat;
57 import org.slf4j.Logger;
58 import org.slf4j.LoggerFactory;
59 import org.springframework.stereotype.Component;
62 * Handles interface definition TOSCA conversions
64 @Component("interfaceDefinitionHandler")
65 public class InterfaceDefinitionHandler {
67 private static final Logger LOGGER = LoggerFactory.getLogger(InterfaceDefinitionHandler.class);
68 private static final String WITH_ATTRIBUTE = "with attribute '{}': '{}'";
69 private final InterfaceOperationBusinessLogic interfaceOperationBusinessLogic;
71 public InterfaceDefinitionHandler(final InterfaceOperationBusinessLogic interfaceOperationBusinessLogic) {
72 this.interfaceOperationBusinessLogic = interfaceOperationBusinessLogic;
76 * Creates an interface definition based on a TOSCA map representing an interface definition.
78 * @param interfaceDefinitionToscaMap the TOSCA interface definition structure
79 * @return an interface definition representation
81 public InterfaceDefinition create(final Map<String, Object> interfaceDefinitionToscaMap, final String model) {
82 final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
83 interfaceDefinition.setModel(model);
84 if (interfaceDefinitionToscaMap.containsKey(TYPE.getElementName())) {
85 final Object typeObj = interfaceDefinitionToscaMap.get(TYPE.getElementName());
86 if (!(typeObj instanceof String)) {
87 throw new ByActionStatusComponentException(ActionStatus.INVALID_YAML);
89 final String type = (String) typeObj;
90 interfaceDefinition.setType(type);
91 interfaceDefinition.setUniqueId(type);
93 final Map<String, InputDefinition> inputDefinitionMap = handleInputs(interfaceDefinitionToscaMap);
94 if (!inputDefinitionMap.isEmpty()) {
95 final Map<String, InputDataDefinition> collect = inputDefinitionMap.entrySet().stream()
96 .collect(Collectors.toMap(Entry::getKey, value -> new InputDataDefinition(value.getValue())));
97 interfaceDefinition.setInputs(collect);
99 final Map<String, OperationDataDefinition> operationMap;
100 if (interfaceDefinitionToscaMap.containsKey(OPERATIONS.getElementName()) || interfaceDefinitionToscaMap
101 .containsKey(NOTIFICATIONS.getElementName())) {
102 operationMap = handleOperations(interfaceDefinitionToscaMap);
103 //TODO handle notifications
105 operationMap = handleLegacyOperations(interfaceDefinitionToscaMap);
107 if (!operationMap.isEmpty()) {
108 validateOperations(interfaceDefinition.getType(), operationMap, model);
109 interfaceDefinition.setOperations(operationMap);
111 return interfaceDefinition;
114 private void validateOperations(final String interfaceType, final Map<String, OperationDataDefinition> operationMap, final String model) {
115 if (MapUtils.isEmpty(operationMap)) {
118 Either<Map<String, InterfaceDefinition>, ResponseFormat> interfaceDefinitionMapEither = interfaceOperationBusinessLogic
119 .getAllInterfaceLifecycleTypes(model);
120 if (interfaceDefinitionMapEither.isRight() || MapUtils.isEmpty(interfaceDefinitionMapEither.left().value())) {
121 throw new ByActionStatusComponentException(ActionStatus.INTERFACE_UNKNOWN, interfaceType);
123 final Map<String, InterfaceDefinition> interfaceDefinitionMap = interfaceDefinitionMapEither.left().value();
124 final Optional<InterfaceDefinition> interfaceDefinitionOptional = interfaceDefinitionMap.entrySet().stream()
125 .filter(interfaceDefinitionEntry -> interfaceDefinitionEntry.getKey().equalsIgnoreCase(UniqueIdBuilder.buildInterfaceTypeUid(model, interfaceType))).map(Entry::getValue).findFirst();
126 if (interfaceDefinitionOptional.isEmpty()) {
127 throw new ByActionStatusComponentException(ActionStatus.INTERFACE_UNKNOWN, interfaceType);
129 final InterfaceDefinition interfaceDefinition = interfaceDefinitionOptional.get();
130 operationMap.keySet().forEach(operation1 -> {
131 if (!interfaceDefinition.hasOperation(operation1)) {
132 throw new ByActionStatusComponentException(ActionStatus.INTERFACE_OPERATION_NOT_DEFINED, operation1, interfaceType);
137 private Map<String, OperationDataDefinition> handleOperations(final Map<String, Object> interfaceDefinitionToscaMap) {
138 if (!interfaceDefinitionToscaMap.containsKey(OPERATIONS.getElementName())) {
139 return Collections.emptyMap();
141 final Map<String, Object> operationMap = (Map<String, Object>) interfaceDefinitionToscaMap.get(OPERATIONS.getElementName());
142 return operationMap.entrySet().stream()
143 .map(interfaceEntry -> createOperation(interfaceEntry.getKey(), (Map<String, Object>) interfaceEntry.getValue()))
144 .collect(Collectors.toMap(OperationDataDefinition::getName, operationDataDefinition -> operationDataDefinition));
147 private Map<String, OperationDataDefinition> handleLegacyOperations(final Map<String, Object> interfaceDefinitionToscaMap) {
148 final List<String> notALegacyOperationEntry = Arrays
149 .asList(OPERATIONS.getElementName(), TYPE.getElementName(), INPUTS.getElementName(), NOTIFICATIONS.getElementName());
150 return interfaceDefinitionToscaMap.entrySet().stream().filter(interfaceEntry -> !notALegacyOperationEntry.contains(interfaceEntry.getKey()))
151 .map(interfaceEntry -> createOperation(interfaceEntry.getKey(), (Map<String, Object>) interfaceEntry.getValue()))
152 .collect(Collectors.toMap(OperationDataDefinition::getName, operationDataDefinition -> operationDataDefinition));
155 private OperationDataDefinition createOperation(final String operationName, final Map<String, Object> operationDefinitionMap) {
156 final OperationDataDefinition operation = new OperationDataDefinition();
157 operation.setUniqueId(UUID.randomUUID().toString());
158 operation.setName(operationName);
159 operation.setImplementation(handleOperationImplementation(operationDefinitionMap).orElse(new ArtifactDataDefinition()));
160 if (operationDefinitionMap.containsKey(INPUTS.getElementName())) {
161 final Map<String, Object> interfaceInputs = (Map<String, Object>) operationDefinitionMap.get(INPUTS.getElementName());
162 operation.setInputs(handleInterfaceOperationInputs(interfaceInputs));
167 private ListDataDefinition<OperationInputDefinition> handleInterfaceOperationInputs(final Map<String, Object> interfaceInputs) {
168 final ListDataDefinition<OperationInputDefinition> inputs = new ListDataDefinition<>();
169 for (final Entry<String, Object> interfaceInput : interfaceInputs.entrySet()) {
170 final OperationInputDefinition operationInput = new OperationInputDefinition();
171 operationInput.setUniqueId(UUID.randomUUID().toString());
172 operationInput.setInputId(operationInput.getUniqueId());
173 operationInput.setName(interfaceInput.getKey());
174 handleInputToscaDefinition(interfaceInput.getKey(), interfaceInput.getValue(), operationInput);
175 inputs.add(operationInput);
180 private void handleInputToscaDefinition(final String inputName, final Object value, final OperationInputDefinition operationInput) {
181 if (value instanceof Map) {
182 final LinkedHashMap<String, Object> inputPropertyValue = (LinkedHashMap<String, Object>) value;
183 LOGGER.debug("Creating interface operation input '{}'", inputName);
184 if (inputPropertyValue.get(TYPE.getElementName()) != null) {
185 final String type = inputPropertyValue.get(TYPE.getElementName()).toString();
186 LOGGER.debug(WITH_ATTRIBUTE, TYPE.getElementName(), type);
187 operationInput.setType(type);
189 if (inputPropertyValue.get(DESCRIPTION.getElementName()) != null) {
190 final String description = inputPropertyValue.get(DESCRIPTION.getElementName()).toString();
191 LOGGER.debug(WITH_ATTRIBUTE, DESCRIPTION.getElementName(), description);
192 operationInput.setDescription(description);
194 if (inputPropertyValue.get(REQUIRED.getElementName()) != null) {
195 final boolean required = Boolean.parseBoolean(inputPropertyValue.get(REQUIRED.getElementName()).toString());
196 LOGGER.debug(WITH_ATTRIBUTE, REQUIRED.getElementName(), required);
197 operationInput.setRequired(required);
199 if (inputPropertyValue.get(DEFAULT.getElementName()) != null) {
200 final Gson gson = new Gson();
201 final String json = gson.toJson(inputPropertyValue.get(DEFAULT.getElementName()));
202 LOGGER.debug(WITH_ATTRIBUTE, DEFAULT.getElementName(), json);
203 operationInput.setToscaDefaultValue(json);
205 if (inputPropertyValue.get(STATUS.getElementName()) != null) {
206 final String status = inputPropertyValue.get(STATUS.getElementName()).toString();
207 LOGGER.debug(WITH_ATTRIBUTE, STATUS.getElementName(), status);
208 operationInput.setStatus(status);
212 if (value instanceof String) {
213 final String stringValue = (String) value;
214 operationInput.setDefaultValue(stringValue);
215 operationInput.setToscaDefaultValue(stringValue);
216 operationInput.setValue(stringValue);
220 private Optional<ArtifactDataDefinition> handleOperationImplementation(final Map<String, Object> operationDefinitionMap) {
221 if (!operationDefinitionMap.containsKey(IMPLEMENTATION.getElementName())) {
222 return Optional.empty();
224 final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
225 final String artifactName = (String) operationDefinitionMap.get(IMPLEMENTATION.getElementName());
226 if (OperationArtifactUtil.artifactNameIsALiteralValue(artifactName)) {
227 artifactDataDefinition.setArtifactName(artifactName);
229 artifactDataDefinition.setArtifactName(QUOTE + artifactName + QUOTE);
231 return Optional.of(artifactDataDefinition);
234 private Map<String, InputDefinition> handleInputs(final Map<String, Object> interfaceDefinitionToscaMap) {
235 if (!interfaceDefinitionToscaMap.containsKey(INPUTS.getElementName())) {
236 return Collections.emptyMap();
238 final Either<Map<String, InputDefinition>, ResultStatusEnum> inputMapEither = ImportUtils.getInputs(interfaceDefinitionToscaMap);
239 if (inputMapEither.isRight()) {
240 return Collections.emptyMap();
242 return inputMapEither.left().value();