X-Git-Url: https://gerrit.fd.io/r/gitweb?p=csit.git;a=blobdiff_plain;f=resources%2Flibraries%2Fpython%2FVPPUtil.py;h=e343d38d2ffbacd2583d97944318fc2faedfa72d;hp=63d9aaca86cd26e20c7a0c081fa7dca727e95e78;hb=6962831a1f1905e50a3d663c0cf3ce8c2873ecc9;hpb=8bac97fb07e863573f5a2914058e1d23229d279b diff --git a/resources/libraries/python/VPPUtil.py b/resources/libraries/python/VPPUtil.py index 63d9aaca86..e343d38d2f 100644 --- a/resources/libraries/python/VPPUtil.py +++ b/resources/libraries/python/VPPUtil.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: @@ -13,20 +13,16 @@ """VPP util library.""" -import time - from robot.api import logger -from resources.libraries.python.constants import Constants +from resources.libraries.python.Constants import Constants from resources.libraries.python.DUTSetup import DUTSetup -from resources.libraries.python.PapiExecutor import PapiExecutor -from resources.libraries.python.PapiErrors import PapiError -from resources.libraries.python.ssh import exec_cmd, exec_cmd_no_error -from resources.libraries.python.topology import NodeType -from resources.libraries.python.VatExecutor import VatExecutor +from resources.libraries.python.PapiExecutor import PapiSocketExecutor +from resources.libraries.python.ssh import exec_cmd_no_error, exec_cmd +from resources.libraries.python.topology import Topology, SocketType, NodeType -class VPPUtil(object): +class VPPUtil: """General class for any VPP related methods/functions.""" @staticmethod @@ -42,249 +38,277 @@ class VPPUtil(object): :type additional_cmds: tuple """ def_setting_tb_displayed = { - 'IPv6 FIB': 'ip6 fib', - 'IPv4 FIB': 'ip fib', - 'Interface IP': 'int addr', - 'Interfaces': 'int', - 'ARP': 'ip arp', - 'Errors': 'err' + u"IPv6 FIB": u"ip6 fib", + u"IPv4 FIB": u"ip fib", + u"Interface IP": u"int addr", + u"Interfaces": u"int", + u"ARP": u"ip arp", + u"Errors": u"err" } if additional_cmds: for cmd in additional_cmds: - def_setting_tb_displayed['Custom Setting: {}'.format(cmd)] = cmd + def_setting_tb_displayed[f"Custom Setting: {cmd}"] = cmd for _, cmd in def_setting_tb_displayed.items(): - command = 'vppctl sh {cmd}'.format(cmd=cmd) + command = f"vppctl sh {cmd}" exec_cmd_no_error(node, command, timeout=30, sudo=True) @staticmethod - def start_vpp_service(node, retries=60): - """Start VPP service on the specified node. + def restart_vpp_service(node, node_key=None): + """Restart VPP service on the specified topology node. - :param node: VPP node. - :param retries: Number of times (default 60) to re-try waiting. + Disconnect possibly connected PAPI executor. + + :param node: Topology node. + :param node_key: Topology node key. :type node: dict - :type retries: int - :raises RuntimeError: If VPP service fails to start. + :type node_key: str """ - DUTSetup.start_service(node, Constants.VPP_UNIT) - # Sleep 1 second, up to times, - # and verify if VPP is running. - for _ in range(retries): - time.sleep(1) - command = 'vppctl show pci' - ret, stdout, _ = exec_cmd(node, command, timeout=30, sudo=True) - if not ret and 'Connection refused' not in stdout: - break - else: - raise RuntimeError('VPP failed to start on host {name}'. - format(name=node['host'])) - DUTSetup.get_service_logs(node, Constants.VPP_UNIT) + # Containers have a separate lifecycle, but better be safe. + PapiSocketExecutor.disconnect_all_sockets_by_node(node) + DUTSetup.restart_service(node, Constants.VPP_UNIT) + if node_key: + Topology.add_new_socket( + node, SocketType.PAPI, node_key, Constants.SOCKSVR_PATH) + Topology.add_new_socket( + node, SocketType.STATS, node_key, Constants.SOCKSTAT_PATH) @staticmethod - def start_vpp_service_on_all_duts(nodes): - """Start up the VPP service on all nodes. + def restart_vpp_service_on_all_duts(nodes): + """Restart VPP service on all DUT nodes. - :param nodes: Nodes in the topology. + :param nodes: Topology nodes. :type nodes: dict """ - for node in nodes.values(): - if node['type'] == NodeType.DUT: - VPPUtil.start_vpp_service(node) + for node_key, node in nodes.items(): + if node[u"type"] == NodeType.DUT: + VPPUtil.restart_vpp_service(node, node_key) @staticmethod - def stop_vpp_service(node): - """Stop VPP service on the specified node. + def stop_vpp_service(node, node_key=None): + """Stop VPP service on the specified topology node. - :param node: VPP node. + Disconnect possibly connected PAPI executor. + + :param node: Topology node. + :param node_key: Topology node key. :type node: dict - :raises RuntimeError: If VPP service fails to stop. + :type node_key: str """ + # Containers have a separate lifecycle, but better be safe. + PapiSocketExecutor.disconnect_all_sockets_by_node(node) DUTSetup.stop_service(node, Constants.VPP_UNIT) + if node_key: + Topology.del_node_socket_id(node, SocketType.PAPI, node_key) + Topology.del_node_socket_id(node, SocketType.STATS, node_key) @staticmethod def stop_vpp_service_on_all_duts(nodes): - """Stop VPP service on all nodes. + """Stop VPP service on all DUT nodes. - :param nodes: Nodes in the topology. + :param nodes: Topology nodes. :type nodes: dict """ - for node in nodes.values(): - if node['type'] == NodeType.DUT: - VPPUtil.stop_vpp_service(node) + for node_key, node in nodes.items(): + if node[u"type"] == NodeType.DUT: + VPPUtil.stop_vpp_service(node, node_key) @staticmethod - def verify_vpp_on_dut(node): - """Verify that VPP is installed on DUT node. + def verify_vpp_installed(node): + """Verify that VPP is installed on the specified topology node. - :param node: DUT node. + :param node: Topology node. :type node: dict - :raises RuntimeError: If failed to restart VPP, get VPP version - or get VPP interfaces. """ - VPPUtil.vpp_show_version_verbose(node) - VPPUtil.vpp_show_interfaces(node) + DUTSetup.verify_program_installed(node, u"vpp") @staticmethod - def verify_vpp_on_all_duts(nodes): - """Verify that VPP is installed on all DUT nodes. + def adjust_privileges(node): + """Adjust privileges to control VPP without sudo. - :param nodes: Nodes in the topology. - :type nodes: dict + :param node: Topology node. + :type node: dict """ - for node in nodes.values(): - if node['type'] == NodeType.DUT: - VPPUtil.start_vpp_service(node) - VPPUtil.verify_vpp_on_dut(node) + cmd = u"chmod -R o+rwx /run/vpp" + exec_cmd_no_error( + node, cmd, sudo=True, message=u"Failed to adjust privileges!", + retries=120) @staticmethod - def vpp_show_version(node, verbose=False): - """Run "show_version" API command. + def verify_vpp_started(node): + """Verify that VPP is started on the specified topology node. - :param node: Node to run command on. - :param verbose: Show version, compile date and compile location if True - otherwise show only version. + :param node: Topology node. :type node: dict - :type verbose: bool - :raises PapiError: If no reply received for show_version API command. """ - # TODO: move composition of api data to separate method - api_data = list() - api = dict(api_name='show_version') - api_args = dict() - api['api_args'] = api_args - api_data.append(api) - - api_reply = None - with PapiExecutor(node) as papi_executor: - papi_executor.execute_papi(api_data) - try: - papi_executor.papi_should_have_passed() - except AssertionError: - raise RuntimeError('Failed to get VPP version on host: {host}'. - format(host=node['host'])) - api_reply = papi_executor.get_papi_reply() - - if api_reply is not None: - version_data = api_reply[0]['api_reply']['show_version_reply'] - ver = version_data['version'].rstrip('\0x00') - if verbose: - date = version_data['build_date'].rstrip('\0x00') - loc = version_data['build_directory'].rstrip('\0x00') - version = \ - 'VPP Version: {ver}\n' \ - 'Compile date: {date}\n' \ - 'Compile location: {loc}\n '\ - .format(ver=ver, date=date, loc=loc) - else: - version = 'VPP version:{ver}'.format(ver=ver) - logger.info(version) - else: - raise PapiError('No reply received for show_version API command on ' - 'host {host}'.format(host=node['host'])) + cmd = u"echo \"show pci\" | sudo socat - UNIX-CONNECT:/run/vpp/cli.sock" + exec_cmd_no_error( + node, cmd, sudo=False, message=u"VPP failed to start!", retries=120 + ) + + cmd = u"vppctl show pci 2>&1 | fgrep -v \"Connection refused\" | " \ + u"fgrep -v \"No such file or directory\"" + exec_cmd_no_error( + node, cmd, sudo=True, message=u"VPP failed to start!", retries=120 + ) + + # Properly enable cards in case they were disabled. This will be + # followed in https://jira.fd.io/browse/VPP-1934. + cmd = u"for i in $(sudo vppctl sho int | grep Eth | cut -d' ' -f1); do"\ + u" sudo vppctl set int sta $i up; done" + exec_cmd(node, cmd, sudo=False) @staticmethod - def vpp_show_version_verbose(node): - """Run "show_version" API command and return verbose string of version - data. + def verify_vpp(node): + """Verify that VPP is installed and started on the specified topology + node. Adjust privileges so user can connect without sudo. - :param node: Node to run command on. + :param node: Topology node. :type node: dict + :raises RuntimeError: If VPP service fails to start. """ - VPPUtil.vpp_show_version(node, verbose=True) + DUTSetup.verify_program_installed(node, 'vpp') + try: + # Verify responsiveness of vppctl. + VPPUtil.verify_vpp_started(node) + # Adjust privileges. + VPPUtil.adjust_privileges(node) + # Verify responsiveness of PAPI. + VPPUtil.show_log(node) + VPPUtil.vpp_show_version(node) + finally: + DUTSetup.get_service_logs(node, Constants.VPP_UNIT) @staticmethod - def show_vpp_version_on_all_duts(nodes): - """Show VPP version on all DUTs. + def verify_vpp_on_all_duts(nodes): + """Verify that VPP is installed and started on all DUT nodes. - :param nodes: VPP nodes. + :param nodes: Nodes in the topology. :type nodes: dict """ for node in nodes.values(): - if node['type'] == NodeType.DUT: - VPPUtil.vpp_show_version_verbose(node) + if node[u"type"] == NodeType.DUT: + VPPUtil.verify_vpp(node) @staticmethod - def vpp_show_interfaces(node): - """Run "show interface" CLI command. - - :param node: Node to run command on. - :type node: dict - """ - vat = VatExecutor() - vat.execute_script("show_interface.vat", node, json_out=False) + def vpp_show_version( + node, remote_vpp_socket=Constants.SOCKSVR_PATH, log=True): + """Run "show_version" PAPI command. - try: - vat.script_should_have_passed() - except AssertionError: - raise RuntimeError('Failed to get VPP interfaces on host: {name}'. - format(name=node['host'])) - - @staticmethod - def vpp_show_crypto_device_mapping(node): - """Run "show crypto device mapping" CLI command. + Socket is configurable, so VPP inside container can be accessed. :param node: Node to run command on. + :param remote_vpp_socket: Path to remote socket to target VPP. + :param log: If true, show the result in Robot log. :type node: dict + :type remote_vpp_socket: str + :type log: bool + :returns: VPP version. + :rtype: str + :raises RuntimeError: If PAPI connection fails. + :raises AssertionError: If PAPI retcode is nonzero. """ - vat = VatExecutor() - vat.execute_script("show_crypto_device_mapping.vat", node, - json_out=False) + cmd = u"show_version" + with PapiSocketExecutor(node, remote_vpp_socket) as papi_exec: + reply = papi_exec.add(cmd).get_reply() + if log: + logger.info(f"VPP version: {reply[u'version']}\n") + return f"{reply[u'version']}" @staticmethod - def vpp_api_trace_dump(node): - """Run "api trace custom-dump" CLI command. + def show_vpp_version_on_all_duts(nodes): + """Show VPP version verbose on all DUTs. - :param node: Node to run command on. - :type node: dict + :param nodes: Nodes in the topology. + :type nodes: dict """ - vat = VatExecutor() - vat.execute_script("api_trace_dump.vat", node, json_out=False) + for node in nodes.values(): + if node[u"type"] == NodeType.DUT: + VPPUtil.vpp_show_version(node) @staticmethod - def vpp_api_trace_save(node): - """Run "api trace save" CLI command. + def vpp_show_interfaces(node): + """Run "show interface" CLI command. :param node: Node to run command on. :type node: dict """ - vat = VatExecutor() - vat.execute_script("api_trace_save.vat", node, json_out=False) + + cmd = u"sw_interface_dump" + args = dict( + name_filter_valid=False, + name_filter=u"" + ) + err_msg = f"Failed to get interface dump on host {node[u'host']}" + with PapiSocketExecutor(node) as papi_exec: + details = papi_exec.add(cmd, **args).get_details(err_msg) + + for if_dump in details: + if_dump[u"l2_address"] = str(if_dump[u"l2_address"]) + if_dump[u"b_dmac"] = str(if_dump[u"b_dmac"]) + if_dump[u"b_smac"] = str(if_dump[u"b_smac"]) + if_dump[u"flags"] = if_dump[u"flags"].value + if_dump[u"type"] = if_dump[u"type"].value + if_dump[u"link_duplex"] = if_dump[u"link_duplex"].value + if_dump[u"sub_if_flags"] = if_dump[u"sub_if_flags"].value \ + if hasattr(if_dump[u"sub_if_flags"], u"value") \ + else int(if_dump[u"sub_if_flags"]) + # TODO: return only base data + logger.trace(f"Interface data of host {node[u'host']}:\n{details}") @staticmethod - def vpp_enable_traces_on_dut(node): + def vpp_enable_traces_on_dut(node, fail_on_error=False): """Enable vpp packet traces on the DUT node. :param node: DUT node to set up. + :param fail_on_error: If True, keyword fails if an error occurs, + otherwise passes. :type node: dict + :type fail_on_error: bool """ - vat = VatExecutor() - vat.execute_script("enable_dpdk_traces.vat", node, json_out=False) - vat.execute_script("enable_vhost_user_traces.vat", node, json_out=False) - vat.execute_script("enable_memif_traces.vat", node, json_out=False) + cmds = [ + u"trace add dpdk-input 50", + u"trace add vhost-user-input 50", + u"trace add memif-input 50", + u"trace add avf-input 50" + ] + + for cmd in cmds: + try: + PapiSocketExecutor.run_cli_cmd_on_all_sockets(node, cmd) + except AssertionError: + if fail_on_error: + raise @staticmethod - def vpp_enable_traces_on_all_duts(nodes): + def vpp_enable_traces_on_all_duts(nodes, fail_on_error=False): """Enable vpp packet traces on all DUTs in the given topology. :param nodes: Nodes in the topology. + :param fail_on_error: If True, keyword fails if an error occurs, + otherwise passes. :type nodes: dict + :type fail_on_error: bool """ for node in nodes.values(): - if node['type'] == NodeType.DUT: - VPPUtil.vpp_enable_traces_on_dut(node) + if node[u"type"] == NodeType.DUT: + VPPUtil.vpp_enable_traces_on_dut(node, fail_on_error) @staticmethod - def vpp_enable_elog_traces_on_dut(node): - """Enable API/CLI/Barrier traces on the DUT node. + def vpp_enable_elog_traces(node): + """Enable API/CLI/Barrier traces on the specified topology node. - :param node: DUT node to set up. + :param node: Topology node. :type node: dict """ - vat = VatExecutor() - vat.execute_script("elog_trace_api_cli_barrier.vat", node, - json_out=False) + try: + PapiSocketExecutor.run_cli_cmd_on_all_sockets( + node, u"event-logger trace api cli barrier") + except AssertionError: + # Perhaps an older VPP build is tested. + PapiSocketExecutor.run_cli_cmd_on_all_sockets( + node, u"elog trace api cli barrier") @staticmethod def vpp_enable_elog_traces_on_all_duts(nodes): @@ -294,18 +318,18 @@ class VPPUtil(object): :type nodes: dict """ for node in nodes.values(): - if node['type'] == NodeType.DUT: - VPPUtil.vpp_enable_elog_traces_on_dut(node) + if node[u"type"] == NodeType.DUT: + VPPUtil.vpp_enable_elog_traces(node) @staticmethod - def show_event_logger_on_dut(node): - """Show event logger on the DUT node. + def show_event_logger(node): + """Show event logger on the specified topology node. - :param node: DUT node to show traces on. + :param node: Topology node. :type node: dict """ - vat = VatExecutor() - vat.execute_script("show_event_logger.vat", node, json_out=False) + PapiSocketExecutor.run_cli_cmd_on_all_sockets( + node, u"show event-logger") @staticmethod def show_event_logger_on_all_duts(nodes): @@ -315,5 +339,66 @@ class VPPUtil(object): :type nodes: dict """ for node in nodes.values(): - if node['type'] == NodeType.DUT: - VPPUtil.show_event_logger_on_dut(node) + if node[u"type"] == NodeType.DUT: + VPPUtil.show_event_logger(node) + + @staticmethod + def show_log(node): + """Show logging on the specified topology node. + + :param node: Topology node. + :type node: dict + """ + PapiSocketExecutor.run_cli_cmd(node, u"show logging") + + @staticmethod + def show_log_on_all_duts(nodes): + """Show logging on all DUTs in the given topology. + + :param nodes: Nodes in the topology. + :type nodes: dict + """ + for node in nodes.values(): + if node[u"type"] == NodeType.DUT: + VPPUtil.show_log(node) + + @staticmethod + def vpp_show_threads(node): + """Show VPP threads on node. + + :param node: Node to run command on. + :type node: dict + :returns: VPP thread data. + :rtype: list + """ + cmd = u"show_threads" + with PapiSocketExecutor(node) as papi_exec: + reply = papi_exec.add(cmd).get_reply() + + threads_data = reply[u"thread_data"] + logger.trace(f"show threads:\n{threads_data}") + + return threads_data + + @staticmethod + def vpp_add_graph_node_next(node, graph_node_name, graph_next_name): + """Set the next node for a given node. + + :param node: Node to run command on. + :param graph_node_name: Graph node to add the next node on. + :param graph_next_name: Graph node to add as the next node. + :type node: dict + :type graph_node_name: str + :type graph_next_name: str + :returns: The index of the next graph node. + :rtype: int + """ + cmd = u"add_node_next" + args = dict( + node_name=graph_node_name, + next_name=graph_next_name + ) + with PapiSocketExecutor(node) as papi_exec: + reply = papi_exec.add(cmd, **args).get_reply() + + return reply[u"next_index"]