4 Vhosts setup test
[csit.git] / resources / libraries / python / L2Util.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 """L2 Utilities Library."""
15
16 from robot.api.deco import keyword
17
18 from resources.libraries.python.topology import Topology
19 from resources.libraries.python.VatExecutor import VatExecutor, VatTerminal
20 from resources.libraries.python.ssh import exec_cmd_no_error
21
22
23 class L2Util(object):
24     """Utilities for l2 configuration."""
25
26     @staticmethod
27     def vpp_add_l2fib_entry(node, mac, interface, bd_id):
28         """ Create a static L2FIB entry on a vpp node.
29
30         :param node: Node to add L2FIB entry on.
31         :param mac: Destination mac address.
32         :param interface: Interface name or sw_if_index.
33         :param bd_id: Bridge domain id.
34         :type node: dict
35         :type mac: str
36         :type interface: str or int
37         :type bd_id: int
38         """
39         if isinstance(interface, basestring):
40             sw_if_index = Topology.get_interface_sw_index(node, interface)
41         else:
42             sw_if_index = interface
43         VatExecutor.cmd_from_template(node, "add_l2_fib_entry.vat",
44                                       mac=mac, bd=bd_id,
45                                       interface=sw_if_index)
46
47     @staticmethod
48     def create_l2_bd(node, bd_id, flood=1, uu_flood=1, forward=1, learn=1,
49                      arp_term=0):
50         """Create a l2 bridge domain on the chosen VPP node
51
52         Execute "bridge_domain_add_del bd_id {bd_id} flood {flood} uu-flood 1
53         forward {forward} learn {learn} arp-term {arp_term}" VAT command on
54         the node.
55
56         :param node: Node where we wish to crate the l2 bridge domain.
57         :param bd_id: Bridge domain index number.
58         :param flood: Enable flooding.
59         :param uu_flood: Enable uu_flood.
60         :param forward: Enable forwarding.
61         :param learn: Enable mac address learning to fib.
62         :param arp_term: Enable arp_termination.
63         :type node: dict
64         :type bd_id: int
65         :type flood: bool
66         :type uu_flood: bool
67         :type forward: bool
68         :type learn: bool
69         :type arp_term:bool
70         """
71         VatExecutor.cmd_from_template(node, "l2_bd_create.vat",
72                                       bd_id=bd_id, flood=flood,
73                                       uu_flood=uu_flood, forward=forward,
74                                       learn=learn, arp_term=arp_term)
75
76     @staticmethod
77     def add_interface_to_l2_bd(node, interface, bd_id, shg=0):
78         """Add a interface to the l2 bridge domain.
79
80         Get SW IF ID and add it to the bridge domain.
81
82         :param node: Node where we want to execute the command that does this.
83         :param interface: Interface name.
84         :param bd_id: Bridge domain index number to add Interface name to.
85         :param shg: Split horizon group.
86         :type node: dict
87         :type interface: str
88         :type bd_id: int
89         :type shg: int
90         """
91         sw_if_index = Topology.get_interface_sw_index(node, interface)
92         L2Util.add_sw_if_index_to_l2_bd(node, sw_if_index, bd_id, shg)
93
94     @staticmethod
95     def add_sw_if_index_to_l2_bd(node, sw_if_index, bd_id, shg=0):
96         """Add interface with sw_if_index to l2 bridge domain.
97
98         Execute the "sw_interface_set_l2_bridge sw_if_index {sw_if_index}
99         bd_id {bd_id} shg {shg} enable" VAT command on the given node.
100
101         :param node: Node where we want to execute the command that does this.
102         :param sw_if_index: Interface index.
103         :param bd_id: Bridge domain index number to add SW IF ID to.
104         :param shg: Split horizon group.
105         :type node: dict
106         :type sw_if_index: int
107         :type bd_id: int
108         :type shg: int
109         :return:
110         """
111         VatExecutor.cmd_from_template(node, "l2_bd_add_sw_if_index.vat",
112                                       bd_id=bd_id, sw_if_index=sw_if_index,
113                                       shg=shg)
114
115     @staticmethod
116     @keyword('Create dict used in bridge domain template file for node '
117              '"${node}" with links "${link_names}" and bd_id "${bd_id}"')
118     def create_bridge_domain_vat_dict(node, link_names, bd_id):
119         """Create dictionary that can be used in l2 bridge domain template.
120
121         The resulting dictionary looks like this:
122         'interface1': interface name of first interface
123         'interface2': interface name of second interface
124         'bd_id': bridge domain index
125
126         :param node: Node data dictionary.
127         :param link_names: List of names of links the bridge domain should be
128         connecting.
129         :param bd_id: Bridge domain index number.
130         :type node: dict
131         :type link_names: list
132         :return: Dictionary used to generate l2 bridge domain VAT configuration
133         from template file.
134         :rtype: dict
135         """
136         bd_dict = Topology().get_interfaces_by_link_names(node, link_names)
137         bd_dict['bd_id'] = bd_id
138         return bd_dict
139
140     @staticmethod
141     def vpp_add_l2_bridge_domain(node, bd_id, port_1, port_2, learn=True):
142         """Add L2 bridge domain with 2 interfaces to the VPP node.
143
144         :param node: Node to add L2BD on.
145         :param bd_id: Bridge domain ID.
146         :param port_1: First interface name added to L2BD.
147         :param port_2: Second interface name added to L2BD.
148         :param learn: Enable/disable MAC learn.
149         :type node: dict
150         :type bd_id: int
151         :type port_1: str
152         :type port_2: str
153         :type learn: bool
154         """
155         sw_if_index1 = Topology.get_interface_sw_index(node, port_1)
156         sw_if_index2 = Topology.get_interface_sw_index(node, port_2)
157         VatExecutor.cmd_from_template(node,
158                                       'l2_bridge_domain.vat',
159                                       sw_if_id1=sw_if_index1,
160                                       sw_if_id2=sw_if_index2,
161                                       bd_id=bd_id,
162                                       learn=int(learn))
163
164     @staticmethod
165     def vpp_setup_bidirectional_cross_connect(node, interface1, interface2):
166         """Create bidirectional cross-connect between 2 interfaces on vpp node.
167
168         :param node: Node to add bidirectional cross-connect.
169         :param interface1: First interface name or sw_if_index.
170         :param interface2: Second interface name or sw_if_index.
171         :type node: dict
172         :type interface1: str or int
173         :type interface2: str or int
174         """
175
176         if isinstance(interface1, basestring):
177             sw_iface1 = Topology().get_interface_sw_index(node, interface1)
178         else:
179             sw_iface1 = interface1
180
181         if isinstance(interface2, basestring):
182             sw_iface2 = Topology().get_interface_sw_index(node, interface2)
183         else:
184             sw_iface2 = interface2
185
186         with VatTerminal(node) as vat:
187             vat.vat_terminal_exec_cmd_from_template('l2_xconnect.vat',
188                                                     interface1=sw_iface1,
189                                                     interface2=sw_iface2)
190             vat.vat_terminal_exec_cmd_from_template('l2_xconnect.vat',
191                                                     interface1=sw_iface2,
192                                                     interface2=sw_iface1)
193
194     @staticmethod
195     def linux_add_bridge(node, br_name, if_1, if_2):
196         """Bridge two interfaces on linux node.
197
198         :param node: Node to add bridge on.
199         :param br_name: Bridge name.
200         :param if_1: First interface to be added to the bridge.
201         :param if_2: Second interface to be added to the bridge.
202         :type node: dict
203         :type br_name: str
204         :type if_1: str
205         :type if_2: str
206
207         """
208         cmd = 'brctl addbr {0}'.format(br_name)
209         exec_cmd_no_error(node, cmd, sudo=True)
210         cmd = 'brctl addif {0} {1}'.format(br_name, if_1)
211         exec_cmd_no_error(node, cmd, sudo=True)
212         cmd = 'brctl addif {0} {1}'.format(br_name, if_2)
213         exec_cmd_no_error(node, cmd, sudo=True)
214
215     @staticmethod
216     def setup_network_namespace(node, namespace_name, interface_name,
217                                 ip_address, prefix):
218         """Setup namespace on given node and attach interface and IP to
219         this namespace. Applicable also on TG node.
220
221         :param node: Node to set namespace on.
222         :param namespace_name: Namespace name.
223         :param interface_name: Interface name.
224         :param ip_address: IP address of namespace's interface.
225         :param prefix: IP address prefix length.
226         :type node: dict
227         :type namespace_name: str
228         :type vhost_if: str
229         :type ip_address: str
230         :type prefix: int
231
232         """
233         cmd = ('ip netns add {0}'.format(namespace_name))
234         exec_cmd_no_error(node, cmd, sudo=True)
235
236         cmd = ('ip link set dev {0} up netns {1}'.format(interface_name,
237                                                          namespace_name))
238         exec_cmd_no_error(node, cmd, sudo=True)
239
240         cmd = ('ip netns exec {0} ip addr add {1}/{2} dev {3}'.format(
241             namespace_name, ip_address, prefix, interface_name))
242         exec_cmd_no_error(node, cmd, sudo=True)
243
244     @staticmethod
245     def linux_del_bridge(node, br_name):
246         """Delete bridge from linux node.
247
248         :param node: Node to delete bridge from.
249         :param br_name: Bridge name.
250         ..note:: The network interface corresponding to the bridge must be
251         down before it can be deleted!
252         """
253         cmd = 'brctl delbr {0}'.format(br_name)
254         exec_cmd_no_error(node, cmd, sudo=True)
255
256     @staticmethod
257     def vpp_get_bridge_domain_data(node, bd_id=None):
258         """Get all bridge domain data from a VPP node. If a domain ID number is
259         provided, return only data for the matching bridge domain.
260
261         :param node: VPP node to get bridge domain data from.
262         :param bd_id: Numeric ID of a specific bridge domain.
263         :type node: dict
264         :type bd_id: int
265         :return: List of dictionaries containing data for each bridge domain, or
266          a single dictionary for the specified bridge domain.
267         :rtype: list or dict
268         """
269         with VatTerminal(node) as vat:
270             response = vat.vat_terminal_exec_cmd_from_template("l2_bd_dump.vat")
271
272         data = response[0]
273
274         if bd_id is not None:
275             for bridge_domain in data:
276                 if bridge_domain["bd_id"] == bd_id:
277
278                     return bridge_domain
279
280         return data
281
282     @staticmethod
283     def l2_tag_rewrite(node, interface, tag_rewrite_method, tag1_id=None):
284         """Rewrite tags in frame.
285
286         :param node: Node to rewrite tags.
287         :param interface: Interface on which rewrite tags.
288         :param tag_rewrite_method: Method of tag rewrite.
289         :param tag1_id: Optional tag1 ID for VLAN.
290         :type node: dict
291         :type interface: str or int
292         :type tag_rewrite_method : str
293         :type tag1_id: int
294         """
295         if tag1_id is None:
296             tag1_id = ''
297         else:
298             tag1_id = 'tag1 {0}'.format(tag1_id)
299         if isinstance(interface, basestring):
300             sw_if_index = Topology.get_interface_sw_index(node, interface)
301         else:
302             sw_if_index = interface
303
304         with VatTerminal(node) as vat:
305             vat.vat_terminal_exec_cmd_from_template("l2_tag_rewrite.vat",
306                                                     sw_if_index=sw_if_index,
307                                                     tag_rewrite_method=
308                                                     tag_rewrite_method,
309                                                     tag1_optional=tag1_id)

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