* ============LICENSE_END=========================================================
*/
-package org.openecomp.sdc.be.model.jsontitan.operations;
+package org.openecomp.sdc.be.model.jsonjanusgraph.operations;
-import com.thinkaurelius.titan.core.TitanVertex;
+import org.janusgraph.core.JanusGraphVertex;
import fj.data.Either;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
import org.apache.tinkerpop.gremlin.structure.Edge;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.openecomp.sdc.be.config.ConfigurationManager;
+import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
import org.openecomp.sdc.be.dao.jsongraph.types.EdgePropertyEnum;
import org.openecomp.sdc.be.dao.jsongraph.utils.IdBuilderUtils;
import org.openecomp.sdc.be.dao.jsongraph.utils.JsonParserUtils;
import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
-import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
import org.openecomp.sdc.be.datatypes.elements.*;
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.OriginTypeEnum;
import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
-import org.openecomp.sdc.be.model.ComponentParametersView;
import org.openecomp.sdc.be.model.DistributionStatusEnum;
import org.openecomp.sdc.be.model.LifecycleStateEnum;
import org.openecomp.sdc.be.model.User;
-import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate;
-import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement;
-import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum;
-import org.openecomp.sdc.be.model.jsontitan.enums.JsonConstantKeysEnum;
+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.datamodel.ToscaElementTypeEnum;
+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.UniqueIdBuilder;
Map<String, GraphVertex> vertices = null;
ToscaElementOperation operation;
try {
- Either<Map<String, GraphVertex>, TitanOperationStatus> getVerticesRes = titanDao.getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForCheckin(toscaElementId, modifierId, ownerId));
+ Either<Map<String, GraphVertex>, JanusGraphOperationStatus> getVerticesRes = janusGraphDao
+ .getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForCheckin(toscaElementId, modifierId, ownerId));
if (getVerticesRes.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId);
- updateResult = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticesRes.right().value()));
+ updateResult = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVerticesRes.right().value()));
} else {
vertices = getVerticesRes.left().value();
updateResult = checkinToscaELement(currState, vertices.get(toscaElementId), vertices.get(ownerId), vertices.get(modifierId), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
public Either<User, StorageOperationStatus> getToscaElementOwner(String toscaElementId) {
Either<User, StorageOperationStatus> result = null;
GraphVertex toscaElement = null;
- Either<GraphVertex, TitanOperationStatus> getToscaElementRes = titanDao.getVertexById(toscaElementId, JsonParseFlagEnum.NoParse);
+ Either<GraphVertex, JanusGraphOperationStatus> getToscaElementRes = janusGraphDao
+ .getVertexById(toscaElementId, JsonParseFlagEnum.NoParse);
if (getToscaElementRes.isRight()) {
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getToscaElementRes.right().value()));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getToscaElementRes.right().value()));
}
if (result == null) {
toscaElement = getToscaElementRes.left().value();
Either<ToscaElement, StorageOperationStatus> result = null;
Map<String, GraphVertex> vertices = null;
try {
- Either<Map<String, GraphVertex>, TitanOperationStatus> getVerticesRes = titanDao.getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForCheckout(toscaElementId, modifierId, ownerId));
+ Either<Map<String, GraphVertex>, JanusGraphOperationStatus> getVerticesRes = janusGraphDao
+ .getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForCheckout(toscaElementId, modifierId, ownerId));
if (getVerticesRes.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId);
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticesRes.right().value()));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVerticesRes.right().value()));
}
if (result == null) {
vertices = getVerticesRes.left().value();
*/
public Either<ToscaElement, StorageOperationStatus> undoCheckout(String toscaElementId) {
Either<ToscaElement, StorageOperationStatus> result = null;
- Either<GraphVertex, TitanOperationStatus> getToscaElementRes = null;
+ Either<GraphVertex, JanusGraphOperationStatus> getToscaElementRes = null;
Iterator<Edge> nextVersionComponentIter = null;
ToscaElementOperation operation;
Vertex preVersionVertex = null;
try {
- getToscaElementRes = titanDao.getVertexById(toscaElementId, JsonParseFlagEnum.ParseMetadata);
+ getToscaElementRes = janusGraphDao.getVertexById(toscaElementId, JsonParseFlagEnum.ParseMetadata);
if (getToscaElementRes.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId);
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getToscaElementRes.right().value()));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getToscaElementRes.right().value()));
}
GraphVertex currVersionV = getToscaElementRes.left().value();
if (result == null && hasPreviousVersion(currVersionV)) {
}
}
if (result == null) {
- StorageOperationStatus updateCatalogRes = updateEdgeToCatalogRootByUndoCheckout((TitanVertex) preVersionVertex, currVersionV);
+ StorageOperationStatus updateCatalogRes = updateEdgeToCatalogRootByUndoCheckout((JanusGraphVertex) preVersionVertex, currVersionV);
if (updateCatalogRes != StorageOperationStatus.OK) {
return Either.right(updateCatalogRes);
}
GraphVertex modifier = null;
GraphVertex owner;
try {
- Either<Map<String, GraphVertex>, TitanOperationStatus> getVerticesRes = titanDao.getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId));
+ Either<Map<String, GraphVertex>, JanusGraphOperationStatus> getVerticesRes = janusGraphDao
+ .getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId));
if (getVerticesRes.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId);
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticesRes.right().value()));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVerticesRes.right().value()));
}
if (result == null) {
toscaElement = getVerticesRes.left().value().get(toscaElementId);
GraphVertex modifier = null;
GraphVertex owner;
try {
- Either<Map<String, GraphVertex>, TitanOperationStatus> getVerticesRes = titanDao.getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId));
+ Either<Map<String, GraphVertex>, JanusGraphOperationStatus> getVerticesRes = janusGraphDao
+ .getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId));
if (getVerticesRes.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId);
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticesRes.right().value()));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVerticesRes.right().value()));
}
if (result == null) {
toscaElement = getVerticesRes.left().value().get(toscaElementId);
StorageOperationStatus status;
try {
- Either<Map<String, GraphVertex>, TitanOperationStatus> getVerticesRes = titanDao.getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId));
+ Either<Map<String, GraphVertex>, JanusGraphOperationStatus> getVerticesRes = janusGraphDao
+ .getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId));
if (getVerticesRes.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId);
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticesRes.right().value()));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVerticesRes.right().value()));
}
if (result == null) {
toscaElement = getVerticesRes.left().value().get(toscaElementId);
Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
properties.put(GraphPropertyEnum.UUID, uuid);
properties.put(GraphPropertyEnum.NAME, componentName);
- Either<List<GraphVertex>, TitanOperationStatus> getToscaElementsRes = titanDao.getByCriteria(vertexType, properties, JsonParseFlagEnum.ParseMetadata);
+ Either<List<GraphVertex>, JanusGraphOperationStatus> getToscaElementsRes = janusGraphDao
+ .getByCriteria(vertexType, properties, JsonParseFlagEnum.ParseMetadata);
if (getToscaElementsRes.isRight()) {
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getToscaElementsRes.right().value()));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getToscaElementsRes.right().value()));
}
if (result == null) {
result = markToscaElementsAsDeleted(operation, getToscaElementsRes.left().value());
GraphVertex toscaElement = null;
GraphVertex modifier = null;
try {
- Either<Map<String, GraphVertex>, TitanOperationStatus> getVerticesRes = titanDao.getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId));
+ Either<Map<String, GraphVertex>, JanusGraphOperationStatus> getVerticesRes = janusGraphDao
+ .getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId));
if (getVerticesRes.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId);
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticesRes.right().value()));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVerticesRes.right().value()));
}
if (result == null) {
toscaElement = getVerticesRes.left().value().get(toscaElementId);
toscaElement.setJsonMetadataField(JsonPresentationFields.USER_ID_LAST_UPDATER, modifier.getUniqueId());
toscaElement.addMetadataProperty(GraphPropertyEnum.STATE, nextState.name());
- Either<GraphVertex, TitanOperationStatus> updateVertexRes = titanDao.updateVertex(toscaElement);
+ Either<GraphVertex, JanusGraphOperationStatus> updateVertexRes = janusGraphDao.updateVertex(toscaElement);
if (updateVertexRes.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update vertex {} . Status is {}. ", toscaElementId, updateVertexRes.right().value());
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateVertexRes.right().value()));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateVertexRes.right().value()));
}
}
if (result == null) {
return result;
}
- public Either<GraphVertex, TitanOperationStatus> findUser(String userId) {
+ public Either<GraphVertex, JanusGraphOperationStatus> findUser(String userId) {
return findUserVertex(userId);
}
result = StorageOperationStatus.NOT_FOUND;
}
if (result == null) {
- TitanOperationStatus createVersionEdgeStatus = titanDao.createEdge(toscaElement, certifiedToscaElement, EdgeLabelEnum.VERSION, new HashMap<>());
- if (createVersionEdgeStatus != TitanOperationStatus.OK) {
+ JanusGraphOperationStatus
+ createVersionEdgeStatus = janusGraphDao
+ .createEdge(toscaElement, certifiedToscaElement, EdgeLabelEnum.VERSION, new HashMap<>());
+ if (createVersionEdgeStatus != JanusGraphOperationStatus.OK) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create version edge from last element {} to new certified element {}. status=", toscaElement.getUniqueId(), certifiedToscaElement.getUniqueId(),
createVersionEdgeStatus);
- result = DaoStatusConverter.convertTitanStatusToStorageStatus(createVersionEdgeStatus);
+ result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createVersionEdgeStatus);
}
}
if (result == null) {
if (certReqUserEdgeIter!=null) {
while (certReqUserEdgeIter.hasNext()) {
Edge edge = certReqUserEdgeIter.next();
- if (((String) titanDao.getProperty(edge, EdgePropertyEnum.STATE)).equals(LifecycleStateEnum.READY_FOR_CERTIFICATION.name())) {
+ if (((String) janusGraphDao.getProperty(edge, EdgePropertyEnum.STATE)).equals(LifecycleStateEnum.READY_FOR_CERTIFICATION.name())) {
foundEdge = edge;
break;
}
}
}
if (result == null) {
- TitanOperationStatus createEdgeRes = titanDao.createEdge(foundEdge.outVertex(), certifiedToscaElement.getVertex(), EdgeLabelEnum.LAST_STATE, foundEdge);
- if (createEdgeRes != TitanOperationStatus.OK) {
+ JanusGraphOperationStatus
+ createEdgeRes = janusGraphDao
+ .createEdge(foundEdge.outVertex(), certifiedToscaElement.getVertex(), EdgeLabelEnum.LAST_STATE, foundEdge);
+ if (createEdgeRes != JanusGraphOperationStatus.OK) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create rfc relation for component {}. status=", certifiedToscaElement.getUniqueId(), createEdgeRes);
- result = DaoStatusConverter.convertTitanStatusToStorageStatus(createEdgeRes);
+ result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createEdgeRes);
}
}
if (result == null) {
private StorageOperationStatus handleRelationsUponFailCertification(GraphVertex toscaElement, LifecycleStateEnum nextState) {
StorageOperationStatus result = null;
- TitanOperationStatus status = null;
+ JanusGraphOperationStatus status = null;
Edge originEdge;
Vertex user = null;
if (nextState == LifecycleStateEnum.NOT_CERTIFIED_CHECKIN) {
Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
properties.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS);
- Either<Edge, TitanOperationStatus> deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.STATE, properties);
+ Either<Edge, JanusGraphOperationStatus> deleteResult = janusGraphDao
+ .deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.STATE, properties);
if (deleteResult.isRight()) {
status = deleteResult.right().value();
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete state edge. Status is {}. ", status);
if (result == null) {
// delete relation READY_FOR_CERTIFICATION
properties.put(GraphPropertyEnum.STATE, LifecycleStateEnum.READY_FOR_CERTIFICATION);
- deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.LAST_STATE, properties);
+ deleteResult = janusGraphDao
+ .deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.LAST_STATE, properties);
if (deleteResult.isRight()) {
status = deleteResult.right().value();
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_DELETE_LAST_STATE_EDGE_STATUS_IS, status);
if (result == null) {
// delete relation NOT_CERTIFIED_CHECKIN (in order to change to STATE)
properties.put(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
- deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.LAST_STATE, properties);
+ deleteResult = janusGraphDao
+ .deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.LAST_STATE, properties);
if (deleteResult.isRight()) {
status = deleteResult.right().value();
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_DELETE_LAST_STATE_EDGE_STATUS_IS, status);
// create new STATE relation NOT_CERTIFIED_CHECKIN
originEdge = deleteResult.left().value();
user = originEdge.outVertex();
- status = titanDao.createEdge(user, toscaElement.getVertex(), EdgeLabelEnum.STATE, originEdge);
- if (status != TitanOperationStatus.OK) {
+ status = janusGraphDao
+ .createEdge(user, toscaElement.getVertex(), EdgeLabelEnum.STATE, originEdge);
+ if (status != JanusGraphOperationStatus.OK) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create state edge. Status is {}. ", status);
result = StorageOperationStatus.INCONSISTENCY;
}
}
if (result == null) {
// delete relation LAST_MODIFIER (in order to change tester to designer)
- deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.LAST_MODIFIER, new HashMap<>());
- if (status != TitanOperationStatus.OK) {
+ deleteResult = janusGraphDao
+ .deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.LAST_MODIFIER, new HashMap<>());
+ if (status != JanusGraphOperationStatus.OK) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create last modifier edge. Status is {}. ", status);
result = StorageOperationStatus.INCONSISTENCY;
}
if (result == null) {
// create new LAST_MODIFIER relation
originEdge = deleteResult.left().value();
- status = titanDao.createEdge(user, toscaElement.getVertex(), EdgeLabelEnum.LAST_MODIFIER, originEdge);
- if (status != TitanOperationStatus.OK) {
+ status = janusGraphDao.createEdge(user, toscaElement.getVertex(), EdgeLabelEnum.LAST_MODIFIER, originEdge);
+ if (status != JanusGraphOperationStatus.OK) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create last modifier edge. Status is {}. ", status);
result = StorageOperationStatus.INCONSISTENCY;
}
// delete relation CERTIFICATION_IN_PROGRESS
Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
properties.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS);
- Either<Edge, TitanOperationStatus> deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.STATE, properties);
+ Either<Edge, JanusGraphOperationStatus> deleteResult = janusGraphDao
+ .deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.STATE, properties);
if (deleteResult.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete state edge. Status is {}. ", deleteResult.right().value());
if (result == null) {
// delete relation READY_FOR_CERTIFICATION (LAST_STATE)
properties.put(GraphPropertyEnum.STATE, nextState);
- deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.LAST_STATE, properties);
+ deleteResult = janusGraphDao
+ .deleteBelongingEdgeByCriteria(toscaElement, EdgeLabelEnum.LAST_STATE, properties);
if (deleteResult.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_DELETE_LAST_STATE_EDGE_STATUS_IS, deleteResult.right().value());
if (result == null) {
// create relation READY_FOR_CERTIFICATION (STATE)
originEdge = deleteResult.left().value();
- TitanOperationStatus status = titanDao.createEdge(originEdge.outVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, originEdge);
- if (status != TitanOperationStatus.OK) {
+ JanusGraphOperationStatus
+ status = janusGraphDao
+ .createEdge(originEdge.outVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, originEdge);
+ if (status != JanusGraphOperationStatus.OK) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create state edge. Status is {}. ", status);
result = StorageOperationStatus.INCONSISTENCY;
}
Vertex lastCertifiedVertex = findRes.left().value();
Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
properties.put(GraphPropertyEnum.IS_HIGHEST_VERSION, false);
- TitanOperationStatus status = titanDao.updateVertexMetadataPropertiesWithJson(lastCertifiedVertex, properties);
- if (status != TitanOperationStatus.OK) {
+ JanusGraphOperationStatus status = janusGraphDao
+ .updateVertexMetadataPropertiesWithJson(lastCertifiedVertex, properties);
+ if (status != JanusGraphOperationStatus.OK) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to set highest version of tosca element {} to [{}]. Status is {}", toscaElement.getUniqueId(), false, status);
- result = DaoStatusConverter.convertTitanStatusToStorageStatus(status);
+ result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
}
// remove previous certified version from the catalog
GraphVertex lastCertifiedV = new GraphVertex();
- lastCertifiedV.setVertex((TitanVertex) lastCertifiedVertex);
- lastCertifiedV.setUniqueId((String) titanDao.getProperty((TitanVertex) lastCertifiedVertex, GraphPropertyEnum.UNIQUE_ID.getProperty()));
+ lastCertifiedV.setVertex((JanusGraphVertex) lastCertifiedVertex);
+ lastCertifiedV.setUniqueId((String) janusGraphDao
+ .getProperty((JanusGraphVertex) lastCertifiedVertex, GraphPropertyEnum.UNIQUE_ID.getProperty()));
StorageOperationStatus res = updateEdgeToCatalogRoot(null, lastCertifiedV);
if (res != StorageOperationStatus.OK) {
return res;
}
private StorageOperationStatus handleRelationsUponRequestForCertification(GraphVertex toscaElement, GraphVertex modifier, GraphVertex owner) {
- TitanOperationStatus status;
+ JanusGraphOperationStatus status;
StorageOperationStatus result = null;
if (((String) toscaElement.getMetadataProperty(GraphPropertyEnum.STATE)).equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
// remove CHECKOUT relation
- Either<Edge, TitanOperationStatus> deleteRes = titanDao.deleteEdge(owner, toscaElement, EdgeLabelEnum.STATE);
+ Either<Edge, JanusGraphOperationStatus> deleteRes = janusGraphDao
+ .deleteEdge(owner, toscaElement, EdgeLabelEnum.STATE);
if (deleteRes.isRight()) {
status = deleteRes.right().value();
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete edge. Status is {}. ", status);
- result = DaoStatusConverter.convertTitanStatusToStorageStatus(status);
+ result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
}
if (result == null) {
// create CHECKIN relation
Map<EdgePropertyEnum, Object> properties = new EnumMap<>(EdgePropertyEnum.class);
properties.put(EdgePropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
- status = titanDao.createEdge(modifier.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.LAST_STATE, properties);
- if (status != TitanOperationStatus.OK) {
+ status = janusGraphDao
+ .createEdge(modifier.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.LAST_STATE, properties);
+ if (status != JanusGraphOperationStatus.OK) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create edge. Status is {}", status);
- result = DaoStatusConverter.convertTitanStatusToStorageStatus(status);
+ result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
}
}
} else {
- status = titanDao.replaceEdgeLabel(owner.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE);
- if (status != TitanOperationStatus.OK) {
- result = DaoStatusConverter.convertTitanStatusToStorageStatus(status);
+ status = janusGraphDao
+ .replaceEdgeLabel(owner.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE);
+ if (status != JanusGraphOperationStatus.OK) {
+ result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
}
}
if (result == null) {
// create RFC relation
Map<EdgePropertyEnum, Object> properties = new EnumMap<>(EdgePropertyEnum.class);
properties.put(EdgePropertyEnum.STATE, LifecycleStateEnum.READY_FOR_CERTIFICATION);
- status = titanDao.createEdge(modifier.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, properties);
- if (status != TitanOperationStatus.OK) {
+ status = janusGraphDao
+ .createEdge(modifier.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, properties);
+ if (status != JanusGraphOperationStatus.OK) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create edge. Status is {}", status);
- result = DaoStatusConverter.convertTitanStatusToStorageStatus(status);
+ result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
}
}
if (result == null) {
private StorageOperationStatus handleRelationsUponCertification(GraphVertex toscaElement, GraphVertex modifier, GraphVertex owner) {
StorageOperationStatus result = null;
- TitanOperationStatus status = titanDao.replaceEdgeLabel(owner.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE);
- if (status != TitanOperationStatus.OK) {
- result = DaoStatusConverter.convertTitanStatusToStorageStatus(status);
+ JanusGraphOperationStatus status = janusGraphDao
+ .replaceEdgeLabel(owner.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE);
+ if (status != JanusGraphOperationStatus.OK) {
+ result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
}
if (result == null) {
Map<EdgePropertyEnum, Object> properties = new EnumMap<>(EdgePropertyEnum.class);
properties.put(EdgePropertyEnum.STATE, LifecycleStateEnum.CERTIFICATION_IN_PROGRESS);
- status = titanDao.createEdge(modifier, toscaElement, EdgeLabelEnum.STATE, properties);
- if (status != TitanOperationStatus.OK) {
+ status = janusGraphDao
+ .createEdge(modifier, toscaElement, EdgeLabelEnum.STATE, properties);
+ if (status != JanusGraphOperationStatus.OK) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "failed to create edge. Status is {}", status);
- result = DaoStatusConverter.convertTitanStatusToStorageStatus(status);
+ result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
}
}
if (result == null) {
jsonMetadataMap.put(GraphPropertyEnum.IS_HIGHEST_VERSION.getProperty(), true);
propertiesToUpdate.put(GraphPropertyEnum.METADATA.getProperty(), JsonParserUtils.toJson(jsonMetadataMap));
- titanDao.setVertexProperties(previousVersionToscaElement, propertiesToUpdate);
+ janusGraphDao.setVertexProperties(previousVersionToscaElement, propertiesToUpdate);
Iterator<Edge> edgesIter = previousVersionToscaElement.edges(Direction.IN, EdgeLabelEnum.LAST_STATE.name());
if (!edgesIter.hasNext()) {
} else {
Edge lastStateEdge = edgesIter.next();
Vertex lastModifier = lastStateEdge.outVertex();
- TitanOperationStatus replaceRes = titanDao.replaceEdgeLabel(lastModifier, previousVersionToscaElement, lastStateEdge, EdgeLabelEnum.LAST_STATE, EdgeLabelEnum.STATE);
- if (replaceRes != TitanOperationStatus.OK) {
+ JanusGraphOperationStatus replaceRes = janusGraphDao
+ .replaceEdgeLabel(lastModifier, previousVersionToscaElement, lastStateEdge, EdgeLabelEnum.LAST_STATE, EdgeLabelEnum.STATE);
+ if (replaceRes != JanusGraphOperationStatus.OK) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to replace label from {} to {}. status = {}", EdgeLabelEnum.LAST_STATE, EdgeLabelEnum.STATE, replaceRes);
result = StorageOperationStatus.INCONSISTENCY;
- if (replaceRes != TitanOperationStatus.INVALID_ID) {
- result = DaoStatusConverter.convertTitanStatusToStorageStatus(replaceRes);
+ if (replaceRes != JanusGraphOperationStatus.INVALID_ID) {
+ result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(replaceRes);
}
}
String toscaElementId = toscaElementVertex.getUniqueId();
if (!toscaElementVertex.getMetadataProperty(GraphPropertyEnum.STATE).equals(LifecycleStateEnum.CERTIFIED.name())) {
toscaElementVertex.addMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION, false);
- Either<GraphVertex, TitanOperationStatus> updateVertexRes = titanDao.updateVertex(toscaElementVertex);
+ Either<GraphVertex, JanusGraphOperationStatus> updateVertexRes = janusGraphDao.updateVertex(toscaElementVertex);
if (updateVertexRes.isRight()) {
- TitanOperationStatus titatStatus = updateVertexRes.right().value();
+ JanusGraphOperationStatus titatStatus = updateVertexRes.right().value();
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update tosca element vertex {}. Status is {}", toscaElementVertex.getUniqueId(), titatStatus);
- result = DaoStatusConverter.convertTitanStatusToStorageStatus(titatStatus);
+ result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(titatStatus);
}
- Either<Edge, TitanOperationStatus> deleteEdgeRes = null;
+ Either<Edge, JanusGraphOperationStatus> deleteEdgeRes = null;
if (result == null) {
CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to replace edge with label {} to label {} from {} to {}. ", EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE, ownerId, toscaElementId);
- deleteEdgeRes = titanDao.deleteEdge(ownerVertex, toscaElementVertex, EdgeLabelEnum.STATE);
+ deleteEdgeRes = janusGraphDao
+ .deleteEdge(ownerVertex, toscaElementVertex, EdgeLabelEnum.STATE);
if (deleteEdgeRes.isRight()) {
- TitanOperationStatus titanStatus = deleteEdgeRes.right().value();
- CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete edge with label {} from {} to {}. Status is {} ", EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE, ownerId, toscaElementId, titanStatus);
- if (!titanStatus.equals(TitanOperationStatus.INVALID_ID)) {
- result = DaoStatusConverter.convertTitanStatusToStorageStatus(titanStatus);
+ JanusGraphOperationStatus janusGraphStatus = deleteEdgeRes.right().value();
+ CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete edge with label {} from {} to {}. Status is {} ", EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE, ownerId, toscaElementId, janusGraphStatus);
+ if (!janusGraphStatus.equals(JanusGraphOperationStatus.INVALID_ID)) {
+ result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(janusGraphStatus);
} else {
result = StorageOperationStatus.INCONSISTENCY;
}
}
}
if (result == null) {
- TitanOperationStatus createEdgeRes = titanDao.createEdge(ownerVertex.getVertex(), toscaElementVertex.getVertex(), EdgeLabelEnum.LAST_STATE, deleteEdgeRes.left().value());
- if (createEdgeRes != TitanOperationStatus.OK) {
- result = DaoStatusConverter.convertTitanStatusToStorageStatus(createEdgeRes);
+ JanusGraphOperationStatus
+ createEdgeRes = janusGraphDao
+ .createEdge(ownerVertex.getVertex(), toscaElementVertex.getVertex(), EdgeLabelEnum.LAST_STATE, deleteEdgeRes.left().value());
+ if (createEdgeRes != JanusGraphOperationStatus.OK) {
+ result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createEdgeRes);
}
}
}
GraphVertex clonedVertex = null;
if (result == null) {
clonedVertex = cloneResult.left().value();
- TitanOperationStatus status = titanDao.createEdge(toscaElementVertex.getVertex(), cloneResult.left().value().getVertex(), EdgeLabelEnum.VERSION, new HashMap<>());
- if (status != TitanOperationStatus.OK) {
+ JanusGraphOperationStatus
+ status = janusGraphDao
+ .createEdge(toscaElementVertex.getVertex(), cloneResult.left().value().getVertex(), EdgeLabelEnum.VERSION, new HashMap<>());
+ if (status != JanusGraphOperationStatus.OK) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create edge with label {} from vertex {} to tosca element vertex {} on graph. Status is {}. ", EdgeLabelEnum.VERSION,
toscaElementVertex.getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME), cloneResult.left().value().getMetadataProperty(GraphPropertyEnum.NORMALIZED_NAME), status);
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
}
}
if (result == null) {
if (!instInputs.isEmpty()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "before add inst inputs {} ", instInputs == null ? 0 : instInputs.size());
GraphVertex toscaDataVertex = null;
- Either<GraphVertex, TitanOperationStatus> instInpVertexEither = titanDao.getChildVertex(toscaElementVertex, EdgeLabelEnum.INST_INPUTS, JsonParseFlagEnum.ParseJson);
+ Either<GraphVertex, JanusGraphOperationStatus> instInpVertexEither = janusGraphDao
+ .getChildVertex(toscaElementVertex, EdgeLabelEnum.INST_INPUTS, JsonParseFlagEnum.ParseJson);
if (instInpVertexEither.isLeft()) {
toscaDataVertex = instInpVertexEither.left().value();
}
if (!instGroups.isEmpty()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "before add inst groups {} ", instGroups == null ? 0 : instGroups.size());
GraphVertex toscaDataVertex = null;
- Either<GraphVertex, TitanOperationStatus> instGrVertexEither = titanDao.getChildVertex(toscaElementVertex, EdgeLabelEnum.INST_GROUPS, JsonParseFlagEnum.ParseJson);
+ Either<GraphVertex, JanusGraphOperationStatus> instGrVertexEither = janusGraphDao
+ .getChildVertex(toscaElementVertex, EdgeLabelEnum.INST_GROUPS, JsonParseFlagEnum.ParseJson);
if (instGrVertexEither.isLeft()) {
toscaDataVertex = instGrVertexEither.left().value();
}
Map<String, CompositionDataDefinition> jsonComposition = (Map<String, CompositionDataDefinition>) clonedVertex.getJson();
CompositionDataDefinition compositionDataDefinition = jsonComposition.get(JsonConstantKeysEnum.COMPOSITION.getValue());
compositionDataDefinition.setComponentInstances(instancesMap);
- Either<GraphVertex, TitanOperationStatus> updateElement = titanDao.updateVertex(clonedVertex);
+ Either<GraphVertex, JanusGraphOperationStatus> updateElement = janusGraphDao.updateVertex(clonedVertex);
if (updateElement.isRight()) {
- TitanOperationStatus status = updateElement.right().value();
+ JanusGraphOperationStatus status = updateElement.right().value();
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update instances on metadata vertex . Status is {}. ", status);
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
return result;
}
}
}
}
if (result == null) {
- TitanOperationStatus status = titanDao.createEdge(previousCertifiedToscaElement, clonedToscaElement.getVertex(), EdgeLabelEnum.VERSION, new HashMap<>());
- if (status != TitanOperationStatus.OK) {
+ JanusGraphOperationStatus
+ status = janusGraphDao
+ .createEdge(previousCertifiedToscaElement, clonedToscaElement.getVertex(), EdgeLabelEnum.VERSION, new HashMap<>());
+ if (status != JanusGraphOperationStatus.OK) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create edge with label {} from vertex {} to tosca element vertex {} on graph. Status is {}. ", EdgeLabelEnum.VERSION,
previousCertifiedToscaElement.property(GraphPropertyEnum.UNIQUE_ID.getProperty()), clonedToscaElement.getUniqueId(), status);
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
}
}
Map<GraphPropertyEnum, Object> properties = new HashMap<>();
properties.put(GraphPropertyEnum.UUID, uuid);
properties.put(GraphPropertyEnum.NAME, componentName);
- Either<List<GraphVertex>, TitanOperationStatus> getToscaElementsRes = titanDao.getByCriteria(toscaElementVertex.getLabel(), properties, JsonParseFlagEnum.ParseMetadata);
+ Either<List<GraphVertex>, JanusGraphOperationStatus> getToscaElementsRes = janusGraphDao
+ .getByCriteria(toscaElementVertex.getLabel(), properties, JsonParseFlagEnum.ParseMetadata);
if (getToscaElementsRes.isRight()) {
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getToscaElementsRes.right().value()));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getToscaElementsRes.right().value()));
}
if (result == null) {
previosVersions = getToscaElementsRes.left().value();
Either<GraphVertex, StorageOperationStatus> result;
- Either<GraphVertex, TitanOperationStatus> updateVertexRes = titanDao.updateVertex(toscaElementVertex);
+ Either<GraphVertex, JanusGraphOperationStatus> updateVertexRes = janusGraphDao.updateVertex(toscaElementVertex);
if (updateVertexRes.isRight()) {
- TitanOperationStatus titatStatus = updateVertexRes.right().value();
+ JanusGraphOperationStatus titatStatus = updateVertexRes.right().value();
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update state of tosca element vertex {} metadata. Status is {}", toscaElementVertex.getUniqueId(), titatStatus);
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(titatStatus));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(titatStatus));
} else {
result = Either.left(updateVertexRes.left().value());
}
// In case of cancel "ready for certification" remove last state edge with "STATE" property equals to "NOT_CERTIFIED_CHECKIN"
Map<GraphPropertyEnum, Object> vertexProperties = new EnumMap<>(GraphPropertyEnum.class);
vertexProperties.put(GraphPropertyEnum.STATE, nextState);
- Either<Edge, TitanOperationStatus> deleteResult = titanDao.deleteBelongingEdgeByCriteria(toscaElementVertex, EdgeLabelEnum.LAST_STATE, vertexProperties);
+ Either<Edge, JanusGraphOperationStatus> deleteResult = janusGraphDao
+ .deleteBelongingEdgeByCriteria(toscaElementVertex, EdgeLabelEnum.LAST_STATE, vertexProperties);
if (deleteResult.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, faileToUpdateStateMsg, toscaElementVertex.getUniqueId(), deleteResult.right().value());
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "failed to update last state relation");
}
if (result == null) {
// Remove CHECKOUT relation
- Either<Edge, TitanOperationStatus> deleteEdgeResult = titanDao.deleteEdge(ownerVertex, toscaElementVertex, EdgeLabelEnum.STATE);
+ Either<Edge, JanusGraphOperationStatus> deleteEdgeResult = janusGraphDao
+ .deleteEdge(ownerVertex, toscaElementVertex, EdgeLabelEnum.STATE);
if (deleteEdgeResult.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, faileToUpdateStateMsg, toscaElementVertex.getUniqueId());
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(deleteEdgeResult.right().value()));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(deleteEdgeResult.right().value()));
}
}
if (result == null) {
// Create CHECKIN relation
Map<EdgePropertyEnum, Object> edgeProperties = new EnumMap<>(EdgePropertyEnum.class);
edgeProperties.put(EdgePropertyEnum.STATE, nextState);
- TitanOperationStatus createEdgeRes = titanDao.createEdge(modifierVertex.getVertex(), toscaElementVertex.getVertex(), EdgeLabelEnum.STATE, edgeProperties);
- if (createEdgeRes != TitanOperationStatus.OK) {
+ JanusGraphOperationStatus
+ createEdgeRes = janusGraphDao
+ .createEdge(modifierVertex.getVertex(), toscaElementVertex.getVertex(), EdgeLabelEnum.STATE, edgeProperties);
+ if (createEdgeRes != JanusGraphOperationStatus.OK) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, faileToUpdateStateMsg, toscaElementVertex.getUniqueId());
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(createEdgeRes));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createEdgeRes));
}
}
if (result == null) {
private Either<GraphVertex, StorageOperationStatus> updateLastModifierEdge(GraphVertex toscaElementVertex, GraphVertex ownerVertex, GraphVertex modifierVertex) {
Either<GraphVertex, StorageOperationStatus> result = null;
if (!modifierVertex.getMetadataProperties().get(GraphPropertyEnum.USERID).equals(ownerVertex.getMetadataProperties().get(GraphPropertyEnum.USERID))) {
- Either<Edge, TitanOperationStatus> deleteEdgeRes = titanDao.deleteEdge(ownerVertex, toscaElementVertex, EdgeLabelEnum.LAST_MODIFIER);
+ Either<Edge, JanusGraphOperationStatus> deleteEdgeRes = janusGraphDao
+ .deleteEdge(ownerVertex, toscaElementVertex, EdgeLabelEnum.LAST_MODIFIER);
if (deleteEdgeRes.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete last modifier {} to tosca element {}. Edge type is {}", ownerVertex.getUniqueId(), ownerVertex.getUniqueId(), EdgeLabelEnum.LAST_MODIFIER);
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(deleteEdgeRes.right().value()));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(deleteEdgeRes.right().value()));
}
if (result == null) {
- TitanOperationStatus createEdgeRes = titanDao.createEdge(modifierVertex.getVertex(), toscaElementVertex.getVertex(), EdgeLabelEnum.LAST_MODIFIER, new HashMap<>());
+ JanusGraphOperationStatus createEdgeRes = janusGraphDao
+ .createEdge(modifierVertex.getVertex(), toscaElementVertex.getVertex(), EdgeLabelEnum.LAST_MODIFIER, new HashMap<>());
- if (createEdgeRes != TitanOperationStatus.OK) {
+ if (createEdgeRes != JanusGraphOperationStatus.OK) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to associate user {} to component {}. Edge type is {}", modifierVertex.getUniqueId(), ownerVertex.getUniqueId(), EdgeLabelEnum.LAST_MODIFIER);
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(createEdgeRes));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createEdgeRes));
} else {
result = Either.left(modifierVertex);
}
GraphVertex modifier = null;
GraphVertex owner;
try {
- Either<Map<String, GraphVertex>, TitanOperationStatus> getVerticesRes = titanDao.getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId));
+ Either<Map<String, GraphVertex>, JanusGraphOperationStatus> getVerticesRes = janusGraphDao
+ .getVerticesByUniqueIdAndParseFlag(prepareParametersToGetVerticesForRequestCertification(toscaElementId, modifierId, ownerId));
if (getVerticesRes.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_GET_VERTICES, toscaElementId);
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getVerticesRes.right().value()));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getVerticesRes.right().value()));
}
if (result == null) {
toscaElement = getVerticesRes.left().value().get(toscaElementId);
private StorageOperationStatus handleRelationsUponForceCertification(GraphVertex toscaElement, GraphVertex modifier, GraphVertex owner) {
StorageOperationStatus result = null;
- TitanOperationStatus status = titanDao.replaceEdgeLabel(owner.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE);
- if (status != TitanOperationStatus.OK) {
- result = DaoStatusConverter.convertTitanStatusToStorageStatus(status);
+ JanusGraphOperationStatus status = janusGraphDao
+ .replaceEdgeLabel(owner.getVertex(), toscaElement.getVertex(), EdgeLabelEnum.STATE, EdgeLabelEnum.LAST_STATE);
+ if (status != JanusGraphOperationStatus.OK) {
+ result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
}
if (result == null) {
Map<EdgePropertyEnum, Object> properties = new EnumMap<>(EdgePropertyEnum.class);
properties.put(EdgePropertyEnum.STATE, LifecycleStateEnum.CERTIFIED);
- status = titanDao.createEdge(modifier, toscaElement, EdgeLabelEnum.STATE, properties);
- if (status != TitanOperationStatus.OK) {
+ status = janusGraphDao
+ .createEdge(modifier, toscaElement, EdgeLabelEnum.STATE, properties);
+ if (status != JanusGraphOperationStatus.OK) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "failed to create edge. Status is {}", status);
- result = DaoStatusConverter.convertTitanStatusToStorageStatus(status);
+ result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
}
}
if (result == null) {
return result;
}
- private StorageOperationStatus updateEdgeToCatalogRootByUndoCheckout(TitanVertex preV, GraphVertex curV) {
+ private StorageOperationStatus updateEdgeToCatalogRootByUndoCheckout(JanusGraphVertex preV, GraphVertex curV) {
if (preV == null) {
return updateEdgeToCatalogRoot(null, curV);
}
- String uniqueIdPreVer = (String) titanDao.getProperty((TitanVertex) preV, GraphPropertyEnum.UNIQUE_ID.getProperty());
- LifecycleStateEnum state = LifecycleStateEnum.findState((String) titanDao.getProperty(preV, GraphPropertyEnum.STATE.getProperty()));
+ String uniqueIdPreVer = (String) janusGraphDao
+ .getProperty((JanusGraphVertex) preV, GraphPropertyEnum.UNIQUE_ID.getProperty());
+ LifecycleStateEnum state = LifecycleStateEnum.findState((String) janusGraphDao
+ .getProperty(preV, GraphPropertyEnum.STATE.getProperty()));
if (state == LifecycleStateEnum.CERTIFIED) {
return updateEdgeToCatalogRoot(null, curV);
}
- return titanDao.getVertexById(uniqueIdPreVer)
+ return janusGraphDao.getVertexById(uniqueIdPreVer)
.either(l -> updateEdgeToCatalogRoot(l, curV),
- DaoStatusConverter::convertTitanStatusToStorageStatus);
+ DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
}
private StorageOperationStatus updateEdgeToCatalogRoot(GraphVertex newVersionV, GraphVertex prevVersionV) {
- Either<GraphVertex, TitanOperationStatus> catalog = titanDao.getVertexByLabel(VertexTypeEnum.CATALOG_ROOT);
+ Either<GraphVertex, JanusGraphOperationStatus> catalog = janusGraphDao.getVertexByLabel(VertexTypeEnum.CATALOG_ROOT);
if (catalog.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch catalog vertex. error {}", catalog.right().value());
- return DaoStatusConverter.convertTitanStatusToStorageStatus(catalog.right().value());
+ return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(catalog.right().value());
}
GraphVertex catalogV = catalog.left().value();
if (newVersionV != null) {
if ( isAbstract == null || !isAbstract ) {
// no new vertex, only delete previous
- TitanOperationStatus result = titanDao.createEdge(catalogV, newVersionV, EdgeLabelEnum.CATALOG_ELEMENT, null);
- if (result != TitanOperationStatus.OK) {
+ JanusGraphOperationStatus
+ result = janusGraphDao
+ .createEdge(catalogV, newVersionV, EdgeLabelEnum.CATALOG_ELEMENT, null);
+ if (result != JanusGraphOperationStatus.OK) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to create edge from {} to catalog vertex. error {}", newVersionV.getUniqueId(), result);
- return DaoStatusConverter.convertTitanStatusToStorageStatus(result);
+ return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(result);
}
}
}
Boolean isAbstract = (Boolean) prevVersionV.getMetadataProperty(GraphPropertyEnum.IS_ABSTRACT);
if (isAbstract == null || !isAbstract) {
// if prev == null -> new resource was added
- Either<Edge, TitanOperationStatus> deleteResult = titanDao.deleteEdge(catalogV, prevVersionV, EdgeLabelEnum.CATALOG_ELEMENT);
+ Either<Edge, JanusGraphOperationStatus> deleteResult = janusGraphDao
+ .deleteEdge(catalogV, prevVersionV, EdgeLabelEnum.CATALOG_ELEMENT);
if (deleteResult.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to delete edge from {} to catalog vertex. error {}", prevVersionV.getUniqueId(), deleteResult.right().value());
- return DaoStatusConverter.convertTitanStatusToStorageStatus(deleteResult.right().value());
+ return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(deleteResult.right().value());
}
}
}
Code Review / sdc.git / blobdiff