Tolerate failures when setting MTU
[csit.git] / resources / libraries / python / InterfaceUtil.py
1 # Copyright (c) 2019 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 """Interface util library."""
15
16 from socket import AF_INET, AF_INET6, inet_ntop
17 from time import sleep
18
19 from enum import IntEnum
20 from ipaddress import ip_address
21 from robot.api import logger
22
23 from resources.libraries.python.Constants import Constants
24 from resources.libraries.python.CpuUtils import CpuUtils
25 from resources.libraries.python.DUTSetup import DUTSetup
26 from resources.libraries.python.L2Util import L2Util
27 from resources.libraries.python.PapiExecutor import PapiExecutor
28 from resources.libraries.python.parsers.JsonParser import JsonParser
29 from resources.libraries.python.ssh import SSH, exec_cmd_no_error
30 from resources.libraries.python.topology import NodeType, Topology
31 from resources.libraries.python.VPPUtil import VPPUtil
32
33
34 class LinkBondLoadBalance(IntEnum):
35     """Link bonding load balance."""
36     L2 = 0
37     L34 = 1
38     L23 = 2
39
40
41 class LinkBondMode(IntEnum):
42     """Link bonding load balance."""
43     ROUND_ROBIN = 1
44     ACTIVE_BACKUP = 2
45     XOR = 3
46     BROADCAST = 4
47     LACP = 5
48
49
50 class InterfaceUtil(object):
51     """General utilities for managing interfaces"""
52
53     __UDEV_IF_RULES_FILE = '/etc/udev/rules.d/10-network.rules'
54
55     @staticmethod
56     def pci_to_int(pci_str):
57         """Convert PCI address from string format (0000:18:0a.0) to
58         integer representation (169345024).
59
60         :param pci_str: PCI address in string representation.
61         :type pci_str: str
62         :returns: Integer representation of PCI address.
63         :rtype: int
64         """
65         pci = list(pci_str.split(':')[0:2])
66         pci.extend(pci_str.split(':')[2].split('.'))
67
68         return (int(pci[0], 16) | int(pci[1], 16) << 16 |
69                 int(pci[2], 16) << 24 | int(pci[3], 16) << 29)
70
71     @staticmethod
72     def get_interface_index(node, interface):
73         """Get interface sw_if_index from topology file.
74
75         :param node: Node where the interface is.
76         :param interface: Numeric index or name string of a specific interface.
77         :type node: dict
78         :type interface: str or int
79         :returns: SW interface index.
80         :rtype: int
81         """
82         try:
83             sw_if_index = int(interface)
84         except ValueError:
85             sw_if_index = Topology.get_interface_sw_index(node, interface)
86             if sw_if_index is None:
87                 sw_if_index = \
88                     Topology.get_interface_sw_index_by_name(node, interface)
89         except TypeError as err:
90             raise TypeError('Wrong interface format {ifc}: {err}'.format(
91                 ifc=interface, err=err.message))
92
93         return sw_if_index
94
95     @staticmethod
96     def set_interface_state(node, interface, state, if_type='key'):
97         """Set interface state on a node.
98
99         Function can be used for DUTs as well as for TGs.
100
101         :param node: Node where the interface is.
102         :param interface: Interface key or sw_if_index or name.
103         :param state: One of 'up' or 'down'.
104         :param if_type: Interface type
105         :type node: dict
106         :type interface: str or int
107         :type state: str
108         :type if_type: str
109         :returns: Nothing.
110         :raises ValueError: If the interface type is unknown.
111         :raises ValueError: If the state of interface is unexpected.
112         :raises ValueError: If the node has an unknown node type.
113         """
114         if if_type == 'key':
115             if isinstance(interface, basestring):
116                 sw_if_index = Topology.get_interface_sw_index(node, interface)
117                 iface_name = Topology.get_interface_name(node, interface)
118             else:
119                 sw_if_index = interface
120         elif if_type == 'name':
121             iface_key = Topology.get_interface_by_name(node, interface)
122             if iface_key is not None:
123                 sw_if_index = Topology.get_interface_sw_index(node, iface_key)
124             iface_name = interface
125         else:
126             raise ValueError('Unknown if_type: {type}'.format(type=if_type))
127
128         if node['type'] == NodeType.DUT:
129             if state == 'up':
130                 admin_up_down = 1
131             elif state == 'down':
132                 admin_up_down = 0
133             else:
134                 raise ValueError('Unexpected interface state: {state}'.format(
135                     state=state))
136             cmd = 'sw_interface_set_flags'
137             err_msg = 'Failed to set interface state on host {host}'.format(
138                 host=node['host'])
139             args = dict(sw_if_index=sw_if_index,
140                         admin_up_down=admin_up_down)
141             with PapiExecutor(node) as papi_exec:
142                 papi_exec.add(cmd, **args).get_replies(err_msg).\
143                     verify_reply(err_msg=err_msg)
144         elif node['type'] == NodeType.TG or node['type'] == NodeType.VM:
145             cmd = 'ip link set {ifc} {state}'.format(
146                 ifc=iface_name, state=state)
147             exec_cmd_no_error(node, cmd, sudo=True)
148         else:
149             raise ValueError('Node {} has unknown NodeType: "{}"'
150                              .format(node['host'], node['type']))
151
152     @staticmethod
153     def set_interface_ethernet_mtu(node, iface_key, mtu):
154         """Set Ethernet MTU for specified interface.
155
156         Function can be used only for TGs.
157
158         :param node: Node where the interface is.
159         :param iface_key: Interface key from topology file.
160         :param mtu: MTU to set.
161         :type node: dict
162         :type iface_key: str
163         :type mtu: int
164         :returns: Nothing.
165         :raises ValueError: If the node type is "DUT".
166         :raises ValueError: If the node has an unknown node type.
167         """
168         if node['type'] == NodeType.DUT:
169             raise ValueError('Node {}: Setting Ethernet MTU for interface '
170                              'on DUT nodes not supported', node['host'])
171         elif node['type'] == NodeType.TG:
172             iface_name = Topology.get_interface_name(node, iface_key)
173             cmd = 'ip link set {} mtu {}'.format(iface_name, mtu)
174             exec_cmd_no_error(node, cmd, sudo=True)
175         else:
176             raise ValueError('Node {} has unknown NodeType: "{}"'
177                              .format(node['host'], node['type']))
178
179     @staticmethod
180     def set_default_ethernet_mtu_on_all_interfaces_on_node(node):
181         """Set default Ethernet MTU on all interfaces on node.
182
183         Function can be used only for TGs.
184
185         :param node: Node where to set default MTU.
186         :type node: dict
187         :returns: Nothing.
188         """
189         for ifc in node['interfaces']:
190             InterfaceUtil.set_interface_ethernet_mtu(node, ifc, 1500)
191
192     @staticmethod
193     def vpp_set_interface_mtu(node, interface, mtu=9200):
194         """Set Ethernet MTU on interface.
195
196         :param node: VPP node.
197         :param interface: Interface to setup MTU. Default: 9200.
198         :param mtu: Ethernet MTU size in Bytes.
199         :type node: dict
200         :type interface: str or int
201         :type mtu: int
202         """
203         if isinstance(interface, basestring):
204             sw_if_index = Topology.get_interface_sw_index(node, interface)
205         else:
206             sw_if_index = interface
207
208         cmd = 'hw_interface_set_mtu'
209         err_msg = 'Failed to set interface MTU on host {host}'.format(
210             host=node['host'])
211         args = dict(sw_if_index=sw_if_index,
212                     mtu=int(mtu))
213         try:
214             with PapiExecutor(node) as papi_exec:
215                 papi_exec.add(cmd, **args).get_replies(err_msg).\
216                     verify_reply(err_msg=err_msg)
217         except AssertionError as err:
218             # TODO: Make failure tolerance optional.
219             logger.debug("Setting MTU failed. Expected?\n{err}".format(
220                 err=err))
221
222     @staticmethod
223     def vpp_set_interfaces_mtu_on_node(node, mtu=9200):
224         """Set Ethernet MTU on all interfaces.
225
226         :param node: VPP node.
227         :param mtu: Ethernet MTU size in Bytes. Default: 9200.
228         :type node: dict
229         :type mtu: int
230         """
231         for interface in node['interfaces']:
232             InterfaceUtil.vpp_set_interface_mtu(node, interface, mtu)
233
234     @staticmethod
235     def vpp_set_interfaces_mtu_on_all_duts(nodes, mtu=9200):
236         """Set Ethernet MTU on all interfaces on all DUTs.
237
238         :param nodes: VPP nodes.
239         :param mtu: Ethernet MTU size in Bytes. Default: 9200.
240         :type nodes: dict
241         :type mtu: int
242         """
243         for node in nodes.values():
244             if node['type'] == NodeType.DUT:
245                 InterfaceUtil.vpp_set_interfaces_mtu_on_node(node, mtu)
246
247     @staticmethod
248     def vpp_node_interfaces_ready_wait(node, retries=15):
249         """Wait until all interfaces with admin-up are in link-up state.
250
251         :param node: Node to wait on.
252         :param retries: Number of retries to check interface status (optional,
253             default 15).
254         :type node: dict
255         :type retries: int
256         :returns: Nothing.
257         :raises RuntimeError: If any interface is not in link-up state after
258             defined number of retries.
259         """
260         for _ in xrange(0, retries):
261             not_ready = list()
262             out = InterfaceUtil.vpp_get_interface_data(node)
263             for interface in out:
264                 if interface.get('admin_up_down') == 1:
265                     if interface.get('link_up_down') != 1:
266                         not_ready.append(interface.get('interface_name'))
267             if not not_ready:
268                 break
269             else:
270                 logger.debug('Interfaces still in link-down state:\n{ifs} '
271                              '\nWaiting...'.format(ifs=not_ready))
272                 sleep(1)
273         else:
274             err = 'Timeout, interfaces not up:\n{ifs}'.format(ifs=not_ready) \
275                 if 'not_ready' in locals() else 'No check executed!'
276             raise RuntimeError(err)
277
278     @staticmethod
279     def all_vpp_interfaces_ready_wait(nodes, retries=15):
280         """Wait until all interfaces with admin-up are in link-up state for all
281         nodes in the topology.
282
283         :param nodes: Nodes in the topology.
284         :param retries: Number of retries to check interface status (optional,
285             default 15).
286         :type nodes: dict
287         :type retries: int
288         :returns: Nothing.
289         """
290         for node in nodes.values():
291             if node['type'] == NodeType.DUT:
292                 InterfaceUtil.vpp_node_interfaces_ready_wait(node, retries)
293
294     @staticmethod
295     def vpp_get_interface_data(node, interface=None):
296         """Get all interface data from a VPP node. If a name or
297         sw_interface_index is provided, return only data for the matching
298         interface(s).
299
300         :param node: VPP node to get interface data from.
301         :param interface: Numeric index or name string of a specific interface.
302         :type node: dict
303         :type interface: int or str
304         :returns: List of dictionaries containing data for each interface, or a
305             single dictionary for the specified interface.
306         :rtype: list or dict
307         :raises TypeError: if the data type of interface is neither basestring
308             nor int.
309         """
310         if interface is not None:
311             if isinstance(interface, basestring):
312                 param = 'interface_name'
313             elif isinstance(interface, int):
314                 param = 'sw_if_index'
315             else:
316                 raise TypeError('Wrong interface format {ifc}'.format(
317                     ifc=interface))
318         else:
319             param = ''
320
321         cmd = 'sw_interface_dump'
322         cmd_reply = 'sw_interface_details'
323         args = dict(name_filter_valid=0,
324                     name_filter='')
325         err_msg = 'Failed to get interface dump on host {host}'.format(
326             host=node['host'])
327         with PapiExecutor(node) as papi_exec:
328             papi_resp = papi_exec.add(cmd, **args).get_dump(err_msg)
329
330         papi_if_dump = papi_resp.reply[0]['api_reply']
331
332         def process_if_dump(if_dump):
333             """Process interface dump.
334
335             :param if_dump: Interface dump.
336             :type if_dump: dict
337             :returns: Processed interface dump.
338             :rtype: dict
339             """
340             if_dump['interface_name'] = if_dump['interface_name'].rstrip('\x00')
341             if_dump['tag'] = if_dump['tag'].rstrip('\x00')
342             if_dump['l2_address'] = L2Util.bin_to_mac(if_dump['l2_address'])
343             if_dump['b_dmac'] = L2Util.bin_to_mac(if_dump['b_dmac'])
344             if_dump['b_smac'] = L2Util.bin_to_mac(if_dump['b_smac'])
345             return if_dump
346
347         data = list() if interface is None else dict()
348         for item in papi_if_dump:
349             if interface is None:
350                 data.append(process_if_dump(item[cmd_reply]))
351             elif str(item[cmd_reply].get(param)).rstrip('\x00') == \
352                     str(interface):
353                 data = process_if_dump(item[cmd_reply])
354                 break
355
356         logger.debug('Interface data:\n{if_data}'.format(if_data=data))
357         return data
358
359     @staticmethod
360     def vpp_get_interface_name(node, sw_if_index):
361         """Get interface name for the given SW interface index from actual
362         interface dump.
363
364         :param node: VPP node to get interface data from.
365         :param sw_if_index: SW interface index of the specific interface.
366         :type node: dict
367         :type sw_if_index: int
368         :returns: Name of the given interface.
369         :rtype: str
370         """
371         if_data = InterfaceUtil.vpp_get_interface_data(node, sw_if_index)
372         if if_data['sup_sw_if_index'] != if_data['sw_if_index']:
373             if_data = InterfaceUtil.vpp_get_interface_data(
374                 node, if_data['sup_sw_if_index'])
375
376         return if_data.get('interface_name')
377
378     @staticmethod
379     def vpp_get_interface_sw_index(node, interface_name):
380         """Get interface name for the given SW interface index from actual
381         interface dump.
382
383         :param node: VPP node to get interface data from.
384         :param interface_name: Interface name.
385         :type node: dict
386         :type interface_name: str
387         :returns: Name of the given interface.
388         :rtype: str
389         """
390         if_data = InterfaceUtil.vpp_get_interface_data(node, interface_name)
391
392         return if_data.get('sw_if_index')
393
394     @staticmethod
395     def vpp_get_interface_mac(node, interface):
396         """Get MAC address for the given interface from actual interface dump.
397
398         :param node: VPP node to get interface data from.
399         :param interface: Numeric index or name string of a specific interface.
400         :type node: dict
401         :type interface: int or str
402         :returns: MAC address.
403         :rtype: str
404         """
405         if_data = InterfaceUtil.vpp_get_interface_data(node, interface)
406         if if_data['sup_sw_if_index'] != if_data['sw_if_index']:
407             if_data = InterfaceUtil.vpp_get_interface_data(
408                 node, if_data['sup_sw_if_index'])
409
410         return if_data.get('l2_address')
411
412     @staticmethod
413     def tg_set_interface_driver(node, pci_addr, driver):
414         """Set interface driver on the TG node.
415
416         :param node: Node to set interface driver on (must be TG node).
417         :param pci_addr: PCI address of the interface.
418         :param driver: Driver name.
419         :type node: dict
420         :type pci_addr: str
421         :type driver: str
422         :raises RuntimeError: If unbinding from the current driver fails.
423         :raises RuntimeError: If binding to the new driver fails.
424         """
425         old_driver = InterfaceUtil.tg_get_interface_driver(node, pci_addr)
426         if old_driver == driver:
427             return
428
429         ssh = SSH()
430         ssh.connect(node)
431
432         # Unbind from current driver
433         if old_driver is not None:
434             cmd = 'sh -c "echo {0} > /sys/bus/pci/drivers/{1}/unbind"'\
435                 .format(pci_addr, old_driver)
436             (ret_code, _, _) = ssh.exec_command_sudo(cmd)
437             if int(ret_code) != 0:
438                 raise RuntimeError("'{0}' failed on '{1}'"
439                                    .format(cmd, node['host']))
440
441         # Bind to the new driver
442         cmd = 'sh -c "echo {0} > /sys/bus/pci/drivers/{1}/bind"'\
443             .format(pci_addr, driver)
444         (ret_code, _, _) = ssh.exec_command_sudo(cmd)
445         if int(ret_code) != 0:
446             raise RuntimeError("'{0}' failed on '{1}'"
447                                .format(cmd, node['host']))
448
449     @staticmethod
450     def tg_get_interface_driver(node, pci_addr):
451         """Get interface driver from the TG node.
452
453         :param node: Node to get interface driver on (must be TG node).
454         :param pci_addr: PCI address of the interface.
455         :type node: dict
456         :type pci_addr: str
457         :returns: Interface driver or None if not found.
458         :rtype: str
459         :raises RuntimeError: If PCI rescan or lspci command execution failed.
460         """
461         return DUTSetup.get_pci_dev_driver(node, pci_addr)
462
463     @staticmethod
464     def tg_set_interfaces_udev_rules(node):
465         """Set udev rules for interfaces.
466
467         Create udev rules file in /etc/udev/rules.d where are rules for each
468         interface used by TG node, based on MAC interface has specific name.
469         So after unbind and bind again to kernel driver interface has same
470         name as before. This must be called after TG has set name for each
471         port in topology dictionary.
472         udev rule example
473         SUBSYSTEM=="net", ACTION=="add", ATTR{address}=="52:54:00:e1:8a:0f",
474         NAME="eth1"
475
476         :param node: Node to set udev rules on (must be TG node).
477         :type node: dict
478         :raises RuntimeError: If setting of udev rules fails.
479         """
480         ssh = SSH()
481         ssh.connect(node)
482
483         cmd = 'rm -f {0}'.format(InterfaceUtil.__UDEV_IF_RULES_FILE)
484         (ret_code, _, _) = ssh.exec_command_sudo(cmd)
485         if int(ret_code) != 0:
486             raise RuntimeError("'{0}' failed on '{1}'"
487                                .format(cmd, node['host']))
488
489         for interface in node['interfaces'].values():
490             rule = 'SUBSYSTEM==\\"net\\", ACTION==\\"add\\", ATTR{address}' + \
491                    '==\\"' + interface['mac_address'] + '\\", NAME=\\"' + \
492                    interface['name'] + '\\"'
493             cmd = 'sh -c "echo \'{0}\' >> {1}"'.format(
494                 rule, InterfaceUtil.__UDEV_IF_RULES_FILE)
495             (ret_code, _, _) = ssh.exec_command_sudo(cmd)
496             if int(ret_code) != 0:
497                 raise RuntimeError("'{0}' failed on '{1}'"
498                                    .format(cmd, node['host']))
499
500         cmd = '/etc/init.d/udev restart'
501         ssh.exec_command_sudo(cmd)
502
503     @staticmethod
504     def tg_set_interfaces_default_driver(node):
505         """Set interfaces default driver specified in topology yaml file.
506
507         :param node: Node to setup interfaces driver on (must be TG node).
508         :type node: dict
509         """
510         for interface in node['interfaces'].values():
511             InterfaceUtil.tg_set_interface_driver(node,
512                                                   interface['pci_address'],
513                                                   interface['driver'])
514
515     @staticmethod
516     def update_vpp_interface_data_on_node(node):
517         """Update vpp generated interface data for a given node in DICT__nodes.
518
519         Updates interface names, software if index numbers and any other details
520         generated specifically by vpp that are unknown before testcase run.
521         It does this by dumping interface list from all devices using python
522         api, and pairing known information from topology (mac address) to state
523         from VPP.
524
525         :param node: Node selected from DICT__nodes.
526         :type node: dict
527         """
528         interface_list = InterfaceUtil.vpp_get_interface_data(node)
529         interface_dict = dict()
530         for ifc in interface_list:
531             interface_dict[ifc['l2_address']] = ifc
532
533         for if_name, if_data in node['interfaces'].items():
534             ifc_dict = interface_dict.get(if_data['mac_address'])
535             if ifc_dict is not None:
536                 if_data['name'] = ifc_dict['interface_name']
537                 if_data['vpp_sw_index'] = ifc_dict['sw_if_index']
538                 if_data['mtu'] = ifc_dict['mtu'][0]
539                 logger.trace('Interface {ifc} found by MAC {mac}'.format(
540                     ifc=if_name, mac=if_data['mac_address']))
541             else:
542                 logger.trace('Interface {ifc} not found by MAC {mac}'.format(
543                     ifc=if_name, mac=if_data['mac_address']))
544                 if_data['vpp_sw_index'] = None
545
546     @staticmethod
547     def update_nic_interface_names(node):
548         """Update interface names based on nic type and PCI address.
549
550         This method updates interface names in the same format as VPP does.
551
552         :param node: Node dictionary.
553         :type node: dict
554         """
555         for ifc in node['interfaces'].values():
556             if_pci = ifc['pci_address'].replace('.', ':').split(':')
557             bus = '{:x}'.format(int(if_pci[1], 16))
558             dev = '{:x}'.format(int(if_pci[2], 16))
559             fun = '{:x}'.format(int(if_pci[3], 16))
560             loc = '{bus}/{dev}/{fun}'.format(bus=bus, dev=dev, fun=fun)
561             if ifc['model'] == 'Intel-XL710':
562                 ifc['name'] = 'FortyGigabitEthernet{loc}'.format(loc=loc)
563             elif ifc['model'] == 'Intel-X710':
564                 ifc['name'] = 'TenGigabitEthernet{loc}'.format(loc=loc)
565             elif ifc['model'] == 'Intel-X520-DA2':
566                 ifc['name'] = 'TenGigabitEthernet{loc}'.format(loc=loc)
567             elif ifc['model'] == 'Cisco-VIC-1385':
568                 ifc['name'] = 'FortyGigabitEthernet{loc}'.format(loc=loc)
569             elif ifc['model'] == 'Cisco-VIC-1227':
570                 ifc['name'] = 'TenGigabitEthernet{loc}'.format(loc=loc)
571             else:
572                 ifc['name'] = 'UnknownEthernet{loc}'.format(loc=loc)
573
574     @staticmethod
575     def update_nic_interface_names_on_all_duts(nodes):
576         """Update interface names based on nic type and PCI address on all DUTs.
577
578         This method updates interface names in the same format as VPP does.
579
580         :param nodes: Topology nodes.
581         :type nodes: dict
582         """
583         for node in nodes.values():
584             if node['type'] == NodeType.DUT:
585                 InterfaceUtil.update_nic_interface_names(node)
586
587     @staticmethod
588     def update_tg_interface_data_on_node(node, skip_tg_udev=False):
589         """Update interface name for TG/linux node in DICT__nodes.
590
591         .. note::
592             # for dev in `ls /sys/class/net/`;
593             > do echo "\"`cat /sys/class/net/$dev/address`\": \"$dev\""; done
594             "52:54:00:9f:82:63": "eth0"
595             "52:54:00:77:ae:a9": "eth1"
596             "52:54:00:e1:8a:0f": "eth2"
597             "00:00:00:00:00:00": "lo"
598
599         :param node: Node selected from DICT__nodes.
600         :param skip_tg_udev: Skip udev rename on TG node.
601         :type node: dict
602         :type skip_tg_udev: bool
603         :raises RuntimeError: If getting of interface name and MAC fails.
604         """
605         # First setup interface driver specified in yaml file
606         InterfaceUtil.tg_set_interfaces_default_driver(node)
607
608         # Get interface names
609         ssh = SSH()
610         ssh.connect(node)
611
612         cmd = ('for dev in `ls /sys/class/net/`; do echo "\\"`cat '
613                '/sys/class/net/$dev/address`\\": \\"$dev\\""; done;')
614
615         (ret_code, stdout, _) = ssh.exec_command(cmd)
616         if int(ret_code) != 0:
617             raise RuntimeError('Get interface name and MAC failed')
618         tmp = "{" + stdout.rstrip().replace('\n', ',') + "}"
619         interfaces = JsonParser().parse_data(tmp)
620         for interface in node['interfaces'].values():
621             name = interfaces.get(interface['mac_address'])
622             if name is None:
623                 continue
624             interface['name'] = name
625
626         # Set udev rules for interfaces
627         if not skip_tg_udev:
628             InterfaceUtil.tg_set_interfaces_udev_rules(node)
629
630     @staticmethod
631     def iface_update_numa_node(node):
632         """For all interfaces from topology file update numa node based on
633            information from the node.
634
635         :param node: Node from topology.
636         :type node: dict
637         :returns: Nothing.
638         :raises ValueError: If numa node ia less than 0.
639         :raises RuntimeError: If update of numa node failes.
640         """
641         ssh = SSH()
642         for if_key in Topology.get_node_interfaces(node):
643             if_pci = Topology.get_interface_pci_addr(node, if_key)
644             ssh.connect(node)
645             cmd = "cat /sys/bus/pci/devices/{}/numa_node".format(if_pci)
646             for _ in range(3):
647                 (ret, out, _) = ssh.exec_command(cmd)
648                 if ret == 0:
649                     try:
650                         numa_node = int(out)
651                         if numa_node < 0:
652                             if CpuUtils.cpu_node_count(node) == 1:
653                                 numa_node = 0
654                             else:
655                                 raise ValueError
656                     except ValueError:
657                         logger.trace('Reading numa location failed for: {0}'
658                                      .format(if_pci))
659                     else:
660                         Topology.set_interface_numa_node(node, if_key,
661                                                          numa_node)
662                         break
663             else:
664                 raise RuntimeError('Update numa node failed for: {0}'
665                                    .format(if_pci))
666
667     @staticmethod
668     def update_all_numa_nodes(nodes, skip_tg=False):
669         """For all nodes and all their interfaces from topology file update numa
670         node information based on information from the node.
671
672         :param nodes: Nodes in the topology.
673         :param skip_tg: Skip TG node
674         :type nodes: dict
675         :type skip_tg: bool
676         :returns: Nothing.
677         """
678         for node in nodes.values():
679             if node['type'] == NodeType.DUT:
680                 InterfaceUtil.iface_update_numa_node(node)
681             elif node['type'] == NodeType.TG and not skip_tg:
682                 InterfaceUtil.iface_update_numa_node(node)
683
684     @staticmethod
685     def update_all_interface_data_on_all_nodes(nodes, skip_tg=False,
686                                                skip_tg_udev=False,
687                                                numa_node=False):
688         """Update interface names on all nodes in DICT__nodes.
689
690         This method updates the topology dictionary by querying interface lists
691         of all nodes mentioned in the topology dictionary.
692
693         :param nodes: Nodes in the topology.
694         :param skip_tg: Skip TG node.
695         :param skip_tg_udev: Skip udev rename on TG node.
696         :param numa_node: Retrieve numa_node location.
697         :type nodes: dict
698         :type skip_tg: bool
699         :type skip_tg_udev: bool
700         :type numa_node: bool
701         """
702         for node_data in nodes.values():
703             if node_data['type'] == NodeType.DUT:
704                 InterfaceUtil.update_vpp_interface_data_on_node(node_data)
705             elif node_data['type'] == NodeType.TG and not skip_tg:
706                 InterfaceUtil.update_tg_interface_data_on_node(
707                     node_data, skip_tg_udev)
708
709             if numa_node:
710                 if node_data['type'] == NodeType.DUT:
711                     InterfaceUtil.iface_update_numa_node(node_data)
712                 elif node_data['type'] == NodeType.TG and not skip_tg:
713                     InterfaceUtil.iface_update_numa_node(node_data)
714
715     @staticmethod
716     def create_vlan_subinterface(node, interface, vlan):
717         """Create VLAN sub-interface on node.
718
719         :param node: Node to add VLAN subinterface on.
720         :param interface: Interface name on which create VLAN subinterface.
721         :param vlan: VLAN ID of the subinterface to be created.
722         :type node: dict
723         :type interface: str
724         :type vlan: int
725         :returns: Name and index of created subinterface.
726         :rtype: tuple
727         :raises RuntimeError: if it is unable to create VLAN subinterface on the
728             node.
729         """
730         iface_key = Topology.get_interface_by_name(node, interface)
731         sw_if_index = Topology.get_interface_sw_index(node, iface_key)
732
733         cmd = 'create_vlan_subif'
734         args = dict(sw_if_index=sw_if_index,
735                     vlan_id=int(vlan))
736         err_msg = 'Failed to create VLAN sub-interface on host {host}'.format(
737             host=node['host'])
738         with PapiExecutor(node) as papi_exec:
739             papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
740                 verify_reply(err_msg=err_msg)
741
742         sw_if_idx = papi_resp['sw_if_index']
743         if_key = Topology.add_new_port(node, 'vlan_subif')
744         Topology.update_interface_sw_if_index(node, if_key, sw_if_idx)
745         ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_idx)
746         Topology.update_interface_name(node, if_key, ifc_name)
747
748         return '{ifc}.{vlan}'.format(ifc=interface, vlan=vlan), sw_if_idx
749
750     @staticmethod
751     def create_vxlan_interface(node, vni, source_ip, destination_ip):
752         """Create VXLAN interface and return sw if index of created interface.
753
754         :param node: Node where to create VXLAN interface.
755         :param vni: VXLAN Network Identifier.
756         :param source_ip: Source IP of a VXLAN Tunnel End Point.
757         :param destination_ip: Destination IP of a VXLAN Tunnel End Point.
758         :type node: dict
759         :type vni: int
760         :type source_ip: str
761         :type destination_ip: str
762         :returns: SW IF INDEX of created interface.
763         :rtype: int
764         :raises RuntimeError: if it is unable to create VxLAN interface on the
765             node.
766         """
767         src_address = ip_address(unicode(source_ip))
768         dst_address = ip_address(unicode(destination_ip))
769
770         cmd = 'vxlan_add_del_tunnel'
771         args = dict(is_add=1,
772                     is_ipv6=1 if src_address.version == 6 else 0,
773                     instance=Constants.BITWISE_NON_ZERO,
774                     src_address=src_address.packed,
775                     dst_address=dst_address.packed,
776                     mcast_sw_if_index=Constants.BITWISE_NON_ZERO,
777                     encap_vrf_id=0,
778                     decap_next_index=Constants.BITWISE_NON_ZERO,
779                     vni=int(vni))
780         err_msg = 'Failed to create VXLAN tunnel interface on host {host}'.\
781             format(host=node['host'])
782         with PapiExecutor(node) as papi_exec:
783             papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
784                 verify_reply(err_msg=err_msg)
785
786         sw_if_idx = papi_resp['sw_if_index']
787         if_key = Topology.add_new_port(node, 'vxlan_tunnel')
788         Topology.update_interface_sw_if_index(node, if_key, sw_if_idx)
789         ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_idx)
790         Topology.update_interface_name(node, if_key, ifc_name)
791
792         return sw_if_idx
793
794     @staticmethod
795     def vxlan_dump(node, interface=None):
796         """Get VxLAN data for the given interface.
797
798         :param node: VPP node to get interface data from.
799         :param interface: Numeric index or name string of a specific interface.
800             If None, information about all VxLAN interfaces is returned.
801         :type node: dict
802         :type interface: int or str
803         :returns: Dictionary containing data for the given VxLAN interface or if
804             interface=None, the list of dictionaries with all VxLAN interfaces.
805         :rtype: dict or list
806         :raises TypeError: if the data type of interface is neither basestring
807             nor int.
808         """
809         if interface is not None:
810             sw_if_index = InterfaceUtil.get_interface_index(node, interface)
811         else:
812             sw_if_index = int(Constants.BITWISE_NON_ZERO)
813
814         cmd = 'vxlan_tunnel_dump'
815         cmd_reply = 'vxlan_tunnel_details'
816         args = dict(sw_if_index=sw_if_index)
817         err_msg = 'Failed to get VXLAN dump on host {host}'.format(
818             host=node['host'])
819         with PapiExecutor(node) as papi_exec:
820             papi_resp = papi_exec.add(cmd, **args).get_dump(err_msg)
821
822         papi_vxlan_dump = papi_resp.reply[0]['api_reply']
823
824         def process_vxlan_dump(vxlan_dump):
825             """Process vxlan dump.
826
827             :param vxlan_dump: Vxlan interface dump.
828             :type vxlan_dump: dict
829             :returns: Processed vxlan interface dump.
830             :rtype: dict
831             """
832             if vxlan_dump['is_ipv6']:
833                 vxlan_dump['src_address'] = \
834                     inet_ntop(AF_INET6, vxlan_dump['src_address'])
835                 vxlan_dump['dst_address'] = \
836                     inet_ntop(AF_INET6, vxlan_dump['dst_address'])
837             else:
838                 vxlan_dump['src_address'] = \
839                     inet_ntop(AF_INET, vxlan_dump['src_address'][0:4])
840                 vxlan_dump['dst_address'] = \
841                     inet_ntop(AF_INET, vxlan_dump['dst_address'][0:4])
842             return vxlan_dump
843
844         data = list() if interface is None else dict()
845         for item in papi_vxlan_dump:
846             if interface is None:
847                 data.append(process_vxlan_dump(item[cmd_reply]))
848             elif item[cmd_reply]['sw_if_index'] == sw_if_index:
849                 data = process_vxlan_dump(item[cmd_reply])
850                 break
851
852         logger.debug('VXLAN data:\n{vxlan_data}'.format(vxlan_data=data))
853         return data
854
855     @staticmethod
856     def vhost_user_dump(node):
857         """Get vhost-user data for the given node.
858
859         TODO: Move to VhostUser.py
860
861         :param node: VPP node to get interface data from.
862         :type node: dict
863         :returns: List of dictionaries with all vhost-user interfaces.
864         :rtype: list
865         """
866         cmd = 'sw_interface_vhost_user_dump'
867         cmd_reply = 'sw_interface_vhost_user_details'
868         err_msg = 'Failed to get vhost-user dump on host {host}'.format(
869             host=node['host'])
870         with PapiExecutor(node) as papi_exec:
871             papi_resp = papi_exec.add(cmd).get_dump(err_msg)
872
873         papi_vxlan_dump = papi_resp.reply[0]['api_reply']
874
875         def process_vhost_dump(vhost_dump):
876             """Process vhost dump.
877
878             :param vhost_dump: Vhost interface dump.
879             :type vhost_dump: dict
880             :returns: Processed vhost interface dump.
881             :rtype: dict
882             """
883             vhost_dump['interface_name'] = \
884                 vhost_dump['interface_name'].rstrip('\x00')
885             vhost_dump['sock_filename'] = \
886                 vhost_dump['sock_filename'].rstrip('\x00')
887             return vhost_dump
888
889         data = list()
890         for item in papi_vxlan_dump:
891             data.append(process_vhost_dump(item[cmd_reply]))
892
893         logger.debug('Vhost-user data:\n{vhost_data}'.format(vhost_data=data))
894         return data
895
896     @staticmethod
897     def tap_dump(node, name=None):
898         """Get all TAP interface data from the given node, or data about
899         a specific TAP interface.
900
901         TODO: Move to Tap.py
902
903         :param node: VPP node to get data from.
904         :param name: Optional name of a specific TAP interface.
905         :type node: dict
906         :type name: str
907         :returns: Dictionary of information about a specific TAP interface, or
908             a List of dictionaries containing all TAP data for the given node.
909         :rtype: dict or list
910         """
911         cmd = 'sw_interface_tap_v2_dump'
912         cmd_reply = 'sw_interface_tap_v2_details'
913         err_msg = 'Failed to get TAP dump on host {host}'.format(
914             host=node['host'])
915         with PapiExecutor(node) as papi_exec:
916             papi_resp = papi_exec.add(cmd).get_dump(err_msg)
917
918         papi_tap_dump = papi_resp.reply[0]['api_reply']
919
920         def process_tap_dump(tap_dump):
921             """Process tap dump.
922
923             :param tap_dump: Tap interface dump.
924             :type tap_dump: dict
925             :returns: Processed tap interface dump.
926             :rtype: dict
927             """
928             tap_dump['dev_name'] = tap_dump['dev_name'].rstrip('\x00')
929             tap_dump['host_if_name'] = tap_dump['host_if_name'].rstrip('\x00')
930             tap_dump['host_namespace'] = \
931                 tap_dump['host_namespace'].rstrip('\x00')
932             tap_dump['host_mac_addr'] = \
933                 L2Util.bin_to_mac(tap_dump['host_mac_addr'])
934             tap_dump['host_ip4_addr'] = \
935                 inet_ntop(AF_INET, tap_dump['host_ip4_addr'])
936             tap_dump['host_ip6_addr'] = \
937                 inet_ntop(AF_INET6, tap_dump['host_ip6_addr'])
938             return tap_dump
939
940         data = list() if name is None else dict()
941         for item in papi_tap_dump:
942             if name is None:
943                 data.append(process_tap_dump(item[cmd_reply]))
944             elif item[cmd_reply].get('dev_name').rstrip('\x00') == name:
945                 data = process_tap_dump(item[cmd_reply])
946                 break
947
948         logger.debug('TAP data:\n{tap_data}'.format(tap_data=data))
949         return data
950
951     @staticmethod
952     def create_subinterface(node, interface, sub_id, outer_vlan_id=None,
953                             inner_vlan_id=None, type_subif=None):
954         """Create sub-interface on node. It is possible to set required
955         sub-interface type and VLAN tag(s).
956
957         :param node: Node to add sub-interface.
958         :param interface: Interface name on which create sub-interface.
959         :param sub_id: ID of the sub-interface to be created.
960         :param outer_vlan_id: Optional outer VLAN ID.
961         :param inner_vlan_id: Optional inner VLAN ID.
962         :param type_subif: Optional type of sub-interface. Values supported by
963             VPP: [no_tags] [one_tag] [two_tags] [dot1ad] [exact_match]
964             [default_sub]
965         :type node: dict
966         :type interface: str or int
967         :type sub_id: int
968         :type outer_vlan_id: int
969         :type inner_vlan_id: int
970         :type type_subif: str
971         :returns: Name and index of created sub-interface.
972         :rtype: tuple
973         :raises RuntimeError: If it is not possible to create sub-interface.
974         """
975         subif_types = type_subif.split()
976
977         cmd = 'create_subif'
978         args = dict(
979             sw_if_index=InterfaceUtil.get_interface_index(node, interface),
980             sub_id=int(sub_id),
981             no_tags=1 if 'no_tags' in subif_types else 0,
982             one_tag=1 if 'one_tag' in subif_types else 0,
983             two_tags=1 if 'two_tags' in subif_types else 0,
984             dot1ad=1 if 'dot1ad' in subif_types else 0,
985             exact_match=1 if 'exact_match' in subif_types else 0,
986             default_sub=1 if 'default_sub' in subif_types else 0,
987             outer_vlan_id_any=1 if type_subif == 'default_sub' else 0,
988             inner_vlan_id_any=1 if type_subif == 'default_sub' else 0,
989             outer_vlan_id=int(outer_vlan_id) if outer_vlan_id else 0,
990             inner_vlan_id=int(inner_vlan_id) if inner_vlan_id else 0)
991         err_msg = 'Failed to create sub-interface on host {host}'.format(
992             host=node['host'])
993         with PapiExecutor(node) as papi_exec:
994             papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
995                 verify_reply(err_msg=err_msg)
996
997         sw_subif_idx = papi_resp['sw_if_index']
998         if_key = Topology.add_new_port(node, 'subinterface')
999         Topology.update_interface_sw_if_index(node, if_key, sw_subif_idx)
1000         ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_subif_idx)
1001         Topology.update_interface_name(node, if_key, ifc_name)
1002
1003         return '{ifc}.{s_id}'.format(ifc=interface, s_id=sub_id), sw_subif_idx
1004
1005     @staticmethod
1006     def create_gre_tunnel_interface(node, source_ip, destination_ip):
1007         """Create GRE tunnel interface on node.
1008
1009         :param node: VPP node to add tunnel interface.
1010         :param source_ip: Source of the GRE tunnel.
1011         :param destination_ip: Destination of the GRE tunnel.
1012         :type node: dict
1013         :type source_ip: str
1014         :type destination_ip: str
1015         :returns: Name and index of created GRE tunnel interface.
1016         :rtype: tuple
1017         :raises RuntimeError: If unable to create GRE tunnel interface.
1018         """
1019         cmd = 'gre_tunnel_add_del'
1020         tunnel = dict(type=0,
1021                       instance=Constants.BITWISE_NON_ZERO,
1022                       src=str(source_ip),
1023                       dst=str(destination_ip),
1024                       outer_fib_id=0,
1025                       session_id=0)
1026         args = dict(is_add=1,
1027                     tunnel=tunnel)
1028         err_msg = 'Failed to create GRE tunnel interface on host {host}'.format(
1029             host=node['host'])
1030         with PapiExecutor(node) as papi_exec:
1031             papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
1032                 verify_reply(err_msg=err_msg)
1033
1034         sw_if_idx = papi_resp['sw_if_index']
1035         if_key = Topology.add_new_port(node, 'gre_tunnel')
1036         Topology.update_interface_sw_if_index(node, if_key, sw_if_idx)
1037         ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_idx)
1038         Topology.update_interface_name(node, if_key, ifc_name)
1039
1040         return ifc_name, sw_if_idx
1041
1042     @staticmethod
1043     def vpp_create_loopback(node):
1044         """Create loopback interface on VPP node.
1045
1046         :param node: Node to create loopback interface on.
1047         :type node: dict
1048         :returns: SW interface index.
1049         :rtype: int
1050         :raises RuntimeError: If it is not possible to create loopback on the
1051             node.
1052         """
1053         cmd = 'create_loopback'
1054         args = dict(mac_address=0)
1055         err_msg = 'Failed to create loopback interface on host {host}'.format(
1056             host=node['host'])
1057         with PapiExecutor(node) as papi_exec:
1058             papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
1059                 verify_reply(err_msg=err_msg)
1060
1061         sw_if_idx = papi_resp['sw_if_index']
1062         if_key = Topology.add_new_port(node, 'loopback')
1063         Topology.update_interface_sw_if_index(node, if_key, sw_if_idx)
1064         ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_idx)
1065         Topology.update_interface_name(node, if_key, ifc_name)
1066
1067         return sw_if_idx
1068
1069     @staticmethod
1070     def vpp_create_bond_interface(node, mode, load_balance=None, mac=None):
1071         """Create bond interface on VPP node.
1072
1073         :param node: DUT node from topology.
1074         :param mode: Link bonding mode.
1075         :param load_balance: Load balance (optional, valid for xor and lacp
1076             modes, otherwise ignored).
1077         :param mac: MAC address to assign to the bond interface (optional).
1078         :type node: dict
1079         :type mode: str
1080         :type load_balance: str
1081         :type mac: str
1082         :returns: Interface key (name) in topology.
1083         :rtype: str
1084         :raises RuntimeError: If it is not possible to create bond interface on
1085             the node.
1086         """
1087         cmd = 'bond_create'
1088         args = dict(id=int(Constants.BITWISE_NON_ZERO),
1089                     use_custom_mac=0 if mac is None else 1,
1090                     mac_address=0 if mac is None else L2Util.mac_to_bin(mac),
1091                     mode=getattr(LinkBondMode, '{md}'.format(
1092                         md=mode.replace('-', '_').upper())).value,
1093                     lb=0 if load_balance is None else getattr(
1094                         LinkBondLoadBalance, '{lb}'.format(
1095                             lb=load_balance.upper())).value)
1096         err_msg = 'Failed to create bond interface on host {host}'.format(
1097             host=node['host'])
1098         with PapiExecutor(node) as papi_exec:
1099             papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
1100                 verify_reply(err_msg=err_msg)
1101
1102         sw_if_idx = papi_resp['sw_if_index']
1103         InterfaceUtil.add_eth_interface(node, sw_if_idx=sw_if_idx,
1104                                         ifc_pfx='eth_bond')
1105         if_key = Topology.get_interface_by_sw_index(node, sw_if_idx)
1106
1107         return if_key
1108
1109     @staticmethod
1110     def add_eth_interface(node, ifc_name=None, sw_if_idx=None, ifc_pfx=None):
1111         """Add ethernet interface to current topology.
1112
1113         :param node: DUT node from topology.
1114         :param ifc_name: Name of the interface.
1115         :param sw_if_idx: SW interface index.
1116         :param ifc_pfx: Interface key prefix.
1117         :type node: dict
1118         :type ifc_name: str
1119         :type sw_if_idx: int
1120         :type ifc_pfx: str
1121         """
1122         if_key = Topology.add_new_port(node, ifc_pfx)
1123
1124         if ifc_name and sw_if_idx is None:
1125             sw_if_idx = InterfaceUtil.vpp_get_interface_sw_index(node, ifc_name)
1126         Topology.update_interface_sw_if_index(node, if_key, sw_if_idx)
1127         if sw_if_idx and ifc_name is None:
1128             ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_idx)
1129         Topology.update_interface_name(node, if_key, ifc_name)
1130         ifc_mac = InterfaceUtil.vpp_get_interface_mac(node, sw_if_idx)
1131         Topology.update_interface_mac_address(node, if_key, ifc_mac)
1132
1133     @staticmethod
1134     def vpp_create_avf_interface(node, vf_pci_addr, num_rx_queues=None):
1135         """Create AVF interface on VPP node.
1136
1137         :param node: DUT node from topology.
1138         :param vf_pci_addr: Virtual Function PCI address.
1139         :param num_rx_queues: Number of RX queues.
1140         :type node: dict
1141         :type vf_pci_addr: str
1142         :type num_rx_queues: int
1143         :returns: Interface key (name) in topology.
1144         :rtype: str
1145         :raises RuntimeError: If it is not possible to create AVF interface on
1146             the node.
1147         """
1148         cmd = 'avf_create'
1149         args = dict(pci_addr=InterfaceUtil.pci_to_int(vf_pci_addr),
1150                     enable_elog=0,
1151                     rxq_num=int(num_rx_queues) if num_rx_queues else 0,
1152                     rxq_size=0,
1153                     txq_size=0)
1154         err_msg = 'Failed to create AVF interface on host {host}'.format(
1155             host=node['host'])
1156         with PapiExecutor(node) as papi_exec:
1157             papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg).\
1158                 verify_reply(err_msg=err_msg)
1159
1160         sw_if_idx = papi_resp['sw_if_index']
1161         InterfaceUtil.add_eth_interface(node, sw_if_idx=sw_if_idx,
1162                                         ifc_pfx='eth_avf')
1163         if_key = Topology.get_interface_by_sw_index(node, sw_if_idx)
1164
1165         return if_key
1166
1167     @staticmethod
1168     def vpp_enslave_physical_interface(node, interface, bond_if):
1169         """Enslave physical interface to bond interface on VPP node.
1170
1171         :param node: DUT node from topology.
1172         :param interface: Physical interface key from topology file.
1173         :param bond_if: Load balance
1174         :type node: dict
1175         :type interface: str
1176         :type bond_if: str
1177         :raises RuntimeError: If it is not possible to enslave physical
1178             interface to bond interface on the node.
1179         """
1180         cmd = 'bond_enslave'
1181         args = dict(
1182             sw_if_index=Topology.get_interface_sw_index(node, interface),
1183             bond_sw_if_index=Topology.get_interface_sw_index(node, bond_if),
1184             is_passive=0,
1185             is_long_timeout=0)
1186         err_msg = 'Failed to enslave physical interface {ifc} to bond ' \
1187                   'interface {bond} on host {host}'.format(ifc=interface,
1188                                                            bond=bond_if,
1189                                                            host=node['host'])
1190         with PapiExecutor(node) as papi_exec:
1191             papi_exec.add(cmd, **args).get_replies(err_msg).\
1192                 verify_reply(err_msg=err_msg)
1193
1194     @staticmethod
1195     def vpp_show_bond_data_on_node(node, details=False):
1196         """Show (detailed) bond information on VPP node.
1197
1198         :param node: DUT node from topology.
1199         :param details: If detailed information is required or not.
1200         :type node: dict
1201         :type details: bool
1202         """
1203         cmd = 'sw_interface_bond_dump'
1204         cmd_reply = 'sw_interface_bond_details'
1205         err_msg = 'Failed to get bond interface dump on host {host}'.format(
1206             host=node['host'])
1207
1208         data = ('Bond data on node {host}:\n'.format(host=node['host']))
1209         with PapiExecutor(node) as papi_exec:
1210             papi_resp = papi_exec.add(cmd).get_dump(err_msg)
1211
1212         papi_dump = papi_resp.reply[0]['api_reply']
1213         for item in papi_dump:
1214             data += ('{b}\n'.format(b=item[cmd_reply]['interface_name'].
1215                                     rstrip('\x00')))
1216             data += ('  mode: {m}\n'.
1217                      format(m=LinkBondMode(item[cmd_reply]['mode']).name.
1218                             lower()))
1219             data += ('  load balance: {lb}\n'.
1220                      format(lb=LinkBondLoadBalance(item[cmd_reply]['lb']).name.
1221                             lower()))
1222             data += ('  number of active slaves: {n}\n'.
1223                      format(n=item[cmd_reply]['active_slaves']))
1224             if details:
1225                 slave_data = InterfaceUtil.vpp_bond_slave_dump(
1226                     node, Topology.get_interface_by_sw_index(
1227                         node, item[cmd_reply]['sw_if_index']))
1228                 for slave in slave_data:
1229                     if not slave['is_passive']:
1230                         data += ('    {s}\n'.format(s=slave['interface_name']))
1231             data += ('  number of slaves: {n}\n'.
1232                      format(n=item[cmd_reply]['slaves']))
1233             if details:
1234                 for slave in slave_data:
1235                     data += ('    {s}\n'.format(s=slave['interface_name']))
1236             data += ('  interface id: {i}\n'.
1237                      format(i=item[cmd_reply]['id']))
1238             data += ('  sw_if_index: {i}\n'.
1239                      format(i=item[cmd_reply]['sw_if_index']))
1240         logger.info(data)
1241
1242     @staticmethod
1243     def vpp_bond_slave_dump(node, interface):
1244         """Get bond interface slave(s) data on VPP node.
1245
1246         :param node: DUT node from topology.
1247         :param interface: Physical interface key from topology file.
1248         :type node: dict
1249         :type interface: str
1250         :returns: Bond slave interface data.
1251         :rtype: dict
1252         """
1253         cmd = 'sw_interface_slave_dump'
1254         cmd_reply = 'sw_interface_slave_details'
1255         args = dict(sw_if_index=Topology.get_interface_sw_index(
1256             node, interface))
1257         err_msg = 'Failed to get slave dump on host {host}'.format(
1258             host=node['host'])
1259
1260         with PapiExecutor(node) as papi_exec:
1261             papi_resp = papi_exec.add(cmd, **args).get_dump(err_msg)
1262
1263         papi_dump = papi_resp.reply[0]['api_reply']
1264
1265         def process_slave_dump(slave_dump):
1266             """Process slave dump.
1267
1268             :param slave_dump: Slave interface dump.
1269             :type slave_dump: dict
1270             :returns: Processed slave interface dump.
1271             :rtype: dict
1272             """
1273             slave_dump['interface_name'] = slave_dump['interface_name'].\
1274                 rstrip('\x00')
1275             return slave_dump
1276
1277         data = list()
1278         for item in papi_dump:
1279             data.append(process_slave_dump(item[cmd_reply]))
1280
1281         logger.debug('Slave data:\n{slave_data}'.format(slave_data=data))
1282         return data
1283
1284     @staticmethod
1285     def vpp_show_bond_data_on_all_nodes(nodes, details=False):
1286         """Show (detailed) bond information on all VPP nodes in DICT__nodes.
1287
1288         :param nodes: Nodes in the topology.
1289         :param details: If detailed information is required or not.
1290         :type nodes: dict
1291         :type details: bool
1292         """
1293         for node_data in nodes.values():
1294             if node_data['type'] == NodeType.DUT:
1295                 InterfaceUtil.vpp_show_bond_data_on_node(node_data, details)
1296
1297     @staticmethod
1298     def vpp_enable_input_acl_interface(node, interface, ip_version,
1299                                        table_index):
1300         """Enable input acl on interface.
1301
1302         :param node: VPP node to setup interface for input acl.
1303         :param interface: Interface to setup input acl.
1304         :param ip_version: Version of IP protocol.
1305         :param table_index: Classify table index.
1306         :type node: dict
1307         :type interface: str or int
1308         :type ip_version: str
1309         :type table_index: int
1310         """
1311         cmd = 'input_acl_set_interface'
1312         args = dict(
1313             sw_if_index=InterfaceUtil.get_interface_index(node, interface),
1314             ip4_table_index=table_index if ip_version == 'ip4'
1315             else Constants.BITWISE_NON_ZERO,
1316             ip6_table_index=table_index if ip_version == 'ip6'
1317             else Constants.BITWISE_NON_ZERO,
1318             l2_table_index=table_index if ip_version == 'l2'
1319             else Constants.BITWISE_NON_ZERO,
1320             is_add=1)
1321         err_msg = 'Failed to enable input acl on interface {ifc}'.format(
1322             ifc=interface)
1323         with PapiExecutor(node) as papi_exec:
1324             papi_exec.add(cmd, **args).get_replies(err_msg).\
1325                 verify_reply(err_msg=err_msg)
1326
1327     @staticmethod
1328     def get_interface_classify_table(node, interface):
1329         """Get name of classify table for the given interface.
1330
1331         TODO: Move to Classify.py.
1332
1333         :param node: VPP node to get data from.
1334         :param interface: Name or sw_if_index of a specific interface.
1335         :type node: dict
1336         :type interface: str or int
1337         :returns: Classify table name.
1338         :rtype: str
1339         """
1340         if isinstance(interface, basestring):
1341             sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
1342         else:
1343             sw_if_index = interface
1344
1345         cmd = 'classify_table_by_interface'
1346         args = dict(sw_if_index=sw_if_index)
1347         err_msg = 'Failed to get classify table name by interface {ifc}'.format(
1348             ifc=interface)
1349         with PapiExecutor(node) as papi_exec:
1350             papi_resp = papi_exec.add(cmd, **args).get_replies(err_msg). \
1351                 verify_reply(err_msg=err_msg)
1352
1353         return papi_resp
1354
1355     @staticmethod
1356     def get_sw_if_index(node, interface_name):
1357         """Get sw_if_index for the given interface from actual interface dump.
1358
1359         :param node: VPP node to get interface data from.
1360         :param interface_name: Name of the specific interface.
1361         :type node: dict
1362         :type interface_name: str
1363         :returns: sw_if_index of the given interface.
1364         :rtype: str
1365         """
1366         interface_data = InterfaceUtil.vpp_get_interface_data(
1367             node, interface=interface_name)
1368         return interface_data.get('sw_if_index')
1369
1370     @staticmethod
1371     def vxlan_gpe_dump(node, interface_name=None):
1372         """Get VxLAN GPE data for the given interface.
1373
1374         :param node: VPP node to get interface data from.
1375         :param interface_name: Name of the specific interface. If None,
1376             information about all VxLAN GPE interfaces is returned.
1377         :type node: dict
1378         :type interface_name: str
1379         :returns: Dictionary containing data for the given VxLAN GPE interface
1380             or if interface=None, the list of dictionaries with all VxLAN GPE
1381             interfaces.
1382         :rtype: dict or list
1383         """
1384         if interface_name is not None:
1385             sw_if_index = InterfaceUtil.get_interface_index(
1386                 node, interface_name)
1387         else:
1388             sw_if_index = int(Constants.BITWISE_NON_ZERO)
1389
1390         cmd = 'vxlan_gpe_tunnel_dump'
1391         cmd_reply = 'vxlan_gpe_tunnel_details'
1392         args = dict(sw_if_index=sw_if_index)
1393         err_msg = 'Failed to get VXLAN-GPE dump on host {host}'.format(
1394             host=node['host'])
1395         with PapiExecutor(node) as papi_exec:
1396             papi_resp = papi_exec.add(cmd, **args).get_dump(err_msg)
1397
1398         papi_vxlan_dump = papi_resp.reply[0]['api_reply']
1399
1400         def process_vxlan_gpe_dump(vxlan_dump):
1401             """Process vxlan_gpe dump.
1402
1403             :param vxlan_dump: Vxlan_gpe nterface dump.
1404             :type vxlan_dump: dict
1405             :returns: Processed vxlan_gpe interface dump.
1406             :rtype: dict
1407             """
1408             if vxlan_dump['is_ipv6']:
1409                 vxlan_dump['local'] = \
1410                     inet_ntop(AF_INET6, vxlan_dump['local'])
1411                 vxlan_dump['remote'] = \
1412                     inet_ntop(AF_INET6, vxlan_dump['remote'])
1413             else:
1414                 vxlan_dump['local'] = \
1415                     inet_ntop(AF_INET, vxlan_dump['local'][0:4])
1416                 vxlan_dump['remote'] = \
1417                     inet_ntop(AF_INET, vxlan_dump['remote'][0:4])
1418             return vxlan_dump
1419
1420         data = list() if interface_name is None else dict()
1421         for item in papi_vxlan_dump:
1422             if interface_name is None:
1423                 data.append(process_vxlan_gpe_dump(item[cmd_reply]))
1424             elif item[cmd_reply]['sw_if_index'] == sw_if_index:
1425                 data = process_vxlan_gpe_dump(item[cmd_reply])
1426                 break
1427
1428         logger.debug('VXLAN-GPE data:\n{vxlan_gpe_data}'.format(
1429             vxlan_gpe_data=data))
1430         return data
1431
1432     @staticmethod
1433     def assign_interface_to_fib_table(node, interface, table_id, ipv6=False):
1434         """Assign VPP interface to specific VRF/FIB table.
1435
1436         :param node: VPP node where the FIB and interface are located.
1437         :param interface: Interface to be assigned to FIB.
1438         :param table_id: VRF table ID.
1439         :param ipv6: Assign to IPv6 table. Default False.
1440         :type node: dict
1441         :type interface: str or int
1442         :type table_id: int
1443         :type ipv6: bool
1444         """
1445         cmd = 'sw_interface_set_table'
1446         args = dict(
1447             sw_if_index=InterfaceUtil.get_interface_index(node, interface),
1448             is_ipv6=1 if ipv6 else 0,
1449             vrf_id=int(table_id))
1450         err_msg = 'Failed to assign interface {ifc} to FIB table'.format(
1451             ifc=interface)
1452         with PapiExecutor(node) as papi_exec:
1453             papi_exec.add(cmd, **args).get_replies(err_msg). \
1454                 verify_reply(err_msg=err_msg)
1455
1456     @staticmethod
1457     def set_linux_interface_mac(node, interface, mac, namespace=None,
1458                                 vf_id=None):
1459         """Set MAC address for interface in linux.
1460
1461         :param node: Node where to execute command.
1462         :param interface: Interface in namespace.
1463         :param mac: MAC to be assigned to interface.
1464         :param namespace: Execute command in namespace. Optional
1465         :param vf_id: Virtual Function id. Optional
1466         :type node: dict
1467         :type interface: str
1468         :type mac: str
1469         :type namespace: str
1470         :type vf_id: int
1471         """
1472         mac_str = 'vf {vf_id} mac {mac}'.format(vf_id=vf_id, mac=mac) \
1473             if vf_id is not None else 'address {mac}'.format(mac=mac)
1474         ns_str = 'ip netns exec {ns}'.format(ns=namespace) if namespace else ''
1475
1476         cmd = ('{ns} ip link set {interface} {mac}'.
1477                format(ns=ns_str, interface=interface, mac=mac_str))
1478         exec_cmd_no_error(node, cmd, sudo=True)
1479
1480     @staticmethod
1481     def set_linux_interface_trust_on(node, interface, namespace=None,
1482                                      vf_id=None):
1483         """Set trust on (promisc) for interface in linux.
1484
1485         :param node: Node where to execute command.
1486         :param interface: Interface in namespace.
1487         :param namespace: Execute command in namespace. Optional
1488         :param vf_id: Virtual Function id. Optional
1489         :type node: dict
1490         :type interface: str
1491         :type namespace: str
1492         :type vf_id: int
1493         """
1494         trust_str = 'vf {vf_id} trust on'.format(vf_id=vf_id) \
1495             if vf_id is not None else 'trust on'
1496         ns_str = 'ip netns exec {ns}'.format(ns=namespace) if namespace else ''
1497
1498         cmd = ('{ns} ip link set dev {interface} {trust}'.
1499                format(ns=ns_str, interface=interface, trust=trust_str))
1500         exec_cmd_no_error(node, cmd, sudo=True)
1501
1502     @staticmethod
1503     def set_linux_interface_spoof_off(node, interface, namespace=None,
1504                                       vf_id=None):
1505         """Set spoof off for interface in linux.
1506
1507         :param node: Node where to execute command.
1508         :param interface: Interface in namespace.
1509         :param namespace: Execute command in namespace. Optional
1510         :param vf_id: Virtual Function id. Optional
1511         :type node: dict
1512         :type interface: str
1513         :type namespace: str
1514         :type vf_id: int
1515         """
1516         spoof_str = 'vf {vf_id} spoof off'.format(vf_id=vf_id) \
1517             if vf_id is not None else 'spoof off'
1518         ns_str = 'ip netns exec {ns}'.format(ns=namespace) if namespace else ''
1519
1520         cmd = ('{ns} ip link set dev {interface} {spoof}'.
1521                format(ns=ns_str, interface=interface, spoof=spoof_str))
1522         exec_cmd_no_error(node, cmd, sudo=True)
1523
1524     @staticmethod
1525     def init_avf_interface(node, ifc_key, numvfs=1, osi_layer='L2'):
1526         """Init PCI device by creating VFs and bind them to vfio-pci for AVF
1527         driver testing on DUT.
1528
1529         :param node: DUT node.
1530         :param ifc_key: Interface key from topology file.
1531         :param numvfs: Number of VFs to initialize, 0 - disable the VFs.
1532         :param osi_layer: OSI Layer type to initialize TG with.
1533             Default value "L2" sets linux interface spoof off.
1534         :type node: dict
1535         :type ifc_key: str
1536         :type numvfs: int
1537         :type osi_layer: str
1538         :returns: Virtual Function topology interface keys.
1539         :rtype: list
1540         :raises RuntimeError: If a reason preventing initialization is found.
1541         """
1542         # Read PCI address and driver.
1543         pf_pci_addr = Topology.get_interface_pci_addr(node, ifc_key)
1544         pf_mac_addr = Topology.get_interface_mac(node, ifc_key).split(":")
1545         uio_driver = Topology.get_uio_driver(node)
1546         kernel_driver = Topology.get_interface_driver(node, ifc_key)
1547         if kernel_driver != "i40e":
1548             raise RuntimeError(
1549                 "AVF needs i40e driver, not {driver} at node {host} ifc {ifc}"\
1550                 .format(driver=kernel_driver, host=node["host"], ifc=ifc_key))
1551         current_driver = DUTSetup.get_pci_dev_driver(
1552             node, pf_pci_addr.replace(':', r'\:'))
1553
1554         VPPUtil.stop_vpp_service(node)
1555         if current_driver != kernel_driver:
1556             # PCI device must be re-bound to kernel driver before creating VFs.
1557             DUTSetup.verify_kernel_module(node, kernel_driver, force_load=True)
1558             # Stop VPP to prevent deadlock.
1559             # Unbind from current driver.
1560             DUTSetup.pci_driver_unbind(node, pf_pci_addr)
1561             # Bind to kernel driver.
1562             DUTSetup.pci_driver_bind(node, pf_pci_addr, kernel_driver)
1563
1564         # Initialize PCI VFs
1565         DUTSetup.set_sriov_numvfs(node, pf_pci_addr, numvfs)
1566
1567         vf_ifc_keys = []
1568         # Set MAC address and bind each virtual function to uio driver.
1569         for vf_id in range(numvfs):
1570             vf_mac_addr = ":".join([pf_mac_addr[0], pf_mac_addr[2],
1571                                     pf_mac_addr[3], pf_mac_addr[4],
1572                                     pf_mac_addr[5], "{:02x}".format(vf_id)])
1573
1574             pf_dev = '`basename /sys/bus/pci/devices/{pci}/net/*`'.\
1575                 format(pci=pf_pci_addr)
1576             InterfaceUtil.set_linux_interface_trust_on(node, pf_dev,
1577                                                        vf_id=vf_id)
1578             if osi_layer == 'L2':
1579                 InterfaceUtil.set_linux_interface_spoof_off(node, pf_dev,
1580                                                             vf_id=vf_id)
1581             InterfaceUtil.set_linux_interface_mac(node, pf_dev, vf_mac_addr,
1582                                                   vf_id=vf_id)
1583
1584             DUTSetup.pci_vf_driver_unbind(node, pf_pci_addr, vf_id)
1585             DUTSetup.pci_vf_driver_bind(node, pf_pci_addr, vf_id, uio_driver)
1586
1587             # Add newly created ports into topology file
1588             vf_ifc_name = '{pf_if_key}_vf'.format(pf_if_key=ifc_key)
1589             vf_pci_addr = DUTSetup.get_virtfn_pci_addr(node, pf_pci_addr, vf_id)
1590             vf_ifc_key = Topology.add_new_port(node, vf_ifc_name)
1591             Topology.update_interface_name(node, vf_ifc_key,
1592                                            vf_ifc_name+str(vf_id+1))
1593             Topology.update_interface_mac_address(node, vf_ifc_key, vf_mac_addr)
1594             Topology.update_interface_pci_address(node, vf_ifc_key, vf_pci_addr)
1595             vf_ifc_keys.append(vf_ifc_key)
1596
1597         return vf_ifc_keys
1598
1599     @staticmethod
1600     def vpp_sw_interface_rx_placement_dump(node):
1601         """Dump VPP interface RX placement on node.
1602
1603         :param node: Node to run command on.
1604         :type node: dict
1605         :returns: Thread mapping information as a list of dictionaries.
1606         :rtype: list
1607         """
1608         cmd = 'sw_interface_rx_placement_dump'
1609         cmd_reply = 'sw_interface_rx_placement_details'
1610         err_msg = "Failed to run '{cmd}' PAPI command on host {host}!".format(
1611             cmd=cmd, host=node['host'])
1612         with PapiExecutor(node) as papi_exec:
1613             for ifc in node['interfaces'].values():
1614                 if ifc['vpp_sw_index'] is not None:
1615                     papi_exec.add(cmd, sw_if_index=ifc['vpp_sw_index'])
1616             papi_resp = papi_exec.get_dump(err_msg)
1617         thr_mapping = [s[cmd_reply] for r in papi_resp.reply
1618                        for s in r['api_reply']]
1619         return sorted(thr_mapping, key=lambda k: k['sw_if_index'])
1620
1621     @staticmethod
1622     def vpp_sw_interface_set_rx_placement(node, sw_if_index, queue_id,
1623                                           worker_id):
1624         """Set interface RX placement to worker on node.
1625
1626         :param node: Node to run command on.
1627         :param sw_if_index: VPP SW interface index.
1628         :param queue_id: VPP interface queue ID.
1629         :param worker_id: VPP worker ID (indexing from 0).
1630         :type node: dict
1631         :type sw_if_index: int
1632         :type queue_id: int
1633         :type worker_id: int
1634         :raises RuntimeError: If failed to run command on host or if no API
1635             reply received.
1636         """
1637         cmd = 'sw_interface_set_rx_placement'
1638         err_msg = "Failed to set interface RX placement to worker on host " \
1639                   "{host}!".format(host=node['host'])
1640         args = dict(sw_if_index=sw_if_index, queue_id=queue_id,
1641                     worker_id=worker_id)
1642         with PapiExecutor(node) as papi_exec:
1643             papi_exec.add(cmd, **args).get_replies(err_msg).\
1644                 verify_reply(err_msg=err_msg)
1645
1646     @staticmethod
1647     def vpp_round_robin_rx_placement(node, prefix):
1648         """Set Round Robin interface RX placement on all worker threads
1649         on node.
1650
1651         :param node: Topology nodes.
1652         :param prefix: Interface name prefix.
1653         :type node: dict
1654         :type prefix: str
1655         """
1656         worker_id = 0
1657         worker_cnt = len(VPPUtil.vpp_show_threads(node)) - 1
1658         if not worker_cnt:
1659             return
1660         for placement in InterfaceUtil.vpp_sw_interface_rx_placement_dump(node):
1661             for interface in node['interfaces'].values():
1662                 if placement['sw_if_index'] == interface['vpp_sw_index'] \
1663                     and prefix in interface['name']:
1664                     InterfaceUtil.vpp_sw_interface_set_rx_placement(
1665                         node, placement['sw_if_index'], placement['queue_id'],
1666                         worker_id % worker_cnt)
1667                     worker_id += 1
1668
1669     @staticmethod
1670     def vpp_round_robin_rx_placement_on_all_duts(nodes, prefix):
1671         """Set Round Robin interface RX placement on all worker threads
1672         on all DUTs.
1673
1674         :param nodes: Topology nodes.
1675         :param prefix: Interface name prefix.
1676         :type nodes: dict
1677         :type prefix: str
1678         """
1679         for node in nodes.values():
1680             if node['type'] == NodeType.DUT:
1681                 InterfaceUtil.vpp_round_robin_rx_placement(node, prefix)

©2016 FD.io a Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation. Linux is a registered trademark of Linus Torvalds.
Please see our privacy policy and terms of use.