def static_route_verify():
st.log("Ip address configuration verification")
if not poll_wait(ip_obj.verify_interface_ip_address,
60,
vars.D1,
vars.D1T1P1,
"{}/{}".format(data.ipv4_address, data.mask),
family="ipv4"):
st.report_fail("ip_routing_int_create_fail", vars.D1T1P1)
else:
st.log("Successfully added ipv4 address on TGen connected interface")
st.log("static route configuration verification")
if not poll_wait(ip_obj.verify_ip_route,
60,
vars.D1,
"ipv4",
ip_address=data.ipv4_address_network,
type="S"):
st.error("Static route - {} information not exists.".format(
data.ipv4_address_network))
st.report_fail("ip_static_route_create_fail",
data.ipv4_address_network)
else:
st.log("creation of static route is successful")
def test_mgmt_vrf_static_dhcp():
config_ip_addr_interface(vars.D1, "eth0", mgmt_vrf.staticip, 20,
mgmt_vrf.af_ipv4)
if not poll_wait(verify_interface_ip_address,
10,
vars.D1,
"eth0",
mgmt_vrf.staticip + '/20',
family="ipv4",
vrfname='mgmt'):
st.log("IP Address not matched")
delete_ip_interface(vars.D1, "eth0", mgmt_vrf.staticip, 20,
mgmt_vrf.af_ipv4)
st.report_fail("mgmt_vrf_static_dhcp", "failed")
output = get_ifconfig(vars.D1, "eth0")
if output[0]['broadcast'][0] == '0.0.0.0':
st.log("Broadcast IP address not assigned")
delete_ip_interface(vars.D1, "eth0", mgmt_vrf.staticip, 20,
mgmt_vrf.af_ipv4)
st.report_fail("test_case_failed")
delete_ip_interface(vars.D1, "eth0", mgmt_vrf.staticip, 20,
mgmt_vrf.af_ipv4)
if not poll_wait(get_ifconfig_inet, 30, vars.D1, 'eth0'):
st.log("IP Address not assigned to eth0 after dhcp")
st.report_fail("mgmt_vrf_static_dhcp", "failed")
st.report_pass("mgmt_vrf_static_dhcp", "successful")
def test_mgmt_vrf_tacacs():
tacacs_params = st.get_service_info(vars.D1, "tacacs")
if not set_aaa_authentication_properties(vars.D1, 'failthrough', 'enable'):
st.report_fail("authentication failthrough config fail")
set_tacacs_server(vars.D1,
'add',
tacacs_params.hosts[0].ip,
tacacs_params.hosts[0].tcp_port,
tacacs_params.hosts[0].timeout,
tacacs_params.hosts[0].passkey,
tacacs_params.hosts[0].auth_type,
tacacs_params.hosts[0].priority,
use_mgmt_vrf=True)
if not verify_tacacs_server(
vars.D1, tacacs_params.hosts[0].ip,
tacacs_params.hosts[0].tcp_port, tacacs_params.hosts[0].timeout,
tacacs_params.hosts[0].passkey, tacacs_params.hosts[0].auth_type,
tacacs_params.hosts[0].priority):
st.report_fail("Tacacs_server_configs_are_not_successful",
tacacs_params.hosts[0].ip)
set_aaa_authentication_properties(vars.D1, 'login', 'tacacs+ local')
ip_addr = get_ifconfig_inet(vars.D1, 'eth0')
if not ip_addr:
st.report_fail('ip_verification_fail')
if not poll_wait(connect_to_device, 10, ip_addr[0], mgmt_vrf.tacusername,
mgmt_vrf.tacpassword, mgmt_vrf.protocol,
mgmt_vrf.ssh_port):
tacacs_cleanup(vars.D1, tacacs_params)
st.report_fail("mgmt_vrf_tacacs", "failed")
tacacs_cleanup(vars.D1, tacacs_params)
st.report_pass("mgmt_vrf_tacacs", "successful")
def test_ft_erspan_portchannel_shut_noshut():
"""
Author: Kanala Ramprakash Reddy ( [email protected])
TC1 FtOpSoSyErspanFn020: Verify that ERSPAN is working as expected after portchannel shut/no shut.
:return:
"""
st.log("############### Test started to check ERSPAN status between multiple link flaps###############")
st.log("Creating mirror session")
mirror.create_session(vars.D1, session_name=data.mirror_session, gre_type=data.gre_type, dscp=data.dscp,
ttl=data.ttl, queue=data.queue, src_ip=data.ip_T1D1P2, dst_ip=data.ip_T1D2P1)
st.log("Creating ACL Policy")
acl_dscp.config_classifier_table(vars.D1, enable='create', match_type="fields", class_name=data.acl_rule)
acl_dscp.config_classifier_table(vars.D1, enable='yes', class_criteria="--src-ip", class_name=data.acl_rule,
criteria_value=data.src_ip_mask, match_type="fields")
acl_dscp.config_flow_update_table(vars.D1, policy_name=data.acl_table_name, flow='add', policy_type=data.type,
class_name=data.acl_rule, priority_value=data.priority,
description=data.description)
acl_dscp.config_flow_update_table(vars.D1, policy_name=data.acl_table_name, flow='update', policy_type=data.type,
class_name=data.acl_rule, priority_option='--mirror-session',
priority_value=data.mirror_action)
stream = data.tg1.tg_traffic_config(port_handle=data.tg_ph_1, mode='create', transmit_mode='continuous', length_mode='fixed',
rate_pps=data.rate_pps, l2_encap='ethernet_ii', mac_src='00:0a:01:00:00:01',
mac_dst=dut_mac, l3_protocol="ipv4", ip_src_addr=data.ip_T1D1P1,
ip_dst_addr=data.ip_T1D1P2)['stream_id']
intf_obj.clear_interface_counters(vars.D1)
st.log("Starting the traffic")
data.tg1.tg_traffic_control(action='run', stream_handle=stream)
for _ in range(5):
intf_obj.interface_shutdown(vars.D1, [vars.D1D2P1], skip_verify=True)
if not poll_wait(mirror.verify_session_all, 20, vars.D1, mirror_type="erspan", status="inactive",
session_name=data.mirror_session):
st.error("Mirror session status should be inactive after port shutdown")
data.flag = 0
intf_obj.interface_noshutdown(vars.D1, [vars.D1D2P1], skip_verify=True)
if not poll_wait(mirror.verify_session_all, 20, vars.D1, mirror_type="erspan", status="active",
session_name=data.mirror_session):
st.error("Mirror session status should be active after port startup")
data.flag = 0
data.tg1.tg_traffic_control(action='stop', stream_handle=stream)
if data.flag == 0:
st.report_fail("test_case_failed")
else:
st.report_pass("test_case_passed")
def bgp_confed_pre_config():
st.banner("BGP CONFED CLASS CONFIG - START")
bgp4nodelib.l3tc_vrfipv4v6_confed_bgp_config(config='yes')
# BGP Neighbour Verification
if not poll_wait(bgp4nodelib.l3tc_vrfipv4v6_address_confed_bgp_check,
10,
config_type='all'):
st.error("Neighbour is failed to Establish between DUTs")
st.report_fail('test_case_failed')
st.log(
"Getting all topology info related to connectivity / TG and other parameters between duts"
)
st.banner("BGP CONFED CLASS CONFIG - END")
def test_ft_tacacs_modify_server_parameters():
"""
Author: Karthik Kumar Goud Battula([email protected])
This Testcase covers the below scenarios
Scenario-1: Verify device behavior when TACACS+ application parameters (valid and invalid) are modified while traffic is running.
Scenario-2: Verify that the key and timeout options default to global but may be specified to unique values on a per Server basis.
Scenario-3: Verify that the NAS will stop communicating with the current server is the server is down after the duration of the configured server timeout or the default timeout value
Scenario-4: Verify that Taccacs server key can be configured with more that 4 special characters
"""
invalid_l4_port = '59'
invalid_pass_key = "key123"
invalid_timeout = '10'
invalid_ip_addr = '10.10.10.1'
tacacs_params = st.get_service_info(vars.D1, "tacacs")
tacacs_obj.set_tacacs_server(vars.D1, 'delete', tacacs_params.hosts[2].ip)
tacacs_obj.set_tacacs_properties(vars.D1, 'passkey', 'secretstring')
st.log("Configuring global tacacs server key with special characters")
tacacs_obj.set_tacacs_properties(vars.D1, 'passkey', data.passkey)
st.log(
"Check client authentication by modifing ip address,timeout,passkey")
tacacs_obj.set_tacacs_server(vars.D1, 'add', invalid_ip_addr,
invalid_l4_port, invalid_timeout,
invalid_pass_key, data.auth_type,
data.priority_server2)
st.log(
"Trying to SSH to the device when TACACS+ server is configured with invalid parameters"
)
if ssh_obj.connect_to_device(data.ip_address, data.username, data.password,
data.protocol, data.ssh_port):
st.log(
"Deleting the TACACS+ server which is invalid for failed scenario")
tacacs_obj.set_tacacs_server(vars.D1, 'delete', invalid_ip_addr)
st.report_fail("Login_to_DUT_via_SSH_is_failed")
st.log("Deleting the TACACS+ server which is invalid")
tacacs_obj.set_tacacs_server(vars.D1, 'delete', invalid_ip_addr)
st.log("Creating valid TACACS+ server")
tacacs_obj.set_tacacs_server(vars.D1, 'add', data.tacacs_ser_ip_1,
data.tcp_port, data.timeout, data.passkey,
data.auth_type, data.priority)
st.wait(2, "sync the tacacs server after config changes")
st.log(
"Trying to SSH to the device with TACACS+ server which is configured with the valid parameters"
)
if not poll_wait(ssh_obj.connect_to_device, 10, data.ip_address,
data.username, data.password, data.protocol,
data.ssh_port):
debug_info("test_ft_tacacs_modify_server_parameters",
data.tacacs_ser_ip_1)
st.report_fail("Login_to_DUT_via_SSH_is_failed")
st.report_pass("test_case_passed")
def mgmt_vrf_prolog():
global vars
vars = st.ensure_min_topology("D1")
ip = mutils.ensure_service_params(vars.D1, "chef", "ip")
username = mutils.ensure_service_params(vars.D1, "chef", "username")
password = mutils.ensure_service_params(vars.D1, "chef", "password")
st.log("Setting the date on DUT")
if not sync_with_server_time(vars.D1, ip, username, password):
st.log("Failed to set time")
st.wait(mgmt_vrf.wait_time)
mvrf.config(vars.D1)
enable_ssh_in_user_vrf(vars.D1, config='add', vrf_name='mgmt')
if not poll_wait(get_ifconfig_inet, 30, vars.D1, 'eth0'):
st.log("IP Address not assigned to eth0 after prologue")
mgmt_vrf_epilog()
st.report_fail("mgmt_vrf_eth0_bind_fail")
def test_ft_bgp_rst001():
# """
# Validate the BGP IPv4 neighborship when configured through REST
# :return:
# """
[out, exceptions] = exec_all(True, [[config_bgp_router_rst, vars.D1, bgp_rst_data.dut1_asn, "add"], \
[config_bgp_router_rst, vars.D2, bgp_rst_data.dut2_asn, "add"]])
ensure_no_exception(exceptions)
for each in out:
if not each:
st.report_fail("bgp_router_create_delete", "Creation", "REST",
"FAILED")
st.wait(5)
dut1_data = {
'neigh_ip': bgp_rst_data.dut2_ip_l[0],
'local_asn': bgp_rst_data.dut1_asn,
'remote_asn': bgp_rst_data.dut2_asn,
'peer_type': "EXTERNAL",
'family': "ipv4",
'config': "add"
}
dut2_data = {
'neigh_ip': bgp_rst_data.dut1_ip_l[0],
'local_asn': bgp_rst_data.dut2_asn,
'remote_asn': bgp_rst_data.dut1_asn,
'peer_type': "EXTERNAL",
'family': "ipv4",
'config': "add"
}
exec_parallel(True, [vars.D1, vars.D2], config_bgp_neighbor_rst,
[dut1_data, dut2_data])
for each in out:
if not each:
st.report_fail("bgp_neighbor_create_delete", "v4", "Creation",
"REST", "FAILED")
if not poll_wait(verify_bgp_neighbor_rst, 60, vars.D1,
bgp_rst_data.dut2_ip_l[0]):
st.report_fail("bgp_neighbor_create_delete", "v4", "Creation", "REST",
"FAILED")
[out, exceptions] = exec_all(True, [[bgp_neighbor_del_rst, vars.D1, bgp_rst_data.dut2_ip_l[0]] , \
[bgp_neighbor_del_rst, vars.D2, bgp_rst_data.dut1_ip_l[0]]])
ensure_no_exception(exceptions)
for each in out:
if not each:
st.report_fail("bgp_neighbor_create_delete", "v4", "Delrtion",
"REST", "FAILED")
st.report_pass("bgp_neighbor_status", "v4", "Successful", "REST")
def config_ntp_server_on_config_db_file(dut, iplist):
st.log("Configuring NTP servers in Config_db file")
add_ntp_servers(dut, iplist=iplist)
st.log("verifying ntp service status")
if verify_ntp_service_status(vars.D1, 'active (running)'):
st.log("ntpd is running")
else:
st.log("ntpd is exited and restarting ntp service")
service_operations(vars.D1, 'ntp', action="restart")
if not poll_wait(
verify_ntp_server_details, 300, dut, iplist, remote=iplist):
st.log("ip not matching")
st.report_fail("operation_failed")
if not verify_ntp_service_status(
dut, 'active (running)', iteration=65, delay=2):
st.log("ntp is exited")
st.report_fail("operation_failed")
def mirror_action_config():
mirror_args = {
"session_name": data.session_name,
"gre_type": data.gre_type,
"dscp": data.dscp,
"ttl": data.ttl,
"queue": data.queue,
"src_ip": data.source_ip,
"dst_ip": data.destination_ip
}
retval = mirror.create_session_table(vars.D1, **mirror_args)
if not retval:
st.log("Failed to create mirror session using json file.")
st.report_fail("operation_failed")
if not poll_wait(sconf_obj.verify_running_config, 60, vars.D1,
"MIRROR_SESSION", "Mirror_Ses", "dst_ip", "15.1.1.2"):
st.log("Failed to show mirror session details in running config.")
st.report_fail("operation_failed")
def mirror_action_verify():
mirror_args = {
"session_name": data.session_name,
"gre_type": data.gre_type,
"dscp": data.dscp,
"ttl": data.ttl,
"queue": data.queue,
"src_ip": data.source_ip,
"dst_ip": data.destination_ip
}
if not mirror.verify_session(vars.D1, **mirror_args):
st.log("failed to show mirror session details after reboot.")
st.report_fail("operation_failed")
if not poll_wait(sconf_obj.verify_running_config, 60, vars.D1,
"MIRROR_SESSION", "Mirror_Ses", "dst_ip", "15.1.1.2"):
st.log(
"failed to show mirror session details in running config after reboot."
)
st.report_fail("operation_failed")
def test_ft_bgp_rst003():
[_, exceptions] = exec_all(True, [
[config_interface_ip6_link_local, vars.D1, [vars.D1D2P1]], \
[config_interface_ip6_link_local, vars.D2, [vars.D2D1P1]]])
ensure_no_exception(exceptions)
dut1_data = {
'neigh_ip': vars.D1D2P1,
'local_asn': bgp_rst_data.dut1_asn,
'remote_asn': bgp_rst_data.dut2_asn,
'peer_type': "EXTERNAL",
'family': "ipv6",
'config': "add"
}
dut2_data = {
'neigh_ip': vars.D2D1P1,
'local_asn': bgp_rst_data.dut2_asn,
'remote_asn': bgp_rst_data.dut1_asn,
'peer_type': "EXTERNAL",
'family': "ipv6",
'config': "add"
}
[out, exceptions] = exec_parallel(True, [vars.D1, vars.D2],
config_bgp_neighbor_rst,
[dut1_data, dut2_data])
ensure_no_exception(exceptions)
for each in out:
if not each:
st.report_fail("bgp_neighbor_create_delete", "v6", "Creation",
"REST", "FAILED")
if not poll_wait(verify_bgp_neighbor_rst, 60, vars.D1, vars.D1D2P1):
st.report_fail("bgp_neighbor_create_delete", "v6", "Creation", "REST",
"FAILED")
[out, exceptions] = exec_all(True, [[bgp_neighbor_del_rst, vars.D1, vars.D2D1P1], \
[bgp_neighbor_del_rst, vars.D2, vars.D1D2P1]])
ensure_no_exception(exceptions)
for each in out:
if not each:
st.report_fail("bgp_neighbor_create_delete", "v6", "Delrtion",
"REST", "FAILED")
st.report_pass("bgp_neighbor_status", "v6", "Successful", "REST")
def test_ft_bgp_rst004():
dut1_data = {
'neigh_ip': "Vlan{}".format(bgp_rst_data.vlan_id[0]),
'local_asn': bgp_rst_data.dut1_asn,
'remote_asn': bgp_rst_data.dut2_asn,
'peer_type': "EXTERNAL",
'family': "ipv6",
'config': "add"
}
dut2_data = {
'neigh_ip': "Vlan{}".format(bgp_rst_data.vlan_id[0]),
'local_asn': bgp_rst_data.dut2_asn,
'remote_asn': bgp_rst_data.dut1_asn,
'peer_type': "EXTERNAL",
'family': "ipv6",
'config': "add"
}
[out, exceptions] = exec_parallel(True, [vars.D1, vars.D2],
config_bgp_neighbor_rst,
[dut1_data, dut2_data])
ensure_no_exception(exceptions)
for each in out:
if not each:
st.report_fail("bgp_neighbor_create_delete", "v6", "Creation",
"REST", "FAILED")
if not poll_wait(verify_bgp_neighbor_rst, 60, vars.D1, "Vlan{}".format(
bgp_rst_data.vlan_id[0])):
st.report_fail("bgp_neighbor_create_delete", "v6", "Creation", "REST",
"FAILED")
[out, exceptions] = exec_all(True, [[bgp_neighbor_del_rst, vars.D1, "Vlan{}".format(bgp_rst_data.vlan_id[0])], \
[bgp_neighbor_del_rst, vars.D2, "Vlan{}".format(bgp_rst_data.vlan_id[0])]])
ensure_no_exception(exceptions)
for each in out:
if not each:
st.report_fail("bgp_neighbor_create_delete", "v6", "Delrtion",
"REST", "FAILED")
st.report_pass("bgp_neighbor_status", "v6", "Successful", "REST")
def l3_performance_enhancements_module_hooks(request):
global vars
global tg_handler
global tg
global dut1
global dut2
global dut3
global dut4
global dut1_to_tg_port_1
global dut1_to_dut2_port_1
global dut2_to_dut1_port_1
global dut1_to_dut3_port_1
global dut3_to_dut1_port_1
global dut2_to_dut4_port_1
global dut4_to_dut2_port_1
global dut3_to_dut4_port_1
global dut4_to_dut3_port_1
global dut4_to_tg_port_1
global hwsku_under_test1
global hwsku_under_test2
global hwsku_under_test3
global hwsku_under_test4
global def_v4_route_count_d1
global def_v4_route_count_d4
global def_v6_route_count_d1
global def_v6_route_count_d4
# Min topology verification
st.log("Ensuring minimum topology")
vars = st.ensure_min_topology("D1D2:1", "D1D3:1", "D2D4:1", "D3D4:1", "D1T1:1", "D4T1:1")
# Initialize TG and TG port handlers
tg_handler = tgapi.get_handles(vars, [vars.T1D1P1, vars.T1D4P1])
tg = tg_handler["tg"]
# Test setup details
dut1 = vars.D1
dut2 = vars.D2
dut3 = vars.D3
dut4 = vars.D4
dut1_to_tg_port_1 = vars.D1T1P1
dut1_to_dut2_port_1 = vars.D1D2P1
dut2_to_dut1_port_1 = vars.D2D1P1
dut1_to_dut3_port_1 = vars.D1D3P1
dut3_to_dut1_port_1 = vars.D3D1P1
dut2_to_dut4_port_1 = vars.D2D4P1
dut4_to_dut2_port_1 = vars.D4D2P1
dut3_to_dut4_port_1 = vars.D3D4P1
dut4_to_dut3_port_1 = vars.D4D3P1
dut4_to_tg_port_1 = vars.D4T1P1
hwsku_under_test1 = basic_obj.get_hwsku(dut1)
hwsku_under_test2 = basic_obj.get_hwsku(dut2)
hwsku_under_test3 = basic_obj.get_hwsku(dut3)
hwsku_under_test4 = basic_obj.get_hwsku(dut4)
# Module Configuration
st.log("L3 Performance Enhancements Module Configuration.")
# Configuring v4/v6 routing interfaces on the DUT.
st.log("Configuring IPv4 routing interfaces.")
ipfeature.config_ip_addr_interface(dut1, dut1_to_tg_port_1, data.dut1_to_tg_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut1, dut1_to_dut2_port_1, data.dut1_to_dut2_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut1, dut1_to_dut3_port_1, data.dut1_to_dut3_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut2, dut2_to_dut1_port_1, data.dut2_to_dut1_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut2, dut2_to_dut4_port_1, data.dut2_to_dut4_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut3, dut3_to_dut1_port_1, data.dut3_to_dut1_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut3, dut3_to_dut4_port_1, data.dut3_to_dut4_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut4, dut4_to_dut2_port_1, data.dut4_to_dut2_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut4, dut4_to_dut3_port_1, data.dut4_to_dut3_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut4, dut4_to_tg_port_1, data.dut4_to_tg_port_1_ip, data.ip_prefixlen, family="ipv4")
st.log("Configuring IPv6 routing interfaces.")
ipfeature.config_ipv6(dut1, action='enable')
ipfeature.config_ip_addr_interface(dut1, dut1_to_tg_port_1, data.dut1_to_tg_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ip_addr_interface(dut1, dut1_to_dut2_port_1, data.dut1_to_dut2_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ip_addr_interface(dut1, dut1_to_dut3_port_1, data.dut1_to_dut3_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ipv6(dut2, action='enable')
ipfeature.config_ip_addr_interface(dut2, dut2_to_dut1_port_1, data.dut2_to_dut1_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ip_addr_interface(dut2, dut2_to_dut4_port_1, data.dut2_to_dut4_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ipv6(dut3, action='enable')
ipfeature.config_ip_addr_interface(dut3, dut3_to_dut1_port_1, data.dut3_to_dut1_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ip_addr_interface(dut3, dut3_to_dut4_port_1, data.dut3_to_dut4_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ipv6(dut4, action='enable')
ipfeature.config_ip_addr_interface(dut4, dut4_to_dut2_port_1, data.dut4_to_dut2_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ip_addr_interface(dut4, dut4_to_dut3_port_1, data.dut4_to_dut3_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ip_addr_interface(dut4, dut4_to_tg_port_1, data.dut4_to_tg_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
# Configuring BGP router and v4/v6 neighbors on the DUT.
st.log("Configuring BGP routers.")
bgpfeature.create_bgp_router(dut1, data.as_num_1, '')
bgpfeature.create_bgp_router(dut2, data.as_num_2, '')
bgpfeature.create_bgp_router(dut3, data.as_num_3, '')
bgpfeature.create_bgp_router(dut4, data.as_num_4, '')
st.log("Configuring BGP IPv4 neighbors.")
bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.tg_to_dut1_port_1_ip, data.remote_as_num1)
bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.dut2_to_dut1_port_1_ip, data.as_num_2)
bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.dut3_to_dut1_port_1_ip, data.as_num_3)
bgpfeature.create_bgp_neighbor(dut2, data.as_num_2, data.dut1_to_dut2_port_1_ip, data.as_num_1)
bgpfeature.create_bgp_neighbor(dut2, data.as_num_2, data.dut4_to_dut2_port_1_ip, data.as_num_4)
bgpfeature.create_bgp_neighbor(dut3, data.as_num_3, data.dut1_to_dut3_port_1_ip, data.as_num_1)
bgpfeature.create_bgp_neighbor(dut3, data.as_num_3, data.dut4_to_dut3_port_1_ip, data.as_num_4)
bgpfeature.create_bgp_neighbor(dut4, data.as_num_4, data.dut2_to_dut4_port_1_ip, data.as_num_2)
bgpfeature.create_bgp_neighbor(dut4, data.as_num_4, data.dut3_to_dut4_port_1_ip, data.as_num_3)
st.log("Configuring BGP IPv6 neighbors.")
bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.tg_to_dut1_port_1_ip6, data.remote_as_num1, family="ipv6")
bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.dut2_to_dut1_port_1_ip6, data.as_num_2, family="ipv6")
bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.dut3_to_dut1_port_1_ip6, data.as_num_3, family="ipv6")
bgpfeature.create_bgp_neighbor(dut2, data.as_num_2, data.dut1_to_dut2_port_1_ip6, data.as_num_1, family="ipv6")
bgpfeature.create_bgp_neighbor(dut2, data.as_num_2, data.dut4_to_dut2_port_1_ip6, data.as_num_4, family="ipv6")
bgpfeature.create_bgp_neighbor(dut3, data.as_num_3, data.dut1_to_dut3_port_1_ip6, data.as_num_1, family="ipv6")
bgpfeature.create_bgp_neighbor(dut3, data.as_num_3, data.dut4_to_dut3_port_1_ip6, data.as_num_4, family="ipv6")
bgpfeature.create_bgp_neighbor(dut4, data.as_num_4, data.dut2_to_dut4_port_1_ip6, data.as_num_2, family="ipv6")
bgpfeature.create_bgp_neighbor(dut4, data.as_num_4, data.dut3_to_dut4_port_1_ip6, data.as_num_3, family="ipv6")
# st.log("Configuring BGP as-path multipath-relax.")
bgpfeature.create_bgp_best_path(dut1, data.as_num_1, "as-path multipath-relax")
bgpfeature.create_bgp_best_path(dut2, data.as_num_2, "as-path multipath-relax")
bgpfeature.create_bgp_best_path(dut3, data.as_num_3, "as-path multipath-relax")
bgpfeature.create_bgp_best_path(dut4, data.as_num_4, "as-path multipath-relax")
# Get the default route count from DUT
def_v4_route_count_d1 = asicapi.bcmcmd_route_count_hardware(dut1)
def_v4_route_count_d4 = asicapi.bcmcmd_route_count_hardware(dut4)
def_v6_route_count_d1 = asicapi.bcmcmd_ipv6_route_count_hardware(dut1)
def_v6_route_count_d4 = asicapi.bcmcmd_ipv6_route_count_hardware(dut4)
# Verifying the BGP neighborship
st.wait(20)
st.log("Verifying the BGP IPv4 neighborships.")
if not poll_wait(bgpfeature.verify_bgp_summary, 120, dut1, neighbor=data.dut2_to_dut1_port_1_ip,state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut1_port_1_ip)
if not poll_wait(bgpfeature.verify_bgp_summary, 120, dut1, neighbor=data.dut3_to_dut1_port_1_ip,state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut1_port_1_ip)
if not poll_wait(bgpfeature.verify_bgp_summary, 120, dut2, neighbor=data.dut1_to_dut2_port_1_ip,state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut2_port_1_ip)
if not poll_wait(bgpfeature.verify_bgp_summary, 120, dut2, neighbor=data.dut4_to_dut2_port_1_ip,state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut2_port_1_ip)
# if not bgpfeature.verify_bgp_summary(dut1, neighbor=data.dut2_to_dut1_port_1_ip, state='Established'):
# st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut1_port_1_ip)
# if not bgpfeature.verify_bgp_summary(dut1, neighbor=data.dut3_to_dut1_port_1_ip, state='Established'):
# st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut1_port_1_ip)
# if not bgpfeature.verify_bgp_summary(dut2, neighbor=data.dut1_to_dut2_port_1_ip, state='Established'):
# st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut2_port_1_ip)
# if not bgpfeature.verify_bgp_summary(dut2, neighbor=data.dut4_to_dut2_port_1_ip, state='Established'):
# st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut2_port_1_ip)
if not bgpfeature.verify_bgp_summary(dut3, neighbor=data.dut1_to_dut3_port_1_ip, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut3_port_1_ip)
if not bgpfeature.verify_bgp_summary(dut3, neighbor=data.dut4_to_dut3_port_1_ip, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut3_port_1_ip)
if not bgpfeature.verify_bgp_summary(dut4, neighbor=data.dut2_to_dut4_port_1_ip, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut4_port_1_ip)
if not bgpfeature.verify_bgp_summary(dut4, neighbor=data.dut3_to_dut4_port_1_ip, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut4_port_1_ip)
st.log("Verifying the BGP IPv6 neighborships.")
if not bgpfeature.verify_bgp_summary(dut1, family='ipv6', neighbor=data.dut2_to_dut1_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut1_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut1, family='ipv6', neighbor=data.dut3_to_dut1_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut1_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut2, family='ipv6', neighbor=data.dut1_to_dut2_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut2_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut2, family='ipv6', neighbor=data.dut4_to_dut2_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut2_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut3, family='ipv6', neighbor=data.dut1_to_dut3_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut3_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut3, family='ipv6', neighbor=data.dut4_to_dut3_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut3_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut4, family='ipv6', neighbor=data.dut2_to_dut4_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut4_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut4, family='ipv6', neighbor=data.dut3_to_dut4_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut4_port_1_ip6)
yield
# Module Cleanup
st.log("L3 Performance Enhancements Module Cleanup.")
st.log("Unconfiguring IPv4 routing interfaces.")
ipfeature.delete_ip_interface(dut1, dut1_to_tg_port_1, data.dut1_to_tg_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut1, dut1_to_dut2_port_1, data.dut1_to_dut2_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut1, dut1_to_dut3_port_1, data.dut1_to_dut3_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut2, dut2_to_dut1_port_1, data.dut2_to_dut1_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut2, dut2_to_dut4_port_1, data.dut2_to_dut4_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut3, dut3_to_dut1_port_1, data.dut3_to_dut1_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut3, dut3_to_dut4_port_1, data.dut3_to_dut4_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut4, dut4_to_dut2_port_1, data.dut4_to_dut2_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut4, dut4_to_dut3_port_1, data.dut4_to_dut3_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut4, dut4_to_tg_port_1, data.dut4_to_tg_port_1_ip, data.ip_prefixlen, family="ipv4")
st.log("Unconfiguring IPv6 routing interfaces.")
ipfeature.delete_ip_interface(dut1, dut1_to_tg_port_1, data.dut1_to_tg_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut1, dut1_to_dut2_port_1, data.dut1_to_dut2_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut1, dut1_to_dut3_port_1, data.dut1_to_dut3_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut2, dut2_to_dut1_port_1, data.dut2_to_dut1_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut2, dut2_to_dut4_port_1, data.dut2_to_dut4_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut3, dut3_to_dut1_port_1, data.dut3_to_dut1_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut3, dut3_to_dut4_port_1, data.dut3_to_dut4_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut4, dut4_to_dut2_port_1, data.dut4_to_dut2_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut4, dut4_to_dut3_port_1, data.dut4_to_dut3_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut4, dut4_to_tg_port_1, data.dut4_to_tg_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
st.log("Unconfiguring BGP IPv4 neighbors.")
bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.tg_to_dut1_port_1_ip, data.remote_as_num1)
bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.dut2_to_dut1_port_1_ip, data.as_num_2)
bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.dut3_to_dut1_port_1_ip, data.as_num_3)
bgpfeature.delete_bgp_neighbor(dut2, data.as_num_2, data.dut1_to_dut2_port_1_ip, data.as_num_1)
bgpfeature.delete_bgp_neighbor(dut2, data.as_num_2, data.dut4_to_dut2_port_1_ip, data.as_num_4)
bgpfeature.delete_bgp_neighbor(dut3, data.as_num_3, data.dut1_to_dut3_port_1_ip, data.as_num_1)
bgpfeature.delete_bgp_neighbor(dut3, data.as_num_3, data.dut4_to_dut3_port_1_ip, data.as_num_4)
bgpfeature.delete_bgp_neighbor(dut4, data.as_num_4, data.dut2_to_dut4_port_1_ip, data.as_num_2)
bgpfeature.delete_bgp_neighbor(dut4, data.as_num_4, data.dut3_to_dut4_port_1_ip, data.as_num_3)
st.log("Unconfiguring BGP IPv6 neighbors.")
bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.tg_to_dut1_port_1_ip6, data.remote_as_num1)
bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.dut2_to_dut1_port_1_ip6, data.as_num_2)
bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.dut3_to_dut1_port_1_ip6, data.as_num_3)
bgpfeature.delete_bgp_neighbor(dut2, data.as_num_2, data.dut1_to_dut2_port_1_ip6, data.as_num_1)
bgpfeature.delete_bgp_neighbor(dut2, data.as_num_2, data.dut4_to_dut2_port_1_ip6, data.as_num_4)
bgpfeature.delete_bgp_neighbor(dut3, data.as_num_3, data.dut1_to_dut3_port_1_ip6, data.as_num_1)
bgpfeature.delete_bgp_neighbor(dut3, data.as_num_3, data.dut4_to_dut3_port_1_ip6, data.as_num_4)
bgpfeature.delete_bgp_neighbor(dut4, data.as_num_4, data.dut2_to_dut4_port_1_ip6, data.as_num_2)
bgpfeature.delete_bgp_neighbor(dut4, data.as_num_4, data.dut3_to_dut4_port_1_ip6, data.as_num_3)
st.log("Unconfiguring BGP routers.")
bgpfeature.cleanup_router_bgp(dut1)
bgpfeature.cleanup_router_bgp(dut2)
bgpfeature.cleanup_router_bgp(dut3)
bgpfeature.cleanup_router_bgp(dut4)
def test_ft_vlan_save_config_warm_and_fast_reboot():
'''
Author: Sai Durga <*****@*****.**>
This script covers the below scenarios
ft_max_vlan_save_reload Verify the save and reload functionality with max vlan configuration.
ft_max_vlan_fast_reload Verify the max vlan configuration is retained after fast-reboot.
FtOpSoSwVlFn026 Verify that VLAN is present and traffic is not disturbed during and after warm reboot
FtOpSoSysFRFn005 Verify the Fast-Reboot must disrupt control plane not more than 90 seconds (from sonic test suite -configuration tests)
ft_reboot_fdb_fast_reboot Verify that the FDB entry is retained after fast reboot.
'''
status = True
msg_id = "max_vlan_config_retain_after_save_fast_warm_reboot"
vlan_module_epilog()
vlan_module_config(config='yes')
st.log("Device name is : {}".format(sc_data.dut_platform))
st.log("Saving the MAX VLAN config on the device")
reboot.config_save(vars.D1)
st.log("Performing reboot and checking the VLAN configuration")
st.reboot(vars.D1)
st.log("Checking VLAN config after reboot")
max_vlan_verify()
st.log(
"Sending traffic with 100 MAC,Checking FDB table updated with 100 MAC addresses and performing reboot and checking the VLAN configuration"
)
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',
length_mode='fixed',
frame_size=72,
mac_src='00:01:00:00:00:01',
mac_src_step='00:00:00:00:00:01',
mac_src_mode='increment',
mac_src_count=sc_data.mac_count,
mac_dst='00:02:00:00:00:02',
rate_pps=2000,
l2_encap='ethernet_ii_vlan',
vlan="enable",
vlan_id=sc_data.vlan,
transmit_mode='continuous')
tg_info['tg1_stream_id'] = tg_1['stream_id']
tg.tg_traffic_control(action='run', stream_handle=tg_info['tg1_stream_id'])
st.wait(2)
tg.tg_traffic_control(action='stop',
stream_handle=tg_info['tg1_stream_id'])
if not poll_wait(mac_verify, 300):
st.error("mac_address_verification_fail")
st.log("Performing fast-reboot and checking the VLAN configuration")
st.reboot(vars.D1, 'fast')
st.log("Checking VLAN config after fast-reboot")
max_vlan_verify()
st.log("Sending traffic after fast reboot and checking the FDB table")
tg.tg_traffic_control(action='run', stream_handle=tg_info['tg1_stream_id'])
st.wait(2)
tg.tg_traffic_control(action='stop',
stream_handle=tg_info['tg1_stream_id'])
if not poll_wait(mac_verify, 300):
st.error("mac_address_verification_fail")
st.log("Performing warm reboot and checking the traffic")
ifapi.clear_interface_counters(vars.D1)
st.wait(2)
ifapi.show_interface_counters_all(vars.D1)
st.wait(2)
tg.tg_traffic_control(action='run', stream_handle=tg_info['tg1_stream_id'])
st.wait(2)
st.reboot(vars.D1, 'warm')
st.log("Checking VLAN config after warm-reboot")
max_vlan_verify()
tg.tg_traffic_control(action='stop',
stream_handle=tg_info['tg1_stream_id'])
st.log("Checking traffic is forwarded without any loss after warm-reboot")
st.log("Fetching TGen statistics")
st.wait(2)
ifapi.show_interface_counters_all(vars.D1)
stats_tg1 = tgapi.get_traffic_stats(tg,
mode="aggregate",
port_handle=tg_handler["tg_ph_1"])
total_tx_tg1 = stats_tg1.tx.total_bytes
stats_tg2 = tgapi.get_traffic_stats(tg,
mode="aggregate",
port_handle=tg_handler["tg_ph_2"])
total_rx_tg2 = stats_tg2.rx.total_bytes
percentage_95_total_tx_tg1 = (95 * int(total_tx_tg1)) / 100
st.log("###############")
st.log("Sent bytes: {} and Received bytes : {}".format(
percentage_95_total_tx_tg1, total_rx_tg2))
st.log("##############")
if int(percentage_95_total_tx_tg1) > int(total_rx_tg2):
st.report_fail("traffic_transmission_failed", vars.T1D1P1)
report_result(status, msg_id)
def poll_wait(method, timeout, *args, **kwargs):
return base.poll_wait(method, timeout, *args, **kwargs)
def config_bgp_topology(config='yes'):
st.banner(
"{}Config BGP on devices".format('Un' if config != 'yes' else ''))
if config == 'yes':
thread_info = list()
thread_info.append(
utils.ExecAllFunc(bgpapi.config_bgp_multi_neigh_use_peergroup,
vars.D1,
local_asn=eh_data.local_asn,
peer_grp_name=eh_data.peer_gp_namev4,
remote_asn=eh_data.remote_asn,
neigh_ip_list=eh_data.ipv4_nbr,
family=eh_data.af_ipv4,
activate=1))
thread_info.append(
utils.ExecAllFunc(bgpapi.config_bgp_multi_neigh_use_peergroup,
vars.D2,
local_asn=eh_data.remote_asn,
peer_grp_name=eh_data.peer_gp_namev4,
remote_asn=eh_data.local_asn,
neigh_ip_list=eh_data.ipv4_addr,
family=eh_data.af_ipv4,
activate=1))
thread_call(thread_info)
thread_info = list()
thread_info.append(
utils.ExecAllFunc(bgpapi.config_bgp_multi_neigh_use_peergroup,
vars.D1,
local_asn=eh_data.local_asn,
peer_grp_name=eh_data.peer_gp_namev6,
remote_asn=eh_data.remote_asn,
neigh_ip_list=eh_data.ipv6_nbr,
family=eh_data.af_ipv6,
activate=1,
routemap=eh_data.route_map_name,
routemap_dir='in'))
thread_info.append(
utils.ExecAllFunc(bgpapi.config_bgp_multi_neigh_use_peergroup,
vars.D2,
local_asn=eh_data.remote_asn,
peer_grp_name=eh_data.peer_gp_namev6,
remote_asn=eh_data.local_asn,
neigh_ip_list=eh_data.ipv6_addr,
family=eh_data.af_ipv6,
activate=1,
routemap=eh_data.route_map_name,
routemap_dir='in'))
thread_call(thread_info)
if config == 'yes':
if not utils.poll_wait(bgpapi.verify_bgp_summary,
30,
vars.D1,
family='ipv4',
neighbor=[eh_data.ipv4_nbr],
state='Established'):
st.error(
"BGP Neighbor failed to Establish between DUT and Partner")
st.report_fail('operation_failed')
if not utils.poll_wait(bgpapi.verify_bgp_summary,
30,
vars.D1,
family='ipv6',
neighbor=[eh_data.ipv6_nbr],
state='Established'):
st.error(
"BGP Neighbor failed to Establish between DUT and Partner")
st.report_fail('operation_failed')
else:
bgpapi.cleanup_router_bgp(st.get_dut_names())
def test_vrf_bgp():
result = 0
###############################################################################################################################
st.log('######------Configure BGP on 100 VRFs-----######')
for vrf, dut1_ip, dut2_ip, dut1_as, dut2_as in zip(
vrf_list[899:1000], data.dut1_dut2_ip_list[899:1000],
data.dut2_dut1_ip_list[899:1000], dut1_as_scale[0:100],
dut2_as_scale[0:100]):
dict1 = {
'vrf_name': vrf,
'router_id': dut1_router_id,
'local_as': dut1_as,
'neighbor': dut2_ip,
'remote_as': dut2_as,
'config_type_list': ['neighbor']
}
dict2 = {
'vrf_name': vrf,
'router_id': dut2_router_id,
'local_as': dut2_as,
'neighbor': dut1_ip,
'remote_as': dut1_as,
'config_type_list': ['neighbor']
}
parallel.exec_parallel(True, [data.dut1, data.dut2],
bgp_api.config_bgp, [dict1, dict2])
dict1 = {
'vrf_name': vrf,
'local_as': dut1_as,
'neighbor': dut2_ip,
'remote_as': dut2_as,
'connect': '3',
'config_type_list': ['activate', 'nexthop_self', 'connect']
}
dict2 = {
'vrf_name': vrf,
'local_as': dut2_as,
'neighbor': dut1_ip,
'remote_as': dut1_as,
'connect': '3',
'config_type_list': ['activate', 'nexthop_self', 'connect']
}
parallel.exec_parallel(True, [data.dut1, data.dut2],
bgp_api.config_bgp, [dict1, dict2])
###############################################################################################################################
st.log('######------Verify the BGP neighbors have come up -----######')
if not utils.poll_wait(ip_bgp.verify_bgp_neighbor,
60,
data.dut1,
neighborip=data.dut2_dut1_ip_list[899],
state='Established',
vrf=vrf_list[899]):
st.log('IPv4 BGP session on VRF-899 did not come up')
result += 1
if not utils.poll_wait(ip_bgp.verify_bgp_neighbor,
60,
data.dut1,
neighborip=data.dut2_dut1_ip_list[950],
state='Established',
vrf=vrf_list[950]):
st.log('IPv4 BGP session on VRF-950 did not come up')
result += 1
###############################################################################################################################
st.log('######------Clear BGP and reverify -----######')
bgp_api.clear_ip_bgp_vrf_vtysh(data.dut1, vrf_list[899], family='ipv4')
st.log('######------Time taken for BGP to come up after clear -----######')
st.wait(10)
if not utils.poll_wait(ip_bgp.verify_bgp_neighbor,
60,
data.dut1,
neighborip=data.dut2_dut1_ip_list[899],
state='Established',
vrf=vrf_list[899]):
st.log('IPv4 BGP session on VRF-899 did not come up')
result += 1
###############################################################################################################################
if result == 0:
st.report_pass('test_case_passed')
else:
st.log('BGP neighborship on 100 VRFs failed')
st.report_fail('test_case_failed')
