def test_ft_ipv6_link_local_static_rt_ecmp(): result_flag=0 st.log("Clearing all interface counters") utils.exec_all(True, [[intf_obj.clear_interface_counters, vars.D1], [intf_obj.clear_interface_counters, vars.D2]]) tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"]) st.wait(data.pkts_tx_time) tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"]) verify_traffic_hash(vars.D1,[vars.D1D2P1, vars.D1D2P2, vars.D1D2P3, vars.D1D2P4], data.pkts_per_port) traffic_details = { '1': { 'tx_ports': [vars.T1D1P1], 'tx_obj': [tg1], 'exp_ratio': [1], 'rx_ports': [vars.T1D2P1], 'rx_obj': [tg2], } } filter_result = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type='packet_count') if not filter_result: st.log("Traffic loss observed for ipv6 traffic forwarded via ipv6 link local next hop") result_flag = 1 if result_flag: st.report_fail("ip6_traffic_over_link_local_nh_fail") st.report_pass("test_case_passed")
def test_ft_erspan_warm_reboot(): """ Author: Anil Kumar Kacharla<*****@*****.**> Verify that ERSPAN is working as expected and intended traffic is mirrored to remote interface while warm reboot """ data.tg1.tg_traffic_control(action="clear_stats", port_handle=data.tg_ph_1) data.tg2.tg_traffic_control(action="clear_stats", port_handle=data.tg_ph_2) data.tg1.tg_traffic_control(action='run', stream_handle=data.stream) st.wait(5) st.log("performing Config save") rb_obj.config_save(vars.D1) st.log("performing warm-reboot") st.reboot(vars.D1, 'warm') st.log("Stop the traffic") data.tg1.tg_traffic_control(action='stop', stream_handle=data.stream) st.wait(10) st.log("verifying traffic after warm reboot") filter_result = tgapi.validate_tgen_traffic( traffic_details=data.traffic_details, mode='aggregate', comp_type='packet_count') if not filter_result: st.log("traffic verification failed") st.report_fail("operation_failed") else: st.log("ERSPAN traffic verification is successful") st.log("verifying erspan configuration after warm reboot") erspan_pre_config_verify() st.report_pass("test_case_passed")
def test_ft_port_frame_fwd_diff_mtu(): intfapi.get_interface_property(vars.D1, vars.D1T1P1, "mtu") intfapi.get_interface_property(vars.D1, vars.D1T1P2, "mtu") st.log("Configuring MTU values for each interface") intfapi.interface_properties_set(vars.D1, [vars.D1T1P1, vars.D1T1P2], 'mtu', intf_data.mtu1) intf_data.tg.tg_traffic_control(action='run', stream_handle=[intf_data.streams['mtu1'], intf_data.streams['mtu2']]) st.wait(2) intf_data.tg.tg_traffic_control(action='stop', stream_handle=[intf_data.streams['mtu1'], intf_data.streams['mtu2']]) st.log("Fetching TGen statistics") traffic_details = { '1': { 'tx_ports': [vars.T1D1P1], 'tx_obj': [intf_data.tg], 'exp_ratio': [[1, 0]], 'rx_ports': [vars.T1D1P2], 'rx_obj': [intf_data.tg], 'stream_list': [[intf_data.streams['mtu1'], intf_data.streams['mtu2']]], }, } streamResult = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='streamblock', comp_type='packet_count') if not streamResult: st.report_fail("traffic_transmission_failed", vars.T1D1P1) st.report_pass("test_case_passed")
def verify_traffic(tx_stream_list, rx_stream_list=[], tx_port="", rx_port="", tx_ratio=1, rx_ratio=1, mode="streamblock", field="packet_count"): ''' :param tx_port: :param rx_port: :param tx_ratio: :param rx_ratio: :param mode: :param field: :param tx_stream_list: :param rx_stream_list: :return: ''' if not tx_port: tx_port = tg_dict["d1_tg_port1"] if not rx_port: rx_port = tg_dict["d3_tg_port1"] if rx_stream_list: traffic_details = { '1': { 'tx_ports': [tx_port], 'tx_obj': [tg_dict["tg"]], 'exp_ratio': [tx_ratio], 'rx_ports': [rx_port], 'rx_obj': [tg_dict["tg"]], 'stream_list': [tuple(tx_stream_list)] }, '2': { 'tx_ports': [rx_port], 'tx_obj': [tg_dict["tg"]], 'exp_ratio': [rx_ratio], 'rx_ports': [tx_port], 'rx_obj': [tg_dict["tg"]], 'stream_list': [tuple(rx_stream_list)] } } else: traffic_details = { '1': { 'tx_ports': [tx_port], 'tx_obj': [tg_dict["tg"]], 'exp_ratio': [tx_ratio], 'rx_ports': [rx_port], 'rx_obj': [tg_dict["tg"]], 'stream_list': [tuple(tx_stream_list)] } } return tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode=mode, comp_type=field, tolerance_factor=1)
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 test_ft_dynamic_nat_warmboot(): # ################ Author Details ################ # Name: Kesava Swamy Karedla # Eamil: [email protected] # ################################################ # Objective - FtOpSoRoNatWb001 - Verify warm boot with dynamic nat scaling entries. # ################################################# result_flag=0 platform = basic_obj.get_hwsku(vars.D1) common_constants = st.get_datastore(vars.D1, "constants", "default") if not platform.lower() in common_constants['WARM_REBOOT_SUPPORTED_PLATFORMS']: st.error("Warm-Reboot is not supported for this platform {}".format(platform)) st.report_unsupported('test_case_unsupported') nat_obj.clear_nat(vars.D1, translations=True) nat_obj.config_nat_pool_binding(vars.D1, binding_name=data.bind_name[0], pool_name=data.pool_name[0], config=data.config_del) nat_obj.config_nat_pool_binding(vars.D1, binding_name="scale_bind", pool_name="scale_pool", acl_name=data.acl_table_in_nat_eg, config=data.config_add) st.log("Sending continuous traffic at 600 pps for the max dynamic nat entries to get learned") tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_scale_nat_udp_data_str_id_1"]) st.log("Waiting for traffic to run, such that max nat entries get learned") if not util_check_nat_translations_count(vars.D1,20,data.max_nat_entries): nat_reboot_debug_fun() st.log("Failed to learn max nat entries") result_flag = 1 tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_scale_nat_udp_data_str_id_1"]) # Show command for debugging purpose in case of failures. intf_obj.show_interface_counters_all(vars.D1) st.log("Warm boot verification") tgapi.traffic_action_control(tg_handler, actions=['clear_stats']) tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_scale_nat_udp_data_str_id_1"]) st.log("Performing warm-reboot, while traffic is forwarding for nat entries") st.reboot(vars.D1, 'warm') tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_scale_nat_udp_data_str_id_1"]) traffic_details = { '1': { 'tx_ports': [vars.T1D1P1], 'tx_obj': [tg1], 'exp_ratio': [1], 'rx_ports': [vars.T1D1P2], 'rx_obj': [tg2], } } filter_result = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type='packet_count') if not filter_result: nat_reboot_debug_fun() st.log("Traffic loss observed for the SNAT traffic during warm-boot") result_flag = 1 nat_obj.config_nat_pool_binding(vars.D1, binding_name=data.bind_name[1], pool_name=data.pool_name[1], config=data.config_add) nat_obj.config_nat_pool_binding(vars.D1, binding_name="scale_bind", pool_name="scale_pool", acl_name=data.acl_table_in_nat_eg, config=data.config_del) if result_flag: st.report_fail("nat_warm_reboot_failed") st.report_pass("test_case_passed")
def test_ft_ipv6_link_local_manual(): result_flag = 0 st.log("Clearing all interface counters") utils.exec_all(True, [[intf_obj.clear_interface_counters, vars.D1], [intf_obj.clear_interface_counters, vars.D2]]) st.log("clearing TG stats") tgapi.traffic_action_control(tg_handler, actions=['clear_stats']) ip_obj.delete_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, 'ipv6', "vtysh", data.prt_chnl) utils.exec_all(True, [[ip_obj.config_interface_ip6_link_local,vars.D1, data.prt_chnl, 'disable'], [ip_obj.config_interface_ip6_link_local,vars.D2, data.prt_chnl, 'disable']]) utils.exec_all(True, [[ip_obj.config_ip_addr_interface, vars.D1, data.prt_chnl, data.ip6_manual_ll_addr[0], data.tg_ip6_addr_mask_l[0], "ipv6", 'add'], [ip_obj.config_ip_addr_interface, vars.D2, data.prt_chnl, data.ip6_manual_ll_addr[1], data.tg_ip6_addr_mask_l[1], "ipv6", 'add']]) utils.exec_all(True, [ [ip_obj.create_static_route, vars.D1, data.ip6_manual_ll_addr[1], data.static_rt_manual, "vtysh", 'ipv6', data.prt_chnl], [ip_obj.create_static_route, vars.D2, data.tg_ip6_addr_l[1], data.static_rt_manual, "vtysh", 'ipv6', vars.D2T1P1]]) utils.exec_all(True, [[ip_obj.get_interface_ip_address, vars.D1, None, "ipv6"], [ip_obj.get_interface_ip_address, vars.D2, None, "ipv6"]]) st.log("Get show ipv6 route output") utils.exec_all(True, [[ip_obj.show_ip_route, vars.D1, "ipv6", "sonic", None], [ip_obj.show_ip_route, vars.D2, "ipv6", "sonic", None]]) tg1.tg_traffic_config(mode='modify', stream_id=tg_str_data[1]["tg1_ipv6_data_str_id_1"], ipv6_dst_addr=data.static_rt_manual_ip) if not poll_verify_interface_ip_address(vars.D1, data.prt_chnl, ["{}%{}/64".format(data.ip6_manual_ll_addr[0], data.prt_chnl), "{}/64".format(data.ip6_manual_ll_addr[0])],10): result_flag = 1 if not ip_obj.ping(vars.D1, data.ip6_manual_ll_addr[1], family='ipv6', interface = data.prt_chnl): st.log("Ipv6 Ping over manual ipv6 Link Local address via the Port Channel based routing interface is failed.") result_flag =1 tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"]) st.wait(1) tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"]) tgapi.traffic_action_control(tg_handler, actions=['clear_stats']) tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"]) st.wait(data.pkts_tx_time) tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"]) traffic_details = { '1': { 'tx_ports': [vars.T1D1P1], 'tx_obj': [tg1], 'exp_ratio': [1], 'rx_ports': [vars.T1D2P1], 'rx_obj': [tg2], } } filter_result = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type='packet_count') if not filter_result: st.log("traffic loss observed for ipv6 traffic forwarded via ipv6 link local next hop") result_flag = 1 if result_flag: st.log("Show command for debugging purpose in case of failures") utils.exec_all(True, [[intf_obj.show_interface_counters_all, vars.D1], [intf_obj.show_interface_counters_all, vars.D2]]) st.report_fail("ip6_traffic_over_link_local_nh_fail_manual") st.report_pass("test_case_passed")
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_ft_ipv6_link_local_nh_change(): report_flag = 0 st.log("Clearing all interface counters") utils.exec_all(True, [[intf_obj.clear_interface_counters, vars.D1], [intf_obj.clear_interface_counters, vars.D2]]) st.log("clearing TG stats") tgapi.traffic_action_control(tg_handler, actions=['clear_stats']) st.log("Remove the vlan participation to bring down the Vlan routing intf") vlan_obj.delete_vlan_member(vars.D1, data.vlan_li[0], vars.D1D2P2, tagging_mode=True) vlan_obj.add_vlan_member(vars.D1, data.vlan_li[0], vars.D1D2P2, tagging_mode=True) if not ip_obj.get_link_local_addresses(vars.D1, data.vlan_in_1): st.error("ipv6 link local addr is not auto generated after remove and re add of vlan routing intf") report_flag = 1 pc_obj.add_del_portchannel_member(vars.D1, data.prt_chnl, [vars.D1D2P3, vars.D1D2P4], flag="del", skip_verify=True) pc_obj.add_del_portchannel_member(vars.D1, data.prt_chnl, [vars.D1D2P3, vars.D1D2P4], flag="add", skip_verify=True) if not ip_obj.get_link_local_addresses(vars.D1, data.prt_chnl): st.error("ipv6 link local addr is not auto generated for {} after remove and re add of members".format(data.prt_chnl)) report_flag = 1 if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = vars.D1D2P1): st.log("Ipv6 Ping over Link Local address via the Port based routing interface is failed.") report_flag = 1 if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = data.vlan_in_1): st.log("Ipv6 Ping over Link Local address via the Vlan based routing interface is failed.") report_flag =1 if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = data.prt_chnl): st.log("Ipv6 Ping over Link Local address via the Port Channel based routing interface is failed.") report_flag =1 utils.exec_all(True, [[get_mac, vars.D1] ,[get_mac, vars.D2]]) st.log("Checking the IPv6 traffic forwarding over ECMP next hops after remove and re adding of next hop interfaces") tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"]) st.wait(data.pkts_tx_time) tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"]) ecmp_cntrs = verify_traffic_hash(vars.D1, [vars.D1D2P1, vars.D1D2P2, vars.D1D2P3, vars.D1D2P4], data.pkts_per_port) st.log("Counter stats on next hop interfaces - {}".format(ecmp_cntrs)) traffic_details = { '1': { 'tx_ports': [vars.T1D1P1], 'tx_obj': [tg1], 'exp_ratio': [1], 'rx_ports': [vars.T1D2P1], 'rx_obj': [tg2], } } filter_result = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type='packet_count') if not filter_result: st.log("After flap in next hop interfaces, traffic loss observed for ipv6 traffic forwarded via ipv6 link local next hop") report_flag = 1 if report_flag: st.report_fail("ip6_traffic_over_link_local_nh_fail") st.report_pass("test_case_passed")
def test_ft_ip_static_route_traffic_forward(): # Objective - Verify the Ipv4 traffic forwarding over IPv4 static route. tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D2P1") tg = tg_handler["tg"] tg.tg_traffic_control(action="reset", port_handle=tg_handler["tg_ph_list"]) tg.tg_traffic_control(action="clear_stats", port_handle=tg_handler["tg_ph_list"]) dut_rt_int_mac1 = basic_obj.get_ifconfig_ether(vars.D1, vars.D1T1P1) h1 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_1"], mode='config', intf_ip_addr=data.ip4_addr[0], \ gateway=data.ip4_addr[1], src_mac_addr=data.tg_mac1, arp_send_req='1') st.log("INTFCONF: " + str(h1)) h2 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_2"], mode='config', intf_ip_addr=data.ip4_addr[9], \ gateway=data.ip4_addr[8], src_mac_addr=data.tg_mac2, arp_send_req='1') st.log("INTFCONF: " + str(h2)) # Ping from tgen to DUT. res = tgapi.verify_ping(src_obj=tg, port_handle=tg_handler["tg_ph_1"], dev_handle=h1['handle'], dst_ip=data.ip4_addr[1], \ ping_count='1', exp_count='1') if res: st.log("Ping succeeded.") else: st.warn("Ping failed.") tr1 = tg.tg_traffic_config(port_handle=tg_handler["tg_ph_1"], mode='create', transmit_mode='single_burst', pkts_per_burst=2000, \ length_mode='fixed', rate_pps=2000, l3_protocol='ipv4', mac_src=data.tg_mac1, \ mac_dst=dut_rt_int_mac1, ip_src_addr=data.ip4_addr[0], ip_dst_addr=data.ip4_addr[9]) st.log("TRAFCONF: " + str(tr1)) res = tg.tg_traffic_control(action='run', stream_handle=tr1['stream_id']) st.log("TR_CTRL: " + str(res)) tg.tg_traffic_control(action='stop', stream_handle=tr1['stream_id']) st.log("Checking the stats and verifying the traffic flow") traffic_details = { '1': { 'tx_ports': [vars.T1D1P1], 'tx_obj': [tg_handler["tg"]], 'exp_ratio': [1], 'rx_ports': [vars.T1D2P1], 'rx_obj': [tg_handler["tg"]], } } #verify statistics aggrResult = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type='packet_count') if not aggrResult: st.report_fail("traffic_verification_failed") st.report_pass("test_case_passed")
def test_ft_ipv6_link_local_vrf(): report_flag = 0 st.log("Clearing all interface counters") utils.exec_all(True, [[intf_obj.clear_interface_counters, vars.D1], [intf_obj.clear_interface_counters, vars.D2]]) st.log("clearing TG stats") tgapi.traffic_action_control(tg_handler, actions=['clear_stats']) st.log("Check the auto configured ipv6 link local address for VRF interface") if not ip_obj.get_link_local_addresses(vars.D1, data.vlan_in_2): st.log( "Ipv6 link local address is not auto generated for VRF binded vlan based routing interface {}".format(data.vlan_in_2)) report_flag = 1 ip_obj.show_ip_route(vars.D1, "ipv6", "sonic", data.vrf_name) st.log("binding the TG connected interface to VRF {}".format(data.vrf_name)) ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P1, data.tgd_ip6_addr_l[0], data.tg_ip6_addr_mask_l[0], "ipv6", 'remove') vrf_obj.bind_vrf_interface(vars.D1, vrf_name=data.vrf_name, intf_name=vars.D1T1P1, config='yes', skip_error=True) ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P1, data.tgd_ip6_addr_l[0],data.tg_ip6_addr_mask_l[0], "ipv6", 'add') tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"]) st.wait(data.pkts_tx_time) tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"]) # Show command for debugging purpose in case of failures. utils.exec_all(True, [[intf_obj.show_interface_counters_all, vars.D1], [intf_obj.show_interface_counters_all, vars.D2]]) traffic_details = { '1': { 'tx_ports': [vars.T1D1P1], 'tx_obj': [tg1], 'exp_ratio': [1], 'rx_ports': [vars.T1D2P1], 'rx_obj': [tg2], } } filter_result = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type='packet_count') if not filter_result: st.log( "After flap in next hop interfaces, traffic loss observed for ipv6 traffic forwarded via ipv6 link local next hop") report_flag = 1 if report_flag: vrf_obj.bind_vrf_interface(vars.D1, vrf_name=data.vrf_name, intf_name=vars.D1T1P1, config='no', skip_error=True) ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P1, data.tgd_ip6_addr_l[0], data.tg_ip6_addr_mask_l[0], "ipv6", 'add') st.report_fail("ip6_traffic_over_link_local_nh_fail_vrf") ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P1, data.tgd_ip6_addr_l[0], data.tg_ip6_addr_mask_l[0], "ipv6", 'remove') vrf_obj.bind_vrf_interface(vars.D1, vrf_name=data.vrf_name, intf_name=vars.D1T1P1, config='no', skip_error=True) ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P1, data.tgd_ip6_addr_l[0],data.tg_ip6_addr_mask_l[0], "ipv6", 'add') st.report_pass("test_case_passed")
def verify_packet_count(tx, tx_port, rx, rx_port, table): result = True tg_tx = data.tgmap[tx] tg_rx = data.tgmap[rx] exp_ratio = 0 attr_list = [] traffic_details = dict() action_list = [] index = 0 for s_id, attr in tg_tx['streams'].items(): if table in attr['TABLE']: index = index + 1 if attr["PACKET_ACTION"] == "FORWARD": exp_ratio = 1 action = "FORWARD" else: exp_ratio = 0 action = "DROP" traffic_details[str(index)] = { 'tx_ports': [tx_port], 'tx_obj': [tg_tx["tg"]], 'exp_ratio': [exp_ratio], 'rx_ports': [rx_port], 'rx_obj': [tg_rx["tg"]], 'stream_list': [[s_id]] } attr_list.append(attr) action_list.append(action) result_all = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='streamblock', comp_type='packet_count', return_all=1, delay_factor=1.2) for result1, action, attr in zip(result_all[1], action_list, attr_list): result = result and result1 if result1: if action == "FORWARD": msg = "Traffic successfully forwarded for the rule: {}".format(json.dumps(attr)) print_log(msg) else: msg = "Traffic successfully dropped for the rule: {}".format(json.dumps(attr)) print_log(msg) else: if action == "FORWARD": msg = "Traffic failed to forward for the rule: {}".format(json.dumps(attr)) print_log(msg) else: msg = "Traffic failed to drop for the rule: {}".format(json.dumps(attr)) print_log(msg) return result
def verify_traffic(field, type='l2'): global sp_ratio_1, sp_ratio_2 if type == 'l2' or type == 'l3': traffic_details = { '1': { 'tx_ports': [vars.T1D1P1], 'tx_obj': [tg], 'exp_ratio': [1], 'rx_ports': [vars.T1D1P2], 'rx_obj': [tg], }, } else: if type == 'dwrr_scheduling': sp_ratio_1, sp_ratio_2 = 0.3, 0.7 elif type == 'sp_dwrr_scheduling': sp_ratio_1, sp_ratio_2 = 0.008, 1 else: sp_ratio_1, sp_ratio_2 = 0.015, 1 traffic_details = { '1': { 'tx_ports': [vars.T1D1P1], 'tx_obj': [tg], 'exp_ratio': [sp_ratio_1], 'rx_ports': [vars.T1D2P1], 'rx_obj': [tg], 'tolerance_factor': '3' }, '2': { 'tx_ports': [vars.T1D1P2], 'tx_obj': [tg], 'exp_ratio': [sp_ratio_2], 'rx_ports': [vars.T1D2P2], 'rx_obj': [tg], 'tolerance_factor': '2' }, } return tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type=field)
def test_ft_ipv6_link_local_warm_boot(): result_flag=0 ip_obj.delete_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, 'ipv6', "vtysh", data.prt_chnl) st.log("Clearing all interface counters") utils.exec_all(True, [[intf_obj.clear_interface_counters, vars.D1], [intf_obj.clear_interface_counters, vars.D2]]) utils.exec_all(True, [[ip_obj.show_ip_route, vars.D1, "ipv6", "sonic", None], [ip_obj.show_ip_route, vars.D2, "ipv6", "sonic", None]]) tg1.tg_traffic_config(mode='modify', stream_id=tg_str_data[1]["tg1_ipv6_data_str_id_1"], ipv6_dst_addr=data.static_rt_ip) st.log("clearing TG stats") tgapi.traffic_action_control(tg_handler, actions=['clear_stats']) tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"]) st.log("Performing warm-reboot, while ipv6 traffic is forwarding via link local next hops ") st.reboot(vars.D1, 'warm') tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"]) verify_traffic_hash(vars.D1,[vars.D1D2P1, vars.D1D2P2], data.pkts_per_port) traffic_details = { '1': { 'tx_ports': [vars.T1D1P1], 'tx_obj': [tg1], 'exp_ratio': [1], 'rx_ports': [vars.T1D2P1], 'rx_obj': [tg2], } } filter_result = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type='packet_count') if not filter_result: st.log("During Warm boot, traffic loss observed for ipv6 traffic forwarded via ipv6 link local next hop") result_flag = 1 if result_flag: utils.exec_all(True, [[ip_obj.get_interface_ip_address, vars.D1, None, "ipv6"], [ip_obj.get_interface_ip_address, vars.D2, None, "ipv6"]]) utils.exec_all(True, [[ip_obj.show_ip_route, vars.D1, "ipv6", "sonic", None], [ip_obj.show_ip_route, vars.D2, "ipv6", "sonic", None]]) utils.exec_all(True, [[intf_obj.show_interface_counters_all, vars.D1], [intf_obj.show_interface_counters_all, vars.D2]]) st.report_fail("ip6_traffic_over_link_local_nh_fail") st.report_pass("test_case_passed")
def test_ft_arp_clear_cache_static_and_dynamic_entries( fixture_ft_arp_clear_cache_static_and_dynamic_entries): ################## Author Details ############### # Name: Rakesh Kumar Vooturi # Email: [email protected] ################################################# # # Objective - Verify that the clearing the ARP cache, # all dynamic entries are removed and static entries are not cleared. # ############### Test bed details ################ # TG-----DUT-----TG ################################################# # Adding static arp entries arp_obj.add_static_arp(dut1, data.static_arp_ip_1, data.static_arp_mac_1, vars.D1T1P1) arp_obj.add_static_arp(dut1, data.static_arp_ip, data.static_arp_mac, data.vlan_int_1) res = tgapi.verify_ping(src_obj=tg, port_handle=tg_handler["tg_ph_1"], dev_handle=h1['handle'], dst_ip=data.d1t1_ip_addr, ping_count='1', exp_count='1') if res: st.log("Ping succeeded.") else: st.warn("Ping failed.") res = tgapi.verify_ping(src_obj=tg, port_handle=tg_handler["tg_ph_2"], dev_handle=h2['handle'], dst_ip=data.d1t2_ip_addr, ping_count='1', exp_count='1') if res: st.log("Ping succeeded.") else: st.warn("Ping failed.") # Verify static and dynamic arp entries st.log("Verifying the arp entries on the DUT") if not arp_obj.verify_arp(dut1, data.t1d1_ip_addr, data.t1d1_mac_addr, vars.D1T1P1): st.report_fail("ARP_entry_dynamic_entry_fail", data.t1d1_ip_addr, dut1) if not arp_obj.verify_arp(dut1, data.t2d1_ip_addr, data.t2d1_mac_addr, vars.D1T1P2, data.vlan_1): st.report_fail("ARP_entry_dynamic_entry_fail", data.t2d1_ip_addr, dut1) if not arp_obj.verify_arp(dut1, data.static_arp_ip_1, data.static_arp_mac_1, vars.D1T1P1): st.report_fail("static_arp_create_fail", dut1) if not arp_obj.verify_arp(dut1, data.static_arp_ip, data.static_arp_mac, "", data.vlan_1): st.report_fail("static_arp_create_fail", dut1) st.banner( "Start - Verifying dynamic and static arp entries behavior on issuing sonic-clear arp command *WITH* traffic flowing" ) # TG ports reset st.log("Resetting the TG ports") tg.tg_traffic_control(action="clear_stats", port_handle=tg_handler["tg_ph_list"]) #TG stream formation s1 = tg.tg_traffic_config(port_handle=tg_handler["tg_ph_2"], mode='create', rate_pps=10, mac_src=data.t2d1_mac_addr, transmit_mode="continuous", mac_dst=d1_mac_addr, l2_encap='ethernet_ii_vlan', l3_protocol="ipv4", ip_dst_addr=data.t1d1_ip_addr, ip_src_addr=data.t2d1_ip_addr, vlan_id=data.vlan_1, vlan="enable") s2 = tg.tg_traffic_config(port_handle=tg_handler["tg_ph_1"], mode='create', rate_pps=10, mac_src=data.t1d1_mac_addr, transmit_mode="continuous", mac_dst=d1_mac_addr, l2_encap='ethernet_ii_vlan', l3_protocol="ipv4", ip_dst_addr=data.t2d1_ip_addr, ip_src_addr=data.t1d1_ip_addr) tg.tg_traffic_control(action="run", stream_handle=[s1['stream_id'], s2['stream_id']]) # Adding wait for traffic to flow. st.wait(5) # Issuing sonic-clear arp command and veryfying the entries behavior. arp_obj.clear_arp_table(dut1) # Adding wait for traffic to flow. st.wait(5) # Verify static and dynamic arp entries after clear arp st.log( "Verifying the arp entries on the DUT after issuing sonic-clear arp command with traffic flowing." ) if not arp_obj.verify_arp(dut1, data.t1d1_ip_addr, data.t1d1_mac_addr, vars.D1T1P1): st.report_fail("ARP_entry_dynamic_entry_fail", data.t1d1_ip_addr, dut1) if not arp_obj.verify_arp(dut1, data.t2d1_ip_addr, data.t2d1_mac_addr, vars.D1T1P2, data.vlan_1): st.report_fail("ARP_entry_dynamic_entry_fail", data.t2d1_ip_addr, dut1) if not arp_obj.verify_arp(dut1, data.static_arp_ip_1, data.static_arp_mac_1, vars.D1T1P1): st.report_fail("static_arp_delete_fail", dut1) if not arp_obj.verify_arp(dut1, data.static_arp_ip, data.static_arp_mac, "", data.vlan_1): st.report_fail("static_arp_delete_fail", dut1) # Stop the traffic tg.tg_traffic_control(action="stop", stream_handle=[s1['stream_id'], s2['stream_id']]) st.log("Verifying the TG stats") 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") else: st.log("traffic verification passed") st.banner( "End - Verified dynamic and static arp entries behavior on issuing sonic-clear arp command *WITH* traffic flowing" ) st.banner( "Start - Verifying dynamic and static arp entries behavior on issuing sonic-clear arp command *WITHOUT* traffic flowing" ) # Issuing sonic-clear arp command and veryfying the entries behavior. arp_obj.clear_arp_table(dut1) # Verify static and dynamic arp entries after clear arp st.log( "Verifying the arp entries on the DUT after issuing sonic-clear arp command" ) if arp_obj.verify_arp(dut1, data.t1d1_ip_addr, data.t1d1_mac_addr, vars.D1T1P1): st.report_fail("ARP_dynamic_entry_clear_arp_fail", data.t1d1_ip_addr, dut1) if arp_obj.verify_arp(dut1, data.t2d1_ip_addr, data.t2d1_mac_addr, vars.D1T1P2, data.vlan_1): st.report_fail("ARP_dynamic_entry_clear_arp_fail", data.t2d1_ip_addr, dut1) if not arp_obj.verify_arp(dut1, data.static_arp_ip_1, data.static_arp_mac_1, vars.D1T1P1): st.report_fail("static_arp_delete_fail", dut1) if not arp_obj.verify_arp(dut1, data.static_arp_ip, data.static_arp_mac, "", data.vlan_1): st.report_fail("static_arp_delete_fail", dut1) st.banner( "End - Verified dynamic and static arp entries behavior on issuing sonic-clear arp command *WITHOUT* traffic flowing" ) st.report_pass("test_case_passed")
def test_fuctPBR_02(): global description global descriptionv6 global vars vars = st.get_testbed_vars() final_result = True description = 'IPv4_ACL_redirect_NH' descriptionv6 = 'IPv6_ACL_redirect_NH' st.log( 'This test covers StSoSeConf014 StSoSeConf015 StSoSeVer014 StSoSeVer015' ) st.log('creating IPv4 static route') ipfeature.create_static_route(dut1, static_ip=srpIP, next_hop=nextHop_ip, shell='') ipfeature.create_static_route(dut1, static_ip=srpIPv6, next_hop=nextHop_ipv6, shell='', family='ipv6') st.log( 'creating IPv4 ACL table and binding to the ports in Ingress direction' ) acl_obj.create_acl_table(dut1, name=acl_table_name, stage=stage, type=type, description=description, ports=[r1_tg_ports1]) acl_obj.create_acl_table(dut1, name=acl_table_namev6, stage=stage, type=typev6, description=descriptionv6, ports=[r1_tg_ports1]) st.log( 'Creating ACL rules with src_ip dst_ip port and action as forward drop' ) acl_obj.create_acl_rule(dut1, table_name=acl_table_name, rule_name=rule_list[0], priority=priority_list[0], packet_action=pktAction + nextHop_ip + '|' + r1_tg_ports2, SRC_IP="{}/{}".format(srpIP, maskACL), DST_IP="{}/{}".format(dstIP, maskACL)) acl_obj.create_acl_rule(dut1, table_name=acl_table_name, rule_name=rule_list[9], priority=priority_list[9], packet_action='drop', IP_TYPE='ipv4any') acl_obj.create_acl_rule(dut1, table_name=acl_table_namev6, rule_name=rule_list[0], priority=priority_list[0], packet_action=pktAction + nextHop_ipv6 + '|' + r1_tg_ports2, SRC_IPV6="{}/{}".format(srpIPv6, '128'), DST_IPV6="{}/{}".format(dstIPv6, '128')) acl_obj.create_acl_rule(dut1, table_name=acl_table_namev6, rule_name=rule_list[9], priority=priority_list[9], packet_action='drop', IP_TYPE='ipv6any') #acl_obj.create_acl_rule(dut1, table_name=acl_table_name, rule_name=rule_list[0],priority=priority_list[0], packet_action=pktAction+nextHop_ip+'|'+r1_tg_ports2, SRC_IP="{}/{}".format(srpIP, maskACL),DST_IP="{}/{}".format(dstIP, maskACL)) start_stop_traffic(tg1, tg2, tg_dut1_p1_handle, tg_dut1_p2_handle) traffic_details = { '1': { 'tx_ports': [vars.T1D1P1], 'tx_obj': [tg1], 'exp_ratio': [[1, 0, 1, 0]], 'rx_ports': [vars.T1D1P2], 'rx_obj': [tg2], 'stream_list': [[stream_id1, stream_id2, stream_id3, stream_id4]] } } test1 = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='streamblock', comp_type='packet_count') if test1 is False: st.error("Traffic Verification Failed") final_result = False t1 = acl_obj.verify_acl_stats(dut1, table_name=acl_table_name, rule_name=rule_list[0], packet_count=expCount) t2 = acl_obj.verify_acl_stats(dut1, table_name=acl_table_name, rule_name=rule_list[9], packet_count=expCount) t3 = acl_obj.verify_acl_stats(dut1, table_name=acl_table_namev6, rule_name=rule_list[0], packet_count=expCount) t4 = acl_obj.verify_acl_stats(dut1, table_name=acl_table_namev6, rule_name=rule_list[9], packet_count=int(expCount) + 16) if False in list(set([t1, t2, t3, t4])): tc = [t1, t2, t3, t4].index(False) print("TC failed for rule : " + str((tc + 1))) st.error("ACL stats validation Failed") final_result = False else: st.log('ACL stats validation Passed') st.log('Deleting IPv4/v6 static route') ipfeature.delete_static_route(dut1, static_ip=srpIP, next_hop=nextHop_ip, shell='') ipfeature.delete_static_route(dut1, static_ip=srpIPv6, next_hop=nextHop_ipv6, shell='', family='ipv6') st.log('Removing the ACL table config') acl_obj.delete_acl_table(dut=dut1, acl_table_name=acl_table_name) acl_obj.delete_acl_table(dut=dut1, acl_table_name=acl_table_namev6) if final_result: st.log( "PBR-Test:Validation of PBR REDIRECT_TO_Next-Hop interface Passed") st.report_pass('test_case_passed') else: st.error( "PBR-Test : Validation of PBR REDIRECT_TO_Next-Hop interface failed" ) st.report_fail('test_case_failed')
def create_v6_route(route_count): vars = st.get_testbed_vars() dut = vars.D1 ipfeature.show_ip_route(dut, family='ipv6') ipfeature.get_interface_ip_address(dut, family='ipv6') bgpfeature.create_bgp_router(dut, data.as_num, '') bgpfeature.create_bgp_neighbor(dut, data.as_num, data.ip6_addr[0], data.remote_as_num, family="ipv6") create_bgp_neighbor_route_map_config(dut, data.as_num, data.ip6_addr[0], data.routemap) tg_handler = tgapi.get_handles_byname("T1D1P2", "T1D2P2") tg = tg_handler["tg"] tg.tg_traffic_control(action="reset", port_handle=tg_handler["tg_ph_list"]) tg.tg_traffic_control(action="clear_stats", port_handle=tg_handler["tg_ph_list"]) dut_rt_int_mac1 = basic_obj.get_ifconfig_ether(vars.D1, vars.D1T1P1) h1 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_1"], mode='config', ipv6_intf_addr=data.ip6_addr[0], \ ipv6_prefix_length='64', ipv6_gateway=data.ip6_addr[1], src_mac_addr=data.tg_mac1, arp_send_req='1') st.log("INTFCONF: " + str(h1)) h2 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_2"], mode='config', ipv6_intf_addr=data.ip6_addr[9], \ ipv6_prefix_length='64', ipv6_gateway=data.ip6_addr[8], src_mac_addr=data.tg_mac2, arp_send_req='1') st.log("INTFCONF: " + str(h2)) # Ping from tgen to DUT. res = tgapi.verify_ping(src_obj=tg, port_handle=tg_handler["tg_ph_1"], dev_handle=h1['handle'], dst_ip=data.ip6_addr[1], \ ping_count='1', exp_count='1') if res: st.log("Ping succeeded.") else: st.warn("Ping failed.") bgp_conf = tg.tg_emulation_bgp_config(handle=h1['handle'], mode='enable', ip_version='6', active_connect_enable='1', local_as=data.as_num, remote_as=data.remote_as_num, remote_ipv6_addr=data.ip6_addr[1]) tg.tg_emulation_bgp_route_config(handle=bgp_conf['handle'], mode='add', ip_version='6', num_routes=route_count, prefix='3300:1::', as_path='as_seq:1') tg.tg_emulation_bgp_control(handle=bgp_conf['handle'], mode='start') # Configuring the BGP router. st.log("BGP neighborship established.") tr1 = tg.tg_traffic_config(port_handle=tg_handler["tg_ph_1"], mode='create', transmit_mode='single_burst', pkts_per_burst=2000, \ length_mode='fixed', rate_pps=2000, l3_protocol='ipv6', mac_src=data.tg_mac1, \ mac_dst=dut_rt_int_mac1, ipv6_src_addr=data.ip6_addr[0], ipv6_dst_addr=data.ip6_addr[9]) st.log("TRAFCONF: " + str(tr1)) res = tg.tg_traffic_control(action='run', stream_handle=tr1['stream_id']) st.log("TR_CTRL: " + str(res)) tg.tg_traffic_control(action='stop', stream_handle=tr1['stream_id']) st.log("Checking the stats and verifying the traffic flow") traffic_details = { '1': { 'tx_ports': [vars.T1D1P2], 'tx_obj': [tg_handler["tg"]], 'exp_ratio': [1], 'rx_ports': [vars.T1D2P2], 'rx_obj': [tg_handler["tg"]], } } # verify statistics aggrResult = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type='packet_count') if not aggrResult: return False else: return True
def create_v4_route(route_count): vars = st.get_testbed_vars() dut = vars.D1 ipfeature.show_ip_route(dut) ipfeature.get_interface_ip_address(dut) intf_obj.interface_status_show(dut) bgpfeature.create_bgp_router(dut, data.as_num, '') bgpfeature.create_bgp_neighbor(dut, data.as_num, data.ip4_addr[0], data.remote_as_num) tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D2P1") tg = tg_handler["tg"] tg.tg_traffic_control(action="reset", port_handle=tg_handler["tg_ph_list"]) tg.tg_traffic_control(action="clear_stats", port_handle=tg_handler["tg_ph_list"]) dut_rt_int_mac1 = basic_obj.get_ifconfig_ether(vars.D1, vars.D1T1P1) h1 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_1"], mode='config', intf_ip_addr=data.ip4_addr[0], \ gateway=data.ip4_addr[1], src_mac_addr=data.tg_mac1, arp_send_req='1') st.log("INTFCONF: " + str(h1)) h2 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_2"], mode='config', intf_ip_addr=data.ip4_addr[9], \ gateway=data.ip4_addr[8], src_mac_addr=data.tg_mac2, arp_send_req='1') st.log("INTFCONF: " + str(h2)) # Ping from tgen to DUT. res = tgapi.verify_ping(src_obj=tg, port_handle=tg_handler["tg_ph_1"], dev_handle=h1['handle'], dst_ip=data.ip4_addr[1], \ ping_count='1', exp_count='1') if res: st.log("Ping succeeded.") else: st.warn("Ping failed.") conf_var = { 'mode': 'enable', 'active_connect_enable': '1', 'local_as': '200', 'remote_as': '100', 'remote_ip_addr': data.ip4_addr[1] } route_var = { 'mode': 'add', 'num_routes': route_count, 'prefix': '121.1.1.0', 'as_path': 'as_seq:1' } ctrl_start = {'mode': 'start'} # Configuring the BGP router. bgp_rtr1 = tgapi.tg_bgp_config(tg=tg, handle=h1['handle'], conf_var=conf_var, route_var=route_var, ctrl_var=ctrl_start) st.log("BGP_HANDLE: " + str(bgp_rtr1)) st.log( "waiting for 10 sec to get the BGP neighbor started before going for another TG operation" ) st.wait(10) # Verified at neighbor. tr1 = tg.tg_traffic_config(port_handle=tg_handler["tg_ph_1"], mode='create', transmit_mode='single_burst', pkts_per_burst=2000, \ length_mode='fixed', rate_pps=2000, l3_protocol='ipv4', mac_src=data.tg_mac1, \ mac_dst=dut_rt_int_mac1, ip_src_addr=data.ip4_addr[0], ip_dst_addr=data.ip4_addr[9]) st.log("TRAFCONF: " + str(tr1)) res = tg.tg_traffic_control(action='run', stream_handle=tr1['stream_id']) st.log("TR_CTRL: " + str(res)) tg.tg_traffic_control(action='stop', stream_handle=tr1['stream_id']) st.log("Checking the stats and verifying the traffic flow") traffic_details = { '1': { 'tx_ports': [vars.T1D1P1], 'tx_obj': [tg_handler["tg"]], 'exp_ratio': [1], 'rx_ports': [vars.T1D2P1], 'rx_obj': [tg_handler["tg"]], } } #verify statistics aggrResult = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type='packet_count') if not aggrResult: return False return True
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_vlan_trunk_tagged(): """ Author:Parvez Alam ([email protected]) Verify that over vlan trunk tagged packets received and be sent out with tag or without tag determined by traffic received from TGen. """ # Start L2 traffic on tg1 and apply vlan_id analayzer filter ifapi.clear_interface_counters(vars.D1) tg.tg_traffic_control(action="clear_stats", port_handle=tg_handler["tg_ph_list"]) tg.tg_traffic_control( action='run', stream_handle=[tg_info['tg1_stream_id'], tg_info['tg2_stream_id']], get='vlan_id') st.wait(5) waitapi.vsonic_mac_learn() learned_mac_address = mac.get_mac_all(vars.D1, sc_data.vlan) if sc_data.source_mac and sc_data.source_mac1 not in learned_mac_address: tg.tg_traffic_control( action='stop', stream_handle=[tg_info['tg1_stream_id'], tg_info['tg2_stream_id']]) st.report_fail("mac_failed_to_learn_in_Particular_vlan", sc_data.vlan) # Stop the traffic and analyzers tg.tg_traffic_control( action='stop', stream_handle=[tg_info['tg1_stream_id'], tg_info['tg2_stream_id']]) st.wait(sc_data.wait_stream_run) st.log("Checking the stats and verifying the traffic flow") traffic_details = { '1': { 'tx_ports': [vars.T1D1P1], 'tx_obj': [tg], 'exp_ratio': [1], 'rx_ports': [vars.T1D1P2], 'rx_obj': [tg], }, '2': { 'tx_ports': [vars.T1D1P2], 'tx_obj': [tg], 'exp_ratio': [1], 'rx_ports': [vars.T1D1P1], 'rx_obj': [tg], } } aggregate_result = tgapi.validate_tgen_traffic( traffic_details=traffic_details, mode='aggregate', comp_type='packet_count') # get tx-pkt count for each streams on tg1 traffic_details = { '1': { 'tx_ports': [vars.T1D1P1], 'tx_obj': [tg], 'exp_ratio': [1], 'rx_ports': [vars.T1D1P2], 'rx_obj': [tg], 'stream_list': [(tg_info['tg1_stream_id'])], 'filter_param': [('vlan')], 'filter_val': [sc_data.vlan], } } # verify analyzer filter statistics filter_result = tgapi.validate_tgen_traffic( traffic_details=traffic_details, mode='filter', comp_type='packet_count') if not aggregate_result: st.report_fail("traffic_verification_failed") elif filter_result: st.log("ALl packets with created vlan tagged received on TG2") st.report_pass("test_case_passed") else: st.log("Drop seen on TG2 for Packets with created vlan") st.report_fail("test_case_failed")
def send_traffic(capture_values, capture_fields, neg_check=False, family='ipv4', verify_capture=False, verify_count=True, tg_src_port= 'tg_ph_1' , **kwargs): """ Author: Lakshminarayana D ([email protected]) :param capture_values: To validate values in cpature packet(Ex: Src_ip: 11.1.1.2) :param capture_fields: To alter offset and header in capture packet :param neg_check: To verify negative traffic scenario :param family: Default address type is ipv4 :param kwargs: Addition parameters to include to TG1 params based on script :return: None (Failed if any traffic step verification) :param tg_src_port: Port from which the traffic is triggered """ # printing arguments passed to function saved_args = locals() st.log("Validating traffic with following parameters: \n\t") for k, v in saved_args.items(): st.log("\t{}: {}".format(k, v)) # Altering required parameters for TG streams (Only for stream params on TG-1) # Altering ip addresses if 'ip_src_addr' in kwargs: ip_src_addr = kwargs['ip_src_addr'] del kwargs['ip_src_addr'] else: ip_src_addr = data.ip_T1D1P1 if 'ip_dst_addr' in kwargs: ip_dst_addr = kwargs['ip_dst_addr'] del kwargs['ip_dst_addr'] else: ip_dst_addr = data.ip_T1D1P2 # Altering mac addresses if 'mac_dst' in kwargs: mac_dst = kwargs['mac_dst'] del kwargs['mac_dst'] else: mac_dst = dut_mac # Altering l3 protocol type if 'l3_protocol' in kwargs: l3_protocol = kwargs['l3_protocol'] del kwargs['l3_protocol'] else: l3_protocol = "ipv4" # Altering pps if 'rate_pps' in kwargs: del kwargs['rate_pps'] if 'pkts_per_burst' in kwargs: pkts_per_burst = kwargs['pkts_per_burst'] del kwargs['pkts_per_burst'] else: pkts_per_burst = data.pkts_per_burst # Altering l4_ports based based on l4 protocol(Ex: tcp : tcp_src_port,tcp_dst_port) if 'l4_protocol' in kwargs: l4proto = 'tcp' if kwargs['l4_protocol'].lower() == 'tcp' else 'udp' if not neg_check: if l4proto + '_src_port' not in kwargs: kwargs[l4proto + '_src_port'] = '2000' if l4proto + '_dst_port' not in kwargs: kwargs[l4proto + '_dst_port'] = '3000' else: if l4proto + '_src_port' not in kwargs: kwargs[l4proto + '_src_port'] = '2001' if l4proto + '_dst_port' not in kwargs: kwargs[l4proto + '_dst_port'] = '3001' # Rest & clear stats on TG ports for action in ['reset']: data.tg1.tg_traffic_control(action=action, port_handle=data.tg_ph_1) data.tg2.tg_traffic_control(action=action, port_handle=data.tg_ph_2) if family == 'ipv4': # Creating IPv4 routing interfaces on TG ports # Configuring ipv4 traffic stream on TG-1/TG-2 based on the tg_src_port argument handle, mac_disc_gw = data.tg_ph_1, data.ip_D1T1P1 if tg_src_port == 'tg_ph_2': handle,mac_disc_gw = data.tg_ph_2, data.ip_D1T1P2 stream = data.tg1.tg_traffic_config(port_handle=handle, mode='create', transmit_mode='single_burst', length_mode='fixed', rate_pps=data.rate_pps, l2_encap='ethernet_ii', mac_src='00:0a:01:00:00:01', mac_dst=mac_dst, l3_protocol=l3_protocol, ip_src_addr=ip_src_addr, ip_dst_addr=ip_dst_addr, mac_discovery_gw=mac_disc_gw, pkts_per_burst=pkts_per_burst, **kwargs) stream1 = stream['stream_id'] else: # Configuring ipv6 traffic stream on TG-1 stream = data.tg1.tg_traffic_config(port_handle=data.tg_ph_1, mode='create', transmit_mode='single_burst', length_mode='fixed', rate_pps=data.rate_pps, l3_protocol='ipv6', mac_discovery_gw='2001:1::1', ipv6_src_addr='2001:1::100', ipv6_dst_addr='2001:2::100', mac_src='00:0a:01:00:00:01', mac_dst=mac_dst, pkts_per_burst=pkts_per_burst) stream1 = stream['stream_id'] ex_ratio = 1 # Fields needed for collecting aggregate stats tx_port, rx_port = vars.T1D1P1, vars.T1D1P2 if tg_src_port == 'tg_ph_2': tx_port, rx_port = vars.T1D1P2, vars.T1D1P1 traffic_details = { '1': { 'tx_ports': [tx_port], 'tx_obj': [data.tg1], 'exp_ratio': [1], 'rx_ports': [rx_port], 'rx_obj': [data.tg2], 'stream_list': [stream1], }, '2': { 'tx_ports': [tx_port], 'tx_obj': [data.tg1], 'exp_ratio': [ex_ratio], 'rx_ports': [vars.T1D2P1], 'rx_obj': [data.tg3], 'stream_list': [stream1], } } # Rest & clear stats on TG ports for action in ['clear_stats']: data.tg1.tg_traffic_control(action=action, port_handle=data.tg_ph_1) data.tg2.tg_traffic_control(action=action, port_handle=data.tg_ph_2) data.tg3.tg_traffic_control(action=action, port_handle=data.tg_ph_3) handle = data.tg_ph_1 if tg_src_port == 'tg_ph_2': handle = data.tg_ph_2 # start capture if verify_capture: data.tg3.tg_packet_control(port_handle=data.tg_ph_3, action='start') # Start streams on data.tg1 data.tg1.tg_traffic_control(action='run',handle=stream1) # Stop the traffic data.tg1.tg_traffic_control(action='stop',handle=stream1) # stop capture if verify_capture: data.tg3.tg_packet_control(port_handle=data.tg_ph_3, action='stop') # verify filter statistics filter_result = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type='packet_count', tolerance_factor='2') capture_result = None if verify_capture: # Collecting offset values based on capture_fields if data.tg3.tg_type == 'stc': offset = {'gre_protocol': 36, 'dst_mac': 38, 'src_mac': 44, 'ether_type': 50, 'ip_protocol': 61, 'dscp': 53, 'src_ip': 64, 'dst_ip': 68, 'tcp_src_port': 72, 'tcp_dst_port': 74, 'udp_src_port': 72, 'udp_dst_port': 74, 'tcp_flags': 85} else: # IXIA will display below parametrs only on GRE data packet. offset = {'gre_protocol': 36, 'dst_mac': 0, 'src_mac': 12, 'ether_type': 24} pack_header = [] offset_li = [] # Checking argument capture_fields is list or not if not isinstance(capture_fields, list): capture_fields = [capture_fields] # Appending header and offsets based on capture_fields for ele in capture_fields: if ele == "gre_protocol": pack_header.append("GRE:Protocol Type") pack_header.append("GRE:Data:" + str(offset[ele])) offset_li.append(offset[ele]) # save the captured packets into a variable pkts_captured = data.tg2.tg_packet_stats(port_handle=data.tg_ph_3, format='var') # verify the capture packets st.log("Verifying capture packet with following parameters: offset: {}, fields: {}, headers {} and values: {}" .format(offset_li, capture_fields, pack_header, capture_values)) capture_result = tgapi.validate_packet_capture(tg_type=data.tg3.tg_type, pkt_dict=pkts_captured, header_list=pack_header, offset_list=offset_li, value_list=capture_values) capture_result = False if capture_result is None else capture_result st.log("Traffic results: Rate-{}, Capture-{}".format(filter_result, capture_result)) return filter_result, capture_result
def test_vrf_route_leak(): result = 0 ############################################################################################################################### st.log('######------Configure static routes on 900 VRFs-----######') dict1 = { 'dest_list': data.tg_dut2_stream_start[0:425], 'next_hop_list': data.dut2_dut1_ip_list[0:425], 'vrf_list': vrf_list[0:425] } dict2 = { 'dest_list': data.tg_dut2_stream_start[0:425], 'vrf_list': vrf_list[0:425] } parallel.exec_parallel(True, [data.dut1, data.dut2], vrf_static_route, [dict1, dict2]) st.wait(30) dict1 = { 'dest_list': data.tg_dut2_stream_start[425:899], 'next_hop_list': data.dut2_dut1_ip_list[425:899], 'vrf_list': vrf_list[425:899] } dict2 = { 'dest_list': data.tg_dut2_stream_start[425:899], 'vrf_list': vrf_list[425:899] } parallel.exec_parallel(True, [data.dut1, data.dut2], vrf_static_route, [dict1, dict2]) st.wait(30) ############################################################################################################################### loc_lib.clear_tg() data.tg2.tg_traffic_control(action='run', stream_handle=data.stream_list_scale.values(), duration=5) traffic_details = { '1': { 'tx_ports': [data.tg_dut1_hw_port], 'tx_obj': [data.tg1], 'exp_ratio': [1], 'rx_ports': [data.tg_dut2_hw_port], 'rx_obj': [data.tg2] } } data.tg2.tg_traffic_control(action='stop', stream_handle=data.stream_list_scale.values()) aggrResult = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type='packet_count') if not aggrResult: st.log('IPv4 Traffic on 1000 VRF with route leak failed') result += 1 ############################################################################################################################### if result == 0: st.report_pass('test_case_passed') else: st.log('Traffic on VRF with static route leak failed') st.report_fail('test_case_failed')
def test_ft_arp_dynamic_renew_traffic_test( fixture_ft_arp_dynamic_renew_traffic_test): ################## Author Details ################ # Name: Rakesh Kumar Vooturi # Email: [email protected] ################################################## # # Objective - Verify a dynamic ARP table entry can be created. # Objective - Verify that there is no data traffic loss during ARP dynamic review. # ############### Test bed details ################ # TG-----DUT-----TG ################################################# # Set DUT values st.log("Setting the DUT values") arp_obj.set_arp_ageout_time(dut1, 5) # Ping from tgen to DUT. res = tgapi.verify_ping(src_obj=tg, port_handle=tg_handler["tg_ph_1"], dev_handle=h1['handle'], dst_ip=data.d1t1_ip_addr, ping_count='1', exp_count='1') if res: st.log("Ping succeeded.") else: st.warn("Ping failed.") res = tgapi.verify_ping(src_obj=tg, port_handle=tg_handler["tg_ph_2"], dev_handle=h2['handle'], dst_ip=data.d1t2_ip_addr, ping_count='1', exp_count='1') if res: st.log("Ping succeeded.") else: st.warn("Ping failed.") # TG ports reset st.log("Resetting the TG ports") tg.tg_traffic_control(action="clear_stats", port_handle=tg_handler["tg_ph_list"]) #TG stream formation s1 = tg.tg_traffic_config(port_handle=tg_handler["tg_ph_2"], mode='create', rate_pps=10, mac_src=data.t2d1_mac_addr, transmit_mode="continuous", mac_dst=d1_mac_addr, l2_encap='ethernet_ii_vlan', l3_protocol="ipv4", ip_dst_addr=data.t1d1_ip_addr, ip_src_addr=data.t2d1_ip_addr, vlan_id=data.vlan_1, vlan="enable") tg.tg_traffic_control(action="run", stream_handle=s1['stream_id']) # Waiting for more than arp ageout time st.wait(10) tg.tg_traffic_control(action="stop", stream_handle=s1['stream_id']) # Adding sleep st.wait(2) st.log("Checking the stats and verifying the traffic flow") 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") else: st.log("traffic verification passed") st.report_pass("test_case_passed")