-# Copyright (c) 2017 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:
"""Memif interface library."""
-from resources.libraries.python.ssh import SSH
-from resources.libraries.python.VatExecutor import VatExecutor, VatTerminal
-from resources.libraries.python.topology import Topology
+from enum import IntEnum
-class Memif(object):
- """Memif interface class."""
+from robot.api import logger
+
+from resources.libraries.python.topology import NodeType, Topology
+from resources.libraries.python.PapiExecutor import PapiSocketExecutor
+
+
+class MemifRole(IntEnum):
+ """Memif interface roles"""
+ MASTER = 0
+ SLAVE = 1
+
+
+class Memif:
+ """Memif interface class"""
def __init__(self):
pass
@staticmethod
- def create_memif_interface(node, filename, mid, sid, rxq=1, txq=1,
- role='slave'):
+ def _memif_details(node):
+ """Get the memif dump details on the given node.
+
+ :param node: Given node to get Memif dump from.
+ :type node: dict
+ :returns: List of memif interfaces extracted from Papi response.
+ :rtype: list
+ """
+ cmd = u"memif_dump"
+ with PapiSocketExecutor(node) as papi_exec:
+ details = papi_exec.add(cmd).get_details()
+
+ for memif in details:
+ memif[u"hw_addr"] = str(memif[u"hw_addr"])
+ memif[u"role"] = memif[u"role"].value
+ memif[u"mode"] = memif[u"mode"].value
+ memif[u"flags"] = memif[u"flags"].value \
+ if hasattr(memif[u"flags"], u"value") else int(memif[u"flags"])
+
+ logger.debug(f"MEMIF details:\n{details}")
+
+ return details
+
+ @staticmethod
+ def _memif_socket_filename_add_del(node, is_add, filename, sid):
+ """Create Memif socket on the given node.
+
+ :param node: Given node to create Memif socket on.
+ :param is_add: If True, socket is added, otherwise deleted.
+ :param filename: Memif interface socket filename.
+ :param sid: Socket ID.
+ :type node: dict
+ :type is_add: bool
+ :type filename: str
+ :type sid: str
+ :returns: Verified data from PAPI response. In this case, the response
+ includes only retval.
+ :rtype: dict
+ """
+ cmd = u"memif_socket_filename_add_del"
+ err_msg = f"Failed to create memif socket on host {node[u'host']}"
+ args = dict(
+ is_add=is_add,
+ socket_id=int(sid),
+ socket_filename=str(u"/tmp/" + filename)
+ )
+ with PapiSocketExecutor(node) as papi_exec:
+ return papi_exec.add(cmd, **args).get_reply(err_msg)
+
+ @staticmethod
+ def _memif_create(node, mid, sid, rxq=1, txq=1, role=1):
+ """Create Memif interface on the given node, return its sw_if_index.
+
+ :param node: Given node to create Memif interface on.
+ :param mid: Memif interface ID.
+ :param sid: Socket ID.
+ :param rxq: Number of RX queues; 0 means do not set.
+ :param txq: Number of TX queues; 0 means do not set.
+ :param role: Memif interface role [master=0|slave=1]. Default is slave.
+ :type node: dict
+ :type mid: str
+ :type sid: str
+ :type rxq: int
+ :type txq: int
+ :type role: int
+ :returns: sw_if_index
+ :rtype: int
+ """
+ cmd = u"memif_create"
+ err_msg = f"Failed to create memif interface on host {node[u'host']}"
+ args = dict(
+ role=role,
+ rx_queues=int(rxq),
+ tx_queues=int(txq),
+ socket_id=int(sid),
+ id=int(mid),
+ secret=u""
+ )
+
+ with PapiSocketExecutor(node) as papi_exec:
+ return papi_exec.add(cmd, **args).get_sw_if_index(err_msg)
+
+ @staticmethod
+ def create_memif_interface(
+ node, filename, mid, sid, rxq=1, txq=1, role=u"SLAVE"):
"""Create Memif interface on the given node.
:param node: Given node to create Memif interface on.
:param filename: Memif interface socket filename.
:param mid: Memif interface ID.
:param sid: Socket ID.
- :param rxq: Number of RX queues.
- :param txq: Number of TX queues.
- :param role: Memif interface role [master|slave]. Default is master.
+ :param rxq: Number of RX queues; 0 means do not set.
+ :param txq: Number of TX queues; 0 means do not set.
+ :param role: Memif interface role [master=0|slave=1]. Default is master.
:type node: dict
:type filename: str
:type mid: str
:rtype: int
:raises ValueError: If command 'create memif' fails.
"""
+ role = getattr(MemifRole, role.upper()).value
- with VatTerminal(node, json_param=False) as vat:
- vat.vat_terminal_exec_cmd_from_template(
- 'memif_socket_filename_add_del.vat',
- add_del='add', id=sid, filename='/tmp/'+filename)
- vat.vat_terminal_exec_cmd_from_template(
- 'memif_create.vat', id=mid, socket=sid, rxq=rxq, txq=txq,
- role=role)
- if 'sw_if_index' in vat.vat_stdout:
- try:
- sw_if_idx = int(vat.vat_stdout.split()[4])
- if_key = Topology.add_new_port(node, 'memif')
- Topology.update_interface_sw_if_index(
- node, if_key, sw_if_idx)
- ifc_name = Memif.vpp_get_memif_interface_name(
- node, sw_if_idx)
- Topology.update_interface_name(node, if_key, ifc_name)
- ifc_mac = Memif.vpp_get_memif_interface_mac(node, sw_if_idx)
- Topology.update_interface_mac_address(node, if_key, ifc_mac)
- Topology.update_interface_memif_socket(node, if_key,
- '/tmp/'+filename)
- Topology.update_interface_memif_id(node, if_key, mid)
- Topology.update_interface_memif_role(node, if_key, role)
- return sw_if_idx
- except KeyError:
- raise ValueError('Create Memif interface failed on node '
- '{}'.format(node['host']))
- else:
- raise ValueError('Create Memif interface failed on node '
- '{}'.format(node['host']))
+ # Create socket
+ Memif._memif_socket_filename_add_del(node, True, filename, sid)
- @staticmethod
- def dump_memif(node):
- """Dump Memif data for the given node.
+ # Create memif
+ sw_if_index = Memif._memif_create(
+ node, mid, sid, rxq=rxq, txq=txq, role=role
+ )
- :param node: Given node to show Memif data on.
- :type node: dict
- """
- vat = VatExecutor()
- vat.execute_script("memif_dump.vat", node, json_out=False)
+ # Update Topology
+ if_key = Topology.add_new_port(node, u"memif")
+ Topology.update_interface_sw_if_index(node, if_key, sw_if_index)
+
+ ifc_name = Memif.vpp_get_memif_interface_name(node, sw_if_index)
+ Topology.update_interface_name(node, if_key, ifc_name)
+
+ ifc_mac = Memif.vpp_get_memif_interface_mac(node, sw_if_index)
+ Topology.update_interface_mac_address(node, if_key, ifc_mac)
+
+ Topology.update_interface_memif_socket(
+ node, if_key, u"/tmp/" + filename
+ )
+ Topology.update_interface_memif_id(node, if_key, mid)
+ Topology.update_interface_memif_role(node, if_key, str(role))
+
+ return sw_if_index
@staticmethod
def show_memif(node):
:param node: Given node to show Memif data on.
:type node: dict
"""
- vat = VatExecutor()
- vat.execute_script("show_memif.vat", node, json_out=False)
-
- @staticmethod
- def clear_memif_socks(node, *socks):
- """Clear Memif sockets for the given node.
-
- :param node: Given node to clear Memif sockets on.
- :param socks: Memif sockets.
- :type node: dict
- :type socks: list
- """
- ssh = SSH()
- ssh.connect(node)
-
- for sock in socks:
- ssh.exec_command_sudo('rm -f {}'.format(sock))
+ Memif._memif_details(node)
@staticmethod
- def parse_memif_dump_data(memif_data):
- """Convert Memif data to dictionary.
+ def show_memif_on_all_duts(nodes):
+ """Show Memif data on all DUTs.
- :param memif_data: Dump of Memif interfaces data.
- :type memif_data: str
- :returns: Memif interfaces data in dictionary.
- :rtype: dict
- :raises RuntimeError: If there is no memif interface name found in
- provided data.
+ :param nodes: Topology nodes.
+ :type nodes: dict
"""
- memif_name = None
- memif_dict = dict()
- memif_data = str(memif_data)
- values = dict()
-
- clutter = ['vat#']
- for garbage in clutter:
- memif_data = memif_data.replace(garbage, '')
-
- for line in memif_data.splitlines():
- if line.startswith('Sending') or len(line) == 0:
- continue
- elif line.startswith('memif'):
- if memif_name:
- memif_dict[memif_name] = values
- line_split = line.split(':', 1)
- memif_name = str(line_split[0])
- values = dict()
- line = line_split[1]
- line_split = line.split()
- for i in range(0, len(line_split), 2):
- key = str(line_split[i])
- try:
- value = line_split[i+1]
- except IndexError:
- value = None
- values[key] = value
- if memif_name:
- memif_dict[memif_name] = values
- else:
- raise RuntimeError('No memif interface name found')
-
- return memif_dict
+ for node in nodes.values():
+ if node[u"type"] == NodeType.DUT:
+ Memif.show_memif(node)
@staticmethod
- def vpp_get_memif_interface_name(node, sw_if_idx):
+ def vpp_get_memif_interface_name(node, sw_if_index):
"""Get Memif interface name from Memif interfaces dump.
:param node: DUT node.
- :param sw_if_idx: DUT node.
+ :param sw_if_index: DUT node.
:type node: dict
- :type sw_if_idx: int
- :returns: Memif interface name.
+ :type sw_if_index: int
+ :returns: Memif interface name, or None if not found.
:rtype: str
"""
- with VatTerminal(node, json_param=False) as vat:
- vat.vat_terminal_exec_cmd_from_template('memif_dump.vat')
- memif_data = Memif.parse_memif_dump_data(vat.vat_stdout)
- for item in memif_data:
- if memif_data[item]['sw_if_index'] == str(sw_if_idx):
- return item
+ details = Memif._memif_details(node)
+
+ for memif in details:
+ if memif[u"sw_if_index"] == sw_if_index:
+ return memif[u"if_name"]
return None
@staticmethod
- def vpp_get_memif_interface_mac(node, sw_if_idx):
+ def vpp_get_memif_interface_mac(node, sw_if_index):
"""Get Memif interface MAC address from Memif interfaces dump.
:param node: DUT node.
- :param sw_if_idx: DUT node.
- :type node: dict
- :type sw_if_idx: int
- :returns: Memif interface MAC address.
- :rtype: str
- """
- with VatTerminal(node, json_param=False) as vat:
- vat.vat_terminal_exec_cmd_from_template('memif_dump.vat')
- memif_data = Memif.parse_memif_dump_data(vat.vat_stdout)
- for item in memif_data:
- if memif_data[item]['sw_if_index'] == str(sw_if_idx):
- return memif_data[item].get('mac', None)
-
- @staticmethod
- def vpp_get_memif_interface_socket(node, sw_if_idx):
- """Get Memif interface socket path from Memif interfaces dump.
-
- :param node: DUT node.
- :param sw_if_idx: DUT node.
+ :param sw_if_index: DUT node.
:type node: dict
- :type sw_if_idx: int
- :returns: Memif interface socket path.
+ :type sw_if_index: int
+ :returns: Memif interface MAC address, or None if not found.
:rtype: str
"""
- with VatTerminal(node, json_param=False) as vat:
- vat.vat_terminal_exec_cmd_from_template('memif_dump.vat')
- memif_data = Memif.parse_memif_dump_data(vat.vat_stdout)
- for item in memif_data:
- if memif_data[item]['sw_if_index'] == str(sw_if_idx):
- return memif_data[item].get('socket', None)
-
- @staticmethod
- def vpp_get_memif_interface_id(node, sw_if_idx):
- """Get Memif interface ID from Memif interfaces dump.
-
- :param node: DUT node.
- :param sw_if_idx: DUT node.
- :type node: dict
- :type sw_if_idx: int
- :returns: Memif interface ID.
- :rtype: int
- """
- with VatTerminal(node, json_param=False) as vat:
- vat.vat_terminal_exec_cmd_from_template('memif_dump.vat')
- memif_data = Memif.parse_memif_dump_data(vat.vat_stdout)
- for item in memif_data:
- if memif_data[item]['sw_if_index'] == str(sw_if_idx):
- return int(memif_data[item].get('id', None))
+ details = Memif._memif_details(node)
- @staticmethod
- def vpp_get_memif_interface_role(node, sw_if_idx):
- """Get Memif interface role from Memif interfaces dump.
-
- :param node: DUT node.
- :param sw_if_idx: DUT node.
- :type node: dict
- :type sw_if_idx: int
- :returns: Memif interface role.
- :rtype: int
- """
- with VatTerminal(node, json_param=False) as vat:
- vat.vat_terminal_exec_cmd_from_template('memif_dump.vat')
- memif_data = Memif.parse_memif_dump_data(vat.vat_stdout)
- for item in memif_data:
- if memif_data[item]['sw_if_index'] == str(sw_if_idx):
- return memif_data[item].get('role', None)
+ for memif in details:
+ if memif[u"sw_if_index"] == sw_if_index:
+ return memif[u"hw_addr"]
+ return None