opendaylight/md-sal/statistics-manager/src/test/java/test/mock/QueueStatisticsTest.java

   1 package test.mock;
   2
   3 import static org.junit.Assert.assertEquals;
   4 import static org.junit.Assert.assertFalse;
   5 import static org.junit.Assert.assertTrue;
   6
   7 import java.util.Collections;
   8 import java.util.concurrent.ExecutionException;
   9
  10 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
  11 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  12 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  13 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
  14 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
  15 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  16 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  17 import org.opendaylight.controller.md.statistics.manager.StatisticsManagerActivator;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnectorBuilder;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityQueueStats;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.port.mod.port.Port;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.queues.Queue;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.queues.QueueBuilder;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorBuilder;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.FlowCapableNodeConnectorQueueStatisticsData;
  31 import org.opendaylight.yangtools.yang.binding.DataObject;
  32 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  33
  34 import test.mock.util.StatisticsManagerTest;
  35
  36 import com.google.common.base.Optional;
  37
  38
  39 public class QueueStatisticsTest extends StatisticsManagerTest {
  40     private final Object waitObject = new Object();
  41
  42 //    @Test(timeout = 5000)
  43     public void addedQueueOnDemandStatsTest() throws ExecutionException, InterruptedException, ReadFailedException {
  44         final StatisticsManagerActivator activator = new StatisticsManagerActivator();
  45         activator.onSessionInitiated(providerContext);
  46
  47         addFlowCapableNode(s1Key);
  48
  49         final Port port = getPort();
  50
  51         final NodeConnectorBuilder ncBuilder = new NodeConnectorBuilder();
  52         final FlowCapableNodeConnectorBuilder fcncBuilder = new FlowCapableNodeConnectorBuilder();
  53         fcncBuilder.setConfiguration(port.getConfiguration());
  54         fcncBuilder.setPortNumber(port.getPortNumber());
  55         fcncBuilder.setQueue(Collections.<Queue>emptyList());
  56         ncBuilder.setKey(new NodeConnectorKey(new NodeConnectorId("connector.1")));
  57         ncBuilder.addAugmentation(FlowCapableNodeConnector.class, fcncBuilder.build());
  58
  59
  60         final Queue queue = getQueue();
  61         final InstanceIdentifier<Queue> queueII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
  62                 .child(NodeConnector.class, ncBuilder.getKey()).augmentation(FlowCapableNodeConnector.class)
  63                 .child(Queue.class, queue.getKey());
  64         final InstanceIdentifier<NodeConnector> nodeConnectorII = InstanceIdentifier.create(Nodes.class)
  65                 .child(Node.class, s1Key).child(NodeConnector.class, ncBuilder.getKey());
  66
  67         final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
  68         writeTx.put(LogicalDatastoreType.CONFIGURATION, nodeConnectorII, ncBuilder.build());
  69         writeTx.put(LogicalDatastoreType.CONFIGURATION, queueII, queue);
  70         writeTx.put(LogicalDatastoreType.OPERATIONAL, nodeConnectorII, ncBuilder.build());
  71         writeTx.put(LogicalDatastoreType.OPERATIONAL, queueII, queue);
  72         assertCommit(writeTx.submit());
  73
  74         getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
  75                 queueII.augmentation(FlowCapableNodeConnectorQueueStatisticsData.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
  76
  77         synchronized (waitObject) {
  78             waitObject.wait();
  79         }
  80
  81         final ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
  82         final Optional<FlowCapableNodeConnectorQueueStatisticsData> queueStatsOptional = readTx.read(LogicalDatastoreType.OPERATIONAL,
  83                 queueII.augmentation(FlowCapableNodeConnectorQueueStatisticsData.class)).checkedGet();
  84         assertTrue(queueStatsOptional.isPresent());
  85         assertEquals(COUNTER_64_TEST_VALUE,
  86                 queueStatsOptional.get().getFlowCapableNodeConnectorQueueStatistics().getTransmittedBytes());
  87     }
  88
  89 //    @Test(timeout = 5000)
  90     public void deletedQueueStatsRemovalTest() throws ExecutionException, InterruptedException, ReadFailedException {
  91         final StatisticsManagerActivator activator = new StatisticsManagerActivator();
  92         activator.onSessionInitiated(providerContext);
  93
  94         addFlowCapableNode(s1Key);
  95
  96         final Port port = getPort();
  97
  98         final NodeConnectorBuilder ncBuilder = new NodeConnectorBuilder();
  99         final FlowCapableNodeConnectorBuilder fcncBuilder = new FlowCapableNodeConnectorBuilder();
 100         fcncBuilder.setConfiguration(port.getConfiguration());
 101         fcncBuilder.setPortNumber(port.getPortNumber());
 102         fcncBuilder.setQueue(Collections.<Queue>emptyList());
 103         ncBuilder.setKey(new NodeConnectorKey(new NodeConnectorId("connector.1")));
 104         ncBuilder.addAugmentation(FlowCapableNodeConnector.class, fcncBuilder.build());
 105
 106
 107         final Queue queue = getQueue();
 108         final InstanceIdentifier<Queue> queueII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
 109                 .child(NodeConnector.class, ncBuilder.getKey()).augmentation(FlowCapableNodeConnector.class)
 110                 .child(Queue.class, queue.getKey());
 111         final InstanceIdentifier<NodeConnector> nodeConnectorII = InstanceIdentifier.create(Nodes.class)
 112                 .child(Node.class, s1Key).child(NodeConnector.class, ncBuilder.getKey());
 113
 114         WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
 115         writeTx.put(LogicalDatastoreType.CONFIGURATION, nodeConnectorII, ncBuilder.build());
 116         writeTx.put(LogicalDatastoreType.CONFIGURATION, queueII, queue);
 117         writeTx.put(LogicalDatastoreType.OPERATIONAL, nodeConnectorII, ncBuilder.build());
 118         writeTx.put(LogicalDatastoreType.OPERATIONAL, queueII, queue);
 119         assertCommit(writeTx.submit());
 120
 121         getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
 122                 queueII.augmentation(FlowCapableNodeConnectorQueueStatisticsData.class),
 123                                         new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
 124
 125         synchronized (waitObject) {
 126             waitObject.wait();
 127         }
 128
 129         ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
 130         Optional<FlowCapableNodeConnectorQueueStatisticsData> queueStatsOptional = readTx.read(LogicalDatastoreType.OPERATIONAL,
 131                 queueII.augmentation(FlowCapableNodeConnectorQueueStatisticsData.class)).checkedGet();
 132         assertTrue(queueStatsOptional.isPresent());
 133         assertEquals(COUNTER_64_TEST_VALUE,
 134                 queueStatsOptional.get().getFlowCapableNodeConnectorQueueStatistics().getTransmittedBytes());
 135
 136         writeTx = getDataBroker().newWriteOnlyTransaction();
 137         writeTx.delete(LogicalDatastoreType.CONFIGURATION, queueII);
 138         assertCommit(writeTx.submit());
 139
 140         readTx = getDataBroker().newReadOnlyTransaction();
 141         queueStatsOptional = readTx.read(LogicalDatastoreType.OPERATIONAL,
 142                 queueII.augmentation(FlowCapableNodeConnectorQueueStatisticsData.class)).checkedGet();
 143         assertFalse(queueStatsOptional.isPresent());
 144     }
 145
 146 //    @Test(timeout = 23000)
 147     public void getAllStatsFromConnectedNodeTest() throws ExecutionException, InterruptedException, ReadFailedException {
 148         final StatisticsManagerActivator activator = new StatisticsManagerActivator();
 149         activator.onSessionInitiated(providerContext);
 150
 151         addFlowCapableNodeWithFeatures(s1Key, false, FlowFeatureCapabilityQueueStats.class);
 152
 153         final NodeConnectorBuilder ncBuilder = new NodeConnectorBuilder();
 154         final FlowCapableNodeConnectorBuilder fcncBuilder = new FlowCapableNodeConnectorBuilder();
 155         ncBuilder.setKey(new NodeConnectorKey(getNodeConnectorId()));
 156         ncBuilder.addAugmentation(FlowCapableNodeConnector.class, fcncBuilder.build());
 157
 158         final InstanceIdentifier<NodeConnector> nodeConnectorII = InstanceIdentifier.create(Nodes.class)
 159                 .child(Node.class, s1Key)
 160                 .child(NodeConnector.class, ncBuilder.getKey());
 161
 162         final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
 163         writeTx.put(LogicalDatastoreType.OPERATIONAL, nodeConnectorII, ncBuilder.build());
 164         final InstanceIdentifier<Queue> queueII = nodeConnectorII.augmentation(FlowCapableNodeConnector.class)
 165                 .child(Queue.class, getQueue().getKey());
 166         final QueueBuilder qBuilder = new QueueBuilder(getQueue());
 167         writeTx.put(LogicalDatastoreType.OPERATIONAL, queueII, qBuilder.build());
 168         assertCommit(writeTx.submit());
 169
 170         getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
 171                 queueII.augmentation(FlowCapableNodeConnectorQueueStatisticsData.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
 172
 173         synchronized (waitObject) {
 174             waitObject.wait();
 175         }
 176
 177         final ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
 178         final Optional<Queue> queueOptional = readTx.read(LogicalDatastoreType.OPERATIONAL, queueII).checkedGet();
 179         assertTrue(queueOptional.isPresent());
 180         final FlowCapableNodeConnectorQueueStatisticsData queueStats =
 181                 queueOptional.get().getAugmentation(FlowCapableNodeConnectorQueueStatisticsData.class);
 182         assertTrue(queueStats != null);
 183         assertEquals(COUNTER_64_TEST_VALUE,
 184                 queueStats.getFlowCapableNodeConnectorQueueStatistics().getTransmittedBytes());
 185     }
 186
 187     private class ChangeListener implements DataChangeListener {
 188
 189         @Override
 190         public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
 191             synchronized (waitObject) {
 192                 waitObject.notify();
 193             }
 194         }
 195     }
 196 }
 197