catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceDefinitionHandler.java

   1 /*
   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
   8  *
   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.
  15  *
  16  *  SPDX-License-Identifier: Apache-2.0
  17  *  ============LICENSE_END=========================================================
  18  */
  19 package org.openecomp.sdc.be.components.impl;
  20
  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;
  31
  32 import com.google.gson.Gson;
  33 import fj.data.Either;
  34 import java.util.ArrayList;
  35 import java.util.Arrays;
  36 import java.util.Collections;
  37 import java.util.LinkedHashMap;
  38 import java.util.List;
  39 import java.util.Map;
  40 import java.util.Map.Entry;
  41 import java.util.Optional;
  42 import java.util.UUID;
  43 import java.util.stream.Collectors;
  44 import org.apache.commons.collections.MapUtils;
  45 import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
  46 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
  47 import org.openecomp.sdc.be.dao.api.ActionStatus;
  48 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  49 import org.openecomp.sdc.be.datatypes.elements.InputDataDefinition;
  50 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  51 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
  52 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
  53 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  54 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
  55 import org.openecomp.sdc.be.model.InputDefinition;
  56 import org.openecomp.sdc.be.model.InterfaceDefinition;
  57 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  58 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
  59 import org.openecomp.sdc.be.tosca.utils.OperationArtifactUtil;
  60 import org.openecomp.sdc.exception.ResponseFormat;
  61 import org.slf4j.Logger;
  62 import org.slf4j.LoggerFactory;
  63 import org.springframework.stereotype.Component;
  64
  65 /**
  66  * Handles interface definition TOSCA conversions
  67  */
  68 @Component("interfaceDefinitionHandler")
  69 public class InterfaceDefinitionHandler {
  70
  71     private static final Logger LOGGER = LoggerFactory.getLogger(InterfaceDefinitionHandler.class);
  72     private static final String WITH_ATTRIBUTE = "with attribute '{}': '{}'";
  73     private final InterfaceOperationBusinessLogic interfaceOperationBusinessLogic;
  74
  75     public InterfaceDefinitionHandler(final InterfaceOperationBusinessLogic interfaceOperationBusinessLogic) {
  76         this.interfaceOperationBusinessLogic = interfaceOperationBusinessLogic;
  77     }
  78
  79     /**
  80      * Creates an interface definition based on a TOSCA map representing an interface definition.
  81      *
  82      * @param interfaceDefinitionToscaMap the TOSCA interface definition structure
  83      * @return an interface definition representation
  84      */
  85     public InterfaceDefinition create(final Map<String, Object> interfaceDefinitionToscaMap, final String model) {
  86         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
  87         interfaceDefinition.setModel(model);
  88         if (interfaceDefinitionToscaMap.containsKey(TYPE.getElementName())) {
  89             final Object typeObj = interfaceDefinitionToscaMap.get(TYPE.getElementName());
  90             if (!(typeObj instanceof String)) {
  91                 throw new ByActionStatusComponentException(ActionStatus.INVALID_YAML);
  92             }
  93             final String type = (String) typeObj;
  94             interfaceDefinition.setType(type);
  95             interfaceDefinition.setUniqueId(type);
  96         }
  97         final Map<String, InputDefinition> inputDefinitionMap = handleInputs(interfaceDefinitionToscaMap);
  98         if (!inputDefinitionMap.isEmpty()) {
  99             final Map<String, InputDataDefinition> collect = inputDefinitionMap.entrySet().stream()
 100                 .collect(Collectors.toMap(Entry::getKey, value -> new InputDataDefinition(value.getValue())));
 101             interfaceDefinition.setInputs(collect);
 102         }
 103         final Map<String, OperationDataDefinition> operationMap;
 104         if (interfaceDefinitionToscaMap.containsKey(OPERATIONS.getElementName()) || interfaceDefinitionToscaMap
 105             .containsKey(NOTIFICATIONS.getElementName())) {
 106             operationMap = handleOperations(interfaceDefinitionToscaMap);
 107             //TODO handle notifications
 108         } else {
 109             operationMap = handleLegacyOperations(interfaceDefinitionToscaMap);
 110         }
 111         if (!operationMap.isEmpty()) {
 112             validateOperations(interfaceDefinition.getType(), operationMap, model);
 113             interfaceDefinition.setOperations(operationMap);
 114         }
 115         return interfaceDefinition;
 116     }
 117
 118     private void validateOperations(final String interfaceType, final Map<String, OperationDataDefinition> operationMap, final String model) {
 119         if (MapUtils.isEmpty(operationMap)) {
 120             return;
 121         }
 122         Either<Map<String, InterfaceDefinition>, ResponseFormat> interfaceDefinitionMapEither = interfaceOperationBusinessLogic
 123             .getAllInterfaceLifecycleTypes(model);
 124         if (interfaceDefinitionMapEither.isRight() || MapUtils.isEmpty(interfaceDefinitionMapEither.left().value())) {
 125             throw new ByActionStatusComponentException(ActionStatus.INTERFACE_UNKNOWN, interfaceType);
 126         }
 127         final Map<String, InterfaceDefinition> interfaceDefinitionMap = interfaceDefinitionMapEither.left().value();
 128         final Optional<InterfaceDefinition> interfaceDefinitionOptional = interfaceDefinitionMap.entrySet().stream()
 129             .filter(interfaceDefinitionEntry -> interfaceDefinitionEntry.getKey().equalsIgnoreCase(UniqueIdBuilder.buildInterfaceTypeUid(model, interfaceType))).map(Entry::getValue).findFirst();
 130         if (interfaceDefinitionOptional.isEmpty()) {
 131             throw new ByActionStatusComponentException(ActionStatus.INTERFACE_UNKNOWN, interfaceType);
 132         }
 133         final InterfaceDefinition interfaceDefinition = interfaceDefinitionOptional.get();
 134         operationMap.keySet().forEach(operation1 -> {
 135             if (!interfaceDefinition.hasOperation(operation1)) {
 136                 throw new ByActionStatusComponentException(ActionStatus.INTERFACE_OPERATION_NOT_DEFINED, operation1, interfaceType);
 137             }
 138         });
 139     }
 140
 141     private Map<String, OperationDataDefinition> handleOperations(final Map<String, Object> interfaceDefinitionToscaMap) {
 142         if (!interfaceDefinitionToscaMap.containsKey(OPERATIONS.getElementName())) {
 143             return Collections.emptyMap();
 144         }
 145         final Map<String, Object> operationMap = (Map<String, Object>) interfaceDefinitionToscaMap.get(OPERATIONS.getElementName());
 146         return operationMap.entrySet().stream()
 147             .map(interfaceEntry -> createOperation(interfaceEntry.getKey(), (Map<String, Object>) interfaceEntry.getValue()))
 148             .collect(Collectors.toMap(OperationDataDefinition::getName, operationDataDefinition -> operationDataDefinition));
 149     }
 150
 151     private Map<String, OperationDataDefinition> handleLegacyOperations(final Map<String, Object> interfaceDefinitionToscaMap) {
 152         final List<String> notALegacyOperationEntry = Arrays
 153             .asList(OPERATIONS.getElementName(), TYPE.getElementName(), INPUTS.getElementName(), NOTIFICATIONS.getElementName());
 154         return interfaceDefinitionToscaMap.entrySet().stream().filter(interfaceEntry -> !notALegacyOperationEntry.contains(interfaceEntry.getKey()))
 155             .map(interfaceEntry -> createOperation(interfaceEntry.getKey(), (Map<String, Object>) interfaceEntry.getValue()))
 156             .collect(Collectors.toMap(OperationDataDefinition::getName, operationDataDefinition -> operationDataDefinition));
 157     }
 158
 159     private OperationDataDefinition createOperation(final String operationName, final Map<String, Object> operationDefinitionMap) {
 160         final OperationDataDefinition operation = new OperationDataDefinition();
 161         operation.setUniqueId(UUID.randomUUID().toString());
 162         operation.setName(operationName);
 163
 164         if (MapUtils.isEmpty(operationDefinitionMap)) {
 165             return operation;
 166         }
 167         Object operationDescription = operationDefinitionMap.get(
 168                 DESCRIPTION.getElementName()
 169         );
 170         if (null != operationDescription) {
 171             operation.setDescription(operationDescription.toString());
 172         }
 173         operation.setImplementation(handleOperationImplementation(operationDefinitionMap).orElse(new ArtifactDataDefinition()));
 174         if (operationDefinitionMap.containsKey(INPUTS.getElementName())) {
 175             final Map<String, Object> interfaceInputs = (Map<String, Object>) operationDefinitionMap.get(INPUTS.getElementName());
 176             operation.setInputs(handleInterfaceOperationInputs(interfaceInputs));
 177         }
 178         return operation;
 179     }
 180
 181     private ListDataDefinition<OperationInputDefinition> handleInterfaceOperationInputs(final Map<String, Object> interfaceInputs) {
 182         final ListDataDefinition<OperationInputDefinition> inputs = new ListDataDefinition<>();
 183         for (final Entry<String, Object> interfaceInput : interfaceInputs.entrySet()) {
 184             final OperationInputDefinition operationInput = new OperationInputDefinition();
 185             operationInput.setUniqueId(UUID.randomUUID().toString());
 186             operationInput.setInputId(operationInput.getUniqueId());
 187             operationInput.setName(interfaceInput.getKey());
 188             handleInputToscaDefinition(interfaceInput.getKey(), interfaceInput.getValue(), operationInput);
 189             inputs.add(operationInput);
 190         }
 191         return inputs;
 192     }
 193
 194     private void handleInputToscaDefinition(final String inputName, final Object value, final OperationInputDefinition operationInput) {
 195         if (value instanceof Map) {
 196             final LinkedHashMap<String, Object> inputPropertyValue = (LinkedHashMap<String, Object>) value;
 197             LOGGER.debug("Creating interface operation input '{}'", inputName);
 198             if (inputPropertyValue.get(TYPE.getElementName()) != null) {
 199                 final String type = inputPropertyValue.get(TYPE.getElementName()).toString();
 200                 LOGGER.debug(WITH_ATTRIBUTE, TYPE.getElementName(), type);
 201                 operationInput.setType(type);
 202             }
 203             if (inputPropertyValue.get(DESCRIPTION.getElementName()) != null) {
 204                 final String description = inputPropertyValue.get(DESCRIPTION.getElementName()).toString();
 205                 LOGGER.debug(WITH_ATTRIBUTE, DESCRIPTION.getElementName(), description);
 206                 operationInput.setDescription(description);
 207             }
 208             if (inputPropertyValue.get(REQUIRED.getElementName()) != null) {
 209                 final boolean required = Boolean.parseBoolean(inputPropertyValue.get(REQUIRED.getElementName()).toString());
 210                 LOGGER.debug(WITH_ATTRIBUTE, REQUIRED.getElementName(), required);
 211                 operationInput.setRequired(required);
 212             }
 213             if (inputPropertyValue.get(DEFAULT.getElementName()) != null) {
 214                 final Gson gson = new Gson();
 215                 final String json = gson.toJson(inputPropertyValue.get(DEFAULT.getElementName()));
 216                 LOGGER.debug(WITH_ATTRIBUTE, DEFAULT.getElementName(), json);
 217                 operationInput.setToscaDefaultValue(json);
 218             }
 219             if (inputPropertyValue.get(STATUS.getElementName()) != null) {
 220                 final String status = inputPropertyValue.get(STATUS.getElementName()).toString();
 221                 LOGGER.debug(WITH_ATTRIBUTE, STATUS.getElementName(), status);
 222                 operationInput.setStatus(status);
 223             }
 224             return;
 225         }
 226         if (value instanceof String) {
 227             final String stringValue = (String) value;
 228             operationInput.setDefaultValue(stringValue);
 229             operationInput.setToscaDefaultValue(stringValue);
 230             operationInput.setValue(stringValue);
 231         }
 232     }
 233
 234     @SuppressWarnings("unchecked")
 235     private Optional<ArtifactDataDefinition> handleOperationImplementation(final Map<String, Object> operationDefinitionMap) {
 236         if (!operationDefinitionMap.containsKey(IMPLEMENTATION.getElementName())) {
 237             return Optional.empty();
 238         }
 239         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 240         if (operationDefinitionMap.get(IMPLEMENTATION.getElementName()) instanceof Map &&
 241                 ((Map)operationDefinitionMap.get(IMPLEMENTATION.getElementName())).containsKey("primary")) {
 242             Map<String, Object> implDetails = (Map) ((Map)operationDefinitionMap.get(IMPLEMENTATION.getElementName())).get("primary");
 243
 244             if (implDetails.get("file") != null) {
 245                 final String file = implDetails.get("file").toString();
 246                 artifactDataDefinition.setArtifactName(generateArtifactName(file));
 247             }
 248             if (implDetails.get("type") != null) {
 249                 artifactDataDefinition.setArtifactType(implDetails.get("type").toString());
 250             }
 251             if (implDetails.get("artifact_version") != null) {
 252                 artifactDataDefinition.setArtifactVersion(implDetails.get("artifact_version").toString());
 253             }
 254
 255             if(implDetails.get("properties") instanceof Map) {
 256                 List<PropertyDataDefinition> operationProperties = artifactDataDefinition.getProperties() == null ? new ArrayList<>() : artifactDataDefinition.getProperties();
 257                 Map<String, Object> properties = (Map<String, Object>) implDetails.get("properties");
 258                 properties.forEach((k,v) -> {
 259                     ToscaPropertyType type = getTypeFromObject(v);
 260                     if (type != null) {
 261                         PropertyDataDefinition propertyDef = new PropertyDataDefinition();
 262                         propertyDef.setName(k);
 263                         propertyDef.setType(type.getType());
 264                         propertyDef.setValue(v.toString());
 265                         if (type.equals(ToscaPropertyType.LIST)) {
 266                             Gson gson = new Gson();
 267                             propertyDef.setValue(gson.toJson(v));
 268                             PropertyDataDefinition pdd = new PropertyDataDefinition();
 269                             pdd.setType("string");
 270                             SchemaDefinition sd = new SchemaDefinition();
 271                             sd.setProperty(pdd);
 272                             propertyDef.setSchema(sd);
 273                         }
 274                         artifactDataDefinition.addProperty(propertyDef);
 275                     }
 276                 });
 277             }
 278         }
 279         if (operationDefinitionMap.get(IMPLEMENTATION.getElementName()) instanceof String) {
 280             final String implementation = (String) operationDefinitionMap.get(IMPLEMENTATION.getElementName());
 281             artifactDataDefinition.setArtifactName(generateArtifactName(implementation));
 282         }
 283         return Optional.of(artifactDataDefinition);
 284     }
 285
 286     private String generateArtifactName(final String name) {
 287         if (OperationArtifactUtil.artifactNameIsALiteralValue(name)) {
 288            return name;
 289         } else {
 290             return QUOTE + name + QUOTE;
 291         }
 292     }
 293
 294     private ToscaPropertyType getTypeFromObject(final Object value) {
 295         if (value instanceof String) {
 296             return ToscaPropertyType.STRING;
 297         }
 298         if (value instanceof Integer) {
 299             return ToscaPropertyType.INTEGER;
 300         }
 301         if (value instanceof Boolean) {
 302             return ToscaPropertyType.BOOLEAN;
 303         }
 304         if (value instanceof Float || value instanceof Double) {
 305             return ToscaPropertyType.FLOAT;
 306         }
 307         if (value instanceof List) {
 308             return ToscaPropertyType.LIST;
 309         }
 310         return null;
 311     }
 312
 313
 314     private Map<String, InputDefinition> handleInputs(final Map<String, Object> interfaceDefinitionToscaMap) {
 315         if (!interfaceDefinitionToscaMap.containsKey(INPUTS.getElementName())) {
 316             return Collections.emptyMap();
 317         }
 318         final Either<Map<String, InputDefinition>, ResultStatusEnum> inputMapEither = ImportUtils.getInputs(interfaceDefinitionToscaMap);
 319         if (inputMapEither.isRight()) {
 320             return Collections.emptyMap();
 321         }
 322         return inputMapEither.left().value();
 323     }
 324 }