7ec259347c8da2487582a5863564a933ac3e1e5e
[csit.git] / resources / libraries / python / honeycomb / Lisp.py
1 # Copyright (c) 2016 Cisco and/or its affiliates.
2 # Licensed under the Apache License, Version 2.0 (the "License");
3 # you may not use this file except in compliance with the License.
4 # You may obtain a copy of the License at:
5 #
6 #     http://www.apache.org/licenses/LICENSE-2.0
7 #
8 # Unless required by applicable law or agreed to in writing, software
9 # distributed under the License is distributed on an "AS IS" BASIS,
10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 # See the License for the specific language governing permissions and
12 # limitations under the License.
13
14 """This module implements keywords to manipulate Lisp data structures using
15 Honeycomb REST API."""
16
17 from resources.libraries.python.HTTPRequest import HTTPCodes
18 from resources.libraries.python.honeycomb.HoneycombSetup import HoneycombError
19 from resources.libraries.python.honeycomb.HoneycombUtil \
20     import HoneycombUtil as HcUtil
21 from resources.libraries.python.honeycomb.HoneycombUtil \
22     import DataRepresentation
23
24
25 class LispKeywords(object):
26     """Implementation of keywords which make it possible to:
27     - enable/disable Lisp feature
28     - configure Lisp mappings
29     - configure locator sets
30     - configure map resolver
31     - configure Lisp PITR feature
32     - read operational data for all of the above
33     """
34
35     def __init__(self):
36         """Initializer."""
37         pass
38
39     @staticmethod
40     def _set_lisp_properties(node, path, data=None):
41         """Set Lisp properties and check the return code.
42
43         :param node: Honeycomb node.
44         :param path: Path which is added to the base path to identify the data.
45         :param data: The new data to be set. If None, the item will be removed.
46         :type node: dict
47         :type path: str
48         :type data: dict
49         :returns: Content of response.
50         :rtype: bytearray
51         :raises HoneycombError: If the status code in response to PUT is not
52         200 = OK or 201 = ACCEPTED.
53         """
54
55         if data:
56             status_code, resp = HcUtil.\
57                 put_honeycomb_data(node, "config_lisp", data, path,
58                                    data_representation=DataRepresentation.JSON)
59         else:
60             status_code, resp = HcUtil.\
61                 delete_honeycomb_data(node, "config_lisp", path)
62
63         if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
64             raise HoneycombError(
65                 "Lisp configuration unsuccessful. "
66                 "Status code: {0}.".format(status_code))
67         else:
68             return resp
69
70     @staticmethod
71     def get_lisp_operational_data(node):
72         """Retrieve Lisp properties from Honeycomb operational data.
73
74         :param node: Honeycomb node.
75         :type node: dict
76         :returns: List operational data.
77         :rtype: bytearray
78         """
79
80         status_code, resp = HcUtil.get_honeycomb_data(node, "oper_lisp")
81
82         if status_code != HTTPCodes.OK:
83             raise HoneycombError("Could not retrieve Lisp operational data."
84                                  "Status code: {0}.".format(status_code))
85         else:
86             # get rid of empty vni-table entry
87             resp["lisp-state"]["lisp-feature-data"]["eid-table"][
88                 "vni-table"].remove(
89                     {
90                         "virtual-network-identifier": 0,
91                         "vrf-subtable": {"table-id": 0}
92                     }
93                 )
94             return resp
95
96     @staticmethod
97     def set_lisp_state(node, state):
98         """Enable or disable the Lisp feature.
99
100         :param node: Honeycomb node.
101         :param state: Desired Lisp state, enable or disable.
102         :type node: dict
103         :type state: str
104         :returns: Content of response.
105         :rtype: bytearray
106         """
107
108         data = {
109             "lisp": {
110                 "enable": True if state.lower() == "enable" else False
111             }
112         }
113
114         return LispKeywords._set_lisp_properties(node, '', data)
115
116     @staticmethod
117     def add_locator(node, interface, locator_set, priority=1, weight=1):
118         """Configure a new Lisp locator set.
119
120         :param node: Honeycomb node.
121         :param interface: An interface on the node.
122         :param locator_set: Name for the new locator set.
123         :param priority: Priority parameter for the locator.
124         :param weight. Weight parameter for the locator.
125         :type node: dict
126         :type interface: str
127         :type locator_set: str
128         :type priority: int
129         :type weight: int
130         :returns: Content of response.
131         :rtype: bytearray
132         """
133
134         path = "/lisp-feature-data/locator-sets/locator-set" \
135                "/{0}".format(locator_set)
136
137         data = {
138             "locator-set": {
139                 "name": locator_set,
140                 "interface": {
141                     "interface-ref": interface,
142                     "priority": priority,
143                     "weight": weight
144                 }
145             }
146         }
147
148         return LispKeywords._set_lisp_properties(node, path, data)
149
150     @staticmethod
151     def configure_lisp_mapping(node, data):
152         """Modify eid-table configuration to the data provided.
153
154         :param node: Honeycomb node.
155         :param data: Settings for the Lisp mappings.
156         :type node: dict
157         :type data: dict
158         :returns: Content of response.
159         :rtype: bytearray
160         """
161
162         path = "/lisp-feature-data/eid-table"
163         return LispKeywords._set_lisp_properties(node, path, data)
164
165     @staticmethod
166     def add_lisp_adjacency(node, vni_id, map_name, adjacency_name, data):
167         """Add an adjacency to an existing Lisp mapping.
168
169         :param node: Honeycomb node.
170         :param vni_id: vni_id of the mapping.
171         :param map_name: Name of the mapping.
172         :param adjacency_name: Name for the new adjacency.
173         :param data: Adjacency settings.
174         :type node: dict
175         :type vni_id: int
176         :type map_name: str
177         :type adjacency_name: str
178         :type data: dict
179         :returns: Content of response.
180         :rtype: bytearray
181         """
182
183         path = (
184             "/lisp-feature-data/eid-table/vni-table/{vni_id}/"
185             "vrf-subtable/remote-mappings/remote-mapping/{map_name}/"
186             "adjacencies/adjacency/{adjacency_name}"
187         )
188         path = path.format(
189             vni_id=vni_id,
190             map_name=map_name,
191             adjacency_name=adjacency_name
192         )
193
194         return LispKeywords._set_lisp_properties(node, path, data)
195
196     @staticmethod
197     def add_map_resolver(node, ip_address):
198         """Configure map resolver with the specified IP address.
199
200         :param node: Honeycomb node.
201         :param ip_address: IP address to configure map resolver with.
202         :type node: dict
203         :type ip_address: str
204         :returns: Content of response.
205         :rtype: bytearray
206         """
207
208         path = "/lisp-feature-data/map-resolvers/map-resolver/{0}".format(
209             ip_address)
210
211         data = {
212             "map-resolver": {
213                 "ip-address": ip_address
214             }
215         }
216
217         return LispKeywords._set_lisp_properties(node, path, data)
218
219     @staticmethod
220     def delete_map_resolver(node):
221         """Delete an existing map resolver.
222
223         :param node: Honeycomb node
224         :type node: dict
225         :returns: Content of response
226         :rtype: bytearray
227         """
228
229         path = "/lisp-feature-data/map-resolvers"
230
231         return LispKeywords._set_lisp_properties(node, path)
232
233     @staticmethod
234     def configure_pitr(node, locator_set=None):
235         """Configure PITR feature with the specified locator set. If not locator
236         set is specified, disable PITR instead.
237
238         :param node: Honeycomb node.
239         :param locator_set: Name of a locator set. Optional.
240         :type node: dict
241         :type locator_set: str
242         :returns: Content of response.
243         :rtype: bytearray
244         """
245
246         path = "/lisp-feature-data/pitr-cfg"
247
248         if locator_set:
249             data = {
250                 "pitr-cfg": {
251                     "locator-set": locator_set
252                 }
253             }
254         else:
255             data = None
256
257         return LispKeywords._set_lisp_properties(node, path, data)
258
259     @staticmethod
260     def disable_lisp(node):
261         """Remove all Lisp settings on the node.
262
263         :param node: Honeycomb node.
264         :type node: dict
265         :returns: Content of response.
266         :rtype: bytearray
267         """
268
269         return LispKeywords._set_lisp_properties(node, "")

©2016 FD.io a Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation. Linux is a registered trademark of Linus Torvalds.
Please see our privacy policy and terms of use.