diff --git a/src/main/java/net/onrc/onos/ofcontroller/flowmanager/ApplnObjectType.java b/src/main/java/net/onrc/onos/ofcontroller/flowmanager/ApplnObjectType.java
new file mode 100644
index 0000000..8cb1316
--- /dev/null
+++ b/src/main/java/net/onrc/onos/ofcontroller/flowmanager/ApplnObjectType.java
@@ -0,0 +1,16 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package net.onrc.onos.ofcontroller.flowmanager;
+
+/**
+ *
+ * @author nickkaranatsios
+ */
+public enum ApplnObjectType {
+    FLOWPATH,
+    FLOWENTRY,  
+    UNKNOWN
+}
+
diff --git a/src/main/java/net/onrc/onos/ofcontroller/flowmanager/DBOperationType.java b/src/main/java/net/onrc/onos/ofcontroller/flowmanager/DBOperationType.java
new file mode 100644
index 0000000..e0de595
--- /dev/null
+++ b/src/main/java/net/onrc/onos/ofcontroller/flowmanager/DBOperationType.java
@@ -0,0 +1,18 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package net.onrc.onos.ofcontroller.flowmanager;
+
+/**
+ *
+ * @author nickkaranatsios
+ */
+public enum DBOperationType {
+    ADD,
+    UPDATE,
+    QUERY,
+    REMOVE,
+    INVALID
+}
+
diff --git a/src/main/java/net/onrc/onos/ofcontroller/flowmanager/FlowDatabaseOperation.java b/src/main/java/net/onrc/onos/ofcontroller/flowmanager/FlowDatabaseOperation.java
index e68d04b..2793dd4 100644
--- a/src/main/java/net/onrc/onos/ofcontroller/flowmanager/FlowDatabaseOperation.java
+++ b/src/main/java/net/onrc/onos/ofcontroller/flowmanager/FlowDatabaseOperation.java
@@ -1,5 +1,6 @@
 package net.onrc.onos.ofcontroller.flowmanager;
 
+import com.tinkerpop.blueprints.Direction;
 import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.util.ArrayList;
@@ -40,10 +41,13 @@
     static boolean addFlowFast(DBOperation dbHandler, FlowPath flowPath) {
 	IFlowPath flowPathObj = null;
 	FlowPathProperty flowProp = new FlowPathProperty();
+        FlowEntity flowPathEntity = new FlowEntity();
+        boolean flowPathUpdate = false;
 	
 	flowPathObj = dbHandler.searchFlowPath(flowPath.flowId()); // toshi memo: getVertices("flow_id")
 	if (flowPathObj == null) {
 	    try {
+                flowPathEntity.operationBegin(DBOperationType.ADD.toString());
 		flowPathObj = dbHandler.newFlowPath(); // toshi memo: addVertex(), setType("flow")
 	    } catch (Exception e) {
 		flowPathObj = null;
@@ -51,13 +55,19 @@
 		e.printStackTrace(new PrintWriter(sw));
 		log.error(":addFlow FlowId:{} failed: {}", flowPath.flowId(), sw.toString());
 	    }
+            flowPathEntity.setProperty("user_state", "FP_USER_ADD");
 	    flowProp.setFlowPathUserState("FP_USER_ADD");
 	} else {
+            flowPathUpdate = true;
 	    // Remove the old Flow Entries (this is special for RAMCloud)
 	    for (IFlowEntry flowEntryObj : flowPathObj.getFlowEntries()) { // toshi memo: get.@Adjacency("flow", IN)
 		//flowObj.removeFlowEntry(flowEntryObj);   // toshi memo: remove.@Adjacency("flow", IN)
+                flowPathEntity.operationBegin(DBOperationType.REMOVE.toString());
 		dbHandler.removeFlowEntry(flowEntryObj); // toshi memo: removeVertex()
+                flowPathEntity.operationEnd(DBOperationType.REMOVE.toString());
 	    }
+            flowPathEntity.operationBegin(DBOperationType.UPDATE.toString());
+            flowPathEntity.setProperty("user_state", "FP_USER_ADD");
 	    flowProp.setFlowPathUserState("FP_USER_MODIFY");
 	}
 	if (flowPathObj == null) {
@@ -67,57 +77,92 @@
 	    return false;
 	}
 
+        flowPathEntity.setProperty("flow_id", flowPath.flowId().toString());
 	// Set the Flow key
 	flowProp.setFlowId(flowPath.flowId().toString());
 
 	// Set the Flow attributes
+
+        flowPathEntity.setProperty("installer_id", flowPath.installerId().toString());
 	flowProp.setInstallerId(flowPath.installerId().toString());
+
+        flowPathEntity.setProperty("flow_path_type", flowPath.flowPathType().toString());
 	flowProp.setFlowPathType(flowPath.flowPathType().toString());
+
+        flowPathEntity.setProperty("user_state", flowPath.flowPathUserState().toString());
 	flowProp.setFlowPathUserState(flowPath.flowPathUserState().toString());
+
+
+        flowPathEntity.setProperty("flow_path_flags", flowPath.flowPathFlags().flags());
 	flowProp.setFlowPathFlags(flowPath.flowPathFlags().flags());
+
+        flowPathEntity.setProperty("idle_timeout", flowPath.idleTimeout());
 	flowProp.setIdleTimeout(flowPath.idleTimeout());
+
+        flowPathEntity.setProperty("hard_timeout", flowPath.hardTimeout());
 	flowProp.setHardTimeout(flowPath.hardTimeout());
+
+        flowPathEntity.setProperty("src_switch", flowPath.dataPath().srcPort().dpid().toString());
 	flowProp.setSrcSwitch(flowPath.dataPath().srcPort().dpid().toString());
+
+        flowPathEntity.setProperty("src_port", flowPath.dataPath().srcPort().port().value());
 	flowProp.setSrcPort(flowPath.dataPath().srcPort().port().value());
+
+        flowPathEntity.setProperty("dst_switch", flowPath.dataPath().dstPort().dpid().toString());
 	flowProp.setDstSwitch(flowPath.dataPath().dstPort().dpid().toString());
+
+        flowPathEntity.setProperty("dst_port", flowPath.dataPath().dstPort().port().value());
 	flowProp.setDstPort(flowPath.dataPath().dstPort().port().value());
 
 	if (flowPath.flowEntryMatch().matchSrcMac()) {
+            flowPathEntity.setProperty("matchSrcMac",flowPath.flowEntryMatch().srcMac().toString());
 	    flowProp.setMatchSrcMac(flowPath.flowEntryMatch().srcMac().toString());
 	}
 	if (flowPath.flowEntryMatch().matchDstMac()) {
+            flowPathEntity.setProperty("matchDstMac", flowPath.flowEntryMatch().dstMac().toString());
 	    flowProp.setMatchDstMac(flowPath.flowEntryMatch().dstMac().toString());
 	}
 	if (flowPath.flowEntryMatch().matchEthernetFrameType()) {
+            flowPathEntity.setProperty("matchEthernetFrameType", flowPath.flowEntryMatch().ethernetFrameType());
 	    flowProp.setMatchEthernetFrameType(flowPath.flowEntryMatch().ethernetFrameType());
 	}
 	if (flowPath.flowEntryMatch().matchVlanId()) {
+            flowPathEntity.setProperty("matchVlanId", flowPath.flowEntryMatch().vlanId());
 	    flowProp.setMatchVlanId(flowPath.flowEntryMatch().vlanId());
 	}
 	if (flowPath.flowEntryMatch().matchVlanPriority()) {
+            flowPathEntity.setProperty("matchVlanPriority", flowPath.flowEntryMatch().vlanPriority());
 	    flowProp.setMatchVlanPriority(flowPath.flowEntryMatch().vlanPriority());
 	}
 	if (flowPath.flowEntryMatch().matchSrcIPv4Net()) {
+            flowPathEntity.setProperty("matchSrcIPv4Net", flowPath.flowEntryMatch().srcIPv4Net().toString());
 	    flowProp.setMatchSrcIPv4Net(flowPath.flowEntryMatch().srcIPv4Net().toString());
 	}
 	if (flowPath.flowEntryMatch().matchDstIPv4Net()) {
+            flowPathEntity.setProperty("matchDstIPv4Net", flowPath.flowEntryMatch().dstIPv4Net().toString());
 	    flowProp.setMatchDstIPv4Net(flowPath.flowEntryMatch().dstIPv4Net().toString());
 	}
 	if (flowPath.flowEntryMatch().matchIpProto()) {
+            flowPathEntity.setProperty("matchIpProto", flowPath.flowEntryMatch().ipProto());
 	    flowProp.setMatchIpProto(flowPath.flowEntryMatch().ipProto());
 	}
 	if (flowPath.flowEntryMatch().matchIpToS()) {
+            flowPathEntity.setProperty("matchIpToS", flowPath.flowEntryMatch().ipToS());
 	    flowProp.setMatchIpToS(flowPath.flowEntryMatch().ipToS());
 	}
 	if (flowPath.flowEntryMatch().matchSrcTcpUdpPort()) {
+            flowPathEntity.setProperty("matchSrcTcpUdpPort", flowPath.flowEntryMatch().srcTcpUdpPort());
 	    flowProp.setMatchSrcTcpUdpPort(flowPath.flowEntryMatch().srcTcpUdpPort());
 	}
 	if (flowPath.flowEntryMatch().matchDstTcpUdpPort()) {
+            flowPathEntity.setProperty("matchDstTcpUdpPort", flowPath.flowEntryMatch().dstTcpUdpPort());
 	    flowProp.setMatchDstTcpUdpPort(flowPath.flowEntryMatch().dstTcpUdpPort());
 	}
 	if (! flowPath.flowEntryActions().actions().isEmpty()) {
+            flowPathEntity.setProperty("actions", flowPath.flowEntryActions().toString());
 	    flowProp.setActions(flowPath.flowEntryActions().toString());
 	}
+        flowPathEntity.setProperty("data_path_summary", flowPath.dataPath().dataPathSummary());
 	flowProp.setDataPathSummary(flowPath.dataPath().dataPathSummary());
 
 	flowProp.commitProperties(dbHandler, flowPathObj); // toshi memo: flowObj.setProperties()
@@ -132,95 +177,146 @@
 
 	    IFlowEntry iFlowEntry = null;
 	    FlowEntryProperty flowEntryProp = new FlowEntryProperty();
+            FlowEntity flowEntryEntity = new FlowEntity();
+            boolean updateFlowEntry = false;
 	    
 	    try {
 		iFlowEntry = dbHandler.searchFlowEntry(flowEntry.flowEntryId()); // toshi memo: getVertices()
 		if (iFlowEntry != null) {
+                    updateFlowEntry = true;
+                    flowEntryEntity.operationBegin(DBOperationType.UPDATE.toString());
+                    flowEntryEntity.setProperty("user_state", "FE_USER_MODIFY");
 		    flowEntryProp.setUserState("FE_USER_MODIFY");
 		} else {
+System.out.println("About to add a flow entry");
+                    flowEntryEntity.operationBegin(DBOperationType.ADD.toString());
+                    flowEntryEntity.setProperty("user_state", "FE_USER_ADD");
 		    flowEntryProp.setUserState("FE_USER_ADD");
-		    iFlowEntry = dbHandler.newFlowEntry(); // toshi memo: addVertex(). setType("flow_entry")
+		    // NK: iFlowEntry = dbHandler.newFlowEntry(); // toshi memo: addVertex(). setType("flow_entry")
 		    //flowObj.addFlowEntry(iFlowEntry);      // toshi memo: add.@Adjacency("flow", IN)
-		    iFlowEntry.setFlow(flowPathObj);           // toshi memo: set.@Adjacency("flow")
+		    // NK: iFlowEntry.setFlow(flowPathObj);           // toshi memo: set.@Adjacency("flow")
+                    flowEntryEntity.addEdge(flowPathObj, Direction.OUT, "flow");
 		}
 	    } catch (Exception e) {
 		iFlowEntry = null;
 	    }
+            /* NK:
 	    if (iFlowEntry == null) {
 		log.error(":addFlow FlowEntryId:{} failed: FlowEntry object not created", flowEntry.flowEntryId());
 		dbHandler.rollback();
 		return false;
 	    }
+            */
 	    
+            flowEntryEntity.setProperty("flow_id", flowEntry.flowEntryId().toString());
 	    // Set the Flow Entry key
-	    flowEntryProp.setFlowEntryId(flowEntry.flowEntryId().toString());
-	    flowEntryProp.setType("flow_entry");
+	    // NK: flowEntryProp.setFlowEntryId(flowEntry.flowEntryId().toString());
+            flowEntryEntity.setProperty("flow_entry_id", flowEntry.flowEntryId().toString());
+
+            flowEntryEntity.setProperty("type", "flow_entry");
+	    // NK: flowEntryProp.setType("flow_entry");
 
 	    // Set the Flow Entry Edges
 	    ISwitchObject sw = dbHandler.searchSwitch(flowEntry.dpid().toString()); // toshi memo: getVertices()
 
-	    flowEntryProp.setIdleTimeout(flowEntry.idleTimeout());
-	    flowEntryProp.setHardTimeout(flowEntry.hardTimeout());
-	    flowEntryProp.setSwitchDpid(flowEntry.dpid().toString());
+            flowEntryEntity.setProperty("idle_timeout", flowEntry.idleTimeout());
+	    // NK: flowEntryProp.setIdleTimeout(flowEntry.idleTimeout());
 
-	    iFlowEntry.setSwitch(sw);  // toshi memo: set.@Adjacency("switch")
+            flowEntryEntity.setProperty("hard_timeout", flowEntry.hardTimeout());
+	    // NK: flowEntryProp.setHardTimeout(flowEntry.hardTimeout());
+
+            flowEntryEntity.setProperty("switch_dpid", flowEntry.dpid().toString());
+	    // NK:flowEntryProp.setSwitchDpid(flowEntry.dpid().toString());
+
+	    //NK: iFlowEntry.setSwitch(sw);  // toshi memo: set.@Adjacency("switch")
+            flowEntryEntity.addEdge(sw, Direction.OUT, "switch");
 	    if (flowEntry.flowEntryMatch().matchInPort()) {
 		IPortObject inport = dbHandler.searchPort(flowEntry.dpid().toString(), flowEntry.flowEntryMatch().inPort().value()); // toshi memo: getVertices()
-		flowEntryProp.setMatchInPort(flowEntry.flowEntryMatch().inPort().value());
-		iFlowEntry.setInPort(inport);  // toshi memo: set.@Adjacency("inport")
+
+                flowEntryEntity.setProperty("matchInPort", flowEntry.flowEntryMatch().inPort().value());
+		// NK: flowEntryProp.setMatchInPort(flowEntry.flowEntryMatch().inPort().value());
+                flowEntryEntity.addEdge(inport, Direction.OUT, "inport");
+		// NK: iFlowEntry.setInPort(inport);  // toshi memo: set.@Adjacency("inport")
 	    }
 
 	    // Set the Flow Entry attributes
 	    if (flowEntry.flowEntryMatch().matchSrcMac()) {
-		flowEntryProp.setMatchSrcMac(flowEntry.flowEntryMatch().srcMac().toString());
+                flowEntryEntity.setProperty("matchSrcMac", flowEntry.flowEntryMatch().srcMac().toString());
+		// NK: flowEntryProp.setMatchSrcMac(flowEntry.flowEntryMatch().srcMac().toString());
 	    }
 	    if (flowEntry.flowEntryMatch().matchDstMac()) {
-		flowEntryProp.setMatchDstMac(flowEntry.flowEntryMatch().dstMac().toString());
+                flowEntryEntity.setProperty("matchDstMac", flowEntry.flowEntryMatch().dstMac().toString());
+		// NK: flowEntryProp.setMatchDstMac(flowEntry.flowEntryMatch().dstMac().toString());
 	    }
 	    if (flowEntry.flowEntryMatch().matchEthernetFrameType()) {
-		flowEntryProp.setMatchEthernetFrameType(flowEntry.flowEntryMatch().ethernetFrameType());
+                flowEntryEntity.setProperty("matchEthernetFrameType", flowEntry.flowEntryMatch().ethernetFrameType());
+		// NK: flowEntryProp.setMatchEthernetFrameType(flowEntry.flowEntryMatch().ethernetFrameType());
 	    }
 	    if (flowEntry.flowEntryMatch().matchVlanId()) {
-		flowEntryProp.setMatchVlanId(flowEntry.flowEntryMatch().vlanId());
+                flowEntryEntity.setProperty("matchVlanId", flowEntry.flowEntryMatch().vlanId());
+		// NK: flowEntryProp.setMatchVlanId(flowEntry.flowEntryMatch().vlanId());
 	    }
 	    if (flowEntry.flowEntryMatch().matchVlanPriority()) {
-		flowEntryProp.setMatchVlanPriority(flowEntry.flowEntryMatch().vlanPriority());
+                flowEntryEntity.setProperty("matchVlanPriority", flowEntry.flowEntryMatch().vlanPriority());
+		// NK: flowEntryProp.setMatchVlanPriority(flowEntry.flowEntryMatch().vlanPriority());
 	    }
 	    if (flowEntry.flowEntryMatch().matchSrcIPv4Net()) {
-		flowEntryProp.setMatchSrcIPv4Net(flowEntry.flowEntryMatch().srcIPv4Net().toString());
+                flowEntryEntity.setProperty("matchSrcIPv4Net", flowEntry.flowEntryMatch().srcIPv4Net().toString());
+		// NK: flowEntryProp.setMatchSrcIPv4Net(flowEntry.flowEntryMatch().srcIPv4Net().toString());
 	    }
 	    if (flowEntry.flowEntryMatch().matchDstIPv4Net()) {
-		flowEntryProp.setMatchDstIPv4Net(flowEntry.flowEntryMatch().dstIPv4Net().toString());
+                flowEntryEntity.setProperty("matchDstIPv4Net", flowEntry.flowEntryMatch().dstIPv4Net().toString());
+		// NK: flowEntryProp.setMatchDstIPv4Net(flowEntry.flowEntryMatch().dstIPv4Net().toString());
 	    }
 	    if (flowEntry.flowEntryMatch().matchIpProto()) {
-		flowEntryProp.setMatchIpProto(flowEntry.flowEntryMatch().ipProto());
+                flowEntryEntity.setProperty("matchIpProto", flowEntry.flowEntryMatch().ipProto());
+		// NK: flowEntryProp.setMatchIpProto(flowEntry.flowEntryMatch().ipProto());
 	    }
 	    if (flowEntry.flowEntryMatch().matchIpToS()) {
-		flowEntryProp.setMatchIpToS(flowEntry.flowEntryMatch().ipToS());
+                flowEntryEntity.setProperty("matchIpToS", flowEntry.flowEntryMatch().ipToS());
+		// NK: flowEntryProp.setMatchIpToS(flowEntry.flowEntryMatch().ipToS());
 	    }
 	    if (flowEntry.flowEntryMatch().matchSrcTcpUdpPort()) {
-		flowEntryProp.setMatchSrcTcpUdpPort(flowEntry.flowEntryMatch().srcTcpUdpPort());
+                flowEntryEntity.setProperty("matchSrcTcpUdpPort", flowEntry.flowEntryMatch().srcTcpUdpPort());
+		// NK: flowEntryProp.setMatchSrcTcpUdpPort(flowEntry.flowEntryMatch().srcTcpUdpPort());
 	    }
 	    if (flowEntry.flowEntryMatch().matchDstTcpUdpPort()) {
-		flowEntryProp.setMatchDstTcpUdpPort(flowEntry.flowEntryMatch().dstTcpUdpPort());
+                flowEntryEntity.setProperty("matchDstTcpUdpPort", flowEntry.flowEntryMatch().dstTcpUdpPort());
+		// NK: flowEntryProp.setMatchDstTcpUdpPort(flowEntry.flowEntryMatch().dstTcpUdpPort());
 	    }
 
 	    for (FlowEntryAction fa : flowEntry.flowEntryActions().actions()) {
 		if (fa.actionOutput() != null) {
 		    IPortObject outport = dbHandler.searchPort(flowEntry.dpid().toString(), fa.actionOutput().port().value()); // toshi memo: getVertices()
-		    flowEntryProp.setActionOutputPort(fa.actionOutput().port().value());
-		    iFlowEntry.setOutPort(outport); // set.@Adjacency("outport")
+                    flowEntryEntity.setProperty("actionOutputPort", fa.actionOutput().port().value());
+		    // NK: flowEntryProp.setActionOutputPort(fa.actionOutput().port().value());
+                    flowEntryEntity.addEdge(outport, Direction.OUT, "outport");
+		    // NK: iFlowEntry.setOutPort(outport); // set.@Adjacency("outport")
 		}
 	    }
 	    if (! flowEntry.flowEntryActions().isEmpty()) {
-		flowEntryProp.setActions(flowEntry.flowEntryActions().toString());
+                flowEntryEntity.setProperty("actions", flowEntry.flowEntryActions().toString());
+		// NK: flowEntryProp.setActions(flowEntry.flowEntryActions().toString());
 	    }
 
-	    flowEntryProp.setSwitchState(flowEntry.flowEntrySwitchState().toString());
-	    flowEntryProp.commitProperties(dbHandler, iFlowEntry); // toshi memo: setProperties()
+            flowEntryEntity.setProperty("switch_state", flowEntry.flowEntrySwitchState().toString());
+	    // NK: flowEntryProp.setSwitchState(flowEntry.flowEntrySwitchState().toString());
+	    // NK: flowEntryProp.commitProperties(dbHandler, iFlowEntry); // toshi memo: setProperties()
+            if (updateFlowEntry) {
+               flowEntryEntity.operationEnd(DBOperationType.UPDATE.toString());
+            } else {
+               flowEntryEntity.operationEnd(DBOperationType.ADD.toString());
+            }
+            flowPathEntity.append(flowEntryEntity);
 	}
 	
-	dbHandler.commit();
+        if (flowPathUpdate) {
+            flowPathEntity.operationEnd(DBOperationType.UPDATE.toString());
+        } else {
+            flowPathEntity.operationEnd(DBOperationType.ADD.toString());
+        }
+        flowPathEntity.persist(dbHandler);
+	// NK:dbHandler.commit();
 	return true;
     }
     
@@ -925,7 +1021,6 @@
 		continue;
 	    deleteIFlowPath(dbHandler, flowPathObj);
 	}
-	dbHandler.commit();
 
 	return true;
     }
@@ -953,7 +1048,6 @@
 	}
 
 	deleteIFlowPath(dbHandler, flowObj);
-	dbHandler.commit();
 
 	return true;
     }
@@ -969,6 +1063,7 @@
 	}
 	// Remove the Flow itself
 	dbHandler.removeFlowPath(flowObj);
+	dbHandler.commit();
     }
 
     /**
diff --git a/src/main/java/net/onrc/onos/ofcontroller/flowmanager/FlowEntity.java b/src/main/java/net/onrc/onos/ofcontroller/flowmanager/FlowEntity.java
new file mode 100644
index 0000000..f4d2dc9
--- /dev/null
+++ b/src/main/java/net/onrc/onos/ofcontroller/flowmanager/FlowEntity.java
@@ -0,0 +1,265 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package net.onrc.onos.ofcontroller.flowmanager;
+
+import com.tinkerpop.blueprints.Direction;
+import com.tinkerpop.blueprints.Vertex;
+import com.tinkerpop.blueprints.Edge;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import net.onrc.onos.graph.DBOperation;
+import net.onrc.onos.ofcontroller.core.INetMapTopologyObjects.IBaseObject;
+import com.tinkerpop.blueprints.impls.ramcloud.RamCloudGraph;
+import com.tinkerpop.blueprints.impls.ramcloud.RamCloudVertex;
+import java.util.List;
+import java.util.Set;
+
+/**
+ *
+ * @author nickkaranatsios
+ */
+public class FlowEntity implements FlowEntityManager {
+    private String primaryKey;
+    private Class<?> hasMany;
+    private Collection<?> many = new ArrayList<>();
+    private Map<String, Object> properties;
+    private Map<String, Map<String, Object>> operations = new HashMap<>();
+    private ArrayList<Object> children = new ArrayList<>();
+    private ArrayList<Object> edges = new ArrayList<>();
+    private int opCount;
+    public Direction dir;
+
+    public FlowEntity() {
+        opCount = 0;
+    }
+    
+    private class EntityEdge {
+        private Object src;
+        private Object dst;
+        private Direction dir;
+        private String label;
+        private DBOperationType op;
+        
+        public EntityEdge(Object src, Object dst, DBOperationType op, Direction dir, String label) {
+            this.src = src;
+            this.dst = dst;
+            this.dir = dir;
+            this.label = label;
+            this.op = op;
+        }
+        
+        public EntityEdge(Object src, Object dst, String label) {
+            this.src = src;
+            this.dst = dst;
+            this.label = label;
+        }
+        
+        @Override
+        public String toString() {
+            return "EntityEdge: " + src + " " + dst + " " + label;
+        }
+    }
+
+    private class RamCloudEdgeEntity implements Edge {
+        private Vertex src;
+        private Vertex dst;
+        private Direction direction;
+        private String label;
+
+        public RamCloudEdgeEntity(Vertex src, Vertex dst, Direction direction, String label) {
+            this.src = src;
+            this.dst = dst;
+            this.direction = direction;
+            this.label = label;
+        }
+        
+        @Override
+        public Vertex getVertex(com.tinkerpop.blueprints.Direction dir) throws IllegalArgumentException {
+            if (dir == Direction.IN) {
+                System.out.println("returning in vertex " + this.dst.getId());
+                return dst;
+            } else if (dir == Direction.OUT) {
+                System.out.println("returning out vertex " + this.src.getId());
+                return src;
+            }
+            return null;
+        }
+
+        @Override
+        public String getLabel() {
+            return this.label;
+        }
+
+        @Override
+        public <T> T getProperty(String key) {
+            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public Set<String> getPropertyKeys() {
+            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public void setProperty(String key, Object value) {
+            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public <T> T removeProperty(String key) {
+            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public void remove() {
+            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public Object getId() {
+            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+        
+    }
+    
+    @Override
+    public void setPrimaryKey(String key) {
+        primaryKey = key;
+    }
+    
+    @Override
+    public String getPrimaryKey() {
+        return primaryKey;
+    }
+
+    @Override
+    public void hasMany(Class<?> cClass) {
+        hasMany = cClass;
+    }
+    
+    @Override
+    public void operationBegin(String opName) {
+        properties = new HashMap<>();
+        operations.put(getOpKey(opName), properties);
+        opCount++;
+    }
+    
+    @Override
+    public void operationEnd(String opName) {
+        String opKey = getOpKey(opName);
+        if (operations.containsKey(opKey)) {
+            System.out.println(operations);
+        }
+        
+    }
+    
+    
+    private String getOpKey(String opName) {
+        return opName + new Integer(opCount).toString();
+        
+    }
+
+    @Override
+    public void setProperty(String propertyName, Object value) {
+        properties.put(propertyName, value);
+    }
+
+    @Override
+    public FlowEntityManager append(Object entity) {
+        children.add(entity);
+        return this;
+    }
+    
+    @Override
+    public Object getProperty(String propertyName) {
+        if (properties.containsKey(propertyName)) {
+            return properties.get(propertyName);
+        }
+        return null;
+    }
+    
+    @Override
+    public void persist(DBOperation dbHandler) {
+        System.out.println("total operations: " );
+        System.out.println(operations);
+        // get a hold of all the flow entries for the current flowpath.
+        if (children.size() > 0) {
+            int noOfChildren = children.size();
+            if (noOfChildren > 0) {
+                // construct a list of null ids for creating vertices for all
+                // flow entries.
+                //ArrayList<Object> ids = new ArrayList<>(noOfChildren);
+                List<RamCloudVertex> addedVertices = new ArrayList<>();
+                RamCloudGraph graph = (RamCloudGraph)dbHandler.getDBConnection().getFramedGraph().getBaseGraph();
+                for (int i = 0; i < noOfChildren; i++) {
+                    // ids.add(null);
+                    addedVertices.add((RamCloudVertex) graph.addVertex(null));
+                }
+                // List<RamCloudVertex> addedVertices = graph.addVertices(ids);
+                System.out.println("Added vertices " + addedVertices);
+                // call setVertices()
+                //Iterable<Vertex> vertices = dbHandler.setVertices(ids);
+                //Iterator vi = vertices.iterator();
+                // get source and destination edge match vertex v construct list
+                // of edges
+
+                ArrayList<Edge> edgesToSet = new ArrayList<>();
+                for (int i = 0; i < noOfChildren; i++) {
+                    FlowEntity childEntity = (FlowEntity)children.get(i);
+                    //Vertex srcVertex = getVertexEdge(vi, i);
+                    Vertex srcVertex = addedVertices.get(i);
+                    if (srcVertex == null) continue;
+                    for (int j = 0; j < childEntity.edges.size(); j++) {
+                        EntityEdge edge = (EntityEdge) childEntity.edges.get(j);
+                        edgesToSet.add(new RamCloudEdgeEntity(srcVertex, ((IBaseObject) edge.dst).asVertex(), edge.dir, edge.label));
+                    }
+                }
+                graph.addEdges(edgesToSet);
+                ArrayList<Map<Vertex, Map<String, Object>>> allProperties = new ArrayList<>();
+                // set properties
+                Map<RamCloudVertex, Map<String, Object>> propertiesToSet = new HashMap<>();
+                for (int i = 0; i < noOfChildren; i++) {
+                    FlowEntity childEntity = (FlowEntity)children.get(i);
+                    propertiesToSet.put((RamCloudVertex)addedVertices.get(i), childEntity.properties);
+                }
+                graph.setProperties(propertiesToSet);
+            }
+        }
+        for (int i = 0; i < children.size(); i++) {
+            FlowEntityManager entity = (FlowEntityManager)children.get(i);
+            System.out.println(entity.getProperties());
+        }
+    }
+
+    private Vertex getVertexEdge(Iterator vi, int idx) {
+        int i = 0;
+        while (vi.hasNext()) {
+            Vertex v = (Vertex)vi.next();
+            if (i == idx) {
+                return v;
+            }
+            i++;
+        }
+        return null;
+    }
+    
+    @Override
+    public Map<String, Object> getProperties() {
+        return properties;
+    }
+    
+    @Override
+    public void addEdge(Object dst, Direction dir, String label) {
+        edges.add(new EntityEdge(this, dst, DBOperationType.ADD, dir, label));
+    }
+    
+    @Override
+    public void removeEdge(Object src, Object dst, Direction dir, String label) {
+        edges.add(new EntityEdge(src, dst, DBOperationType.REMOVE, dir, label));
+    }
+}
diff --git a/src/main/java/net/onrc/onos/ofcontroller/flowmanager/FlowEntityManager.java b/src/main/java/net/onrc/onos/ofcontroller/flowmanager/FlowEntityManager.java
new file mode 100644
index 0000000..38e694b
--- /dev/null
+++ b/src/main/java/net/onrc/onos/ofcontroller/flowmanager/FlowEntityManager.java
@@ -0,0 +1,29 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package net.onrc.onos.ofcontroller.flowmanager;
+
+import com.tinkerpop.blueprints.Direction;
+import java.util.Map;
+import net.onrc.onos.graph.DBOperation;
+
+/**
+ *
+ * @author nickkaranatsios
+ */
+public interface FlowEntityManager {
+    public void setPrimaryKey(String key);
+    public String getPrimaryKey();
+    public void hasMany(Class<?> cClass);
+    public void operationBegin(String opName);
+    public void operationEnd(String opName);
+    public void setProperty(String propertyName, Object value);
+    public Object getProperty(String propertyName);
+    public Map<String, Object> getProperties();
+    public FlowEntityManager append(Object entity);
+    public void addEdge(Object dst, Direction dir, String label);
+    public void removeEdge(Object src, Object dst, Direction dir, String label);
+    public void persist(DBOperation dbHandler);
+}
+