JumpAvg: Fix string format
[csit.git] / resources / libraries / python / VPPUtil.py
1 # Copyright (c) 2021 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 util library."""
15
16 from robot.api import logger
17
18 from resources.libraries.python.Constants import Constants
19 from resources.libraries.python.DUTSetup import DUTSetup
20 from resources.libraries.python.PapiExecutor import PapiSocketExecutor
21 from resources.libraries.python.model.ExportResult import (
22     export_dut_type_and_version
23 )
24 from resources.libraries.python.ssh import exec_cmd_no_error, exec_cmd
25 from resources.libraries.python.topology import Topology, SocketType, NodeType
26
27
28 class VPPUtil:
29     """General class for any VPP related methods/functions."""
30
31     @staticmethod
32     def show_vpp_settings(node, *additional_cmds):
33         """Print default VPP settings. In case others are needed, can be
34         accepted as next parameters (each setting one parameter), preferably
35         in form of a string.
36
37         :param node: VPP node.
38         :param additional_cmds: Additional commands that the vpp should print
39             settings for.
40         :type node: dict
41         :type additional_cmds: tuple
42         """
43         def_setting_tb_displayed = {
44             u"IPv6 FIB": u"ip6 fib",
45             u"IPv4 FIB": u"ip fib",
46             u"Interface IP": u"int addr",
47             u"Interfaces": u"int",
48             u"ARP": u"ip arp",
49             u"Errors": u"err"
50         }
51
52         if additional_cmds:
53             for cmd in additional_cmds:
54                 def_setting_tb_displayed[f"Custom Setting: {cmd}"] = cmd
55
56         for _, cmd in def_setting_tb_displayed.items():
57             command = f"vppctl sh {cmd}"
58             exec_cmd_no_error(node, command, timeout=30, sudo=True)
59
60     @staticmethod
61     def restart_vpp_service(node, node_key=None):
62         """Restart VPP service on the specified topology node.
63
64         Disconnect possibly connected PAPI executor.
65
66         :param node: Topology node.
67         :param node_key: Topology node key.
68         :type node: dict
69         :type node_key: str
70         """
71         # Containers have a separate lifecycle, but better be safe.
72         PapiSocketExecutor.disconnect_all_sockets_by_node(node)
73         DUTSetup.restart_service(node, Constants.VPP_UNIT)
74         if node_key:
75             Topology.add_new_socket(
76                 node, SocketType.PAPI, node_key, Constants.SOCKSVR_PATH)
77             Topology.add_new_socket(
78                 node, SocketType.STATS, node_key, Constants.SOCKSTAT_PATH)
79
80     @staticmethod
81     def restart_vpp_service_on_all_duts(nodes):
82         """Restart VPP service on all DUT nodes.
83
84         :param nodes: Topology nodes.
85         :type nodes: dict
86         """
87         for node_key, node in nodes.items():
88             if node[u"type"] == NodeType.DUT:
89                 VPPUtil.restart_vpp_service(node, node_key)
90
91     @staticmethod
92     def stop_vpp_service(node, node_key=None):
93         """Stop VPP service on the specified topology node.
94
95         Disconnect possibly connected PAPI executor.
96
97         :param node: Topology node.
98         :param node_key: Topology node key.
99         :type node: dict
100         :type node_key: str
101         """
102         # Containers have a separate lifecycle, but better be safe.
103         PapiSocketExecutor.disconnect_all_sockets_by_node(node)
104         DUTSetup.stop_service(node, Constants.VPP_UNIT)
105         if node_key:
106             Topology.del_node_socket_id(node, SocketType.PAPI, node_key)
107             Topology.del_node_socket_id(node, SocketType.STATS, node_key)
108
109     @staticmethod
110     def stop_vpp_service_on_all_duts(nodes):
111         """Stop VPP service on all DUT nodes.
112
113         :param nodes: Topology nodes.
114         :type nodes: dict
115         """
116         for node_key, node in nodes.items():
117             if node[u"type"] == NodeType.DUT:
118                 VPPUtil.stop_vpp_service(node, node_key)
119
120     @staticmethod
121     def verify_vpp_installed(node):
122         """Verify that VPP is installed on the specified topology node.
123
124         :param node: Topology node.
125         :type node: dict
126         """
127         DUTSetup.verify_program_installed(node, u"vpp")
128
129     @staticmethod
130     def adjust_privileges(node):
131         """Adjust privileges to control VPP without sudo.
132
133         :param node: Topology node.
134         :type node: dict
135         """
136         cmd = u"chmod -R o+rwx /run/vpp"
137         exec_cmd_no_error(
138             node, cmd, sudo=True, message=u"Failed to adjust privileges!",
139             retries=120)
140
141     @staticmethod
142     def verify_vpp_started(node):
143         """Verify that VPP is started on the specified topology node.
144
145         :param node: Topology node.
146         :type node: dict
147         """
148         cmd = u"echo \"show pci\" | sudo socat - UNIX-CONNECT:/run/vpp/cli.sock"
149         exec_cmd_no_error(
150             node, cmd, sudo=False, message=u"VPP failed to start!", retries=120
151         )
152
153         cmd = u"vppctl show pci 2>&1 | fgrep -v \"Connection refused\" | " \
154               u"fgrep -v \"No such file or directory\""
155         exec_cmd_no_error(
156             node, cmd, sudo=True, message=u"VPP failed to start!", retries=120
157         )
158
159         # Properly enable cards in case they were disabled. This will be
160         # followed in https://jira.fd.io/browse/VPP-1934.
161         cmd = u"for i in $(sudo vppctl sho int | grep Eth | cut -d' ' -f1); do"\
162               u" sudo vppctl set int sta $i up; done"
163         exec_cmd(node, cmd, sudo=False)
164
165     @staticmethod
166     def verify_vpp(node):
167         """Verify that VPP is installed and started on the specified topology
168         node. Adjust privileges so user can connect without sudo.
169
170         :param node: Topology node.
171         :type node: dict
172         :raises RuntimeError: If VPP service fails to start.
173         """
174         DUTSetup.verify_program_installed(node, 'vpp')
175         try:
176             # Verify responsiveness of vppctl.
177             VPPUtil.verify_vpp_started(node)
178             # Adjust privileges.
179             VPPUtil.adjust_privileges(node)
180             # Verify responsiveness of PAPI.
181             VPPUtil.show_log(node)
182             VPPUtil.vpp_show_version(node)
183         finally:
184             DUTSetup.get_service_logs(node, Constants.VPP_UNIT)
185
186     @staticmethod
187     def verify_vpp_on_all_duts(nodes):
188         """Verify that VPP is installed and started on all DUT nodes.
189
190         :param nodes: Nodes in the topology.
191         :type nodes: dict
192         """
193         for node in nodes.values():
194             if node[u"type"] == NodeType.DUT:
195                 VPPUtil.verify_vpp(node)
196
197     @staticmethod
198     def vpp_show_version(
199             node, remote_vpp_socket=Constants.SOCKSVR_PATH, log=True):
200         """Run "show_version" PAPI command.
201
202         Socket is configurable, so VPP inside container can be accessed.
203         The result is exported to JSON UTI output as "dut-version".
204
205         :param node: Node to run command on.
206         :param remote_vpp_socket: Path to remote socket to target VPP.
207         :param log: If true, show the result in Robot log.
208         :type node: dict
209         :type remote_vpp_socket: str
210         :type log: bool
211         :returns: VPP version.
212         :rtype: str
213         :raises RuntimeError: If PAPI connection fails.
214         :raises AssertionError: If PAPI retcode is nonzero.
215         """
216         cmd = u"show_version"
217         with PapiSocketExecutor(node, remote_vpp_socket) as papi_exec:
218             reply = papi_exec.add(cmd).get_reply()
219         if log:
220             logger.info(f"VPP version: {reply[u'version']}\n")
221         version = f"{reply[u'version']}"
222         export_dut_type_and_version(u"VPP", version)
223         return version
224
225     @staticmethod
226     def show_vpp_version_on_all_duts(nodes):
227         """Show VPP version verbose on all DUTs.
228
229         :param nodes: Nodes in the topology.
230         :type nodes: dict
231         """
232         for node in nodes.values():
233             if node[u"type"] == NodeType.DUT:
234                 VPPUtil.vpp_show_version(node)
235
236     @staticmethod
237     def vpp_show_interfaces(node):
238         """Run "show interface" CLI command.
239
240         :param node: Node to run command on.
241         :type node: dict
242         """
243
244         cmd = u"sw_interface_dump"
245         args = dict(
246             name_filter_valid=False,
247             name_filter=u""
248         )
249         err_msg = f"Failed to get interface dump on host {node[u'host']}"
250         with PapiSocketExecutor(node) as papi_exec:
251             details = papi_exec.add(cmd, **args).get_details(err_msg)
252
253         for if_dump in details:
254             if_dump[u"l2_address"] = str(if_dump[u"l2_address"])
255             if_dump[u"b_dmac"] = str(if_dump[u"b_dmac"])
256             if_dump[u"b_smac"] = str(if_dump[u"b_smac"])
257             if_dump[u"flags"] = if_dump[u"flags"].value
258             if_dump[u"type"] = if_dump[u"type"].value
259             if_dump[u"link_duplex"] = if_dump[u"link_duplex"].value
260             if_dump[u"sub_if_flags"] = if_dump[u"sub_if_flags"].value \
261                 if hasattr(if_dump[u"sub_if_flags"], u"value") \
262                 else int(if_dump[u"sub_if_flags"])
263         # TODO: return only base data
264         logger.trace(f"Interface data of host {node[u'host']}:\n{details}")
265
266     @staticmethod
267     def vpp_enable_traces_on_dut(node, fail_on_error=False):
268         """Enable vpp packet traces on the DUT node.
269
270         :param node: DUT node to set up.
271         :param fail_on_error: If True, keyword fails if an error occurs,
272             otherwise passes.
273         :type node: dict
274         :type fail_on_error: bool
275         """
276         cmds = [
277             u"trace add dpdk-input 50",
278             u"trace add vhost-user-input 50",
279             u"trace add memif-input 50",
280             u"trace add avf-input 50"
281         ]
282
283         for cmd in cmds:
284             try:
285                 PapiSocketExecutor.run_cli_cmd_on_all_sockets(node, cmd)
286             except AssertionError:
287                 if fail_on_error:
288                     raise
289
290     @staticmethod
291     def vpp_enable_traces_on_all_duts(nodes, fail_on_error=False):
292         """Enable vpp packet traces on all DUTs in the given topology.
293
294         :param nodes: Nodes in the topology.
295         :param fail_on_error: If True, keyword fails if an error occurs,
296             otherwise passes.
297         :type nodes: dict
298         :type fail_on_error: bool
299         """
300         for node in nodes.values():
301             if node[u"type"] == NodeType.DUT:
302                 VPPUtil.vpp_enable_traces_on_dut(node, fail_on_error)
303
304     @staticmethod
305     def vpp_enable_elog_traces(node):
306         """Enable API/CLI/Barrier traces on the specified topology node.
307
308         :param node: Topology node.
309         :type node: dict
310         """
311         try:
312             PapiSocketExecutor.run_cli_cmd_on_all_sockets(
313                 node, u"event-logger trace api cli barrier")
314         except AssertionError:
315             # Perhaps an older VPP build is tested.
316             PapiSocketExecutor.run_cli_cmd_on_all_sockets(
317                 node, u"elog trace api cli barrier")
318
319     @staticmethod
320     def vpp_enable_elog_traces_on_all_duts(nodes):
321         """Enable API/CLI/Barrier traces on all DUTs in the given topology.
322
323         :param nodes: Nodes in the topology.
324         :type nodes: dict
325         """
326         for node in nodes.values():
327             if node[u"type"] == NodeType.DUT:
328                 VPPUtil.vpp_enable_elog_traces(node)
329
330     @staticmethod
331     def show_event_logger(node):
332         """Show event logger on the specified topology node.
333
334         :param node: Topology node.
335         :type node: dict
336         """
337         PapiSocketExecutor.run_cli_cmd_on_all_sockets(
338             node, u"show event-logger")
339
340     @staticmethod
341     def show_event_logger_on_all_duts(nodes):
342         """Show event logger on all DUTs in the given topology.
343
344         :param nodes: Nodes in the topology.
345         :type nodes: dict
346         """
347         for node in nodes.values():
348             if node[u"type"] == NodeType.DUT:
349                 VPPUtil.show_event_logger(node)
350
351     @staticmethod
352     def show_log(node):
353         """Show logging on the specified topology node.
354
355         :param node: Topology node.
356         :type node: dict
357         """
358         PapiSocketExecutor.run_cli_cmd(node, u"show logging")
359
360     @staticmethod
361     def show_log_on_all_duts(nodes):
362         """Show logging on all DUTs in the given topology.
363
364         :param nodes: Nodes in the topology.
365         :type nodes: dict
366         """
367         for node in nodes.values():
368             if node[u"type"] == NodeType.DUT:
369                 VPPUtil.show_log(node)
370
371     @staticmethod
372     def vpp_show_threads(node):
373         """Show VPP threads on node.
374
375         :param node: Node to run command on.
376         :type node: dict
377         :returns: VPP thread data.
378         :rtype: list
379         """
380         cmd = u"show_threads"
381         with PapiSocketExecutor(node) as papi_exec:
382             reply = papi_exec.add(cmd).get_reply()
383
384         threads_data = reply[u"thread_data"]
385         logger.trace(f"show threads:\n{threads_data}")
386
387         return threads_data
388
389     @staticmethod
390     def vpp_add_graph_node_next(node, graph_node_name, graph_next_name):
391         """Set the next node for a given node.
392
393         :param node: Node to run command on.
394         :param graph_node_name: Graph node to add the next node on.
395         :param graph_next_name: Graph node to add as the next node.
396         :type node: dict
397         :type graph_node_name: str
398         :type graph_next_name: str
399         :returns: The index of the next graph node.
400         :rtype: int
401         """
402         cmd = u"add_node_next"
403         args = dict(
404             node_name=graph_node_name,
405             next_name=graph_next_name
406         )
407         with PapiSocketExecutor(node) as papi_exec:
408             reply = papi_exec.add(cmd, **args).get_reply()
409
410         return reply[u"next_index"]