def initialize_topology():
st.log(
"Script Starts Here!. Initialize.........................................................................................."
)
vars = st.ensure_min_topology("D1D2:4", "D2D3:4", "D1T1:2", "D3T1:2")
data.dut_list = st.get_dut_names()
data.dut1 = data.dut_list[0]
data.dut2 = data.dut_list[1]
data.dut3 = data.dut_list[2]
utils.exec_all(True,
[[bgp_obj.enable_docker_routing_config_mode, data.dut1],
[bgp_obj.enable_docker_routing_config_mode, data.dut2],
[bgp_obj.enable_docker_routing_config_mode, data.dut3]])
data.d1_d2_ports = [vars.D1D2P1, vars.D1D2P2, vars.D1D2P3, vars.D1D2P4]
data.d2_d1_ports = [vars.D2D1P1, vars.D2D1P2, vars.D2D1P3, vars.D2D1P4]
data.d2_d3_ports = [vars.D2D3P1, vars.D2D3P2, vars.D2D3P3, vars.D2D3P4]
data.d3_d2_ports = [vars.D3D2P1, vars.D3D2P2, vars.D3D2P3, vars.D3D2P4]
data.dut1_tg_ports = [vars.D1T1P1, vars.D1T1P2]
data.dut3_tg_ports = [vars.D3T1P1, vars.D3T1P2]
data.tg_dut1_ports = [vars.T1D1P1, vars.T1D1P2]
data.tg_dut3_ports = [vars.T1D3P1, vars.T1D3P2]
data.tg = tgen_obj_dict[vars['tgen_list'][0]]
data.tg_dut1_p1 = data.tg.get_port_handle(vars.T1D1P1)
data.tg_dut3_p1 = data.tg.get_port_handle(vars.T1D3P1)
data.tg_dut1_p2 = data.tg.get_port_handle(vars.T1D1P2)
data.tg_dut3_p2 = data.tg.get_port_handle(vars.T1D3P2)
data.d1_stream_list = {}
data.d1_stream_list_vrf = {}
data.d3_stream_list = {}
if 'ixia' in vars['tgen_list'][0]:
data.tgen_type = 'ixia'
data.delay_factor = 2
else:
data.tgen_type = 'stc'
data.delay_factor = 1
def nat_pre_config():
global vars
vars = st.ensure_min_topology("D1D2:1", "D2D3:1")
platform = basic_obj.get_hwsku(vars.D2)
common_constants = st.get_datastore(vars.D2, "constants", "default")
if platform.lower() in common_constants['TH3_PLATFORMS']:
st.error("NAT is not supported for this platform {}".format(platform))
st.report_unsupported('NAT_unsupported_platform',platform)
ip_obj.config_ip_addr_interface(vars.D1, vars.D1D2P1, data.d1d2_ip_addr, data.ip_addr_mask, family=data.af_ipv4)
ip_obj.config_ip_addr_interface(vars.D2, vars.D2D1P1, data.d2d1_ip_addr, data.ip_addr_mask, family=data.af_ipv4)
ip_obj.config_ip_addr_interface(vars.D2, vars.D2D3P1, data.d2d3_ip_addr, data.ip_addr_mask, family=data.af_ipv4)
ip_obj.config_ip_addr_interface(vars.D3, vars.D3D2P1, data.d3d2_ip_addr, data.ip_addr_mask, family=data.af_ipv4)
ip_obj.create_static_route(vars.D1, data.d2d1_ip_addr,"{}/{}".format(data.d1_static_nw, data.ip_addr_mask),
shell=data.shell_vtysh, family=data.af_ipv4)
ip_obj.create_static_route(vars.D3, data.d2d3_ip_addr, "{}/{}".format(data.d3_static_nw, data.ip_addr_mask),
shell=data.shell_vtysh, family=data.af_ipv4)
st.log("NAT Configuration")
nat_obj.config_nat_feature(vars.D2, 'enable')
util_nat_zone_config(vars.D2, [vars.D2D1P1, vars.D2D3P1], [data.zone_1, data.zone_2], config=data.config_add)
st.log("Creating NAT Pool")
nat_obj.config_nat_pool(vars.D2, pool_name=data.pool_name[0], global_ip_range=data.d2d1_ip_addr,
global_port_range=data.global_port_range, config=data.config_add)
st.log("Creating NAT Pool binding")
nat_obj.config_nat_pool_binding(vars.D2, binding_name=data.bind_name[0], pool_name=data.pool_name[0],
config=data.config_add)
utils.exec_all(True, [[ip_obj.show_ip_route, vars.D1], [ip_obj.show_ip_route, vars.D2]])
ip_obj.show_ip_route(vars.D3)
def debug_bgp_bfd(dut):
dut_list = make_list(dut)
st.banner("********* Dubug commands starts ************")
func_list = [clear_interface_counters, show_arp, show_ndp, show_interface_counters_all,
asicapi.dump_l3_ip6route, asicapi.dump_l3_defip]
for func in func_list:
api_list = [[func, dut] for dut in dut_list]
exec_all(True, api_list)
st.banner(" ******** End of Dubug commands ************")
def apply_module_configuration():
print_log("Applying module configuration")
data.dut1_lag_members = [vars.D1D2P1, vars.D1D2P2]
data.dut2_lag_members = [vars.D2D1P1, vars.D2D1P2]
# create portchannel
utils.exec_all(True, [
utils.ExecAllFunc(pc_obj.create_portchannel, vars.D1, data.portChannelName),
utils.ExecAllFunc(pc_obj.create_portchannel, vars.D2, data.portChannelName),
])
# add portchannel members
utils.exec_all(True, [
utils.ExecAllFunc(pc_obj.add_portchannel_member, vars.D1, data.portChannelName, data.dut1_lag_members),
utils.ExecAllFunc(pc_obj.add_portchannel_member, vars.D2, data.portChannelName, data.dut2_lag_members),
])
def module_config():
result = True
result = utils.exec_all(True, [[dut1_config], [dut2_config]])
if result is False:
st.error(
"Module config Failed - IP address/Portchannel/Vlan configuration failed"
)
pytest.skip()
def prologue_epilogue(request):
initialize_topology_vars()
[res, _] = utils.exec_all(True, [[create_tg_hosts], [ecmp_base_config]],
True)
create_tg_streams()
if res[1] is False:
more_debugs(duts=dut_list)
st.report_fail("module_config_verification_failed")
yield
ecmp_base_unconfig()
def clear_module_configuration():
print_log("Clearing module configuration")
# delete Ipv4 address
print_log("Delete ip address configuration:")
ip_obj.clear_ip_configuration([vars.D1, vars.D2], family='ipv4')
# delete Ipv6 address
ip_obj.clear_ip_configuration([vars.D1, vars.D2], family='ipv6')
# delete ipv4 static routes
ip_obj.delete_static_route(vars.D1, data.ipv4_portchannel_D2, data.ipv4_network_D2, shell="vtysh",
family="ipv4")
ip_obj.delete_static_route(vars.D2, data.ipv4_portchannel_D1, data.ipv4_network_D1, shell="vtysh",
family="ipv4")
# delete ipv6 static routes
ip_obj.delete_static_route(vars.D1, data.ipv6_portchannel_D2, data.ipv6_network_D2, shell="vtysh",
family="ipv6")
ip_obj.delete_static_route(vars.D2, data.ipv6_portchannel_D1, data.ipv6_network_D1, shell="vtysh",
family="ipv6")
# delete port channel members
print_log("Deleting members from port channel:")
utils.exec_all(True, [
utils.ExecAllFunc(pc_obj.delete_portchannel_member, vars.D1, data.portChannelName, data.dut1_lag_members),
utils.ExecAllFunc(pc_obj.delete_portchannel_member, vars.D2, data.portChannelName, data.dut2_lag_members),
])
# delete port channel
print_log("Deleting port channel configuration:")
utils.exec_all(True, [
utils.ExecAllFunc(pc_obj.delete_portchannel, vars.D1, data.portChannelName),
utils.ExecAllFunc(pc_obj.delete_portchannel, vars.D2, data.portChannelName),
])
# delete acl tables and rules
print_log("Deleting ACLs:")
[_, exceptions] = utils.exec_all(True, [[acl_obj.acl_delete, vars.D1], [acl_obj.acl_delete, vars.D2]])
ensure_no_exception(exceptions)
#Clear static arp entries
print_log("Clearing ARP entries")
arp_obj.clear_arp_table(vars.D1)
arp_obj.clear_arp_table(vars.D2)
#Clear static ndp entries
print_log("Clearing NDP entries")
arp_obj.clear_ndp_table(vars.D1)
arp_obj.clear_ndp_table(vars.D2)
def udld_module_config():
'''
- Configure vlans 10 on DUT1 to DUT2 to DUT3
- Configure the ports to add in acess vlan 10
- Configure UDLD global and interface
'''
ver_flag = True
print_log("Starting UDLD Module Configurations...\n\
STEPS:\n\
- Configure vlans 10 on DUT1 to DUT2 to DUT3\n\
- Configure the ports to add in acess vlan 10\n\
- Configure UDLD global and interface.", "HIGH")
### Create Access VLAN on all DUTs
utils.exec_all(True,[[vlan.create_vlan, dut, trunk_base_vlan] for dut in dut_list])
### Add Access ports between DUT1<->DUT2<->DUT3<->DUT1 in vlan 10
api_list = []
api_list.append([vlan.add_vlan_member, dut1, trunk_base_vlan, [vars.D1D2P1]])
api_list.append([vlan.add_vlan_member, dut2, trunk_base_vlan, [vars.D2D1P1,vars.D2D3P1,vars.D2D3P2]])
api_list.append([vlan.add_vlan_member, dut3, trunk_base_vlan, [vars.D3D2P1,vars.D3D2P2]])
utils.exec_all(True, api_list)
[result, exceptions] = pll.exec_parallel(True, [dut2, dut3], udld.udld_cfg_ebtables_rule, [{'add': False}, {'add': False}])
if not all(i is None for i in exceptions):
result.append(False)
print_log(exceptions)
if False in result:
print_log('UDLD Delete ebtables rule FAILED','ERROR')
ver_flag = False
###Enable UDLD global
dict1 = {'udld_enable': udld_global[dut1]['udld_enable'], 'config': udld_global[dut1]['config']}
pll.exec_parallel(True,[dut1],udld.config_udld_global, [dict1])
###Enable UDLD on Interfaces
dict1 = {'intf': udld_int[dut1]['udld_int'],'udld_enable': udld_int[dut1]['udld_enable'], 'config': udld_int[dut1]['config']}
pll.exec_parallel(True,[dut1],udld.config_intf_udld, [dict1])
return ver_flag
def validate_topology():
# Enable all links in the topology and verify links up
dut_port_dict = {}
for dut in dut_list:
port_list = st.get_dut_links_local(dut, peer=None, index=None)
dut_port_dict[dut] = port_list
#Usage: exec_all(use_threads, list_of_funcs)
[result, exceptions] = utils.exec_all(True, [[intf.interface_operation, dut, dut_port_dict[dut], 'startup',False]
for dut in dut_port_dict.keys()])
if not all(i is None for i in exceptions):
print_log(exceptions)
return False if False in result else True
def udld_module_unconfig():
ver_flag = True
print_log("Starting UDLD Module UnConfigurations...", "HIGH")
### Remove the trunk ports between DUT1<->DUT2<->DUT3 in vlan 10
api_list = []
api_list.append([vlan.delete_vlan_member, dut1, trunk_base_vlan, [vars.D1D2P1]])
api_list.append([vlan.delete_vlan_member, dut2, trunk_base_vlan, [vars.D2D1P1]])
utils.exec_all(True, api_list)
### delete Access VLAN on all DUTs
utils.exec_all(True,[[vlan.delete_vlan, dut, trunk_base_vlan] for dut in dut_list])
[result, exceptions] = pll.exec_parallel(True, [dut2, dut3], udld.udld_cfg_ebtables_rule, [{'add': True}, {'add': True}])
if not all(i is None for i in exceptions):
result.append(False)
print_log(exceptions)
if False in result:
print_log('UDLD Add ebtables rule FAILED','ERROR')
ver_flag = False
return ver_flag
def initialize_topology():
# code for ensuring min topology
st.log(
"Initialize............................................................................................................."
)
vars = st.ensure_min_topology("D1D2:4", "D1T1:2", "D2T1:2")
data.dut_list = st.get_dut_names()
data.dut1 = data.dut_list[0]
data.dut2 = data.dut_list[1]
utils.exec_all(True,
[[bgp_api.enable_docker_routing_config_mode, data.dut1],
[bgp_api.enable_docker_routing_config_mode, data.dut2]])
data.d1_dut_ports = [vars.D1D2P1]
data.d2_dut_ports = [vars.D2D1P1]
data.dut1_tg1_ports = [vars.D1T1P1]
data.dut2_tg1_ports = [vars.D2T1P1]
data.tg_dut1_hw_port = vars.T1D1P1
data.tg_dut2_hw_port = vars.T1D2P1
data.tg1 = tgapi.get_chassis(vars)
data.tg2 = data.tg1
data.tg_dut1_p1 = data.tg1.get_port_handle(vars.T1D1P1)
data.tg_dut2_p1 = data.tg2.get_port_handle(vars.T1D2P1)
data.d1_p1_intf_v4 = {}
data.d1_p1_intf_v6 = {}
data.d2_p1_intf_v4 = {}
data.d2_p1_intf_v6 = {}
data.stream_list_scale = {}
data.stream = []
data.dut1_dut2_ip_list = ip_range('5.0.0.1', 2, 1000)
data.dut2_dut1_ip_list = ip_range('5.0.0.2', 2, 1000)
data.dut1_tg_host = '6.0.0.1'
data.tg_dut1_host = '6.0.0.2'
data.dut2_tg_host = '7.0.0.1'
data.tg_dut2_host = '7.0.0.2'
data.tg_dut1_stream_start = ip_range('6.0.0.3', 3, 1000)
data.tg_dut2_stream_start = ip_range('7.0.0.3', 3, 1000)
data.intf_list = []
for vlan in dut1_dut2_vlan_scale:
data.intf_list.append('Vlan' + vlan)
def prologue_epilogue():
print_log("Starting to initialize and validate topology...",'MED')
initialize_topology()
validate_topology()
api_list = []
api_list.append([udld_module_config])
[result, exceptions] = utils.exec_all(True, api_list, True)
if not all(i is None for i in exceptions):
result.append(False)
print_log(exceptions)
if False in result:
st.report_fail("module_config_failed", "prolog")
return
yield
api_list = []
api_list.append([udld_module_unconfig])
[result, exceptions] = utils.exec_all(True, api_list, True)
if not all(i is None for i in exceptions):
result.append(False)
print_log(exceptions)
if False in result:
st.report_fail("module_unconfig_failed", "epilog")
def qos_save_reboot_module_hooks(request):
# add things at the start of this module
global vars
st.log("Ensuring minimum topology")
vars = st.ensure_min_topology("D1T1:1")
st.log("Configuring supported QoS features")
wred_data = wred_config.init_vars(vars)
st.log('Creating WRED and ECN table')
utils.exec_all(True, [
utils.ExecAllFunc(apply_wred_ecn_config, vars.D1,
wred_data['wred_ecn_json_config'])
])
st.log("Checking for wred config before save and reboot")
wred_verify()
st.log("checking for ecn config before save and reboot")
ecn_verify()
st.log("Configuring IPV4 ACL with rule")
ipv4_acl_config()
st.log("Configuring IPV6 ACL with rule")
ipv6_acl_config()
st.log("Checking for IPV4 ACL config before save and reboot")
ipv4_acl_verify()
st.log("Checking for IPV6 ACL config before save and reboot")
ipv6_acl_verify()
st.log("Configuring COS")
cos_config()
st.log("Checking for COS config before save and reboot")
cos_config_verify()
yield
# add things at the end of this module"
#Below step will clear COS, WRED and ECN config from the device.
qos_obj.clear_qos_config(vars.D1)
#Below step will clear all ACL config from the device.
acl_obj.clear_acl_config(vars.D1)
def interface_operation_parallel(input, operation='startup', thread=True):
"""
Author : Chaitanya Lohith Bollapragada
This will perform the shutdown and noshutdown of given ports in given DUTs parallel.
:param input: dic keys = dut, values = list of interfaces
:param operation: shutdown | startup(default)
:param thread:
:return:
Ex: interface_operation_parallel({vars:D1:[vars.D1D2P1,vars.D1D2P2], vars.D2:[vars.D2D1P1,vars.D2T1P1]},)
"""
[out, exceptions
] = exec_all(thread, [[interface_operation, duts, input[duts], operation]
for duts in input.keys()])
st.log(exceptions)
return False if False in out else True
def links_status(threads, check_type):
header = [
'DUT', 'Local', "LStatus (A/O)", "Partner", "Remote", "RStatus (A/O)"
]
funcs = [[tg_links_status, check_type], [duts_links_status, threads]]
[[v1, v2], [e1, e2]] = utils.exec_all(threads, funcs, True)
if v1 is None or v2 is None or e1 is not None or e2 is not None:
print(v1, v2, e1, e2)
return [True, header, []]
v1_default = "?2?" if v1 else "NA"
(results, exclude, alias) = ([], [], fill_alias())
for dut in st.get_dut_names():
for local, partner, remote in st.get_tg_links(dut):
res = []
res.append(alias.get(dut, "?"))
res.append(local)
res.append(v2.get("{}--{}".format(dut, local), "?1?"))
res.append(alias.get(partner, "?"))
res.append(remote)
res.append(v1.get("{}--{}".format(partner, remote), v1_default))
results.append(res)
for local, partner, remote in st.get_dut_links(dut):
name = "{}--{}".format(dut, local)
if name in exclude:
continue
res = []
res.append(alias.get(dut, "?"))
res.append(local)
res.append(v2.get("{}--{}".format(dut, local), "?3?"))
res.append(alias.get(partner, "?"))
res.append(remote)
res.append(v2.get("{}--{}".format(partner, remote), "?4?"))
exclude.append("{}--{}".format(partner, remote))
results.append(res)
return [True, header, results]
def test_unnumvrf_basic(fixture_test_unnumvrf_basic):
tc_list = [
'FtOpSoRoIPnumvrfFun001', 'FtOpSoRoIPnumvrfFun002',
'FtOpSoRoIPnumvrfFun003'
]
final_result = 0
error_list = []
st.banner('FtOpSoRoIPnumvrfFun001 -- to -- FtOpSoRoIPnumvrfFun003')
st.banner(
'Configure and verify IP unnumbered over non-default vrf and default-vrf on a physical interface '
)
tc_result = True
result = utils.exec_all(True,
[[loc_lib.dut1_config_unnumbered, 'phy', ''],
[loc_lib.dut2_config_unnumbered, 'phy', '']])
if result is False:
error = "IP unnumbered configuration on a physical interface failed"
tc_result = False
error_list.append(error)
result = utils.exec_all(True, [[loc_lib.dut1_verify_unnumbered, 'phy'],
[loc_lib.dut2_verify_unnumbered, 'phy']])
if result is False:
error = "IP unnumbered verification on a physical interface failed"
tc_result = False
error_list.append(error)
st.log('On DUT1 verify routes on non default vrf use physical interface')
result = retry_api(ip_obj.verify_ip_route,
data.dut1,
vrf_name=data.dut1_vrf[0],
type='O',
nexthop=data.dut2_loopback_ip[0],
interface=data.d1_d2_ports[0],
ip_address=data.dut2_loopback_ip[0] + '/' +
data.ip_loopback_prefix,
family="ipv4",
retry_count=7,
delay=5)
if result is False:
error = "IP routes on non-default vrf failed"
tc_result = False
error_list.append(error)
result = loc_lib.send_verify_traffic(type='ipv4')
if result is False:
error = 'IPv4 traffic with IPv4 unnumbered over physical interface on a non-default vrf failed'
tc_result = False
error_list.append(error)
if tc_result:
st.report_tc_pass(tc_list[0], 'tc_passed')
else:
final_result += 1
st.report_tc_fail(tc_list[0], 'test_case_failure_message', error)
st.banner(
'Configure and verify IP unnumbered over non-default vrf and default-vrf on a portchannel interface '
)
st.log(
'On DUT1 disable physical interface for the routes to be learnt from portchannel'
)
port_obj.shutdown(data.dut1, data.d1_d2_ports[0])
tc_result = True
result = utils.exec_all(True, [[loc_lib.dut1_config_unnumbered, 'pc', ''],
[loc_lib.dut2_config_unnumbered, 'pc', '']])
if result is False:
error = "IP unnumbered configuration on a portchannel interface failed"
tc_result = False
error_list.append(error)
result = utils.exec_all(True, [[loc_lib.dut1_verify_unnumbered, 'pc'],
[loc_lib.dut2_verify_unnumbered, 'pc']])
if result is False:
error = "IP unnumbered verification on a portchannel interface failed"
tc_result = False
error_list.append(error)
st.log('On DUT1 verify routes on non default vrf use portchannel')
result = retry_api(ip_obj.verify_ip_route,
data.dut1,
vrf_name=data.dut1_vrf[0],
type='O',
nexthop=data.dut2_loopback_ip[2],
interface=data.portchannel,
ip_address=data.dut2_loopback_ip[2] + '/' +
data.ip_loopback_prefix,
family="ipv4",
retry_count=7,
delay=5)
if result is False:
error = "IP routes on non-default vrf using portchannel failed"
tc_result = False
error_list.append(error)
result = loc_lib.send_verify_traffic(type='ipv4')
if result is False:
error = 'IPv4 traffic with IPv4 unnumbered over portchannel on a non-default vrf failed'
tc_result = False
error_list.append(error)
if tc_result:
st.report_tc_pass(tc_list[1], 'tc_passed')
else:
final_result += 1
st.report_tc_fail(tc_list[1], 'test_case_failure_message', error)
st.log(
'Configure and verify IP unnumbered over non-default vrf and default-vrf on a vlan interface '
)
st.log(
'On DUT1 disable physical interface for the routes to be learnt from portchannel'
)
port_obj.shutdown(data.dut1, [data.d1_d2_ports[2], data.d1_d2_ports[3]])
tc_result = True
result = utils.exec_all(True,
[[loc_lib.dut1_config_unnumbered, 'vlan', ''],
[loc_lib.dut2_config_unnumbered, 'vlan', '']])
if result is False:
error = "IP unnumbered configuration on a vlan interface failed"
tc_result = False
error_list.append(error)
result = utils.exec_all(True, [[loc_lib.dut1_verify_unnumbered, 'vlan'],
[loc_lib.dut2_verify_unnumbered, 'vlan']])
if result is False:
error = "IP unnumbered verification on a vlan interface failed"
tc_result = False
error_list.append(error)
st.log('On DUT1 verify routes on non default vrf use vlan')
result = retry_api(ip_obj.verify_ip_route,
data.dut1,
vrf_name=data.dut1_vrf[0],
type='O',
nexthop=data.dut2_loopback_ip[1],
interface='Vlan' + data.dut1_dut2_vlan[0],
ip_address=data.dut2_loopback_ip[1] + '/' +
data.ip_loopback_prefix,
family="ipv4",
retry_count=7,
delay=5)
if result is False:
error = "IP routes on non-default vrf using vlan failed"
tc_result = False
error_list.append(error)
result = loc_lib.send_verify_traffic(type='ipv4')
if result is False:
error = 'IPv4 traffic with IPv4 unnumbered over vlan interface on a non-default vrf failed'
tc_result = False
error_list.append(error)
if tc_result:
st.report_tc_pass(tc_list[2], 'tc_passed')
else:
final_result += 1
st.report_tc_fail(tc_list[2], 'test_case_failure_message', error)
if final_result != 0:
st.report_fail('test_case_failure_message', error_list)
else:
st.report_pass('test_case_passed')
def test_dynamic_unnumbered_scale():
##########################################################################################################################################
result = 0
st.banner('FtOpSoRoAutoSc001 - Verify maximum BGP unnumbered sessions')
st.banner('FtOpSoRoAutoSc002 - Verify maximum sessions with listen range')
vlan_list_d1_d2 = ['%s' % x for x in range(1, 101)]
ip_list_dut2 = loc_lib.ip_range('2.0.0.1', 2, 100)
ip_list_dut3 = loc_lib.ip_range('2.0.0.2', 2, 100)
loc_lib.bgp_router_id()
loc_lib.redistribute_routes()
st.log(
'Configure BGP unnumbered sessions or 100 vlans between DUT1 and DUT2')
for vlan in vlan_list_d1_d2:
dict1 = {
'addr_family': 'ipv6',
'local_as': dut1_as,
'remote_as': dut2_as,
'config_type_list': ['remote-as', 'activate'],
'interface': 'Vlan' + vlan,
'neighbor': 'Vlan' + vlan
}
dict2 = {
'addr_family': 'ipv6',
'local_as': dut2_as,
'remote_as': dut1_as,
'config_type_list': ['remote-as', 'activate'],
'interface': 'Vlan' + vlan,
'neighbor': 'Vlan' + vlan
}
putils.exec_parallel(True, [data.dut1, data.dut2], bgp_obj.config_bgp,
[dict1, dict2])
st.log('Configure IPv4 peer groups on DUT2 and DUT3')
utils.exec_all(True, [[
bgp_obj.create_bgp_peergroup, data.dut2, dut2_as, 'd2d3_v4_peer',
dut3_as
],
[
bgp_obj.create_bgp_peergroup, data.dut3, dut3_as,
'd2d3_v4_peer', dut2_as
]])
st.log('Configure listen range on DUT2')
bgp_obj.config_bgp_listen_range(dut=data.dut2,
local_asn=dut2_as,
neighbor_address='2.0.0.0',
subnet=16,
peer_grp_name='d2d3_v4_peer',
limit=100,
config='yes')
st.log('Configure IPv4 and IPv6 BGP sessions on DUT2 and DUT3')
st.log('Configure neighbors on DUT3')
for ip in ip_list_dut2:
bgp_obj.create_bgp_neighbor_use_peergroup(dut=data.dut3,
local_asn=dut3_as,
peer_grp_name='d2d3_v4_peer',
neighbor_ip=ip,
family="ipv4")
bgp_obj.activate_bgp_neighbor(data.dut3,
dut3_as,
ip,
'ipv4',
remote_asn=dut2_as)
bgp_obj.activate_bgp_neighbor(data.dut3,
dut3_as,
ip,
'ipv6',
remote_asn=dut2_as)
st.log('Configure 100 BGP sessions with listen range')
if not loc_lib.retry_api(bgp_obj.verify_bgp_summary,
data.dut2,
family='ipv4',
shell=bgp_cli_type,
neighbor=['Vlan2', '*' + ip_list_dut3[0]],
state='Established',
retry_count=10,
delay=15):
st.error(
"Failed to form BGP unnumbered session using IPv6 link local address over vlan"
)
result += 1
ip_obj.show_ip_route(data.dut1, family="ipv4")
if not loc_lib.retry_api(ip_obj.ping,
data.dut1,
addresses=dut3_tg_ip[0],
retry_count=10,
delay=10,
source_ip=dut1_tg_ip[0]):
st.error('IPv4 Ping from DUT1 to DUT3 failed')
result += 1
aggrResult = loc_lib.send_verify_traffic()
if not aggrResult:
st.error(
'IPv4 and IPv6 traffic over vlan with BGP unnumbered and Dynamic Discovery failed'
)
result += 1
st.log("Reduce the limit and verify the neighbor is removed")
bgp_obj.config_bgp_listen_range(dut=data.dut2, local_asn=dut2_as, limit=1)
bgp_obj.clear_ip_bgp_vtysh(data.dut2, value="*")
bgp_obj.config_bgp_listen_range(dut=data.dut2,
local_asn=dut2_as,
limit=100)
bgp_obj.clear_ip_bgp_vtysh(data.dut2, value="*")
st.wait(2)
if not loc_lib.retry_api(bgp_obj.verify_bgp_summary,
data.dut2,
family='ipv4',
shell=bgp_cli_type,
neighbor=['Vlan2', '*' + ip_list_dut3[0]],
state='Established',
retry_count=10,
delay=15):
st.error(
"Failed to form BGP unnumbered session using IPv6 link local address over vlan"
)
result += 1
if result == 0:
st.report_tc_pass('FtOpSoRoAutoSc001', 'test_case_passed')
else:
st.report_tc_fail('FtOpSoRoAutoSc001', 'test_case_failed')
if result == 0:
st.report_tc_pass('FtOpSoRoAutoSc002', 'test_case_passed')
else:
st.report_tc_fail('FtOpSoRoAutoSc002', 'test_case_failed')
if result == 0:
st.report_pass('test_case_passed')
else:
st.report_fail('test_case_failed')
def test_ecmp_vxlan_func003():
tc_list = ['FtOpSoRoLBFunc004', 'FtOpSoRoLBFunc008', 'FtOpSoRoLBFunc010']
st.banner(
"Testcase: Verify IPv4 and IPv6 ECMP Loadbalance and Hash polarization in VxLAN topology.\n TCs:{}."
.format(tc_list))
retvar = True
fail_msgs = ''
tc_res = {}
for tc in tc_list:
tc_res[tc] = True
spine1 = data.dut1
spine2 = data.dut2
leaf1 = data.dut3
leaf2 = data.dut4
leaf3 = data.dut5
vxlan_tolerance = 30
st.banner("Step T1: Verify default show cli.")
def f3_t1_1():
res1 = ip.verify_ip_loadshare(spine1,
ip=ecmpv4,
ipv6=ecmpv6,
seed=data.seed_def)
if res1 is False:
fail_msg = "ERROR: Step T1 Default show failed on spine1."
st.log(fail_msg)
return False
return True
def f3_t1_2():
res1 = ip.verify_ip_loadshare(spine2,
ip=ecmpv4,
ipv6=ecmpv6,
seed=data.seed_def)
if res1 is False:
fail_msg = "ERROR: Step T1 Default show failed on spine2."
st.log(fail_msg)
return False
return True
def f3_t1_3():
res1 = ip.verify_ip_loadshare(leaf1,
ip=ecmpv4,
ipv6=ecmpv6,
seed=data.seed_def)
if res1 is False:
fail_msg = "ERROR: Step T1 Default show failed on leaf1."
st.log(fail_msg)
return False
return True
def f3_t1_4():
res1 = ip.verify_ip_loadshare(leaf2,
ip=ecmpv4,
ipv6=ecmpv6,
seed=data.seed_def)
if res1 is False:
fail_msg = "ERROR: Step T1 Default show failed on leaf2."
st.log(fail_msg)
return False
return True
def f3_t1_5():
res1 = ip.verify_ip_loadshare(leaf3,
ip=ecmpv4,
ipv6=ecmpv6,
seed=data.seed_def)
if res1 is False:
fail_msg = "ERROR: Step T1 Default show failed on leaf3."
st.log(fail_msg)
return False
return True
[res, _] = utils.exec_all(
True, [[f3_t1_1], [f3_t1_2], [f3_t1_3], [f3_t1_4], [f3_t1_5]])
if False in set(res):
fail_msg = "ERROR: Step T1 show cli for default values failed."
fail_msgs += fail_msg
st.log(fail_msg)
tc_res[tc_list[0]] = False
retvar = False
'''
st.log("Step T1a: Fine tuning the config and verification.")
f3_f2_1=lambda x: intf.interface_shutdown(spine1, [vars.D1D3P2, vars.D1D4P2, vars.D1D5P2])
f3_f2_2=lambda x: intf.interface_shutdown(spine2, [vars.D2D3P2, vars.D2D4P2, vars.D2D5P2])
[res, _] = utils.exec_all(True, [[f3_f2_1, 1], [f3_f2_2, 1]])
st.wait(waitvar)
'''
st.banner("Step T2: Start all IPv4 and IPv6 Streams.")
tg_v4s = [tg_l3l1_1['stream_id']]
tg_v6s = [tg_l3l1_6_1['stream_id']]
tg_strs = tg_v4s + tg_v6s
f3_f1_1 = lambda x: intf.clear_interface_counters(spine1)
f3_f1_2 = lambda x: intf.clear_interface_counters(spine2)
f3_f1_3 = lambda x: intf.clear_interface_counters(leaf1)
f3_f1_4 = lambda x: intf.clear_interface_counters(leaf2)
f3_f1_5 = lambda x: intf.clear_interface_counters(leaf3)
[res, _] = utils.exec_all(
True,
[[f3_f1_1, 1], [f3_f1_2, 1], [f3_f1_3, 1], [f3_f1_4, 1], [f3_f1_5, 1]])
tg.tg_traffic_control(action='clear_stats', port_handle=tg_all)
res = tg.tg_traffic_control(action='run', handle=tg_strs)
st.wait(waitvar)
res = tg.tg_traffic_control(action='stop', handle=tg_strs)
st.wait(waitvar / 2)
st.banner("Step T3: Verify ECMP.")
leaf_tg_ports = [[leaf1, vars.D3T1P1], [leaf1, vars.D3T1P2],
[leaf2, vars.D4T1P1], [leaf2, vars.D4T1P2]]
l3_spine_ports = [[leaf3, vars.D5D1P1], [leaf3, vars.D5D1P2],
[leaf3, vars.D5D2P1], [leaf3, vars.D5D2P2]]
spine_leaf_ports = [[spine1, vars.D1D3P1], [spine1, vars.D1D3P2],
[spine1, vars.D1D4P1], [spine1, vars.D1D4P2],
[spine2, vars.D2D3P1], [spine2, vars.D2D3P2],
[spine2, vars.D2D4P1], [spine2, vars.D2D4P2]]
res1 = verify_intf_counters(rx=[[leaf3, vars.D5T1P1]],
tx=leaf_tg_ports,
ratio=[[1], [0.25, 0.25, 0.25, 0.25]],
clear_save=True,
tolerance=vxlan_tolerance)
res2 = verify_intf_counters(rx=[[leaf3, vars.D5T1P1]],
tx=l3_spine_ports,
ratio=[[1], [0.25, 0.25, 0.25, 0.25]],
saved_flag=True,
tolerance=vxlan_tolerance)
res3 = verify_intf_counters(
rx=[[leaf3, vars.D5T1P1]],
tx=spine_leaf_ports,
ratio=[[1], [0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125]],
saved_flag=True,
tolerance=vxlan_tolerance)
st.log("Step T3: res1={}, res2={}, res3={} - all should be True".format(
res1, res2, res3))
if res1 is False or res2 is False or res3 is False:
fail_msg = "ERROR: Step T3 Initial ECMP failed."
fail_msgs += fail_msg
st.log(fail_msg)
tc_res[tc_list[0]] = tc_res[tc_list[1]] = False
retvar = False
gen_tech_supp(filename='f3_t3_')
more_debugs(duts=dut_list)
st.banner("Step T4: Remove dst-ip on leaf3, src-l4-port from other duts.")
def f3_t4_1():
ip.config_ip_loadshare_hash(spine1,
key='ip',
val=ecmpv4[3],
config='no')
ip.config_ip_loadshare_hash(spine1,
key='ipv6',
val=ecmpv6[3],
config='no')
res1 = ip.verify_ip_loadshare(spine1, ip=ecmpv4[3], ipv6=ecmpv6[3])
if res1 is True:
fail_msg = "ERROR: Step T4 show failed on spine1."
st.log(fail_msg)
return False
return True
def f3_t4_2():
ip.config_ip_loadshare_hash(spine2,
key='ip',
val=ecmpv4[3],
config='no')
ip.config_ip_loadshare_hash(spine2,
key='ipv6',
val=ecmpv6[3],
config='no')
res1 = ip.verify_ip_loadshare(spine2, ip=ecmpv4[3], ipv6=ecmpv6[3])
if res1 is True:
fail_msg = "ERROR: Step T4 show failed on spine2."
st.log(fail_msg)
return False
return True
def f3_t4_3():
ip.config_ip_loadshare_hash(leaf1,
key='ip',
val=ecmpv4[3],
config='no')
ip.config_ip_loadshare_hash(leaf1,
key='ipv6',
val=ecmpv6[3],
config='no')
res1 = ip.verify_ip_loadshare(leaf1, ip=ecmpv4[3], ipv6=ecmpv6[3])
if res1 is True:
fail_msg = "ERROR: Step T4 show failed on leaf1."
st.log(fail_msg)
return False
return True
def f3_t4_4():
ip.config_ip_loadshare_hash(leaf2,
key='ip',
val=ecmpv4[3],
config='no')
ip.config_ip_loadshare_hash(leaf2,
key='ipv6',
val=ecmpv6[3],
config='no')
res1 = ip.verify_ip_loadshare(leaf2, ip=ecmpv4[3], ipv6=ecmpv6[3])
if res1 is True:
fail_msg = "ERROR: Step T4 show failed on leaf2."
st.log(fail_msg)
return False
return True
def f3_t4_5():
ip.config_ip_loadshare_hash(leaf3,
key='ip',
val=ecmpv4[1],
config='no')
ip.config_ip_loadshare_hash(leaf3,
key='ipv6',
val=ecmpv6[1],
config='no')
res1 = ip.verify_ip_loadshare(leaf3, ip=ecmpv4[1], ipv6=ecmpv6[1])
if res1 is True:
fail_msg = "ERROR: Step T4 show failed on leaf3."
st.log(fail_msg)
return False
return True
[res, _] = utils.exec_all(
True, [[f3_t4_1], [f3_t4_2], [f3_t4_3], [f3_t4_4], [f3_t4_5]])
if False in set(res):
fail_msg = "ERROR: Step T4 show cli failed."
fail_msgs += fail_msg
st.log(fail_msg)
tc_res[tc_list[0]] = tc_res[tc_list[1]] = False
retvar = False
st.wait(waitvar, "Waiting for hardware programming to complete.")
st.banner("Step T5: Start the Streams - IPv4.")
[res, _] = utils.exec_all(
True,
[[f3_f1_1, 1], [f3_f1_2, 1], [f3_f1_3, 1], [f3_f1_4, 1], [f3_f1_5, 1]])
tg.tg_traffic_control(action='clear_stats', port_handle=tg_all)
res = tg.tg_traffic_control(action='run', handle=tg_v4s)
st.wait(waitvar)
res = tg.tg_traffic_control(action='stop', handle=tg_v4s)
st.wait(waitvar / 2)
st.banner("Step T6: Verify no ECMP at leaf1 and leaf2 - IPv4.")
res1a = verify_intf_counters(rx=[[leaf3, vars.D5T1P1]],
tx=leaf_tg_ports,
ratio=[[1], [1, 0, 0, 0]],
clear_save=True)
res1b = verify_intf_counters(rx=[[leaf3, vars.D5T1P1]],
tx=leaf_tg_ports,
ratio=[[1], [0, 1, 0, 0]],
saved_flag=True)
res1c = verify_intf_counters(rx=[[leaf3, vars.D5T1P1]],
tx=leaf_tg_ports,
ratio=[[1], [0, 0, 1, 0]],
saved_flag=True)
res1d = verify_intf_counters(rx=[[leaf3, vars.D5T1P1]],
tx=leaf_tg_ports,
ratio=[[1], [0, 0, 0, 1]],
saved_flag=True)
st.log(
"Step T6: tx11={}, tx12={}, tx21={}, tx22={} - only one of these should be True"
.format(res1a, res1b, res1c, res1d))
res1 = len([r for r in [res1a, res1b, res1c, res1d] if r is True])
ratio_list = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
res2_list = []
for r_l in ratio_list:
res = verify_intf_counters(rx=[[leaf3, vars.D5T1P1]],
tx=l3_spine_ports,
ratio=[[1], r_l],
saved_flag=True)
res2_list.append(res)
st.log(
"Step T6: L3S1P1,L3S1P2,L3S2P1,L3S2P2={} - only one of these should be True"
.format(res2_list))
res2 = len([r for r in res2_list if r is True])
ratio_list3 = [[1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 1]]
res3_list = []
for r_l in ratio_list3:
res = verify_intf_counters(rx=[[leaf3, vars.D5T1P1]],
tx=spine_leaf_ports,
ratio=[[1], r_l],
saved_flag=True)
res3_list.append(res)
st.log(
"Step T6: S1L1P1,S1L1P2,S1L2P1,S1L2P2,S2L1P1,S2L1P2,S2L2P1,S2L2P2={} - only one of these should be True"
.format(res3_list))
res3 = len([r for r in res3_list if r is True])
st.log("Step T8: res1={}, res2={}, res3={} - all should be 1".format(
res1, res2, res3))
if res1 != 1 or res2 != 1 or res3 != 1:
st.log("Step T6: res1={}, res2={}, res3={} - all should be 1".format(
res1, res2, res3))
st.log(
"Step T6: tx11={}, tx12={}, tx21={}, tx22={} - only one of these should be True"
.format(res1a, res1b, res1c, res1d))
st.log(
"Step T6: L3S1P1,L3S1P2,L3S2P1,L3S2P2={} - only one of these should be True"
.format(res2_list))
st.log(
"Step T6: S1L1P1,S1L1P2,S1L2P1,S1L2P2,S2L1P1,S2L1P2,S2L2P1,S2L2P2={} - only one of these should be True"
.format(res3_list))
fail_msg = "ERROR: Step T6 IPv4 - ECMP still working even after disabling."
fail_msgs += fail_msg
st.log(fail_msg)
tc_res[tc_list[0]] = False
retvar = False
st.banner("Step T7: Start the Streams - IPv6.")
[res, _] = utils.exec_all(
True,
[[f3_f1_1, 1], [f3_f1_2, 1], [f3_f1_3, 1], [f3_f1_4, 1], [f3_f1_5, 1]])
tg.tg_traffic_control(action='clear_stats', port_handle=tg_all)
res = tg.tg_traffic_control(action='run', handle=tg_v6s)
st.wait(waitvar)
res = tg.tg_traffic_control(action='stop', handle=tg_v6s)
st.wait(waitvar / 2)
st.banner("Step T8: Verify no ECMP at leaf1 and leaf2 - IPv6.")
res1a = verify_intf_counters(rx=[[leaf3, vars.D5T1P1]],
tx=leaf_tg_ports,
ratio=[[1], [1, 0, 0, 0]],
clear_save=True)
res1b = verify_intf_counters(rx=[[leaf3, vars.D5T1P1]],
tx=leaf_tg_ports,
ratio=[[1], [0, 1, 0, 0]],
saved_flag=True)
res1c = verify_intf_counters(rx=[[leaf3, vars.D5T1P1]],
tx=leaf_tg_ports,
ratio=[[1], [0, 0, 1, 0]],
saved_flag=True)
res1d = verify_intf_counters(rx=[[leaf3, vars.D5T1P1]],
tx=leaf_tg_ports,
ratio=[[1], [0, 0, 0, 1]],
saved_flag=True)
st.log(
"Step T8: tx11={}, tx12={}, tx21={}, tx22={} - only one of these should be True"
.format(res1a, res1b, res1c, res1d))
res1 = len([r for r in [res1a, res1b, res1c, res1d] if r is True])
res2_list = []
for r_l in ratio_list:
res = verify_intf_counters(rx=[[leaf3, vars.D5T1P1]],
tx=l3_spine_ports,
ratio=[[1], r_l],
saved_flag=True)
res2_list.append(res)
st.log(
"Step T8: L3S1P1,L3S1P2,L3S2P1,L3S2P2={} - only one of these should be True"
.format(res2_list))
res2 = len([r for r in res2_list if r is True])
res3_list = []
for r_l in ratio_list3:
res = verify_intf_counters(rx=[[leaf3, vars.D5T1P1]],
tx=spine_leaf_ports,
ratio=[[1], r_l],
saved_flag=True)
res3_list.append(res)
st.log(
"Step T8: S1L1P1,S1L1P2,S1L2P1,S1L2P2,S2L1P1,S2L1P2,S2L2P1,S2L2P2={} - only one of these should be True"
.format(res3_list))
res3 = len([r for r in res3_list if r is True])
st.log("Step T8: res1={}, res2={}, res3={} - all should be 1".format(
res1, res2, res3))
if res1 != 1 or res2 != 1 or res3 != 1:
st.log("Step T8: res1={}, res2={}, res3={} - all should be 1".format(
res1, res2, res3))
st.log(
"Step T8: tx11={}, tx12={}, tx21={}, tx22={} - only one of these should be True"
.format(res1a, res1b, res1c, res1d))
st.log(
"Step T8: L3S1P1,L3S1P2,L3S2P1,L3S2P2={} - only one of these should be True"
.format(res2_list))
st.log(
"Step T8: S1L1P1,S1L1P2,S1L2P1,S1L2P2,S2L1P1,S2L1P2,S2L2P1,S2L2P2={} - only one of these should be True"
.format(res3_list))
fail_msg = "ERROR: Step T8 IPv6 - ECMP still working even after disabling."
fail_msgs += fail_msg
st.log(fail_msg)
tc_res[tc_list[1]] = False
retvar = False
if retvar is False:
gen_tech_supp(filename='f3_t8_')
more_debugs(duts=dut_list)
st.banner("Step T10: Reconfigure the ECMP params.")
def f3_t10_1():
ip.config_ip_loadshare_hash(spine1, key='ip', val=ecmpv4[3])
ip.config_ip_loadshare_hash(spine1, key='ipv6', val=ecmpv6[3])
res1 = ip.verify_ip_loadshare(spine1,
ip=ecmpv4,
ipv6=ecmpv6,
seed=data.seed_def)
if res1 is False:
fail_msg = "ERROR: Step T10 show failed on spine1."
st.log(fail_msg)
return False
return True
def f3_t10_2():
ip.config_ip_loadshare_hash(spine2, key='ip', val=ecmpv4[3])
ip.config_ip_loadshare_hash(spine2, key='ipv6', val=ecmpv6[3])
res1 = ip.verify_ip_loadshare(spine2,
ip=ecmpv4,
ipv6=ecmpv6,
seed=data.seed_def)
if res1 is False:
fail_msg = "ERROR: Step T10 show failed on spine2."
st.log(fail_msg)
return False
return True
def f3_t10_3():
ip.config_ip_loadshare_hash(leaf1, key='ip', val=ecmpv4[3])
ip.config_ip_loadshare_hash(leaf1, key='ipv6', val=ecmpv6[3])
res1 = ip.verify_ip_loadshare(leaf1,
ip=ecmpv4,
ipv6=ecmpv6,
seed=data.seed_def)
if res1 is False:
fail_msg = "ERROR: Step T10 show failed on leaf1."
st.log(fail_msg)
return False
return True
def f3_t10_4():
ip.config_ip_loadshare_hash(leaf2, key='ip', val=ecmpv4[3])
ip.config_ip_loadshare_hash(leaf2, key='ipv6', val=ecmpv6[3])
res1 = ip.verify_ip_loadshare(leaf2,
ip=ecmpv4,
ipv6=ecmpv6,
seed=data.seed_def)
if res1 is False:
fail_msg = "ERROR: Step T10 show failed on leaf2."
st.log(fail_msg)
return False
return True
def f3_t10_5():
ip.config_ip_loadshare_hash(leaf3, key='ip', val=ecmpv4[1])
ip.config_ip_loadshare_hash(leaf3, key='ipv6', val=ecmpv6[1])
res1 = ip.verify_ip_loadshare(leaf3,
ip=ecmpv4,
ipv6=ecmpv6,
seed=data.seed_def)
if res1 is False:
fail_msg = "ERROR: Step T10 show failed on leaf3."
st.log(fail_msg)
return False
return True
[res, _] = utils.exec_all(
True, [[f3_t10_1], [f3_t10_2], [f3_t10_3], [f3_t10_4], [f3_t10_5]])
if False in set(res):
fail_msg = "ERROR: Step T10 show cli failed."
fail_msgs += fail_msg
st.log(fail_msg)
tc_res[tc_list[0]] = tc_res[tc_list[1]] = tc_res[tc_list[2]] = False
retvar = False
st.wait(waitvar, "Waiting for hardware programming to complete.")
st.banner("Step T11: Start the Streams.")
[res, _] = utils.exec_all(
True,
[[f3_f1_1, 1], [f3_f1_2, 1], [f3_f1_3, 1], [f3_f1_4, 1], [f3_f1_5, 1]])
tg.tg_traffic_control(action='clear_stats', port_handle=tg_all)
res = tg.tg_traffic_control(action='run', handle=tg_strs)
st.wait(waitvar)
res = tg.tg_traffic_control(action='stop', handle=tg_strs)
st.wait(waitvar / 2)
st.banner("Step T12: Verify ECMP is restored.")
res1 = verify_intf_counters(rx=[[leaf3, vars.D5T1P1]],
tx=leaf_tg_ports,
ratio=[[1], [0.25, 0.25, 0.25, 0.25]],
clear_save=True,
tolerance=vxlan_tolerance)
res2 = verify_intf_counters(rx=[[leaf3, vars.D5T1P1]],
tx=l3_spine_ports,
ratio=[[1], [0.25, 0.25, 0.25, 0.25]],
saved_flag=True,
tolerance=vxlan_tolerance)
res3 = verify_intf_counters(
rx=[[leaf3, vars.D5T1P1]],
tx=spine_leaf_ports,
ratio=[[1], [0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125]],
saved_flag=True,
tolerance=vxlan_tolerance)
st.log("Step T12: res1={}, res2={}, res3={} - all should be True".format(
res1, res2, res3))
if res1 is False or res2 is False or res3 is False:
fail_msg = "ERROR: Step T12 ECMP restoration failed."
fail_msgs += fail_msg
st.log(fail_msg)
tc_res[tc_list[0]] = tc_res[tc_list[1]] = tc_res[tc_list[2]] = False
retvar = False
gen_tech_supp(filename='f3_t12_')
more_debugs(duts=dut_list)
for tc in tc_list:
if tc_res[tc]:
st.report_tc_pass(tc, "tc_passed")
if retvar is False:
st.report_fail("test_case_failure_message", fail_msgs)
st.report_pass("test_case_passed")
def base_config():
###############################################################################################################################
st.log('###### ----- Taking backup for unconfig ------######')
src_path = "/etc/sonic/config_db.json"
dst_path = "/etc/sonic/default.json"
#cmd = 'cp /etc/sonic/config_db.json /etc/sonic/default.json'
utils.exec_all(
True,
[[basic_obj.copy_file_to_local_path, data.dut1, src_path, dst_path],
[basic_obj.copy_file_to_local_path, data.dut2, src_path, dst_path]])
###############################################################################################################################
st.log(
'###### ----- Loading json file with vrf and IP address config ------######'
)
curr_path = os.getcwd()
json_file_dut1 = curr_path + "/routing/VRF/vrf_scale_dut1.json"
st.apply_files(data.dut1, [json_file_dut1])
json_file_dut2 = curr_path + "/routing/VRF/vrf_scale_dut2.json"
st.apply_files(data.dut2, [json_file_dut2])
utils.exec_all(True, [[st.apply_files, data.dut1, [json_file_dut1]],
[st.apply_files, data.dut2, [json_file_dut2]]])
st.log('######------Configure vlans and add members------######')
utils.exec_all(True,
[[vlan_api.config_vlan_range, data.dut1, '1 999', 'add'],
[vlan_api.config_vlan_range, data.dut2, '1 999', 'add']])
utils.exec_all(True, [[
vlan_api.config_vlan_range_members, data.dut1, '1 999',
data.d1_dut_ports[0], 'add'
],
[
vlan_api.config_vlan_range_members, data.dut2,
'1 999', data.d2_dut_ports[0], 'add'
]])
###############################################################################################################################
st.log('######----- Configure IP on DUT--TG interface------######')
utils.exec_all(True,
[[
ip_api.config_ip_addr_interface, data.dut1,
data.dut1_tg1_ports[0], data.dut1_tg_host, '16', 'ipv4'
],
[
ip_api.config_ip_addr_interface, data.dut2,
data.dut2_tg1_ports[0], data.dut2_tg_host, '16', 'ipv4'
]])
###############################################################################################################################
st.log(
'######----- Configure hosts and create traffic streams for all VRFs------######'
)
host_config()
gateway_mac = mac_api.get_sbin_intf_mac(data.dut1, data.dut1_tg1_ports[0])
data.stream = data.tg1.tg_traffic_config(
port_handle=data.tg_dut1_p1,
mode='create',
duration='5',
transmit_mode='continuous',
length_mode='fixed',
port_handle2=data.tg_dut2_p1,
rate_pps=1000,
mac_src='00.00.00.11.12.53',
mac_dst=gateway_mac,
ip_src_addr=data.tg_dut1_stream_start[0],
ip_dst_addr=data.tg_dut2_stream_start[0],
l3_protocol='ipv4',
ip_src_mode='increment',
ip_src_count=1000,
ip_src_step='0.0.0.1')
data.stream_list_scale.update({'pc_v4_stream': data.stream['stream_id']})
st.wait(30)
def thread_call(thread_info, first_on_main=False):
[out, exceptions] = utils.exec_all(eh_data.thread_mode,
thread_info,
first_on_main=first_on_main)
st.log([out, exceptions])
def l3_ipv4v6_address_config_unconfig(config='yes',
vrf_type='all',
config_type='all'):
"""
:param config:
:param vrf_type:
:param config_type:
:return:
"""
st.banner(
"{}Configuring IP Addresses between linear topology nodes.".format(
'Un' if config != 'yes' else ''))
tb_vars = st.get_testbed_vars()
st.log("TestBed Vars => {}\n".format(tb_vars))
topo['dut_list'] = tb_vars.dut_list
st.log("topo dut_list {}".format(topo['dut_list']))
config = 'add' if config == 'yes' else 'remove'
ipv4_adr = '11'
ipv6_adr = '67fe'
result = True
k = 1
i = 0
while i < (len(topo['dut_list']) - 1):
dut = topo['dut_list'][i]
peer_dut = topo['dut_list'][i + 1]
link = 1
for local, _, remote in st.get_dut_links(dut, peer_dut):
if config_type == 'ipv4' or config_type == 'all':
ipaddr1 = "{}.{}.0.1".format(ipv4_adr, k)
ipaddr2 = "{}.{}.0.2".format(ipv4_adr, k)
topo['D{}D{}P{}'.format(i + 1, i + 2, link)] = local
topo['D{}D{}P{}_ipv4'.format(i + 1, i + 2, link)] = ipaddr1
topo['D{}D{}P{}_neigh_ipv4'.format(i + 1, i + 2,
link)] = ipaddr2
topo['D{}D{}P{}'.format(i + 2, i + 1, link)] = remote
topo['D{}D{}P{}_ipv4'.format(i + 2, i + 1, link)] = ipaddr2
topo['D{}D{}P{}_neigh_ipv4'.format(i + 2, i + 1,
link)] = ipaddr1
[out, exceptions] = utils.exec_all(
bgplib.fast_start,
[[
ipapi.config_ip_addr_interface, dut, local, ipaddr1,
'24', "ipv4", config
],
[
ipapi.config_ip_addr_interface, peer_dut, remote,
ipaddr2, '24', "ipv4", config
]])
st.log([out, exceptions])
if config_type == 'ipv6' or config_type == 'all':
ip6addr1 = "{}:{}::1".format(ipv6_adr, k)
ip6addr2 = "{}:{}::2".format(ipv6_adr, k)
topo['D{}D{}P{}'.format(i + 1, i + 2, link)] = local
topo['D{}D{}P{}_ipv6'.format(i + 1, i + 2, link)] = ip6addr1
topo['D{}D{}P{}_neigh_ipv6'.format(i + 1, i + 2,
link)] = ip6addr2
topo['D{}D{}P{}'.format(i + 2, i + 1, link)] = remote
topo['D{}D{}P{}_ipv6'.format(i + 2, i + 1, link)] = ip6addr2
topo['D{}D{}P{}_neigh_ipv6'.format(i + 2, i + 1,
link)] = ip6addr1
[out, exceptions] = utils.exec_all(
bgplib.fast_start,
[[
ipapi.config_ip_addr_interface, dut, local, ip6addr1,
'64', "ipv6", config
],
[
ipapi.config_ip_addr_interface, peer_dut, remote,
ip6addr2, '64', "ipv6", config
]])
st.log([out, exceptions])
link += 1
break
k += 1
i += 1
return result
def base_unconfig():
###############################################################################################################################
st.log('######------Unconfigure static routes on 900 VRFs-----######')
for vrf, dut1_as, dut2_as in zip(vrf_list[899:1000], dut1_as_scale[0:100],
dut2_as_scale[0:100]):
dict1 = {
'vrf_name': vrf,
'local_as': dut1_as,
'config': 'no',
'removeBGP': 'yes',
'config_type_list': ['removeBGP']
}
dict2 = {
'vrf_name': vrf,
'local_as': dut2_as,
'config': 'no',
'removeBGP': 'yes',
'config_type_list': ['removeBGP']
}
parallel.exec_parallel(True, [data.dut1, data.dut2],
bgp_api.config_bgp, [dict1, dict2])
###############################################################################################################################
st.log('######------Unconfigure static routes on 900 VRFs-----######')
dict1 = {
'dest_list': data.tg_dut2_stream_start[0:425],
'next_hop_list': data.dut2_dut1_ip_list[0:425],
'vrf_list': vrf_list[0:425],
'config': 'no'
}
dict2 = {
'dest_list': data.tg_dut2_stream_start[0:425],
'vrf_list': vrf_list[0:425],
'config': 'no'
}
parallel.exec_parallel(True, [data.dut1, data.dut2], vrf_static_route,
[dict1, dict2])
st.wait(30)
st.log('######----- UnConfigure IP on DUT--TG interface------######')
utils.exec_all(
True,
[[
ip_api.config_ip_addr_interface, data.dut1, data.dut1_tg1_ports[0],
data.dut1_tg_host, '16', 'ipv4', 'remove'
],
[
ip_api.config_ip_addr_interface, data.dut2,
data.dut2_tg1_ports[0], data.dut2_tg_host, '16', 'ipv4', 'remove'
]])
dict1 = {
'dest_list': data.tg_dut2_stream_start[425:899],
'next_hop_list': data.dut2_dut1_ip_list[425:899],
'vrf_list': vrf_list[425:899],
'config': 'no'
}
dict2 = {
'dest_list': data.tg_dut2_stream_start[425:899],
'vrf_list': vrf_list[425:899],
'config': 'no'
}
parallel.exec_parallel(True, [data.dut1, data.dut2], vrf_static_route,
[dict1, dict2])
st.wait(30)
###############################################################################################################################
st.log('###### ----- Laoding back the config_db file ------######')
#cmd = 'cp /etc/sonic/default.json /etc/sonic/config_db.json'
src_path = "/etc/sonic/default.json"
dst_path = "/etc/sonic/config_db.json"
utils.exec_all(
True,
[[basic_obj.copy_file_to_local_path, data.dut1, src_path, dst_path],
[basic_obj.copy_file_to_local_path, data.dut2, src_path, dst_path]])
utils.exec_all(
True, [[st.reboot, data.dut1, 'fast'], [st.reboot, data.dut2, 'fast']])
###############################################################################################################################
host_config(config='no')
def exec_all(use_threads, entries, first_on_main=False):
return base.exec_all(use_threads, entries, first_on_main)
def acl_v4_module_hooks(request):
# initialize topology
initialize_topology()
# apply module configuration
apply_module_configuration()
acl_config1 = acl_data.acl_json_config_v4_l3_traffic
add_port_to_acl_table(acl_config1, 'L3_IPV4_INGRESS', vars.D1T1P1)
acl_config2 = acl_data.acl_json_config_v6_l3_traffic
add_port_to_acl_table(acl_config2, 'L3_IPV6_INGRESS', vars.D2T1P1)
# creating ACL tables and rules
print_log('Creating ACL tables and rules')
utils.exec_all(True, [
utils.ExecAllFunc(acl_obj.apply_acl_config, vars.D1, acl_config1),
utils.ExecAllFunc(acl_obj.apply_acl_config, vars.D2, acl_config2),
])
# create streams
data.mac1 = basic_obj.get_ifconfig_ether(vars.D1, vars.D1T1P1)
data.mac2 = basic_obj.get_ifconfig_ether(vars.D2, vars.D2T1P1)
print_log('Creating streams')
create_streams("tg1", "tg2", acl_config1['ACL_RULE'], "L3_IPV4_INGRESS", \
mac_src="00:0a:01:00:00:01", mac_dst=data.mac1)
create_streams("tg1", "tg2", acl_config2['ACL_RULE'], "L3_IPV6_EGRESS", \
mac_src="00:0a:01:00:00:01", mac_dst="00:0a:01:00:11:02")
create_streams("tg2", "tg1", acl_config2['ACL_RULE'], "L3_IPV6_INGRESS", \
mac_src="00:0a:01:00:11:02", mac_dst=data.mac2)
create_streams("tg2", "tg1", acl_config1['ACL_RULE'], "L3_IPV4_EGRESS", \
mac_src="00:0a:01:00:11:02", mac_dst="00:0a:01:00:00:01")
print_log('Completed module configuration')
st.log("Configuring ipv4 address on ixia connected interfaces and portchannels present on both the DUTs")
ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P1, data.ipv4_address_D1, 24, family="ipv4", config='add')
ip_obj.config_ip_addr_interface(vars.D2, vars.D2T1P1, data.ipv4_address_D2, 24, family="ipv4", config='add')
ip_obj.config_ip_addr_interface(vars.D1, data.portChannelName, data.ipv4_portchannel_D1, 24, family="ipv4",
config='add')
ip_obj.config_ip_addr_interface(vars.D2, data.portChannelName, data.ipv4_portchannel_D2, 24, family="ipv4",
config='add')
st.log("Configuring ipv6 address on ixia connected interfaces and portchannels present on both the DUTs")
ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P1, data.ipv6_address_D1, 64, family="ipv6", config='add')
ip_obj.config_ip_addr_interface(vars.D2, vars.D2T1P1, data.ipv6_address_D2, 64, family="ipv6", config='add')
ip_obj.config_ip_addr_interface(vars.D1, data.portChannelName, data.ipv6_portchannel_D1, 64, family="ipv6",
config='add')
ip_obj.config_ip_addr_interface(vars.D2, data.portChannelName, data.ipv6_portchannel_D2, 64, family="ipv6",
config='add')
st.log("configuring ipv4 static routes on both the DUTs")
ip_obj.create_static_route(vars.D1, data.ipv4_portchannel_D2, data.ipv4_network_D2, shell="vtysh",
family="ipv4")
ip_obj.create_static_route(vars.D2, data.ipv4_portchannel_D1, data.ipv4_network_D1, shell="vtysh",
family="ipv4")
st.log("configuring ipv6 static routes on both the DUTs")
ip_obj.create_static_route(vars.D1, data.ipv6_portchannel_D2, data.ipv6_network_D2, shell="vtysh",
family="ipv6")
ip_obj.create_static_route(vars.D2, data.ipv6_portchannel_D1, data.ipv6_network_D1, shell="vtysh",
family="ipv6")
st.log("configuring static arp entries")
arp_obj.add_static_arp(vars.D1, "1.1.1.2", "00:0a:01:00:00:01", vars.D1T1P1)
arp_obj.add_static_arp(vars.D2, "2.2.2.2", "00:0a:01:00:11:02", vars.D2T1P1)
arp_obj.add_static_arp(vars.D2, "2.2.2.4", "00:0a:01:00:11:02", vars.D2T1P1)
arp_obj.add_static_arp(vars.D1, "1.1.1.4", "00:0a:01:00:00:01", vars.D1T1P1)
arp_obj.add_static_arp(vars.D2, "2.2.2.5", "00:0a:01:00:11:02", vars.D2T1P1)
arp_obj.add_static_arp(vars.D1, "1.1.1.5", "00:0a:01:00:00:01", vars.D1T1P1)
arp_obj.add_static_arp(vars.D2, "2.2.2.6", "00:0a:01:00:11:02", vars.D2T1P1)
arp_obj.add_static_arp(vars.D1, "1.1.1.6", "00:0a:01:00:00:01", vars.D1T1P1)
arp_obj.show_arp(vars.D1)
arp_obj.show_arp(vars.D2)
st.log("configuring static ndp entries")
arp_obj.config_static_ndp(vars.D1, "1001::2", "00:0a:01:00:00:01", vars.D1T1P1, operation="add")
arp_obj.config_static_ndp(vars.D2, "2001::2", "00:0a:01:00:11:02", vars.D2T1P1, operation="add")
arp_obj.show_ndp(vars.D1)
arp_obj.show_ndp(vars.D2)
yield
clear_module_configuration()
def test_udld_loops_normal_aggressive():
'''
Verify UDLD Tx/Rx loops in normal mode with out PVST/RPVST
Verify UDLD Tx/Rx loops in aggressive mode with out PVST/RPVST
'''
tc_list = ['FtOpSoSwudldloopnormal001', 'FtOpSoSwudldloopaggressive001']
print_log("START of TC:test_pvst_udld_normal_aggressive ==>Sub-Test:Verify UDLD functionality with PVST\n TCs:<{}>".format(tc_list), "HIGH")
final_result = True
tc_result1 = 0
tc_result2 = 0
#udld_global_fail = 0
udld_mode_fail = 0
udld_interface_normal_loop_fail = 0
udld_interface_no_normal_loop_fail = 0
udld_interface_aggressive_loop_fail = 0
udld_interface_no_aggressive_loop_fail = 0
udld_neighbor_fail = 0
udld_neighbor_warm_reboot_norm_fail = 0
##########################################NORMAL MODE UDLD RX/TX loop TESTS START#######################################
st.wait(5)
print_log("Verify that the port from DUT1 to DUT2 should go down in Normal Mode with UDLD TX/RX loop...",'MED')
udld_interfaces = [vars.D1D2P1]
state = 'down'
if verify_udld_port_status(udld_interfaces,dut1,state):
print_log("The ports from DUT1 to DUT3 is going to down state verification PASSED", "HIGH")
else:
print_log("The ports from DUT1 to DUT3 is not going to down state verification FAILED", "HIGH")
udld_interface_normal_loop_fail += 1
tc_result1 += 1
final_result = False
###Disable UDLD on Interfaces
dict1 = {'intf': udld_int[dut1]['udld_int'],'udld_enable': 'no', 'config': 'no'}
pll.exec_parallel(True,[dut1],udld.config_intf_udld, [dict1])
###Disable UDLD global
dict1 = {'udld_enable': 'no', 'config': 'no'}
pll.exec_parallel(True,[dut1],udld.config_udld_global, [dict1])
###do shut and no shut on DUt1 to DUT2
udld_interfaces = [vars.D1D2P1]
for udld_interface in udld_interfaces:
intf.interface_operation(dut1, udld_interface , "shutdown")
intf.interface_operation(dut1, udld_interface , "startup")
st.wait(5)
print_log("Verify that the port from DUT1 to DUT2 should go up in Normal Mode with UDLD TX/RX loop...",'MED')
udld_interfaces = [vars.D1D2P1]
state = 'up'
if verify_udld_port_status(udld_interfaces,dut1,state):
print_log("The ports from DUT1 to DUT2 is going to up state verification PASSED", "HIGH")
else:
print_log("The ports from DUT1 to DUT2 is not going to up state verification FAILED", "HIGH")
udld_interface_no_normal_loop_fail += 1
tc_result1 += 1
final_result = False
if tc_result1 > 0:
st.report_tc_fail("FtOpSoSwudldloopnormal001", "UDLD_TX_RX_loop_Normal_Failed", "test_udld_loops_normal_aggressive")
else:
st.report_tc_pass("FtOpSoSwudldloopnormal001", "UDLD_TX_RX_loop_Normal_Passed", "test_udld_loops_normal_aggressive")
###Enable UDLD global
dict1 = {'udld_enable': udld_global[dut1]['udld_enable'], 'config': udld_global[dut1]['config']}
pll.exec_parallel(True,[dut1],udld.config_udld_global, [dict1])
###Enable UDLD on Interfaces
dict1 = {'intf': udld_int[dut1]['udld_int'],'udld_enable': udld_int[dut1]['udld_enable'], 'config': udld_int[dut1]['config']}
pll.exec_parallel(True,[dut1],udld.config_intf_udld, [dict1])
###Enable UDLD mode Aggressive
print_log("Enable the UDLD Mode Agrgressive on All DUTs...", 'MED')
dict1 = {'udld_mode': udld_global[dut1]['udld_enable'], 'config': udld_global[dut1]['config']}
pll.exec_parallel(True,[dut1],udld.config_udld_mode, [dict1])
### Verify UDLD mode
if verify_udld_mode('Aggressive'):
print_log("UDLD Mode Aggressive verification PASSED", "HIGH")
else:
print_log("UDLD Mode Aggressive verification FAILED", "HIGH")
udld_mode_fail += 1
tc_result2 += 1
final_result = False
st.wait(2)
print_log("Verify that the port from DUT1 to DUT2 should go down in Aggressive Mode with UDLD TX/RX loop...",'MED')
udld_interfaces = [vars.D1D2P1]
state = 'down'
if verify_udld_port_status(udld_interfaces,dut1,state):
print_log("The ports from DUT1 to DUT2 is going to down state verification PASSED", "HIGH")
else:
print_log("The ports from DUT1 to DUT2 is not going to down state verification FAILED", "HIGH")
udld_interface_aggressive_loop_fail += 1
tc_result2 += 1
final_result = False
###Disable UDLD on Interfaces
dict1 = {'intf': udld_int[dut1]['udld_int'],'udld_enable': 'no', 'config': 'no'}
pll.exec_parallel(True,[dut1],udld.config_intf_udld, [dict1])
###Disable UDLD global
dict1 = {'udld_enable': 'no', 'config': 'no'}
pll.exec_parallel(True,[dut1],udld.config_udld_global, [dict1])
###do shut and no shut on DUt1 to DUT2
udld_interfaces = [vars.D1D2P1]
for udld_interface in udld_interfaces:
intf.interface_operation(dut1, udld_interface , "shutdown")
intf.interface_operation(dut1, udld_interface , "startup")
st.wait(5)
print_log("Verify that the port from DUT1 to DUT2 should go up in Aggressive Mode with UDLD TX/RX loop...",'MED')
udld_interfaces = [vars.D1D2P1]
state = 'up'
if verify_udld_port_status(udld_interfaces,dut1,state):
print_log("The ports from DUT1 to DUT2 is going to up state verification PASSED", "HIGH")
else:
print_log("The ports from DUT1 to DUT2 is not going to up state verification FAILED", "HIGH")
udld_interface_no_aggressive_loop_fail += 1
tc_result2 += 1
final_result = False
api_list = []
api_list.append([vlan.delete_vlan_member, dut2, trunk_base_vlan, [vars.D2D3P1,vars.D2D3P2]])
api_list.append([vlan.delete_vlan_member, dut3, trunk_base_vlan, [vars.D3D2P1,vars.D3D2P2]])
utils.exec_all(True, api_list)
###Enable UDLD global
dict1 = {'udld_enable': udld_global[dut1]['udld_enable'], 'config': udld_global[dut1]['config']}
dict2 = {'udld_enable': udld_global[dut2]['udld_enable'], 'config': udld_global[dut2]['config']}
pll.exec_parallel(True,dut_list,udld.config_udld_global, [dict1, dict2])
###Enable UDLD on Interfaces
dict1 = {'intf': udld_int[dut1]['udld_int'],'udld_enable': udld_int[dut1]['udld_enable'], 'config': udld_int[dut1]['config']}
dict2 = {'intf': udld_int[dut2]['udld_int'],'udld_enable': udld_int[dut2]['udld_enable'], 'config': udld_int[dut2]['config']}
pll.exec_parallel(True,dut_list,udld.config_intf_udld, [dict1, dict2])
st.wait(2)
####################PDB will REMOVE after suite completion
#import pdb;pdb.set_trace()
if verify_udld_neighbor(udld_neighbor):
print_log("UDLD neighbor verification PASSED", "HIGH")
else:
print_log("UDLD neighbor verification FAILED", "HIGH")
udld_neighbor_fail += 1
tc_result2 += 1
final_result = False
print_log("Do Warm Reboot in Aggressive Mode...", 'MED')
utils.exec_foreach(True, dut_reload, reboot_api.config_warm_restart, oper="enable")
utils.exec_all(True, [[st.reboot, dut, "warm"] for dut in dut_reload])
st.wait(10)
if verify_udld_neighbor(udld_neighbor):
print_log("UDLD neighbor in normal mode after cold reboot verification PASSED", "HIGH")
else:
print_log("UDLD neighbor in normal mode after cold reboot verification FAILED", "HIGH")
udld_neighbor_warm_reboot_norm_fail += 1
tc_result2 += 1
final_result = False
###Disable UDLD on Interfaces
dict1 = {'intf': udld_int[dut1]['udld_int'],'udld_enable': 'no', 'config': 'no'}
dict2 = {'intf': udld_int[dut2]['udld_int'],'udld_enable': 'no', 'config': 'no'}
pll.exec_parallel(True,dut_list,udld.config_intf_udld, [dict1, dict2])
###Disable UDLD global
dict1 = {'udld_enable': 'no', 'config': 'no'}
dict2 = {'udld_enable': 'no', 'config': 'no'}
pll.exec_parallel(True,dut_list,udld.config_udld_global, [dict1, dict2])
if tc_result2 > 0:
st.report_tc_fail("FtOpSoSwudldloopaggressive001", "UDLD_TX_RX_loop_Aggressive_Failed", "test_udld_loops_normal_aggressive")
else:
st.report_tc_pass("FtOpSoSwudldloopaggressive001", "UDLD_TX_RX_loop_Aggressive_Passed", "test_udld_loops_normal_aggressive")
if final_result:
st.report_pass("test_case_passed")
else:
fail_msg = ''
if udld_interface_normal_loop_fail > 0:
fail_msg += 'UDLD loop port down Failed in Normal mode:'
if udld_interface_no_normal_loop_fail > 0:
fail_msg += 'UDLD no loop port up Failed in Normal mode:'
if udld_mode_fail > 0:
fail_msg += 'UDLD mode Aggressive config Failed:'
if udld_interface_aggressive_loop_fail > 0:
fail_msg += 'UDLD loop port down Failed in Aggressive mode:'
if udld_interface_no_aggressive_loop_fail > 0:
fail_msg += 'UDLD no loop port up Failed in Aggressive mode:'
if udld_neighbor_fail > 0:
fail_msg += 'UDLD neighbor Failed:'
if udld_neighbor_warm_reboot_norm_fail > 0:
fail_msg += 'UDLD neighbor Failed after warm reboot:'
st.report_fail("test_case_failure_message", fail_msg.strip(':'))
def wred_module_hooks(request):
# add things at the start of this module
global vars
vars = st.ensure_min_topology("D1T1:3")
wred_data = wred_config.init_vars(vars, apply_wred=True)
st.log('Creating WRED table')
utils.exec_all(True, [
utils.ExecAllFunc(apply_wred_ecn_config, vars.D1,
wred_data['wred_config_json'])
])
st.log("Getting TG handlers")
data.tg1, data.tg_ph_1 = tgapi.get_handle_byname("T1D1P1")
data.tg2, data.tg_ph_2 = tgapi.get_handle_byname("T1D1P2")
data.tg3, data.tg_ph_3 = tgapi.get_handle_byname("T1D1P3")
data.tg = data.tg1
st.log("Reset and clear statistics of TG ports")
data.tg.tg_traffic_control(
action='reset', port_handle=[data.tg_ph_1, data.tg_ph_2, data.tg_ph_3])
data.tg.tg_traffic_control(
action='clear_stats',
port_handle=[data.tg_ph_1, data.tg_ph_2, data.tg_ph_3])
st.log("Creating TG streams")
data.streams = {}
stream = data.tg.tg_traffic_config(port_handle=data.tg_ph_3,
mode='create',
length_mode='fixed',
frame_size=64,
pkts_per_burst=10,
l2_encap='ethernet_ii_vlan',
transmit_mode='single_burst',
vlan_id=data.vlan,
mac_src=data.dscp_dest_mac,
mac_dst='00:0a:12:00:00:01',
vlan="enable")
data.streams['vlan_tagged_egress'] = stream['stream_id']
stream = data.tg.tg_traffic_config(
port_handle=data.tg_ph_1,
mode='create',
transmit_mode='continuous',
length_mode='fixed',
rate_percent=10,
l2_encap='ethernet_ii_vlan',
vlan_id=data.vlan,
vlan="enable",
mac_src=data.dscp_src1,
mac_dst=data.dscp_dest_mac,
l3_protocol='ipv4',
ip_src_addr='1.1.1.1',
ip_dst_addr='5.5.5.5',
ip_dscp="8",
high_speed_result_analysis=0,
track_by='trackingenabled0 ipv4DefaultPhb0',
ip_dscp_tracking=1)
data.streams['dscp1'] = stream['stream_id']
stream = data.tg.tg_traffic_config(
port_handle=data.tg_ph_1,
mode='create',
transmit_mode='continuous',
length_mode='fixed',
rate_percent=10,
l2_encap='ethernet_ii_vlan',
vlan_id=data.vlan,
vlan="enable",
mac_src=data.dscp_src2,
mac_dst=data.dscp_dest_mac,
l3_protocol='ipv4',
ip_src_addr='1.1.1.1',
ip_dst_addr='5.5.5.5',
ip_dscp="24",
high_speed_result_analysis=0,
track_by='trackingenabled0 ipv4DefaultPhb0',
ip_dscp_tracking=1)
data.streams['dscp2'] = stream['stream_id']
yield
#clearing WRED config
qos_obj.clear_qos_config(vars.D1)
vlan_obj.clear_vlan_configuration(vars.D1, thread=True)
