* ============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.openecomp.sdc.be.config.BeEcompErrorManager;
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.types.JsonParseFlagEnum;
import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
import org.openecomp.sdc.be.dao.jsongraph.utils.JsonParserUtils;
-import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
import org.openecomp.sdc.be.model.RequirementDefinition;
import org.openecomp.sdc.be.model.User;
-import org.openecomp.sdc.be.model.jsontitan.datamodel.NodeType;
-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.jsontitan.utils.ModelConverter;
+import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.NodeType;
+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.jsonjanusgraph.utils.ModelConverter;
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;
ComponentInstanceDataDefinition componentInstanceData = null;
Either<String, StorageOperationStatus> newInstanceNameRes = null;
- Either<GraphVertex, TitanOperationStatus> metadataVertex = titanDao.getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseJson);
+ Either<GraphVertex, JanusGraphOperationStatus> metadataVertex = janusGraphDao
+ .getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseJson);
if (metadataVertex.isRight()) {
- TitanOperationStatus status = metadataVertex.right().value();
- if (status == TitanOperationStatus.NOT_FOUND) {
- status = TitanOperationStatus.INVALID_ID;
+ JanusGraphOperationStatus status = metadataVertex.right().value();
+ if (status == JanusGraphOperationStatus.NOT_FOUND) {
+ status = JanusGraphOperationStatus.INVALID_ID;
}
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
}
if (result == null) {
Map<String, MapPropertiesDataDefinition> instPropertiesMap = new HashMap<>();
instPropertiesMap.put(componentInstance.getUniqueId(), instProperties);
updatedContainer.setInstProperties(instPropertiesMap);
- Either<GraphVertex, TitanOperationStatus> getToscaElementRes = titanDao.getVertexById(updatedContainer.getUniqueId(), JsonParseFlagEnum.NoParse);
+ Either<GraphVertex, JanusGraphOperationStatus> getToscaElementRes = janusGraphDao
+ .getVertexById(updatedContainer.getUniqueId(), JsonParseFlagEnum.NoParse);
if(getToscaElementRes.isLeft()){
deleteToscaDataDeepElementsBlockToToscaElement(getToscaElementRes.left().value(), EdgeLabelEnum.INST_PROPERTIES,
VertexTypeEnum.INST_PROPERTIES, componentInstance.getUniqueId());
String containerComponentId = container.getUniqueId();
CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to create component instance {} in component {}", componentInstance, containerComponentId);
String instOriginComponentId = componentInstance.getComponentUid();
- Either<GraphVertex, TitanOperationStatus> updateElement = null;
+ Either<GraphVertex, JanusGraphOperationStatus> updateElement = null;
Boolean isDeleted = (Boolean) originToscaElement.getMetadataValue(JsonPresentationFields.IS_DELETED);
container.addComponentInstance(componentInstance);
metadataVertex.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis());
topologyTemplateOperation.fillToscaElementVertexData(metadataVertex, container, JsonParseFlagEnum.ParseAll);
- updateElement = titanDao.updateVertex(metadataVertex);
+ updateElement = janusGraphDao.updateVertex(metadataVertex);
if (updateElement.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_UPDATE_TOPOLOGY_TEMPLATE_WITH_NEW_COMPONENT_INSTANCE, container.getName(), componentInstance.getName());
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateElement.right().value()));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateElement.right().value()));
}
}
if (result == null) {
CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to update component instance metadata {} of container component {}", componentInstance, containerComponentId);
ComponentInstanceDataDefinition componentInstanceData = null;
- Either<GraphVertex, TitanOperationStatus> metadataVertex = titanDao.getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseMetadata);
+ Either<GraphVertex, JanusGraphOperationStatus> metadataVertex = janusGraphDao
+ .getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseMetadata);
if (metadataVertex.isRight()) {
- TitanOperationStatus status = metadataVertex.right().value();
- if (status == TitanOperationStatus.NOT_FOUND) {
- status = TitanOperationStatus.INVALID_ID;
+ JanusGraphOperationStatus status = metadataVertex.right().value();
+ if (status == JanusGraphOperationStatus.NOT_FOUND) {
+ status = JanusGraphOperationStatus.INVALID_ID;
}
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
}
if (result == null) {
componentInstanceData = buildComponentInstanceDataDefinition(componentInstance, container.getUniqueId(), componentInstance.getName(), false, originToscaElement);
container.addComponentInstance(componentInstanceData);
metadataVertex.left().value().setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis());
topologyTemplateOperation.fillToscaElementVertexData(metadataVertex.left().value(), container, JsonParseFlagEnum.ParseAll);
- Either<GraphVertex, TitanOperationStatus> updateElement = titanDao.updateVertex(metadataVertex.left().value());
+ Either<GraphVertex, JanusGraphOperationStatus> updateElement = janusGraphDao
+ .updateVertex(metadataVertex.left().value());
if (updateElement.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_UPDATE_TOPOLOGY_TEMPLATE_WITH_NEW_COMPONENT_INSTANCE, container.getName(), componentInstance.getName());
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateElement.right().value()));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateElement.right().value()));
}
}
if (result == null) {
String containerComponentId = container.getUniqueId();
CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to update component instance metadata of container component {}", containerComponentId);
- Either<GraphVertex, TitanOperationStatus> metadataVertex = titanDao.getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseMetadata);
+ Either<GraphVertex, JanusGraphOperationStatus> metadataVertex = janusGraphDao
+ .getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseMetadata);
if (metadataVertex.isRight()) {
- TitanOperationStatus status = metadataVertex.right().value();
- if (status == TitanOperationStatus.NOT_FOUND) {
- status = TitanOperationStatus.INVALID_ID;
+ JanusGraphOperationStatus status = metadataVertex.right().value();
+ if (status == JanusGraphOperationStatus.NOT_FOUND) {
+ status = JanusGraphOperationStatus.INVALID_ID;
}
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
}
if (result == null) {
metadataVertex.left().value().setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis());
topologyTemplateOperation.fillToscaElementVertexData(metadataVertex.left().value(), container, JsonParseFlagEnum.ParseAll);
- Either<GraphVertex, TitanOperationStatus> updateElement = titanDao.updateVertex(metadataVertex.left().value());
+ Either<GraphVertex, JanusGraphOperationStatus> updateElement = janusGraphDao
+ .updateVertex(metadataVertex.left().value());
if (updateElement.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update topology template {}. ", container.getName());
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateElement.right().value()));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateElement.right().value()));
}
}
if (result == null) {
String containerComponentId = container.getUniqueId();
CommonUtility.addRecordToLog(log, LogLevelEnum.TRACE, "Going to update component instance metadata {} of container component {}", componentInstanceId, containerComponentId);
- Either<GraphVertex, TitanOperationStatus> metadataVertex = titanDao.getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseMetadata);
+ Either<GraphVertex, JanusGraphOperationStatus> metadataVertex = janusGraphDao
+ .getVertexById(container.getUniqueId(), JsonParseFlagEnum.ParseMetadata);
if (metadataVertex.isRight()) {
- TitanOperationStatus status = metadataVertex.right().value();
- if (status == TitanOperationStatus.NOT_FOUND) {
- status = TitanOperationStatus.INVALID_ID;
+ JanusGraphOperationStatus status = metadataVertex.right().value();
+ if (status == JanusGraphOperationStatus.NOT_FOUND) {
+ status = JanusGraphOperationStatus.INVALID_ID;
}
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
}
GraphVertex containerV = null;
ComponentInstanceDataDefinition removedComponentInstance = null;
containerV.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis());
topologyTemplateOperation.fillToscaElementVertexData(containerV, container, JsonParseFlagEnum.ParseAll);
- Either<GraphVertex, TitanOperationStatus> updateElement = titanDao.updateVertex(containerV);
+ Either<GraphVertex, JanusGraphOperationStatus> updateElement = janusGraphDao.updateVertex(containerV);
if (updateElement.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_UPDATE_TOPOLOGY_TEMPLATE_WITH_NEW_COMPONENT_INSTANCE, container.getName(), componentInstanceId);
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateElement.right().value()));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateElement.right().value()));
}
}
if (result == null) {
@SuppressWarnings({ "unchecked" })
public <T extends ToscaDataDefinition> Either<List<RequirementCapabilityRelDef>, StorageOperationStatus> associateResourceInstances(String componentId, List<RequirementCapabilityRelDef> relations) {
- Either<GraphVertex, TitanOperationStatus> containerVEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseAll);
+ Either<GraphVertex, JanusGraphOperationStatus> containerVEither = janusGraphDao
+ .getVertexById(componentId, JsonParseFlagEnum.ParseAll);
if (containerVEither.isRight()) {
- TitanOperationStatus error = containerVEither.right().value();
+ JanusGraphOperationStatus error = containerVEither.right().value();
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_FETCH_CONTAINER_VERTEX_ERROR, componentId, error);
- return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error));
+ return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error));
}
GraphVertex containerV = containerVEither.left().value();
Either<Pair<GraphVertex, Map<String, MapListCapabilityDataDefinition>>, StorageOperationStatus> capResult = fetchContainerCalculatedCapability(containerV, EdgeLabelEnum.CALCULATED_CAPABILITIES);
if (relationships == null || relationships.isEmpty()) {
BeEcompErrorManager.getInstance().logBeFailedAddingResourceInstanceError("AssociateResourceInstances - missing relationship", fromNode, componentId);
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "No requirement definition sent in order to set the relation between {} to {}", fromNode, toNode);
- return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(TitanOperationStatus.ILLEGAL_ARGUMENT));
+ return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(
+ JanusGraphOperationStatus.ILLEGAL_ARGUMENT));
}
for (CapabilityRequirementRelationship immutablePair : relationships) {
Either<Pair<GraphVertex, Map<String, MapListCapabilityDataDefinition>>, StorageOperationStatus> capFullResult, Either<Pair<GraphVertex, Map<String, MapListRequirementDataDefinition>>, StorageOperationStatus> reqResult,
Either<Pair<GraphVertex, Map<String, MapListRequirementDataDefinition>>, StorageOperationStatus> reqFullResult) {
containerV.setJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE, System.currentTimeMillis());
- Either<GraphVertex, TitanOperationStatus> updateElement = titanDao.updateVertex(containerV);
+ Either<GraphVertex, JanusGraphOperationStatus> updateElement = janusGraphDao.updateVertex(containerV);
if (updateElement.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update topology template {} with new relations error {}. ", componentId, updateElement.right().value());
- return DaoStatusConverter.convertTitanStatusToStorageStatus(updateElement.right().value());
+ return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateElement.right().value());
}
// update cap/req jsons, fulfilled cap/req jsons!!!!!
- Either<GraphVertex, TitanOperationStatus> status;
+ Either<GraphVertex, JanusGraphOperationStatus> status;
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Update calculated capabilty for container {}", containerV.getUniqueId());
status = updateOrCopyOnUpdate(capResult.left().value().getLeft(), containerV, EdgeLabelEnum.CALCULATED_CAPABILITIES);
if (status.isRight()) {
- TitanOperationStatus error = status.right().value();
+ JanusGraphOperationStatus error = status.right().value();
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update calculated capabilty for container {} error {}", containerV.getUniqueId(), error);
- return DaoStatusConverter.convertTitanStatusToStorageStatus(error);
+ return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error);
}
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Update calculated requirement for container {}", containerV.getUniqueId());
status = updateOrCopyOnUpdate(reqResult.left().value().getLeft(), containerV, EdgeLabelEnum.CALCULATED_REQUIREMENTS);
if (status.isRight()) {
- TitanOperationStatus error = status.right().value();
+ JanusGraphOperationStatus error = status.right().value();
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update calculated requiremnt for container {} error {}", containerV.getUniqueId(), error);
- return DaoStatusConverter.convertTitanStatusToStorageStatus(error);
+ return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error);
}
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Update fullfilled capabilty for container {}", containerV.getUniqueId());
status = updateOrCopyOnUpdate(capFullResult.left().value().getLeft(), containerV, EdgeLabelEnum.FULLFILLED_CAPABILITIES);
if (status.isRight()) {
- TitanOperationStatus error = status.right().value();
+ JanusGraphOperationStatus error = status.right().value();
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update fullfilled capabilty for container {} error {}", containerV.getUniqueId(), error);
- return DaoStatusConverter.convertTitanStatusToStorageStatus(error);
+ return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error);
}
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Update fullfilled requirement for container {}", containerV.getUniqueId());
status = updateOrCopyOnUpdate(reqFullResult.left().value().getLeft(), containerV, EdgeLabelEnum.FULLFILLED_REQUIREMENTS);
if (status.isRight()) {
- TitanOperationStatus error = status.right().value();
+ JanusGraphOperationStatus error = status.right().value();
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update fullfilled requirement for container {} error {}", containerV.getUniqueId(), error);
- return DaoStatusConverter.convertTitanStatusToStorageStatus(error);
+ return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error);
}
return StorageOperationStatus.OK;
}
String fromResInstanceUid = requirementDef.getFromNode();
String toResInstanceUid = requirementDef.getToNode();
- Either<GraphVertex, TitanOperationStatus> containerVEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseAll);
+ Either<GraphVertex, JanusGraphOperationStatus> containerVEither = janusGraphDao
+ .getVertexById(componentId, JsonParseFlagEnum.ParseAll);
if (containerVEither.isRight()) {
- TitanOperationStatus error = containerVEither.right().value();
+ JanusGraphOperationStatus error = containerVEither.right().value();
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_FETCH_CONTAINER_VERTEX_ERROR, componentId, error);
- return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error));
+ return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error));
}
GraphVertex containerV = containerVEither.left().value();
MapListRequirementDataDefinition reqMapOfLists = null;
Optional<RequirementDataDefinition> foundRequirement;
RelationshipInfo relationshipInfo = foundRelation.resolveSingleRelationship().getRelation();
- Either<GraphVertex, TitanOperationStatus> containerVEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseAll);
+ Either<GraphVertex, JanusGraphOperationStatus> containerVEither = janusGraphDao
+ .getVertexById(componentId, JsonParseFlagEnum.ParseAll);
if (containerVEither.isRight()) {
- TitanOperationStatus error = containerVEither.right().value();
+ JanusGraphOperationStatus error = containerVEither.right().value();
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_FETCH_CONTAINER_VERTEX_ERROR, componentId, error);
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error));
}
if (result == null) {
GraphVertex containerV = containerVEither.left().value();
Optional<CapabilityDataDefinition> foundRequirement;
RelationshipInfo relationshipInfo = foundRelation.resolveSingleRelationship().getRelation();
- Either<GraphVertex, TitanOperationStatus> containerVEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseAll);
+ Either<GraphVertex, JanusGraphOperationStatus> containerVEither = janusGraphDao
+ .getVertexById(componentId, JsonParseFlagEnum.ParseAll);
if (containerVEither.isRight()) {
- TitanOperationStatus error = containerVEither.right().value();
+ JanusGraphOperationStatus error = containerVEither.right().value();
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, FAILED_TO_FETCH_CONTAINER_VERTEX_ERROR, componentId, error);
- result = Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error));
+ result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error));
}
if (result == null) {
GraphVertex containerV = containerVEither.left().value();
private Either<Pair<GraphVertex, Map<String, MapListCapabilityDataDefinition>>, StorageOperationStatus> fetchContainerCalculatedCapability(GraphVertex containerV, EdgeLabelEnum capLabel) {
- Either<Pair<GraphVertex, Map<String, MapListCapabilityDataDefinition>>, TitanOperationStatus> calculatedCapabiltyEither = getDataAndVertexFromGraph(containerV, capLabel);
+ Either<Pair<GraphVertex, Map<String, MapListCapabilityDataDefinition>>, JanusGraphOperationStatus> calculatedCapabiltyEither = getDataAndVertexFromGraph(containerV, capLabel);
if (calculatedCapabiltyEither.isRight()) {
- TitanOperationStatus error = calculatedCapabiltyEither.right().value();
+ JanusGraphOperationStatus error = calculatedCapabiltyEither.right().value();
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch calculated capabilties for container {}.", containerV.getUniqueId(), error);
- return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error));
+ return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error));
}
Pair<GraphVertex, Map<String, MapListCapabilityDataDefinition>> calculatedCapabilty = calculatedCapabiltyEither.left().value();
return Either.left(calculatedCapabilty);
}
private Either<Pair<GraphVertex, Map<String, MapListRequirementDataDefinition>>, StorageOperationStatus> fetchContainerCalculatedRequirement(GraphVertex containerV, EdgeLabelEnum reqLabel) {
- Either<Pair<GraphVertex, Map<String, MapListRequirementDataDefinition>>, TitanOperationStatus> calculatedRequirementEither = getDataAndVertexFromGraph(containerV, reqLabel);
+ Either<Pair<GraphVertex, Map<String, MapListRequirementDataDefinition>>, JanusGraphOperationStatus> calculatedRequirementEither = getDataAndVertexFromGraph(containerV, reqLabel);
if (calculatedRequirementEither.isRight()) {
- TitanOperationStatus error = calculatedRequirementEither.right().value();
+ JanusGraphOperationStatus error = calculatedRequirementEither.right().value();
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to fetch calculated requirements for container {}.", containerV.getUniqueId(), error);
- return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(error));
+ return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(error));
}
Pair<GraphVertex, Map<String, MapListRequirementDataDefinition>> calculatedRequirement = calculatedRequirementEither.left().value();
return Either.left(calculatedRequirement);
StorageOperationStatus result = null;
String containerId = containerComponent.getUniqueId();
Map<String, ComponentInstanceDataDefinition> instancesJsonData = null;
- Either<GraphVertex, TitanOperationStatus> updateElement = null;
+ Either<GraphVertex, JanusGraphOperationStatus> updateElement = null;
if (!validateInstanceNames(componentInstanceTMap)) {
result = StorageOperationStatus.INCONSISTENCY;
}
composition.setComponentInstances(instancesJsonData);
compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), composition);
containerVertex.setJson(compositions);
- updateElement = titanDao.updateVertex(containerVertex);
+ updateElement = janusGraphDao.updateVertex(containerVertex);
if (updateElement.isRight()) {
CommonUtility.addRecordToLog(log, LogLevelEnum.DEBUG, "Failed to update topology template {} with new component instances. ", containerComponent.getName());
- result = DaoStatusConverter.convertTitanStatusToStorageStatus(updateElement.right().value());
+ result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateElement.right().value());
}
}
if (result == null && updateElement != null) {
}
public StorageOperationStatus addArtifactsToInstance(String toscaElementId, String instanceId, Map<String, ArtifactDataDefinition> instDeplArtifacts, EdgeLabelEnum edgeLabel, VertexTypeEnum vertexType) {
- Either<GraphVertex, TitanOperationStatus> metadataVertex = titanDao.getVertexById(toscaElementId, JsonParseFlagEnum.NoParse);
+ Either<GraphVertex, JanusGraphOperationStatus> metadataVertex = janusGraphDao
+ .getVertexById(toscaElementId, JsonParseFlagEnum.NoParse);
if (metadataVertex.isRight()) {
- TitanOperationStatus status = metadataVertex.right().value();
- if (status == TitanOperationStatus.NOT_FOUND) {
- status = TitanOperationStatus.INVALID_ID;
+ JanusGraphOperationStatus status = metadataVertex.right().value();
+ if (status == JanusGraphOperationStatus.NOT_FOUND) {
+ status = JanusGraphOperationStatus.INVALID_ID;
}
- return DaoStatusConverter.convertTitanStatusToStorageStatus(status);
+ return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
}
MapArtifactDataDefinition instArtifacts = new MapArtifactDataDefinition(instDeplArtifacts);
return addToscaDataDeepElementsBlockToToscaElement(metadataVertex.left().value(), edgeLabel, vertexType, instArtifacts, instanceId);
@SuppressWarnings({ "unchecked" })
public StorageOperationStatus generateCustomizationUUIDOnInstance(String componentId, String instanceId) {
- Either<GraphVertex, TitanOperationStatus> metadataVertex = titanDao.getVertexById(componentId, JsonParseFlagEnum.ParseAll);
+ Either<GraphVertex, JanusGraphOperationStatus> metadataVertex = janusGraphDao
+ .getVertexById(componentId, JsonParseFlagEnum.ParseAll);
if (metadataVertex.isRight()) {
- TitanOperationStatus status = metadataVertex.right().value();
- if (status == TitanOperationStatus.NOT_FOUND) {
- status = TitanOperationStatus.INVALID_ID;
+ JanusGraphOperationStatus status = metadataVertex.right().value();
+ if (status == JanusGraphOperationStatus.NOT_FOUND) {
+ status = JanusGraphOperationStatus.INVALID_ID;
}
- return DaoStatusConverter.convertTitanStatusToStorageStatus(status);
+ return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
}
GraphVertex metaVertex = metadataVertex.left().value();
Map<String, CompositionDataDefinition> json = (Map<String, CompositionDataDefinition>) metaVertex.getJson();
log.debug("Failed to update customization UUID for instance {} in component {} error {}", instanceId, componentId, status);
return status;
}
- Either<GraphVertex, TitanOperationStatus> updateVertex = titanDao.updateVertex(metaVertex);
+ Either<GraphVertex, JanusGraphOperationStatus> updateVertex = janusGraphDao.updateVertex(metaVertex);
if (updateVertex.isRight()) {
log.debug("Failed to update vertex of component {} error {}", componentId, updateVertex.right().value());
- return DaoStatusConverter.convertTitanStatusToStorageStatus(updateVertex.right().value());
+ return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateVertex.right().value());
}
return StorageOperationStatus.OK;
}
public StorageOperationStatus generateCustomizationUUIDOnInstanceGroup(String componentId, String instanceId, List<String> groupInstances) {
if (groupInstances != null) {
- Either<Map<String, MapGroupsDataDefinition>, TitanOperationStatus> dataFromGraph = getDataFromGraph(componentId, EdgeLabelEnum.INST_GROUPS);
+ Either<Map<String, MapGroupsDataDefinition>, JanusGraphOperationStatus> dataFromGraph = getDataFromGraph(componentId, EdgeLabelEnum.INST_GROUPS);
if (dataFromGraph.isRight()) {
- return DaoStatusConverter.convertTitanStatusToStorageStatus(dataFromGraph.right().value());
+ return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(dataFromGraph.right().value());
}
MapGroupsDataDefinition grInstPerInstance = dataFromGraph.left().value().get(instanceId);
if (grInstPerInstance == null) {
// create edge between container and origin ( in case of proxy this edge will be to ProxyService node type)
StorageOperationStatus result = createOrUpdateInstanceEdge(metadataVertex, EdgeLabelEnum.INSTANCE_OF, componentInstance.getComponentUid(), instUniqueId).either(v -> StorageOperationStatus.OK,
- DaoStatusConverter::convertTitanStatusToStorageStatus);
+ DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
if (result == StorageOperationStatus.OK && componentInstance.getIsProxy()) {
// create edge between container and service origin
result = createOrUpdateInstanceEdge(metadataVertex, EdgeLabelEnum.PROXY_OF, componentInstance.getSourceModelUid(), instUniqueId)
- .either(v -> StorageOperationStatus.OK, DaoStatusConverter::convertTitanStatusToStorageStatus);
+ .either(v -> StorageOperationStatus.OK, DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
}
return result;
}
public StorageOperationStatus createAllottedOfEdge(String componentId, String instanceId, String serviceUUID) {
- Either<GraphVertex, TitanOperationStatus> vertexById = titanDao.getVertexById(componentId);
+ Either<GraphVertex, JanusGraphOperationStatus> vertexById = janusGraphDao.getVertexById(componentId);
if ( vertexById.isRight() ){
log.debug("Failed to fetch component metadata vertex for id {} error {}", componentId, vertexById.right().value());
- return DaoStatusConverter.convertTitanStatusToStorageStatus(vertexById.right().value());
+ return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(vertexById.right().value());
}
GraphVertex metadataVertex = vertexById.left().value();
EnumMap<GraphPropertyEnum, Object> hasNot = new EnumMap<>(GraphPropertyEnum.class);
hasNot.put(GraphPropertyEnum.IS_DELETED, true);
- Either<List<GraphVertex>, TitanOperationStatus> byCriteria = titanDao.getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, props,hasNot, JsonParseFlagEnum.ParseMetadata );
+ Either<List<GraphVertex>, JanusGraphOperationStatus> byCriteria = janusGraphDao
+ .getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, props,hasNot, JsonParseFlagEnum.ParseMetadata );
if ( byCriteria.isRight() ){
log.debug("Failed to fetch vertex by criteria {} error {}", props, byCriteria.right().value());
- return DaoStatusConverter.convertTitanStatusToStorageStatus(byCriteria.right().value());
+ return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(byCriteria.right().value());
}
List<GraphVertex> vertecies = byCriteria.left().value();
StorageOperationStatus result = StorageOperationStatus.OK;
log.debug("Try to create or update edge between resource {} and service {} ", metadataVertex, serviceVertex.getUniqueId());
// create edge between container and service reference
result = createOrUpdateInstanceEdge(metadataVertex, EdgeLabelEnum.ALLOTTED_OF, serviceVertex.getUniqueId(), instanceId).either(v -> StorageOperationStatus.OK,
- DaoStatusConverter::convertTitanStatusToStorageStatus);
+ DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
}
return result;
}
// create edge between container and origin ( in case of proxy this edge will be to ProxyService node type)
StorageOperationStatus result = removeOrUpdateInstanceEdge(metadataVertex, EdgeLabelEnum.INSTANCE_OF, componentInstance.getComponentUid(), instUniqueId)
.either(v -> StorageOperationStatus.OK,
- DaoStatusConverter::convertTitanStatusToStorageStatus);
+ DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
if (componentInstance.getIsProxy()) {
// create edge between container and service origin
result = removeOrUpdateInstanceEdge(metadataVertex, EdgeLabelEnum.PROXY_OF, componentInstance.getSourceModelUid(), instUniqueId)
- .either(v -> StorageOperationStatus.OK, DaoStatusConverter::convertTitanStatusToStorageStatus);
+ .either(v -> StorageOperationStatus.OK, DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
}
return result;
}
- private Either<GraphVertex, TitanOperationStatus> createOrUpdateInstanceEdge(GraphVertex metadataVertex, EdgeLabelEnum edgeLabel, String componentUid, String instUniqueId) {
+ private Either<GraphVertex, JanusGraphOperationStatus> createOrUpdateInstanceEdge(GraphVertex metadataVertex, EdgeLabelEnum edgeLabel, String componentUid, String instUniqueId) {
Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
properties.put(GraphPropertyEnum.UNIQUE_ID, componentUid);
- return titanDao.getEdgeByChildrenVertexProperties(metadataVertex, edgeLabel, properties)
+ return janusGraphDao.getEdgeByChildrenVertexProperties(metadataVertex, edgeLabel, properties)
.left()
.bind(v -> addInstanceToPropertyOnEdge(instUniqueId, v, metadataVertex))
.right()
.bind(s -> createInstanceEdge(metadataVertex, edgeLabel, componentUid, instUniqueId, s));
}
- private Either<GraphVertex, TitanOperationStatus> removeOrUpdateInstanceEdge(GraphVertex metadataVertex, EdgeLabelEnum edgeLabel, String componentUid, String instUniqueId) {
+ private Either<GraphVertex, JanusGraphOperationStatus> removeOrUpdateInstanceEdge(GraphVertex metadataVertex, EdgeLabelEnum edgeLabel, String componentUid, String instUniqueId) {
Map<GraphPropertyEnum, Object> properties = new EnumMap<>(GraphPropertyEnum.class);
properties.put(GraphPropertyEnum.UNIQUE_ID, componentUid);
- return titanDao.getEdgeByChildrenVertexProperties(metadataVertex, edgeLabel, properties).left().bind(v -> removeInstanceFromPropertyOnEdge(instUniqueId, v, metadataVertex)).right()
+ return janusGraphDao.getEdgeByChildrenVertexProperties(metadataVertex, edgeLabel, properties).left().bind(v -> removeInstanceFromPropertyOnEdge(instUniqueId, v, metadataVertex)).right()
.map(err -> removeInstanceEdgeLogError(metadataVertex, edgeLabel, componentUid, err));
}
- private Either<GraphVertex, TitanOperationStatus> addInstanceToPropertyOnEdge(String instUniqueId, Edge edge, GraphVertex metadataVertex) {
+ private Either<GraphVertex, JanusGraphOperationStatus> addInstanceToPropertyOnEdge(String instUniqueId, Edge edge, GraphVertex metadataVertex) {
// edge exist need to add instance id to list on edge's property
- List<String> property = (List<String>) titanDao.getProperty(edge, EdgePropertyEnum.INSTANCES);
+ List<String> property = (List<String>) janusGraphDao.getProperty(edge, EdgePropertyEnum.INSTANCES);
if (property == null) {
property = new ArrayList<>();
}
edge.property(EdgePropertyEnum.INSTANCES.getProperty(), jsonArr);
} catch (IOException e) {
log.debug("Failed to convert INSTANCES edge property to json for container {}", metadataVertex.getUniqueId(), e );
- return Either.right(TitanOperationStatus.GENERAL_ERROR);
+ return Either.right(JanusGraphOperationStatus.GENERAL_ERROR);
}
return Either.left(metadataVertex);
}
- private Either<GraphVertex, TitanOperationStatus> removeInstanceFromPropertyOnEdge(String instUniqueId, Edge edge, GraphVertex metadataVertex) {
+ private Either<GraphVertex, JanusGraphOperationStatus> removeInstanceFromPropertyOnEdge(String instUniqueId, Edge edge, GraphVertex metadataVertex) {
// edge exist need to add instance id to list on edge's property
- List<String> property = (List<String>) titanDao.getProperty(edge, EdgePropertyEnum.INSTANCES);
+ List<String> property = (List<String>) janusGraphDao.getProperty(edge, EdgePropertyEnum.INSTANCES);
if (property == null) {
property = new ArrayList<>();
}
edge.property(EdgePropertyEnum.INSTANCES.getProperty(), jsonArr);
} catch (IOException e) {
log.debug("Failed to convert INSTANCES edge property to json for container {}", metadataVertex.getUniqueId(), e );
- return Either.right(TitanOperationStatus.GENERAL_ERROR);
+ return Either.right(JanusGraphOperationStatus.GENERAL_ERROR);
}
}
return Either.left(metadataVertex);
}
- private Either<GraphVertex, TitanOperationStatus> createInstanceEdge(GraphVertex metadataVertex, EdgeLabelEnum edgeLabel, String componentUid, String instUniqueId, TitanOperationStatus retrieveEdgeStatus) {
- if (retrieveEdgeStatus == TitanOperationStatus.NOT_FOUND) {
+ private Either<GraphVertex, JanusGraphOperationStatus> createInstanceEdge(GraphVertex metadataVertex, EdgeLabelEnum edgeLabel, String componentUid, String instUniqueId, JanusGraphOperationStatus retrieveEdgeStatus) {
+ if (retrieveEdgeStatus == JanusGraphOperationStatus.NOT_FOUND) {
// create new edge
- Either<GraphVertex, TitanOperationStatus> vertexById = titanDao.getVertexById(componentUid);
+ Either<GraphVertex, JanusGraphOperationStatus> vertexById = janusGraphDao.getVertexById(componentUid);
if (vertexById.isRight()) {
return vertexById;
}
edgeProps.put(EdgePropertyEnum.INSTANCES, instList);
log.debug("Create new edge {} between {} and {} and properties {} ", edgeLabel, metadataVertex.getUniqueId(), originVertex.getUniqueId(), edgeProps);
- TitanOperationStatus edgeResult = titanDao.createEdge(metadataVertex, originVertex, edgeLabel, edgeProps);
- return edgeResult == TitanOperationStatus.OK ? Either.left(metadataVertex) : Either.right(edgeResult);
+ JanusGraphOperationStatus
+ edgeResult = janusGraphDao
+ .createEdge(metadataVertex, originVertex, edgeLabel, edgeProps);
+ return edgeResult == JanusGraphOperationStatus.OK ? Either.left(metadataVertex) : Either.right(edgeResult);
}
// error
log.debug("Failed to fetch edge with label {} and to vertex with id {} error {} ", edgeLabel, componentUid, retrieveEdgeStatus);
return Either.right(retrieveEdgeStatus);
}
- private TitanOperationStatus removeInstanceEdgeLogError(GraphVertex metadataVertex, EdgeLabelEnum edgeLabel, String componentUid, TitanOperationStatus retrieveEdgeStatus) {
- if (retrieveEdgeStatus == TitanOperationStatus.NOT_FOUND) {
+ private JanusGraphOperationStatus removeInstanceEdgeLogError(GraphVertex metadataVertex, EdgeLabelEnum edgeLabel, String componentUid, JanusGraphOperationStatus retrieveEdgeStatus) {
+ if (retrieveEdgeStatus == JanusGraphOperationStatus.NOT_FOUND) {
log.debug("No edge {} to remove between container {} and origin {}", edgeLabel, metadataVertex.getUniqueId(), componentUid);
} else {
// error
}
public void removeAllAllotedEdges(String uniqueId) {
- Either<GraphVertex, TitanOperationStatus> vertexById = titanDao.getVertexById(uniqueId);
+ Either<GraphVertex, JanusGraphOperationStatus> vertexById = janusGraphDao.getVertexById(uniqueId);
if (vertexById.isLeft()) {
GraphVertex originVertex = vertexById.left().value();
- TitanVertex vertex = originVertex.getVertex();
+ JanusGraphVertex vertex = originVertex.getVertex();
Iterator<Edge> edges = vertex.edges(Direction.OUT, EdgeLabelEnum.ALLOTTED_OF.name());
while ( edges != null && edges.hasNext() ){
Edge edge = edges.next();