CSIT-563: HC Test: improved Lisp test coverage
[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 verify_map_server_data_from_honeycomb(data, ip_addresses):
98         """Verify whether MAP server data from Honeycomb is correct.
99
100         :param data: Lisp operational data containing map server IP addresses.
101         :param ip_addresses: IP addresses to verify map server data against.
102         :type data: dict
103         :type ip_addresses: list
104         :returns: Boolean Value indicating equality of IP Lists.
105         :rtype: bool
106         """
107
108         data =\
109             data['lisp-state']['lisp-feature-data']['map-servers']['map-server']
110
111         data = sorted([entry['ip-address'] for entry in data])
112         ip_addresses.sort()
113
114         return data == ip_addresses
115
116     @staticmethod
117     def verify_map_server_data_from_vat(data, ip_addresses):
118         """Verify whether MAP server data from VAT is correct.
119
120         :param data: Lisp operational data containing map server IP addresses.
121         :param ip_addresses: IP addresses to verify map server data against.
122         :type data: dict
123         :type ip_addresses: list
124         :returns: Boolean Value indicating equality of IP Lists.
125         :rtype: bool
126         """
127
128         data = sorted([entry['map-server'] for entry in data])
129         ip_addresses.sort()
130
131         return data == ip_addresses
132
133     @staticmethod
134     def set_lisp_state(node, state=True):
135         """Enable or disable the Lisp feature.
136
137         :param node: Honeycomb node.
138         :param state: Enable or disable Lisp.
139         :type node: dict
140         :type state: bool
141         :returns: Content of response.
142         :rtype: bytearray
143         :raises HoneycombError: If the return code is not 200:OK
144         or 404:NOT FOUND.
145         """
146
147         ret_code, data = HcUtil.get_honeycomb_data(node, "config_lisp")
148         if ret_code == HTTPCodes.OK:
149             data["lisp"]["enable"] = bool(state)
150         elif ret_code == HTTPCodes.NOT_FOUND:
151                 data = {"lisp": {"enable": bool(state)}}
152         else:
153             raise HoneycombError("Unexpected return code when getting existing"
154                                  " Lisp configuration.")
155
156         return LispKeywords._set_lisp_properties(node, '', data)
157
158     @staticmethod
159     def set_rloc_probe_state(node, state=False):
160         """Enable or disable the Routing Locator probe.
161
162         :param node: Honeycomb node.
163         :param state: Enable or Disable the Rloc probe.
164         :type node: dict
165         :type state: bool
166         :returns: Content of response.
167         :rtype: bytearray
168         """
169
170         path = "/lisp-feature-data/rloc-probe"
171
172         data = {
173             "rloc-probe": {
174                 "enabled": bool(state)
175             }
176         }
177
178         return LispKeywords._set_lisp_properties(node, path, data)
179
180     @staticmethod
181     def add_locator(node, interface, locator_set, priority=1, weight=1):
182         """Configure a new Lisp locator set.
183
184         :param node: Honeycomb node.
185         :param interface: An interface on the node.
186         :param locator_set: Name for the new locator set.
187         :param priority: Priority parameter for the locator.
188         :param weight. Weight parameter for the locator.
189         :type node: dict
190         :type interface: str
191         :type locator_set: str
192         :type priority: int
193         :type weight: int
194         :returns: Content of response.
195         :rtype: bytearray
196         """
197
198         path = "/lisp-feature-data/locator-sets/locator-set" \
199                "/{0}".format(locator_set)
200
201         data = {
202             "locator-set": {
203                 "name": locator_set,
204                 "interface": {
205                     "interface-ref": interface,
206                     "priority": priority,
207                     "weight": weight
208                 }
209             }
210         }
211
212         return LispKeywords._set_lisp_properties(node, path, data)
213
214     @staticmethod
215     def configure_lisp_mapping(node, data):
216         """Modify eid-table configuration to the data provided.
217
218         :param node: Honeycomb node.
219         :param data: Settings for the Lisp mappings.
220         :type node: dict
221         :type data: dict
222         :returns: Content of response.
223         :rtype: bytearray
224         """
225
226         path = "/lisp-feature-data/eid-table"
227         return LispKeywords._set_lisp_properties(node, path, data)
228
229     @staticmethod
230     def configure_lisp_map_request_mode(node, option):
231         """Modify Lisp Map Request Mode configuration to the data provided.
232
233         :param node: Honeycomb node.
234         :param option: Settings for the Lisp map request mode.
235         :type node: dict
236         :type option: str
237         :returns: Content of response.
238         :rtype: bytearray
239         """
240
241         data = {
242             "map-request-mode": {
243                 "mode": option
244             }
245         }
246
247         path = "/lisp-feature-data/map-request-mode"
248         return LispKeywords._set_lisp_properties(node, path, data)
249
250     @staticmethod
251     def add_lisp_adjacency(node, vni_id, map_name, adjacency_name, data):
252         """Add an adjacency to an existing Lisp mapping.
253
254         :param node: Honeycomb node.
255         :param vni_id: vni_id of the mapping.
256         :param map_name: Name of the mapping.
257         :param adjacency_name: Name for the new adjacency.
258         :param data: Adjacency settings.
259         :type node: dict
260         :type vni_id: int
261         :type map_name: str
262         :type adjacency_name: str
263         :type data: dict
264         :returns: Content of response.
265         :rtype: bytearray
266         """
267
268         path = (
269             "/lisp-feature-data/eid-table/vni-table/{vni_id}/"
270             "vrf-subtable/remote-mappings/remote-mapping/{map_name}/"
271             "adjacencies/adjacency/{adjacency_name}"
272         )
273         path = path.format(
274             vni_id=vni_id,
275             map_name=map_name,
276             adjacency_name=adjacency_name
277         )
278
279         return LispKeywords._set_lisp_properties(node, path, data)
280
281     @staticmethod
282     def add_map_resolver(node, ip_address):
283         """Configure map resolver with the specified IP address.
284
285         :param node: Honeycomb node.
286         :param ip_address: IP address to configure map resolver with.
287         :type node: dict
288         :type ip_address: str
289         :returns: Content of response.
290         :rtype: bytearray
291         """
292
293         path = "/lisp-feature-data/map-resolvers/map-resolver/{0}".format(
294             ip_address)
295
296         data = {
297             "map-resolver": {
298                 "ip-address": ip_address
299             }
300         }
301
302         return LispKeywords._set_lisp_properties(node, path, data)
303
304     @staticmethod
305     def set_map_register(node, map_register=False):
306         """Configure Map Register.
307
308         :param node: Honeycomb node.
309         :param map_register: Enable or disable Map Register.
310         :type node: dict
311         :type map_register: bool
312         :returns: Content of response.
313         :rtype: bytearray
314         """
315
316         path = "/lisp-feature-data/map-register"
317
318         data = {
319             "map-register": {
320                 "enabled": bool(map_register)
321             }
322         }
323
324         return LispKeywords._set_lisp_properties(node, path, data)
325
326     @staticmethod
327     def set_map_request_mode(node, src_dst=False):
328         """Configure Map Request Mode.
329
330         :param node: Honeycomb node.
331         :param src_dst: Configure Map Request Mode with source destination.
332         :type node: dict
333         :type src_dst: bool
334         :returns: Content of response.
335         :rtype: bytearray
336         """
337
338         path = "/lisp-feature-data/map-request-mode"
339
340         data = {
341             "map-request-mode": {
342                 "mode": "source-destination" if src_dst
343                 else "target-destination"
344             }
345         }
346
347         return LispKeywords._set_lisp_properties(node, path, data)
348
349     @staticmethod
350     def delete_map_resolver(node):
351         """Delete an existing map resolver.
352
353         :param node: Honeycomb node
354         :type node: dict
355         :returns: Content of response
356         :rtype: bytearray
357         """
358
359         path = "/lisp-feature-data/map-resolvers"
360
361         return LispKeywords._set_lisp_properties(node, path)
362
363     @staticmethod
364     def add_map_server(node, *ip_addresses):
365         """Configure map server with the specified IP addresses.
366
367         :param node: Honeycomb node.
368         :param ip_addresses: IP addresses to configure map server with.
369         :type node: dict
370         :type ip_addresses: list
371         :returns: Content of response.
372         :rtype: bytearray
373         """
374
375         path = "/lisp-feature-data/map-servers"
376
377         data = {
378             "map-servers": {
379                 "map-server": [
380                     {"ip-address": ip_address} for ip_address in ip_addresses
381                 ]
382             }
383         }
384
385         return LispKeywords._set_lisp_properties(node, path, data)
386
387     @staticmethod
388     def delete_map_server(node):
389         """Delete all map servers.
390
391         :param node: Honeycomb node
392         :type node: dict
393         :returns: Content of response
394         :rtype: bytearray
395         """
396
397         path = "/lisp-feature-data/map-servers"
398
399         return LispKeywords._set_lisp_properties(node, path)
400
401     @staticmethod
402     def configure_pitr(node, locator_set=None):
403         """Configure PITR feature with the specified locator set. If not locator
404         set is specified, disable PITR instead.
405
406         :param node: Honeycomb node.
407         :param locator_set: Name of a locator set. Optional.
408         :type node: dict
409         :type locator_set: str
410         :returns: Content of response.
411         :rtype: bytearray
412         """
413
414         path = "/lisp-feature-data/pitr-cfg"
415
416         if locator_set:
417             data = {
418                 "pitr-cfg": {
419                     "locator-set": locator_set
420                 }
421             }
422         else:
423             data = None
424
425         return LispKeywords._set_lisp_properties(node, path, data)
426
427     @staticmethod
428     def configure_petr(node, ip_address):
429         """Configure PETR feature with the specified IP. If no IP
430         specified, disable PETR instead.
431
432         :param node: Honeycomb node.
433         :param ip_address: IPv6 address.
434         :type node: dict
435         :type ip_address: str
436         :returns: Content of response.
437         :rtype: bytearray
438         """
439
440         path = "/lisp-feature-data/petr-cfg"
441
442         if ip_address:
443             data = {
444                 "petr-cfg": {
445                     "petr-address": ip_address
446                 }
447             }
448         else:
449             data = None
450
451         return LispKeywords._set_lisp_properties(node, path, data)
452
453     @staticmethod
454     def disable_lisp(node):
455         """Remove all Lisp settings on the node.
456
457         :param node: Honeycomb node.
458         :type node: dict
459         :returns: Content of response.
460         :rtype: bytearray
461         """
462
463         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.