X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=resources%2Flibraries%2Fpython%2FInterfaceUtil.py;h=a84d5957673f7c40e6fdf829ab71fbce608422bd;hb=a74531b4483ae9122ba18e064cd20b8550039d21;hp=35194f248726c6cf10fb7357f908382a8d7be87e;hpb=f32168ef95c3b68567ccd57e098d74ad9a536edd;p=csit.git diff --git a/resources/libraries/python/InterfaceUtil.py b/resources/libraries/python/InterfaceUtil.py index 35194f2487..a84d595767 100644 --- a/resources/libraries/python/InterfaceUtil.py +++ b/resources/libraries/python/InterfaceUtil.py @@ -190,15 +190,15 @@ class InterfaceUtil(object): if interface is not None: if isinstance(interface, basestring): - sw_if_index = Topology.get_interface_sw_index(node, interface) + param = "interface_name" + elif isinstance(interface, int): + param = "sw_if_index" else: - sw_if_index = interface - + raise TypeError for data_if in data: - if data_if["sw_if_index"] == sw_if_index: - + if data_if[param] == interface: return data_if - + return dict() return data @staticmethod @@ -490,34 +490,82 @@ class InterfaceUtil(object): if output["retval"] == 0: return output["sw_if_index"] else: - raise RuntimeError('Unable to create VXLAN interface on node {}' + raise RuntimeError('Unable to create VXLAN interface on node {0}' .format(node)) @staticmethod - def vxlan_dump(node, interface): + def vxlan_dump(node, interface=None): """Get VxLAN data for the given interface. :param node: VPP node to get interface data from. :param interface: Numeric index or name string of a specific interface. + If None, information about all VxLAN interfaces is returned. :type node: dict :type interface: int or str - :return: Dictionary containing data for the given VxLAN. - :rtype dict + :return: Dictionary containing data for the given VxLAN interface or if + interface=None, the list of dictionaries with all VxLAN interfaces. + :rtype: dict or list """ - - if isinstance(interface, basestring): + param = "sw_if_index" + if interface is None: + param = '' + sw_if_index = '' + elif isinstance(interface, basestring): sw_if_index = Topology.get_interface_sw_index(node, interface) - else: + elif isinstance(interface, int): sw_if_index = interface + else: + raise Exception("Wrong interface format {0}".format(interface)) with VatTerminal(node) as vat: response = vat.vat_terminal_exec_cmd_from_template( - "vxlan_dump.vat", sw_if_index=sw_if_index) + "vxlan_dump.vat", param=param, sw_if_index=sw_if_index) + + if sw_if_index: + for vxlan in response[0]: + if vxlan["sw_if_index"] == sw_if_index: + return vxlan + return {} + return response[0] + + @staticmethod + def vhost_user_dump(node): + """Get vhost-user data for the given node. + + :param node: VPP node to get interface data from. + :type node: dict + :return: List of dictionaries with all vhost-user interfaces. + :rtype: list + """ + with VatTerminal(node) as vat: + response = vat.vat_terminal_exec_cmd_from_template( + "vhost_user_dump.vat") - for vxlan in response[0]: - if vxlan["sw_if_index"] == sw_if_index: - return vxlan - return {} + return response[0] + + @staticmethod + def tap_dump(node, name=None): + """Get all TAP interface data from the given node, or data about + a specific TAP interface. + + :param node: VPP node to get data from. + :param name: Optional name of a specific TAP interface. + :type node: dict + :type name: str + :return: Dictionary of information about a specific TAP interface, or + a List of dictionaries containing all TAP data for the given node. + :rtype: dict or list + """ + with VatTerminal(node) as vat: + response = vat.vat_terminal_exec_cmd_from_template( + "tap_dump.vat") + if name is None: + return response[0] + else: + for item in response[0]: + if name == item['dev_name']: + return item + return {} @staticmethod def create_subinterface(node, interface, sub_id, outer_vlan_id, @@ -563,7 +611,40 @@ class InterfaceUtil(object): with VatTerminal(node) as vat: vat.vat_terminal_exec_cmd('exec show interfaces') - return '{}.{}'.format(interface, sub_id), sw_subif_index + name = '{}.{}'.format(interface, sub_id) + return name, sw_subif_index + + @staticmethod + def create_gre_tunnel_interface(node, source_ip, destination_ip): + """Create GRE tunnel interface on node. + + :param node: VPP node to add tunnel interface. + :param source_ip: Source of the GRE tunnel. + :param destination_ip: Destination of the GRE tunnel. + :type node: dict + :type source_ip: str + :type destination_ip: str + :return: Name and index of created GRE tunnel interface. + :rtype: tuple + :raises RuntimeError: If unable to create GRE tunnel interface. + """ + output = VatExecutor.cmd_from_template(node, "create_gre.vat", + src=source_ip, + dst=destination_ip) + output = output[0] + + if output["retval"] == 0: + sw_if_index = output["sw_if_index"] + + vat_executor = VatExecutor() + vat_executor.execute_script_json_out("dump_interfaces.vat", node) + interface_dump_json = vat_executor.get_script_stdout() + name = VatJsonUtil.get_interface_name_from_json( + interface_dump_json, sw_if_index) + return name, sw_if_index + else: + raise RuntimeError('Unable to create GRE tunnel on node {}.' + .format(node)) @staticmethod def vpp_create_loopback(node): @@ -580,3 +661,78 @@ class InterfaceUtil(object): else: raise RuntimeError('Create loopback failed on node "{}"' .format(node['host'])) + + @staticmethod + def vpp_enable_input_acl_interface(node, interface, ip_version, + table_index): + """Enable input acl on interface. + + :param node: VPP node to setup interface for input acl. + :param interface: Interface to setup input acl. + :param ip_version: Version of IP protocol. + :param table_index: Classify table index. + :type node: dict + :type interface: str or int + :type ip_version: str + :type table_index: int + """ + if isinstance(interface, basestring): + sw_if_index = Topology.get_interface_sw_index(node, interface) + else: + sw_if_index = interface + + with VatTerminal(node) as vat: + vat.vat_terminal_exec_cmd_from_template("input_acl_int.vat", + sw_if_index=sw_if_index, + ip_version=ip_version, + table_index=table_index) + + @staticmethod + def get_sw_if_index(node, interface_name): + """Get sw_if_index for the given interface from actual interface dump. + + :param node: VPP node to get interface data from. + :param interface_name: Name of the specific interface. + :type node: dict + :type interface_name: str + :return: sw_if_index of the given interface. + :rtype: str + """ + + with VatTerminal(node) as vat: + if_data = vat.vat_terminal_exec_cmd_from_template( + "interface_dump.vat") + for interface in if_data[0]: + if interface["interface_name"] == interface_name: + return interface["sw_if_index"] + + return None + + @staticmethod + def vxlan_gpe_dump(node, interface_name=None): + """Get VxLAN GPE data for the given interface. + + :param node: VPP node to get interface data from. + :param interface_name: Name of the specific interface. If None, + information about all VxLAN GPE interfaces is returned. + :type node: dict + :type interface_name: str + :return: Dictionary containing data for the given VxLAN GPE interface or + if interface=None, the list of dictionaries with all VxLAN GPE + interfaces. + :rtype: dict or list + """ + + with VatTerminal(node) as vat: + vxlan_gpe_data = vat.vat_terminal_exec_cmd_from_template( + "vxlan_gpe_dump.vat") + + if interface_name: + sw_if_index = InterfaceUtil.get_sw_if_index(node, interface_name) + if sw_if_index: + for vxlan_gpe in vxlan_gpe_data[0]: + if vxlan_gpe["sw_if_index"] == sw_if_index: + return vxlan_gpe + return {} + + return vxlan_gpe_data[0]