def vpp_get_ip_table(node): """Get IPv4 FIB table on a VPP node. :param node: VPP node. :type node: dict """ PapiSocketExecutor.run_cli_cmd(node, u"show ip fib")
def set_hoststack_quic_crypto_engine(node, quic_crypto_engine, fail_on_error=False): """Set the Hoststack QUIC crypto engine on node :param node: Node to enable/disable HostStack. :param quic_crypto_engine: type of crypto engine :type node: dict :type quic_crypto_engine: str """ vpp_crypto_engines = {u"openssl", u"native", u"ipsecmb"} if quic_crypto_engine == u"nocrypto": logger.trace(u"No QUIC crypto engine.") return if quic_crypto_engine in vpp_crypto_engines: cmds = [u"quic set crypto api vpp", f"set crypto handler aes-128-gcm {quic_crypto_engine}", f"set crypto handler aes-256-gcm {quic_crypto_engine}"] elif quic_crypto_engine == u"picotls": cmds = [u"quic set crypto api picotls"] else: raise ValueError(f"Unknown QUIC crypto_engine {quic_crypto_engine}") for cmd in cmds: try: PapiSocketExecutor.run_cli_cmd(node, cmd) except AssertionError: if fail_on_error: raise
def show_log(node): """Show logging on the specified topology node. :param node: Topology node. :type node: dict """ PapiSocketExecutor.run_cli_cmd(node, u"show logging")
def set_hoststack_quic_fifo_size(node, fifo_size): """Set the QUIC protocol fifo size. :param node: Node to set the QUIC fifo size on. :param fifo_size: fifo size, passed to the quic set fifo-size command. :type node: dict :type fifo_size: str """ cmd = f"quic set fifo-size {fifo_size}" PapiSocketExecutor.run_cli_cmd(node, cmd)
def start_vpp_http_server_params(cls, node, http_static_plugin, prealloc_fifos, fifo_size, private_segment_size): """Start the test HTTP server internal application or the HTTP static server plugin internal applicatoin on the given node. http static server www-root <www-root-dir> prealloc-fifos <N> fifo-size <size in kB> private-segment-size <seg_size expressed as number + unit, e.g. 100m> -- or -- test http server static prealloc-fifos <N> fifo-size <size in kB> private-segment-size <seg_size expressed as number + unit, e.g. 100m> Where N is the max number of connections you expect to handle at one time and <size> should be small if you test for CPS and exchange few bytes, say 4, if each connection just exchanges few packets. Or it should be much larger, up to 1024/4096 (i.e. 1-4MB) if you have only one connection and exchange a lot of packets, i.e., when you test for RPS. If you need to allocate lots of FIFOs, so you test for CPS, make private-segment-size something like 4g. Example: For CPS http static server www-root <www-root-dir> prealloc-fifos 10000 fifo-size 64 private-segment-size 4000m For RPS test http server static prealloc-fifos 500000 fifo-size 4 private-segment-size 4000m :param node: Node to start HTTP server on. :param http_static_plugin: Run HTTP static server plugin :param prealloc_fifos: Max number of connections you expect to handle at one time. :param fifo_size: FIFO size in kB. :param private_segment_size: Private segment size. Number + unit. :type node: dict :type http_static_plugin: boolean :type prealloc_fifos: str :type fifo_size: str :type private_segment_size: str """ cmd = f"http static server www-root {cls.www_root_dir} " \ f"prealloc-fifos {prealloc_fifos} fifo-size {fifo_size} " \ f"private-segment-size {private_segment_size}" \ if http_static_plugin \ else f"test http server static prealloc-fifos {prealloc_fifos} " \ f"fifo-size {fifo_size} private-segment-size {private_segment_size}" PapiSocketExecutor.run_cli_cmd(node, cmd)
def vpp_get_ip_tables_prefix(node, address): """Get dump of all IP FIB tables on a VPP node. :param node: VPP node. :param address: IP address. :type node: dict :type address: str """ addr = ip_address(address) ip_ver = u"ip6" if addr.version == 6 else u"ip" PapiSocketExecutor.run_cli_cmd( node, f"show {ip_ver} fib {addr}/{addr.max_prefixlen}")
def log_vpp_hoststack_data(node): """Retrieve and log VPP HostStack data. :param node: DUT node. :type node: dict :raises RuntimeError: If node subtype is not a DUT or startup failed. """ if node[u"type"] != u"DUT": raise RuntimeError(u"Node type is not a DUT!") PapiSocketExecutor.run_cli_cmd(node, u"show error") PapiSocketExecutor.run_cli_cmd(node, u"show interface")
def vpp_get_ip_tables(node): """Get dump of all IP FIB tables on a VPP node. :param node: VPP node. :type node: dict """ PapiSocketExecutor.run_cli_cmd(node, u"show ip fib") PapiSocketExecutor.run_cli_cmd(node, u"show ip fib summary") PapiSocketExecutor.run_cli_cmd(node, u"show ip6 fib") PapiSocketExecutor.run_cli_cmd(node, u"show ip6 fib summary")
def show_nat44_summary(node): """Show NAT44 summary on the specified topology node. :param node: Topology node. :type node: dict :returns: NAT44 summary data. :rtype: str """ return PapiSocketExecutor.run_cli_cmd(node, u"show nat44 summary")
def show_classify_tables_verbose(node): """Show classify tables verbose. :param node: Topology node. :type node: dict :returns: Classify tables verbose data. :rtype: str """ return PapiSocketExecutor.run_cli_cmd(node, u"show classify tables verbose")
def configure_sr_localsid(node, local_sid, behavior, interface=None, next_hop=None, fib_table=None, out_if=None, in_if=None, src_addr=None, sid_list=None): """Create SRv6 LocalSID and binds it to a particular behaviour on the given node. :param node: Given node to create localSID on. :param local_sid: LocalSID IPv6 address. :param behavior: SRv6 LocalSID function. :param interface: Interface name (Optional, required for L2/L3 xconnects). :param next_hop: Next hop IPv4/IPv6 address (Optional, required for L3 xconnects). :param fib_table: FIB table for IPv4/IPv6 lookup (Optional, required for L3 routing). :param out_if: Interface name of local interface for sending traffic towards the Service Function (Optional, required for SRv6 endpoint to SR-unaware appliance). :param in_if: Interface name of local interface receiving the traffic coming back from the Service Function (Optional, required for SRv6 endpoint to SR-unaware appliance). :param src_addr: Source address on the packets coming back on in_if interface (Optional, required for SRv6 endpoint to SR-unaware appliance via static proxy). :param sid_list: SID list (Optional, required for SRv6 endpoint to SR-unaware appliance via static proxy). :type node: dict :type local_sid: str :type behavior: str :type interface: str :type next_hop: str :type fib_table: str :type out_if: str :type in_if: str :type src_addr: str :type sid_list: list :raises ValueError: If required parameter is missing. """ beh = behavior.replace(u".", u"_").upper() # There is no SRv6Behaviour enum defined for functions from SRv6 plugins # so we need to use CLI command to configure it. if beh in (getattr(SRv6Behavior, u"END_AD").name, getattr(SRv6Behavior, u"END_AS").name, getattr(SRv6Behavior, u"END_AM").name): if beh == getattr(SRv6Behavior, u"END_AS").name: if next_hop is None or out_if is None or in_if is None or \ src_addr is None or sid_list is None: raise ValueError(f"Required parameter(s) missing.\n" f"next_hop:{next_hop}\n " f"out_if:{out_if}\n" f"in_if:{in_if}\n" f"src_addr:{src_addr}\n" f"sid_list:{sid_list}") sid_conf = f"next {u' next '.join(sid_list)}" params = f"nh {next_hop} oif {out_if} iif {in_if} " \ f"src {src_addr} {sid_conf}" else: if next_hop is None or out_if is None or in_if is None: raise ValueError(f"Required parameter(s) missing.\n" f"next_hop:{next_hop}\n" f"out_if:{out_if}\n" f"in_if:{in_if}") params = f"nh {next_hop} oif {out_if} iif {in_if}" cli_cmd = f"sr localsid address {local_sid} behavior {behavior} " \ f"{params}" PapiSocketExecutor.run_cli_cmd(node, cli_cmd) return cmd = u"sr_localsid_add_del" args = dict(is_del=False, localsid=IPv6Address(local_sid).packed, end_psp=False, behavior=getattr(SRv6Behavior, beh).value, sw_if_index=Constants.BITWISE_NON_ZERO, vlan_index=0, fib_table=0, nh_addr=0) err_msg = f"Failed to add SR localSID {local_sid} " \ f"host {node[u'host']}" if beh in (getattr(SRv6Behavior, u"END_X").name, getattr(SRv6Behavior, u"END_DX4").name, getattr(SRv6Behavior, u"END_DX6").name): if interface is None or next_hop is None: raise ValueError(f"Required parameter(s) missing.\n" f"interface:{interface}\n" f"next_hop:{next_hop}") args[u"sw_if_index"] = InterfaceUtil.get_interface_index( node, interface) args[u"nh_addr"] = IPAddress.create_ip_address_object( ip_address(next_hop)) elif beh == getattr(SRv6Behavior, u"END_DX2").name: if interface is None: raise ValueError( f"Required parameter missing.\ninterface: {interface}") args[u"sw_if_index"] = InterfaceUtil.get_interface_index( node, interface) elif beh in (getattr(SRv6Behavior, u"END_DT4").name, getattr(SRv6Behavior, u"END_DT6").name): if fib_table is None: raise ValueError(f"Required parameter missing.\n" f"fib_table: {fib_table}") args[u"fib_table"] = fib_table with PapiSocketExecutor(node) as papi_exec: papi_exec.add(cmd, **args).get_reply(err_msg)