Trending: Add mellanox - csit - Integration tests

Integration tests
Grokmirror user
about summary refs log tree commit diff stats
diff options
author	Tibor Frank <tifrank@cisco.com>	2020-01-31 10:23:23 +0100
committer	Tibor Frank <tifrank@cisco.com>	2020-01-31 10:23:23 +0100
commit	e1ee0480969dbb35695228fd64f8dfab1a1c07a4 (patch)
tree	0396eaebf0ddf1c0734420ec95ab2097cd5e9333 /docs/cpta/trending/dpdk.rst
parent	d79b753c1fde3cd831f60ac5cc0034f613c44b43 (diff)
Trending: Add mellanox
Change-Id: Id6f621ee4d604da96cf65c7f1cb889ec055df9b1 Signed-off-by: Tibor Frank <tifrank@cisco.com>
Diffstat (limited to 'docs/cpta/trending/dpdk.rst')
-rw-r--r--
docs/cpta/trending/dpdk.rst
1 files changed, 2 insertions, 0 deletions
href='#n178'>178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268
# Copyright (c) 2019 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:
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Memif interface library."""

from resources.libraries.python.ssh import SSH
from resources.libraries.python.VatExecutor import VatExecutor, VatTerminal
from resources.libraries.python.topology import NodeType, Topology


class Memif(object):
    """Memif interface class."""

    def __init__(self):
        pass

    @staticmethod
    def create_memif_interface(node, filename, mid, sid, rxq=1, txq=1,
                               role='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; 0 means do not set.
        :param txq: Number of TX queues; 0 means do not set.
        :param role: Memif interface role [master|slave]. Default is master.
        :type node: dict
        :type filename: str
        :type mid: str
        :type sid: str
        :type rxq: int
        :type txq: int
        :type role: str
        :returns: SW interface index.
        :rtype: int
        :raises ValueError: If command 'create memif' fails.
        """

        rx_q = 'rx-queues {rxq}'.format(rxq=rxq) if rxq else ''
        tx_q = 'tx-queues {txq}'.format(txq=txq) if txq else ''

        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, rx_q=rx_q, tx_q=tx_q,
                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']))

    @staticmethod
    def dump_memif(node):
        """Dump Memif data for the given node.

        :param node: Given node to show Memif data on.
        :type node: dict
        """
        vat = VatExecutor()
        vat.execute_script("memif_dump.vat", node, json_out=False)

    @staticmethod
    def show_memif(node):
        """Show Memif data for the given 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 show_memif_on_all_duts(nodes):
        """Show Memif data on all DUTs.

        :param nodes: Topology nodes.
        :type nodes: dict
        """
        for node in nodes.values():
            if node['type'] == NodeType.DUT:
                Memif.show_memif(node)

    @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))

    @staticmethod
    def parse_memif_dump_data(memif_data):
        """Convert Memif data to dictionary.

        :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.
        """
        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 not line or line.startswith('Sending'):
                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

    @staticmethod
    def vpp_get_memif_interface_name(node, sw_if_idx):
        """Get Memif interface name 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 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
        return None

    @staticmethod
    def vpp_get_memif_interface_mac(node, sw_if_idx):
        """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, 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('mac', None)
        return 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.
        :type node: dict
        :type sw_if_idx: int
        :returns: Memif interface socket path, 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)
        return 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, or None if not found.
        :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))
        return None

    @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, or None if not found.
        :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)
        return None

context:
space:
mode: