def test_l3_host_scaling_tc5_5(): pre_test_l3_fwding() vars = st.get_testbed_vars() # Config 2 IPV4 interfaces on DUT. (tg1, _, tg_ph_1, _) = 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) tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1) tr1 = create_l3_host(tg1, tg_ph_1, 8000, 120) st.wait(15) # Verified ARP and counters at the DUT. total = arpfeature.get_arp_count(dut1) st.log("Total ARP entries: {}".format(total)) if (total): arpfeature.clear_arp_table(vars.D1) st.wait(30) 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) post_test_l3_fwding() if (total >= data.max_host_1): st.report_pass("test_case_passed") else: st.report_fail("test_case_failed")
def nat_pre_config(): global vars vars = st.ensure_min_topology("D1D2:1", "D2D3:1") platform = basic_obj.get_hwsku(vars.D2) common_constants = st.get_datastore(vars.D2, "constants", "default") if platform.lower() in common_constants['TH3_PLATFORMS']: st.error("NAT is not supported for this platform {}".format(platform)) st.report_unsupported('NAT_unsupported_platform',platform) ip_obj.config_ip_addr_interface(vars.D1, vars.D1D2P1, data.d1d2_ip_addr, data.ip_addr_mask, family=data.af_ipv4) ip_obj.config_ip_addr_interface(vars.D2, vars.D2D1P1, data.d2d1_ip_addr, data.ip_addr_mask, family=data.af_ipv4) ip_obj.config_ip_addr_interface(vars.D2, vars.D2D3P1, data.d2d3_ip_addr, data.ip_addr_mask, family=data.af_ipv4) ip_obj.config_ip_addr_interface(vars.D3, vars.D3D2P1, data.d3d2_ip_addr, data.ip_addr_mask, family=data.af_ipv4) ip_obj.create_static_route(vars.D1, data.d2d1_ip_addr,"{}/{}".format(data.d1_static_nw, data.ip_addr_mask), shell=data.shell_vtysh, family=data.af_ipv4) ip_obj.create_static_route(vars.D3, data.d2d3_ip_addr, "{}/{}".format(data.d3_static_nw, data.ip_addr_mask), shell=data.shell_vtysh, family=data.af_ipv4) st.log("NAT Configuration") nat_obj.config_nat_feature(vars.D2, 'enable') util_nat_zone_config(vars.D2, [vars.D2D1P1, vars.D2D3P1], [data.zone_1, data.zone_2], config=data.config_add) st.log("Creating NAT Pool") nat_obj.config_nat_pool(vars.D2, pool_name=data.pool_name[0], global_ip_range=data.d2d1_ip_addr, global_port_range=data.global_port_range, config=data.config_add) st.log("Creating NAT Pool binding") nat_obj.config_nat_pool_binding(vars.D2, binding_name=data.bind_name[0], pool_name=data.pool_name[0], config=data.config_add) utils.exec_all(True, [[ip_obj.show_ip_route, vars.D1], [ip_obj.show_ip_route, vars.D2]]) ip_obj.show_ip_route(vars.D3)
def test_l3_perf_tc_14_1(): pre_test_l3_fwding() vars = st.get_testbed_vars() # Config 2 IPV4 interfaces on DUT. (tg1, _, tg_ph_1, _) = get_handles() dut1 = vars.D1 ipfeature.get_interface_ip_address(dut1, family="ipv4") ipfeature.show_ip_route(dut1) interface_status_show(dut1) tr1 = create_l3_host(tg1, tg_ph_1, 10000) st.wait(15) # Verified ARP and counters at the DUT. output = bcm_show(dut1, "time show arp") st.log(output) tg1.tg_traffic_control(action='stop', handle=tr1['stream_id'], max_wait_timer=10) tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1) post_test_l3_fwding() st.report_pass("test_case_passed")
def test_l3_host_scaling_tc5_8(): vars = st.get_testbed_vars() # Config 2 IPV4 interfaces on DUT. (tg1, _, tg_ph_1, _) = get_handles_1() dut1 = vars.D1 ipfeature.get_interface_ip_address(dut1, family="ipv4") ipfeature.get_interface_ip_address(dut1, family="ipv6") ipfeature.show_ip_route(dut1) papi.get_status(dut1) ret = fast_reboot_node(dut1) pre_test_l3_fwding() if (ret): 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) total = 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) post_test_l3_fwding() if (total >= data.max_host_1): st.report_pass("test_case_passed") else: st.report_fail("test_case_failed") else: post_test_l3_fwding() st.report_fail("test_case_failed")
def erspan_pre_config_verify(): """ Author: Lakshminarayana D ([email protected]) Using this pre config at module level. So, applicable for all test cases which includes in this module. :return: True or False """ retval = True # Displaying ip route table for dut in (vars.D1, vars.D2): st.log("Displaying routes on device {}....".format(dut)) ip.show_ip_route(dut) # Veification of acl policy and table match = [{'policy_name': data.acl_table_name}] if not acl_dscp.verify(vars.D1, 'policy', verify_list=match): st.log("acl policy verification failed") retval = False # Verification of Monitor session if not mirror.verify_session(vars.D1, session_name=data.session_name, src_ip=data.ip_D1T1P1, dst_ip=data.ip_T1D2P1, gre_type=data.gre_type, dscp=data.dscp, ttl=data.ttl, queue=data.queue, status="active"): st.log("Failed to create mirror session '{}' ".format(data.session_name)) retval = False return retval
def nat_reboot_debug_fun(): st.banner("Start of Collecting the needed debug info for failure analysis", width=100) ip_obj.show_ip_route(vars.D1) intf_obj.show_interface_counters_all(vars.D1) arp_obj.show_arp(vars.D1) nat_obj.show_nat_translations(vars.D1) st.banner("End of Collecting the needed debug info for failure analysis", width=100)
def test_l3_host_scaling_tc5_1(): pre_test_l3_fwding() vars = st.get_testbed_vars() # Config 2 IPV4 interfaces on DUT. (tg1, _, tg_ph_1, _) = 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, 8000, 5) st.wait(15) # Verified ARP and counters at the DUT. total_in_sw = arpfeature.get_arp_count(dut1) st.log("Total ARP entries: {}".format(total_in_sw)) #We expect all 8k host entries should be programmed in hw within 32secs st.wait(20) output = bcm_show(dut1, 'bcmcmd "l3 l3table show" | wc -l') total_in_hw = parse_route_output(output) tg1.tg_traffic_control(action='stop', handle=tr1['stream_id']) tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1) post_test_l3_fwding() if (total_in_sw >= data.max_host_1 and total_in_hw >= data.max_host_1): st.report_pass("test_case_passed") else: st.report_fail("test_case_failed")
def test_l3_perf_tc_12_5(): pre_test_l3_fwding_v6() vars = st.get_testbed_vars() # Config 2 IPV4 interfaces on DUT. (tg1, _, tg_ph_1, _) = 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) interface_status_show(dut1) tr1 = create_l3_host_v6(tg1, tg_ph_1, 16000) # Verified ARP and counters at the DUT. default_nd = arpapi.get_ndp_count(dut1) st.log("Total NDP entries are: {}".format(default_nd)) measure_nd_learn_time(dut1, default_nd, 16000) tg1.tg_traffic_control(action='stop', handle=tr1['stream_id'], max_wait_timer=10) tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1) post_test_l3_fwding_v6() st.report_pass("test_case_passed")
def test_ft_nat_config_reload(): # ################ Author Details ################ # Name: Kiran Vedula # Eamil: [email protected] # ################################################ # Objective - Verify dynamic NAPT translations after config save and reload # ################################################# nat_obj.clear_nat(vars.D1, translations=True) nat_obj.clear_nat(vars.D1, statistics=True) st.log("Config reload the DUT") reboot_obj.config_save_reload(vars.D1) st.log("Get some debug info after config reload is complete") ip_obj.show_ip_route(vars.D1) arp_obj.show_arp(vars.D1) nat_obj.show_nat_translations(vars.D1) st.wait(2) st.log("Traffic for snat case") tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_dyn_nat_udp_data_str_id_1"]) tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_dyn_nat_udp_data_str_id_1"]) st.wait(data.wait_nat_stats) trn_val_1 = nat_obj.get_nat_translations(vars.D1, protocol=data.proto_all, src_ip=data.in1_ip_addr_h[0]) if not trn_val_1: nat_reboot_debug_fun() st.report_fail("nat_translation_table_entry_deleted_incorrectly") count = data.pkt_count trn_val = nat_obj.get_nat_translations(vars.D1, protocol=data.proto_udp, src_ip=data.in1_ip_addr_h[-1], src_ip_port=data.local_src_port[0]) if not trn_val: nat_reboot_debug_fun() st.error("Received empty list,nat translation table not updated") st.report_fail("dynamic_snat_translation_entry_create_fail", data.in1_ip_addr_h[-1], data.out_ip_pool[0]) trn_src_ip = trn_val[0]["trn_src_ip"] trn_src_port = trn_val[0]["trn_src_ip_port"] st.log("Traffic for dnat case") tg2_str_obj = tg2_str_selector(trn_src_ip, trn_src_port) tg2.tg_traffic_control(action='run', handle=tg2_str_obj) tg2.tg_traffic_control(action='stop', handle=tg2_str_obj) st.wait(data.wait_nat_stats) nat_stats_s = nat_obj.poll_for_nat_statistics(vars.D1, protocol=data.proto_udp, src_ip=data.in1_ip_addr_h[-1], src_ip_port=data.local_src_port[0]) if not nat_stats_s: nat_reboot_debug_fun() st.error("Received empty list,nat statistics are not updated") st.report_fail("dynamic_snat_translation_entry_create_fail", data.in1_ip_addr_h[-1], data.out_ip_pool[0]) if not int(nat_stats_s[0]['packets']) >= (0.80 * (int(count))): nat_reboot_debug_fun() st.report_fail("dynamic_snat_translation_entry_create_fail", data.in1_ip_addr_h[-1], data.out_ip_pool[0]) nat_stats_d = nat_obj.poll_for_nat_statistics(vars.D1, protocol=data.proto_udp, dst_ip=trn_src_ip, dst_ip_port=trn_src_port) if not nat_stats_d: nat_reboot_debug_fun() st.error("Received empty list, nat statistics are not updated") st.report_fail("dynamic_dnat_translation_entry_create_fail", data.out_ip_pool[0], data.out_ip_pool[0]) if not int(nat_stats_d[0]['packets']) >= (0.80 * (int(count))): nat_reboot_debug_fun() st.report_fail("dynamic_dnat_translation_entry_create_fail", data.out_ip_pool[0], data.out_ip_pool[0]) st.report_pass("nat_translation_successful_after_config_reload")
def f2(): res1 = verify_ping_dut(leaf2, data.keepalive_ips[0]) arp.show_arp(leaf2) ip.show_ip_route(leaf2) if res1 is False: fail_msg = "ERROR: In Leaf2, ping to keepalive_link failed." print_log(fail_msg, "MED") return False return True
def test_l3_perf_tc_12_1(): pre_test_l3_fwding() vars = st.get_testbed_vars() # Config 2 IPV4 interfaces on DUT. (tg1, _, tg_ph_1, _) = get_handles() dut1 = vars.D1 port1 = vars.D1T1P1 ipfeature.get_interface_ip_address(dut1, family="ipv4") ipfeature.get_interface_ip_address(dut1, family="ipv6") ipfeature.show_ip_route(dut1) interface_status_show(dut1) tr1 = create_l3_host(tg1, tg_ph_1, 8000) # Verified ARP and counters at the DUT. cmd = "show arp | grep Total" default_arp = arpapi.get_arp_count(dut1) st.log("Total ARP entries: {}".format(default_arp)) measure_arp_learn_time(dut1, default_arp, 8000, cmd, False) #shut the link and make sure all the entries deleted from the hw interface_operation(dut1, port1, operation="shutdown") st.wait(15) cmd = 'bcmcmd "l3 l3table show" | wc -l' output = bcm_show(dut1, cmd) st.log(output) curr_arp = parse_route_output(output) if (curr_arp != default_arp): st.log("cleaning up host entries from HW failed" + str(curr_arp) + str(default_arp)) interface_operation(dut1, port1, operation="startup") #Now measure the hardware performance cmd = 'bcmcmd "l3 l3table show" | wc -l' output = bcm_show(dut1, cmd) st.log(output) default_arp = parse_route_output(output) measure_arp_learn_time(dut1, default_arp, 8000, cmd, True) tg1.tg_traffic_control(action='stop', handle=tr1['stream_id']) tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1) post_test_l3_fwding() 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 f4(): #intf.clear_interface_counters(client2) ip.show_ip_route(client2) arp.show_arp(client2) arp.show_ndp(client2) evpn.show_ip_neigh(client2) bcm.bcmcmd_l3_defip_show(client2) bcm.bcmcmd_l3_l3table_show(client2) bcm.bcmcmd_l3_ip6host_show(client2) bcm.bcmcmd_l3_ip6route_show(client2) bcm.read_l2(client2) bcm.bcm_cmd_l3_intf_show(client2) bcm.bcmcmd_show(client2, "l3 egress show") intf.show_interfaces_counters(client2) mac.get_mac(client2) ip.show_ip_route(client2, family='ipv6')
def f2(): #intf.clear_interface_counters(leaf2) ip.show_ip_route(leaf2) arp.show_arp(leaf2) arp.show_ndp(leaf2) evpn.show_ip_neigh(leaf2) bcm.bcmcmd_l3_defip_show(leaf2) bcm.bcmcmd_l3_l3table_show(leaf2) bcm.bcmcmd_l3_ip6host_show(leaf2) bcm.bcmcmd_l3_ip6route_show(leaf2) bcm.read_l2(leaf2) bcm.bcm_cmd_l3_intf_show(leaf2) bcm.bcmcmd_show(leaf2, "l3 egress show") intf.show_interfaces_counters(leaf2) mac.get_mac(leaf2) ip.show_ip_route(leaf2, family='ipv6') mclag.verify_domain(leaf2, domain_id=data.po_domainid) mclag.verify_iccp_macs(leaf2, domain_id=data.po_domainid, return_type='NULL') mclag.show_iccp_arp(leaf2, domain_id=data.po_domainid) mclag.show_iccp_nd(leaf2, domain_id=data.po_domainid)
def erspan_pre_config_verify(): """ Author: Anil Kumar Kacharla<*****@*****.**> Using this pre config at module level. So, applicable for all test cases which includes in this module. :return: None """ retval = True # Displaying ip route table for dut in (data.dut1, data.dut2): st.log("Displaying routes on device {}....".format(dut)) ip.show_ip_route(dut) # Verification of ACL Table if not acl_dscp.verify(data.dut1, 'policy', verify_list=[{ "policy_name": data.acl_table_name }]): st.log("Failed to create ACL policy '{}' ".format(data.acl_table_name)) retval = False # Verification of Monitor session if not mirror.verify_session(data.dut1, session_name=data.session_name, src_ip=data.ip_D1T1P1, dst_ip=data.ip_T1D2P1, gre_type=data.gre_type, dscp=data.dscp, ttl=data.ttl, queue=data.queue, status="active"): st.log("Failed to create mirror session '{}' ".format( data.session_name)) retval = False return retval
def ipv6_link_local_pre_config(): global vars vars = st.ensure_min_topology("D1D2:4", "D1T1:1", "D2T1:1") global tg_handler, tg1, tg2, tg_ph_1, tg_ph_2, tg_str_data, dut1_rt_int_mac, dut2_rt_int_mac, \ tg_rt_int_handle, d1_prt_link_local, d2_prt_link_local, d1_int_ipv6_list, d2_int_ipv6_list tg_handler = util_tg_init(vars, [vars.T1D1P1, vars.T1D2P1]) tg1 = tg_handler["tg"] tg2 = tg_handler["tg"] tg_ph_1 = tg_handler["tg_ph_1"] tg_ph_2 = tg_handler["tg_ph_2"] st.log("For debugging purpose, checking 'running config' before proceeding for module config") utils.exec_all(True, [[sc_obj.get_running_config, vars.D1], [sc_obj.get_running_config, vars.D2]]) st.log("For debugging purpose, checking 'routing interfaces' before proceeding for module config") utils.exec_all(True, [[ip_obj.get_interface_ip_address, vars.D1, None, "ipv6"], [ip_obj.get_interface_ip_address, vars.D2, None, "ipv6"]]) pc_obj.config_portchannel(vars.D1, vars.D2, data.prt_chnl, [vars.D1D2P3, vars.D1D2P4], [vars.D2D1P3, vars.D2D1P4], config='add', thread=True) st.log("Vlan config") utils.exec_all(True, [[vlan_obj.create_vlan, vars.D1, [data.vlan_li[0], data.vlan_li[1]]], [vlan_obj.create_vlan, vars.D2, [data.vlan_li[0], data.vlan_li[1]]]]) utils.exec_all(True, [ [vlan_mem_cfg, vars.D1, [[data.vlan_li[0], vars.D1D2P2, True], [data.vlan_li[1], vars.D1D2P2, True]]], [vlan_mem_cfg, vars.D2, [[data.vlan_li[0], vars.D2D1P2, True], [data.vlan_li[1], vars.D2D1P2, True]]]]) st.log("VRF Config and binding 2nd vlan routing interface to that VRF") vrf_obj.config_vrf(vars.D1, vrf_name=data.vrf_name, config='yes') vrf_obj.bind_vrf_interface(vars.D1, vrf_name=data.vrf_name, intf_name=data.vlan_in_2, config='yes', skip_error=True) st.log("Enabling ipv6 link local") d1_int_ipv6_list =[vars.D1D2P1, data.vlan_in_1, data.vlan_in_2,data.prt_chnl] d2_int_ipv6_list = [vars.D2D1P1, data.vlan_in_1, data.vlan_in_2, data.prt_chnl] utils.exec_all(True, [[ip_obj.config_interface_ip6_link_local, vars.D1,d1_int_ipv6_list, 'enable'], [ip_obj.config_interface_ip6_link_local, vars.D2,d2_int_ipv6_list, 'enable']]) st.log("TG connected int ipv6 address config") utils.exec_all(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'], [ip_obj.config_ip_addr_interface, vars.D2, vars.D2T1P1, data.tgd_ip6_addr_l[1], data.tg_ip6_addr_mask_l[1],"ipv6",'add']]) st.log("Get DUT mac address") [rt_int_mac, exceptions] = utils.exec_all(True, [[basic_obj.get_ifconfig_ether, vars.D1, vars.D1D2P1], [basic_obj.get_ifconfig_ether, vars.D2, vars.D2D1P1]]) utils.ensure_no_exception(exceptions) dut1_rt_int_mac = rt_int_mac[0] dut2_rt_int_mac = rt_int_mac[1] st.log("Get DUT link local addresses") [rt_link_local_addr, exceptions] = utils.exec_all(True, [[ip_obj.get_link_local_addresses, vars.D1, vars.D1D2P1], [ip_obj.get_link_local_addresses, vars.D2, vars.D2D1P1]]) utils.ensure_no_exception(exceptions) d1_prt_link_local = rt_link_local_addr[0] d2_prt_link_local = rt_link_local_addr[1] if not d1_prt_link_local or not d2_prt_link_local: st.log("DUT Link Local Address are empty") st.report_fail("link_local_address_not_found") st.log("Routing interface config in TG") tg_rt_int_handle = util_tg_routing_int_config(vars, tg1, tg2, tg_ph_1, tg_ph_2) st.log("Doing ping to the TG ipv6 address to resolve the next hop") utils.exec_all(True, [[ip_obj.ping, vars.D1, data.tgd_ip6_addr_l[0], 'ipv6'],[ip_obj.ping, vars.D2, data.tgd_ip6_addr_l[1], 'ipv6']]) st.log("Get show ndp output") utils.exec_all(True, [[arp_obj.show_ndp, vars.D1, None],[arp_obj.show_ndp, vars.D2, None]]) st.log("Static route config") utils.exec_all(True, [[ip_obj.create_static_route, vars.D1, d2_prt_link_local[0], data.static_rt, "vtysh", 'ipv6', vars.D1D2P1], [ip_obj.create_static_route, vars.D2, data.tg_ip6_addr_l[1], data.static_rt, "vtysh", 'ipv6', vars.D2T1P1]]) ip_obj.create_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, "vtysh", 'ipv6', data.vlan_in_1) ip_obj.create_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, "vtysh", 'ipv6', data.prt_chnl) ip_obj.create_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, "vtysh", 'ipv6', data.vlan_in_2, vrf=data.vrf_name) 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]]) ip_obj.show_ip_route(vars.D1, "ipv6", "sonic", data.vrf_name) st.log("TG Stream config") tg_str_data = util_tg_stream_config(tg1, tg2, tg_ph_1, tg_ph_2) st.log("Clearing all interface counters for debugging purpose") utils.exec_all(True, [[intf_obj.clear_interface_counters, vars.D1], [intf_obj.clear_interface_counters, vars.D2]])
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 nat_pre_config(): global vars vars = st.ensure_min_topology("D1T1:2") platform = basic_obj.get_hwsku(vars.D1) common_constants = st.get_datastore(vars.D1, "constants", "default") if platform.lower() in common_constants['TH3_PLATFORMS']: st.error("NAT is not supported for this platform {}".format(platform)) st.report_unsupported('NAT_unsupported_platform',platform) global tg_handler, tg1, tg2, tg_ph_1, tg_ph_2, dut1_rt_int_mac, tg_str_data, tg_rt_int_handle tg_handler = util_tg_init(vars, [vars.T1D1P1, vars.T1D1P2]) tg1 = tg_handler["tg"] tg2 = tg_handler["tg"] tg_ph_1 = tg_handler["tg_ph_1"] tg_ph_2 = tg_handler["tg_ph_2"] ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P1, data.in1_ip_addr, data.in1_ip_addr_mask, family=data.af_ipv4) ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P2, data.out_ip_addr_l[0], data.out_ip_addr_mask, family=data.af_ipv4) dut1_rt_int_mac = basic_obj.get_ifconfig_ether(vars.D1, vars.D1T1P1) ip_obj.create_static_route(vars.D1, data.out_ip_addr_h, "{}/{}".format(data.global_ip_addr_rt, data.global_ip_addr_mask), shell=data.shell_vtysh, family=data.af_ipv4) ip_obj.create_static_route(vars.D1, data.in1_ip_addr_h[0], "{}/{}".format(data.s_global_ip_rt, data.s_global_ip_mask)) tg_rt_int_handle = util_tg_routing_int_config(vars, tg1, tg2, tg_ph_1, tg_ph_2) st.log("NAT Configuration") nat_obj.config_nat_feature(vars.D1, 'enable') util_nat_zone_config(vars, [vars.D1T1P1, vars.D1T1P2], [data.zone_1, data.zone_2], config=data.config_add) nat_obj.config_nat_static(vars.D1, protocol=data.proto_all, global_ip=data.out_ip_addr_l[0], local_ip=data.in1_ip_addr_h[0], config=data.config_add, nat_type=data.nat_type_dnat) nat_obj.config_nat_static(vars.D1, protocol=data.proto_tcp, global_ip=data.out_ip_addr_l[1], local_ip=data.in1_ip_addr_h[1], local_port_id=data.tcp_src_local_port, global_port_id=data.tcp_src_global_port, config=data.config_add, nat_type=data.nat_type_dnat) nat_obj.config_nat_static(vars.D1, protocol=data.proto_udp, global_ip=data.in1_ip_addr_h[2], local_ip=data.out_ip_addr_l[2], local_port_id=data.udp_src_global_port, global_port_id=data.udp_src_local_port, config=data.config_add, nat_type=data.nat_type_snat) nat_obj.config_nat_static(vars.D1, protocol=data.proto_all, global_ip=data.s_global_ip, local_ip=data.s_local_ip, config=data.config_add, nat_type=data.nat_type_snat) nat_obj.config_nat_static(vars.D1,protocol=data.proto_all,global_ip=data.out_ip_addr_l[3],local_ip=data.in1_ip_addr_h[3], config=data.config_add,nat_type=data.nat_type_dnat,twice_nat_id=data.twice_nat_id_1) nat_obj.config_nat_static(vars.D1, protocol=data.proto_all, global_ip=data.global_ip_addr, local_ip=data.test_ip_addr, config=data.config_add, nat_type=data.nat_type_snat, twice_nat_id=data.twice_nat_id_1) # dynamic NAT config st.log("Creating NAT Pool-1") nat_obj.config_nat_pool(vars.D1, pool_name=data.pool_name[0], global_ip_range=data.out_ip_range, global_port_range= data.global_port_range, config=data.config_add) nat_obj.config_nat_pool(vars.D1, pool_name="scale_pool", global_ip_range="125.56.90.23-125.56.90.30", global_port_range="1001-8001", config=data.config_add) st.log("Creating NAT Pool binding") nat_obj.config_nat_pool_binding(vars.D1, binding_name=data.bind_name[0], pool_name=data.pool_name[0], config=data.config_add) st.log("Creating NAT Pool-2") nat_obj.config_nat_pool(vars.D1, pool_name=data.pool_name[1], global_ip_range=data.out2_ip_range, config=data.config_add) st.log("Creating NAT Pool-2 binding") 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 acl for ingress traffic acl_obj.create_acl_table(vars.D1, name=data.acl_table_in_nat_eg, stage="INGRESS", type=data.type, description="ingress-acl", ports=[vars.D1T1P1]) acl_obj.create_acl_rule(vars.D1, table_name=data.acl_table_in_nat_eg, rule_name="rule-32", packet_action=data.packet_forward_action, SRC_IP="{}/{}".format(data.in1_ip_addr_rt, data.in1_ip_addr_mask), priority='98', type=data.type, ip_protocol="4") acl_obj.create_acl_rule(vars.D1, table_name=data.acl_table_in_nat_eg, rule_name="rule-33", packet_action=data.packet_do_not_nat_action, SRC_IP="{}/{}".format('14.1.0.1', data.mask), priority='97', type=data.type, ip_protocol="4") # Checking arp table for debugging arp_obj.show_arp(vars.D1) ip_obj.show_ip_route(vars.D1) # Clearing all interface counters for debugging purpose intf_obj.clear_interface_counters(vars.D1) tg_str_data = util_tg_stream_config(tg1, tg2, tg_ph_1, tg_ph_2)
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_dynamic_unnumbered_scale(): ########################################################################################################################################## result = 0 st.banner('FtOpSoRoAutoSc001 - Verify maximum BGP unnumbered sessions') st.banner('FtOpSoRoAutoSc002 - Verify maximum sessions with listen range') vlan_list_d1_d2 = ['%s' % x for x in range(1, 101)] ip_list_dut2 = loc_lib.ip_range('2.0.0.1', 2, 100) ip_list_dut3 = loc_lib.ip_range('2.0.0.2', 2, 100) loc_lib.bgp_router_id() loc_lib.redistribute_routes() st.log( 'Configure BGP unnumbered sessions or 100 vlans between DUT1 and DUT2') for vlan in vlan_list_d1_d2: dict1 = { 'addr_family': 'ipv6', 'local_as': dut1_as, 'remote_as': dut2_as, 'config_type_list': ['remote-as', 'activate'], 'interface': 'Vlan' + vlan, 'neighbor': 'Vlan' + vlan } dict2 = { 'addr_family': 'ipv6', 'local_as': dut2_as, 'remote_as': dut1_as, 'config_type_list': ['remote-as', 'activate'], 'interface': 'Vlan' + vlan, 'neighbor': 'Vlan' + vlan } putils.exec_parallel(True, [data.dut1, data.dut2], bgp_obj.config_bgp, [dict1, dict2]) st.log('Configure IPv4 peer groups on DUT2 and DUT3') utils.exec_all(True, [[ bgp_obj.create_bgp_peergroup, data.dut2, dut2_as, 'd2d3_v4_peer', dut3_as ], [ bgp_obj.create_bgp_peergroup, data.dut3, dut3_as, 'd2d3_v4_peer', dut2_as ]]) st.log('Configure listen range on DUT2') bgp_obj.config_bgp_listen_range(dut=data.dut2, local_asn=dut2_as, neighbor_address='2.0.0.0', subnet=16, peer_grp_name='d2d3_v4_peer', limit=100, config='yes') st.log('Configure IPv4 and IPv6 BGP sessions on DUT2 and DUT3') st.log('Configure neighbors on DUT3') for ip in ip_list_dut2: bgp_obj.create_bgp_neighbor_use_peergroup(dut=data.dut3, local_asn=dut3_as, peer_grp_name='d2d3_v4_peer', neighbor_ip=ip, family="ipv4") bgp_obj.activate_bgp_neighbor(data.dut3, dut3_as, ip, 'ipv4', remote_asn=dut2_as) bgp_obj.activate_bgp_neighbor(data.dut3, dut3_as, ip, 'ipv6', remote_asn=dut2_as) st.log('Configure 100 BGP sessions with listen range') if not loc_lib.retry_api(bgp_obj.verify_bgp_summary, data.dut2, family='ipv4', shell=bgp_cli_type, neighbor=['Vlan2', '*' + ip_list_dut3[0]], state='Established', retry_count=10, delay=15): st.error( "Failed to form BGP unnumbered session using IPv6 link local address over vlan" ) result += 1 ip_obj.show_ip_route(data.dut1, family="ipv4") if not loc_lib.retry_api(ip_obj.ping, data.dut1, addresses=dut3_tg_ip[0], retry_count=10, delay=10, source_ip=dut1_tg_ip[0]): st.error('IPv4 Ping from DUT1 to DUT3 failed') result += 1 aggrResult = loc_lib.send_verify_traffic() if not aggrResult: st.error( 'IPv4 and IPv6 traffic over vlan with BGP unnumbered and Dynamic Discovery failed' ) result += 1 st.log("Reduce the limit and verify the neighbor is removed") bgp_obj.config_bgp_listen_range(dut=data.dut2, local_asn=dut2_as, limit=1) bgp_obj.clear_ip_bgp_vtysh(data.dut2, value="*") bgp_obj.config_bgp_listen_range(dut=data.dut2, local_asn=dut2_as, limit=100) bgp_obj.clear_ip_bgp_vtysh(data.dut2, value="*") st.wait(2) if not loc_lib.retry_api(bgp_obj.verify_bgp_summary, data.dut2, family='ipv4', shell=bgp_cli_type, neighbor=['Vlan2', '*' + ip_list_dut3[0]], state='Established', retry_count=10, delay=15): st.error( "Failed to form BGP unnumbered session using IPv6 link local address over vlan" ) result += 1 if result == 0: st.report_tc_pass('FtOpSoRoAutoSc001', 'test_case_passed') else: st.report_tc_fail('FtOpSoRoAutoSc001', 'test_case_failed') if result == 0: st.report_tc_pass('FtOpSoRoAutoSc002', 'test_case_passed') else: st.report_tc_fail('FtOpSoRoAutoSc002', 'test_case_failed') if result == 0: st.report_pass('test_case_passed') else: 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 measure_v4_route_scale_time(route_count, show_flag): vars = st.get_testbed_vars() dut = vars.D1 default_route = 0 #TG pumps 512k per sec so to make measure route install #time more accurate we start from 600k + route_count #base_route_count = 60000 + route_count base_route_count = route_count ipfeature.clear_ip_configuration(st.get_dut_names()) ipfeature.clear_ip_configuration(st.get_dut_names(), 'ipv6') member3 = vars.D1T1P1 member4 = vars.D1T1P2 ipfeature.config_ip_addr_interface(dut, member3, data.my_ip_addr, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut, member4, data.intf_ip_addr, data.ip_prefixlen, family="ipv4") ipfeature.get_interface_ip_address(dut, family="ipv4") ipfeature.show_ip_route(dut) interface_status_show(dut) bgpfeature.create_bgp_router(dut, data.as_num, '') bgpfeature.create_bgp_neighbor(dut, data.as_num, data.neigh_ip_addr, data.remote_as_num) (tg1, tg2, tg_ph_1, tg_ph_2) = get_handles() tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1) tg2.tg_traffic_control(action='reset', port_handle=tg_ph_2) h1 = tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.10.10.2', gateway='10.10.10.1', src_mac_addr='00:0a:01:00:00:01', arp_send_req='1') st.log("INTFCONF: " + str(h1)) h2 = tg2.tg_interface_config(port_handle=tg_ph_2, mode='config', intf_ip_addr='20.20.20.2', gateway='20.20.20.1', arp_send_req='1') st.log("INTFCONF: " + str(h2)) conf_var = { 'mode': 'enable', 'active_connect_enable': '1', 'local_as': '200', 'remote_as': '100', 'remote_ip_addr': '10.10.10.1' } route_var = { 'mode': 'add', 'num_routes': base_route_count, 'prefix': '121.1.1.0', 'as_path': 'as_seq:1' } ctrl_start = {'mode': 'start'} ctrl_stop = {'mode': 'stop'} # Configuring the BGP router. bgp_rtr1 = tgapi.tg_bgp_config(tg=tg1, handle=h1['handle'], conf_var=conf_var, route_var=route_var, ctrl_var=ctrl_start) st.log("BGP_HANDLE: " + str(bgp_rtr1)) # Verified at neighbor. st.log("BGP neighborship established.") st.wait(10) tr1 = tg2.tg_traffic_config( port_handle=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=512000, enable_stream_only_gen='0') retval = bgpfeature.verify_bgp_summary(dut, neighbor=data.neigh_ip_addr, state='Established') if retval is True: output = bcm_show(dut, 'bcmcmd "l3 defip show" | wc -l') st.log(output) default_route = parse_route_output(output) route_count += default_route cmd = 'bcmcmd "l3 defip show" | wc -l' measure_route_learn_time(dut, default_route, route_count, cmd) if (show_flag): cmd = "time show ip route" bcm_show(dut, cmd) data.result_14_3 = True res = tg2.tg_traffic_control(action='stop', handle=tr1['stream_id']) st.log("TR_CTRL: " + str(res)) tgapi.tg_bgp_config(tg=tg1, handle=bgp_rtr1['conf']['handle'], ctrl_var=ctrl_stop) ipfeature.delete_ip_interface(dut, member4, data.intf_ip_addr, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut, member3, data.my_ip_addr, data.ip_prefixlen, family="ipv4") bgpfeature.delete_bgp_neighbor(dut, data.as_num, data.neigh_ip_addr, data.remote_as_num) delete_bgp_router(dut, '', data.as_num) tg2.tg_traffic_control(action='reset', port_handle=tg_ph_2) tg1.tg_interface_config(port_handle=tg_ph_1, handle=h1['handle'], mode='destroy') tg2.tg_interface_config(port_handle=tg_ph_2, handle=h2['handle'], mode='destroy') st.wait(20)
def measure_v6_route_learning_time(route_count): vars = st.get_testbed_vars() dut = vars.D1 ipfeature.clear_ip_configuration(st.get_dut_names()) ipfeature.clear_ip_configuration(st.get_dut_names(), 'ipv6') member3 = vars.D1T1P1 member4 = vars.D1T1P2 ipfeature.config_ip_addr_interface(dut, member3, data.my_ipv6_addr, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ip_addr_interface(dut, member4, data.intf_ipv6_addr, data.ipv6_prefixlen, family="ipv6") ipfeature.get_interface_ip_address(dut, family="ipv6") ipfeature.show_ip_route(dut, family="ipv6") bgpfeature.create_bgp_router(dut, data.as_num, '') bgpfeature.create_bgp_neighbor(dut, data.as_num, data.neigh_ipv6_addr, data.remote_as_num, family="ipv6") create_bgp_neighbor_route_map_config(dut, data.as_num, data.neigh_ipv6_addr, data.routemap) (tg1, tg2, tg_ph_1, tg_ph_2) = get_handles() tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1) tg2.tg_traffic_control(action='reset', port_handle=tg_ph_2) h1 = tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', ipv6_intf_addr='2000::2', ipv6_prefix_length='64', ipv6_gateway='2000::1', src_mac_addr='00:0a:01:00:00:01', arp_send_req='1') st.log("INTFCONF: " + str(h1)) h2 = tg2.tg_interface_config(port_handle=tg_ph_2, mode='config', ipv6_intf_addr='2200::2', ipv6_prefix_length='64', ipv6_gateway='2200::1', arp_send_req='1') st.log("INTFCONF: " + str(h2)) bgp_conf = tg1.tg_emulation_bgp_config(handle=h1['handle'], mode='enable', ip_version='6', active_connect_enable='1', local_as='200', remote_as='100', remote_ipv6_addr='2000::1') bgp_route = tg1.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') tg1.tg_emulation_bgp_control(handle=bgp_conf['handle'], mode='start') # Configuring the BGP router. st.log("BGP neighborship established.") tr2 = tg2.tg_traffic_config(port_handle=tg_ph_2, emulation_src_handle=h2['handle'], emulation_dst_handle=bgp_route['handle'], circuit_endpoint_type='ipv6', mode='create', transmit_mode='continuous', length_mode='fixed', rate_pps=512000, enable_stream_only_gen='0') tg2.tg_traffic_control(action='run', handle=tr2['stream_id']) output = bcm_show(dut, 'bcmcmd "l3 ip6route show" | wc -l') default_route = parse_route_output(output) #Assume default route as current number of routes in the system #and measure route_count perforamnce on top of it route_count += default_route cmd = 'bcmcmd "l3 ip6route show" | wc -l' measure_route_learn_time(dut, default_route, route_count, cmd) res = tg2.tg_traffic_control(action='stop', handle=tr2['stream_id']) st.log("TR_CTRL: " + str(res)) # Withdraw the routes. st.wait(10) bgp_ctrl = tg1.tg_emulation_bgp_control(handle=bgp_conf['handle'], mode='stop') st.log("BGPCTRL: " + str(bgp_ctrl)) tg2.tg_traffic_control(action='reset', port_handle=tg_ph_2) st.wait(50) tg1.tg_interface_config(port_handle=tg_ph_1, handle=h1['handle'], mode='destroy') tg2.tg_interface_config(port_handle=tg_ph_2, handle=h2['handle'], mode='destroy')