X-Git-Url: https://gerrit.fd.io/r/gitweb?p=csit.git;a=blobdiff_plain;f=resources%2Flibraries%2Fpython%2FNATUtil.py;h=a9f760768e115226979986063c1618b6cbb098bf;hp=620e14aea166e12ef7339bdaca8ed5b909605d77;hb=HEAD;hpb=905ab17015b24183770e3b55517482e30904d7f4 diff --git a/resources/libraries/python/NATUtil.py b/resources/libraries/python/NATUtil.py index 620e14aea1..e5f530ab46 100644 --- a/resources/libraries/python/NATUtil.py +++ b/resources/libraries/python/NATUtil.py @@ -1,4 +1,4 @@ -# Copyright (c) 2020 Cisco and/or its affiliates. +# Copyright (c) 2023 Cisco and/or its affiliates. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at: @@ -27,7 +27,7 @@ from resources.libraries.python.PapiExecutor import PapiSocketExecutor class NatConfigFlags(IntEnum): - """Common NAT plugin APIs""" + """NAT plugin configuration flags""" NAT_IS_NONE = 0x00 NAT_IS_TWICE_NAT = 0x01 NAT_IS_SELF_TWICE_NAT = 0x02 @@ -39,6 +39,15 @@ class NatConfigFlags(IntEnum): NAT_IS_EXT_HOST_VALID = 0x80 +class Nat44ConfigFlags(IntEnum): + """NAT44 configuration flags""" + NAT44_IS_ENDPOINT_INDEPENDENT = 0x00 + NAT44_IS_ENDPOINT_DEPENDENT = 0x01 + NAT44_IS_STATIC_MAPPING_ONLY = 0x02 + NAT44_IS_CONNECTION_TRACKING = 0x04 + NAT44_IS_OUT2IN_DPO = 0x08 + + class NatAddrPortAllocAlg(IntEnum): """NAT Address and port assignment algorithms.""" NAT_ALLOC_ALG_DEFAULT = 0 @@ -52,6 +61,48 @@ class NATUtil: def __init__(self): pass + @staticmethod + def enable_nat44_ed_plugin( + node, inside_vrf=0, outside_vrf=0, sessions=0, session_memory=0, + mode=u""): + """Enable NAT44 plugin. + + :param node: DUT node. + :param inside_vrf: Inside VRF ID. + :param outside_vrf: Outside VRF ID. + :param sessions: Maximum number of sessions. + :param session_memory: Session memory size - overwrite auto calculated + hash allocation parameter if non-zero. + :param mode: NAT44 mode. Valid values: + - endpoint-independent + - endpoint-dependent + - static-mapping-only + - connection-tracking + - out2in-dpo + :type node: dict + :type inside_vrf: str or int + :type outside_vrf: str or int + :type sessions: str or int + :type session_memory: str or int + :type mode: str + """ + cmd = u"nat44_ed_plugin_enable_disable" + err_msg = f"Failed to enable NAT44 plugin on the host {node[u'host']}!" + args_in = dict( + enable=True, + inside_vrf=int(inside_vrf), + outside_vrf=int(outside_vrf), + sessions=int(sessions), + session_memory=int(session_memory), + flags=getattr( + Nat44ConfigFlags, + f"NAT44_IS_{mode.replace(u'-', u'_').upper()}" + ).value + ) + + with PapiSocketExecutor(node) as papi_exec: + papi_exec.add(cmd, **args_in).get_reply(err_msg) + @staticmethod def set_nat44_interface(node, interface, flag): """Set inside and outside interfaces for NAT44. @@ -96,6 +147,10 @@ class NATUtil: flag=u"NAT_IS_NONE"): """Set NAT44 address range. + The return value is a callable (zero argument Python function) + which can be used to reset NAT state, so repeated trial measurements + hit the same slow path. + :param node: DUT node. :param start_ip: IP range start. :param end_ip: IP range end. @@ -106,6 +161,8 @@ class NATUtil: :type end_ip: str :type vrf_id: int :type flag: str + :returns: Resetter of the NAT state. + :rtype: Callable[[], None] """ cmd = u"nat44_add_del_address_range" err_msg = f"Failed to set NAT44 address range on host {node[u'host']}" @@ -120,20 +177,31 @@ class NATUtil: with PapiSocketExecutor(node) as papi_exec: papi_exec.add(cmd, **args_in).get_reply(err_msg) + # A closure, accessing the variables above. + def resetter(): + """Delete and re-add the NAT range setting.""" + with PapiSocketExecutor(node) as papi_exec: + args_in[u"is_add"] = False + papi_exec.add(cmd, **args_in).get_reply(err_msg) + args_in[u"is_add"] = True + papi_exec.add(cmd, **args_in).get_reply(err_msg) + + return resetter + @staticmethod - def show_nat_config(node): - """Show the NAT configuration. + def show_nat44_config(node): + """Show the NAT44 plugin running configuration. :param node: DUT node. :type node: dict """ - cmd = u"nat_show_config" - err_msg = f"Failed to get NAT configuration on host {node[u'host']}" + cmd = u"nat44_show_running_config" + err_msg = f"Failed to get NAT44 configuration on host {node[u'host']}" with PapiSocketExecutor(node) as papi_exec: reply = papi_exec.add(cmd).get_reply(err_msg) - logger.debug(f"NAT Configuration:\n{pformat(reply)}") + logger.debug(f"NAT44 Configuration:\n{pformat(reply)}") @staticmethod def show_nat44_summary(node): @@ -200,32 +268,78 @@ class NATUtil: :returns: Value of max_translations_per_thread NAT44 parameter. :rtype: int """ + # vpp-device tests have not dedicated physical core so + # ${dp_count_int} == 0 but we need to use one thread + threads = 1 if not int(threads) else int(threads) rest, mult = modf(log2(sessions/(10*threads))) return 2 ** (int(mult) + (1 if rest else 0)) * 10 @staticmethod def get_nat44_sessions_number(node, proto): - """Get number of established NAT44 sessions from actual NAT44 mapping - data. + """Get number of expected NAT44 sessions from NAT44 mapping data. + + This keyword uses output from a CLI command, + so it can start failing when VPP changes the output format. + TODO: Switch to API (or stat segment) when available. + + The current implementation supports both 2202 and post-2202 format. + (The Gerrit number changing the output format is 34877.) + + For TCP proto, the expected state after rampup is + some number of sessions in transitory state (VPP has seen the FINs), + and some number of sessions in established state (meaning + some FINs were lost in the last trial). + While the two states may need slightly different number of cycles + to process next packet, the current implementation considers + both of them the "fast path", so they are both counted as expected. + + As the tests should fail if a session is timed-out, + the logic substracts timed out sessions for the returned value + (only available for post-2202 format). + + TODO: Investigate if it is worth to insert additional rampup trials + in TPUT tests to ensure all sessions are transitory before next + measurement. :param node: DUT node. :param proto: Required protocol - TCP/UDP/ICMP. :type node: dict :type proto: str - :returns: Number of established NAT44 sessions. + :returns: Number of active established NAT44 sessions. :rtype: int :raises ValueError: If not supported protocol. + :raises RuntimeError: If output is not formatted as expected. """ - nat44_data = dict() - if proto in [u"UDP", u"TCP", u"ICMP"]: - for line in NATUtil.show_nat44_summary(node).splitlines(): - sum_k, sum_v = line.split(u":") if u":" in line \ - else (line, None) - nat44_data[sum_k] = sum_v.strip() if isinstance(sum_v, str) \ - else sum_v - else: + proto_l = proto.strip().lower() + if proto_l not in [u"udp", u"tcp", u"icmp"]: raise ValueError(f"Unsupported protocol: {proto}!") - return nat44_data.get(f"total {proto.lower()} sessions", 0) + summary_text = NATUtil.show_nat44_summary(node) + summary_lines = summary_text.splitlines() + # Output from VPP v22.02 and before, delete when no longer needed. + pattern_2202 = f"total {proto_l} sessions:" + if pattern_2202 in summary_text: + for line in summary_lines: + if pattern_2202 not in line: + continue + return int(line.split(u":", 1)[1].strip()) + # Post-2202, the proto info and session info are not on the same line. + found = False + for line in summary_lines: + if not found: + if f"{proto_l} sessions:" in line: + found = True + continue + # Proto is found, find the line we are interested in. + if u"total" not in line: + raise RuntimeError(f"show nat summary: no {proto} total.") + # We have the line with relevant numbers. + total_part, timed_out_part = line.split(u"(", 1) + timed_out_part = timed_out_part.split(u")", 1)[0] + total_count = int(total_part.split(u":", 1)[1].strip()) + timed_out_count = int(timed_out_part.split(u":", 1)[1].strip()) + active_count = total_count - timed_out_count + return active_count + raise RuntimeError(u"Unknown format of show nat44 summary") # DET44 PAPI calls # DET44 means deterministic mode of NAT44 @@ -279,6 +393,10 @@ class NATUtil: def set_det44_mapping(node, ip_in, subnet_in, ip_out, subnet_out): """Set DET44 mapping. + The return value is a callable (zero argument Python function) + which can be used to reset NAT state, so repeated trial measurements + hit the same slow path. + :param node: DUT node. :param ip_in: Inside IP. :param subnet_in: Inside IP subnet. @@ -303,6 +421,17 @@ class NATUtil: with PapiSocketExecutor(node) as papi_exec: papi_exec.add(cmd, **args_in).get_reply(err_msg) + # A closure, accessing the variables above. + def resetter(): + """Delete and re-add the deterministic NAT mapping.""" + with PapiSocketExecutor(node) as papi_exec: + args_in[u"is_add"] = False + papi_exec.add(cmd, **args_in).get_reply(err_msg) + args_in[u"is_add"] = True + papi_exec.add(cmd, **args_in).get_reply(err_msg) + + return resetter + @staticmethod def get_det44_mapping(node): """Get DET44 mapping data. @@ -325,14 +454,12 @@ class NATUtil: def get_det44_sessions_number(node): """Get number of established DET44 sessions from actual DET44 mapping data. - :param node: DUT node. :type node: dict :returns: Number of established DET44 sessions. :rtype: int """ det44_data = NATUtil.get_det44_mapping(node) - return det44_data.get(u"ses_num", 0) @staticmethod