X-Git-Url: https://gerrit.fd.io/r/gitweb?p=csit.git;a=blobdiff_plain;f=resources%2Flibraries%2Fpython%2FVPPUtil.py;h=3c7894988be293a74e9d464b1e039de8dd59949b;hp=8744dc0154a521d1363e6c5cd2ac27ea97a0d30b;hb=HEAD;hpb=3b408b7ea702dd3817442186035121fe862cbf7f diff --git a/resources/libraries/python/VPPUtil.py b/resources/libraries/python/VPPUtil.py index 8744dc0154..1ede76cdd4 100644 --- a/resources/libraries/python/VPPUtil.py +++ b/resources/libraries/python/VPPUtil.py @@ -1,4 +1,4 @@ -# Copyright (c) 2020 Cisco and/or its affiliates. +# Copyright (c) 2023 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: @@ -18,53 +18,40 @@ from robot.api import logger from resources.libraries.python.Constants import Constants from resources.libraries.python.DUTSetup import DUTSetup from resources.libraries.python.PapiExecutor import PapiSocketExecutor -from resources.libraries.python.ssh import exec_cmd_no_error +from resources.libraries.python.model.ExportResult import ( + export_dut_type_and_version +) +from resources.libraries.python.ssh import exec_cmd_no_error, exec_cmd from resources.libraries.python.topology import Topology, SocketType, NodeType class VPPUtil: """General class for any VPP related methods/functions.""" - @staticmethod - def show_vpp_settings(node, *additional_cmds): - """Print default VPP settings. In case others are needed, can be - accepted as next parameters (each setting one parameter), preferably - in form of a string. - - :param node: VPP node. - :param additional_cmds: Additional commands that the vpp should print - settings for. - :type node: dict - :type additional_cmds: tuple - """ - def_setting_tb_displayed = { - 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[f"Custom Setting: {cmd}"] = cmd - - for _, cmd in def_setting_tb_displayed.items(): - command = f"vppctl sh {cmd}" - exec_cmd_no_error(node, command, timeout=30, sudo=True) - @staticmethod def restart_vpp_service(node, node_key=None): """Restart VPP service on the specified topology node. + Disconnect possibly connected PAPI executor. + :param node: Topology node. :param node_key: Topology node key. :type node: dict :type node_key: str """ - DUTSetup.restart_service(node, Constants.VPP_UNIT) + # Containers have a separate lifecycle, but better be safe. + PapiSocketExecutor.disconnect_all_sockets_by_node(node) + + VPPUtil.stop_vpp_service(node) + command = "/usr/bin/vpp -c /etc/vpp/startup.conf" + message = f"Node {node[u'host']} failed to start VPP!" + exec_cmd_no_error( + node, command, timeout=180, sudo=True, message=message + ) + if node_key: + Topology.add_new_socket( + node, SocketType.CLI, node_key, Constants.SOCKCLI_PATH) Topology.add_new_socket( node, SocketType.PAPI, node_key, Constants.SOCKSVR_PATH) Topology.add_new_socket( @@ -85,15 +72,26 @@ class VPPUtil: def stop_vpp_service(node, node_key=None): """Stop VPP service on the specified topology node. + Disconnect possibly connected PAPI executor. + :param node: Topology node. :param node_key: Topology node key. :type node: dict :type node_key: str """ - DUTSetup.stop_service(node, Constants.VPP_UNIT) + PapiSocketExecutor.disconnect_all_sockets_by_node(node) + command = "pkill -9 vpp; sleep 1" + exec_cmd(node, command, timeout=180, sudo=True) + command = ( + "/bin/rm -f /dev/shm/db /dev/shm/global_vm /dev/shm/vpe-api" + ) + exec_cmd(node, command, timeout=180, sudo=True) + if node_key: - Topology.del_node_socket_id(node, SocketType.PAPI, node_key) - Topology.del_node_socket_id(node, SocketType.STATS, node_key) + if Topology.get_node_sockets(node, socket_type=SocketType.PAPI): + Topology.del_node_socket_id(node, SocketType.PAPI, node_key) + if Topology.get_node_sockets(node, socket_type=SocketType.STATS): + Topology.del_node_socket_id(node, SocketType.STATS, node_key) @staticmethod def stop_vpp_service_on_all_duts(nodes): @@ -106,6 +104,39 @@ class VPPUtil: if node[u"type"] == NodeType.DUT: VPPUtil.stop_vpp_service(node, node_key) + @staticmethod + def install_vpp_on_all_duts(nodes, vpp_pkg_dir): + """Install VPP on all DUT nodes. + + :param nodes: Nodes in the topology. + :param vpp_pkg_dir: Path to directory where VPP packages are stored. + :type nodes: dict + :type vpp_pkg_dir: str + """ + VPPUtil.stop_vpp_service_on_all_duts(nodes) + for node in nodes.values(): + message = f"Failed to install VPP on host {node['host']}!" + if node["type"] == NodeType.DUT: + command = "mkdir -p /var/log/vpp/" + exec_cmd(node, command, sudo=True) + + command = "ln -s /dev/null /etc/systemd/system/vpp.service" + exec_cmd(node, command, sudo=True) + + command = "ln -s /dev/null /etc/sysctl.d/80-vpp.conf" + exec_cmd(node, command, sudo=True) + + command = "apt-get purge -y '*vpp*' || true" + exec_cmd_no_error(node, command, timeout=120, sudo=True) + + command = f"dpkg -i --force-all {vpp_pkg_dir}*.deb" + exec_cmd_no_error( + node, command, timeout=120, sudo=True, message=message + ) + + command = "dpkg -l | grep vpp" + exec_cmd_no_error(node, command, sudo=True) + @staticmethod def verify_vpp_installed(node): """Verify that VPP is installed on the specified topology node. @@ -145,6 +176,12 @@ class VPPUtil: 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 verify_vpp(node): """Verify that VPP is installed and started on the specified topology @@ -178,19 +215,32 @@ class VPPUtil: VPPUtil.verify_vpp(node) @staticmethod - def vpp_show_version(node): + def vpp_show_version( + node, remote_vpp_socket=Constants.SOCKSVR_PATH, log=True): """Run "show_version" PAPI command. + Socket is configurable, so VPP inside container can be accessed. + The result is exported to JSON UTI output as "dut-version". + :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. """ cmd = u"show_version" - with PapiSocketExecutor(node) as papi_exec: + with PapiSocketExecutor(node, remote_vpp_socket) as papi_exec: reply = papi_exec.add(cmd).get_reply() - logger.info(f"VPP version: {reply[u'version']}\n") - return f"{reply[u'version']}" + if log: + logger.info(f"VPP version: {reply[u'version']}\n") + version = f"{reply[u'version']}" + export_dut_type_and_version(u"VPP", version) + return version @staticmethod def show_vpp_version_on_all_duts(nodes): @@ -278,8 +328,13 @@ class VPPUtil: :param node: Topology node. :type node: dict """ - PapiSocketExecutor.run_cli_cmd_on_all_sockets( - node, u"elog trace api cli barrier") + 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): @@ -350,3 +405,43 @@ class VPPUtil: 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"] + + @staticmethod + def vpp_set_neighbor_limit_on_all_duts(nodes, count): + """VPP set neighbor count limit on all DUTs in the given topology. + + :param nodes: Nodes in the topology. + :param count: Neighbor count need to set. + :type nodes: dict + :type count: int + """ + for node in nodes.values(): + if node[u"type"] == NodeType.DUT: + cmd = f"set ip neighbor-config ip4 limit {count}" + PapiSocketExecutor.run_cli_cmd(node, cmd) + + cmd = f"set ip neighbor-config ip6 limit {count}" + PapiSocketExecutor.run_cli_cmd(node, cmd)