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