def test_ft_stormcontrol_verification():
status = 1
msg_id = "storm_control_traffic_verification_successful"
new_kbps_value = 1010
st.log("Module config got passed")
st.report_tc_pass('ft_stormcontrol_config_all_same_interface', 'test_case_passed')
if not verify_bum_traffic_mode('broadcast', tg_info['tg1_stream_id'], skip_traffic_verify=False):
st.error("Broadcast traffic verification got failed")
status = 0
if not verify_bum_traffic_mode('unknown-unicast', tg_info['tg1_stream_id'], skip_traffic_verify=False):
st.error("Unknown-unicast traffic verification got failed")
status = 0
if not verify_bum_traffic_mode('unknown-multicast', tg_info['tg1_stream_id'], skip_traffic_verify=False):
st.error("Unknown-multicast traffic verification got failed")
status = 0
if status:
st.report_tc_pass('ft_stormcontrol_BUM_traffic_policer_params', 'test_case_passed')
st.report_tc_pass('ft_stormcontrol_traffic_rate_limited_bpsvalue', 'test_case_passed')
else:
st.report_tc_fail('ft_stormcontrol_BUM_traffic_policer_params', 'test_case_failed')
st.report_tc_fail('ft_stormcontrol_traffic_rate_limited_bpsvalue', 'test_case_failed')
status=1
st.log("Configuring kbps value on interface to verify kpbs value is independent of interface")
scapi.config(vars.D1, type="broadcast", action="add", interface_name=vars.D1T1P1, bits_per_sec=new_kbps_value)
if not scapi.verify_config(vars.D1, interface_name=vars.D1T1P1, type="broadcast", rate=new_kbps_value):
st.error("KBPS value configured on interface is dependent to other interface")
status = 0
if status:
st.report_tc_pass('ft_stormcontrol_bps_intf_indp', 'test_case_passed')
st.report_tc_pass('ft_stormcontrol_bps_overwrite_new_bps_value', 'test_case_passed')
else:
st.report_tc_fail('ft_stormcontrol_bps_intf_indp', 'test_case_failed')
st.report_tc_fail('ft_stormcontrol_bps_overwrite_new_bps_value', 'test_case_failed')
status = 1
st.log("configuring back to previous config")
scapi.config(vars.D1, type="broadcast", action="add", interface_name=vars.D1T1P1, bits_per_sec=sc_data.kbps)
scapi.verify_config(vars.D1, interface_name=vars.D1T1P1, type="broadcast", rate=sc_data.kbps)
if not verify_bum_traffic_mode('broadcast', tg_info['tg1_stream_id'], skip_traffic_verify=False):
st.error("Broadcast traffic verification got failed")
status = 0
if status:
st.report_tc_pass('ft_stormcontrol_config_clear_noaffect_traffic', 'test_case_passed')
else:
st.report_tc_fail('ft_stormcontrol_config_clear_noaffect_traffic', 'test_case_failed')
status = 1
st.log("clearing bum traffic type to verify othertraffic does not effect bum storm-control")
scapi.config(vars.D1, type="unknown-unicast", action="del", interface_name=vars.D1T1P1, bits_per_sec=sc_data.kbps)
st.log("verifying the other traffic is not get effected.")
if not verify_bum_traffic_mode('unknown-unicast', tg_info['tg1_stream_id'], skip_traffic_verify=True):
st.error("Other_traffic traffic verification got failed")
status = 0
if status:
st.report_tc_pass('ft_stormcontrol_config_unaffect_other_traffic', 'test_case_passed')
else:
st.report_tc_fail('ft_stormcontrol_config_unaffect_other_traffic', 'test_case_failed')
st.log("configuring back to previous config")
scapi.config(vars.D1, type="unknown-unicast", action="add", interface_name=vars.D1T1P1, bits_per_sec=sc_data.kbps)
if not status:
msg_id = "storm_control_traffic_verification_failed"
report_result(status, msg_id)
def vlan_module_prolog():
"""
Module prolog for module configuration
:return:
"""
st.log("Creating vlan in device and adding members ...")
vlan.create_vlan_and_add_members(sc_data.vlan_data)
if st.is_feature_supported("strom-control", vars.D1):
st.banner("Configuring BUM Storm control on interfaces")
interface_list = [vars.D1T1P1, vars.D1T1P2]
storm_control_type = [
"broadcast", "unknown-multicast", "unknown-unicast"
]
for interface in interface_list:
for stc_type in storm_control_type:
scapi.config(vars.D1,
type=stc_type,
action="add",
interface_name=interface,
bits_per_sec=sc_data.kbps)
if not scapi.verify_config(vars.D1,
interface_name=interface,
type=stc_type,
rate=sc_data.kbps):
st.report_fail("storm_control_config_verify_failed",
stc_type, interface)
def test_ft_stormcontrol_fast_reboot():
status = 1
interface_list = [vars.D1T1P1, vars.D1T1P2]
storm_control_type = ["broadcast", "unknown-multicast", "unknown-unicast"]
msg_id = "storm_control_reboot_successful"
utils.banner_log("Verifying BUM storm control before fast reboot")
if not verify_bum_traffic_mode(
'broadcast', tg_info['tg1_stream_id'], skip_traffic_verify=False):
st.error("Broadcast traffic verification got failed")
status = 0
st.log("performing Config save")
reboot.config_save(vars.D1)
#############################################################################################
utils.banner_log("Performing fast-reboot operation --STARTED")
#############################################################################################
st.log("performing fast-reboot")
st.reboot(vars.D1, 'fast')
#############################################################################################
utils.banner_log("Performing fast-reboot operation --COMPLETED")
#############################################################################################
for interface in interface_list:
for stc_type in storm_control_type:
if not scapi.verify_config(vars.D1,
interface_name=interface,
type=stc_type,
rate=sc_data.kbps):
st.report_fail("storm_control_config_verify_failed", stc_type,
interface)
status = 0
st.log("Traffic Config for verifying BUM storm control feature")
tg.tg_traffic_control(action="reset", port_handle=tg_handler["tg_ph_list"])
tg_1 = tg.tg_traffic_config(port_handle=tg_handler["tg_ph_1"],
mode='create',
rate_pps=5000,
duration=10,
l2_encap='ethernet_ii_vlan',
vlan_id=sc_data.vlan,
mac_src="00:00:00:00:00:01",
mac_dst="ff:ff:ff:ff:ff:ff",
high_speed_result_analysis=0,
vlan="enable",
port_handle2=tg_handler["tg_ph_2"],
frame_size=sc_data.frame_size,
length_mode='fixed')
tg_info['tg1_stream_id'] = tg_1['stream_id']
utils.banner_log("Verifying BUM storm control after fast reboot")
if not verify_bum_traffic_mode(
'broadcast', tg_info['tg1_stream_id'], skip_traffic_verify=False):
st.error("Broadcast traffic verification got failed")
status = 0
if not status:
msg_id = "storm_control_reboot_failed"
report_result(status, msg_id)
def test_ft_stormcontrol_incremental_bps_max_vlan():
status = 1
counters_avg =0
msg_id = "storm_control_traffic_incremental_bps_max_vlan_successful"
initial_kbps_value = 600
last_kbps_value = 1000
interface_list = [vars.D1T1P1, vars.D1T1P2]
for kbps_value in range(initial_kbps_value, last_kbps_value, 200):
for interf in interface_list:
scapi.config(vars.D1, type="broadcast", action="add", interface_name=interf, bits_per_sec=kbps_value)
if not scapi.verify_config(vars.D1, interface_name=interf, type="broadcast", rate=kbps_value):
st.error("incremental kbps is not working")
status = 0
sc_data.packets = (kbps_value * 1024) / (sc_data.frame_size * 8)
sc_data.bum_deviation1 = int(0.10 * sc_data.packets)
sc_data.lower_pkt_cnt = int(sc_data.packets - sc_data.bum_deviation1)
sc_data.higher_pkt_cnt = int(sc_data.packets + sc_data.bum_deviation1)
for _ in range(1,3,1):
verify_bum_traffic_mode('broadcast', tg_info['tg1_stream_id'], skip_traffic_verify=True)
st.log("Clearing interface counters")
ifapi.clear_interface_counters(vars.D1)
st.log("Starting of traffic from TGen")
tg.tg_traffic_control(action='run',stream_handle=tg_info['tg1_stream_id'], duration=10)
st.wait(sc_data.wait_stream_run)
st.log("Stopping of traffic from TGen to get counters")
tg.tg_traffic_control(action='stop', stream_handle=tg_info['tg1_stream_id'])
st.wait(sc_data.wait_for_stats)
tg_1_stats = tgapi.get_traffic_stats(tg, mode='aggregate', port_handle=tg_handler["tg_ph_1"])
tg_2_stats = tgapi.get_traffic_stats(tg, mode='aggregate', port_handle=tg_handler["tg_ph_2"])
counter = tg_2_stats.rx.total_packets
counter2 = tg_1_stats.tx.total_packets
try:
time = int(counter2 / sc_data.rate_pps)
counters_avg = counter / time
except Exception:
counters_avg = 0
st.log("Average of counters are : {}".format(counters_avg))
st.log("Higher packet count value is : {}".format(sc_data.higher_pkt_cnt))
st.log("Lower packet count value is : {}".format(sc_data.lower_pkt_cnt))
st.log("value of status is : {}".format(status))
if counters_avg <= sc_data.higher_pkt_cnt and counters_avg >= sc_data.lower_pkt_cnt:
break
if counters_avg > sc_data.higher_pkt_cnt or counters_avg < sc_data.lower_pkt_cnt:
st.error("storm control traffic verification failed")
status = 0
st.log("Unconfiguring back to previous config")
for interf in interface_list:
scapi.config(vars.D1, type="broadcast", action="add", interface_name=interf, bits_per_sec=sc_data.kbps)
if not status:
msg_id = "storm_control_traffic_incremental_bps_max_vlan_failed"
report_result(status, msg_id)
def storm_control_verify():
status = 1
platform_check()
st.log(
"Removing mirror session related information to ensure that BUM is unaffected due to mirror sessions"
)
mirror.delete_session(vars.D1, mirror_session=data.session_name_port)
st.log("Creating vlan in device and adding members ...")
vlan_data = [{
"dut": [vars.D1],
"vlan_id": data.vlan,
"tagged": [vars.D1T1P1, vars.D1T1P2]
}]
vlan.create_vlan_and_add_members(vlan_data)
msg_id = "storm_control_reboot_successful"
interface_list = [vars.D1T1P1, vars.D1T1P2]
storm_control_type = ["broadcast", "unknown-multicast", "unknown-unicast"]
for interface_li in interface_list:
for stc_type in storm_control_type:
if not scapi.verify_config(vars.D1,
interface_name=interface_li,
type=stc_type,
rate=data.kbps):
st.report_fail("storm_control_config_verify_failed", stc_type,
interface_li)
if not verify_bum_traffic_mode(
'broadcast', tg_info['tg1_stream_id'], skip_traffic_verify=False):
st.error("Broadcast traffic verification got failed")
status = 0
if not verify_bum_traffic_mode('unknown-unicast',
tg_info['tg1_stream_id'],
skip_traffic_verify=False):
st.error("Unknown-unicast traffic verification got failed")
status = 0
if not verify_bum_traffic_mode('unknown-multicast',
tg_info['tg1_stream_id'],
skip_traffic_verify=False):
st.error("Unknown-multicast traffic verification got failed")
status = 0
if not status:
msg_id = "storm_control_reboot_failed"
if status:
st.report_tc_pass('ft_stormcontrol_cold_reboot', 'test_case_passed')
else:
st.report_tc_fail('ft_stormcontrol_cold_reboot', 'test_case_failed')
report_result(status, msg_id)
def storm_control_config():
st.banner("Configuring BUM Storm control on interfaces")
interface_list = [vars.D1T1P1, vars.D1T1P2]
storm_control_type = ["broadcast", "unknown-multicast", "unknown-unicast"]
for interface_li in interface_list:
for stc_type in storm_control_type:
scapi.config(vars.D1,
type=stc_type,
action="add",
interface_name=interface_li,
bits_per_sec=data.kbps)
if not scapi.verify_config(vars.D1,
interface_name=interface_li,
type=stc_type,
rate=data.kbps):
st.report_fail("storm_control_config_verify_failed", stc_type,
interface_li)
