X-Git-Url: https://gerrit.fd.io/r/gitweb?p=csit.git;a=blobdiff_plain;f=resources%2Flibraries%2Fpython%2Fhoneycomb%2FHcAPIKwACL.py;h=556c39644f806fa476505f1c7852defc6ed05382;hp=c11e3251943e92faee77a589b53db043e1ac98cc;hb=b5fe0fd9a4266773125cc4d4c1edaa1c1a8a1731;hpb=28e17b8002b50a04cdd6c9e74c15cdc4aa33a5e2 diff --git a/resources/libraries/python/honeycomb/HcAPIKwACL.py b/resources/libraries/python/honeycomb/HcAPIKwACL.py index c11e325194..556c39644f 100644 --- a/resources/libraries/python/honeycomb/HcAPIKwACL.py +++ b/resources/libraries/python/honeycomb/HcAPIKwACL.py @@ -13,7 +13,9 @@ """This module implements keywords to manipulate ACL data structures using Honeycomb REST API.""" +from robot.api import logger +from resources.libraries.python.topology import Topology from resources.libraries.python.HTTPRequest import HTTPCodes from resources.libraries.python.honeycomb.HoneycombSetup import HoneycombError from resources.libraries.python.honeycomb.HoneycombUtil \ @@ -45,7 +47,7 @@ class ACLKeywords(object): :type node: dict :type path: str :type data: dict - :return: Content of response. + :returns: Content of response. :rtype: bytearray :raises HoneycombError: If the status code in response to PUT is not 200 = OK. @@ -59,10 +61,13 @@ class ACLKeywords(object): status_code, resp = HcUtil.\ delete_honeycomb_data(node, "config_classify_table", path) - if status_code != HTTPCodes.OK: - raise HoneycombError( - "The configuration of classify table was not successful. " - "Status code: {0}.".format(status_code)) + if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED): + if data is None and '"error-tag":"data-missing"' in resp: + logger.debug("data does not exist in path.") + else: + raise HoneycombError( + "The configuration of classify table was not successful. " + "Status code: {0}.".format(status_code)) return resp @staticmethod @@ -74,7 +79,7 @@ class ACLKeywords(object): :param table: Classify table to be added. :type node: dict :type table: dict - :return: Content of response. + :returns: Content of response. :rtype: bytearray """ @@ -88,7 +93,7 @@ class ACLKeywords(object): :param node: Honeycomb node. :type node: dict - :return: Content of response. + :returns: Content of response. :rtype: bytearray """ @@ -102,7 +107,7 @@ class ACLKeywords(object): :param table_name: Name of the classify table to be removed. :type node: dict :type table_name: str - :return: Content of response. + :returns: Content of response. :rtype: bytearray """ @@ -115,7 +120,7 @@ class ACLKeywords(object): :param node: Honeycomb node. :type node: dict - :return: List of classify tables. + :returns: List of classify tables. :rtype: list """ @@ -126,10 +131,8 @@ class ACLKeywords(object): raise HoneycombError( "Not possible to get operational information about the " "classify tables. Status code: {0}.".format(status_code)) - try: - return resp["vpp-classifier"]["classify-table"] - except (KeyError, TypeError): - return [] + + return resp["vpp-classifier-state"]["classify-table"] @staticmethod def get_classify_table_oper_data(node, table_name): @@ -139,22 +142,16 @@ class ACLKeywords(object): :param table_name: Name of the classify table. :type node: dict :type table_name: str - :return: Operational data about the given classify table. + :returns: Operational data about the given classify table. :rtype: dict """ - path = "/classify-table/" + table_name - status_code, resp = HcUtil.\ - get_honeycomb_data(node, "oper_classify_table", path) - - if status_code != HTTPCodes.OK: - raise HoneycombError( - "Not possible to get operational information about the " - "classify tables. Status code: {0}.".format(status_code)) - try: - return resp["classify-table"][0] - except (KeyError, TypeError): - return [] + tables = ACLKeywords.get_all_classify_tables_oper_data(node) + for table in tables: + if table["name"] == table_name: + return table + raise HoneycombError("Table {0} not found in ACL table list.".format( + table_name)) @staticmethod def get_all_classify_tables_cfg_data(node): @@ -162,7 +159,7 @@ class ACLKeywords(object): :param node: Honeycomb node. :type node: dict - :return: List of classify tables. + :returns: List of classify tables. :rtype: list """ @@ -188,7 +185,7 @@ class ACLKeywords(object): :type node: dict :type table_name: str :type session: dict - :return: Content of response. + :returns: Content of response. :rtype: bytearray """ @@ -207,7 +204,7 @@ class ACLKeywords(object): :type node: dict :type table_name: str :type session_match: str - :return: Content of response. + :returns: Content of response. :rtype: bytearray """ @@ -224,15 +221,13 @@ class ACLKeywords(object): :param table_name: Name of the classify table. :type node: dict :type table_name: str - :return: List of classify sessions present in the classify table. + :returns: List of classify sessions present in the classify table. :rtype: list """ table_data = ACLKeywords.get_classify_table_oper_data(node, table_name) - try: - return table_data["classify-table"][0]["classify-session"] - except (KeyError, TypeError): - return [] + + return table_data["classify-session"] @staticmethod def get_classify_session_oper_data(node, table_name, session_match): @@ -245,20 +240,156 @@ class ACLKeywords(object): :type node: dict :type table_name: str :type session_match: str - :return: Classify session operational data. + :returns: Classify session operational data. :rtype: dict + :raises HoneycombError: If no session the specified match Id is found. """ - path = "/classify-table/" + table_name + \ - "/classify-session/" + session_match - status_code, resp = HcUtil.\ - get_honeycomb_data(node, "oper_classify_table", path) + sessions = ACLKeywords.get_all_classify_sessions_oper_data( + node, table_name) + for session in sessions: + if session["match"] == session_match: + return session + raise HoneycombError( + "Session with match value \"{0}\" not found" + " under ACL table {1}.".format(session_match, table_name)) + + @staticmethod + def create_acl_plugin_classify_chain(node, list_name, data, macip=False): + """Create classify chain using the ietf-acl node. + + :param node: Honeycomb node. + :param list_name: Name for the classify list. + :param data: Dictionary of settings to send to Honeycomb. + :param macip: Use simple MAC+IP classifier. Optional. + :type node: dict + :type list_name: str + :type data: dict + :type macip: bool + + :returns: Content of response. + :rtype: bytearray + :raises HoneycombError: If the operation fails. + """ + + if macip: + path = "/acl/vpp-acl:vpp-macip-acl/{0}".format(list_name) + else: + path = "/acl/vpp-acl:vpp-acl/{0}".format(list_name) + + status_code, resp = HcUtil.put_honeycomb_data( + node, "config_plugin_acl", data, path) + + if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED): + raise HoneycombError( + "Could not create classify chain." + "Status code: {0}.".format(status_code)) + + return resp + + @staticmethod + def set_acl_plugin_interface(node, interface, acl_name, + direction, macip=False): + """Assign an interface to an ietf-acl classify chain. + + :param node: Honeycomb node. + :param interface: Name of an interface on the node. + :param acl_name: Name of an ACL chain configured through ACL-plugin. + :param direction: Classify incoming or outgiong packets. + Valid options are: ingress, egress + :param macip: Use simple MAC+IP classifier. Optional. + :type node: dict + :type interface: str or int + :type acl_name: str + :type direction: str + :type macip: bool + + :returns: Content of response. + :rtype: bytearray + :raises ValueError: If the direction argument is incorrect. + :raises HoneycombError: If the operation fails. + """ + + interface = Topology.convert_interface_reference( + node, interface, "name") + + interface = interface.replace("/", "%2F") + + if direction not in ("ingress", "egress"): + raise ValueError("Unknown traffic direction {0}. " + "Valid options are: ingress, egress." + .format(direction)) + + path = "/interface/{0}/interface-acl:acl/{1}".format( + interface, direction) + + if macip: + data = { + direction: { + "vpp-macip-acl": { + "type": "vpp-acl:vpp-macip-acl", + "name": acl_name + } + } + } + else: + data = { + direction: { + "vpp-acls": [ + { + "type": "vpp-acl:vpp-acl", + "name": acl_name + } + ] + } + } + + status_code, resp = HcUtil.put_honeycomb_data( + node, "config_vpp_interfaces", data, path) + + if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED): + raise HoneycombError( + "Could not configure ACL on interface. " + "Status code: {0}.".format(status_code)) + + return resp + + @staticmethod + def delete_interface_plugin_acls(node, interface): + """Remove all plugin-acl assignments from an interface. + + :param node: Honeycomb node. + :param interface: Name of an interface on the node. + :type node: dict + :type interface: str or int + """ + + interface = Topology.convert_interface_reference( + node, interface, "name") + + interface = interface.replace("/", "%2F") + + path = "/interface/{0}/interface-acl:acl/".format(interface) + status_code, _ = HcUtil.delete_honeycomb_data( + node, "config_vpp_interfaces", path) if status_code != HTTPCodes.OK: raise HoneycombError( - "Not possible to get operational information about the " - "classify tables. Status code: {0}.".format(status_code)) - try: - return resp["classify-session"][0] - except (KeyError, TypeError): - return {} + "Could not remove ACL assignment from interface. " + "Status code: {0}.".format(status_code)) + + @staticmethod + def delete_acl_plugin_classify_chains(node): + """Remove all plugin-ACL classify chains. + + :param node: Honeycomb node. + :type node: dict + """ + + status_code, _ = HcUtil.delete_honeycomb_data( + node, "config_plugin_acl") + + if status_code != HTTPCodes.OK: + raise HoneycombError( + "Could not remove plugin-acl chain. " + "Status code: {0}.".format(status_code))