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 vlan_module_epilog():
if st.is_feature_supported("strom-control", vars.D1):
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="del", interface_name=interface, bits_per_sec=sc_data.kbps)
vlan.clear_vlan_configuration(st.get_dut_names(), thread=False)
portchannel.clear_portchannel_configuration(st.get_dut_names(),thread=True)
def bum_clear_config():
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="del",
interface_name=interface,
bits_per_sec=data.kbps)
vlan.clear_vlan_configuration(st.get_dut_names(), thread=False)
portchannel.clear_portchannel_configuration(st.get_dut_names(),
thread=True)
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 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 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)
def vlan_module_epilog():
if not st.is_community_build(vars.D1):
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="del",
interface_name=interface,
bits_per_sec=sc_data.kbps,
cli_type="click")
vlan.clear_vlan_configuration(st.get_dut_names(),
thread=False,
cli_type="click")
portchannel.clear_portchannel_configuration(st.get_dut_names(),
thread=True)
def test_ft_stormcontrol_portchannel_intf():
status = 1
msg_id = "storm_control_portchannel_verification_successful"
portchannel_name = 'PortChannel13'
vlan_info = [{
"dut": [vars.D2],
"vlan_id": sc_data.vlan,
"tagged": [vars.D2T1P1, vars.D2T1P2, portchannel_name]
}]
portchannel_interfaces_dut1 = [vars.D1D2P1, vars.D1D2P2]
portchannel_interfaces_dut2 = [vars.D2D1P1, vars.D2D1P2]
portchannel.config_portchannel(vars.D1,
vars.D2,
portchannel_name,
portchannel_interfaces_dut1,
portchannel_interfaces_dut2,
config="add",
thread=True)
vlan.add_vlan_member(vars.D1,
sc_data.vlan,
portchannel_name,
tagging_mode=True)
vlan.create_vlan_and_add_members(vlan_info)
st.log(
"Verifying whether stormcontrol config can be applied on portchannel {} interfaces"
.format(portchannel_name))
if scapi.config(vars.D1,
type="broadcast",
action="add",
interface_name=portchannel_name,
rate=sc_data.kbps,
skip_error_check=True):
st.error(
"storm-control config can be applied on portchannel interface")
status = 0
else:
st.log(
"storm-control config cannot be applied on portchannel interface.")
if status:
st.report_tc_pass('ft_stormcontrol_neg_config_vlan_portchannel',
'test_case_passed')
else:
st.report_tc_fail('ft_stormcontrol_neg_config_vlan_portchannel',
'test_case_failed')
status = 1
st.log("configuring bum stormcontrol on portchannel interfaces")
scapi.config(vars.D1,
type="broadcast",
action="del",
interface_name=vars.D1T1P1,
bits_per_sec=sc_data.kbps)
scapi.config(vars.D1,
type="broadcast",
action="del",
interface_name=vars.D1T1P2,
bits_per_sec=sc_data.kbps)
scapi.config(vars.D2,
type="broadcast",
action="add",
interface_name=vars.D2D1P1,
bits_per_sec=sc_data.kbps)
scapi.config(vars.D2,
type="broadcast",
action="add",
interface_name=vars.D2D1P2,
bits_per_sec=sc_data.kbps)
verify_bum_traffic_mode('broadcast',
tg_info['tg1_stream_id'],
skip_traffic_verify=True)
st.log("Clearing interface counters")
ifapi.clear_interface_counters(vars.D2)
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 interface 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_3_stats = tgapi.get_traffic_stats(tg,
mode='aggregate',
port_handle=tg_handler["tg_ph_3"])
counter = tg_3_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_count))
st.log("Lower packet count value is : {}".format(sc_data.lower_pkt_count))
st.log("value of status is : {}".format(status))
if counters_avg > sc_data.higher_pkt_count or counters_avg < sc_data.lower_pkt_count:
st.error("storm control traffic verification failed")
status = 0
if status:
st.report_tc_pass('ft_stormcontrol_portchannel_intf',
'test_case_passed')
else:
st.report_tc_fail('ft_stormcontrol_portchannel_intf',
'test_case_failed')
status = 1
st.log("Configuring stormcontrol without providing bps value")
if scapi.config(vars.D1,
type="broadcast",
action="add",
interface_name=vars.D1T1P1,
skip_error_check=True):
st.error("Storm-control config is accepting not throwing any error")
status = 0
else:
st.log("Config is not accepted and thrown an error")
if status:
st.report_tc_pass('ft_stormcontrol_neg_config_without_bpsvalue',
'test_case_passed')
else:
st.report_tc_fail('ft_stormcontrol_neg_config_without_bpsvalue',
'test_case_failed')
status = 1
st.log("unconfiguring of bum stormcontrol type by providing bps value")
if scapi.config(vars.D1,
type="broadcast",
action="del",
interface_name=vars.D1T1P1,
rate=sc_data.kbps,
skip_error_check=True):
st.error("Storm-control config is removed and not throwing any error")
status = 0
else:
st.log("Config is not accepted and thrown an error")
if status:
st.report_tc_pass('ft_stormcontrol_neg_unconfig_with_bpsvalue',
'test_case_passed')
else:
st.report_tc_fail('ft_stormcontrol_neg_unconfig_with_bpsvalue',
'test_case_failed')
st.log("Back to module config")
scapi.config(vars.D2,
type="broadcast",
action="del",
interface_name=vars.D2D1P1,
bits_per_sec=sc_data.kbps)
scapi.config(vars.D2,
type="broadcast",
action="del",
interface_name=vars.D2D1P2,
bits_per_sec=sc_data.kbps)
scapi.config(vars.D1,
type="broadcast",
action="add",
interface_name=vars.D1T1P1,
bits_per_sec=sc_data.kbps)
scapi.config(vars.D1,
type="broadcast",
action="add",
interface_name=vars.D1T1P2,
bits_per_sec=sc_data.kbps)
st.log(
"Unconfiguring portchannel config in both devices and only vlan configuration in device2"
)
vlan.clear_vlan_configuration(vars.D2)
vlan.delete_vlan_member(vars.D1,
sc_data.vlan,
portchannel_name,
tagging_mode=True)
portchannel.clear_portchannel_configuration(st.get_dut_names(),
thread=True)
if not status:
msg_id = "storm_control_portchannel_verification_failed"
report_result(status, msg_id)
