Upgrade SDC from Titan to Janus Graph

[sdc.git] / catalog-model / src / main / java / org / openecomp / sdc / be / model / operations / impl / HeatParametersOperation.java

diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperation.java
index 6d050af..823c33a 100644 (file)
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperation.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperation.java
@@ -25,10 +25,10 @@ import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.apache.tinkerpop.gremlin.structure.Edge;
 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.JanusGraphGenericDao;
+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.dao.titan.TitanGenericDao;
-import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
 import org.openecomp.sdc.be.model.HeatParameterDefinition;
 import org.openecomp.sdc.be.model.heat.HeatParameterType;
@@ -55,27 +55,28 @@ public class HeatParametersOperation implements IHeatParametersOperation {
     private static final Logger log = Logger.getLogger(HeatParametersOperation.class.getName());
 
     @javax.annotation.Resource
-    private TitanGenericDao titanGenericDao;
+    private JanusGraphGenericDao janusGraphGenericDao;
 
-    public TitanGenericDao getTitanGenericDao() {
-        return titanGenericDao;
+    public JanusGraphGenericDao getJanusGraphGenericDao() {
+        return janusGraphGenericDao;
     }
 
-    public void setTitanGenericDao(TitanGenericDao titanGenericDao) {
-        this.titanGenericDao = titanGenericDao;
+    public void setJanusGraphGenericDao(JanusGraphGenericDao janusGraphGenericDao) {
+        this.janusGraphGenericDao = janusGraphGenericDao;
     }
 
     public StorageOperationStatus getHeatParametersOfNode(NodeTypeEnum nodeType, String uniqueId, List<HeatParameterDefinition> properties) {
 
-        Either<List<ImmutablePair<HeatParameterData, GraphEdge>>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(nodeType), uniqueId, GraphEdgeLabels.HEAT_PARAMETER, NodeTypeEnum.HeatParameter,
+        Either<List<ImmutablePair<HeatParameterData, GraphEdge>>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao
+            .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(nodeType), uniqueId, GraphEdgeLabels.HEAT_PARAMETER, NodeTypeEnum.HeatParameter,
                 HeatParameterData.class);
 
         if (childrenNodes.isRight()) {
-            TitanOperationStatus status = childrenNodes.right().value();
-            if (status == TitanOperationStatus.NOT_FOUND) {
-                status = TitanOperationStatus.OK;
+            JanusGraphOperationStatus status = childrenNodes.right().value();
+            if (status == JanusGraphOperationStatus.NOT_FOUND) {
+                status = JanusGraphOperationStatus.OK;
             }
-            return DaoStatusConverter.convertTitanStatusToStorageStatus(status);
+            return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
         }
 
         List<ImmutablePair<HeatParameterData, GraphEdge>> values = childrenNodes.left().value();
@@ -103,15 +104,16 @@ public class HeatParametersOperation implements IHeatParametersOperation {
 
     public StorageOperationStatus getParametersValueNodes(NodeTypeEnum parentNodeType, String parentUniqueId, List<HeatParameterValueData> heatValues) {
 
-        Either<List<ImmutablePair<HeatParameterValueData, GraphEdge>>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(parentNodeType), parentUniqueId, GraphEdgeLabels.PARAMETER_VALUE,
+        Either<List<ImmutablePair<HeatParameterValueData, GraphEdge>>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao
+            .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(parentNodeType), parentUniqueId, GraphEdgeLabels.PARAMETER_VALUE,
                 NodeTypeEnum.HeatParameterValue, HeatParameterValueData.class);
 
         if (childrenNodes.isRight()) {
-            TitanOperationStatus status = childrenNodes.right().value();
-            if (status == TitanOperationStatus.NOT_FOUND) {
-                status = TitanOperationStatus.OK;
+            JanusGraphOperationStatus status = childrenNodes.right().value();
+            if (status == JanusGraphOperationStatus.NOT_FOUND) {
+                status = JanusGraphOperationStatus.OK;
             }
-            return DaoStatusConverter.convertTitanStatusToStorageStatus(status);
+            return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
         }
 
         List<ImmutablePair<HeatParameterValueData, GraphEdge>> values = childrenNodes.left().value();
@@ -144,14 +146,14 @@ public class HeatParametersOperation implements IHeatParametersOperation {
         for (HeatParameterDefinition propertyDefinition : heatParams) {
 
             String propertyUid = propertyDefinition.getUniqueId();
-            Either<HeatParameterData, TitanOperationStatus> deletePropertyRes = deleteHeatParameterFromGraph(propertyUid);
+            Either<HeatParameterData, JanusGraphOperationStatus> deletePropertyRes = deleteHeatParameterFromGraph(propertyUid);
             if (deletePropertyRes.isRight()) {
                 log.error("Failed to delete heat parameter with id {}", propertyUid);
-                TitanOperationStatus status = deletePropertyRes.right().value();
-                if (status == TitanOperationStatus.NOT_FOUND) {
-                    status = TitanOperationStatus.INVALID_ID;
+                JanusGraphOperationStatus status = deletePropertyRes.right().value();
+                if (status == JanusGraphOperationStatus.NOT_FOUND) {
+                    status = JanusGraphOperationStatus.INVALID_ID;
                 }
-                return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status));
+                return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
             }
 
         }
@@ -173,14 +175,14 @@ public class HeatParametersOperation implements IHeatParametersOperation {
         for (HeatParameterValueData propertyDefinition : heatValues) {
 
             String propertyUid = (String) propertyDefinition.getUniqueId();
-            Either<HeatParameterValueData, TitanOperationStatus> deletePropertyRes = deleteHeatParameterValueFromGraph(propertyUid);
+            Either<HeatParameterValueData, JanusGraphOperationStatus> deletePropertyRes = deleteHeatParameterValueFromGraph(propertyUid);
             if (deletePropertyRes.isRight()) {
                 log.error("Failed to delete heat parameter value with id {}", propertyUid);
-                TitanOperationStatus status = deletePropertyRes.right().value();
-                if (status == TitanOperationStatus.NOT_FOUND) {
-                    status = TitanOperationStatus.INVALID_ID;
+                JanusGraphOperationStatus status = deletePropertyRes.right().value();
+                if (status == JanusGraphOperationStatus.NOT_FOUND) {
+                    status = JanusGraphOperationStatus.INVALID_ID;
                 }
-                return DaoStatusConverter.convertTitanStatusToStorageStatus(status);
+                return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
             }
 
         }
@@ -189,14 +191,15 @@ public class HeatParametersOperation implements IHeatParametersOperation {
         return StorageOperationStatus.OK;
     }
 
-    private Either<HeatParameterData, TitanOperationStatus> deleteHeatParameterFromGraph(String propertyId) {
+    private Either<HeatParameterData, JanusGraphOperationStatus> deleteHeatParameterFromGraph(String propertyId) {
         log.debug("Before deleting heat parameter from graph {}" , propertyId);
-        return titanGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.HeatParameter), propertyId, HeatParameterData.class);
+        return janusGraphGenericDao
+            .deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.HeatParameter), propertyId, HeatParameterData.class);
     }
 
-    private Either<HeatParameterValueData, TitanOperationStatus> deleteHeatParameterValueFromGraph(String propertyId) {
+    private Either<HeatParameterValueData, JanusGraphOperationStatus> deleteHeatParameterValueFromGraph(String propertyId) {
         log.debug("Before deleting heat parameter from graph {}" , propertyId);
-        return titanGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.HeatParameterValue), propertyId, HeatParameterValueData.class);
+        return janusGraphGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.HeatParameterValue), propertyId, HeatParameterValueData.class);
     }
 
     @Override
@@ -207,10 +210,10 @@ public class HeatParametersOperation implements IHeatParametersOperation {
 
                 String propertyName = propertyDefinition.getName();
 
-                Either<HeatParameterData, TitanOperationStatus> addPropertyToGraph = addPropertyToGraph(propertyName, propertyDefinition, parentId, nodeType);
+                Either<HeatParameterData, JanusGraphOperationStatus> addPropertyToGraph = addPropertyToGraph(propertyName, propertyDefinition, parentId, nodeType);
 
                 if (addPropertyToGraph.isRight()) {
-                    return DaoStatusConverter.convertTitanStatusToStorageStatus(addPropertyToGraph.right().value());
+                    return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(addPropertyToGraph.right().value());
                 }
             }
         }
@@ -228,17 +231,18 @@ public class HeatParametersOperation implements IHeatParametersOperation {
         for (HeatParameterDefinition property : properties) {
 
             HeatParameterData heatParameterData = new HeatParameterData(property);
-            Either<HeatParameterData, TitanOperationStatus> updateNode = titanGenericDao.updateNode(heatParameterData, HeatParameterData.class);
+            Either<HeatParameterData, JanusGraphOperationStatus> updateNode = janusGraphGenericDao
+                .updateNode(heatParameterData, HeatParameterData.class);
             if (updateNode.isRight()) {
                 log.debug("failed to update heat parameter in graph. id = {}", property.getUniqueId());
-                return DaoStatusConverter.convertTitanStatusToStorageStatus(updateNode.right().value());
+                return DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateNode.right().value());
             }
         }
 
         return StorageOperationStatus.OK;
     }
 
-    public Either<HeatParameterData, TitanOperationStatus> addPropertyToGraph(String propertyName, HeatParameterDefinition propertyDefinition, String parentId, NodeTypeEnum nodeType) {
+    public Either<HeatParameterData, JanusGraphOperationStatus> addPropertyToGraph(String propertyName, HeatParameterDefinition propertyDefinition, String parentId, NodeTypeEnum nodeType) {
 
         UniqueIdData parentNode = new UniqueIdData(nodeType, parentId);
 
@@ -246,19 +250,21 @@ public class HeatParametersOperation implements IHeatParametersOperation {
         HeatParameterData propertyData = new HeatParameterData(propertyDefinition);
 
         log.debug("Before adding property to graph {}" , propertyData);
-        Either<HeatParameterData, TitanOperationStatus> createNodeResult = titanGenericDao.createNode(propertyData, HeatParameterData.class);
+        Either<HeatParameterData, JanusGraphOperationStatus> createNodeResult = janusGraphGenericDao
+            .createNode(propertyData, HeatParameterData.class);
         log.debug("After adding property to graph {}" , propertyData);
         if (createNodeResult.isRight()) {
-            TitanOperationStatus operationStatus = createNodeResult.right().value();
+            JanusGraphOperationStatus operationStatus = createNodeResult.right().value();
             log.error("Failed to add property {} to graph. status is {}", propertyName, operationStatus);
             return Either.right(operationStatus);
         }
 
         Map<String, Object> props = new HashMap<>();
         props.put(GraphPropertiesDictionary.NAME.getProperty(), propertyName);
-        Either<GraphRelation, TitanOperationStatus> createRelResult = titanGenericDao.createRelation(parentNode, propertyData, GraphEdgeLabels.HEAT_PARAMETER, props);
+        Either<GraphRelation, JanusGraphOperationStatus> createRelResult = janusGraphGenericDao
+            .createRelation(parentNode, propertyData, GraphEdgeLabels.HEAT_PARAMETER, props);
         if (createRelResult.isRight()) {
-            TitanOperationStatus operationStatus = createRelResult.right().value();
+            JanusGraphOperationStatus operationStatus = createRelResult.right().value();
             log.error("Failed to associate {} {} to heat parameter {} in graph. status is {}", nodeType.getName(), parentId, propertyName, operationStatus);
             return Either.right(operationStatus);
         }
@@ -371,7 +377,8 @@ public class HeatParametersOperation implements IHeatParametersOperation {
     @Override
     public Either<HeatParameterValueData, StorageOperationStatus> updateHeatParameterValue(HeatParameterDefinition heatParam, String artifactId, String resourceInstanceId, String artifactLabel) {
         String heatEnvId = UniqueIdBuilder.buildHeatParameterValueUniqueId(resourceInstanceId, artifactLabel, heatParam.getName());
-        Either<HeatParameterValueData, TitanOperationStatus> getNode = titanGenericDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), heatEnvId, HeatParameterValueData.class);
+        Either<HeatParameterValueData, JanusGraphOperationStatus> getNode = janusGraphGenericDao
+            .getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), heatEnvId, HeatParameterValueData.class);
         if (getNode.isRight() || getNode.left().value() == null) {
             if (heatParam.getCurrentValue() == null || (heatParam.getDefaultValue() != null && heatParam.getCurrentValue().equals(heatParam.getDefaultValue()))) {
                 log.debug("Updated heat parameter value equals default value. No need to create heat parameter value for heat parameter {}", heatParam.getUniqueId());
@@ -388,15 +395,17 @@ public class HeatParametersOperation implements IHeatParametersOperation {
         HeatParameterValueData heatParameterValue = new HeatParameterValueData();
         heatParameterValue.setUniqueId(heatParam.getUniqueId());
         if (heatParam.getCurrentValue() == null || (heatParam.getDefaultValue() != null && heatParam.getCurrentValue().equals(heatParam.getDefaultValue()))) {
-            Either<GraphRelation, TitanOperationStatus> deleteParameterValueIncomingRelation = titanGenericDao.deleteIncomingRelationByCriteria(heatParameterValue, GraphEdgeLabels.PARAMETER_VALUE, null);
+            Either<GraphRelation, JanusGraphOperationStatus> deleteParameterValueIncomingRelation = janusGraphGenericDao
+                .deleteIncomingRelationByCriteria(heatParameterValue, GraphEdgeLabels.PARAMETER_VALUE, null);
             if (deleteParameterValueIncomingRelation.isRight()) {
                 log.debug("Failed to delete heat parameter value incoming relation on graph. id = {}", heatParameterValue.getUniqueId());
-                return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(deleteParameterValueIncomingRelation.right().value()));
+                return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(deleteParameterValueIncomingRelation.right().value()));
             }
-            Either<Edge, TitanOperationStatus> getOutgoingRelation = titanGenericDao.getOutgoingEdgeByCriteria(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) heatParameterValue.getUniqueId(), GraphEdgeLabels.PARAMETER_IMPL, null);
+            Either<Edge, JanusGraphOperationStatus> getOutgoingRelation = janusGraphGenericDao
+                .getOutgoingEdgeByCriteria(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) heatParameterValue.getUniqueId(), GraphEdgeLabels.PARAMETER_IMPL, null);
             if (getOutgoingRelation.isRight()) {
                 log.debug("Failed to get heat parameter value outgoing relation from graph. id = {}", heatParameterValue.getUniqueId());
-                return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(getOutgoingRelation.right().value()));
+                return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(getOutgoingRelation.right().value()));
             }
             Edge edge = getOutgoingRelation.left().value();
             if (edge == null) {
@@ -405,33 +414,35 @@ public class HeatParametersOperation implements IHeatParametersOperation {
             }
             edge.remove();
 
-            Either<HeatParameterValueData, TitanOperationStatus> deleteNode = titanGenericDao.deleteNode(heatParameterValue, HeatParameterValueData.class);
+            Either<HeatParameterValueData, JanusGraphOperationStatus> deleteNode = janusGraphGenericDao
+                .deleteNode(heatParameterValue, HeatParameterValueData.class);
             if (deleteNode.isRight()) {
                 log.debug("Failed to delete heat parameter value on graph. id = {}", heatParameterValue.getUniqueId());
-                return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(deleteNode.right().value()));
+                return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(deleteNode.right().value()));
             }
             return Either.left(deleteNode.left().value());
         }
         heatParameterValue.setValue(heatParam.getCurrentValue());
-        Either<HeatParameterValueData, TitanOperationStatus> updateNode = titanGenericDao.updateNode(heatParameterValue, HeatParameterValueData.class);
+        Either<HeatParameterValueData, JanusGraphOperationStatus> updateNode = janusGraphGenericDao
+            .updateNode(heatParameterValue, HeatParameterValueData.class);
         if (updateNode.isRight()) {
             log.debug("Failed to update heat parameter value in graph. id = {}", heatParameterValue.getUniqueId());
-            return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(updateNode.right().value()));
+            return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(updateNode.right().value()));
         }
         return Either.left(updateNode.left().value());
     }
 
     public Either<HeatParameterValueData, StorageOperationStatus> createHeatParameterValue(HeatParameterDefinition heatParam, String artifactId, String resourceInstanceId, String artifactLabel) {
 
-        Either<HeatParameterValueData, TitanOperationStatus> addHeatValueToGraph = addHeatValueToGraph(heatParam, artifactLabel, artifactId, resourceInstanceId);
+        Either<HeatParameterValueData, JanusGraphOperationStatus> addHeatValueToGraph = addHeatValueToGraph(heatParam, artifactLabel, artifactId, resourceInstanceId);
         if (addHeatValueToGraph.isRight()) {
             log.debug("Failed to create heat parameters value on graph for artifact {}", artifactId);
-            return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(addHeatValueToGraph.right().value()));
+            return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(addHeatValueToGraph.right().value()));
         }
         return Either.left(addHeatValueToGraph.left().value());
     }
 
-    public Either<HeatParameterValueData, TitanOperationStatus> addHeatValueToGraph(HeatParameterDefinition heatParameter, String artifactLabel, String artifactId, String resourceInstanceId) {
+    public Either<HeatParameterValueData, JanusGraphOperationStatus> addHeatValueToGraph(HeatParameterDefinition heatParameter, String artifactLabel, String artifactId, String resourceInstanceId) {
 
         UniqueIdData heatEnvNode = new UniqueIdData(NodeTypeEnum.ArtifactRef, artifactId);
         HeatParameterValueData heatValueData = new HeatParameterValueData();
@@ -439,26 +450,29 @@ public class HeatParametersOperation implements IHeatParametersOperation {
         heatValueData.setValue(heatParameter.getCurrentValue());
 
         log.debug("Before adding property to graph {}", heatValueData);
-        Either<HeatParameterValueData, TitanOperationStatus> createNodeResult = titanGenericDao.createNode(heatValueData, HeatParameterValueData.class);
+        Either<HeatParameterValueData, JanusGraphOperationStatus> createNodeResult = janusGraphGenericDao
+            .createNode(heatValueData, HeatParameterValueData.class);
         log.debug("After adding property to graph {}", heatValueData);
         if (createNodeResult.isRight()) {
-            TitanOperationStatus operationStatus = createNodeResult.right().value();
+            JanusGraphOperationStatus operationStatus = createNodeResult.right().value();
             log.error("Failed to add heat value {} to graph. status is {}", heatValueData.getUniqueId(), operationStatus);
             return Either.right(operationStatus);
         }
 
         Map<String, Object> props = new HashMap<>();
         props.put(GraphPropertiesDictionary.NAME.getProperty(), heatParameter.getName());
-        Either<GraphRelation, TitanOperationStatus> createRelResult = titanGenericDao.createRelation(heatEnvNode, heatValueData, GraphEdgeLabels.PARAMETER_VALUE, props);
+        Either<GraphRelation, JanusGraphOperationStatus> createRelResult = janusGraphGenericDao
+            .createRelation(heatEnvNode, heatValueData, GraphEdgeLabels.PARAMETER_VALUE, props);
         if (createRelResult.isRight()) {
-            TitanOperationStatus operationStatus = createRelResult.right().value();
+            JanusGraphOperationStatus operationStatus = createRelResult.right().value();
             log.error("Failed to associate heat value {} to heat env artifact {} in graph. status is {}", heatValueData.getUniqueId(), artifactId, operationStatus);
             return Either.right(operationStatus);
         }
         UniqueIdData heatParameterNode = new UniqueIdData(NodeTypeEnum.HeatParameter, heatParameter.getUniqueId());
-        Either<GraphRelation, TitanOperationStatus> createRel2Result = titanGenericDao.createRelation(heatValueData, heatParameterNode, GraphEdgeLabels.PARAMETER_IMPL, null);
+        Either<GraphRelation, JanusGraphOperationStatus> createRel2Result = janusGraphGenericDao
+            .createRelation(heatValueData, heatParameterNode, GraphEdgeLabels.PARAMETER_IMPL, null);
         if (createRel2Result.isRight()) {
-            TitanOperationStatus operationStatus = createRel2Result.right().value();
+            JanusGraphOperationStatus operationStatus = createRel2Result.right().value();
             log.error("Failed to associate heat value {} to heat parameter {} in graph. status is {}", heatValueData.getUniqueId(), heatParameter.getName(), operationStatus);
             return Either.right(operationStatus);
         }