X-Git-Url: https://gerrit.fd.io/r/gitweb?p=csit.git;a=blobdiff_plain;f=resources%2Flibraries%2Fpython%2FL2Util.py;h=f1476044a6f7ab8b015b21e89c8956d9b963326d;hp=e44a6b360aa43dad89b9c61d43f2cf78bd2afa6e;hb=fe1975eb1ac994df1bd759deda7154bb7dd9d7a7;hpb=6000b2abc3d6b8bb8ff2941aacf005a04a33be60 diff --git a/resources/libraries/python/L2Util.py b/resources/libraries/python/L2Util.py index e44a6b360a..f1476044a6 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) 2019 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,198 @@ """L2 Utilities Library.""" -from robot.api.deco import keyword +import binascii +from textwrap import wrap +from enum import IntEnum + +from resources.libraries.python.Constants import Constants +from resources.libraries.python.PapiExecutor import PapiExecutor 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 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(object): """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(':', ''), 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 ':'.join(wrap("{:012x}".format(mac_int), width=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: binary + """ + return binascii.unhexlify(mac_str.replace(':', '')) + + @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: binary + :returns: String representation of MAC address. + :rtype: str + """ + mac_str = ':'.join(binascii.hexlify(mac_bin)[i:i + 2] + for i in range(0, 12, 2)) + return str(mac_str.decode('ascii')) + + @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): 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 = 'l2fib_add_del' + err_msg = 'Failed to add L2FIB entry on host {host}'.format( + host=node['host']) + args = dict(mac=L2Util.mac_to_bin(mac), + bd_id=int(bd_id), + sw_if_index=sw_if_index, + is_add=1, + static_mac=int(static_mac), + filter_mac=int(filter_mac), + bvi_mac=int(bvi_mac)) + with PapiExecutor(node) as papi_exec: + papi_exec.add(cmd, **args).get_replies(err_msg).\ + verify_reply(err_msg=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. + """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 flood: bool - :type uu_flood: bool - :type forward: bool - :type learn: bool - :type arp_term:bool + :type bd_id: int or str + :type flood: int or str + :type uu_flood: int or str + :type forward: int or str + :type learn: int or str + :type arp_term: int or str """ - 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 = 'bridge_domain_add_del' + err_msg = 'Failed to create L2 bridge domain on host {host}'.format( + host=node['host']) + args = dict(bd_id=int(bd_id), + flood=int(flood), + uu_flood=int(uu_flood), + forward=int(forward), + learn=int(learn), + arp_term=int(arp_term), + is_add=1) + with PapiExecutor(node) as papi_exec: + papi_exec.add(cmd, **args).get_replies(err_msg).\ + verify_reply(err_msg=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. - - 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) + sw_if_index = Topology.get_interface_sw_index(node, interface) - @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 + cmd = 'sw_interface_set_l2_bridge' + err_msg = 'Failed to add interface {ifc} to L2 bridge domain on host ' \ + '{host}'.format(ifc=interface, host=node['host']) + args = dict(rx_sw_if_index=sw_if_index, + bd_id=int(bd_id), + shg=int(shg), + port_type=int(port_type), + enable=1) + with PapiExecutor(node) as papi_exec: + papi_exec.add(cmd, **args).get_replies(err_msg).\ + verify_reply(err_msg=err_msg) @staticmethod def vpp_add_l2_bridge_domain(node, bd_id, port_1, port_2, learn=True): @@ -152,14 +221,39 @@ class L2Util(object): :type port_2: str :type learn: bool """ + 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)) + learn_int = 1 if learn else 0 + + cmd1 = 'bridge_domain_add_del' + args1 = dict(bd_id=int(bd_id), + flood=1, + uu_flood=1, + forward=1, + learn=learn_int, + arp_term=0, + is_add=1) + + cmd2 = '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=1) + + args3 = dict(rx_sw_if_index=sw_if_index2, + bd_id=int(bd_id), + shg=0, + port_type=0, + enable=1) + + err_msg = 'Failed to add L2 bridge domain with 2 interfaces on host' \ + ' {host}'.format(host=node['host']) + + with PapiExecutor(node) as papi_exec: + papi_exec.add(cmd1, **args1).add(cmd2, **args2).add(cmd2, **args3).\ + get_replies(err_msg).verify_replies(err_msg=err_msg) @staticmethod def vpp_setup_bidirectional_cross_connect(node, interface1, interface2): @@ -183,78 +277,109 @@ class L2Util(object): 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 = 'sw_interface_set_l2_xconnect' + args1 = dict(rx_sw_if_index=sw_iface1, + tx_sw_if_index=sw_iface2, + enable=1) + args2 = dict(rx_sw_if_index=sw_iface2, + tx_sw_if_index=sw_iface1, + enable=1) + + err_msg = 'Failed to add L2 cross-connect between two interfaces on' \ + ' host {host}'.format(host=node['host']) + + with PapiExecutor(node) as papi_exec: + papi_exec.add(cmd, **args1).add(cmd, **args2).get_replies(err_msg).\ + verify_replies(err_msg=err_msg) @staticmethod - def linux_add_bridge(node, br_name, if_1, if_2): + 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, basestring): + sw_iface1 = Topology().get_interface_sw_index(node, interface1) + else: + sw_iface1 = interface1 + + if isinstance(interface2, basestring): + sw_iface2 = Topology().get_interface_sw_index(node, interface2) + else: + sw_iface2 = interface2 + + cmd = 'l2_patch_add_del' + args1 = dict(rx_sw_if_index=sw_iface1, + tx_sw_if_index=sw_iface2, + is_add=1) + args2 = dict(rx_sw_if_index=sw_iface2, + tx_sw_if_index=sw_iface1, + is_add=1) + + err_msg = 'Failed to add L2 patch between two interfaces on' \ + ' host {host}'.format(host=node['host']) + + with PapiExecutor(node) as papi_exec: + papi_exec.add(cmd, **args1).add(cmd, **args2).get_replies(err_msg).\ + verify_replies(err_msg=err_msg) + + @staticmethod + 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) exec_cmd_no_error(node, cmd, sudo=True) + if set_up: + cmd = 'ip link set dev {0} up'.format(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)) - exec_cmd_no_error(node, cmd, sudo=True) - - cmd = ('ip link set dev {0} up netns {1}'.format(interface_name, - namespace_name)) - 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) - - @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 """ + + if set_down: + cmd = 'ip link set dev {0} down'.format(br_name) + exec_cmd_no_error(node, cmd, sudo=True) cmd = 'brctl delbr {0}'.format(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=0xffffffff): """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,48 +387,125 @@ 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") - data = response[0] + cmd = 'bridge_domain_dump' + cmd_reply = 'bridge_domain_details' + args = dict(bd_id=int(bd_id)) + err_msg = 'Failed to get L2FIB dump on host {host}'.format( + host=node['host']) + with PapiExecutor(node) as papi_exec: + papi_resp = papi_exec.add(cmd, **args).get_dump(err_msg) - if bd_id is not None: - for bridge_domain in data: - if bridge_domain["bd_id"] == bd_id: + data = papi_resp.reply[0]['api_reply'] - return bridge_domain + bd_data = list() if bd_id == Constants.BITWISE_NON_ZERO else dict() + for bridge_domain in data: + if bd_id == Constants.BITWISE_NON_ZERO: + bd_data.append(bridge_domain[cmd_reply]) + else: + if bridge_domain[cmd_reply]['bd_id'] == bd_id: + return bridge_domain[cmd_reply] - return data + return bd_data @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) + + tag1_id = int(tag1_id) if tag1_id else 0 + tag2_id = int(tag2_id) if tag2_id else 0 + + vtr_oper = getattr(L2VtrOp, 'L2_VTR_{}'.format( + tag_rewrite_method.replace('-', '_').upper())) + if isinstance(interface, basestring): - sw_if_index = Topology.get_interface_sw_index(node, interface) + 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 - 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) + cmd = '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 = 'Failed to set VLAN TAG rewrite on host {host}'.format( + host=node['host']) + with PapiExecutor(node) as papi_exec: + papi_exec.add(cmd, **args).get_replies(err_msg).\ + verify_reply(err_msg=err_msg) + + @staticmethod + def get_l2_fib_table(node, bd_id): + """Retrieves the L2 FIB table. + + :param node: VPP node. + :param bd_id: Index of the bridge domain. + :type node: dict + :type bd_id: int + :returns: L2 FIB table. + :rtype: list + """ + + cmd = 'l2_fib_table_dump' + cmd_reply = 'l2_fib_table_details' + args = dict(bd_id=int(bd_id)) + err_msg = 'Failed to get L2FIB dump on host {host}'.format( + host=node['host']) + with PapiExecutor(node) as papi_exec: + papi_resp = papi_exec.add(cmd, **args).get_dump(err_msg) + + data = papi_resp.reply[0]['api_reply'] + + fib_data = list() + for fib in data: + fib_item = fib[cmd_reply] + fib_item['mac'] = L2Util.bin_to_mac(fib_item['mac']) + fib_data.append(fib_item) + + return fib_data + + @staticmethod + 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. + :param mac: MAC address used as the key in L2 FIB data structure. + :type node: dict + :type bd_index: int + :type mac: str + :returns: L2 FIB entry + :rtype: dict + """ + + bd_data = L2Util.vpp_get_bridge_domain_data(node) + bd_id = bd_data[bd_index-1]['bd_id'] + + table = L2Util.get_l2_fib_table(node, bd_id) + + for entry in table: + if entry['mac'] == mac: + return entry + return {}