InventoryService caching and First-level Transaction Support

Few more changes pending on the Transaction side.
Once the Update/Notification callback processing from Ashwin is done,
we will have a good base to start integrating with the plugin code.

Signed-off-by: Madhu Venugopal <mavenugo@gmail.com>

diff --git a/ovsdb/.settings/org.eclipse.core.resources.prefs b/ovsdb/.settings/org.eclipse.core.resources.prefs
index 4c28b1a898a0f0bc507b93f8f5393d172709fe73..8bc0e1c8b512d001245af215a67b67bc6d5b94ba 100755 (executable)
--- a/ovsdb/.settings/org.eclipse.core.resources.prefs
+++ b/ovsdb/.settings/org.eclipse.core.resources.prefs
@@ -1,4 +1,5 @@
 eclipse.preferences.version=1\r
 encoding//src/main/java=UTF-8\r
 encoding//src/test/java=UTF-8\r
+encoding//src/test/resources=UTF-8\r
 encoding/<project>=UTF-8\r

diff --git a/ovsdb/src/main/java/org/opendaylight/ovsdb/lib/message/TableUpdate.java b/ovsdb/src/main/java/org/opendaylight/ovsdb/lib/message/TableUpdate.java
index 1b89ba40aed09c715613f0ee3b5ab675d03d4048..72e4af10fa6472e7f6af7455e8fd031dc0d079e8 100644 (file)
--- a/ovsdb/src/main/java/org/opendaylight/ovsdb/lib/message/TableUpdate.java
+++ b/ovsdb/src/main/java/org/opendaylight/ovsdb/lib/message/TableUpdate.java
@@ -38,7 +38,7 @@ public  class TableUpdate<T extends Table>  {
         return "TableUpdate [map=" + map + "]";
     }
 
-    static class Row<T> {
+    public static class Row<T> {
 
         @JsonIgnore
         String id;

diff --git a/ovsdb/src/main/java/org/opendaylight/ovsdb/lib/message/TransactBuilder.java b/ovsdb/src/main/java/org/opendaylight/ovsdb/lib/message/TransactBuilder.java
index 211b812ffd028f995bdf2eea8239712f8cb94c4c..b3a561683df04e21c6b852dc9e9cd649c7f7e5b3 100644 (file)
--- a/ovsdb/src/main/java/org/opendaylight/ovsdb/lib/message/TransactBuilder.java
+++ b/ovsdb/src/main/java/org/opendaylight/ovsdb/lib/message/TransactBuilder.java
@@ -22,6 +22,10 @@ public class TransactBuilder implements Params {
         return lists;
     }
 
+    public void addOperations (List<Operation> o) {
+        requests.addAll(o);
+    }
+
     public void addOperation (Operation o) {
         requests.add(o);
     }

diff --git a/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/Activator.java b/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/Activator.java
index 0826a00378761fdf5bb817edcaa8fd6f48543098..f308f5e327c5f84ef1c6b18a44d7b107db7cc2fb 100755 (executable)
--- a/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/Activator.java
+++ b/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/Activator.java
@@ -4,7 +4,6 @@ import java.util.Dictionary;
 import java.util.Hashtable;
 
 import org.apache.felix.dm.Component;
-
 import org.opendaylight.controller.sal.networkconfig.bridgedomain.IPluginInBridgeDomainConfigService;
 import org.opendaylight.controller.sal.connection.IPluginInConnectionService;
 import org.opendaylight.controller.sal.core.ComponentActivatorAbstractBase;
@@ -13,8 +12,8 @@ import org.opendaylight.controller.sal.utils.INodeFactory;
 import org.opendaylight.controller.sal.core.Node;
 import org.opendaylight.controller.sal.core.NodeConnector;
 import org.opendaylight.controller.sal.flowprogrammer.IPluginInFlowProgrammerService;
+import org.opendaylight.controller.sal.inventory.IPluginInInventoryService;
 import org.opendaylight.controller.sal.utils.GlobalConstants;
-
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -48,7 +47,7 @@ public class Activator extends ComponentActivatorAbstractBase {
         NodeConnector.NodeConnectorIDType.unRegisterIDType("OVS");
     }
     public Object[] getGlobalImplementations() {
-        Object[] res = { ConnectionService.class, ConfigurationService.class, NodeFactory.class, NodeConnectorFactory.class };
+        Object[] res = { ConnectionService.class, ConfigurationService.class, NodeFactory.class, NodeConnectorFactory.class, InventoryService.class };
         return res;
     }
 
@@ -65,6 +64,10 @@ public class Activator extends ComponentActivatorAbstractBase {
                     .setService(IConnectionServiceInternal.class)
                     .setCallbacks("setConnectionServiceInternal", "unsetConnectionServiceInternal")
                     .setRequired(true));
+            c.add(createServiceDependency()
+                    .setService(InventoryServiceInternal.class)
+                    .setCallbacks("setInventoryServiceInternal", "unsetInventoryServiceInternal")
+                    .setRequired(true));
         }
 
         if (imp.equals(ConnectionService.class)) {
@@ -76,6 +79,18 @@ public class Activator extends ComponentActivatorAbstractBase {
             c.setInterface(
                     new String[] {IPluginInConnectionService.class.getName(),
                                   IConnectionServiceInternal.class.getName()}, props);
+            c.add(createServiceDependency()
+                    .setService(InventoryServiceInternal.class)
+                    .setCallbacks("setInventoryServiceInternal", "unsetInventoryServiceInternal")
+                    .setRequired(true));
+        }
+
+        if (imp.equals(InventoryService.class)) {
+            Dictionary<String, Object> props = new Hashtable<String, Object>();
+            props.put(GlobalConstants.PROTOCOLPLUGINTYPE.toString(), "OVS");
+            c.setInterface(
+                    new String[] {IPluginInInventoryService.class.getName(),
+                            InventoryServiceInternal.class.getName()}, props);
         }
 
         if (imp.equals(NodeFactory.class)) {

diff --git a/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/ConfigurationService.java b/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/ConfigurationService.java
index 7f081769ab909e4f19200c8893ee58996e9cb898..4441a72987393cdf136f5d384892ef52831ceb0e 100755 (executable)
--- a/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/ConfigurationService.java
+++ b/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/ConfigurationService.java
@@ -27,6 +27,7 @@ public class ConfigurationService implements IPluginInBridgeDomainConfigService,
             .getLogger(ConfigurationService.class);
 
     IConnectionServiceInternal connectionService;
+    InventoryServiceInternal inventoryServiceInternal;
     boolean forceConnect = false;
 
     void init() {
@@ -76,6 +77,16 @@ public class ConfigurationService implements IPluginInBridgeDomainConfigService,
         }
     }
 
+    public void setInventoryServiceInternal(InventoryServiceInternal inventoryServiceInternal) {
+        this.inventoryServiceInternal = inventoryServiceInternal;
+    }
+
+    public void unsetInventoryServiceInternal(InventoryServiceInternal inventoryServiceInternal) {
+        if (this.inventoryServiceInternal == inventoryServiceInternal) {
+            this.inventoryServiceInternal = null;
+        }
+    }
+
     private Connection getConnection (Node node) {
         Connection connection = connectionService.getConnection(node);
         if (connection == null || !connection.getChannel().isActive()) {

diff --git a/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/ConnectionService.java b/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/ConnectionService.java
index 14189d20f48f32c5ceb9d0054838883c85bef76d..e94e8988b96043e222bc64ed7f5b316b88aea9c0 100755 (executable)
--- a/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/ConnectionService.java
+++ b/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/ConnectionService.java
@@ -41,6 +41,17 @@ public class ConnectionService implements IPluginInConnectionService, IConnectio
     private static final Integer defaultOvsdbPort = 6632;
     ConcurrentMap<String, Connection> ovsdbConnections;
     List<ChannelHandler> handlers = null;
+    InventoryServiceInternal inventoryServiceInternal;
+
+    public void setInventoryServiceInternal(InventoryServiceInternal inventoryServiceInternal) {
+        this.inventoryServiceInternal = inventoryServiceInternal;
+    }
+
+    public void unsetInventoryServiceInternal(InventoryServiceInternal inventoryServiceInternal) {
+        if (this.inventoryServiceInternal == inventoryServiceInternal) {
+            this.inventoryServiceInternal = null;
+        }
+    }
 
     public void init() {
         ovsdbConnections = new ConcurrentHashMap<String, Connection>();

diff --git a/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/InventoryService.java b/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/InventoryService.java
index 4302bf29f7c47ff3e30656b0099297ad61a54c40..40918d893dcaf1eec135e6d0df5a341888580811 100755 (executable)
--- a/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/InventoryService.java
+++ b/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/InventoryService.java
@@ -1,37 +1,23 @@
 package org.opendaylight.ovsdb.plugin;
 
-import java.net.InetAddress;
-import java.net.UnknownHostException;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.Dictionary;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
+import java.util.Collection;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 
-import org.apache.felix.dm.Component;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-
-import org.opendaylight.controller.sal.core.Actions;
-import org.opendaylight.controller.sal.core.Bandwidth;
-import org.opendaylight.controller.sal.core.Buffers;
-import org.opendaylight.controller.sal.core.Capabilities;
-import org.opendaylight.controller.sal.core.Capabilities.CapabilitiesType;
-import org.opendaylight.controller.sal.core.ConstructionException;
 import org.opendaylight.controller.sal.core.Node;
 import org.opendaylight.controller.sal.core.NodeConnector;
 import org.opendaylight.controller.sal.core.Property;
-import org.opendaylight.controller.sal.core.State;
-import org.opendaylight.controller.sal.core.Tables;
-import org.opendaylight.controller.sal.core.TimeStamp;
 import org.opendaylight.controller.sal.inventory.IPluginInInventoryService;
-import org.opendaylight.controller.sal.utils.NodeCreator;
-import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
+import org.opendaylight.ovsdb.lib.message.TableUpdate;
+import org.opendaylight.ovsdb.lib.message.TableUpdate.Row;
+import org.opendaylight.ovsdb.lib.message.TableUpdates;
+import org.opendaylight.ovsdb.lib.table.internal.Table;
+
+import com.google.common.collect.Maps;
 
 /**
  * Stub Implementation for IPluginInReadService used by SAL
@@ -44,6 +30,7 @@ public class InventoryService implements IPluginInInventoryService, InventorySer
 
     private ConcurrentMap<Node, Map<String, Property>> nodeProps;
     private ConcurrentMap<NodeConnector, Map<String, Property>> nodeConnectorProps;
+    private Map<Node, NodeDB<Table<?>>> dbCache = Maps.newHashMap();
 
     /**
      * Function called by the dependency manager when all the required
@@ -53,11 +40,11 @@ public class InventoryService implements IPluginInInventoryService, InventorySer
     void init() {
         nodeProps = new ConcurrentHashMap<Node, Map<String, Property>>();
         nodeConnectorProps = new ConcurrentHashMap<NodeConnector, Map<String, Property>>();
+        dbCache = new ConcurrentHashMap<Node, NodeDB<Table<?>>>();
         Node.NodeIDType.registerIDType("OVS", String.class);
         NodeConnector.NodeConnectorIDType.registerIDType("OVS", String.class, "OVS");
     }
 
-
     /**
      * Function called by the dependency manager when at least one dependency
      * become unsatisfied or when the component is shutting down because for
@@ -101,4 +88,76 @@ public class InventoryService implements IPluginInInventoryService, InventorySer
         return nodeConnectorProps;
     }
 
+
+    @Override
+    public Map<String, Map<String, Table<?>>> getCache(Node n) {
+        NodeDB<Table<?>> db = dbCache.get(n);
+        if (db == null) return null;
+        return db.getTableCache();
+    }
+
+
+    @Override
+    public Map<String, Table<?>> getTableCache(Node n, String tableName) {
+        NodeDB<Table<?>> db = dbCache.get(n);
+        if (db == null) return null;
+        return db.getTableCache(tableName);
+    }
+
+
+    @Override
+    public Table<?> getRow(Node n, String tableName, String uuid) {
+        NodeDB<Table<?>> db = dbCache.get(n);
+        if (db == null) return null;
+        return db.getRow(tableName, uuid);
+    }
+
+
+    @Override
+    public void updateRow(Node n, String tableName, String uuid, Table<?> row) {
+        NodeDB<Table<?>> db = dbCache.get(n);
+        if (db == null) {
+            db = new NodeDB<Table<?>>();
+            dbCache.put(n, db);
+        }
+        db.updateRow(tableName, uuid, row);
+    }
+
+    @Override
+    public void removeRow(Node n, String tableName, String uuid) {
+        NodeDB<Table<?>> db = dbCache.get(n);
+        if (db != null) db.removeRow(tableName, uuid);
+    }
+
+    @Override
+    public void processTableUpdates(Node n, TableUpdates tableUpdates) {
+        NodeDB<Table<?>> db = dbCache.get(n);
+        if (db == null) {
+            db = new NodeDB<Table<?>>();
+            dbCache.put(n, db);
+        }
+
+        Set<Table.Name> available = tableUpdates.availableUpdates();
+        for (Table.Name name : available) {
+            System.out.println(name.getName() +":"+ tableUpdates.getUpdate(name).toString());
+            TableUpdate tableUpdate = tableUpdates.getUpdate(name);
+            Collection<TableUpdate.Row<?>> rows = tableUpdate.getRows();
+            for (Row<?> row : rows) {
+                String uuid = row.getId();
+                Table<?> newRow = (Table<?>)row.getNew();
+                Table<?> oldRow = (Table<?>)row.getOld();
+                if (newRow != null) {
+                    db.updateRow(name.getName(), uuid, newRow);
+                } else if (oldRow != null) {
+                    db.removeRow(name.getName(), uuid);
+                }
+            }
+        }
+    }
+
+    @Override
+    public void printCache(Node n) {
+        NodeDB<Table<?>> db = dbCache.get(n);
+        if (db != null) db.printTableCache();
+    }
 }

diff --git a/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/InventoryServiceInternal.java b/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/InventoryServiceInternal.java
index 703583fa70af8715933a040f57bced2e1610c46e..ea7587c6cca70fe07675b94038f5fc2e044b6ad5 100644 (file)
--- a/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/InventoryServiceInternal.java
+++ b/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/InventoryServiceInternal.java
@@ -1,5 +1,17 @@
 package org.opendaylight.ovsdb.plugin;
 
-public interface InventoryServiceInternal {
+import java.util.Map;
+
+import org.opendaylight.controller.sal.core.Node;
+import org.opendaylight.ovsdb.lib.message.TableUpdates;
+import org.opendaylight.ovsdb.lib.table.internal.Table;
 
+public interface InventoryServiceInternal {
+    public Map<String, Map<String, Table<?>>> getCache(Node n);
+    public Map<String, Table<?>> getTableCache(Node n, String tableName);
+    public Table<?> getRow (Node n, String tableName, String uuid);
+    public void updateRow(Node n, String tableName, String uuid, Table<?> row);
+    public void removeRow(Node n, String tableName, String uuid);
+    public void processTableUpdates(Node n, TableUpdates tableUpdates);
+    public void printCache(Node n);
 }

diff --git a/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/NodeDB.java b/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/NodeDB.java
new file mode 100644 (file)
index 0000000..29ed901
--- /dev/null
+++ b/ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/NodeDB.java
@@ -0,0 +1,50 @@
+package org.opendaylight.ovsdb.plugin;
+
+import java.util.Map;
+
+import com.google.common.collect.Maps;
+import org.opendaylight.ovsdb.lib.table.internal.Table;
+
+public class NodeDB <T extends Table<?>>{
+    Map<String, Map<String, T>> cache = Maps.newHashMap();
+
+    public Map<String, Map<String, T>> getTableCache() {
+        return cache;
+    }
+
+    public Map<String, T> getTableCache(String tableName) {
+        return cache.get(tableName);
+    }
+
+    private void setTableCache(String tableName,  Map<String, T> tableCache) {
+        cache.put(tableName, tableCache);
+    }
+
+    public T getRow (String tableName, String uuid) {
+        Map<String, T> tableCache = getTableCache(tableName);
+        if (tableCache != null) {
+            return tableCache.get(uuid);
+        }
+        return null;
+    }
+
+    public void updateRow(String tableName, String uuid, T row) {
+        Map<String, T> tableCache = getTableCache(tableName);
+        if (tableCache == null) {
+            tableCache = Maps.newHashMap();
+            setTableCache(tableName, tableCache);
+        }
+        tableCache.put(uuid, row);
+    }
+
+    public void removeRow(String tableName, String uuid) {
+        Map<String, T> tableCache = getTableCache(tableName);
+        if (tableCache != null) {
+            tableCache.remove(uuid);
+        }
+    }
+
+    public void printTableCache() {
+        System.out.println(cache.toString());
+    }
+}

diff --git a/ovsdb/src/test/java/org/opendaylight/ovsdb/lib/message/OVSDBNettyFactoryTest.java b/ovsdb/src/test/java/org/opendaylight/ovsdb/lib/message/OVSDBNettyFactoryTest.java
index 3d3aa92270595d21a695be0d7138a474c0a51ecd..f80dbc229fe1c6441c95f7827252cb16c703b79f 100644 (file)
--- a/ovsdb/src/test/java/org/opendaylight/ovsdb/lib/message/OVSDBNettyFactoryTest.java
+++ b/ovsdb/src/test/java/org/opendaylight/ovsdb/lib/message/OVSDBNettyFactoryTest.java
@@ -1,7 +1,5 @@
 package org.opendaylight.ovsdb.lib.message;
 
-import com.fasterxml.jackson.annotation.JsonAutoDetect;
-import com.fasterxml.jackson.annotation.PropertyAccessor;
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.collect.Lists;
@@ -12,7 +10,6 @@ import io.netty.handler.codec.string.StringEncoder;
 import io.netty.handler.logging.LogLevel;
 import io.netty.handler.logging.LoggingHandler;
 import io.netty.util.CharsetUtil;
-import junit.framework.TestCase;
 
 import org.junit.Test;
 import org.opendaylight.controller.sal.connection.ConnectionConstants;
@@ -21,28 +18,32 @@ import org.opendaylight.ovsdb.lib.database.DatabaseSchema;
 import org.opendaylight.ovsdb.lib.jsonrpc.JsonRpcDecoder;
 import org.opendaylight.ovsdb.lib.jsonrpc.JsonRpcEndpoint;
 import org.opendaylight.ovsdb.lib.jsonrpc.JsonRpcServiceBinderHandler;
-import org.opendaylight.ovsdb.lib.message.EchoResponse;
 import org.opendaylight.ovsdb.lib.message.MonitorRequestBuilder;
 import org.opendaylight.ovsdb.lib.message.OVSDB;
 import org.opendaylight.ovsdb.lib.message.TableUpdates;
 import org.opendaylight.ovsdb.lib.message.operations.InsertOperation;
+import org.opendaylight.ovsdb.lib.message.operations.MutateOperation;
+import org.opendaylight.ovsdb.lib.message.operations.Operation;
+import org.opendaylight.ovsdb.lib.notation.Condition;
+import org.opendaylight.ovsdb.lib.notation.Function;
+import org.opendaylight.ovsdb.lib.notation.Mutation;
+import org.opendaylight.ovsdb.lib.notation.Mutator;
+import org.opendaylight.ovsdb.lib.table.Bridge;
+import org.opendaylight.ovsdb.lib.table.Interface;
 import org.opendaylight.ovsdb.lib.table.Open_vSwitch;
+import org.opendaylight.ovsdb.lib.table.Port;
 import org.opendaylight.ovsdb.lib.table.internal.Table;
 import org.opendaylight.ovsdb.lib.table.internal.Tables;
 import org.opendaylight.ovsdb.plugin.ConnectionService;
-import org.opendaylight.ovsdb.plugin.InsertRequest;
-import org.opendaylight.ovsdb.plugin.MessageHandler;
-import org.opendaylight.ovsdb.plugin.MutateRequest;
+import org.opendaylight.ovsdb.plugin.InventoryService;
+import org.opendaylight.ovsdb.plugin.InventoryServiceInternal;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-
 
 public class OVSDBNettyFactoryTest {
 
@@ -50,6 +51,7 @@ public class OVSDBNettyFactoryTest {
     public void testSome() throws InterruptedException, ExecutionException {
 
         ConnectionService service = new ConnectionService();
+        InventoryServiceInternal inventoryService = new InventoryService();
         ObjectMapper objectMapper = new ObjectMapper();
         objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
         JsonRpcEndpoint factory = new JsonRpcEndpoint(objectMapper, service);
@@ -76,72 +78,95 @@ public class OVSDBNettyFactoryTest {
         OVSDB ovsdb = factory.getClient(node, OVSDB.class);
 
         //GET DB-SCHEMA
-        List<String> dbNames = Arrays.asList("Open_vSwitch");
+        List<String> dbNames = Arrays.asList(Open_vSwitch.NAME.getName());
         ListenableFuture<DatabaseSchema> dbSchemaF = ovsdb.get_schema(dbNames);
         DatabaseSchema databaseSchema = dbSchemaF.get();
         System.out.println(databaseSchema);
 
         //TEST MONITOR
         MonitorRequestBuilder monitorReq = new MonitorRequestBuilder();
-        for (Table table : Tables.getTables()) {
+        for (Table<?> table : Tables.getTables()) {
             monitorReq.monitor(table);
         }
 
         ListenableFuture<TableUpdates> monResponse = ovsdb.monitor(monitorReq);
         System.out.println("Monitor Request sent :");
         TableUpdates updates = monResponse.get();
-
-        Set<Table.Name> available = updates.availableUpdates();
-        for (Table.Name name : available) {
-            System.out.println(name.getName() +":"+ updates.getUpdate(name).toString());
-        }
-
+        inventoryService.processTableUpdates(node, updates);
+        inventoryService.printCache(node);
         // TRANSACT INSERT TEST
 
-        /*
-        Map<String, Object> vswitchRow = new HashMap<String, Object>();
-        Map<String, Object> bridgeRow = new HashMap<String, Object>();
-        bridgeRow.put("name", "br2");
-        TransactBuilder transaction = new TransactBuilder();
-        InsertOperation addBridge = new InsertOperation("Bridge", "br2", bridgeRow);
+        Map<String, Table<?>> ovsTable = inventoryService.getTableCache(node, Open_vSwitch.NAME.getName());
+        String newBridge = "new_bridge";
+        String newInterface = "new_interface";
+        String newPort = "new_port";
+        String newSwitch = "new_switch";
 
-        transaction.addOperation(addBridge);
+        String bridgeIdentifier = "br6";
+        Operation addSwitchRequest = null;
 
-        ListenableFuture<List<Object>> transResponse = ovsdb.transact(transaction);
-        System.out.println("Transcation sent :");
-        Object tr = transResponse.get();
-        System.out.println(tr.toString());
-        */
+        if(ovsTable != null){
+            String ovsTableUUID = (String) ovsTable.keySet().toArray()[0];
+            List<String> bridgeUuidPair = new ArrayList<String>();
+            bridgeUuidPair.add("named-uuid");
+            bridgeUuidPair.add(newBridge);
 
-        // TRANSACT MUTATE TEST
-        /*
-        List<String> bridgeUuidPair = new ArrayList<String>();
-        bridgeUuidPair.add("named-uuid");
-        bridgeUuidPair.add(newBridge);
+            Mutation bm = new Mutation("bridges", Mutator.INSERT, bridgeUuidPair);
+            List<Mutation> mutations = new ArrayList<Mutation>();
+            mutations.add(bm);
 
-        List<Object> mutation = new ArrayList<Object>();
-        mutation.add("bridges");
-        mutation.add("insert");
-        mutation.add(bridgeUuidPair);
+            List<String> uuid = new ArrayList<String>();
+            uuid.add("uuid");
+            uuid.add(ovsTableUUID);
 
-        List<Object> mutations = new ArrayList<Object>();
-        mutations.add(mutation);
+            //UUID uuid = new UUID(ovsTableUUID);
+            Condition condition = new Condition("_uuid", Function.EQUALS, uuid);
 
-        List<String> ovsUuidPair = new ArrayList<String>();
-        ovsUuidPair.add("uuid");
-        ovsUuidPair.add(instance.getUuid());
+            List<Condition> where = new ArrayList<Condition>();
+            where.add(condition);
 
-        List<Object> whereInner = new ArrayList<Object>();
-        whereInner.add("_uuid");
-        whereInner.add("==");
-        whereInner.add(ovsUuidPair);
+            addSwitchRequest = new MutateOperation(Open_vSwitch.NAME.getName(), where, mutations);
+        }
+        else{
+            Map<String, Object> vswitchRow = new HashMap<String, Object>();
+            ArrayList<String> bridges = new ArrayList<String>();
+            bridges.add("named-uuid");
+            bridges.add(newBridge);
+            vswitchRow.put("bridges", bridges);
+            addSwitchRequest = new InsertOperation(Open_vSwitch.NAME.getName(), newSwitch, vswitchRow);
+        }
 
-        List<Object> where = new ArrayList<Object>();
-        where.add(whereInner);
+        Map<String, Object> bridgeRow = new HashMap<String, Object>();
+        bridgeRow.put("name", bridgeIdentifier);
+        ArrayList<String> ports = new ArrayList<String>();
+        ports.add("named-uuid");
+        ports.add(newPort);
+        bridgeRow.put("ports", ports);
+        InsertOperation addBridgeRequest = new InsertOperation(Bridge.NAME.getName(), newBridge, bridgeRow);
+
+        Map<String, Object> portRow = new HashMap<String, Object>();
+        portRow.put("name", bridgeIdentifier);
+        ArrayList<String> interfaces = new ArrayList<String>();
+        interfaces.add("named-uuid");
+        interfaces.add(newInterface);
+        portRow.put("interfaces", interfaces);
+        InsertOperation addPortRequest = new InsertOperation(Port.NAME.getName(), newPort, portRow);
+
+        Map<String, Object> interfaceRow = new HashMap<String, Object>();
+        interfaceRow.put("name", bridgeIdentifier);
+        interfaceRow.put("type", "internal");
+        InsertOperation addIntfRequest = new InsertOperation(Interface.NAME.getName(), newInterface, interfaceRow);
+
+        TransactBuilder transaction = new TransactBuilder();
+        transaction.addOperations(new ArrayList<Operation>(
+                                  Arrays.asList(addSwitchRequest, addIntfRequest, addPortRequest, addBridgeRequest)));
 
-        addSwitchRequest = new MutateRequest("Open_vSwitch", where, mutations);
-         */
+        ListenableFuture<List<Object>> transResponse = ovsdb.transact(transaction);
+        System.out.println("Transcation sent :");
+        Object tr = transResponse.get();
+        System.out.println(tr.toString());
         // TEST ECHO
+
         ListenableFuture<List<String>> some = ovsdb.echo();
         Object s = some.get();
         System.out.printf("Result of echo is %s \n", s);