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:
6 # http://www.apache.org/licenses/LICENSE-2.0
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.
14 """Interface util library"""
16 from time import time, sleep
18 from robot.api import logger
20 from resources.libraries.python.ssh import SSH
21 from resources.libraries.python.IPUtil import convert_ipv4_netmask_prefix
22 from resources.libraries.python.ssh import exec_cmd_no_error
23 from resources.libraries.python.topology import NodeType, Topology
24 from resources.libraries.python.VatExecutor import VatExecutor, VatTerminal
25 from resources.libraries.python.VatJsonUtil import VatJsonUtil
26 from resources.libraries.python.parsers.JsonParser import JsonParser
29 class InterfaceUtil(object):
30 """General utilities for managing interfaces"""
32 __UDEV_IF_RULES_FILE = '/etc/udev/rules.d/10-network.rules'
35 def set_interface_state(node, interface, state, if_type="key"):
36 """Set interface state on a node.
38 Function can be used for DUTs as well as for TGs.
40 :param node: Node where the interface is.
41 :param interface: Interface key or sw_if_index or name.
42 :param state: One of 'up' or 'down'.
43 :param if_type: Interface type
45 :type interface: str or int
52 if isinstance(interface, basestring):
53 sw_if_index = Topology.get_interface_sw_index(node, interface)
54 iface_name = Topology.get_interface_name(node, interface)
56 sw_if_index = interface
57 elif if_type == "name":
58 iface_key = Topology.get_interface_by_name(node, interface)
59 if iface_key is not None:
60 sw_if_index = Topology.get_interface_sw_index(node, iface_key)
61 iface_name = interface
63 raise ValueError("if_type unknown: {}".format(if_type))
65 if node['type'] == NodeType.DUT:
71 raise ValueError('Unexpected interface state: {}'.format(state))
72 VatExecutor.cmd_from_template(node, 'set_if_state.vat',
73 sw_if_index=sw_if_index, state=state)
74 elif node['type'] == NodeType.TG or node['type'] == NodeType.VM:
75 cmd = 'ip link set {} {}'.format(iface_name, state)
76 exec_cmd_no_error(node, cmd, sudo=True)
78 raise Exception('Node {} has unknown NodeType: "{}"'.
79 format(node['host'], node['type']))
82 def set_interface_ethernet_mtu(node, iface_key, mtu):
83 """Set Ethernet MTU for specified interface.
85 Function can be used only for TGs.
87 :param node: Node where the interface is.
88 :param interface: Interface key from topology file.
89 :param mtu: MTU to set.
95 if node['type'] == NodeType.DUT:
96 ValueError('Node {}: Setting Ethernet MTU for interface '
97 'on DUT nodes not supported', node['host'])
98 elif node['type'] == NodeType.TG:
99 iface_name = Topology.get_interface_name(node, iface_key)
100 cmd = 'ip link set {} mtu {}'.format(iface_name, mtu)
101 exec_cmd_no_error(node, cmd, sudo=True)
103 raise ValueError('Node {} has unknown NodeType: "{}"'.
104 format(node['host'], node['type']))
107 def set_default_ethernet_mtu_on_all_interfaces_on_node(node):
108 """Set default Ethernet MTU on all interfaces on node.
110 Function can be used only for TGs.
112 :param node: Node where to set default MTU.
116 for ifc in node['interfaces']:
117 InterfaceUtil.set_interface_ethernet_mtu(node, ifc, 1500)
120 def vpp_node_interfaces_ready_wait(node, timeout=10):
121 """Wait until all interfaces with admin-up are in link-up state.
123 :param node: Node to wait on.
124 :param timeout: Waiting timeout in seconds (optional, default 10s).
127 :raises: RuntimeError if the timeout period value has elapsed.
133 out = InterfaceUtil.vpp_get_interface_data(node)
134 if time() - start > timeout:
135 for interface in out:
136 if interface.get('admin_up_down') == 1:
137 if interface.get('link_up_down') != 1:
138 logger.debug('{0} link-down'.format(
139 interface.get('interface_name')))
140 raise RuntimeError('timeout, not up {0}'.format(not_ready))
142 for interface in out:
143 if interface.get('admin_up_down') == 1:
144 if interface.get('link_up_down') != 1:
145 not_ready.append(interface.get('interface_name'))
149 logger.debug('Interfaces still in link-down state: {0}, '
150 'waiting...'.format(not_ready))
154 def vpp_nodes_interfaces_ready_wait(nodes, timeout=10):
155 """Wait until all interfaces with admin-up are in link-up state for
158 :param nodes: List of nodes to wait on.
159 :param timeout: Seconds to wait per node for all interfaces to come up.
162 :raises: RuntimeError if the timeout period value has elapsed.
165 InterfaceUtil.vpp_node_interfaces_ready_wait(node, timeout)
168 def all_vpp_interfaces_ready_wait(nodes, timeout=10):
169 """Wait until all interfaces with admin-up are in link-up state for all
170 nodes in the topology.
172 :param nodes: Nodes in the topology.
173 :param timeout: Seconds to wait per node for all interfaces to come up.
176 :raises: RuntimeError if the timeout period value has elapsed.
178 for node in nodes.values():
179 if node['type'] == NodeType.DUT:
180 InterfaceUtil.vpp_node_interfaces_ready_wait(node, timeout)
183 def vpp_get_interface_data(node, interface=None):
184 """Get all interface data from a VPP node. If a name or
185 sw_interface_index is provided, return only data for the matching
188 :param node: VPP node to get interface data from.
189 :param interface: Numeric index or name string of a specific interface.
191 :type interface: int or str
192 :return: List of dictionaries containing data for each interface, or a
193 single dictionary for the specified interface.
196 with VatTerminal(node) as vat:
197 response = vat.vat_terminal_exec_cmd_from_template(
198 "interface_dump.vat")
202 if interface is not None:
203 if isinstance(interface, basestring):
204 param = "interface_name"
205 elif isinstance(interface, int):
206 param = "sw_if_index"
210 if data_if[param] == interface:
216 def vpp_get_interface_mac(node, interface=None):
217 """Get MAC address for the given interface from actual interface dump.
219 :param node: VPP node to get interface data from.
220 :param interface: Numeric index or name string of a specific interface.
222 :type interface: int or str
223 :return: MAC address.
227 if_data = InterfaceUtil.vpp_get_interface_data(node, interface)
228 if if_data['sup_sw_if_index'] != if_data['sw_if_index']:
229 if_data = InterfaceUtil.vpp_get_interface_data(
230 node, if_data['sup_sw_if_index'])
231 mac_data = [str(hex(item))[2:] for item in if_data['l2_address'][:6]]
233 for item in mac_data:
236 mac_data_nice.append(item)
237 mac = ":".join(mac_data_nice)
241 def vpp_get_interface_ip_addresses(node, interface, ip_version):
242 """Get list of IP addresses from an interface on a VPP node.
244 :param node: VPP node to get data from.
245 :param interface: Name of an interface on the VPP node.
246 :param ip_version: IP protocol version (ipv4 or ipv6).
249 :type ip_version: str
250 :return: List of dictionaries, each containing IP address, subnet
251 prefix length and also the subnet mask for ipv4 addresses.
252 Note: A single interface may have multiple IP addresses assigned.
255 sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
257 with VatTerminal(node) as vat:
258 response = vat.vat_terminal_exec_cmd_from_template(
259 "ip_address_dump.vat", ip_version=ip_version,
260 sw_if_index=sw_if_index)
264 if ip_version == "ipv4":
266 item["netmask"] = convert_ipv4_netmask_prefix(
267 item["prefix_length"])
271 def tg_set_interface_driver(node, pci_addr, driver):
272 """Set interface driver on the TG node.
274 :param node: Node to set interface driver on (must be TG node).
275 :param pci_addr: PCI address of the interface.
276 :param driver: Driver name.
281 old_driver = InterfaceUtil.tg_get_interface_driver(node, pci_addr)
282 if old_driver == driver:
288 # Unbind from current driver
289 if old_driver is not None:
290 cmd = 'sh -c "echo {0} > /sys/bus/pci/drivers/{1}/unbind"'.format(
291 pci_addr, old_driver)
292 (ret_code, _, _) = ssh.exec_command_sudo(cmd)
293 if int(ret_code) != 0:
294 raise Exception("'{0}' failed on '{1}'".format(cmd,
297 # Bind to the new driver
298 cmd = 'sh -c "echo {0} > /sys/bus/pci/drivers/{1}/bind"'.format(
300 (ret_code, _, _) = ssh.exec_command_sudo(cmd)
301 if int(ret_code) != 0:
302 raise Exception("'{0}' failed on '{1}'".format(cmd, node['host']))
305 def tg_get_interface_driver(node, pci_addr):
306 """Get interface driver from the TG node.
308 :param node: Node to get interface driver on (must be TG node).
309 :param pci_addr: PCI address of the interface.
312 :return: Interface driver or None if not found.
316 # lspci -vmmks 0000:00:05.0
318 Class: Ethernet controller
320 Device: Virtio network device
321 SVendor: Red Hat, Inc
329 cmd = 'lspci -vmmks {0}'.format(pci_addr)
331 (ret_code, stdout, _) = ssh.exec_command(cmd)
332 if int(ret_code) != 0:
333 raise Exception("'{0}' failed on '{1}'".format(cmd, node['host']))
335 for line in stdout.splitlines():
338 (name, value) = line.split("\t", 1)
339 if name == 'Driver:':
345 def tg_set_interfaces_udev_rules(node):
346 """Set udev rules for interfaces.
348 Create udev rules file in /etc/udev/rules.d where are rules for each
349 interface used by TG node, based on MAC interface has specific name.
350 So after unbind and bind again to kernel driver interface has same
351 name as before. This must be called after TG has set name for each
352 port in topology dictionary.
354 SUBSYSTEM=="net", ACTION=="add", ATTR{address}=="52:54:00:e1:8a:0f",
357 :param node: Node to set udev rules on (must be TG node).
363 cmd = 'rm -f {0}'.format(InterfaceUtil.__UDEV_IF_RULES_FILE)
364 (ret_code, _, _) = ssh.exec_command_sudo(cmd)
365 if int(ret_code) != 0:
366 raise Exception("'{0}' failed on '{1}'".format(cmd, node['host']))
368 for interface in node['interfaces'].values():
369 rule = 'SUBSYSTEM==\\"net\\", ACTION==\\"add\\", ATTR{address}' + \
370 '==\\"' + interface['mac_address'] + '\\", NAME=\\"' + \
371 interface['name'] + '\\"'
372 cmd = 'sh -c "echo \'{0}\' >> {1}"'.format(
373 rule, InterfaceUtil.__UDEV_IF_RULES_FILE)
374 (ret_code, _, _) = ssh.exec_command_sudo(cmd)
375 if int(ret_code) != 0:
376 raise Exception("'{0}' failed on '{1}'".format(cmd,
379 cmd = '/etc/init.d/udev restart'
380 ssh.exec_command_sudo(cmd)
383 def tg_set_interfaces_default_driver(node):
384 """Set interfaces default driver specified in topology yaml file.
386 :param node: Node to setup interfaces driver on (must be TG node).
389 for interface in node['interfaces'].values():
390 InterfaceUtil.tg_set_interface_driver(node,
391 interface['pci_address'],
395 def update_vpp_interface_data_on_node(node):
396 """Update vpp generated interface data for a given node in DICT__nodes.
398 Updates interface names, software if index numbers and any other details
399 generated specifically by vpp that are unknown before testcase run.
400 It does this by dumping interface list to JSON output from all
401 devices using vpp_api_test, and pairing known information from topology
402 (mac address/pci address of interface) to state from VPP.
404 :param node: Node selected from DICT__nodes.
407 vat_executor = VatExecutor()
408 vat_executor.execute_script_json_out("dump_interfaces.vat", node)
409 interface_dump_json = vat_executor.get_script_stdout()
410 VatJsonUtil.update_vpp_interface_data_from_json(node,
414 def update_tg_interface_data_on_node(node):
415 """Update interface name for TG/linux node in DICT__nodes.
417 :param node: Node selected from DICT__nodes.
421 # for dev in `ls /sys/class/net/`;
422 > do echo "\"`cat /sys/class/net/$dev/address`\": \"$dev\""; done
423 "52:54:00:9f:82:63": "eth0"
424 "52:54:00:77:ae:a9": "eth1"
425 "52:54:00:e1:8a:0f": "eth2"
426 "00:00:00:00:00:00": "lo"
428 .. todo:: parse lshw -json instead
430 # First setup interface driver specified in yaml file
431 InterfaceUtil.tg_set_interfaces_default_driver(node)
433 # Get interface names
437 cmd = ('for dev in `ls /sys/class/net/`; do echo "\\"`cat '
438 '/sys/class/net/$dev/address`\\": \\"$dev\\""; done;')
440 (ret_code, stdout, _) = ssh.exec_command(cmd)
441 if int(ret_code) != 0:
442 raise Exception('Get interface name and MAC failed')
443 tmp = "{" + stdout.rstrip().replace('\n', ',') + "}"
444 interfaces = JsonParser().parse_data(tmp)
445 for interface in node['interfaces'].values():
446 name = interfaces.get(interface['mac_address'])
449 interface['name'] = name
451 # Set udev rules for interfaces
452 InterfaceUtil.tg_set_interfaces_udev_rules(node)
455 def iface_update_numa_node(node):
456 """For all interfaces from topology file update numa node based on
457 information from the node.
459 :param node: Node from topology.
464 for if_key in Topology.get_node_interfaces(node):
465 if_pci = Topology.get_interface_pci_addr(node, if_key)
467 cmd = "cat /sys/bus/pci/devices/{}/numa_node".format(if_pci)
469 (ret, out, _) = ssh.exec_command(cmd)
476 logger.trace('Reading numa location failed for: {0}'\
479 Topology.set_interface_numa_node(node, if_key,
483 raise RuntimeError('Update numa node failed for: {0}'\
487 def update_all_interface_data_on_all_nodes(nodes, skip_tg=False,
489 """Update interface names on all nodes in DICT__nodes.
491 This method updates the topology dictionary by querying interface lists
492 of all nodes mentioned in the topology dictionary.
494 :param nodes: Nodes in the topology.
495 :param skip_tg: Skip TG node
496 :param numa_node: Retrieve numa_node location.
499 :type numa_node: bool
501 for node_data in nodes.values():
502 if node_data['type'] == NodeType.DUT:
503 InterfaceUtil.update_vpp_interface_data_on_node(node_data)
504 elif node_data['type'] == NodeType.TG and not skip_tg:
505 InterfaceUtil.update_tg_interface_data_on_node(node_data)
508 if node_data['type'] == NodeType.DUT:
509 InterfaceUtil.iface_update_numa_node(node_data)
510 elif node_data['type'] == NodeType.TG and not skip_tg:
511 InterfaceUtil.iface_update_numa_node(node_data)
514 def create_vlan_subinterface(node, interface, vlan):
515 """Create VLAN subinterface on node.
517 :param node: Node to add VLAN subinterface on.
518 :param interface: Interface name on which create VLAN subinterface.
519 :param vlan: VLAN ID of the subinterface to be created.
523 :return: Name and index of created subinterface.
526 iface_key = Topology.get_interface_by_name(node, interface)
527 sw_if_index = Topology.get_interface_sw_index(node, iface_key)
529 output = VatExecutor.cmd_from_template(node, "create_vlan_subif.vat",
530 sw_if_index=sw_if_index,
532 if output[0]["retval"] == 0:
533 sw_subif_index = output[0]["sw_if_index"]
534 logger.trace('VLAN subinterface with sw_if_index {} and VLAN ID {} '
535 'created on node {}'.format(sw_subif_index,
538 raise RuntimeError('Unable to create VLAN subinterface on node {}'
539 .format(node['host']))
541 with VatTerminal(node, False) as vat:
542 vat.vat_terminal_exec_cmd('exec show interfaces')
544 return '{}.{}'.format(interface, vlan), sw_subif_index
547 def create_vxlan_interface(node, vni, source_ip, destination_ip):
548 """Create VXLAN interface and return sw if index of created interface.
550 Executes "vxlan_add_del_tunnel src {src} dst {dst} vni {vni}" VAT
553 :param node: Node where to create VXLAN interface.
554 :param vni: VXLAN Network Identifier.
555 :param source_ip: Source IP of a VXLAN Tunnel End Point.
556 :param destination_ip: Destination IP of a VXLAN Tunnel End Point.
560 :type destination_ip: str
561 :return: SW IF INDEX of created interface.
564 output = VatExecutor.cmd_from_template(node, "vxlan_create.vat",
570 if output["retval"] == 0:
571 return output["sw_if_index"]
573 raise RuntimeError('Unable to create VXLAN interface on node {0}'
577 def vxlan_dump(node, interface=None):
578 """Get VxLAN data for the given interface.
580 :param node: VPP node to get interface data from.
581 :param interface: Numeric index or name string of a specific interface.
582 If None, information about all VxLAN interfaces is returned.
584 :type interface: int or str
585 :return: Dictionary containing data for the given VxLAN interface or if
586 interface=None, the list of dictionaries with all VxLAN interfaces.
589 param = "sw_if_index"
590 if interface is None:
593 elif isinstance(interface, basestring):
594 sw_if_index = Topology.get_interface_sw_index(node, interface)
595 elif isinstance(interface, int):
596 sw_if_index = interface
598 raise Exception("Wrong interface format {0}".format(interface))
600 with VatTerminal(node) as vat:
601 response = vat.vat_terminal_exec_cmd_from_template(
602 "vxlan_dump.vat", param=param, sw_if_index=sw_if_index)
605 for vxlan in response[0]:
606 if vxlan["sw_if_index"] == sw_if_index:
612 def vhost_user_dump(node):
613 """Get vhost-user data for the given node.
615 :param node: VPP node to get interface data from.
617 :return: List of dictionaries with all vhost-user interfaces.
620 with VatTerminal(node) as vat:
621 response = vat.vat_terminal_exec_cmd_from_template(
622 "vhost_user_dump.vat")
627 def tap_dump(node, name=None):
628 """Get all TAP interface data from the given node, or data about
629 a specific TAP interface.
631 :param node: VPP node to get data from.
632 :param name: Optional name of a specific TAP interface.
635 :return: Dictionary of information about a specific TAP interface, or
636 a List of dictionaries containing all TAP data for the given node.
639 with VatTerminal(node) as vat:
640 response = vat.vat_terminal_exec_cmd_from_template(
645 for item in response[0]:
646 if name == item['dev_name']:
651 def create_subinterface(node, interface, sub_id, outer_vlan_id=None,
652 inner_vlan_id=None, type_subif=None):
653 """Create sub-interface on node. It is possible to set required
654 sub-interface type and VLAN tag(s).
656 :param node: Node to add sub-interface.
657 :param interface: Interface name on which create sub-interface.
658 :param sub_id: ID of the sub-interface to be created.
659 :param outer_vlan_id: Optional outer VLAN ID.
660 :param inner_vlan_id: Optional inner VLAN ID.
661 :param type_subif: Optional type of sub-interface. Values supported by
662 VPP: [no_tags] [one_tag] [two_tags] [dot1ad] [exact_match] [default_sub]
664 :type interface: str or int
666 :type outer_vlan_id: int
667 :type inner_vlan_id: int
668 :type type_subif: str
669 :return: Name and index of created sub-interface.
671 :raises RuntimeError: If it is not possible to create sub-interface.
674 outer_vlan_id = 'outer_vlan_id {0}'.format(outer_vlan_id)\
675 if outer_vlan_id else ''
677 inner_vlan_id = 'inner_vlan_id {0}'.format(inner_vlan_id)\
678 if inner_vlan_id else ''
680 if type_subif is None:
683 if isinstance(interface, basestring):
684 iface_key = Topology.get_interface_by_name(node, interface)
685 sw_if_index = Topology.get_interface_sw_index(node, iface_key)
687 sw_if_index = interface
689 output = VatExecutor.cmd_from_template(node, "create_sub_interface.vat",
690 sw_if_index=sw_if_index,
692 outer_vlan_id=outer_vlan_id,
693 inner_vlan_id=inner_vlan_id,
694 type_subif=type_subif)
696 if output[0]["retval"] == 0:
697 sw_subif_index = output[0]["sw_if_index"]
698 logger.trace('Created subinterface with index {}'
699 .format(sw_subif_index))
701 raise RuntimeError('Unable to create sub-interface on node {}'
702 .format(node['host']))
704 with VatTerminal(node, json_param=False) as vat:
705 vat.vat_terminal_exec_cmd('exec show interfaces')
707 name = '{}.{}'.format(interface, sub_id)
708 return name, sw_subif_index
711 def create_gre_tunnel_interface(node, source_ip, destination_ip):
712 """Create GRE tunnel interface on node.
714 :param node: VPP node to add tunnel interface.
715 :param source_ip: Source of the GRE tunnel.
716 :param destination_ip: Destination of the GRE tunnel.
719 :type destination_ip: str
720 :return: Name and index of created GRE tunnel interface.
722 :raises RuntimeError: If unable to create GRE tunnel interface.
724 output = VatExecutor.cmd_from_template(node, "create_gre.vat",
729 if output["retval"] == 0:
730 sw_if_index = output["sw_if_index"]
732 vat_executor = VatExecutor()
733 vat_executor.execute_script_json_out("dump_interfaces.vat", node)
734 interface_dump_json = vat_executor.get_script_stdout()
735 name = VatJsonUtil.get_interface_name_from_json(
736 interface_dump_json, sw_if_index)
737 return name, sw_if_index
739 raise RuntimeError('Unable to create GRE tunnel on node {}.'
743 def vpp_create_loopback(node):
744 """Create loopback interface on VPP node.
746 :param node: Node to create loopback interface on.
748 :return: SW interface index.
751 out = VatExecutor.cmd_from_template(node, "create_loopback.vat")
752 if out[0].get('retval') == 0:
753 return out[0].get('sw_if_index')
755 raise RuntimeError('Create loopback failed on node "{}"'
756 .format(node['host']))
759 def vpp_enable_input_acl_interface(node, interface, ip_version,
761 """Enable input acl on interface.
763 :param node: VPP node to setup interface for input acl.
764 :param interface: Interface to setup input acl.
765 :param ip_version: Version of IP protocol.
766 :param table_index: Classify table index.
768 :type interface: str or int
769 :type ip_version: str
770 :type table_index: int
772 if isinstance(interface, basestring):
773 sw_if_index = Topology.get_interface_sw_index(node, interface)
775 sw_if_index = interface
777 with VatTerminal(node) as vat:
778 vat.vat_terminal_exec_cmd_from_template("input_acl_int.vat",
779 sw_if_index=sw_if_index,
780 ip_version=ip_version,
781 table_index=table_index)
784 def get_interface_classify_table(node, interface):
785 """Get name of classify table for the given interface.
787 :param node: VPP node to get data from.
788 :param interface: Name or sw_if_index of a specific interface.
790 :type interface: str or int
791 :return: Classify table name.
794 if isinstance(interface, basestring):
795 sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
797 sw_if_index = interface
799 with VatTerminal(node) as vat:
800 data = vat.vat_terminal_exec_cmd_from_template(
801 "classify_interface_table.vat",
802 sw_if_index=sw_if_index
807 def get_sw_if_index(node, interface_name):
808 """Get sw_if_index for the given interface from actual interface dump.
810 :param node: VPP node to get interface data from.
811 :param interface_name: Name of the specific interface.
813 :type interface_name: str
814 :return: sw_if_index of the given interface.
818 with VatTerminal(node) as vat:
819 if_data = vat.vat_terminal_exec_cmd_from_template(
820 "interface_dump.vat")
821 for interface in if_data[0]:
822 if interface["interface_name"] == interface_name:
823 return interface["sw_if_index"]
828 def vxlan_gpe_dump(node, interface_name=None):
829 """Get VxLAN GPE data for the given interface.
831 :param node: VPP node to get interface data from.
832 :param interface_name: Name of the specific interface. If None,
833 information about all VxLAN GPE interfaces is returned.
835 :type interface_name: str
836 :return: Dictionary containing data for the given VxLAN GPE interface or
837 if interface=None, the list of dictionaries with all VxLAN GPE
842 with VatTerminal(node) as vat:
843 vxlan_gpe_data = vat.vat_terminal_exec_cmd_from_template(
844 "vxlan_gpe_dump.vat")
847 sw_if_index = InterfaceUtil.get_sw_if_index(node, interface_name)
849 for vxlan_gpe in vxlan_gpe_data[0]:
850 if vxlan_gpe["sw_if_index"] == sw_if_index:
854 return vxlan_gpe_data[0]
857 def vpp_proxy_arp_interface_enable(node, interface):
858 """Enable proxy ARP on interface.
860 :param node: VPP node to enable proxy ARP on interface.
861 :param interface: Interface to enable proxy ARP.
863 :type interface: str or int
865 if isinstance(interface, basestring):
866 sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
868 sw_if_index = interface
870 with VatTerminal(node) as vat:
871 vat.vat_terminal_exec_cmd_from_template(
872 "proxy_arp_intfc_enable.vat",
873 sw_if_index=sw_if_index)
876 def vpp_ip_source_check_setup(node, interface):
877 """Setup Reverse Path Forwarding source check on interface.
879 :param node: Node to setup RPF source check.
880 :param interface: Interface name to setup RPF source check.
884 with VatTerminal(node) as vat:
885 vat.vat_terminal_exec_cmd_from_template("ip_source_check.vat",
886 interface_name=interface)
889 def assign_interface_to_fib_table(node, interface, table_id, ipv6=False):
890 """Assign VPP interface to specific VRF/FIB table.
892 :param node: VPP node where the FIB and interface are located.
893 :param interface: Interface to be assigned to FIB.
894 :param table_id: VRF table ID.
895 :param ipv6: Assign to IPv6 table. Default False.
897 :type interface: str or int
901 if isinstance(interface, basestring):
902 sw_if_index = Topology.get_interface_sw_index(node, interface)
904 sw_if_index = interface
906 ipv6 = 'ipv6' if ipv6 else ''
908 with VatTerminal(node) as vat:
909 vat.vat_terminal_exec_cmd_from_template("set_fib_to_interface.vat",
910 sw_index=sw_if_index,
915 def set_linux_interface_mac(node, interface, mac, namespace=None):
916 """Set MAC address for interface in linux.
918 :param node: Node where to execute command.
919 :param interface: Interface in namespace.
920 :param mac: MAC to be assigned to interface.
921 :param namespace: Execute command in namespace. Optional
927 if namespace is not None:
928 cmd = 'ip netns exec {} ip link set {} address {}'.format(
929 namespace, interface, mac)
931 cmd = 'ip link set {} address {}'.format(interface, mac)
932 exec_cmd_no_error(node, cmd, sudo=True)