def test_ft_bgp_unnumbered_bfd():
utils_obj.banner_log('FtOtSoRtBgpUnFn006')
# ################ Author Details ################
# Name: Kiran Vedula
# Email: [email protected]
# ################################################
result = 0
st.log('######------Enable BFD on unnumbered BGP peers------######')
dict1 = {
'config': 'yes',
'local_asn': data.d1_local_as,
'neighbor_ip': vars.D1D2P1,
'interface': vars.D1D2P1
}
dict2 = {
'config': 'yes',
'local_asn': data.d2_local_as,
'neighbor_ip': vars.D2D1P1,
'interface': vars.D2D1P1
}
parallel.exec_parallel(True, [vars.D1, vars.D2], bfd_obj.configure_bfd,
[dict1, dict2])
if not utils.poll_wait(bfd_obj.verify_bfd_peers_brief,
data.wait_timer,
vars.D2,
peeraddress=d1_prt_link_local[0],
ouraddress=d2_prt_link_local[0],
status="UP"):
st.log("Failed to get BFD status Up")
result += 1
if result == 0:
st.report_pass("test_case_passed")
else:
st.log("BGP unnumbered neighborship failure")
st.report_fail("test_case_failed")
def bgp_rr_traffic_pre_config():
global topo
st.banner("BGP RR WITH TRAFFIC CLASS CONFIG - START")
# underlay config - configure physical interfaces
bgplib.l3tc_underlay_config_unconfig(config='yes')
# config ip on underlay interface
bgplib.l3tc_vrfipv4v6_address_leafspine_config_unconfig(config='yes',
config_type='all')
# Ping Verification
if not bgplib.l3tc_vrfipv4v6_address_leafspine_ping_test(config_type='all',
ping_count=3):
st.error("Ping failed in between Spine - Leaf")
st.report_fail('test_case_failed')
bgplib.l3tc_vrfipv4v6_address_leafspine_rr_tg_bgp_config(config='yes',
rr_enable='true')
bgplib.l3tc_vrfipv4v6_address_leafspine_bgp_config(config='yes',
rr_enable='true')
# BGP Neighbor Verification
if not poll_wait(bgplib.l3tc_vrfipv4v6_address_leafspine_bgp_check,
10,
config_type='all'):
st.error("Neighbour is failed to Establish between Spine - Leaf")
st.report_fail('test_case_failed')
st.log(
"Getting all topology info related to connectivity / TG and other parameters between duts"
)
topo = bgplib.get_leaf_spine_topology_info()
st.banner("BGP RR WITH TRAFFIC CLASS CONFIG - END")
def test_ft_bgp_unnumbered_pc_mem_add_rem():
# ################ Author Details ################
# Name: Kiran Vedula
# Email: [email protected]
# ################################################
utils_obj.banner_log('FtOtSoRtBgpUnFn003,FtOtSoRtBgpUnFn008')
result = 0
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=data.portchannel_name,
state='Established'):
st.log("Failed to form BGP unnumbered peering using IPv6 link local")
result += 1
ip_obj.config_interface_ip6_link_local(vars.D1, data.portchannel_name,
'disable')
pc_obj.add_del_portchannel_member(vars.D1, data.portchannel_name,
[vars.D1D2P3, vars.D1D2P4], 'del')
st.wait(data.wait)
pc_obj.add_del_portchannel_member(vars.D1, data.portchannel_name,
[vars.D1D2P3, vars.D1D2P4], 'add')
ip_obj.config_interface_ip6_link_local(vars.D1, data.portchannel_name,
'enable')
st.wait(data.wait)
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=data.portchannel_name,
state='Established'):
st.log("Failed to form BGP unnumbered peering using IPv6 link local")
result += 1
if result == 0:
st.report_pass("test_case_passed")
else:
st.log(
"BGP unnumbered neighborship failed after PC member del and re-add"
)
st.report_fail("test_case_failed")
def test_ft_ssh_config_reload_docker():
"""
Author : Prudvi Mangadu ([email protected])
"""
result = True
get_docker_ps(vars.D1)
count = get_and_match_docker_count(vars.D1)
ssh_d1 = connect_to_device(st.get_mgmt_ip(vars.D1), ssh_data.usr_default,
ssh_data.pwd_final)
if ssh_d1:
st.log(
"Executing command - 'sudo config reload -y &' in to the SSH session."
)
st.log(execute_command(ssh_d1, 'sudo config reload -y &'))
st.wait(5, 'After executing "config reload" cmd on SSH session.')
st.log("Forcefully disconnecting the SSH session..")
ssh_disconnect(ssh_d1)
else:
st.error('Cannot SSH into Device with default credentials')
st.report_fail("ssh_failed")
if not poll_wait(verify_docker_status, 180, vars.D1, 'Exited'):
st.error(
"Post 'config reload' from SSH, dockers are not auto recovered.")
result = False
if result:
if not poll_wait(get_and_match_docker_count, 180, vars.D1, count):
st.error("Post 'config reload' from SSH, ALL dockers are not UP.")
result = False
if not result:
st.log("Test Failed: So recovering the device by reboot.")
st.reboot(vars.D1)
st.report_fail("test_case_failed")
st.report_pass("test_case_passed")
def test_dhcp_relay_save_reboot():
#################################################
#
# Objective - Configure DHCP relay and verify if the configuration is reatined post reboot.
#
#################################################
st.log("Performing Config save")
rb_obj.config_save(vars.D2)
st.log("Performing Reboot")
st.reboot(vars.D2)
st.log("Verifying DHCP Helper configuration post reboot")
check_dhcp_relay_config()
dhcp_relay_obj.dhcp_client_start(vars.D3, vars.D3D2P1)
if not poll_wait(verify_dhcp_client, 60, vars.D3, vars.D3D2P1):
dhcp_relay_debug(vars.D2, interface="Vlan{}".format(data.vlan))
st.report_fail("dhcp_relay_functionality_tc_status", "IPv4", "failed",
"vlan")
st.log("Verifying DHCP Relay statistics in dhcp client post cold reboot")
check_dhcp_relay_statistics()
st.log(
"Successfully verified DHCP Helper configuration is retained post reboot"
)
st.report_pass("test_case_passed")
def docker_restart_test():
st.log("Performing Config save")
rb_obj.config_save(vars.D2)
#check the docker part
st.log("DHCP relay docker restart")
basic_obj.service_operations_by_systemctl(vars.D2, "dhcp_relay.service",
"restart")
st.log("Wait for DHCP relay docker restart")
if not basic_obj.poll_for_system_status(vars.D2, 'dhcp_relay.service', 120,
3):
st.report_fail("service_not_running", "dhcp-relay")
if not st.poll_wait(basic_obj.verify_service_status, 60, vars.D2,
"dhcp_relay"):
st.report_fail("docker_restart_failed")
st.log("Verifying DHCP Helper configuration post Docker Restart")
check_dhcp_relay_config()
dhcp_relay_obj.dhcp_client_start(vars.D3, vars.D3D2P1)
if not poll_wait(verify_dhcp_client, 60, vars.D3, vars.D3D2P1):
dhcp_relay_debug(vars.D2, interface="Vlan{}".format(data.vlan))
st.report_fail("dhcp_relay_functionality_tc_status", "IPv4", "failed",
"vlan")
st.report_pass("test_case_passed")
def test_ft_bgp_unnumbered_manual_ll():
"""
# ################ Author Details ################
# Name: Sesha Reddy Koilkonda
# Email: [email protected]
# ################################################
:return:
"""
utils_obj.banner_log(
'FtOtSoRtBgpUnFn013,FtOtSoRtBgpUnFn014,FtOtSoRtBgpUnFn015')
result = 0
# Configure the Link-local manually on Dut1 and auto link-local on DUT2 and verify the neighbourship.
bgp_obj.cleanup_router_bgp(st.get_dut_names())
ip_obj.config_ip_addr_interface(vars.D1,
vars.D1D2P1,
data.ip6_addr_manual_ll[0],
96,
family='ipv6')
dict1 = {
'config': 'yes',
'router_id': data.d1_rid,
'addr_family': 'ipv6',
'local_as': data.d1_local_as,
'remote_as': 'external',
'config_type_list': ["remote-as", "activate"],
'interface': vars.D1D2P1,
'neighbor': vars.D1D2P1
}
dict2 = {
'config': 'yes',
'router_id': data.d2_rid,
'addr_family': 'ipv6',
'local_as': data.d2_local_as,
'remote_as': 'external',
'config_type_list': ["remote-as", "activate"],
'interface': vars.D2D1P1,
'neighbor': vars.D2D1P1
}
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.error(
"Failed to form BGP unnumbered peering using IPv6 link local with the Manual-Auto link-local address combination."
)
result += 1
# with the manual link-local on Dut1 and configure the link-local on DUT2 also manually and verify the neighbourship.
bgp_obj.cleanup_router_bgp(st.get_dut_names())
ip_obj.config_ip_addr_interface(vars.D2,
vars.D2D1P1,
data.ip6_addr_manual_ll[1],
96,
family='ipv6')
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.error(
"Failed to form BGP unnumbered peering using IPv6 link local with the manual-manual link-local address combination."
)
result += 1
# update the manual link-local on Dut2 and verify the neighbourship.
bgp_obj.cleanup_router_bgp(st.get_dut_names())
data.ip6_addr_ll3 = 'FE80:0:0:0:204:5FF:FE00:500'
ip_obj.config_ip_addr_interface(vars.D2,
vars.D2D1P1,
data.ip6_addr_manual_ll[2],
96,
family='ipv6')
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.error(
"Failed to form BGP unnumbered peering using IPv6 link local, after uodating the manual link-local address on peer DUT.."
)
result += 1
bgp_obj.cleanup_router_bgp(st.get_dut_names())
ip_obj.config_ip_addr_interface(vars.D1,
vars.D1D2P1,
data.ip6_addr_manual_ll[0],
96,
family='ipv6',
config='remove')
ip_obj.config_ip_addr_interface(vars.D2,
vars.D2D1P1,
data.ip6_addr_manual_ll[1],
96,
family='ipv6',
config='remove')
ip_obj.config_ip_addr_interface(vars.D2,
vars.D2D1P1,
data.ip6_addr_manual_ll[2],
96,
family='ipv6',
config='remove')
if result == 0:
st.report_pass("test_case_passed")
else:
st.error(
"BGP unnumbered neighborship failed with the manual link-local address configuration."
)
st.report_fail("test_case_failed")
def test_ft_chef_config_cli_cmd_recipe():
cookbook = "sonic-cli"
recipe = "recipe[sonic-cli]"
free_ports_samespeed = get_free_ports_speed_list(vars.D1, exclude_list)
if len(free_ports_samespeed) < 8:
st.log(
"Received less than 8 ports in the list of ports, needed a min of 8 ports"
)
st.log("Length is freeports list is:{}".format(
len(free_ports_samespeed)))
st.log("Received free ports same speed list:{}".format(
free_ports_samespeed))
st.report_fail("test_case_failed")
destination_path = "{}{}".format(chef_params.path, chef_params.default_rb)
configuration = {
"vlans": {
"add": {
"10": {
"members": [{
"port": free_ports_samespeed[0],
"tagged": True
}, {
"port": free_ports_samespeed[1],
"tagged": False
}]
},
"40": {
"members": [{
"port": free_ports_samespeed[2],
"tagged": True
}, {
"port": free_ports_samespeed[3],
"tagged": False
}]
}
}
},
"fdbs": {
"add": [{
"mac": "00:00:00:00:00:01",
"vlan_id": 10,
"port": free_ports_samespeed[0]
}, {
"mac": "00:00:00:00:40:01",
"vlan_id": 600,
"port": free_ports_samespeed[1]
}],
"del": [{
"mac": "00:00:00:00:00:01",
"vlan_id": 600,
"port": free_ports_samespeed[2]
}]
},
"lags": {
"add": {
"PortChannel004": {
"links":
[free_ports_samespeed[4], free_ports_samespeed[5]],
"min-links": "2"
},
"PortChannel005": {
"links":
[free_ports_samespeed[6], free_ports_samespeed[7]],
"fallback": True,
"min_links": "2"
}
}
},
"interfaces": {
free_ports_samespeed[1]: {
"admin_status": "up"
},
free_ports_samespeed[2]: {
"admin_status": "up"
}
}
}
commands = ""
#chef_obj.create_chef_cookbook(ssh_conn_obj, chef_params.cookbook_path, cookbook)
commands = chef_obj.chef_execute_cli_commands(configuration)
if commands:
file_path = basic_obj.write_to_text_file(commands)
basic_obj.copy_file_from_client_to_server(ssh_conn_obj,
src_path=file_path,
dst_path=destination_path)
chef_obj.upload_chef_cookbook(ssh_conn_obj, chef_params.cookbook_path,
cookbook)
chef_obj.operations_on_runlist(ssh_conn_obj, "{} ''".format(node_name),
"set")
chef_obj.show_node_run_list(ssh_conn_obj, node_name)
chef_obj.update_node_run_list(ssh_conn_obj, node_name,
"'{}'".format(recipe))
st.log("Running chef client ..")
if not chef_obj.run_chef_client(vars.D1):
st.report_fail("test_case_failed")
st.log("Verifying client file on chef client")
vlan_id = 10
if not utils.poll_wait(portchannel_obj.verify_portchannel_member,
data.poll_wait, vars.D1, "PortChannel005",
free_ports_samespeed[6]):
st.report_fail("operation_failed")
if not utils.poll_wait(mac_obj.verify_mac_address_table, data.poll_wait,
vars.D1, "00:00:00:00:00:01", vlan_id):
st.log("MAC '{}' is failed to learn in port = {}".format(
"00:00:00:00:00:01", free_ports_samespeed[0]))
st.report_fail('mac_address_verification_fail')
if not utils.poll_wait(vlan_obj.verify_vlan_brief, data.poll_wait, vars.D1,
vlan_id):
st.report_fail("operation_failed")
if not utils.poll_wait(intf_obj.verify_interface_status, data.poll_wait,
vars.D1, free_ports_samespeed[1], 'admin', 'up'):
st.report_fail("operation_failed")
chef_obj.operations_on_runlist(ssh_conn_obj, "{} ''".format(node_name),
"set")
st.report_pass("test_case_passed")
def test_ft_chef_config_apply():
role_file = "sonic_dut_1.json"
destination_path = "{}/{}".format(chef_params.roles, role_file)
free_ports = st.get_free_ports(vars.D1)
vlan_list = vlan_obj.get_non_existing_vlan(vars.D1, 1)
vlan_id = vlan_list[0]
vlan_members = [free_ports[0], free_ports[1], free_ports[2]]
vlan_config = {
"VLAN {}".format(vlan_id): {
"vlan_id": vlan_id,
"tagging_mode": "tagged",
"participation_list": vlan_members
}
}
chef_obj.generate_cookbook_json(feature="vlans",
config=vlan_config,
run_list="recipe[sonic::vlan]")
interface_config = {"{}".format(free_ports[2]): {"admin_status": "up"}}
chef_obj.generate_cookbook_json(feature="interfaces",
config=interface_config,
run_list="recipe[sonic::interface]")
fbd_config = {
"FDB 1": {
"mac": "00:00:00:00:00:01",
"vlan_id": vlan_id,
"port": free_ports[0]
},
"FDB 2": {
"mac": "00:11:22:33:44:55",
"vlan_id": vlan_id,
"port": free_ports[1]
}
}
chef_obj.generate_cookbook_json(feature="fdbs",
config=fbd_config,
run_list="recipe[sonic::fdb]")
lag_config = {
"PortChannel500": {
"links": [free_ports_samespeed[0]]
},
"PortChannel900": {
"minimum_links": "2",
"fallback": True,
"links": [free_ports_samespeed[1], free_ports_samespeed[2]]
}
}
chef_obj.generate_cookbook_json(feature="lags",
config=lag_config,
run_list="recipe[sonic::lag]")
file_path = chef_obj.write_cookbook_json()
basic_obj.copy_file_from_client_to_server(ssh_conn_obj,
src_path=file_path,
dst_path=destination_path)
config = SpyTestDict()
config.role_file = role_file
config.vlan_id = vlan_id
config.vlan_members = vlan_members
updating_node_run_list_operations(ssh_conn_obj, node_name, chef_params,
role_file)
run_and_verify_chef_client(vars.D1, chef_params)
if not utils.poll_wait(portchannel_obj.verify_portchannel_member,
data.poll_wait, vars.D1, "PortChannel500",
free_ports_samespeed[0]):
st.report_fail("portchannel_member_verification_failed",
"PortChannel500", vars.D1, free_ports_samespeed[0])
if not utils.poll_wait(portchannel_obj.verify_portchannel_member,
data.poll_wait, vars.D1, "PortChannel900",
free_ports_samespeed[1]):
st.report_fail("portchannel_member_verification_failed",
"PortChanne900", vars.D1, free_ports_samespeed[1])
if not utils.poll_wait(mac_obj.verify_mac_address_table,
data.poll_wait,
vars.D1,
"00:00:00:00:00:01",
port=free_ports[0]):
st.log("MAC '{}' is failed to learn in port = {}".format(
"00:00:00:00:00:01", free_ports[0]))
st.report_fail('mac_address_verification_fail')
if not utils.poll_wait(vlan_obj.verify_vlan_brief, data.poll_wait, vars.D1,
vlan_id):
st.report_fail("operation_failed")
if not utils.poll_wait(intf_obj.verify_interface_status, data.poll_wait,
vars.D1, free_ports[2], 'admin', 'up'):
st.report_fail("operation_failed")
st.report_pass("test_case_passed")
def test_ft_bgp_unnumbered_warmboot():
# ################ Author Details ################
# Name: Kiran Vedula
# Email: [email protected]
# ################################################
utils_obj.banner_log('FtOtSoRtBgpUnFn009')
utils.exec_all(True, [[bgp_obj.show_bgp_ipv6_summary_vtysh, vars.D1],
[bgp_obj.show_bgp_ipv6_summary_vtysh, vars.D2]])
utils.exec_all(
True,
[[arp_obj.show_ndp, vars.D1, None], [arp_obj.show_ndp, vars.D2, None]])
result = 0
st.log('######------Warm reboot with BGP unnumbered------######')
platform = basic_obj.get_hwsku(vars.D1)
common_constants = st.get_datastore(vars.D1, "constants", "default")
if not platform.lower(
) in common_constants['WARM_REBOOT_SUPPORTED_PLATFORMS']:
st.error("Warm-Reboot is not supported for this platform {}".format(
platform))
st.report_unsupported('Warmboot_unsupported_platform', platform)
reboot_obj.config_save(vars.D1, "sonic")
reboot_obj.config_save(vars.D1, "vtysh")
st.reboot(vars.D1, 'warm')
st.wait(data.wait)
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D2,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D2D1P1,
state='Established'):
st.log("Failed to form BGP unnumbered peering after warm reboot")
result += 1
st.wait(data.wait)
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D2,
family='ipv6',
shell=bgp_cli_type,
neighbor=data.vlan_in_1,
state='Established'):
st.log("Failed to form BGP unnumbered peering after warm reboot")
result += 1
st.wait(data.wait)
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D2,
family='ipv6',
shell=bgp_cli_type,
neighbor=data.portchannel_name,
state='Established'):
st.log("Failed to form BGP unnumbered peering after warm reboot")
result += 1
if result == 0:
st.report_pass("test_case_passed")
else:
st.log("BGP unnumbered neighborship failed warm reboot")
utils.exec_all(True, [[arp_obj.show_ndp, vars.D1, None],
[arp_obj.show_ndp, vars.D2, None]])
utils.exec_all(True, [[bgp_obj.show_bgp_ipv6_neighbor_vtysh, vars.D1],
[bgp_obj.show_bgp_ipv6_neighbor_vtysh, vars.D2]])
st.report_fail("test_case_failed")
def test_ft_bgp_unnumbered_peer_basic():
# ################ Author Details ################
# Name: Kiran Vedula
# Email: [email protected]
# ################################################
utils_obj.banner_log(
'FtOtSoRtBgpUnFn001,FtOtSoRtBgpUnFn002,FtOtSoRtBgpUnFn018,FtOtSoRtBgpUnFn019'
)
st.log('######------Configure Unnumbered BGP peers------######')
result = 0
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.log("Failed to form BGP unnumbered peering using IPv6 link local")
result += 1
bgp_obj.config_bgp_neighbor_properties(vars.D1,
data.d1_local_as,
vars.D1D2P1,
family="ipv6",
neighbor_shutdown='',
no_form='')
if utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.log("unnumbered BGP peering is established even after shutdown")
result += 1
bgp_obj.config_bgp_neighbor_properties(vars.D1,
data.d1_local_as,
vars.D1D2P1,
family="ipv6",
neighbor_shutdown='',
no_form='no')
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.log(
"Failed to form BGP unnumbered peering using IPv6 link local after no shutdown"
)
result += 1
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=data.vlan_in_1,
state='Established'):
st.log(
"Failed to form BGP unnumbered peering using IPv6 link local on a VLAN"
)
result += 1
# Get show ndp output
st.log('######------shut/no shut link with unnumbered BGP------######')
utils.exec_all(
True,
[[arp_obj.show_ndp, vars.D1, None], [arp_obj.show_ndp, vars.D2, None]])
intf_obj.interface_operation(vars.D1,
vars.D1D2P1,
operation="shutdown",
skip_verify=True)
st.wait(data.wait)
intf_obj.interface_status_show(vars.D1, vars.D1D2P1)
intf_obj.interface_operation(vars.D1,
vars.D1D2P1,
operation="startup",
skip_verify=True)
st.wait(data.wait)
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.log("Failed to form BGP unnumbered peering using IPv6 link local")
result += 1
if result == 0:
st.report_pass("test_case_passed")
else:
st.log("BGP IPv6 unnumbered neighborship failure")
st.report_fail("test_case_failed")
def test_ft_ssh_add_user_verify():
"""
Author : Prudvi Mangadu ([email protected])
"""
user_ssh = 0
acl_sshv4 = 0
acl_sshv6 = 0
acl_snmp = 0
if not snmp_config(config='add'): acl_snmp = +1
ipaddress = st.get_mgmt_ip(vars.D1)
if not ipaddress:
st.report_env_fail("ip_verification_fail")
snmp_cmd = "snmpget -Oqv -v 2c -c {} {} {}".format(ssh_data.ro_community,
ipaddress,
ssh_data.oid_sysName)
out = config_nondefault_user()
if not out: user_ssh = +1
st.log("connecting to device with username={},password={}".format(
ssh_data.usr_default, ssh_data.pwd_final))
if not st.exec_ssh(vars.D1, ssh_data.usr_default, ssh_data.pwd_final,
ssh_data.commands_to_verify):
st.error('Cannot SSH into Device with default credentials')
user_ssh = +1
st.log('connecting to device with username={},password={}'.format(
ssh_data.usr_non_default, ssh_data.pwd_non_default))
if not st.exec_ssh(vars.D1, ssh_data.usr_non_default,
ssh_data.pwd_non_default, ssh_data.commands_to_verify):
st.error('Cannot SSH into Device with non-default credentials')
user_ssh = +1
output = verify_ssh_connection(vars.D2, ssh_data.ipv4_address_D1D2P2,
ssh_data.usr_default, ssh_data.pwd_final)
if not output:
user_ssh = +1
IPAddr = ensure_service_params(vars.D1, "snmptrap", "ip") + "/32"
change_acl_rules(acl_data.acl_json_config_control_plane, "SNMP_SSH|RULE_1",
"SRC_IP", IPAddr)
change_acl_rules(acl_data.acl_json_config_control_plane, "SNMP_SSH|RULE_2",
"SRC_IP", IPAddr)
change_acl_rules(acl_data.acl_json_config_control_plane, "SNMP_SSH|RULE_3",
"SRC_IP", ssh_data.ipv4_network)
change_acl_rules(acl_data.acl_json_config_control_plane,
"V6_SSH_ONLY|RULE_1", "SRC_IPV6",
ssh_data.ipv6_network_D1)
acl_config = acl_data.acl_json_config_control_plane
st.log("ACL_DATA: {}".format(acl_config))
acl_obj.apply_acl_config(vars.D1, acl_config)
acl_obj.show_acl_table(vars.D1)
acl_obj.show_acl_rule(vars.D1)
if not poll_wait(acl_obj.verify_acl_table_rule, 5, vars.D1, "SNMP_SSH",
"RULE_1"):
st.error("Failed to create ACL rule '{}' ".format("SNMP_SSH"))
acl_snmp = +1
if not poll_wait(acl_obj.verify_acl_table_rule, 5, vars.D1, "SNMP_SSH",
"RULE_2"):
st.error("Failed to create ACL rule '{}' ".format("SNMP_SSH"))
acl_sshv4 = +1
if not poll_wait(acl_obj.verify_acl_table_rule, 5, vars.D1, "V6_SSH_ONLY",
"RULE_1"):
st.error("Failed to create ACL rule '{}' ".format("V6_SSH_ONLY"))
acl_sshv6 = +1
hostname = get_hostname(vars.D1)
st.log("HOSTNAME: {}".format(hostname))
snmp_out = execute_command(ssh_conn_obj, snmp_cmd)
if hostname not in snmp_out:
st.error("SNMP walk operation is failed")
acl_snmp = +1
st.log("connecting to device with default username={},password={}".format(
ssh_data.usr_default, ssh_data.pwd_final))
output = verify_ssh_connection(vars.D2, ssh_data.ipv4_address_D1D2P2,
ssh_data.usr_default, ssh_data.pwd_final)
if output: acl_sshv4 = +1
output = verify_ssh_connection(vars.D2, ssh_data.ipv6_address_D1D2P2,
ssh_data.usr_default, ssh_data.pwd_final)
if output: acl_sshv6 = +1
output = verify_ssh_connection(vars.D2, ssh_data.ipv4_address_D1D2P1,
ssh_data.usr_default, ssh_data.pwd_final)
if not output: acl_sshv4 = +1
output = verify_ssh_connection(vars.D2, ssh_data.ipv6_address_D1D2P1,
ssh_data.usr_default, ssh_data.pwd_final)
if not output: acl_sshv6 = +1
st.log(
"connecting to device with non default username={},password={}".format(
ssh_data.usr_non_default, ssh_data.pwd_non_default))
output = verify_ssh_connection(vars.D2, ssh_data.ipv4_address_D1D2P1,
ssh_data.usr_non_default,
ssh_data.pwd_non_default)
if not output: acl_sshv4 = +1
output = verify_ssh_connection(vars.D2, ssh_data.ipv6_address_D1D2P1,
ssh_data.usr_non_default,
ssh_data.pwd_non_default)
if not output: acl_sshv6 = +1
config_save(vars.D1)
st.log('rebooting the device.')
st.reboot(vars.D1, 'fast')
acl_obj.show_acl_table(vars.D1)
acl_obj.show_acl_rule(vars.D1)
if not poll_wait(acl_obj.verify_acl_table_rule, 5, vars.D1, "SNMP_SSH",
"RULE_2"):
st.log("Failed to create ACL rule '{}' ".format("SSH_SSH"))
acl_sshv4 = +1
if not poll_wait(acl_obj.verify_acl_table_rule, 5, vars.D1, "V6_SSH_ONLY",
"RULE_1"):
st.log("Failed to create ACL rule '{}' ".format("V6_SSH_ONLY"))
acl_sshv4 = +1
if not poll_wait(acl_obj.verify_acl_table_rule, 5, vars.D1, "SNMP_SSH",
"RULE_1"):
st.error("Failed to create ACL rule '{}' ".format("SNMP_SSH"))
acl_snmp = +1
ipaddress = st.get_mgmt_ip(vars.D1)
if not ipaddress or not ip_obj.ping(vars.D1, IPAddr.strip('/32')):
st.error(
"Ping to SNMP server or getting ip address to the dut is failed after reload"
)
acl_obj.acl_delete(vars.D1)
config_nondefault_user(config='remove')
st.report_fail("ip_verification_fail")
snmp_cmd = "snmpget -Oqv -v 2c -c {} {} {}".format(ssh_data.ro_community,
ipaddress,
ssh_data.oid_sysName)
hostname = get_hostname(vars.D1)
snmp_out = execute_command(ssh_conn_obj, snmp_cmd)
if hostname not in snmp_out:
st.error("SNMP walk operation is failed after reload")
acl_snmp = +1
st.log('Verifying SNMP ACL with invalid source address')
change_acl_rules(acl_data.acl_json_config_control_plane, "SNMP_SSH|RULE_1",
"SRC_IP", "2.2.2.0/24")
acl_config = acl_data.acl_json_config_control_plane
acl_obj.acl_delete(vars.D1)
acl_obj.apply_acl_config(vars.D1, acl_config)
st.wait(3, "Waiting to apply acl rules")
snmp_out = execute_command(ssh_conn_obj, snmp_cmd)
if "Timeout" not in snmp_out: acl_snmp = +1
st.log("connecting to device with default username={},password={}".format(
ssh_data.usr_default, ssh_data.pwd_final))
output = verify_ssh_connection(vars.D2, ssh_data.ipv4_address_D1D2P2,
ssh_data.usr_default, ssh_data.pwd_final)
if output: acl_sshv4 = +1
output = verify_ssh_connection(vars.D2, ssh_data.ipv6_address_D1D2P2,
ssh_data.usr_default, ssh_data.pwd_final)
if output: acl_sshv6 = +1
output = verify_ssh_connection(vars.D2, ssh_data.ipv4_address_D1D2P1,
ssh_data.usr_default, ssh_data.pwd_final)
if not output: acl_sshv4 = +1
output = verify_ssh_connection(vars.D2, ssh_data.ipv6_address_D1D2P1,
ssh_data.usr_default, ssh_data.pwd_final)
if not output: acl_sshv6 = +1
if acl_sshv4:
st.report_tc_fail("test_ft_controlplane_acl_service_sshv4",
"ssh_failed",
"with control plane ACL service SSHv4 after reboot")
else:
st.report_tc_pass("test_ft_controlplane_acl_service_sshv4",
"ssh_failed",
"with control plane ACL service SSHv4 after reboot")
if acl_sshv6:
st.report_tc_fail("test_ft_controlplane_acl_service_sshv6",
"ssh_failed",
"with control plane ACL service SSHv6 after reboot")
else:
st.report_tc_pass("test_ft_controlplane_acl_service_sshv6",
"ssh_failed",
"with control plane ACL service SSHv6 after reboot")
if acl_snmp:
st.report_tc_fail("test_ft_controlplane_acl_service_snmp",
"snmp_output_failed",
"with control plane ACL service SNMP after reboot")
else:
st.report_tc_pass("test_ft_controlplane_acl_service_snmp",
"snmp_output_failed",
"with control plane ACL service SNMP after reboot")
acl_obj.acl_delete(vars.D1)
if acl_sshv4 or acl_sshv6 or acl_snmp:
st.generate_tech_support(vars.D1,
"controlplane_acl_services_after_reboot")
st.log('Verifying SSH connection after removing control plane ACLs')
st.log("connecting to device with username={},password={}".format(
ssh_data.usr_default, ssh_data.pwd_final))
if not st.exec_ssh(vars.D1, ssh_data.usr_default, ssh_data.pwd_final,
ssh_data.commands_to_verify):
st.error(
'Cannot SSH into Device with default credentials after reboot')
user_ssh = +1
st.log('connecting to device with username={},password={}'.format(
ssh_data.usr_non_default, ssh_data.pwd_non_default))
if not st.exec_ssh(vars.D1, ssh_data.usr_non_default,
ssh_data.pwd_non_default, ssh_data.commands_to_verify):
st.error(
'Cannot SSH into Device with non-default credentials after reboot')
user_ssh = +1
config_nondefault_user(config='remove')
if (user_ssh or acl_snmp or acl_sshv4 or acl_sshv6):
st.report_fail("test_case_failed")
st.report_pass("test_case_passed")
def test_ft_wred_functionality():
"""
Author : Sai Durga <*****@*****.**>
FtOpSoQsWdFn012 : Verify that WRED fnctionality working fine and WRED green drop counters incremented properly.
Setup:
===========
DUT-----3---- TGen
Procedure:
===========
1. Create a VLAN 10 and participate all the 3 ports in VLAN 10.
2. Send tagged traffic from 3rd port and check the FDB table.
3. Now configure WRED, dscp_to_tc_map and tc to queue map tables and bind it to 3 ports.
4. Now send matched traffic from port1 to port3 and unmatched traffic from port2 to port3.
Expected Results:
=====================
1. Verify that VLAN 10 created and all the 3 ports added to vlan 10
2. Verify that FDB table updated with 3rd port MAC addresses.
3. Verify that WRED, dscp_to_tc_map and tc to queue map tables created and binded to 3 ports
5. Verify that matched traffic forwared to configured queues based on the min and max threshold values and unmatched traffic is dropped and WRED green incremented properly.
"""
st.log("Configuring MAC age time out")
fdb_config()
st.log("Creating vlan and adding the TGen connected ports to it")
vlan_config()
st.log("Clearing the interface counters before sending the traffic")
ifapi.clear_interface_counters(vars.D1, interface_type="all")
st.log("Sending traffic from port 3 to learn the MAC in FDB table")
data.tg.tg_traffic_control(
action='run', stream_handle=data.streams['vlan_tagged_egress'])
st.log("Verifying FDB table")
if not poll_wait(mac_obj.verify_mac_address_table, 30, vars.D1,
data.dscp_dest_mac):
st.log(
"Displaying the interface counters to verify traffic is sent or not"
)
ifapi.show_interface_counters_all(vars.D1)
st.report_fail("mac_address_verification_fail")
wred_running_config()
configuring_tc_to_queue_map()
configuring_dscp_to_tc_map()
binding_queue_map_to_interfaces()
st.log("Clearing the interface counters before sending the traffic")
ifapi.clear_interface_counters(vars.D1, interface_type="all")
st.log("Sending traffic from 1st and 2nd port")
data.tg.tg_traffic_control(
action='run',
stream_handle=[data.streams['dscp1'], data.streams['dscp2']])
st.wait(3)
data.tg.tg_traffic_control(action='stop',
stream_handle=[
data.streams['dscp1'],
data.streams['dscp2'],
data.streams['vlan_tagged_egress']
])
st.log("Displaying the interface counters after traffic test")
ifapi.show_interface_counters_all(vars.D1)
cos_counters_checking()
st.report_pass("test_case_passed")
def test_ft_bgp_unnumbered_rr():
"""
# ################ Author Details ################
# Name: Sesha Reddy Koilkonda
# Email: [email protected]
# ################################################
:return:
"""
utils_obj.banner_log('FtOtSoRtBgpUnFn011,FtOtSoRtBgpUnFn012')
result = 0
bgp_obj.cleanup_router_bgp(st.get_dut_names())
dict1 = {
'config': 'yes',
'router_id': data.d1_rid,
'addr_family': 'ipv6',
'local_as': data.d1_local_as,
'remote_as': 'internal',
'config_type_list': ["remote-as", "activate"],
'interface': vars.D1D2P1,
'neighbor': vars.D1D2P1
}
dict2 = {
'config': 'yes',
'router_id': data.d2_rid,
'addr_family': 'ipv6',
'local_as': data.d1_local_as,
'remote_as': 'internal',
'config_type_list': ["remote-as", "activate"],
'interface': vars.D2D1P1,
'neighbor': vars.D2D1P1
}
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
result_rr = bgp_obj.create_bgp_route_reflector_client(
vars.D1, data.d1_local_as, 'ipv6', vars.D1D2P1, 'yes')
if not result_rr:
st.error(
"BGP SP - Configuring client reflection on {} {} bgp {} Failed".
format(vars.D1, 'ipv6', data.d1_local_as))
result += 1
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.error(
"Failed to form iBGP unnumbered peering using IPv6 link local with Route-reflector-client config"
)
result += 1
# Unconfiguration
bgp_obj.create_bgp_route_reflector_client(vars.D1,
data.d1_local_as,
'ipv6',
vars.D1D2P1,
config='no')
bgp_obj.cleanup_router_bgp(st.get_dut_names())
if result == 0:
st.report_pass("test_case_passed")
else:
st.error(
"BGP unnumbered neighborship failed with the Route-reflector-client configuration failed."
)
st.report_fail("test_case_failed")
def test_ft_bgp_unnumbered_rmap():
"""
# ################ Author Details ################
# Name: Sesha Reddy Koilkonda
# Email: [email protected]
# ################################################
:return:
"""
utils_obj.banner_log('FtOtSoRtBgpUnFn010,FtOtSoRtBgpUnFn016')
result = 0
network_ipv6 = '6002:1::0/64'
bgp_obj.config_bgp(config='yes',
dut=vars.D2,
local_as=data.d2_local_as,
addr_family='ipv6',
neighbor=vars.D2D1P1,
weight='35000',
config_type_list=["weight"])
bgp_obj.config_bgp_network_advertise(vars.D1,
data.d1_local_as,
network_ipv6,
addr_family='ipv6',
config='yes',
network_import_check=True)
st.wait(60)
n1 = ip_obj.verify_ip_route(vars.D2,
family='ipv6',
shell='sonic',
ip_address='6002:1::/64')
if (n1 is False):
st.error("Failed to advertise the ipv6 network to the peer")
result += 1
bgp_obj.get_ip_bgp_route(vars.D2, family="ipv6", network="6002:1/64")
# Add route-map to advertised network
ip_obj.config_access_list(vars.D1,
'Ubgp-access-list1',
network_ipv6,
'deny',
family='ipv6',
seq_num="1")
ip_obj.config_route_map_match_ip_address(vars.D1,
'Ubgp-rmap',
'deny',
'10',
'Ubgp-access-list1',
family='ipv6')
bgp_obj.advertise_bgp_network(vars.D1,
data.d1_local_as,
network_ipv6,
'Ubgp-rmap',
family='ipv6')
# verify route-map to advertised network
n1 = ip_obj.verify_ip_route(vars.D2,
family='ipv6',
shell='sonic',
ip_address='6002:1::/64')
if (n1 is True):
st.error(
"Advertised network is not filtered by the configured route map")
result += 1
else:
st.log("As expected, advertised network is filtered by the route map.")
# Veirfy the BGP unnumbered neighbourship post r-map config
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.error(
"Failed to form BGP unnumbered peering using IPv6 link local, with the route map configuration."
)
result += 1
# Unconfig the r-map and verify the BGP neighbourship
ip_obj.config_route_map_mode(vars.D1,
'Ubgp-rmap',
'deny',
'10',
config='no')
ip_obj.config_access_list(vars.D1,
'Ubgp-access-list1',
network_ipv6,
'deny',
config='no',
family='ipv6',
seq_num="1")
bgp_obj.config_bgp(config='no',
dut=vars.D2,
local_as=data.d2_local_as,
addr_family='ipv6',
neighbor=vars.D2D1P1,
weight='35000',
config_type_list=["weight"])
bgp_obj.config_bgp_network_advertise(vars.D1,
data.d1_local_as,
network_ipv6,
addr_family='ipv6',
config='no')
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.error(
"Failed to form BGP unnumbered peering using IPv6 link local, after route map un-configuration."
)
result += 1
if result == 0:
st.report_pass("test_case_passed")
else:
st.error(
"BGP unnumbered neighborship failed with the route map configuration."
)
st.report_fail("test_case_failed")
def verify_thresholds(data=[]):
max_threshold = 999999
var_delay = 2
opt_delay = 2
clear_wait = 8
final_wait = 20
mymode = ""
family_list = crm_obj.crm_get_family_list(data.D1)
for family in family_list:
if family != 'all':
(data.used_counter[family],
data.free_counter[family]) = crm_obj.crm_get_resources_count(
data.D1, family)
data.resource_count_max[
family] = data.used_counter[family] + data.free_counter[family]
st.log("verify_thresholds: {} used {} free {} max {}".format(
family, data.used_counter[family], data.free_counter[family],
data.resource_count_max[family]))
##################### USED #############################
for family in family_list:
if family != 'all':
crm_obj.set_crm_thresholds_type(data.D1,
family=family,
type="used")
crm_obj.set_crm_thresholds_value(data.D1,
family=family,
mode="high",
value=max_threshold)
crm_obj.set_crm_thresholds_value(data.D1,
family=family,
mode="low",
value=max_threshold)
#show logs
st.log("show log messages:")
slog_obj.show_logging(data.D1, lines=50)
# Clear Logs
slog_obj.clear_logging(data.D1)
st.log("configure Thresholds for used")
for family in family_list:
if family != 'all':
hi_th = data.used_counter[family] - 1
if hi_th < 0:
hi_th = 0
mymode = "high"
if family in acl_family_list:
mymode = "low"
crm_obj.set_crm_thresholds_value(data.D1,
family=family,
mode=mymode,
value=hi_th)
mymode = "low"
if family in acl_family_list:
mymode = "high"
low_th = hi_th - 1
if low_th < 0:
low_th = 0
#crm_obj.set_crm_thresholds_type(data.D1, family=family, type="used")
crm_obj.set_crm_thresholds_value(data.D1,
family=family,
mode=mymode,
value=low_th)
crm_obj.set_crm_thresholds_type(data.D1,
family=family,
type="used")
st.wait(opt_delay) ## EXCEED
st.wait(var_delay) ## EXCEED
crm_obj.get_crm_resources(data.D1, "all")
interface_obj.interface_shutdown(data.D1,
data.dut_p1_interface,
skip_verify=False)
interface_obj.interface_shutdown(data.D1,
data.dut_p2_interface,
skip_verify=False)
macapi.clear_mac(data.D1)
crm_fdb_config_clear(data)
st.wait(opt_delay) ## CLEAR
# Restore
interface_obj.interface_noshutdown(data.D1,
data.dut_p1_interface,
skip_verify=False)
interface_obj.interface_noshutdown(data.D1,
data.dut_p2_interface,
skip_verify=False)
st.wait(opt_delay) # delay is required to populate tables
##################### PERCENTAGE #############################
for family in family_list:
if family != 'all':
crm_obj.set_crm_thresholds_value(data.D1,
family=family,
mode="high",
value=max_threshold)
crm_obj.set_crm_thresholds_value(data.D1,
family=family,
mode="low",
value=max_threshold)
crm_fdb_send_traffic(data)
st.log("Configure Thresholds for percentage")
for family in family_list:
if family != 'all' and family != 'snat' and family != 'dnat' and family != 'ipmc':
hi_th = 0
mymode = "high"
crm_obj.set_crm_thresholds_value(data.D1,
family=family,
mode=mymode,
value=hi_th)
mymode = "low"
low_th = 100
#crm_obj.set_crm_thresholds_type(data.D1, family=family, type="percentage")
crm_obj.set_crm_thresholds_value(data.D1,
family=family,
mode=mymode,
value=low_th)
crm_obj.set_crm_thresholds_type(data.D1,
family=family,
type="percentage")
st.wait(opt_delay) ## EXCEED
st.wait(var_delay) ## EXCEED
crm_obj.get_crm_resources(data.D1, "all")
crm_acl_unconfig(data)
crm_acl_config(data)
interface_obj.interface_shutdown(data.D1,
data.dut_p1_interface,
skip_verify=False)
interface_obj.interface_shutdown(data.D1,
data.dut_p2_interface,
skip_verify=False)
macapi.clear_mac(data.D1)
crm_fdb_config_clear(data)
st.wait(opt_delay) ## CLEAR
st.wait(var_delay) ## EXCEED
##################### FREE #############################
crm_obj.get_crm_resources(data.D1, "all")
for family in family_list:
if family != 'all':
crm_obj.set_crm_thresholds_type(data.D1,
family=family,
type="used")
crm_obj.set_crm_thresholds_value(data.D1,
family=family,
mode="high",
value=max_threshold)
crm_obj.set_crm_thresholds_value(data.D1,
family=family,
mode="low",
value=max_threshold)
st.wait(clear_wait)
st.log("configure Thresholds for free")
for family in family_list:
if family != 'all':
mymode = "high"
hi_th = 0
crm_obj.set_crm_thresholds_value(data.D1,
family=family,
mode=mymode,
value=hi_th)
mymode = "low"
low_th = max_threshold
#crm_obj.set_crm_thresholds_type(data.D1, family=family, type="free")
crm_obj.set_crm_thresholds_value(data.D1,
family=family,
mode=mymode,
value=low_th)
crm_obj.set_crm_thresholds_type(data.D1,
family=family,
type="free")
st.wait(opt_delay) ## EXCEED
crm_obj.get_crm_resources(data.D1, "all")
interface_obj.interface_noshutdown(data.D1,
data.dut_p1_interface,
skip_verify=False)
interface_obj.interface_noshutdown(data.D1,
data.dut_p2_interface,
skip_verify=False)
crm_fdb_send_traffic(data)
# CLEAR TH
st.wait(final_wait) ## CLEAR
if not poll_wait(check_logging_result, 60, data):
crm_obj.get_crm_resources(data.D1, "all")
st.error('Failed to get threshold logs, CRM threshold tests failed')
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')
def test_ft_bgp_unnumbered_clear_bgp_ndp():
# ################ Author Details ################
# Name: Kiran Vedula
# Email: [email protected]
# ################################################
utils_obj.banner_log(
'FtOtSoRtBgpUnFn004,FtOtSoRtBgpUnFn005,FtOtSoRtBgpUnFn007')
result = 0
st.log('######------Clear BGP on both nodes------######')
utils.exec_all(True, [[arp_obj.clear_ndp_table, vars.D1],
[arp_obj.clear_ndp_table, vars.D2]])
utils.exec_all(True,
[[arp_obj.show_ndp, vars.D1], [arp_obj.show_ndp, vars.D2]])
utils.exec_all(True, [[bgp_obj.clear_ip_bgp_vtysh, vars.D1],
[bgp_obj.clear_ip_bgp_vtysh, vars.D2]])
utils.exec_all(True,
[[arp_obj.show_ndp, vars.D1], [arp_obj.show_ndp, vars.D2]])
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
state='Established'):
st.log("Failed to form BGP unnumbered peering after clear NDP/BGP")
result += 1
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D2,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D2D1P1,
state='Established'):
st.log("Failed to form BGP unnumbered peering after clear NDP/BGP")
result += 1
utils.exec_all(True, [[ip_obj.config_ipv6, vars.D1, "disable"],
[ip_obj.config_ipv6, vars.D2, "disable"]])
utils.exec_all(True, [[bgp_obj.clear_ip_bgp_vtysh, vars.D1],
[bgp_obj.clear_ip_bgp_vtysh, vars.D2]])
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D2,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D2D1P1,
state='Active'):
st.log("BGP unnumbered peers established even after disable IPv6")
result += 1
utils.exec_all(True, [[ip_obj.config_ipv6, vars.D1, "enable"],
[ip_obj.config_ipv6, vars.D2, "enable"]])
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D2,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D2D1P1,
state='Established'):
st.log("Failed to form BGP unnumbered peering after enable IPv6")
result += 1
if result == 0:
st.report_pass("test_case_passed")
else:
st.log("BGP unnumbered neighborship failed after config state toggle")
st.report_fail("test_case_failed")
def test_ft_bgp_unnumbered_nondefault_vrf():
"""
# ################ Author Details ################
# Name: Sesha Reddy Koilkonda
# Email: [email protected]
# ################################################
:return:
"""
utils_obj.banner_log("FtOtSoRtBgpUnFn016,FtOtSoRtBgpUnFn017")
result = 0
bgp_obj.cleanup_router_bgp(st.get_dut_names())
dict1 = {'vrf_name': data.vrf_name, 'skip_error': True}
parallel.exec_parallel(True, [vars.D1, vars.D2], vrf_api.config_vrf,
[dict1, dict1])
utils.exec_all(True, [[
ip_obj.config_interface_ip6_link_local, vars.D1, vars.D1D2P1, "disable"
], [
ip_obj.config_interface_ip6_link_local, vars.D2, vars.D2D1P1, "disable"
]])
dict1 = {
'vrf_name': data.vrf_name,
'intf_name': vars.D1D2P1,
'skip_error': True
}
dict2 = {
'vrf_name': data.vrf_name,
'intf_name': vars.D2D1P1,
'skip_error': True
}
parallel.exec_parallel(True, [vars.D1, vars.D2],
vrf_api.bind_vrf_interface, [dict1, dict2])
utils.exec_all(
True, [[ip_obj.config_interface_ip6_link_local, vars.D1, vars.D1D2P1],
[ip_obj.config_interface_ip6_link_local, vars.D2, vars.D2D1P1]])
utils.exec_all(True,
[[ip_obj.get_interface_ip_address, vars.D1, None, "ipv6"],
[ip_obj.get_interface_ip_address, vars.D2, None, "ipv6"]])
dict1 = {
'vrf_name': data.vrf_name,
'router_id': data.d1_rid,
'local_as': data.d1_local_as,
'addr_family': 'ipv6',
'neighbor': vars.D1D2P1,
'remote_as': 'external',
'config_type_list': ["remote-as", "activate"],
'interface': vars.D1D2P1
}
dict2 = {
'vrf_name': data.vrf_name,
'router_id': data.d2_rid,
'local_as': data.d2_local_as,
'addr_family': 'ipv6',
'neighbor': vars.D2D1P1,
'remote_as': 'external',
'config_type_list': ["remote-as", "activate"],
'interface': vars.D2D1P1
}
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
vrf=data.vrf_name,
state='Established'):
st.error(
"BGP unnumbered neighbourship with the non-default vrf configuration failed."
)
result += 1
st.log('######------Save and reboot------######')
reboot_obj.config_save(vars.D1, "sonic")
reboot_obj.config_save(vars.D1, "vtysh")
st.reboot(vars.D1)
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
vrf=data.vrf_name,
state='Established'):
st.error(
"BGP unnumbered neighbourship with the non-default vrf configuration failed after save and reboot."
)
result += 1
st.log('######------Config reload with BGP unnumbered------######')
st.log("Config reload the DUT")
reboot_obj.config_save_reload(vars.D1)
if not utils.poll_wait(bgp_obj.verify_bgp_summary,
data.wait_timer,
vars.D1,
family='ipv6',
shell=bgp_cli_type,
neighbor=vars.D1D2P1,
vrf=data.vrf_name,
state='Established'):
st.error(
"BGP unnumbered neighbourship with the non-default vrf configuration failed after config reload."
)
result += 1
# unconfig part:
dict1 = {
'vrf_name': data.vrf_name,
'local_as': data.d1_local_as,
'config': 'no',
'removeBGP': 'yes',
'config_type_list': ['removeBGP']
}
dict2 = {
'vrf_name': data.vrf_name,
'local_as': data.d2_local_as,
'config': 'no',
'removeBGP': 'yes',
'config_type_list': ['removeBGP']
}
parallel.exec_parallel(True, [vars.D1, vars.D2], bgp_obj.config_bgp,
[dict1, dict2])
utils.exec_all(True, [[
ip_obj.config_interface_ip6_link_local, vars.D1, vars.D1D2P1, "disable"
], [
ip_obj.config_interface_ip6_link_local, vars.D2, vars.D2D1P1, "disable"
]])
dict1 = {
'vrf_name': data.vrf_name,
'intf_name': vars.D1D2P1,
'skip_error': True,
'config': 'no'
}
dict2 = {
'vrf_name': data.vrf_name,
'intf_name': vars.D2D1P1,
'skip_error': True,
'config': 'no'
}
parallel.exec_parallel(True, [vars.D1, vars.D2],
vrf_api.bind_vrf_interface, [dict1, dict2])
dict1 = {'vrf_name': data.vrf_name, 'skip_error': True, 'config': 'no'}
parallel.exec_parallel(True, [vars.D1, vars.D2], vrf_api.config_vrf,
[dict1, dict1])
bgp_obj.cleanup_router_bgp(st.get_dut_names())
utils.exec_all(
True,
[[ip_obj.config_interface_ip6_link_local, vars.D1, d1_int_ipv6_list],
[ip_obj.config_interface_ip6_link_local, vars.D2, d2_int_ipv6_list]])
if result == 0:
st.report_pass("test_case_passed")
else:
st.error(
"BGP unnumbered neighborship failed with the non-default vrf configuration."
)
st.report_fail("test_case_failed")
def test_ft_bgp_ebgp_multihop_4byteASN():
"""
Verify the functioning of ebgp multihop command with 4 byte ASN
"""
# On DUT1 and DUT3, create BGP with 4byte ASN
dut1_as = 6500001
dut1 = topo['dut_list'][0]
dut3_as = 6500002
dut3 = topo['dut_list'][2]
result = 0
wait_timer = 150
st.banner("Verify the ebgp multihop functionality with 4 byte AS Number")
# Configure bgp on DUT1 and configure DUT3 as neighbor with ebgp-multihop ttl set to 5
st.log(
"Configure eBGP on DUT1 with Neighbor as DUT3 with multihop set to maximum hops of 5"
)
bgpapi.config_bgp(dut1,
local_as=dut1_as,
neighbor=topo['D3D2P1_ipv4'],
remote_as=dut3_as,
config_type_list=["neighbor", "ebgp_mhop"],
ebgp_mhop='5')
# Add static route towards neighbor DUT3
st.log("Add static route towards DUT3")
ipapi.create_static_route(dut1, topo['D1D2P1_neigh_ipv4'],
"{}/24".format(topo['D3D2P1_ipv4']))
# Configure bgp on DUT3 and configure DUT1 as neighbor with ebgp-multihop ttl set to 5
st.log(
"Configure eBGP on DUT3 with DUT1 as Neighbor with multihop set to maximum hops of 5"
)
bgpapi.config_bgp(dut3,
local_as=dut3_as,
neighbor=topo['D1D2P1_ipv4'],
remote_as=dut1_as,
config_type_list=["neighbor", "ebgp_mhop"],
ebgp_mhop='5')
# Add static route towards neighbor DUT1
st.log("Add static route towards DUT1")
ipapi.create_static_route(dut3, topo['D3D2P1_neigh_ipv4'],
"{}/24".format(topo['D1D2P1_ipv4']))
st.log("Verify BGP neighborship on DUT1")
#result = bgpapi.verify_bgp_summary(dut1, family='ipv4', neighbor=topo['D3D2P1_ipv4'], state='Established')
if not utils.poll_wait(bgpapi.verify_bgp_summary,
wait_timer,
dut1,
family='ipv4',
neighbor=topo['D3D2P1_ipv4'],
state='Established'):
st.log("Failed to form BGP eBGP multihop peering with 4byte ASN")
result += 1
if result == 0:
st.log("Pass: BGP neighborship established between DUT1 and DUT3")
else:
st.error(
"Fail: BGP neighborship not established between DUT1 and DUT3")
st.banner("Collecting techsupport")
exec_all(True, [[
st.generate_tech_support, topo['dut_list'][0],
"test_ft_bgp_ebgp_multihop_4byteASN"
],
[
st.generate_tech_support, topo['dut_list'][1],
"test_ft_bgp_ebgp_multihop_4byteASN"
],
[
st.generate_tech_support, topo['dut_list'][2],
"test_ft_bgp_ebgp_multihop_4byteASN"
]])
#Clear applied configs
st.banner("Cleanup for TestFunction")
bgpapi.cleanup_router_bgp(dut1)
bgpapi.cleanup_router_bgp(dut3)
ipapi.delete_static_route(dut1, topo['D1D2P1_neigh_ipv4'],
"{}/24".format(topo['D3D2P1_ipv4']))
ipapi.delete_static_route(dut3, topo['D3D2P1_neigh_ipv4'],
"{}/24".format(topo['D1D2P1_ipv4']))
if result == 0:
st.report_pass("test_case_passed")
else:
st.report_fail("test_case_failed")
