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')
