-# Copyright (c) 2016 Cisco and/or its affiliates.
+# 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:
# See the License for the specific language governing permissions and
# limitations under the License.
-"""This module implements keywords to manipulate Lisp data structures using
+"""This module implements keywords to manipulate LISP data structures using
Honeycomb REST API."""
from resources.libraries.python.HTTPRequest import HTTPCodes
import HoneycombUtil as HcUtil
from resources.libraries.python.honeycomb.HoneycombUtil \
import DataRepresentation
+from resources.libraries.python.topology import Topology
class LispKeywords(object):
"""Implementation of keywords which make it possible to:
- - enable/disable Lisp feature
- - configure Lisp mappings
+ - enable/disable LISP feature
+ - configure LISP mappings
- configure locator sets
- configure map resolver
- - configure Lisp PITR feature
+ - configure LISP PITR feature
- read operational data for all of the above
"""
@staticmethod
def _set_lisp_properties(node, path, data=None):
- """Set Lisp properties and check the return code.
+ """Set LISP properties and check the return code.
:param node: Honeycomb node.
:param path: Path which is added to the base path to identify the data.
:returns: Content of response.
:rtype: bytearray
:raises HoneycombError: If the status code in response to PUT is not
- 200 = OK or 201 = ACCEPTED.
+ 200 = OK or 201 = ACCEPTED.
"""
if data:
status_code, resp = HcUtil.get_honeycomb_data(node, "oper_lisp")
if status_code != HTTPCodes.OK:
- raise HoneycombError("Could not retrieve Lisp operational data."
+ raise HoneycombError("Could not retrieve LISP operational data."
"Status code: {0}.".format(status_code))
else:
# get rid of empty vni-table entry
def verify_map_server_data_from_honeycomb(data, ip_addresses):
"""Verify whether MAP server data from Honeycomb is correct.
- :param data: Lisp operational data containing map server IP addresses.
+ :param data: LISP operational data containing map server IP addresses.
:param ip_addresses: IP addresses to verify map server data against.
:type data: dict
:type ip_addresses: list
def verify_map_server_data_from_vat(data, ip_addresses):
"""Verify whether MAP server data from VAT is correct.
- :param data: Lisp operational data containing map server IP addresses.
+ :param data: LISP operational data containing map server IP addresses.
:param ip_addresses: IP addresses to verify map server data against.
:type data: dict
:type ip_addresses: list
@staticmethod
def set_lisp_state(node, state=True):
- """Enable or disable the Lisp feature.
+ """Enable or disable the LISP feature.
:param node: Honeycomb node.
- :param state: Enable or disable Lisp.
+ :param state: Enable or disable LISP.
:type node: dict
:type state: bool
:returns: Content of response.
:rtype: bytearray
:raises HoneycombError: If the return code is not 200:OK
- or 404:NOT FOUND.
+ or 404:NOT FOUND.
"""
ret_code, data = HcUtil.get_honeycomb_data(node, "config_lisp")
if ret_code == HTTPCodes.OK:
data["lisp"]["enable"] = bool(state)
elif ret_code == HTTPCodes.NOT_FOUND:
- data = {"lisp": {"enable": bool(state)}}
+ data = {"lisp": {"enable": bool(state)}}
else:
raise HoneycombError("Unexpected return code when getting existing"
- " Lisp configuration.")
+ " LISP configuration.")
return LispKeywords._set_lisp_properties(node, '', data)
@staticmethod
def add_locator(node, interface, locator_set, priority=1, weight=1):
- """Configure a new Lisp locator set.
+ """Configure a new LISP locator set.
:param node: Honeycomb node.
:param interface: An interface on the node.
:param locator_set: Name for the new locator set.
:param priority: Priority parameter for the locator.
- :param weight. Weight parameter for the locator.
+ :param weight: Weight parameter for the locator.
:type node: dict
:type interface: str
:type locator_set: str
:rtype: bytearray
"""
+ interface = Topology.convert_interface_reference(
+ node, interface, "name")
+
path = "/lisp-feature-data/locator-sets/locator-set" \
"/{0}".format(locator_set)
"""Modify eid-table configuration to the data provided.
:param node: Honeycomb node.
- :param data: Settings for the Lisp mappings.
+ :param data: Settings for the LISP mappings.
:type node: dict
:type data: dict
:returns: Content of response.
@staticmethod
def configure_lisp_map_request_mode(node, option):
- """Modify Lisp Map Request Mode configuration to the data provided.
+ """Modify LISP Map Request Mode configuration to the data provided.
:param node: Honeycomb node.
- :param option: Settings for the Lisp map request mode.
+ :param option: Settings for the LISP map request mode.
:type node: dict
:type option: str
:returns: Content of response.
@staticmethod
def add_lisp_adjacency(node, vni_id, map_name, adjacency_name, data):
- """Add an adjacency to an existing Lisp mapping.
+ """Add an adjacency to an existing LISP mapping.
:param node: Honeycomb node.
:param vni_id: vni_id of the mapping.
data = {
"map-request-mode": {
"mode": "source-destination" if src_dst
- else "target-destination"
+ else "target-destination"
}
}
@staticmethod
def disable_lisp(node):
- """Remove all Lisp settings on the node.
+ """Remove all LISP settings on the node.
:param node: Honeycomb node.
:type node: dict
"""
return LispKeywords._set_lisp_properties(node, "")
+
+
+class LispGPEKeywords(object):
+ """Implementation of keywords which make it possible to:
+ - enable/disable LISP GPE feature
+ - configure LISP GPE forwarding entries
+ - read operational data for all of the above
+ """
+
+ def __init__(self):
+ """Initializer."""
+ pass
+
+ @staticmethod
+ def _set_lispgpe_properties(node, path, data=None):
+ """Set LISP GPE properties and check the return code.
+
+ :param node: Honeycomb node.
+ :param path: Path which is added to the base path to identify the data.
+ :param data: The new data to be set. If None, the item will be removed.
+ :type node: dict
+ :type path: str
+ :type data: dict
+ :returns: Content of response.
+ :rtype: bytearray
+ :raises HoneycombError: If the status code in response to PUT is not
+ 200 = OK or 201 = ACCEPTED.
+ """
+
+ if data:
+ status_code, resp = HcUtil.\
+ put_honeycomb_data(node, "config_lisp_gpe", data, path,
+ data_representation=DataRepresentation.JSON)
+ else:
+ status_code, resp = HcUtil.\
+ delete_honeycomb_data(node, "config_lisp_gpe", path)
+
+ if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
+ raise HoneycombError(
+ "Lisp GPE configuration unsuccessful. "
+ "Status code: {0}.".format(status_code))
+ else:
+ return resp
+
+ @staticmethod
+ def get_lispgpe_operational_data(node):
+ """Retrieve LISP GPE properties from Honeycomb operational data.
+
+ :param node: Honeycomb node.
+ :type node: dict
+ :returns: LISP GPE operational data.
+ :rtype: bytearray
+ :raises HoneycombError: If the status code in response to GET is not
+ 200 = OK.
+ """
+
+ status_code, resp = HcUtil.get_honeycomb_data(node, "oper_lisp_gpe")
+
+ if status_code != HTTPCodes.OK:
+ raise HoneycombError("Could not retrieve Lisp GPE operational data."
+ "Status code: {0}.".format(status_code))
+ else:
+ return resp
+
+ @staticmethod
+ def get_lispgpe_mapping(node, name):
+ """Retrieve LISP GPE operational data and parse for a specific mapping.
+
+ :param node: Honeycomb node.
+ :param name: Name of the mapping to look for.
+ :type node: dict
+ :type name: str
+ :returns: LISP GPE mapping.
+ :rtype: dict
+ :raises HoneycombError: If the mapping is not present in operational
+ data.
+ """
+
+ data = LispGPEKeywords.get_lispgpe_operational_data(node)
+ try:
+ data = data["gpe-state"]["gpe-feature-data"]["gpe-entry-table"] \
+ ["gpe-entry"]
+ except KeyError:
+ raise HoneycombError("No mappings present in operational data.")
+ for item in data:
+ if item["id"] == name:
+ mapping = item
+ break
+ else:
+ raise HoneycombError("Mapping with name {name} not found in "
+ "operational data.".format(name=name))
+
+ return mapping
+
+ @staticmethod
+ def get_lispgpe_config_data(node):
+ """Retrieve LISP GPE properties from Honeycomb config data.
+
+ :param node: Honeycomb node.
+ :type node: dict
+ :returns: LISP GPE config data.
+ :rtype: bytearray
+ :raises HoneycombError: If the status code in response to GET is not
+ 200 = OK.
+ """
+
+ status_code, resp = HcUtil.get_honeycomb_data(node, "config_lisp_gpe")
+
+ if status_code != HTTPCodes.OK:
+ raise HoneycombError("Could not retrieve Lisp GPE config data."
+ "Status code: {0}.".format(status_code))
+ else:
+ return resp
+
+ @staticmethod
+ def set_lispgpe_state(node, state=True):
+ """Enable or disable the LISP GPE feature.
+
+ :param node: Honeycomb node.
+ :param state: Enable or disable LISP.
+ :type node: dict
+ :type state: bool
+ :returns: Content of response.
+ :rtype: bytearray
+ :raises HoneycombError: If the return code is not 200:OK
+ or 404:NOT FOUND.
+ """
+
+ ret_code, data = HcUtil.get_honeycomb_data(node, "config_lisp_gpe")
+ if ret_code == HTTPCodes.OK:
+ data["gpe"]["gpe-feature-data"]["enable"] = bool(state)
+ elif ret_code == HTTPCodes.NOT_FOUND:
+ data = {"gpe": {"gpe-feature-data": {"enable": bool(state)}}}
+ else:
+ raise HoneycombError("Unexpected return code when getting existing"
+ " Lisp GPE configuration.")
+
+ return LispGPEKeywords._set_lispgpe_properties(node, '', data)
+
+ @staticmethod
+ def configure_lispgpe_mapping(node, data=None):
+ """Modify LISP GPE mapping configuration to the data provided.
+
+ :param node: Honeycomb node.
+ :param data: Settings for the LISP GPE mappings.
+ :type node: dict
+ :type data: dict
+ :returns: Content of response.
+ :rtype: bytearray
+ """
+
+ path = "/gpe-feature-data/gpe-entry-table"
+ if data:
+ data = {"gpe-entry-table": {"gpe-entry": data}}
+ return LispGPEKeywords._set_lispgpe_properties(node, path, data)
+ else:
+ return LispGPEKeywords._set_lispgpe_properties(node, path)
+
+ @staticmethod
+ def add_lispgpe_mapping(node, name, data):
+ """Add the specified LISP GPE mapping.
+
+ :param node: Honeycomb node.
+ :param name: Name for the mapping.
+ :param data: Mapping details.
+ :type node: dict
+ :type name: str
+ :type data: dict
+ :returns: Content of response.
+ :rtype: bytearray
+ """
+
+ path = "/gpe-feature-data/gpe-entry-table/gpe-entry/{name}".format(
+ name=name)
+
+ data = {"gpe-entry": data}
+ return LispGPEKeywords._set_lispgpe_properties(node, path, data)
+
+ @staticmethod
+ def delete_lispgpe_mapping(node, mapping):
+ """Delete the specified LISP GPE mapping from configuration.
+
+ :param node: Honeycomb node.
+ :param mapping: Name of the mapping to remove.
+ :type node: dict
+ :type mapping: str
+ :returns: Content of response.
+ :rtype: bytearray
+ """
+
+ path = "/gpe-feature-data/gpe-entry-table/gpe-entry/{0}".format(mapping)
+ return LispGPEKeywords._set_lispgpe_properties(node, path)
+
+ @staticmethod
+ def disable_lispgpe(node):
+ """Remove all LISP GPE settings on the node.
+
+ :param node: Honeycomb node.
+ :type node: dict
+ :returns: Content of response.
+ :rtype: bytearray
+ """
+
+ return LispGPEKeywords._set_lispgpe_properties(node, "")