catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/ModelOperation.java

   1 /*
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021 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.model.operations.impl;
  20
  21 import fj.data.Either;
  22 import java.nio.charset.StandardCharsets;
  23 import java.nio.file.Path;
  24 import java.util.ArrayList;
  25 import java.util.Collections;
  26 import java.util.EnumMap;
  27 import java.util.LinkedHashMap;
  28 import java.util.List;
  29 import java.util.Map;
  30 import java.util.Objects;
  31 import java.util.Optional;
  32 import java.util.stream.Collectors;
  33 import org.apache.commons.collections.MapUtils;
  34 import org.apache.commons.lang3.StringUtils;
  35 import org.apache.commons.lang3.tuple.ImmutablePair;
  36 import org.onap.sdc.tosca.services.YamlUtil;
  37 import org.openecomp.sdc.be.dao.api.ActionStatus;
  38 import org.openecomp.sdc.be.dao.cassandra.ToscaModelImportCassandraDao;
  39 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
  40 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
  41 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
  42 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  43 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  44 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  45 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  46 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  47 import org.openecomp.sdc.be.data.model.ToscaImportByModel;
  48 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  49 import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
  50 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  51 import org.openecomp.sdc.be.model.Model;
  52 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.ModelOperationExceptionSupplier;
  53 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.OperationException;
  54 import org.openecomp.sdc.be.model.normatives.ElementTypeEnum;
  55 import org.openecomp.sdc.be.model.operations.api.DerivedFromOperation;
  56 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  57 import org.openecomp.sdc.be.resources.data.ModelData;
  58 import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode;
  59 import org.openecomp.sdc.common.log.wrappers.Logger;
  60 import org.springframework.beans.factory.annotation.Autowired;
  61 import org.springframework.stereotype.Component;
  62 import org.yaml.snakeyaml.Yaml;
  63
  64 @Component("model-operation")
  65 public class ModelOperation {
  66
  67     private static final Logger log = Logger.getLogger(ModelOperation.class);
  68     static final Path ADDITIONAL_TYPE_DEFINITIONS_PATH = Path.of("additional_type_definitions.yaml");
  69
  70     private final JanusGraphGenericDao janusGraphGenericDao;
  71     private final JanusGraphDao janusGraphDao;
  72     private final ToscaModelImportCassandraDao toscaModelImportCassandraDao;
  73     private final DerivedFromOperation derivedFromOperation;
  74     private ModelElementOperation modelElementOperation;
  75
  76     @Autowired
  77     public ModelOperation(final JanusGraphGenericDao janusGraphGenericDao,
  78                           final JanusGraphDao janusGraphDao,
  79                           final ToscaModelImportCassandraDao toscaModelImportCassandraDao,
  80                           final DerivedFromOperation derivedFromOperation) {
  81         this.janusGraphGenericDao = janusGraphGenericDao;
  82         this.janusGraphDao = janusGraphDao;
  83         this.toscaModelImportCassandraDao = toscaModelImportCassandraDao;
  84         this.derivedFromOperation = derivedFromOperation;
  85     }
  86
  87     public Model createModel(final Model model, final boolean inTransaction) {
  88         Model result = null;
  89         final var modelData = new ModelData(model.getName(), UniqueIdBuilder.buildModelUid(model.getName()), model.getModelType());
  90         try {
  91             final Either<ModelData, JanusGraphOperationStatus> createNode = janusGraphGenericDao.createNode(modelData, ModelData.class);
  92             if (createNode.isRight()) {
  93                 final var janusGraphOperationStatus = createNode.right().value();
  94                 log.error(EcompLoggerErrorCode.DATA_ERROR, ModelOperation.class.getName(), "Problem while creating model, reason {}",
  95                     janusGraphOperationStatus);
  96                 if (janusGraphOperationStatus == JanusGraphOperationStatus.JANUSGRAPH_SCHEMA_VIOLATION) {
  97                     throw ModelOperationExceptionSupplier.modelAlreadyExists(model.getName()).get();
  98                 }
  99                 throw new OperationException(ActionStatus.GENERAL_ERROR,
 100                     String.format("Failed to create model %s on JanusGraph with %s error", model, janusGraphOperationStatus));
 101             }
 102             addDerivedFromRelation(model);
 103             result = new Model(createNode.left().value().getName(), model.getDerivedFrom(), model.getModelType());
 104             return result;
 105         } finally {
 106             if (!inTransaction) {
 107                 if (Objects.nonNull(result)) {
 108                     janusGraphGenericDao.commit();
 109                 } else {
 110                     janusGraphGenericDao.rollback();
 111                 }
 112             }
 113         }
 114     }
 115
 116     private void addDerivedFromRelation(final Model model) {
 117         final String derivedFrom = model.getDerivedFrom();
 118         if (derivedFrom == null) {
 119             return;
 120         }
 121         log.debug("Adding derived from relation between model {} to its parent {}",
 122             model.getName(), derivedFrom);
 123         final Optional<Model> derivedFromModelOptional = this.findModelByName(derivedFrom);
 124         if (derivedFromModelOptional.isPresent()) {
 125             final Either<GraphRelation, StorageOperationStatus> result = derivedFromOperation.addDerivedFromRelation(
 126                 UniqueIdBuilder.buildModelUid(model.getName()),
 127                 UniqueIdBuilder.buildModelUid(derivedFromModelOptional.get().getName()), NodeTypeEnum.Model);
 128             if (result.isRight()) {
 129                 throw new OperationException(ActionStatus.GENERAL_ERROR,
 130                     String.format("Failed to create relationship from model %s to derived from model %s on JanusGraph with %s error", model,
 131                         derivedFrom, result.right().value()));
 132             }
 133         }
 134     }
 135
 136     public Optional<GraphVertex> findModelVertexByName(final String name) {
 137         if (StringUtils.isEmpty(name)) {
 138             return Optional.empty();
 139         }
 140         final Map<GraphPropertyEnum, Object> props = new EnumMap<>(GraphPropertyEnum.class);
 141         props.put(GraphPropertyEnum.NAME, name);
 142         props.put(GraphPropertyEnum.UNIQUE_ID, UniqueIdBuilder.buildModelUid(name));
 143         final List<GraphVertex> modelVerticesList = findModelVerticesByCriteria(props);
 144         if (modelVerticesList.isEmpty()) {
 145             return Optional.empty();
 146         }
 147         return Optional.ofNullable(modelVerticesList.get(0));
 148     }
 149
 150     public Optional<Model> findModelByName(final String name) {
 151         if (StringUtils.isEmpty(name)) {
 152             return Optional.empty();
 153         }
 154         final Optional<GraphVertex> modelVertexOpt = findModelVertexByName(name);
 155         if (modelVertexOpt.isEmpty()) {
 156             return Optional.empty();
 157         }
 158
 159         final GraphVertex graphVertex = modelVertexOpt.get();
 160         return Optional.of(convertToModel(graphVertex));
 161     }
 162
 163     public void createModelImports(final String modelId, final Map<String, byte[]> zipContent) {
 164         if (MapUtils.isEmpty(zipContent)) {
 165             return;
 166         }
 167         final List<ToscaImportByModel> toscaImportByModelList = zipContent.entrySet().stream()
 168             .map(entry -> {
 169                 final String path = entry.getKey();
 170                 final byte[] bytes = entry.getValue();
 171                 final String content = new String(bytes, StandardCharsets.UTF_8);
 172                 final var toscaImportByModel = new ToscaImportByModel();
 173                 toscaImportByModel.setModelId(modelId);
 174                 toscaImportByModel.setFullPath(path);
 175                 toscaImportByModel.setContent(content);
 176                 return toscaImportByModel;
 177             }).collect(Collectors.toList());
 178         toscaModelImportCassandraDao.replaceImports(modelId, toscaImportByModelList);
 179     }
 180
 181     /**
 182      * Find all the model default imports, with the option to include the default imports from the parent model.
 183      *
 184      * @param modelId       the model id
 185      * @param includeParent a flag to include the parent model imports.
 186      * @return the list of model default imports, or an empty list if no imports were found.
 187      */
 188     public List<ToscaImportByModel> findAllModelImports(final String modelId, final boolean includeParent) {
 189         final List<ToscaImportByModel> toscaImportByModelList = toscaModelImportCassandraDao.findAllByModel(modelId);
 190         if (includeParent) {
 191             findModelByName(modelId).ifPresent(model -> {
 192                 if (model.getDerivedFrom() != null) {
 193                     toscaImportByModelList.addAll(toscaModelImportCassandraDao.findAllByModel(model.getDerivedFrom()));
 194                 }
 195             });
 196         }
 197         toscaImportByModelList.sort((o1, o2) -> {
 198             final int modelIdComparison = o1.getModelId().compareTo(o2.getModelId());
 199             if (modelIdComparison == 0) {
 200                 return o1.getFullPath().compareTo(o2.getFullPath());
 201             }
 202             return modelIdComparison;
 203         });
 204         return toscaImportByModelList;
 205     }
 206
 207     /**
 208      * Finds all the models.
 209      *
 210      * @return the list of models
 211      */
 212     public List<Model> findAllModels() {
 213         return findModelsByCriteria(Collections.emptyMap());
 214     }
 215
 216     public List<Model> findModels(final ModelTypeEnum modelType) {
 217         final Map<GraphPropertyEnum, Object> propertyCriteria = new EnumMap<>(GraphPropertyEnum.class);
 218         propertyCriteria.put(GraphPropertyEnum.MODEL_TYPE, modelType.getValue());
 219
 220         return findModelsByCriteria(propertyCriteria);
 221     }
 222
 223     private List<Model> findModelsByCriteria(final Map<GraphPropertyEnum, Object> propertyCriteria) {
 224         final List<GraphVertex> modelVerticesByCriteria = findModelVerticesByCriteria(propertyCriteria);
 225         if (modelVerticesByCriteria.isEmpty()) {
 226             return Collections.emptyList();
 227         }
 228
 229         return modelVerticesByCriteria.stream().map(this::convertToModel).collect(Collectors.toList());
 230     }
 231
 232     private List<GraphVertex> findModelVerticesByCriteria(final Map<GraphPropertyEnum, Object> propertyCriteria) {
 233         final Either<List<GraphVertex>, JanusGraphOperationStatus> result = janusGraphDao.getByCriteria(VertexTypeEnum.MODEL, propertyCriteria);
 234         if (result.isRight()) {
 235             final var janusGraphOperationStatus = result.right().value();
 236             if (janusGraphOperationStatus == JanusGraphOperationStatus.NOT_FOUND) {
 237                 return Collections.emptyList();
 238             }
 239             final var operationException = ModelOperationExceptionSupplier.failedToRetrieveModels(janusGraphOperationStatus).get();
 240             log.error(EcompLoggerErrorCode.DATA_ERROR, this.getClass().getName(), operationException.getMessage());
 241             throw operationException;
 242         }
 243         return result.left().value();
 244     }
 245
 246     private Model convertToModel(final GraphVertex modelGraphVertex) {
 247         final String modelName = (String) modelGraphVertex.getMetadataProperty(GraphPropertyEnum.NAME);
 248         final String modelTypeProperty = (String) modelGraphVertex.getMetadataProperty(GraphPropertyEnum.MODEL_TYPE);
 249         final ModelTypeEnum modelType = StringUtils.isEmpty(modelTypeProperty) ? ModelTypeEnum.NORMATIVE :
 250                 ModelTypeEnum.findByValue(modelTypeProperty).isPresent() ? ModelTypeEnum.findByValue(modelTypeProperty).get() : ModelTypeEnum.NORMATIVE;
 251
 252         final Either<ImmutablePair<ModelData, GraphEdge>, JanusGraphOperationStatus> parentNode =
 253             janusGraphGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Model), UniqueIdBuilder.buildModelUid(modelName),
 254                 GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Model, ModelData.class);
 255         log.debug("After retrieving DERIVED_FROM node of {}. status is {}", modelName, parentNode);
 256         if (parentNode.isRight()) {
 257             final JanusGraphOperationStatus janusGraphOperationStatus = parentNode.right().value();
 258             if (janusGraphOperationStatus != JanusGraphOperationStatus.NOT_FOUND) {
 259                 final var operationException = ModelOperationExceptionSupplier.failedToRetrieveModels(janusGraphOperationStatus).get();
 260                 log.error(EcompLoggerErrorCode.DATA_ERROR, this.getClass().getName(), operationException.getMessage());
 261                 throw operationException;
 262             }
 263             return new Model((String) modelGraphVertex.getMetadataProperty(GraphPropertyEnum.NAME), modelType);
 264         } else {
 265             final ModelData parentModel = parentNode.left().value().getKey();
 266             return new Model((String) modelGraphVertex.getMetadataProperty(GraphPropertyEnum.NAME), parentModel.getName(), modelType);
 267         }
 268     }
 269
 270     public void addTypesToDefaultImports(final ElementTypeEnum elementTypeEnum, final String typesYaml, final String modelName) {
 271         final List<ToscaImportByModel> modelImportList = toscaModelImportCassandraDao.findAllByModel(modelName);
 272         final Optional<ToscaImportByModel> additionalTypeDefinitionsImportOptional = modelImportList.stream()
 273             .filter(t -> ADDITIONAL_TYPE_DEFINITIONS_PATH.equals(Path.of(t.getFullPath()))).findAny();
 274         final ToscaImportByModel additionalTypeDefinitionsImport;
 275         final List<ToscaImportByModel> rebuiltModelImportList;
 276         if (additionalTypeDefinitionsImportOptional.isPresent()) {
 277             additionalTypeDefinitionsImport = additionalTypeDefinitionsImportOptional.get();
 278             rebuiltModelImportList = modelImportList.stream()
 279                 .filter(toscaImportByModel -> !ADDITIONAL_TYPE_DEFINITIONS_PATH.equals(Path.of(toscaImportByModel.getFullPath())))
 280                 .collect(Collectors.toList());
 281         } else {
 282             additionalTypeDefinitionsImport = new ToscaImportByModel();
 283             additionalTypeDefinitionsImport.setModelId(modelName);
 284             additionalTypeDefinitionsImport.setFullPath(ADDITIONAL_TYPE_DEFINITIONS_PATH.toString());
 285             additionalTypeDefinitionsImport.setContent(createAdditionalTypeDefinitionsHeader());
 286             rebuiltModelImportList = new ArrayList<>(modelImportList);
 287         }
 288
 289         final Map<String, Object> typesYamlMap = new Yaml().load(typesYaml);
 290         removeExistingTypesFromDefaultImports(elementTypeEnum, typesYamlMap, rebuiltModelImportList);
 291
 292         final Map<String, Object> originalContent = new Yaml().load(additionalTypeDefinitionsImport.getContent());
 293         additionalTypeDefinitionsImport.setContent(buildAdditionalTypeDefinitionsContent(elementTypeEnum, typesYamlMap, originalContent));
 294         rebuiltModelImportList.add(additionalTypeDefinitionsImport);
 295
 296         toscaModelImportCassandraDao.saveAll(modelName, rebuiltModelImportList);
 297     }
 298
 299     private void removeExistingTypesFromDefaultImports(final ElementTypeEnum elementTypeEnum, final Map<String, Object> typesYaml,
 300                                                        final List<ToscaImportByModel> defaultImportList) {
 301         defaultImportList.forEach(toscaImportByModel -> {
 302             final Map<String, Object> existingImportYamlMap = new Yaml().load(toscaImportByModel.getContent());
 303             final Map<String, Object> currentTypeYamlMap = (Map<String, Object>) existingImportYamlMap.get(elementTypeEnum.getToscaEntryName());
 304             if (MapUtils.isNotEmpty(currentTypeYamlMap)) {
 305                 typesYaml.keySet().forEach(currentTypeYamlMap::remove);
 306             }
 307             toscaImportByModel.setContent(new YamlUtil().objectToYaml(existingImportYamlMap));
 308         });
 309     }
 310
 311     private String buildAdditionalTypeDefinitionsContent(final ElementTypeEnum elementTypeEnum, final Map<String, Object> typesYamlMap,
 312                                                          final Map<String, Object> originalContent) {
 313         final Map<String, Object> originalTypeContent = (Map<String, Object>) originalContent.get(elementTypeEnum.getToscaEntryName());
 314         if (MapUtils.isEmpty(originalTypeContent)) {
 315             originalContent.put(elementTypeEnum.getToscaEntryName(), new LinkedHashMap<>(typesYamlMap));
 316         } else {
 317             originalTypeContent.putAll(typesYamlMap);
 318         }
 319         return new YamlUtil().objectToYaml(originalContent);
 320     }
 321
 322     private String createAdditionalTypeDefinitionsHeader() {
 323         return "tosca_definitions_version: tosca_simple_yaml_1_3" + "\n"
 324             + "description: Auto-generated file that contains package custom types or types added after system installation." + "\n";
 325     }
 326
 327     /**
 328      * Deletes the given model if it exists, along with its MODEL_ELEMENT edges and import files.
 329      *
 330      * @param model         the model
 331      * @param inTransaction if the operation is called in the middle of a janusgraph transaction
 332      */
 333     public void deleteModel(final Model model, final boolean inTransaction) {
 334         boolean rollback = false;
 335
 336         try {
 337             final GraphVertex modelVertexByName = findModelVertexByName(model.getName()).orElse(null);
 338             if (modelVertexByName == null) {
 339                 return;
 340             }
 341             toscaModelImportCassandraDao.deleteAllByModel(model.getName());
 342             modelElementOperation.deleteModelElements(model, inTransaction);
 343             deleteModel(model);
 344         } catch (final OperationException e) {
 345             rollback = true;
 346             throw e;
 347         } catch (final Exception e) {
 348             rollback = true;
 349             throw new OperationException(e, ActionStatus.COULD_NOT_DELETE_MODEL, model.getName());
 350         } finally {
 351             if (!inTransaction) {
 352                 if (rollback) {
 353                     janusGraphGenericDao.rollback();
 354                 } else {
 355                     janusGraphGenericDao.commit();
 356                 }
 357             }
 358         }
 359     }
 360
 361     private void deleteModel(final Model model) {
 362         final var modelData = new ModelData(model.getName(), UniqueIdBuilder.buildModelUid(model.getName()), model.getModelType());
 363         final Either<ModelData, JanusGraphOperationStatus> deleteParentNodeByModel = janusGraphGenericDao.deleteNode(modelData, ModelData.class);
 364         if (deleteParentNodeByModel.isRight()) {
 365             final var janusGraphOperationStatus = deleteParentNodeByModel.right().value();
 366             log.error(EcompLoggerErrorCode.DATA_ERROR, ModelOperation.class.getName(),
 367                 "Failed to delete model {} on JanusGraph with status {}", new Object[] {model.getName(), janusGraphOperationStatus});
 368             throw new OperationException(ActionStatus.COULD_NOT_DELETE_MODEL, model.getName());
 369         }
 370     }
 371
 372     @Autowired
 373     public void setModelElementOperation(final ModelElementOperation modelElementOperation) {
 374         this.modelElementOperation = modelElementOperation;
 375     }
 376
 377 }