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

   1 /*
   2  * Copyright (c) 2014, 2015 IBM Corporation and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.openflowplugin.test;
  10
  11 import java.util.Iterator;
  12 import java.util.List;
  13
  14 import org.eclipse.osgi.framework.console.CommandInterpreter;
  15 import org.eclipse.osgi.framework.console.CommandProvider;
  16 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  17 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  18 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.MeterKey;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.AggregateFlowStatisticsData;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowStatisticsData;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.FlowTableStatisticsData;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupDescStats;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupStatistics;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupKey;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterConfigStats;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterStatistics;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatisticsData;
  42 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  43 import org.osgi.framework.BundleContext;
  44 import org.slf4j.Logger;
  45 import org.slf4j.LoggerFactory;
  46
  47 import com.google.common.base.Preconditions;
  48
  49 public class OpenflowpluginStatsTestCommandProvider implements CommandProvider {
  50
  51  private static final Logger LOG = LoggerFactory
  52    .getLogger(OpenflowpluginStatsTestCommandProvider.class);
  53  private DataBroker dataProviderService;
  54  private final BundleContext ctx;
  55
  56  public OpenflowpluginStatsTestCommandProvider(BundleContext ctx) {
  57   this.ctx = ctx;
  58  }
  59
  60  public void onSessionInitiated(ProviderContext session) {
  61   dataProviderService = session.getSALService(DataBroker.class);
  62   ctx.registerService(CommandProvider.class.getName(), this, null);
  63
  64  }
  65
  66  public void _portStats(CommandInterpreter ci) {
  67   int nodeConnectorCount = 0;
  68   int nodeConnectorStatsCount = 0;
  69   List<Node> nodes = getNodes();
  70   for (Iterator<Node> iterator = nodes.iterator(); iterator.hasNext();) {
  71    NodeKey nodeKey = iterator.next().getKey();
  72    InstanceIdentifier<Node> nodeRef = InstanceIdentifier.create(Nodes.class)
  73      .child(Node.class, nodeKey);
  74    ReadOnlyTransaction readOnlyTransaction = dataProviderService
  75      .newReadOnlyTransaction();
  76    Node node = TestProviderTransactionUtil.getDataObject(readOnlyTransaction,
  77      nodeRef);
  78    if (node != null) {
  79     if (node.getNodeConnector() != null) {
  80      List<NodeConnector> ports = node.getNodeConnector();
  81
  82      for (Iterator<NodeConnector> iterator2 = ports.iterator(); iterator2
  83        .hasNext();) {
  84       nodeConnectorCount++;
  85       NodeConnectorKey nodeConnectorKey = iterator2.next().getKey();
  86       InstanceIdentifier<NodeConnector> connectorRef = InstanceIdentifier
  87         .create(Nodes.class).child(Node.class, nodeKey)
  88         .child(NodeConnector.class, nodeConnectorKey);
  89       NodeConnector nodeConnector = TestProviderTransactionUtil.getDataObject(
  90         readOnlyTransaction, connectorRef);
  91       if (nodeConnector != null) {
  92        FlowCapableNodeConnectorStatisticsData data = nodeConnector
  93          .getAugmentation(FlowCapableNodeConnectorStatisticsData.class);
  94        if (null != data) {
  95         nodeConnectorStatsCount++;
  96        }
  97       }
  98      }
  99     }
 100    }
 101   }
 102
 103   if (nodeConnectorCount == nodeConnectorStatsCount) {
 104    LOG.debug("portStats - Success");
 105   } else {
 106    LOG.debug("portStats - Failed");
 107    LOG
 108      .debug("System fetchs stats data in 50 seconds interval, so pls wait and try again.");
 109   }
 110
 111  }
 112
 113  public void _portDescStats(CommandInterpreter ci) {
 114   int nodeConnectorCount = 0;
 115   int nodeConnectorDescStatsCount = 0;
 116   List<Node> nodes = getNodes();
 117   for (Iterator<Node> iterator = nodes.iterator(); iterator.hasNext();) {
 118    NodeKey nodeKey = iterator.next().getKey();
 119    InstanceIdentifier<Node> nodeRef = InstanceIdentifier.create(Nodes.class)
 120      .child(Node.class, nodeKey);
 121
 122    ReadOnlyTransaction readOnlyTransaction = dataProviderService
 123      .newReadOnlyTransaction();
 124    Node node = TestProviderTransactionUtil.getDataObject(readOnlyTransaction,
 125      nodeRef);
 126    if (node != null) {
 127     if (node.getNodeConnector() != null) {
 128      List<NodeConnector> ports = node.getNodeConnector();
 129      for (Iterator<NodeConnector> iterator2 = ports.iterator(); iterator2
 130        .hasNext();) {
 131       nodeConnectorCount++;
 132       NodeConnectorKey nodeConnectorKey = iterator2.next().getKey();
 133       InstanceIdentifier<FlowCapableNodeConnector> connectorRef = InstanceIdentifier
 134         .create(Nodes.class).child(Node.class, nodeKey)
 135         .child(NodeConnector.class, nodeConnectorKey)
 136         .augmentation(FlowCapableNodeConnector.class);
 137       FlowCapableNodeConnector nodeConnector = TestProviderTransactionUtil
 138         .getDataObject(readOnlyTransaction, connectorRef);
 139       if (nodeConnector != null) {
 140        if (null != nodeConnector.getName()
 141          && null != nodeConnector.getCurrentFeature()
 142          && null != nodeConnector.getState()
 143          && null != nodeConnector.getHardwareAddress()
 144          && null != nodeConnector.getPortNumber()) {
 145         nodeConnectorDescStatsCount++;
 146        }
 147       }
 148      }
 149     }
 150
 151    }
 152   }
 153
 154   if (nodeConnectorCount == nodeConnectorDescStatsCount) {
 155    LOG.debug("portDescStats - Success");
 156   } else {
 157    LOG.debug("portDescStats - Failed");
 158    LOG
 159      .debug("System fetchs stats data in 50 seconds interval, so pls wait and try again.");
 160   }
 161
 162  }
 163
 164  public void _flowStats(CommandInterpreter ci) {
 165   int flowCount = 0;
 166   int flowStatsCount = 0;
 167   List<Node> nodes = getNodes();
 168   for (Iterator<Node> iterator = nodes.iterator(); iterator.hasNext();) {
 169    NodeKey nodeKey = iterator.next().getKey();
 170    InstanceIdentifier<FlowCapableNode> nodeRef = InstanceIdentifier
 171      .create(Nodes.class).child(Node.class, nodeKey)
 172      .augmentation(FlowCapableNode.class);
 173
 174    ReadOnlyTransaction readOnlyTransaction = dataProviderService
 175      .newReadOnlyTransaction();
 176    FlowCapableNode node = TestProviderTransactionUtil.getDataObject(
 177      readOnlyTransaction, nodeRef);
 178
 179    if (node != null) {
 180     List<Table> tables = node.getTable();
 181     for (Iterator<Table> iterator2 = tables.iterator(); iterator2.hasNext();) {
 182      TableKey tableKey = iterator2.next().getKey();
 183      InstanceIdentifier<Table> tableRef = InstanceIdentifier
 184        .create(Nodes.class).child(Node.class, nodeKey)
 185        .augmentation(FlowCapableNode.class).child(Table.class, tableKey);
 186      Table table = TestProviderTransactionUtil.getDataObject(
 187        readOnlyTransaction, tableRef);
 188      if (table != null) {
 189       if (table.getFlow() != null) {
 190        List<Flow> flows = table.getFlow();
 191        for (Iterator<Flow> iterator3 = flows.iterator(); iterator3.hasNext();) {
 192         flowCount++;
 193         FlowKey flowKey = iterator3.next().getKey();
 194         InstanceIdentifier<Flow> flowRef = InstanceIdentifier
 195           .create(Nodes.class).child(Node.class, nodeKey)
 196           .augmentation(FlowCapableNode.class).child(Table.class, tableKey)
 197           .child(Flow.class, flowKey);
 198         Flow flow = TestProviderTransactionUtil.getDataObject(
 199           readOnlyTransaction, flowRef);
 200         if (flow != null) {
 201          FlowStatisticsData data = flow
 202            .getAugmentation(FlowStatisticsData.class);
 203          if (null != data) {
 204           flowStatsCount++;
 205           LOG.debug("--------------------------------------------");
 206           ci.print(data);
 207          }
 208         }
 209
 210        }
 211       }
 212      }
 213     }
 214    }
 215   }
 216
 217   if (flowCount == flowStatsCount) {
 218    LOG.debug("flowStats - Success");
 219   } else {
 220    LOG.debug("flowStats - Failed");
 221    LOG
 222      .debug("System fetchs stats data in 50 seconds interval, so pls wait and try again.");
 223   }
 224
 225  }
 226
 227  public void _tableStats(CommandInterpreter ci) {
 228   int tableCount = 0;
 229   int tableStatsCount = 0;
 230   List<Node> nodes = getNodes();
 231   for (Iterator<Node> iterator = nodes.iterator(); iterator.hasNext();) {
 232    NodeKey nodeKey = iterator.next().getKey();
 233    InstanceIdentifier<FlowCapableNode> nodeRef = InstanceIdentifier
 234      .create(Nodes.class).child(Node.class, nodeKey)
 235      .augmentation(FlowCapableNode.class);
 236
 237    ReadOnlyTransaction readOnlyTransaction = dataProviderService
 238      .newReadOnlyTransaction();
 239    FlowCapableNode node = TestProviderTransactionUtil.getDataObject(
 240      readOnlyTransaction, nodeRef);
 241    if (node != null) {
 242     List<Table> tables = node.getTable();
 243     for (Iterator<Table> iterator2 = tables.iterator(); iterator2.hasNext();) {
 244      tableCount++;
 245      TableKey tableKey = iterator2.next().getKey();
 246      InstanceIdentifier<Table> tableRef = InstanceIdentifier
 247        .create(Nodes.class).child(Node.class, nodeKey)
 248        .augmentation(FlowCapableNode.class).child(Table.class, tableKey);
 249      Table table = TestProviderTransactionUtil.getDataObject(
 250        readOnlyTransaction, tableRef);
 251      if (table != null) {
 252       FlowTableStatisticsData data = table
 253         .getAugmentation(FlowTableStatisticsData.class);
 254       if (null != data) {
 255        tableStatsCount++;
 256       }
 257      }
 258     }
 259    }
 260   }
 261
 262   if (tableCount == tableStatsCount) {
 263    LOG.debug("tableStats - Success");
 264   } else {
 265    LOG.debug("tableStats - Failed");
 266    LOG
 267      .debug("System fetchs stats data in 50 seconds interval, so pls wait and try again.");
 268   }
 269
 270  }
 271
 272  public void _groupStats(CommandInterpreter ci) {
 273   int groupCount = 0;
 274   int groupStatsCount = 0;
 275   NodeGroupStatistics data = null;
 276   List<Node> nodes = getNodes();
 277   for (Iterator<Node> iterator = nodes.iterator(); iterator.hasNext();) {
 278    NodeKey nodeKey = iterator.next().getKey();
 279    InstanceIdentifier<FlowCapableNode> nodeRef = InstanceIdentifier
 280      .create(Nodes.class).child(Node.class, nodeKey)
 281      .augmentation(FlowCapableNode.class);
 282    ReadOnlyTransaction readOnlyTransaction = dataProviderService
 283      .newReadOnlyTransaction();
 284    FlowCapableNode node = TestProviderTransactionUtil.getDataObject(
 285      readOnlyTransaction, nodeRef);
 286    if (node != null) {
 287     if (node.getGroup() != null) {
 288      List<Group> groups = node.getGroup();
 289      for (Iterator<Group> iterator2 = groups.iterator(); iterator2.hasNext();) {
 290       groupCount++;
 291       GroupKey groupKey = iterator2.next().getKey();
 292       InstanceIdentifier<Group> groupRef = InstanceIdentifier
 293         .create(Nodes.class).child(Node.class, nodeKey)
 294         .augmentation(FlowCapableNode.class).child(Group.class, groupKey);
 295       Group group = TestProviderTransactionUtil.getDataObject(
 296         readOnlyTransaction, groupRef);
 297       if (group != null) {
 298        data = group.getAugmentation(NodeGroupStatistics.class);
 299        if (null != data) {
 300         groupStatsCount++;
 301        }
 302       }
 303      }
 304     }
 305
 306    }
 307   }
 308
 309   if (groupCount == groupStatsCount) {
 310    LOG
 311      .debug("---------------------groupStats - Success-------------------------------");
 312   } else {
 313    LOG
 314      .debug("------------------------------groupStats - Failed--------------------------");
 315    LOG
 316      .debug("System fetchs stats data in 50 seconds interval, so pls wait and try again.");
 317   }
 318  }
 319
 320  public void _groupDescStats(CommandInterpreter ci) {
 321   int groupCount = 0;
 322   int groupDescStatsCount = 0;
 323   NodeGroupDescStats data = null;
 324   List<Node> nodes = getNodes();
 325   for (Iterator<Node> iterator = nodes.iterator(); iterator.hasNext();) {
 326    NodeKey nodeKey = iterator.next().getKey();
 327    InstanceIdentifier<FlowCapableNode> nodeRef = InstanceIdentifier
 328      .create(Nodes.class).child(Node.class, nodeKey)
 329      .augmentation(FlowCapableNode.class);
 330    ReadOnlyTransaction readOnlyTransaction = dataProviderService
 331      .newReadOnlyTransaction();
 332    FlowCapableNode node = TestProviderTransactionUtil.getDataObject(
 333      readOnlyTransaction, nodeRef);
 334
 335    if (node != null) {
 336     if (node.getGroup() != null) {
 337      List<Group> groups = node.getGroup();
 338      for (Iterator<Group> iterator2 = groups.iterator(); iterator2.hasNext();) {
 339       groupCount++;
 340       GroupKey groupKey = iterator2.next().getKey();
 341       InstanceIdentifier<Group> groupRef = InstanceIdentifier
 342         .create(Nodes.class).child(Node.class, nodeKey)
 343         .augmentation(FlowCapableNode.class).child(Group.class, groupKey);
 344       Group group = TestProviderTransactionUtil.getDataObject(
 345         readOnlyTransaction, groupRef);
 346       if (group != null) {
 347        data = group.getAugmentation(NodeGroupDescStats.class);
 348        if (null != data) {
 349         groupDescStatsCount++;
 350        }
 351       }
 352
 353      }
 354     }
 355    }
 356
 357    if (groupCount == groupDescStatsCount) {
 358     LOG
 359       .debug("---------------------groupDescStats - Success-------------------------------");
 360    } else {
 361     LOG
 362       .debug("------------------------------groupDescStats - Failed--------------------------");
 363     LOG
 364       .debug("System fetchs stats data in 50 seconds interval, so pls wait and try again.");
 365    }
 366   }
 367  }
 368
 369  public void _meterStats(CommandInterpreter ci) {
 370   int meterCount = 0;
 371   int meterStatsCount = 0;
 372   NodeMeterStatistics data = null;
 373   List<Node> nodes = getNodes();
 374   for (Iterator<Node> iterator = nodes.iterator(); iterator.hasNext();) {
 375    NodeKey nodeKey = iterator.next().getKey();
 376    InstanceIdentifier<FlowCapableNode> nodeRef = InstanceIdentifier
 377      .create(Nodes.class).child(Node.class, nodeKey)
 378      .augmentation(FlowCapableNode.class);
 379    ReadOnlyTransaction readOnlyTransaction = dataProviderService
 380      .newReadOnlyTransaction();
 381    FlowCapableNode node = TestProviderTransactionUtil.getDataObject(
 382      readOnlyTransaction, nodeRef);
 383    if (node != null) {
 384     if (node.getMeter() != null) {
 385      List<Meter> meters = node.getMeter();
 386      for (Iterator<Meter> iterator2 = meters.iterator(); iterator2.hasNext();) {
 387       meterCount++;
 388       MeterKey meterKey = iterator2.next().getKey();
 389       InstanceIdentifier<Meter> meterRef = InstanceIdentifier
 390         .create(Nodes.class).child(Node.class, nodeKey)
 391         .augmentation(FlowCapableNode.class).child(Meter.class, meterKey);
 392       Meter meter = TestProviderTransactionUtil.getDataObject(
 393         readOnlyTransaction, meterRef);
 394       if (meter != null) {
 395        data = meter.getAugmentation(NodeMeterStatistics.class);
 396        if (null != data) {
 397         meterStatsCount++;
 398        }
 399       }
 400      }
 401
 402     }
 403    }
 404   }
 405
 406   if (meterCount == meterStatsCount) {
 407    LOG
 408      .debug("---------------------------meterStats - Success-------------------------------------");
 409   } else {
 410    LOG
 411      .debug("----------------------------meterStats - Failed-------------------------------------");
 412    LOG
 413      .debug("System fetchs stats data in 50 seconds interval, so pls wait and try again.");
 414   }
 415  }
 416
 417  public void _meterConfigStats(CommandInterpreter ci) {
 418   int meterCount = 0;
 419   int meterConfigStatsCount = 0;
 420   NodeMeterConfigStats data = null;
 421   List<Node> nodes = getNodes();
 422   for (Iterator<Node> iterator = nodes.iterator(); iterator.hasNext();) {
 423    NodeKey nodeKey = iterator.next().getKey();
 424    InstanceIdentifier<FlowCapableNode> nodeRef = InstanceIdentifier
 425      .create(Nodes.class).child(Node.class, nodeKey)
 426      .augmentation(FlowCapableNode.class);
 427    ReadOnlyTransaction readOnlyTransaction = dataProviderService
 428      .newReadOnlyTransaction();
 429    FlowCapableNode node = TestProviderTransactionUtil.getDataObject(
 430      readOnlyTransaction, nodeRef);
 431    if (node != null) {
 432     if (node.getMeter() != null) {
 433      List<Meter> meters = node.getMeter();
 434      for (Iterator<Meter> iterator2 = meters.iterator(); iterator2.hasNext();) {
 435       meterCount++;
 436       MeterKey meterKey = iterator2.next().getKey();
 437       InstanceIdentifier<Meter> meterRef = InstanceIdentifier
 438         .create(Nodes.class).child(Node.class, nodeKey)
 439         .augmentation(FlowCapableNode.class).child(Meter.class, meterKey);
 440       Meter meter = TestProviderTransactionUtil.getDataObject(
 441         readOnlyTransaction, meterRef);
 442       if (meter != null) {
 443        data = meter.getAugmentation(NodeMeterConfigStats.class);
 444        if (null != data) {
 445         meterConfigStatsCount++;
 446        }
 447       }
 448      }
 449
 450     }
 451    }
 452   }
 453
 454   if (meterCount == meterConfigStatsCount) {
 455    LOG
 456      .debug("---------------------------meterConfigStats - Success-------------------------------------");
 457    ci.print(data);
 458   } else {
 459    LOG
 460      .debug("----------------------------meterConfigStats - Failed-------------------------------------");
 461    LOG
 462      .debug("System fetchs stats data in 50 seconds interval, so pls wait and try again.");
 463   }
 464  }
 465
 466  public void _aggregateStats(CommandInterpreter ci) {
 467   int aggregateFlowCount = 0;
 468   int aggerateFlowStatsCount = 0;
 469   List<Node> nodes = getNodes();
 470   for (Iterator<Node> iterator = nodes.iterator(); iterator.hasNext();) {
 471    NodeKey nodeKey = iterator.next().getKey();
 472    InstanceIdentifier<FlowCapableNode> nodeRef = InstanceIdentifier
 473      .create(Nodes.class).child(Node.class, nodeKey)
 474      .augmentation(FlowCapableNode.class);
 475    ReadOnlyTransaction readOnlyTransaction = dataProviderService
 476      .newReadOnlyTransaction();
 477    FlowCapableNode node = TestProviderTransactionUtil.getDataObject(
 478      readOnlyTransaction, nodeRef);
 479    if (node != null) {
 480     List<Table> tables = node.getTable();
 481     for (Iterator<Table> iterator2 = tables.iterator(); iterator2.hasNext();) {
 482      aggregateFlowCount++;
 483      TableKey tableKey = iterator2.next().getKey();
 484      InstanceIdentifier<Table> tableRef = InstanceIdentifier
 485        .create(Nodes.class).child(Node.class, nodeKey)
 486        .augmentation(FlowCapableNode.class).child(Table.class, tableKey);
 487      Table table = TestProviderTransactionUtil.getDataObject(
 488        readOnlyTransaction, tableRef);
 489      if (table != null) {
 490       AggregateFlowStatisticsData data = table
 491         .getAugmentation(AggregateFlowStatisticsData.class);
 492       if (null != data) {
 493        aggerateFlowStatsCount++;
 494       }
 495      }
 496     }
 497    }
 498   }
 499
 500   if (aggregateFlowCount == aggerateFlowStatsCount) {
 501    LOG.debug("aggregateStats - Success");
 502   } else {
 503    LOG.debug("aggregateStats - Failed");
 504    LOG
 505      .debug("System fetchs stats data in 50 seconds interval, so pls wait and try again.");
 506   }
 507
 508  }
 509
 510  public void _descStats(CommandInterpreter ci) {
 511   int descCount = 0;
 512   int descStatsCount = 0;
 513   List<Node> nodes = getNodes();
 514   for (Iterator<Node> iterator = nodes.iterator(); iterator.hasNext();) {
 515    descCount++;
 516    NodeKey nodeKey = iterator.next().getKey();
 517    InstanceIdentifier<FlowCapableNode> nodeRef = InstanceIdentifier
 518      .create(Nodes.class).child(Node.class, nodeKey)
 519      .augmentation(FlowCapableNode.class);
 520    ReadOnlyTransaction readOnlyTransaction = dataProviderService
 521      .newReadOnlyTransaction();
 522    FlowCapableNode node = TestProviderTransactionUtil.getDataObject(
 523      readOnlyTransaction, nodeRef);
 524    if (node != null) {
 525     if (null != node.getHardware() && null != node.getManufacturer()
 526       && null != node.getSoftware()) {
 527      descStatsCount++;
 528     }
 529    }
 530   }
 531
 532   if (descCount == descStatsCount) {
 533    LOG.debug("descStats - Success");
 534   } else {
 535    LOG.debug("descStats - Failed");
 536    LOG
 537      .debug("System fetches stats data in 50 seconds interval, so please wait and try again.");
 538   }
 539
 540  }
 541
 542  private List<Node> getNodes() {
 543   ReadOnlyTransaction readOnlyTransaction = dataProviderService
 544     .newReadOnlyTransaction();
 545   InstanceIdentifier<Nodes> nodesID = InstanceIdentifier.create(Nodes.class);
 546   Nodes nodes = TestProviderTransactionUtil.getDataObject(readOnlyTransaction,
 547     nodesID);
 548   if (nodes == null) {
 549    throw new RuntimeException("nodes are not found, pls add the node.");
 550   }
 551   return nodes.getNode();
 552  }
 553
 554  @Override
 555  public String getHelp() {
 556   StringBuilder help = new StringBuilder();
 557   help.append("---MD-SAL Stats test module---\n");
 558   return help.toString();
 559  }
 560
 561 }