X-Git-Url: https://gerrit.fd.io/r/gitweb?p=csit.git;a=blobdiff_plain;f=resources%2Flibraries%2Fpython%2FVppCounters.py;h=6bd0aea4bf53c32852c64e8a06e16c657d72738b;hp=d8d4554899884dd3b549f124b1ba5cd924476a23;hb=e6316e28601c8ee9ad0a441518dbb7bfd4b9de14;hpb=2e6b88e7c414e31336fd6644143b257e94b89624 diff --git a/resources/libraries/python/VppCounters.py b/resources/libraries/python/VppCounters.py index d8d4554899..6bd0aea4bf 100644 --- a/resources/libraries/python/VppCounters.py +++ b/resources/libraries/python/VppCounters.py @@ -1,4 +1,4 @@ -# 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: @@ -13,132 +13,260 @@ """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. + @staticmethod + def vpp_show_errors(node): + """Run "show errors" debug CLI command. + + :param node: Node to run command on. + :type node: dict + """ + PapiSocketExecutor.run_cli_cmd_on_all_sockets(node, u"show errors") - :param nodes: Nodes in topology. + @staticmethod + 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['type'] == NodeType.DUT: - self.vpp_clear_interface_counters(node) + if node[u"type"] == NodeType.DUT: + VppCounters.vpp_show_errors(node) @staticmethod - def vpp_show_errors(node): - """Run "show errors" debug CLI command. + 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.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_runtime_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[u"type"] == NodeType.DUT: + VppCounters.vpp_show_runtime(node) @staticmethod - def vpp_show_errors_verbose(node): - """Run "show errors verbose" debug 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_errors_verbose.vat", node, json_out=False) + PapiSocketExecutor.run_cli_cmd_on_all_sockets( + node, u"show hardware verbose" + ) + + @staticmethod + 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 + """ + PapiSocketExecutor.run_cli_cmd_on_all_sockets( + node, u"show memory verbose api-segment stats-segment main-heap" + ) + + @staticmethod + def vpp_show_memory_on_all_duts(nodes): + """Run "show memory" on all DUTs. + + :param nodes: VPP nodes. + :type nodes: dict + """ + for node in nodes.values(): + if node[u"type"] == NodeType.DUT: + VppCounters.vpp_show_memory(node) @staticmethod - def vpp_show_runtime_verbose(node): - """Run "show runtime" debug CLI command. + 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("show_runtime_verbose.vat", node, json_out=False) + PapiSocketExecutor.run_cli_cmd_on_all_sockets( + node, u"clear runtime", log=False + ) + + @staticmethod + def vpp_clear_runtime_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[u"type"] == NodeType.DUT: + VppCounters.vpp_clear_runtime(node) @staticmethod - def vpp_show_hardware_detail(node): - """Run "show hardware-interfaces detail" debug CLI command. + def vpp_clear_hardware(node): + """Run "clear hardware" CLI command. :param node: Node to run command on. :type node: dict + :returns: Verified data from PAPI response. + :rtype: dict + """ + PapiSocketExecutor.run_cli_cmd_on_all_sockets( + node, u"clear hardware", log=False + ) + + @staticmethod + def vpp_clear_hardware_on_all_duts(nodes): + """Clear hardware on all DUTs. + + :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_clear_hardware(node) @staticmethod - def vpp_clear_interface_counters(node): - """Clear interface counters on VPP node. + def vpp_clear_errors(node): + """Run "clear errors" CLI command. - :param node: Node to clear interface counters on. + :param node: Node to run command on. :type node: dict """ - vat = VatExecutor() - vat.execute_script('clear_interface.vat', node) - vat.script_should_have_passed() + PapiSocketExecutor.run_cli_cmd_on_all_sockets( + node, u"clear errors", log=False + ) - def vpp_dump_stats_table(self, node): - """Dump stats table on VPP node. + @staticmethod + def vpp_clear_errors_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[u"type"] == NodeType.DUT: + VppCounters.vpp_clear_errors(node) - :param node: Node to dump stats table on. + @staticmethod + def show_vpp_statistics(node): + """Show [errors, hardware] stats. + + :param node: VPP node. :type node: dict - :return: 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 - - def vpp_get_ipv4_interface_counter(self, node, interface): - return self.vpp_get_ipv46_interface_counter(node, interface, False) - - def vpp_get_ipv6_interface_counter(self, node, interface): - 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. - - :param node: Node to get interface IPv4/IPv6 counter on. - :param interface: Interface name. - :param is_ipv6: Specify IP version. + """ + VppCounters.vpp_show_errors(node) + VppCounters.vpp_show_hardware(node) + + @staticmethod + def show_statistics_on_all_duts(nodes): + """Show statistics on all DUTs. + + :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: VPP node. :type node: dict - :type interface: str - :type is_ipv6: bool - :return: 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 + """ + VppCounters.vpp_clear_errors(node) + VppCounters.vpp_clear_hardware(node) + + @staticmethod + def clear_statistics_on_all_duts(nodes): + """Clear statistics on all DUTs. + + :param nodes: DUT nodes. + :type nodes: dict + """ + for node in nodes.values(): + if node[u"type"] == NodeType.DUT: + VppCounters.clear_vpp_statistics(node)