CSIT-427: Honeycomb ietf-ACL tests - L2

[csit.git] / resources / libraries / python / honeycomb / HcAPIKwInterfaces.py

diff --git a/resources/libraries/python/honeycomb/HcAPIKwInterfaces.py b/resources/libraries/python/honeycomb/HcAPIKwInterfaces.py
index c143b06..83267b5 100644 (file)
--- a/resources/libraries/python/honeycomb/HcAPIKwInterfaces.py
+++ b/resources/libraries/python/honeycomb/HcAPIKwInterfaces.py
@@ -16,7 +16,7 @@
 The keywords make possible to put and get configuration data and to get
 operational data.
 """
 The keywords make possible to put and get configuration data and to get
 operational data.
 """

-
+from resources.libraries.python.topology import Topology

 from resources.libraries.python.HTTPRequest import HTTPCodes
 from resources.libraries.python.honeycomb.HoneycombSetup import HoneycombError
 from resources.libraries.python.honeycomb.HoneycombUtil \
 from resources.libraries.python.HTTPRequest import HTTPCodes
 from resources.libraries.python.honeycomb.HoneycombSetup import HoneycombError
 from resources.libraries.python.honeycomb.HoneycombUtil \


@@ -35,7 +35,8 @@ class InterfaceKeywords(object):
     """
 
     INTF_PARAMS = ("name", "description", "type", "enabled",
     """
 
     INTF_PARAMS = ("name", "description", "type", "enabled",

-                   "link-up-down-trap-enable", "v3po:l2")
+                   "link-up-down-trap-enable", "v3po:l2", "v3po:vxlan-gpe",
+                   "vpp-vlan:sub-interfaces")

     IPV4_PARAMS = ("enabled", "forwarding", "mtu")
     IPV6_PARAMS = ("enabled", "forwarding", "mtu", "dup-addr-detect-transmits")
     IPV6_AUTOCONF_PARAMS = ("create-global-addresses",
     IPV4_PARAMS = ("enabled", "forwarding", "mtu")
     IPV6_PARAMS = ("enabled", "forwarding", "mtu", "dup-addr-detect-transmits")
     IPV6_AUTOCONF_PARAMS = ("create-global-addresses",


@@ -47,22 +48,24 @@ class InterfaceKeywords(object):
     VXLAN_PARAMS = ("src", "dst", "vni", "encap-vrf-id")
     L2_PARAMS = ("bridge-domain", "split-horizon-group",
                  "bridged-virtual-interface")
     VXLAN_PARAMS = ("src", "dst", "vni", "encap-vrf-id")
     L2_PARAMS = ("bridge-domain", "split-horizon-group",
                  "bridged-virtual-interface")

-    L2_REWRITE_TAG_PARAMS = ("rewrite-operation",
-                             "first-pushed",
-                             "tag1",
-                             "tag2")

     TAP_PARAMS = ("tap-name", "mac", "device-instance")
     VHOST_USER_PARAMS = ("socket", "role")
     TAP_PARAMS = ("tap-name", "mac", "device-instance")
     VHOST_USER_PARAMS = ("socket", "role")

-    SUB_INTF_PARAMS = ("super-interface",
-                       "identifier",
-                       "vlan-type",
-                       "number-of-tags",
-                       "outer-id",
-                       "inner-id",
-                       "match-any-outer-id",
-                       "match-any-inner-id",
-                       "exact-match",
-                       "default-subif")
+    SUB_IF_PARAMS = ("identifier",
+                     "vlan-type",
+                     "enabled")
+    SUB_IF_MATCH = ("default",
+                    "untagged",
+                    "vlan-tagged",
+                    "vlan-tagged-exact-match")
+    BD_PARAMS = ("bridge-domain",
+                 "split-horizon-group",
+                 "bridged-virtual-interface")
+    VXLAN_GPE_PARAMS = ("local",
+                        "remote",
+                        "vni",
+                        "next-protocol",
+                        "encap-vrf-id",
+                        "decap-vrf-id")

 
     def __init__(self):
         pass
 
     def __init__(self):
         pass


@@ -219,7 +222,7 @@ class InterfaceKeywords(object):
         depending on the parameter "state".
 
         :param node: Honeycomb node.
         depending on the parameter "state".
 
         :param node: Honeycomb node.

-        :param interface: The name of interface.
+        :param interface: Interface name, key, link name or sw_if_index.

         :param state: The requested state, only "up" and "down" are valid
         values.
         :type node: dict
         :param state: The requested state, only "up" and "down" are valid
         values.
         :type node: dict


@@ -234,9 +237,29 @@ class InterfaceKeywords(object):
         intf_state = {"up": "true",
                       "down": "false"}
 
         intf_state = {"up": "true",
                       "down": "false"}
 

-        path = ("interfaces", ("interface", "name", str(interface)), "enabled")
-        return InterfaceKeywords._set_interface_properties(
-            node, interface, path, intf_state[state.lower()])
+        interface = Topology.convert_interface_reference(
+            node, interface, "name")
+
+        intf = interface.replace("/", "%2F")
+        path = "/interface/{0}".format(intf)
+
+        status_code, resp = HcUtil.\
+            get_honeycomb_data(node, "config_vpp_interfaces", path)
+        if status_code != HTTPCodes.OK:
+            raise HoneycombError(
+                "Not possible to get configuration information about the "
+                "interfaces. Status code: {0}.".format(status_code))
+
+        resp["interface"][0]["enabled"] = intf_state[state.lower()]
+
+        status_code, resp = HcUtil. \
+            put_honeycomb_data(node, "config_vpp_interfaces", resp, path,
+                               data_representation=DataRepresentation.JSON)
+        if status_code != HTTPCodes.OK:
+            raise HoneycombError(
+                "The configuration of interface '{0}' was not successful. "
+                "Status code: {1}.".format(interface, status_code))
+        return resp

 
     @staticmethod
     def set_interface_up(node, interface):
 
     @staticmethod
     def set_interface_up(node, interface):


@@ -272,7 +295,7 @@ class InterfaceKeywords(object):
         """Add a new bridge domain to an interface and set its parameters.
 
         :param node: Honeycomb node.
         """Add a new bridge domain to an interface and set its parameters.
 
         :param node: Honeycomb node.

-        :param interface: The name of interface.
+        :param interface: Interface name, key, link name or sw_if_index.

         :param bd_name: Bridge domain name.
         :param split_horizon_group: Split-horizon group name.
         :param bvi: The bridged virtual interface.
         :param bd_name: Bridge domain name.
         :param split_horizon_group: Split-horizon group name.
         :param bvi: The bridged virtual interface.


@@ -286,6 +309,9 @@ class InterfaceKeywords(object):
         :raises HoneycombError: If the interface is not present on the node.
         """
 
         :raises HoneycombError: If the interface is not present on the node.
         """
 

+        interface = Topology.convert_interface_reference(
+            node, interface, "name")
+

         v3po_l2 = {"bridge-domain": str(bd_name)}
         if split_horizon_group:
             v3po_l2["split-horizon-group"] = str(split_horizon_group)
         v3po_l2 = {"bridge-domain": str(bd_name)}
         if split_horizon_group:
             v3po_l2["split-horizon-group"] = str(split_horizon_group)


@@ -297,6 +323,56 @@ class InterfaceKeywords(object):
         return InterfaceKeywords._set_interface_properties(
             node, interface, path, v3po_l2)
 
         return InterfaceKeywords._set_interface_properties(
             node, interface, path, v3po_l2)
 

+    @staticmethod
+    def remove_bridge_domain_from_interface(node, interface):
+        """Remove bridge domain assignment from interface.
+
+        :param node: Honeycomb node.
+        :param interface: Interface name, key, link name or sw_if_index.
+        :type node: dict
+        :type interface: str or int
+
+        :raises HoneycombError: If the operation fails.
+        """
+
+        interface = Topology.convert_interface_reference(
+            node, interface, "name")
+
+        intf = interface.replace("/", "%2F")
+
+        path = "/interface/{0}/v3po:l2".format(intf)
+
+        status_code, _ = HcUtil.delete_honeycomb_data(
+            node, "config_vpp_interfaces", path)
+
+        if status_code != HTTPCodes.OK:
+            raise HoneycombError(
+                "Could not remove bridge domain assignment from interface "
+                "'{0}'. Status code: {1}.".format(interface, status_code))
+
+    @staticmethod
+    def get_bd_oper_data_from_interface(node, interface):
+        """Returns operational data about bridge domain settings in the
+        interface.
+
+        :param node: Honeycomb node.
+        :param interface: The name of interface.
+        :type node: dict
+        :type interface: str
+        :return: Operational data about bridge domain settings in the
+        interface.
+        :rtype: dict
+        """
+
+        if_data = InterfaceKeywords.get_interface_oper_data(node, interface)
+
+        if if_data:
+            try:
+                return if_data["v3po:l2"]
+            except KeyError:
+                return {}
+        return {}
+

     @staticmethod
     def configure_interface_base(node, interface, param, value):
         """Configure the base parameters of interface.
     @staticmethod
     def configure_interface_base(node, interface, param, value):
         """Configure the base parameters of interface.


@@ -324,7 +400,7 @@ class InterfaceKeywords(object):
 
     @staticmethod
     def configure_interface_ipv4(node, interface, param, value):
 
     @staticmethod
     def configure_interface_ipv4(node, interface, param, value):

-        """Configure IPv4 parameters of interface
+        """Configure IPv4 parameters of interface.

 
         :param node: Honeycomb node.
         :param interface: The name of interface.
 
         :param node: Honeycomb node.
         :param interface: The name of interface.


@@ -340,6 +416,9 @@ class InterfaceKeywords(object):
         :raises HoneycombError: If the parameter is not valid.
         """
 
         :raises HoneycombError: If the parameter is not valid.
         """
 

+        interface = Topology.convert_interface_reference(
+            node, interface, "name")
+

         if param not in InterfaceKeywords.IPV4_PARAMS:
             raise HoneycombError("The parameter {0} is invalid.".format(param))
 
         if param not in InterfaceKeywords.IPV4_PARAMS:
             raise HoneycombError("The parameter {0} is invalid.".format(param))
 


@@ -364,8 +443,12 @@ class InterfaceKeywords(object):
         :type network: str or int
         :return: Content of response.
         :rtype: bytearray
         :type network: str or int
         :return: Content of response.
         :rtype: bytearray

+        :raises HoneycombError: If the provided netmask or prefix is not valid.

         """
 
         """
 

+        interface = Topology.convert_interface_reference(
+            node, interface, "name")
+

         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4")
         if isinstance(network, basestring):
             address = {"address": [{"ip": ip_addr, "netmask": network}, ]}
         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4")
         if isinstance(network, basestring):
             address = {"address": [{"ip": ip_addr, "netmask": network}, ]}


@@ -391,8 +474,12 @@ class InterfaceKeywords(object):
         :type network: str or int
         :return: Content of response.
         :rtype: bytearray
         :type network: str or int
         :return: Content of response.
         :rtype: bytearray

+        :raises HoneycombError: If the provided netmask or prefix is not valid.

         """
 
         """
 

+        interface = Topology.convert_interface_reference(
+            node, interface, "name")
+

         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4",
                 "address")
         if isinstance(network, basestring):
         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4",
                 "address")
         if isinstance(network, basestring):


@@ -422,30 +509,6 @@ class InterfaceKeywords(object):
         return InterfaceKeywords._set_interface_properties(
             node, interface, path, None)
 
         return InterfaceKeywords._set_interface_properties(
             node, interface, path, None)
 

-    @staticmethod
-    def add_first_ipv4_neighbor(node, interface, ip_addr, link_layer_address):
-        """Add the first IPv4 neighbour.
-
-        If there are any other neighbours configured, they will be removed.
-
-        :param node: Honeycomb node.
-        :param interface: The name of interface.
-        :param ip_addr: IPv4 address of neighbour to be set.
-        :param link_layer_address: Link layer address.
-        :type node: dict
-        :type interface: str
-        :type ip_addr: str
-        :type link_layer_address: str
-        :return: Content of response.
-        :rtype: bytearray
-        """
-
-        path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4")
-        neighbor = {"neighbor": [{"ip": ip_addr,
-                                  "link-layer-address": link_layer_address}, ]}
-        return InterfaceKeywords._set_interface_properties(
-            node, interface, path, neighbor)
-

     @staticmethod
     def add_ipv4_neighbor(node, interface, ip_addr, link_layer_address):
         """Add the IPv4 neighbour.
     @staticmethod
     def add_ipv4_neighbor(node, interface, ip_addr, link_layer_address):
         """Add the IPv4 neighbour.


@@ -577,30 +640,6 @@ class InterfaceKeywords(object):
         return InterfaceKeywords._set_interface_properties(
             node, interface, path, None)
 
         return InterfaceKeywords._set_interface_properties(
             node, interface, path, None)
 

-    @staticmethod
-    def add_first_ipv6_neighbor(node, interface, ip_addr, link_layer_address):
-        """Add the first IPv6 neighbour.
-
-        If there are any other neighbours configured, they will be removed.
-
-        :param node: Honeycomb node.
-        :param interface: The name of interface.
-        :param ip_addr: IPv6 address of neighbour to be set.
-        :param link_layer_address: Link layer address.
-        :type node: dict
-        :type interface: str
-        :type ip_addr: str
-        :type link_layer_address: str
-        :return: Content of response.
-        :rtype: bytearray
-        """
-
-        path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6")
-        neighbor = {"neighbor": [{"ip": ip_addr,
-                                  "link-layer-address": link_layer_address}, ]}
-        return InterfaceKeywords._set_interface_properties(
-            node, interface, path, neighbor)
-

     @staticmethod
     def add_ipv6_neighbor(node, interface, ip_addr, link_layer_address):
         """Add the IPv6 neighbour.
     @staticmethod
     def add_ipv6_neighbor(node, interface, ip_addr, link_layer_address):
         """Add the IPv6 neighbour.


@@ -948,102 +987,534 @@ class InterfaceKeywords(object):
             node, interface, path, new_vhost_structure)
 
     @staticmethod
             node, interface, path, new_vhost_structure)
 
     @staticmethod

-    def create_sub_interface(node, super_interface, identifier, **kwargs):
+    def create_sub_interface(node, super_interface, match, tags=None, **kwargs):

         """Create a new sub-interface.
 
         :param node: Honeycomb node.
         """Create a new sub-interface.
 
         :param node: Honeycomb node.

-        :param super_interface: The name of super interface.
-        :param identifier: sub-interface identifier.
+        :param super_interface: Super interface.
+        :param match: Match type. The valid values are defined in
+        InterfaceKeywords.SUB_IF_MATCH.
+        :param tags: List of tags.

         :param kwargs: Parameters and their values. The accepted parameters are
         :param kwargs: Parameters and their values. The accepted parameters are

-        defined in InterfaceKeywords.SUB_INTF_PARAMS.
+        defined in InterfaceKeywords.SUB_IF_PARAMS.

         :type node: dict
         :type super_interface: str
         :type node: dict
         :type super_interface: str

-        :type identifier: int
+        :type match: str
+        :type tags: list

         :type kwargs: dict
         :return: Content of response.
         :rtype: bytearray
         :raises HoneycombError: If the parameter is not valid.
         :type kwargs: dict
         :return: Content of response.
         :rtype: bytearray
         :raises HoneycombError: If the parameter is not valid.

+        :raises KeyError: If the parameter 'match' is invalid.

         """
 
         """
 

-        # These parameters are empty types (in JSON represented as empty
-        # dictionary) but ODL internally represents them as Booleans. If the
-        # value is an empty dictionary, it is True, if the parameter is
-        # missing, it is False.
-        empty_types = ("match-any-outer-id",
-                       "match-any-inner-id",
-                       "exact-match",
-                       "default-subif")
+        match_type = {
+            "default":
+                {"default": {}},
+            "untagged":
+                {"untagged": {}},
+            "vlan-tagged":
+                {"vlan-tagged": {"match-exact-tags": "false"}},
+            "vlan-tagged-exact-match":
+                {"vlan-tagged": {"match-exact-tags": "true"}}
+        }

 
 

-        sub_interface_name = "{0}.{1}".format(super_interface, str(identifier))

         new_sub_interface = {
         new_sub_interface = {

-            "name": sub_interface_name,
-            "type": "v3po:sub-interface",
-            "enabled": "false",
-            "sub-interface": {
-                "super-interface": super_interface,
-                "identifier": identifier
-            }
+            "tags": {
+                "tag": []
+            },

         }
         }

+

         for param, value in kwargs.items():
         for param, value in kwargs.items():

-            if param in InterfaceKeywords.INTF_PARAMS:
+            if param in InterfaceKeywords.SUB_IF_PARAMS:

                 new_sub_interface[param] = value
                 new_sub_interface[param] = value

-            elif param in InterfaceKeywords.SUB_INTF_PARAMS:
-                if param in empty_types:
-                    if value:
-                        new_sub_interface["sub-interface"][param] = dict()
-                else:
-                    new_sub_interface["sub-interface"][param] = value

             else:
                 raise HoneycombError("The parameter {0} is invalid.".
                                      format(param))
             else:
                 raise HoneycombError("The parameter {0} is invalid.".
                                      format(param))

-
-        path = ("interfaces", "interface")
+        try:
+            new_sub_interface["match"] = match_type[match]
+        except KeyError:
+            raise HoneycombError("The value '{0}' of parameter 'match' is "
+                                 "invalid.".format(match))
+
+        if tags:
+            new_sub_interface["tags"]["tag"].extend(tags)
+
+        path = ("interfaces",
+                ("interface", "name", super_interface),
+                "vpp-vlan:sub-interfaces",
+                "sub-interface")

         new_sub_interface_structure = [new_sub_interface, ]
         return InterfaceKeywords._set_interface_properties(
         new_sub_interface_structure = [new_sub_interface, ]
         return InterfaceKeywords._set_interface_properties(

-            node, sub_interface_name, path, new_sub_interface_structure)
+            node, super_interface, path, new_sub_interface_structure)
+
+    @staticmethod
+    def get_sub_interface_oper_data(node, super_interface, identifier):
+        """Retrieves sub-interface operational data using Honeycomb API.
+
+        :param node: Honeycomb node.
+        :param super_interface: Super interface.
+        :param identifier: The ID of sub-interface.
+        :type node: dict
+        :type super_interface: str
+        :type identifier: int
+        :return: Sub-interface operational data.
+        :rtype: dict
+        :raises HoneycombError: If there is no sub-interface with the given ID.
+        """
+
+        if_data = InterfaceKeywords.get_interface_oper_data(node,
+                                                            super_interface)
+        for sub_if in if_data["vpp-vlan:sub-interfaces"]["sub-interface"]:
+            if str(sub_if["identifier"]) == str(identifier):
+                return sub_if
+
+        raise HoneycombError("The interface {0} does not have sub-interface "
+                             "with ID {1}".format(super_interface, identifier))
+
+    @staticmethod
+    def remove_all_sub_interfaces(node, super_interface):
+        """Remove all sub-interfaces from the given interface.
+
+        :param node: Honeycomb node.
+        :param super_interface: Super interface.
+        :type node: dict
+        :type super_interface: str
+        :return: Content of response.
+        :rtype: bytearray
+        """
+
+        path = ("interfaces",
+                ("interface", "name", super_interface),
+                "vpp-vlan:sub-interfaces")
+
+        return InterfaceKeywords._set_interface_properties(
+            node, super_interface, path, {})
+
+    @staticmethod
+    def set_sub_interface_state(node, super_interface, identifier, state):
+        """Set the administrative state of sub-interface.
+
+        :param node: Honeycomb node.
+        :param super_interface: Super interface.
+        :param identifier: The ID of sub-interface.
+        :param state: Required sub-interface state - up or down.
+        :type node: dict
+        :type super_interface: str
+        :type identifier: int
+        :type state: str
+        :return: Content of response.
+        :rtype: bytearray
+        """
+
+        intf_state = {"up": "true",
+                      "down": "false"}
+
+        path = ("interfaces",
+                ("interface", "name", super_interface),
+                "vpp-vlan:sub-interfaces",
+                ("sub-interface", "identifier", identifier),
+                "enabled")
+
+        return InterfaceKeywords._set_interface_properties(
+            node, super_interface, path, intf_state[state])
+
+    @staticmethod
+    def add_bridge_domain_to_sub_interface(node, super_interface, identifier,
+                                           config):
+        """Add a sub-interface to a bridge domain and set its parameters.
+
+        :param node: Honeycomb node.
+        :param super_interface: Super interface.
+        :param identifier: The ID of sub-interface.
+        :param config: Bridge domain configuration.
+        :type node: dict
+        :type super_interface: str
+        :type identifier: int
+        :type config: dict
+        :return: Content of response.
+        :rtype: bytearray
+        """
+
+        path = ("interfaces",
+                ("interface", "name", super_interface),
+                "vpp-vlan:sub-interfaces",
+                ("sub-interface", "identifier", int(identifier)),
+                "l2")
+
+        return InterfaceKeywords._set_interface_properties(
+            node, super_interface, path, config)
+
+    @staticmethod
+    def get_bd_data_from_sub_interface(node, super_interface, identifier):
+        """Get the operational data about the bridge domain from sub-interface.
+
+        :param node: Honeycomb node.
+        :param super_interface: Super interface.
+        :param identifier: The ID of sub-interface.
+        :type node: dict
+        :type super_interface: str
+        :type identifier: int
+        :return: Operational data about the bridge domain.
+        :rtype: dict
+        :raises HoneycombError: If there is no sub-interface with the given ID.
+        """
+
+        try:
+            bd_data = InterfaceKeywords.get_sub_interface_oper_data(
+                node, super_interface, identifier)["l2"]
+            return bd_data
+        except KeyError:
+            raise HoneycombError("The operational data does not contain "
+                                 "information about a bridge domain.")
+
+    @staticmethod
+    def configure_tag_rewrite(node, super_interface, identifier, config):
+        """Add / change / disable vlan tag rewrite on a sub-interface.
+
+        :param node: Honeycomb node.
+        :param super_interface: Super interface.
+        :param identifier: The ID of sub-interface.
+        :param config: Rewrite tag configuration.
+        :type node: dict
+        :type super_interface: str
+        :type identifier: int
+        :type config: dict
+        :return: Content of response.
+        :rtype: bytearray
+        """
+
+        path = ("interfaces",
+                ("interface", "name", super_interface),
+                "vpp-vlan:sub-interfaces",
+                ("sub-interface", "identifier", int(identifier)),
+                "l2",
+                "rewrite")
+
+        return InterfaceKeywords._set_interface_properties(
+            node, super_interface, path, config)

 
     @staticmethod
 
     @staticmethod

-    def add_vlan_tag_rewrite_to_sub_interface(node, sub_interface, **kwargs):
-        """Add vlan tag rewrite to a sub-interface.
+    def get_tag_rewrite_oper_data(node, super_interface, identifier):
+        """Get the operational data about tag rewrite.

 
         :param node: Honeycomb node.
 
         :param node: Honeycomb node.

-        :param sub_interface: The name of sub-interface.
+        :param super_interface: Super interface.
+        :param identifier: The ID of sub-interface.
+        :type node: dict
+        :type super_interface: str
+        :type identifier: int
+        :return: Operational data about tag rewrite.
+        :rtype: dict
+        :raises HoneycombError: If there is no sub-interface with the given ID.
+        """
+
+        try:
+            tag_rewrite = InterfaceKeywords.get_sub_interface_oper_data(
+                node, super_interface, identifier)["l2"]["rewrite"]
+            return tag_rewrite
+        except KeyError:
+            raise HoneycombError("The operational data does not contain "
+                                 "information about the tag-rewrite.")
+
+    @staticmethod
+    def add_ipv4_address_to_sub_interface(node, super_interface, identifier,
+                                          ip_addr, network):
+        """Add an ipv4 address to the specified sub-interface, with the provided
+        netmask or network prefix length. Any existing ipv4 addresses on the
+        sub-interface will be replaced.
+
+        :param node: Honeycomb node.
+        :param super_interface: Super interface.
+        :param identifier: The ID of sub-interface.
+        :param ip_addr: IPv4 address to be set.
+        :param network: Network mask or network prefix length.
+        :type node: dict
+        :type super_interface: str
+        :type identifier: int
+        :type ip_addr: str
+        :type network: str or int
+        :return: Content of response.
+        :rtype: bytearray
+        :raises HoneycombError: If the provided netmask or prefix is not valid.
+        """
+
+        path = ("interfaces",
+                ("interface", "name", super_interface),
+                "vpp-vlan:sub-interfaces",
+                ("sub-interface", "identifier", int(identifier)),
+                "ipv4")
+
+        if isinstance(network, basestring):
+            address = {"address": [{"ip": ip_addr, "netmask": network}, ]}
+
+        elif isinstance(network, int) and 0 < network < 33:
+            address = {"address": [{"ip": ip_addr, "prefix-length": network}, ]}
+
+        else:
+            raise HoneycombError("{0} is not a valid netmask or prefix length."
+                                 .format(network))
+
+        return InterfaceKeywords._set_interface_properties(
+            node, super_interface, path, address)
+
+    @staticmethod
+    def remove_all_ipv4_addresses_from_sub_interface(node, super_interface, # pylint: disable=invalid-name
+                                                     identifier):
+        """Remove all ipv4 addresses from the specified sub-interface.
+
+        :param node: Honeycomb node.
+        :param super_interface: Super interface.
+        :param identifier: The ID of sub-interface.
+        :type node: dict
+        :type super_interface: str
+        :type identifier: int
+        :return: Content of response.
+        :rtype: bytearray
+        """
+
+        path = ("interfaces",
+                ("interface", "name", super_interface),
+                "vpp-vlan:sub-interfaces",
+                ("sub-interface", "identifier", int(identifier)),
+                "ipv4", "address")
+
+        return InterfaceKeywords._set_interface_properties(
+            node, super_interface, path, None)
+
+    @staticmethod
+    def compare_data_structures(data, ref, ignore=()):
+        """Checks if data obtained from UUT is as expected.
+
+        :param data: Data to be checked.
+        :param ref: Referential data used for comparison.
+        :param ignore: Dictionary keys to be ignored.
+        :type data: dict
+        :type ref: dict
+        :type ignore: iterable
+        :raises HoneycombError: If a parameter from referential data is not
+        present in operational data or if it has different value.
+        """
+
+        errors = ""
+
+        for key, item in ref.items():
+            if key in ignore:
+                continue
+            try:
+                if data[key] != item:
+                    errors += ("\nThe value of parameter '{0}' is "
+                               "incorrect. It should be "
+                               "'{1}' but it is '{2}'".
+                               format(key, item, data[key]))
+            except KeyError:
+                errors += ("\nThe parameter '{0}' is not present in "
+                           "operational data".format(key))
+
+        if errors:
+            raise HoneycombError(errors)
+
+    @staticmethod
+    def compare_interface_lists(list1, list2):
+        """Compare provided lists of interfaces by name.
+
+        :param list1: List of interfaces.
+        :param list2: List of interfaces.
+        :type list1: list
+        :type list2: list
+        :raises HoneycombError: If an interface exists in only one of the lists.
+        """
+
+        ignore = ["vx_tunnel0", "vxlan_gpe_tunnel0"]
+        # these have no equivalent in config data and no effect on VPP
+
+        names1 = [x['name'] for x in list1]
+        names2 = [x['name'] for x in list2]
+
+        for name in names1:
+            if name not in names2 and name not in ignore:
+                raise HoneycombError("Interface {0} not present in list {1}"
+                                     .format(name, list2))
+        for name in names2:
+            if name not in names1 and name not in ignore:
+                raise HoneycombError("Interface {0} not present in list {1}"
+                                     .format(name, list1))
+
+    @staticmethod
+    def create_vxlan_gpe_interface(node, interface, **kwargs):
+        """Create a new VxLAN GPE interface.
+
+        :param node: Honeycomb node.
+        :param interface: The name of interface to be created.

         :param kwargs: Parameters and their values. The accepted parameters are
         :param kwargs: Parameters and their values. The accepted parameters are

-        defined in InterfaceKeywords.L2_REWRITE_TAG_PARAMS.
+        defined in InterfaceKeywords.VXLAN_GPE_PARAMS.

         :type node: dict
         :type node: dict

-        :type sub_interface: str
+        :type interface: str

         :type kwargs: dict
         :return: Content of response.
         :rtype: bytearray
         :type kwargs: dict
         :return: Content of response.
         :rtype: bytearray

-        :raises HoneycombError: If the parameter is not valid.
+        :raises HoneycombError: If a parameter in kwargs is not valid.

         """
 
         """
 

-        new_rewrite = dict()
+        new_vxlan_gpe = {
+            "name": interface,
+            "type": "v3po:vxlan-gpe-tunnel",
+            "v3po:vxlan-gpe": {}
+        }

         for param, value in kwargs.items():
         for param, value in kwargs.items():

-            if param in InterfaceKeywords.L2_REWRITE_TAG_PARAMS:
-                new_rewrite[param] = value
+            if param in InterfaceKeywords.INTF_PARAMS:
+                new_vxlan_gpe[param] = value
+            elif param in InterfaceKeywords.VXLAN_GPE_PARAMS:
+                new_vxlan_gpe["v3po:vxlan-gpe"][param] = value

             else:
                 raise HoneycombError("The parameter {0} is invalid.".
                                      format(param))
             else:
                 raise HoneycombError("The parameter {0} is invalid.".
                                      format(param))

-
-        path = ("interfaces", ("interface", "name", sub_interface), "v3po:l2",
-                "vlan-tag-rewrite")
+        path = ("interfaces", "interface")
+        vxlan_gpe_structure = [new_vxlan_gpe, ]

         return InterfaceKeywords._set_interface_properties(
         return InterfaceKeywords._set_interface_properties(

-            node, sub_interface, path, new_rewrite)
+            node, interface, path, vxlan_gpe_structure)

 
     @staticmethod
 
     @staticmethod

-    def remove_vlan_tag_rewrite_from_sub_interface(node, sub_interface):
-        """Remove vlan tag rewrite from a sub-interface.
+    def enable_acl_on_interface(node, interface, table_name):
+        """Enable ACL on the given interface.

 
         :param node: Honeycomb node.
 
         :param node: Honeycomb node.

-        :param sub_interface: The name of sub-interface.
+        :param interface: The interface where the ACL will be enabled.
+        :param table_name: Name of the classify table.

         :type node: dict
         :type node: dict

-        :type sub_interface: str
+        :type interface: str
+        :type table_name: str
+        :return: Content of response.

         :rtype: bytearray
         :rtype: bytearray

-        :raises HoneycombError: If the parameter is not valid.
+        :raises HoneycombError: If the configuration of interface is not
+        successful.

         """
 
         """
 

-        path = ("interfaces", ("interface", "name", sub_interface), "v3po:l2",
-                "vlan-tag-rewrite")
-        return InterfaceKeywords._set_interface_properties(
-            node, sub_interface, path, None)
+        interface = interface.replace("/", "%2F")
+
+        data = {
+            "v3po:acl": {
+                "l2-acl": {
+                    "classify-table": table_name
+                },
+                "ip4-acl": {
+                    "classify-table": table_name
+                }
+            }
+        }
+
+        path = "/interface/" + interface + "/v3po:acl"
+        status_code, resp = HcUtil.\
+            put_honeycomb_data(node, "config_vpp_interfaces", data, path,
+                               data_representation=DataRepresentation.JSON)
+        if status_code != HTTPCodes.OK:
+            raise HoneycombError(
+                "The configuration of interface '{0}' was not successful. "
+                "Status code: {1}.".format(interface, status_code))
+        return resp
+
+    @staticmethod
+    def disable_acl_on_interface(node, interface):
+        """Disable ACL on the given interface.
+
+        :param node: Honeycomb node.
+        :param interface: The interface where the ACL will be disabled.
+        :type node: dict
+        :type interface: str
+        :return: Content of response.
+        :rtype: bytearray
+        :raises HoneycombError: If the configuration of interface is not
+        successful.
+        """
+
+        interface = interface.replace("/", "%2F")
+
+        path = "/interface/" + interface + "/v3po:acl"
+
+        status_code, resp = HcUtil.\
+            delete_honeycomb_data(node, "config_vpp_interfaces", path)
+
+        if status_code != HTTPCodes.OK:
+            raise HoneycombError(
+                "The configuration of interface '{0}' was not successful. "
+                "Status code: {1}.".format(interface, status_code))
+        return resp
+
+    @staticmethod
+    def create_pbb_sub_interface(node, intf, sub_if_id, params):
+        """Creates a PBB sub-interface on the given interface and sets its
+        parameters.
+
+        :param node: Honeycomb node.
+        :param intf: The interface where PBB sub-interface will be configured.
+        :param sub_if_id: Sub-interface ID.
+        :param params: Configuration parameters of the sub-interface to be
+        created.
+        :type node: dict
+        :type intf: str
+        :type sub_if_id: str or int
+        :type params: dict
+        :return: Content of response.
+        :rtype: bytearray
+        :raises HoneycombError: If the configuration of sub-interface is not
+        successful.
+        """
+
+        interface = intf.replace("/", "%2F")
+        path = "/interface/{0}/sub-interfaces:sub-interfaces/sub-interface/" \
+               "{1}".format(interface, sub_if_id)
+        status_code, resp = HcUtil. \
+            put_honeycomb_data(node, "config_vpp_interfaces", params, path,
+                               data_representation=DataRepresentation.JSON)
+        if status_code != HTTPCodes.OK:
+            raise HoneycombError(
+                "The configuration of PBB sub-interface '{0}' was not "
+                "successful. Status code: {1}.".format(intf, status_code))
+        return resp
+
+    @staticmethod
+    def delete_pbb_sub_interface(node, intf, sub_if_id):
+        """Deletes the given PBB sub-interface.
+
+        :param node: Honeycomb node.
+        :param intf: The interface where PBB sub-interface will be deleted.
+        :param sub_if_id: ID of the PBB sub-interface to be deleted.
+        :type node: dict
+        :type intf: str
+        :type sub_if_id: str or int
+        :return: Content of response.
+        :rtype: bytearray
+        :raises HoneycombError: If the removal of sub-interface is not
+        successful.
+        """
+
+        interface = intf.replace("/", "%2F")
+        path = "/interface/{0}/sub-interfaces:sub-interfaces/sub-interface/" \
+               "{1}".format(interface, sub_if_id)
+
+        status_code, resp = HcUtil. \
+            delete_honeycomb_data(node, "config_vpp_interfaces", path)
+        if status_code != HTTPCodes.OK:
+            raise HoneycombError(
+                "The removal of pbb sub-interface '{0}' was not successful. "
+                "Status code: {1}.".format(intf, status_code))
+        return resp
+
+    @staticmethod
+    def get_pbb_sub_interface_oper_data(node, intf, sub_if_id):
+        """Retrieves PBB sub-interface operational data from Honeycomb.
+
+        :param node: Honeycomb node.
+        :param intf: The interface where PBB sub-interface is located.
+        :param sub_if_id: ID of the PBB sub-interface.
+        :type node: dict
+        :type intf: str
+        :type sub_if_id: str or int
+        :return: PBB sub-interface operational data.
+        :rtype: dict
+        :raises HoneycombError: If the removal of sub-interface is not
+        successful.
+        """
+
+        interface = "{0}.{1}".format(intf, sub_if_id)
+        return InterfaceKeywords.get_interface_oper_data(node, interface)