Fix warnings reported by gen_doc.sh
[csit.git] / resources / libraries / python / honeycomb / HcAPIKwBridgeDomain.py
1 # Copyright (c) 2018 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 """Keywords to manipulate bridge domain configuration using Honeycomb REST API.
15
16 The keywords make possible to put and get configuration data and to get
17 operational data.
18 """
19
20 from resources.libraries.python.HTTPRequest import HTTPCodes
21 from resources.libraries.python.honeycomb.HoneycombSetup import HoneycombError
22 from resources.libraries.python.honeycomb.HoneycombUtil \
23     import DataRepresentation
24 from resources.libraries.python.honeycomb.HoneycombUtil \
25     import HoneycombUtil as HcUtil
26
27
28 class BridgeDomainKeywords(object):
29     """Keywords to manipulate bridge domain configuration.
30
31     Implements keywords which get configuration and operational data about
32     bridge domains and put the bridge domains' parameters using Honeycomb REST
33     API.
34     """
35
36     PARAMS = ("flood", "forward", "learn", "unknown-unicast-flood",
37               "arp-termination")
38
39     def __init__(self):
40         pass
41
42     @staticmethod
43     def _configure_bd(node, bd_name, data,
44                       data_representation=DataRepresentation.JSON):
45         """Send bridge domain configuration data and check the response.
46
47         :param node: Honeycomb node.
48         :param bd_name: The name of bridge domain.
49         :param data: Configuration data to be sent in PUT request.
50         :param data_representation: How the data is represented.
51         :type node: dict
52         :type bd_name: str
53         :type data: dict
54         :type data_representation: DataRepresentation
55         :returns: Content of response.
56         :rtype: bytearray
57         :raises HoneycombError: If the status code in response on PUT is not
58             200 = OK.
59         """
60
61         status_code, resp = HcUtil.\
62             put_honeycomb_data(node, "config_bridge_domain", data,
63                                data_representation=data_representation)
64         if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
65             raise HoneycombError(
66                 "The configuration of bridge domain '{0}' was not successful. "
67                 "Status code: {1}.".format(bd_name, status_code))
68         return resp
69
70     @staticmethod
71     def _set_bd_properties(node, bd_name, path, new_value=None):
72         """Set bridge domain properties.
73
74         This method reads bridge domain configuration data, creates, changes or
75         removes the requested data and puts it back to Honeycomb.
76
77         :param node: Honeycomb node.
78         :param bd_name: The name of bridge domain.
79         :param path:  Path to data we want to change, create or remove.
80         :param new_value: The new value to be set. If None, the item will be
81             removed.
82         :type node: dict
83         :type bd_name: str
84         :type path: tuple
85         :type new_value: str, dict or list
86         :returns: Content of response.
87         :rtype: bytearray
88         :raises HoneycombError: If it is not possible to get or set the data.
89         """
90
91         status_code, resp = HcUtil.\
92             get_honeycomb_data(node, "config_bridge_domain")
93         if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
94             raise HoneycombError(
95                 "Not possible to get configuration information about the "
96                 "bridge domains. Status code: {0}.".format(status_code))
97
98         if new_value:
99             new_data = HcUtil.set_item_value(resp, path, new_value)
100         else:
101             new_data = HcUtil.remove_item(resp, path)
102
103         return BridgeDomainKeywords._configure_bd(node, bd_name, new_data)
104
105     @staticmethod
106     def _create_bd_structure(bd_name, **kwargs):
107         """Create the bridge domain data structure as it is expected by
108         Honeycomb REST API.
109
110         :param bd_name: Bridge domain name.
111         :param kwargs: Parameters and their values. The accepted parameters are
112             defined in BridgeDomainKeywords.PARAMS.
113         :type bd_name: str
114         :type kwargs: dict
115         :returns: Bridge domain data structure.
116         :rtype: dict
117         """
118
119         bd_structure = {"name": bd_name}
120
121         for param, value in kwargs.items():
122             if param not in BridgeDomainKeywords.PARAMS:
123                 raise HoneycombError("The parameter {0} is invalid.".
124                                      format(param))
125             bd_structure[param] = str(value)
126
127         return bd_structure
128
129     @staticmethod
130     def get_all_bds_cfg_data(node):
131         """Get configuration data about all bridge domains from Honeycomb.
132
133         :param node: Honeycomb node.
134         :type node: dict
135         :returns: Configuration data about all bridge domains from Honeycomb.
136         :rtype: list
137         :raises HoneycombError: If it is not possible to get configuration data.
138         """
139
140         status_code, resp = HcUtil.\
141             get_honeycomb_data(node, "config_bridge_domain")
142         if status_code != HTTPCodes.OK:
143             raise HoneycombError(
144                 "Not possible to get configuration information about the "
145                 "bridge domains. Status code: {0}.".format(status_code))
146         try:
147             return resp["bridge-domains"]["bridge-domain"]
148
149         except (KeyError, TypeError):
150             return []
151
152     @staticmethod
153     def get_bd_cfg_data(node, bd_name):
154         """Get configuration data about the given bridge domain from Honeycomb.
155
156         :param node: Honeycomb node.
157         :param bd_name: The name of bridge domain.
158         :type node: dict
159         :type bd_name: str
160         :returns: Configuration data about the given bridge domain from
161             Honeycomb.
162         :rtype: dict
163         """
164
165         intfs = BridgeDomainKeywords.get_all_bds_cfg_data(node)
166         for intf in intfs:
167             if intf["name"] == bd_name:
168                 return intf
169         return {}
170
171     @staticmethod
172     def get_all_bds_oper_data(node):
173         """Get operational data about all bridge domains from Honeycomb.
174
175         :param node: Honeycomb node.
176         :type node: dict
177         :returns: Operational data about all bridge domains from Honeycomb.
178         :rtype: list
179         :raises HoneycombError: If it is not possible to get operational data.
180         """
181
182         status_code, resp = HcUtil.\
183             get_honeycomb_data(node, "oper_bridge_domains")
184         if status_code != HTTPCodes.OK:
185             raise HoneycombError(
186                 "Not possible to get operational information about the "
187                 "bridge domains. Status code: {0}.".format(status_code))
188         try:
189             return resp["bridge-domains-state"]["bridge-domain"]
190
191         except (KeyError, TypeError):
192             return []
193
194     @staticmethod
195     def get_bd_oper_data(node, bd_name):
196         """Get operational data about the given bridge domain from Honeycomb.
197
198         :param node: Honeycomb node.
199         :param bd_name: The name of bridge domain.
200         :type node: dict
201         :type bd_name: str
202         :returns: Operational data about the given bridge domain from Honeycomb.
203         :rtype: dict
204         """
205
206         intfs = BridgeDomainKeywords.get_all_bds_oper_data(node)
207         for intf in intfs:
208             if intf["name"] == bd_name:
209                 return intf
210         return {}
211
212     @staticmethod
213     def add_first_bd(node, bd_name, **kwargs):
214         """Add the first bridge domain.
215
216         If there are any other bridge domains configured, they will be removed.
217
218         :param node: Honeycomb node.
219         :param bd_name: Bridge domain name.
220         :param kwargs: Parameters and their values. The accepted parameters are
221             defined in BridgeDomainKeywords.PARAMS
222         :type node: dict
223         :type bd_name: str
224         :type kwargs: dict
225         :returns: Bridge domain data structure.
226         :rtype: dict
227         """
228
229         new_bd = BridgeDomainKeywords._create_bd_structure(bd_name, **kwargs)
230         bridge_domain = {"bridge-domains": {"bridge-domain": [new_bd, ]}}
231         return BridgeDomainKeywords._configure_bd(node, bd_name, bridge_domain)
232
233     @staticmethod
234     def add_bd(node, bd_name, **kwargs):
235         """Add a bridge domain.
236
237         :param node: Honeycomb node.
238         :param bd_name: Bridge domain name.
239         :param kwargs: Parameters and their values. The accepted parameters are
240             defined in BridgeDomainKeywords.PARAMS
241         :type node: dict
242         :type bd_name: str
243         :type kwargs: dict
244         :returns: Bridge domain data structure.
245         :rtype: dict
246         """
247
248         path = ("bridge-domains", "bridge-domain")
249         new_bd = BridgeDomainKeywords._create_bd_structure(bd_name, **kwargs)
250         bridge_domain = [new_bd, ]
251         return BridgeDomainKeywords._set_bd_properties(node, bd_name, path,
252                                                        bridge_domain)
253
254     @staticmethod
255     def remove_all_bridge_domains(node):
256         """Remove all bridge domains.
257
258         :param node: Honeycomb node.
259         :type node: dict
260         :returns: Content of response.
261         :rtype: bytearray
262         :raises HoneycombError: If it is not possible to remove all bridge
263             domains.
264         """
265
266         data = {"bridge-domains": {"bridge-domain": []}}
267
268         status_code, resp = HcUtil.\
269             put_honeycomb_data(node, "config_bridge_domain", data)
270
271         if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
272             raise HoneycombError("Not possible to remove all bridge domains. "
273                                  "Status code: {0}.".format(status_code))
274         return resp
275
276     @staticmethod
277     def remove_bridge_domain(node, bd_name):
278         """Remove a bridge domain.
279
280         :param node:  Honeycomb node.
281         :param bd_name: The name of bridge domain to be removed.
282         :type node: dict
283         :type bd_name: str
284         :returns: Content of response.
285         :rtype: bytearray
286         :raises HoneycombError: If it is not possible to remove the bridge
287             domain.
288         """
289
290         path = ("bridge-domains", ("bridge-domain", "name", bd_name))
291
292         status_code, resp = HcUtil.\
293             get_honeycomb_data(node, "config_bridge_domain")
294         if status_code != HTTPCodes.OK:
295             raise HoneycombError(
296                 "Not possible to get configuration information about the "
297                 "bridge domains. Status code: {0}.".format(status_code))
298
299         new_data = HcUtil.remove_item(resp, path)
300         status_code, resp = HcUtil.\
301             put_honeycomb_data(node, "config_bridge_domain", new_data)
302         if status_code != HTTPCodes.OK:
303             raise HoneycombError("Not possible to remove bridge domain {0}. "
304                                  "Status code: {1}.".
305                                  format(bd_name, status_code))
306         return resp
307
308     @staticmethod
309     def configure_bridge_domain(node, bd_name, param, value):
310         """Configure a bridge domain.
311
312         :param node: Honeycomb node.
313         :param bd_name: Bridge domain name.
314         :param param: Parameter to set, change or remove. The accepted
315             parameters are defined in BridgeDomainKeywords.PARAMS
316         :param value: The new value to be set, change or remove. If None, the
317             item will be removed.
318         :type node: dict
319         :type bd_name: str
320         :type param: str
321         :type value: str
322         :returns: Content of response.
323         :rtype: bytearray
324         """
325
326         if param not in BridgeDomainKeywords.PARAMS:
327             raise HoneycombError("The parameter {0} is invalid.".format(param))
328
329         path = ("bridge-domains", ("bridge-domain", "name", bd_name), param)
330         return BridgeDomainKeywords.\
331             _set_bd_properties(node, bd_name, path, value)
332
333     @staticmethod
334     def add_l2_fib_entry(node, bd_name, l2_fib_entry):
335         """Add an L2 FIB entry to the bridge domain's list of L2 FIB entries.
336
337         :param node: Honeycomb node.
338         :param bd_name: Bridge domain's name.
339         :param l2_fib_entry: L2 FIB entry to be added to the L2 FIB table.
340         :type node: dict
341         :type bd_name: str
342         :type l2_fib_entry: dict
343         :returns: Content of response.
344         :rtype: bytearray
345         """
346
347         path = ("bridge-domains",
348                 ("bridge-domain", "name", bd_name),
349                 "l2-fib-table",
350                 "l2-fib-entry")
351
352         new_l2_fib_entry = [l2_fib_entry, ]
353         return BridgeDomainKeywords._set_bd_properties(
354             node, bd_name, path, new_l2_fib_entry)
355
356     @staticmethod
357     def modify_l2_fib_entry(node, bd_name, mac, param, value):
358         """Modify an existing L2 FIB entry in the bridge domain's L2 FIB table.
359         The L2 FIB entry is specified by MAC address.
360
361         :param node: Honeycomb node.
362         :param bd_name: Bridge domain's name.
363         :param mac: MAC address used as the key in L2 FIB data structure.
364         :param param: The parameter to be modified.
365         :param value: The new value of the parameter.
366         :type node: dict
367         :type bd_name: str
368         :type mac: str
369         :type param: str
370         :type value: str or int
371         :returns: Content of response.
372         :rtype: bytearray
373         """
374
375         path = ("bridge-domains",
376                 ("bridge-domain", "name", bd_name),
377                 "l2-fib-table",
378                 ("l2-fib-entry", "phys-address", mac),
379                 param)
380
381         return BridgeDomainKeywords._set_bd_properties(
382             node, bd_name, path, value)
383
384     @staticmethod
385     def remove_l2_fib_entry(node, bd_name, mac):
386         """Remove an L2 FIB entry from bridge domain's L2 FIB table. The
387         entry is specified by MAC address.
388
389         :param node: Honeycomb node.
390         :param bd_name: Bridge domain's name.
391         :param mac: MAC address used as the key in L2 FIB data structure.
392         :type node: dict
393         :type bd_name: str
394         :type mac: str
395         :returns: Content of response.
396         :rtype: bytearray
397         :raises HoneycombError: If it is not possible to remove the specified
398             entry.
399         """
400
401         path = ("bridge-domains",
402                 ("bridge-domain", "name", bd_name),
403                 "l2-fib-table",
404                 ("l2-fib-entry", "phys-address", str(mac)))
405
406         status_code, resp = HcUtil.\
407             get_honeycomb_data(node, "config_bridge_domain")
408         if status_code != HTTPCodes.OK:
409             raise HoneycombError("Not possible to get configuration information"
410                                  " about the L2 FIB entry {0} from bridge "
411                                  "domain {1}. Status code: {2}.".
412                                  format(mac, bd_name, status_code))
413
414         new_data = HcUtil.remove_item(resp, path)
415         status_code, resp = HcUtil.\
416             put_honeycomb_data(node, "config_bridge_domain", new_data)
417         if status_code != HTTPCodes.OK:
418             raise HoneycombError("Not possible to remove L2 FIB entry {0} from "
419                                  "bridge domain {1}. Status code: {2}.".
420                                  format(mac, bd_name, status_code))
421         return resp
422
423
424     @staticmethod
425     def remove_all_l2_fib_entries(node, bd_name):
426         """Remove all entries from the bridge domain's L2 FIB table.
427
428         :param node: Honeycomb node.
429         :param bd_name: Bridge domain's name.
430         :type node: dict
431         :type bd_name: str
432         :returns: Content of response.
433         :rtype: bytearray
434         """
435
436         path = ("bridge-domains",
437                 ("bridge-domain", "name", bd_name),
438                 "l2-fib-table")
439
440         return BridgeDomainKeywords._set_bd_properties(
441             node, bd_name, path, None)
442
443     @staticmethod
444     def get_all_l2_fib_entries(node, bd_name):
445         """Retrieves all entries from the bridge domain's L2 FIB table.
446
447         :param node: Honeycomb node.
448         :param bd_name: Bridge domain's name.
449         :type node: dict
450         :type bd_name: str
451         :returns: Bridge domain's L2 FIB table or empty list if the table does
452             not exist or it is empty.
453         :rtype: list
454         """
455
456         bd_data = BridgeDomainKeywords.get_bd_oper_data(node, bd_name)
457         try:
458             return bd_data["l2-fib-table"]["l2-fib-entry"]
459         except KeyError:
460             return []
461
462     @staticmethod
463     def get_l2_fib_entry(node, bd_name, mac):
464         """Retrieves an entry from bridge domain's L2 FIB table. The entry is
465         specified by MAC address.
466
467         :param node: Honeycomb node.
468         :param bd_name: Bridge domain's name.
469         :param mac: MAC address used as the key in L2 FIB data structure.
470         :type node: dict
471         :type bd_name: str
472         :type mac: str
473         :returns: The requested entry from bridge domain's L2 FIB table or empty
474             dictionary if it does not exist in the L2 FIB table.
475         :rtype: dict
476         """
477
478         l2_fib = BridgeDomainKeywords.get_all_l2_fib_entries(node, bd_name)
479         for entry in l2_fib:
480             if entry["phys-address"] == mac:
481                 return entry
482         return {}

©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.