def test_ft_ipv6_link_local_ip6_disable():
report_flag = 0
ip_obj.config_ipv6(vars.D1, action='disable')
if ip_obj.get_link_local_addresses(vars.D1, vars.D1D2P1):
st.error("Auto generated ipv6 link local addr is not removed when ipv6 is disabled globally")
report_flag = 1
ip_obj.config_interface_ip6_link_local(vars.D1, d1_int_ipv6_list, 'enable')
if not ip_obj.get_link_local_addresses(vars.D1, vars.D1D2P1):
st.error("ipv6 link local addr is not auto generated when ipv6 is disabled and enabled globally")
report_flag = 1
if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = vars.D1D2P1):
st.log("Ipv6 Ping over Link Local address via the Port based routing interface is failed.")
report_flag=1
if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = data.vlan_in_1):
st.log("Ipv6 Ping over Link Local address via the Vlan based routing interface is failed.")
report_flag = 1
if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = data.vlan_in_2):
st.log("Ipv6 Ping over Link Local address via the Vlan based routing interface is failed.")
report_flag = 1
if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = data.prt_chnl):
st.log("Ipv6 Ping over Link Local address via the Port Channel based routing interface is failed.")
report_flag = 1
if report_flag:
st.report_fail("ip6_link_local_addr_auto_generation_failed")
st.report_pass("test_case_passed")
def test_ft_port_fn_verify_shut_noshut():
if not ipapi.config_ip_addr_interface(vars.D1, interface_name=vars.D1D2P1, ip_address=intf_data.ip_address,
subnet=intf_data.mask, family="ipv4", config='add'):
st.report_fail("operation_failed")
if not ipapi.config_ip_addr_interface(vars.D2, interface_name=vars.D2D1P1, ip_address=intf_data.ip_address1,
subnet=intf_data.mask, family="ipv4", config='add'):
st.report_fail("operation_failed")
if not ipapi.ping(vars.D1, intf_data.ip_address1, family='ipv4', count=1):
st.report_fail("ping_fail", intf_data.ip_address, intf_data.ip_address1)
if not ipapi.ping(vars.D2, intf_data.ip_address, family='ipv4', count=1):
st.report_fail("ping_fail", intf_data.ip_address1, intf_data.ip_address)
for _ in range(3):
intfapi.interface_shutdown(vars.D1, [vars.D1D2P1], skip_verify=True)
intfapi.interface_noshutdown(vars.D1, [vars.D1D2P1], skip_verify=True)
if not ipapi.ping(vars.D1, intf_data.ip_address1, family='ipv4', count=5):
st.report_fail("ping_fail", intf_data.ip_address, intf_data.ip_address1)
if not ipapi.ping(vars.D2, intf_data.ip_address, family='ipv4', count=1):
st.report_fail("ping_fail", intf_data.ip_address1, intf_data.ip_address)
rbapi.config_save_reload(vars.D1)
if not ipapi.config_ip_addr_interface(vars.D1, interface_name=vars.D1D2P1, ip_address=intf_data.ip_address,
subnet=intf_data.mask, family="ipv4", config='remove'):
st.report_fail("operation_failed")
if not ipapi.config_ip_addr_interface(vars.D2, interface_name=vars.D2D1P1, ip_address=intf_data.ip_address1,
subnet=intf_data.mask, family="ipv4", config='remove'):
st.report_fail("operation_failed")
for _ in range(3):
intfapi.interface_shutdown(vars.D1, [vars.D1D2P1], skip_verify=True)
intfapi.interface_noshutdown(vars.D1, [vars.D1D2P1], skip_verify=True)
if not st.poll_wait(intfapi.verify_interface_status, 15, vars.D1, vars.D1D2P1, "oper", "up"):
st.report_fail("interface_is_down_on_dut", [vars.D1D2P1])
if not st.poll_wait(intfapi.verify_interface_status, 15, vars.D2, vars.D2D1P1, "oper", "up"):
st.report_fail("interface_is_down_on_dut", [vars.D2D1P1])
st.report_pass("test_case_passed")
def test_mgmt_vrf_ping_traceroute():
report_flag = 0
ip_addr = get_ifconfig_inet(vars.D1, 'eth0')
if not ip_addr:
st.report_fail('ip_verification_fail')
if not ping(vars.D1, mgmt_vrf.extip, interface=mgmt_vrf.vrfname):
report_flag = 1
if not ping(vars.D1, ip_addr[0], external=True):
report_flag = 1
if report_flag:
st.report_tc_fail("ft_mgmtVrf_ping", "mgmt_vrf_ping_fail")
else:
st.report_tc_pass("ft_mgmtVrf_ping", "mgmt_vrf_ping_pass")
report_flag = 0
if not traceroute(vars.D1, mgmt_vrf.extip, vrf_name=mgmt_vrf.vrfname):
report_flag = 1
if not traceroute(vars.D1, ip_addr[0], external=True):
report_flag = 1
if report_flag:
st.report_tc_fail("ft_mgmtVrf_traceroute", "mgmt_vrf_tr_fail")
else:
st.report_tc_pass("ft_mgmtVrf_traceroute", "mgmt_vrf_tr_pass")
if report_flag:
st.report_fail("mgmt_vrf_tr_fail")
else:
st.report_pass("mgmt_vrf_tr_pass")
def debug_bfd_ping(dut, addresses, vrf_name='default', enable_debug=True, cli_type=''):
st.banner("********* Ping Dubug commands starts ************")
for addr in addresses:
family = 'ipv4' if is_valid_ipv4(addr) else 'ipv6'
if vrf_name in ['default', 'default-vrf']:
ip_api.ping(dut, addr, family, cli_type=cli_type)
else:
ip_api.ping(dut, addr, family, interface=vrf_name, cli_type=cli_type)
if enable_debug: debug_bgp_bfd(dut)
def test_ft_dynamic_napt_traceroute():
# ################ Author Details ################
# Name: Kiran Vedula
# Eamil: [email protected]
# ################################################
# Objective - Verify traceroute over a NAT translation
# #################################################
nat_obj.clear_nat(vars.D2, translations=True)
nat_obj.clear_nat(vars.D2, statistics=True)
ip_obj.ping(vars.D3, data.d1d2_ip_addr, family='ipv4', count=3)
ip_obj.traceroute(vars.D3, data.d1d2_ip_addr)
trn_val = nat_obj.get_nat_translations(vars.D2, protocol=data.proto_udp, dst_ip=data.d2d1_ip_addr,
dst_ip_port=data.global_port[0])
if not trn_val:
ip_obj.ping(vars.D1, data.d2d1_ip_addr, family='ipv4', count=1)
ip_obj.ping(vars.D1, data.d3d2_ip_addr, family='ipv4', count=1)
st.error("Received empty list0,nat translation table not updated")
st.report_fail("traceroute_over_nat_failed")
trn_val = nat_obj.get_nat_translations(vars.D2, protocol=data.proto_udp, dst_ip=data.d2d1_ip_addr,
dst_ip_port=data.global_port[1])
if not trn_val:
ip_obj.ping(vars.D2, data.d3d2_ip_addr, family='ipv4', count=1)
st.error("Received empty list1,nat translation table not updated")
st.report_fail("traceroute_over_nat_failed")
trn_val = nat_obj.get_nat_translations(vars.D2, protocol=data.proto_udp, dst_ip=data.d2d1_ip_addr,
dst_ip_port=data.global_port[2])
if not trn_val:
st.error("Received empty list2,nat translation table not updated")
st.report_fail("traceroute_over_nat_failed")
st.report_pass("traceroute_over_nat_translation_successful")
def test_ft_ipv6_link_local_nh_change():
report_flag = 0
st.log("Clearing all interface counters")
utils.exec_all(True, [[intf_obj.clear_interface_counters, vars.D1], [intf_obj.clear_interface_counters, vars.D2]])
st.log("clearing TG stats")
tgapi.traffic_action_control(tg_handler, actions=['clear_stats'])
st.log("Remove the vlan participation to bring down the Vlan routing intf")
vlan_obj.delete_vlan_member(vars.D1, data.vlan_li[0], vars.D1D2P2, tagging_mode=True)
vlan_obj.add_vlan_member(vars.D1, data.vlan_li[0], vars.D1D2P2, tagging_mode=True)
if not ip_obj.get_link_local_addresses(vars.D1, data.vlan_in_1):
st.error("ipv6 link local addr is not auto generated after remove and re add of vlan routing intf")
report_flag = 1
pc_obj.add_del_portchannel_member(vars.D1, data.prt_chnl, [vars.D1D2P3, vars.D1D2P4], flag="del", skip_verify=True)
pc_obj.add_del_portchannel_member(vars.D1, data.prt_chnl, [vars.D1D2P3, vars.D1D2P4], flag="add", skip_verify=True)
if not ip_obj.get_link_local_addresses(vars.D1, data.prt_chnl):
st.error("ipv6 link local addr is not auto generated for {} after remove and re add of members".format(data.prt_chnl))
report_flag = 1
if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = vars.D1D2P1):
st.log("Ipv6 Ping over Link Local address via the Port based routing interface is failed.")
report_flag = 1
if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = data.vlan_in_1):
st.log("Ipv6 Ping over Link Local address via the Vlan based routing interface is failed.")
report_flag =1
if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = data.prt_chnl):
st.log("Ipv6 Ping over Link Local address via the Port Channel based routing interface is failed.")
report_flag =1
utils.exec_all(True, [[get_mac, vars.D1] ,[get_mac, vars.D2]])
st.log("Checking the IPv6 traffic forwarding over ECMP next hops after remove and re adding of next hop interfaces")
tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"])
st.wait(data.pkts_tx_time)
tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"])
ecmp_cntrs = verify_traffic_hash(vars.D1, [vars.D1D2P1, vars.D1D2P2, vars.D1D2P3, vars.D1D2P4], data.pkts_per_port)
st.log("Counter stats on next hop interfaces - {}".format(ecmp_cntrs))
traffic_details = {
'1': {
'tx_ports': [vars.T1D1P1],
'tx_obj': [tg1],
'exp_ratio': [1],
'rx_ports': [vars.T1D2P1],
'rx_obj': [tg2],
}
}
filter_result = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type='packet_count')
if not filter_result:
st.log("After flap in next hop interfaces, traffic loss observed for ipv6 traffic forwarded via ipv6 link local next hop")
report_flag = 1
if report_flag:
st.report_fail("ip6_traffic_over_link_local_nh_fail")
st.report_pass("test_case_passed")
def test_ft_ping_v4_v6_vlan():
# Objective - Verify that IPv6 & Ipv4 ping is successful over vlan routing interfaces.
st.log(
"Checking IPv4 ping from {} to {} over vlan routing interface".format(
vars.D1, vars.D2))
if not ipfeature.ping(
vars.D1, data.ip4_addr[3], family=data.af_ipv4, count=1):
st.report_fail("ping_fail", data.ip4_addr[2], data.ip4_addr[3])
st.log(
"Checking IPv6 ping from {} to {} over vlan routing interface".format(
vars.D1, vars.D2))
if not ipfeature.ping(
vars.D2, data.ip6_addr[2], family=data.af_ipv6, count=1):
st.report_fail("ping_fail", data.ip6_addr[3], data.ip6_addr[2])
st.report_pass("test_case_passed")
def snmp_pre_config():
"""
SNMP pre config
"""
global ipaddress
ipaddress_list = basic_obj.get_ifconfig_inet(vars.D1, data.mgmt_int)
st.log("Checking Ip address of the Device ")
if not ipaddress_list:
st.report_env_fail("ip_verification_fail")
ipaddress = ipaddress_list[0]
st.log("Device ip addresse - {}".format(ipaddress))
snmp_obj.set_snmp_config(vars.D1,
snmp_rocommunity=data.ro_community,
snmp_location=data.location)
if not st.is_community_build():
ipfeature.configure_loopback(vars.D1,
loopback_name="Loopback0",
config="yes")
ipfeature.config_ip_addr_interface(vars.D1,
data.loopback0,
data.loopback_addr,
32,
family=data.af_ipv4)
if not ipfeature.ping(vars.D1, ipaddress, family='ipv4', external=True):
st.error("Ping reachability is failed between SNMP server and Device.")
if not snmp_obj.poll_for_snmp(vars.D1,
data.wait_time,
1,
ipaddress=ipaddress,
oid=data.oid_sysName,
community_name=data.ro_community):
st.log("Post SNMP config , snmp is not working")
st.report_fail("operation_failed")
def ztp_module_hooks(request):
st.add_prevent("ztp")
initialize_config_params()
pre_config_ztp()
initialize_data_variables()
path_list = [ztp_params.home_path+ztp_params.config_path, ztp_params.home_path+ztp_params.firmware_path,
ztp_params.home_path+ztp_params.provision_script_path, ztp_params.home_path+ztp_params.xml_path]
ztp_obj.create_required_folders(ssh_conn_obj, path_list)
basic_obj.move_file_to_local_path(vars.D1, "/etc/sonic/snmp.yml", "/etc/sonic/snmp.yml.bkp")
source_path = "{}{}".format(config_params.local_provision_scripts_folder, config_params.snmp_filename)
st.upload_file_to_dut(vars.D1, source_path, "/home/admin/snmp.yml")
basic_obj.copy_file_to_local_path(vars.D1, "/home/admin/snmp.yml", "/etc/sonic/snmp.yml")
if ztp_params.breakout:
if breakout(vars.D1, ztp_params.breakout, cli_type="klish", skip_error=True):
intf_details = get_interface_details_by_alt_name(vars.D1, ztp_params.inband_port)
if isinstance(intf_details, dict):
inband_port = intf_details["interface"]
else:
inband_port = intf_details
interface_noshutdown(vars.D1, inband_port)
config_ip_addr_interface(vars.D1, inband_port, ztp_params.dhcp.client_ip_inband, ztp_params.dhcp.inband_v4_subnet)
# enable_dhcp_on_interface(vars.D1, ztp_params.inband_port)
if not ping(vars.D1, ztp_params.dhcp.inband_static_ip):
st.log("Pinging to DHCP server failed from DUT, issue either with DUT or server")
# config_save(vars.D1)
# write_config_db(vars.D1, interface_data)
yield
reset_module_config()
basic_obj.move_file_to_local_path(vars.D1, "/etc/sonic/snmp.yml.bkp", "/etc/sonic/snmp.yml")
def test_ft_nat_save_reboot():
# ################ Author Details ################
# Name: Kiran Vedula
# Eamil: [email protected]
# ################################################
# Objective - Verify dynamic NAPT translations after DUT reboot
# #################################################
nat_obj.clear_nat(vars.D1, translations=True)
nat_obj.clear_nat(vars.D1, statistics=True)
nat_obj.show_nat_translations(vars.D1)
st.log("Reboot the DUT")
reboot_obj.config_save(vars.D1, "sonic")
reboot_obj.config_save(vars.D1, "vtysh")
st.reboot(vars.D1)
st.log("Traffic for snat case")
tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_dyn_nat_udp_data_str_id_1"])
tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_dyn_nat_udp_data_str_id_1"])
if not ip_obj.ping(vars.D1, data.in1_ip_addr_h[-1], family='ipv4',count=3):
nat_reboot_debug_fun()
st.report_fail("ping_fail",data.in1_ip_addr,data.in1_ip_addr_h[-1])
st.wait(data.wait_nat_stats)
st.log("Checking for STATIC entries after reboot")
trn_val_1 = nat_obj.get_nat_translations(vars.D1, protocol=data.proto_all, src_ip=data.in1_ip_addr_h[0])
if not trn_val_1:
nat_reboot_debug_fun()
st.report_fail("static_nat_translation_entry_create_fail", data.in1_ip_addr_h[0], data.out_ip_pool[0])
count = data.pkt_count
trn_val = nat_obj.get_nat_translations(vars.D1, protocol=data.proto_udp, src_ip=data.in1_ip_addr_h[-1],
src_ip_port=data.local_src_port[0])
if not trn_val:
nat_reboot_debug_fun()
st.error("Received empty list,nat translation table not updated")
st.report_fail("dynamic_snat_translation_entry_create_fail", data.in1_ip_addr_h[-1], data.out_ip_pool[0])
trn_src_ip = trn_val[0]["trn_src_ip"]
trn_src_port = trn_val[0]["trn_src_ip_port"]
st.log("Traffic for dnat case")
tg2_str_obj = tg2_str_selector(trn_src_ip, trn_src_port)
tg2.tg_traffic_control(action='run', handle=tg2_str_obj)
tg2.tg_traffic_control(action='stop', handle=tg2_str_obj)
st.wait(data.wait_nat_stats)
nat_stats_s = nat_obj.poll_for_nat_statistics(vars.D1, protocol=data.proto_udp,
src_ip=data.in1_ip_addr_h[-1], src_ip_port=data.local_src_port[0])
if not nat_stats_s:
nat_reboot_debug_fun()
st.error("Received empty list,nat statistics are not updated")
st.report_fail("dynamic_snat_translation_entry_create_fail", data.in1_ip_addr_h[-1], data.out_ip_pool[0])
if not (int(nat_stats_s[0]['packets']) >= (0.80 * (int(count)))):
nat_reboot_debug_fun()
st.report_fail("dynamic_snat_translation_entry_create_fail", data.in1_ip_addr_h[-1], data.out_ip_pool[0])
nat_stats_d = nat_obj.poll_for_nat_statistics(vars.D1, protocol=data.proto_udp, dst_ip=trn_src_ip,
dst_ip_port=trn_src_port)
if not nat_stats_d:
nat_reboot_debug_fun()
st.error("Received empty list, nat statistics are not updated")
st.report_fail("dynamic_dnat_translation_entry_create_fail", data.out_ip_pool[0], data.out_ip_pool[0])
if not (int(nat_stats_d[0]['packets']) >= (0.80 * (int(count)))):
nat_reboot_debug_fun()
st.report_fail("dynamic_dnat_translation_entry_create_fail", data.out_ip_pool[0], data.out_ip_pool[0])
st.report_pass("nat_translation_successful_after_reboot")
def config_ntp_server_on_config_db_file(dut, iplist):
"""
Author: Anil Kumar Kacharla <*****@*****.**>
"""
st.log("Configuring NTP servers in Config_db file")
ntp_obj.add_ntp_servers(dut, iplist=iplist)
data.time_date = time.strftime('%a %B %d %H:%M:%S %Z %Y')
ntp_obj.config_date(vars.D1, data.time_date)
reboot_obj.config_save(vars.D1)
st.log("verifying ntp service status")
if ntp_obj.verify_ntp_service_status(vars.D1, 'active (running)'):
st.log("ntpd is running")
else:
st.log("ntpd is exited and restarting ntp service")
basic_obj.service_operations(vars.D1, data.ntp_service, action="restart")
if not st.poll_wait(ntp_obj.verify_ntp_server_details, 30, dut, iplist, remote=iplist):
st.log("ip not matching")
st.report_fail("operation_failed")
if not ntp_obj.verify_ntp_service_status(dut, 'active (running)', iteration=65, delay=2):
st.log("ntp is exited")
st.report_fail("operation_failed")
st.log("Verify that NTP server connectivity from DUT")
result = 0
for server_ip in data.servers:
if not ping_obj.ping(vars.D1, server_ip):
st.log("ping to ntp server is not successfull:{}".format(server_ip))
result += 1
if len(data.servers) == result:
st.report_fail("None_of_the_configured_ntp_server_reachable")
if not ntp_obj.verify_ntp_status(vars.D1, iteration=65, delay=2, server=data.servers):
st.log("ntp syncronization failed")
st.report_fail("operation_failed")
def check_ping_dhcpserver(dut):
hdrMsg("Verify reachabality to dhcp server drom dut2")
result = ip_api.ping(dut, data.dhcp_server_ip)
if result is False:
st.error("Dhcp server is not reachable from dut2")
return False
return True
def ztp_module_hooks(request):
st.add_prevent("ztp")
initialize_variables()
pre_config_ztp()
path_list = [ztp_params.home_path+ztp_params.config_path, ztp_params.home_path+ztp_params.provision_script_path]
ztp_obj.create_required_folders(ssh_conn_obj, path_list)
basic_obj.move_file_to_local_path(vars.D1, "/etc/sonic/snmp.yml", "/etc/sonic/snmp.yml.bkp")
source_path = "{}{}".format(config_params.local_provision_scripts_folder, config_params.snmp_filename)
st.upload_file_to_dut(vars.D1, source_path, "/home/admin/snmp.yml")
basic_obj.copy_file_to_local_path(vars.D1, "/home/admin/snmp.yml", "/etc/sonic/snmp.yml")
if ztp_params.breakout:
if breakout(vars.D1, ztp_params.breakout, cli_type="klish", skip_error=True):
intf_details = get_interface_details_by_alt_name(vars.D1, ztp_params.inband_port)
if isinstance(intf_details, dict):
inband_port = intf_details["interface"]
else:
inband_port = intf_details
interface_noshutdown(vars.D1, inband_port)
config_ip_addr_interface(vars.D1, inband_port, ztp_params.dhcp6.client_ip_inband, ztp_params.dhcp6.inband_v6_subnet, family="ipv6")
# enable_dhcp_on_interface(vars.D1, ztp_params.inband_port)
if not ping(vars.D1, ztp_params.dhcp6.inband_static_ip, family="ipv6"):
st.log("Pinging to DHCP server failed from DUT, issue either with DUT or server")
# config_save(vars.D1)
yield
ztp_cfg = {"admin-mode": True, "restart-ztp-interval": 30, "feat-console-logging": feat_logging_console}
ztp_obj.config_ztp_backdoor_options(vars.D1, ztp_cfg)
reset_module_config()
basic_obj.move_file_to_local_path(vars.D1, "/etc/sonic/snmp.yml.bkp", "/etc/sonic/snmp.yml")
def device_eth0_ip_addr():
"""
To get the ip address of device after reboot.
"""
ipaddress = st.get_mgmt_ip(vars.D1)
st.log("Device ip address - {}".format(ipaddress))
if not ipfeature.ping(vars.D1, ipaddress, family='ipv4', external=True):
st.error("Ping reachability is failed between SNMP server and Device.")
def check_ip_ping(dut, ipv4=None, ipv6=None, retry=1, time_delay=5):
i = 0
while True:
result = True
if ipv4:
if not ipapi.ping(dut, ipv4, family=eh_data.af_ipv4):
st.log("Ping to {} on Dut {} is failed.".format(ipv4, dut))
result = False
if ipv6:
if not ipapi.ping(dut, ipv6, family=eh_data.af_ipv6):
st.log("Ping to {} on Dut {} is failed.".format(ipv6, dut))
result = False
if result or (i == retry):
break
i += 1
st.wait(time_delay)
return result
def l3tc_vrfipv4v6_address_ping_test(vrf_type='all',
config_type='all',
ping_count=3):
"""
:param vrf_type:
:param config_type:
:param ping_count:
:return:
"""
st.banner("Ping Checking between Spine and Leaf nodes.")
ipv4_adr = '11'
ipv6_adr = '67fe'
result = True
k = 1
i = 0
while i < (len(topo['dut_list']) - 1):
dut = topo['dut_list'][i]
peer_dut = topo['dut_list'][i + 1]
link = 1
for local, partner, remote in st.get_dut_links(dut, peer_dut):
if config_type == 'ipv4' or config_type == 'all':
ipaddr1 = "{}.{}.0.1".format(ipv4_adr, k)
ipaddr2 = "{}.{}.0.2".format(ipv4_adr, k)
if not ipapi.ping(
dut, ipaddr2, family='ipv4', count=ping_count):
st.log("{}- {} configured on {} - ping failed".format(
dut, local, ipaddr2))
result = False
if config_type == 'ipv6' or config_type == 'all':
ip6addr1 = "{}:{}::1".format(ipv6_adr, k)
ip6addr2 = "{}:{}::2".format(ipv6_adr, k)
if not ipapi.ping(
dut, ip6addr2, family='ipv6', count=ping_count):
st.log("{}- {} configured on {} - ping v6 failed".format(
dut, local, ip6addr2))
result = False
link += 1
break
k += 1
i += 1
return result
def test_mgmt_vrf_warmboot():
st.log("Warmboot the DUT")
report_flag = 0
st.reboot(vars.D1, "warm")
ip_addr = get_ifconfig_inet(vars.D1, 'eth0')
if not ip_addr:
st.report_fail('ip_verification_fail')
if not ping(vars.D1, mgmt_vrf.extip, interface=mgmt_vrf.vrfname):
report_flag = 1
if not ping(vars.D1, ip_addr[0], external=True):
report_flag = 1
if report_flag:
st.report_tc_fail("ft_mgmtVrf_warmboot", "mgmt_vrf_warmboot", "failed")
else:
st.report_tc_pass("ft_mgmtVrf_warmboot", "mgmt_vrf_warmboot",
"successful")
if report_flag:
st.report_fail("test_case_failed")
else:
st.report_pass("test_case_passed")
def test_ft_ipv6_link_local_manual():
result_flag = 0
st.log("Clearing all interface counters")
utils.exec_all(True, [[intf_obj.clear_interface_counters, vars.D1], [intf_obj.clear_interface_counters, vars.D2]])
st.log("clearing TG stats")
tgapi.traffic_action_control(tg_handler, actions=['clear_stats'])
ip_obj.delete_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, 'ipv6', "vtysh", data.prt_chnl)
utils.exec_all(True, [[ip_obj.config_interface_ip6_link_local,vars.D1, data.prt_chnl, 'disable'],
[ip_obj.config_interface_ip6_link_local,vars.D2, data.prt_chnl, 'disable']])
utils.exec_all(True, [[ip_obj.config_ip_addr_interface, vars.D1, data.prt_chnl, data.ip6_manual_ll_addr[0], data.tg_ip6_addr_mask_l[0], "ipv6", 'add'],
[ip_obj.config_ip_addr_interface, vars.D2, data.prt_chnl, data.ip6_manual_ll_addr[1], data.tg_ip6_addr_mask_l[1], "ipv6", 'add']])
utils.exec_all(True, [
[ip_obj.create_static_route, vars.D1, data.ip6_manual_ll_addr[1], data.static_rt_manual, "vtysh", 'ipv6', data.prt_chnl],
[ip_obj.create_static_route, vars.D2, data.tg_ip6_addr_l[1], data.static_rt_manual, "vtysh", 'ipv6', vars.D2T1P1]])
utils.exec_all(True, [[ip_obj.get_interface_ip_address, vars.D1, None, "ipv6"],
[ip_obj.get_interface_ip_address, vars.D2, None, "ipv6"]])
st.log("Get show ipv6 route output")
utils.exec_all(True, [[ip_obj.show_ip_route, vars.D1, "ipv6", "sonic", None],
[ip_obj.show_ip_route, vars.D2, "ipv6", "sonic", None]])
tg1.tg_traffic_config(mode='modify', stream_id=tg_str_data[1]["tg1_ipv6_data_str_id_1"],
ipv6_dst_addr=data.static_rt_manual_ip)
if not poll_verify_interface_ip_address(vars.D1, data.prt_chnl, ["{}%{}/64".format(data.ip6_manual_ll_addr[0], data.prt_chnl), "{}/64".format(data.ip6_manual_ll_addr[0])],10):
result_flag = 1
if not ip_obj.ping(vars.D1, data.ip6_manual_ll_addr[1], family='ipv6', interface = data.prt_chnl):
st.log("Ipv6 Ping over manual ipv6 Link Local address via the Port Channel based routing interface is failed.")
result_flag =1
tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"])
st.wait(1)
tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"])
tgapi.traffic_action_control(tg_handler, actions=['clear_stats'])
tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"])
st.wait(data.pkts_tx_time)
tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"])
traffic_details = {
'1': {
'tx_ports': [vars.T1D1P1],
'tx_obj': [tg1],
'exp_ratio': [1],
'rx_ports': [vars.T1D2P1],
'rx_obj': [tg2],
}
}
filter_result = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type='packet_count')
if not filter_result:
st.log("traffic loss observed for ipv6 traffic forwarded via ipv6 link local next hop")
result_flag = 1
if result_flag:
st.log("Show command for debugging purpose in case of failures")
utils.exec_all(True, [[intf_obj.show_interface_counters_all, vars.D1],
[intf_obj.show_interface_counters_all, vars.D2]])
st.report_fail("ip6_traffic_over_link_local_nh_fail_manual")
st.report_pass("test_case_passed")
def verify_ping_dut(src_dut, dest_ip_list):
'''
Verify ping to given list of IPs from src_dut (Detects IPV6 automatically)
:param src_dut: dut in which ping initiated
:param dest_ip_list: list of IPs which need to be ping
:return:
'''
dest_ip_list = [dest_ip_list
] if type(dest_ip_list) is str else dest_ip_list
ver_flag = True
for ip_addr in dest_ip_list:
res = re.search(r'.*:.*', ip_addr)
if res is None:
result = ip.ping(src_dut, ip_addr)
else:
result = ip.ping(src_dut, ip_addr, family='ipv6')
if not result:
print_log("FAIL:Ping failed to {} ".format(ip_addr), 'ERROR')
ver_flag = False
return ver_flag
def test_ft_ip_static_ip_on_mgmt_intrf():
"""
Author:Karthik Kumar Goud Battula([email protected])
Scenario: Verify the configuration of static ip address on eth0 interface and check the reachability
"""
result = True
vars = st.ensure_min_topology("D1", "CONSOLE_ONLY")
data.interface = 'eth0'
intf_obj.enable_dhcp_on_interface(vars.D1, data.interface)
st.wait(5)
ip_address_list = basic_obj.get_ifconfig_inet(vars.D1, data.interface)
if not ip_address_list:
st.report_fail("DUT_does_not_have_IP_address".format(
vars.D1, data.interface))
data.ip_address = ip_address_list[0]
data.netmask = basic_obj.get_ifconfig(vars.D1,
data.interface)[0]['netmask'][0]
data.gateway = basic_obj.get_ifconfig_gateway(vars.D1, data.interface)
intf_obj.config_static_ip_to_interface(vars.D1, data.interface,
data.ip_address, data.netmask,
data.gateway)
st.log("Verify connectivity from DUT")
if not ping_obj.ping(vars.D1, data.gateway):
st.error("Ping is not successful for address {}".format(data.gateway))
result = False
intf_obj.delete_ip_on_interface_linux(
vars.D1, data.interface, "{}/{}".format(data.ip_address, data.netmask))
ip_address_list = basic_obj.get_ifconfig_inet(vars.D1, data.interface)
if ip_address_list:
st.error("DUT_have_IP_address".format(vars.D1, data.interface))
result = False
intf_obj.enable_dhcp_on_interface(vars.D1, data.interface)
if not ping_obj.ping(vars.D1, data.gateway):
st.error("Ping is not successful for address".format(data.gateway))
result = False
if not result:
st.report_fail("test_case_failed")
st.report_pass("test_case_passed")
def dhcp_relay_module_config(request):
initialize_variables()
vars = st.ensure_min_topology("D1D2:1", "D2D3:2")
bind_class_action_copp_policy(vars.D3,
classifier='copp-system-dhcpl2',
action_group='copp-system-dhcp')
response = basic_obj.dhcp_server_config(
vars.D1,
dhcp_files_path=data.dhcp_files_path,
server_port=vars.D1D2P1,
server_ipv4=data.dhcp_server_ip,
route_list=data.route_list,
ipv4_relay_agent_ip=data.RA_ipaddress_1)
if not response:
st.report_fail("service_operation_status", "isc-dhcp-server",
"installation", "failed")
connected_port_ip_address_config()
if not basic_obj.check_interface_status(vars.D2, data.dhcp_relay_params,
"up"):
basic_obj.ifconfig_operation(vars.D2, data.dhcp_relay_params, "up")
if not ip_obj.ping(vars.D2, data.dhcp_server_ip):
st.log(
"Pinging to DHCP server failed from DUT, issue either with DUT or server"
)
st.report_fail("ping_fail", data.dhcp_server_ip)
basic_dhcp_relay_config_addition()
yield
response = basic_obj.dhcp_server_config(
vars.D1,
action="unconfig",
dhcp_files_path=data.dhcp_files_path,
server_port=vars.D1D2P1,
server_ipv4=data.dhcp_server_ip,
route_list=data.route_list,
ipv4_relay_agent_ip=data.RA_ipaddress_1)
if not response:
st.report_fail("service_operation_status", "isc-dhcp-server",
"uninstallation", "failed")
dhcp_relay_obj.dhcp_relay_config_remove(vars.D2,
vlan=data.vlan_int,
IP=data.dhcp_server_ip)
ip_obj.config_ip_addr_interface(vars.D2,
data.dhcp_relay_params,
data.RA_ipaddress_1,
data.subnet,
family=data.family,
config='remove')
ip_obj.clear_ip_configuration(st.get_dut_names())
ip_obj.clear_ip_configuration(st.get_dut_names(), 'ipv6')
vlan_obj.clear_vlan_configuration(st.get_dut_names())
def test_mgmt_vrf_reboot_cfgreload():
st.banner('mgmt_vrf_reboot, mgmt_vrf_cfgreload')
st.log("Config reload the DUT")
report_flag = 0
config_save_reload(vars.D1)
ip_addr = get_ifconfig_inet(vars.D1, 'eth0')
if not ip_addr:
st.report_fail('ip_verification_fail')
if not ping(vars.D1, mgmt_vrf.extip, interface=mgmt_vrf.vrfname):
report_flag = 1
if not ping(vars.D1, ip_addr[0], external=True):
report_flag = 1
if report_flag == 1:
st.report_tc_fail("ft_mgmtVrf_cfgreload", "mgmt_vrf_cfgreload_fail")
st.generate_tech_support(vars.D1, "ft_mgmtVrf_cfgreload")
else:
st.report_tc_pass("ft_mgmtVrf_cfgreload", "mgmt_vrf_cfgreload_pass")
config_save(vars.D1, "sonic")
config_save(vars.D1, "vtysh")
st.reboot(vars.D1)
ip_addr = get_ifconfig_inet(vars.D1, 'eth0')
if not ip_addr:
st.report_fail('ip_verification_fail')
if not ping(vars.D1, mgmt_vrf.extip, interface=mgmt_vrf.vrfname):
report_flag = 2
if not ping(vars.D1, ip_addr[0], external=True):
report_flag = 2
if report_flag == 2:
st.report_tc_fail("ft_mgmtVrf_reboot", "mgmt_vrf_reboot_fail")
st.generate_tech_support(vars.D1, "ft_mgmtVrf_reboot")
else:
st.report_tc_pass("ft_mgmtVrf_reboot", "mgmt_vrf_reboot_pass")
if report_flag:
st.report_fail("test_case_failed")
else:
st.report_pass("test_case_passed")
def test_ft_ipv6_link_local_ping():
report_flag = 0
if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = vars.D1D2P1):
st.log("Ipv6 Ping over Link Local address via the Port based routing interface is failed.")
report_flag = 1
if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = data.vlan_in_1):
st.log("Ipv6 Ping over Link Local address via the Vlan based routing interface is failed.")
report_flag =1
if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = data.prt_chnl):
st.log("Ipv6 Ping over Link Local address via the Port Channel based routing interface is failed.")
report_flag =1
# Get show ndp output
utils.exec_all(True, [[arp_obj.show_ndp, vars.D1, None], [arp_obj.show_ndp, vars.D2, None]])
d1_int_li = [vars.D2D1P1, vars.D2D1P2, data.prt_chnl]
intf_obj.interface_operation(vars.D2, [vars.D2D1P1, vars.D2D1P2, data.prt_chnl], operation="shutdown", skip_verify=True)
st.log("Waiting for 10 sec after shutdown the interfaces")
st.wait(10)
intf_obj.interface_status_show(vars.D1, [vars.D2D1P1, vars.D2D1P2, data.prt_chnl])
intf_obj.interface_operation(vars.D2, [vars.D2D1P1, vars.D2D1P2, data.prt_chnl], operation="startup",
skip_verify=True)
st.log("Polling for interface status after no shutdown")
for intf in d1_int_li:
if not intf_obj.poll_for_interface_status(vars.D2, intf, "oper", "up", iteration=5, delay=1):
st.error("Failed to startup interface {} on the DUT {}".format(intf, vars.D2))
report_flag = 0
if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = vars.D1D2P1):
st.log("After shut no shut, Ipv6 Ping over Link Local address via the Port based routing interface is failed.")
report_flag = 1
if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface=data.vlan_in_1):
st.log("After shut no shut, Ipv6 Ping over Link Local address via the Vlan based routing interface is failed.")
report_flag = 1
if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface=data.prt_chnl):
st.log("After shut no shut, Ipv6 Ping over Link Local address via the Port Channel based routing interface is failed.")
report_flag = 1
if report_flag:
st.report_fail("ip6_ping_fail_over_link_local_addr")
st.report_pass("test_case_passed")
def test_ft_control_plane_acl_icmp():
result = True
[output, exceptions] = parallel.exec_all(
True, [[st.get_mgmt_ip, vars.D1], [st.get_mgmt_ip, vars.D2]])
parallel.ensure_no_exception(exceptions)
d1_ipaddress, d2_ipaddress = output
d1_ipv6address = ip_obj.get_link_local_addresses(
vars.D1, "eth0", cli_type='click'
) ##Passing parameter cli_type as click until the SONIC-32291 fixed
if not d1_ipv6address:
st.report_fail('dut_not_getting_ip_address')
d1_ipv6address = d1_ipv6address[0]
st.log("Creating acl rules to drop icmp packets")
acl_config = acl_data.acl_json_config_control_plane_v2
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 ip_obj.ping(dut=vars.D2, addresses=d1_ipaddress):
st.error(
"ICMP ipv4 packets are not dropped with applied control plane acl rules."
)
result = False
st.report_tc_fail("ft_controlplane_acl_ipv4_icmp", "test_case_failed")
if ip_obj.ping(dut=vars.D1,
addresses=d1_ipv6address,
interface="eth0",
family="ipv6"):
st.error(
"ICMP ipv6 packets are not dropped with applied control plane acl rules."
)
result = False
st.report_tc_fail("ft_controlplane_acl_ipv6_icmp", "test_case_failed")
change_acl_rules(acl_config, "L3_IPV4_ICMP|rule1", "SRC_IP",
"{}/32".format(d2_ipaddress))
change_acl_rules(acl_config, "L3_IPV6_ICMP|rule1", "SRC_IPV6",
"{}/128".format(d1_ipv6address))
acl_obj.acl_delete(vars.D1)
acl_obj.apply_acl_config(vars.D1, acl_config)
if not ip_obj.ping(dut=vars.D2, addresses=d1_ipaddress):
st.error(
"ICMP ipv4 packets are dropped with applied control plane acl rules."
)
result = False
st.report_tc_fail("ft_controlplane_acl_seq_priority",
"test_case_failed")
st.report_tc_fail("ft_controlplane_acl_ipv4_icmp_permit",
"test_case_failed")
if not ip_obj.ping(
dut=vars.D1, addresses=d1_ipv6address, interface="eth0",
family="ipv6"):
st.error(
"ICMP ipv6 packets are dropped with applied control plane acl rules."
)
result = False
st.report_tc_fail("ft_controlplane_acl_ipv6_icmp_permit",
"test_case_failed")
config_save(vars.D1)
st.log('rebooting the device.')
st.reboot(vars.D1, 'fast')
if not ip_obj.ping(dut=vars.D2, addresses=d1_ipaddress):
st.error(
"control plane ipv4 acl functionality is failed after reboot.")
st.report_tc_fail("ft_controlplane_acl_reboot", "test_case_failed")
result = False
if not ip_obj.ping(
dut=vars.D1, addresses=d1_ipv6address, interface="eth0",
family="ipv6"):
st.error(
"control plane ipv6 acl functionality is failed after reboot.")
st.report_tc_fail("ft_controlplane_acl_reboot", "test_case_failed")
result = False
if not result:
st.report_fail("test_case_failed")
else:
st.report_pass("test_case_passed")
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 config_dhcpv6_options(ssh_conn_obj, ztp_params, config_params, options=dict(), cli_type=""):
"""
Common function to configure dhcpv6 options and verify the result on both inband and out of band interfaces
:param ssh_conn_obj:
:param ztp_params:
:param config_params:
:param options:
:return:
"""
cli_type = st.get_ui_type(config_params.dut, cli_type=cli_type)
retry_count = config_params.retry_count if "retry_count" in config_params and config_params.retry_count else 0
iteration = config_params.iteration if "iteration" in config_params and config_params.iteration else 300
delay = config_params.delay if "delay" in config_params and config_params.delay else 3
expect_reboot = True if "expect_reboot" in options and options ["expect_reboot"] else False
st.log(config_params)
if "func_name" in config_params:
syslog_file_names = ["syslog_1_{}".format(config_params.func_name), "syslog_{}".format(config_params.func_name)]
if "json_content" in config_params:
file_path = basic_obj.write_to_json_file(config_params.json_content)
st.log(file_path)
if file_path:
destination_path = "{}{}/{}".format(config_params.home_path, ztp_params.config_path, config_params.ztp_file)
st.log(destination_path)
basic_obj.copy_file_from_client_to_server(ssh_conn_obj, src_path=file_path, dst_path=destination_path)
config_params.option_59_url = "http://[{}]{}/{}".format(config_params.static_ip, ztp_params.config_path, config_params.ztp_file)
config_params.search_pattern = r'\s*option\s+dhcp6.boot-file-url\s+"\S+";'
write_option_59_to_dhcp_server(ssh_conn_obj, config_params)
basic_obj.service_operations(ssh_conn_obj, config_params.dhcp6_service_name, "restart", "server")
if not verify_dhcpd_service_status(ssh_conn_obj, config_params.dhcpd6_pid):
st.log("{} service is running which is not expected".format(config_params.dhcp6_service_name))
st.report_fail("service_running_not_expected", config_params.dhcp6_service_name)
reboot_type = config_params.reboot_type if "reboot_type" in config_params and config_params.reboot_type else "normal"
if "ztp_operation" in config_params:
config_params.ztp_operation = "reboot" if cli_type == "klish" else config_params.ztp_operation
if config_params.ztp_operation == "reboot":
basic_obj.remove_file(config_params.dut, config_params.config_db_path)
st.reboot(config_params.dut, reboot_type, skip_port_wait=True)
elif config_params.ztp_operation == "run":
ztp_operations(config_params.dut, config_params.ztp_operation)
else:
st.log("ZTP operation is not mentioned hence rebooting the device ...")
basic_obj.remove_file(config_params.dut, config_params.config_db_path)
st.reboot(config_params.dut, reboot_type, skip_port_wait=True)
if "reboot_on_success" in options and options["reboot_on_success"]:
result = verify_ztp_status(config_params.dut, retry_count, iteration, delay, expect_reboot=expect_reboot, reboot_on_success=options["reboot_on_success"], cli_type=cli_type)
else:
result = verify_ztp_status(config_params.dut, retry_count, iteration, delay, expect_reboot=expect_reboot, cli_type=cli_type)
if not result:
if "logs_path" in config_params and "func_name" in config_params:
capture_syslogs(config_params.dut, config_params.logs_path, syslog_file_names)
st.log("ZTP status verification failed")
st.report_fail("ztp_status_verification_failed")
if "reboot_on_success" in options and options["reboot_on_success"]:
reboot_obj.config_reload(config_params.dut)
st.wait(5)
if not ip_obj.ping(config_params.dut, config_params.static_ip, family="ipv6"):
st.log("Pinging to DHCP server failed from DUT, issue either with DUT or server")
# intf_obj.enable_dhcp_on_interface(config_params.dut, config_params.network_port, "v6")
if not verify_ztp_status(config_params.dut, retry_count, iteration, delay, cli_type=cli_type):
if "logs_path" in config_params and "func_name" in config_params:
capture_syslogs(config_params.dut, config_params.logs_path, syslog_file_names)
st.log("ZTP status verification failed")
st.report_fail("ztp_status_verification_failed")
verify_ztp_filename_logs(config_params.dut, config_params)
if "ztp_log_string" in config_params and config_params.ztp_log_string:
if not basic_obj.poll_for_error_logs(config_params.dut, config_params.ztp_log_path, config_params.ztp_log_string):
st.log("ZTP log {} verification failed for message {}".format(config_params.ztp_log_path, config_params.ztp_log_string))
if not basic_obj.poll_for_error_logs(config_params.dut, config_params.ztp_log_path_1, config_params.ztp_log_string):
st.log("ZTP log {} verification failed for message {}".format(config_params.ztp_log_path_1, config_params.ztp_log_string))
st.report_fail("ztp_log_verification_failed", config_params.ztp_log_path_1, config_params.ztp_log_string)
if "result" in config_params and config_params.result == "pass":
st.report_pass("test_case_passed")
def l3_intf_scaling_tc_6_1_to_6_5():
(dut) = (data.dut)
vars = st.get_testbed_vars()
tc_fail_flag = 0
member3 = vars.D1T1P3
member4 = vars.D1T1P4
json_path = os.getcwd()
apply_file = True
res1 = True
json_apply_path = json_path+"/routing/th2-270_ve_config_db.json"
#st.apply_files(dut, ["$PWD/tests/routing/1k_ve_config_db.json"])
if apply_file is True:
st.apply_files(dut, [json_apply_path])
# L3 INTF SCALING TEST CASE 1.1 START
st.wait(30)
data.my_dut_list = st.get_dut_names()
#dut1 = data.my_dut_list[0]
#res1 = verify_ve_count(dut)
if (res1):
data.result[0] = True
# L3 traffic streams
#For now Spirent link with 100G is not working , so the below code from START to END just books spirent port, it will be rectified
# once infra team provides support for RS-FEC
#START
(tg1, tg_ph_1, tg2, tg_ph_2) = get_handles()
st.log("INTFCONF: "+str(member3))
st.log("INTFCONF: "+str(member4))
tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1)
tg2.tg_traffic_control(action='reset', port_handle=tg_ph_2)
h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.3.49.10', gateway='10.3.49.1', src_mac_addr='00:0a:01:00:00:01', vlan='1', vlan_id='305', vlan_id_count=data.intf_count, arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0', vlan_id_step='1')
#import pdb;pdb.set_trace()
edit_vid = 305
st.wait(15)
#END
if res1:
st.log("Interface Scaling Test Case 6.2 PASSED PING TEST")
st.log("INTFCONF: "+str(res1))
dut1 = dut
# L3 INTF SCALING TEST CASE 1.2 START
# For now ping for only one ip . We intend to use 10 ip for ping test
# As of now the ping goes to next connected one spirent host
#Once spirent works fine , the below ping/arp resolution will ping to spirent hosts
result1 = verify_arp_entry(dut, edit_vid, data.t1d1_ip_addr)
if result1:
st.log("Interface Scaling Test Case 6.2 PASSED ")
data.result[1] = True
else:
tc_fail_flag = 1
st.log("Ping operation_failed")
tg1.tg_interface_config(port_handle=tg_ph_1, handle=h1['handle'], mode='destroy')
# L3 INTF SCALING TEST CASE 1.2 END
# L3 INTF SCALING TEST CASE 1.3 START
clear_arp_entries(dut)
st.wait(15)
h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.3.49.10', gateway='10.3.49.1', src_mac_addr='00:0a:01:00:00:01', vlan='1', vlan_id='305', vlan_id_count=data.intf_count, arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0', vlan_id_step='1')
st.wait(30)
result1 = verify_arp_entry(dut, edit_vid, data.t1d1_ip_addr)
if result1:
st.log("Interface Scaling Test Case 6.3 PASSED ")
data.result[2] = True
else:
tc_fail_flag = 1
st.log("Ping operation_failed")
tg1.tg_interface_config(port_handle=tg_ph_1, handle=h1['handle'], mode='destroy')
# L3 INTF SCALING TEST CASE 6.3 END
# L3 INTF SCALING TEST CASE 1.4 START
trigger_link_flap(dut1, member3)
st.wait(30)
h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.3.49.10', gateway='10.3.49.1', src_mac_addr='00:0a:01:00:00:01', vlan='1', vlan_id='305', vlan_id_count=data.intf_count, arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0', vlan_id_step='1')
st.wait(30)
st.log("INTFCONF: "+str(res1))
ipfeature.ping(dut1, data.t1d1_ip_addr)
result1 = verify_arp_entry(dut, edit_vid, data.t1d1_ip_addr)
if result1:
st.log("Interface Scaling Test Case 6.4 PASSED ")
data.result[3] = True
else:
st.log("Ping operation_failed")
tc_fail_flag = 1
# st.report_fail("Ping operation_failed")
tg1.tg_interface_config(port_handle=tg_ph_1, handle=h1['handle'], mode='destroy')
# L3 INTF SCALING TEST CASE 1.4 END
# L3 INTF SCALING TEST CASE 1.5 START
verify_ip_from_vlan_interface(dut1, edit_vid)
ipfeature.delete_ip_interface(dut, 'Vlan'+str(edit_vid), data.d1t1_ip_addr, subnet="24")
ipfeature.config_ip_addr_interface(dut, 'Vlan'+str(edit_vid), data.d1t1_ip_addr, data.ip_prefixlen, family="ipv4")
h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.3.49.10', gateway='10.3.49.1', src_mac_addr='00:0a:01:00:00:01', vlan='1', vlan_id='305', vlan_id_count=data.intf_count, arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0', vlan_id_step='1')
st.wait(30)
st.log("INTFCONF: "+str(res1))
ipfeature.ping(dut1, data.t1d1_ip_addr)
result1 = verify_arp_entry(dut, edit_vid, data.t1d1_ip_addr)
if result1:
st.log("Interface Scaling Test Case 6.5 PASSED ")
data.result[4] = True
else:
st.log("Ping operation_failed")
tc_fail_flag = 1
# st.report_fail("Ping operation_failed")
tg1.tg_interface_config(port_handle=tg_ph_1, handle=h1['handle'], mode='destroy')
# L3 INTF SCALING TEST CASE 1.5 END
# L3 INTF SCALING TEST CASE 1.6 START
#ipfeature.delete_ip_interface(dut, 'Vlan'+str(edit_vid), data.d1t1_ip_addr, subnet="24")
#vapi.delete_vlan_member(dut, edit_vid, [vars.D2T1P1])
#vapi.delete_vlan(dut,[edit_vid])
# vapi.create_vlan(dut, [edit_vid])
#vapi.add_vlan_member(dut, edit_vid, [vars.D2T1P1], True)
#ipfeature.config_ip_addr_interface(dut, 'Vlan'+str(edit_vid), data.d1t1_ip_addr, data.ip_prefixlen, family="ipv4")
#st.wait(30)
#h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.3.49.10', gateway='10.3.49.1', src_mac_addr='00:0a:01:00:00:01', vlan='1', vlan_id='305', vlan_id_count=data.intf_count, arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0')
#res1=verify_ping(src_obj=tg1, port_handle=tg_ph_1, dev_handle=h1['handle'], dst_ip='10.3.49.1',\
# ping_count='6', exp_count='6')
#st.log("INTFCONF: "+str(res1))
#ipfeature.ping(dut1, data.t1d1_ip_addr)
#result1 = verify_arp_entry(dut, edit_vid, data.t1d1_ip_addr)
#if result1:
# st.log("Interface Scaling Test Case 6.6 PASSED ")
#else:
# st.log("Ping operation_failed")
# tc_fail_flag = 1
#json_apply_path = json_path+"/routing/td3_restore_config_db.json"
#st.apply_files(dut, ["$PWD/tests/routing/1k_ve_config_db.json"])
st.clear_config(dut1)
#tg1.tg_interface_config(port_handle=tg_ph_1, handle=h1['handle'], mode='destroy')
# L3 INTF SCALING TEST CASE 1.6 END
if tc_fail_flag == 0:
st.log("Interface Scaling Test Case 6.1 6.2 6.3 6.4 6.5 PASSED")
st.report_pass("test_case_passed")
else:
st.log("IPV4 Route Scaling Test Case FAILURE Seen");
st.report_fail("test_case_failed")
st.report_pass("operation_successful")
def verify_tacacs_server_reachability(dut, tacacs_ser_ip):
st.log("Verify that tacacs server connectivity from DUT")
if not ping_obj.ping(dut, tacacs_ser_ip):
st.report_fail("Ping_to_tacacs_server_is_not_successful",
tacacs_ser_ip)
def test_ft_ip_v4_v6_L2_L3_translation():
# Objective - Verify that L2 port to IPv4 L3 port transition and vice-versa is successful.
st.log("Checking IPv4 ping from {} to {} over routing interface".format(
vars.D1, vars.D2))
if not ipfeature.ping(
vars.D1, data.ip4_addr[7], family=data.af_ipv4, count=1):
st.report_fail("ping_fail", data.ip4_addr[6], data.ip4_addr[7])
st.log(
"Checking IPv6 ping from {} to {} over vlan routing interface".format(
vars.D1, vars.D2))
if not ipfeature.ping(
vars.D2, data.ip6_addr[6], family=data.af_ipv6, count=1):
st.report_fail("ping_fail", data.ip6_addr[7], data.ip6_addr[6])
st.log("L3 to L2 port transition")
st.log("Removing ipv4,ipv6 address from interface")
ipfeature.delete_ip_interface(vars.D1,
vars.D1D2P4,
data.ip4_addr[6],
24,
family=data.af_ipv4)
ipfeature.delete_ip_interface(vars.D2,
vars.D2D1P4,
data.ip4_addr[7],
24,
family=data.af_ipv4)
ipfeature.delete_ip_interface(vars.D1,
vars.D1D2P4,
data.ip6_addr[6],
96,
family=data.af_ipv6)
ipfeature.delete_ip_interface(vars.D2,
vars.D2D1P4,
data.ip6_addr[7],
96,
family=data.af_ipv6)
ipfeature.delete_ip_interface(vars.D1,
vars.D1T1P1,
data.ip4_addr[1],
24,
family=data.af_ipv4)
ipfeature.delete_ip_interface(vars.D2,
vars.D2T1P1,
data.ip4_addr[8],
24,
family=data.af_ipv4)
st.log("Removing the static routes")
ipfeature.delete_static_route(vars.D1,
data.ip4_addr[7],
data.static_ip_rt,
shell=data.shell_vtysh,
family=data.af_ipv4)
ipfeature.delete_static_route(vars.D1,
data.static_ip6_rt_drop,
data.static_ip6_rt,
shell=data.shell_vtysh,
family=data.af_ipv6)
st.log("Vlan creation and port association configuration")
vlan_obj.create_vlan(vars.D1, data.vlan_2)
st.log("Adding back to back connecting ports to vlan {}".format(
data.vlan_2))
vlan_obj.add_vlan_member(vars.D1,
data.vlan_2, [vars.D1D2P4],
tagging_mode=True)
vlan_obj.create_vlan(vars.D2, data.vlan_2)
vlan_obj.add_vlan_member(vars.D2,
data.vlan_2, [vars.D2D1P4],
tagging_mode=True)
st.log("Adding TG connecting ports to vlan {}".format(data.vlan_1))
vlan_obj.add_vlan_member(vars.D1,
data.vlan_2,
vars.D1T1P1,
tagging_mode=True)
vlan_obj.add_vlan_member(vars.D2,
data.vlan_2,
vars.D2T1P1,
tagging_mode=True)
tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D2P1")
tg.tg_traffic_control(action="reset", port_handle=tg_handler["tg_ph_list"])
tg.tg_traffic_control(action="clear_stats",
port_handle=tg_handler["tg_ph_list"])
tr2 = tg.tg_traffic_config(port_handle=tg_handler["tg_ph_2"],
mode='create',
rate_pps="2000",
mac_src_mode="fixed",
transmit_mode="single_burst",
pkts_per_burst=2000,
length_mode='fixed',
l2_encap='ethernet_ii_vlan',
vlan_id=data.vlan_2,
mac_dst_mode="fixed",
vlan="enable",
mac_src="00:a1:bb:cc:dd:01",
mac_dst="00:b1:bb:cc:dd:01")
st.log("TRAFCONF: " + str(tr2))
res = tg.tg_traffic_control(action='run', stream_handle=tr2['stream_id'])
tg.tg_traffic_control(action='stop', stream_handle=tr2['stream_id'])
st.wait(data.wait_tgstats)
st.log("TR_CTRL: " + str(res))
st.log("Fetching TGen statistics")
stats_tg1 = tgapi.get_traffic_stats(tg_handler["tg"],
mode="aggregate",
port_handle=tg_handler["tg_ph_2"])
total_tx_tg1 = stats_tg1.tx.total_packets
stats_tg2 = tgapi.get_traffic_stats(tg_handler["tg"],
mode="aggregate",
port_handle=tg_handler["tg_ph_1"])
total_rx_tg2 = stats_tg2.rx.total_packets
st.log("total_tx_tg1 = {}".format(total_tx_tg1))
total_tx_tg1_95_percentage = int(total_tx_tg1) * 0.95
st.log("total_tx_tg1_95_percentage= {}".format(total_tx_tg1_95_percentage))
st.log("total_rx_tg2 = {}".format(total_rx_tg2))
if int(total_tx_tg1_95_percentage) > int(total_rx_tg2):
st.report_fail("traffic_verification_failed")
st.log("Removing vlan configuration")
vlan_obj.delete_vlan_member(vars.D1, data.vlan_2,
[vars.D1D2P4, vars.D1T1P1], True)
vlan_obj.delete_vlan_member(vars.D2, data.vlan_2,
[vars.D2D1P4, vars.D2T1P1], True)
st.log("L2 to L3 port transition")
ipfeature.config_ip_addr_interface(vars.D1,
vars.D1D2P4,
data.ip4_addr[6],
24,
family=data.af_ipv4)
ipfeature.config_ip_addr_interface(vars.D2,
vars.D2D1P4,
data.ip4_addr[7],
24,
family=data.af_ipv4)
ipfeature.create_static_route(vars.D1,
data.ip4_addr[7],
data.static_ip_rt,
shell=data.shell_vtysh,
family=data.af_ipv4)
st.log("Checking IPv4 ping from {} to {} over routing interface".format(
vars.D1, vars.D2))
if not ipfeature.ping(
vars.D1, data.ip4_addr[7], family=data.af_ipv4, count=1):
st.report_fail("ping_fail", data.ip4_addr[6], data.ip4_addr[7])
ipfeature.config_ip_addr_interface(vars.D1,
vars.D1D2P4,
data.ip6_addr[6],
96,
family=data.af_ipv6)
ipfeature.config_ip_addr_interface(vars.D2,
vars.D2D1P4,
data.ip6_addr[7],
96,
family=data.af_ipv6)
ipfeature.create_static_route(vars.D1,
data.static_ip6_rt_drop,
data.static_ip6_rt,
shell=data.shell_vtysh,
family=data.af_ipv6)
st.log(
"Checking IPv6 ping from {} to {} over vlan routing interface".format(
vars.D1, vars.D2))
if not ipfeature.ping(
vars.D2, data.ip6_addr[6], family=data.af_ipv6, count=1):
st.report_fail("ping_fail", data.ip6_addr[7], data.ip6_addr[6])
st.report_pass("test_case_passed")
def verify_traffic_results(dut):
vars = st.get_testbed_vars()
tc_fail_flag = 0
member3 = vars.D2T1P3
member4 = vars.D2T1P4
res1 = True
dut1 = dut
v_range_t = str(data.tc6_xbase_vlan) + " " + str(data.tc6_xbase_vlan +
data.max_vlan_count - 1)
vapi.config_vlan_range_members(dut1, v_range_t, member3)
if (res1):
data.result[0] = True
(tg1, tg_ph_1, tg2, tg_ph_2) = get_handles_1()
clear_arp_entries(dut)
arpapi.show_arp(dut)
st.wait(15)
st.log("INTFCONF: " + str(member3))
st.log("INTFCONF: " + str(member4))
tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1)
tg2.tg_traffic_control(action='reset', port_handle=tg_ph_2)
h1 = tg1.tg_interface_config(port_handle=tg_ph_1,
mode='config',
intf_ip_addr='10.0.62.10',
gateway='10.0.62.1',
src_mac_addr='00:0a:01:00:00:01',
vlan='1',
vlan_id='61',
vlan_id_count=data.intf_count,
arp_send_req='1',
gateway_step='0.0.1.0',
intf_ip_addr_step='0.0.1.0',
vlan_id_step='1')
#pdb.set_trace()
edit_vid = 219
st.wait(15)
arpapi.show_arp(dut)
#END
if res1:
st.log("Interface Scaling Test Case 6.2 PASSED PING TEST")
dut1 = dut
# L3 INTF SCALING TEST CASE 1.2 START
result1 = verify_arp_entry(dut, edit_vid, data.tc6_xt1d1_ip_addr)
if result1:
st.log("Interface Scaling Test Case 6.2 PASSED ")
data.tc6_xresult[0] = True
data.tc6_xresult[1] = True
else:
tc_fail_flag = 1
st.log("Ping operation_failed")
#tg1.tg_interface_config(port_handle=tg_ph_1, handle=h1['handle'], mode='destroy')
# L3 INTF SCALING TEST CASE 1.2 END
# L3 INTF SCALING TEST CASE 1.3 START
clear_arp_entries(dut)
st.wait(15)
trigger_link_flap(dut1, member3)
tg1.tg_arp_control(handle=h1['handle'], arp_target='all')
st.wait(30)
arpapi.show_arp(dut)
#h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.0.62.10', gateway='10.0.62.1', src_mac_addr='00:0a:01:00:00:01', vlan='1', vlan_id='61', vlan_id_count=data.intf_count, arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0', vlan_id_step='1')
#st.wait(30)
result1 = verify_arp_entry(dut, edit_vid, data.tc6_xt1d1_ip_addr)
if result1:
st.log("Interface Scaling Test Case 6.3 PASSED ")
data.tc6_xresult[2] = True
else:
tc_fail_flag = 1
st.log("Ping operation_failed")
#tg1.tg_interface_config(port_handle=tg_ph_1, handle=h1['handle'], mode='destroy')
# L3 INTF SCALING TEST CASE 6.3 END
# L3 INTF SCALING TEST CASE 1.4 START
trigger_link_flap(dut1, member3)
st.wait(30)
tg1.tg_arp_control(handle=h1['handle'], arp_target='all')
#h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.0.62.10', gateway='10.0.62.1', src_mac_addr='00:0a:01:00:00:01', vlan='1', vlan_id='61', vlan_id_count=data.intf_count, arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0', vlan_id_step='1')
st.wait(30)
arpapi.show_arp(dut)
ipfeature.ping(dut1, data.tc6_xt1d1_ip_addr)
result1 = verify_arp_entry(dut, edit_vid, data.tc6_xt1d1_ip_addr)
if result1:
st.log("Interface Scaling Test Case 6.4 PASSED ")
data.tc6_xresult[3] = True
else:
st.log("Ping operation_failed")
tc_fail_flag = 1
# st.report_fail("Ping operation_failed")
#tg1.tg_interface_config(port_handle=tg_ph_1, handle=h1['handle'], mode='destroy')
# L3 INTF SCALING TEST CASE 1.4 END
# L3 INTF SCALING TEST CASE 1.5 START
verify_ip_from_vlan_interface(dut1, edit_vid)
ipfeature.delete_ip_interface(dut,
'Vlan' + str(edit_vid),
data.tc6_xd1t1_ip_addr,
subnet="24")
ipfeature.config_ip_addr_interface(dut,
'Vlan' + str(edit_vid),
data.tc6_xd1t1_ip_addr,
data.ip_prefixlen,
family="ipv4")
tg1.tg_arp_control(handle=h1['handle'], arp_target='all')
#h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.0.62.10', gateway='10.0.62.1', src_mac_addr='00:0a:01:00:00:01', vlan='1', vlan_id='61', vlan_id_count=data.intf_count, arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0', vlan_id_step='1')
st.wait(30)
arpapi.show_arp(dut)
ipfeature.ping(dut1, data.tc6_xt1d1_ip_addr)
result1 = verify_arp_entry(dut, edit_vid, data.tc6_xt1d1_ip_addr)
if result1:
st.log("Interface Scaling Test Case 6.5 PASSED ")
data.tc6_xresult[4] = True
else:
st.log("Ping operation_failed")
tc_fail_flag = 1
# st.report_fail("Ping operation_failed")
tg1.tg_interface_config(port_handle=tg_ph_1,
handle=h1['handle'],
mode='destroy')
if tc_fail_flag == 0:
st.log("Interface Scaling Test Case 6.1 6.2 6.3 6.4 6.5 PASSED")
st.report_pass("test_case_passed")
else:
st.log("IPV4 Route Scaling Test Case FAILURE Seen")
st.report_pass("operation_successful")
