X-Git-Url: https://gerrit.fd.io/r/gitweb?p=csit.git;a=blobdiff_plain;f=resources%2Flibraries%2Fpython%2FVppCounters.py;h=6bd0aea4bf53c32852c64e8a06e16c657d72738b;hp=65d647709d1b6dd7eb474a96f95b366368b7098d;hb=e6316e28601c8ee9ad0a441518dbb7bfd4b9de14;hpb=c4528bcd137c0813d34b1b248bc92670736e78e6 diff --git a/resources/libraries/python/VppCounters.py b/resources/libraries/python/VppCounters.py index 65d647709d..6bd0aea4bf 100644 --- a/resources/libraries/python/VppCounters.py +++ b/resources/libraries/python/VppCounters.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019 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: @@ -16,12 +16,13 @@ from pprint import pformat from robot.api import logger -from resources.libraries.python.PapiExecutor import PapiExecutor -from resources.libraries.python.PapiExecutor import PapiSocketExecutor + +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): @@ -34,8 +35,7 @@ class VppCounters(object): :param node: Node to run command on. :type node: dict """ - PapiSocketExecutor.run_cli_cmd_on_all_sockets( - node, 'show errors') + PapiSocketExecutor.run_cli_cmd_on_all_sockets(node, u"show errors") @staticmethod def vpp_show_errors_on_all_duts(nodes): @@ -45,7 +45,7 @@ class VppCounters(object): :type nodes: dict """ for node in nodes.values(): - if node['type'] == NodeType.DUT: + if node[u"type"] == NodeType.DUT: VppCounters.vpp_show_errors(node) @staticmethod @@ -57,82 +57,85 @@ class VppCounters(object): :type node: dict :type log_zeros: bool """ - args = dict(path='^/sys/node') + 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("vpp-stats", **args).\ + stats = papi_exec.add(u"vpp-stats", **args).\ get_stats(socket=socket)[0] - names = stats['/sys/node/names'] + names = stats[u"/sys/node/names"] if not names: return - runtime = [] - runtime_non_zero = [] + runtime = list() + runtime_nz = list() for name in names: - runtime.append({'name': name}) + runtime.append({u"name": name}) for idx, runtime_item in enumerate(runtime): calls_th = [] - for thread in stats['/sys/node/calls']: + for thread in stats[u"/sys/node/calls"]: calls_th.append(thread[idx]) - runtime_item["calls"] = calls_th + runtime_item[u"calls"] = calls_th vectors_th = [] - for thread in stats['/sys/node/vectors']: + for thread in stats[u"/sys/node/vectors"]: vectors_th.append(thread[idx]) - runtime_item["vectors"] = vectors_th + runtime_item[u"vectors"] = vectors_th suspends_th = [] - for thread in stats['/sys/node/suspends']: + for thread in stats[u"/sys/node/suspends"]: suspends_th.append(thread[idx]) - runtime_item["suspends"] = suspends_th + runtime_item[u"suspends"] = suspends_th clocks_th = [] - for thread in stats['/sys/node/clocks']: + for thread in stats[u"/sys/node/clocks"]: clocks_th.append(thread[idx]) - runtime_item["clocks"] = clocks_th + runtime_item[u"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) + runtime_nz.append(runtime_item) if log_zeros: logger.info( - "stats runtime ({host} - {socket}):\n{runtime}".format( - host=node['host'], runtime=pformat(runtime), - socket=socket)) + f"stats runtime ({node[u'host']} - {socket}):\n" + f"{pformat(runtime)}" + ) else: logger.info( - "stats runtime ({host} - {socket}):\n{runtime}".format( - host=node['host'], runtime=pformat(runtime_non_zero), - socket=socket)) + 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_counters_on_all_duts(nodes): + 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['type'] == NodeType.DUT: + if node[u"type"] == NodeType.DUT: VppCounters.vpp_show_runtime(node) @staticmethod - def vpp_show_hardware_verbose(node): - """Run "show hardware-interfaces 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 """ PapiSocketExecutor.run_cli_cmd_on_all_sockets( - node, 'show hardware verbose') + node, u"show hardware verbose" + ) @staticmethod def vpp_show_memory(node): @@ -143,8 +146,20 @@ class VppCounters(object): :param node: Node to run command on. :type node: dict """ - PapiSocketExecutor.run_cli_cmd( - node, 'show memory verbose api-segment stats-segment main-heap') + 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_clear_runtime(node): @@ -154,21 +169,22 @@ class VppCounters(object): :type node: dict """ PapiSocketExecutor.run_cli_cmd_on_all_sockets( - node, 'clear runtime', log=False) + node, u"clear runtime", log=False + ) @staticmethod - def vpp_clear_runtime_counters_on_all_duts(nodes): + 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['type'] == NodeType.DUT: + if node[u"type"] == NodeType.DUT: VppCounters.vpp_clear_runtime(node) @staticmethod - def vpp_clear_hardware_counters(node): + def vpp_clear_hardware(node): """Run "clear hardware" CLI command. :param node: Node to run command on. @@ -177,51 +193,51 @@ class VppCounters(object): :rtype: dict """ PapiSocketExecutor.run_cli_cmd_on_all_sockets( - node, 'clear hardware', log=False) + node, u"clear hardware", log=False + ) @staticmethod - def vpp_clear_hardware_counters_on_all_duts(nodes): - """Clear hardware counters on all DUTs. + def vpp_clear_hardware_on_all_duts(nodes): + """Clear hardware 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) + if node[u"type"] == NodeType.DUT: + VppCounters.vpp_clear_hardware(node) @staticmethod - def vpp_clear_errors_counters(node): + def vpp_clear_errors(node): """Run "clear errors" CLI command. :param node: Node to run command on. :type node: dict """ PapiSocketExecutor.run_cli_cmd_on_all_sockets( - node, 'clear errors', log=False) + node, u"clear errors", log=False + ) @staticmethod - def vpp_clear_error_counters_on_all_duts(nodes): + 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['type'] == NodeType.DUT: - VppCounters.vpp_clear_errors_counters(node) + if node[u"type"] == NodeType.DUT: + VppCounters.vpp_clear_errors(node) @staticmethod def show_vpp_statistics(node): - """Show [error, hardware, interface] stats. + """Show [errors, hardware] stats. :param node: VPP node. :type node: dict """ VppCounters.vpp_show_errors(node) - VppCounters.vpp_show_hardware_verbose(node) - VppCounters.vpp_show_runtime(node) - VppCounters.vpp_show_memory(node) + VppCounters.vpp_show_hardware(node) @staticmethod def show_statistics_on_all_duts(nodes): @@ -231,19 +247,18 @@ class VppCounters(object): :type nodes: dict """ for node in nodes.values(): - if node['type'] == NodeType.DUT: + if node[u"type"] == NodeType.DUT: VppCounters.show_vpp_statistics(node) @staticmethod def clear_vpp_statistics(node): - """Clear [error, hardware, interface] stats. + """Clear [errors, hardware] stats. :param node: VPP node. :type node: dict """ - VppCounters.vpp_clear_errors_counters(node) - VppCounters.vpp_clear_hardware_counters(node) - VppCounters.vpp_clear_runtime(node) + VppCounters.vpp_clear_errors(node) + VppCounters.vpp_clear_hardware(node) @staticmethod def clear_statistics_on_all_duts(nodes): @@ -253,5 +268,5 @@ class VppCounters(object): :type nodes: dict """ for node in nodes.values(): - if node['type'] == NodeType.DUT: + if node[u"type"] == NodeType.DUT: VppCounters.clear_vpp_statistics(node)