aboutsummaryrefslogtreecommitdiffstats
path: root/resources/libraries/python/honeycomb/HcAPIKwInterfaces.py
diff options
context:
space:
mode:
authorPeter Mikus <pmikus@cisco.com>2019-11-11 16:14:32 +0000
committerPeter Mikus <pmikus@cisco.com>2019-11-19 06:43:59 +0000
commite7ad66f3147662973039caaac33015de7e0c6f8c (patch)
tree809a056325425bad672a8a9274c3c2d696a35030 /resources/libraries/python/honeycomb/HcAPIKwInterfaces.py
parent20cc67d5f23a7f4e05b08012bf3d3a63be4bcf63 (diff)
HONEYCOMB: Remove
Signed-off-by: Peter Mikus <pmikus@cisco.com> Change-Id: I60d80564050cb786c7b1e0a08f31f8292f82197e
Diffstat (limited to 'resources/libraries/python/honeycomb/HcAPIKwInterfaces.py')
-rw-r--r--resources/libraries/python/honeycomb/HcAPIKwInterfaces.py1908
1 files changed, 0 insertions, 1908 deletions
diff --git a/resources/libraries/python/honeycomb/HcAPIKwInterfaces.py b/resources/libraries/python/honeycomb/HcAPIKwInterfaces.py
deleted file mode 100644
index 662fedca10..0000000000
--- a/resources/libraries/python/honeycomb/HcAPIKwInterfaces.py
+++ /dev/null
@@ -1,1908 +0,0 @@
-# Copyright (c) 2018 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.
-
-"""Keywords to manipulate interface configuration using Honeycomb REST API.
-
-The keywords make possible to put and get configuration data and to get
-operational data.
-"""
-from robot.api import logger
-
-from resources.libraries.python.HTTPRequest import HTTPCodes
-from resources.libraries.python.honeycomb.HoneycombSetup import HoneycombError
-from resources.libraries.python.honeycomb.HoneycombUtil \
- import DataRepresentation
-from resources.libraries.python.honeycomb.HoneycombUtil \
- import HoneycombUtil as HcUtil
-from resources.libraries.python.topology import Topology
-
-
-class InterfaceKeywords(object):
- """Keywords for Interface manipulation.
-
- Implements keywords which get configuration and operational data about
- vpp interfaces and set the interface's parameters using Honeycomb REST API.
- """
-
- INTF_PARAMS = ("name", "description", "type", "enabled",
- "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",
- "create-temporary-addresses",
- "temporary-valid-lifetime",
- "temporary-preferred-lifetime")
- ETH_PARAMS = ("mtu", )
- ROUTING_PARAMS = ("ipv4-vrf-id", "ipv6-vrf-id")
- VXLAN_PARAMS = ("src", "dst", "vni", "encap-vrf-id")
- L2_PARAMS = ("bridge-domain", "split-horizon-group",
- "bridged-virtual-interface")
- TAP_PARAMS = ("id", "tx-ring-size", "rx-ring-size", "host-mac",
- "host-interface-name", "host-namespace", "host-bridge",
- "host-ipv4-address", "host-ipv6-address", "tag",
- "host-ipv4-gateway", "host-ipv6-gateway", "mac")
- VHOST_USER_PARAMS = ("socket", "role")
- 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
-
- @staticmethod
- def _configure_interface(node, interface, data,
- data_representation=DataRepresentation.JSON):
- """Send interface configuration data and check the response.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :param data: Configuration data to be sent in PUT request.
- :param data_representation: How the data is represented.
- :type node: dict
- :type interface: str
- :type data: dict
- :type data_representation: DataRepresentation
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If the status code in response on PUT is not
- 200 = OK.
- """
-
- status_code, resp = HcUtil.\
- put_honeycomb_data(node, "config_vpp_interfaces", data,
- data_representation=data_representation)
- if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
- raise HoneycombError(
- "The configuration of interface '{0}' was not successful. "
- "Status code: {1}.".format(interface, status_code))
- return resp
-
- @staticmethod
- def get_all_interfaces_cfg_data(node):
- """Get configuration data about all interfaces from Honeycomb.
-
- :param node: Honeycomb node.
- :type node: dict
- :returns: Configuration data about all interfaces from Honeycomb.
- :rtype: list
- :raises HoneycombError: If it is not possible to get configuration data.
- """
-
- status_code, resp = HcUtil.\
- get_honeycomb_data(node, "config_vpp_interfaces")
- if status_code != HTTPCodes.OK:
- raise HoneycombError(
- "Not possible to get configuration information about the "
- "interfaces. Status code: {0}.".format(status_code))
- try:
- return resp["interfaces"]["interface"]
-
- except (KeyError, TypeError):
- return []
-
- @staticmethod
- def get_interface_cfg_data(node, interface):
- """Get configuration data about the given interface from Honeycomb.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :type node: dict
- :type interface: str
- :returns: Configuration data about the given interface from Honeycomb.
- :rtype: dict
- """
-
- intfs = InterfaceKeywords.get_all_interfaces_cfg_data(node)
- for intf in intfs:
- if intf["name"] == interface:
- return intf
- return {}
-
- @staticmethod
- def get_all_interfaces_oper_data(node):
- """Get operational data about all interfaces from Honeycomb.
-
- :param node: Honeycomb node.
- :type node: dict
- :returns: Operational data about all interfaces from Honeycomb.
- :rtype: list
- :raises HoneycombError: If it is not possible to get operational data.
- """
-
- status_code, resp = HcUtil.\
- get_honeycomb_data(node, "oper_vpp_interfaces")
- if status_code != HTTPCodes.OK:
- raise HoneycombError(
- "Not possible to get operational information about the "
- "interfaces. Status code: {0}.".format(status_code))
- try:
- return resp["interfaces"]["interface"]
-
- except (KeyError, TypeError):
- return []
-
- @staticmethod
- def get_disabled_interfaces_oper_data(node):
- """Get operational data about all disabled interfaces from Honeycomb.
-
- :param node: Honeycomb node.
- :type node: dict
- :returns: Operational data about disabled interfaces.
- :rtype: list
- :raises HoneycombError: If it is not possible to get operational data.
- """
-
- status_code, resp = HcUtil. \
- get_honeycomb_data(node, "oper_disabled_interfaces")
- if status_code == HTTPCodes.NOT_FOUND:
- raise HoneycombError(
- "No disabled interfaces present on node."
- )
- if status_code != HTTPCodes.OK:
- raise HoneycombError(
- "Not possible to get operational information about the "
- "interfaces. Status code: {0}.".format(status_code))
- try:
- return resp["disabled-interfaces"]["disabled-interface-index"]
-
- except (KeyError, TypeError):
- return []
-
- @staticmethod
- def get_interface_oper_data(node, interface):
- """Get operational data about the given interface from Honeycomb.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :type node: dict
- :type interface: str
- :returns: Operational data about the given interface from Honeycomb.
- :rtype: dict
- """
-
- try:
- interface = Topology.convert_interface_reference(
- node, interface, "name")
- except RuntimeError:
- if isinstance(interface, basestring):
- # Probably name of a custom interface (TAP, VxLAN, Vhost, ...)
- pass
- else:
- raise
-
- intfs = InterfaceKeywords.get_all_interfaces_oper_data(node)
- for intf in intfs:
- if intf["name"] == interface:
- return intf
- return {}
-
- @staticmethod
- def _set_interface_properties(node, interface, path, new_value=None):
- """Set interface properties.
-
- This method reads interface configuration data, creates, changes or
- removes the requested data and puts it back to Honeycomb.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :param path: Path to data we want to change / create / remove.
- :param new_value: The new value to be set. If None, the item will be
- removed.
- :type node: dict
- :type interface: str
- :type path: tuple
- :type new_value: str, dict or list
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If it is not possible to get or set the data.
- """
-
- status_code, resp = HcUtil.\
- get_honeycomb_data(node, "config_vpp_interfaces")
- if status_code != HTTPCodes.OK:
- raise HoneycombError(
- "Not possible to get configuration information about the "
- "interfaces. Status code: {0}.".format(status_code))
-
- if new_value:
- new_data = HcUtil.set_item_value(resp, path, new_value)
- else:
- new_data = HcUtil.remove_item(resp, path)
- return InterfaceKeywords._configure_interface(node, interface, new_data)
-
- @staticmethod
- def honeycomb_set_interface_state(node, interface, state="up"):
- """Set VPP interface state.
-
- The keyword changes the administration state of interface to up or down
- depending on the parameter "state".
-
- :param node: Honeycomb node.
- :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
- :type interface: str
- :type state: str
- :returns: Content of response.
- :rtype: bytearray
- :raises KeyError: If the argument "state" is nor "up" or "down".
- :raises HoneycombError: If the interface is not present on the node.
- """
-
- intf_state = {"up": "true",
- "down": "false"}
-
- 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 not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
- 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):
- """Set the administration state of VPP interface to up.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :type node: dict
- :type interface: str
- :returns: Content of response
- :rtype: bytearray
- """
-
- return InterfaceKeywords.honeycomb_set_interface_state(
- node, interface, "up")
-
- @staticmethod
- def set_interface_down(node, interface):
- """Set the administration state of VPP interface to down.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :type node: dict
- :type interface: str
- :returns: Content of response.
- :rtype: bytearray
- """
-
- return InterfaceKeywords.honeycomb_set_interface_state(
- node, interface, "down")
-
- @staticmethod
- def add_bridge_domain_to_interface(node, interface, bd_name,
- split_horizon_group=None, bvi=None):
- """Add a new bridge domain to an interface and set its parameters.
-
- :param node: Honeycomb node.
- :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.
- :type node: dict
- :type interface: str
- :type bd_name: str
- :type split_horizon_group: str
- :type bvi: str
- :returns: Content of response.
- :rtype: bytearray
- :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)
- if bvi:
- v3po_l2["bridged-virtual-interface"] = str(bvi)
-
- path = ("interfaces", ("interface", "name", str(interface)), "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, response = HcUtil.delete_honeycomb_data(
- node, "config_vpp_interfaces", path)
-
- if status_code != HTTPCodes.OK:
- if '"error-tag":"data-missing"' in response:
- logger.debug("Data does not exist in path.")
- else:
- 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
- :returns: 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.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :param param: Parameter to configure (set, change, remove)
- :param value: The value of parameter. If None, the parameter will be
- removed.
- :type node: dict
- :type interface: str
- :type param: str
- :type value: str
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If the parameter is not valid.
- """
-
- if param not in InterfaceKeywords.INTF_PARAMS:
- raise HoneycombError("The parameter {0} is invalid.".format(param))
-
- path = ("interfaces", ("interface", "name", interface), param)
- return InterfaceKeywords._set_interface_properties(
- node, interface, path, value)
-
- @staticmethod
- def configure_interface_ipv4(node, interface, param, value):
- """Configure IPv4 parameters of interface.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :param param: Parameter to configure (set, change, remove)
- :param value: The value of parameter. If None, the parameter will be
- removed.
- :type node: dict
- :type interface: str
- :type param: str
- :type value: str
- :returns: Content of response.
- :rtype: bytearray
- :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))
-
- path = ("interfaces", ("interface", "name", interface),
- "ietf-ip:ipv4", param)
- return InterfaceKeywords._set_interface_properties(
- node, interface, path, value)
-
- @staticmethod
- def add_first_ipv4_address(node, interface, ip_addr, network):
- """Add the first IPv4 address.
-
- If there are any other addresses configured, they will be removed.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :param ip_addr: IPv4 address to be set.
- :param network: Netmask or length of network prefix.
- :type node: dict
- :type interface: str
- :type ip_addr: str
- :type network: str or int
- :returns: Content of response.
- :rtype: bytearray
- :raises ValueError: If the provided netmask or prefix is not valid.
- :raises HoneycombError: If the operation fails.
- """
-
- interface = InterfaceKeywords.handle_interface_reference(
- node, interface)
-
- path = "/interface/{0}/ietf-ip:ipv4".format(interface)
- if isinstance(network, basestring):
- data = {
- "ietf-ip:ipv4": {
- "address": [{"ip": ip_addr, "netmask": network}, ]}}
- elif isinstance(network, int) and (0 < network < 33):
- data = {
- "ietf-ip:ipv4": {
- "address": [{"ip": ip_addr, "prefix-length": network}, ]}}
- else:
- raise ValueError("Value {0} is not a valid netmask or network "
- "prefix length.".format(network))
- status_code, _ = HcUtil.put_honeycomb_data(
- node, "config_vpp_interfaces", data, path)
-
- if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
- raise HoneycombError(
- "Configuring IPv4 address failed. "
- "Status code:{0}".format(status_code))
-
- @staticmethod
- def add_ipv4_address(node, interface, ip_addr, network):
- """Add IPv4 address.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :param ip_addr: IPv4 address to be set.
- :param network: Netmask or length of network prefix.
- :type node: dict
- :type interface: str
- :type ip_addr: str
- :type network: str or int
- :returns: 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):
- address = [{"ip": ip_addr, "netmask": network}]
- elif isinstance(network, int) and (0 < network < 33):
- address = [{"ip": ip_addr, "prefix-length": network}]
- else:
- raise HoneycombError("Value {0} is not a valid netmask or network "
- "prefix length.".format(network))
- return InterfaceKeywords._set_interface_properties(
- node, interface, path, address)
-
- @staticmethod
- def remove_all_ipv4_addresses(node, interface):
- """Remove all IPv4 addresses from interface.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :type node: dict
- :type interface: str
- :returns: Content of response.
- :rtype: bytearray
- """
-
- interface = Topology.convert_interface_reference(
- node, interface, "name")
-
- path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4",
- "address")
- return InterfaceKeywords._set_interface_properties(
- node, interface, path, None)
-
- @staticmethod
- def add_ipv4_neighbor(node, interface, ip_addr, link_layer_address):
- """Add the IPv4 neighbour.
-
- :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
- :returns: Content of response.
- :rtype: bytearray
- """
-
- interface = Topology.convert_interface_reference(
- node, interface, "name")
-
- 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 remove_all_ipv4_neighbors(node, interface):
- """Remove all IPv4 neighbours.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :type node: dict
- :type interface: str
- :returns: Content of response.
- :rtype: bytearray
- """
-
- interface = Topology.convert_interface_reference(
- node, interface, "name")
-
- path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4",
- "neighbor")
- return InterfaceKeywords._set_interface_properties(
- node, interface, path, None)
-
- @staticmethod
- def configure_interface_ipv6(node, interface, param, value):
- """Configure IPv6 parameters of interface
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :param param: Parameter to configure (set, change, remove)
- :param value: The value of parameter. If None, the parameter will be
- removed.
- :type node: dict
- :type interface: str
- :type param: str
- :type value: str
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If the parameter is not valid.
- """
-
- if param in InterfaceKeywords.IPV6_PARAMS:
- path = ("interfaces", ("interface", "name", interface),
- "ietf-ip:ipv6", param)
- elif param in InterfaceKeywords.IPV6_AUTOCONF_PARAMS:
- path = ("interfaces", ("interface", "name", interface),
- "ietf-ip:ipv6", "autoconf", param)
- else:
- raise HoneycombError("The parameter {0} is invalid.".format(param))
-
- return InterfaceKeywords._set_interface_properties(
- node, interface, path, value)
-
- @staticmethod
- def add_first_ipv6_address(node, interface, ip_addr, prefix_len):
- """Add the first IPv6 address.
-
- If there are any other addresses configured, they will be removed.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :param ip_addr: IPv6 address to be set.
- :param prefix_len: Prefix length.
- :type node: dict
- :type interface: str
- :type ip_addr: str
- :type prefix_len: str
- :returns: Content of response.
- :rtype: bytearray
- """
-
- interface = Topology.convert_interface_reference(
- node, interface, "name")
-
- path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6")
- address = {"address": [{"ip": ip_addr, "prefix-length": prefix_len}, ]}
- return InterfaceKeywords._set_interface_properties(
- node, interface, path, address)
-
- @staticmethod
- def add_ipv6_address(node, interface, ip_addr, prefix_len):
- """Add IPv6 address.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :param ip_addr: IPv6 address to be set.
- :param prefix_len: Prefix length.
- :type node: dict
- :type interface: str
- :type ip_addr: str
- :type prefix_len: str
- :returns: Content of response.
- :rtype: bytearray
- """
-
- interface = Topology.convert_interface_reference(
- node, interface, "name")
-
- path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6",
- "address")
- address = [{"ip": ip_addr, "prefix-length": prefix_len}, ]
- return InterfaceKeywords._set_interface_properties(
- node, interface, path, address)
-
- @staticmethod
- def remove_all_ipv6_addresses(node, interface):
- """Remove all IPv6 addresses from interface.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :type node: dict
- :type interface: str
- :returns: Content of response.
- :rtype: bytearray
- """
-
- interface = Topology.convert_interface_reference(
- node, interface, "name")
-
- path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6",
- "address")
- return InterfaceKeywords._set_interface_properties(
- node, interface, path, None)
-
- @staticmethod
- def add_ipv6_neighbor(node, interface, ip_addr, link_layer_address):
- """Add the IPv6 neighbour.
-
- :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
- :returns: Content of response.
- :rtype: bytearray
- """
-
- interface = Topology.convert_interface_reference(
- node, interface, "name")
-
- 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 remove_all_ipv6_neighbors(node, interface):
- """Remove all IPv6 neighbours.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :type node: dict
- :type interface: str
- :returns: Content of response.
- :rtype: bytearray
- """
-
- interface = Topology.convert_interface_reference(
- node, interface, "name")
-
- path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6",
- "neighbor")
- return InterfaceKeywords._set_interface_properties(
- node, interface, path, None)
-
- @staticmethod
- def configure_interface_ethernet(node, interface, param, value):
- """Configure the ethernet parameters of interface.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :param param: Parameter to configure (set, change, remove)
- :param value: The value of parameter. If None, the parameter will be
- removed.
- :type node: dict
- :type interface: str
- :type param: str
- :type value: str
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If the parameter is not valid.
- """
-
- if param not in InterfaceKeywords.ETH_PARAMS:
- raise HoneycombError("The parameter {0} is invalid.".format(param))
- path = ("interfaces", ("interface", "name", interface), "v3po:ethernet",
- param)
- return InterfaceKeywords._set_interface_properties(
- node, interface, path, value)
-
- @staticmethod
- def configure_interface_routing(node, interface, param, value):
- """Configure the routing parameters of interface.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :param param: Parameter to configure (set, change, remove)
- :param value: The value of parameter. If None, the parameter will be
- removed.
- :type node: dict
- :type interface: str
- :type param: str
- :type value: str
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If the parameter is not valid.
- """
-
- interface = Topology.convert_interface_reference(
- node, interface, "name")
-
- if param not in InterfaceKeywords.ROUTING_PARAMS:
- raise HoneycombError("The parameter {0} is invalid.".format(param))
-
- path = ("interfaces", ("interface", "name", interface), "v3po:routing",
- param)
- return InterfaceKeywords._set_interface_properties(
- node, interface, path, value)
-
- @staticmethod
- def honeycomb_create_vxlan_interface(node, interface, **kwargs):
- """Create a new VxLAN interface.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :param kwargs: Parameters and their values. The accepted parameters are
- defined in InterfaceKeywords.VXLAN_PARAMS.
- :type node: dict
- :type interface: str
- :type kwargs: dict
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If the parameter is not valid.
- """
-
- new_vx_lan = {
- "name": interface,
- "type": "v3po:vxlan-tunnel",
- "v3po:vxlan": {}
- }
- for param, value in kwargs.items():
- if param not in InterfaceKeywords.VXLAN_PARAMS:
- raise HoneycombError("The parameter {0} is invalid.".
- format(param))
- new_vx_lan["v3po:vxlan"][param] = value
-
- path = ("interfaces", "interface")
- vx_lan_structure = [new_vx_lan, ]
- return InterfaceKeywords._set_interface_properties(
- node, interface, path, vx_lan_structure)
-
- @staticmethod
- def delete_interface(node, interface):
- """Delete an interface.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :type node: dict
- :type interface: str
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If it is not possible to get information about
- interfaces or it is not possible to delete the interface.
- """
-
- path = ("interfaces", ("interface", "name", interface))
-
- status_code, resp = HcUtil.\
- get_honeycomb_data(node, "config_vpp_interfaces")
- if status_code != HTTPCodes.OK:
- raise HoneycombError(
- "Not possible to get configuration information about the "
- "interfaces. Status code: {0}.".format(status_code))
-
- new_data = HcUtil.remove_item(resp, path)
- status_code, resp = HcUtil.\
- put_honeycomb_data(node, "config_vpp_interfaces", new_data)
- if status_code != HTTPCodes.OK:
- raise HoneycombError("Not possible to remove interface {0}. "
- "Status code: {1}.".
- format(interface, status_code))
- return resp
-
- @staticmethod
- def honeycomb_configure_interface_vxlan(node, interface, **kwargs):
- """Configure VxLAN on the interface.
-
- The keyword configures VxLAN parameters on the given interface. The type
- of interface must be set to "v3po:vxlan-tunnel".
- The new VxLAN parameters overwrite the current configuration. If a
- parameter in new configuration is missing, it is removed from VxLAN
- configuration.
- If the dictionary kwargs is empty, VxLAN configuration is removed.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :param kwargs: Parameters and their values. The accepted parameters are
- defined in InterfaceKeywords.VXLAN_PARAMS.
- :type node: dict
- :type interface: str
- :type kwargs: dict
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If the parameter is not valid.
- """
-
- vx_lan_structure = dict()
- for param, value in kwargs.items():
- if param not in InterfaceKeywords.VXLAN_PARAMS:
- raise HoneycombError("The parameter {0} is invalid.".
- format(param))
- vx_lan_structure[param] = value
-
- path = ("interfaces", ("interface", "name", interface), "v3po:vxlan")
- return InterfaceKeywords._set_interface_properties(
- node, interface, path, vx_lan_structure)
-
- @staticmethod
- def configure_interface_l2(node, interface, param, value):
- """Configure the L2 parameters of interface.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :param param: Parameter to configure (set, change, remove)
- :param value: The value of parameter. If None, the parameter will be
- removed.
- :type node: dict
- :type interface: str
- :type param: str
- :type value: str
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If the parameter is not valid.
- """
-
- if param not in InterfaceKeywords.L2_PARAMS:
- raise HoneycombError("The parameter {0} is invalid.".format(param))
- path = ("interfaces", ("interface", "name", interface), "v3po:l2",
- param)
- return InterfaceKeywords._set_interface_properties(
- node, interface, path, value)
-
- @staticmethod
- def create_tap_interface(node, interface, **kwargs):
- """Create a new TAP interface.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :param kwargs: Parameters and their values. The accepted parameters are
- defined in InterfaceKeywords.TAP_PARAMS.
- :type node: dict
- :type interface: str
- :type kwargs: dict
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If the parameter is not valid.
- """
-
- new_tap = {
- "name": interface,
- "type": "v3po:tap-v2",
- "v3po:tap-v2": {}
- }
- for param, value in kwargs.items():
- if param not in InterfaceKeywords.TAP_PARAMS:
- raise HoneycombError(
- "The parameter {0} is invalid.".format(param))
- new_tap["v3po:tap-v2"][param] = value
-
- path = ("interfaces", "interface")
- new_tap_structure = [new_tap, ]
- return InterfaceKeywords._set_interface_properties(
- node, interface, path, new_tap_structure)
-
- @staticmethod
- def configure_interface_tap(node, interface, **kwargs):
- """Configure TAP on the interface.
-
- The keyword configures TAP parameters on the given interface. The type
- of interface must be set to "v3po:tap-v2".
- The new TAP parameters overwrite the current configuration. If a
- parameter in new configuration is missing, it is removed from TAP
- configuration.
- If the dictionary kwargs is empty, TAP configuration is removed.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :param kwargs: Parameters and their values. The accepted parameters are
- defined in InterfaceKeywords.TAP_PARAMS.
- :type node: dict
- :type interface: str
- :type kwargs: dict
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If the parameter is not valid.
- """
-
- tap_structure = dict()
- for param, value in kwargs.items():
- if param not in InterfaceKeywords.TAP_PARAMS:
- raise HoneycombError("The parameter {0} is invalid.".
- format(param))
- tap_structure[param] = value
-
- path = ("interfaces", ("interface", "name", interface), "v3po:tap-v2")
- return InterfaceKeywords._set_interface_properties(
- node, interface, path, tap_structure)
-
- @staticmethod
- def configure_interface_vhost_user(node, interface, **kwargs):
- """Configure vhost-user on the interface.
-
- The keyword configures vhost-user parameters on the given interface.
- The type of interface must be set to "v3po:vhost-user".
- The new vhost-user parameters overwrite the current configuration. If a
- parameter in new configuration is missing, it is removed from vhost-user
- configuration.
- If the dictionary kwargs is empty, vhost-user configuration is removed.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :param kwargs: Parameters and their values. The accepted parameters are
- defined in InterfaceKeywords.VHOST_USER_PARAMS.
- :type node: dict
- :type interface: str
- :type kwargs: dict
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If the parameter is not valid.
- """
-
- vhost_structure = dict()
- for param, value in kwargs.items():
- if param not in InterfaceKeywords.VHOST_USER_PARAMS:
- raise HoneycombError("The parameter {0} is invalid.".
- format(param))
- vhost_structure[param] = value
-
- path = ("interfaces", ("interface", "name", interface),
- "v3po:vhost-user")
- return InterfaceKeywords._set_interface_properties(
- node, interface, path, vhost_structure)
-
- @staticmethod
- def create_vhost_user_interface(node, interface, **kwargs):
- """Create a new vhost-user interface.
-
- :param node: Honeycomb node.
- :param interface: The name of interface.
- :param kwargs: Parameters and their values. The accepted parameters are
- defined in InterfaceKeywords.VHOST_USER_PARAMS.
- :type node: dict
- :type interface: str
- :type kwargs: dict
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If the parameter is not valid.
- """
-
- new_vhost = {
- "name": interface,
- "type": "v3po:vhost-user",
- "v3po:vhost-user": {}
- }
- for param, value in kwargs.items():
- if param not in InterfaceKeywords.VHOST_USER_PARAMS:
- raise HoneycombError("The parameter {0} is invalid.".
- format(param))
- new_vhost["v3po:vhost-user"][param] = value
-
- path = ("interfaces", "interface")
- new_vhost_structure = [new_vhost, ]
- return InterfaceKeywords._set_interface_properties(
- node, interface, path, new_vhost_structure)
-
- @staticmethod
- def honeycomb_create_sub_interface(node, super_interface, match, tags=None,
- **kwargs):
- """Create a new sub-interface.
-
- :param node: Honeycomb node.
- :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
- defined in InterfaceKeywords.SUB_IF_PARAMS.
- :type node: dict
- :type super_interface: str
- :type match: str
- :type tags: list
- :type kwargs: dict
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If the parameter is not valid.
- :raises KeyError: If the parameter 'match' is invalid.
- """
-
- super_interface = Topology.convert_interface_reference(
- node, super_interface, "name")
-
- match_type = {
- "default":
- {"default": {}},
- "untagged":
- {"untagged": {}},
- "vlan-tagged":
- {"vlan-tagged": {"match-exact-tags": "false"}},
- "vlan-tagged-exact-match":
- {"vlan-tagged": {"match-exact-tags": "true"}}
- }
-
- new_sub_interface = {
- "tags": {
- "tag": []
- },
- }
-
- for param, value in kwargs.items():
- if param in InterfaceKeywords.SUB_IF_PARAMS:
- new_sub_interface[param] = value
- else:
- raise HoneycombError("The parameter {0} is invalid.".
- format(param))
- 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(
- 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
- :returns: 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
- :returns: 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
- :returns: Content of response.
- :rtype: bytearray
- """
-
- super_interface = Topology.convert_interface_reference(
- node, super_interface, "name")
-
- intf_state = {"up": "true",
- "down": "false"}
-
- path = ("interfaces",
- ("interface", "name", super_interface),
- "vpp-vlan:sub-interfaces",
- ("sub-interface", "identifier", int(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
- :returns: 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
- :returns: 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
- :returns: 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
- def get_tag_rewrite_oper_data(node, super_interface, identifier):
- """Get the operational data about tag rewrite.
-
- :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
- :returns: 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_ip_address_to_sub_interface(node, super_interface, identifier,
- ip_addr, network, ip_version):
- """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.
- :param ip_version: ipv4 or ipv6
- :type node: dict
- :type super_interface: str
- :type identifier: int
- :type ip_addr: str
- :type network: str or int
- :type ip_version: string
- :returns: 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)),
- ip_version.lower())
-
- if isinstance(network, basestring) and ip_version.lower() == "ipv4":
- 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_ip_addresses_from_sub_interface(node, super_interface,
- identifier, ip_version):
- """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.
- :param ip_version: ipv4 or ipv6
- :type node: dict
- :type super_interface: str
- :type identifier: int
- :type ip_version: string
- :returns: Content of response.
- :rtype: bytearray
- """
-
- path = ("interfaces",
- ("interface", "name", super_interface),
- "vpp-vlan:sub-interfaces",
- ("sub-interface", "identifier", int(identifier)),
- str(ip_version), "address")
-
- return InterfaceKeywords._set_interface_properties(
- node, super_interface, path, None)
-
- @staticmethod
- def compare_data_structures(data, ref, _path=''):
- """Checks if data obtained from UUT is as expected. If it is not,
- proceeds down the list/dictionary tree and finds the point of mismatch.
-
- :param data: Data to be checked.
- :param ref: Referential data used for comparison.
- :param _path: Used in recursive calls, stores the path taken down
- the JSON tree.
- :type data: dict
- :type ref: dict
- :type _path: str
-
- :raises HoneycombError: If the data structures do not match in some way,
- or if they are not in deserialized JSON format.
- """
-
- if data == ref:
- return True
-
- elif isinstance(data, dict) and isinstance(ref, dict):
- for key in ref:
- if key not in data:
- raise HoneycombError(
- "Key {key} is not present in path {path}. Keys in path:"
- "{data_keys}".format(
- key=key,
- path=_path,
- data_keys=data.keys()))
-
- if data[key] != ref[key]:
- if isinstance(data[key], list) \
- or isinstance(data[key], dict):
- InterfaceKeywords.compare_data_structures(
- data[key], ref[key],
- _path + '[{0}]'.format(key))
- else:
- raise HoneycombError(
- "Data mismatch, key {key} in path {path} has value"
- " {data}, but should be {ref}".format(
- key=key,
- path=_path,
- data=data[key],
- ref=ref[key]))
-
- elif isinstance(data, list) and isinstance(ref, list):
- for item in ref:
- if item not in data:
- if isinstance(item, dict):
- InterfaceKeywords.compare_data_structures(
- data[0], item,
- _path + '[{0}]'.format(ref.index(item)))
- else:
- raise HoneycombError(
- "Data mismatch, list item {index} in path {path}"
- " has value {data}, but should be {ref}".format(
- index=ref.index(item),
- path=_path,
- data=data[0],
- ref=item))
-
- else:
- raise HoneycombError(
- "Unexpected data type {data_type} in path {path}, reference"
- " type is {ref_type}. Must be list or dictionary.".format(
- data_type=type(data),
- ref_type=type(ref),
- path=_path))
-
- @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
- defined in InterfaceKeywords.VXLAN_GPE_PARAMS.
- :type node: dict
- :type interface: str
- :type kwargs: dict
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If a parameter in kwargs is not valid.
- """
-
- new_vxlan_gpe = {
- "name": interface,
- "type": "v3po:vxlan-gpe-tunnel",
- "v3po:vxlan-gpe": {}
- }
- for param, value in kwargs.items():
- 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))
- path = ("interfaces", "interface")
- vxlan_gpe_structure = [new_vxlan_gpe, ]
- return InterfaceKeywords._set_interface_properties(
- node, interface, path, vxlan_gpe_structure)
-
- @staticmethod
- def enable_acl_on_interface(node, interface, table_name):
- """Enable ACL on the given interface.
-
- :param node: Honeycomb node.
- :param interface: The interface where the ACL will be enabled.
- :param table_name: Name of the classify table.
- :type node: dict
- :type interface: str
- :type table_name: str
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If the configuration of interface is not
- successful.
- """
-
- interface = interface.replace("/", "%2F")
-
- data = {
- "vpp-interface-acl:acl": {
- "ingress": {
- "ip4-acl": {
- "classify-table": table_name
- },
- "l2-acl": {
- "classify-table": table_name
- }
- }
- }
- }
-
- path = "/interface/" + interface + "/vpp-interface-acl:acl"
- status_code, resp = HcUtil.\
- put_honeycomb_data(node, "config_vpp_interfaces", data, path,
- data_representation=DataRepresentation.JSON)
- if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
- raise HoneycombError(
- "The configuration of interface '{0}' was not successful. "
- "Status code: {1}.".format(interface, status_code))
- return resp
-
- @staticmethod
- def enable_policer_on_interface(node, interface, table_name):
- """Enable Policer on the given interface.
-
- :param node: Honeycomb node.
- :param interface: The interface where policer will be enabled.
- :param table_name: Name of the classify table.
- :type node: dict
- :type interface: str
- :type table_name: str
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If the configuration of interface is not
- successful.
- """
- interface = Topology.convert_interface_reference(
- node, interface, "name")
- interface = interface.replace("/", "%2F")
-
- data = {
- "interface-policer:policer": {
- "ip4-table": table_name
- }
- }
-
- path = "/interface/" + interface + "/interface-policer:policer"
- status_code, resp = HcUtil.\
- put_honeycomb_data(node, "config_vpp_interfaces", data, path,
- data_representation=DataRepresentation.JSON)
- if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
- raise HoneycombError(
- "The configuration of interface '{0}' was not successful. "
- "Status code: {1}.".format(interface, status_code))
- return resp
-
- @staticmethod
- def disable_policer_on_interface(node, interface):
- """Disable Policer on the given interface.
-
- :param node: Honeycomb node.
- :param interface: The interface where policer will be disabled.
- :type node: dict
- :type interface: str
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If the configuration of interface is not
- successful.
- """
- interface = Topology.convert_interface_reference(
- node, interface, "name")
- interface = interface.replace("/", "%2F")
-
- path = "/interface/" + interface + "/interface-policer:policer"
- 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 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
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If the configuration of interface is not
- successful.
- """
-
- interface = interface.replace("/", "%2F")
-
- path = "/interface/" + interface + "/vpp-interface-acl: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, 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 params: Configuration parameters of the sub-interface to be
- created.
- :type node: dict
- :type intf: str
- :type params: dict
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If the configuration of sub-interface is not
- successful.
- """
-
- interface = intf.replace("/", "%2F")
- path = "/interface/{0}/pbb-rewrite".format(interface)
- status_code, resp = HcUtil. \
- put_honeycomb_data(node, "config_vpp_interfaces", params, path,
- data_representation=DataRepresentation.JSON)
- if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
- 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):
- """Deletes the given PBB sub-interface.
-
- :param node: Honeycomb node.
- :param intf: The interface where PBB sub-interface will be deleted.
- :type node: dict
- :type intf: str
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If the removal of sub-interface is not
- successful.
- """
-
- interface = intf.replace("/", "%2F")
- path = "/interface/{0}/pbb-rewrite".format(interface)
-
- 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
- :returns: PBB sub-interface operational data.
- :rtype: dict
- :raises HoneycombError: If the removal of sub-interface is not
- successful.
- """
-
- raise NotImplementedError
-
- @staticmethod
- def check_disabled_interface(node, interface):
- """Retrieves list of disabled interface indices from Honeycomb,
- and matches with the provided interface by index.
-
- :param node: Honeycomb node.
- :param interface: Index number of an interface on the node.
- :type node: dict
- :type interface: int
- :returns: True if the interface exists in disabled interfaces.
- :rtype: bool
- :raises HoneycombError: If the interface is not present
- in retrieved list of disabled interfaces.
- """
- data = InterfaceKeywords.get_disabled_interfaces_oper_data(node)
- # decrement by one = conversion from HC if-index to VPP sw_if_index
- interface -= 1
-
- for item in data:
- if item["index"] == interface:
- return True
- raise HoneycombError("Interface index {0} not present in list"
- " of disabled interfaces.".format(interface))
-
- @staticmethod
- def configure_interface_span(node, dst_interface, src_interfaces=None):
- """Configure SPAN port mirroring on the specified interfaces. If no
- source interface is provided, SPAN will be disabled.
-
- :param node: Honeycomb node.
- :param dst_interface: Interface to mirror packets to.
- :param src_interfaces: List of interfaces to mirror packets from.
- :type node: dict
- :type dst_interface: str or int
- :type src_interfaces: list of dict
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If SPAN could not be configured.
- """
-
- interface = Topology.convert_interface_reference(
- node, dst_interface, "name")
- interface = interface.replace("/", "%2F")
- path = "/interface/" + interface + "/span"
-
- if not src_interfaces:
- status_code, _ = HcUtil.delete_honeycomb_data(
- node, "config_vpp_interfaces", path)
- else:
- for src_interface in src_interfaces:
- src_interface["iface-ref"] = Topology.\
- convert_interface_reference(
- node, src_interface["iface-ref"], "name")
- data = {
- "span": {
- "mirrored-interfaces": {
- "mirrored-interface": src_interfaces
- }
- }
- }
-
- status_code, _ = HcUtil.put_honeycomb_data(
- node, "config_vpp_interfaces", data, path)
-
- if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
- raise HoneycombError(
- "Configuring SPAN failed. Status code:{0}".format(status_code))
-
- @staticmethod
- def configure_sub_interface_span(node, super_interface, dst_interface_index,
- src_interfaces=None):
- """Configure SPAN port mirroring on the specified sub-interface. If no
- source interface is provided, SPAN will be disabled.
-
- Note: Does not support source sub-interfaces, only destination.
-
- :param node: Honeycomb node.
- :param super_interface: Name, link name or sw_if_index
- of the destination interface's super-interface.
- :param dst_interface_index: Index of sub-interface to mirror packets to.
- :param src_interfaces: List of interfaces to mirror packets from.
- :type node: dict
- :type super_interface: str or int
- :type dst_interface_index: int
- :type src_interfaces: list of dict
- :returns: Content of response.
- :rtype: bytearray
- :raises HoneycombError: If SPAN could not be configured.
- """
-
- super_interface = Topology.convert_interface_reference(
- node, super_interface, "name")
- super_interface = super_interface.replace("/", "%2F")
-
- path = "/interface/{0}/vpp-vlan:sub-interfaces/sub-interface/{1}/span"\
- .format(super_interface, dst_interface_index)
-
- if not src_interfaces:
- status_code, _ = HcUtil.delete_honeycomb_data(
- node, "config_vpp_interfaces", path)
- else:
- for src_interface in src_interfaces:
- src_interface["iface-ref"] = Topology. \
- convert_interface_reference(
- node, src_interface["iface-ref"], "name")
- data = {
- "span": {
- "mirrored-interfaces": {
- "mirrored-interface": src_interfaces
- }
- }
- }
-
- status_code, _ = HcUtil.put_honeycomb_data(
- node, "config_vpp_interfaces", data, path)
-
- if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
- raise HoneycombError(
- "Configuring SPAN failed. Status code:{0}".format(status_code))
-
- @staticmethod
- def add_interface_local0_to_topology(node):
- """Use Topology methods to add interface "local0" to working topology,
- if not already present.
-
- :param node: DUT node.
- :type node: dict
- """
-
- if Topology.get_interface_by_sw_index(node, 0) is None:
- local0_key = Topology.add_new_port(node, "localzero")
- Topology.update_interface_sw_if_index(node, local0_key, 0)
- Topology.update_interface_name(node, local0_key, "local0")
-
- @staticmethod
- def configure_interface_unnumbered(node, interface, interface_src=None):
- """Configure the specified interface as unnumbered. The interface
- borrows IP address from the specified source interface. If not source
- interface is provided, unnumbered configuration will be removed.
-
- :param node: Honeycomb node.
- :param interface: Name, link name or sw_if_index of an interface.
- :param interface_src: Name of source interface.
- :type node: dict
- :type interface: str or int
- :type interface_src: str
- :raises HoneycombError: If the configuration fails.
- """
-
- interface = InterfaceKeywords.handle_interface_reference(
- node, interface)
-
- path = "/interface/{0}/unnumbered-interfaces:unnumbered"\
- .format(interface)
-
- if interface_src:
- data = {
- "unnumbered": {
- "use": interface_src
- }
- }
- status_code, _ = HcUtil.put_honeycomb_data(
- node, "config_vpp_interfaces", data, path)
- else:
- status_code, _ = HcUtil.delete_honeycomb_data(
- node, "config_vpp_interfaces", path)
-
- if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
- raise HoneycombError(
- "Configuring unnumbered interface failed. "
- "Status code:{0}".format(status_code))
-
- @staticmethod
- def handle_interface_reference(node, interface):
- """Convert any interface reference to interface name used by Honeycomb.
-
- :param node: Honeycomb node.
- :param interface: Name, link name or sw_if_index of an interface,
- name of a custom interface or name of a sub-interface.
- :type node: Honeycomb node.
- :type interface: str or int
- :returns: Name of interface that can be used in Honeycomb requests.
- :rtype: str
- """
-
- try:
- interface = Topology.convert_interface_reference(
- node, interface, "name")
- interface = interface.replace("/", "%2F")
- except RuntimeError:
- # interface is not in topology
- if "." in interface:
- # Assume it's the name of a sub-interface
- interface, index = interface.split(".")
- interface = interface.replace("/", "%2F")
- interface = "{0}/vpp-vlan:sub-interfaces/sub-interface/{1}".\
- format(interface, index)
- else:
- # Assume it's the name of a custom interface (pbb, vxlan, etc.)
- interface = interface.replace("/", "%2F")
-
- return interface