def test_ft_bgp_unnumbered_bfd():
utils_obj.banner_log('FtOtSoRtBgpUnFn006')
# ################ Author Details ################
# Name: Kiran Vedula
# Email: [email protected]
# ################################################
result = 0
st.log('######------Enable BFD on unnumbered BGP peers------######')
dict1 = {
'config': 'yes',
'local_asn': data.d1_local_as,
'neighbor_ip': vars.D1D2P1,
'interface': vars.D1D2P1
}
dict2 = {
'config': 'yes',
'local_asn': data.d2_local_as,
'neighbor_ip': vars.D2D1P1,
'interface': vars.D2D1P1
}
parallel.exec_parallel(True, [vars.D1, vars.D2], bfd_obj.configure_bfd,
[dict1, dict2])
if not utils.poll_wait(bfd_obj.verify_bfd_peers_brief,
data.wait_timer,
vars.D2,
peeraddress=d1_prt_link_local[0],
ouraddress=d2_prt_link_local[0],
status="UP"):
st.log("Failed to get BFD status Up")
result += 1
if result == 0:
st.report_pass("test_case_passed")
else:
st.log("BGP unnumbered neighborship failure")
st.report_fail("test_case_failed")
def get_root_bridge_for_vlan(dut_vlan_data, thread=True):
params = list()
result = dict()
for dut, vlan in dut_vlan_data.items():
params.append([check_dut_is_root_bridge_for_vlan, dut, vlan])
if params:
[out, exceptions] = exec_all(thread, params)
utils.banner_log("Getting root bridge details")
for i, response in enumerate(out):
result[params[i][1]] = response
print(result)
return result
def tf_collecting_debug_logs_when_test_fails(test, delay, traffic_mode):
cutils.banner_log("TEST Failed - Collecting the DEBUG log and prints")
tfapi.threshold_feature_debug(vars.D1,
mode=['clear_counters', 'debug_log_enable'])
tf_tg_traffic_start_stop(traffic_mode, traffic_action=False)
tf_data.tg.tg_traffic_control(action='run',
stream_handle=tf_data.stream_list)
st.wait(delay)
tfapi.threshold_feature_debug(
vars.D1,
mode=['show_counters', 'asic_info', 'show_logging'],
platform=tf_data.platform,
test=test)
tf_data.tg.tg_traffic_control(action='stop',
stream_handle=tf_data.stream_list)
tfapi.threshold_feature_debug(vars.D1, mode='debug_log_disable')
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_bgp_unnumbered_pc_mem_add_rem():
# ################ Author Details ################
# Name: Kiran Vedula
# Email: [email protected]
# ################################################
utils_obj.banner_log('FtOtSoRtBgpUnFn003,FtOtSoRtBgpUnFn008')
result = 0
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=data.portchannel_name,
state='Established'):
st.log("Failed to form BGP unnumbered peering using IPv6 link local")
result += 1
ip_obj.config_interface_ip6_link_local(vars.D1, data.portchannel_name,
'disable')
pc_obj.add_del_portchannel_member(vars.D1, data.portchannel_name,
[vars.D1D2P3, vars.D1D2P4], 'del')
st.wait(data.wait)
pc_obj.add_del_portchannel_member(vars.D1, data.portchannel_name,
[vars.D1D2P3, vars.D1D2P4], 'add')
ip_obj.config_interface_ip6_link_local(vars.D1, data.portchannel_name,
'enable')
st.wait(data.wait)
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=data.portchannel_name,
state='Established'):
st.log("Failed to form BGP unnumbered peering using IPv6 link local")
result += 1
if result == 0:
st.report_pass("test_case_passed")
else:
st.log(
"BGP unnumbered neighborship failed after PC member del and re-add"
)
st.report_fail("test_case_failed")
def get_stp_stats(dut, vlan, interface, param):
"""
:param dut:
:param vlan:
:param interface:
:param param:
tx_bpdu : BPDU Transmission count
rx_bpdu : BPDU Receive count
tx_tcn : TCN Transmission count
rx_tcn : TCN Receive count
:return:
"""
output = show_stp_stats_vlan(dut, vlan)
#show_stp_config_using_klish(dut, 'statistics', vlan)
value_list = [
row[param] for row in output
if int(row['st_vid']) == vlan and row['st_portno'] == interface
]
utils.banner_log(value_list)
return None if len(output) == 0 else int(value_list[0])
def test_ft_bgp_unnumbered_peer_basic():
# ################ Author Details ################
# Name: Kiran Vedula
# Email: [email protected]
# ################################################
utils_obj.banner_log(
'FtOtSoRtBgpUnFn001,FtOtSoRtBgpUnFn002,FtOtSoRtBgpUnFn018,FtOtSoRtBgpUnFn019'
)
st.log('######------Configure Unnumbered BGP peers------######')
result = 0
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.log("Failed to form BGP unnumbered peering using IPv6 link local")
result += 1
bgp_obj.config_bgp_neighbor_properties(vars.D1,
data.d1_local_as,
vars.D1D2P1,
family="ipv6",
neighbor_shutdown='',
no_form='')
if utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.log("unnumbered BGP peering is established even after shutdown")
result += 1
bgp_obj.config_bgp_neighbor_properties(vars.D1,
data.d1_local_as,
vars.D1D2P1,
family="ipv6",
neighbor_shutdown='',
no_form='no')
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.log(
"Failed to form BGP unnumbered peering using IPv6 link local after no shutdown"
)
result += 1
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=data.vlan_in_1,
state='Established'):
st.log(
"Failed to form BGP unnumbered peering using IPv6 link local on a VLAN"
)
result += 1
# Get show ndp output
st.log('######------shut/no shut link with unnumbered BGP------######')
utils.exec_all(
True,
[[arp_obj.show_ndp, vars.D1, None], [arp_obj.show_ndp, vars.D2, None]])
intf_obj.interface_operation(vars.D1,
vars.D1D2P1,
operation="shutdown",
skip_verify=True)
st.wait(data.wait)
intf_obj.interface_status_show(vars.D1, vars.D1D2P1)
intf_obj.interface_operation(vars.D1,
vars.D1D2P1,
operation="startup",
skip_verify=True)
st.wait(data.wait)
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.log("Failed to form BGP unnumbered peering using IPv6 link local")
result += 1
if result == 0:
st.report_pass("test_case_passed")
else:
st.log("BGP IPv6 unnumbered neighborship failure")
st.report_fail("test_case_failed")
def test_ft_bgp_unnumbered_warmboot():
# ################ Author Details ################
# Name: Kiran Vedula
# Email: [email protected]
# ################################################
utils_obj.banner_log('FtOtSoRtBgpUnFn009')
utils.exec_all(True, [[bgp_obj.show_bgp_ipv6_summary_vtysh, vars.D1],
[bgp_obj.show_bgp_ipv6_summary_vtysh, vars.D2]])
utils.exec_all(
True,
[[arp_obj.show_ndp, vars.D1, None], [arp_obj.show_ndp, vars.D2, None]])
result = 0
st.log('######------Warm reboot with BGP unnumbered------######')
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('Warmboot_unsupported_platform', platform)
reboot_obj.config_save(vars.D1, "sonic")
reboot_obj.config_save(vars.D1, "vtysh")
st.reboot(vars.D1, 'warm')
st.wait(data.wait)
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D2,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D2D1P1,
state='Established'):
st.log("Failed to form BGP unnumbered peering after warm reboot")
result += 1
st.wait(data.wait)
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D2,
family='ipv6',
shell=bgp_cli_type,
neighbor=data.vlan_in_1,
state='Established'):
st.log("Failed to form BGP unnumbered peering after warm reboot")
result += 1
st.wait(data.wait)
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D2,
family='ipv6',
shell=bgp_cli_type,
neighbor=data.portchannel_name,
state='Established'):
st.log("Failed to form BGP unnumbered peering after warm reboot")
result += 1
if result == 0:
st.report_pass("test_case_passed")
else:
st.log("BGP unnumbered neighborship failed warm reboot")
utils.exec_all(True, [[arp_obj.show_ndp, vars.D1, None],
[arp_obj.show_ndp, vars.D2, None]])
utils.exec_all(True, [[bgp_obj.show_bgp_ipv6_neighbor_vtysh, vars.D1],
[bgp_obj.show_bgp_ipv6_neighbor_vtysh, vars.D2]])
st.report_fail("test_case_failed")
def test_ft_bgp_unnumbered_nondefault_vrf():
"""
# ################ Author Details ################
# Name: Sesha Reddy Koilkonda
# Email: [email protected]
# ################################################
:return:
"""
utils_obj.banner_log("FtOtSoRtBgpUnFn016,FtOtSoRtBgpUnFn017")
result = 0
bgp_obj.cleanup_router_bgp(st.get_dut_names())
dict1 = {'vrf_name': data.vrf_name, 'skip_error': True}
parallel.exec_parallel(True, [vars.D1, vars.D2], vrf_api.config_vrf,
[dict1, dict1])
utils.exec_all(True, [[
ip_obj.config_interface_ip6_link_local, vars.D1, vars.D1D2P1, "disable"
], [
ip_obj.config_interface_ip6_link_local, vars.D2, vars.D2D1P1, "disable"
]])
dict1 = {
'vrf_name': data.vrf_name,
'intf_name': vars.D1D2P1,
'skip_error': True
}
dict2 = {
'vrf_name': data.vrf_name,
'intf_name': vars.D2D1P1,
'skip_error': True
}
parallel.exec_parallel(True, [vars.D1, vars.D2],
vrf_api.bind_vrf_interface, [dict1, dict2])
utils.exec_all(
True, [[ip_obj.config_interface_ip6_link_local, vars.D1, vars.D1D2P1],
[ip_obj.config_interface_ip6_link_local, vars.D2, vars.D2D1P1]])
utils.exec_all(True,
[[ip_obj.get_interface_ip_address, vars.D1, None, "ipv6"],
[ip_obj.get_interface_ip_address, vars.D2, None, "ipv6"]])
dict1 = {
'vrf_name': data.vrf_name,
'router_id': data.d1_rid,
'local_as': data.d1_local_as,
'addr_family': 'ipv6',
'neighbor': vars.D1D2P1,
'remote_as': 'external',
'config_type_list': ["remote-as", "activate"],
'interface': vars.D1D2P1
}
dict2 = {
'vrf_name': data.vrf_name,
'router_id': data.d2_rid,
'local_as': data.d2_local_as,
'addr_family': 'ipv6',
'neighbor': vars.D2D1P1,
'remote_as': 'external',
'config_type_list': ["remote-as", "activate"],
'interface': vars.D2D1P1
}
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
vrf=data.vrf_name,
state='Established'):
st.error(
"BGP unnumbered neighbourship with the non-default vrf configuration failed."
)
result += 1
st.log('######------Save and reboot------######')
reboot_obj.config_save(vars.D1, "sonic")
reboot_obj.config_save(vars.D1, "vtysh")
st.reboot(vars.D1)
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
vrf=data.vrf_name,
state='Established'):
st.error(
"BGP unnumbered neighbourship with the non-default vrf configuration failed after save and reboot."
)
result += 1
st.log('######------Config reload with BGP unnumbered------######')
st.log("Config reload the DUT")
reboot_obj.config_save_reload(vars.D1)
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
vrf=data.vrf_name,
state='Established'):
st.error(
"BGP unnumbered neighbourship with the non-default vrf configuration failed after config reload."
)
result += 1
# unconfig part:
dict1 = {
'vrf_name': data.vrf_name,
'local_as': data.d1_local_as,
'config': 'no',
'removeBGP': 'yes',
'config_type_list': ['removeBGP']
}
dict2 = {
'vrf_name': data.vrf_name,
'local_as': data.d2_local_as,
'config': 'no',
'removeBGP': 'yes',
'config_type_list': ['removeBGP']
}
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
utils.exec_all(True, [[
ip_obj.config_interface_ip6_link_local, vars.D1, vars.D1D2P1, "disable"
], [
ip_obj.config_interface_ip6_link_local, vars.D2, vars.D2D1P1, "disable"
]])
dict1 = {
'vrf_name': data.vrf_name,
'intf_name': vars.D1D2P1,
'skip_error': True,
'config': 'no'
}
dict2 = {
'vrf_name': data.vrf_name,
'intf_name': vars.D2D1P1,
'skip_error': True,
'config': 'no'
}
parallel.exec_parallel(True, [vars.D1, vars.D2],
vrf_api.bind_vrf_interface, [dict1, dict2])
dict1 = {'vrf_name': data.vrf_name, 'skip_error': True, 'config': 'no'}
parallel.exec_parallel(True, [vars.D1, vars.D2], vrf_api.config_vrf,
[dict1, dict1])
bgp_obj.cleanup_router_bgp(st.get_dut_names())
utils.exec_all(
True,
[[ip_obj.config_interface_ip6_link_local, vars.D1, d1_int_ipv6_list],
[ip_obj.config_interface_ip6_link_local, vars.D2, d2_int_ipv6_list]])
if result == 0:
st.report_pass("test_case_passed")
else:
st.error(
"BGP unnumbered neighborship failed with the non-default vrf configuration."
)
st.report_fail("test_case_failed")
def test_ft_bgp_unnumbered_manual_ll():
"""
# ################ Author Details ################
# Name: Sesha Reddy Koilkonda
# Email: [email protected]
# ################################################
:return:
"""
utils_obj.banner_log(
'FtOtSoRtBgpUnFn013,FtOtSoRtBgpUnFn014,FtOtSoRtBgpUnFn015')
result = 0
# Configure the Link-local manually on Dut1 and auto link-local on DUT2 and verify the neighbourship.
bgp_obj.cleanup_router_bgp(st.get_dut_names())
ip_obj.config_ip_addr_interface(vars.D1,
vars.D1D2P1,
data.ip6_addr_manual_ll[0],
96,
family='ipv6')
dict1 = {
'config': 'yes',
'router_id': data.d1_rid,
'addr_family': 'ipv6',
'local_as': data.d1_local_as,
'remote_as': 'external',
'config_type_list': ["remote-as", "activate"],
'interface': vars.D1D2P1,
'neighbor': vars.D1D2P1
}
dict2 = {
'config': 'yes',
'router_id': data.d2_rid,
'addr_family': 'ipv6',
'local_as': data.d2_local_as,
'remote_as': 'external',
'config_type_list': ["remote-as", "activate"],
'interface': vars.D2D1P1,
'neighbor': vars.D2D1P1
}
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.error(
"Failed to form BGP unnumbered peering using IPv6 link local with the Manual-Auto link-local address combination."
)
result += 1
# with the manual link-local on Dut1 and configure the link-local on DUT2 also manually and verify the neighbourship.
bgp_obj.cleanup_router_bgp(st.get_dut_names())
ip_obj.config_ip_addr_interface(vars.D2,
vars.D2D1P1,
data.ip6_addr_manual_ll[1],
96,
family='ipv6')
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.error(
"Failed to form BGP unnumbered peering using IPv6 link local with the manual-manual link-local address combination."
)
result += 1
# update the manual link-local on Dut2 and verify the neighbourship.
bgp_obj.cleanup_router_bgp(st.get_dut_names())
data.ip6_addr_ll3 = 'FE80:0:0:0:204:5FF:FE00:500'
ip_obj.config_ip_addr_interface(vars.D2,
vars.D2D1P1,
data.ip6_addr_manual_ll[2],
96,
family='ipv6')
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.error(
"Failed to form BGP unnumbered peering using IPv6 link local, after uodating the manual link-local address on peer DUT.."
)
result += 1
bgp_obj.cleanup_router_bgp(st.get_dut_names())
ip_obj.config_ip_addr_interface(vars.D1,
vars.D1D2P1,
data.ip6_addr_manual_ll[0],
96,
family='ipv6',
config='remove')
ip_obj.config_ip_addr_interface(vars.D2,
vars.D2D1P1,
data.ip6_addr_manual_ll[1],
96,
family='ipv6',
config='remove')
ip_obj.config_ip_addr_interface(vars.D2,
vars.D2D1P1,
data.ip6_addr_manual_ll[2],
96,
family='ipv6',
config='remove')
if result == 0:
st.report_pass("test_case_passed")
else:
st.error(
"BGP unnumbered neighborship failed with the manual link-local address configuration."
)
st.report_fail("test_case_failed")
def test_ft_tf_pg_thre_con_shared():
"""
Author : Prudvi Mangadu ([email protected])
"""
tf_data.index = 7
if tf_data.platform in tf_data.th3_platforms:
tf_data.index = 0
st.log("Testing with PG{} for PG SHARED test on {}".format(
tf_data.index, tf_data.platform))
tf_data.threshold = 4
count = 1
while True:
result = 1
result2 = 1
cutils.banner_log("TEST Starts for iteration - {}".format(count))
config_parameter = {
"threshold_type": 'priority-group',
"buffer_type": 'shared',
"port_alias": vars.D1T1P1,
"pg{}".format(tf_data.index): tf_data.threshold
}
st.log("PG shared threshold config")
tfapi.config_threshold(vars.D1,
threshold_type='priority-group',
port_alias=vars.D1T1P1,
index=tf_data.index,
buffer_type='shared',
value=tf_data.threshold)
st.log("PG shared threshold config verify")
if not tfapi.verify_threshold(vars.D1, **config_parameter):
st.error(
"Unable to configure the PG index and corresponding threshold value on PG shared buffer"
)
result = 0
st.log("Traffic start and stop")
tf_tg_traffic_start_stop(tf_data.unicast, tf_data.traffic_duration)
st.log("Checking PG shared breach event")
if not tfapi.verify_threshold_breaches(vars.D1,
buffer='priority-group',
port=vars.D1T1P1,
index=tf_data.index,
threshold_type='shared'):
st.error("PG shared threshold breach Event is not found")
if tf_data.need_debug_prints:
tf_collecting_debug_logs_when_test_fails(
'shared', tf_data.traffic_duration, tf_data.unicast)
result = 0
result2 = 0
st.log("Clear PG shared threshold breach")
tfapi.clear_threshold(vars.D1, breach='all')
st.log("Checking PG shared breach event")
if tfapi.verify_threshold_breaches(vars.D1,
buffer='priority-group',
port=vars.D1T1P1,
index=tf_data.index,
threshold_type='shared'):
st.error("Post clear - PG shared threshold breach Event is found")
result = 0
st.log("PG shared threshold config clear")
tfapi.clear_threshold(vars.D1,
threshold_type='priority-group',
port_alias=vars.D1T1P1,
index=tf_data.index,
buffer_type='shared')
st.log("PG shared threshold config verify")
if tfapi.verify_threshold(vars.D1, **config_parameter):
st.error(
"Unable to configure the PG index and corresponding shared threshold value"
)
result = 0
if not result2 and tf_data.need_debug_prints:
st.log(
"As Breach events are not observed collecting logs by disabling the Thresholds"
)
tf_collecting_debug_logs_when_test_fails('shared',
tf_data.traffic_duration,
tf_data.unicast)
tfapi.clear_threshold(vars.D1, breach='all')
if result:
st.log("Test PASSED in Iteration {}.".format(count))
report_result(result)
break
if count == tf_data.test_max_retries_count:
st.log("Test Failed in all {} Iterations. Hence Declaring as FAIL".
format(count))
report_result(result)
st.log(
"Test Failed in the Iteration-{}. Hence re-testing".format(count))
count += 1
def gnmi_call(dut, **kwargs):
"""
Call to test gnmi session using diff users w.r.t RBAC.
Author : Prudvi Mangadu ([email protected])
:param dut:
:param kwargs:
:return:
"""
banner_log('Performing gnmi operations using - {}'.format(kwargs))
for each in ['login_type', 'username', 'password', 'mode']:
if not kwargs.get(each):
st.error("Mandatory argument is not found - {}".format(each))
return False
dut_ip = "127.0.0.1"
result = {'gnmi_get_out': True, 'gnmi_set_out': True}
result2 = True
username = kwargs.get('username')
password = kwargs.get('password')
cert = kwargs.get('cert')
login_type = kwargs.get('login_type')
mode = kwargs.get('mode')
port = st.get_free_ports(dut)[0]
insecure = kwargs.get('insecure', '')
xpath = '/openconfig-interfaces:interfaces/interface[name={}]/config/description'.format(
port)
json_content = {"openconfig-interfaces:description": "Eth"}
if login_type == 'cred':
gnmi_set_out = gnmi_set(dut,
xpath,
json_content=json_content,
ip_address=dut_ip,
username=username,
password=password)
st.log(gnmi_set_out)
gnmi_get_out = gnmi_get(dut,
xpath,
ip_address=dut_ip,
username=username,
password=password)
st.log(gnmi_get_out)
elif login_type == 'cert':
gnmi_set_out = gnmi_set(dut,
xpath,
json_content=json_content,
ip_address=dut_ip,
cert=cert,
username=None,
password=None,
insecure='none',
target_name='admin')
st.log(gnmi_set_out)
gnmi_get_out = gnmi_get(dut,
xpath,
ip_address=dut_ip,
cert=cert,
username=None,
password=None,
insecure='none',
target_name='admin')
st.log(gnmi_get_out)
else:
st.error("Invalid 'login_type' used = {}".format(login_type))
return False
if mode == 'rw':
if not (gnmi_set_out and gnmi_get_out):
st.report_fail('rbac_call_fail', "gNMI", mode, login_type)
else:
if not (not gnmi_set_out and gnmi_get_out):
st.report_fail('rbac_call_fail', "gNMI", mode, login_type)
msg = 'Failed to execute set command using gNMI session with mode- {mode}, type- {login_type}'
if mode == 'rw' and "op: UPDATE" not in gnmi_set_out and "description" not in str(
gnmi_get_out):
st.error(msg.format(**kwargs))
result2 = False
if mode == 'ro' and not gnmi_set_out and "description" not in str(
gnmi_get_out):
st.error(msg.format(**kwargs))
result2 = False
if not result2:
st.report_fail('rbac_test_status', 'Fail', mode, 'gNMI', login_type,
result)
st.report_pass('rbac_test_status', 'Pass', mode, 'gNMI', login_type,
result)
def test_ft_bgp_unnumbered_traffic():
"""
# ################ Author Details ################
# Name: Sesha Reddy Koilkonda
# Email: [email protected]
# ################################################
:return:
"""
utils_obj.banner_log('FtOtSoRtBgpUnFn021')
(tg1, tg2, tg_ph_1, tg_ph_2) = get_handles()
dut1_mac = basic_obj.get_ifconfig_ether(vars.D1, vars.D1T1P1)
h1 = tg1.tg_interface_config(port_handle=tg_ph_1,
mode='config',
intf_ip_addr=data.tg_ip4_addr_l[0],
gateway=data.tgd_ip4_addr_l[0],
src_mac_addr='00:0a:01:00:00:01',
arp_send_req='1')
h2 = tg2.tg_interface_config(port_handle=tg_ph_2,
mode='config',
intf_ip_addr=data.tg_ip4_addr_l[1],
gateway=data.tgd_ip4_addr_l[1],
src_mac_addr='00:0a:01:00:00:01',
arp_send_req='1')
# Advertise a network to peer
network = '55.1.1.0/24'
bgp_obj.advertise_bgp_network(vars.D2, data.d2_local_as, network)
stream_tg1 = tg1.tg_traffic_config(port_handle=tg_ph_1,
mode='create',
transmit_mode="single_burst",
length_mode='fixed',
pkts_per_burst=1000,
mac_src='00.00.00.11.12.53',
mac_dst=dut1_mac,
l3_protocol='ipv4',
ip_src_addr=data.tg_ip4_addr_l[0],
ip_dst_addr=data.tg_ip4_addr_l[1],
port_handle2=tg_ph_2)
stream_id = stream_tg1['stream_id']
tg1.tg_traffic_control(action='run', stream_handle=stream_id)
st.wait(5)
tg1.tg_traffic_control(action='stop', stream_handle=stream_id)
traffic_details = {
'1': {
'tx_ports': [vars.T1D1P1],
'tx_obj': [tg1],
'exp_ratio': [1],
'rx_ports': [vars.T1D2P1],
'rx_obj': [tg2],
'stream_list': [(stream_id)],
}
}
# verify statistics
aggrResult = validate_tgen_traffic(traffic_details=traffic_details,
mode='aggregate',
comp_type='packet_count')
tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1)
tg1.tg_interface_config(port_handle=tg_ph_1,
handle=h1['handle'],
mode='destroy')
tg2.tg_interface_config(port_handle=tg_ph_2,
handle=h2['handle'],
mode='destroy')
bgp_obj.advertise_bgp_network(vars.D2,
data.d2_local_as,
network,
config='no')
if aggrResult:
st.log("IPv4 traffic over BGPv6 unnumbered neighbour is passed")
st.report_pass("test_case_passed")
else:
st.error("IPv4 traffic over BGPv6 unnumbered neighbour is failed.")
st.report_fail("test_case_failed")
def test_ft_bgp_unnumbered_clear_bgp_ndp():
# ################ Author Details ################
# Name: Kiran Vedula
# Email: [email protected]
# ################################################
utils_obj.banner_log(
'FtOtSoRtBgpUnFn004,FtOtSoRtBgpUnFn005,FtOtSoRtBgpUnFn007')
result = 0
st.log('######------Clear BGP on both nodes------######')
utils.exec_all(True, [[arp_obj.clear_ndp_table, vars.D1],
[arp_obj.clear_ndp_table, vars.D2]])
utils.exec_all(True,
[[arp_obj.show_ndp, vars.D1], [arp_obj.show_ndp, vars.D2]])
utils.exec_all(True, [[bgp_obj.clear_ip_bgp_vtysh, vars.D1],
[bgp_obj.clear_ip_bgp_vtysh, vars.D2]])
utils.exec_all(True,
[[arp_obj.show_ndp, vars.D1], [arp_obj.show_ndp, vars.D2]])
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.log("Failed to form BGP unnumbered peering after clear NDP/BGP")
result += 1
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D2,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D2D1P1,
state='Established'):
st.log("Failed to form BGP unnumbered peering after clear NDP/BGP")
result += 1
utils.exec_all(True, [[ip_obj.config_ipv6, vars.D1, "disable"],
[ip_obj.config_ipv6, vars.D2, "disable"]])
utils.exec_all(True, [[bgp_obj.clear_ip_bgp_vtysh, vars.D1],
[bgp_obj.clear_ip_bgp_vtysh, vars.D2]])
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D2,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D2D1P1,
state='Active'):
st.log("BGP unnumbered peers established even after disable IPv6")
result += 1
utils.exec_all(True, [[ip_obj.config_ipv6, vars.D1, "enable"],
[ip_obj.config_ipv6, vars.D2, "enable"]])
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D2,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D2D1P1,
state='Established'):
st.log("Failed to form BGP unnumbered peering after enable IPv6")
result += 1
if result == 0:
st.report_pass("test_case_passed")
else:
st.log("BGP unnumbered neighborship failed after config state toggle")
st.report_fail("test_case_failed")
def test_ft_tf_queue_thre_con_multicast():
"""
Author : Prudvi Mangadu ([email protected])
"""
tf_data.index = 0
tf_data.threshold = 2
count = 1
while True:
result = 1
result2 = 1
cutils.banner_log("TEST Starts for iteration - {}".format(count))
st.log("Multicast queue threshold config")
tfapi.config_threshold(vars.D1,
threshold_type='queue',
port_alias=vars.D1T1P4,
index=tf_data.index,
buffer_type='multicast',
value=tf_data.threshold)
st.log("Multicast queue threshold config verify")
if not tfapi.verify_threshold(vars.D1,
threshold_type='queue',
buffer_type='multicast',
port_alias=vars.D1T1P4,
mc0=tf_data.threshold):
st.error(
"Unable to configure multicast queue threshold value on multicast-queue buffer"
)
result = 0
st.log("Traffic start and stop")
tf_tg_traffic_start_stop(tf_data.multicast,
tf_data.traffic_duration + 7)
st.log("Checking multicast queue breach event")
if not tfapi.verify_threshold_breaches(vars.D1,
buffer='queue',
port=vars.D1T1P4,
index=tf_data.index,
threshold_type='multicast'):
st.error("Multicast queue threshold breach Event is not found")
if tf_data.need_debug_prints:
tf_collecting_debug_logs_when_test_fails(
'multicast', tf_data.traffic_duration + 7,
tf_data.multicast)
result = 0
result2 = 0
st.log("Clear Multicast queue threshold breach")
tfapi.clear_threshold(vars.D1, breach='all')
st.log("Checking multicast queue breach event")
if tfapi.verify_threshold_breaches(vars.D1,
buffer='multicast',
port=vars.D1T1P4,
index=tf_data.index,
threshold_type='queue'):
st.error(
"Post clear - Multicast queue threshold breach Event is found")
result = 0
st.log("Multicast queue threshold config clear")
tfapi.clear_threshold(vars.D1,
threshold_type='queue',
port_alias=vars.D1T1P4,
index=tf_data.index,
buffer_type='multicast')
st.log("Multicast queue threshold config verify")
if tfapi.verify_threshold(vars.D1,
threshold_type='queue',
buffer_type='multicast',
port_alias=vars.D1T1P4,
mc0=tf_data.threshold):
st.error("Unable to configure multicast queue threshold value")
result = 0
if not result2 and tf_data.need_debug_prints:
st.log(
"As Breach events are not observed collecting logs by disabling the Thresholds"
)
tf_collecting_debug_logs_when_test_fails('multicast',
tf_data.traffic_duration,
tf_data.multicast)
tfapi.clear_threshold(vars.D1, breach='all')
if result:
st.log("Test PASSED in Iteration {}.".format(count))
report_result(result)
break
if count == tf_data.test_max_retries_count:
st.log("Test Failed in all {} Iterations. Hence Declaring as FAIL".
format(count))
report_result(result)
st.log(
"Test Failed in the Iteration-{}. Hence re-testing".format(count))
count += 1
def rest_rbac_call(dut, **kwargs):
"""
Call to test REST sessions using diff users w.r.t RBAC.
Author : Prudvi Mangadu ([email protected])
:param dut:
:param kwargs:
:return:
"""
banner_log('Performing REST call using - {}'.format(kwargs))
for each in ['login_type', 'username', 'password', 'mode']:
if not kwargs.get(each):
st.error("Mandatory argument is not found - {}".format(each))
return False
result = {'get': True, 'put': True}
result2 = True
pass_status = [200, 204]
fail_status = [401, 403]
username = kwargs.get('username')
password = kwargs.get('password')
login_type = kwargs.get('login_type')
mode = kwargs.get('mode')
operation_down = {"sonic-port:admin_status": "down"}
operation_up = {"sonic-port:admin_status": "up"}
port = st.get_free_ports(dut)[0]
device_ip = st.get_mgmt_ip(dut)
cert = kwargs.get("cert")
url = 'restconf/data/sonic-port:sonic-port/PORT/PORT_LIST={}/admin_status'.format(
port)
if login_type == 'cred':
headers1 = {
'Content-Type': 'application/yang-data+json',
'Accept': 'application/yang-data+json'
}
rest_get_out = rest_call(dut,
headers=headers1,
username=username,
password=password,
url=url,
call_type='get')
st.log(rest_get_out)
rest_put_out = rest_call(dut,
headers=headers1,
username=username,
password=password,
url=url,
call_type='put',
data=operation_down)
st.log(rest_put_out)
elif login_type == 'token':
headers2 = {
'Content-Type': 'application/yang-data+json',
'Accept': 'application/yang-data+json',
'Authorization': 'Bearer {}'
}
tocken = get_jwt_token(dut, username=username, password=password)
if not tocken:
st.report_fail('rbac_test_jwt_token_fail', mode, login_type)
headers2['Authorization'] = headers2['Authorization'].format(tocken)
rest_get_out = rest_call(dut,
headers=headers2,
url=url,
call_type='get')
st.log(rest_get_out)
rest_put_out = rest_call(dut,
headers=headers2,
url=url,
call_type='put',
data=operation_up)
st.log(rest_put_out)
elif login_type == 'cert':
get_curl = 'curl --key {} --cert {} ' \
'"https://localhost/restconf/data/sonic-port:sonic-port/PORT/PORT_LIST={}/admin_status"' \
' -k'.format(cert[0], cert[1], port)
out = st.show(dut, get_curl, skip_tmpl=True, skip_error_check=True)
rest_get_out = {'status': 401}
rest_put_out = {'status': 200}
if 'sonic-port:admin_status' in out:
rest_get_out = {'status': 200}
else:
st.error("Invalid 'login_type' used = {}".format(login_type))
return False
if not (rest_get_out and rest_put_out):
st.report_fail('rbac_call_fail', "REST", mode, login_type)
msg = 'Failed to authenticate using rest session with mode- {mode}, type- {login_type}'
if mode == 'rw' and not (rest_get_out["status"] in pass_status
and rest_put_out["status"] in pass_status):
st.error(msg.format(**kwargs))
result2 = False
if mode == 'ro' and not (rest_get_out["status"] in pass_status
and rest_put_out["status"] in fail_status):
st.error(msg.format(**kwargs))
result2 = False
if not result2:
st.report_fail('rbac_test_status', 'Fail', mode, 'REST', login_type,
result)
st.report_pass('rbac_test_status', 'Pass', mode, 'REST', login_type,
result)
def test_ft_bgp_unnumbered_rmap():
"""
# ################ Author Details ################
# Name: Sesha Reddy Koilkonda
# Email: [email protected]
# ################################################
:return:
"""
utils_obj.banner_log('FtOtSoRtBgpUnFn010,FtOtSoRtBgpUnFn016')
result = 0
network_ipv6 = '6002:1::0/64'
bgp_obj.config_bgp(config='yes',
dut=vars.D2,
local_as=data.d2_local_as,
addr_family='ipv6',
neighbor=vars.D2D1P1,
weight='35000',
config_type_list=["weight"])
bgp_obj.config_bgp_network_advertise(vars.D1,
data.d1_local_as,
network_ipv6,
addr_family='ipv6',
config='yes',
network_import_check=True)
st.wait(60)
n1 = ip_obj.verify_ip_route(vars.D2,
family='ipv6',
shell='sonic',
ip_address='6002:1::/64')
if (n1 is False):
st.error("Failed to advertise the ipv6 network to the peer")
result += 1
bgp_obj.get_ip_bgp_route(vars.D2, family="ipv6", network="6002:1/64")
# Add route-map to advertised network
ip_obj.config_access_list(vars.D1,
'Ubgp-access-list1',
network_ipv6,
'deny',
family='ipv6',
seq_num="1")
ip_obj.config_route_map_match_ip_address(vars.D1,
'Ubgp-rmap',
'deny',
'10',
'Ubgp-access-list1',
family='ipv6')
bgp_obj.advertise_bgp_network(vars.D1,
data.d1_local_as,
network_ipv6,
'Ubgp-rmap',
family='ipv6')
# verify route-map to advertised network
n1 = ip_obj.verify_ip_route(vars.D2,
family='ipv6',
shell='sonic',
ip_address='6002:1::/64')
if (n1 is True):
st.error(
"Advertised network is not filtered by the configured route map")
result += 1
else:
st.log("As expected, advertised network is filtered by the route map.")
# Veirfy the BGP unnumbered neighbourship post r-map config
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.error(
"Failed to form BGP unnumbered peering using IPv6 link local, with the route map configuration."
)
result += 1
# Unconfig the r-map and verify the BGP neighbourship
ip_obj.config_route_map_mode(vars.D1,
'Ubgp-rmap',
'deny',
'10',
config='no')
ip_obj.config_access_list(vars.D1,
'Ubgp-access-list1',
network_ipv6,
'deny',
config='no',
family='ipv6',
seq_num="1")
bgp_obj.config_bgp(config='no',
dut=vars.D2,
local_as=data.d2_local_as,
addr_family='ipv6',
neighbor=vars.D2D1P1,
weight='35000',
config_type_list=["weight"])
bgp_obj.config_bgp_network_advertise(vars.D1,
data.d1_local_as,
network_ipv6,
addr_family='ipv6',
config='no')
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.error(
"Failed to form BGP unnumbered peering using IPv6 link local, after route map un-configuration."
)
result += 1
if result == 0:
st.report_pass("test_case_passed")
else:
st.error(
"BGP unnumbered neighborship failed with the route map configuration."
)
st.report_fail("test_case_failed")
def ssh_call(dut, remote_dut=None, **kwargs):
"""
Call to test SSH session using diff users w.r.t RBAC.
Author : Prudvi Mangadu ([email protected])
:param dut:
:param remote_dut:
:param kwargs:
:return:
"""
banner_log('Performing SSH call using - {}'.format(kwargs))
for each in ['login_type', 'username', 'password', 'mode']:
if not kwargs.get(each):
st.error("Mandatory argument is not found - {}".format(each))
return False
dut_ip = st.get_mgmt_ip(dut)
result = {'show': True, 'config': True}
result2 = True
username = kwargs.get('username')
password = kwargs.get('password')
login_type = kwargs.get('login_type')
mode = kwargs.get('mode')
if login_type == 'cred':
ssh_out = st.exec_ssh(dut, username, password, [
'show vlan config', 'sudo config vlan add 100\n{}'.format(password)
])
st.log(ssh_out)
elif login_type == 'pubkey':
show_out = st.exec_ssh_remote_dut(remote_dut, dut_ip, username,
password, 'show vlan config')
config_out = st.exec_ssh_remote_dut(
remote_dut, dut_ip, username, password,
'sudo config vlan add 100\n{}'.format(password))
ssh_out = show_out + "\n" + config_out
else:
st.error("Invalid 'login_type' used = {}".format(login_type))
return False
if not ssh_out:
st.report_fail('rbac_call_fail', "SSH", mode, login_type)
if 'Sorry, user {} is not allowed to execute'.format(username) in ssh_out or \
"no askpass program specified" in ssh_out:
result['config'] = False
if 'VID' not in ssh_out:
result['show'] = False
st.log(result)
msg = 'Failed to execute show command using ssh session with mode- {mode}, type- {login_type}'
if mode == 'rw' and not all(result.values()):
st.error(msg.format(**kwargs))
result2 = False
if mode == 'ro' and not (result['show'] and not result['config']):
st.error(msg.format(**kwargs))
result2 = False
if not result2:
st.report_fail('rbac_test_status', 'Fail', mode, 'SSH', login_type,
result)
st.report_pass('rbac_test_status', 'Pass', mode, 'SSH', login_type, result)
def test_ft_bgp_unnumbered_rr():
"""
# ################ Author Details ################
# Name: Sesha Reddy Koilkonda
# Email: [email protected]
# ################################################
:return:
"""
utils_obj.banner_log('FtOtSoRtBgpUnFn011,FtOtSoRtBgpUnFn012')
result = 0
bgp_obj.cleanup_router_bgp(st.get_dut_names())
dict1 = {
'config': 'yes',
'router_id': data.d1_rid,
'addr_family': 'ipv6',
'local_as': data.d1_local_as,
'remote_as': 'internal',
'config_type_list': ["remote-as", "activate"],
'interface': vars.D1D2P1,
'neighbor': vars.D1D2P1
}
dict2 = {
'config': 'yes',
'router_id': data.d2_rid,
'addr_family': 'ipv6',
'local_as': data.d1_local_as,
'remote_as': 'internal',
'config_type_list': ["remote-as", "activate"],
'interface': vars.D2D1P1,
'neighbor': vars.D2D1P1
}
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
result_rr = bgp_obj.create_bgp_route_reflector_client(
vars.D1, data.d1_local_as, 'ipv6', vars.D1D2P1, 'yes')
if not result_rr:
st.error(
"BGP SP - Configuring client reflection on {} {} bgp {} Failed".
format(vars.D1, 'ipv6', data.d1_local_as))
result += 1
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.error(
"Failed to form iBGP unnumbered peering using IPv6 link local with Route-reflector-client config"
)
result += 1
# Unconfiguration
bgp_obj.create_bgp_route_reflector_client(vars.D1,
data.d1_local_as,
'ipv6',
vars.D1D2P1,
config='no')
bgp_obj.cleanup_router_bgp(st.get_dut_names())
if result == 0:
st.report_pass("test_case_passed")
else:
st.error(
"BGP unnumbered neighborship failed with the Route-reflector-client configuration failed."
)
st.report_fail("test_case_failed")