"""VPP util library."""
-import time
+import binascii
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 PapiExecutor
-from resources.libraries.python.PapiErrors import PapiError
-from resources.libraries.python.ssh import exec_cmd, exec_cmd_no_error
+from resources.libraries.python.ssh import exec_cmd_no_error
from resources.libraries.python.topology import NodeType
from resources.libraries.python.VatExecutor import VatExecutor
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):
+ """Restart VPP service on the specified topology node.
- :param node: VPP node.
- :param retries: Number of times (default 60) to re-try waiting.
+ :param node: Topology node.
:type node: dict
- :type retries: int
- :raises RuntimeError: If VPP service fails to start.
"""
- 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)
+ DUTSetup.restart_service(node, Constants.VPP_UNIT)
@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)
+ VPPUtil.restart_vpp_service(node)
@staticmethod
def stop_vpp_service(node):
- """Stop VPP service on the specified node.
+ """Stop VPP service on the specified topology node.
- :param node: VPP node.
+ :param node: Topology node.
:type node: dict
- :raises RuntimeError: If VPP service fails to stop.
"""
DUTSetup.stop_service(node, Constants.VPP_UNIT)
@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():
VPPUtil.stop_vpp_service(node)
@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: Topology node.
+ :type node: dict
+ """
+ cmd = 'command -v vpp'
+ exec_cmd_no_error(
+ node, cmd, message='VPP is not installed!')
+
+ @staticmethod
+ def verify_vpp_started(node):
+ """Verify that VPP is started 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)
+ cmd = ('vppctl show pci 2>&1 | '
+ 'fgrep -v "Connection refused" | '
+ 'fgrep -v "No such file or directory"')
+ exec_cmd_no_error(
+ node, cmd, sudo=True, message='VPP failed to start!', retries=120)
+
+ @staticmethod
+ def verify_vpp(node):
+ """Verify that VPP is installed and started on the specified topology
+ node.
+
+ :param node: Topology node.
+ :type node: dict
+ :raises RuntimeError: If VPP service fails to start.
+ """
+ VPPUtil.verify_vpp_installed(node)
+ try:
+ # Verify responsivness of vppctl.
+ VPPUtil.verify_vpp_started(node)
+ # Verify responsivness of PAPI.
+ VPPUtil.show_log(node)
+ finally:
+ DUTSetup.get_service_logs(node, Constants.VPP_UNIT)
@staticmethod
def verify_vpp_on_all_duts(nodes):
- """Verify that VPP is installed on all DUT nodes.
+ """Verify that VPP is installed and started on all DUT nodes.
:param nodes: Nodes in the topology.
:type nodes: dict
"""
for node in nodes.values():
if node['type'] == NodeType.DUT:
- VPPUtil.start_vpp_service(node)
- VPPUtil.verify_vpp_on_dut(node)
+ VPPUtil.verify_vpp(node)
@staticmethod
- def vpp_show_version(node, verbose=False):
- """Run "show_version" API command.
+ def vpp_show_version(node, verbose=True):
+ """Run "show_version" PAPI command.
:param node: Node to run command on.
:param verbose: Show version, compile date and compile location if True
otherwise show only version.
: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']))
-
- @staticmethod
- def vpp_show_version_verbose(node):
- """Run "show_version" API command and return verbose string of version
- data.
-
- :param node: Node to run command on.
- :type node: dict
+ :returns: VPP version.
+ :rtype: str
"""
- VPPUtil.vpp_show_version(node, verbose=True)
+ with PapiExecutor(node) as papi_exec:
+ data = papi_exec.add('show_version').execute_should_pass().\
+ verify_reply()
+ version = ('VPP version: {ver}\n'.
+ format(ver=data['version'].rstrip('\0x00')))
+ if verbose:
+ version += ('Compile date: {date}\n'
+ 'Compile location: {cl}\n '.
+ format(date=data['build_date'].rstrip('\0x00'),
+ cl=data['build_directory'].rstrip('\0x00')))
+ logger.info(version)
+ return data['version'].rstrip('\0x00')
@staticmethod
def show_vpp_version_on_all_duts(nodes):
- """Show VPP version on all DUTs.
+ """Show VPP version verbose on all DUTs.
- :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)
+ VPPUtil.vpp_show_version(node)
@staticmethod
def vpp_show_interfaces(node):
: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']))
+ cmd = 'sw_interface_dump'
+ cmd_reply = 'sw_interface_details'
+ args = dict(name_filter_valid=0, name_filter='')
+ err_msg = 'Failed to get interface dump on host {host}'.format(
+ host=node['host'])
+ with PapiExecutor(node) as papi_exec:
+ papi_resp = papi_exec.add(cmd, **args).execute_should_pass(err_msg)
+
+ papi_if_dump = papi_resp.reply[0]['api_reply']
+
+ if_data = list()
+ for item in papi_if_dump:
+ data = item[cmd_reply]
+ data['interface_name'] = data['interface_name'].rstrip('\x00')
+ data['tag'] = data['tag'].rstrip('\x00')
+ data['l2_address'] = str(':'.join(binascii.hexlify(
+ data['l2_address'])[i:i + 2] for i in range(0, 12, 2)).
+ decode('ascii'))
+ if_data.append(data)
+ # TODO: return only base data
+ logger.trace('Interface data of host {host}:\n{if_data}'.format(
+ host=node['host'], if_data=if_data))
@staticmethod
def vpp_show_crypto_device_mapping(node):
vat.execute_script("show_crypto_device_mapping.vat", node,
json_out=False)
- @staticmethod
- def vpp_api_trace_dump(node):
- """Run "api trace custom-dump" CLI command.
-
- :param node: Node to run command on.
- :type node: dict
- """
- vat = VatExecutor()
- vat.execute_script("api_trace_dump.vat", node, json_out=False)
-
- @staticmethod
- def vpp_api_trace_save(node):
- """Run "api trace save" 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)
-
@staticmethod
def vpp_enable_traces_on_dut(node):
"""Enable vpp packet traces on the DUT node.
if node['type'] == NodeType.DUT:
VPPUtil.show_event_logger_on_dut(node)
+ @staticmethod
+ def show_log(node):
+ """Show log on the specified topology node.
+
+ :param node: Topology node.
+ :type node: dict
+ :returns: VPP log data.
+ :rtype: list
+ """
+ with PapiExecutor(node) as papi_exec:
+ return papi_exec.add('cli_inband', cmd='show log').get_replies().\
+ verify_reply()["reply"]
+
@staticmethod
def vpp_show_threads(node):
"""Show VPP threads on 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))
+ with PapiExecutor(node) as papi_exec:
+ return papi_exec.add('show_threads').execute_should_pass().\
+ verify_reply()["thread_data"]