X-Git-Url: https://gerrit.fd.io/r/gitweb?p=csit.git;a=blobdiff_plain;f=resources%2Flibraries%2Fpython%2FL2Util.py;h=eea66b82b1722d200a2607f6f70b67a61b64f0ad;hp=db550f0640d8095d97d69df073446ff374f8d5db;hb=9377c956a86e42727039d9dab8879c10c9399f4c;hpb=95253bdf705a06ec01c2a04f437bae2ef23355c3 diff --git a/resources/libraries/python/L2Util.py b/resources/libraries/python/L2Util.py index db550f0640..eea66b82b1 100644 --- a/resources/libraries/python/L2Util.py +++ b/resources/libraries/python/L2Util.py @@ -1,4 +1,4 @@ -# Copyright (c) 2016 Cisco and/or its affiliates. +# Copyright (c) 2020 Cisco and/or its affiliates. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at: @@ -13,129 +13,196 @@ """L2 Utilities Library.""" -from robot.api.deco import keyword +from enum import IntEnum +from resources.libraries.python.Constants import Constants +from resources.libraries.python.PapiExecutor import PapiSocketExecutor from resources.libraries.python.topology import Topology -from resources.libraries.python.VatExecutor import VatExecutor, VatTerminal from resources.libraries.python.ssh import exec_cmd_no_error -class L2Util(object): +class L2VtrOp(IntEnum): + """VLAN tag rewrite operation.""" + L2_VTR_DISABLED = 0 + L2_VTR_PUSH_1 = 1 + L2_VTR_PUSH_2 = 2 + L2_VTR_POP_1 = 3 + L2_VTR_POP_2 = 4 + L2_VTR_TRANSLATE_1_1 = 5 + L2_VTR_TRANSLATE_1_2 = 6 + L2_VTR_TRANSLATE_2_1 = 7 + L2_VTR_TRANSLATE_2_2 = 8 + + +class L2Util: """Utilities for l2 configuration.""" @staticmethod - def vpp_add_l2fib_entry(node, mac, interface, bd_id): - """ Create a static L2FIB entry on a vpp node. + def mac_to_int(mac_str): + """Convert MAC address from string format (e.g. 01:02:03:04:05:06) to + integer representation (1108152157446). + + :param mac_str: MAC address in string representation. + :type mac_str: str + :returns: Integer representation of MAC address. + :rtype: int + """ + return int(mac_str.replace(u":", u""), 16) + + @staticmethod + def int_to_mac(mac_int): + """Convert MAC address from integer representation (e.g. 1108152157446) + to string format (01:02:03:04:05:06). + + :param mac_int: MAC address in integer representation. + :type mac_int: int + :returns: String representation of MAC address. + :rtype: str + """ + return u":".join( + f"{hex(mac_int)[2:]:0>12}"[i:i+2] for i in range(0, 12, 2) + ) + + @staticmethod + def mac_to_bin(mac_str): + """Convert MAC address from string format (e.g. 01:02:03:04:05:06) to + binary representation (\x01\x02\x03\x04\x05\x06). + + :param mac_str: MAC address in string representation. + :type mac_str: str + :returns: Binary representation of MAC address. + :rtype: bytes + """ + return bytes.fromhex(mac_str.replace(u":", u"")) + + @staticmethod + def bin_to_mac(mac_bin): + """Convert MAC address from binary representation + (\x01\x02\x03\x04\x05\x06) to string format (e.g. 01:02:03:04:05:06). + + :param mac_bin: MAC address in binary representation. + :type mac_bin: bytes + :returns: String representation of MAC address. + :rtype: str + """ + return u":".join(mac_bin.hex()[i:i + 2] for i in range(0, 12, 2)) + + @staticmethod + def vpp_add_l2fib_entry( + node, mac, interface, bd_id, static_mac=1, filter_mac=0, bvi_mac=0): + """ Create a static L2FIB entry on a VPP node. :param node: Node to add L2FIB entry on. - :param mac: Destination mac address. + :param mac: Destination mac address in string format 01:02:03:04:05:06. :param interface: Interface name or sw_if_index. - :param bd_id: Bridge domain id. + :param bd_id: Bridge domain index. + :param static_mac: Set to 1 to create static MAC entry. + (Default value = 1) + :param filter_mac: Set to 1 to drop packet that's source or destination + MAC address contains defined MAC address. (Default value = 0) + :param bvi_mac: Set to 1 to create entry that points to BVI interface. + (Default value = 0) :type node: dict :type mac: str :type interface: str or int - :type bd_id: int + :type bd_id: int or str + :type static_mac: int or str + :type filter_mac: int or str + :type bvi_mac: int or str """ - if isinstance(interface, basestring): + if isinstance(interface, str): sw_if_index = Topology.get_interface_sw_index(node, interface) else: sw_if_index = interface - VatExecutor.cmd_from_template(node, "add_l2_fib_entry.vat", - mac=mac, bd=bd_id, - interface=sw_if_index) + + cmd = u"l2fib_add_del" + err_msg = f"Failed to add L2FIB entry on host {node[u'host']}" + args = dict( + mac=L2Util.mac_to_bin(mac), + bd_id=int(bd_id), + sw_if_index=sw_if_index, + is_add=True, + static_mac=int(static_mac), + filter_mac=int(filter_mac), + bvi_mac=int(bvi_mac) + + ) + with PapiSocketExecutor(node) as papi_exec: + papi_exec.add(cmd, **args).get_reply(err_msg) @staticmethod - def create_l2_bd(node, bd_id, flood=1, uu_flood=1, forward=1, learn=1, - arp_term=0): - """Create a l2 bridge domain on the chosen VPP node - - Execute "bridge_domain_add_del bd_id {bd_id} flood {flood} uu-flood 1 - forward {forward} learn {learn} arp-term {arp_term}" VAT command on - the node. - - :param node: Node where we wish to crate the l2 bridge domain. - :param bd_id: Bridge domain index number. - :param flood: Enable flooding. - :param uu_flood: Enable uu_flood. - :param forward: Enable forwarding. - :param learn: Enable mac address learning to fib. - :param arp_term: Enable arp_termination. + def create_l2_bd( + node, bd_id, flood=True, uu_flood=True, forward=True, learn=True, + arp_term=False): + """Create an L2 bridge domain on a VPP node. + + :param node: Node where we wish to crate the L2 bridge domain. + :param bd_id: Bridge domain index. + :param flood: Enable/disable bcast/mcast flooding in the BD. + (Default value = 1) + :param uu_flood: Enable/disable unknown unicast flood in the BD. + (Default value = 1) + :param forward: Enable/disable forwarding on all interfaces in + the BD. (Default value = 1) + :param learn: Enable/disable MAC learning on all interfaces in the BD. + (Default value = 1) + :param arp_term: Enable/disable arp termination in the BD. + (Default value = 1) :type node: dict - :type bd_id: int + :type bd_id: int or str :type flood: bool :type uu_flood: bool :type forward: bool :type learn: bool - :type arp_term:bool + :type arp_term: bool """ - VatExecutor.cmd_from_template(node, "l2_bd_create.vat", - bd_id=bd_id, flood=flood, - uu_flood=uu_flood, forward=forward, - learn=learn, arp_term=arp_term) + cmd = u"bridge_domain_add_del" + err_msg = f"Failed to create L2 bridge domain on host {node[u'host']}" + args = dict( + bd_id=int(bd_id), + flood=flood, + uu_flood=uu_flood, + forward=forward, + learn=learn, + arp_term=arp_term, + is_add=True + ) + with PapiSocketExecutor(node) as papi_exec: + papi_exec.add(cmd, **args).get_reply(err_msg) @staticmethod - def add_interface_to_l2_bd(node, interface, bd_id, shg=0): - """Add a interface to the l2 bridge domain. + def add_interface_to_l2_bd(node, interface, bd_id, shg=0, port_type=0): + """Add an interface to the L2 bridge domain. Get SW IF ID and add it to the bridge domain. :param node: Node where we want to execute the command that does this. :param interface: Interface name. - :param bd_id: Bridge domain index number to add Interface name to. - :param shg: Split horizon group. + :param bd_id: Bridge domain index. + :param shg: Split-horizon group index. (Default value = 0) + :param port_type: Port mode: 0 - normal, 1 - BVI, 2 - UU_FWD. + (Default value = 0) :type node: dict :type interface: str - :type bd_id: int - :type shg: int + :type bd_id: int or str + :type shg: int or str + :type port_type: int or str """ sw_if_index = Topology.get_interface_sw_index(node, interface) - L2Util.add_sw_if_index_to_l2_bd(node, sw_if_index, bd_id, shg) - @staticmethod - def add_sw_if_index_to_l2_bd(node, sw_if_index, bd_id, shg=0): - """Add interface with sw_if_index to l2 bridge domain. + cmd = u"sw_interface_set_l2_bridge" + err_msg = f"Failed to add interface {interface} to L2 bridge domain " \ + f"on host {node[u'host']}" + args = dict( + rx_sw_if_index=sw_if_index, + bd_id=int(bd_id), + shg=int(shg), + port_type=int(port_type), + enable=True + ) - Execute the "sw_interface_set_l2_bridge sw_if_index {sw_if_index} - bd_id {bd_id} shg {shg} enable" VAT command on the given node. - - :param node: Node where we want to execute the command that does this. - :param sw_if_index: Interface index. - :param bd_id: Bridge domain index number to add SW IF ID to. - :param shg: Split horizon group. - :type node: dict - :type sw_if_index: int - :type bd_id: int - :type shg: int - :return: - """ - VatExecutor.cmd_from_template(node, "l2_bd_add_sw_if_index.vat", - bd_id=bd_id, sw_if_index=sw_if_index, - shg=shg) - - @staticmethod - @keyword('Create dict used in bridge domain template file for node ' - '"${node}" with links "${link_names}" and bd_id "${bd_id}"') - def create_bridge_domain_vat_dict(node, link_names, bd_id): - """Create dictionary that can be used in l2 bridge domain template. - - The resulting dictionary looks like this: - 'interface1': interface name of first interface - 'interface2': interface name of second interface - 'bd_id': bridge domain index - - :param node: Node data dictionary. - :param link_names: List of names of links the bridge domain should be - connecting. - :param bd_id: Bridge domain index number. - :type node: dict - :type link_names: list - :return: Dictionary used to generate l2 bridge domain VAT configuration - from template file. - :rtype: dict - """ - bd_dict = Topology().get_interfaces_by_link_names(node, link_names) - bd_dict['bd_id'] = bd_id - return bd_dict + with PapiSocketExecutor(node) as papi_exec: + papi_exec.add(cmd, **args).get_reply(err_msg) @staticmethod def vpp_add_l2_bridge_domain(node, bd_id, port_1, port_2, learn=True): @@ -154,12 +221,41 @@ class L2Util(object): """ sw_if_index1 = Topology.get_interface_sw_index(node, port_1) sw_if_index2 = Topology.get_interface_sw_index(node, port_2) - VatExecutor.cmd_from_template(node, - 'l2_bridge_domain.vat', - sw_if_id1=sw_if_index1, - sw_if_id2=sw_if_index2, - bd_id=bd_id, - learn=int(learn)) + + cmd1 = u"bridge_domain_add_del" + args1 = dict( + bd_id=int(bd_id), + flood=True, + uu_flood=True, + forward=True, + learn=learn, + arp_term=False, + is_add=True + ) + + cmd2 = u"sw_interface_set_l2_bridge" + args2 = dict( + rx_sw_if_index=sw_if_index1, + bd_id=int(bd_id), + shg=0, + port_type=0, + enable=True + ) + + args3 = dict( + rx_sw_if_index=sw_if_index2, + bd_id=int(bd_id), + shg=0, + port_type=0, + enable=True + ) + + err_msg = f"Failed to add L2 bridge domain with 2 interfaces " \ + f"on host {node[u'host']}" + + with PapiSocketExecutor(node) as papi_exec: + papi_exec.add(cmd1, **args1).add(cmd2, **args2).add(cmd2, **args3) + papi_exec.get_replies(err_msg) @staticmethod def vpp_setup_bidirectional_cross_connect(node, interface1, interface2): @@ -172,89 +268,124 @@ class L2Util(object): :type interface1: str or int :type interface2: str or int """ + if isinstance(interface1, str): + sw_iface1 = Topology().get_interface_sw_index(node, interface1) + else: + sw_iface1 = interface1 - if isinstance(interface1, basestring): + if isinstance(interface2, str): + sw_iface2 = Topology().get_interface_sw_index(node, interface2) + else: + sw_iface2 = interface2 + + cmd = u"sw_interface_set_l2_xconnect" + args1 = dict( + rx_sw_if_index=sw_iface1, + tx_sw_if_index=sw_iface2, + enable=True + ) + args2 = dict( + rx_sw_if_index=sw_iface2, + tx_sw_if_index=sw_iface1, + enable=True + ) + err_msg = f"Failed to add L2 cross-connect between two interfaces " \ + f"on host {node['host']}" + + with PapiSocketExecutor(node) as papi_exec: + papi_exec.add(cmd, **args1).add(cmd, **args2).get_replies(err_msg) + + @staticmethod + def vpp_setup_bidirectional_l2_patch(node, interface1, interface2): + """Create bidirectional l2 patch between 2 interfaces on vpp node. + + :param node: Node to add bidirectional l2 patch. + :param interface1: First interface name or sw_if_index. + :param interface2: Second interface name or sw_if_index. + :type node: dict + :type interface1: str or int + :type interface2: str or int + """ + if isinstance(interface1, str): sw_iface1 = Topology().get_interface_sw_index(node, interface1) else: sw_iface1 = interface1 - if isinstance(interface2, basestring): + if isinstance(interface2, str): sw_iface2 = Topology().get_interface_sw_index(node, interface2) else: sw_iface2 = interface2 - with VatTerminal(node) as vat: - vat.vat_terminal_exec_cmd_from_template('l2_xconnect.vat', - interface1=sw_iface1, - interface2=sw_iface2) - vat.vat_terminal_exec_cmd_from_template('l2_xconnect.vat', - interface1=sw_iface2, - interface2=sw_iface1) + cmd = u"l2_patch_add_del" + args1 = dict( + rx_sw_if_index=sw_iface1, + tx_sw_if_index=sw_iface2, + is_add=True + ) + args2 = dict( + rx_sw_if_index=sw_iface2, + tx_sw_if_index=sw_iface1, + is_add=True + ) + err_msg = f"Failed to add L2 patch between two interfaces " \ + f"on host {node['host']}" + + with PapiSocketExecutor(node) as papi_exec: + papi_exec.add(cmd, **args1).add(cmd, **args2).get_replies(err_msg) @staticmethod - def linux_add_bridge(node, br_name, if_1, if_2): + def linux_add_bridge(node, br_name, if_1, if_2, set_up=True): """Bridge two interfaces on linux node. :param node: Node to add bridge on. :param br_name: Bridge name. :param if_1: First interface to be added to the bridge. :param if_2: Second interface to be added to the bridge. + :param set_up: Change bridge interface state to up after create bridge. + Optional. Default: True. :type node: dict :type br_name: str :type if_1: str :type if_2: str - + :type set_up: bool """ - cmd = 'brctl addbr {0}'.format(br_name) - exec_cmd_no_error(node, cmd, sudo=True) - cmd = 'brctl addif {0} {1}'.format(br_name, if_1) - exec_cmd_no_error(node, cmd, sudo=True) - cmd = 'brctl addif {0} {1}'.format(br_name, if_2) + cmd = f"brctl addbr {br_name}" exec_cmd_no_error(node, cmd, sudo=True) - @staticmethod - def setup_network_namespace(node, namespace_name, interface_name, - ip_address, prefix): - """Setup namespace on given node and attach interface and IP to - this namespace. Applicable also on TG node. - - :param node: Node to set namespace on. - :param namespace_name: Namespace name. - :param interface_name: Interface name. - :param ip_address: IP address of namespace's interface. - :param prefix: IP address prefix length. - :type node: dict - :type namespace_name: str - :type vhost_if: str - :type ip_address: str - :type prefix: int - - """ - cmd = ('ip netns add {0}'.format(namespace_name)) + cmd = f"brctl addif {br_name} {if_1}" exec_cmd_no_error(node, cmd, sudo=True) - cmd = ('ip link set dev {0} up netns {1}'.format(interface_name, - namespace_name)) + cmd = f"brctl addif {br_name} {if_2}" exec_cmd_no_error(node, cmd, sudo=True) - cmd = ('ip netns exec {0} ip addr add {1}/{2} dev {3}'.format( - namespace_name, ip_address, prefix, interface_name)) - exec_cmd_no_error(node, cmd, sudo=True) + if set_up: + cmd = f"ip link set dev {br_name} up" + exec_cmd_no_error(node, cmd, sudo=True) @staticmethod - def linux_del_bridge(node, br_name): + def linux_del_bridge(node, br_name, set_down=True): """Delete bridge from linux node. + ..note:: The network interface corresponding to the bridge must be + down before it can be deleted! + :param node: Node to delete bridge from. :param br_name: Bridge name. - ..note:: The network interface corresponding to the bridge must be - down before it can be deleted! + :param set_down: Change bridge interface state to down before delbr + command. Optional. Default: True. + :type node: dict + :type br_name: str + :type set_down: bool """ - cmd = 'brctl delbr {0}'.format(br_name) + if set_down: + cmd = f"ip link set dev {br_name} down" + exec_cmd_no_error(node, cmd, sudo=True) + + cmd = f"brctl delbr {br_name}" exec_cmd_no_error(node, cmd, sudo=True) @staticmethod - def vpp_get_bridge_domain_data(node, bd_id=None): + def vpp_get_bridge_domain_data(node, bd_id=Constants.BITWISE_NON_ZERO): """Get all bridge domain data from a VPP node. If a domain ID number is provided, return only data for the matching bridge domain. @@ -262,110 +393,101 @@ class L2Util(object): :param bd_id: Numeric ID of a specific bridge domain. :type node: dict :type bd_id: int - :return: List of dictionaries containing data for each bridge domain, or - a single dictionary for the specified bridge domain. + :returns: List of dictionaries containing data for each bridge domain, + or a single dictionary for the specified bridge domain. :rtype: list or dict """ - with VatTerminal(node) as vat: - response = vat.vat_terminal_exec_cmd_from_template("l2_bd_dump.vat") + cmd = u"bridge_domain_dump" + args = dict( + bd_id=int(bd_id) + ) + err_msg = f"Failed to get L2FIB dump on host {node[u'host']}" - data = response[0] + with PapiSocketExecutor(node) as papi_exec: + details = papi_exec.add(cmd, **args).get_details(err_msg) - if bd_id is not None: - for bridge_domain in data: - if bridge_domain["bd_id"] == bd_id: + retval = details if bd_id == Constants.BITWISE_NON_ZERO else None - return bridge_domain + for bridge_domain in details: + if bridge_domain[u"bd_id"] == bd_id: + retval = bridge_domain - return data + return retval @staticmethod - def l2_tag_rewrite(node, interface, tag_rewrite_method, tag1_id=None): - """Rewrite tags in frame. + def l2_vlan_tag_rewrite( + node, interface, tag_rewrite_method, push_dot1q=True, tag1_id=None, + tag2_id=None): + """Rewrite tags in ethernet frame. :param node: Node to rewrite tags. :param interface: Interface on which rewrite tags. :param tag_rewrite_method: Method of tag rewrite. + :param push_dot1q: Optional parameter to disable to push dot1q tag + instead of dot1ad. :param tag1_id: Optional tag1 ID for VLAN. + :param tag2_id: Optional tag2 ID for VLAN. :type node: dict :type interface: str or int - :type tag_rewrite_method : str + :type tag_rewrite_method: str + :type push_dot1q: bool :type tag1_id: int + :type tag2_id: int """ - if tag1_id is None: - tag1_id = '' - else: - tag1_id = 'tag1 {0}'.format(tag1_id) - if isinstance(interface, basestring): - sw_if_index = Topology.get_interface_sw_index(node, interface) - else: - sw_if_index = interface + tag1_id = int(tag1_id) if tag1_id else 0 + tag2_id = int(tag2_id) if tag2_id else 0 - with VatTerminal(node) as vat: - vat.vat_terminal_exec_cmd_from_template("l2_tag_rewrite.vat", - sw_if_index=sw_if_index, - tag_rewrite_method= - tag_rewrite_method, - tag1_optional=tag1_id) + vtr_oper = getattr( + L2VtrOp, f"L2_VTR_{tag_rewrite_method.replace(u'-', u'_').upper()}" + ) - @staticmethod - def delete_bridge_domain_vat(node, bd_id): - """Delete the specified bridge domain from the node. + if isinstance(interface, str): + iface_key = Topology.get_interface_by_name(node, interface) + sw_if_index = Topology.get_interface_sw_index(node, iface_key) + else: + sw_if_index = interface - :param node: VPP node to delete a bridge domain from. - :param bd_id: Bridge domain ID. - :type node: dict - :type bd_id: int - """ + cmd = u"l2_interface_vlan_tag_rewrite" + args = dict( + sw_if_index=sw_if_index, + vtr_op=int(vtr_oper), + push_dot1q=int(push_dot1q), + tag1=tag1_id, + tag2=tag2_id + ) + err_msg = f"Failed to set VLAN TAG rewrite on host {node['host']}" - with VatTerminal(node) as vat: - vat.vat_terminal_exec_cmd_from_template( - "l2_bridge_domain_delete.vat", bd_id=bd_id) + with PapiSocketExecutor(node) as papi_exec: + papi_exec.add(cmd, **args).get_reply(err_msg) @staticmethod - def delete_l2_fib_entry(node, bd_id, mac): - """Delete the specified L2 FIB entry. + def get_l2_fib_table(node, bd_id): + """Retrieves the L2 FIB table. :param node: VPP node. - :param bd_id: Bridge domain ID. - :param mac: MAC address used as the key in L2 FIB entry. + :param bd_id: Index of the bridge domain. :type node: dict :type bd_id: int - :type mac: str - """ - - with VatTerminal(node) as vat: - vat.vat_terminal_exec_cmd_from_template("l2_fib_entry_delete.vat", - mac=mac, - bd_id=bd_id) - - @staticmethod - def get_l2_fib_table_vat(node, bd_index): - """Retrieves the L2 FIB table using VAT. - - :param node: VPP node. - :param bd_index: Index of the bridge domain. - :type node: dict - :type bd_index: int - :return: L2 FIB table. + :returns: L2 FIB table. :rtype: list """ + cmd = u"l2_fib_table_dump" + args = dict( + bd_id=int(bd_id) + ) + err_msg = f"Failed to get L2FIB dump on host {node['host']}" - bd_data = L2Util.vpp_get_bridge_domain_data(node) - bd_id = bd_data[bd_index-1]["bd_id"] + with PapiSocketExecutor(node) as papi_exec: + details = papi_exec.add(cmd, **args).get_details(err_msg) - try: - with VatTerminal(node) as vat: - table = vat.vat_terminal_exec_cmd_from_template( - "l2_fib_table_dump.vat", bd_id=bd_id) + for fib_item in details: + fib_item[u"mac"] = L2Util.bin_to_mac(fib_item[u"mac"]) - return table[0] - except ValueError: - return [] + return details @staticmethod - def get_l2_fib_entry_vat(node, bd_index, mac): - """Retrieves the L2 FIB entry specified by MAC address using VAT. + def get_l2_fib_entry_by_mac(node, bd_index, mac): + """Retrieves the L2 FIB entry specified by MAC address using PAPI. :param node: VPP node. :param bd_index: Index of the bridge domain. @@ -373,12 +495,15 @@ class L2Util(object): :type node: dict :type bd_index: int :type mac: str - :return: L2 FIB entry + :returns: L2 FIB entry :rtype: dict """ + bd_data = L2Util.vpp_get_bridge_domain_data(node) + bd_id = bd_data[bd_index-1][u"bd_id"] + + table = L2Util.get_l2_fib_table(node, bd_id) - table = L2Util.get_l2_fib_table_vat(node, bd_index) for entry in table: - if entry["mac"] == mac: + if entry[u"mac"] == mac: return entry return {}