ovsdb/src/test/java/org/opendaylight/ovsdb/lib/message/OVSDBNettyFactoryTest.java

   1 package org.opendaylight.ovsdb.lib.message;
   2
   3 import com.google.common.util.concurrent.ListenableFuture;
   4
   5 import org.apache.commons.collections.MapUtils;
   6 import org.junit.Test;
   7 import org.opendaylight.controller.sal.connection.ConnectionConstants;
   8 import org.opendaylight.controller.sal.core.Node;
   9 import org.opendaylight.ovsdb.lib.database.DatabaseSchema;
  10 import org.opendaylight.ovsdb.lib.message.MonitorRequestBuilder;
  11 import org.opendaylight.ovsdb.lib.message.OvsdbRPC;
  12 import org.opendaylight.ovsdb.lib.message.TableUpdates;
  13 import org.opendaylight.ovsdb.lib.message.operations.InsertOperation;
  14 import org.opendaylight.ovsdb.lib.message.operations.MutateOperation;
  15 import org.opendaylight.ovsdb.lib.message.operations.Operation;
  16 import org.opendaylight.ovsdb.lib.message.operations.OperationResult;
  17 import org.opendaylight.ovsdb.lib.notation.Condition;
  18 import org.opendaylight.ovsdb.lib.notation.Function;
  19 import org.opendaylight.ovsdb.lib.notation.Mutation;
  20 import org.opendaylight.ovsdb.lib.notation.Mutator;
  21 import org.opendaylight.ovsdb.lib.notation.OvsDBSet;
  22 import org.opendaylight.ovsdb.lib.notation.UUID;
  23 import org.opendaylight.ovsdb.lib.table.Bridge;
  24 import org.opendaylight.ovsdb.lib.table.Interface;
  25 import org.opendaylight.ovsdb.lib.table.Open_vSwitch;
  26 import org.opendaylight.ovsdb.lib.table.Port;
  27 import org.opendaylight.ovsdb.lib.table.internal.Table;
  28 import org.opendaylight.ovsdb.lib.table.internal.Tables;
  29 import org.opendaylight.ovsdb.plugin.Connection;
  30 import org.opendaylight.ovsdb.plugin.ConnectionService;
  31 import org.opendaylight.ovsdb.plugin.InventoryService;
  32
  33 import java.util.ArrayList;
  34 import java.util.Arrays;
  35 import java.util.HashMap;
  36 import java.util.List;
  37 import java.util.Map;
  38 import java.util.concurrent.ExecutionException;
  39
  40 public class OVSDBNettyFactoryTest {
  41     InventoryService inventoryService;
  42     private static String bridgeIdentifier = "br1";
  43
  44     @Test
  45     public void testSome() throws InterruptedException, ExecutionException {
  46         ConnectionService connectionService = new ConnectionService();
  47         connectionService.init();
  48         inventoryService = new InventoryService();
  49         inventoryService.init();
  50         connectionService.setInventoryServiceInternal(inventoryService);
  51         Node.NodeIDType.registerIDType("OVS", String.class);
  52         Map<ConnectionConstants, String> params = new HashMap<ConnectionConstants, String>();
  53         params.put(ConnectionConstants.ADDRESS, "192.168.56.101");
  54         params.put(ConnectionConstants.PORT, "6634");
  55         Node node = connectionService.connect("TEST", params);
  56         if (node == null) {
  57             System.out.println("ERROR : Unable to connect to the host");
  58             return;
  59         }
  60
  61         Connection connection = connectionService.getConnection(node);
  62         if (connection == null) {
  63             System.out.println("ERROR : Unable to connect to the host");
  64             return;
  65         }
  66
  67         OvsdbRPC ovsdb = connection.getRpc();
  68         if (ovsdb == null) {
  69             System.out.println("ERROR : Unable to obtain RPC instance");
  70             return;
  71         }
  72
  73         //GET DB-SCHEMA
  74         List<String> dbNames = Arrays.asList(Open_vSwitch.NAME.getName());
  75         ListenableFuture<DatabaseSchema> dbSchemaF = ovsdb.get_schema(dbNames);
  76         DatabaseSchema databaseSchema = dbSchemaF.get();
  77         MapUtils.debugPrint(System.out, null, databaseSchema.getTables());
  78
  79         // TEST MONITOR
  80         // YES it is expected to fail with "duplicate monitor ID" as we have a perpetual monitor in Inventory Service
  81         MonitorRequestBuilder monitorReq = new MonitorRequestBuilder();
  82         for (Table<?> table : Tables.getTables()) {
  83             monitorReq.monitor(table);
  84         }
  85
  86         ListenableFuture<TableUpdates> monResponse = ovsdb.monitor(monitorReq);
  87         System.out.println("Monitor Request sent :");
  88         TableUpdates updates = monResponse.get();
  89         inventoryService.processTableUpdates(node, updates);
  90         inventoryService.printCache(node);
  91
  92         // TRANSACT INSERT TEST
  93
  94         Map<String, Table<?>> ovsTable = inventoryService.getTableCache(node, Open_vSwitch.NAME.getName());
  95         String newBridge = "new_bridge";
  96         String newInterface = "new_interface";
  97         String newPort = "new_port";
  98         String newSwitch = "new_switch";
  99
 100         Operation addSwitchRequest = null;
 101
 102         if(ovsTable != null){
 103             String ovsTableUUID = (String) ovsTable.keySet().toArray()[0];
 104             UUID bridgeUuidPair = new UUID(newBridge);
 105             Mutation bm = new Mutation("bridges", Mutator.INSERT, bridgeUuidPair);
 106             List<Mutation> mutations = new ArrayList<Mutation>();
 107             mutations.add(bm);
 108
 109             UUID uuid = new UUID(ovsTableUUID);
 110             Condition condition = new Condition("_uuid", Function.EQUALS, uuid);
 111             List<Condition> where = new ArrayList<Condition>();
 112             where.add(condition);
 113             addSwitchRequest = new MutateOperation(Open_vSwitch.NAME.getName(), where, mutations);
 114         }
 115         else{
 116             Open_vSwitch ovsTableRow = new Open_vSwitch();
 117             OvsDBSet<UUID> bridges = new OvsDBSet<UUID>();
 118             UUID bridgeUuidPair = new UUID(newBridge);
 119             bridges.add(bridgeUuidPair);
 120             ovsTableRow.setBridges(bridges);
 121             addSwitchRequest = new InsertOperation(Open_vSwitch.NAME.getName(), newSwitch, ovsTableRow);
 122         }
 123
 124         Bridge bridgeRow = new Bridge();
 125         bridgeRow.setName(bridgeIdentifier);
 126         OvsDBSet<UUID> ports = new OvsDBSet<UUID>();
 127         UUID port = new UUID(newPort);
 128         ports.add(port);
 129         bridgeRow.setPorts(ports);
 130         InsertOperation addBridgeRequest = new InsertOperation(Bridge.NAME.getName(), newBridge, bridgeRow);
 131
 132         Port portRow = new Port();
 133         portRow.setName(bridgeIdentifier);
 134         OvsDBSet<UUID> interfaces = new OvsDBSet<UUID>();
 135         UUID interfaceid = new UUID(newInterface);
 136         interfaces.add(interfaceid);
 137         portRow.setInterfaces(interfaces);
 138         InsertOperation addPortRequest = new InsertOperation(Port.NAME.getName(), newPort, portRow);
 139
 140         Interface interfaceRow = new Interface();
 141         interfaceRow.setName(bridgeIdentifier);
 142         interfaceRow.setType("internal");
 143         InsertOperation addIntfRequest = new InsertOperation(Interface.NAME.getName(), newInterface, interfaceRow);
 144
 145         TransactBuilder transaction = new TransactBuilder();
 146         transaction.addOperations(new ArrayList<Operation>(
 147                                   Arrays.asList(addSwitchRequest, addIntfRequest, addPortRequest, addBridgeRequest)));
 148
 149         ListenableFuture<List<OperationResult>> transResponse = ovsdb.transact(transaction);
 150         System.out.println("Transcation sent :");
 151         List<OperationResult> tr = transResponse.get();
 152         System.out.println("Transaction response : "+transResponse.toString());
 153         List<Operation> requests = transaction.getRequests();
 154         for (int i = 0; i < tr.size() ; i++) {
 155             if (i < requests.size()) requests.get(i).setResult(tr.get(i));
 156         }
 157
 158         System.out.println("Request + Response : "+requests.toString());
 159         if (tr.size() > requests.size()) {
 160             System.out.println("ERROR : "+tr.get(tr.size()-1).getError());
 161             System.out.println("Details : "+tr.get(tr.size()-1).getDetails());
 162         }
 163
 164         // TEST ECHO
 165
 166         ListenableFuture<List<String>> some = ovsdb.echo();
 167         Object s = some.get();
 168         System.out.printf("Result of echo is %s \n", s);
 169
 170         // TEST ECHO REQUEST/REPLY
 171         Thread.sleep(10000);
 172
 173         connectionService.disconnect(node);
 174     }
 175 }