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 PapiSocketExecutor
  21 from resources.libraries.python.ssh import exec_cmd_no_error
  22 from resources.libraries.python.topology import NodeType
  23
  24
  25 class VPPUtil(object):
  26     """General class for any VPP related methods/functions."""
  27
  28     @staticmethod
  29     def show_vpp_settings(node, *additional_cmds):
  30         """Print default VPP settings. In case others are needed, can be
  31         accepted as next parameters (each setting one parameter), preferably
  32         in form of a string.
  33
  34         :param node: VPP node.
  35         :param additional_cmds: Additional commands that the vpp should print
  36             settings for.
  37         :type node: dict
  38         :type additional_cmds: tuple
  39         """
  40         def_setting_tb_displayed = {
  41             'IPv6 FIB': 'ip6 fib',
  42             'IPv4 FIB': 'ip fib',
  43             'Interface IP': 'int addr',
  44             'Interfaces': 'int',
  45             'ARP': 'ip arp',
  46             'Errors': 'err'
  47         }
  48
  49         if additional_cmds:
  50             for cmd in additional_cmds:
  51                 def_setting_tb_displayed['Custom Setting: {}'.format(cmd)] = cmd
  52
  53         for _, cmd in def_setting_tb_displayed.items():
  54             command = 'vppctl sh {cmd}'.format(cmd=cmd)
  55             exec_cmd_no_error(node, command, timeout=30, sudo=True)
  56
  57     @staticmethod
  58     def restart_vpp_service(node):
  59         """Restart VPP service on the specified topology node.
  60
  61         :param node: Topology node.
  62         :type node: dict
  63         """
  64         DUTSetup.restart_service(node, Constants.VPP_UNIT)
  65
  66     @staticmethod
  67     def restart_vpp_service_on_all_duts(nodes):
  68         """Restart VPP service on all DUT nodes.
  69
  70         :param nodes: Topology nodes.
  71         :type nodes: dict
  72         """
  73         for node in nodes.values():
  74             if node['type'] == NodeType.DUT:
  75                 VPPUtil.restart_vpp_service(node)
  76
  77     @staticmethod
  78     def stop_vpp_service(node):
  79         """Stop VPP service on the specified topology node.
  80
  81         :param node: Topology node.
  82         :type node: dict
  83         """
  84         DUTSetup.stop_service(node, Constants.VPP_UNIT)
  85
  86     @staticmethod
  87     def stop_vpp_service_on_all_duts(nodes):
  88         """Stop VPP service on all DUT nodes.
  89
  90         :param nodes: Topology nodes.
  91         :type nodes: dict
  92         """
  93         for node in nodes.values():
  94             if node['type'] == NodeType.DUT:
  95                 VPPUtil.stop_vpp_service(node)
  96
  97     @staticmethod
  98     def verify_vpp_installed(node):
  99         """Verify that VPP is installed on the specified topology node.
 100
 101         :param node: Topology node.
 102         :type node: dict
 103         """
 104         cmd = 'command -v vpp'
 105         exec_cmd_no_error(
 106             node, cmd, message='VPP is not installed!')
 107
 108     @staticmethod
 109     def verify_vpp_started(node):
 110         """Verify that VPP is started on the specified topology node.
 111
 112         :param node: Topology node.
 113         :type node: dict
 114         """
 115         cmd = ('vppctl show pci 2>&1 | '
 116                'fgrep -v "Connection refused" | '
 117                'fgrep -v "No such file or directory"')
 118         exec_cmd_no_error(
 119             node, cmd, sudo=True, message='VPP failed to start!', retries=120)
 120
 121     @staticmethod
 122     def verify_vpp(node):
 123         """Verify that VPP is installed and started on the specified topology
 124         node.
 125
 126         :param node: Topology node.
 127         :type node: dict
 128         :raises RuntimeError: If VPP service fails to start.
 129         """
 130         VPPUtil.verify_vpp_installed(node)
 131         try:
 132             # Verify responsivness of vppctl.
 133             VPPUtil.verify_vpp_started(node)
 134             # Verify responsivness of PAPI.
 135             VPPUtil.show_log(node)
 136             VPPUtil.vpp_show_version(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         cmd = 'show_version'
 164         with PapiSocketExecutor(node) as papi_exec:
 165             reply = papi_exec.add(cmd).get_reply()
 166         return_version = reply['version'].rstrip('\0x00')
 167         version = 'VPP version:      {ver}\n'.format(ver=return_version)
 168         if verbose:
 169             version += ('Compile date:     {date}\n'
 170                         'Compile location: {cl}\n'.
 171                         format(date=reply['build_date'].rstrip('\0x00'),
 172                                cl=reply['build_directory'].rstrip('\0x00')))
 173         logger.info(version)
 174         return return_version
 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
 195         cmd = 'sw_interface_dump'
 196         args = dict(
 197             name_filter_valid=False,
 198             name_filter=''
 199         )
 200         err_msg = 'Failed to get interface dump on host {host}'.format(
 201             host=node['host'])
 202         with PapiSocketExecutor(node) as papi_exec:
 203             details = papi_exec.add(cmd, **args).get_details(err_msg)
 204
 205         for if_dump in details:
 206             if_dump['l2_address'] = str(if_dump['l2_address'])
 207             if_dump['b_dmac'] = str(if_dump['b_dmac'])
 208             if_dump['b_smac'] = str(if_dump['b_smac'])
 209             if_dump['flags'] = if_dump['flags'].value
 210             if_dump['type'] = if_dump['type'].value
 211             if_dump['link_duplex'] = if_dump['link_duplex'].value
 212             if_dump['sub_if_flags'] = if_dump['sub_if_flags'].value \
 213                 if hasattr(if_dump['sub_if_flags'], 'value') \
 214                 else int(if_dump['sub_if_flags'])
 215         # TODO: return only base data
 216         logger.trace('Interface data of host {host}:\n{details}'.format(
 217             host=node['host'], details=details))
 218
 219     @staticmethod
 220     def vpp_enable_traces_on_dut(node, fail_on_error=False):
 221         """Enable vpp packet traces on the DUT node.
 222
 223         :param node: DUT node to set up.
 224         :param fail_on_error: If True, keyword fails if an error occurs,
 225             otherwise passes.
 226         :type node: dict
 227         :type fail_on_error: bool
 228         """
 229         cmds = [
 230             "trace add dpdk-input 50",
 231             "trace add vhost-user-input 50",
 232             "trace add memif-input 50",
 233             "trace add avf-input 50"
 234         ]
 235
 236         for cmd in cmds:
 237             try:
 238                 PapiSocketExecutor.run_cli_cmd(node, cmd)
 239             except AssertionError:
 240                 if fail_on_error:
 241                     raise
 242
 243     @staticmethod
 244     def vpp_enable_traces_on_all_duts(nodes, fail_on_error=False):
 245         """Enable vpp packet traces on all DUTs in the given topology.
 246
 247         :param nodes: Nodes in the topology.
 248         :param fail_on_error: If True, keyword fails if an error occurs,
 249             otherwise passes.
 250         :type nodes: dict
 251         :type fail_on_error: bool
 252         """
 253         for node in nodes.values():
 254             if node['type'] == NodeType.DUT:
 255                 VPPUtil.vpp_enable_traces_on_dut(node, fail_on_error)
 256
 257     @staticmethod
 258     def vpp_enable_elog_traces_on_dut(node):
 259         """Enable API/CLI/Barrier traces on the DUT node.
 260
 261         :param node: DUT node to set up.
 262         :type node: dict
 263         """
 264         PapiSocketExecutor.run_cli_cmd(node, "elog trace api cli barrier")
 265
 266     @staticmethod
 267     def vpp_enable_elog_traces_on_all_duts(nodes):
 268         """Enable API/CLI/Barrier traces on all DUTs in the given topology.
 269
 270         :param nodes: Nodes in the topology.
 271         :type nodes: dict
 272         """
 273         for node in nodes.values():
 274             if node['type'] == NodeType.DUT:
 275                 VPPUtil.vpp_enable_elog_traces_on_dut(node)
 276
 277     @staticmethod
 278     def show_event_logger_on_dut(node):
 279         """Show event logger on the DUT node.
 280
 281         :param node: DUT node to show traces on.
 282         :type node: dict
 283         """
 284         PapiSocketExecutor.run_cli_cmd(node, "show event-logger")
 285
 286     @staticmethod
 287     def show_event_logger_on_all_duts(nodes):
 288         """Show event logger on all DUTs in the given topology.
 289
 290         :param nodes: Nodes in the topology.
 291         :type nodes: dict
 292         """
 293         for node in nodes.values():
 294             if node['type'] == NodeType.DUT:
 295                 VPPUtil.show_event_logger_on_dut(node)
 296
 297     @staticmethod
 298     def show_log(node):
 299         """Show log on the specified topology node.
 300
 301         :param node: Topology node.
 302         :type node: dict
 303         :returns: VPP log data.
 304         :rtype: list
 305         """
 306         return PapiSocketExecutor.run_cli_cmd(node, "show log")
 307
 308     @staticmethod
 309     def vpp_show_threads(node):
 310         """Show VPP threads on node.
 311
 312         :param node: Node to run command on.
 313         :type node: dict
 314         :returns: VPP thread data.
 315         :rtype: list
 316         """
 317         cmd = 'show_threads'
 318         with PapiSocketExecutor(node) as papi_exec:
 319             reply = papi_exec.add(cmd).get_reply()
 320
 321         threads_data = list()
 322         for thread in reply["thread_data"]:
 323             thread_data = list()
 324             for item in thread:
 325                 if isinstance(item, unicode):
 326                     item = item.rstrip('\x00')
 327                 thread_data.append(item)
 328             threads_data.append(thread_data)
 329
 330         logger.info("show threads:\n{threads}".format(threads=threads_data))
 331
 332         return threads_data