diff --git a/docs/testplan/BGP-Suppress-FIB-Pending-test-plan-T2-Chassis.md b/docs/testplan/BGP-Suppress-FIB-Pending-test-plan-T2-Chassis.md index 20546de4519..223bffa79f4 100644 --- a/docs/testplan/BGP-Suppress-FIB-Pending-test-plan-T2-Chassis.md +++ b/docs/testplan/BGP-Suppress-FIB-Pending-test-plan-T2-Chassis.md @@ -51,6 +51,8 @@ admin@sonic:~$ sudo config suppress-fib-pending disabled ``` Note: Issue raised for the above command not working on multi-asic environment globally, https://github.com/sonic-net/sonic-buildimage/issues/19022 . Currently it works only as specific asic commands. +> Note: changing the `suppress-fib-pending` configuration requires reload to become operational. + ### Supported Topology The tests will be supported on t1 as well as on t2 topo. @@ -196,31 +198,27 @@ kill -SIGSTOP $(pidof orchagent) 4. Verify the routes are announced via __IBGP__ and __EBGP__ to all T3 peer neighbors on the upstream DUT. 5. Send traffic matching the prefixes from the T3 peer and verify packets are forwarded back to the same T3 peer. 6. Enable BGP suppress-fib-pending function on the downstream DUT. -7. Restore orchagent process on both asics on the downstream DUT now, -``` -kill -SIGCONT $(pidof orchagent) -``` -8. Make sure the routes are programmed in FIB by checking offloaded flag in the downstream DUT routing table. -9. Send traffic matching the prefixes from one of T3 peer and verify packets are forwarded to expected T1 peer only. +7. Make sure the routes are programmed in FIB by checking offloaded flag in the downstream DUT routing table. +8. Send traffic matching the prefixes from one of T3 peer and verify packets are forwarded to expected T1 peer only. ### Test case # 6 - Test BGP route suppress under stress -1. Do BGP route flap 5 times - Announce/Withdraw BGP prefixes from one of T1 peer using exabgp. -2. Disable BGP suppress-fib-pending function on both upstream and downstream DUT -3. Send traffic matching the prefixes in the BGP route flap from one of T3 peer and verify packets are forwarded back to the same T3 peer. -4. Suspend orchagent process to simulate a delay on both asics of the downstream DUT. +1. Enable BGP suppress-fib-pending function on both upstream and downstream DUTs. +2. Do BGP route flap 5 times - Announce/Withdraw BGP prefixes from one of T1 peer using exabgp (stresses the route processing pipeline). +3. Suspend orchagent process to simulate a route install delay on both asics of the downstream DUT. ``` kill -SIGSTOP $(pidof orchagent) ``` -5. Announce 33K BGP prefixes to DUT from T1 peer by exabgp -6. Verify the routes are announced via __IBGP__ and __EBGP__ to all T3 peer neighbors on the upstream DUT. -7. Send traffic matching the prefixes in the BGP route flap from one of T3 VM and verify packets are forwarded back to the same T3 VM. -8. Enable BGP suppress-fib-pending function at downstream DUT. -9. Restore orchagent process on both asics on the downstream DUT now, +4. Announce 33K BGP prefixes to downstream DUT from T1 peer by exabgp. +5. Verify the BGP routes are in __queued__ state in the downstream DUT routing table. +6. Verify the BGP routes are NOT announced via __IBGP__ or __EBGP__ to any of the T3 peer neighbors on the upstream DUT. +7. Send traffic matching the prefixes from one of T3 peer and verify packets are NOT forwarded to T1 peers (blackholing). +8. Restore orchagent process on both asics on the downstream DUT, ``` kill -SIGCONT $(pidof orchagent) ``` -10. Verify the routes are programmed in FIB by checking offloaded flag in the downstream DUT routing table +9. Verify the BGP routes are in __offloaded__ state in the downstream DUT routing table. +10. Verify the routes are announced via __IBGP__ and __EBGP__ to all T3 peer neighbors on the upstream DUT. 11. Send traffic matching the prefixes from one of T3 peer and verify packets are forwarded to expected T1 peer only. diff --git a/docs/testplan/BGP-Suppress-FIB-Pending-test-plan.md b/docs/testplan/BGP-Suppress-FIB-Pending-test-plan.md index aa4b0f195a9..ea9fdaf6a52 100644 --- a/docs/testplan/BGP-Suppress-FIB-Pending-test-plan.md +++ b/docs/testplan/BGP-Suppress-FIB-Pending-test-plan.md @@ -41,6 +41,8 @@ Command to disable the feature: admin@sonic:~$ sudo config suppress-fib-pending disabled ``` +> Note: changing the `suppress-fib-pending` configuration requires reload to become operational. + ### Supported Topology The tests will be supported on t1 topo. @@ -135,15 +137,7 @@ show ip route 1.1.1.0/24 json 7. Make sure the routes are programmed in FIB by checking __offloaded__ flag in the DUT routing table 8. Send traffic matching the prefixes and verify packets are forwarded to T0 VM -### Test case # 4 - Test BGP test work with suppress -1. No BGP suppress-fib-pending function configured at DUT -2. Run BGP test suite -3. Make sure BGP tests are not affected -4. Enable BGP suppress-fib-pending function at DUT -5. Run BGP test suite -6. Make sure BGP tests are not affected - -### Test case # 5 - Test BGP route suppress under negative operation +### Test case # 4 - Test BGP route suppress under negative operation 1. Enable BGP suppress-fib-pending function at DUT 2. Suspend orchagent process to simulate a delay 3. Announce BGP prefixes to DUT from T0 VM by exabgp @@ -160,7 +154,7 @@ show ip route 1.1.1.0/24 json 14. Verify the BGP routes are announced to T2 peer 15. Send traffic matching the prefixes and verify packets are forwarded to T0 VM -### Test case # 6 - Test BGP route suppress in credit loops scenario +### Test case # 5 - Test BGP route suppress in credit loops scenario 1. No BGP suppress-fib-pending function configured at DUT 2. Suspend orchagent process to simulate a delay 3. Announce a default route to DUT from T2 VM @@ -168,24 +162,23 @@ show ip route 1.1.1.0/24 json 5. Verify the BGP routes are announced to T2 VM peer 6. Send traffic matching the prefixes and verify packets are forwarded __back to T2 VM__ 7. Enable BGP suppress-fib-pending function at DUT +8. Make sure the routes are programmed in FIB by checking __offloaded__ flag in the DUT routing table +9. Send traffic matching the prefixes and verify packets are forwarded to __T0 VM__ + +### Test case # 6 - Test BGP route suppress under stress +1. Enable BGP suppress-fib-pending function at DUT +2. Do BGP route flap 5 times (announce + withdraw 1K BGP prefixes) to stress the route processing pipeline +3. Suspend orchagent process to simulate a route install delay +4. Announce 1K BGP prefixes to DUT from T0 VM by exabgp +5. Verify the BGP routes are in __queued__ state in the DUT routing table +6. Verify the BGP routes are NOT announced to T2 VM peer +7. Send traffic matching the prefixes and verify packets are NOT forwarded to T0 VM (blackholing) 8. Restore orchagent process -9. Make sure the routes are programmed in FIB by checking __offloaded__ flag in the DUT routing table -10. Send traffic matching the prefixes and verify packets are forwarded to __T0 VM__ - -### Test case # 7 - Test BGP route suppress under stress -1. Do BGP route flap 5 times -2. Disable BGP suppress-fib-pending function -3. Send traffic matching the prefixes in the BGP route flap and verify packets are forwarded __back to T2 VM__ -4. Suspend orchagent process to simulate a delay -5. Announce 1K BGP prefixes to DUT from T0 VM by exabgp -6. Verify the BGP routes are announced to T2 VM peer -7. Send traffic matching the prefixes in the BGP route flap and verify packets are forwarded __back to T2 VM__ -8. Enable BGP suppress-fib-pending function at DUT -9. Restore orchagent process -10. Verify the routes are programmed in FIB by checking __offloaded__ flag in the DUT routing table +9. Verify the BGP routes are in __offloaded__ state in the DUT routing table +10. Verify the BGP routes are announced to T2 VM peer 11. Send traffic matching the prefixes and verify packets are forwarded to __T0 VM__ -### Test case # 8 - Test BGP route suppress performance +### Test case # 7 - Test BGP route suppress performance 1. Enable BGP suppress-fib-pending function at DUT 2. Start tcpdump capture at the ingress and egress port at DUT 3. Announce 1K BGP prefixes to DUT from T0 VM by exabgp diff --git a/tests/bgp/conftest.py b/tests/bgp/conftest.py index 95ece6eb4bc..bb17d724390 100644 --- a/tests/bgp/conftest.py +++ b/tests/bgp/conftest.py @@ -850,6 +850,7 @@ def config_bgp_suppress_fib(duthosts, rand_one_dut_hostname, request): logger.info('Enable BGP suppress fib pending function') duthost.shell('sudo config suppress-fib-pending enabled') duthost.shell('sudo config save -y') + config_reload(duthost, safe_reload=True, check_intf_up_ports=True, wait_for_bgp=True) yield @@ -857,6 +858,7 @@ def config_bgp_suppress_fib(duthosts, rand_one_dut_hostname, request): logger.info('Disable BGP suppress fib pending function') duthost.shell('sudo config suppress-fib-pending disabled') duthost.shell('sudo config save -y') + config_reload(duthost, safe_reload=True, check_intf_up_ports=True, wait_for_bgp=True) @pytest.fixture(scope="module") diff --git a/tests/bgp/test_bgp_peer_shutdown.py b/tests/bgp/test_bgp_peer_shutdown.py index bb04d729a2d..4db8d679993 100644 --- a/tests/bgp/test_bgp_peer_shutdown.py +++ b/tests/bgp/test_bgp_peer_shutdown.py @@ -13,7 +13,7 @@ from tests.common.errors import RunAnsibleModuleFail from tests.common.helpers.bgp import BGPNeighbor from tests.common.helpers.constants import DEFAULT_NAMESPACE -from tests.common.utilities import wait_until, delete_running_config +from tests.common.utilities import wait_until from tests.common.utilities import is_ipv6_only_topology pytestmark = [ @@ -96,12 +96,6 @@ def common_setup_teardown( yield bgp_neighbor, use_vtysh - # Cleanup suppress-fib-pending config - delete_tacacs_json = [ - {"DEVICE_METADATA": {"localhost": {"suppress-fib-pending": "disabled"}}} - ] - delete_running_config(delete_tacacs_json, duthost) - @pytest.fixture def constants(is_quagga, setup_interfaces, pytestconfig): diff --git a/tests/bgp/test_bgp_suppress_fib.py b/tests/bgp/test_bgp_suppress_fib.py index 63574f5a7a9..a1e51b7c695 100644 --- a/tests/bgp/test_bgp_suppress_fib.py +++ b/tests/bgp/test_bgp_suppress_fib.py @@ -175,32 +175,67 @@ def ignore_expected_loganalyzer_errors(duthosts, rand_one_dut_hostname, loganaly loganalyzer[duthost.hostname].ignore_regex.extend(ignoreRegex) -@pytest.fixture(scope="function") -def restore_bgp_suppress_fib(duthosts, enum_downstream_dut_hostname): - """ - Record the configuration before test only restore bgp suppress fib - if it is not enabled before test - Restoring on Downstream dut. - """ - duthost = duthosts[enum_downstream_dut_hostname] - suppress_fib = True - rets = duthost.shell('show suppress-fib-pending') - if rets['rc'] != 0: - logger.info("Failed to get suppress-fib-pending configuration") - else: - logger.info("Get suppress-fib-pending configuration: {}".format(rets['stdout'])) - if rets['stdout'] == 'Enabled': - suppress_fib = True - else: - suppress_fib = False +@pytest.fixture(scope="module", autouse=True) +def disable_zmq_for_fib_suppress(duthost): + """ + Disable orch_northbond_route_zmq_enabled for the duration of the module. + When ZMQ is enabled, TCP operations from fpmsyncd are blocked when the + orchagent process is paused, which breaks suppress-fib tests that + intentionally stop orchagent to simulate route install delays. + Restores the original value at module teardown. + """ + original = duthost.shell( + 'sonic-db-cli CONFIG_DB HGET "DEVICE_METADATA|localhost" "orch_northbond_route_zmq_enabled"', + module_ignore_errors=True + )['stdout'].strip() + logger.info("Original orch_northbond_route_zmq_enabled value: '{}'".format(original)) + + if original == "true": + logger.info("Disabling orch_northbond_route_zmq_enabled for suppress-fib tests") + duthost.shell('sonic-db-cli CONFIG_DB HSET "DEVICE_METADATA|localhost" ' + '"orch_northbond_route_zmq_enabled" "false"') + duthost.shell('sudo config save -y') + config_reload(duthost, safe_reload=True, check_intf_up_ports=True, wait_for_bgp=True) + # LLDP neighbors re-appear only after the remote side sends its next hello + # (up to 30 s after reload). config_reload has no LLDP option; wait explicitly. + logger.info("Waiting for LLDP neighbors to repopulate after config reload") + wait_until(90, 5, 0, + lambda: bool(duthost.shell( + "show lldp table | grep -v LocalPort | grep -v '^$'", + module_ignore_errors=True)['stdout'].strip())) + yield + + if original == "true": + logger.info("Restoring orch_northbond_route_zmq_enabled to true") + duthost.shell('sonic-db-cli CONFIG_DB HSET "DEVICE_METADATA|localhost" ' + '"orch_northbond_route_zmq_enabled" "true"') + duthost.shell('sudo config save -y') + config_reload(duthost, safe_reload=True, check_intf_up_ports=True, wait_for_bgp=True) + +@pytest.fixture(scope="module", autouse=True) +def restore_bgp_suppress_fib(duthosts): """ - Restore bgp suppress fib pending function + Record suppress-fib-pending state for every DUT before the module runs + and restore each one after the module completes. + + Iterating over all DUTs (rather than a single duthost) is necessary for + multi-DUT topologies where upstream and downstream hosts are different + devices. config_bgp_suppress_fib is idempotent, so DUTs whose state + did not change will skip the expensive config reload. """ + suppress_fib_map = {} + for dut in duthosts: + rets = dut.shell('show suppress-fib-pending', module_ignore_errors=True) + pytest_assert(rets['rc'] == 0, + "Failed to read suppress-fib-pending on {}: {}".format(dut.hostname, rets['stderr'])) + logger.info("suppress-fib-pending on {}: {}".format(dut.hostname, rets['stdout'])) + suppress_fib_map[dut] = (rets['stdout'].strip() == 'Enabled') + yield - config_bgp_suppress_fib(duthost, suppress_fib) - logger.info("Save configuration") - duthost.shell('sudo config save -y') + + for dut, was_enabled in suppress_fib_map.items(): + config_bgp_suppress_fib(dut, was_enabled) @pytest.fixture(scope='module') @@ -766,7 +801,19 @@ def config_bgp_suppress_fib(duthost, enable=True, validate_result=False): """ Enable or disable bgp suppress-fib-pending function For Multi-asic as well + Requires config reload to take effect. Skips reload if the CONFIG_DB + state already matches the desired state. """ + config_result = duthost.shell('show suppress-fib-pending', module_ignore_errors=True) + config_enabled = config_result['rc'] == 0 and config_result['stdout'].strip() == 'Enabled' + + logger.info("suppress-fib-pending: config_enabled={}".format(config_enabled)) + + if config_enabled == enable: + logger.info("BGP suppress-fib-pending is already '{}'" + "skipping config change".format("Enabled" if config_enabled else "Disabled")) + return + if enable: logger.info('Enable BGP suppress fib pending function') cmd_pstfix = ' enabled' @@ -780,6 +827,8 @@ def config_bgp_suppress_fib(duthost, enable=True, validate_result=False): show_cmd = "show suppress-fib-pending" duthost.shell(cfg_cmd) + duthost.shell('sudo config save -y') + config_reload(duthost, safe_reload=True, check_intf_up_ports=True, wait_for_bgp=True) if validate_result: for i in range(duthost.num_asics()): res = duthost.shell(show_cmd)['stdout_lines'][i] @@ -1066,12 +1115,6 @@ def test_bgp_route_with_suppress(duthosts, enum_downstream_dut_hostname, enum_up if multi_dut: config_bgp_suppress_fib(duthost_up) - with allure.step("Save configuration"): - logger.info("Save configuration") - duthost_down.shell('sudo config save -y') - if multi_dut: - duthost_up.shell('sudo config save -y') - for continous_boot_index in range(continuous_boot_times): if continuous_boot_times > 1: logger.info("======== Continuous boot needed - this is the {} time boot test ========". @@ -1440,10 +1483,6 @@ def test_credit_loop(duthosts, enum_downstream_dut_hostname, enum_upstream_dut_h with allure.step("Config bgp suppress-fib-pending function"): config_bgp_suppress_fib(duthost_up, validate_result=True) - with allure.step("Restore orchagent process"): - assert is_orchagent_stopped(duthost_up), "orchagent shall in stop state" - operate_orchagent(duthost_up, action=ACTION_CONTINUE) - with allure.step("Validate announced BGP ipv4 and ipv6 routes are in {} state".format(OFFLOADED)): if enum_upstream_dut_hostname != enum_downstream_dut_hostname: time.sleep(20) @@ -1466,15 +1505,21 @@ def test_credit_loop(duthosts, enum_downstream_dut_hostname, enum_upstream_dut_h def test_suppress_fib_stress(duthosts, enum_downstream_dut_hostname, enum_upstream_dut_hostname, tbinfo, nbrhosts, - ptfadapter, ptfhost, prepare_param, completeness_level, - generate_route_and_traffic_data, restore_bgp_suppress_fib, ): + ptfadapter, prepare_param, completeness_level, + generate_route_and_traffic_data, restore_bgp_suppress_fib): + """ + Verify BGP suppress-fib-pending under stress conditions. + + Steps: + 1. Enable BGP suppress-fib-pending at the downstream DUT. + 2. Do BGP route flap to stress the route processing pipeline. + 3. Suspend orchagent to simulate a route install delay. + 4. Announce routes and verify they are held in queued state (blackholing). + 5. Restore orchagent and verify routes transition to offloaded state and traffic is forwarded. + """ duthost_down = duthosts[enum_downstream_dut_hostname] duthost_up = duthosts[enum_upstream_dut_hostname] - tcpdump_helper_downstream = tcpdump_helper(ptfadapter, duthost_down, ptfhost, - pcap_path="/tmp/capture.pcap_down") - tcpdump_sniffer = tcpdump_helper(ptfadapter, duthost_up, ptfhost, - pcap_path="/tmp/capture.pcap") with allure.step("Prepare needed parameters"): router_mac, mg_facts, ptf_ip, exabgp_port_list, exabgp_port_list_v6, recv_port_list = prepare_param @@ -1482,64 +1527,68 @@ def test_suppress_fib_stress(duthosts, enum_downstream_dut_hostname, enum_upstre ipv4_route_list, ipv6_route_list, traffic_data_ipv4_forward, traffic_data_ipv6_forward, \ traffic_data_ipv4_drop, traffic_data_ipv6_drop = generate_route_and_traffic_data[STRESS] + mg_facts_up = duthost_up.get_extended_minigraph_facts(tbinfo) + router_mac_up = duthost_up.facts["router_mac"] + ptf_interfaces = get_upstream_ptf_intfs(mg_facts_up, tbinfo) + + with allure.step("Enable BGP suppress-fib-pending function at DUT"): + config_bgp_suppress_fib(duthost_down) + for exabgp_port, exabgp_port_v6, recv_port in zip(exabgp_port_list, exabgp_port_list_v6, recv_port_list): try: - with allure.step("Do BGP route flap"): - flap_time = 1 if completeness_level == "thorough" else BGP_ROUTE_FLAP_TIMES - bgp_route_flap_with_stress(duthosts, enum_upstream_dut_hostname, duthost_down, tbinfo, nbrhosts, ptf_ip, - ipv4_route_list, exabgp_port, + with allure.step("Do BGP route flap to stress the route processing pipeline"): + flap_time = BGP_ROUTE_FLAP_TIMES if completeness_level == "thorough" else 1 + bgp_route_flap_with_stress(duthosts, enum_upstream_dut_hostname, duthost_down, tbinfo, nbrhosts, + ptf_ip, ipv4_route_list, exabgp_port, ipv6_route_list, exabgp_port_v6, flap_time=flap_time) - with allure.step("Disable bgp suppress-fib-pending function"): - config_bgp_suppress_fib(duthost_up, enable=False, validate_result=True) - - with allure.step( - "Validate traffics are back to Upstream VM to make sure routes in HW are removed by orchagent"): - mg_facts = duthost_up.get_extended_minigraph_facts(tbinfo) - router_mac = duthost_up.facts["router_mac"] - ptf_interfaces = get_upstream_ptf_intfs(mg_facts, tbinfo) - retry_call(validate_bulk_traffic, - fargs=[tcpdump_helper_downstream, ptfadapter, - traffic_data_ipv4_forward + traffic_data_ipv6_forward, - router_mac, ptf_interfaces, ptf_interfaces], tries=3, delay=2) + with allure.step("Verify stress routes are fully withdrawn before pausing orchagent"): + validate_route_propagate(duthost_up, nbrhosts, tbinfo, + ipv4_route_list, ipv6_route_list, exist=False) with allure.step("Suspend orchagent process to simulate a route install delay"): - operate_orchagent(duthost_up) + operate_orchagent(duthost_down) - with allure.step(f"Announce BGP ipv4 and ipv6 routes to DUT from Downstream VM by ExaBGP - " + with allure.step(f"Announce BGP ipv4 and ipv6 routes to DUT from T0 VM by ExaBGP - " f"v4: {exabgp_port} v6: {exabgp_port_v6}"): announce_ipv4_ipv6_routes(ptf_ip, ipv4_route_list, exabgp_port, ipv6_route_list, exabgp_port_v6) - with allure.step("Validate the BGP routes are propagated to Upstream VM"): - validate_route_propagate(duthost_up, nbrhosts, tbinfo, ipv4_route_list, - ipv6_route_list) + with allure.step("Verify the BGP routes are in queued state in the DUT routing table"): + validate_route_states(duthost_down, ipv4_route_list, ipv6_route_list, exabgp_port, + exabgp_port_v6, tbinfo, check_point=QUEUED, action=ACTION_IN, + verify_suppress_oth_asic=duthost_down.is_multi_asic) - with allure.step("Validate traffics are forwarded back to Upstream VM"): - validate_bulk_traffic(tcpdump_sniffer, ptfadapter, - traffic_data_ipv4_forward + traffic_data_ipv6_forward, router_mac, - ptf_interfaces, ptf_interfaces) + with allure.step("Verify the BGP routes are NOT announced to T2 VM peer"): + validate_route_propagate(duthost_up, nbrhosts, tbinfo, + ipv4_route_list, ipv6_route_list, exist=False) - with allure.step("Config bgp suppress-fib-pending function"): - config_bgp_suppress_fib(duthost_up, validate_result=True) + with allure.step("Send traffic and verify packets are NOT forwarded (blackholing)"): + validate_traffic(ptfadapter, [traffic_data_ipv4_drop, traffic_data_ipv6_drop], + router_mac_up, ptf_interfaces, recv_port) with allure.step("Restore orchagent process"): - assert is_orchagent_stopped(duthost_up), "orchagent shall in stop state" - operate_orchagent(duthost_up, action=ACTION_CONTINUE) + operate_orchagent(duthost_down, action=ACTION_CONTINUE) - with allure.step("Validate announced BGP ipv4 and ipv6 routes are installed into fib"): - validate_fib_route(duthost_down, ipv4_route_list, ipv6_route_list) + with allure.step("Verify the BGP routes are in offloaded state in the DUT routing table"): + validate_route_states(duthost_down, ipv4_route_list, ipv6_route_list, exabgp_port, + exabgp_port_v6, tbinfo, check_point=OFFLOADED, action=ACTION_IN, + verify_oth_asic=duthost_down.is_multi_asic) - with allure.step("Validate traffic would be forwarded to Downstream VM"): - validate_bulk_traffic(tcpdump_helper_downstream, ptfadapter, - traffic_data_ipv4_forward + traffic_data_ipv6_forward, router_mac, - ptf_interfaces, recv_port) + with allure.step("Verify the BGP routes are announced to T2 VM peer"): + validate_route_propagate(duthost_up, nbrhosts, tbinfo, + ipv4_route_list, ipv6_route_list, exist=True) + + with allure.step("Send traffic and verify packets are forwarded to T0 VM"): + validate_traffic(ptfadapter, [traffic_data_ipv4_forward, traffic_data_ipv6_forward], + router_mac_up, ptf_interfaces, recv_port) finally: - with allure.step(f"Withdraw BGP ipv4 and ipv6 routes from Downstream VM by ExaBGP - " + with allure.step(f"Withdraw BGP ipv4 and ipv6 routes from T0 VM by ExaBGP - " f"v4: {exabgp_port} v6: {exabgp_port_v6}"): announce_ipv4_ipv6_routes(ptf_ip, ipv4_route_list, exabgp_port, ipv6_route_list, exabgp_port_v6, action=WITHDRAW) - + if is_orchagent_stopped(duthost_down): + operate_orchagent(duthost_down, action=ACTION_CONTINUE) def test_suppress_fib_performance(duthosts, enum_downstream_dut_hostname, enum_upstream_dut_hostname, tbinfo, nbrhosts, ptfadapter, prepare_param, ptfhost, generate_route_and_traffic_data, restore_bgp_suppress_fib): diff --git a/tests/bgp/test_bgp_update_timer.py b/tests/bgp/test_bgp_update_timer.py index 0f75d71d9b1..e960ef373cb 100644 --- a/tests/bgp/test_bgp_update_timer.py +++ b/tests/bgp/test_bgp_update_timer.py @@ -18,7 +18,7 @@ check_routes_presence ) from tests.common.helpers.bgp import BGPNeighbor -from tests.common.utilities import wait_until, delete_running_config +from tests.common.utilities import wait_until from tests.common.utilities import is_ipv6_only_topology from tests.common.helpers.assertions import pytest_assert @@ -189,12 +189,6 @@ def common_setup_teardown( yield bgp_neighbors, use_vtysh - # Cleanup suppress-fib-pending config - delete_tacacs_json = [ - {"DEVICE_METADATA": {"localhost": {"suppress-fib-pending": "disabled"}}} - ] - delete_running_config(delete_tacacs_json, duthost) - @pytest.fixture def constants(is_quagga, setup_interfaces, has_suppress_feature, pytestconfig, tbinfo,