495e96e0fd60b94b551e61e8b661ebb0194156fe
[csit.git] / resources / libraries / python / honeycomb / Routing.py
1 # Copyright (c) 2017 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 routing tables using
15 Honeycomb REST API."""
16
17 from robot.api import logger
18
19 from resources.libraries.python.topology import Topology
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 HoneycombUtil as HcUtil
24 from resources.libraries.python.honeycomb.HoneycombUtil \
25     import DataRepresentation
26 from resources.libraries.python.VatExecutor import VatTerminal
27
28
29 class RoutingKeywords(object):
30     """Implementation of keywords which make it possible to:
31     - add/remove routing tables,
32     - add/remove routing table entries
33     - get operational data about routing tables,
34     """
35
36     def __init__(self):
37         pass
38
39     @staticmethod
40     def _set_routing_table_properties(node, path, data=None):
41         """Set routing table 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         :return: Content of response.
50         :rtype: bytearray
51         :raises HoneycombError: If the status code in response is not
52         200 = OK.
53         """
54
55         if data:
56             status_code, resp = HcUtil.\
57                 put_honeycomb_data(node, "config_routing_table", data, path,
58                                    data_representation=DataRepresentation.JSON)
59         else:
60             status_code, resp = HcUtil.\
61                 delete_honeycomb_data(node, "config_routing_table", path)
62
63         if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
64             if data is None and '"error-tag":"data-missing"' in resp:
65                 logger.debug("data does not exist in path.")
66             else:
67                 raise HoneycombError(
68                     "The configuration of routing table was not successful. "
69                     "Status code: {0}.".format(status_code))
70         return resp
71
72     @staticmethod
73     def configure_routing_table(node, name, ip_version, data, vrf=1,
74                                 special=False):
75         """Configure a routing table according to the data provided.
76
77         :param node: Honeycomb node.
78         :param name: Name for the table.
79         :param ip_version: IP protocol version, ipv4 or ipv6.
80         :param data: Route configuration that should be set.
81         :param vrf: vrf-id to attach configuration to.
82         :param special: Must be True if the configuration is a special route.
83         :type node: dict
84         :type name: str
85         :type ip_version: str
86         :type data: dict
87         :type vrf: int
88         :type special: bool
89         :returns: Content of response.
90         :rtype: bytearray
91         """
92         if special:
93             ip_version = "hc2vpp-ietf-{0}-unicast-routing:{0}".format(
94                 ip_version)
95             protocol = "vpp-routing:vpp-protocol-attributes"
96         else:
97             ip_version = ip_version
98             protocol = "vpp-protocol-attributes"
99
100         full_data = {
101             "routing-protocol": [
102                 {
103                     "name": name,
104                     "description": "hc2vpp-csit test route",
105                     "enabled": "true",
106                     "type": "static",
107                     protocol: {
108                         "primary-vrf": vrf
109                     },
110                     "static-routes": {
111                         ip_version: {
112                             "route": data
113                         }
114                     }
115                 }
116             ]
117         }
118
119         path = "/routing-protocol/{0}".format(name)
120         return RoutingKeywords._set_routing_table_properties(
121             node, path, full_data)
122
123     @staticmethod
124     def delete_routing_table(node, name):
125         """Delete the specified routing table from configuration data.
126
127         :param node: Honeycomb node.
128         :param name: Name of the table.
129         :type node: dict
130         :type name: str
131         :returns: Content of response.
132         :rtype: bytearray
133         """
134
135         path = "/routing-protocol/{0}".format(name)
136         return RoutingKeywords._set_routing_table_properties(node, path)
137
138     @staticmethod
139     def get_routing_table_oper(node, name, ip_version):
140         """Retrieve operational data about the specified routing table.
141
142         :param node: Honeycomb node.
143         :param name: Name of the routing table.
144         :param ip_version: IP protocol version, ipv4 or ipv6.
145         :type node: dict
146         :type name: str
147         :type ip_version: str
148         :returns: Routing table operational data.
149         :rtype: list
150         :raises HoneycombError: If the operation fails.
151         """
152
153         path = "/routing-protocol/{0}".format(name)
154         status_code, resp = HcUtil.\
155             get_honeycomb_data(node, "oper_routing_table", path)
156
157         if status_code != HTTPCodes.OK:
158             raise HoneycombError(
159                 "Not possible to get operational information about the "
160                 "classify tables. Status code: {0}.".format(status_code))
161
162         data = RoutingKeywords.clean_routing_oper_data(
163             resp['routing-protocol'][0]['static-routes']
164             ['hc2vpp-ietf-{0}-unicast-routing:{0}'.format(ip_version)]['route'])
165
166         return data
167
168     @staticmethod
169     def clean_routing_oper_data(data):
170         """Prepare received routing operational data to be verified against
171          expected data.
172
173         :param data: Routing operational data.
174         :type data: list
175         :returns: Routing operational data without entry ID numbers.
176         :rtype: list
177         """
178
179         for item in data:
180             # ID values are auto-incremented based on existing routes in VPP
181             item.pop("id", None)
182             if "next-hop-list" in item.keys():
183                 for item2 in item["next-hop-list"]["next-hop"]:
184                     item2.pop("id", None)
185
186             if "next-hop-list" in item.keys():
187                 # List items come in random order
188                 item["next-hop-list"]["next-hop"].sort()
189
190         return data
191
192     @staticmethod
193     def log_routing_configuration(node):
194         """Retrieve route configuration using VAT and print the response
195          to robot log.
196
197          :param node: VPP node.
198          :type node: dict
199          """
200
201         with VatTerminal(node) as vat:
202             vat.vat_terminal_exec_cmd("ip_fib_dump")
203
204     @staticmethod
205     def configure_interface_slaac(node, interface, slaac_data=None):
206         """Configure SLAAC on the specified interfaces.
207
208         :param node: Honeycomb node.
209         :param interface: Interface to configure SLAAC.
210         :param slaac_data: Dictionary of configurations to apply. \
211         If it is None then the existing configuration is removed.
212         :type node: dict
213         :type interface: str
214         :type slaac_data: dict of dicts
215         :returns: Content of response.
216         :rtype: bytearray
217         :raises HoneycombError: If RA could not be configured.
218         """
219
220         interface = Topology.convert_interface_reference(
221             node, interface, 'name')
222         interface_orig = interface
223         interface = interface.replace('/', '%2F')
224         path = 'interface/' + interface
225
226         if not slaac_data:
227             status_code, _ = HcUtil.delete_honeycomb_data(
228                 node, 'config_slaac', path)
229         else:
230             data = {
231                 'interface': [
232                     {
233                         'name': interface_orig,
234                         'ipv6-router-advertisements': slaac_data
235                     }
236                 ]
237             }
238
239             status_code, _ = HcUtil.put_honeycomb_data(
240                 node, 'config_slaac', data, path)
241
242         if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
243             raise HoneycombError(
244                 'Configuring SLAAC failed. Status code:{0}'.format(status_code))
245
246     @staticmethod
247     def get_interface_slaac_oper_data(node, interface):
248         """Get operational data about SLAAC table present on the node.
249
250         :param node: Honeycomb node.
251         :param interface: Interface SLAAC data are retrieved from.
252         :type node: dict
253         :type interface: str
254         :returns: dict of SLAAC operational data.
255         :rtype: dict
256         :raises HoneycombError: If status code differs from successful.
257         """
258         interface = Topology.convert_interface_reference(
259             node, interface, 'name')
260         interface = interface.replace('/', '%2F')
261         path = 'interface/' + interface
262
263         status_code, resp = HcUtil.\
264             get_honeycomb_data(node, "config_slaac", path)
265
266         if status_code != HTTPCodes.OK:
267             raise HoneycombError(
268                 "Not possible to get operational information about SLAAC. "
269                 "Status code: {0}.".format(status_code))
270         try:
271             dict_of_str = resp['interface'][0][
272                 'hc2vpp-ietf-ipv6-unicast-routing:ipv6-router-advertisements']
273             return {k: str(v) for k, v in dict_of_str.items()}
274         except (KeyError, TypeError):
275             return {}
276
277     @staticmethod
278     def configure_policer(node, policy_name, policer_data=None):
279         """Configure Policer on the specified node.
280
281         :param node: Honeycomb node.
282         :param policer_data: Dictionary of configurations to apply. \
283         If it is None then the existing configuration is removed.
284         :type node: dict
285         :type policer_data: dict
286         :returns: Content of response.
287         :rtype: bytearray
288         :raises HoneycombError: If policer could not be configured.
289         """
290
291         path = '/' + policy_name
292
293         if not policer_data:
294             status_code, _ = HcUtil.delete_honeycomb_data(
295                 node, 'config_policer', path)
296         else:
297             data = {
298                 'policer': policer_data
299             }
300
301             status_code, _ = HcUtil.put_honeycomb_data(
302                 node, 'config_policer', data, path)
303
304         if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
305             raise HoneycombError(
306                 'Configuring policer failed. Status code:{0}'\
307                     .format(status_code))
308
309     @staticmethod
310     def get_policer_oper_data(node, policy_name):
311         """Get operational data about Policer on the node.
312
313         :param node: Honeycomb node.
314         :type node: dict
315         :returns: dict of Policer operational data.
316         :rtype: dict
317         :raises HoneycombError: If status code differs from successful.
318         """
319
320         path = '/' + policy_name
321
322         status_code, resp = HcUtil.\
323             get_honeycomb_data(node, "oper_policer", path)
324
325         if status_code != HTTPCodes.OK:
326             raise HoneycombError(
327                 "Not possible to get operational information about Policer. "
328                 "Status code: {0}.".format(status_code))
329         try:
330             return resp['policer']
331         except (KeyError, TypeError):
332             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.