X-Git-Url: https://gerrit.fd.io/r/gitweb?p=csit.git;a=blobdiff_plain;f=resources%2Flibraries%2Fpython%2FVppCounters.py;h=cc3554829ed8f5c946de43187b8c7057a9421c90;hp=375bdfb519bd814a7538daae5f10dad3e6eac1b4;hb=3c863def2096b573832499985e3a12bbccf82ea8;hpb=8c12ff59f1a5e750151f5eb0e806dcc80e91c3c2 diff --git a/resources/libraries/python/VppCounters.py b/resources/libraries/python/VppCounters.py index 375bdfb519..cc3554829e 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) 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: @@ -15,10 +15,11 @@ import time -from robot.api import logger +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,35 +28,157 @@ class VppCounters(object): 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 _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. - :param nodes: Nodes in topology. + :param node: Node to run command on. + :type node: dict + """ + VppCounters._run_cli_cmd(node, 'show errors') + + @staticmethod + def vpp_show_errors_verbose(node): + """Run "show errors verbose" debug CLI command. + + :param node: Node to run command on. + :type node: dict + """ + VppCounters._run_cli_cmd(node, 'show errors verbose') + + @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: - self.vpp_clear_interface_counters(node) + if verbose: + VppCounters.vpp_show_errors_verbose(node) + else: + VppCounters.vpp_show_errors(node) @staticmethod - def vpp_show_errors_verbose(node): - """Run "show errors verbose" 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_verbose.vat", node, json_out=False) + 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" debug CLI command. + """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 """ - vat = VatExecutor() - vat.execute_script("show_runtime_verbose.vat", node, json_out=False) + VppCounters.vpp_show_runtime(node) + + @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_hardware_detail(node): @@ -64,42 +187,118 @@ 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) + VppCounters._run_cli_cmd(node, 'show hardware detail') + + @staticmethod + def vpp_clear_runtime(node): + """Run "clear runtime" CLI command. + + :param node: Node to run command on. + :type node: dict + :returns: Verified data from PAPI response. + :rtype: dict + """ + return VppCounters._run_cli_cmd(node, 'clear runtime', log=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. + """Run "clear interfaces" CLI command. + + :param node: Node to run command on. + :type node: dict + :returns: Verified data from PAPI response. + :rtype: dict + """ + return VppCounters._run_cli_cmd(node, 'clear interfaces', log=False) + + @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): + """Run "clear hardware" 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 """ - vat = VatExecutor() - vat.execute_script('clear_interface.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): + """Clear hardware counters on all DUTs. - def vpp_dump_stats_table(self, node): - """Dump stats table on VPP node. + :param nodes: VPP nodes. + :type nodes: dict + """ + for node in nodes.values(): + if node['type'] == NodeType.DUT: + VppCounters.vpp_clear_hardware_counters(node) - :param node: Node to dump stats table on. + @staticmethod + def vpp_clear_errors_counters(node): + """Run "clear errors" CLI command. + + :param node: Node to run command on. :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 + :returns: Verified data from PAPI response. + :rtype: dict + """ + return VppCounters._run_cli_cmd(node, 'clear errors', log=False) + + @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_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): @@ -111,7 +310,7 @@ class VppCounters(object): :type node: dict :type interface: str :type is_ipv6: bool - :return: Interface IPv4/IPv6 counter. + :returns: Interface IPv4/IPv6 counter. :rtype: int """ version = 'ip6' if is_ipv6 else 'ip4' @@ -122,13 +321,39 @@ class VppCounters(object): return 0 if_counters = self._stats_table.get('interface_counters') - if if_counters is None or len(if_counters) == 0: + if not if_counters: 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)) + 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)