code: 400,
message: "Invalid label name. Only the following characters are allowed in label name: '%1'",
messageId: "SVC4158"
+ }
+
+ #---------SVC4159-----------------------------
+ # %1 - The model name
+ COULD_NOT_DELETE_MODEL: {
+ code: 500,
+ message: "Could not delete the model '%1'.",
+ messageId: "SVC4159"
+ }
+
+ #---------SVC4160-----------------------------
+ # %1 - The model name
+ COULD_NOT_DELETE_MODEL_ELEMENTS: {
+ code: 500,
+ message: "Could not delete the model '%1' elements.",
+ messageId: "SVC4160"
}
\ No newline at end of file
Either<? extends Component, ResponseFormat> result = null;
log.debug("start performing undo-checkout for resource {}", component.getUniqueId());
try {
- Either<ToscaElement, StorageOperationStatus> undoCheckoutResourceResult = lifeCycleOperation.undoCheckout(component.getUniqueId());
+ Either<ToscaElement, StorageOperationStatus> undoCheckoutResourceResult = lifeCycleOperation.undoCheckout(component.getUniqueId(), component.getModel());
if (undoCheckoutResourceResult.isRight()) {
log.debug("checkout failed on graph");
StorageOperationStatus response = undoCheckoutResourceResult.right().value();
import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.ModelElementOperation;
import org.openecomp.sdc.be.model.operations.impl.ModelOperation;
import org.openecomp.sdc.be.servlets.exception.ComponentExceptionMapper;
import org.openecomp.sdc.be.servlets.exception.DefaultExceptionMapper;
return new ModelOperation(null, null, null, null);
}
+ @Bean
+ ModelElementOperation modelElementOperation() {
+ return new ModelElementOperation(null, null, null);
+ }
+
private void initGraphForTest() {
//Create Catalog Root
catalogVertex = GraphTestUtils.createRootCatalogVertex(janusGraphDao);
// Model related
MODEL_ALREADY_EXISTS, INVALID_MODEL, MODEL_IMPORTS_IS_EMPTY, COULD_NOT_READ_MODEL_IMPORTS, MODEL_NOT_FOUND, MODEL_NAME_CANNOT_BE_EMPTY,
COMPONENT_WITH_MODEL_ALREADY_EXIST, COMPONENT_WITH_VENDOR_RELEASE_ALREADY_EXISTS, COMPONENT_WITH_VENDOR_RELEASE_ALREADY_EXISTS_IN_MODEL,
- UNKNOWN_MODEL_TYPE,
+ UNKNOWN_MODEL_TYPE, COULD_NOT_DELETE_MODEL, COULD_NOT_DELETE_MODEL_ELEMENTS,
// Service API URL
INVALID_SERVICE_API_URL,
// Property related
--- /dev/null
+/*
+ * -
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2021 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.be.dao.api.exception;
+
+import lombok.Getter;
+import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
+
+@Getter
+public class JanusGraphException extends RuntimeException {
+
+ private final JanusGraphOperationStatus status;
+
+ public JanusGraphException(final JanusGraphOperationStatus status, final String message) {
+ super(message);
+ this.status = status;
+ }
+}
return toscaImportByModelAccessor.findAllByModel(modelId).all();
}
+ public void deleteAllByModel(final String modelId) {
+ final List<ToscaImportByModel> allByModel = findAllByModel(modelId);
+ allByModel.forEach(toscaImportByModelMapper::delete);
+ }
+
}
import org.janusgraph.core.PropertyKey;
import org.janusgraph.graphdb.query.JanusGraphPredicate;
import org.openecomp.sdc.be.config.ConfigurationManager;
+import org.openecomp.sdc.be.dao.api.exception.JanusGraphException;
import org.openecomp.sdc.be.dao.graph.GraphElementFactory;
import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
import org.openecomp.sdc.be.dao.graph.datatype.GraphElementTypeEnum;
import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.resources.data.GraphNodeLock;
+import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode;
import org.openecomp.sdc.common.log.wrappers.Logger;
import org.springframework.beans.factory.annotation.Qualifier;
return Either.left(immutablePairs);
}
+ public <T extends GraphNode> JanusGraphOperationStatus deleteAllChildrenNodes(String key, String uniqueId, GraphEdgeLabels edgeType) {
+ final JanusGraph janusGraph = getJanusGraph();
+ final Iterable<JanusGraphVertex> vertices = janusGraph.query().has(key, uniqueId).vertices();
+ if (vertices == null || !vertices.iterator().hasNext()) {
+ return JanusGraphOperationStatus.NOT_FOUND;
+ }
+ final Vertex rootVertex = vertices.iterator().next();
+ final Iterator<Edge> outEdges = rootVertex.edges(Direction.OUT, edgeType.getProperty());
+ while (outEdges.hasNext()) {
+ final Edge edge = outEdges.next();
+ final Vertex vertexIn = edge.inVertex();
+ final Iterator<Edge> outSubEdges = vertexIn.edges(Direction.OUT);
+ while (outSubEdges.hasNext()) {
+ Edge subEdge = outSubEdges.next();
+ Vertex vertex = subEdge.inVertex();
+ Map<String, Object> properties = getProperties(vertex);
+ if (properties != null) {
+ String label = (String) properties.get(GraphPropertiesDictionary.LABEL.getProperty());
+ if (label.equals("property")) {
+ vertex.remove();
+ }
+ }
+ }
+ Map<String, Object> properties = getProperties(vertexIn);
+ if (properties != null) {
+ String label = (String) properties.get(GraphPropertiesDictionary.LABEL.getProperty());
+ GraphNode node = GraphElementFactory
+ .createElement(label, GraphElementTypeEnum.Node, properties, GraphNode.class);
+ if (node != null) {
+ vertexIn.remove();
+ }
+ }
+ }
+ return JanusGraphOperationStatus.OK;
+ }
+
+ /**
+ * Gets the JanusGraph instance.
+ *
+ * @return the JanusGraph instance
+ * @throws JanusGraphException when the graph was not created
+ */
+ public JanusGraph getJanusGraph() {
+ final Either<JanusGraph, JanusGraphOperationStatus> graphRes = janusGraphClient.getGraph();
+ if (graphRes.isRight()) {
+ final var errorMsg = String.format("Failed to retrieve graph. Status was '%s'", graphRes.right().value());
+ log.error(EcompLoggerErrorCode.SCHEMA_ERROR, JanusGraphGenericDao.class.getName(), errorMsg);
+ throw new JanusGraphException(graphRes.right().value(), errorMsg);
+ }
+ return graphRes.left().value();
+ }
+
public Either<List<ImmutablePair<JanusGraphVertex, Edge>>, JanusGraphOperationStatus> getChildrenVertecies(String key, String uniqueId,
GraphEdgeLabels edgeType) {
List<ImmutablePair<JanusGraphVertex, Edge>> immutablePairs = new ArrayList<>();
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
+import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
import org.openecomp.sdc.be.model.DistributionStatusEnum;
import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.Model;
import org.openecomp.sdc.be.model.User;
import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate;
import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
import org.openecomp.sdc.be.model.jsonjanusgraph.enums.JsonConstantKeysEnum;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
+import org.openecomp.sdc.be.model.operations.impl.ModelOperation;
import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
import org.openecomp.sdc.common.jsongraph.util.CommonUtility;
import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum;
import org.openecomp.sdc.common.log.wrappers.Logger;
+import org.springframework.beans.factory.annotation.Autowired;
@org.springframework.stereotype.Component("tosca-element-lifecycle-operation")
/**
private static final String FAILED_TO_DELETE_LAST_STATE_EDGE_STATUS_IS = "Failed to delete last state edge. Status is {}. ";
private static final String FAILED_TO_GET_VERTICES = "Failed to get vertices by id {}. Status is {}. ";
private static final Logger log = Logger.getLogger(ToscaElementLifecycleOperation.class);
+ private final ModelOperation modelOperation;
+
+ @Autowired
+ public ToscaElementLifecycleOperation(ModelOperation modelOperation) {
+ this.modelOperation = modelOperation;
+ }
static StorageOperationStatus handleFailureToPrepareParameters(final JanusGraphOperationStatus status, final String toscaElementId) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId);
* @param toscaElementId
* @return
*/
- public Either<ToscaElement, StorageOperationStatus> undoCheckout(String toscaElementId) {
+ public Either<ToscaElement, StorageOperationStatus> undoCheckout(String toscaElementId, String model) {
try {
return janusGraphDao.getVertexById(toscaElementId, JsonParseFlagEnum.ParseMetadata).right().map(errorStatus -> {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId);
return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(errorStatus);
- }).left().bind(this::retrieveAndUpdatePreviousVersion).left().bind(this::updateEdgeToCatalogRootAndReturnPreVersionElement);
+ }).left().bind(this::retrieveAndUpdatePreviousVersion).left().bind(tuple -> updateEdgeToCatalogRootAndReturnPreVersionElement(tuple, model));
} catch (Exception e) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Exception occurred during undo checkout tosca element {}. {}", toscaElementId,
e.getMessage());
}
private Either<ToscaElement, StorageOperationStatus> updateEdgeToCatalogRootAndReturnPreVersionElement(
- final P2<GraphVertex, JanusGraphVertex> tuple) {
+ final P2<GraphVertex, JanusGraphVertex> tuple, final String model) {
final GraphVertex currVersionV = tuple._1();
final JanusGraphVertex preVersionVertex = tuple._2();
StorageOperationStatus updateCatalogRes = updateEdgeToCatalogRootByUndoCheckout(preVersionVertex, currVersionV);
if (updateCatalogRes != StorageOperationStatus.OK) {
return Either.right(updateCatalogRes);
} else {
+ final Optional<Model> modelOptional = modelOperation.findModelByName(model);
+ if (modelOptional.isPresent() && modelOptional.get().getModelType() == ModelTypeEnum.NORMATIVE_EXTENSION) {
+ modelOperation.deleteModel(modelOptional.get(), false);
+ }
final ToscaElementOperation operation = getToscaElementOperation(currVersionV.getLabel());
return operation.deleteToscaElement(currVersionV).left().bind(discarded -> getUpdatedPreVersionElement(operation, preVersionVertex));
}
params = new String[0];
}
- public OperationException(final ActionStatus actionStatus, String... params) {
+ public OperationException(final ActionStatus actionStatus, final String... params) {
+ this.actionStatus = actionStatus;
+ this.params = params;
+ }
+
+ public OperationException(final Throwable cause, final ActionStatus actionStatus, final String... params) {
+ super(cause);
this.actionStatus = actionStatus;
this.params = params;
}
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import java.util.stream.Collectors;
import org.apache.commons.collections.CollectionUtils;
-import org.apache.commons.collections4.MapUtils;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.janusgraph.core.JanusGraph;
import org.openecomp.sdc.be.config.BeEcompErrorManager;
import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphGenericDao;
import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
+import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
+import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
-import org.openecomp.sdc.be.model.DataTypeDefinition;
import org.openecomp.sdc.be.resources.data.DataTypeData;
import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode;
import org.slf4j.Logger;
private static final Logger LOGGER = LoggerFactory.getLogger(DataTypeOperation.class);
- private final ModelOperation modelOperation;
+ private ModelOperation modelOperation;
@Autowired
- public DataTypeOperation(final HealingJanusGraphGenericDao janusGraphGenericDao,
- final ModelOperation modelOperation) {
+ public DataTypeOperation(final HealingJanusGraphGenericDao janusGraphGenericDao) {
this.janusGraphGenericDao = janusGraphGenericDao;
+ }
+
+ //circular dependency ModelOperation->ModelElementOperation->DataTypeOperation
+ @Autowired
+ public void setModelOperation(final ModelOperation modelOperation) {
this.modelOperation = modelOperation;
}
return getDataTypes.left().value();
}
+ public void deleteDataTypesByModelId(final String modelId) {
+ final JanusGraph janusGraph = janusGraphGenericDao.getJanusGraph();
+ final GraphTraversalSource traversal = janusGraph.traversal();
+ final List<Vertex> dataTypeList = traversal.V()
+ .has(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), modelId)
+ .out(GraphEdgeLabels.MODEL_ELEMENT.getProperty())
+ .has(GraphPropertiesDictionary.LABEL.getProperty(), NodeTypeEnum.DataType.getName())
+ .toList();
+ dataTypeList.forEach(dataTypeVertex -> {
+ traversal.V(dataTypeVertex).out(GraphEdgeLabels.PROPERTY.getProperty()).drop().iterate();
+ dataTypeVertex.remove();
+ });
+ }
+
}
--- /dev/null
+/*
+ * -
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2021 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.be.model.operations.impl;
+
+import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
+import org.openecomp.sdc.be.model.Model;
+import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.OperationException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component("model-element-operation")
+public class ModelElementOperation {
+
+ private final JanusGraphGenericDao janusGraphGenericDao;
+ private final DataTypeOperation dataTypeOperation;
+ private final PolicyTypeOperation policyTypeOperation;
+
+ @Autowired
+ public ModelElementOperation(final JanusGraphGenericDao janusGraphGenericDao,
+ final DataTypeOperation dataTypeOperation,
+ final PolicyTypeOperation policyTypeOperation) {
+ this.janusGraphGenericDao = janusGraphGenericDao;
+ this.dataTypeOperation = dataTypeOperation;
+ this.policyTypeOperation = policyTypeOperation;
+ }
+
+ /**
+ * Deletes the given model if it exists, along with its MODEL_ELEMENT edges and import files.
+ *
+ * @param model the model
+ * @param inTransaction if the operation is called in the middle of a janusgraph transaction
+ */
+ public void deleteModelElements(final Model model, final boolean inTransaction) {
+ boolean rollback = false;
+
+ try {
+ final String modelId = UniqueIdBuilder.buildModelUid(model.getName());
+ dataTypeOperation.deleteDataTypesByModelId(modelId);
+ policyTypeOperation.deletePolicyTypesByModelId(modelId);
+ } catch (final Exception e) {
+ rollback = true;
+ throw new OperationException(e, ActionStatus.COULD_NOT_DELETE_MODEL_ELEMENTS, model.getName());
+ } finally {
+ if (!inTransaction) {
+ if (rollback) {
+ janusGraphGenericDao.rollback();
+ } else {
+ janusGraphGenericDao.commit();
+ }
+ }
+ }
+ }
+
+}
import org.openecomp.sdc.be.dao.cassandra.ToscaModelImportCassandraDao;
import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
+import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
-import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
import org.openecomp.sdc.be.data.model.ToscaImportByModel;
private final JanusGraphDao janusGraphDao;
private final ToscaModelImportCassandraDao toscaModelImportCassandraDao;
private final DerivedFromOperation derivedFromOperation;
+ private ModelElementOperation modelElementOperation;
@Autowired
public ModelOperation(final JanusGraphGenericDao janusGraphGenericDao,
+ "description: Auto-generated file that contains package custom types or types added after system installation." + "\n";
}
+ /**
+ * Deletes the given model if it exists, along with its MODEL_ELEMENT edges and import files.
+ *
+ * @param model the model
+ * @param inTransaction if the operation is called in the middle of a janusgraph transaction
+ */
+ public void deleteModel(final Model model, final boolean inTransaction) {
+ boolean rollback = false;
+
+ try {
+ final GraphVertex modelVertexByName = findModelVertexByName(model.getName()).orElse(null);
+ if (modelVertexByName == null) {
+ return;
+ }
+ toscaModelImportCassandraDao.deleteAllByModel(model.getName());
+ modelElementOperation.deleteModelElements(model, inTransaction);
+ deleteModel(model);
+ } catch (final OperationException e) {
+ rollback = true;
+ throw e;
+ } catch (final Exception e) {
+ rollback = true;
+ throw new OperationException(e, ActionStatus.COULD_NOT_DELETE_MODEL, model.getName());
+ } finally {
+ if (!inTransaction) {
+ if (rollback) {
+ janusGraphGenericDao.rollback();
+ } else {
+ janusGraphGenericDao.commit();
+ }
+ }
+ }
+ }
+
+ private void deleteModel(final Model model) {
+ final var modelData = new ModelData(model.getName(), UniqueIdBuilder.buildModelUid(model.getName()), model.getModelType());
+ final Either<ModelData, JanusGraphOperationStatus> deleteParentNodeByModel = janusGraphGenericDao.deleteNode(modelData, ModelData.class);
+ if (deleteParentNodeByModel.isRight()) {
+ final var janusGraphOperationStatus = deleteParentNodeByModel.right().value();
+ log.error(EcompLoggerErrorCode.DATA_ERROR, ModelOperation.class.getName(),
+ "Failed to delete model {} on JanusGraph with status {}", new Object[] {model.getName(), janusGraphOperationStatus});
+ throw new OperationException(ActionStatus.COULD_NOT_DELETE_MODEL, model.getName());
+ }
+ }
+
+ @Autowired
+ public void setModelElementOperation(final ModelElementOperation modelElementOperation) {
+ this.modelElementOperation = modelElementOperation;
+ }
+
}
* ============LICENSE_END=========================================================
*/
package org.openecomp.sdc.be.model.operations.impl;
+
import static org.openecomp.sdc.be.dao.janusgraph.JanusGraphUtils.buildNotInPredicate;
-import static org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR;
import fj.data.Either;
import java.util.ArrayList;
import java.util.Set;
import java.util.stream.Collectors;
import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.janusgraph.core.JanusGraph;
import org.janusgraph.graphdb.query.JanusGraphPredicate;
import org.openecomp.sdc.be.config.BeEcompErrorManager;
import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
private static final Logger log = Logger.getLogger(PolicyTypeOperation.class.getName());
private static final String CREATE_FLOW_CONTEXT = "CreatePolicyType";
private static final String GET_FLOW_CONTEXT = "GetPolicyType";
- @Autowired
- private PropertyOperation propertyOperation;
- @Autowired
- private DerivedFromOperation derivedFromOperation;
- @Autowired
- private OperationUtils operationUtils;
+ private final PropertyOperation propertyOperation;
+ private final DerivedFromOperation derivedFromOperation;
+ private final OperationUtils operationUtils;
+ @Autowired
+ public PolicyTypeOperation(final PropertyOperation propertyOperation, final DerivedFromOperation derivedFromOperation,
+ final OperationUtils operationUtils) {
+ this.propertyOperation = propertyOperation;
+ this.derivedFromOperation = derivedFromOperation;
+ this.operationUtils = operationUtils;
+ }
@Override
public Either<PolicyTypeDefinition, StorageOperationStatus> getLatestPolicyTypeByType(String type, String model) {
updatedTypeDefinition.setCreationTime(currTypeDefinition.getCreationTime());
updatedTypeDefinition.setModificationTime(System.currentTimeMillis());
}
+
+ public void deletePolicyTypesByModelId(final String modelId) {
+ final JanusGraph janusGraph = janusGraphGenericDao.getJanusGraph();
+ final GraphTraversalSource traversal = janusGraph.traversal();
+ final List<Vertex> policyTypeList = traversal.V()
+ .has(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), modelId)
+ .out(GraphEdgeLabels.MODEL_ELEMENT.getProperty())
+ .has(GraphPropertiesDictionary.LABEL.getProperty(), NodeTypeEnum.PolicyType.getName())
+ .toList();
+ policyTypeList.forEach(policyTypeVertex -> {
+ traversal.V(policyTypeVertex).out(GraphEdgeLabels.PROPERTY.getProperty()).drop().iterate();
+ policyTypeVertex.remove();
+ });
+ }
}
private static final String THE_VALUE_OF_PROPERTY_FROM_TYPE_IS_INVALID = "The value {} of property from type {} is invalid";
private static final String PROPERTY = "Property";
private static final String UPDATE_DATA_TYPE = "UpdateDataType";
- private static Logger log = Logger.getLogger(PropertyOperation.class.getName());
- private DerivedFromOperation derivedFromOperation;
+ private static final Logger log = Logger.getLogger(PropertyOperation.class.getName());
+ private final DerivedFromOperation derivedFromOperation;
private DataTypeOperation dataTypeOperation;
@Autowired
- public PropertyOperation(HealingJanusGraphGenericDao janusGraphGenericDao, DerivedFromOperation derivedFromOperation,
- DataTypeOperation dataTypeOperation) {
+ public PropertyOperation(final HealingJanusGraphGenericDao janusGraphGenericDao, final DerivedFromOperation derivedFromOperation) {
this.janusGraphGenericDao = janusGraphGenericDao;
this.derivedFromOperation = derivedFromOperation;
+ }
+
+ //circular dependency DataTypeOperation->ModelOperation->ModelElementOperation->PropertyOperation
+ @Autowired
+ public void setDataTypeOperation(DataTypeOperation dataTypeOperation) {
this.dataTypeOperation = dataTypeOperation;
}
return null;
}
}
+
}
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.model.DataTypeDefinition;
import org.openecomp.sdc.be.model.Model;
-import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
import org.openecomp.sdc.be.resources.data.DataTypeData;
import org.springframework.test.context.ContextConfiguration;
private ModelOperation modelOperation;
@Mock
private HealingJanusGraphGenericDao janusGraphGenericDao;
- @Mock
- private ApplicationDataTypeCache applicationDataTypeCache;
private final String modelName = "ETSI-SDC-MODEL-TEST";
private final List<DataTypeData> dataTypesWithoutModel = new ArrayList<>();
final Map<String, DataTypeDefinition> allDataTypesFoundDefinitionMap = new HashMap<>();
private Model model;
-
@BeforeEach
void beforeEachInit() {
MockitoAnnotations.openMocks(this);
+ dataTypeOperation.setModelOperation(modelOperation);
initTestData();
}
--- /dev/null
+/*
+ * -
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2021 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.be.model.operations.impl;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
+import org.openecomp.sdc.be.model.Model;
+
+class ModelElementOperationTest {
+
+ @Mock
+ private JanusGraphGenericDao janusGraphGenericDao;
+ @Mock
+ private DataTypeOperation dataTypeOperation;
+ @Mock
+ private PolicyTypeOperation policyTypeOperation;
+ @InjectMocks
+ private ModelElementOperation modelElementOperation;
+
+ @BeforeEach
+ void setUp() {
+ MockitoAnnotations.openMocks(this);
+ }
+
+ @Test
+ void deleteModelElements_noTransactionSuccessTest() {
+ var model = new Model("name");
+ final String modelId = UniqueIdBuilder.buildModelUid(model.getName());
+ modelElementOperation.deleteModelElements(model, false);
+ verify(dataTypeOperation).deleteDataTypesByModelId(modelId);
+ verify(policyTypeOperation).deletePolicyTypesByModelId(modelId);
+ verify(janusGraphGenericDao).commit();
+ verify(janusGraphGenericDao, times(0)).rollback();
+ }
+
+ @Test
+ void deleteModelElements_inTransactionSuccessTest() {
+ var model = new Model("name");
+ final String modelId = UniqueIdBuilder.buildModelUid(model.getName());
+ modelElementOperation.deleteModelElements(model, true);
+ verify(dataTypeOperation).deleteDataTypesByModelId(modelId);
+ verify(policyTypeOperation).deletePolicyTypesByModelId(modelId);
+ verify(janusGraphGenericDao, times(0)).commit();
+ verify(janusGraphGenericDao, times(0)).rollback();
+ }
+
+ @Test
+ void deleteModelElements_noTransactionErrorTest() {
+ var model = new Model("name");
+ final String modelId = UniqueIdBuilder.buildModelUid(model.getName());
+ doThrow(new RuntimeException()).when(dataTypeOperation).deleteDataTypesByModelId(modelId);
+ assertThrows(RuntimeException.class, () -> modelElementOperation.deleteModelElements(model, false));
+ verify(dataTypeOperation).deleteDataTypesByModelId(modelId);
+ verify(janusGraphGenericDao).rollback();
+ verify(janusGraphGenericDao, times(0)).commit();
+ }
+
+ @Test
+ void deleteModelElements_inTransactionErrorTest() {
+ var model = new Model("name");
+ final String modelId = UniqueIdBuilder.buildModelUid(model.getName());
+ doThrow(new RuntimeException()).when(dataTypeOperation).deleteDataTypesByModelId(modelId);
+ assertThrows(RuntimeException.class, () -> modelElementOperation.deleteModelElements(model, true));
+ verify(dataTypeOperation).deleteDataTypesByModelId(modelId);
+ verify(janusGraphGenericDao, times(0)).commit();
+ verify(janusGraphGenericDao, times(0)).rollback();
+ }
+}
\ No newline at end of file
final DataTypeOperation dataTypeOperation = mock(DataTypeOperation.class);
- PropertyOperation propertyOperation = new PropertyOperation(janusGraphGenericDao, null, dataTypeOperation);
+ PropertyOperation propertyOperation = new PropertyOperation(janusGraphGenericDao, null);
@Before
public void setup() {
+ propertyOperation.setDataTypeOperation(dataTypeOperation);
propertyOperation.setJanusGraphGenericDao(janusGraphGenericDao);
-
}
private PropertyDefinition buildPropertyDefinition() {
}
- private PropertyOperation createTestSubject() {
- return new PropertyOperation(new HealingJanusGraphGenericDao(new JanusGraphClient()), null, dataTypeOperation);
- }
+ private PropertyOperation createTestSubject() {
+ final var propertyOperation = new PropertyOperation(new HealingJanusGraphGenericDao(new JanusGraphClient()), null);
+ propertyOperation.setDataTypeOperation(dataTypeOperation);
+ return propertyOperation;
+ }
@Test
public void testConvertPropertyDataToPropertyDefinition() throws Exception {
expectedIds.add(vertex4.getUniqueId());
verifyInCatalogData(4, expectedIds);
- lifecycleOperation.undoCheckout(vertex4.getUniqueId());
+ lifecycleOperation.undoCheckout(vertex4.getUniqueId(), null);
expectedIds.remove(vertex4.getUniqueId());
verifyInCatalogData(3, expectedIds);
super(message);
}
+ protected BusinessException(final Throwable cause) {
+ super(cause);
+ }
+
protected BusinessException(final String message, final Throwable cause) {
super(message, cause);
}
Code Review / sdc.git / commitdiff