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