CSIT-811 HC Test: BGP tests - IPv4 CRUD
[csit.git] / resources / libraries / python / honeycomb / BGP.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 """Keywords to manipulate BGP configuration using Honeycomb REST API."""
15
16 from resources.libraries.python.HTTPRequest import HTTPCodes
17 from resources.libraries.python.honeycomb.HoneycombSetup import HoneycombError
18 from resources.libraries.python.honeycomb.HoneycombUtil \
19     import HoneycombUtil as HcUtil
20
21
22 class BGPKeywords(object):
23     """Keywords to manipulate BGP configuration.
24
25     Implements keywords which read configuration and operational data for
26     the BGP feature, and configure BGP parameters using Honeycomb REST API.
27     """
28
29     def __init__(self):
30         pass
31
32     @staticmethod
33     def _configure_bgp_peer(node, path, data=None):
34         """Send BGP peer configuration data and check the response.
35
36         :param node: Honeycomb node.
37         :param path: Additional path to append to the base BGP config path.
38         :param data: Configuration data to be sent in PUT request.
39         :type node: dict
40         :type path: str
41         :type data: dict
42         :returns: Content of response.
43         :rtype: bytearray
44         :raises HoneycombError: If the status code in response on PUT is not
45         200 = OK or 201 = ACCEPTED.
46         """
47
48         if data is None:
49             status_code, resp = HcUtil. \
50                 delete_honeycomb_data(node, "config_bgp_peer", path)
51         else:
52             status_code, resp = HcUtil.\
53                 put_honeycomb_data(node, "config_bgp_peer", data, path)
54         if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
55             raise HoneycombError(
56                 "The configuration of BGP peer was not successful. "
57                 "Status code: {0}.".format(status_code))
58         return resp
59
60     @staticmethod
61     def _configure_bgp_route(node, path, data=None):
62         """Send BGP route configuration data and check the response.
63
64         :param node: Honeycomb node.
65         :param path: Additional path to append to the base BGP config path.
66         :param data: Configuration data to be sent in PUT request.
67         :type node: dict
68         :type path: str
69         :type data: dict
70         :returns: Content of response.
71         :rtype: bytearray
72         :raises HoneycombError: If the status code in response on PUT is not
73         200 = OK or 201 = ACCEPTED.
74         """
75
76         if data is None:
77             status_code, resp = HcUtil. \
78                 delete_honeycomb_data(node, "config_bgp_route", path)
79         else:
80             status_code, resp = HcUtil. \
81                 put_honeycomb_data(node, "config_bgp_route", data, path)
82         if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
83             raise HoneycombError(
84                 "The configuration of BGP route was not successful. "
85                 "Status code: {0}.".format(status_code))
86         return resp
87
88     @staticmethod
89     def get_full_bgp_configuration(node):
90         """Get BGP configuration from the node.
91
92         :param node: Honeycomb node.
93         :type node: dict
94         :returns: BGP configuration data.
95         :rtype: dict
96         """
97
98         status_code, resp = HcUtil. \
99             get_honeycomb_data(node, "config_bgp_peer")
100         if status_code != HTTPCodes.OK:
101             raise HoneycombError(
102                 "Not possible to get configuration information about BGP."
103                 " Status code: {0}.".format(status_code))
104         return resp
105
106     @staticmethod
107     def get_bgp_peer(node, address):
108         """Get BGP configuration of the specified peer from the node.
109
110         :param node: Honeycomb node.
111         :param address: IP address of the peer.
112         :type node: dict
113         :type address: str
114         :returns: BGP peer configuration data.
115         :rtype: dict
116         """
117
118         path = "bgp-openconfig-extensions:neighbors/" \
119                "neighbor/{0}".format(address)
120         status_code, resp = HcUtil. \
121             get_honeycomb_data(node, "config_bgp_peer", path)
122         if status_code != HTTPCodes.OK:
123             raise HoneycombError(
124                 "Not possible to get configuration information about the BGP"
125                 " peer. Status code: {0}.".format(status_code))
126         return resp
127
128     @staticmethod
129     def add_bgp_peer(node, address, data):
130         """Configure a BGP peer on the node.
131
132         :param node: Honeycomb node.
133         :param address: IP address of the peer.
134         :param data: Peer configuration data.
135         :type node: dict
136         :type address: str
137         :type data: dict
138         :returns: Content of response.
139         :rtype: bytearray
140         """
141
142         path = "bgp-openconfig-extensions:neighbors/neighbor/{address}".format(
143             address=address)
144         return BGPKeywords._configure_bgp_peer(node, path, data)
145
146     @staticmethod
147     def remove_bgp_peer(node, address):
148         """Remove a BGP peer from the configuration.
149
150         :param node: Honeycomb node.
151         :param address: IP address of the peer.
152         :type node: dict
153         :type address: str
154         :returns: Content of response.
155         :rtype: bytearray
156         """
157
158         path = "bgp-openconfig-extensions:neighbors/neighbor/{address}".format(
159             address=address)
160         return BGPKeywords._configure_bgp_peer(node, path)
161
162     @staticmethod
163     def configure_bgp_route(node, peer_address, data, route_address,
164                             index, ip_version):
165         """Configure a route for the BGP peer specified by peer IP address.
166
167         :param node: Honeycomb node.
168         :param peer_address: IP address of the BGP peer.
169         :param data: Route configuration data.
170         :param route_address: IP address of the route.
171         :param index: Index number of the route within specified peer.
172         :param ip_version: IP protocol version. ipv4 or ipv6
173         :type node: dict
174         :type peer_address: str
175         :type data: dict
176         :type route_address: str
177         :type index: int
178         :type ip_version: str
179         :returns: Content of response.
180         :rtype: bytearray
181         """
182
183         route_address = route_address.replace("/", "%2F")
184
185         if ip_version.lower() == "ipv4":
186             path = "{0}/tables/bgp-types:ipv4-address-family/" \
187                    "bgp-types:unicast-subsequent-address-family/" \
188                    "bgp-inet:ipv4-routes/ipv4-route/{1}/{2}" \
189                 .format(peer_address, route_address, index)
190         else:
191             path = "{0}/tables/bgp-types:ipv6-address-family/" \
192                    "bgp-types:unicast-subsequent-address-family/" \
193                    "bgp-inet:ipv6-routes/ipv6-route/{1}/{2}" \
194                 .format(peer_address, route_address, index)
195
196         return BGPKeywords._configure_bgp_route(node, path, data)
197
198     @staticmethod
199     def get_bgp_route(node, peer_address, route_address, index, ip_version):
200         """Get all BGP peers from operational data.
201
202         :param node: Honeycomb node.
203         :param peer_address: IP address of the BGP peer.
204         :param route_address: IP address of the route.
205         :param index: Index number of the route within specified peer.
206         :param ip_version: IP protocol version. ipv4 or ipv6
207         :type node: dict
208         :type peer_address: str
209         :type route_address: str
210         :type index: int
211         :type ip_version: str
212         :returns: Content of response.
213         :rtype: bytearray
214         :raises HoneycombError: If the operation fails.
215         """
216
217         route_address = route_address.replace("/", "%2F")
218
219         if ip_version.lower() == "ipv4":
220             path = "{0}/tables/bgp-types:ipv4-address-family/" \
221                    "bgp-types:unicast-subsequent-address-family/" \
222                    "bgp-inet:ipv4-routes/ipv4-route/{1}/{2}" \
223                 .format(peer_address, route_address, index)
224         else:
225             path = "{0}/tables/bgp-types:ipv6-address-family/" \
226                    "bgp-types:unicast-subsequent-address-family/" \
227                    "bgp-inet:ipv6-routes/ipv6-route/{1}/{2}" \
228                 .format(peer_address, route_address, index)
229         status_code, resp = HcUtil. \
230             get_honeycomb_data(node, "config_bgp_route", path)
231         if status_code != HTTPCodes.OK:
232             raise HoneycombError(
233                 "Not possible to get configuration information about the BGP"
234                 " route. Status code: {0}.".format(status_code))
235
236         return resp
237
238     @staticmethod
239     def get_all_peer_routes(node, peer_address, ip_version):
240         """Get all configured routes for the given BGP peer.
241
242         :param node: HOneycomb node.
243         :param peer_address: IP address of the peer.
244         :param ip_version: IP protocol version. ipv4 or ipv6
245         :type node: dict
246         :type peer_address: str
247         :type ip_version: str
248         :returns: Content of response.
249         :rtype: bytearray
250         :raises HoneycombError: If the operation fails.
251         """
252
253         if ip_version.lower() == "ipv4":
254             path = "{0}/tables/bgp-types:ipv4-address-family/" \
255                    "bgp-types:unicast-subsequent-address-family/" \
256                    "bgp-inet:ipv4-routes".format(peer_address)
257         else:
258             path = "{0}/tables/bgp-types:ipv6-address-family/" \
259                    "bgp-types:unicast-subsequent-address-family/" \
260                    "bgp-inet:ipv6-routes".format(peer_address)
261         status_code, resp = HcUtil. \
262             get_honeycomb_data(node, "config_bgp_route", path)
263         if status_code != HTTPCodes.OK:
264             raise HoneycombError(
265                 "Not possible to get configuration information about BGP"
266                 " routes. Status code: {0}.".format(status_code))
267
268         return resp
269
270     @staticmethod
271     def remove_bgp_route(node, peer_address, route_address, index, ip_version):
272         """Remove the specified BGP route from configuration.
273
274         :param node: Honeycomb node.
275         :param peer_address: IP address of the BGP peer.
276         :param route_address: IP address of the route.
277         :param index: Index number of the route within specified peer.
278         :param ip_version: IP protocol version. ipv4 or ipv6
279         :type node: dict
280         :type peer_address: str
281         :type route_address: str
282         :type index: int
283         :type ip_version: str
284         :returns: Content of response.
285         :rtype: bytearray
286         """
287
288         route_address = route_address.replace("/", "%2F")
289
290         if ip_version.lower() == "ipv4":
291             path = "{0}/tables/bgp-types:ipv4-address-family/" \
292                    "bgp-types:unicast-subsequent-address-family/" \
293                    "bgp-inet:ipv4-routes/ipv4-route/{1}/{2}" \
294                 .format(peer_address, route_address, index)
295         else:
296             path = "{0}/tables/bgp-types:ipv6-address-family/" \
297                    "bgp-types:unicast-subsequent-address-family/" \
298                    "bgp-inet:ipv6-routes/ipv6-route/{1}/{2}" \
299                 .format(peer_address, route_address, index)
300
301         return BGPKeywords._configure_bgp_route(node, path)

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