VAT-to-PAPI: VPPCounters 24/19924/41
authorTibor Frank <tifrank@cisco.com>
Mon, 3 Jun 2019 10:55:55 +0000 (12:55 +0200)
committerTibor Frank <tifrank@cisco.com>
Wed, 19 Jun 2019 13:54:08 +0000 (13:54 +0000)
Change-Id: I5954fdd61ead9b4143f8cc4e20294cf8e199e0af
Signed-off-by: Tibor Frank <tifrank@cisco.com>
resources/libraries/python/PapiExecutor.py
resources/libraries/python/VppConfigGenerator.py
resources/libraries/python/VppCounters.py
resources/libraries/robot/shared/default.robot
resources/tools/papi/vpp_papi_provider.py

index 98eb59c..5e35422 100644 (file)
@@ -327,6 +327,25 @@ class PapiExecutor(object):
 
         return json.loads(stdout)
 
+    def get_stats_reply(self, err_msg="Failed to get statistics.", timeout=120):
+        """Get VPP Stats reply from VPP Python API.
+
+        :param err_msg: The message used if the PAPI command(s) execution fails.
+        :param timeout: Timeout in seconds.
+        :type err_msg: str
+        :type timeout: int
+        :returns: Requested VPP statistics.
+        :rtype: list
+        """
+
+        args = self._api_command_list[0]['api_args']
+        self._api_command_list = list()
+
+        stdout, _ = self._execute_papi(
+            args, method='stats_request', err_msg=err_msg, timeout=timeout)
+
+        return json.loads(stdout)
+
     def get_replies(self, err_msg="Failed to get replies.",
                     process_reply=True, ignore_errors=False, timeout=120):
         """Get reply/replies from VPP Python API.
@@ -536,7 +555,8 @@ class PapiExecutor(object):
         if not api_data:
             RuntimeError("No API data provided.")
 
-        json_data = json.dumps(api_data) if method == "stats" \
+        json_data = json.dumps(api_data) \
+            if method in ("stats", "stats_request") \
             else json.dumps(self._process_api_data(api_data))
 
         cmd = "{fw_dir}/{papi_provider} --method {method} --data '{json}'".\
index 179e4a0..e92d674 100644 (file)
@@ -436,6 +436,15 @@ class VppConfigGenerator(object):
         path = ['statseg', 'size']
         self.add_config_item(self._nodeconfig, value, path)
 
+    def add_statseg_per_node_counters(self, value):
+        """Add stats per-node-counters configuration.
+
+        :param value: "on" to switch the counters on.
+        :type value: str
+        """
+        path = ['statseg', 'per-node-counters']
+        self.add_config_item(self._nodeconfig, value, path)
+
     def add_plugin(self, state, *plugins):
         """Add plugin section for specific plugin(s).
 
index b65b58c..cc35548 100644 (file)
@@ -1,4 +1,4 @@
-# Copyright (c) 2016 Cisco and/or its affiliates.
+# Copyright (c) 2019 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
 
 import time
 
+from pprint import pformat
+
 from robot.api import logger
 from resources.libraries.python.PapiExecutor import PapiExecutor
 from resources.libraries.python.topology import NodeType, Topology
-from resources.libraries.python.VatExecutor import VatExecutor, VatTerminal
 
 
 class VppCounters(object):
@@ -27,6 +28,44 @@ class VppCounters(object):
     def __init__(self):
         self._stats_table = None
 
+    @staticmethod
+    def _run_cli_cmd(node, cmd, log=True):
+        """Run a CLI command.
+
+        :param node: Node to run command on.
+        :param cmd: The CLI command to be run on the node.
+        :param log: If True, the response is logged.
+        :type node: dict
+        :type cmd: str
+        :type log: bool
+        :returns: Verified data from PAPI response.
+        :rtype: dict
+        """
+        cli = 'cli_inband'
+        args = dict(cmd=cmd)
+        err_msg = "Failed to run 'cli_inband {cmd}' PAPI command on host " \
+                  "{host}".format(host=node['host'], cmd=cmd)
+
+        with PapiExecutor(node) as papi_exec:
+            data = papi_exec.add(cli, **args).get_replies(err_msg). \
+                verify_reply(err_msg=err_msg)
+
+        if log:
+            logger.info("{cmd}:\n{data}".format(cmd=cmd, data=data["reply"]))
+
+        return data
+
+    @staticmethod
+    def _get_non_zero_items(data):
+        """Extract and return non-zero items from the input data.
+
+        :param data: Data to filter.
+        :type data: dict
+        :returns: Dictionary with non-zero items.
+        :rtype dict
+        """
+        return {k: data[k] for k in data.keys() if sum(data[k])}
+
     @staticmethod
     def vpp_show_errors(node):
         """Run "show errors" debug CLI command.
@@ -34,9 +73,7 @@ class VppCounters(object):
         :param node: Node to run command on.
         :type node: dict
         """
-        vat = VatExecutor()
-        vat.execute_script("show_errors.vat", node, json_out=False)
-        vat.script_should_have_passed()
+        VppCounters._run_cli_cmd(node, 'show errors')
 
     @staticmethod
     def vpp_show_errors_verbose(node):
@@ -45,9 +82,7 @@ class VppCounters(object):
         :param node: Node to run command on.
         :type node: dict
         """
-        vat = VatExecutor()
-        vat.execute_script("show_errors_verbose.vat", node, json_out=False)
-        vat.script_should_have_passed()
+        VppCounters._run_cli_cmd(node, 'show errors verbose')
 
     @staticmethod
     def vpp_show_errors_on_all_duts(nodes, verbose=False):
@@ -58,7 +93,6 @@ class VppCounters(object):
         :type nodes: dict
         :type verbose: bool
         """
-
         for node in nodes.values():
             if node['type'] == NodeType.DUT:
                 if verbose:
@@ -67,16 +101,73 @@ class VppCounters(object):
                     VppCounters.vpp_show_errors(node)
 
     @staticmethod
-    def vpp_show_runtime(node):
+    def vpp_show_runtime(node, log_zeros=False):
         """Run "show runtime" CLI command.
 
         :param node: Node to run command on.
+        :param log_zeros: Log also items with zero values.
         :type node: dict
+        :type log_zeros: bool
         """
-        vat = VatExecutor()
-        vat.execute_script("show_runtime.vat", node, json_out=False)
-        logger.info(vat.get_script_stdout())
-        vat.script_should_have_passed()
+        args = dict(path='^/sys/node')
+        with PapiExecutor(node) as papi_exec:
+            stats = papi_exec.add("vpp-stats", **args).get_stats()[0]
+
+        names = stats['/sys/node/names']
+
+        if not names:
+            return
+
+        runtime = []
+        runtime_non_zero = []
+
+        for name in names:
+            runtime.append({'name': name})
+
+        for idx, runtime_item in enumerate(runtime):
+
+            calls_th = []
+            for thread in stats['/sys/node/calls']:
+                calls_th.append(thread[idx])
+            runtime_item["calls"] = calls_th
+
+            vectors_th = []
+            for thread in stats['/sys/node/vectors']:
+                vectors_th.append(thread[idx])
+            runtime_item["vectors"] = vectors_th
+
+            suspends_th = []
+            for thread in stats['/sys/node/suspends']:
+                suspends_th.append(thread[idx])
+            runtime_item["suspends"] = suspends_th
+
+            clocks_th = []
+            for thread in stats['/sys/node/clocks']:
+                clocks_th.append(thread[idx])
+            runtime_item["clocks"] = clocks_th
+
+            if (sum(calls_th) or sum(vectors_th) or
+                    sum(suspends_th) or sum(clocks_th)):
+                runtime_non_zero.append(runtime_item)
+
+        if log_zeros:
+            logger.info("Runtime:\n{runtime}".format(
+                runtime=pformat(runtime)))
+        else:
+            logger.info("Runtime:\n{runtime}".format(
+                runtime=pformat(runtime_non_zero)))
+
+    @staticmethod
+    def vpp_show_runtime_verbose(node):
+        """Run "show runtime verbose" CLI command.
+
+        TODO: Remove?
+              Only verbose output is possible to get using VPPStats.
+
+        :param node: Node to run command on.
+        :type node: dict
+        """
+        VppCounters.vpp_show_runtime(node)
 
     @staticmethod
     def show_runtime_counters_on_all_duts(nodes):
@@ -89,18 +180,6 @@ class VppCounters(object):
             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)
-        logger.info(vat.get_script_stdout())
-        vat.script_should_have_passed()
-
     @staticmethod
     def vpp_show_hardware_detail(node):
         """Run "show hardware-interfaces detail" debug CLI command.
@@ -108,9 +187,7 @@ class VppCounters(object):
         :param node: Node to run command on.
         :type node: dict
         """
-        vat = VatExecutor()
-        vat.execute_script("show_hardware_detail.vat", node, json_out=False)
-        vat.script_should_have_passed()
+        VppCounters._run_cli_cmd(node, 'show hardware detail')
 
     @staticmethod
     def vpp_clear_runtime(node):
@@ -118,18 +195,10 @@ class VppCounters(object):
 
         :param node: Node to run command on.
         :type node: dict
+        :returns: Verified data from PAPI response.
+        :rtype: dict
         """
-        cmd = 'cli_inband'
-        cmd_reply = 'cli_inband_reply'
-        err_msg = "Failed to run '{cmd}' PAPI command on host {host}!".format(
-            host=node['host'], cmd=cmd)
-        args = dict(cmd='clear runtime')
-        with PapiExecutor(node) as papi_exec:
-            papi_resp = papi_exec.add(cmd, **args).execute_should_pass(err_msg)
-        data = papi_resp.reply[0]['api_reply'][cmd_reply]
-        if data['retval'] != 0:
-            raise RuntimeError("Failed to clear runtime on host {host}".
-                               format(host=node['host']))
+        return VppCounters._run_cli_cmd(node, 'clear runtime', log=False)
 
     @staticmethod
     def clear_runtime_counters_on_all_duts(nodes):
@@ -144,22 +213,14 @@ class VppCounters(object):
 
     @staticmethod
     def vpp_clear_interface_counters(node):
-        """Clear interface counters on VPP node.
+        """Run "clear interfaces" CLI command.
 
-        :param node: Node to clear interface counters on.
+        :param node: Node to run command on.
         :type node: dict
+        :returns: Verified data from PAPI response.
+        :rtype: dict
         """
-        cmd = 'cli_inband'
-        cmd_reply = 'cli_inband_reply'
-        err_msg = "Failed to run '{cmd}' PAPI command on host {host}!".format(
-            host=node['host'], cmd=cmd)
-        args = dict(cmd='clear interfaces')
-        with PapiExecutor(node) as papi_exec:
-            papi_resp = papi_exec.add(cmd, **args).execute_should_pass(err_msg)
-        data = papi_resp.reply[0]['api_reply'][cmd_reply]
-        if data['retval'] != 0:
-            raise RuntimeError("Failed to clear interfaces on host {host}".
-                               format(host=node['host']))
+        return VppCounters._run_cli_cmd(node, 'clear interfaces', log=False)
 
     @staticmethod
     def clear_interface_counters_on_all_duts(nodes):
@@ -174,14 +235,14 @@ class VppCounters(object):
 
     @staticmethod
     def vpp_clear_hardware_counters(node):
-        """Clear interface hardware counters on VPP node.
+        """Run "clear hardware" CLI command.
 
-        :param node: Node to clear hardware counters on.
+        :param node: Node to run command on.
         :type node: dict
+        :returns: Verified data from PAPI response.
+        :rtype: dict
         """
-        vat = VatExecutor()
-        vat.execute_script('clear_hardware.vat', node)
-        vat.script_should_have_passed()
+        return VppCounters._run_cli_cmd(node, 'clear hardware', log=False)
 
     @staticmethod
     def clear_hardware_counters_on_all_duts(nodes):
@@ -196,14 +257,14 @@ class VppCounters(object):
 
     @staticmethod
     def vpp_clear_errors_counters(node):
-        """Clear errors counters on VPP node.
+        """Run "clear errors" CLI command.
 
-        :param node: Node to clear errors counters on.
+        :param node: Node to run command on.
         :type node: dict
+        :returns: Verified data from PAPI response.
+        :rtype: dict
         """
-        vat = VatExecutor()
-        vat.execute_script('clear_errors.vat', node)
-        vat.script_should_have_passed()
+        return VppCounters._run_cli_cmd(node, 'clear errors', log=False)
 
     @staticmethod
     def clear_error_counters_on_all_duts(nodes):
@@ -216,23 +277,6 @@ class VppCounters(object):
             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
-        :returns: Stats table.
-        """
-        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 stats_table['interface_counters']:
-                    self._stats_table = stats_table
-                    return stats_table
-                time.sleep(1)
-            return None
-
     def vpp_get_ipv4_interface_counter(self, node, interface):
         """
 
index 897b3be..262dc02 100644 (file)
 | | | Run keyword | ${dut}.Add DPDK Uio Driver
 | | | Run keyword | ${dut}.Add Heapsize | 4G
 | | | Run keyword | ${dut}.Add Statseg size | 4G
+| | | Run keyword | ${dut}.Add Statseg Per Node Counters | on
 | | | Run keyword | ${dut}.Add Plugin | disable | default
 | | | Run keyword | ${dut}.Add Plugin | enable | @{plugins_to_enable}
 | | | Run keyword | ${dut}.Add IP6 Hash Buckets | 2000000
index ee0d538..ded3c30 100755 (executable)
@@ -214,6 +214,33 @@ def process_stats(args):
             reply=reply, exc=repr(err)))
 
 
+def process_stats_request(args):
+    """Process the VPP Stats requests.
+
+    :param args: Command line arguments passed to VPP PAPI Provider.
+    :type args: ArgumentParser
+    :returns: JSON formatted string.
+    :rtype: str
+    :raises RuntimeError: If PAPI command error occurs.
+    """
+
+    try:
+        stats = VPPStats(args.socket)
+    except Exception as err:
+        raise RuntimeError('PAPI init failed:\n{err}'.format(err=repr(err)))
+
+    try:
+        json_data = json.loads(args.data)
+    except ValueError as err:
+        raise RuntimeError('Input json string is invalid:\n{err}'.
+                           format(err=repr(err)))
+
+    papi_fn = getattr(stats, json_data["api_name"])
+    reply = papi_fn(**json_data.get("api_args", {}))
+
+    return json.dumps(reply)
+
+
 def main():
     """Main function for the Python API provider.
     """
@@ -222,7 +249,8 @@ def main():
     process_request = dict(
         request=process_json_request,
         dump=process_json_request,
-        stats=process_stats
+        stats=process_stats,
+        stats_request=process_stats_request
     )
 
     parser = argparse.ArgumentParser(

©2016 FD.io a Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation. Linux is a registered trademark of Linus Torvalds.
Please see our privacy policy and terms of use.