diff options
Diffstat (limited to 'resources/libraries/python/HoneycombAPIKeywords.py')
| -rw-r--r-- | resources/libraries/python/HoneycombAPIKeywords.py | 543 |
1 files changed, 0 insertions, 543 deletions
diff --git a/resources/libraries/python/HoneycombAPIKeywords.py b/resources/libraries/python/HoneycombAPIKeywords.py deleted file mode 100644 index 0369a32d5b..0000000000 --- a/resources/libraries/python/HoneycombAPIKeywords.py +++ /dev/null @@ -1,543 +0,0 @@ -# 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)) |