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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.components.impl;
  22
  23 import fj.data.Either;
  24 import java.util.ArrayList;
  25 import java.util.Collection;
  26 import java.util.HashMap;
  27 import java.util.HashSet;
  28 import java.util.List;
  29 import java.util.Map;
  30 import java.util.Optional;
  31 import java.util.Set;
  32 import java.util.stream.Collectors;
  33 import javax.annotation.Resource;
  34 import org.apache.commons.lang3.StringUtils;
  35 import org.apache.commons.lang3.tuple.ImmutablePair;
  36 import org.openecomp.sdc.be.dao.api.ActionStatus;
  37 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  38 import org.openecomp.sdc.be.impl.ComponentsUtils;
  39 import org.openecomp.sdc.be.model.DataTypeDefinition;
  40 import org.openecomp.sdc.be.model.Model;
  41 import org.openecomp.sdc.be.model.PropertyDefinition;
  42 import org.openecomp.sdc.be.model.normatives.ElementTypeEnum;
  43 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  44 import org.openecomp.sdc.be.model.operations.impl.ModelOperation;
  45 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
  46 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  47 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
  48 import org.openecomp.sdc.be.utils.TypeUtils;
  49 import org.openecomp.sdc.common.log.wrappers.Logger;
  50 import org.openecomp.sdc.exception.ResponseFormat;
  51 import org.springframework.stereotype.Component;
  52
  53 @Component("dataTypeImportManager")
  54 public class DataTypeImportManager {
  55
  56     private static final Logger log = Logger.getLogger(DataTypeImportManager.class.getName());
  57     @Resource
  58     private PropertyOperation propertyOperation;
  59     @Resource
  60     private ComponentsUtils componentsUtils;
  61     @Resource
  62     private CommonImportManager commonImportManager;
  63     @Resource
  64     private ModelOperation modelOperation;
  65
  66     public Either<List<ImmutablePair<DataTypeDefinition, Boolean>>, ResponseFormat> createDataTypes(final String dataTypeYml, final String modelName,
  67                                                                                                     final boolean includeToModelDefaultImports) {
  68         final var elementTypes = commonImportManager.createElementTypes(
  69             dataTypeYml, dataTypesFromYml -> createDataTypesFromYml(dataTypeYml, modelName), this::createDataTypesByDao, ElementTypeEnum.DATA_TYPE);
  70
  71         if (includeToModelDefaultImports && StringUtils.isNotEmpty(modelName)) {
  72             commonImportManager.addTypesToDefaultImports(ElementTypeEnum.DATA_TYPE, dataTypeYml, modelName);
  73         }
  74         return elementTypes;
  75     }
  76
  77     private Either<List<DataTypeDefinition>, ActionStatus> createDataTypesFromYml(final String dataTypesYml, final String modelName) {
  78         final Either<List<DataTypeDefinition>, ActionStatus> dataTypesEither = commonImportManager.createElementTypesFromYml(dataTypesYml,
  79             this::createDataType);
  80         if (dataTypesEither.isRight()) {
  81             return dataTypesEither;
  82         }
  83         final List<DataTypeDefinition> dataTypes = dataTypesEither.left().value();
  84         if (StringUtils.isNotEmpty(modelName)) {
  85             final Optional<Model> modelOptional = modelOperation.findModelByName(modelName);
  86             if (modelOptional.isPresent()) {
  87                 dataTypes.forEach(dataType -> dataType.setModel(modelName));
  88             } else {
  89                 return Either.right(ActionStatus.INVALID_MODEL);
  90             }
  91         }
  92         if (log.isTraceEnabled()) {
  93             log.trace("Unsorted datatypes order:");
  94             dataTypes.stream().forEach(dt -> log.trace(dt.getName()));
  95         }
  96
  97         long startTime = System.currentTimeMillis();
  98         List<DataTypeDefinition> sortedDataTypeDefinitions = sortDataTypesByDependencyOrder(dataTypes);
  99
 100         if (log.isTraceEnabled()) {
 101             long sortTime = System.currentTimeMillis() - startTime;
 102             log.trace("Sorting " + sortedDataTypeDefinitions.size() + " data types from model: " + modelName + " took: " + sortTime);
 103             log.trace("Sorted datatypes order:");
 104             sortedDataTypeDefinitions.stream().forEach(dt -> log.trace(dt.getName()));
 105         }
 106         return Either.left(sortedDataTypeDefinitions);
 107     }
 108
 109     private List<DataTypeDefinition> sortDataTypesByDependencyOrder(final List<DataTypeDefinition> dataTypes) {
 110         final List<DataTypeDefinition> sortedDataTypeDefinitions = new ArrayList<>();
 111         final Map<String, DataTypeDefinition> dataTypeDefinitionsMap = new HashMap<>();
 112
 113         dataTypes.forEach(dataType -> {
 114
 115             int highestDependencyIndex = -1;
 116             for (final String dependencyName : getDependencyTypes(dataType)) {
 117                 final DataTypeDefinition dependency = dataTypeDefinitionsMap.get(dependencyName);
 118                 final int indexOfDependency = sortedDataTypeDefinitions.lastIndexOf(dependency);
 119                 highestDependencyIndex = indexOfDependency > highestDependencyIndex ? indexOfDependency : highestDependencyIndex;
 120             }
 121             sortedDataTypeDefinitions.add(highestDependencyIndex + 1, dataType);
 122             dataTypeDefinitionsMap.put(dataType.getName(), dataType);
 123
 124             } );
 125
 126         return sortedDataTypeDefinitions;
 127     }
 128
 129     private Collection<String> getDependencyTypes(final DataTypeDefinition dataType) {
 130         final Set<String> dependencies = new HashSet<>();
 131         if (dataType.getDerivedFromName() != null) {
 132             dependencies.add(dataType.getDerivedFromName());
 133         }
 134         if (dataType.getProperties() != null) {
 135             dataType.getProperties().stream().forEach(property -> dependencies.add(property.getType()));
 136         }
 137         return dependencies;
 138     }
 139
 140     private Either<List<ImmutablePair<DataTypeDefinition, Boolean>>, ResponseFormat> createDataTypesByDao(
 141         List<DataTypeDefinition> dataTypesToCreate) {
 142         return commonImportManager.createElementTypesByDao(dataTypesToCreate, this::validateDataType,
 143             dataType -> new ImmutablePair<>(ElementTypeEnum.DATA_TYPE, UniqueIdBuilder.buildDataTypeUid(dataType.getModel(), dataType.getName())),
 144             dataTypeUid -> propertyOperation.getDataTypeByUidWithoutDerived(dataTypeUid, true),
 145             dataType -> propertyOperation.addDataType(dataType),
 146             (newDataType, oldDataType) -> propertyOperation.updateDataType(newDataType, oldDataType));
 147     }
 148
 149     private Either<ActionStatus, ResponseFormat> validateDataType(DataTypeDefinition dataType) {
 150         String dataTypeName = dataType.getName();
 151         List<PropertyDefinition> properties = dataType.getProperties();
 152         if (properties == null) {
 153             // At least one parameter should be defined either in the properties
 154
 155             // section or at one of the parents
 156             String derivedDataType = dataType.getDerivedFromName();
 157             // If there are no properties, then we can create a data type if it
 158
 159             // is an abstract one or it derives from non abstract data type
 160             if (derivedDataType == null || derivedDataType.isEmpty()) {
 161                 if (!isAbstract(dataType.getName()) && !ToscaPropertyType.isScalarType(dataTypeName)) {
 162                     log.debug("Data type {} must have properties unless it derives from non abstract data type", dataType.getName());
 163                     ResponseFormat responseFormat = componentsUtils
 164                         .getResponseFormatByDataType(ActionStatus.DATA_TYPE_NOR_PROPERTIES_NEITHER_DERIVED_FROM, dataType, null);
 165                     return Either.right(responseFormat);
 166                 }
 167             } else {
 168                 if (!ToscaPropertyType.isScalarType(dataTypeName) && isAbstract(derivedDataType)) {
 169                     log.warn("Creating data type {} which derived from abstract data type with no properties", dataType.getName());
 170                 }
 171             }
 172         } else {
 173             // properties tag cannot be empty
 174             if (properties.isEmpty()) {
 175                 ResponseFormat responseFormat = componentsUtils
 176                     .getResponseFormatByDataType(ActionStatus.DATA_TYPE_PROPERTIES_CANNOT_BE_EMPTY, dataType, null);
 177                 return Either.right(responseFormat);
 178             }
 179             // check no duplicates
 180             Set<String> collect = properties.stream().map(PropertyDataDefinition::getName).collect(Collectors.toSet());
 181             if (collect != null && properties.size() != collect.size()) {
 182                 ResponseFormat responseFormat = componentsUtils
 183                     .getResponseFormatByDataType(ActionStatus.DATA_TYPE_DUPLICATE_PROPERTY, dataType, null);
 184                 return Either.right(responseFormat);
 185             }
 186             List<String> propertiesWithSameTypeAsDataType = properties.stream().filter(p -> p.getType().equals(dataType.getName()))
 187                 .map(PropertyDataDefinition::getName).collect(Collectors.toList());
 188             if (propertiesWithSameTypeAsDataType != null && !propertiesWithSameTypeAsDataType.isEmpty()) {
 189                 log.debug("The data type {} contains properties with the type {}", dataType.getName(), dataType.getName());
 190                 ResponseFormat responseFormat = componentsUtils
 191                     .getResponseFormatByDataType(ActionStatus.DATA_TYPE_PROEPRTY_CANNOT_HAVE_SAME_TYPE_OF_DATA_TYPE, dataType,
 192                         propertiesWithSameTypeAsDataType);
 193                 return Either.right(responseFormat);
 194             }
 195         }
 196         String derivedDataType = dataType.getDerivedFromName();
 197         if (derivedDataType != null) {
 198             Either<DataTypeDefinition, StorageOperationStatus> derivedDataTypeByName = propertyOperation.getDataTypeByName(derivedDataType,
 199                 dataType.getModel());
 200             if (derivedDataTypeByName.isRight()) {
 201                 StorageOperationStatus status = derivedDataTypeByName.right().value();
 202                 if (status == StorageOperationStatus.NOT_FOUND) {
 203                     ResponseFormat responseFormat = componentsUtils
 204                         .getResponseFormatByDataType(ActionStatus.DATA_TYPE_DERIVED_IS_MISSING, dataType, null);
 205                     return Either.right(responseFormat);
 206                 } else {
 207                     ResponseFormat responseFormat = componentsUtils.getResponseFormatByDataType(ActionStatus.GENERAL_ERROR, dataType, null);
 208                     return Either.right(responseFormat);
 209                 }
 210             } else {
 211                 DataTypeDefinition derivedDataTypeDef = derivedDataTypeByName.left().value();
 212                 if (properties != null && !properties.isEmpty() && derivedDataTypeDef != null) {
 213                     if (isScalarType(derivedDataTypeDef)) {
 214                         ResponseFormat responseFormat = componentsUtils
 215                             .getResponseFormatByDataType(ActionStatus.DATA_TYPE_CANNOT_HAVE_PROPERTIES, dataType, null);
 216                         return Either.right(responseFormat);
 217                     }
 218                     Set<String> allParentsProps = new HashSet<>();
 219                     do {
 220                         List<PropertyDefinition> currentParentsProps = derivedDataTypeDef.getProperties();
 221                         if (currentParentsProps != null) {
 222                             for (PropertyDefinition propertyDefinition : currentParentsProps) {
 223                                 allParentsProps.add(propertyDefinition.getName());
 224                             }
 225                         }
 226                         derivedDataTypeDef = derivedDataTypeDef.getDerivedFrom();
 227                     } while (derivedDataTypeDef != null);
 228                     // Check that no property is already defined in one of the
 229
 230                     // ancestors
 231                     Set<String> alreadyExistPropsCollection = properties.stream().filter(p -> allParentsProps.contains(p.getName()))
 232                         .map(PropertyDataDefinition::getName).collect(Collectors.toSet());
 233                     if (alreadyExistPropsCollection != null && !alreadyExistPropsCollection.isEmpty()) {
 234                         List<String> duplicateProps = new ArrayList<>();
 235                         duplicateProps.addAll(alreadyExistPropsCollection);
 236                         ResponseFormat responseFormat = componentsUtils
 237                             .getResponseFormatByDataType(ActionStatus.DATA_TYPE_PROPERTY_ALREADY_DEFINED_IN_ANCESTOR, dataType, duplicateProps);
 238                         return Either.right(responseFormat);
 239                     }
 240                 }
 241             }
 242         }
 243         return Either.left(ActionStatus.OK);
 244     }
 245
 246     private boolean isAbstract(String dataTypeName) {
 247         ToscaPropertyType isPrimitiveToscaType = ToscaPropertyType.isValidType(dataTypeName);
 248         return isPrimitiveToscaType != null && isPrimitiveToscaType.isAbstract();
 249     }
 250
 251     private boolean isScalarType(DataTypeDefinition dataTypeDef) {
 252         boolean isScalar = false;
 253         DataTypeDefinition dataType = dataTypeDef;
 254         while (dataType != null) {
 255             String name = dataType.getName();
 256             if (ToscaPropertyType.isScalarType(name)) {
 257                 isScalar = true;
 258                 break;
 259             }
 260             dataType = dataType.getDerivedFrom();
 261         }
 262         return isScalar;
 263     }
 264
 265     private DataTypeDefinition createDataType(String dataTypeName, Map<String, Object> toscaJson) {
 266         DataTypeDefinition dataType = new DataTypeDefinition();
 267         dataType.setName(dataTypeName);
 268         if (toscaJson != null) {
 269             // Description
 270             commonImportManager.setField(toscaJson, TypeUtils.ToscaTagNamesEnum.DESCRIPTION.getElementName(), dataType::setDescription);
 271             // Derived From
 272             commonImportManager.setField(toscaJson, TypeUtils.ToscaTagNamesEnum.DERIVED_FROM.getElementName(), dataType::setDerivedFromName);
 273             // Properties
 274             CommonImportManager.setProperties(toscaJson, dataType::setProperties);
 275         }
 276         return dataType;
 277     }
 278 }