def test_vrf_scale(vrf_fixture_vrf_scale):
result = 0
###############################################################################################################################
if not vrf_api.verify_vrf(data.dut2, vrfname=vrf_list):
st.log('VRF creation failed on DUT2')
result += 1
###############################################################################################################################
st.log(
'######------Flap the underlying interface and reverify the VRF-----######'
)
port_api.shutdown(data.dut1, data.d1_dut_ports)
port_api.noshutdown(data.dut1, data.d1_dut_ports)
st.wait(5)
###############################################################################################################################
if not vrf_api.verify_vrf(data.dut1, vrfname=vrf_list):
st.log('Binding of VRF to interfaces failed on DUT1')
result += 1
###############################################################################################################################
if result == 0:
st.report_pass('test_case_passed')
else:
st.log('Interface binding failed for 1000 VRFs')
st.report_fail('test_case_failed')
def fixture_unnumvrf_test_donar(request, prologue_epilogue):
yield
port_obj.noshutdown(
data.dut1,
[data.d1_d2_ports[1], data.d1_d2_ports[2], data.d1_d2_ports[3]])
ip_obj.config_unnumbered_interface(data.dut1,
family='ipv4',
action='del',
interface=data.d1_d2_ports[0],
loop_back=data.dut1_loopback[0])
ospf_obj.config_ospf_network(
data.dut1, data.dut1_loopback_ip[3] + '/' + data.ip_loopback_prefix, 0,
data.dut1_vrf[0], '', 'no')
ip_obj.config_ip_addr_interface(data.dut1, data.dut1_loopback[0],
data.dut1_loopback_ip[0],
data.ip_loopback_prefix, "ipv4")
ospf_obj.config_ospf_network(
data.dut1, data.dut1_loopback_ip[0] + '/' + data.ip_loopback_prefix, 0,
data.dut1_vrf[0], '', 'yes')
loc_lib.dut1_config_unnumbered('phy', '')
loc_lib.verify_ospf()
def test_scale_ip_unnumbered():
##########################################################################################################################################
result = 0
st.banner('FtOpSoRoIPunScl001 - Verify maximum IPv4 unnumbered interfaces')
st.log(
'Configure IP unnumbered on Physical interfaces between DUT1 and DUT3')
for d1port, d2port in zip(data.d1_d2_ports, data.d2_d1_ports):
dict1 = {
'family': 'ipv4',
'action': 'add',
'interface': d1port,
'loop_back': dut1_loopback[0]
}
dict2 = {
'family': 'ipv4',
'action': 'add',
'interface': d2port,
'loop_back': dut2_loopback[0]
}
parallel.exec_parallel(True, [data.dut1, data.dut2],
ip_obj.config_unnumbered_interface,
[dict1, dict2])
st.log(
'Configure IP unnumbered on Physical interfaces between DUT2 and DUT3')
for d2port, d3port in zip(data.d2_d3_ports, data.d3_d2_ports):
dict2 = {
'family': 'ipv4',
'action': 'add',
'interface': d2port,
'loop_back': dut2_loopback[0]
}
dict3 = {
'family': 'ipv4',
'action': 'add',
'interface': d3port,
'loop_back': dut3_loopback[0]
}
parallel.exec_parallel(True, [data.dut2, data.dut3],
ip_obj.config_unnumbered_interface,
[dict2, dict3])
if not ip_obj.verify_interface_ip_address(
data.dut2, data.d2_d3_ports[0],
dut2_loopback_ip[0] + '/' + ip_loopback_prefix, 'ipv4', '', 'U'):
st.error(
'IP Unnumbered configuration on DUT2-Physical Interface failed')
result += 1
if not loc_lib.retry_api(ip_obj.ping,
data.dut1,
addresses=dut3_loopback_ip[0],
retry_count=5,
delay=10):
st.error('IPv4 Ping from DUT1 to DUT3 failed')
result += 1
if not arp_obj.verify_arp(dut=data.dut2, ipaddress=dut3_loopback_ip[0]):
st.error(
"Failed to resolve ARP for link local address over physical interface"
)
result += 1
aggrResult = loc_lib.send_verify_traffic(type='ipv4')
if not aggrResult:
st.error('IPv4 traffic with IPv4 unnumbered failed')
result += 1
port_obj.shutdown(data.dut2, [
data.d2_d1_ports[0], data.d2_d1_ports[1], data.d2_d1_ports[2],
data.d2_d1_ports[3], data.d2_d3_ports[0], data.d2_d3_ports[1],
data.d2_d3_ports[2], data.d2_d3_ports[3]
])
st.log('Wait for OSFP to go down')
st.wait(10)
port_obj.noshutdown(data.dut2, [
data.d2_d1_ports[0], data.d2_d1_ports[1], data.d2_d1_ports[2],
data.d2_d1_ports[3], data.d2_d3_ports[0], data.d2_d3_ports[1],
data.d2_d3_ports[2], data.d2_d3_ports[3]
])
st.log('Wait for OSFP to come up')
st.wait(10)
if not loc_lib.retry_api(ip_obj.ping,
data.dut1,
addresses=dut3_loopback_ip[0],
retry_count=5,
delay=10):
st.error('IPv4 Ping from DUT1 to DUT2 failed')
result += 1
aggrResult = loc_lib.send_verify_traffic(type='ipv4')
if not aggrResult:
st.error('IPv4 traffic with IPv4 unnumbered failed')
result += 1
if result == 0:
st.report_tc_pass('FtOpSoRoIPunScl001', 'test_case_passed')
else:
st.report_tc_fail('FtOpSoRoIPunScl001', 'test_case_failed')
if result == 0:
st.report_pass('test_case_passed')
else:
st.report_fail('test_case_failed')
def fixture_test_unnumvrf_basic(request, prologue_epilogue):
yield
port_obj.noshutdown(data.dut1, data.d1_d2_ports)
def noshutdown(self, dut, portlist):
cli_type = st.getenv("SPYTEST_HOOKS_PORT_ADMIN_STATE_UITYPE", "click")
port.noshutdown(dut, portlist, cli_type=cli_type)
def test_vrrpv3_scale_001(prologue_epilogue):
#tc_list = ["FtOpSoRoVrrpv3Fn054","FtOpSoRoVrrpv3Fn055","FtOpSoRoVrrpv3Fn056"]
tc_result = True ;err_list=[]
###########################################################
hdrMsg("Step01 : Verify VRRP Master/Backup election for all {} configured sessions".format(vrrp_sessions))
############################################################
result = verify_vrrp(summary="yes")
if result is False:
err = "VRRP Master/Backup election is incorrect for one or more VRRP sessions"
st.report_fail('test_case_failure_message', err)
result =vrrp.configure_vrrp(data.dut1, vrid='129',interface='Vlan8', config="yes",enable='',skip_error=True,scale_instance_error=1)
expected_err ="Error"
if expected_err not in str(result):
err = "VRRP instance 129 is accepted but Max number of VRRP instances supported is 128 "
st.error(err);tc_result=False;err_list.append(err)
###########################################################
hdrMsg("Start Traffic for VRRP instance scale config")
###########################################################
#data.tg1.tg_traffic_control(action='run', stream_handle=data.stream_handles.values())
run_traffic()
###########################################################
hdrMsg("Step02 : Verify Traffic for scale config for all VRID")
############################################################
result = verify_tg_traffic_rate(data.tg1,data.tg2,data.tgd3_ports,data.tgd4_ports)
if result is False:
err = "Traffic check failed for configure VRRP {} and flap Vlan".format(vrrp_ip_list[0][0])
st.error(err);tc_result=False;err_list.append(err)
###########################################################
hdrMsg("Stop Traffic for VRRP instance scale config")
###########################################################
#data.tg1.tg_traffic_control(action='stop', stream_handle=data.stream_handles.values())
run_traffic(action='stop')
###########################################################
hdrMsg("Step03 : Delete/Configure VRRP sessions {} on dut1(Master) and verify vrrp master backup role".format(vrid_list[0:int(vrrp_sessions/2)]))
############################################################
for vrid,vlan,vip,prio,vmac in zip(vrid_list[0:int(vrrp_sessions/2)],vrrp_vlan_intf[0:int(vrrp_sessions/2)],
vip_list[0:int(vrrp_sessions/2)],vrrp_priority_list_dut1[0:int(vrrp_sessions/2)],
vmac_list_1[0:int(vrrp_sessions/2)]):
if vrid - (int(vrrp_sessions/2)) == -1 or vrid - (int(vrrp_sessions/2)) == 0 or vrid - (int(vrrp_sessions/2)) == 1:
st.log(">>>> Delete/Configur VRRP session {} <<<<<".format(vrid))
vrrp.configure_vrrp(data.dut1, vrid=vrid, interface=vlan, config="no",disable='')
vrrp.configure_vrrp(data.dut1, vrid=vrid, vip=vip, interface=vlan, priority=prio, config="yes",enable='')
vrrp.configure_vrrp(data.dut1,vrid=vrid,interface=vlan,version=3)
for vrid,vlan,vip,prio,vmac in zip(vrid_list[0:int(vrrp_sessions/2)],vrrp_vlan_intf[0:int(vrrp_sessions/2)],
vip_list[0:int(vrrp_sessions/2)],vrrp_priority_list_dut1[0:int(vrrp_sessions/2)],
vmac_list_1[0:int(vrrp_sessions/2)]):
if vrid - (int(vrrp_sessions/2)) == -1 or vrid - (int(vrrp_sessions/2)) == 0 or vrid - (int(vrrp_sessions/2)) == 1:
st.log("Verify dut1 elected as VRRP Master for VRID {} ".format(vrid))
result =verify_master_backup(vrid,vlan,vmac,vip,master_dut=data.dut1,backup_dut=data.dut2)
if result is False:
err = "dut1 not elected as VRRP Master for VRID {}".format(vrid)
st.error(err);err_list.append(err);tc_result = False
###########################################################
hdrMsg("Step04 : Shutdown/No-shutdown VRRP enabled LAG member port in master node dut1 and check new vrrp role")
############################################################
port.shutdown(data.dut1,data.d1d3_ports)
for vrid,vlan,vip,prio,vmac in zip(vrid_list[0:int(vrrp_sessions/2)],vrrp_vlan_intf[0:int(vrrp_sessions/2)],
vip_list[0:int(vrrp_sessions/2)],vrrp_priority_list_dut1[0:int(vrrp_sessions/2)],
vmac_list_1[0:int(vrrp_sessions/2)]):
if vrid - (int(vrrp_sessions/2)) == -2 or vrid - (int(vrrp_sessions/2)) == -1 or vrid - (int(vrrp_sessions/2)) == 0:
st.log("Verify dut2 elected as VRRP Master for VRID {} ".format(vrid))
result =verify_master_backup(vrid,vlan,vmac,vip,master_dut=data.dut2,backup_dut=data.dut1,skip_backup_check='yes')
if result is False:
err = "dut2 not elected as VRRP Master for VRID {}".format(vrid)
st.error(err);err_list.append(err);tc_result = False
for vrid,intf,vmac,vip in zip(vrid_list[int(vrrp_sessions/2):],dut1_vlan_intf[int(vrrp_sessions/2):vrrp_sessions],vmac_list_1[int(vrrp_sessions/2):],vip_list[int(vrrp_sessions/2):]):
if vrid - (int(vrrp_sessions/2)) == 1 or vrid - (int(vrrp_sessions/2)) == 2 or vrid - vrrp_sessions == 0:
st.log("Verify dut2 elected as VRRP Master for VRID {} ".format(vrid))
result =verify_master_backup(vrid,intf,vmac,vip,master_dut=data.dut2,backup_dut=data.dut1,skip_backup_check='yes')
if result is False:
err = "dut1 not elected as VRRP Master for VRID {}".format(vrid)
st.error(err);err_list.append(err);tc_result = False
###########################################################
hdrMsg("Start Traffic for VRRP instance scale config after old master is down")
###########################################################
#data.tg1.tg_traffic_control(action='run', stream_handle=data.stream_handles.values())
run_traffic()
###########################################################
hdrMsg("Step05 : Verify Traffic for scale VRRP instances with new VRRP master ")
############################################################
result = verify_tg_traffic_rate(data.tg1,data.tg2,data.tgd3_ports,data.tgd4_ports)
if result is False:
err = "Traffic check failed with after delete/configure VRRP {} and flap Vlan".format(vrrp_ip_list[0][0])
st.error(err);tc_result=False;err_list.append(err)
###########################################################
hdrMsg("Stop Traffic for VRRP instance scale config after after old master is down")
###########################################################
#data.tg1.tg_traffic_control(action='stop', stream_handle=data.stream_handles.values())
run_traffic(action='stop')
###########################################################
hdrMsg("No-shutdown VRRP enabled LAG member port in dut1")
############################################################
port.noshutdown(data.dut1,data.d1d3_ports)
###########################################################################################
hdrMsg("Step06: Config save and fast boot DUT" )
###########################################################################################
reboot_api.config_save(data.dut1)
reboot_api.config_save(data.dut1,shell='vtysh')
st.reboot(data.dut1,'fast')
###########################################################
hdrMsg("Step07 : Verify VRRP Master/Backup election for all {} configured sessions after dut1 fast reload".format(vrrp_sessions))
############################################################
result = verify_vrrp(summary="yes",retry_count=20)
if result is False:
err = "VRRP Master/Backup election is incorrect for one or more VRRP sessions"
st.report_fail('test_case_failure_message', err)
###########################################################
hdrMsg("Start Traffic for VRRP instance scale config after dut1 fast reload")
###########################################################
#data.tg1.tg_traffic_control(action='run', stream_handle=data.stream_handles.values())
run_traffic()
###########################################################
hdrMsg("Step08 : Verify Traffic for scale VRRP instances after dut1 fast reload ")
############################################################
result = verify_tg_traffic_rate(data.tg1,data.tg2,data.tgd3_ports,data.tgd4_ports)
if result is False:
err = "Traffic check failed with after delete/configure VRRP {} and flap Vlan".format(vrrp_ip_list[0][0])
st.error(err);tc_result=False;err_list.append(err)
###########################################################
hdrMsg("Stop Traffic for VRRP instance scale config after after dut1 fast reload")
###########################################################
#data.tg1.tg_traffic_control(action='stop', stream_handle=data.stream_handles.values())
run_traffic(action='stop')
if tc_result is False:
st.report_fail('test_case_failure_message',err_list[0])
else:
st.report_pass('test_case_passed')
def test_FtOpSoRoBfdSc085(prologue_epilogue):
tc_result = True
err_list = []
############################################################################################
hdrMsg("Step T1 : Enable BFD for 64 BGP neighbors under peer-group")
############################################################################################
if test_type == 'ipv4':
bfd_peer = ['peer_v4']
nbr_list = dut2_ip
local_list = dut1_ip
elif test_type == 'ipv6':
bfd_peer = ['peer_v6']
nbr_list = dut2_ipv6
local_list = dut1_ipv6
else:
bfd_peer = ['peer_v4', 'peer_v6']
nbr_list = dut2_ip + dut2_ipv6
local_list = dut1_ip + dut1_ipv6
nbr_list_vrf = dut2_ip_vrf + dut2_ipv6_vrf
local_list_vrf = dut1_ip_vrf + dut1_ipv6_vrf
dict1 = {
"local_asn": dut1_as,
'peergroup': bfd_peer,
'neighbor_ip': bfd_peer,
'config': 'yes'
}
dict2 = {
"local_asn": dut2_as,
'peergroup': bfd_peer,
'neighbor_ip': bfd_peer,
'config': 'yes'
}
parallel.exec_parallel(True, [dut1, dut2], bfd.configure_bfd,
[dict1, dict2])
dict1 = {
'vrf_name': user_vrf_name,
"local_asn": dut1_as,
'peergroup': bfd_peer,
'neighbor_ip': bfd_peer,
'config': 'yes'
}
dict2 = {
'vrf_name': user_vrf_name,
"local_asn": dut2_as,
'peergroup': bfd_peer,
'neighbor_ip': bfd_peer,
'config': 'yes'
}
parallel.exec_parallel(True, [dut1, dut2], bfd.configure_bfd,
[dict1, dict2])
############################################################################################
hdrMsg("Step T2 :Verify all 64 BFD sessions are UP with default timers")
############################################################################################
if test_type != 'mix':
intf_multiplier = 1
else:
intf_multiplier = 2
result = retry_api(bfd.verify_bfd_peer,
dut1,
peer=nbr_list,
interface=vlan_intf * intf_multiplier,
status=['up'] * max_bfd,
rx_interval=[['300', '300']] * max_bfd,
tx_interval=[['300', '300']] * max_bfd,
retry_count=5,
delay=1,
ping_verify=True)
if result is False:
err = "BFD parameters are incorrect for one or more BFD peers"
err_list.append(err)
tc_result = False
st.error(err)
result = retry_api(bfd.verify_bfd_peer,
dut1,
vrf_name=user_vrf_name,
peer=nbr_list_vrf,
interface=vlan_intf_vrf * intf_multiplier,
status=['up'] * max_bfd_vrf,
rx_interval=[['300', '300']] * max_bfd_vrf,
tx_interval=[['300', '300']] * max_bfd_vrf,
retry_count=5,
delay=1,
ping_verify=True)
if result is False:
err = "BFD parameters are incorrect for one or more BFD peers"
err_list.append(err)
tc_result = False
st.error(err)
############################################################################################
hdrMsg(
"Step T3 :Configure 100ms*3 for all BFD sessions and enable echo-mode on both dut"
)
############################################################################################
bfd.configure_bfd(dut1,
interface=vlan_intf * intf_multiplier,
neighbor_ip=nbr_list,
multiplier=["3"] * max_bfd,
rx_intv=["100"] * max_bfd,
tx_intv=["100"] * max_bfd,
echo_mode_enable='',
echo_intv=[1000] * max_bfd)
bfd.configure_bfd(dut2,
interface=vlan_intf * intf_multiplier,
neighbor_ip=local_list,
multiplier=["3"] * max_bfd,
rx_intv=["100"] * max_bfd,
tx_intv=["100"] * max_bfd,
echo_mode_enable='',
echo_intv=[1000] * max_bfd)
bfd.configure_bfd(dut1,
vrf_name=user_vrf_name,
interface=vlan_intf_vrf * intf_multiplier,
neighbor_ip=nbr_list_vrf,
multiplier=["3"] * max_bfd_vrf,
rx_intv=["100"] * max_bfd_vrf,
tx_intv=["100"] * max_bfd_vrf,
echo_mode_enable='',
echo_intv=[1000] * max_bfd_vrf)
bfd.configure_bfd(dut2,
vrf_name=user_vrf_name,
interface=vlan_intf_vrf * intf_multiplier,
neighbor_ip=local_list_vrf,
multiplier=["3"] * max_bfd_vrf,
rx_intv=["100"] * max_bfd_vrf,
tx_intv=["100"] * max_bfd_vrf,
echo_mode_enable='',
echo_intv=[1000] * max_bfd_vrf)
############################################################################################
hdrMsg("Step T4 :Verify all 64 BFD sessions are UP with 100*3 ms timers")
############################################################################################
st.wait(120)
result = retry_api(bfd.verify_bfd_peer,
dut1,
peer=nbr_list,
interface=vlan_intf * intf_multiplier,
status=['up'] * max_bfd,
rx_interval=[['100', '100']] * max_bfd,
tx_interval=[['100', '100']] * max_bfd,
retry_count=2,
delay=1)
if result is False:
err = "BFD parameters are incorrect for one or more BFD peers"
err_list.append(err)
tc_result = False
st.error(err)
result = retry_api(bfd.verify_bfd_peer,
dut1,
vrf_name=user_vrf_name,
peer=nbr_list_vrf,
interface=vlan_intf_vrf * intf_multiplier,
status=['up'] * max_bfd_vrf,
rx_interval=[['100', '100']] * max_bfd_vrf,
tx_interval=[['100', '100']] * max_bfd_vrf,
retry_count=2,
delay=1)
if result is False:
err = "BFD parameters are incorrect for one or more BFD peers"
err_list.append(err)
tc_result = False
st.error(err)
############################################################################################
hdrMsg("Step T5 :Verify BFD state under BGP neighbors are up")
############################################################################################
result = ip_bgp.verify_bgp_neighbor(dut1,
neighborip=nbr_list,
state=['Established'] * len(nbr_list))
if result is False:
err = "BFD parameters are incorrect for BGP neighbor with scale config"
err_list.append(err)
tc_result = False
st.error(err)
result = ip_bgp.verify_bgp_neighbor(dut1,
vrf=user_vrf_name,
neighborip=nbr_list_vrf,
state=['Established'] *
len(nbr_list_vrf))
if result is False:
err = "BFD parameters are incorrect for BGP neighbor with scale config"
err_list.append(err)
tc_result = False
st.error(err)
############################################################################################
hdrMsg(
"Step T6 :Disable/enable BFD unser BGP and verify max BFD sessions gets established"
)
############################################################################################
dict1 = {
"local_asn": dut1_as,
'peergroup': bfd_peer,
'neighbor_ip': bfd_peer,
'config': 'no'
}
dict2 = {
"local_asn": dut2_as,
'peergroup': bfd_peer,
'neighbor_ip': bfd_peer,
'config': 'no'
}
parallel.exec_parallel(True, [dut1, dut2], bfd.configure_bfd,
[dict1, dict2])
dict1 = {
"local_asn": dut1_as,
'peergroup': bfd_peer,
'neighbor_ip': bfd_peer,
'config': 'yes'
}
dict2 = {
"local_asn": dut2_as,
'peergroup': bfd_peer,
'neighbor_ip': bfd_peer,
'config': 'yes'
}
parallel.exec_parallel(True, [dut1, dut2], bfd.configure_bfd,
[dict1, dict2])
result = retry_api(bfd.verify_bfd_peer,
dut1,
peer=nbr_list,
interface=vlan_intf * intf_multiplier,
status=['up'] * max_bfd,
rx_interval=[['100', '100']] * max_bfd,
tx_interval=[['100', '100']] * max_bfd,
retry_count=2,
delay=1)
if result is False:
err = "BFD parameters are incorrect for one or more BFD peers after disable/enable BFD"
err_list.append(err)
tc_result = False
st.error(err)
############################################################################################
hdrMsg(
"Step T7 :Bring down port on dut2 and verify BGP sessions goes down immediately"
)
############################################################################################
port.shutdown(dut2, [D2_ports[0], D2_ports[1]])
st.wait(2)
result = retry_api(bfd.verify_bfd_peer,
dut1,
peer=nbr_list,
interface=vlan_intf * intf_multiplier,
status=['down'] * max_bfd,
retry_count=2,
delay=1)
if result is False:
err = "BFD parameters are incorrect for one or more BFD peers"
err_list.append(err)
tc_result = False
st.error(err)
############################################################################################
hdrMsg(
"Step T8 :Verify BFD state and BGP state is down under BGP neighbors")
############################################################################################
result = ip_bgp.check_bgp_session(dut1,
nbr_list=nbr_list,
state_list=['Established'] * max_bfd)
if result is True:
err = 'BGP sessions did not go down after link down'
err_list.append(err)
tc_result = False
st.error(err)
############################################################################################
hdrMsg(
"Step T9 :Bring up port on dut2 and verify BGP BFD sessions comes up")
############################################################################################
port.noshutdown(dut2, [D2_ports[0], D2_ports[1]])
result = retry_api(ip_bgp.verify_bgp_neighbor,
dut1,
neighborip=nbr_list,
state=['Established'] * len(nbr_list))
if result is False:
err = "BFD /BGP state not UP for one or more BGP neighbors with scale config"
err_list.append(err)
tc_result = False
st.error(err)
############################################################################################
hdrMsg("Step T10 :Disable BFD under BGP and delete static BFD entries")
############################################################################################
dict1 = {
"local_asn": dut1_as,
'peergroup': bfd_peer,
'neighbor_ip': bfd_peer,
'config': 'no'
}
dict2 = {
"local_asn": dut2_as,
'peergroup': bfd_peer,
'neighbor_ip': bfd_peer,
'config': 'no'
}
parallel.exec_parallel(True, [dut1, dut2], bfd.configure_bfd,
[dict1, dict2])
if test_type == 'ipv6':
bfd.configure_bfd(dut1,
interface=vlan_intf,
neighbor_ip=nbr_list,
local_address=local_list,
config='no')
bfd.configure_bfd(dut2,
interface=vlan_intf,
neighbor_ip=local_list,
local_address=nbr_list,
config='no')
elif test_type == 'mix':
bfd.configure_bfd(dut1,
interface=vlan_intf,
neighbor_ip=dut2_ip,
config='no')
bfd.configure_bfd(dut1,
interface=vlan_intf,
neighbor_ip=dut2_ipv6,
local_address=dut1_ipv6,
config='no')
bfd.configure_bfd(dut2,
interface=vlan_intf,
neighbor_ip=dut1_ip,
config='no')
bfd.configure_bfd(dut2,
interface=vlan_intf,
neighbor_ip=dut1_ipv6,
local_address=dut2_ipv6,
config='no')
else:
bfd.configure_bfd(dut1,
interface=vlan_intf,
neighbor_ip=nbr_list,
config='no')
bfd.configure_bfd(dut2,
interface=vlan_intf,
neighbor_ip=local_list,
config='no')
if tc_result is False:
st.report_fail('bfd_fail_reason', err_list[0])
st.report_pass('test_case_passed')
def verify_topology(check_type, threads=True):
if check_type in ["status", "status2", "status3", "status4"]:
return links_status(threads, check_type)
retval = True
results = []
header = ['DUT', 'Local', "Partner", "Remote", "Status"]
check_oneway = True
exclude = []
for dut in st.get_dut_names():
alias = st.get_device_alias(dut)
for local, partner, remote in st.get_dut_links(dut):
palias = st.get_device_alias(partner)
# check if the port is verified from other direction
skip = False
for ex in exclude:
#print("CMP", dut, local, ex[0], ex[1])
if dut == ex[0] and local == ex[1]:
skip = True
break
if skip:
log_info("{}/{} is already verified".format(alias, local))
continue
result = [alias, local, palias, remote, "Fail"]
# shutdown local link and get remote link stats in partner
portapi.shutdown(dut, [local])
wait()
status1 = portapi.get_interface_status(partner, remote)
trace(alias, local, palias, remote, status1)
# noshutdown local link and get remote link stats in partner
portapi.noshutdown(dut, [local])
wait()
status2 = portapi.get_interface_status(partner, remote)
trace(alias, local, palias, remote, status2)
# log the result on fail
if not check_status(status1, "down", status2, "up"):
warn("1. port %s/%s is not connected to %s/%s\n", alias, local,
palias, remote)
results.append(result)
exclude.append([partner, remote])
retval = False
continue
if not check_oneway:
# shutdown remote link and get local link status
portapi.shutdown(partner, [remote])
wait()
status3 = portapi.get_interface_status(dut, local)
trace(alias, local, palias, remote, status3)
# noshutdown remote link and get local link status
portapi.noshutdown(partner, [remote])
wait()
status4 = portapi.get_interface_status(dut, local)
trace(alias, local, palias, remote, status4)
# log the result on fail
if not check_status(status3, "down", status4, "up"):
warn("2. port %s/%s is not connected to %s/%s\n", alias,
local, palias, remote)
results.append(result)
retval = False
continue
# log the result on pass
result[4] = "OK"
results.append(result)
exclude.append([partner, remote])
for local, partner, remote in st.get_tg_links(dut):
palias = st.get_device_alias(partner)
(tg, ph) = tgapi.get_handle_byname(None, tg=partner, port=remote)
result = [alias, local, palias, remote, "Fail"]
tgen_link_status_supported = False
if tgen_link_status_supported:
# shutdown local link and get remote link stats in partner
portapi.shutdown(dut, [local])
wait()
status1 = get_link_status(tg, ph)
trace(alias, local, palias, remote, status1)
# no shutdown local link and get remote link stats in partner
portapi.noshutdown(dut, [local])
wait()
status2 = get_link_status(tg, ph)
trace(alias, local, palias, remote, status2)
# log the result on fail
if tgen_link_status_supported and (status1 or not status2):
warn("3. port %s/%s is not connected to %s/%s\n", alias,
local, palias, remote)
results.append(result)
retval = False
continue
# shutdown remote link and get local link status
tg.tg_interface_control(mode="break_link", port_handle=ph)
wait()
status3 = portapi.get_interface_status(dut, local)
trace(alias, local, palias, remote, status3)
# noshutdown remote link and get local link status
tg.tg_interface_control(mode="restore_link", port_handle=ph)
wait()
status4 = portapi.get_interface_status(dut, local)
trace(alias, local, palias, remote, status4)
# log the result on fail
if not check_status(status3, "down", status4, "up"):
warn("4. port %s/%s is not connected to %s/%s\n", alias, local,
palias, remote)
results.append(result)
retval = False
continue
# log the result on pass
result[4] = "OK"
results.append(result)
return [retval, header, results]
def common_config(request):
global dut1, r1_tg_ports1, r1_tg_ports2
global tg_r1_hw_port1, tg_r1_hw_port2
global tg1, tg2, tg_dut1_p1_handle, tg_dut1_p2_handle
global r1tg1_1_ipAddr, r1tg2_1_ipAddr
global nextHop_ip, nextHop_ipv6
global static_macAdd
global r1tg1_1_ipv6Addr, r1tg2_1_ipv6Addr
global subnetMask, subnetMaskv6
global Vlan, maskACL
global acl_table_name, acl_table_namev6
global description, descriptionv6
global type, typev6
global stage, expCount, pktrate, pktAction
global srpIP, dstIP, srpIPv6, dstIPv6
global rule_list, priority_list
vars = st.ensure_min_topology("D1T1:2")
dut1 = vars.D1
r1_tg_ports1 = vars.D1T1P1
r1_tg_ports2 = vars.D1T1P2
tg_r1_hw_port1 = vars.T1D1P1
tg_r1_hw_port2 = vars.T1D1P2
tg1, tg_dut1_p1_handle = tgapi.get_handle_byname("T1D1P1")
tg2, tg_dut1_p2_handle = tgapi.get_handle_byname("T1D1P2")
r1tg1_1_ipAddr = '30.30.30.1'
r1tg2_1_ipAddr = '20.20.20.1'
nextHop_ip = '20.20.20.100'
nextHop_ipv6 = '3001::100'
static_macAdd = '00:0a:01:00:11:02'
r1tg1_1_ipv6Addr = '2001::10'
r1tg2_1_ipv6Addr = '3001::10'
subnetMask = '24'
subnetMaskv6 = '64'
Vlan = '100'
maskACL = '32'
acl_table_name = 'ACL0'
acl_table_namev6 = 'ACL1'
description = 'IPv4_ACL_redirect_port'
descriptionv6 = 'IPv6_ACL_redirect_port'
type = 'L3'
typev6 = 'L3V6'
stage = 'INGRESS'
expCount = '1000'
pktrate = '1000'
pktAction = 'redirect:'
srpIP = '1.1.1.3'
dstIP = '3.3.3.1'
srpIPv6 = '1234::1'
dstIPv6 = '5001::1'
rule_list = [
'rule_1', 'rule_2', 'rule_3', 'rule_4', 'rule_5', 'rule_6', 'rule_7',
'rule_8', 'rule_9', 'rule_10'
]
priority_list = ['10', '9', '8', '7', '6', '5', '4', '3', '2', '1']
st.log("Bring Up the required topology for the test to run")
port.noshutdown(dut1, [r1_tg_ports1, r1_tg_ports2])
ipfeature.config_ip_addr_interface(dut1,
interface_name=r1_tg_ports1,
ip_address=r1tg1_1_ipAddr,
subnet=subnetMask,
family="ipv4")
ipfeature.config_ip_addr_interface(dut1,
interface_name=r1_tg_ports2,
ip_address=r1tg2_1_ipAddr,
subnet=subnetMask,
family="ipv4")
ipfeature.config_ip_addr_interface(dut1,
interface_name=r1_tg_ports1,
ip_address=r1tg1_1_ipv6Addr,
subnet=subnetMaskv6,
family="ipv6")
ipfeature.config_ip_addr_interface(dut1,
interface_name=r1_tg_ports2,
ip_address=r1tg2_1_ipv6Addr,
subnet=subnetMaskv6,
family="ipv6")
st.log("Create static arp on dut1")
arp_obj.add_static_arp(dut1, nextHop_ip, static_macAdd)
st.log("Create static ndp on dut1")
arp_obj.config_static_ndp(dut1, nextHop_ipv6, static_macAdd, r1_tg_ports2)
st.log("Get the device MAC- dut1")
routing_mac = mapi.get_sbin_intf_mac(dut1, r1_tg_ports1)
st.log("Create host on the Traffic generator")
create_trafficStreams(tg1,
tg2,
tg_dut1_p1_handle,
tg_dut1_p2_handle,
rate=pktrate,
rule='forward',
dstMAC=routing_mac)
yield
# add things at the end of this module"
arp_obj.delete_static_arp(dut1, nextHop_ip, static_macAdd)
arp_obj.clear_ndp_table(dut1)
st.log("Delete interface config on dut1")
ipfeature.delete_ip_interface(dut1,
interface_name=r1_tg_ports1,
ip_address=r1tg1_1_ipAddr,
subnet=subnetMask,
family="ipv4")
ipfeature.delete_ip_interface(dut1,
interface_name=r1_tg_ports2,
ip_address=r1tg2_1_ipAddr,
subnet=subnetMask,
family="ipv4")
ipfeature.delete_ip_interface(dut1,
interface_name=r1_tg_ports1,
ip_address=r1tg1_1_ipv6Addr,
subnet=subnetMaskv6,
family="ipv6")
ipfeature.delete_ip_interface(dut1,
interface_name=r1_tg_ports2,
ip_address=r1tg2_1_ipv6Addr,
subnet=subnetMaskv6,
family="ipv6")
port.shutdown(dut1, [r1_tg_ports1, r1_tg_ports2])