--- /dev/null
+# Copyright (c) 2016 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 used with Honeycomb.
+
+There are implemented keywords which work with:
+- Honeycomb operations
+- VPP Interfaces
+- Bridge domains
+
+The keywords make possible to put and get configuration data and to get
+operational data.
+"""
+
+from json import dumps
+
+from robot.api import logger
+
+from resources.libraries.python.HTTPRequest import HTTPCodes
+from resources.libraries.python.HoneycombSetup import HoneycombError
+from resources.libraries.python.HoneycombUtil import HoneycombUtil as HcUtil
+from resources.libraries.python.HoneycombUtil import DataRepresentation
+
+
+class OperationsKeywords(object):
+ """Keywords which perform "operations" in Honeycomb.
+
+ The keywords in this class are not a part of a specific area in Honeycomb,
+ e.g.: interfaces or bridge domains, but they perform "operations" in any
+ area of Honeycomb.
+ """
+
+ def __init__(self):
+ pass
+
+ @staticmethod
+ def poll_oper_data(node):
+ """Poll operational data.
+
+ You can use this keyword when you configure something in Honeycomb and
+ you want configuration data to make effect immediately, e.g.:
+
+ | | Create Bridge Domain | ....
+ | | Add Bridge Domain To Interface | ....
+ | | Poll Oper Data | ....
+ | | ${br}= | Get Oper Info About Bridge Domain | ....
+
+ ..note:: This is not very reliable way how to poll operational data.
+ This keyword is only temporary workaround and will be removed when this
+ problem is solved in Honeycomb.
+ :param node: Honeycomb node.
+ :type: dict
+ :raises HoneycombError: If it is not possible to poll operational data.
+ """
+
+ status_code, _ = HcUtil.\
+ post_honeycomb_data(node, "poll_oper_data", data='',
+ data_representation=DataRepresentation.NO_DATA,
+ timeout=30)
+ if status_code != HTTPCodes.OK:
+ raise HoneycombError("It was not possible to poll operational data "
+ "on node {0}.".format(node['host']))
+
+
+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.
+ """
+
+ 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: str
+ :type data_representation: DataRepresentation
+ :return: 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 != HTTPCodes.OK:
+ 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
+ :return: 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:
+ intf = HcUtil.parse_json_response(resp, ("interfaces", "interface"))
+ return intf
+ except KeyError:
+ return []
+
+ @staticmethod
+ def get_interface_cfg_info(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
+ :return: 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_info(node):
+ """Get operational data about all interfaces from Honeycomb.
+
+ :param node: Honeycomb node.
+ :type node: dict
+ :return: 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:
+ intf = HcUtil.parse_json_response(resp, ("interfaces-state",
+ "interface"))
+ return intf
+ except KeyError:
+ return []
+
+ @staticmethod
+ def get_interface_oper_info(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
+ :return: Operational data about the given interface from Honeycomb.
+ :rtype: dict
+ """
+
+ intfs = InterfaceKeywords.get_all_interfaces_oper_info(node)
+ for intf in intfs:
+ if intf["name"] == interface:
+ return intf
+ return {}
+
+ @staticmethod
+ def 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: The name of interface.
+ :param state: The requested state, only "up" and "down" are valid
+ values.
+ :type node: dict
+ :type interface: str
+ :type state: str
+ :return: 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"}
+ intfs = InterfaceKeywords.get_all_interfaces_cfg_data(node)
+ for intf in intfs:
+ if intf["name"] == interface:
+ intf["enabled"] = intf_state[state.lower()]
+ new_intf = {"interfaces": {"interface": intfs}}
+ return InterfaceKeywords._configure_interface(node, interface,
+ dumps(new_intf))
+ raise HoneycombError("The interface '{0}' is not present on node "
+ "'{1}'.".format(interface, node['host']))
+
+ @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
+ :return: Content of response
+ :rtype: bytearray
+ """
+
+ return InterfaceKeywords.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
+ :return: Content of response.
+ :rtype: bytearray
+ """
+
+ return InterfaceKeywords.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: The name of interface.
+ :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
+ :return: Content of response.
+ :rtype: bytearray
+ :raises HoneycombError: If the interface is not present on the node.
+ """
+
+ intfs = InterfaceKeywords.get_all_interfaces_cfg_data(node)
+ 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)
+ for intf in intfs:
+ if intf["name"] == interface:
+ intf["v3po:l2"] = v3po_l2
+ new_intf = {"interfaces": {"interface": intfs}}
+ return InterfaceKeywords._configure_interface(node, interface,
+ dumps(new_intf))
+ raise HoneycombError("The interface '{0}' is not present on node "
+ "'{1}'.".format(interface, node['host']))
+
+
+class BridgeDomainKeywords(object):
+ """Keywords for Bridge domain manipulation.
+
+ Implements keywords which get configuration and operational data about
+ bridge domains and put the bridge domains' parameters using Honeycomb REST
+ API.
+ """
+
+ def __init__(self):
+ pass
+
+ @staticmethod
+ def _create_json_bridge_domain_info(name, **kwargs):
+ """Generate bridge domain information in the structure as it is expected
+ by Honeycomb.
+
+ The generated data structure is as follows:
+ {
+ "bridge-domains": {
+ "bridge-domain": [
+ {
+ "name": "bd_name",
+ "flood": "false",
+ "forward": "false",
+ "learn": "false",
+ "unknown-unicast-flood": "false",
+ "arp-termination": "false"
+ }
+ ]
+ }
+ }
+
+ :param name: The name of new bridge-domain.
+ :param kwargs: named arguments:
+ flood (bool): If True, flooding is enabled.
+ forward (bool): If True, packet forwarding is enabled.
+ learn (bool): If True, learning is enabled.
+ uu_flood (bool): If True, unknown unicast flooding is enabled.
+ arp_termination (bool): If True, ARP termination is enabled.
+ :type name: str
+ :type kwargs: dict
+ :return: Bridge domain information in format suitable for Honeycomb.
+ :rtype: dict
+ :raises KeyError: If at least one of kwargs items is missing.
+ """
+
+ brd_info = {
+ "bridge-domains": {
+ "bridge-domain": [
+ {"name": name,
+ "flood": str(kwargs["flood"]).lower(),
+ "forward": str(kwargs["forward"]).lower(),
+ "learn": str(kwargs["learn"]).lower(),
+ "unknown-unicast-flood": str(kwargs["uu_flood"]).lower(),
+ "arp-termination": str(kwargs["arp_termination"]).lower()},
+ ]
+ }
+ }
+
+ return brd_info
+
+ @staticmethod
+ def create_bridge_domain(node, name, flood=True, forward=True, learn=True,
+ uu_flood=True, arp_termination=False):
+ """Create a bridge domain using Honeycomb.
+
+ This keyword adds a new bridge domain to the list of bridge domains and
+ sets its parameters. The existing bridge domains are untouched.
+ :param node: Node with Honeycomb where the bridge domain should be
+ created.
+ :param name: The name of new bridge-domain.
+ :param flood: If True, flooding is enabled.
+ :param forward: If True, packet forwarding is enabled.
+ :param learn: If True, learning is enabled.
+ :param uu_flood: If True, unknown unicast flooding is enabled.
+ :param arp_termination: If True, ARP termination is enabled.
+ :type node: dict
+ :type name: str
+ :type flood: bool
+ :type forward: bool
+ :type learn: bool
+ :type uu_flood: bool
+ :type arp_termination: bool
+ :raises HoneycombError: If the bridge domain already exists or it has
+ not been created.
+ """
+
+ existing_brds = BridgeDomainKeywords.\
+ get_all_bds_cfg_data(node, ignore_404=True)
+
+ for brd in existing_brds:
+ if brd["name"] == name:
+ raise HoneycombError("Bridge domain {0} already exists.".
+ format(name))
+
+ brd_info = BridgeDomainKeywords._create_json_bridge_domain_info(
+ name, flood=flood, forward=forward, learn=learn, uu_flood=uu_flood,
+ arp_termination=arp_termination)
+ for brd in existing_brds:
+ brd_info["bridge-domains"]["bridge-domain"].append(brd)
+
+ status_code, _ = HcUtil.put_honeycomb_data(node, "config_bridge_domain",
+ dumps(brd_info))
+ if status_code != HTTPCodes.OK:
+ raise HoneycombError(
+ "Bridge domain {0} was not created. "
+ "Status code: {01}.".format(name, status_code))
+
+ @staticmethod
+ def get_all_bds_oper_data(node):
+ """Get operational data about all bridge domains from Honeycomb.
+
+ :param node: Honeycomb node.
+ :type node: dict
+ :return: Operational data about all bridge domains from Honeycomb.
+ :rtype: list
+ :raises HoneycombError: If it is not possible to get information about
+ the bridge domains.
+ """
+
+ status_code, resp = HcUtil.get_honeycomb_data(node,
+ "oper_bridge_domains")
+ if status_code != HTTPCodes.OK:
+ raise HoneycombError(
+ "Not possible to get information about the bridge domains. "
+ "Status code: {0}.".format(status_code))
+ try:
+ br_domains = HcUtil.parse_json_response(resp, ("bridge-domains",
+ "bridge-domain"))
+ except KeyError:
+ return []
+ return br_domains
+
+ @staticmethod
+ def get_bd_oper_data(node, name):
+ """Get operational data about the given bridge domain from Honeycomb.
+
+ :param node: Honeycomb node.
+ :param name: The name of bridge domain.
+ :type node: dict
+ :type name: str
+ :return: Operational data about the given bridge domain from Honeycomb.
+ :rtype: dict
+ """
+
+ br_domains = BridgeDomainKeywords.get_all_bds_oper_data(node)
+ for br_domain in br_domains:
+ if br_domain["name"] == name:
+ br_domain["name"] = br_domain["name"]
+ return br_domain
+ return {}
+
+ @staticmethod
+ def get_all_bds_cfg_data(node, ignore_404=False):
+ """Get configuration data about all bridge domains from Honeycomb.
+
+ :param node: Honeycomb node.
+ :param ignore_404: If True, the error 404 is ignored.
+ :type node: dict
+ :type ignore_404: bool
+ :return: Configuration data about all bridge domains from Honeycomb.
+ :rtype: list
+ :raises HoneycombError: If it is not possible to get information about
+ the bridge domains.
+ """
+
+ status_code, resp = HcUtil.get_honeycomb_data(node,
+ "config_bridge_domain")
+ if status_code != HTTPCodes.OK:
+ if ignore_404 and status_code == HTTPCodes.NOT_FOUND:
+ br_domains = list()
+ logger.debug("Error 404 ignored")
+ else:
+ raise HoneycombError(
+ "Not possible to get information about the bridge domains. "
+ "Status code: {0}.".format(status_code))
+ else:
+ try:
+ br_domains = HcUtil.parse_json_response(resp, ("bridge-domains",
+ "bridge-domain"))
+ except KeyError:
+ return []
+ return br_domains
+
+ @staticmethod
+ def get_bd_cfg_data(node, name):
+ """Get configuration data about the given bridge domain from Honeycomb.
+
+ :param node: Honeycomb node.
+ :param name: The name of bridge domain.
+ :type node: dict
+ :type name: str
+ :return: Configuration data about the given bridge domain from
+ Honeycomb.
+ :rtype: dict
+ """
+
+ br_domains = BridgeDomainKeywords.get_all_bds_cfg_data(node)
+ for br_domain in br_domains:
+ if br_domain["name"] == name:
+ return br_domain
+ return {}
+
+ @staticmethod
+ def delete_all_bridge_domains(node):
+ """Delete all bridge domains on Honeycomb node.
+
+ :param node: Honeycomb node.
+ :type node: dict
+ :return: Response from DELETE request.
+ :rtype: str
+ :raises HoneycombError: If it is not possible to delete all bridge
+ domains.
+ """
+
+ status_code, resp = HcUtil.delete_honeycomb_data(node,
+ "config_bridge_domain")
+ if status_code != HTTPCodes.OK:
+ raise HoneycombError(
+ "Not possible to delete all bridge domains. "
+ "Status code: {0}.".format(status_code))
+ return resp
+
+ @staticmethod
+ def remove_bridge_domain(node, name):
+ """Remove one bridge domain from Honeycomb.
+
+ :param node: Honeycomb node.
+ :param name: Name of the bridge domain to be removed.
+ :type node: dict
+ :type name: str
+ :return: True if the bridge domain was removed.
+ :rtype: bool
+ :raises HoneycombError: If it is not possible to remove the bridge
+ domain.
+ """
+
+ br_domains = BridgeDomainKeywords.get_all_bds_cfg_data(node)
+ for br_domain in br_domains:
+ if br_domain["name"] == name:
+ br_domains.remove(br_domain)
+ brd_info = {"bridge-domains": {"bridge-domain": br_domains}}
+ status_code, _ = HcUtil.put_honeycomb_data(
+ node, "config_bridge_domain", dumps(brd_info))
+ if status_code != HTTPCodes.OK:
+ raise HoneycombError(
+ "Bridge domain '{0}' was not deleted. "
+ "Status code: {1}.".format(name, status_code))
+ return True
+
+ raise HoneycombError("Not possible to delete bridge domain '{0}'. The "
+ "bridge domain was not found".format(name))
"""
from json import loads
+from enum import Enum, unique
from robot.api import logger
from resources.libraries.python.constants import Constants as Const
+@unique
+class DataRepresentation(Enum):
+ """Representation of data sent by PUT and POST requests."""
+ NO_DATA = 0
+ JSON = 1
+ XML = 2
+ TXT = 3
+
+
+# Headers used in requests. Key - content representation, value - header.
+HEADERS = {DataRepresentation.NO_DATA:
+ {}, # Must be empty.
+ DataRepresentation.JSON:
+ {"Content-Type": "application/json",
+ "Accept": "text/plain"},
+ DataRepresentation.XML:
+ {"Content-Type": "application/xml",
+ "Accept": "text/plain"},
+ DataRepresentation.TXT:
+ {"Content-Type": "text/plain",
+ "Accept": "text/plain"}
+ }
+
+
class HoneycombError(Exception):
"""Exception(s) raised by methods working with Honeycomb.
without extension, not the full path.
:type node: dict
:type url_file: str
- :return: Requested information.
- :rtype list
+ :return: Status code and content of response.
+ :rtype tuple
"""
path = HoneycombUtil.read_path_from_url_file(url_file)
- status_code, resp = HTTPRequest.get(node, path)
- return status_code, resp
+ return HTTPRequest.get(node, path)
@staticmethod
- def put_honeycomb_data(node, url_file, data, data_representation='json'):
+ def put_honeycomb_data(node, url_file, data,
+ data_representation=DataRepresentation.JSON):
"""Send configuration data using PUT request and return the status code
- and response.
+ and response content.
:param node: Honeycomb node.
:param url_file: URL file. The argument contains only the name of file
without extension, not the full path.
:param data: Configuration data to be sent to Honeycomb.
- :param data_representation: How the data is represented. Supported types
- of representation are: json, xml and txt.
+ :param data_representation: How the data is represented.
:type node: dict
:type url_file: str
:type data: str
- :type data_representation: str
+ :type data_representation: DataRepresentation
:return: Status code and content of response.
:rtype: tuple
+ :raises HoneycombError: If the given data representation is not defined
+ in HEADERS.
"""
- headers = {'json':
- {"Content-Type": "application/json",
- 'Accept': 'text/plain'},
- 'xml':
- {"Content-Type": "application/xml",
- 'Accept': 'text/plain'},
- 'txt':
- {"Content-Type": "text/plain",
- 'Accept': 'text/plain'}
- }
try:
- header = headers[data_representation]
- except KeyError as err:
- raise HoneycombError("Wrong data type: {0}.".
+ header = HEADERS[data_representation]
+ except AttributeError as err:
+ raise HoneycombError("Wrong data representation: {0}.".
format(data_representation), repr(err))
path = HoneycombUtil.read_path_from_url_file(url_file)
- status_code, resp = HTTPRequest.put(node=node, path=path,
- headers=header, payload=data)
- return status_code, resp
+ return HTTPRequest.put(node=node, path=path, headers=header,
+ payload=data)
+
+ @staticmethod
+ def post_honeycomb_data(node, url_file, data=None,
+ data_representation=DataRepresentation.JSON,
+ timeout=10):
+ """Send a POST request and return the status code and response content.
+
+ :param node: Honeycomb node.
+ :param url_file: URL file. The argument contains only the name of file
+ without extension, not the full path.
+ :param data: Configuration data to be sent to Honeycomb.
+ :param data_representation: How the data is represented.
+ :param timeout: How long to wait for the server to send data before
+ giving up.
+ :type node: dict
+ :type url_file: str
+ :type data: str
+ :type data_representation: DataRepresentation
+ :type timeout: int
+ :return: Status code and content of response.
+ :rtype: tuple
+ :raises HoneycombError: If the given data representation is not defined
+ in HEADERS.
+ """
+
+ try:
+ header = HEADERS[data_representation]
+ except AttributeError as err:
+ raise HoneycombError("Wrong data representation: {0}.".
+ format(data_representation), repr(err))
+
+ path = HoneycombUtil.read_path_from_url_file(url_file)
+ return HTTPRequest.post(node=node, path=path, headers=header,
+ payload=data, timeout=timeout)
@staticmethod
def delete_honeycomb_data(node, url_file):
without extension, not the full path.
:type node: dict
:type url_file: str
- :return: Status code and response.
+ :return: Status code and content of response.
:rtype tuple
"""
Code Review / csit.git / commitdiff