X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=library%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fovsdb%2Flib%2FOvsDBClientTestIT.java;h=799f04e6766abc904de95314f0db4e45d23666f7;hb=31de2f97a43518ecc501b8ee0137617baf6f2778;hp=de49027e4806a8660ed62e8b9c11b2a3106181f5;hpb=ecf5258213b48dd8efe7fffcd494e772d7fede60;p=ovsdb.git diff --git a/library/src/test/java/org/opendaylight/ovsdb/lib/OvsDBClientTestIT.java b/library/src/test/java/org/opendaylight/ovsdb/lib/OvsDBClientTestIT.java index de49027e4..799f04e67 100644 --- a/library/src/test/java/org/opendaylight/ovsdb/lib/OvsDBClientTestIT.java +++ b/library/src/test/java/org/opendaylight/ovsdb/lib/OvsDBClientTestIT.java @@ -9,20 +9,19 @@ */ package org.opendaylight.ovsdb.lib; -import com.google.common.collect.Lists; -import com.google.common.collect.Sets; -import com.google.common.util.concurrent.ListenableFuture; import static org.opendaylight.ovsdb.lib.operations.Operations.op; import java.io.IOException; import java.util.List; import java.util.Map; +import java.util.Set; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import junit.framework.Assert; +import org.junit.After; import org.junit.Before; import org.junit.Test; import org.opendaylight.ovsdb.lib.message.MonitorRequest; @@ -32,7 +31,10 @@ import org.opendaylight.ovsdb.lib.message.OvsdbRPC; import org.opendaylight.ovsdb.lib.message.TableUpdate; import org.opendaylight.ovsdb.lib.message.TableUpdates; import org.opendaylight.ovsdb.lib.message.UpdateNotification; +import org.opendaylight.ovsdb.lib.notation.Column; import org.opendaylight.ovsdb.lib.notation.Mutator; +import org.opendaylight.ovsdb.lib.notation.Row; +import org.opendaylight.ovsdb.lib.notation.UUID; import org.opendaylight.ovsdb.lib.operations.OperationResult; import org.opendaylight.ovsdb.lib.schema.ColumnSchema; import org.opendaylight.ovsdb.lib.schema.DatabaseSchema; @@ -41,93 +43,48 @@ import org.opendaylight.ovsdb.lib.schema.TableSchema; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import java.util.Set; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import com.google.common.collect.Sets; +import com.google.common.util.concurrent.ListenableFuture; public class OvsDBClientTestIT extends OvsdbTestBase { Logger logger = LoggerFactory.getLogger(OvsDBClientTestIT.class); OvsDBClientImpl ovs; - + DatabaseSchema dbSchema = null; + static String testBridgeName = "br-test"; + static UUID testBridgeUuid = null; @Test public void testTransact() throws IOException, InterruptedException, ExecutionException { - - ListenableFuture schema = ovs.getSchema(OvsDBClient.OPEN_VSWITCH_SCHEMA, true); - TableSchema bridge = schema.get().table("Bridge", GenericTableSchema.class); - - for (Map.Entry names : bridge.getColumnSchemas().entrySet()) { - System.out.println("names = " + names.getKey()); - System.out.println("names.getValue().getType() = " + names.getValue().getType().getBaseType()); - } - + Assert.assertNotNull(dbSchema); + TableSchema bridge = dbSchema.table("Bridge", GenericTableSchema.class); ColumnSchema name = bridge.column("name", String.class); - ColumnSchema fail_mode = bridge.column("fail_mode", String.class); - ColumnSchema> flood_vlans = bridge.multiValuedColumn("flood_vlans", Integer.class); - - ListenableFuture> results = ovs.transactBuilder() - .add(op.insert(bridge) - .value(name, "br-int") - .value(flood_vlans, Sets.newHashSet(100, 101, 4001)) - ) - .add(op.update(bridge) - .set(fail_mode, "secure") - .where(name.opEqual("br-int")) - .operation()) - .add(op.select(bridge) - .column(name) - .where(name.opEqual("br-int")) - .operation()) - .add(op.mutate(bridge) - .addMutation(flood_vlans, Mutator.INSERT, Sets.newHashSet(100, 101, 4001)) - .where(name.opEqual("br-int")) - .operation()) - .add(op.commit(true)) - .execute(); - - List operationResults = results.get(); - Assert.assertFalse(operationResults.isEmpty()); - System.out.println("Insert & Update operation results = " + operationResults); - - results = ovs.transactBuilder() - .add(op.delete(bridge) - .where(name.opEqual("br-int")) - .operation()) - .add(op.commit(true)) - .execute(); - - operationResults = results.get(); - Assert.assertFalse(operationResults.isEmpty()); - System.out.println("Delete operation results = " + operationResults); - - /* - * Adding a separate Abort operation in a transaction. Lets not mix this with other - * valid transactions as above. - */ - results = ovs.transactBuilder() - .add(op.delete(bridge) - .where(name.opEqual("br-int")) - .operation()) - .add(op.abort()) - .execute(); - - operationResults = results.get(); - Assert.assertFalse(operationResults.isEmpty()); - System.out.println("Abort operation results = " + operationResults); + createBridgeTransaction(); + abortTransaction(); + assertTransaction(); } @Test - public void testMonitorRequest() throws ExecutionException, InterruptedException { + public void testMonitorRequest() throws ExecutionException, InterruptedException, IOException { + Assert.assertNotNull(dbSchema); + // Create Test Bridge before testing the Monitor operation + createBridgeTransaction(); - DatabaseSchema dbSchema = ovs.getSchema(OvsDBClient.OPEN_VSWITCH_SCHEMA, true).get(); GenericTableSchema bridge = dbSchema.table("Bridge", GenericTableSchema.class); List> monitorRequests = Lists.newArrayList(); + ColumnSchema> flood_vlans = bridge.multiValuedColumn("flood_vlans", Integer.class); + ColumnSchema> externalIds = bridge.multiValuedColumn("external_ids", String.class, String.class); monitorRequests.add( MonitorRequestBuilder.builder(bridge) .addColumn(bridge.column("name")) .addColumn(bridge.column("fail_mode", String.class)) - .addColumn(bridge.multiValuedColumn("flood_vlans", Integer.class)) + .addColumn(flood_vlans) + .addColumn(externalIds) .with(new MonitorSelect(true, true, true, true)) .build()); @@ -147,28 +104,222 @@ public class OvsDBClientTestIT extends OvsdbTestBase { } }); - for (int i = 0; i < 5 ; i++) { //wait 5 seconds to get a result - System.out.println("waiting"); + for (int i = 0; i < 3 ; i++) { //wait 3 seconds to get a result + System.out.println("waiting on monitor response for Bridge Table..."); + if (!results.isEmpty()) break; Thread.sleep(1000); } Assert.assertTrue(!results.isEmpty()); Object result = results.get(0); Assert.assertTrue(result instanceof TableUpdates); - TableUpdate bridgeUpdate = ((TableUpdates) result).getUpdate(bridge); - Assert.assertNotNull(bridgeUpdate); + TableUpdates updates = (TableUpdates) result; + TableUpdate update = updates.getUpdate(bridge); + Row aNew = update.getNew(); + for (Column column: aNew.getColumns()) { + if (column.getSchema().equals(flood_vlans)) { + // Test for the 5 flood_vlans inserted in Bridge br-test in createBridgeTransaction + Set data = column.getData(flood_vlans); + Assert.assertTrue(!data.isEmpty()); + Assert.assertEquals(5, data.size()); + } else if (column.getSchema().equals(externalIds)) { + // Test for the {"key", "value"} external_ids inserted in Bridge br-test in createBridgeTransaction + Map data = column.getData(externalIds); + Assert.assertNotNull(data.get("key")); + Assert.assertEquals("value", data.get("key")); + } + } + } + + /* + * Ideally we should be using selectOpenVSwitchTableUuid() instead of this method. + * But Row.java needs some Jackson Jitsu to obtain the appropriate Row Json mapped to Java object + * for Select operation. + * Hence using the Monitor approach to obtain the uuid of the open_vSwitch table entry. + * Replace this method with selectOpenVSwitchTableUuid() once it is functional, + */ + private UUID getOpenVSwitchTableUuid() throws ExecutionException, InterruptedException { + Assert.assertNotNull(dbSchema); + GenericTableSchema ovsTable = dbSchema.table("Open_vSwitch", GenericTableSchema.class); + List> monitorRequests = Lists.newArrayList(); + ColumnSchema _uuid = ovsTable.column("_uuid", UUID.class); + + monitorRequests.add( + MonitorRequestBuilder.builder(ovsTable) + .addColumn(_uuid) + .with(new MonitorSelect(true, true, true, true)) + .build()); + + final List results = Lists.newArrayList(); + + MonitorHandle monitor = ovs.monitor(dbSchema, monitorRequests, new MonitorCallBack() { + @Override + public void update(TableUpdates result) { + results.add(result); + } + + @Override + public void exception(Throwable t) { + results.add(t); + System.out.println("t = " + t); + } + }); + + for (int i = 0; i < 3 ; i++) { //wait 5 seconds to get a result + System.out.println("waiting on monitor response for open_vSwtich Table..."); + if (!results.isEmpty()) break; + Thread.sleep(1000); + } + + Assert.assertTrue(!results.isEmpty()); + Object result = results.get(0); // open_vSwitch table has just 1 row. + Assert.assertTrue(result instanceof TableUpdates); + TableUpdates updates = (TableUpdates) result; + TableUpdate update = updates.getUpdate(ovsTable); + return update.getUuid(); + } + + /* + * TODO : selectOpenVSwitchTableUuid method isn't working as expected due to the Jackson + * parsing challenges on the Row object returned by the Select operation. + */ + private UUID selectOpenVSwitchTableUuid() throws ExecutionException, InterruptedException { + Assert.assertNotNull(dbSchema); + GenericTableSchema ovsTable = dbSchema.table("Open_vSwitch", GenericTableSchema.class); + + List> monitorRequests = Lists.newArrayList(); + ColumnSchema _uuid = ovsTable.column("_uuid", UUID.class); + + List results = ovs.transactBuilder() + .add(op.select(ovsTable) + .column(_uuid)) + .execute() + .get(); + + Assert.assertTrue(!results.isEmpty()); + OperationResult result = results.get(0); + List> rows = result.getRows(); + Row ovsTableRow = rows.get(0); + return ovsTableRow.getColumn(_uuid).getData(); + } + + private void createBridgeTransaction() throws IOException, InterruptedException, ExecutionException { + Assert.assertNotNull(dbSchema); + TableSchema bridge = dbSchema.table("Bridge", GenericTableSchema.class); + GenericTableSchema ovsTable = dbSchema.table("Open_vSwitch", GenericTableSchema.class); + + ColumnSchema name = bridge.column("name", String.class); + ColumnSchema fail_mode = bridge.column("fail_mode", String.class); + ColumnSchema> flood_vlans = bridge.multiValuedColumn("flood_vlans", Integer.class); + ColumnSchema> externalIds = bridge.multiValuedColumn("external_ids", String.class, String.class); + ColumnSchema> bridges = ovsTable.multiValuedColumn("bridges", UUID.class); + ColumnSchema _uuid = ovsTable.column("_uuid", UUID.class); + + String namedUuid = "br_test"; + int nOperations = 7; + int insertOperationIndex = 0; + UUID parentTable = getOpenVSwitchTableUuid(); + ListenableFuture> results = ovs.transactBuilder() + /* + * Make sure that the position of insert operation matches the insertOperationIndex. + * This will be used later when the Results are processed. + */ + .add(op.insert(bridge) + .withId(namedUuid) + .value(name, testBridgeName) + .value(flood_vlans, Sets.newHashSet(100, 101, 4001)) + .value(externalIds, Maps.newHashMap(ImmutableMap.of("key","value")))) + .add(op.comment("Inserting Bridge br-int")) + .add(op.update(bridge) + .set(fail_mode, "secure") + .where(name.opEqual(testBridgeName)) + .build()) + .add(op.select(bridge) + .column(name) + .column(_uuid) + .where(name.opEqual(testBridgeName)) + .build()) + .add(op.mutate(bridge) + .addMutation(flood_vlans, Mutator.INSERT, Sets.newHashSet(200,400)) + .where(name.opEqual(testBridgeName)) + .build()) + .add(op.mutate(ovsTable) + .addMutation(bridges, Mutator.INSERT, Sets.newHashSet(new UUID(namedUuid))) + .where(_uuid.opEqual(parentTable)) + .build()) + .add(op.commit(true)) + .execute(); + + List operationResults = results.get(); + Assert.assertFalse(operationResults.isEmpty()); + // Check if Results matches the number of operations in transaction + Assert.assertEquals(nOperations, operationResults.size()); + System.out.println("Insert & Update operation results = " + operationResults); + testBridgeUuid = operationResults.get(insertOperationIndex).getUuid(); + } + + private void assertTransaction() throws InterruptedException, ExecutionException { + Assert.assertNotNull(dbSchema); + TableSchema bridge = dbSchema.table("Bridge", GenericTableSchema.class); + ColumnSchema name = bridge.column("name", String.class); + + /* + * Adding a separate Assert operation in a transaction. Lets not mix this with other + * valid transactions as above. + */ + ListenableFuture> results = ovs.transactBuilder() + .add(op.delete(bridge) + .where(name.opEqual(testBridgeName)) + .build()) + .add(op.assertion("Assert12345")) // Failing intentionally + .execute(); + + List operationResults = results.get(); + Assert.assertFalse(operationResults.isEmpty()); + /* Testing for an Assertion Error */ + Assert.assertFalse(operationResults.get(1).getError() == null); + System.out.println("Assert operation results = " + operationResults); + } + + private void abortTransaction() throws InterruptedException, ExecutionException { + Assert.assertNotNull(dbSchema); + TableSchema bridge = dbSchema.table("Bridge", GenericTableSchema.class); + ColumnSchema name = bridge.column("name", String.class); + + /* + * Adding a separate Abort operation in a transaction. Lets not mix this with other + * valid transactions as above. + */ + ListenableFuture> results = ovs.transactBuilder() + .add(op.delete(bridge) + .where(name.opEqual(testBridgeName)) + .build()) + .add(op.abort()) + .execute(); + + List operationResults = results.get(); + Assert.assertFalse(operationResults.isEmpty()); + /* Testing for Abort Error */ + Assert.assertFalse(operationResults.get(1).getError() == null); + System.out.println("Abort operation results = " + operationResults); } - @Test public void testGetDBs() throws ExecutionException, InterruptedException { ListenableFuture> databases = ovs.getDatabases(); List dbNames = databases.get(); Assert.assertNotNull(dbNames); - Assert.assertTrue(dbNames.size() > 0); + boolean hasOpenVswitchSchema = false; + for(String dbName : dbNames) { + if (dbName.equals(OPEN_VSWITCH_SCHEMA)) { + hasOpenVswitchSchema = true; + break; + } + } + Assert.assertTrue(OPEN_VSWITCH_SCHEMA+" schema is not supported by the switch", hasOpenVswitchSchema); } @Before - public void initalize() throws IOException { + public void setUp() throws IOException, ExecutionException, InterruptedException { if (ovs != null) { return; } @@ -178,6 +329,32 @@ public class OvsDBClientTestIT extends OvsdbTestBase { } ExecutorService executorService = Executors.newFixedThreadPool(3); ovs = new OvsDBClientImpl(rpc, executorService); + testGetDBs(); + dbSchema = ovs.getSchema(OPEN_VSWITCH_SCHEMA, true).get(); + } + + @After + public void tearDown() throws InterruptedException, ExecutionException { + TableSchema bridge = dbSchema.table("Bridge", GenericTableSchema.class); + ColumnSchema name = bridge.column("name", String.class); + GenericTableSchema ovsTable = dbSchema.table("Open_vSwitch", GenericTableSchema.class); + ColumnSchema> bridges = ovsTable.multiValuedColumn("bridges", UUID.class); + ColumnSchema _uuid = ovsTable.column("_uuid", UUID.class); + UUID parentTable = getOpenVSwitchTableUuid(); + + ListenableFuture> results = ovs.transactBuilder() + .add(op.delete(bridge) + .where(name.opEqual(testBridgeName)) + .build()) + .add(op.mutate(ovsTable) + .addMutation(bridges, Mutator.DELETE, Sets.newHashSet(testBridgeUuid)) + .where(_uuid.opEqual(parentTable)) + .build()) + .add(op.commit(true)) + .execute(); + + List operationResults = results.get(); + System.out.println("Delete operation results = " + operationResults); }