CSIT-1493 VPP restart handling code
[csit.git] / resources / libraries / python / VPPUtil.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 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 PapiExecutor
21 from resources.libraries.python.ssh import exec_cmd_no_error
22 from resources.libraries.python.topology import NodeType
23 from resources.libraries.python.VatExecutor import VatExecutor
24
25
26 class VPPUtil(object):
27     """General class for any VPP related methods/functions."""
28
29     @staticmethod
30     def show_vpp_settings(node, *additional_cmds):
31         """Print default VPP settings. In case others are needed, can be
32         accepted as next parameters (each setting one parameter), preferably
33         in form of a string.
34
35         :param node: VPP node.
36         :param additional_cmds: Additional commands that the vpp should print
37             settings for.
38         :type node: dict
39         :type additional_cmds: tuple
40         """
41         def_setting_tb_displayed = {
42             'IPv6 FIB': 'ip6 fib',
43             'IPv4 FIB': 'ip fib',
44             'Interface IP': 'int addr',
45             'Interfaces': 'int',
46             'ARP': 'ip arp',
47             'Errors': 'err'
48         }
49
50         if additional_cmds:
51             for cmd in additional_cmds:
52                 def_setting_tb_displayed['Custom Setting: {}'.format(cmd)] = cmd
53
54         for _, cmd in def_setting_tb_displayed.items():
55             command = 'vppctl sh {cmd}'.format(cmd=cmd)
56             exec_cmd_no_error(node, command, timeout=30, sudo=True)
57
58     @staticmethod
59     def restart_vpp_service(node):
60         """Restart VPP service on the specified topology node.
61
62         :param node: Topology node.
63         :type node: dict
64         """
65         DUTSetup.restart_service(node, Constants.VPP_UNIT)
66
67     @staticmethod
68     def restart_vpp_service_on_all_duts(nodes):
69         """Restart VPP service on all DUT nodes.
70
71         :param nodes: Topology nodes.
72         :type nodes: dict
73         """
74         for node in nodes.values():
75             if node['type'] == NodeType.DUT:
76                 VPPUtil.restart_vpp_service(node)
77
78     @staticmethod
79     def stop_vpp_service(node):
80         """Stop VPP service on the specified topology node.
81
82         :param node: Topology node.
83         :type node: dict
84         """
85         DUTSetup.stop_service(node, Constants.VPP_UNIT)
86
87     @staticmethod
88     def stop_vpp_service_on_all_duts(nodes):
89         """Stop VPP service on all DUT nodes.
90
91         :param nodes: Topology nodes.
92         :type nodes: dict
93         """
94         for node in nodes.values():
95             if node['type'] == NodeType.DUT:
96                 VPPUtil.stop_vpp_service(node)
97
98     @staticmethod
99     def verify_vpp_installed(node):
100         """Verify that VPP is installed on the specified topology node.
101
102         :param node: Topology node.
103         :type node: dict
104         """
105         cmd = 'command -v vpp'
106         exec_cmd_no_error(
107             node, cmd, message='VPP is not installed!')
108
109     @staticmethod
110     def verify_vpp_started(node):
111         """Verify that VPP is started on the specified topology node.
112
113         :param node: Topology node.
114         :type node: dict
115         """
116         cmd = ('vppctl show pci 2>&1 | '
117                'fgrep -v "Connection refused" | '
118                'fgrep -v "No such file or directory"')
119         exec_cmd_no_error(
120             node, cmd, sudo=True, message='VPP failed to start!', retries=120)
121
122     @staticmethod
123     def verify_vpp(node):
124         """Verify that VPP is installed and started on the specified topology
125         node.
126
127         :param node: Topology node.
128         :type node: dict
129         :raises RuntimeError: If VPP service fails to start.
130         """
131         VPPUtil.verify_vpp_installed(node)
132         try:
133             # Verify responsivness of vppctl.
134             VPPUtil.verify_vpp_started(node)
135             # Verify responsivness of PAPI.
136             VPPUtil.show_log(node)
137         finally:
138             DUTSetup.get_service_logs(node, Constants.VPP_UNIT)
139
140     @staticmethod
141     def verify_vpp_on_all_duts(nodes):
142         """Verify that VPP is installed and started on all DUT nodes.
143
144         :param nodes: Nodes in the topology.
145         :type nodes: dict
146         """
147         for node in nodes.values():
148             if node['type'] == NodeType.DUT:
149                 VPPUtil.verify_vpp(node)
150
151     @staticmethod
152     def vpp_show_version(node, verbose=True):
153         """Run "show_version" PAPI command.
154
155         :param node: Node to run command on.
156         :param verbose: Show version, compile date and compile location if True
157             otherwise show only version.
158         :type node: dict
159         :type verbose: bool
160         :returns: VPP version.
161         :rtype: str
162         """
163         with PapiExecutor(node) as papi_exec:
164             data = papi_exec.add('show_version').execute_should_pass().\
165                 verify_reply()
166         version = ('VPP version:      {ver}\n'.
167                    format(ver=data['version'].rstrip('\0x00')))
168         if verbose:
169             version += ('Compile date:     {date}\n'
170                         'Compile location: {cl}\n '.
171                         format(date=data['build_date'].rstrip('\0x00'),
172                                cl=data['build_directory'].rstrip('\0x00')))
173         logger.info(version)
174         return data['version'].rstrip('\0x00')
175
176     @staticmethod
177     def show_vpp_version_on_all_duts(nodes):
178         """Show VPP version verbose on all DUTs.
179
180         :param nodes: Nodes in the topology.
181         :type nodes: dict
182         """
183         for node in nodes.values():
184             if node['type'] == NodeType.DUT:
185                 VPPUtil.vpp_show_version(node)
186
187     @staticmethod
188     def vpp_show_interfaces(node):
189         """Run "show interface" CLI command.
190
191         :param node: Node to run command on.
192         :type node: dict
193         """
194         vat = VatExecutor()
195         vat.execute_script("show_interface.vat", node, json_out=False)
196
197         try:
198             vat.script_should_have_passed()
199         except AssertionError:
200             raise RuntimeError('Failed to get VPP interfaces on host: {name}'.
201                                format(name=node['host']))
202
203     @staticmethod
204     def vpp_show_crypto_device_mapping(node):
205         """Run "show crypto device mapping" CLI command.
206
207         :param node: Node to run command on.
208         :type node: dict
209         """
210         vat = VatExecutor()
211         vat.execute_script("show_crypto_device_mapping.vat", node,
212                            json_out=False)
213
214     @staticmethod
215     def vpp_enable_traces_on_dut(node):
216         """Enable vpp packet traces on the DUT node.
217
218         :param node: DUT node to set up.
219         :type node: dict
220         """
221         vat = VatExecutor()
222         vat.execute_script("enable_dpdk_traces.vat", node, json_out=False)
223         vat.execute_script("enable_vhost_user_traces.vat", node, json_out=False)
224         vat.execute_script("enable_memif_traces.vat", node, json_out=False)
225
226     @staticmethod
227     def vpp_enable_traces_on_all_duts(nodes):
228         """Enable vpp packet traces on all DUTs in the given topology.
229
230         :param nodes: Nodes in the topology.
231         :type nodes: dict
232         """
233         for node in nodes.values():
234             if node['type'] == NodeType.DUT:
235                 VPPUtil.vpp_enable_traces_on_dut(node)
236
237     @staticmethod
238     def vpp_enable_elog_traces_on_dut(node):
239         """Enable API/CLI/Barrier traces on the DUT node.
240
241         :param node: DUT node to set up.
242         :type node: dict
243         """
244         vat = VatExecutor()
245         vat.execute_script("elog_trace_api_cli_barrier.vat", node,
246                            json_out=False)
247
248     @staticmethod
249     def vpp_enable_elog_traces_on_all_duts(nodes):
250         """Enable API/CLI/Barrier traces on all DUTs in the given topology.
251
252         :param nodes: Nodes in the topology.
253         :type nodes: dict
254         """
255         for node in nodes.values():
256             if node['type'] == NodeType.DUT:
257                 VPPUtil.vpp_enable_elog_traces_on_dut(node)
258
259     @staticmethod
260     def show_event_logger_on_dut(node):
261         """Show event logger on the DUT node.
262
263         :param node: DUT node to show traces on.
264         :type node: dict
265         """
266         vat = VatExecutor()
267         vat.execute_script("show_event_logger.vat", node, json_out=False)
268
269     @staticmethod
270     def show_event_logger_on_all_duts(nodes):
271         """Show event logger on all DUTs in the given topology.
272
273         :param nodes: Nodes in the topology.
274         :type nodes: dict
275         """
276         for node in nodes.values():
277             if node['type'] == NodeType.DUT:
278                 VPPUtil.show_event_logger_on_dut(node)
279
280     @staticmethod
281     def show_log(node):
282         """Show log on the specified topology node.
283
284         :param node: Topology node.
285         :type node: dict
286         :returns: VPP log data.
287         :rtype: list
288         """
289         with PapiExecutor(node) as papi_exec:
290             return papi_exec.add('cli_inband', cmd='show log').get_replies().\
291                 verify_reply()["reply"]
292
293     @staticmethod
294     def vpp_show_threads(node):
295         """Show VPP threads on node.
296
297         :param node: Node to run command on.
298         :type node: dict
299         :returns: VPP thread data.
300         :rtype: list
301         """
302         with PapiExecutor(node) as papi_exec:
303             return papi_exec.add('show_threads').execute_should_pass().\
304                 verify_reply()["thread_data"]

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