CSIT-1337: Migrate L2Util library from VAT to PAPI 10/18110/30
authorJan Gelety <jgelety@cisco.com>
Wed, 6 Mar 2019 20:47:28 +0000 (21:47 +0100)
committerVratko Polak <vrpolak@cisco.com>
Mon, 1 Apr 2019 10:03:15 +0000 (10:03 +0000)
Change-Id: I22879c7bdd100d00216b9528663bf17406169826
Signed-off-by: Jan Gelety <jgelety@cisco.com>
resources/libraries/python/L2Util.py
resources/libraries/python/PapiExecutor.py
resources/libraries/robot/honeycomb/l2_fib.robot
resources/libraries/robot/honeycomb/papi.robot [new file with mode: 0644]
resources/tools/papi/vpp_papi_provider.py
tests/vpp/device/l2bd/eth2p-eth-l2bdbasemaclrn-dev.robot

index 52d1385..03ba564 100644 (file)
@@ -1,4 +1,4 @@
-# Copyright (c) 2018 Cisco and/or its affiliates.
+# 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:
 
 """L2 Utilities Library."""
 
+import binascii
 from textwrap import wrap
 
-from robot.api.deco import keyword
+from enum import IntEnum
 
+from resources.libraries.python.PapiExecutor import PapiExecutor
 from resources.libraries.python.topology import Topology
-from resources.libraries.python.VatExecutor import VatExecutor, VatTerminal
 from resources.libraries.python.ssh import exec_cmd_no_error
 
 
+class L2VtrOp(IntEnum):
+    """VLAN tag rewrite operation."""
+    L2_VTR_DISABLED = 0
+    L2_VTR_PUSH_1 = 1
+    L2_VTR_PUSH_2 = 2
+    L2_VTR_POP_1 = 3
+    L2_VTR_POP_2 = 4
+    L2_VTR_TRANSLATE_1_1 = 5
+    L2_VTR_TRANSLATE_1_2 = 6
+    L2_VTR_TRANSLATE_2_1 = 7
+    L2_VTR_TRANSLATE_2_2 = 8
+
+
 class L2Util(object):
     """Utilities for l2 configuration."""
 
@@ -50,117 +64,146 @@ class L2Util(object):
         return ':'.join(wrap("{:012x}".format(mac_int), width=2))
 
     @staticmethod
-    def vpp_add_l2fib_entry(node, mac, interface, bd_id):
-        """ Create a static L2FIB entry on a vpp node.
+    def mac_to_bin(mac_str):
+        """Convert MAC address from string format (e.g. 01:02:03:04:05:06) to
+        binary representation (\x01\x02\x03\x04\x05\x06).
+
+        :param mac_str: MAC address in string representation.
+        :type mac_str: str
+        :returns: Binary representation of MAC address.
+        :rtype: binary
+        """
+        return binascii.unhexlify(mac_str.replace(':', ''))
+
+    @staticmethod
+    def bin_to_mac(mac_bin):
+        """Convert MAC address from binary representation
+        (\x01\x02\x03\x04\x05\x06) to string format (e.g. 01:02:03:04:05:06).
+
+        :param mac_bin: MAC address in binary representation.
+        :type mac_bin: binary
+        :returns: String representation of MAC address.
+        :rtype: str
+        """
+        x = ':'.join(binascii.hexlify(mac_bin)[i:i + 2]
+                     for i in range(0, 12, 2))
+        return str(x.decode('ascii'))
+
+    @staticmethod
+    def vpp_add_l2fib_entry(node, mac, interface, bd_id, static_mac=1,
+                            filter_mac=0, bvi_mac=0):
+        """ Create a static L2FIB entry on a VPP node.
 
         :param node: Node to add L2FIB entry on.
-        :param mac: Destination mac address.
+        :param mac: Destination mac address in string format 01:02:03:04:05:06.
         :param interface: Interface name or sw_if_index.
-        :param bd_id: Bridge domain id.
+        :param bd_id: Bridge domain index.
+        :param static_mac: Set to 1 to create static MAC entry.
+            (Default value = 1)
+        :param filter_mac: Set to 1 to drop packet that's source or destination
+            MAC address contains defined MAC address. (Default value = 0)
+        :param bvi_mac: Set to 1 to create entry that points to BVI interface.
+            (Default value = 0)
         :type node: dict
         :type mac: str
         :type interface: str or int
-        :type bd_id: int
+        :type bd_id: int or str
+        :type static_mac: int or str
+        :type filter_mac: int or str
+        :type bvi_mac: int or str
         """
+
         if isinstance(interface, basestring):
             sw_if_index = Topology.get_interface_sw_index(node, interface)
         else:
             sw_if_index = interface
-        VatExecutor.cmd_from_template(node, "add_l2_fib_entry.vat",
-                                      mac=mac, bd=bd_id,
-                                      interface=sw_if_index)
+
+        cmd = 'l2fib_add_del'
+        err_msg = 'Failed to add L2FIB entry on host {host}'.format(
+            host=node['host'])
+        args = dict(mac=L2Util.mac_to_bin(mac),
+                    bd_id=int(bd_id),
+                    sw_if_index=sw_if_index,
+                    is_add=1,
+                    static_mac=int(static_mac),
+                    filter_mac=int(filter_mac),
+                    bvi_mac=int(bvi_mac))
+        with PapiExecutor(node) as papi_exec:
+            papi_exec.add(cmd, **args).get_replies(err_msg).\
+                verify_reply(err_msg=err_msg)
 
     @staticmethod
     def create_l2_bd(node, bd_id, flood=1, uu_flood=1, forward=1, learn=1,
                      arp_term=0):
-        """Create a l2 bridge domain on the chosen VPP node
-
-        Execute "bridge_domain_add_del bd_id {bd_id} flood {flood} uu-flood 1
-        forward {forward} learn {learn} arp-term {arp_term}" VAT command on
-        the node.
-
-        :param node: Node where we wish to crate the l2 bridge domain.
-        :param bd_id: Bridge domain index number.
-        :param flood: Enable flooding.
-        :param uu_flood: Enable uu_flood.
-        :param forward: Enable forwarding.
-        :param learn: Enable mac address learning to fib.
-        :param arp_term: Enable arp_termination.
+        """Create an L2 bridge domain on a VPP node.
+
+        :param node: Node where we wish to crate the L2 bridge domain.
+        :param bd_id: Bridge domain index.
+        :param flood: Enable/disable bcast/mcast flooding in the BD.
+            (Default value = 1)
+        :param uu_flood: Enable/disable unknown unicast flood in the BD.
+            (Default value = 1)
+        :param forward: Enable/disable forwarding on all interfaces in
+            the BD. (Default value = 1)
+        :param learn: Enable/disable MAC learning on all interfaces in the BD.
+            (Default value = 1)
+        :param arp_term: Enable/disable arp termination in the BD.
+            (Default value = 1)
         :type node: dict
-        :type bd_id: int
-        :type flood: bool
-        :type uu_flood: bool
-        :type forward: bool
-        :type learn: bool
-        :type arp_term: bool
+        :type bd_id: int or str
+        :type flood: int or str
+        :type uu_flood: int or str
+        :type forward: int or str
+        :type learn: int or str
+        :type arp_term: int or str
         """
-        VatExecutor.cmd_from_template(node, "l2_bd_create.vat",
-                                      bd_id=bd_id, flood=flood,
-                                      uu_flood=uu_flood, forward=forward,
-                                      learn=learn, arp_term=arp_term)
+
+        cmd = 'bridge_domain_add_del'
+        err_msg = 'Failed to create L2 bridge domain on host {host}'.format(
+            host=node['host'])
+        args = dict(bd_id=int(bd_id),
+                    flood=int(flood),
+                    uu_flood=int(uu_flood),
+                    forward=int(forward),
+                    learn=int(learn),
+                    arp_term=int(arp_term),
+                    is_add=1)
+        with PapiExecutor(node) as papi_exec:
+            papi_exec.add(cmd, **args).get_replies(err_msg).\
+                verify_reply(err_msg=err_msg)
 
     @staticmethod
-    def add_interface_to_l2_bd(node, interface, bd_id, shg=0):
-        """Add a interface to the l2 bridge domain.
+    def add_interface_to_l2_bd(node, interface, bd_id, shg=0, port_type=0):
+        """Add an interface to the L2 bridge domain.
 
         Get SW IF ID and add it to the bridge domain.
 
         :param node: Node where we want to execute the command that does this.
         :param interface: Interface name.
-        :param bd_id: Bridge domain index number to add Interface name to.
-        :param shg: Split horizon group.
+        :param bd_id: Bridge domain index.
+        :param shg: Split-horizon group index. (Default value = 0)
+        :param port_type: Port mode: 0 - normal, 1 - BVI, 2 - UU_FWD.
+            (Default value = 0)
         :type node: dict
         :type interface: str
-        :type bd_id: int
-        :type shg: int
+        :type bd_id: int or str
+        :type shg: int or str
+        :type port_type: int or str
         """
-        sw_if_index = Topology.get_interface_sw_index(node, interface)
-        L2Util.add_sw_if_index_to_l2_bd(node, sw_if_index, bd_id, shg)
-
-    @staticmethod
-    def add_sw_if_index_to_l2_bd(node, sw_if_index, bd_id, shg=0):
-        """Add interface with sw_if_index to l2 bridge domain.
-
-        Execute the "sw_interface_set_l2_bridge sw_if_index {sw_if_index}
-        bd_id {bd_id} shg {shg} enable" VAT command on the given node.
 
-        :param node: Node where we want to execute the command that does this.
-        :param sw_if_index: Interface index.
-        :param bd_id: Bridge domain index number to add SW IF ID to.
-        :param shg: Split horizon group.
-        :type node: dict
-        :type sw_if_index: int
-        :type bd_id: int
-        :type shg: int
-        """
-        VatExecutor.cmd_from_template(node, "l2_bd_add_sw_if_index.vat",
-                                      bd_id=bd_id, sw_if_index=sw_if_index,
-                                      shg=shg)
+        sw_if_index = Topology.get_interface_sw_index(node, interface)
 
-    @staticmethod
-    @keyword('Create dict used in bridge domain template file for node '
-             '"${node}" with links "${link_names}" and bd_id "${bd_id}"')
-    def create_bridge_domain_vat_dict(node, link_names, bd_id):
-        """Create dictionary that can be used in l2 bridge domain template.
-
-        The resulting dictionary looks like this:
-        'interface1': interface name of first interface
-        'interface2': interface name of second interface
-        'bd_id': bridge domain index
-
-        :param node: Node data dictionary.
-        :param link_names: List of names of links the bridge domain should be
-            connecting.
-        :param bd_id: Bridge domain index number.
-        :type node: dict
-        :type link_names: list
-        :returns: Dictionary used to generate l2 bridge domain VAT configuration
-            from template file.
-        :rtype: dict
-        """
-        bd_dict = Topology().get_interfaces_by_link_names(node, link_names)
-        bd_dict['bd_id'] = bd_id
-        return bd_dict
+        cmd = 'sw_interface_set_l2_bridge'
+        err_msg = 'Failed to add interface {ifc} to L2 bridge domain on host ' \
+                  '{host}'.format(ifc=interface, host=node['host'])
+        args = dict(rx_sw_if_index=sw_if_index,
+                    bd_id=int(bd_id),
+                    shg=int(shg),
+                    port_type=int(port_type),
+                    enable=1)
+        with PapiExecutor(node) as papi_exec:
+            papi_exec.add(cmd, **args).get_replies(err_msg).\
+                verify_reply(err_msg=err_msg)
 
     @staticmethod
     def vpp_add_l2_bridge_domain(node, bd_id, port_1, port_2, learn=True):
@@ -177,14 +220,39 @@ class L2Util(object):
         :type port_2: str
         :type learn: bool
         """
+
         sw_if_index1 = Topology.get_interface_sw_index(node, port_1)
         sw_if_index2 = Topology.get_interface_sw_index(node, port_2)
-        VatExecutor.cmd_from_template(node,
-                                      'l2_bridge_domain.vat',
-                                      sw_if_id1=sw_if_index1,
-                                      sw_if_id2=sw_if_index2,
-                                      bd_id=bd_id,
-                                      learn=int(learn))
+        learn_int = 1 if learn else 0
+
+        cmd1 = 'bridge_domain_add_del'
+        args1 = dict(bd_id=int(bd_id),
+                     flood=1,
+                     uu_flood=1,
+                     forward=1,
+                     learn=learn_int,
+                     arp_term=0,
+                     is_add=1)
+
+        cmd2 = 'sw_interface_set_l2_bridge'
+        args2 = dict(rx_sw_if_index=sw_if_index1,
+                     bd_id=int(bd_id),
+                     shg=0,
+                     port_type=0,
+                     enable=1)
+
+        args3 = dict(rx_sw_if_index=sw_if_index2,
+                     bd_id=int(bd_id),
+                     shg=0,
+                     port_type=0,
+                     enable=1)
+
+        err_msg = 'Failed to add L2 bridge domain with 2 interfaces on host' \
+                  ' {host}'.format(host=node['host'])
+
+        with PapiExecutor(node) as papi_exec:
+            papi_exec.add(cmd1, **args1).add(cmd2, **args2).add(cmd2, **args3).\
+                get_replies(err_msg).verify_replies(err_msg=err_msg)
 
     @staticmethod
     def vpp_setup_bidirectional_cross_connect(node, interface1, interface2):
@@ -208,13 +276,20 @@ class L2Util(object):
         else:
             sw_iface2 = interface2
 
-        with VatTerminal(node) as vat:
-            vat.vat_terminal_exec_cmd_from_template('l2_xconnect.vat',
-                                                    interface1=sw_iface1,
-                                                    interface2=sw_iface2)
-            vat.vat_terminal_exec_cmd_from_template('l2_xconnect.vat',
-                                                    interface1=sw_iface2,
-                                                    interface2=sw_iface1)
+        cmd = 'sw_interface_set_l2_xconnect'
+        args1 = dict(rx_sw_if_index=sw_iface1,
+                     tx_sw_if_index=sw_iface2,
+                     enable=1)
+        args2 = dict(rx_sw_if_index=sw_iface2,
+                     tx_sw_if_index=sw_iface1,
+                     enable=1)
+
+        err_msg = 'Failed to add L2 cross-connect between two interfaces on' \
+                  ' host {host}'.format(host=node['host'])
+
+        with PapiExecutor(node) as papi_exec:
+            papi_exec.add(cmd, **args1).add(cmd, **args2).get_replies(err_msg).\
+                verify_replies(err_msg=err_msg)
 
     @staticmethod
     def vpp_setup_bidirectional_l2_patch(node, interface1, interface2):
@@ -238,13 +313,20 @@ class L2Util(object):
         else:
             sw_iface2 = interface2
 
-        with VatTerminal(node) as vat:
-            vat.vat_terminal_exec_cmd_from_template('l2_patch.vat',
-                                                    interface1=sw_iface1,
-                                                    interface2=sw_iface2)
-            vat.vat_terminal_exec_cmd_from_template('l2_patch.vat',
-                                                    interface1=sw_iface2,
-                                                    interface2=sw_iface1)
+        cmd = 'l2_patch_add_del'
+        args1 = dict(rx_sw_if_index=sw_iface1,
+                     tx_sw_if_index=sw_iface2,
+                     is_add=1)
+        args2 = dict(rx_sw_if_index=sw_iface2,
+                     tx_sw_if_index=sw_iface1,
+                     is_add=1)
+
+        err_msg = 'Failed to add L2 patch between two interfaces on' \
+                  ' host {host}'.format(host=node['host'])
+
+        with PapiExecutor(node) as papi_exec:
+            papi_exec.add(cmd, **args1).add(cmd, **args2).get_replies(err_msg).\
+                verify_replies(err_msg=err_msg)
 
     @staticmethod
     def linux_add_bridge(node, br_name, if_1, if_2, set_up=True):
@@ -262,6 +344,7 @@ class L2Util(object):
         :type if_2: str
         :type set_up: bool
         """
+
         cmd = 'brctl addbr {0}'.format(br_name)
         exec_cmd_no_error(node, cmd, sudo=True)
         cmd = 'brctl addif {0} {1}'.format(br_name, if_1)
@@ -287,6 +370,7 @@ class L2Util(object):
         :type br_name: str
         :type set_down: bool
         """
+
         if set_down:
             cmd = 'ip link set dev {0} down'.format(br_name)
             exec_cmd_no_error(node, cmd, sudo=True)
@@ -294,7 +378,7 @@ class L2Util(object):
         exec_cmd_no_error(node, cmd, sudo=True)
 
     @staticmethod
-    def vpp_get_bridge_domain_data(node, bd_id=None):
+    def vpp_get_bridge_domain_data(node, bd_id=0xffffffff):
         """Get all bridge domain data from a VPP node. If a domain ID number is
         provided, return only data for the matching bridge domain.
 
@@ -306,18 +390,30 @@ class L2Util(object):
             or a single dictionary for the specified bridge domain.
         :rtype: list or dict
         """
-        with VatTerminal(node) as vat:
-            response = vat.vat_terminal_exec_cmd_from_template("l2_bd_dump.vat")
 
-        data = response[0]
+        # TODO: set following variable per whole suite when planned FIB API
+        # changes are merged in VPP
+        bitwise_non_zero = 0xffffffff   # equals to ~0 used in vpp code
+
+        cmd = 'bridge_domain_dump'
+        cmd_reply = 'bridge_domain_details'
+        args = dict(bd_id=bd_id if isinstance(bd_id, int) else int(bd_id))
+        err_msg = 'Failed to get L2FIB dump on host {host}'.format(
+            host=node['host'])
+        with PapiExecutor(node) as papi_exec:
+            papi_resp = papi_exec.add(cmd, **args).get_dump(err_msg)
 
-        if bd_id is not None:
-            for bridge_domain in data:
-                if bridge_domain["bd_id"] == bd_id:
+        data = papi_resp.reply[0]['api_reply']
 
-                    return bridge_domain
+        bd_data = list() if bd_id == bitwise_non_zero else dict()
+        for bridge_domain in data:
+            if bd_id == bitwise_non_zero:
+                bd_data.append(bridge_domain[cmd_reply])
+            else:
+                if bridge_domain[cmd_reply]['bd_id'] == bd_id:
+                    return bridge_domain[cmd_reply]
 
-        return data
+        return bd_data
 
     @staticmethod
     def l2_vlan_tag_rewrite(node, interface, tag_rewrite_method,
@@ -338,10 +434,12 @@ class L2Util(object):
         :type tag1_id: int
         :type tag2_id: int
         """
-        push_dot1q = 'push_dot1q 0' if not push_dot1q else ''
 
-        tag1_id = 'tag1 {0}'.format(tag1_id) if tag1_id else ''
-        tag2_id = 'tag2 {0}'.format(tag2_id) if tag2_id else ''
+        tag1_id = int(tag1_id) if tag1_id else 0
+        tag2_id = int(tag2_id) if tag2_id else 0
+
+        vtr_oper = getattr(L2VtrOp, 'L2_VTR_{}'.format(
+            tag_rewrite_method.replace('-', '_').upper()))
 
         if isinstance(interface, basestring):
             iface_key = Topology.get_interface_by_name(node, interface)
@@ -349,73 +447,51 @@ class L2Util(object):
         else:
             sw_if_index = interface
 
-        with VatTerminal(node) as vat:
-            vat.vat_terminal_exec_cmd_from_template("l2_vlan_tag_rewrite.vat",
-                                                    sw_if_index=sw_if_index,
-                                                    tag_rewrite_method=
-                                                    tag_rewrite_method,
-                                                    push_dot1q=push_dot1q,
-                                                    tag1_optional=tag1_id,
-                                                    tag2_optional=tag2_id)
-
-    @staticmethod
-    def delete_bridge_domain_vat(node, bd_id):
-        """Delete the specified bridge domain from the node.
-
-        :param node: VPP node to delete a bridge domain from.
-        :param bd_id: Bridge domain ID.
-        :type node: dict
-        :type bd_id: int
-        """
-
-        with VatTerminal(node) as vat:
-            vat.vat_terminal_exec_cmd_from_template(
-                "l2_bridge_domain_delete.vat", bd_id=bd_id)
+        cmd = 'l2_interface_vlan_tag_rewrite'
+        args = dict(sw_if_index=sw_if_index,
+                    vtr_op=int(vtr_oper),
+                    push_dot1q=int(push_dot1q),
+                    tag1=tag1_id,
+                    tag2=tag2_id)
+        err_msg = 'Failed to set VLAN TAG rewrite on host {host}'.format(
+            host=node['host'])
+        with PapiExecutor(node) as papi_exec:
+            papi_exec.add(cmd, **args).get_replies(err_msg).\
+                verify_reply(err_msg=err_msg)
 
     @staticmethod
-    def delete_l2_fib_entry(node, bd_id, mac):
-        """Delete the specified L2 FIB entry.
+    def get_l2_fib_table(node, bd_id):
+        """Retrieves the L2 FIB table.
 
         :param node: VPP node.
-        :param bd_id: Bridge domain ID.
-        :param mac: MAC address used as the key in L2 FIB entry.
+        :param bd_id: Index of the bridge domain.
         :type node: dict
         :type bd_id: int
-        :type mac: str
-        """
-
-        with VatTerminal(node) as vat:
-            vat.vat_terminal_exec_cmd_from_template("l2_fib_entry_delete.vat",
-                                                    mac=mac,
-                                                    bd_id=bd_id)
-
-    @staticmethod
-    def get_l2_fib_table_vat(node, bd_index):
-        """Retrieves the L2 FIB table using VAT.
-
-        :param node: VPP node.
-        :param bd_index: Index of the bridge domain.
-        :type node: dict
-        :type bd_index: int
         :returns: L2 FIB table.
         :rtype: list
         """
 
-        bd_data = L2Util.vpp_get_bridge_domain_data(node)
-        bd_id = bd_data[bd_index-1]["bd_id"]
+        cmd = 'l2_fib_table_dump'
+        cmd_reply = 'l2_fib_table_details'
+        args = dict(bd_id=int(bd_id))
+        err_msg = 'Failed to get L2FIB dump on host {host}'.format(
+            host=node['host'])
+        with PapiExecutor(node) as papi_exec:
+            papi_resp = papi_exec.add(cmd, **args).get_dump(err_msg)
 
-        try:
-            with VatTerminal(node) as vat:
-                table = vat.vat_terminal_exec_cmd_from_template(
-                    "l2_fib_table_dump.vat", bd_id=bd_id)
+        data = papi_resp.reply[0]['api_reply']
 
-            return table[0]
-        except ValueError:
-            return []
+        fib_data = list()
+        for fib in data:
+            fib_item = fib[cmd_reply]
+            fib_item['mac'] = L2Util.bin_to_mac(fib_item['mac'])
+            fib_data.append(fib_item)
+
+        return fib_data
 
     @staticmethod
-    def get_l2_fib_entry_vat(node, bd_index, mac):
-        """Retrieves the L2 FIB entry specified by MAC address using VAT.
+    def get_l2_fib_entry_by_mac(node, bd_index, mac):
+        """Retrieves the L2 FIB entry specified by MAC address using PAPI.
 
         :param node: VPP node.
         :param bd_index: Index of the bridge domain.
@@ -427,8 +503,12 @@ class L2Util(object):
         :rtype: dict
         """
 
-        table = L2Util.get_l2_fib_table_vat(node, bd_index)
+        bd_data = L2Util.vpp_get_bridge_domain_data(node)
+        bd_id = bd_data[bd_index-1]['bd_id']
+
+        table = L2Util.get_l2_fib_table(node, bd_id)
+
         for entry in table:
-            if entry["mac"] == mac:
+            if entry['mac'] == mac:
                 return entry
         return {}
index f6df200..a026199 100644 (file)
@@ -457,7 +457,8 @@ class PapiExecutor(object):
         reply_value = dict()
         for reply_key, reply_v in api_r.iteritems():
             for a_k, a_v in reply_v.iteritems():
-                reply_value[a_k] = a_v
+                reply_value[a_k] = binascii.unhexlify(a_v) \
+                    if isinstance(a_v, unicode) else a_v
             reply_dict[reply_key] = reply_value
         return reply_dict
 
@@ -581,6 +582,9 @@ class PapiExecutor(object):
                         raise
                 papi_reply.append(api_reply_processed)
 
+        # Log processed papi reply to be able to check API replies changes
+        logger.debug("Processed PAPI reply: {reply}".format(reply=papi_reply))
+
         return PapiResponse(papi_reply=papi_reply,
                             stdout=stdout,
                             stderr=stderr,
index f90cbff..6889fb2 100644 (file)
@@ -12,9 +12,9 @@
 # limitations under the License.
 
 *** Settings ***
-| Library | resources.libraries.python.L2Util
 | Library | resources.libraries.python.honeycomb.HcAPIKwBridgeDomain.BridgeDomainKeywords
 | Library | resources.libraries.python.honeycomb.HcAPIKwInterfaces.InterfaceKeywords
+| Resource | resources/libraries/robot/honeycomb/papi.robot
 
 *** Keywords ***
 | Honeycomb adds L2 FIB entry to bridge domain
 
 | L2 FIB entry from VAT should be
 | | [Documentation] | Retrieves the operational data about the specified L2 \
-| | ... | FIB entry using VAT and checks if it is as expected.
+| | ... | FIB entry using Python API and checks if it is as expected.
 | | ...
 | | ... | *Arguments:*
 | | ... | - node - Information about a DUT node. Type: dictionary
 | | ...
 | | [Arguments] | ${node} | ${bd_index} | ${l2_fib_ref_data}
 | | ...
-| | ${l2_fib_data}= | Get L2 FIB entry VAT | ${node} | ${bd_index}
+| | ${l2_fib_data}= | Get L2 FIB entry PAPI | ${node} | ${bd_index}
 | | ... | ${l2_fib_ref_data['mac']}
 | | Compare Data Structures | ${l2_fib_data} | ${l2_fib_ref_data}
 
 | L2 FIB Table from VAT should be empty
 | | [Documentation] | Check if the L2 FIB table in the specified bridge domain \
-| | ... | is empty. VAT is used to get operational data.
+| | ... | is empty. Python API is used to get operational data.
 | | ...
 | | ... | *Arguments:*
 | | ... | - node - Information about a DUT node. Type: dictionary
 | | ...
 | | [Arguments] | ${node} | ${bd_index}
 | | ...
-| | ${l2_fib_data}= | Get L2 FIB table VAT | ${node} | ${bd_index}
+| | ${l2_fib_data}= | Get L2 FIB table PAPI | ${node} | ${bd_index}
 | | Should be empty | ${l2_fib_data}
diff --git a/resources/libraries/robot/honeycomb/papi.robot b/resources/libraries/robot/honeycomb/papi.robot
new file mode 100644 (file)
index 0000000..33797f1
--- /dev/null
@@ -0,0 +1,53 @@
+# 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.
+
+*** Settings ***
+| Library | resources.libraries.python.L2Util
+
+*** Keywords ***
+| Get L2 FIB entry PAPI
+| | [Documentation] | Retrieve the operational data about the specified L2 \
+| | ... | FIB entry using Python API.
+| | ...
+| | ... | *Arguments:*
+| | ... | - node - Information about a DUT node. Type: dictionary
+| | ... | - bd_index - Index of the bridge domain. Type: integer
+| | ... | - mac - MAC address. Type: string
+| | ...
+| | ... | *Example:*
+| | ... | \| Get L2 FIB entry PAPI \
+| | ... | \| ${nodes['DUT1']} \| test_bd \| 00:fe:c8:e5:46:d1 \|
+| | ...
+| | [Arguments] | ${node} | ${bd_index} | ${mac}
+| | ...
+| | [Return] | ${l2_fib_data}
+| | ...
+| | ${l2_fib_data}= | Get L2 FIB entry by MAC | ${node} | ${bd_index}
+| | ... | ${mac}
+
+| Get L2 FIB table PAPI
+| | [Documentation] | Retrieve L2 FIB table data of the specified bridge \
+| | ... | domain using Python API.
+| | ...
+| | ... | *Arguments:*
+| | ... | - node - Information about a DUT node. Type: dictionary
+| | ... | - bd_index - Index of the bridge domain. Type: integer
+| | ...
+| | ... | *Example:*
+| | ... | \| Get L2 FIB table PAPI \| ${nodes['DUT1']} \| test_bd \|
+| | ...
+| | [Arguments] | ${node} | ${bd_index}
+| | ...
+| | [Return] | ${l2_fib_data}
+| | ...
+| | ${l2_fib_data}= | Get L2 FIB table | ${node} | ${bd_index}
index 299cd2c..cec8197 100755 (executable)
@@ -96,7 +96,20 @@ def _convert_reply(api_r):
     reply_value = dict()
     for item in dir(api_r):
         if not item.startswith('_') and item not in unwanted_fields:
-            reply_value[item] = getattr(api_r, item)
+            attr_value = getattr(api_r, item)
+            if isinstance(attr_value, list) or isinstance(attr_value, dict):
+                value = attr_value
+            elif hasattr(attr_value, '__int__'):
+                value = int(attr_value)
+            elif hasattr(attr_value, '__str__'):
+                value = binascii.hexlify(str(attr_value))
+            # Next handles parameters not supporting preferred integer or string
+            # representation to get it logged
+            elif hasattr(attr_value, '__repr__'):
+                value = repr(attr_value)
+            else:
+                value = attr_value
+            reply_value[item] = value
     reply_dict[reply_key] = reply_value
     return reply_dict
 
@@ -182,7 +195,11 @@ def process_stats(args):
         data = stats.dump(directory)
         reply.append(data)
 
-    return json.dumps(reply)
+    try:
+        return json.dumps(reply)
+    except UnicodeDecodeError as err:
+        raise RuntimeError('PAPI reply {reply} error:\n{exc}'.format(
+            reply=reply, exc=repr(err)))
 
 
 def main():
index 2565320..24c46c5 100644 (file)
@@ -12,6 +12,7 @@
 # limitations under the License.
 
 *** Settings ***
+| Library | resources.libraries.python.L2Util
 | Resource | resources/libraries/robot/l2/l2_bridge_domain.robot
 | Resource | resources/libraries/robot/l2/l2_traffic.robot
 | Resource | resources/libraries/robot/shared/default.robot
@@ -64,6 +65,9 @@
 | | When All Vpp Interfaces Ready Wait | ${nodes}
 | | Then Send ICMPv4 bidirectionally and verify received packets | ${tg_node}
 | | ... | ${tg_to_dut_if1} | ${tg_to_dut_if2}
+| | ...
+| | And VPP get bridge domain data | ${nodes['DUT1']}
+| | And Get L2 Fib Table | ${nodes['DUT1']} | ${bd_id}
 
 | tc02-eth2p-ethicmpv6-l2bdbase-device
 | | [Documentation]
@@ -85,3 +89,4 @@
 | | When All Vpp Interfaces Ready Wait | ${nodes}
 | | Then Send ICMPv6 bidirectionally and verify received packets
 | | ... | ${tg_node} | ${tg_to_dut_if1} | ${tg_to_dut_if2}
+| | VPP get bridge domain data | ${nodes['DUT1']} | bd_id=${bd_id}

©2016 FD.io a Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation. Linux is a registered trademark of Linus Torvalds.
Please see our privacy policy and terms of use.