test-provider/src/main/java/org/opendaylight/openflowplugin/test/OpenflowpluginStatsTestCommandProvider.java

   1 package org.opendaylight.openflowplugin.test;
   2
   3 import java.util.Iterator;
   4 import java.util.List;
   5
   6 import org.eclipse.osgi.framework.console.CommandInterpreter;
   7 import org.eclipse.osgi.framework.console.CommandProvider;
   8 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
   9 import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
  10 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  11 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
  12 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
  13 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
  14 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
  15 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
  16 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.AggregateFlowStatisticsData;
  17 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowStatisticsData;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.FlowTableStatisticsData;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.queues.Queue;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.queues.QueueKey;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatisticsData;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.FlowCapableNodeConnectorQueueStatisticsData;
  28 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  29 import org.osgi.framework.BundleContext;
  30
  31 public class OpenflowpluginStatsTestCommandProvider implements CommandProvider {
  32
  33     private DataProviderService dataProviderService;
  34     private final BundleContext ctx;
  35
  36     public OpenflowpluginStatsTestCommandProvider(BundleContext ctx) {
  37         this.ctx = ctx;
  38     }
  39
  40
  41     public void onSessionInitiated(ProviderContext session) {
  42         dataProviderService = session.getSALService(DataProviderService.class);
  43         ctx.registerService(CommandProvider.class.getName(), this, null);
  44
  45     }
  46
  47     public void _portStats(CommandInterpreter ci) {
  48         int nodeConnectorCount = 0;
  49         int nodeConnectorStatsCount = 0;
  50             List<Node> nodes = getNodes();
  51             for (Iterator<Node> iterator = nodes.iterator(); iterator.hasNext();) {
  52                 NodeKey nodeKey =  iterator.next().getKey();
  53                 InstanceIdentifier<Node> nodeRef = InstanceIdentifier.builder(Nodes.class).child(Node.class, nodeKey).toInstance();
  54                 Node node = (Node)dataProviderService.readOperationalData(nodeRef);
  55                 List<NodeConnector> ports =  node.getNodeConnector();
  56                 for (Iterator<NodeConnector> iterator2 = ports.iterator(); iterator2.hasNext();) {
  57                     nodeConnectorCount++;
  58                     NodeConnectorKey nodeConnectorKey = iterator2.next().getKey();
  59                     InstanceIdentifier<NodeConnector> connectorRef = InstanceIdentifier.builder(Nodes.class).child(Node.class, nodeKey).child(NodeConnector.class, nodeConnectorKey).toInstance();
  60                     NodeConnector nodeConnector = (NodeConnector)dataProviderService.readOperationalData(connectorRef);
  61                     FlowCapableNodeConnectorStatisticsData data = nodeConnector.getAugmentation(FlowCapableNodeConnectorStatisticsData.class);
  62                     if(null != data)
  63                     {
  64                         nodeConnectorStatsCount++;
  65                     }
  66                 }
  67             }
  68
  69             if(nodeConnectorCount == nodeConnectorStatsCount)
  70             {
  71                 ci.println("portStats - Success");
  72             }
  73             else
  74             {
  75                 ci.println("portStats - Failed");
  76                 ci.println("System fetchs stats data in 50 seconds interval, so pls wait and try again.");
  77             }
  78
  79        }
  80
  81
  82     public void _portDescStats(CommandInterpreter ci) {
  83         int nodeConnectorCount = 0;
  84         int nodeConnectorDescStatsCount = 0;
  85             List<Node> nodes = getNodes();
  86             for (Iterator<Node> iterator = nodes.iterator(); iterator.hasNext();) {
  87                 NodeKey nodeKey =  iterator.next().getKey();
  88                 InstanceIdentifier<Node> nodeRef = InstanceIdentifier.builder(Nodes.class).child(Node.class, nodeKey).toInstance();
  89                 Node node = (Node)dataProviderService.readOperationalData(nodeRef);
  90
  91                List<NodeConnector> ports =  node.getNodeConnector();
  92                 for (Iterator<NodeConnector> iterator2 = ports.iterator(); iterator2.hasNext();) {
  93                     nodeConnectorCount++;
  94                     NodeConnectorKey nodeConnectorKey = iterator2.next().getKey();
  95                     InstanceIdentifier<FlowCapableNodeConnector> connectorRef = InstanceIdentifier.builder(Nodes.class).child(Node.class, nodeKey).child(NodeConnector.class, nodeConnectorKey).augmentation(FlowCapableNodeConnector.class).toInstance();
  96                     FlowCapableNodeConnector nodeConnector = (FlowCapableNodeConnector)dataProviderService.readOperationalData(connectorRef);
  97                     if(null != nodeConnector.getName() &&
  98                             null != nodeConnector.getCurrentFeature() &&
  99                             null != nodeConnector.getState() &&
 100                             null != nodeConnector.getHardwareAddress() &&
 101                             null != nodeConnector.getPortNumber())
 102                     {
 103                         nodeConnectorDescStatsCount++;
 104                     }
 105                 }
 106             }
 107
 108             if(nodeConnectorCount == nodeConnectorDescStatsCount)
 109             {
 110                 ci.println("portDescStats - Success");
 111             }
 112             else
 113             {
 114                 ci.println("portDescStats - Failed");
 115                 ci.println("System fetchs stats data in 50 seconds interval, so pls wait and try again.");
 116             }
 117
 118        }
 119
 120     public void _flowStats(CommandInterpreter ci) {
 121         int flowCount = 0;
 122         int flowStatsCount = 0;
 123             List<Node> nodes = getNodes();
 124             for (Iterator<Node> iterator = nodes.iterator(); iterator.hasNext();) {
 125                 NodeKey nodeKey =  iterator.next().getKey();
 126                 InstanceIdentifier<FlowCapableNode> nodeRef = InstanceIdentifier.builder(Nodes.class).child(Node.class, nodeKey).augmentation(FlowCapableNode.class).toInstance();
 127                 FlowCapableNode node = (FlowCapableNode)dataProviderService.readOperationalData(nodeRef);
 128                 List<Table> tables =  node.getTable();
 129                 for (Iterator<Table> iterator2 = tables.iterator(); iterator2.hasNext();) {
 130                     TableKey tableKey = iterator2.next().getKey();
 131                     InstanceIdentifier<Table> tableRef = InstanceIdentifier.builder(Nodes.class).child(Node.class, nodeKey).augmentation(FlowCapableNode.class).child(Table.class, tableKey).toInstance();
 132                     Table table = (Table)dataProviderService.readOperationalData(tableRef);
 133                     List<Flow> flows = table.getFlow();
 134                     for (Iterator<Flow> iterator3 = flows.iterator(); iterator3.hasNext();) {
 135                         flowCount++;
 136                         FlowKey flowKey =  iterator3.next().getKey();
 137                         InstanceIdentifier<Flow> flowRef = InstanceIdentifier.builder(Nodes.class).child(Node.class, nodeKey).augmentation(FlowCapableNode.class).child(Table.class, tableKey).child(Flow.class, flowKey).toInstance();
 138                         Flow flow = (Flow)dataProviderService.readOperationalData(flowRef);
 139                         FlowStatisticsData data = flow.getAugmentation(FlowStatisticsData.class);
 140                         if(null != data)
 141                         {
 142                             flowStatsCount++;
 143                         }
 144                     }
 145                 }
 146             }
 147
 148             if(flowCount == flowStatsCount)
 149             {
 150                 ci.println("flowStats - Success");
 151             }
 152             else
 153             {
 154                 ci.println("flowStats - Failed");
 155                 ci.println("System fetchs stats data in 50 seconds interval, so pls wait and try again.");
 156             }
 157
 158        }
 159
 160     public void _queueStats(CommandInterpreter ci) {
 161         boolean isFound = false;
 162         List<Node> nodes = getNodes();
 163         for (Iterator<Node> iterator = nodes.iterator(); iterator.hasNext();) {
 164             NodeKey nodeKey = iterator.next().getKey();
 165             InstanceIdentifier<Node> nodeRef = InstanceIdentifier.builder(Nodes.class).child(Node.class, nodeKey)
 166                     .toInstance();
 167             Node node = (Node) dataProviderService.readOperationalData(nodeRef);
 168             List<NodeConnector> ports = node.getNodeConnector();
 169             for (Iterator<NodeConnector> iterator2 = ports.iterator(); iterator2.hasNext();) {
 170                 NodeConnectorKey nodeConnectorKey = iterator2.next().getKey();
 171                 InstanceIdentifier<FlowCapableNodeConnector> connectorRef = InstanceIdentifier.builder(Nodes.class)
 172                         .child(Node.class, nodeKey).child(NodeConnector.class, nodeConnectorKey)
 173                         .augmentation(FlowCapableNodeConnector.class).toInstance();
 174                 FlowCapableNodeConnector nodeConnector = (FlowCapableNodeConnector) dataProviderService
 175                         .readOperationalData(connectorRef);
 176                 // queue list is always empty, bug 307 is raised.
 177                 List<Queue> queueList = nodeConnector.getQueue();
 178
 179                 for (Iterator<Queue> iterator3 = queueList.iterator(); iterator3.hasNext();) {
 180                     QueueKey queueKey = iterator3.next().getKey();
 181                     InstanceIdentifier<Queue> queueRef = InstanceIdentifier.builder(Nodes.class)
 182                             .child(Node.class, nodeKey).child(NodeConnector.class, nodeConnectorKey)
 183                             .augmentation(FlowCapableNodeConnector.class).child(Queue.class, queueKey).toInstance();
 184                     Queue queue = (Queue) dataProviderService.readOperationalData(queueRef);
 185                     FlowCapableNodeConnectorQueueStatisticsData data = queue
 186                             .getAugmentation(FlowCapableNodeConnectorQueueStatisticsData.class);
 187                     if (null != data) {
 188                         isFound = true;
 189                     }
 190                 }
 191             }
 192         }
 193
 194         if (isFound) {
 195             ci.println("queueStats - Success");
 196         } else {
 197             ci.println("queueStats - Failed");
 198             ci.println("System fetchs stats data in 50 seconds interval, so pls wait and try again.");
 199         }
 200
 201     }
 202
 203     public void _tableStats(CommandInterpreter ci) {
 204         int tableCount = 0;
 205         int tableStatsCount = 0;
 206             List<Node> nodes = getNodes();
 207             for (Iterator<Node> iterator = nodes.iterator(); iterator.hasNext();) {
 208                 NodeKey nodeKey =  iterator.next().getKey();
 209                 InstanceIdentifier<FlowCapableNode> nodeRef = InstanceIdentifier.builder(Nodes.class).child(Node.class, nodeKey).augmentation(FlowCapableNode.class).toInstance();
 210                 FlowCapableNode node = (FlowCapableNode)dataProviderService.readOperationalData(nodeRef);
 211
 212                List<Table> tables =  node.getTable();
 213                 for (Iterator<Table> iterator2 = tables.iterator(); iterator2.hasNext();) {
 214                     tableCount++;
 215                     TableKey tableKey = iterator2.next().getKey();
 216                     InstanceIdentifier<Table> tableRef = InstanceIdentifier.builder(Nodes.class).child(Node.class, nodeKey).augmentation(FlowCapableNode.class).child(Table.class, tableKey).toInstance();
 217                     Table table = (Table)dataProviderService.readOperationalData(tableRef);
 218                     FlowTableStatisticsData data = table.getAugmentation(FlowTableStatisticsData.class);
 219                     if(null != data)
 220                     {
 221                         tableStatsCount++;
 222                     }
 223                 }
 224             }
 225
 226             if(tableCount == tableStatsCount)
 227             {
 228                 ci.println("tableStats - Success");
 229             }
 230             else
 231             {
 232                 ci.println("tableStats - Failed");
 233                 ci.println("System fetchs stats data in 50 seconds interval, so pls wait and try again.");
 234             }
 235
 236        }
 237
 238     public void _aggregateStats(CommandInterpreter ci) {
 239         int aggregateFlowCount = 0;
 240         int aggerateFlowStatsCount = 0;
 241             List<Node> nodes = getNodes();
 242             for (Iterator<Node> iterator = nodes.iterator(); iterator.hasNext();) {
 243                 NodeKey nodeKey =  iterator.next().getKey();
 244                 InstanceIdentifier<FlowCapableNode> nodeRef = InstanceIdentifier.builder(Nodes.class).child(Node.class, nodeKey).augmentation(FlowCapableNode.class).toInstance();
 245                 FlowCapableNode node = (FlowCapableNode)dataProviderService.readOperationalData(nodeRef);
 246
 247                List<Table> tables =  node.getTable();
 248                 for (Iterator<Table> iterator2 = tables.iterator(); iterator2.hasNext();) {
 249                     aggregateFlowCount++;
 250                     TableKey tableKey = iterator2.next().getKey();
 251                     InstanceIdentifier<Table> tableRef = InstanceIdentifier.builder(Nodes.class).child(Node.class, nodeKey).augmentation(FlowCapableNode.class).child(Table.class, tableKey).toInstance();
 252                     Table table = (Table)dataProviderService.readOperationalData(tableRef);
 253                     AggregateFlowStatisticsData data = table.getAugmentation(AggregateFlowStatisticsData.class);
 254                     if(null != data)
 255                     {
 256                         aggerateFlowStatsCount++;
 257                     }
 258                 }
 259             }
 260
 261             if(aggregateFlowCount == aggerateFlowStatsCount)
 262             {
 263                 ci.println("aggregateStats - Success");
 264             }
 265             else
 266             {
 267                 ci.println("aggregateStats - Failed");
 268                 ci.println("System fetchs stats data in 50 seconds interval, so pls wait and try again.");
 269             }
 270
 271        }
 272
 273     public void _descStats(CommandInterpreter ci) {
 274         int descCount = 0;
 275         int descStatsCount = 0;
 276             List<Node> nodes = getNodes();
 277             for (Iterator<Node> iterator = nodes.iterator(); iterator.hasNext();) {
 278                 descCount++;
 279                 NodeKey nodeKey =  iterator.next().getKey();
 280                 InstanceIdentifier<FlowCapableNode> nodeRef = InstanceIdentifier.builder(Nodes.class).child(Node.class, nodeKey).augmentation(FlowCapableNode.class).toInstance();
 281                 FlowCapableNode node = (FlowCapableNode)dataProviderService.readOperationalData(nodeRef);
 282                     if(null != node.getHardware() &&
 283                             null != node.getManufacturer() &&
 284                             null != node.getSoftware())
 285                     {
 286                         descStatsCount++;
 287                     }
 288             }
 289
 290             if(descCount == descStatsCount)
 291             {
 292                 ci.println("descStats - Success");
 293             }
 294             else
 295             {
 296                 ci.println("descStats - Failed");
 297                 ci.println("System fetchs stats data in 50 seconds interval, so pls wait and try again.");
 298             }
 299
 300        }
 301
 302     private List<Node> getNodes()
 303     {
 304         Nodes nodes = (Nodes)dataProviderService.readOperationalData(InstanceIdentifier.builder(Nodes.class).toInstance());
 305         if(null == nodes)
 306         {
 307             throw new RuntimeException("nodes are not found, pls add the node.");
 308         }
 309         return nodes.getNode();
 310
 311     }
 312
 313
 314     @Override
 315     public String getHelp() {
 316         StringBuffer help = new StringBuffer();
 317         help.append("---MD-SAL Stats test module---\n");
 318         return help.toString();
 319     }
 320
 321
 322 }