def check_intf_traffic_counters(dut1): papi.clear_interface_counters(dut1) st.wait(10) vars = st.get_testbed_vars() DUT_rx_value = papi.get_interface_counters(dut1, vars.D1T1P1, "rx_bps") DUT_tx_value = papi.get_interface_counters(dut1, vars.D1T1P2, "tx_bps") for i in DUT_rx_value: p1_rcvd = i['rx_bps'] p1_rcvd = p1_rcvd.replace(" MB/s", "") p1_rcvd = p1_rcvd.replace(" B/s", "") for i in DUT_tx_value: p2_txmt = i['tx_bps'] p2_txmt = p2_txmt.replace(" MB/s", "") p2_txmt = p2_txmt.replace(" B/s", "") st.log( "rx_ok counter value on DUT Ingress port: {} and tx_ok xounter value on DUT Egress port : {}" .format(p1_rcvd, p2_txmt)) if (p1_rcvd and p2_txmt): return True else: return False
def check_intf_traffic_counters(): (dut1) = (data.dut) papi.clear_interface_counters(dut1) st.wait(5) DUT_tx_value = papi.get_interface_counters(dut1, vars.D1T1P4, "tx_bps") for i in DUT_tx_value: p2_txmt = i['tx_bps'] p2_txmt = p2_txmt.replace(" MB/s","") p2_txmt = p2_txmt.replace(" KB/s","") p2_txmt = p2_txmt.replace(" B/s","") st.log("tx_ok xounter value on DUT Egress port : {}".format(p2_txmt)) if (abs(int(float(p2_txmt))) == 0): output = papi.get_interface_counters_all(dut1) entry1 = filter_and_select(output, ["tx_bps"], {'iface': vars.D1T1P4}) for i in entry1: p2_txmt = i['tx_bps'] p2_txmt = p2_txmt.replace(" MB/s","") p2_txmt = p2_txmt.replace(" KB/s","") p2_txmt = p2_txmt.replace(" B/s","") st.log("RETRY tx_ok xounter value on DUT Egress port : {}".format(p2_txmt)) if (abs(int(float(p2_txmt))) == 0): st.show(dut1, "show arp") asicapi.dump_l3_egress(dut1) return False else: return True else: return True
def snapshot_feature_func_hooks(request): if (st.get_func_name(request) not in 'test_ft_watermark_telemetry_interval' ) and (st.get_func_name(request) not in 'test_ft_snapshot_interval'): clear_interface_counters(vars.D1) yield if st.get_func_name( request ) == 'test_ft_sf_all_buffer_stats_using_unicast_traffic' or st.get_func_name( request) == 'test_ft_sf_verify_buffer_pool_counters': sf_tg_traffic_start_stop(sf_data.unicast, False) sfapi.config_snapshot_interval(vars.D1, snap="clear_snaphot_interval") if st.get_func_name( request) == 'test_ft_sf_all_buffer_stats_using_multicast_traffic': sf_tg_traffic_start_stop(sf_data.multicast, False) sfapi.config_snapshot_interval(vars.D1, snap="clear_snaphot_interval") if st.get_func_name(request) == 'test_ft_sf_verify_cpu_counters': sflow.config_attributes(vars.D1, sample_rate=sf_data.sflow_sample_rate, interface_name=vars.D1T1P1, no_form=True) sflow.enable_disable_config(vars.D1, interface=False, interface_name=None, action="disable") sf_tg_traffic_start_stop(sf_data.unicast, False) sfapi.config_snapshot_interval(vars.D1, snap="clear_snaphot_interval")
def test_bgp_v4_warm_reboot(fixture_v4): ################# Author Details ################ # Name: V Sreenivasula Reddy # Email: [email protected] # ############### Test bed details ################ # TG --- DUT --- TG ################################################# bgpfeature.enable_docker_routing_config_mode(vars.D1) tr1 = tg.tg_traffic_config( port_handle=tg_handler["tg_ph_2"], emulation_src_handle=h2['handle'], emulation_dst_handle=bgp_rtr1['route'][0]['handle'], circuit_endpoint_type='ipv4', mode='create', transmit_mode='continuous', length_mode='fixed', rate_pps=data.traffic_rate_pps, enable_stream_only_gen='0') # Verify the total route count count = verify_bgp_route_count(dut, family='ipv4', neighbor=data.neigh_ip_addr, state='Established') st.log("Route count: " + str(count)) if int(count) != int(data.test_bgp_route_count): st.report_fail("route_table_not_updated_by_advertise_from_tg") # Starting the TG traffic after clearing the DUT counters papi.clear_interface_counters(dut) tg.tg_traffic_control(action="run", handle=tr1['stream_id']) bgpfeature.enable_docker_routing_config_mode(vars.D1) st.log("saving the BGP config in vtysh shell") reboot_obj.config_save(vars.D1, shell='vtysh') st.log("config save in D1") reboot_obj.config_save([vars.D1]) st.log("Performing warm reboot") st.reboot(vars.D1, "warm") # Stopping the TG traffic tg.tg_traffic_control(action='stop', handle=tr1['stream_id']) traffic_details = { '1': { 'tx_ports': [vars.T1D1P2], 'tx_obj': [tg], 'exp_ratio': [1], 'rx_ports': [vars.T1D1P1], 'rx_obj': [tg], } } if not tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type='packet_count'): st.report_fail("traffic_verification_failed_during_warm_reboot") st.report_pass("test_case_passed")
def check_intf_traffic_bo_counters(): (dut1) = (data.dut) papi.clear_interface_counters(dut1) st.wait(5) output = papi.get_interface_counters_all(dut1) p1_tx = intf_traffic_stats(filter_and_select(output, ["tx_bps"], {'iface': vars.D1T1P1})) p2_tx = intf_traffic_stats(filter_and_select(output, ["tx_bps"], {'iface': vars.D1T1P2})) p3_tx = intf_traffic_stats(filter_and_select(output, ["tx_bps"], {'iface': vars.D1T1P3})) p4_tx = intf_traffic_stats(filter_and_select(output, ["tx_bps"], {'iface': vars.D1T1P4})) st.log("Inter Dut port stats tx_ok xounter value on DUT Egress ports : {} {} {} {}".format(p1_tx, p2_tx, p3_tx, p4_tx)) if (p2_tx == 0) | (p3_tx == 0) | (p4_tx == 0): st.log("Error:Inter Dut port stats tx_ok xounter value on DUT Egress ports : {} {} {}".format(p2_tx, p3_tx, p4_tx)) else: return True DUT_rx_value = papi.get_interface_counters(dut1, vars.D1T1P4, "rx_ok") for i in DUT_rx_value: p1_rcvd = i['rx_ok'] p1_rcvd = p1_rcvd.replace(",","") st.log("rx_ok xounter value on DUT Inress port : {}".format(p1_rcvd)) if (abs(int(float(p1_rcvd))) > 0): output = papi.get_interface_counters_all(dut1) entry1 = filter_and_select(output, ["tx_bps"], {'iface': vars.D1T1P1}) entry2 = filter_and_select(output, ["tx_bps"], {'iface': vars.D1T1P2}) entry3 = filter_and_select(output, ["tx_bps"], {'iface': vars.D1T1P3}) entry4 = filter_and_select(output, ["tx_bps"], {'iface': vars.D1T1P4}) for i in entry1: p1_txmt = i['tx_bps'] p1_txmt = p1_txmt.replace(" MB/s","") p1_txmt = p1_txmt.replace(" KB/s","") p1_txmt = p1_txmt.replace(" B/s","") for i in entry2: p2_txmt = i['tx_bps'] p2_txmt = p2_txmt.replace(" MB/s","") p2_txmt = p2_txmt.replace(" KB/s","") p2_txmt = p2_txmt.replace(" B/s","") for i in entry3: p3_txmt = i['tx_bps'] p3_txmt = p3_txmt.replace(" MB/s","") p3_txmt = p3_txmt.replace(" KB/s","") p3_txmt = p3_txmt.replace(" B/s","") for i in entry4: p4_txmt = i['tx_bps'] p4_txmt = p4_txmt.replace(" MB/s","") p4_txmt = p4_txmt.replace(" KB/s","") p4_txmt = p4_txmt.replace(" B/s","") st.log("RETRY tx_ok xounter value on DUT Egress ports : {} {} {} {}".format(p1_txmt, p2_txmt, p3_txmt, p4_txmt)) if (abs(int(float(p2_txmt))) == 0) | (abs(int(float(p3_txmt))) == 0) | (abs(int(float(p4_txmt))) == 0): st.show(dut1, "show arp") return False else: return True else: return False
def test_bgp_v6_warm_boot(fixture_v6): ################# Author Details ################ # Name: V Sreenivasula Reddy # Email: [email protected] # ############### Test bed details ################ # TG --- DUT --- TG ################################################# # Configuring traffic stream on the TG interfac tr1 = tg.tg_traffic_config( port_handle=tg_handler["tg_ph_2"], emulation_src_handle=h2['handle'], emulation_dst_handle=bgp_rtr2['route'][0]['handle'], circuit_endpoint_type='ipv6', mode='create', transmit_mode='continuous', length_mode='fixed', rate_pps=data.traffic_rate_pps, enable_stream_only_gen='0') # Starting the TG traffic after clearing the DUT counters papi.clear_interface_counters(dut) tgapi.traffic_action_control(tg_handler, actions=['clear_stats']) tg.tg_traffic_control(action="run", handle=tr1['stream_id']) bgpfeature.enable_docker_routing_config_mode(vars.D1) st.log("saving the BGP config in vtysh shell") reboot_obj.config_save(vars.D1, shell='vtysh') st.log("config save in D1") reboot_obj.config_save([vars.D1]) st.log("Performing warm reboot") st.reboot(vars.D1, "warm") # Stopping the TG traffic tg.tg_traffic_control(action='stop', handle=tr1['stream_id']) st.wait(5) traffic_details = { '1': { 'tx_ports': [vars.T1D1P2], 'tx_obj': [tg], 'exp_ratio': [1], 'rx_ports': [vars.T1D1P1], 'rx_obj': [tg], } } if not tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type='packet_count'): st.report_fail("traffic_verification_failed_during_warm_reboot") st.report_pass("test_case_passed")
def test_l3_host_scaling_tc5_4(): pre_test_l3_fwding() vars = st.get_testbed_vars() data.my_dut_list = st.get_dut_names() dut1 = vars.D1 ipfeature.get_interface_ip_address(dut1, family="ipv4") ipfeature.get_interface_ip_address(dut1, family="ipv6") ipfeature.show_ip_route(dut1) ifapi.interface_status_show(dut1) # L3 traffic streams (tg1, tg2, tg_ph_1, tg_ph_2) = get_handles() tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1) tr1 = create_l3_host(tg1, tg_ph_1, data.max_host_1, 20) st.wait(15) # Verified ARP and counters at the DUT. total = arpfeature.get_arp_count(dut1) st.log("Total ARP entries: {}".format(total)) tg1.tg_traffic_control(action='stop', handle=tr1['stream_id']) tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1) tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1) tg2.tg_traffic_control(action='reset', port_handle=tg_ph_2) res = tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr=data.t1d1_ip_addr, gateway=data.d1t1_ip_addr, src_mac_addr='00:0a:01:00:11:01', arp_send_req='1') st.log("INTFCONF: " + str(res)) handle1 = res['handle'] #tg1.tg_test_control(action='sync') res = tg2.tg_interface_config(port_handle=tg_ph_2, mode='config', intf_ip_addr=data.t1d2_ip_addr, gateway=data.d1t2_ip_addr, src_mac_addr='00:0a:01:00:12:01', arp_send_req='1') st.log("INTFCONF: " + str(res)) handle2 = res['handle'] #tg2.tg_test_control(action='sync') tr1 = tg1.tg_traffic_config(port_handle=tg_ph_1, mode='create', transmit_mode='continuous', length_mode='fixed', l3_length=data.tgen_l3_len, rate_pps=data.tgen_rate_pps, emulation_src_handle=handle1, emulation_dst_handle=handle2) tr2 = tg2.tg_traffic_config(port_handle=tg_ph_2, mode='create', transmit_mode='continuous', length_mode='fixed', l3_length=data.tgen_l3_len, rate_pps=data.tgen_rate_pps, emulation_src_handle=handle2, emulation_dst_handle=handle1) tg1.tg_packet_control(port_handle=tg_ph_1, action='start') tg2.tg_packet_control(port_handle=tg_ph_2, action='start') tg1.tg_traffic_control(action='clear_stats', handle=tr1['stream_id']) tg2.tg_traffic_control(action='clear_stats', handle=tr2['stream_id']) papi.clear_interface_counters(dut1) tg1.tg_traffic_control(action='run', handle=tr1['stream_id'], duration=2) tg2.tg_traffic_control(action='run', handle=tr2['stream_id'], duration=2) st.wait(data.traffic_run_time) tg1.tg_traffic_control(action='stop', handle=tr1['stream_id']) tg2.tg_traffic_control(action='stop', handle=tr2['stream_id']) st.wait(5) tg1.tg_packet_control(port_handle=tg_ph_1, action='stop') tg2.tg_packet_control(port_handle=tg_ph_2, action='stop') stats_tg1 = tg1.tg_traffic_stats(port_handle=tg_ph_1, mode='aggregate') total_tg1_tx = stats_tg1[tg_ph_1]['aggregate']['tx']['total_pkts'] total_tg1_rx = stats_tg1[tg_ph_1]['aggregate']['rx']['total_pkts'] stats_tg2 = tg2.tg_traffic_stats(port_handle=tg_ph_2, mode='aggregate') total_tg2_tx = stats_tg2[tg_ph_2]['aggregate']['tx']['total_pkts'] total_tg2_rx = stats_tg2[tg_ph_2]['aggregate']['rx']['total_pkts'] st.log( "Tgen Sent Packets on D1T1P1: {} and Received Packets on D2T1P1: {}". format(total_tg1_tx, total_tg2_rx)) st.log( "Tgen Sent Packets on D2T1P1: {} and Received Packets on D1T1P1: {}". format(total_tg2_tx, total_tg1_rx)) flap_interface(vars.D1T1P1) flap_interface(vars.D1T1P2) #Getting interfaces counter values on DUT DUT_rx_value = ifapi.get_interface_counters(dut1, vars.D1T1P1, "rx_ok") DUT_tx_value = ifapi.get_interface_counters(dut1, vars.D1T1P2, "tx_ok") for i in DUT_rx_value: p1_rcvd = i['rx_ok'] p1_rcvd = p1_rcvd.replace(",", "") for i in DUT_tx_value: p2_txmt = i['tx_ok'] p2_txmt = p2_txmt.replace(",", "") st.log( "rx_ok counter value on DUT Ingress port: {} and tx_ok xounter value on DUT Egress port : {}" .format(p1_rcvd, p2_txmt)) post_test_l3_fwding() if (total >= data.max_host_1): st.report_pass("test_case_passed") else: st.report_fail("test_case_failed")
def test_l3_host_scaling_tc5_3(): pre_test_l3_fwding() vars = st.get_testbed_vars() # Config 2 IPV4 interfaces on DUT. (tg1, tg2, tg_ph_1, tg_ph_2) = get_handles() dut1 = vars.D1 ipfeature.get_interface_ip_address(dut1, family="ipv4") ipfeature.get_interface_ip_address(dut1, family="ipv6") ipfeature.show_ip_route(dut1) ifapi.interface_status_show(dut1) tr1 = create_l3_host(tg1, tg_ph_1, data.max_host_1, 20) st.wait(15) # Verified ARP and counters at the DUT. total = arpfeature.get_arp_count(dut1) st.log("Total ARP entries: {}".format(total)) tg1.tg_traffic_control(action='stop', handle=tr1['stream_id']) tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1) tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1) tg2.tg_traffic_control(action='reset', port_handle=tg_ph_2) res = tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr=data.t1d1_ip_addr, gateway=data.d1t1_ip_addr, src_mac_addr='00:0a:01:00:11:01', arp_send_req='1') st.log("INTFCONF: " + str(res)) handle1 = res['handle'] #tg1.tg_test_control(action='sync') res = tg2.tg_interface_config(port_handle=tg_ph_2, mode='config', intf_ip_addr=data.t1d2_ip_addr, gateway=data.d1t2_ip_addr, src_mac_addr='00:0a:01:00:12:01', arp_send_req='1') st.log("INTFCONF: " + str(res)) handle2 = res['handle'] #tg2.tg_test_control(action='sync') tr1 = tg1.tg_traffic_config(port_handle=tg_ph_1, mode='create', transmit_mode='continuous', length_mode='fixed', l3_length=data.tgen_l3_len, rate_pps=data.tgen_rate_pps, emulation_src_handle=handle1, emulation_dst_handle=handle2) tr2 = tg2.tg_traffic_config(port_handle=tg_ph_2, mode='create', transmit_mode='continuous', length_mode='fixed', l3_length=data.tgen_l3_len, rate_pps=data.tgen_rate_pps, emulation_src_handle=handle2, emulation_dst_handle=handle1) tg1.tg_packet_control(port_handle=tg_ph_1, action='start') tg2.tg_packet_control(port_handle=tg_ph_2, action='start') tg1.tg_traffic_control(action='clear_stats', handle=tr1['stream_id']) tg2.tg_traffic_control(action='clear_stats', handle=tr2['stream_id']) papi.clear_interface_counters(dut1) tg1.tg_traffic_control(action='run', handle=tr1['stream_id'], duration=2) tg2.tg_traffic_control(action='run', handle=tr2['stream_id'], duration=2) st.wait(data.traffic_run_time) tg1.tg_traffic_control(action='stop', handle=tr1['stream_id']) tg2.tg_traffic_control(action='stop', handle=tr2['stream_id']) tg1.tg_packet_control(port_handle=tg_ph_1, action='stop') tg2.tg_packet_control(port_handle=tg_ph_2, action='stop') papi.clear_interface_counters(dut1) tg2.tg_traffic_control(action='run', handle=tr1['stream_id']) st.wait(20) retval = check_intf_traffic_counters(dut1) post_test_l3_fwding() if (total >= data.max_host_1 and retval): st.report_pass("test_case_passed") else: st.report_fail("test_case_failed")
def test_l3_fwding(): #pre_test_l3_fwding() data.my_dut_list = st.get_dut_names() dut1 = vars.D1 ipfeature.get_interface_ip_address(dut1, family="ipv4") ipfeature.get_interface_ip_address(dut1, family="ipv6") ipfeature.show_ip_route(dut1) # L3 traffic streams (tg1, _, tg_ph_1, tg_ph_2) = get_handles() tg1.tg_traffic_control(action='reset', port_handle=[tg_ph_1, tg_ph_2]) res = tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr=data.t1d1_ip_addr, gateway=data.d1t1_ip_addr, src_mac_addr='00:0a:01:00:11:01', arp_send_req='1') st.log("INTFCONF: " + str(res)) handle1 = res['handle'] res = tg1.tg_interface_config(port_handle=tg_ph_2, mode='config', intf_ip_addr=data.t1d2_ip_addr, gateway=data.d2t1_ip_addr, src_mac_addr='00:0a:01:00:12:01', arp_send_req='1') st.log("INTFCONF: " + str(res)) handle2 = res['handle'] rv = tg1.tg_traffic_config(port_handle=tg_ph_1, port_handle2=tg_ph_2, mode='create', transmit_mode='continuous', length_mode='fixed', l3_length=data.tgen_l3_len, rate_pps=data.tgen_rate_pps, emulation_src_handle=handle1, emulation_dst_handle=handle2) tg_info['tg1_stream_id'] = rv['stream_id'] rv_1 = tg1.tg_traffic_config(port_handle=tg_ph_2, port_handle2=tg_ph_1, mode='create', transmit_mode='continuous', length_mode='fixed', l3_length=data.tgen_l3_len, rate_pps=data.tgen_rate_pps, emulation_src_handle=handle2, emulation_dst_handle=handle1) tg_info['tg2_stream_id'] = rv_1['stream_id'] tg1.tg_traffic_control(action='clear_stats', port_handle=[tg_ph_1, tg_ph_2]) papi.clear_interface_counters(dut1) tg1.tg_traffic_control( action='run', stream_handle=[tg_info['tg1_stream_id'], tg_info['tg2_stream_id']]) st.wait(data.traffic_run_time) tg1.tg_traffic_control( action='stop', stream_handle=[tg_info['tg1_stream_id'], tg_info['tg2_stream_id']]) traffic_details = { '1': { 'tx_ports': [vars.T1D1P1], 'tx_obj': [tg1], 'exp_ratio': [1], 'rx_ports': [vars.T1D2P1], 'rx_obj': [tg1], 'stream_list': [[tg_info['tg1_stream_id']]] }, '2': { 'tx_ports': [vars.T1D2P1], 'tx_obj': [tg1], 'exp_ratio': [1], 'rx_ports': [vars.T1D1P1], 'rx_obj': [tg1], 'stream_list': [[tg_info['tg2_stream_id']]] } } if not tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='streamblock', comp_type='packet_count'): st.report_fail("failed_traffic_verification") # read interface counters rx_counters = intapi.get_interface_counters(dut1, vars.D1T1P1, "rx_ok") tx_counters = intapi.get_interface_counters(dut1, vars.D1D2P1, "tx_ok") # process interface counters p1_rcvd, p2_txmt = 0, 0 for i in rx_counters: p1_rcvd = int(i['rx_ok'].replace(",", "")) for i in tx_counters: p2_txmt = int(i['tx_ok'].replace(",", "")) diff_count = abs(p1_rcvd - p2_txmt) st.log("ingress rx_ok = {} egress tx_ok = {} diff = {}".format( p1_rcvd, p2_txmt, diff_count)) # verify interface counters if p1_rcvd == 0: st.report_fail("msg", "rx_ok is invalid") if p2_txmt == 0: st.report_fail("msg", "tx_ok is invalid") #if diff_count > data.counters_threshold: st.report_fail("msg", "unexpected counter values") # verify the ipv4 ping result = ipfeature.ping(dut1, data.d2t1_ip_addr) if not result: st.report_fail("msg", "IPv4 Ping Failed") # verify the ipv6 ping result = ipfeature.ping(dut1, data.d2t1_ip_addr_v6, 'ipv6') if not result: st.report_fail("msg", "IPv6 Ping Failed") st.report_pass("operation_successful")
def test_ft_l3_performance_enhancements_v4_bgp_clos_topology_indirect_link_fail_convergence_time(fixture_v4): ################# Author Details ################ # Name: Rakesh Kumar Vooturi # Email: [email protected] ################################################# # # Objective - FtOpSoRtPerfFn034 : Measure convergence time with BGP routes (with ECMP paths) in case of indirectly connected link failure # ############### Test bed details ################ # TG --- DUT1 --- DUT2 --- DUT3 --- DUT4 --- TG ################################################# print_topology("Indirect link failover time", "D3 -> D1 Link") # Verify the total route count using bcmcmd if not check_bcmcmd_route_count(dut1, 50, "ipv4", def_v4_route_count_d1, data.test_bgp_route_count): st.report_fail("route_table_not_updated_by_advertise_from_tg") if not check_bcmcmd_route_count(dut4, 50, "ipv4", def_v4_route_count_d4, data.test_bgp_route_count): st.report_fail("route_table_not_updated_by_advertise_from_tg") # Configuring traffic stream on the TG interface tr1=tg.tg_traffic_config(port_handle=tg_handler["tg_ph_2"], emulation_src_handle=h2['handle'], emulation_dst_handle=bgp_rtr1['route'][0]['handle'], circuit_endpoint_type='ipv4', mode='create', transmit_mode='continuous', length_mode='fixed', rate_pps=data.traffic_rate_pps, enable_stream_only_gen='0') st.log("#######################################################################################################################################################") st.log("# Measuring convergence time with BGP v4 routes (with ECMP paths) in case of indirectly connected link failure") st.log("#######################################################################################################################################################") # Starting the TG traffic after clearing the DUT counters papi.clear_interface_counters(dut1) tgapi.traffic_action_control(tg_handler, actions=['clear_stats']) tg.tg_traffic_control(action="run",handle=tr1['stream_id']) # Shutdown the routing interface link. st.log("Shutdown the routing interface link.") if not interface_obj.interface_operation(dut3, dut3_to_dut1_port_1 , "shutdown"): st.report_fail('interface_admin_shut_down_fail', dut3_to_dut1_port_1) # Wait for traffic to reroute papi.get_interface_counters_all(dut1) st.wait(30) if not check_intf_traffic_counters(dut1, dut1_to_tg_port_1, 30): st.report_fail("ingress_traffic_rate_not_matching_with_egress_rate") # Stopping the TG traffic tg.tg_traffic_control(action='stop', handle=tr1['stream_id']) # Stats fetching st.log("Fetching the stats on TG ports") tg_1_stats = tgapi.get_traffic_stats(tg, mode='aggregate', port_handle=tg_handler["tg_ph_1"]) tg_2_stats = tgapi.get_traffic_stats(tg, mode='aggregate', port_handle=tg_handler["tg_ph_2"]) total_rx = tg_1_stats.rx.total_packets total_tx = tg_2_stats.tx.total_packets # Stats verification st.log("Sent Packets On TG2: {} and Received Packets On TG1: {}".format(total_tx, total_rx)) if (int(total_tx) == 0): st.log("Traffic verification failed : Failed to send traffic from TG2 to TG1.") st.report_fail("traffic_verification_failed") time_taken = round((int(total_tx)-int(total_rx))/(int(data.test_bgp_route_count)*1.0),1) # Time taken for convergence st.log("#######################################################################################################################################################") st.log(" Convergence time with BGP v4 routes (with ECMP paths) in case of indirectly connected link failure in secs = " +str(time_taken)) st.log("#######################################################################################################################################################") st.report_pass("test_case_passed")
def test_ft_l3_performance_enhancements_v4_bgp_session_failover_convergence_time( fixture_v4): ################# Author Details ################ # Name: Rakesh Kumar Vooturi # Email: [email protected] ################################################# # # Objective - FtOpSoRtPerfFn032 : Performance measurement for BGP Session Failover case # Measure time taken for the traffic ( corresponding to BGP routes ) to resume fully # (i.e RX rate = TX rate) after the BGP session flaps ( i.e BGP session goes down and then comes up # This is triggered using "clear ip bgp * " CLI command ). # ############### Test bed details ################ # TG --- DUT --- TG ################################################# # Configuring traffic stream on the TG interface tr1 = tg.tg_traffic_config( port_handle=tg_handler["tg_ph_2"], emulation_src_handle=h2['handle'], emulation_dst_handle=bgp_rtr1['route'][0]['handle'], circuit_endpoint_type='ipv4', mode='create', transmit_mode='continuous', length_mode='fixed', rate_pps=data.traffic_rate_pps, enable_stream_only_gen='0') # Verify the total route count using bcmcmd if not check_bcmcmd_route_count(dut, 50, "ipv4", def_v4_route_count, data.test_bgp_route_count): st.report_fail("route_table_not_updated_by_advertise_from_tg") # Verify the total route count count = verify_bgp_route_count(dut, family='ipv4', neighbor=data.neigh_ip_addr, state='Established') st.log("Route count: " + str(count)) if int(count) != int(data.test_bgp_route_count): st.report_fail("route_table_not_updated_by_advertise_from_tg") # Starting the TG traffic after clearing the DUT counters papi.clear_interface_counters(dut) tg.tg_traffic_control(action="run", handle=tr1['stream_id']) st.wait(25) # Verifying the BGP route count on the DUT if not check_intf_traffic_counters(dut, 20, "install"): st.report_fail("ingress_traffic_rate_not_matching_with_egress_rate") # Clearing the BGP session. st.log("Clearing the BGP session.") bgpfeature.clear_ip_bgp(dut) st.banner( "# Measuring Convergence time ( control plane + data plane ) taken for BGP session failover scenario on HWSKU {}" .format(hwsku_under_test)) # Taking the start time timestamp start_time = datetime.datetime.now() bgpfeature.config_bgp(dut=vars.D1, local_as=data.as_num, config='yes', neighbor=data.neigh_ip_addr, config_type_list=["connect"], connect='1') # Verify the total route count using bcmcmd if not check_bcmcmd_route_count(dut, 50, "ipv4", def_v4_route_count, data.test_bgp_route_count): st.report_fail("route_table_not_updated_by_advertise_from_tg") # Verify the total route count count = verify_bgp_route_count(dut, family='ipv4', neighbor=data.neigh_ip_addr, state='Established') st.log("Route count: " + str(count)) if int(count) != int(data.test_bgp_route_count): st.report_fail("route_table_not_updated_by_advertise_from_tg") # Taking the end time timestamp end_time = datetime.datetime.now() # Time taken for route installation st.log("Start Time: {}".format(start_time)) st.log("End Time: {}".format(end_time)) time_in_secs = end_time - start_time st.banner( "Convergence time ( control plane + data plane ) taken for BGP session failover scenario (After session up, time taken for BGP to re establish, learn and install the routes to hardware) on HWSKU {} = " .format(hwsku_under_test) + str(time_in_secs.seconds)) # Stopping the TG traffic tg.tg_traffic_control(action='stop', handle=tr1['stream_id']) st.report_pass("test_case_passed")
def test_ft_l3_performance_enhancements_v6_route_intstall_withdraw(fixture_v6): ################# Author Details ################ # Name: Rakesh Kumar Vooturi # Email: [email protected] ################################################# # # Objective - FtOpSoRtPerfFn042 : Performance measurement for IPv6 route installation in hardware # Measure time taken for routes to get installed into the hardware # (with fresh advertisement of routes ...but not due to any other trigger). # Objective - FtOpSoRtPerfFn043 : Performance measurement for IPv6 route withdraw in hardware # Measure time taken for routes to get removed from the hardware by stop advertising the Routes from neighbor. # ############### Test bed details ################ # TG --- DUT --- TG ################################################# # Withdraw the routes. ctrl1 = tg.tg_bgp_routes_control( handle=bgp_rtr2['conf']['handle'], route_handle=bgp_rtr2['route'][0]['handle'], mode='withdraw') st.log("TR_CTRL: " + str(ctrl1)) # Verify the total route count using bcmcmd if not check_bcmcmd_route_count(dut, 50, "ipv6", def_v6_route_count, 0): st.report_fail("route_table_not_cleared_by_withdraw_from_tg") # Verify the total route count count = verify_bgp_route_count(dut, family='ipv6', neighbor=data.neigh_ipv6_addr, state='Established') st.log("Route count: " + str(count)) if int(count) != 0: st.report_fail("route_table_not_cleared_by_withdraw_from_tg") if data.includeTraffic: # Configuring traffic stream on the TG interface tr2 = tg.tg_traffic_config( port_handle=tg_handler["tg_ph_2"], emulation_src_handle=h2['handle'], emulation_dst_handle=bgp_rtr2['route'][0]['handle'], circuit_endpoint_type='ipv6', mode='create', transmit_mode='continuous', length_mode='fixed', rate_pps=data.traffic_rate_pps, enable_stream_only_gen='0') # Starting the TG traffic after clearing the DUT counters papi.clear_interface_counters(dut) tg.tg_traffic_control(action="run", handle=tr2['stream_id']) st.banner( "# Measuring time taken for route installation of {} ipv6 routes on HWSKU {}" .format(data.test_bgp_route_count, hwsku_under_test)) # Taking the start time timestamp start_time = datetime.datetime.now() # Readvertise the routes. ctrl1 = tg.tg_bgp_routes_control( handle=bgp_rtr2['conf']['handle'], route_handle=bgp_rtr2['route'][0]['handle'], mode='readvertise') st.log("TR_CTRL: " + str(ctrl1)) # Verify the total route count using bcmcmd if not check_bcmcmd_route_count(dut, 50, "ipv6", def_v6_route_count, data.test_bgp_route_count): st.report_fail("route_table_not_updated_by_advertise_from_tg") if data.includeTraffic: st.wait(25) # Verifying the BGP route count on the DUT if not check_intf_traffic_counters(dut, 20, "install"): st.report_fail( "ingress_traffic_rate_not_matching_with_egress_rate") # Taking the end time timestamp end_time = datetime.datetime.now() # Verify the total route count count = verify_bgp_route_count(dut, family='ipv6', neighbor=data.neigh_ipv6_addr, state='Established') st.log("Route count: " + str(count)) if int(count) != int(data.test_bgp_route_count): st.report_fail("route_table_not_updated_by_advertise_from_tg") # Time taken for route installation st.log("Start Time: {}".format(start_time)) st.log("End Time: {}".format(end_time)) time_in_secs = end_time - start_time st.banner("Time taken for intsalling {} v6 routes on HWSKU {} = ".format( data.test_bgp_route_count, hwsku_under_test) + str(time_in_secs.seconds)) st.banner( "# Measuring time taken for route withdraw of {} ipv4 routes on HWSKU {}" .format(data.test_bgp_route_count, hwsku_under_test)) # Taking the start time timestamp start_time = datetime.datetime.now() # Withdraw the routes. ctrl1 = tg.tg_bgp_routes_control( handle=bgp_rtr2['conf']['handle'], route_handle=bgp_rtr2['route'][0]['handle'], mode='withdraw') st.log("TR_CTRL: " + str(ctrl1)) # Verify the total route count using bcmcmd if not check_bcmcmd_route_count(dut, 50, "ipv6", def_v6_route_count, 0): st.report_fail("route_table_not_cleared_by_withdraw_from_tg") if data.includeTraffic: # Verifying the BGP route count on the DUT if not check_intf_traffic_counters(dut, 20, "withdraw"): st.report_fail("egress_traffic_rate_not_zero") # Taking the end time timestamp end_time = datetime.datetime.now() # Verify the total route count count = verify_bgp_route_count(dut, family='ipv6', neighbor=data.neigh_ipv6_addr, state='Established') st.log("Route count: " + str(count)) if int(count) != 0: st.report_fail("route_table_not_cleared_by_withdraw_from_tg") # Time taken for route withdraw st.log("Start Time: {}".format(start_time)) st.log("End Time: {}".format(end_time)) time_in_secs = end_time - start_time st.banner("Time taken for withdrawing {} v6 routes on HWSKU {} = ".format( data.test_bgp_route_count, hwsku_under_test) + str(time_in_secs.seconds)) if data.includeTraffic: # Stopping the TG traffic tg.tg_traffic_control(action='stop', handle=tr2['stream_id']) st.report_pass("test_case_passed")