X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=openflowplugin-impl%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fopenflowplugin%2Fimpl%2Fregistry%2Fflow%2FDeviceFlowRegistryImplTest.java;h=9cc4d36ef6aa659de639b4db39d5bd4e58171d83;hb=1aee9a9a8d8df9d3207696a98021295ae2e92ad7;hp=0f9e65181d928499e1bb5b7480731ad4a317fd0b;hpb=af8ead7873bc02797d6beb46054b5f7d3f2aa29a;p=openflowplugin.git diff --git a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/registry/flow/DeviceFlowRegistryImplTest.java b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/registry/flow/DeviceFlowRegistryImplTest.java index 0f9e65181d..9cc4d36ef6 100644 --- a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/registry/flow/DeviceFlowRegistryImplTest.java +++ b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/registry/flow/DeviceFlowRegistryImplTest.java @@ -5,35 +5,51 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ - package org.opendaylight.openflowplugin.impl.registry.flow; -import static org.mockito.Matchers.any; -import static org.mockito.Mockito.mock; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -import com.google.common.base.Optional; -import com.google.common.util.concurrent.Futures; +import java.math.BigInteger; +import java.util.Collections; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.regex.Matcher; +import java.util.regex.Pattern; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; +import org.mockito.InOrder; import org.mockito.Mock; -import org.mockito.runners.MockitoJUnitRunner; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.mockito.junit.MockitoJUnitRunner; +import org.opendaylight.mdsal.binding.api.DataBroker; +import org.opendaylight.mdsal.binding.api.ReadTransaction; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.openflowplugin.api.OFConstants; import org.opendaylight.openflowplugin.api.openflow.registry.flow.FlowDescriptor; import org.opendaylight.openflowplugin.api.openflow.registry.flow.FlowRegistryKey; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.flow.and.statistics.map.list.FlowAndStatisticsMapList; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowCookie; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey; +import org.opendaylight.yangtools.util.concurrent.FluentFutures; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier; @@ -43,107 +59,198 @@ import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier; @RunWith(MockitoJUnitRunner.class) public class DeviceFlowRegistryImplTest { private static final String NODE_ID = "openflow:1"; + private static final Pattern INDEX_PATTERN = Pattern.compile("^#UF\\$TABLE\\*1-([0-9]+)$"); + private static final Short DUMMY_TABLE_ID = 1; + private DeviceFlowRegistryImpl deviceFlowRegistry; private FlowRegistryKey key; private FlowDescriptor descriptor; + private KeyedInstanceIdentifier nodeInstanceIdentifier; @Mock private DataBroker dataBroker; @Mock - private ReadOnlyTransaction readOnlyTransaction; + private ReadTransaction readOnlyTransaction; @Before - public void setUp() throws Exception { + public void setUp() { + nodeInstanceIdentifier = + InstanceIdentifier.create(Nodes.class).child(Node.class, new NodeKey(new NodeId(NODE_ID))); when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction); - when(readOnlyTransaction.read(any(), any())).thenReturn(Futures.immediateCheckedFuture(Optional.absent())); - deviceFlowRegistry = new DeviceFlowRegistryImpl(dataBroker); + deviceFlowRegistry = + new DeviceFlowRegistryImpl(OFConstants.OFP_VERSION_1_3, dataBroker, nodeInstanceIdentifier); final FlowAndStatisticsMapList flowStats = TestFlowHelper.createFlowAndStatisticsMapListBuilder(1).build(); - key = FlowRegistryKeyFactory.create(flowStats); + key = FlowRegistryKeyFactory.create(OFConstants.OFP_VERSION_1_3, flowStats); descriptor = FlowDescriptorFactory.create(key.getTableId(), new FlowId("ut:1")); Assert.assertEquals(0, deviceFlowRegistry.getAllFlowDescriptors().size()); - deviceFlowRegistry.store(key, descriptor); + deviceFlowRegistry.storeDescriptor(key, descriptor); Assert.assertEquals(1, deviceFlowRegistry.getAllFlowDescriptors().size()); } @Test public void testFill() throws Exception { - final KeyedInstanceIdentifier nodeInstanceIdentifier = InstanceIdentifier.create(Nodes.class).child(Node.class, new NodeKey(new NodeId(NODE_ID))); final InstanceIdentifier path = nodeInstanceIdentifier.augmentation(FlowCapableNode.class); - deviceFlowRegistry.fill(nodeInstanceIdentifier); + final Flow flow = new FlowBuilder() + .setTableId((short)1) + .setPriority(10) + .setCookie(new FlowCookie(BigInteger.TEN)) + .setId(new FlowId("HELLO")) + .build(); + + final Table table = new TableBuilder() + .setFlow(Collections.singletonList(flow)) + .build(); + + final FlowCapableNode flowCapableNode = new FlowCapableNodeBuilder() + .setTable(Collections.singletonList(table)) + .build(); + + final Map allFlowDescriptors = fillRegistry(path, flowCapableNode); + key = FlowRegistryKeyFactory.create(OFConstants.OFP_VERSION_1_3, flow); + + InOrder order = inOrder(dataBroker, readOnlyTransaction); + order.verify(dataBroker).newReadOnlyTransaction(); + order.verify(readOnlyTransaction).read(LogicalDatastoreType.CONFIGURATION, path); + order.verify(dataBroker).newReadOnlyTransaction(); + order.verify(readOnlyTransaction).read(LogicalDatastoreType.OPERATIONAL, path); + assertTrue(allFlowDescriptors.containsKey(key)); + + deviceFlowRegistry.addMark(key); + } + + @Test + public void testFailedFill() throws Exception { + final InstanceIdentifier path = nodeInstanceIdentifier.augmentation(FlowCapableNode.class); + + fillRegistry(path, null); + + fillRegistry(path, new FlowCapableNodeBuilder() + .setTable(null) + .build()); + + fillRegistry(path, new FlowCapableNodeBuilder() + .setTable(Collections.singletonList(null)) + .build()); + + fillRegistry(path, new FlowCapableNodeBuilder() + .setTable(Collections.singletonList(new TableBuilder() + .setFlow(null) + .build())) + .build()); + + fillRegistry(path, new FlowCapableNodeBuilder() + .setTable(Collections.singletonList(new TableBuilder() + .setFlow(Collections.singletonList(null)) + .build())) + .build()); + + fillRegistry(path, new FlowCapableNodeBuilder() + .setTable(Collections.singletonList(new TableBuilder() + .setFlow(Collections.singletonList(new FlowBuilder() + .setId(null) + .build())) + .build())) + .build()); + + verify(dataBroker, times(12)).newReadOnlyTransaction(); + verify(readOnlyTransaction, times(6)).read(LogicalDatastoreType.CONFIGURATION, path); + verify(readOnlyTransaction, times(6)).read(LogicalDatastoreType.OPERATIONAL, path); - verify(dataBroker, times(2)).newReadOnlyTransaction(); - verify(readOnlyTransaction).read(LogicalDatastoreType.CONFIGURATION, path); - verify(readOnlyTransaction).read(LogicalDatastoreType.OPERATIONAL, path); + Assert.assertEquals(1, deviceFlowRegistry.getAllFlowDescriptors().size()); + } + + private Map fillRegistry(final InstanceIdentifier path, + final FlowCapableNode flowCapableNode) throws Exception { + doReturn(FluentFutures.immediateFluentFuture(Optional.ofNullable(flowCapableNode))).when(readOnlyTransaction) + .read(any(), any()); + deviceFlowRegistry.fill().get(); + return deviceFlowRegistry.getAllFlowDescriptors(); } @Test - public void testRetrieveIdForFlow() throws Exception { - Assert.assertEquals(descriptor, deviceFlowRegistry.retrieveIdForFlow(key)); + public void testRetrieveIdForFlow() { + Assert.assertEquals(descriptor, deviceFlowRegistry.retrieveDescriptor(key)); } @Test - public void testStore() throws Exception { + public void testStore() { //store the same key with different value final FlowDescriptor descriptor2 = FlowDescriptorFactory.create(key.getTableId(), new FlowId("ut:2")); - deviceFlowRegistry.store(key, descriptor2); + deviceFlowRegistry.storeDescriptor(key, descriptor2); Assert.assertEquals(1, deviceFlowRegistry.getAllFlowDescriptors().size()); - Assert.assertEquals("ut:2", deviceFlowRegistry.retrieveIdForFlow(key).getFlowId().getValue()); + Assert.assertEquals("ut:2", deviceFlowRegistry.retrieveDescriptor(key).getFlowId().getValue()); // store new key with old value final FlowAndStatisticsMapList flowStats = TestFlowHelper.createFlowAndStatisticsMapListBuilder(2).build(); - final FlowRegistryKey key2 = FlowRegistryKeyFactory.create(flowStats); - deviceFlowRegistry.store(key2, descriptor); + final FlowRegistryKey key2 = FlowRegistryKeyFactory.create(OFConstants.OFP_VERSION_1_3, flowStats); + deviceFlowRegistry.storeDescriptor(key2, descriptor); Assert.assertEquals(2, deviceFlowRegistry.getAllFlowDescriptors().size()); - Assert.assertEquals("ut:1", deviceFlowRegistry.retrieveIdForFlow(key2).getFlowId().getValue()); + Assert.assertEquals("ut:1", deviceFlowRegistry.retrieveDescriptor(key2).getFlowId().getValue()); } @Test - public void testStoreIfNecessary() throws Exception { + public void testStoreIfNecessary() { FlowId newFlowId; //store existing key - newFlowId = deviceFlowRegistry.storeIfNecessary(key); + deviceFlowRegistry.store(key); + newFlowId = deviceFlowRegistry.retrieveDescriptor(key).getFlowId(); Assert.assertEquals(1, deviceFlowRegistry.getAllFlowDescriptors().size()); - Assert.assertEquals(descriptor, deviceFlowRegistry.retrieveIdForFlow(key)); + Assert.assertEquals(descriptor, deviceFlowRegistry.retrieveDescriptor(key)); Assert.assertEquals(descriptor.getFlowId(), newFlowId); //store new key final String alienPrefix = "#UF$TABLE*2-"; - final FlowRegistryKey key2 = FlowRegistryKeyFactory.create(TestFlowHelper.createFlowAndStatisticsMapListBuilder(2).build()); - newFlowId = deviceFlowRegistry.storeIfNecessary(key2); + final FlowRegistryKey key2 = FlowRegistryKeyFactory.create(OFConstants.OFP_VERSION_1_3, + TestFlowHelper.createFlowAndStatisticsMapListBuilder(2).build()); + deviceFlowRegistry.store(key2); + newFlowId = deviceFlowRegistry.retrieveDescriptor(key2).getFlowId(); Assert.assertTrue(newFlowId.getValue().startsWith(alienPrefix)); - Assert.assertTrue(deviceFlowRegistry.retrieveIdForFlow(key2).getFlowId().getValue().startsWith(alienPrefix)); + Assert.assertTrue(deviceFlowRegistry.retrieveDescriptor(key2).getFlowId().getValue().startsWith(alienPrefix)); Assert.assertEquals(2, deviceFlowRegistry.getAllFlowDescriptors().size()); } @Test - public void testRemoveMarked() throws Exception { - deviceFlowRegistry.markToBeremoved(key); - deviceFlowRegistry.removeMarked(); + public void testRemoveDescriptor() { + deviceFlowRegistry.addMark(key); Assert.assertEquals(0, deviceFlowRegistry.getAllFlowDescriptors().size()); } @Test - public void testRemoveMarkedNegative() throws Exception { - final FlowAndStatisticsMapList flowStats = TestFlowHelper.createFlowAndStatisticsMapListBuilder(2).build(); - FlowRegistryKey key2 = FlowRegistryKeyFactory.create(flowStats); - deviceFlowRegistry.markToBeremoved(key2); - deviceFlowRegistry.removeMarked(); - Assert.assertEquals(1, deviceFlowRegistry.getAllFlowDescriptors().size()); + public void testClose() { + deviceFlowRegistry.close(); + Assert.assertEquals(0, deviceFlowRegistry.getAllFlowDescriptors().size()); } @Test - public void testClose() throws Exception { - deviceFlowRegistry.markToBeremoved(key); - deviceFlowRegistry.close(); - Assert.assertEquals(0, deviceFlowRegistry.getAllFlowDescriptors().size()); + public void createAlienFlowIdTest() { + final String alienFlowId1 = DeviceFlowRegistryImpl.createAlienFlowId(DUMMY_TABLE_ID).getValue(); + final Integer index1 = parseIndex(alienFlowId1); + final String alienFlowId2 = DeviceFlowRegistryImpl.createAlienFlowId(DUMMY_TABLE_ID).getValue(); + final Integer index2 = parseIndex(alienFlowId2); - deviceFlowRegistry.store(key, descriptor); - Assert.assertEquals(1, deviceFlowRegistry.getAllFlowDescriptors().size()); - deviceFlowRegistry.removeMarked(); - Assert.assertEquals(1, deviceFlowRegistry.getAllFlowDescriptors().size()); + assertNotNull("index1 parsing failed: " + alienFlowId1, index1); + assertNotNull("index2 parsing failed: " + alienFlowId2, index2); + assertTrue(index1 < index2); + } + + @Test + public void testForEach() { + final AtomicInteger counter = new AtomicInteger(0); + deviceFlowRegistry.forEach(k -> counter.incrementAndGet()); + Assert.assertEquals(1, counter.get()); + } + + private static Integer parseIndex(String alienFlowIdValue) { + final Matcher mach = INDEX_PATTERN.matcher(alienFlowIdValue); + + if (mach.find()) { + return Integer.valueOf(mach.group(1)); + } + + return null; } -} \ No newline at end of file +}