def build_qemu(node, force_install=False, apply_patch=False): """Build QEMU from sources. :param node: Node to build QEMU on. :param force_install: If True, then remove previous build. :param apply_patch: If True, then apply patches from qemu_patches dir. :type node: dict :type force_install: bool :type apply_patch: bool :raises RuntimeError: If building QEMU failed. """ ssh = SSH() ssh.connect(node) directory = ' --directory={0}'.format(Constants.QEMU_INSTALL_DIR) if apply_patch: directory += '-patch' else: directory += '-base' version = ' --version={0}'.format(Constants.QEMU_INSTALL_VERSION) force = ' --force' if force_install else '' patch = ' --patch' if apply_patch else '' arch = Topology.get_node_arch(node) target_list = ' --target-list={0}-softmmu'.format(arch) (ret_code, stdout, stderr) = \ ssh.exec_command( "sudo -E sh -c '{0}/{1}/qemu_build.sh{2}{3}{4}{5}{6}'"\ .format(Constants.REMOTE_FW_DIR, Constants.RESOURCES_LIB_SH, version, directory, force, patch, target_list), 1000) if int(ret_code) != 0: logger.debug('QEMU build failed {0}'.format(stdout + stderr)) raise RuntimeError('QEMU build failed on {0}'.format(node['host']))
def crypto_device_init(node, numvfs): """Init Crypto QAT device virtual functions on DUT. :param node: DUT node. :param numvfs: Number of VFs to initialize, 0 - disable the VFs. :type node: dict :type numvfs: int :returns: nothing :raises RuntimeError: If QAT failed to initialize. """ ssh = SSH() ssh.connect(node) cryptodev = Topology.get_cryptodev(node) # QAT device must be bind to kernel driver before initialization DUTSetup.pci_driver_unbind(node, cryptodev) DUTSetup.pci_driver_bind(node, cryptodev, "dh895xcc") # Initialize QAT VFs ret_code, _, _ = ssh.exec_command( "sudo sh -c 'echo {} | tee /sys/bus/pci/devices/{}/sriov_numvfs'". format(numvfs, cryptodev.replace(':', r'\:'))) if int(ret_code) != 0: raise RuntimeError('Failed to initialize {} VFs on QAT device on ' 'host: {}'.format(numvfs, node['host']))
def set_acl_list_for_interface(node, interface, acl_type, acl_idx=None): """Set the list of input or output ACLs applied to the interface. It unapplies any previously applied ACLs. :param node: VPP node to set ACL on. :param interface: Interface name or sw_if_index. :param acl_type: Type of ACL(s) - input or output. :param acl_idx: Index(ies) of ACLs to be applied on the interface. :type node: dict :type interface: str or int :type acl_type: str :type acl_idx: list :raises RuntimeError: If unable to set ACL list for the interface. """ if isinstance(interface, basestring): sw_if_index = Topology.get_interface_sw_index(node, interface) else: sw_if_index = interface acl_list = acl_type + ' ' + ' '.join(str(idx) for idx in acl_idx) \ if acl_idx else acl_type try: with VatTerminal(node, json_param=False) as vat: vat.vat_terminal_exec_cmd_from_template( "acl_plugin/acl_interface_set_acl_list.vat", interface=sw_if_index, acl_list=acl_list) except RuntimeError: raise RuntimeError("Setting of ACL list for interface {0} failed " "on node {1}".format(interface, node['host']))
def vpp_ip_probe(node, interface, addr, if_type="key"): """Run ip probe on VPP node. :param node: VPP node. :param interface: Interface key or name. :param addr: IPv4/IPv6 address. :param if_type: Interface type :type node: dict :type interface: str :type addr: str :type if_type: str :raises ValueError: If the if_type is unknown. :raises Exception: If vpp probe fails. """ ssh = SSH() ssh.connect(node) if if_type == "key": iface_name = Topology.get_interface_name(node, interface) elif if_type == "name": iface_name = interface else: raise ValueError("if_type unknown: {0}".format(if_type)) cmd = "{c}".format(c=Constants.VAT_BIN_NAME) cmd_input = 'exec ip probe {dev} {ip}'.format(dev=iface_name, ip=addr) (ret_code, _, _) = ssh.exec_command_sudo(cmd, cmd_input) if int(ret_code) != 0: raise Exception('VPP ip probe {dev} {ip} failed on {h}'.format( dev=iface_name, ip=addr, h=node['host']))
def crypto_device_init(node, numvfs): """Init Crypto QAT device virtual functions on DUT. :param node: DUT node. :param numvfs: Number of VFs to initialize, 0 - disable the VFs. :type node: dict :type numvfs: int :returns: nothing :raises RuntimeError: If failed to stop VPP or QAT failed to initialize. """ pci_addr = Topology.get_cryptodev(node) # QAT device must be re-bound to kernel driver before initialization. DUTSetup.verify_kernel_module(node, 'qat_dh895xcc', force_load=True) # Stop VPP to prevent deadlock. DUTSetup.stop_service(node, Constants.VPP_UNIT) current_driver = DUTSetup.get_pci_dev_driver( node, pci_addr.replace(':', r'\:')) if current_driver is not None: DUTSetup.pci_driver_unbind(node, pci_addr) # Bind to kernel driver. DUTSetup.pci_driver_bind(node, pci_addr, 'dh895xcc') # Initialize QAT VFs. if numvfs > 0: DUTSetup.set_sriov_numvfs(node, pci_addr, numvfs)
def create_kernelvm_config_testpmd_mac(self, **kwargs): """Create QEMU testpmd-mac command line. :param kwargs: Key-value pairs to construct command line parameters. :type kwargs: dict """ testpmd_path = ('{path}/{arch}-native-linuxapp-gcc/app'. format(path=Constants.QEMU_VM_DPDK, arch=Topology.get_node_arch(self._node))) testpmd_cmd = DpdkUtil.get_testpmd_cmdline( eal_corelist='0-{smp}'.format(smp=self._opt.get('smp') - 1), eal_driver=False, eal_in_memory=True, pmd_num_mbufs=16384, pmd_fwd_mode='mac', pmd_eth_peer_0='0,{mac}'.format(mac=kwargs['vif1_mac']), pmd_eth_peer_1='1,{mac}'.format(mac=kwargs['vif2_mac']), pmd_rxq=kwargs['queues'], pmd_txq=kwargs['queues'], pmd_tx_offloads=False, pmd_disable_hw_vlan=False, pmd_max_pkt_len=9200 if kwargs['jumbo_frames'] else None, pmd_nb_cores=str(self._opt.get('smp') - 1)) self._opt['vnf_bin'] = ('{testpmd_path}/{testpmd_cmd}'. format(testpmd_path=testpmd_path, testpmd_cmd=testpmd_cmd))
def install_sfc_test(node): """Prepare the NSH SFC test envrionment. :param node: Dictionary created from topology :type node: dict :returns: nothing """ logger.console('Install the NSH SFC on {0}'.format(node['host'])) if_name_list = Topology.get_node_interfaces(node) ssh = SSH() ssh.connect(node) (ret_code, _, stderr) = ssh.exec_command( 'cd {0}/tests/nsh_sfc/sfc_scripts/ && ./install_sfc.sh {1} {2}' .format(con.REMOTE_FW_DIR, if_name_list[0], if_name_list[1]), \ timeout=600) if ret_code != 0: logger.error('Install the NSH SFC error: {0}'.format(stderr)) raise RuntimeError('Install the NSH SFC failed') else: logger.console('Install the NSH SFC on {0} success!'. format(node['host']))
def start_the_l2fwd_test(dut_node, cpu_cores, nb_cores, queue_nums, jumbo_frames): """ Execute the l2fwd on the dut_node. :param dut_node: Will execute the l2fwd on this node. :param cpu_cores: The DPDK run cores. :param nb_cores: The cores number for the forwarding. :param queue_nums: The queues number for the NIC. :param jumbo_frames: Are jumbo frames used or not. :type dut_node: dict :type cpu_cores: str :type nb_cores: str :type queue_nums: str :type jumbo_frames: str :raises RuntimeError: If the script "run_l2fwd.sh" fails. """ if dut_node['type'] == NodeType.DUT: ssh = SSH() ssh.connect(dut_node) arch = Topology.get_node_arch(dut_node) cmd = '{fwdir}/tests/dpdk/dpdk_scripts/run_l2fwd.sh {cpu_cores} ' \ '{nb_cores} {queues} {jumbo} {arch}'.\ format(fwdir=Constants.REMOTE_FW_DIR, cpu_cores=cpu_cores, nb_cores=nb_cores, queues=queue_nums, jumbo=jumbo_frames, arch=arch) ret_code, _, _ = ssh.exec_command_sudo(cmd, timeout=600) if ret_code != 0: raise RuntimeError('Failed to execute l2fwd test at node ' '{name}'.format(name=dut_node['host']))
def vpp_add_ip_neighbor(node, iface_key, ip_addr, mac_address): """Add IP neighbor on DUT node. :param node: VPP node. :param iface_key: Interface key. :param ip_addr: IP address of the interface. :param mac_address: MAC address of the interface. :type node: dict :type iface_key: str :type ip_addr: str :type mac_address: str """ dst_ip = ip_address(ip_addr) neighbor = dict(sw_if_index=Topology.get_interface_sw_index( node, iface_key), flags=0, mac_address=str(mac_address), ip_address=str(dst_ip)) cmd = u"ip_neighbor_add_del" args = dict(is_add=True, neighbor=neighbor) err_msg = f"Failed to add IP neighbor on interface {iface_key}" with PapiSocketExecutor(node) as papi_exec: papi_exec.add(cmd, **args).get_reply(err_msg)
def add_pci_device(self, node, *pci_devices): """Add PCI device configuration for node. :param node: DUT node. :param pci_devices: PCI devices (format 0000:00:00.0 or 00:00.0) :type node: dict :type pci_devices: tuple :returns: nothing """ if node['type'] != NodeType.DUT: raise ValueError('Node type is not a DUT') # Specific device was given. hostname = Topology.get_node_hostname(node) pattern = re.compile("^[0-9A-Fa-f]{4}:[0-9A-Fa-f]{2}:" "[0-9A-Fa-f]{2}\\.[0-9A-Fa-f]$") for pci_device in pci_devices: if not pattern.match(pci_device): raise ValueError('PCI address {} to be added to host {} ' 'is not in valid format xxxx:xx:xx.x'. format(pci_device, hostname)) if hostname not in self._nodeconfig: self._nodeconfig[hostname] = {} if 'pci_addrs' not in self._nodeconfig[hostname]: self._nodeconfig[hostname]['pci_addrs'] = [] self._nodeconfig[hostname]['pci_addrs'].append(pci_device) logger.debug('Adding PCI device {1} to {0}'.format(hostname, pci_device))
def get_affinity_vhost(node, pf_key, skip_cnt=0, cpu_cnt=1): """Get affinity for vhost. Result will be used to pin vhost threads. :param node: Topology node. :param pf_key: Topology interface. :param skip_cnt: Amount of CPU cores to skip. :param cpu_cnt: CPU threads count. :type node: dict :type pf_key: str :type skip_cnt: int :type cpu_cnt: int :returns: List of CPUs allocated to vhost process. :rtype: str """ if pf_key: cpu_node = Topology.get_interface_numa_node(node, pf_key) else: cpu_node = 0 smt_used = CpuUtils.is_smt_enabled(node[u"cpuinfo"]) if smt_used: cpu_cnt = cpu_cnt // CpuUtils.NR_OF_THREADS return CpuUtils.cpu_slice_of_list_per_node(node, cpu_node=cpu_node, skip_cnt=skip_cnt, cpu_cnt=cpu_cnt, smt_used=smt_used)
def acquire(self, force=True): """Pull an image or a repository from a registry. :param force: Destroy a container if exists. :type force: bool :raises RuntimeError: If pulling a container failed. """ if self.is_container_present(): if force: self.destroy() else: return if not self.container.image: img = Constants.DOCKER_SUT_IMAGE_UBUNTU_ARM \ if Topology.get_node_arch(self.container.node) == u"aarch64" \ else Constants.DOCKER_SUT_IMAGE_UBUNTU setattr(self.container, u"image", img) cmd = f"docker pull {self.container.image}" ret, _, _ = self.container.ssh.exec_command_sudo(cmd, timeout=1800) if int(ret) != 0: raise RuntimeError( f"Failed to create container {self.container.name}." ) if self.container.cpuset_cpus: self._configure_cgroup(u"docker")
def acquire(self, force=True): """Acquire a privileged system object where configuration is stored. :param force: If a container exists, destroy it and create a new container. :type force: bool :raises RuntimeError: If creating the container or writing the container config fails. """ if self.is_container_present(): if force: self.destroy() else: return target_arch = u"arm64" \ if Topology.get_node_arch(self.container.node) == u"aarch64" \ else u"amd64" image = self.container.image if self.container.image \ else f"-d ubuntu -r bionic -a {target_arch}" cmd = f"lxc-create -t download --name {self.container.name} " \ f"-- {image} --no-validate" ret, _, _ = self.container.ssh.exec_command_sudo(cmd, timeout=1800) if int(ret) != 0: raise RuntimeError(u"Failed to create container.") self._configure_cgroup(u"lxc")
def vpp_add_ip_neighbor(node, iface_key, ip_addr, mac_address): """Add IP neighbor on DUT node. :param node: VPP node. :param iface_key: Interface key. :param ip_addr: IP address of the interface. :param mac_address: MAC address of the interface. :type node: dict :type iface_key: str :type ip_addr: str :type mac_address: str """ dst_ip = ip_address(unicode(ip_addr)) neighbor = dict( sw_if_index=Topology.get_interface_sw_index(node, iface_key), flags=0, mac_address=str(mac_address), ip_address=str(dst_ip)) cmd = 'ip_neighbor_add_del' args = dict( is_add=1, neighbor=neighbor) err_msg = 'Failed to add IP neighbor on interface {ifc}'.format( ifc=iface_key) with PapiExecutor(node) as papi_exec: papi_exec.add(cmd, **args).get_replies(err_msg). \ verify_reply(err_msg=err_msg)
def vxlan_dump(node, interface=None): """Get VxLAN data for the given interface. :param node: VPP node to get interface data from. :param interface: Numeric index or name string of a specific interface. If None, information about all VxLAN interfaces is returned. :type node: dict :type interface: int or str :returns: Dictionary containing data for the given VxLAN interface or if interface=None, the list of dictionaries with all VxLAN interfaces. :rtype: dict or list :raises TypeError: if the data type of interface is neither basestring nor int. """ param = "sw_if_index" if interface is None: param = '' sw_if_index = '' elif isinstance(interface, basestring): sw_if_index = Topology.get_interface_sw_index(node, interface) elif isinstance(interface, int): sw_if_index = interface else: raise TypeError("Wrong interface format {0}".format(interface)) with VatTerminal(node) as vat: response = vat.vat_terminal_exec_cmd_from_template( "vxlan_dump.vat", param=param, sw_if_index=sw_if_index) if sw_if_index: for vxlan in response[0]: if vxlan["sw_if_index"] == sw_if_index: return vxlan return {} return response[0]
def vpp_set_if_ipv6_addr(node, iface_key, addr, prefix): """Set IPv6 address on VPP. :param node: VPP node. :param iface_key: Node interface key. :param addr: IPv6 address. :param prefix: IPv6 address prefix. :type node: dict :type iface_key: str :type addr: str :type prefix: str """ sw_if_index = Topology.get_interface_sw_index(node, iface_key) with VatTerminal(node) as vat: vat.vat_terminal_exec_cmd_from_template('add_ip_address.vat', sw_if_index=sw_if_index, address=addr, prefix_length=prefix) vat.vat_terminal_exec_cmd_from_template('set_if_state.vat', sw_if_index=sw_if_index, state='admin-up') ssh = SSH() ssh.connect(node) cmd_input = 'exec show int' (ret_code, stdout, stderr) = ssh.exec_command_sudo(Constants.VAT_BIN_NAME, cmd_input) logger.debug('ret: {0}'.format(ret_code)) logger.debug('stdout: {0}'.format(stdout)) logger.debug('stderr: {0}'.format(stderr))
def set_interface_ethernet_mtu(node, iface_key, mtu): """Set Ethernet MTU for specified interface. Function can be used only for TGs. :param node: Node where the interface is. :param iface_key: Interface key from topology file. :param mtu: MTU to set. :type node: dict :type iface_key: str :type mtu: int :returns: Nothing. :raises ValueError: If the node type is "DUT". :raises ValueError: If the node has an unknown node type. """ if node['type'] == NodeType.DUT: raise ValueError( 'Node {}: Setting Ethernet MTU for interface ' 'on DUT nodes not supported', node['host']) elif node['type'] == NodeType.TG: iface_name = Topology.get_interface_name(node, iface_key) cmd = 'ip link set {} mtu {}'.format(iface_name, mtu) exec_cmd_no_error(node, cmd, sudo=True) else: raise ValueError('Node {} has unknown NodeType: "{}"'.format( node['host'], node['type']))
def get_ip_addr(node, iface_key, nodes_addr): """Return IPv4 address of the node port. :param node: Node in the topology. :param iface_key: Interface key of the node. :param nodes_addr: Nodes IPv4 addresses. :type node: dict :type iface_key: str :type nodes_addr: dict :returns: IPv4 address. :rtype: str """ interface = Topology.get_interface_name(node, iface_key) for net in nodes_addr.values(): for port in net['ports'].values(): host = port.get('node') dev = port.get('if') if host == node['host'] and dev == interface: ip_addr = port.get('addr') if ip_addr is not None: return ip_addr else: raise Exception( 'Node {n} port {p} IPv4 address is not set'.format( n=node['host'], p=interface)) raise Exception('Node {n} port {p} IPv4 address not found.'.format( n=node['host'], p=interface))
def stop_vpp_service(node, node_key=None): """Stop VPP service on the specified topology node. Disconnect possibly connected PAPI executor. :param node: Topology node. :param node_key: Topology node key. :type node: dict :type node_key: str """ # Containers have a separate lifecycle, but better be safe. PapiSocketExecutor.disconnect_all_sockets_by_node(node) DUTSetup.stop_service(node, Constants.VPP_UNIT) if node_key: Topology.del_node_socket_id(node, SocketType.PAPI, node_key) Topology.del_node_socket_id(node, SocketType.STATS, node_key)
def install_dmm_test(node): """Prepare the DMM test envrionment. Raise errors when failed. :param node: Dictionary created from topology. :type node: dict :returns: nothing. :raises RuntimeError: If install dmm failed. """ arch = Topology.get_node_arch(node) logger.console('Install the DMM on {0} ({1})'.format(node['host'], arch)) ssh = SSH() ssh.connect(node) (ret_code, _, stderr) = ssh.exec_command( 'cd {0}/{1} && ./install_prereq.sh {2} 2>&1 | tee ' 'log_install_prereq.txt' .format(con.REMOTE_FW_DIR, con.DMM_SCRIPTS, arch), timeout=600) if ret_code != 0: logger.error('Install the DMM error: {0}'.format(stderr)) raise RuntimeError('Install prereq failed') else: logger.console('Install prereq on {0} success!'.format(node['host']))
def add_del_macip_acl_interface(node, interface, action, acl_idx): """Apply/un-apply the MACIP ACL to/from a given interface. :param node: VPP node to set MACIP ACL on. :param interface: Interface name or sw_if_index. :param action: Required action - add or del. :param acl_idx: ACL index to be applied on the interface. :type node: dict :type interface: str or int :type action: str :type acl_idx: str or int :raises RuntimeError: If unable to set MACIP ACL for the interface. """ if isinstance(interface, basestring): sw_if_index = Topology.get_interface_sw_index(node, interface) else: sw_if_index = interface is_add = 1 if action == "add" else 0 cmd = 'macip_acl_interface_add_del' err_msg = "Failed to get 'macip_acl_interface' on host {host}".format( host=node['host']) args = dict(is_add=is_add, sw_if_index=int(sw_if_index), acl_index=int(acl_idx)) with PapiExecutor(node) as papi_exec: papi_exec.add(cmd, **args).get_replies(err_msg).\ verify_reply(err_msg=err_msg)
def start_the_tcpdump_on_the_node(from_node, from_port, filter_ip): """ Start the tcpdump on the frome_node. :param from_node: Will execute the tcpdump on this node. :param from_port: Will capture the packets on this interface. :param filter_ip: filter the dest ip. :type from_node: dict :type from_port: str :type filter_ip: str :returns: none :raises RuntimeError: If the script "start_tcpdump.sh" fails. """ interface_name = Topology.get_interface_name(from_node, from_port) ssh = SSH() ssh.connect(from_node) cmd = 'cd {0}/nsh_sfc_tests/sfc_scripts/ && sudo ./start_tcpdump.sh ' \ '{1} {2}'.format(con.REMOTE_FW_DIR, interface_name, filter_ip) (ret_code, _, _) = ssh.exec_command(cmd, timeout=600) if ret_code != 0: raise RuntimeError( 'Failed to exec start_tcpdump.sh at node {0}'.format( from_node['host']))
def crypto_device_verify(node, force_init=False, numvfs=32): """Verify if Crypto QAT device virtual functions are initialized on all DUTs. If parameter force initialization is set to True, then try to initialize or remove VFs on QAT. :param node: DUT node. :param force_init: If True then try to initialize to specific value. :param numvfs: Number of VFs to initialize, 0 - disable the VFs. :type node: dict :type force_init: bool :type numvfs: int :returns: nothing :raises RuntimeError: If QAT VFs are not created and force init is set to False. """ pci_addr = Topology.get_cryptodev(node) sriov_numvfs = DUTSetup.get_sriov_numvfs(node, pci_addr) if sriov_numvfs != numvfs: if force_init: # QAT is not initialized and we want to initialize with numvfs DUTSetup.crypto_device_init(node, numvfs) else: raise RuntimeError( 'QAT device failed to create VFs on {host}'.format( host=node['host']))
def cop_add_whitelist_entry( node, interface, ip_version, fib_id, default_cop=0): """Add cop whitelisted entry. :param node: Node to add COP whitelist on. :param interface: Interface of the node where the COP is added. :param ip_version: IP version. 'ip4' and 'ip6' are valid values. :param fib_id: Specify the fib table ID. :param default_cop: 1 => enable non-ip4, non-ip6 filtration, 0 => disable it. :type node: dict :type interface: str :type ip_version: str :type fib_id: int :type default_cop: int :raises ValueError: If parameter 'ip_version' has incorrect value. """ if ip_version not in (u"ip4", u"ip6"): raise ValueError(u"IP version is not in correct format") cmd = u"cop_whitelist_enable_disable" err_msg = f"Failed to add COP whitelist on interface {interface} " \ f"on host {node[u'host']}" args = dict( sw_if_index=Topology.get_interface_sw_index(node, interface), fib_id=int(fib_id), ip4=bool(ip_version == u"ip4"), ip6=bool(ip_version == u"ip6"), default_cop=default_cop ) with PapiSocketExecutor(node) as papi_exec: papi_exec.add(cmd, **args).get_reply(err_msg)
def vpp_lb_add_del_intf_nat4(node, **kwargs): """Enable/disable NAT4 feature on the interface. :param node: Node where the interface is. :param kwargs: Optional key-value arguments: is_add: true if add, false if delete. (bool) interface: software index of the interface. (int) :type node: dict :type kwargs: dict :returns: Nothing. :raises ValueError: If the node has an unknown node type. """ if node[u"type"] == NodeType.DUT: cmd = u"lb_add_del_intf_nat4" err_msg = f"Failed to add interface nat4 on host {node[u'host']}" is_add = kwargs.pop(u"is_add", True) interface = kwargs.pop(u"interface", 0) sw_if_index = Topology.get_interface_sw_index(node, interface) args = dict(is_add=is_add, sw_if_index=sw_if_index) with PapiSocketExecutor(node) as papi_exec: papi_exec.add(cmd, **args).get_reply(err_msg) else: raise ValueError( f"Node {node[u'host']} has unknown NodeType: '{node[u'type']}'" )
def cop_interface_enable_or_disable(node, interface, state): """Enable or disable COP on the interface. :param node: Node to add COP whitelist on. :param interface: Interface of the node where the COP is added. :param state: Enable or disable COP on the interface. :type node: dict :type interface: str :type state: str :raises ValueError: If parameter 'state' has incorrect value. """ state = state.lower() if state in (u"enable", u"disable"): enable = bool(state == u"enable") else: raise ValueError(u"Possible state values are 'enable' or 'disable'") cmd = u"cop_interface_enable_disable" err_msg = f"Failed to enable/disable COP on interface {interface} " \ f"on host {node[u'host']}" args = dict( sw_if_index=Topology.get_interface_sw_index(node, interface), enable_disable=enable ) with PapiSocketExecutor(node) as papi_exec: papi_exec.add(cmd, **args).get_reply(err_msg)
def add_interface_to_l2_bd(node, interface, bd_id, shg=0, port_type=0): """Add an interface to the L2 bridge domain. Get SW IF ID and add it to the bridge domain. :param node: Node where we want to execute the command that does this. :param interface: Interface name. :param bd_id: Bridge domain index. :param shg: Split-horizon group index. (Default value = 0) :param port_type: Port mode: 0 - normal, 1 - BVI, 2 - UU_FWD. (Default value = 0) :type node: dict :type interface: str :type bd_id: int or str :type shg: int or str :type port_type: int or str """ sw_if_index = Topology.get_interface_sw_index(node, interface) cmd = 'sw_interface_set_l2_bridge' err_msg = 'Failed to add interface {ifc} to L2 bridge domain on host ' \ '{host}'.format(ifc=interface, host=node['host']) args = dict(rx_sw_if_index=sw_if_index, bd_id=int(bd_id), shg=int(shg), port_type=int(port_type), enable=1) with PapiExecutor(node) as papi_exec: papi_exec.add(cmd, **args).get_replies(err_msg).\ verify_reply(err_msg=err_msg)
def assign_interface_to_fib_table(node, interface, table_id, ipv6=False): """Assign VPP interface to specific VRF/FIB table. :param node: VPP node where the FIB and interface are located. :param interface: Interface to be assigned to FIB. :param table_id: VRF table ID. :param ipv6: Assign to IPv6 table. Default False. :type node: dict :type interface: str or int :type table_id: int :type ipv6: bool """ if isinstance(interface, basestring): sw_if_index = Topology.get_interface_sw_index(node, interface) else: sw_if_index = interface ipv6 = 'ipv6' if ipv6 else '' with VatTerminal(node) as vat: ret = vat.vat_terminal_exec_cmd_from_template( "set_fib_to_interface.vat", sw_index=sw_if_index, vrf=table_id, ipv6=ipv6) if ret[0]["retval"] != 0: raise RuntimeError( 'Unable to assign interface to FIB node {}.'.format(node))
def add_del_macip_acl_interface(node, interface, action, acl_idx): """Apply/un-apply the MACIP ACL to/from a given interface. :param node: VPP node to set MACIP ACL on. :param interface: Interface name or sw_if_index. :param action: Required action - add or del. :param acl_idx: ACL index to be applied on the interface. :type node: dict :type interface: str or int :type action: str :type acl_idx: str or int :raises RuntimeError: If unable to set MACIP ACL for the interface. """ if isinstance(interface, basestring): sw_if_index = Topology.get_interface_sw_index(node, interface) else: sw_if_index = interface try: with VatTerminal(node, json_param=False) as vat: vat.vat_terminal_exec_cmd_from_template( "acl_plugin/macip_acl_interface_add_del.vat", sw_if_index=sw_if_index, action=action, acl_idx=acl_idx) except RuntimeError: raise RuntimeError("Setting of MACIP ACL index for interface {0} " "failed on node {1}".format( interface, node['host']))
def add_locator(node, interface, locator_set, priority=1, weight=1): """Configure a new LISP locator set. :param node: Honeycomb node. :param interface: An interface on the node. :param locator_set: Name for the new locator set. :param priority: Priority parameter for the locator. :param weight. Weight parameter for the locator. :type node: dict :type interface: str :type locator_set: str :type priority: int :type weight: int :returns: Content of response. :rtype: bytearray """ interface = Topology.convert_interface_reference( node, interface, "name") path = "/lisp-feature-data/locator-sets/locator-set" \ "/{0}".format(locator_set) data = { "locator-set": { "name": locator_set, "interface": { "interface-ref": interface, "priority": priority, "weight": weight } } } return LispKeywords._set_lisp_properties(node, path, data)