-# Copyright (c) 2016 Cisco and/or its affiliates.
+# Copyright (c) 2021 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:
"""VPP counters utilities library."""
-import time
+from pprint import pformat
from robot.api import logger
-from resources.libraries.python.topology import NodeType, Topology
-from resources.libraries.python.VatExecutor import VatExecutor, VatTerminal
+from resources.libraries.python.PapiExecutor import PapiExecutor, \
+ PapiSocketExecutor
+from resources.libraries.python.topology import Topology, SocketType, NodeType
-class VppCounters(object):
+class VppCounters:
"""VPP counters utilities."""
def __init__(self):
self._stats_table = None
- 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
- """
- 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)
+ PapiSocketExecutor.run_cli_cmd_on_all_sockets(node, u"show errors")
@staticmethod
- def vpp_show_errors_verbose(node):
- """Run "show errors verbose" debug CLI command.
+ def vpp_show_errors_on_all_duts(nodes):
+ """Show errors on all DUTs.
+
+ :param nodes: VPP nodes.
+ :type nodes: dict
+ """
+ for node in nodes.values():
+ if node[u"type"] == NodeType.DUT:
+ VppCounters.vpp_show_errors(node)
+
+ @staticmethod
+ 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_errors_verbose.vat", node, json_out=False)
+ args = dict(path=u"^/sys/node")
+ sockets = Topology.get_node_sockets(node, socket_type=SocketType.STATS)
+ if sockets:
+ for socket in sockets.values():
+ with PapiExecutor(node) as papi_exec:
+ stats = papi_exec.add(u"vpp-stats", **args).\
+ get_stats(socket=socket)[0]
+
+ names = stats[u"/sys/node/names"]
+
+ if not names:
+ return
+
+ runtime = list()
+ runtime_nz = list()
+
+ for name in names:
+ runtime.append({u"name": name})
+
+ for idx, runtime_item in enumerate(runtime):
+
+ calls_th = []
+ for thread in stats[u"/sys/node/calls"]:
+ calls_th.append(thread[idx])
+ runtime_item[u"calls"] = calls_th
+
+ vectors_th = []
+ for thread in stats[u"/sys/node/vectors"]:
+ vectors_th.append(thread[idx])
+ runtime_item[u"vectors"] = vectors_th
+
+ suspends_th = []
+ for thread in stats[u"/sys/node/suspends"]:
+ suspends_th.append(thread[idx])
+ runtime_item[u"suspends"] = suspends_th
+
+ clocks_th = []
+ for thread in stats[u"/sys/node/clocks"]:
+ clocks_th.append(thread[idx])
+ runtime_item[u"clocks"] = clocks_th
+
+ if (sum(calls_th) or sum(vectors_th) or
+ sum(suspends_th) or sum(clocks_th)):
+ runtime_nz.append(runtime_item)
+
+ if log_zeros:
+ logger.info(
+ f"stats runtime ({node[u'host']} - {socket}):\n"
+ f"{pformat(runtime)}"
+ )
+ else:
+ logger.info(
+ f"stats runtime ({node[u'host']} - {socket}):\n"
+ f"{pformat(runtime_nz)}"
+ )
+ # Run also the CLI command, the above sometimes misses some info.
+ PapiSocketExecutor.run_cli_cmd_on_all_sockets(node, u"show runtime")
@staticmethod
- def vpp_show_errors_on_all_duts(nodes, verbose=False):
- """Show errors on all DUTs.
+ def vpp_show_runtime_on_all_duts(nodes):
+ """Clear VPP runtime counters on all DUTs.
- :param nodes: VPP nodes
- :param verbose: If True show verbose output.
+ :param nodes: VPP nodes.
: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)
+ if node[u"type"] == NodeType.DUT:
+ VppCounters.vpp_show_runtime(node)
@staticmethod
- def vpp_show_runtime(node):
- """Run "show runtime" CLI command.
+ def vpp_show_hardware(node):
+ """Run "show hardware" debug CLI command.
:param node: Node to run command on.
:type node: dict
"""
- vat = VatExecutor()
- vat.execute_script("show_runtime.vat", node, json_out=False)
+ PapiSocketExecutor.run_cli_cmd_on_all_sockets(
+ node, u"show hardware verbose"
+ )
@staticmethod
- def vpp_show_runtime_verbose(node):
- """Run "show runtime verbose" CLI command.
+ def vpp_show_memory(node):
+ """Run "show memory" debug CLI command.
+
+ Currently, every flag is hardcoded, giving the longest output.
:param node: Node to run command on.
:type node: dict
"""
- vat = VatExecutor()
- vat.execute_script("show_runtime_verbose.vat", node, json_out=False)
+ PapiSocketExecutor.run_cli_cmd_on_all_sockets(
+ node, u"show memory verbose api-segment stats-segment main-heap"
+ )
@staticmethod
- def vpp_show_hardware_detail(node):
- """Run "show hardware-interfaces detail" debug CLI command.
+ def vpp_show_memory_on_all_duts(nodes):
+ """Run "show memory" on all DUTs.
- :param node: Node to run command on.
- :type node: dict
+ :param nodes: VPP nodes.
+ :type nodes: dict
"""
- vat = VatExecutor()
- vat.execute_script("show_hardware_detail.vat", node, json_out=False)
+ for node in nodes.values():
+ if node[u"type"] == NodeType.DUT:
+ VppCounters.vpp_show_memory(node)
@staticmethod
def vpp_clear_runtime(node):
:param node: Node to run command on.
:type node: dict
"""
- vat = VatExecutor()
- vat.execute_script("clear_runtime.vat", node, json_out=False)
+ PapiSocketExecutor.run_cli_cmd_on_all_sockets(
+ node, u"clear runtime", log=False
+ )
@staticmethod
- def vpp_clear_interface_counters(node):
- """Clear interface counters on VPP node.
+ def vpp_clear_runtime_on_all_duts(nodes):
+ """Run "clear runtime" CLI command on all DUTs.
- :param node: Node to clear interface counters on.
- :type node: dict
+ :param nodes: VPP nodes.
+ :type nodes: dict
"""
- vat = VatExecutor()
- vat.execute_script('clear_interface.vat', node)
- vat.script_should_have_passed()
+ for node in nodes.values():
+ if node[u"type"] == NodeType.DUT:
+ VppCounters.vpp_clear_runtime(node)
@staticmethod
- def vpp_clear_hardware_counters(node):
- """Clear interface hardware counters on VPP node.
+ def vpp_clear_hardware(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()
+ PapiSocketExecutor.run_cli_cmd_on_all_sockets(
+ node, u"clear hardware", log=False
+ )
@staticmethod
- def vpp_clear_errors_counters(node):
- """Clear errors counters on VPP node.
+ def vpp_clear_hardware_on_all_duts(nodes):
+ """Clear hardware on all DUTs.
- :param node: Node to clear errors counters on.
- :type node: dict
+ :param nodes: VPP nodes.
+ :type nodes: dict
"""
- vat = VatExecutor()
- vat.execute_script('clear_errors.vat', node)
- vat.script_should_have_passed()
+ for node in nodes.values():
+ if node[u"type"] == NodeType.DUT:
+ VppCounters.vpp_clear_hardware(node)
- def vpp_dump_stats_table(self, node):
- """Dump stats table on VPP node.
+ @staticmethod
+ def vpp_clear_errors(node):
+ """Run "clear errors" CLI command.
- :param node: Node to dump stats table on.
+ :param node: Node to run command 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_counters = stats_table['interface_counters']
- if len(if_counters) > 0:
- self._stats_table = stats_table
- return stats_table
- time.sleep(1)
- return None
+ PapiSocketExecutor.run_cli_cmd_on_all_sockets(
+ node, u"clear errors", log=False
+ )
+
+ @staticmethod
+ def vpp_clear_errors_on_all_duts(nodes):
+ """Clear VPP errors counters on all DUTs.
- def vpp_get_ipv4_interface_counter(self, node, interface):
+ :param nodes: VPP nodes.
+ :type nodes: dict
"""
+ for node in nodes.values():
+ if node[u"type"] == NodeType.DUT:
+ VppCounters.vpp_clear_errors(node)
+
+ @staticmethod
+ def show_vpp_statistics(node):
+ """Show [errors, hardware] stats.
- :param node: Node to get interface IPv4 counter on.
- :param interface: Interface name.
+ :param node: VPP node.
:type node: dict
- :type interface: str
- :returns: Interface IPv4 counter.
- :rtype: int
"""
- return self.vpp_get_ipv46_interface_counter(node, interface, False)
+ VppCounters.vpp_show_errors(node)
+ VppCounters.vpp_show_hardware(node)
+
+ @staticmethod
+ def show_statistics_on_all_duts(nodes):
+ """Show statistics on all DUTs.
- def vpp_get_ipv6_interface_counter(self, node, interface):
+ :param nodes: DUT nodes.
+ :type nodes: dict
"""
+ for node in nodes.values():
+ if node[u"type"] == NodeType.DUT:
+ VppCounters.show_vpp_statistics(node)
+
+ @staticmethod
+ def clear_vpp_statistics(node):
+ """Clear [errors, hardware] stats.
- :param node: Node to get interface IPv6 counter on.
- :param interface: Interface name.
+ :param node: VPP node.
:type node: dict
- :type interface: str
- :returns: Interface IPv6 counter.
- :rtype: int
"""
- return self.vpp_get_ipv46_interface_counter(node, interface, True)
+ VppCounters.vpp_clear_errors(node)
+ VppCounters.vpp_clear_hardware(node)
- def vpp_get_ipv46_interface_counter(self, node, interface, is_ipv6=True):
- """Return interface IPv4/IPv6 counter.
+ @staticmethod
+ def clear_statistics_on_all_duts(nodes):
+ """Clear statistics on all DUTs.
- :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()
- if_index = topo.get_interface_sw_index(node, interface)
- if if_index is None:
- logger.trace('{i} sw_index not found.'.format(i=interface))
- return 0
-
- if_counters = self._stats_table.get('interface_counters')
- if if_counters is None or len(if_counters) == 0:
- logger.trace('No interface counters.')
- return 0
- for counter in if_counters:
- if counter['vnet_counter_type'] == version:
- data = counter['data']
- return data[if_index]
- logger.trace('{i} {v} counter not found.'.format(i=interface,
- v=version))
- return 0
+ :param nodes: DUT nodes.
+ :type nodes: dict
+ """
+ for node in nodes.values():
+ if node[u"type"] == NodeType.DUT:
+ VppCounters.clear_vpp_statistics(node)
Code Review / csit.git / blobdiff