PapiExecutor always verifies
[csit.git] / resources / libraries / python / VppCounters.py
1 # Copyright (c) 2019 Cisco and/or its affiliates.
2 # Licensed under the Apache License, Version 2.0 (the "License");
3 # you may not use this file except in compliance with the License.
4 # You may obtain a copy of the License at:
5 #
6 #     http://www.apache.org/licenses/LICENSE-2.0
7 #
8 # Unless required by applicable law or agreed to in writing, software
9 # distributed under the License is distributed on an "AS IS" BASIS,
10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 # See the License for the specific language governing permissions and
12 # limitations under the License.
13
14 """VPP counters utilities library."""
15
16 import time
17
18 from pprint import pformat
19
20 from robot.api import logger
21 from resources.libraries.python.PapiExecutor import PapiExecutor
22 from resources.libraries.python.topology import NodeType, Topology
23
24
25 class VppCounters(object):
26     """VPP counters utilities."""
27
28     def __init__(self):
29         self._stats_table = None
30
31     @staticmethod
32     def _get_non_zero_items(data):
33         """Extract and return non-zero items from the input data.
34
35         :param data: Data to filter.
36         :type data: dict
37         :returns: Dictionary with non-zero items.
38         :rtype dict
39         """
40         return {k: data[k] for k in data.keys() if sum(data[k])}
41
42     @staticmethod
43     def vpp_show_errors(node):
44         """Run "show errors" debug CLI command.
45
46         :param node: Node to run command on.
47         :type node: dict
48         """
49         PapiExecutor.run_cli_cmd(node, 'show errors')
50
51     @staticmethod
52     def vpp_show_errors_verbose(node):
53         """Run "show errors verbose" debug CLI command.
54
55         :param node: Node to run command on.
56         :type node: dict
57         """
58         PapiExecutor.run_cli_cmd(node, 'show errors verbose')
59
60     @staticmethod
61     def vpp_show_errors_on_all_duts(nodes, verbose=False):
62         """Show errors on all DUTs.
63
64         :param nodes: VPP nodes.
65         :param verbose: If True show verbose output.
66         :type nodes: dict
67         :type verbose: bool
68         """
69         for node in nodes.values():
70             if node['type'] == NodeType.DUT:
71                 if verbose:
72                     VppCounters.vpp_show_errors_verbose(node)
73                 else:
74                     VppCounters.vpp_show_errors(node)
75
76     @staticmethod
77     def vpp_show_runtime(node, log_zeros=False):
78         """Run "show runtime" CLI command.
79
80         :param node: Node to run command on.
81         :param log_zeros: Log also items with zero values.
82         :type node: dict
83         :type log_zeros: bool
84         """
85         args = dict(path='^/sys/node')
86         with PapiExecutor(node) as papi_exec:
87             stats = papi_exec.add("vpp-stats", **args).get_stats()[0]
88             # TODO: Introduce get_stat?
89
90         names = stats['/sys/node/names']
91
92         if not names:
93             return
94
95         runtime = []
96         runtime_non_zero = []
97
98         for name in names:
99             runtime.append({'name': name})
100
101         for idx, runtime_item in enumerate(runtime):
102
103             calls_th = []
104             for thread in stats['/sys/node/calls']:
105                 calls_th.append(thread[idx])
106             runtime_item["calls"] = calls_th
107
108             vectors_th = []
109             for thread in stats['/sys/node/vectors']:
110                 vectors_th.append(thread[idx])
111             runtime_item["vectors"] = vectors_th
112
113             suspends_th = []
114             for thread in stats['/sys/node/suspends']:
115                 suspends_th.append(thread[idx])
116             runtime_item["suspends"] = suspends_th
117
118             clocks_th = []
119             for thread in stats['/sys/node/clocks']:
120                 clocks_th.append(thread[idx])
121             runtime_item["clocks"] = clocks_th
122
123             if (sum(calls_th) or sum(vectors_th) or
124                     sum(suspends_th) or sum(clocks_th)):
125                 runtime_non_zero.append(runtime_item)
126
127         if log_zeros:
128             logger.info("Runtime:\n{runtime}".format(
129                 runtime=pformat(runtime)))
130         else:
131             logger.info("Runtime:\n{runtime}".format(
132                 runtime=pformat(runtime_non_zero)))
133
134     @staticmethod
135     def vpp_show_runtime_verbose(node):
136         """Run "show runtime verbose" CLI command.
137
138         TODO: Remove?
139               Only verbose output is possible to get using VPPStats.
140
141         :param node: Node to run command on.
142         :type node: dict
143         """
144         VppCounters.vpp_show_runtime(node)
145
146     @staticmethod
147     def show_runtime_counters_on_all_duts(nodes):
148         """Clear VPP runtime counters on all DUTs.
149
150         :param nodes: VPP nodes.
151         :type nodes: dict
152         """
153         for node in nodes.values():
154             if node['type'] == NodeType.DUT:
155                 VppCounters.vpp_show_runtime(node)
156
157     @staticmethod
158     def vpp_show_hardware_detail(node):
159         """Run "show hardware-interfaces detail" debug CLI command.
160
161         :param node: Node to run command on.
162         :type node: dict
163         """
164         PapiExecutor.run_cli_cmd(node, 'show hardware detail')
165
166     @staticmethod
167     def vpp_clear_runtime(node):
168         """Run "clear runtime" CLI command.
169
170         :param node: Node to run command on.
171         :type node: dict
172         :returns: Verified data from PAPI response.
173         :rtype: dict
174         """
175         return PapiExecutor.run_cli_cmd(node, 'clear runtime', log=False)
176
177     @staticmethod
178     def clear_runtime_counters_on_all_duts(nodes):
179         """Run "clear runtime" CLI command on all DUTs.
180
181         :param nodes: VPP nodes.
182         :type nodes: dict
183         """
184         for node in nodes.values():
185             if node['type'] == NodeType.DUT:
186                 VppCounters.vpp_clear_runtime(node)
187
188     @staticmethod
189     def vpp_clear_interface_counters(node):
190         """Run "clear interfaces" CLI command.
191
192         :param node: Node to run command on.
193         :type node: dict
194         :returns: Verified data from PAPI response.
195         :rtype: dict
196         """
197         return PapiExecutor.run_cli_cmd(node, 'clear interfaces', log=False)
198
199     @staticmethod
200     def clear_interface_counters_on_all_duts(nodes):
201         """Clear interface counters on all DUTs.
202
203         :param nodes: VPP nodes.
204         :type nodes: dict
205         """
206         for node in nodes.values():
207             if node['type'] == NodeType.DUT:
208                 VppCounters.vpp_clear_interface_counters(node)
209
210     @staticmethod
211     def vpp_clear_hardware_counters(node):
212         """Run "clear hardware" CLI command.
213
214         :param node: Node to run command on.
215         :type node: dict
216         :returns: Verified data from PAPI response.
217         :rtype: dict
218         """
219         return PapiExecutor.run_cli_cmd(node, 'clear hardware', log=False)
220
221     @staticmethod
222     def clear_hardware_counters_on_all_duts(nodes):
223         """Clear hardware counters on all DUTs.
224
225         :param nodes: VPP nodes.
226         :type nodes: dict
227         """
228         for node in nodes.values():
229             if node['type'] == NodeType.DUT:
230                 VppCounters.vpp_clear_hardware_counters(node)
231
232     @staticmethod
233     def vpp_clear_errors_counters(node):
234         """Run "clear errors" CLI command.
235
236         :param node: Node to run command on.
237         :type node: dict
238         :returns: Verified data from PAPI response.
239         :rtype: dict
240         """
241         return PapiExecutor.run_cli_cmd(node, 'clear errors', log=False)
242
243     @staticmethod
244     def clear_error_counters_on_all_duts(nodes):
245         """Clear VPP errors counters on all DUTs.
246
247         :param nodes: VPP nodes.
248         :type nodes: dict
249         """
250         for node in nodes.values():
251             if node['type'] == NodeType.DUT:
252                 VppCounters.vpp_clear_errors_counters(node)
253
254     def vpp_get_ipv4_interface_counter(self, node, interface):
255         """
256
257         :param node: Node to get interface IPv4 counter on.
258         :param interface: Interface name.
259         :type node: dict
260         :type interface: str
261         :returns: Interface IPv4 counter.
262         :rtype: int
263         """
264         return self.vpp_get_ipv46_interface_counter(node, interface, False)
265
266     def vpp_get_ipv6_interface_counter(self, node, interface):
267         """
268
269         :param node: Node to get interface IPv6 counter on.
270         :param interface: Interface name.
271         :type node: dict
272         :type interface: str
273         :returns: Interface IPv6 counter.
274         :rtype: int
275         """
276         return self.vpp_get_ipv46_interface_counter(node, interface, True)
277
278     def vpp_get_ipv46_interface_counter(self, node, interface, is_ipv6=True):
279         """Return interface IPv4/IPv6 counter.
280
281         :param node: Node to get interface IPv4/IPv6 counter on.
282         :param interface: Interface name.
283         :param is_ipv6: Specify IP version.
284         :type node: dict
285         :type interface: str
286         :type is_ipv6: bool
287         :returns: Interface IPv4/IPv6 counter.
288         :rtype: int
289         """
290         version = 'ip6' if is_ipv6 else 'ip4'
291         topo = Topology()
292         sw_if_index = topo.get_interface_sw_index(node, interface)
293         if sw_if_index is None:
294             logger.trace('{i} sw_if_index not found.'.format(i=interface))
295             return 0
296
297         if_counters = self._stats_table.get('interface_counters')
298         if not if_counters:
299             logger.trace('No interface counters.')
300             return 0
301         for counter in if_counters:
302             if counter['vnet_counter_type'] == version:
303                 data = counter['data']
304                 return data[sw_if_index]
305         logger.trace('{i} {v} counter not found.'.format(
306             i=interface, v=version))
307         return 0
308
309     @staticmethod
310     def show_vpp_statistics(node):
311         """Show [error, hardware, interface] stats.
312
313         :param node: VPP node.
314         :type node: dict
315         """
316         VppCounters.vpp_show_errors(node)
317         VppCounters.vpp_show_hardware_detail(node)
318         VppCounters.vpp_show_runtime(node)
319
320     @staticmethod
321     def show_statistics_on_all_duts(nodes, sleeptime=5):
322         """Show VPP statistics on all DUTs.
323
324         :param nodes: VPP nodes.
325         :type nodes: dict
326         :param sleeptime: Time to wait for traffic to arrive back to TG.
327         :type sleeptime: int
328         """
329         logger.trace('Waiting for statistics to be collected')
330         time.sleep(sleeptime)
331         for node in nodes.values():
332             if node['type'] == NodeType.DUT:
333                 VppCounters.show_vpp_statistics(node)

©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.