X-Git-Url: https://gerrit.fd.io/r/gitweb?p=csit.git;a=blobdiff_plain;f=resources%2Flibraries%2Fpython%2FVppCounters.py;h=8247a1e8abf1c56713335cc4669664976abce831;hp=f34d7a76d18b9bd2f9a768c56b3d66811e718ec7;hb=d40746ab2134b0cedb2199685aab0ca8cea649cb;hpb=33499c81c94c2d3baef9d3e9f061cd76ef86fa74

diff --git a/resources/libraries/python/VppCounters.py b/resources/libraries/python/VppCounters.py
index f34d7a76d1..8247a1e8ab 100644
--- a/resources/libraries/python/VppCounters.py
+++ b/resources/libraries/python/VppCounters.py
@@ -14,9 +14,10 @@
 """VPP counters utilities library."""
 
 import time
-from topology import NodeType, Topology
-from VatExecutor import VatExecutor, VatTerminal
+
 from robot.api import logger
+from resources.libraries.python.topology import NodeType, Topology
+from resources.libraries.python.VatExecutor import VatExecutor, VatTerminal
 
 
 class VppCounters(object):
@@ -28,62 +29,231 @@ class VppCounters(object):
     def vpp_nodes_clear_interface_counters(self, nodes):
         """Clear interface counters on all VPP nodes in topology.
 
-           :param nodes: Nodes in topology.
-           :type nodes: dict
+        :param nodes: Nodes in topology.
+        :type nodes: dict
         """
         for node in nodes.values():
             if node['type'] == NodeType.DUT:
                 self.vpp_clear_interface_counters(node)
 
+    @staticmethod
+    def vpp_show_errors(node):
+        """Run "show errors" debug CLI command.
+
+        :param node: Node to run command on.
+        :type node: dict
+        """
+        vat = VatExecutor()
+        vat.execute_script("show_errors.vat", node, json_out=False)
+
+    @staticmethod
+    def vpp_show_errors_verbose(node):
+        """Run "show errors verbose" debug CLI command.
+
+        :param node: Node to run command on.
+        :type node: dict
+        """
+        vat = VatExecutor()
+        vat.execute_script("show_errors_verbose.vat", node, json_out=False)
+
+    @staticmethod
+    def vpp_show_errors_on_all_duts(nodes, verbose=False):
+        """Show errors on all DUTs.
+
+        :param nodes: VPP nodes.
+        :param verbose: If True show verbose output.
+        :type nodes: dict
+        :type verbose: bool
+        """
+
+        for node in nodes.values():
+            if node['type'] == NodeType.DUT:
+                if verbose:
+                    VppCounters.vpp_show_errors_verbose(node)
+                else:
+                    VppCounters.vpp_show_errors(node)
+
+    @staticmethod
+    def vpp_show_runtime(node):
+        """Run "show runtime" CLI command.
+
+        :param node: Node to run command on.
+        :type node: dict
+        """
+        vat = VatExecutor()
+        vat.execute_script("show_runtime.vat", node, json_out=False)
+
+    @staticmethod
+    def show_runtime_counters_on_all_duts(nodes):
+        """Clear VPP runtime counters on all DUTs.
+
+        :param nodes: VPP nodes.
+        :type nodes: dict
+        """
+        for node in nodes.values():
+            if node['type'] == NodeType.DUT:
+                VppCounters.vpp_show_runtime(node)
+
+    @staticmethod
+    def vpp_show_runtime_verbose(node):
+        """Run "show runtime verbose" CLI command.
+
+        :param node: Node to run command on.
+        :type node: dict
+        """
+        vat = VatExecutor()
+        vat.execute_script("show_runtime_verbose.vat", node, json_out=False)
+
+    @staticmethod
+    def vpp_show_hardware_detail(node):
+        """Run "show hardware-interfaces detail" debug CLI command.
+
+        :param node: Node to run command on.
+        :type node: dict
+        """
+        vat = VatExecutor()
+        vat.execute_script("show_hardware_detail.vat", node, json_out=False)
+
+    @staticmethod
+    def vpp_clear_runtime(node):
+        """Run "clear runtime" CLI command.
+
+        :param node: Node to run command on.
+        :type node: dict
+        """
+        vat = VatExecutor()
+        vat.execute_script("clear_runtime.vat", node, json_out=False)
+
+    @staticmethod
+    def clear_runtime_counters_on_all_duts(nodes):
+        """Run "clear runtime" CLI command on all DUTs.
+
+        :param nodes: VPP nodes.
+        :type nodes: dict
+        """
+        for node in nodes.values():
+            if node['type'] == NodeType.DUT:
+                VppCounters.vpp_clear_runtime(node)
+
     @staticmethod
     def vpp_clear_interface_counters(node):
         """Clear interface counters on VPP node.
 
-           :param node: Node to clear interface counters on.
-           :type node: dict
+        :param node: Node to clear interface counters on.
+        :type node: dict
         """
         vat = VatExecutor()
         vat.execute_script('clear_interface.vat', node)
         vat.script_should_have_passed()
 
+    @staticmethod
+    def clear_interface_counters_on_all_duts(nodes):
+        """Clear interface counters on all DUTs.
+
+        :param nodes: VPP nodes.
+        :type nodes: dict
+        """
+        for node in nodes.values():
+            if node['type'] == NodeType.DUT:
+                VppCounters.vpp_clear_interface_counters(node)
+
+    @staticmethod
+    def vpp_clear_hardware_counters(node):
+        """Clear interface hardware counters on VPP node.
+
+        :param node: Node to clear hardware counters on.
+        :type node: dict
+        """
+        vat = VatExecutor()
+        vat.execute_script('clear_hardware.vat', node)
+        vat.script_should_have_passed()
+
+    @staticmethod
+    def clear_hardware_counters_on_all_duts(nodes):
+        """Clear hardware counters on all DUTs.
+
+        :param nodes: VPP nodes.
+        :type nodes: dict
+        """
+        for node in nodes.values():
+            if node['type'] == NodeType.DUT:
+                VppCounters.vpp_clear_hardware_counters(node)
+
+    @staticmethod
+    def vpp_clear_errors_counters(node):
+        """Clear errors counters on VPP node.
+
+        :param node: Node to clear errors counters on.
+        :type node: dict
+        """
+        vat = VatExecutor()
+        vat.execute_script('clear_errors.vat', node)
+        vat.script_should_have_passed()
+
+    @staticmethod
+    def clear_error_counters_on_all_duts(nodes):
+        """Clear VPP errors counters on all DUTs.
+
+        :param nodes: VPP nodes.
+        :type nodes: dict
+        """
+        for node in nodes.values():
+            if node['type'] == NodeType.DUT:
+                VppCounters.vpp_clear_errors_counters(node)
+
     def vpp_dump_stats_table(self, node):
         """Dump stats table on VPP node.
 
-           :param node: Node to dump stats table on.
-           :type node: dict
-           :return: Stats table.
+        :param node: Node to dump stats table on.
+        :type node: dict
+        :returns: Stats table.
         """
-        vat = VatTerminal(node)
-        vat.vat_terminal_exec_cmd('want_stats enable')
-        for _ in range(0, 12):
-            stats_table = vat.vat_terminal_exec_cmd('dump_stats_table')
-            if_counters = stats_table['interface_counters']
-            if len(if_counters) > 0:
-                self._stats_table = stats_table
-                vat.vat_terminal_close()
-                return stats_table
-            time.sleep(1)
-
-        vat.vat_terminal_close()
-        return None
+        with VatTerminal(node) as vat:
+            vat.vat_terminal_exec_cmd('want_stats enable')
+            for _ in range(0, 12):
+                stats_table = vat.vat_terminal_exec_cmd('dump_stats_table')
+                if_counters = stats_table['interface_counters']
+                if len(if_counters) > 0:
+                    self._stats_table = stats_table
+                    return stats_table
+                time.sleep(1)
+            return None
 
     def vpp_get_ipv4_interface_counter(self, node, interface):
+        """
+
+        :param node: Node to get interface IPv4 counter on.
+        :param interface: Interface name.
+        :type node: dict
+        :type interface: str
+        :returns: Interface IPv4 counter.
+        :rtype: int
+        """
         return self.vpp_get_ipv46_interface_counter(node, interface, False)
 
     def vpp_get_ipv6_interface_counter(self, node, interface):
+        """
+
+        :param node: Node to get interface IPv6 counter on.
+        :param interface: Interface name.
+        :type node: dict
+        :type interface: str
+        :returns: Interface IPv6 counter.
+        :rtype: int
+        """
         return self.vpp_get_ipv46_interface_counter(node, interface, True)
 
     def vpp_get_ipv46_interface_counter(self, node, interface, is_ipv6=True):
-        """Return interface IPv4/IPv6 counter
+        """Return interface IPv4/IPv6 counter.
 
-           :param node: Node to get interface IPv4/IPv6 counter on.
-           :param interface: Interface name.
-           :type node: dict
-           :type interface: str
-           :return: Interface IPv4/IPv6 counter.
-           :param is_ipv6: specify IP version
-           :type is_ipv6: bool
-           :rtype: int
+        :param node: Node to get interface IPv4/IPv6 counter on.
+        :param interface: Interface name.
+        :param is_ipv6: Specify IP version.
+        :type node: dict
+        :type interface: str
+        :type is_ipv6: bool
+        :returns: Interface IPv4/IPv6 counter.
+        :rtype: int
         """
         version = 'ip6' if is_ipv6 else 'ip4'
         topo = Topology()
@@ -103,3 +273,29 @@ class VppCounters(object):
         logger.trace('{i} {v} counter not found.'.format(i=interface,
                                                          v=version))
         return 0
+
+    @staticmethod
+    def show_vpp_statistics(node):
+        """Show [error, hardware, interface] stats.
+
+        :param node: VPP node.
+        :type node: dict
+        """
+        VppCounters.vpp_show_errors(node)
+        VppCounters.vpp_show_hardware_detail(node)
+        VppCounters.vpp_show_runtime(node)
+
+    @staticmethod
+    def show_statistics_on_all_duts(nodes, sleeptime=5):
+        """Show VPP statistics on all DUTs.
+
+        :param nodes: VPP nodes.
+        :type nodes: dict
+        :param sleeptime: Time to wait for traffic to arrive back to TG.
+        :type sleeptime: int
+        """
+        logger.trace('Waiting for statistics to be collected')
+        time.sleep(sleeptime)
+        for node in nodes.values():
+            if node['type'] == NodeType.DUT:
+                VppCounters.show_vpp_statistics(node)