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.util.ArrayList;
  24 import java.util.Collections;
  25 import java.util.EnumMap;
  26 import java.util.HashMap;
  27 import java.util.List;
  28 import java.util.Map;
  29 import java.util.Objects;
  30 import java.util.Optional;
  31 import java.util.Set;
  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.JanusGraphGenericDao;
  42 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  43 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  44 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
  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.NodeTypeEnum;
  50 import org.openecomp.sdc.be.model.Model;
  51 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.ModelOperationExceptionSupplier;
  52 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.OperationException;
  53 import org.openecomp.sdc.be.model.operations.api.DerivedFromOperation;
  54 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  55 import org.openecomp.sdc.be.resources.data.ModelData;
  56 import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode;
  57 import org.openecomp.sdc.common.log.wrappers.Logger;
  58 import org.springframework.beans.factory.annotation.Autowired;
  59 import org.springframework.stereotype.Component;
  60 import org.yaml.snakeyaml.Yaml;
  61
  62 @Component("model-operation")
  63 public class ModelOperation {
  64
  65     private static final Logger log = Logger.getLogger(ModelOperation.class);
  66     private static final String ADDITIONAL_TYPE_DEFINITIONS = "additional_type_definitions.yml";
  67
  68     private final JanusGraphGenericDao janusGraphGenericDao;
  69     private final JanusGraphDao janusGraphDao;
  70     private final ToscaModelImportCassandraDao toscaModelImportCassandraDao;
  71     private final DerivedFromOperation derivedFromOperation;
  72
  73     @Autowired
  74     public ModelOperation(final JanusGraphGenericDao janusGraphGenericDao,
  75                           final JanusGraphDao janusGraphDao,
  76                           final ToscaModelImportCassandraDao toscaModelImportCassandraDao,
  77                           final DerivedFromOperation derivedFromOperation) {
  78         this.janusGraphGenericDao = janusGraphGenericDao;
  79         this.janusGraphDao = janusGraphDao;
  80         this.toscaModelImportCassandraDao = toscaModelImportCassandraDao;
  81         this.derivedFromOperation = derivedFromOperation;
  82     }
  83
  84     public Model createModel(final Model model, final boolean inTransaction) {
  85         Model result = null;
  86         final var modelData = new ModelData(model.getName(), UniqueIdBuilder.buildModelUid(model.getName()));
  87         try {
  88             final Either<ModelData, JanusGraphOperationStatus> createNode = janusGraphGenericDao.createNode(modelData, ModelData.class);
  89             if (createNode.isRight()) {
  90                 final var janusGraphOperationStatus = createNode.right().value();
  91                 log.error(EcompLoggerErrorCode.DATA_ERROR, ModelOperation.class.getName(), "Problem while creating model, reason {}",
  92                     janusGraphOperationStatus);
  93                 if (janusGraphOperationStatus == JanusGraphOperationStatus.JANUSGRAPH_SCHEMA_VIOLATION) {
  94                     throw ModelOperationExceptionSupplier.modelAlreadyExists(model.getName()).get();
  95                 }
  96                 throw new OperationException(ActionStatus.GENERAL_ERROR,
  97                     String.format("Failed to create model %s on JanusGraph with %s error", model, janusGraphOperationStatus));
  98             }
  99             addDerivedFromRelation(model);
 100             result = new Model(createNode.left().value().getName(), model.getDerivedFrom());
 101             return result;
 102         } finally {
 103             if (!inTransaction) {
 104                 if (Objects.nonNull(result)) {
 105                     janusGraphGenericDao.commit();
 106                 } else {
 107                     janusGraphGenericDao.rollback();
 108                 }
 109             }
 110         }
 111     }
 112
 113     private void addDerivedFromRelation(final Model model) {
 114         final String derivedFrom = model.getDerivedFrom();
 115         if (derivedFrom == null) {
 116             return;
 117         }
 118         log.debug("Adding derived from relation between model {} to its parent {}",
 119             model.getName(), derivedFrom);
 120         final Optional<Model> derivedFromModelOptional = this.findModelByName(derivedFrom);
 121         if (derivedFromModelOptional.isPresent()) {
 122             final Either<GraphRelation, StorageOperationStatus> result = derivedFromOperation.addDerivedFromRelation(
 123                 UniqueIdBuilder.buildModelUid(model.getName()),
 124                 UniqueIdBuilder.buildModelUid(derivedFromModelOptional.get().getName()), NodeTypeEnum.Model);
 125             if (result.isRight()) {
 126                 throw new OperationException(ActionStatus.GENERAL_ERROR,
 127                     String.format("Failed to create relationship from model %s to derived from model %s on JanusGraph with %s error", model,
 128                         derivedFrom, result.right().value()));
 129             }
 130         }
 131     }
 132
 133     public Optional<GraphVertex> findModelVertexByName(final String name) {
 134         if (StringUtils.isEmpty(name)) {
 135             return Optional.empty();
 136         }
 137         final Map<GraphPropertyEnum, Object> props = new EnumMap<>(GraphPropertyEnum.class);
 138         props.put(GraphPropertyEnum.NAME, name);
 139         props.put(GraphPropertyEnum.UNIQUE_ID, UniqueIdBuilder.buildModelUid(name));
 140         final List<GraphVertex> modelVerticesList = findModelVerticesByCriteria(props);
 141         if (modelVerticesList.isEmpty()) {
 142             return Optional.empty();
 143         }
 144         return Optional.ofNullable(modelVerticesList.get(0));
 145     }
 146
 147     public Optional<Model> findModelByName(final String name) {
 148         if (StringUtils.isEmpty(name)) {
 149             return Optional.empty();
 150         }
 151         final Optional<GraphVertex> modelVertexOpt = findModelVertexByName(name);
 152         if (modelVertexOpt.isEmpty()) {
 153             return Optional.empty();
 154         }
 155
 156         final GraphVertex graphVertex = modelVertexOpt.get();
 157         return Optional.of(convertToModel(graphVertex));
 158     }
 159
 160     public void createModelImports(final String modelId, final Map<String, byte[]> zipContent) {
 161         if (MapUtils.isEmpty(zipContent)) {
 162             return;
 163         }
 164         final List<ToscaImportByModel> toscaImportByModelList = zipContent.entrySet().stream()
 165             .map(entry -> {
 166                 final String path = entry.getKey();
 167                 final byte[] bytes = entry.getValue();
 168                 final String content = new String(bytes, StandardCharsets.UTF_8);
 169                 final var toscaImportByModel = new ToscaImportByModel();
 170                 toscaImportByModel.setModelId(modelId);
 171                 toscaImportByModel.setFullPath(path);
 172                 toscaImportByModel.setContent(content);
 173                 return toscaImportByModel;
 174             }).collect(Collectors.toList());
 175         toscaModelImportCassandraDao.importAll(modelId, toscaImportByModelList);
 176     }
 177
 178     /**
 179      * Finds all the models.
 180      *
 181      * @return the list of models
 182      */
 183     public List<Model> findAllModels() {
 184         return findModelsByCriteria(Collections.emptyMap());
 185     }
 186
 187     private List<Model> findModelsByCriteria(final Map<GraphPropertyEnum, Object> propertyCriteria) {
 188         final List<GraphVertex> modelVerticesByCriteria = findModelVerticesByCriteria(propertyCriteria);
 189         if (modelVerticesByCriteria.isEmpty()) {
 190             return Collections.emptyList();
 191         }
 192
 193         return modelVerticesByCriteria.stream().map(this::convertToModel).collect(Collectors.toList());
 194     }
 195
 196     private List<GraphVertex> findModelVerticesByCriteria(final Map<GraphPropertyEnum, Object> propertyCriteria) {
 197         final Either<List<GraphVertex>, JanusGraphOperationStatus> result = janusGraphDao.getByCriteria(VertexTypeEnum.MODEL, propertyCriteria);
 198         if (result.isRight()) {
 199             final var janusGraphOperationStatus = result.right().value();
 200             if (janusGraphOperationStatus == JanusGraphOperationStatus.NOT_FOUND) {
 201                 return Collections.emptyList();
 202             }
 203             final var operationException = ModelOperationExceptionSupplier.failedToRetrieveModels(janusGraphOperationStatus).get();
 204             log.error(EcompLoggerErrorCode.DATA_ERROR, this.getClass().getName(), operationException.getMessage());
 205             throw operationException;
 206         }
 207         return result.left().value();
 208     }
 209
 210     private Model convertToModel(final GraphVertex modelGraphVertex) {
 211         final String modelName = (String) modelGraphVertex.getMetadataProperty(GraphPropertyEnum.NAME);
 212
 213         final Either<ImmutablePair<ModelData, GraphEdge>, JanusGraphOperationStatus> parentNode =
 214             janusGraphGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Model), UniqueIdBuilder.buildModelUid(modelName),
 215                 GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Model, ModelData.class);
 216         log.debug("After retrieving DERIVED_FROM node of {}. status is {}", modelName, parentNode);
 217         if (parentNode.isRight()) {
 218             final JanusGraphOperationStatus janusGraphOperationStatus = parentNode.right().value();
 219             if (janusGraphOperationStatus != JanusGraphOperationStatus.NOT_FOUND) {
 220                 final var operationException = ModelOperationExceptionSupplier.failedToRetrieveModels(janusGraphOperationStatus).get();
 221                 log.error(EcompLoggerErrorCode.DATA_ERROR, this.getClass().getName(), operationException.getMessage());
 222                 throw operationException;
 223             }
 224             return new Model((String) modelGraphVertex.getMetadataProperty(GraphPropertyEnum.NAME));
 225         } else {
 226             final ModelData parentModel = parentNode.left().value().getKey();
 227             return new Model((String) modelGraphVertex.getMetadataProperty(GraphPropertyEnum.NAME), parentModel.getName());
 228         }
 229     }
 230
 231     public void addTypesToDefaultImports(final String typesYaml, final String modelName) {
 232         final List<ToscaImportByModel> allSchemaImportsByModel = toscaModelImportCassandraDao.findAllByModel(modelName);
 233         final Optional<ToscaImportByModel> additionalTypeDefinitionsOptional = allSchemaImportsByModel.stream()
 234             .filter(t -> ADDITIONAL_TYPE_DEFINITIONS.equals(t.getFullPath())).findAny();
 235         final ToscaImportByModel toscaImportByModelAdditionalTypeDefinitions;
 236         final List<ToscaImportByModel> schemaImportsByModel;
 237         if (additionalTypeDefinitionsOptional.isPresent()) {
 238             toscaImportByModelAdditionalTypeDefinitions = additionalTypeDefinitionsOptional.get();
 239             schemaImportsByModel = allSchemaImportsByModel.stream()
 240                 .filter(toscaImportByModel -> !ADDITIONAL_TYPE_DEFINITIONS.equals(toscaImportByModel.getFullPath()))
 241                 .collect(Collectors.toList());
 242         } else {
 243             toscaImportByModelAdditionalTypeDefinitions = new ToscaImportByModel();
 244             toscaImportByModelAdditionalTypeDefinitions.setModelId(modelName);
 245             toscaImportByModelAdditionalTypeDefinitions.setFullPath(ADDITIONAL_TYPE_DEFINITIONS);
 246             toscaImportByModelAdditionalTypeDefinitions.setContent(typesYaml);
 247             schemaImportsByModel = new ArrayList<>(allSchemaImportsByModel);
 248         }
 249
 250         final List<ToscaImportByModel> toscaImportByModels = removeExistingDefaultImports(typesYaml, schemaImportsByModel);
 251
 252         final Map<String, Object> originalContent = (Map<String, Object>) new Yaml().load(toscaImportByModelAdditionalTypeDefinitions.getContent());
 253         toscaImportByModelAdditionalTypeDefinitions.setContent(buildAdditionalTypeDefinitionsContent(typesYaml, originalContent).toString());
 254         toscaImportByModels.add(toscaImportByModelAdditionalTypeDefinitions);
 255
 256         toscaModelImportCassandraDao.importOnly(modelName, toscaImportByModels);
 257     }
 258
 259     private List<ToscaImportByModel> removeExistingDefaultImports(final String typesYaml, final List<ToscaImportByModel> schemaImportsByModel) {
 260         final List<ToscaImportByModel> toscaImportByModels = new ArrayList<>();
 261         schemaImportsByModel.forEach(toscaImportByModel -> {
 262             final ToscaImportByModel toscaImportByModelNew = new ToscaImportByModel();
 263             toscaImportByModelNew.setModelId(toscaImportByModel.getModelId());
 264             toscaImportByModelNew.setFullPath(toscaImportByModel.getFullPath());
 265
 266             final Map<String, Object> existingImportYamlMap = (Map<String, Object>) new Yaml().load(toscaImportByModel.getContent());
 267
 268             ((Map<String, Object>) new Yaml().load(typesYaml)).keySet().forEach(existingImportYamlMap::remove);
 269
 270             final StringBuilder stringBuilder = new StringBuilder();
 271             existingImportYamlMap.forEach((key, value) -> {
 272                 final Map<Object, Object> hashMap = new HashMap<>();
 273                 hashMap.put(key, value);
 274                 stringBuilder.append("\n").append(new YamlUtil().objectToYaml(hashMap));
 275             });
 276
 277             toscaImportByModelNew.setContent(stringBuilder.toString());
 278             toscaImportByModels.add(toscaImportByModelNew);
 279         });
 280         return toscaImportByModels;
 281     }
 282
 283     private StringBuilder buildAdditionalTypeDefinitionsContent(final String typesYaml, final Map<String, Object> originalContent) {
 284         final var stringBuilder = new StringBuilder();
 285
 286         final Map<String, Object> typesYamlMap = (Map<String, Object>) new Yaml().load(typesYaml);
 287         final Set<String> typeYmlKeySet = typesYamlMap.keySet();
 288
 289         originalContent.forEach((key, value) -> {
 290             final Map<Object, Object> hashMap = new HashMap<>();
 291             if (typeYmlKeySet.contains(key)) {
 292                 hashMap.put(key, typesYamlMap.get(key));
 293             } else {
 294                 hashMap.put(key, value);
 295             }
 296             final String newContent = new YamlUtil().objectToYaml(hashMap);
 297             stringBuilder.append("\n").append(newContent);
 298         });
 299         return stringBuilder;
 300     }
 301
 302 }