resources/libraries/python/L2Util.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 """L2 Utilities Library."""
  15
  16 from textwrap import wrap
  17
  18 from robot.api.deco import keyword
  19
  20 from resources.libraries.python.topology import Topology
  21 from resources.libraries.python.VatExecutor import VatExecutor, VatTerminal
  22 from resources.libraries.python.ssh import exec_cmd_no_error
  23
  24
  25 class L2Util(object):
  26     """Utilities for l2 configuration."""
  27
  28     @staticmethod
  29     def mac_to_int(mac_str):
  30         """Convert MAC address from string format (e.g. 01:02:03:04:05:06) to
  31         integer representation (1108152157446).
  32
  33         :param mac_str: MAC address in string representation.
  34         :type mac_str: str
  35         :returns: Integer representation of MAC address.
  36         :rtype: int
  37         """
  38         return int(mac_str.replace(':', ''), 16)
  39
  40     @staticmethod
  41     def int_to_mac(mac_int):
  42         """Convert MAC address from integer representation (e.g. 1108152157446)
  43         to string format (01:02:03:04:05:06).
  44
  45         :param mac_int: MAC address in integer representation.
  46         :type mac_int: str
  47         :returns: String representation of MAC address.
  48         :rtype: int
  49         """
  50         return ':'.join(wrap("{:012x}".format(mac_int), width=2))
  51
  52     @staticmethod
  53     def vpp_add_l2fib_entry(node, mac, interface, bd_id):
  54         """ Create a static L2FIB entry on a vpp node.
  55
  56         :param node: Node to add L2FIB entry on.
  57         :param mac: Destination mac address.
  58         :param interface: Interface name or sw_if_index.
  59         :param bd_id: Bridge domain id.
  60         :type node: dict
  61         :type mac: str
  62         :type interface: str or int
  63         :type bd_id: int
  64         """
  65         if isinstance(interface, basestring):
  66             sw_if_index = Topology.get_interface_sw_index(node, interface)
  67         else:
  68             sw_if_index = interface
  69         VatExecutor.cmd_from_template(node, "add_l2_fib_entry.vat",
  70                                       mac=mac, bd=bd_id,
  71                                       interface=sw_if_index)
  72
  73     @staticmethod
  74     def create_l2_bd(node, bd_id, flood=1, uu_flood=1, forward=1, learn=1,
  75                      arp_term=0):
  76         """Create a l2 bridge domain on the chosen VPP node
  77
  78         Execute "bridge_domain_add_del bd_id {bd_id} flood {flood} uu-flood 1
  79         forward {forward} learn {learn} arp-term {arp_term}" VAT command on
  80         the node.
  81
  82         :param node: Node where we wish to crate the l2 bridge domain.
  83         :param bd_id: Bridge domain index number.
  84         :param flood: Enable flooding.
  85         :param uu_flood: Enable uu_flood.
  86         :param forward: Enable forwarding.
  87         :param learn: Enable mac address learning to fib.
  88         :param arp_term: Enable arp_termination.
  89         :type node: dict
  90         :type bd_id: int
  91         :type flood: bool
  92         :type uu_flood: bool
  93         :type forward: bool
  94         :type learn: bool
  95         :type arp_term: bool
  96         """
  97         VatExecutor.cmd_from_template(node, "l2_bd_create.vat",
  98                                       bd_id=bd_id, flood=flood,
  99                                       uu_flood=uu_flood, forward=forward,
 100                                       learn=learn, arp_term=arp_term)
 101
 102     @staticmethod
 103     def add_interface_to_l2_bd(node, interface, bd_id, shg=0):
 104         """Add a interface to the l2 bridge domain.
 105
 106         Get SW IF ID and add it to the bridge domain.
 107
 108         :param node: Node where we want to execute the command that does this.
 109         :param interface: Interface name.
 110         :param bd_id: Bridge domain index number to add Interface name to.
 111         :param shg: Split horizon group.
 112         :type node: dict
 113         :type interface: str
 114         :type bd_id: int
 115         :type shg: int
 116         """
 117         sw_if_index = Topology.get_interface_sw_index(node, interface)
 118         L2Util.add_sw_if_index_to_l2_bd(node, sw_if_index, bd_id, shg)
 119
 120     @staticmethod
 121     def add_sw_if_index_to_l2_bd(node, sw_if_index, bd_id, shg=0):
 122         """Add interface with sw_if_index to l2 bridge domain.
 123
 124         Execute the "sw_interface_set_l2_bridge sw_if_index {sw_if_index}
 125         bd_id {bd_id} shg {shg} enable" VAT command on the given node.
 126
 127         :param node: Node where we want to execute the command that does this.
 128         :param sw_if_index: Interface index.
 129         :param bd_id: Bridge domain index number to add SW IF ID to.
 130         :param shg: Split horizon group.
 131         :type node: dict
 132         :type sw_if_index: int
 133         :type bd_id: int
 134         :type shg: int
 135         :returns: None
 136         """
 137         VatExecutor.cmd_from_template(node, "l2_bd_add_sw_if_index.vat",
 138                                       bd_id=bd_id, sw_if_index=sw_if_index,
 139                                       shg=shg)
 140
 141     @staticmethod
 142     @keyword('Create dict used in bridge domain template file for node '
 143              '"${node}" with links "${link_names}" and bd_id "${bd_id}"')
 144     def create_bridge_domain_vat_dict(node, link_names, bd_id):
 145         """Create dictionary that can be used in l2 bridge domain template.
 146
 147         The resulting dictionary looks like this:
 148         'interface1': interface name of first interface
 149         'interface2': interface name of second interface
 150         'bd_id': bridge domain index
 151
 152         :param node: Node data dictionary.
 153         :param link_names: List of names of links the bridge domain should be
 154             connecting.
 155         :param bd_id: Bridge domain index number.
 156         :type node: dict
 157         :type link_names: list
 158         :returns: Dictionary used to generate l2 bridge domain VAT configuration
 159             from template file.
 160         :rtype: dict
 161         """
 162         bd_dict = Topology().get_interfaces_by_link_names(node, link_names)
 163         bd_dict['bd_id'] = bd_id
 164         return bd_dict
 165
 166     @staticmethod
 167     def vpp_add_l2_bridge_domain(node, bd_id, port_1, port_2, learn=True):
 168         """Add L2 bridge domain with 2 interfaces to the VPP node.
 169
 170         :param node: Node to add L2BD on.
 171         :param bd_id: Bridge domain ID.
 172         :param port_1: First interface name added to L2BD.
 173         :param port_2: Second interface name added to L2BD.
 174         :param learn: Enable/disable MAC learn.
 175         :type node: dict
 176         :type bd_id: int
 177         :type port_1: str
 178         :type port_2: str
 179         :type learn: bool
 180         """
 181         sw_if_index1 = Topology.get_interface_sw_index(node, port_1)
 182         sw_if_index2 = Topology.get_interface_sw_index(node, port_2)
 183         VatExecutor.cmd_from_template(node,
 184                                       'l2_bridge_domain.vat',
 185                                       sw_if_id1=sw_if_index1,
 186                                       sw_if_id2=sw_if_index2,
 187                                       bd_id=bd_id,
 188                                       learn=int(learn))
 189
 190     @staticmethod
 191     def vpp_setup_bidirectional_cross_connect(node, interface1, interface2):
 192         """Create bidirectional cross-connect between 2 interfaces on vpp node.
 193
 194         :param node: Node to add bidirectional cross-connect.
 195         :param interface1: First interface name or sw_if_index.
 196         :param interface2: Second interface name or sw_if_index.
 197         :type node: dict
 198         :type interface1: str or int
 199         :type interface2: str or int
 200         """
 201
 202         if isinstance(interface1, basestring):
 203             sw_iface1 = Topology().get_interface_sw_index(node, interface1)
 204         else:
 205             sw_iface1 = interface1
 206
 207         if isinstance(interface2, basestring):
 208             sw_iface2 = Topology().get_interface_sw_index(node, interface2)
 209         else:
 210             sw_iface2 = interface2
 211
 212         with VatTerminal(node) as vat:
 213             vat.vat_terminal_exec_cmd_from_template('l2_xconnect.vat',
 214                                                     interface1=sw_iface1,
 215                                                     interface2=sw_iface2)
 216             vat.vat_terminal_exec_cmd_from_template('l2_xconnect.vat',
 217                                                     interface1=sw_iface2,
 218                                                     interface2=sw_iface1)
 219
 220     @staticmethod
 221     def linux_add_bridge(node, br_name, if_1, if_2, set_up=True):
 222         """Bridge two interfaces on linux node.
 223
 224         :param node: Node to add bridge on.
 225         :param br_name: Bridge name.
 226         :param if_1: First interface to be added to the bridge.
 227         :param if_2: Second interface to be added to the bridge.
 228         :param set_up: Change bridge interface state to up after create bridge.
 229             Optional. Default: True.
 230         :type node: dict
 231         :type br_name: str
 232         :type if_1: str
 233         :type if_2: str
 234         :type set_up: bool
 235         """
 236         cmd = 'brctl addbr {0}'.format(br_name)
 237         exec_cmd_no_error(node, cmd, sudo=True)
 238         cmd = 'brctl addif {0} {1}'.format(br_name, if_1)
 239         exec_cmd_no_error(node, cmd, sudo=True)
 240         cmd = 'brctl addif {0} {1}'.format(br_name, if_2)
 241         exec_cmd_no_error(node, cmd, sudo=True)
 242         if set_up:
 243             cmd = 'ip link set dev {0} up'.format(br_name)
 244             exec_cmd_no_error(node, cmd, sudo=True)
 245
 246     @staticmethod
 247     def linux_del_bridge(node, br_name, set_down=True):
 248         """Delete bridge from linux node.
 249
 250         ..note:: The network interface corresponding to the bridge must be
 251             down before it can be deleted!
 252
 253         :param node: Node to delete bridge from.
 254         :param br_name: Bridge name.
 255         :param set_down: Change bridge interface state to down before delbr
 256             command. Optional. Default: True.
 257         :type node: str
 258         :type br_name: str
 259         :type set_down: bool
 260         """
 261         if set_down:
 262             cmd = 'ip link set dev {0} down'.format(br_name)
 263             exec_cmd_no_error(node, cmd, sudo=True)
 264         cmd = 'brctl delbr {0}'.format(br_name)
 265         exec_cmd_no_error(node, cmd, sudo=True)
 266
 267     @staticmethod
 268     def vpp_get_bridge_domain_data(node, bd_id=None):
 269         """Get all bridge domain data from a VPP node. If a domain ID number is
 270         provided, return only data for the matching bridge domain.
 271
 272         :param node: VPP node to get bridge domain data from.
 273         :param bd_id: Numeric ID of a specific bridge domain.
 274         :type node: dict
 275         :type bd_id: int
 276         :returns: List of dictionaries containing data for each bridge domain,
 277             or a single dictionary for the specified bridge domain.
 278         :rtype: list or dict
 279         """
 280         with VatTerminal(node) as vat:
 281             response = vat.vat_terminal_exec_cmd_from_template("l2_bd_dump.vat")
 282
 283         data = response[0]
 284
 285         if bd_id is not None:
 286             for bridge_domain in data:
 287                 if bridge_domain["bd_id"] == bd_id:
 288
 289                     return bridge_domain
 290
 291         return data
 292
 293     @staticmethod
 294     def l2_vlan_tag_rewrite(node, interface, tag_rewrite_method,
 295                             push_dot1q=True, tag1_id=None, tag2_id=None):
 296         """Rewrite tags in ethernet frame.
 297
 298         :param node: Node to rewrite tags.
 299         :param interface: Interface on which rewrite tags.
 300         :param tag_rewrite_method: Method of tag rewrite.
 301         :param push_dot1q: Optional parameter to disable to push dot1q tag
 302             instead of dot1ad.
 303         :param tag1_id: Optional tag1 ID for VLAN.
 304         :param tag2_id: Optional tag2 ID for VLAN.
 305         :type node: dict
 306         :type interface: str or int
 307         :type tag_rewrite_method: str
 308         :type push_dot1q: bool
 309         :type tag1_id: int
 310         :type tag2_id: int
 311         """
 312         push_dot1q = 'push_dot1q 0' if not push_dot1q else ''
 313
 314         tag1_id = 'tag1 {0}'.format(tag1_id) if tag1_id else ''
 315         tag2_id = 'tag2 {0}'.format(tag2_id) if tag2_id else ''
 316
 317         if isinstance(interface, basestring):
 318             iface_key = Topology.get_interface_by_name(node, interface)
 319             sw_if_index = Topology.get_interface_sw_index(node, iface_key)
 320         else:
 321             sw_if_index = interface
 322
 323         with VatTerminal(node) as vat:
 324             vat.vat_terminal_exec_cmd_from_template("l2_vlan_tag_rewrite.vat",
 325                                                     sw_if_index=sw_if_index,
 326                                                     tag_rewrite_method=
 327                                                     tag_rewrite_method,
 328                                                     push_dot1q=push_dot1q,
 329                                                     tag1_optional=tag1_id,
 330                                                     tag2_optional=tag2_id)
 331
 332     @staticmethod
 333     def delete_bridge_domain_vat(node, bd_id):
 334         """Delete the specified bridge domain from the node.
 335
 336         :param node: VPP node to delete a bridge domain from.
 337         :param bd_id: Bridge domain ID.
 338         :type node: dict
 339         :type bd_id: int
 340         """
 341
 342         with VatTerminal(node) as vat:
 343             vat.vat_terminal_exec_cmd_from_template(
 344                 "l2_bridge_domain_delete.vat", bd_id=bd_id)
 345
 346     @staticmethod
 347     def delete_l2_fib_entry(node, bd_id, mac):
 348         """Delete the specified L2 FIB entry.
 349
 350         :param node: VPP node.
 351         :param bd_id: Bridge domain ID.
 352         :param mac: MAC address used as the key in L2 FIB entry.
 353         :type node: dict
 354         :type bd_id: int
 355         :type mac: str
 356         """
 357
 358         with VatTerminal(node) as vat:
 359             vat.vat_terminal_exec_cmd_from_template("l2_fib_entry_delete.vat",
 360                                                     mac=mac,
 361                                                     bd_id=bd_id)
 362
 363     @staticmethod
 364     def get_l2_fib_table_vat(node, bd_index):
 365         """Retrieves the L2 FIB table using VAT.
 366
 367         :param node: VPP node.
 368         :param bd_index: Index of the bridge domain.
 369         :type node: dict
 370         :type bd_index: int
 371         :returns: L2 FIB table.
 372         :rtype: list
 373         """
 374
 375         bd_data = L2Util.vpp_get_bridge_domain_data(node)
 376         bd_id = bd_data[bd_index-1]["bd_id"]
 377
 378         try:
 379             with VatTerminal(node) as vat:
 380                 table = vat.vat_terminal_exec_cmd_from_template(
 381                     "l2_fib_table_dump.vat", bd_id=bd_id)
 382
 383             return table[0]
 384         except ValueError:
 385             return []
 386
 387     @staticmethod
 388     def get_l2_fib_entry_vat(node, bd_index, mac):
 389         """Retrieves the L2 FIB entry specified by MAC address using VAT.
 390
 391         :param node: VPP node.
 392         :param bd_index: Index of the bridge domain.
 393         :param mac: MAC address used as the key in L2 FIB data structure.
 394         :type node: dict
 395         :type bd_index: int
 396         :type mac: str
 397         :returns: L2 FIB entry
 398         :rtype: dict
 399         """
 400
 401         table = L2Util.get_l2_fib_table_vat(node, bd_index)
 402         for entry in table:
 403             if entry["mac"] == mac:
 404                 return entry
 405         return {}