-# Copyright (c) 2019 Cisco and/or its affiliates.
+# Copyright (c) 2022 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:
"""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.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(object):
+class VPPUtil:
"""General class for any VPP related methods/functions."""
@staticmethod
: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 <retry> 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.CLI, node_key, Constants.SOCKCLI_PATH)
+ 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.
+ def vpp_show_version(
+ node, remote_vpp_socket=Constants.SOCKSVR_PATH, log=True):
+ """Run "show_version" PAPI command.
- :param node: Node to run command on.
- :type node: dict
- """
- vat = VatExecutor()
- vat.execute_script("show_interface.vat", node, json_out=False)
-
- 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.
+ 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.
"""
- 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")
+ version = f"{reply[u'version']}"
+ export_dut_type_and_version(u"VPP", version)
+ return 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):
: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):
: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):
:type node: dict
:returns: VPP thread data.
:rtype: list
- :raises RuntimeError: If failed to run command on host.
- :raises PapiError: If no API reply received.
"""
- api_data = list()
- api = dict(api_name='show_threads')
- api_args = dict()
- api['api_args'] = api_args
- api_data.append(api)
-
- with PapiExecutor(node) as papi_executor:
- papi_executor.execute_papi(api_data)
- try:
- papi_executor.papi_should_have_passed()
- api_reply = papi_executor.get_papi_reply()
- except AssertionError:
- raise RuntimeError('Failed to run {api_name} on host '
- '{host}!'.format(host=node['host'], **api))
-
- if api_reply:
- return \
- api_reply[0]['api_reply']['show_threads_reply']['thread_data']
- else:
- raise PapiError('No reply received for {api_name} on host {host}!'.
- format(host=node['host'], **api))
+ 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"]
Code Review / csit.git / blobdiff