diff --git a/ansible/roles/test/files/ptftests/inner_hash_test.py b/ansible/roles/test/files/ptftests/inner_hash_test.py index c2731ad0679..5186eee5d33 100644 --- a/ansible/roles/test/files/ptftests/inner_hash_test.py +++ b/ansible/roles/test/files/ptftests/inner_hash_test.py @@ -79,7 +79,6 @@ def setUp(self): self.vxlan_port = self.test_params['vxlan_port'] self.outer_encap_formats = self.test_params['outer_encap_formats'] self.symmetric_hashing = self.test_params.get('symmetric_hashing', False) - self.nvgre_tni = self.test_params.get('nvgre_tni', '') self.outer_dst_ip = self.outer_dst_ip_interval.get_first_ip() self.next_hop = self.fib[self.outer_dst_ip] @@ -227,7 +226,6 @@ def check_ipv4_route_nvgre(self, hash_key, src_port, ip_dst, ip_src, dport, spor outer_ip_src = self.outer_src_ip_interval.get_random_ip() if hash_key == 'outer-tuples' else self.outer_src_ip_interval.get_first_ip() outer_ip_dst = self.outer_dst_ip_interval.get_random_ip() if hash_key == 'outer-tuples' else self.outer_dst_ip_interval.get_first_ip() - nvgre_tni = self.nvgre_tni if self.nvgre_tni else random.randint(1, 254) + 20000 pkt = self.generate_inner_pkt(sport, dport, ip_src, ip_dst, ip_proto) nvgre_pkt = simple_nvgre_packet( @@ -237,9 +235,8 @@ def check_ipv4_route_nvgre(self, hash_key, src_port, ip_dst, ip_src, dport, spor ip_src=outer_ip_src, ip_dst=outer_ip_dst, ip_ttl=64, - inner_frame=pkt, - nvgre_tni=nvgre_tni, - nvgre_flowid=0) + nvgre_tni=random.randint(1, 254)+20000, + inner_frame=pkt) logging.info("Sending packet from port {} outer_ip_src {} outer_ip_dst {} inner_src_ip {} inner_dst_ip {} inner_sport {} inner_dport {} inner_ipproto {}"\ .format(src_port, outer_ip_src, outer_ip_dst, ip_src, ip_dst, sport, dport, ip_proto)) @@ -319,7 +316,6 @@ def check_ipv6_route_nvgre(self, hash_key, src_port, ip_dst, ip_src, dport, spor outer_ip_src = self.outer_src_ip_interval.get_random_ip() if hash_key == 'outer-tuples' else self.outer_src_ip_interval.get_first_ip() outer_ip_dst = self.outer_dst_ip_interval.get_random_ip() if hash_key == 'outer-tuples' else self.outer_dst_ip_interval.get_first_ip() - nvgre_tni = self.nvgre_tni if self.nvgre_tni else random.randint(1, 254) + 20000 pkt = self.generate_inner_pkt(sport, dport, ip_src, ip_dst, ip_proto) nvgre_pkt = self.simple_nvgrev6_packet( @@ -327,9 +323,8 @@ def check_ipv6_route_nvgre(self, hash_key, src_port, ip_dst, ip_src, dport, spor eth_src=src_mac, ipv6_src=outer_ip_src, ipv6_dst=outer_ip_dst, - inner_frame=pkt, - nvgre_tni=nvgre_tni, - nvgre_flowid=0) + nvgre_tni=random.randint(1, 254)+20000, + inner_frame=pkt) logging.info("Sending packet from port {} outer_ip_src {} outer_ip_dst {} inner_src_ip {} inner_dst_ip {} inner_sport {} inner_dport {} inner_ipproto {}"\ .format(src_port, outer_ip_src, outer_ip_dst, ip_src, ip_dst, sport, dport, ip_proto)) diff --git a/tests/ecmp/inner_hashing/conftest.py b/tests/ecmp/inner_hashing/conftest.py index 3325dce8935..bbba04d1cb3 100644 --- a/tests/ecmp/inner_hashing/conftest.py +++ b/tests/ecmp/inner_hashing/conftest.py @@ -3,7 +3,6 @@ import logging import tempfile import re -import allure from datetime import datetime @@ -29,7 +28,6 @@ VXLAN_PORT = 13330 DUT_VXLAN_PORT_JSON_FILE = '/tmp/vxlan.switch.json' -T0_VLAN = "1000" IP_VERSIONS_LIST = ["ipv4", "ipv6"] OUTER_ENCAP_FORMATS = ["vxlan", "nvgre"] TABLE_NAME = "pbh_table" @@ -44,16 +42,10 @@ V6_ETHER_TYPE = "0x86dd" VXLAN_IP_PROTOCOL = "0x11" NVGRE_IP_PROTOCOL = "0x2f" -GRE_KEY = "0x2500" -NVGRE_TNI = 0x25 -GRE_MASK = "0xffffff00" VXLAN_L4_DST_PORT = "0x3412" VXLAN_L4_DST_PORT_OPTION = " --l4-dst-port {}".format(VXLAN_L4_DST_PORT) -NVGRE_GRE_KEY_OPTION = " --gre-key {}/{}".format(GRE_KEY, GRE_MASK) ADD_PBH_TABLE_CMD = "sudo config pbh table add '{}' --interface-list '{}' --description '{}'" DEL_PBH_TABLE_CMD = "sudo config pbh table delete '{}'" -ADD_PBH_RULE_BASE_CMD = "sudo config pbh rule add '{}' '{}' --priority '{}' --ether-type {}" \ - " --inner-ether-type '{}' --hash '{}' --packet-action '{}' --flow-counter 'ENABLED'" ADD_PBH_RULE_BASE_CMD = "sudo config pbh rule add '{}' '{}' --priority '{}' --ether-type {}" \ " --inner-ether-type '{}' --hash '{}' --packet-action '{}' --flow-counter 'ENABLED'" DEL_PBH_RULE_CMD = "sudo config pbh rule delete '{}' '{}'" @@ -189,59 +181,6 @@ def vlan_ptf_ports(config_facts, tbinfo, duthost): return ports -@pytest.fixture(scope='module') -def lag_port_map(duthost, config_facts, vlan_ptf_ports, tbinfo): - ''' - Create lag-port map for vlan ptf ports - ''' - portchannels = config_facts.get('PORTCHANNEL', {}).keys() - mg_facts = duthost.get_extended_minigraph_facts(tbinfo) - port_list_idx = 0 - lag_port_map = {} - port_key_list = list(mg_facts['minigraph_ptf_indices'].keys()) - port_val_list = list(mg_facts['minigraph_ptf_indices'].values()) - - for portchannel_idx in range(1, 10000): # Max len of PortChannel index can be '9999' - lag_port = 'PortChannel{}'.format(portchannel_idx) - - if lag_port not in portchannels: - port_idx_value = vlan_ptf_ports[port_list_idx] - position = port_val_list.index(port_idx_value) - port_name = port_key_list[position] - lag_port_map[lag_port] = port_name - port_list_idx += 1 - - if len(lag_port_map) == len(vlan_ptf_ports): - break - - return lag_port_map - - -@pytest.fixture(scope='module') -def lag_ip_map(lag_port_map): - index = 1 - base_ipv4_addr = '100.0.{}.1/31' - base_ipv6_addr = 'fc00:{}::1/126' - lag_ip_map = {} - - for lag_port, _ in lag_port_map.items(): - ipv4_addr = base_ipv4_addr.format(index) - ipv6_addr = base_ipv6_addr.format(index) - lag_ip_map[lag_port] = {'ipv4': ipv4_addr, 'ipv6': ipv6_addr} - index += 1 - - return lag_ip_map - - -@pytest.fixture(scope='module') -def config_lag_ports(duthost, lag_port_map, lag_ip_map): - add_lag_config(duthost, lag_port_map, lag_ip_map) - - yield - - remove_lag_config(duthost, lag_port_map, lag_ip_map) - - @pytest.fixture(scope='module') def router_mac(duthosts, rand_one_dut_hostname): duthost = duthosts[rand_one_dut_hostname] @@ -275,23 +214,8 @@ def inner_ipver(request): return request.param -@pytest.fixture(scope="module") -def config_pbh_table_lag(duthost, lag_port_map): - logging.info("Create PBH table: {}".format(TABLE_NAME)) - test_intfs_str = ",".join(lag_port_map.keys()) - - duthost.command(ADD_PBH_TABLE_CMD.format(TABLE_NAME, - test_intfs_str, - TABLE_DESCRIPTION)) - - yield - - duthost.command(DEL_PBH_TABLE_CMD.format(TABLE_NAME)) - - @pytest.fixture(scope="module") def config_pbh_table(duthost, vlan_ptf_ports, tbinfo): - logging.info("Create PBH table: {}".format(TABLE_NAME)) test_intfs_str = get_dut_test_intfs_str(duthost, vlan_ptf_ports, tbinfo) duthost.command(ADD_PBH_TABLE_CMD.format(TABLE_NAME, @@ -315,7 +239,6 @@ def get_dut_test_intfs_str(duthost, vlan_ptf_ports, tbinfo): @pytest.fixture(scope="module") def config_hash_fields(duthost): - logging.info("Create PBH hash-fields") for hash_field, hash_field_params_dict in HASH_FIELD_CONFIG.items(): cmd = get_hash_field_add_cmd(hash_field, hash_field_params_dict) duthost.command(cmd) @@ -337,7 +260,6 @@ def get_hash_field_add_cmd(hash_field_name, hash_field_params_dict): @pytest.fixture(scope="module") def config_hash(duthost): - logging.info("Create PBH hash: {}".format(HASH_NAME)) duthost.command(ADD_PBH_HASH_CMD.format(HASH_NAME, PBH_HASH_FIELD_LIST)) yield @@ -369,7 +291,6 @@ def config_ipv6_rules(duthost, inner_ipver): def config_vxlan_rule(duthost, ip_ver_option, ether_type, outer_ipver, inner_ipver): - logging.info("Create PBH rule: {}".format(VXLAN_RULE_NAME.format(outer_ipver, inner_ipver))) inner_ether_type = V4_ETHER_TYPE if inner_ipver == "ipv4" else V6_ETHER_TYPE duthost.command((ADD_PBH_RULE_BASE_CMD + ip_ver_option + VXLAN_L4_DST_PORT_OPTION) .format(TABLE_NAME, @@ -384,9 +305,8 @@ def config_vxlan_rule(duthost, ip_ver_option, ether_type, outer_ipver, inner_ipv def config_nvgre_rule(duthost, ip_ver_option, ether_type, outer_ipver, inner_ipver): - logging.info("Create PBH rule: {}".format(NVGRE_RULE_NAME.format(outer_ipver, inner_ipver))) inner_ether_type = V4_ETHER_TYPE if inner_ipver == "ipv4" else V6_ETHER_TYPE - duthost.command((ADD_PBH_RULE_BASE_CMD + ip_ver_option + NVGRE_GRE_KEY_OPTION) + duthost.command((ADD_PBH_RULE_BASE_CMD + ip_ver_option) .format(TABLE_NAME, NVGRE_RULE_NAME.format(outer_ipver, inner_ipver), NVGRE_RULE_PRIO, @@ -421,40 +341,16 @@ def get_src_dst_ip_range(ipver): def check_pbh_counters(duthost, outer_ipver, inner_ipver, balancing_test_times, symmetric_hashing, hash_keys): - logging.info('Verify PBH counters') - with allure.step('Verify PBH counters'): - symmetric_multiplier = 2 if symmetric_hashing else 1 - exp_port_multiplier = 4 # num of POs in t0 topology - hash_keys_multiplier = len(hash_keys) - # for hash key "ip-proto", the traffic sends always in one way - exp_count = str((balancing_test_times * symmetric_multiplier * exp_port_multiplier * (hash_keys_multiplier-1)) - + (balancing_test_times * exp_port_multiplier)) - pbh_statistic_output = duthost.shell("show pbh statistic")['stdout'] - for outer_encap_format in OUTER_ENCAP_FORMATS: - regex = r'{}\s+{}_{}_{}\s+(\d+)\s+\d+'.format(TABLE_NAME, outer_encap_format, outer_ipver, inner_ipver) - current_count = re.search(regex, pbh_statistic_output).group(1) - assert current_count == exp_count,\ - "PBH counters are different from expected for {}, outer ipver {}, inner ipver {}. Expected: {}, " \ - "Current: {}".format(outer_encap_format, outer_ipver, inner_ipver, exp_count, current_count) - - -def add_lag_config(duthost, lag_port_map, lag_ip_map): - logging.info('Add LAG configuration') - with allure.step('Add LAG configuration'): - for lag_port, port_name in lag_port_map.items(): - duthost.shell('sudo config vlan member del {} {}'.format(T0_VLAN, port_name)) - duthost.shell('sudo config portchannel add {} --fallback enable'.format(lag_port)) - duthost.shell('sudo config portchannel member add {} {}'.format(lag_port, port_name)) - duthost.shell('config interface ip add {} {}'.format(lag_port, lag_ip_map[lag_port]['ipv4'])) - duthost.shell('config interface ip add {} {}'.format(lag_port, lag_ip_map[lag_port]['ipv6'])) - - -def remove_lag_config(duthost, lag_port_map, lag_ip_map): - logging.info('Remove LAG configuration') - with allure.step('Remove LAG configuration'): - for lag_port, port_name in lag_port_map.items(): - duthost.shell('config interface ip remove {} {}'.format(lag_port, lag_ip_map[lag_port]['ipv4'])) - duthost.shell('config interface ip remove {} {}'.format(lag_port, lag_ip_map[lag_port]['ipv6'])) - duthost.shell('sudo config portchannel member del {} {}'.format(lag_port, port_name)) - duthost.shell('sudo config portchannel del {}'.format(lag_port)) - duthost.shell('sudo config vlan member add {} {} --untagged'.format(T0_VLAN, port_name)) + symmetric_multiplier = 2 if symmetric_hashing else 1 + exp_port_multiplier = 4 # num of POs in t0 topology + hash_keys_multiplier = len(hash_keys) + # for hash key "ip-proto", the traffic sends always in one way + exp_count = str((balancing_test_times * symmetric_multiplier * exp_port_multiplier * (hash_keys_multiplier-1)) + + (balancing_test_times * exp_port_multiplier)) + pbh_statistic_output = duthost.shell("show pbh statistic")['stdout'] + for outer_encap_format in OUTER_ENCAP_FORMATS: + regex = r'{}\s+{}_{}_{}\s+(\d+)\s+\d+'.format(TABLE_NAME, outer_encap_format, outer_ipver, inner_ipver) + current_count = re.search(regex, pbh_statistic_output).group(1) + assert current_count == exp_count,\ + "PBH counters are different from expected for {}, outer ipver {}, inner ipver {}. Expected: {}, " \ + "Current: {}".format(outer_encap_format, outer_ipver, inner_ipver, exp_count, current_count) diff --git a/tests/ecmp/inner_hashing/test_inner_hashing.py b/tests/ecmp/inner_hashing/test_inner_hashing.py index 6a025007fd7..4458c1e64c3 100644 --- a/tests/ecmp/inner_hashing/test_inner_hashing.py +++ b/tests/ecmp/inner_hashing/test_inner_hashing.py @@ -4,13 +4,12 @@ import logging import pytest -import allure from datetime import datetime from retry.api import retry_call from tests.ptf_runner import ptf_runner from tests.ecmp.inner_hashing.conftest import get_src_dst_ip_range, FIB_INFO_FILE_DST,\ - VXLAN_PORT, PTF_QLEN, check_pbh_counters, OUTER_ENCAP_FORMATS, NVGRE_TNI + VXLAN_PORT, PTF_QLEN, check_pbh_counters, OUTER_ENCAP_FORMATS logger = logging.getLogger(__name__) @@ -25,47 +24,44 @@ class TestDynamicInnerHashing(): @pytest.fixture(scope="class", autouse=True) def setup_dynamic_pbh(self, request): - with allure.step('Config Dynamic PBH'): - request.getfixturevalue("config_pbh_table") - request.getfixturevalue("config_hash_fields") - request.getfixturevalue("config_hash") - request.getfixturevalue("config_rules") + request.getfixturevalue("config_pbh_table") + request.getfixturevalue("config_hash_fields") + request.getfixturevalue("config_hash") + request.getfixturevalue("config_rules") def test_inner_hashing(self, hash_keys, ptfhost, outer_ipver, inner_ipver, router_mac, vlan_ptf_ports, symmetric_hashing, duthost): logging.info("Executing dynamic inner hash test for outer {} and inner {} with symmetric_hashing set to {}" .format(outer_ipver, inner_ipver, str(symmetric_hashing))) - with allure.step('Run ptf test InnerHashTest'): - timestamp = datetime.now().strftime('%Y-%m-%d-%H:%M:%S') - log_file = "/tmp/inner_hash_test.DynamicInnerHashTest.{}.{}.{}.log".format(outer_ipver, inner_ipver, timestamp) - logging.info("PTF log file: %s" % log_file) - - outer_src_ip_range, outer_dst_ip_range = get_src_dst_ip_range(outer_ipver) - inner_src_ip_range, inner_dst_ip_range = get_src_dst_ip_range(inner_ipver) - - balancing_test_times = 150 - balancing_range = 0.3 - - ptf_runner(ptfhost, - "ptftests", - "inner_hash_test.InnerHashTest", - platform_dir="ptftests", - params={"fib_info": FIB_INFO_FILE_DST, - "router_mac": router_mac, - "src_ports": vlan_ptf_ports, - "hash_keys": hash_keys, - "vxlan_port": VXLAN_PORT, - "inner_src_ip_range": ",".join(inner_src_ip_range), - "inner_dst_ip_range": ",".join(inner_dst_ip_range), - "outer_src_ip_range": ",".join(outer_src_ip_range), - "outer_dst_ip_range": ",".join(outer_dst_ip_range), - "balancing_test_times": balancing_test_times, - "balancing_range": balancing_range, - "outer_encap_formats": OUTER_ENCAP_FORMATS, - "nvgre_tni": NVGRE_TNI, - "symmetric_hashing": symmetric_hashing}, - log_file=log_file, - qlen=PTF_QLEN, - socket_recv_size=16384) + timestamp = datetime.now().strftime('%Y-%m-%d-%H:%M:%S') + log_file = "/tmp/inner_hash_test.DynamicInnerHashTest.{}.{}.{}.log".format(outer_ipver, inner_ipver, timestamp) + logging.info("PTF log file: %s" % log_file) + + outer_src_ip_range, outer_dst_ip_range = get_src_dst_ip_range(outer_ipver) + inner_src_ip_range, inner_dst_ip_range = get_src_dst_ip_range(inner_ipver) + + balancing_test_times = 150 + balancing_range = 0.3 + + ptf_runner(ptfhost, + "ptftests", + "inner_hash_test.InnerHashTest", + platform_dir="ptftests", + params={"fib_info": FIB_INFO_FILE_DST, + "router_mac": router_mac, + "src_ports": vlan_ptf_ports, + "hash_keys": hash_keys, + "vxlan_port": VXLAN_PORT, + "inner_src_ip_range": ",".join(inner_src_ip_range), + "inner_dst_ip_range": ",".join(inner_dst_ip_range), + "outer_src_ip_range": ",".join(outer_src_ip_range), + "outer_dst_ip_range": ",".join(outer_dst_ip_range), + "balancing_test_times": balancing_test_times, + "balancing_range": balancing_range, + "outer_encap_formats": OUTER_ENCAP_FORMATS, + "symmetric_hashing": symmetric_hashing}, + log_file=log_file, + qlen=PTF_QLEN, + socket_recv_size=16384) retry_call(check_pbh_counters, fargs=[duthost, outer_ipver, inner_ipver, balancing_test_times, symmetric_hashing, hash_keys], diff --git a/tests/ecmp/inner_hashing/test_inner_hashing_lag.py b/tests/ecmp/inner_hashing/test_inner_hashing_lag.py deleted file mode 100644 index 16ee37d7488..00000000000 --- a/tests/ecmp/inner_hashing/test_inner_hashing_lag.py +++ /dev/null @@ -1,75 +0,0 @@ -# Summary: Inner packet hashing test -# How to run this test: sudo ./run_tests.sh -n -i -u -m group -e --skip_sanity -l info -c ecmp/test_inner_hashing.py --static_config -# parameter "--static_config" used when already exists hashing configurations and will be executed suitable test - -import logging -import pytest -import allure - -from datetime import datetime -from retry.api import retry_call -from tests.ptf_runner import ptf_runner -from tests.ecmp.inner_hashing.conftest import get_src_dst_ip_range, FIB_INFO_FILE_DST,\ - VXLAN_PORT, PTF_QLEN, check_pbh_counters, OUTER_ENCAP_FORMATS, NVGRE_TNI - -logger = logging.getLogger(__name__) - -pytestmark = [ - pytest.mark.topology('t0'), - pytest.mark.asic('mellanox') -] - - -@pytest.mark.dynamic_config -class TestDynamicInnerHashingLag(): - - @pytest.fixture(scope="class", autouse=True) - def setup_dynamic_pbh(self, request): - with allure.step('Add required LAG config'): - request.getfixturevalue("config_lag_ports") - with allure.step('Config Dynamic PBH'): - request.getfixturevalue("config_pbh_table_lag") - request.getfixturevalue("config_hash_fields") - request.getfixturevalue("config_hash") - request.getfixturevalue("config_rules") - - def test_inner_hashing(self, hash_keys, ptfhost, outer_ipver, inner_ipver, router_mac, vlan_ptf_ports, symmetric_hashing, duthost): - logging.info("Executing dynamic inner hash test for outer {} and inner {} with symmetric_hashing set to {}" - .format(outer_ipver, inner_ipver, str(symmetric_hashing))) - with allure.step('Run ptf test InnerHashTest'): - timestamp = datetime.now().strftime('%Y-%m-%d-%H:%M:%S') - log_file = "/tmp/inner_hash_test.DynamicInnerHashTest.{}.{}.{}.log".format(outer_ipver, inner_ipver, timestamp) - logging.info("PTF log file: %s" % log_file) - - outer_src_ip_range, outer_dst_ip_range = get_src_dst_ip_range(outer_ipver) - inner_src_ip_range, inner_dst_ip_range = get_src_dst_ip_range(inner_ipver) - - balancing_test_times = 150 - balancing_range = 0.3 - - ptf_runner(ptfhost, - "ptftests", - "inner_hash_test.InnerHashTest", - platform_dir="ptftests", - params={"fib_info": FIB_INFO_FILE_DST, - "router_mac": router_mac, - "src_ports": vlan_ptf_ports, - "hash_keys": hash_keys, - "vxlan_port": VXLAN_PORT, - "inner_src_ip_range": ",".join(inner_src_ip_range), - "inner_dst_ip_range": ",".join(inner_dst_ip_range), - "outer_src_ip_range": ",".join(outer_src_ip_range), - "outer_dst_ip_range": ",".join(outer_dst_ip_range), - "balancing_test_times": balancing_test_times, - "balancing_range": balancing_range, - "outer_encap_formats": OUTER_ENCAP_FORMATS, - "nvgre_tni": NVGRE_TNI, - "symmetric_hashing": symmetric_hashing}, - log_file=log_file, - qlen=PTF_QLEN, - socket_recv_size=16384) - - retry_call(check_pbh_counters, - fargs=[duthost, outer_ipver, inner_ipver, balancing_test_times, symmetric_hashing, hash_keys], - tries=5, - delay=5) diff --git a/tests/ecmp/inner_hashing/test_wr_inner_hashing.py b/tests/ecmp/inner_hashing/test_wr_inner_hashing.py index 93c5cbd391c..090fbc50275 100644 --- a/tests/ecmp/inner_hashing/test_wr_inner_hashing.py +++ b/tests/ecmp/inner_hashing/test_wr_inner_hashing.py @@ -2,12 +2,11 @@ import threading import pytest import random -import allure from datetime import datetime from tests.common import reboot from tests.ecmp.inner_hashing.conftest import get_src_dst_ip_range, FIB_INFO_FILE_DST, VXLAN_PORT,\ - PTF_QLEN, OUTER_ENCAP_FORMATS, NVGRE_TNI + PTF_QLEN, OUTER_ENCAP_FORMATS from tests.ptf_runner import ptf_runner logger = logging.getLogger(__name__) @@ -18,64 +17,62 @@ ] @pytest.mark.dynamic_config -class TestWRDynamicInnerHashing(): +class TestDynamicInnerHashing(): @pytest.fixture(scope="class", autouse=True) def setup_dynamic_pbh(self, request): - with allure.step('Config Dynamic PBH'): - request.getfixturevalue("config_pbh_table") - request.getfixturevalue("config_hash_fields") - request.getfixturevalue("config_hash") - request.getfixturevalue("config_rules") + request.getfixturevalue("config_pbh_table") + request.getfixturevalue("config_hash_fields") + request.getfixturevalue("config_hash") + request.getfixturevalue("config_rules") def test_inner_hashing(self, duthost, hash_keys, ptfhost, outer_ipver, inner_ipver, router_mac, vlan_ptf_ports, symmetric_hashing, localhost): logging.info("Executing warm boot dynamic inner hash test for outer {} and inner {} with symmetric_hashing" " set to {}".format(outer_ipver, inner_ipver, str(symmetric_hashing))) - with allure.step('Run ptf test InnerHashTest and warm-reboot in parallel'): - timestamp = datetime.now().strftime('%Y-%m-%d-%H:%M:%S') - log_file = "/tmp/wr_inner_hash_test.DynamicInnerHashTest.{}.{}.{}.log".format(outer_ipver, inner_ipver, timestamp) - logging.info("PTF log file: %s" % log_file) - - # to reduce test run time, check one of encapsulation formats - outer_encap_format = random.choice(OUTER_ENCAP_FORMATS).split() - logging.info("Tested encapsulation format: {}".format(outer_encap_format[0])) - - outer_src_ip_range, outer_dst_ip_range = get_src_dst_ip_range(outer_ipver) - inner_src_ip_range, inner_dst_ip_range = get_src_dst_ip_range(inner_ipver) - - balancing_test_times = 200 - balancing_range = 0.3 - - reboot_thr = threading.Thread(target=reboot, args=(duthost, localhost, 'warm',)) - reboot_thr.start() - - ptf_runner(ptfhost, - "ptftests", - "inner_hash_test.InnerHashTest", - platform_dir="ptftests", - params={"fib_info": FIB_INFO_FILE_DST, - "router_mac": router_mac, - "src_ports": vlan_ptf_ports, - "hash_keys": hash_keys, - "vxlan_port": VXLAN_PORT, - "inner_src_ip_range": ",".join(inner_src_ip_range), - "inner_dst_ip_range": ",".join(inner_dst_ip_range), - "outer_src_ip_range": ",".join(outer_src_ip_range), - "outer_dst_ip_range": ",".join(outer_dst_ip_range), - "balancing_test_times": balancing_test_times, - "balancing_range": balancing_range, - "outer_encap_formats": outer_encap_format, - "nvgre_tni": NVGRE_TNI, - "symmetric_hashing": symmetric_hashing}, - log_file=log_file, - qlen=PTF_QLEN, - socket_recv_size=16384) - reboot_thr.join() + timestamp = datetime.now().strftime('%Y-%m-%d-%H:%M:%S') + log_file = "/tmp/wr_inner_hash_test.DynamicInnerHashTest.{}.{}.{}.log".format(outer_ipver, inner_ipver, timestamp) + logging.info("PTF log file: %s" % log_file) + + # to reduce test run time, check one of encapsulation formats + outer_encap_format = random.choice(OUTER_ENCAP_FORMATS).split() + logging.info("Tested encapsulation format: {}".format(outer_encap_format[0])) + + outer_src_ip_range, outer_dst_ip_range = get_src_dst_ip_range(outer_ipver) + inner_src_ip_range, inner_dst_ip_range = get_src_dst_ip_range(inner_ipver) + + balancing_test_times = 200 + balancing_range = 0.3 + + duthost.command('sudo config save -y') + reboot_thr = threading.Thread(target=reboot, args=(duthost, localhost, 'warm',)) + reboot_thr.start() + + ptf_runner(ptfhost, + "ptftests", + "inner_hash_test.InnerHashTest", + platform_dir="ptftests", + params={"fib_info": FIB_INFO_FILE_DST, + "router_mac": router_mac, + "src_ports": vlan_ptf_ports, + "hash_keys": hash_keys, + "vxlan_port": VXLAN_PORT, + "inner_src_ip_range": ",".join(inner_src_ip_range), + "inner_dst_ip_range": ",".join(inner_dst_ip_range), + "outer_src_ip_range": ",".join(outer_src_ip_range), + "outer_dst_ip_range": ",".join(outer_dst_ip_range), + "balancing_test_times": balancing_test_times, + "balancing_range": balancing_range, + "outer_encap_formats": outer_encap_format, + "symmetric_hashing": symmetric_hashing}, + log_file=log_file, + qlen=PTF_QLEN, + socket_recv_size=16384) + reboot_thr.join() @pytest.mark.static_config -class TestWRStaticInnerHashing(): +class TestStaticInnerHashing(): def test_inner_hashing(self, duthost, hash_keys, ptfhost, outer_ipver, inner_ipver, router_mac, vlan_ptf_ports, symmetric_hashing, localhost): @@ -88,6 +85,7 @@ def test_inner_hashing(self, duthost, hash_keys, ptfhost, outer_ipver, inner_ipv outer_src_ip_range, outer_dst_ip_range = get_src_dst_ip_range(outer_ipver) inner_src_ip_range, inner_dst_ip_range = get_src_dst_ip_range(inner_ipver) + duthost.command('sudo config save -y') reboot_thr = threading.Thread(target=reboot, args=(duthost, localhost, 'warm',)) reboot_thr.start() diff --git a/tests/ecmp/inner_hashing/test_wr_inner_hashing_lag.py b/tests/ecmp/inner_hashing/test_wr_inner_hashing_lag.py deleted file mode 100644 index 3883b7a7b4a..00000000000 --- a/tests/ecmp/inner_hashing/test_wr_inner_hashing_lag.py +++ /dev/null @@ -1,75 +0,0 @@ -import logging -import threading -import pytest -import random -import allure - -from datetime import datetime -from tests.common import reboot -from tests.ecmp.inner_hashing.conftest import get_src_dst_ip_range, FIB_INFO_FILE_DST, VXLAN_PORT,\ - PTF_QLEN, OUTER_ENCAP_FORMATS, NVGRE_TNI -from tests.ptf_runner import ptf_runner - -logger = logging.getLogger(__name__) - -pytestmark = [ - pytest.mark.topology('t0'), - pytest.mark.asic('mellanox') -] - -@pytest.mark.dynamic_config -class TestWRDynamicInnerHashingLag(): - - @pytest.fixture(scope="class", autouse=True) - def setup_dynamic_pbh(self, request): - with allure.step('Add required LAG config'): - request.getfixturevalue("config_lag_ports") - with allure.step('Config Dynamic PBH'): - request.getfixturevalue("config_pbh_table_lag") - request.getfixturevalue("config_hash_fields") - request.getfixturevalue("config_hash") - request.getfixturevalue("config_rules") - - def test_inner_hashing(self, duthost, hash_keys, ptfhost, outer_ipver, inner_ipver, router_mac, - vlan_ptf_ports, symmetric_hashing, localhost): - logging.info("Executing warm boot dynamic inner hash test for outer {} and inner {} with symmetric_hashing" - " set to {}".format(outer_ipver, inner_ipver, str(symmetric_hashing))) - timestamp = datetime.now().strftime('%Y-%m-%d-%H:%M:%S') - log_file = "/tmp/wr_inner_hash_test.DynamicInnerHashTest.{}.{}.{}.log".format(outer_ipver, inner_ipver, timestamp) - logging.info("PTF log file: %s" % log_file) - - # to reduce test run time, check one of encapsulation formats - outer_encap_format = random.choice(OUTER_ENCAP_FORMATS).split() - logging.info("Tested encapsulation format: {}".format(outer_encap_format[0])) - - outer_src_ip_range, outer_dst_ip_range = get_src_dst_ip_range(outer_ipver) - inner_src_ip_range, inner_dst_ip_range = get_src_dst_ip_range(inner_ipver) - - balancing_test_times = 200 - balancing_range = 0.3 - - reboot_thr = threading.Thread(target=reboot, args=(duthost, localhost, 'warm',)) - reboot_thr.start() - - ptf_runner(ptfhost, - "ptftests", - "inner_hash_test.InnerHashTest", - platform_dir="ptftests", - params={"fib_info": FIB_INFO_FILE_DST, - "router_mac": router_mac, - "src_ports": vlan_ptf_ports, - "hash_keys": hash_keys, - "vxlan_port": VXLAN_PORT, - "inner_src_ip_range": ",".join(inner_src_ip_range), - "inner_dst_ip_range": ",".join(inner_dst_ip_range), - "outer_src_ip_range": ",".join(outer_src_ip_range), - "outer_dst_ip_range": ",".join(outer_dst_ip_range), - "balancing_test_times": balancing_test_times, - "balancing_range": balancing_range, - "outer_encap_formats": outer_encap_format, - "nvgre_tni": NVGRE_TNI, - "symmetric_hashing": symmetric_hashing}, - log_file=log_file, - qlen=PTF_QLEN, - socket_recv_size=16384) - reboot_thr.join()