def ipv6_link_local_config(action="add"):
if action == "add":
st.log("Creating VLAN and participating interfaces ...")
vlan_data = [{
"dut": [vars.D1],
"vlan_id": bgp_rst_data.vlan_id[0],
"tagged": [vars.D1D2P2]
}, {
"dut": [vars.D2],
"vlan_id": bgp_rst_data.vlan_id[0],
"tagged": [vars.D2D1P2]
}]
create_vlan_and_add_members(vlan_data)
st.log("Creating PortChannel and participating interfaces ...")
config_portchannel(vars.D1, vars.D2, bgp_rst_data.portchannel_name,
[vars.D1D2P3, vars.D1D2P4],
[vars.D2D1P3, vars.D2D1P4])
st.log("Enable IPV6 on physical interface on both the devices")
[_, exceptions] = exec_all(True, [[config_interface_ip6_link_local, vars.D1, ["Vlan{}".format(bgp_rst_data.vlan_id[0]), bgp_rst_data.portchannel_name]], \
[config_interface_ip6_link_local, vars.D2, ["Vlan{}".format(bgp_rst_data.vlan_id[0]), bgp_rst_data.portchannel_name]]])
ensure_no_exception(exceptions)
else:
[_, exceptions] = exec_all(True, [
[config_interface_ip6_link_local, vars.D1, [vars.D1D2P1, "Vlan{}".format(bgp_rst_data.vlan_id[0]), bgp_rst_data.portchannel_name], "disable"], \
[config_interface_ip6_link_local, vars.D2, [vars.D2D1P1, "Vlan{}".format(bgp_rst_data.vlan_id[0]), bgp_rst_data.portchannel_name], "disable"]])
ensure_no_exception(exceptions)
clear_portchannel_configuration([vars.D1, vars.D2])
clear_vlan_configuration([vars.D1, vars.D2])
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 bgp_rst_epilogue():
st.banner("Routing interface un-configuration in both DUTs")
[_, exceptions] = exec_all(
True, [[dut1_routing_int_cfg, "del"], [dut2_routing_int_cfg, "del"]])
ensure_no_exception(exceptions)
[_, exceptions] = exec_all(True, [[config_bgp_router_rst, vars.D1, bgp_rst_data.dut1_asn, "del"], \
[config_bgp_router_rst, vars.D2, bgp_rst_data.dut2_asn, "del"]])
ensure_no_exception(exceptions)
def test_ft_system_verify_traffic_through_port_channel_during_fast_reboot():
[output,
exceptions] = exec_all(True,
[[
po_obj.verify_portchannel_member, vars.D1,
data.portchannel_name, data.members_dut1
],
[
po_obj.verify_portchannel_member, vars.D2,
data.portchannel_name, data.members_dut2
]])
if False in output:
st.report_fail('portchannel_member_verification_failed',
data.portchannel_name, vars.D1, data.members_dut1)
ensure_no_exception(exceptions)
exceptions = exec_all(True, [[
vlan_obj.add_vlan_member, vars.D1, data.vlan, data.portchannel_name,
True
],
[
vlan_obj.add_vlan_member, vars.D2,
data.vlan, data.portchannel_name, True
]])[1]
ensure_no_exception(exceptions)
data.tg_handler["tg"].tg_traffic_config(
mode='modify',
stream_id=data.stream['stream_id'],
transmit_mode='continuous',
port_handle=data.tg_handler["tg_ph_1"])
st.log("performing Config save")
rb_obj.config_save(vars.D1)
data.tg_handler["tg"].tg_traffic_control(
action='clear_stats',
port_handle=[data.tg_handler["tg_ph_1"], data.tg_handler["tg_ph_3"]])
data.tg_handler["tg"].tg_traffic_control(
action='run', stream_handle=data.stream['stream_id'])
st.log("performing fast-reboot")
st.reboot(vars.D1, 'fast')
data.tg_handler["tg"].tg_traffic_control(
action='stop', stream_handle=data.stream['stream_id'])
loss_pkts_count = 26 * 100
stats_tg1 = tgapi.get_traffic_stats(data.tg_handler["tg"],
mode="aggregate",
port_handle=data.tg_handler["tg_ph_1"])
tx_pkts = stats_tg1.tx.total_packets
stats_tg2 = tgapi.get_traffic_stats(data.tg_handler["tg"],
mode="aggregate",
port_handle=data.tg_handler["tg_ph_3"])
rx_pkts = stats_tg2.rx.total_packets
st.log("Traffic sent from TGEN: {}".format(tx_pkts))
st.log("Traffic received on TGEN: {}".format(rx_pkts))
if not loss_pkts_count > int(tx_pkts) - int(rx_pkts):
st.report_fail('data_traffic_loss_during_fast_reboot')
st.report_pass("test_case_passed")
def test_ft_verify_static_portchannel_with_l2_traffic():
'''
Author: Venkatesh Terli <*****@*****.**>
Scenario - 3.1.2 Verify that l2 traffic is forwarded Through the Static Port Channel.
'''
st.log(
'Scenario - 3.1.2 Verify that l2 traffic is forwarded Through the Static Port Channel.'
)
exceptions = exec_all(True,
[[intfobj.clear_interface_counters, vars.D1],
[intfobj.clear_interface_counters, vars.D2]])[1]
ensure_no_exception(exceptions)
static_data.tg.tg_traffic_control(
action='run',
stream_handle=[
static_data.streams['D1T1_SD_Mac_Hash1'],
static_data.streams['D2T1_SD_Mac_Hash1']
])
st.wait(5)
static_data.tg.tg_traffic_control(
action='stop',
stream_handle=[
static_data.streams['D1T1_SD_Mac_Hash1'],
static_data.streams['D2T1_SD_Mac_Hash1']
])
verify_traffic_hashed_or_not(
vars.D1, [vars.D1D2P1, vars.D1D2P2, vars.D1D2P3, vars.D1D2P4],
20,
traffic_loss_verify=True,
rx_port=vars.D1T1P1,
tx_port=vars.D2T1P1,
dut2=vars.D2)
verify_traffic_hashed_or_not(
vars.D2, [vars.D2D1P1, vars.D2D1P2, vars.D2D1P3, vars.D2D1P4],
20,
traffic_loss_verify=True,
rx_port=vars.D2T1P1,
tx_port=vars.D1T1P1,
dut2=vars.D1)
[output, exceptions] = exec_all(
True,
[[get_mac_address_count, vars.D1, None, static_data.portchannel_name],
[get_mac_address_count, vars.D2, None, static_data.portchannel_name]])
ensure_no_exception(exceptions)
mac_count1, mac_count2 = output
if int(mac_count1) < 100:
st.report_fail('traffic_verification_fail', vars.D1)
if int(mac_count2) < 100:
st.report_fail('traffic_verification_fail', vars.D2)
st.log('verified that traffic is successfully passing')
st.report_pass('portchannel_l2_forwarding_success')
def dut_vlan_config():
st.log("creating vlan and participating TGEN ports")
data.vlan = str(random_vlan_list()[0])
exceptions = exec_all(True,
[[vlan_obj.create_vlan, vars.D1, data.vlan],
[vlan_obj.create_vlan, vars.D2, data.vlan]])[1]
ensure_no_exception(exceptions)
exceptions = exec_all(True, [[
vlan_obj.add_vlan_member, vars.D1, data.vlan,
[vars.D1T1P1, vars.D1T1P2], True
], [vlan_obj.add_vlan_member, vars.D2, data.vlan, [vars.D2T1P1], True]])[1]
ensure_no_exception(exceptions)
def portchannel_module_hooks(request):
# add things at the start of this module
global vars
vars = st.ensure_min_topology("D1D2:4", "D1T1:1", "D2T1:1")
initialize_variables()
exec_all(
True,
[[static_port_channel_tg_config], [static_port_channel_dut_config]],
first_on_main=True)
yield
st.log('Module config Cleanup')
clear_vlan_configuration([vars.D1, vars.D2])
portchannelobj.clear_portchannel_configuration([vars.D1, vars.D2])
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 looguard_module_prolog():
parallel.exec_all(
True, [[vlan.create_vlan_and_add_members, sc_data.vlan_data_d1],
[vlan.create_vlan_and_add_members, sc_data.vlan_data_d2]])
parallel.exec_all(
True, [[vlan.create_vlan_and_add_members, sc_data.vlan1_data_d1],
[vlan.create_vlan_and_add_members, sc_data.vlan1_data_d2]])
stp.config_stp_in_parallel(sc_data.dut_list,
feature="rpvst",
mode="enable",
vlan=None)
stp.config_stp_vlan_parameters(vars.D2, sc_data.vlan, priority=0)
stp.config_stp_vlan_parameters(vars.D2, sc_data.vlan1, priority=0)
st.log("Wait for convergence")
st.wait(10)
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 bgp_rst_prologue():
global vars
vars = st.ensure_min_topology("D1D2:4")
st.banner("Routing interface configuration in both DUTs")
[_, exceptions] = exec_all(
True, [[dut1_routing_int_cfg, "add"], [dut2_routing_int_cfg, "add"]])
ensure_no_exception(exceptions)
def test_ft_bgp_rst001():
# """
# Validate the BGP IPv4 neighborship when configured through REST
# :return:
# """
[out, exceptions] = exec_all(True, [[config_bgp_router_rst, vars.D1, bgp_rst_data.dut1_asn, "add"], \
[config_bgp_router_rst, vars.D2, bgp_rst_data.dut2_asn, "add"]])
ensure_no_exception(exceptions)
for each in out:
if not each:
st.report_fail("bgp_router_create_delete", "Creation", "REST",
"FAILED")
st.wait(5)
dut1_data = {
'neigh_ip': bgp_rst_data.dut2_ip_l[0],
'local_asn': bgp_rst_data.dut1_asn,
'remote_asn': bgp_rst_data.dut2_asn,
'peer_type': "EXTERNAL",
'family': "ipv4",
'config': "add"
}
dut2_data = {
'neigh_ip': bgp_rst_data.dut1_ip_l[0],
'local_asn': bgp_rst_data.dut2_asn,
'remote_asn': bgp_rst_data.dut1_asn,
'peer_type': "EXTERNAL",
'family': "ipv4",
'config': "add"
}
exec_parallel(True, [vars.D1, vars.D2], config_bgp_neighbor_rst,
[dut1_data, dut2_data])
for each in out:
if not each:
st.report_fail("bgp_neighbor_create_delete", "v4", "Creation",
"REST", "FAILED")
if not poll_wait(verify_bgp_neighbor_rst, 60, vars.D1,
bgp_rst_data.dut2_ip_l[0]):
st.report_fail("bgp_neighbor_create_delete", "v4", "Creation", "REST",
"FAILED")
[out, exceptions] = exec_all(True, [[bgp_neighbor_del_rst, vars.D1, bgp_rst_data.dut2_ip_l[0]] , \
[bgp_neighbor_del_rst, vars.D2, bgp_rst_data.dut1_ip_l[0]]])
ensure_no_exception(exceptions)
for each in out:
if not each:
st.report_fail("bgp_neighbor_create_delete", "v4", "Delrtion",
"REST", "FAILED")
st.report_pass("bgp_neighbor_status", "v4", "Successful", "REST")
def static_port_channel_dut_config():
static_data.dut1_rt_int_mac = get_ifconfig_ether(vars.D1, vars.D1T1P1)
static_data.members_dut1 = [
vars.D1D2P1, vars.D1D2P2, vars.D1D2P3, vars.D1D2P4
]
static_data.members_dut2 = [
vars.D2D1P1, vars.D2D1P2, vars.D2D1P3, vars.D2D1P4
]
st.log('Creating port-channel and adding members in both DUTs')
dict1 = {
'portchannel_list': [static_data.portchannel_name],
'static': True
}
dict2 = {
'portchannel_list': [static_data.portchannel_name],
'static': True
}
exceptions = exec_parallel(True, [vars.D1, vars.D2],
portchannelobj.create_portchannel,
[dict1, dict2])[1]
ensure_no_exception(exceptions)
dict1 = {
'portchannel': static_data.portchannel_name,
'members': static_data.members_dut1
}
dict2 = {
'portchannel': static_data.portchannel_name,
'members': static_data.members_dut2
}
exceptions = exec_parallel(True, [vars.D1, vars.D2],
portchannelobj.add_del_portchannel_member,
[dict1, dict2])[1]
ensure_no_exception(exceptions)
st.log('Creating random VLAN in both the DUTs')
exceptions = exec_all(True, [[create_vlan, vars.D1, static_data.vid],
[create_vlan, vars.D2, static_data.vid]])[1]
ensure_no_exception(exceptions)
st.log(
'Adding Port-Channel and TGen connected ports as tagged members to the random VLAN'
)
exceptions = \
exec_all(True, [[add_vlan_member, vars.D1, static_data.vid, [static_data.portchannel_name, vars.D1T1P1], True],
[add_vlan_member, vars.D2, static_data.vid, [static_data.portchannel_name, vars.D2T1P1], True]])[1]
ensure_no_exception(exceptions)
def scheduling_module_config(config='yes'):
if config == 'yes':
st.debug("Configuring MAC age out time")
[output, exceptions] = exec_all(
True, [[config_mac_agetime, vars.D1, scheduling_data.ageout_time],
[config_mac_agetime, vars.D2, scheduling_data.ageout_time]])
ensure_no_exception(exceptions)
if not all(output):
st.report_fail("mac_aging_time_failed_config")
st.debug("Verifying MAC age out time")
[output, exceptions
] = exec_all(True,
[[get_mac_agetime, vars.D1], [get_mac_agetime, vars.D2]])
ensure_no_exception(exceptions)
if not ((int(output[0]) == scheduling_data.ageout_time) and
(int(output[1]) == scheduling_data.ageout_time)):
st.report_fail(
"msg", "MAC age out time is not configured as: {}".format(
scheduling_data.ageout_time))
st.debug("Create a vlan and add ports as tagged members to it")
if not create_vlan_and_add_members(
[{
"dut": [vars.D1],
"vlan_id": scheduling_data.vlan,
"tagged": [vars.D1T1P1, vars.D1T1P2, vars.D1D2P1]
}, {
"dut": [vars.D2],
"vlan_id": scheduling_data.vlan,
"tagged": [vars.D2T1P1, vars.D2T1P2, vars.D2D1P1]
}]):
st.report_fail(
"msg",
"Failed to add port as tagged members of VLAN: {}".format(
scheduling_data.vlan))
else:
# clearing scheduling and vlan config
clear_port_shaper(vars.D1,
port=vars.D1D2P1,
shaper_data=scheduling_data.policy_name,
qos_clear=True)
clear_vlan_configuration([vars.D1, vars.D2], thread=True)
scheduling_data.tg.tg_traffic_control(
action='stop', stream_handle=scheduling_data.streams.values())
def verify_traffic_hashed_or_not(dut,
port_list,
pkts_per_port,
traffic_loss_verify=False,
rx_port='',
tx_port='',
dut2=''):
if traffic_loss_verify is True:
[output,
exceptions] = exec_all(True,
[[intfobj.show_interface_counters_all, dut],
[intfobj.show_interface_counters_all, dut2]])
ensure_no_exception(exceptions)
static_data.intf_counters_1, static_data.intf_counters_2 = output
else:
static_data.intf_counters_1 = intfobj.show_interface_counters_all(dut)
static_data.intf_count_dict = {}
for port in port_list:
for counter_dict in static_data.intf_counters_1:
if counter_dict['iface'] == port:
try:
tx_ok_counter = counter_dict['tx_ok'].replace(',', '')
static_data.intf_count_dict[port] = int(
tx_ok_counter) if tx_ok_counter.isdigit() else 0
except Exception:
st.report_fail('invalid_traffic_stats')
if not (static_data.intf_count_dict[port] >= pkts_per_port):
intfobj.show_interface_counters_detailed(
vars.D1, vars.D1T1P1)
st.report_fail("traffic_not_hashed", dut)
if traffic_loss_verify is True:
for counter_dict in static_data.intf_counters_1:
if counter_dict['iface'] == rx_port:
try:
rx_ok_counter = counter_dict['rx_ok'].replace(',', '')
static_data.rx_traffic = int(
rx_ok_counter) if rx_ok_counter.isdigit() else 0
except Exception:
st.report_fail('invalid_traffic_stats')
break
for counter_dict in static_data.intf_counters_2:
if counter_dict['iface'] == tx_port:
try:
tx_ok_counter = counter_dict['tx_ok'].replace(',', '')
static_data.tx_traffic = int(
tx_ok_counter) if tx_ok_counter.isdigit() else 0
except Exception:
st.report_fail('invalid_traffic_stats')
break
if not (static_data.tx_traffic >= 0.95 * static_data.rx_traffic):
st.log("data.tx_traffic:{}".format(static_data.tx_traffic))
st.log("data.rx_traffic:{}".format(static_data.rx_traffic))
intfobj.show_interface_counters_detailed(vars.D1, vars.D1T1P1)
st.report_fail('traffic_loss_observed')
return True
def vlan_module_hooks(request):
global vars
vars = st.ensure_min_topology("D1D2:2", "D1T1:2", "D2T1:2")
sc_data.version_data = basic_obj.show_version(vars.D1)
vlan_variables()
if not st.is_feature_supported("vlan-range", vars.D1):
sc_data.max_vlan = 100
[_, exceptions] = exec_all(True, [[config_tg_stream], [vlan_module_prolog]], first_on_main=True)
ensure_no_exception(exceptions)
yield
vlan.clear_vlan_configuration(st.get_dut_names(), thread=False)
def test_ft_bgp_rst003():
[_, exceptions] = exec_all(True, [
[config_interface_ip6_link_local, vars.D1, [vars.D1D2P1]], \
[config_interface_ip6_link_local, vars.D2, [vars.D2D1P1]]])
ensure_no_exception(exceptions)
dut1_data = {
'neigh_ip': vars.D1D2P1,
'local_asn': bgp_rst_data.dut1_asn,
'remote_asn': bgp_rst_data.dut2_asn,
'peer_type': "EXTERNAL",
'family': "ipv6",
'config': "add"
}
dut2_data = {
'neigh_ip': vars.D2D1P1,
'local_asn': bgp_rst_data.dut2_asn,
'remote_asn': bgp_rst_data.dut1_asn,
'peer_type': "EXTERNAL",
'family': "ipv6",
'config': "add"
}
[out, exceptions] = exec_parallel(True, [vars.D1, vars.D2],
config_bgp_neighbor_rst,
[dut1_data, dut2_data])
ensure_no_exception(exceptions)
for each in out:
if not each:
st.report_fail("bgp_neighbor_create_delete", "v6", "Creation",
"REST", "FAILED")
if not poll_wait(verify_bgp_neighbor_rst, 60, vars.D1, vars.D1D2P1):
st.report_fail("bgp_neighbor_create_delete", "v6", "Creation", "REST",
"FAILED")
[out, exceptions] = exec_all(True, [[bgp_neighbor_del_rst, vars.D1, vars.D2D1P1], \
[bgp_neighbor_del_rst, vars.D2, vars.D1D2P1]])
ensure_no_exception(exceptions)
for each in out:
if not each:
st.report_fail("bgp_neighbor_create_delete", "v6", "Delrtion",
"REST", "FAILED")
st.report_pass("bgp_neighbor_status", "v6", "Successful", "REST")
def pvst_elastic_function_hooks(request):
if st.get_func_name(request) == "test_ft_stp_loopguard_lag_interfaces":
vlan.clear_vlan_configuration(st.get_dut_names(), thread=False)
st.log('Creating port-channel and adding members in both DUTs')
portchannel.config_portchannel(vars.D1, vars.D2,
sc_data.portchannel_name,
sc_data.members_dut1,
sc_data.members_dut2, "add")
portchannel.config_portchannel(vars.D1, vars.D2,
sc_data.portchannel_name2,
sc_data.members_dut1_p2,
sc_data.members_dut2_p2, "add")
parallel.exec_all(
True, [[vlan.create_vlan_and_add_members, sc_data.vlan_pc_d1],
[vlan.create_vlan_and_add_members, sc_data.vlan_pc_d2]])
yield
if st.get_func_name(request) == "test_ft_stp_loopguard_lag_interfaces":
vlan.clear_vlan_configuration(st.get_dut_names(), thread=False)
portchannel.clear_portchannel_configuration([vars.D1, vars.D2])
parallel.exec_all(
True, [[vlan.create_vlan_and_add_members, sc_data.vlan_data_d1],
[vlan.create_vlan_and_add_members, sc_data.vlan_data_d2]])
parallel.exec_all(
True, [[vlan.create_vlan_and_add_members, sc_data.vlan1_data_d1],
[vlan.create_vlan_and_add_members, sc_data.vlan1_data_d2]])
def bgp_rst_func_hooks(request):
yield
if st.get_func_name(request) == "test_ft_bgp_rst002":
[_, exceptions] = exec_all(
True, [[
config_ip_addr_rst, vars.D1, bgp_rst_data.dut1_ip6_l[0],
bgp_rst_data.ip6_pre_len, vars.D1D2P1, "ipv6", "del"
],
[
config_ip_addr_rst, vars.D2, bgp_rst_data.dut2_ip6_l[0],
bgp_rst_data.ip6_pre_len, vars.D2D1P1, "ipv6", "del"
]])
ensure_no_exception(exceptions)
def test_ft_verify_static_portchannel_funtionality_after_save_and_reboot():
'''
Author: Venkatesh Terli <*****@*****.**>
Scenario - 3.3.1 Verify that the Static LAG configuration should be retained after save and reboot.
'''
st.log(
'Scenario - 3.3.1 Verify that the Static LAG configuration should be retained after save and reboot.'
)
st.log("performing Config save and reboot")
rbobj.config_save_reload([vars.D1, vars.D2])
st.wait(10)
exceptions = exec_all(True,
[[
portchannelobj.verify_portchannel_state, vars.D1,
static_data.portchannel_name, "up"
],
[
portchannelobj.verify_portchannel_state,
vars.D2, static_data.portchannel_name, "up"
]])[1]
ensure_no_exception(exceptions)
exceptions = exec_all(True,
[[intfobj.clear_interface_counters, vars.D1],
[intfobj.clear_interface_counters, vars.D2]])[1]
ensure_no_exception(exceptions)
static_data.tg.tg_traffic_control(
action='run', stream_handle=[static_data.streams['D1T1_SD_Mac_Hash1']])
st.wait(5)
static_data.tg.tg_traffic_control(
action='stop',
stream_handle=[static_data.streams['D1T1_SD_Mac_Hash1']])
verify_traffic_hashed_or_not(
vars.D1, [vars.D1D2P1, vars.D1D2P2, vars.D1D2P3, vars.D1D2P4],
20,
traffic_loss_verify=True,
rx_port=vars.D1T1P1,
tx_port=vars.D2T1P1,
dut2=vars.D2)
st.report_pass('portchannel_functionality_after_save_and_reboot')
def storm_control_module_hooks(request):
global vars
vars = st.ensure_min_topology("D1D2:2", "D1T1:2", "D2T1:2")
sc_data.version_data = basic_obj.show_version(vars.D1)
vlan_variables()
[out, exceptions] = exec_all(True,
[[config_tg_stream], [vlan_module_prolog]],
first_on_main=True)
ensure_no_exception(exceptions)
yield
vlan.clear_vlan_configuration(st.get_dut_names(),
thread=False,
cli_type="click")
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 ipv6_link_local_post_config():
vars = st.get_testbed_vars()
st.log("Static route cleanup")
utils.exec_all(True, [
[ip_obj.delete_static_route, vars.D1, d2_prt_link_local[0], data.static_rt, 'ipv6', "vtysh", vars.D1D2P1],
[ip_obj.delete_static_route, vars.D2, data.tg_ip6_addr_l[1], data.static_rt, 'ipv6', "vtysh", vars.D2T1P1]])
ip_obj.delete_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, 'ipv6',"vtysh", data.vlan_in_1)
ip_obj.delete_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, 'ipv6',"vtysh", data.prt_chnl)
ip_obj.delete_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, 'ipv6', "vtysh", data.vlan_in_2, vrf=data.vrf_name)
vrf_obj.config_vrf(vars.D1, vrf_name=data.vrf_name, config='no')
st.log("Disabling ipv6 link local")
utils.exec_all(True, [[ip_obj.config_interface_ip6_link_local, vars.D1, d1_int_ipv6_list, 'disable'],
[ip_obj.config_interface_ip6_link_local, vars.D2, d2_int_ipv6_list, 'disable']])
ip_obj.clear_ip_configuration(st.get_dut_names(), family = 'ipv6')
st.log("Vlan and Port Channel clean up")
vlan_obj.clear_vlan_configuration(st.get_dut_names())
pc_obj.clear_portchannel_configuration(st.get_dut_names())
st.log("Cleaning up routing interfaces configured on TG")
st.log("Stopping the TG traffic again, if in case of any failures in test function misses the stop operation")
tgapi.traffic_action_control(tg_handler, actions=['reset'])
tg1.tg_interface_config(port_handle=tg_ph_1, handle=tg_rt_int_handle[0]['handle'], mode='destroy')
tg2.tg_interface_config(port_handle=tg_ph_2, handle=tg_rt_int_handle[1]['handle'], mode='destroy')
def test_ft_ipv6_link_local_ping():
report_flag = 0
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
# Get show ndp output
utils.exec_all(True, [[arp_obj.show_ndp, vars.D1, None], [arp_obj.show_ndp, vars.D2, None]])
d1_int_li = [vars.D2D1P1, vars.D2D1P2, data.prt_chnl]
intf_obj.interface_operation(vars.D2, [vars.D2D1P1, vars.D2D1P2, data.prt_chnl], operation="shutdown", skip_verify=True)
st.log("Waiting for 10 sec after shutdown the interfaces")
st.wait(10)
intf_obj.interface_status_show(vars.D1, [vars.D2D1P1, vars.D2D1P2, data.prt_chnl])
intf_obj.interface_operation(vars.D2, [vars.D2D1P1, vars.D2D1P2, data.prt_chnl], operation="startup",
skip_verify=True)
st.log("Polling for interface status after no shutdown")
for intf in d1_int_li:
if not intf_obj.poll_for_interface_status(vars.D2, intf, "oper", "up", iteration=5, delay=1):
st.error("Failed to startup interface {} on the DUT {}".format(intf, vars.D2))
report_flag = 0
if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = vars.D1D2P1):
st.log("After shut no shut, 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("After shut no shut, 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("After shut no shut, Ipv6 Ping over Link Local address via the Port Channel based routing interface is failed.")
report_flag = 1
if report_flag:
st.report_fail("ip6_ping_fail_over_link_local_addr")
st.report_pass("test_case_passed")
def pvst_elastic_module_hooks(request):
global vars
vars = st.ensure_min_topology("D1D2:4", "D1T1:2", "D2T1:2")
vlan_variables()
vlan.clear_vlan_configuration(st.get_dut_names(), thread=False)
[_, exceptions] = exec_all(True,
[[config_tg_stream], [looguard_module_prolog]],
first_on_main=True)
ensure_no_exception(exceptions)
yield
stp.config_stp_in_parallel(sc_data.dut_list,
feature="rpvst",
mode="disable",
vlan=None)
vlan.clear_vlan_configuration(st.get_dut_names(), thread=False)
def ipv6_link_local_func_hooks(request):
utils.exec_all(True, [[ip_obj.show_ip_route, vars.D1, "ipv6"], [ip_obj.show_ip_route, vars.D2, "ipv6"]])
yield
if st.get_func_name(request) == 'test_ft_ipv6_link_local_warm_boot':
ip_obj.create_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, "vtysh", 'ipv6', data.prt_chnl)
tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"])
if st.get_func_name(request) == 'test_ft_ipv6_link_local_manual':
utils.exec_all(True, [
[ip_obj.delete_static_route, vars.D1, data.ip6_manual_ll_addr[1], data.static_rt_manual, 'ipv6', "vtysh",
data.prt_chnl],
[ip_obj.delete_static_route, vars.D2, data.tg_ip6_addr_l[1], data.static_rt_manual, 'ipv6', "vtysh", vars.D2T1P1]])
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", 'remove'],
[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", 'remove']])
utils.exec_all(True, [[ip_obj.config_interface_ip6_link_local, vars.D1, data.prt_chnl, 'enable'],
[ip_obj.config_interface_ip6_link_local, vars.D2, data.prt_chnl, 'enable']])
ip_obj.create_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, "vtysh", 'ipv6', data.prt_chnl)
def test_ft_del_ip_assigned_portchannel():
'''
Author: Venkatesh Terli <*****@*****.**>
Scenario - 3.2.2 Verify that deletion of a Static Port Channel with IP address is assigned on it is not Successful.
'''
st.log(
'Scenario - 3.2.2 Verify that deletion of a Static Port Channel with IP address is assigned on it is not Successful.'
)
portchannelobj.delete_portchannel_member(vars.D1,
static_data.portchannel_name,
static_data.members_dut1)
exceptions = exec_all(True, [
ExecAllFunc(delete_vlan_member,
vars.D1,
static_data.vid,
static_data.portchannel_name,
tagging_mode=True),
ExecAllFunc(delete_vlan_member,
vars.D2,
static_data.vid,
static_data.portchannel_name,
tagging_mode=True)
])[1]
ensure_no_exception(exceptions)
ipobj.config_ip_addr_interface(vars.D1, static_data.portchannel_name,
static_data.ip41, static_data.ip_mask)
result = portchannelobj.delete_portchannel(vars.D1,
static_data.portchannel_name,
skip_error=True)
cli_type = st.get_ui_type(vars.D1)
if cli_type == 'click':
if result:
st.report_fail(
'msg',
'Allowed to delete PortChannel which is configured with IP address'
)
else:
if not result:
st.report_fail(
'msg',
'Delete PortChannel which is configured with IP address is not allowed'
)
st.report_pass('portchannel_delete_with_ip_configured_portchannel')
def verify_traffic_hash(dut, port_list, pkts_per_port, traffic_loss_verify=False, rx_port = '',
tx_port = '', dut2 =''):
if traffic_loss_verify:
sub_list = []
sub_list.append([intf_obj.show_interface_counters_all, dut])
sub_list.append([intf_obj.show_interface_counters_all, dut2])
[output, exceptions] = utils.exec_all(True, sub_list)
utils.ensure_no_exception(exceptions)
data.int_cntr_1, data.int_cntr_2 = output
else:
data.int_cntr_1 = intf_obj.show_interface_counters_all(dut)
data.intf_count_dict = {}
for port in port_list:
for counter_dict in iterable(data.int_cntr_1):
if counter_dict['iface'] == port:
try:
data.intf_count_dict[port] = int(counter_dict['tx_ok'].replace(',',''))
except Exception:
st.report_fail('invalid_traffic_stats')
if not (data.intf_count_dict[port] >= pkts_per_port):
intf_obj.show_interface_counters_detailed(vars.D1, vars.D1T1P1)
st.report_fail("traffic_not_hashed", dut)
if traffic_loss_verify:
for counter_dict in data.int_cntr_1:
if counter_dict['iface'] == rx_port:
try:
data.rx_traffic = int(counter_dict['rx_ok'].replace(',', ''))
except Exception:
st.report_fail('invalid_traffic_stats')
break
for counter_dict in data.int_cntr_2:
if counter_dict['iface'] == tx_port:
try:
data.tx_traffic = int(counter_dict['tx_ok'].replace(',', ''))
except Exception:
st.report_fail('invalid_traffic_stats')
break
if not (data.tx_traffic >= 0.95* data.rx_traffic):
st.log("data.tx_traffic:{}".format(data.tx_traffic))
st.log("data.rx_traffic:{}".format(data.rx_traffic))
intf_obj.show_interface_counters_detailed(vars.D1, vars.D1T1P1)
st.report_fail('traffic_loss_observed')
return data.intf_count_dict
def test_ft_bgp_rst004():
dut1_data = {
'neigh_ip': "Vlan{}".format(bgp_rst_data.vlan_id[0]),
'local_asn': bgp_rst_data.dut1_asn,
'remote_asn': bgp_rst_data.dut2_asn,
'peer_type': "EXTERNAL",
'family': "ipv6",
'config': "add"
}
dut2_data = {
'neigh_ip': "Vlan{}".format(bgp_rst_data.vlan_id[0]),
'local_asn': bgp_rst_data.dut2_asn,
'remote_asn': bgp_rst_data.dut1_asn,
'peer_type': "EXTERNAL",
'family': "ipv6",
'config': "add"
}
[out, exceptions] = exec_parallel(True, [vars.D1, vars.D2],
config_bgp_neighbor_rst,
[dut1_data, dut2_data])
ensure_no_exception(exceptions)
for each in out:
if not each:
st.report_fail("bgp_neighbor_create_delete", "v6", "Creation",
"REST", "FAILED")
if not poll_wait(verify_bgp_neighbor_rst, 60, vars.D1, "Vlan{}".format(
bgp_rst_data.vlan_id[0])):
st.report_fail("bgp_neighbor_create_delete", "v6", "Creation", "REST",
"FAILED")
[out, exceptions] = exec_all(True, [[bgp_neighbor_del_rst, vars.D1, "Vlan{}".format(bgp_rst_data.vlan_id[0])], \
[bgp_neighbor_del_rst, vars.D2, "Vlan{}".format(bgp_rst_data.vlan_id[0])]])
ensure_no_exception(exceptions)
for each in out:
if not each:
st.report_fail("bgp_neighbor_create_delete", "v6", "Delrtion",
"REST", "FAILED")
st.report_pass("bgp_neighbor_status", "v6", "Successful", "REST")
def test_ft_control_plane_acl_icmp():
result = True
[output, exceptions] = parallel.exec_all(
True, [[st.get_mgmt_ip, vars.D1], [st.get_mgmt_ip, vars.D2]])
parallel.ensure_no_exception(exceptions)
d1_ipaddress, d2_ipaddress = output
d1_ipv6address = ip_obj.get_link_local_addresses(
vars.D1, "eth0", cli_type='click'
) ##Passing parameter cli_type as click until the SONIC-32291 fixed
if not d1_ipv6address:
st.report_fail('dut_not_getting_ip_address')
d1_ipv6address = d1_ipv6address[0]
st.log("Creating acl rules to drop icmp packets")
acl_config = acl_data.acl_json_config_control_plane_v2
st.log("ACL_DATA: {}".format(acl_config))
acl_obj.apply_acl_config(vars.D1, acl_config)
acl_obj.show_acl_table(vars.D1)
acl_obj.show_acl_rule(vars.D1)
if ip_obj.ping(dut=vars.D2, addresses=d1_ipaddress):
st.error(
"ICMP ipv4 packets are not dropped with applied control plane acl rules."
)
result = False
st.report_tc_fail("ft_controlplane_acl_ipv4_icmp", "test_case_failed")
if ip_obj.ping(dut=vars.D1,
addresses=d1_ipv6address,
interface="eth0",
family="ipv6"):
st.error(
"ICMP ipv6 packets are not dropped with applied control plane acl rules."
)
result = False
st.report_tc_fail("ft_controlplane_acl_ipv6_icmp", "test_case_failed")
change_acl_rules(acl_config, "L3_IPV4_ICMP|rule1", "SRC_IP",
"{}/32".format(d2_ipaddress))
change_acl_rules(acl_config, "L3_IPV6_ICMP|rule1", "SRC_IPV6",
"{}/128".format(d1_ipv6address))
acl_obj.acl_delete(vars.D1)
acl_obj.apply_acl_config(vars.D1, acl_config)
if not ip_obj.ping(dut=vars.D2, addresses=d1_ipaddress):
st.error(
"ICMP ipv4 packets are dropped with applied control plane acl rules."
)
result = False
st.report_tc_fail("ft_controlplane_acl_seq_priority",
"test_case_failed")
st.report_tc_fail("ft_controlplane_acl_ipv4_icmp_permit",
"test_case_failed")
if not ip_obj.ping(
dut=vars.D1, addresses=d1_ipv6address, interface="eth0",
family="ipv6"):
st.error(
"ICMP ipv6 packets are dropped with applied control plane acl rules."
)
result = False
st.report_tc_fail("ft_controlplane_acl_ipv6_icmp_permit",
"test_case_failed")
config_save(vars.D1)
st.log('rebooting the device.')
st.reboot(vars.D1, 'fast')
if not ip_obj.ping(dut=vars.D2, addresses=d1_ipaddress):
st.error(
"control plane ipv4 acl functionality is failed after reboot.")
st.report_tc_fail("ft_controlplane_acl_reboot", "test_case_failed")
result = False
if not ip_obj.ping(
dut=vars.D1, addresses=d1_ipv6address, interface="eth0",
family="ipv6"):
st.error(
"control plane ipv6 acl functionality is failed after reboot.")
st.report_tc_fail("ft_controlplane_acl_reboot", "test_case_failed")
result = False
if not result:
st.report_fail("test_case_failed")
else:
st.report_pass("test_case_passed")
