3 import static org.junit.Assert.assertEquals;
4 import static org.junit.Assert.assertFalse;
5 import static org.junit.Assert.assertTrue;
7 import java.util.Collections;
8 import java.util.concurrent.ExecutionException;
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;
34 import test.mock.util.StatisticsManagerTest;
36 import com.google.common.base.Optional;
39 public class QueueStatisticsTest extends StatisticsManagerTest {
40 private final Object waitObject = new Object();
42 // @Test(timeout = 5000)
43 public void addedQueueOnDemandStatsTest() throws ExecutionException, InterruptedException, ReadFailedException {
44 final StatisticsManagerActivator activator = new StatisticsManagerActivator();
45 activator.onSessionInitiated(providerContext);
47 addFlowCapableNode(s1Key);
49 final Port port = getPort();
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());
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());
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());
74 getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
75 queueII.augmentation(FlowCapableNodeConnectorQueueStatisticsData.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
77 synchronized (waitObject) {
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());
89 // @Test(timeout = 5000)
90 public void deletedQueueStatsRemovalTest() throws ExecutionException, InterruptedException, ReadFailedException {
91 final StatisticsManagerActivator activator = new StatisticsManagerActivator();
92 activator.onSessionInitiated(providerContext);
94 addFlowCapableNode(s1Key);
96 final Port port = getPort();
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());
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());
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());
121 getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
122 queueII.augmentation(FlowCapableNodeConnectorQueueStatisticsData.class),
123 new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
125 synchronized (waitObject) {
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());
136 writeTx = getDataBroker().newWriteOnlyTransaction();
137 writeTx.delete(LogicalDatastoreType.CONFIGURATION, queueII);
138 assertCommit(writeTx.submit());
140 readTx = getDataBroker().newReadOnlyTransaction();
141 queueStatsOptional = readTx.read(LogicalDatastoreType.OPERATIONAL,
142 queueII.augmentation(FlowCapableNodeConnectorQueueStatisticsData.class)).checkedGet();
143 assertFalse(queueStatsOptional.isPresent());
146 // @Test(timeout = 23000)
147 public void getAllStatsFromConnectedNodeTest() throws ExecutionException, InterruptedException, ReadFailedException {
148 final StatisticsManagerActivator activator = new StatisticsManagerActivator();
149 activator.onSessionInitiated(providerContext);
151 addFlowCapableNodeWithFeatures(s1Key, false, FlowFeatureCapabilityQueueStats.class);
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());
158 final InstanceIdentifier<NodeConnector> nodeConnectorII = InstanceIdentifier.create(Nodes.class)
159 .child(Node.class, s1Key)
160 .child(NodeConnector.class, ncBuilder.getKey());
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());
170 getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
171 queueII.augmentation(FlowCapableNodeConnectorQueueStatisticsData.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
173 synchronized (waitObject) {
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());
187 private class ChangeListener implements DataChangeListener {
190 public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
191 synchronized (waitObject) {