def test_ft_arp_static_route_config_mgmt_verifying_config_with_warm_reboot():
'''
Author: Surendra Kumar Vella([email protected])
Verify static ARP route config after warm-reboot
'''
st.log("Checking whether the platform supports warm-reboot")
if not data.platform.lower(
) in data.constants['WARM_REBOOT_SUPPORTED_PLATFORMS']:
st.report_unsupported('test_case_unsupported')
st.log("Performing warm-reboot on DUT")
st.reboot(vars.D1, "warm")
st.log("Verifying static route entries after save and warm-reboot")
st.wait(5)
static_route_verify()
st.log("Verifying dynamic ARP entries after save and warm-reboot")
if not arp_obj.verify_arp(vars.D1, data.ipv4_address_tgen,
data.src_mac_addr, vars.D1T1P1):
st.report_fail("ARP_entry_dynamic_entry_fail", data.ipv4_address_tgen,
vars.D1)
else:
st.log("Verified that dynamic ARP entry is present in arp table")
if st.get_ui_type(vars.D1) != "click":
st.log("Verifying static ARP entries after save and warm-reboot")
if not arp_obj.verify_arp(vars.D1, data.static_arp_ip,
data.static_arp_mac, ""):
st.report_fail("static_arp_create_fail", vars.D1)
else:
st.log("Verified that static ARP entry is present in arp table")
st.report_pass("test_case_passed")
def nat_pre_config():
global vars
vars = st.ensure_min_topology("D1D2:1", "D2D3:1")
platform = basic_obj.get_hwsku(vars.D2)
common_constants = st.get_datastore(vars.D2, "constants", "default")
if platform.lower() in common_constants['TH3_PLATFORMS']:
st.error("NAT is not supported for this platform {}".format(platform))
st.report_unsupported('NAT_unsupported_platform',platform)
ip_obj.config_ip_addr_interface(vars.D1, vars.D1D2P1, data.d1d2_ip_addr, data.ip_addr_mask, family=data.af_ipv4)
ip_obj.config_ip_addr_interface(vars.D2, vars.D2D1P1, data.d2d1_ip_addr, data.ip_addr_mask, family=data.af_ipv4)
ip_obj.config_ip_addr_interface(vars.D2, vars.D2D3P1, data.d2d3_ip_addr, data.ip_addr_mask, family=data.af_ipv4)
ip_obj.config_ip_addr_interface(vars.D3, vars.D3D2P1, data.d3d2_ip_addr, data.ip_addr_mask, family=data.af_ipv4)
ip_obj.create_static_route(vars.D1, data.d2d1_ip_addr,"{}/{}".format(data.d1_static_nw, data.ip_addr_mask),
shell=data.shell_vtysh, family=data.af_ipv4)
ip_obj.create_static_route(vars.D3, data.d2d3_ip_addr, "{}/{}".format(data.d3_static_nw, data.ip_addr_mask),
shell=data.shell_vtysh, family=data.af_ipv4)
st.log("NAT Configuration")
nat_obj.config_nat_feature(vars.D2, 'enable')
util_nat_zone_config(vars.D2, [vars.D2D1P1, vars.D2D3P1], [data.zone_1, data.zone_2], config=data.config_add)
st.log("Creating NAT Pool")
nat_obj.config_nat_pool(vars.D2, pool_name=data.pool_name[0], global_ip_range=data.d2d1_ip_addr,
global_port_range=data.global_port_range, config=data.config_add)
st.log("Creating NAT Pool binding")
nat_obj.config_nat_pool_binding(vars.D2, binding_name=data.bind_name[0], pool_name=data.pool_name[0],
config=data.config_add)
utils.exec_all(True, [[ip_obj.show_ip_route, vars.D1], [ip_obj.show_ip_route, vars.D2]])
ip_obj.show_ip_route(vars.D3)
def test_ft_dynamic_nat_warmboot():
# ################ Author Details ################
# Name: Kesava Swamy Karedla
# Eamil: [email protected]
# ################################################
# Objective - FtOpSoRoNatWb001 - Verify warm boot with dynamic nat scaling entries.
# #################################################
result_flag=0
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('test_case_unsupported')
nat_obj.clear_nat(vars.D1, translations=True)
nat_obj.config_nat_pool_binding(vars.D1, binding_name=data.bind_name[0], pool_name=data.pool_name[0],
config=data.config_del)
nat_obj.config_nat_pool_binding(vars.D1, binding_name="scale_bind", pool_name="scale_pool",
acl_name=data.acl_table_in_nat_eg, config=data.config_add)
st.log("Sending continuous traffic at 600 pps for the max dynamic nat entries to get learned")
tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_scale_nat_udp_data_str_id_1"])
st.log("Waiting for traffic to run, such that max nat entries get learned")
if not util_check_nat_translations_count(vars.D1,20,data.max_nat_entries):
nat_reboot_debug_fun()
st.log("Failed to learn max nat entries")
result_flag = 1
tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_scale_nat_udp_data_str_id_1"])
# Show command for debugging purpose in case of failures.
intf_obj.show_interface_counters_all(vars.D1)
st.log("Warm boot verification")
tgapi.traffic_action_control(tg_handler, actions=['clear_stats'])
tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_scale_nat_udp_data_str_id_1"])
st.log("Performing warm-reboot, while traffic is forwarding for nat entries")
st.reboot(vars.D1, 'warm')
tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_scale_nat_udp_data_str_id_1"])
traffic_details = {
'1': {
'tx_ports': [vars.T1D1P1],
'tx_obj': [tg1],
'exp_ratio': [1],
'rx_ports': [vars.T1D1P2],
'rx_obj': [tg2],
}
}
filter_result = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type='packet_count')
if not filter_result:
nat_reboot_debug_fun()
st.log("Traffic loss observed for the SNAT traffic during warm-boot")
result_flag = 1
nat_obj.config_nat_pool_binding(vars.D1, binding_name=data.bind_name[1], pool_name=data.pool_name[1],
config=data.config_add)
nat_obj.config_nat_pool_binding(vars.D1, binding_name="scale_bind", pool_name="scale_pool",
acl_name=data.acl_table_in_nat_eg, config=data.config_del)
if result_flag:
st.report_fail("nat_warm_reboot_failed")
st.report_pass("test_case_passed")
def tf_rest_support_checker():
if tf_rest_supported:
st.log(
"Threshold REST - Supported in this Build, Hence test proceeding..."
)
else:
st.log(
"Threshold REST - NOT Supported in this Build, Hence test moving to UnSupported..."
)
st.report_unsupported('test_case_unsupported')
def test_ft_enable_kdump():
vars = st.get_testbed_vars()
if not st.is_feature_supported("show-kdump-status-command", vars.D1):
st.report_unsupported('test_case_unsupported')
result = perform_test(vars)
clean_up(vars)
st.config(vars.D1, 'rm -rf /var/crash/20*')
if result: st.report_fail("msg", result)
st.report_pass("operation_successful")
def new_version(version, flag="major"):
if version:
try:
[major, minor, patch] = version.split(".")
if flag == "major":
major = str(int(major) + 1)
elif flag == "minor":
minor = str(int(minor) + 1)
elif flag == "patch":
patch = str(int(patch) + 1)
return "{}.{}.{}".format(major, minor, patch)
except ValueError as e:
st.error(e)
st.report_unsupported("ocyang_unsupported_build_version")
return version
def initialize_topology_vars():
global vars, tg, d3_tg_ph1, d3_tg_ph2, d4_tg_ph1, d4_tg_ph2, d5_tg_ph1, d5_tg_ph2, tg_all, dut_list
vars = st.ensure_min_topology("D1D3:3", "D1D4:3", "D1D5:3", "D2D3:3",
"D2D4:3", "D2D5:3", "D3T1:2", "D4T1:2",
"D5T1:2", "D3CHIP=TD3", "D4CHIP=TD3",
"D5CHIP=TD3")
vars = st.get_testbed_vars()
if st.get_ui_type() == 'click':
st.report_unsupported("test_execution_skipped",
"Skipping cli mode CLICK")
data.dut_list = st.get_dut_names()
data.rtr_list = data.dut_list[0:]
data.leaf_list = data.rtr_list[2:]
data.dut1 = data.dut_list[0]
data.dut2 = data.dut_list[1]
data.dut3 = data.dut_list[2]
data.dut4 = data.dut_list[3]
data.dut5 = data.dut_list[4]
dut_list = [data.dut1, data.dut2, data.dut3, data.dut4, data.dut5]
data.d1d3_ports = [vars.D1D3P1, vars.D1D3P2, vars.D1D3P3]
data.d3d1_ports = [vars.D3D1P1, vars.D3D1P2, vars.D3D1P3]
data.d1d4_ports = [vars.D1D4P1, vars.D1D4P2, vars.D1D4P3]
data.d4d1_ports = [vars.D4D1P1, vars.D4D1P2, vars.D4D1P3]
data.d1d5_ports = [vars.D1D5P1, vars.D1D5P2, vars.D1D5P3]
data.d5d1_ports = [vars.D5D1P1, vars.D5D1P2, vars.D5D1P3]
data.d2d3_ports = [vars.D2D3P1, vars.D2D3P2, vars.D2D3P3]
data.d3d2_ports = [vars.D3D2P1, vars.D3D2P2, vars.D3D2P3]
data.d2d4_ports = [vars.D2D4P1, vars.D2D4P2, vars.D2D4P3]
data.d4d2_ports = [vars.D4D2P1, vars.D4D2P2, vars.D4D2P3]
data.d2d5_ports = [vars.D2D5P1, vars.D2D5P2, vars.D2D5P3]
data.d5d2_ports = [vars.D5D2P1, vars.D5D2P2, vars.D5D2P3]
data.t1d3_ports = [vars.T1D3P1, vars.T1D3P2]
data.t1d4_ports = [vars.T1D4P1, vars.T1D4P2]
data.t1d5_ports = [vars.T1D5P1, vars.T1D5P2]
data.d3t1_ports = [vars.D3T1P1, vars.D3T1P2]
data.d4t1_ports = [vars.D4T1P1, vars.D4T1P2]
data.d5t1_ports = [vars.D5T1P1, vars.D5T1P2]
tg = tgapi.get_chassis(vars)
d3_tg_ph1, d3_tg_ph2 = tg.get_port_handle(vars.T1D3P1), tg.get_port_handle(
vars.T1D3P2)
d4_tg_ph1, d4_tg_ph2 = tg.get_port_handle(vars.T1D4P1), tg.get_port_handle(
vars.T1D4P2)
d5_tg_ph1, d5_tg_ph2 = tg.get_port_handle(vars.T1D5P1), tg.get_port_handle(
vars.T1D5P2)
tg_all = [d3_tg_ph1, d3_tg_ph2, d4_tg_ph1, d4_tg_ph2, d5_tg_ph1, d5_tg_ph2]
def security_warm_reboot_module_hooks(request):
# add things at the start of this module
init_vars()
initialize_variables()
get_parms()
st.log("Checking whether the platform supports warm-reboot")
if not data.platform.lower() in data.constants['WARM_REBOOT_SUPPORTED_PLATFORMS']:
st.report_unsupported('test_case_unsupported')
st.log("configuring tacacs server")
tacacs_config()
st.log("Verifying tacacs server details in running-config before warm-reboot")
tacacs_config_verify()
yield
# add things at the end of this module"
#Below step will clear the TACACS+ server config from the device
tacacs_params = st.get_service_info(vars.D1, "tacacs")
tacacs_obj.set_tacacs_server(vars.D1, 'delete', tacacs_params.hosts[0].ip)
def test_ft_tf_config_priority_group_headroom_rest():
"""
Author : Prudvi Mangadu ([email protected])
"""
if tf_rest_data.platform and tf_rest_data.platform.lower(
) in tf_rest_data.pg_headroom_un_supported_platforms:
st.error(
"Threshold priority-group headroom is not supported for this platform ({})"
.format(tf_rest_data.platform))
st.report_unsupported('test_case_unsupported')
data = {
'dut': vars.D1,
'threshold_type': "priority-group",
'buffer_type': 'headroom',
'index_name': 'pg4',
'port_alias': dut_port[0],
'threshold_value': 89
}
tf_rest_config_testing(**data)
def chef_module_hooks(request):
global vars
vars = st.ensure_min_topology("D1")
if st.get_ui_type() in ['klish']:
st.report_unsupported(
'test_execution_skipped',
'Skipping Chef test case for ui_type={}'.format(st.get_ui_type()))
global free_ports
global node_name
global exclude_list
global free_ports_samespeed
free_ports = st.get_free_ports(vars.D1)
if not free_ports:
st.log("No free ports available")
st.report_env_fail("test_case_not_executeds")
vlan_members = [free_ports[0], free_ports[1], free_ports[2]]
st.log("VLAN Members: {}".format(",".join(vlan_members)))
free_ports_samespeed = get_free_ports_speed_list(vars.D1, vlan_members)
st.log("Free ports same speed: {}".format(",".join(free_ports_samespeed)))
exclude_list = vlan_members + [
free_ports_samespeed[0], free_ports_samespeed[1],
free_ports_samespeed[2]
]
node_name = 'testsonic{}'.format(random.randrange(1, 5000))
chef_params.client_path = util_obj.ensure_service_params(
vars.D1, "chef", "client_path")
chef_obj.delete_client_pem_files(
vars.D1, "{}/{}".format(chef_params.client_path, "client.pem"))
chef_obj.delete_client_pem_files(
vars.D1, "{}/{}".format(chef_params.client_path, "validation.pem"))
chef_pre_config_in_parallel()
yield
vlan_obj.clear_vlan_configuration(vars.D1)
portchannel_obj.clear_portchannel_configuration(vars.D1)
mac_obj.clear_mac(vars.D1)
basic_obj.service_operations(vars.D1, "chef-client", "stop")
chef_obj.delete_client_pem_files(
vars.D1, "{}/{}".format(chef_params.client_path, "client.pem"))
chef_obj.delete_chef_node(ssh_conn_obj, node_name)
if ssh_conn_obj:
con_obj.ssh_disconnect(ssh_conn_obj)
def qos_warm_reboot_module_hooks(request):
# add things at the start of this module
init_vars()
initialize_variables()
get_parms()
st.log("Checking whether the platform supports warm-reboot")
if not data.platform.lower(
) in data.constants['WARM_REBOOT_SUPPORTED_PLATFORMS']:
st.report_unsupported('test_case_unsupported')
st.log("Configuring supported QoS features")
wred_data = wred_config.init_vars(vars)
st.log('Creating WRED and ECN table')
putils.exec_all(True, [
putils.ExecAllFunc(apply_wred_ecn_config, vars.D1,
wred_data['wred_ecn_json_config'])
])
st.log("Checking for wred config before save and warm-reboot")
wred_verify()
st.log("checking for ecn config before save and warm-reboot")
ecn_verify()
st.log("Configuring IPV4 ACL with rule")
ipv4_acl_config()
st.log("Configuring IPV6 ACL with rule")
ipv6_acl_config()
st.log("Checking for IPV4 ACL config before save and warm-reboot")
ipv4_acl_verify()
st.log("Checking for IPV6 ACL config before save and warm-reboot")
ipv6_acl_verify()
st.log("Configuring COS")
cos_config()
st.log("Checking for COS config before save and warm-reboot")
cos_config_verify()
yield
# add things at the end of this module"
#Below step will clear COS, WRED and ECN config from the device.
qos_obj.clear_qos_config(vars.D1)
#Below step will clear all ACL config from the device.
acl_obj.clear_acl_config(vars.D1)
def evpn_underlay_hooks(request):
global vars
create_glob_vars()
vars = st.get_testbed_vars()
if st.get_ui_type() == 'click':
st.report_unsupported("test_execution_skipped",
"Not supported for ui_type - click")
api_list = [[create_evpn_5549_config]]
parallel.exec_all(True, api_list, True)
create_stream()
st.log("verify MC LAG status in LVTEP nodes")
mclag.verify_domain(
evpn_dict["leaf_node_list"][0],
domain_id=evpn_dict["l3_vni_sag"]['mlag_domain_id'],
session_status='OK',
local_ip=evpn_dict['leaf1']['iccpd_ip_list'][0],
peer_ip=evpn_dict['leaf1']['iccpd_ip_list'][1],
mclag_intfs=1,
peer_link_inf=evpn_dict["leaf1"]["iccpd_pch_intf_list"][0],
node_role='Active')
mclag.verify_domain(
evpn_dict["leaf_node_list"][1],
domain_id=evpn_dict["l3_vni_sag"]['mlag_domain_id'],
session_status='OK',
local_ip=evpn_dict['leaf2']['iccpd_ip_list'][0],
peer_ip=evpn_dict['leaf2']['iccpd_ip_list'][1],
mclag_intfs=1,
peer_link_inf=evpn_dict["leaf2"]["iccpd_pch_intf_list"][0],
node_role='Standby')
st.log("verify MC LAG interface status in LVTEP nodes")
mclag.verify_interfaces(
evpn_dict["leaf_node_list"][0],
domain_id=evpn_dict["l3_vni_sag"]['mlag_domain_id'],
mclag_intf=evpn_dict["leaf1"]["mlag_pch_intf_list"][0],
mclag_intf_local_state="Up",
mclag_intf_peer_state="Up",
mclag_intf_l3_status='No',
isolate_peer_link='Yes',
traffic_disable='No')
mclag.verify_interfaces(
evpn_dict["leaf_node_list"][1],
domain_id=evpn_dict["l3_vni_sag"]['mlag_domain_id'],
mclag_intf=evpn_dict["leaf2"]["mlag_pch_intf_list"][0],
mclag_intf_local_state="Up",
mclag_intf_peer_state="Up",
mclag_intf_l3_status='No',
isolate_peer_link='Yes',
traffic_disable='No')
st.log("verify BGP EVPN neighborship for all nodes ")
result = st.exec_all([[spine1_verify_evpn], [spine2_verify_evpn],
[leaf1_verify_evpn], [leaf2_verify_evpn],
[leaf3_verify_evpn]])
if result[0].count(False) > 0:
st.error(
"########## BGP EVPN neighborship is NOT UP on all spine and leaf nodes; Abort the suite ##########"
)
st.report_fail("base_config_verification_failed")
st.log("verify vxlan tunnel status on leaf nodes")
result = st.exec_all([[leaf1_verify_vxlan], [leaf2_verify_vxlan],
[leaf3_verify_vxlan]])
if result[0].count(False) > 0:
st.error(
"########## VxLAN tunnel status is NOT up on all leaf nodes; Abort the suite ##########"
)
st.report_fail("base_config_verification_failed")
get_mlag_active_stdby('Active')
st.exec_all([[reboot_api.config_save, data['active']],
[reboot_api.config_save, data['stdby']],
[reboot_api.config_save, evpn_dict['spine_node_list'][0]]])
st.exec_all(
[[reboot_api.config_save, data['active'], 'vtysh'],
[reboot_api.config_save, data['stdby'], 'vtysh'],
[reboot_api.config_save, evpn_dict['spine_node_list'][0], 'vtysh']])
data.config_tgen_bgp = False
yield
def platform_check():
if pddf_data.platform_hwsku not in pddf_data.hw_constants[
pddf_data.support[pddf_data.feature]]:
st.report_unsupported('pddf_unsupported', pddf_data.feature,
pddf_data.platform_hwsku)
def qos_module_hooks(request):
# add things at the start of this module
global vars
vars = dict()
vars = st.ensure_min_topology("D1D2:1", "D1T1:2", "D2T1:2")
intf_show = interface_status_show(vars.D1,
interfaces=[vars.D1T1P1, vars.D1D2P1])
port_speed_info = dict()
for port in [vars.D1T1P1, vars.D1D2P1]:
filter_data = filter_and_select(intf_show, ['speed'],
{'interface': port})
if filter_data and 'speed' in filter_data[0]:
port_speed_info[port] = int(filter_data[0]['speed'].replace(
'G', '000'))
if port_speed_info[vars.D1D2P1] != port_speed_info[vars.D1T1P1]:
st.debug("The TG connected port speed: {}".format(
port_speed_info[vars.D1T1P1]))
st.debug("The DUT interconnected port speed: {}".format(
port_speed_info[vars.D1D2P1]))
st.report_unsupported(
"msg",
"The TG connected port and the DUT interconnected port speeds are not equal"
)
scheduling_vars()
scheduling_data.pmap_details = asicapi.get_intf_pmap(
vars.D1, interface_name=[vars.D1D2P1])
if not scheduling_data.pmap_details:
st.debug("PMAP details are: {}".format(scheduling_data.pmap_details))
st.report_fail('no_data_found')
scheduling_module_config(config='yes')
st.debug("Getting TG handlers")
tg1, scheduling_data.tg_ph_1 = tgapi.get_handle_byname("T1D1P1")
tg2, scheduling_data.tg_ph_2 = tgapi.get_handle_byname("T1D1P2")
tg3, scheduling_data.tg_ph_3 = tgapi.get_handle_byname("T1D2P1")
tg4, scheduling_data.tg_ph_4 = tgapi.get_handle_byname("T1D2P2")
scheduling_data.tg = tg1
st.unused(tg2, tg3, tg4)
st.debug("Reset and clear statistics of TG ports")
scheduling_data.tg.tg_traffic_control(action='reset',
port_handle=[
scheduling_data.tg_ph_1,
scheduling_data.tg_ph_2,
scheduling_data.tg_ph_3,
scheduling_data.tg_ph_4
])
scheduling_data.tg.tg_traffic_control(action='clear_stats',
port_handle=[
scheduling_data.tg_ph_1,
scheduling_data.tg_ph_2,
scheduling_data.tg_ph_3,
scheduling_data.tg_ph_4
])
st.debug("Creating TG streams")
scheduling_data.streams = {}
stream = scheduling_data.tg.tg_traffic_config(
port_handle=scheduling_data.tg_ph_3,
mode='create',
length_mode='fixed',
frame_size=64,
pkts_per_burst=10,
l2_encap='ethernet_ii_vlan',
transmit_mode='single_burst',
vlan_id=scheduling_data.vlan,
mac_src=scheduling_data.mac_egress_1,
mac_dst='00:0a:12:00:00:01',
vlan="enable")
scheduling_data.streams['vlan_tagged_egress_port1'] = stream['stream_id']
stream = scheduling_data.tg.tg_traffic_config(
port_handle=scheduling_data.tg_ph_4,
mode='create',
length_mode='fixed',
frame_size=64,
pkts_per_burst=10,
l2_encap='ethernet_ii_vlan',
transmit_mode='single_burst',
vlan_id=scheduling_data.vlan,
mac_src=scheduling_data.mac_egress_2,
mac_dst='00:0a:12:00:00:02',
vlan="enable")
scheduling_data.streams['vlan_tagged_egress_port2'] = stream['stream_id']
stream = scheduling_data.tg.tg_traffic_config(
port_handle=scheduling_data.tg_ph_1,
mode='create',
transmit_mode='continuous',
length_mode='fixed',
rate_percent=100,
l2_encap='ethernet_ii_vlan',
frame_size=1024,
vlan_id=scheduling_data.vlan,
vlan="enable",
vlan_user_priority=scheduling_data.dwrr_queue1,
mac_src="00:00:00:00:00:11",
mac_dst=scheduling_data.mac_egress_1)
scheduling_data.streams['scheduling_port_dwrr_ingress1'] = stream[
'stream_id']
stream = scheduling_data.tg.tg_traffic_config(
port_handle=scheduling_data.tg_ph_2,
mode='create',
transmit_mode='continuous',
length_mode='fixed',
rate_percent=100,
l2_encap='ethernet_ii_vlan',
frame_size=1024,
vlan_id=scheduling_data.vlan,
vlan="enable",
vlan_user_priority=scheduling_data.dwrr_queue2,
mac_src="00:00:00:00:00:22",
mac_dst=scheduling_data.mac_egress_2)
scheduling_data.streams['scheduling_port_dwrr_ingress2'] = stream[
'stream_id']
yield
st.debug('Module config Cleanup')
scheduling_module_config(config='no')
def platform_check():
if not data.version_data.lower(
) in data.hw_constants_DUT['HW_WATCHDOG_SUPPORTED_PLATFORMS']:
st.log("--- Detected HW watchdog unsupported Platform..")
st.report_unsupported("hw_watchdog_unsupported")
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 platform_check():
if sc_data.version_data['hwsku'].lower(
) in hw_constants_DUT['TH3_PLATFORMS']:
st.log("--- Detected BUM UnSupported Platform..")
st.report_unsupported("storm_control_unsupported")
def prologue_epilogue():
if st.get_ui_type() in ['klish']:
st.report_unsupported(
'test_execution_skipped',
'Skipping Chef_MCLAG test case for ui_type={}'.format(
st.get_ui_type()))
st.log('Define Common config, including TGEN related, if any')
initialize_topology()
loc_lib.chef_pre_config(data.d1, data.d1_ip)
if not chef_evpn_obj.sync_with_server_time(
data.my_dut_list, chef_server.ip, chef_server.username,
chef_server.password):
st.report_env_fail("test_case_not_executeds")
f1 = lambda x: chef_evpn_obj.delete_client_pem_files(
data.d1, chef_server.client_path)
f2 = lambda x: chef_evpn_obj.delete_client_pem_files(
data.d2, chef_server.client_path)
f3 = lambda x: chef_evpn_obj.delete_client_pem_files(
data.d3, chef_server.client_path)
putils.exec_all(True, [[f1, 1], [f2, 1], [f3, 1]])
chef_evpn_obj.generate_certs(chef_server.ssh_obj, chef_server.path)
# Cleanup exisitng node if any
chef_evpn_obj.delete_chef_node(chef_server.ssh_obj,
' '.join(data.node_list_mc),
' '.join(data.role_list_mc))
# Generate certs and bootstrap node
chef_evpn_obj.generate_certs(chef_server.ssh_obj, chef_server.path)
if not chef_evpn_obj.bootstrap_chef_node(
chef_server.ssh_obj, chef_server.path, data.d1_ip, 'admin',
'broadcom', data.node_list_mc[0]):
st.report_env_fail("chef_bootstrap_fail")
if not chef_evpn_obj.bootstrap_chef_node(
chef_server.ssh_obj, chef_server.path, data.d2_ip, 'admin',
'broadcom', data.node_list_mc[1]):
st.report_env_fail("chef_bootstrap_fail")
if not chef_evpn_obj.bootstrap_chef_node(
chef_server.ssh_obj, chef_server.path, data.d3_ip, 'admin',
'broadcom', data.node_list_mc[2]):
st.report_env_fail("chef_bootstrap_fail")
# upload cookbook
#chef_evpn_obj.upload_chef_cookbook(chef_server.ssh_obj, chef_server.path)
yield
st.log('Define Common cleanup, including TGEN related, if any')
for role, node_name in zip(data.role_list_mc, data.node_list_mc):
run_list = 'role[{}],recipe[sonic::vlan],recipe[sonic::lag],recipe[sonic::interface],recipe[sonic::mclag]'.format(
role)
chef_evpn_obj.update_node_run_list(chef_server.ssh_obj, node_name,
run_list, 'remove')
# Cleanup exisitng node if any
chef_evpn_obj.delete_chef_node(chef_server.ssh_obj,
' '.join(data.node_list_mc),
' '.join(data.role_list_mc))
def test_ft_vlan_save_config_warm_and_fast_reboot():
'''
Author: Sai Durga <*****@*****.**>
This script covers the below scenarios
ft_max_vlan_save_reload Verify the save and reload functionality with max vlan configuration.
ft_max_vlan_fast_reload Verify the max vlan configuration is retained after fast-reboot.
FtOpSoSwVlFn026 Verify that VLAN is present and traffic is not disturbed during and after warm reboot
FtOpSoSysFRFn005 Verify the Fast-Reboot must disrupt control plane not more than 90 seconds (from sonic test suite -configuration tests)
ft_reboot_fdb_fast_reboot Verify that the FDB entry is retained after fast reboot.
'''
status = True
msg_id = "max_vlan_config_retain_after_save_fast_warm_reboot"
vlan_module_epilog()
vlan_module_config(config='yes')
st.log("Device name is : {}".format(sc_data.dut_platform))
if sc_data.dut_platform and sc_data.dut_platform.lower(
) not in sc_data.warm_reboot_supported_platforms:
st.error("Warm-Reboot is not supported for this platform ({})".format(
sc_data.dut_platform))
st.report_unsupported('test_case_unsupported')
st.log("Saving the MAX VLAN config on the device")
reboot.config_save(vars.D1)
st.log("Performing reboot and checking the VLAN configuration")
st.reboot(vars.D1)
st.log("Checking VLAN config after reboot")
max_vlan_verify()
st.log(
"Sending traffic with 100 MAC,Checking FDB table updated with 100 MAC addresses and performing reboot and checking the VLAN configuration"
)
tg.tg_traffic_control(action="reset", port_handle=tg_handler["tg_ph_list"])
tg_1 = tg.tg_traffic_config(port_handle=tg_handler["tg_ph_1"],
mode='create',
length_mode='fixed',
frame_size=72,
mac_src='00:01:00:00:00:01',
mac_src_step='00:00:00:00:00:01',
mac_src_mode='increment',
mac_src_count=sc_data.mac_count,
mac_dst='00:02:00:00:00:02',
rate_pps=2000,
l2_encap='ethernet_ii_vlan',
vlan="enable",
vlan_id=sc_data.vlan,
transmit_mode='continuous')
tg_info['tg1_stream_id'] = tg_1['stream_id']
tg.tg_traffic_control(action='run', stream_handle=tg_info['tg1_stream_id'])
st.wait(2)
tg.tg_traffic_control(action='stop',
stream_handle=tg_info['tg1_stream_id'])
if not poll_wait(mac_verify, 300):
st.error("mac_address_verification_fail")
st.log("Performing fast-reboot and checking the VLAN configuration")
st.reboot(vars.D1, 'fast')
st.log("Checking VLAN config after fast-reboot")
max_vlan_verify()
st.log("Sending traffic after fast reboot and checking the FDB table")
tg.tg_traffic_control(action='run', stream_handle=tg_info['tg1_stream_id'])
st.wait(2)
tg.tg_traffic_control(action='stop',
stream_handle=tg_info['tg1_stream_id'])
if not poll_wait(mac_verify, 300):
st.error("mac_address_verification_fail")
st.log("Performing warm reboot and checking the traffic")
ifapi.clear_interface_counters(vars.D1)
st.wait(2)
ifapi.show_interface_counters_all(vars.D1)
st.wait(2)
tg.tg_traffic_control(action='run', stream_handle=tg_info['tg1_stream_id'])
st.wait(2)
st.reboot(vars.D1, 'warm')
st.log("Checking VLAN config after warm-reboot")
max_vlan_verify()
tg.tg_traffic_control(action='stop',
stream_handle=tg_info['tg1_stream_id'])
st.log("Checking traffic is forwarded without any loss after warm-reboot")
st.log("Fetching IXIA statistics")
st.wait(2)
ifapi.show_interface_counters_all(vars.D1)
stats_tg1 = tgapi.get_traffic_stats(tg,
mode="aggregate",
port_handle=tg_handler["tg_ph_1"])
total_tx_tg1 = stats_tg1.tx.total_bytes
stats_tg2 = tgapi.get_traffic_stats(tg,
mode="aggregate",
port_handle=tg_handler["tg_ph_2"])
total_rx_tg2 = stats_tg2.rx.total_bytes
percentage_95_total_tx_tg1 = (95 * int(total_tx_tg1)) / 100
st.log("###############")
st.log("Sent bytes: {} and Received bytes : {}".format(
percentage_95_total_tx_tg1, total_rx_tg2))
st.log("##############")
if not int(percentage_95_total_tx_tg1) <= int(total_rx_tg2):
st.report_fail("traffic_transmission_failed", vars.T1D1P1)
report_result(status, msg_id)
def nat_pre_config():
global vars
vars = st.ensure_min_topology("D1T1:2")
platform = basic_obj.get_hwsku(vars.D1)
common_constants = st.get_datastore(vars.D1, "constants", "default")
if platform.lower() in common_constants['TH3_PLATFORMS']:
st.error("NAT is not supported for this platform {}".format(platform))
st.report_unsupported('NAT_unsupported_platform',platform)
global tg_handler, tg1, tg2, tg_ph_1, tg_ph_2, dut1_rt_int_mac, tg_str_data, tg_rt_int_handle
tg_handler = util_tg_init(vars, [vars.T1D1P1, vars.T1D1P2])
tg1 = tg_handler["tg"]
tg2 = tg_handler["tg"]
tg_ph_1 = tg_handler["tg_ph_1"]
tg_ph_2 = tg_handler["tg_ph_2"]
ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P1, data.in1_ip_addr, data.in1_ip_addr_mask, family=data.af_ipv4)
ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P2, data.out_ip_addr_l[0], data.out_ip_addr_mask, family=data.af_ipv4)
dut1_rt_int_mac = basic_obj.get_ifconfig_ether(vars.D1, vars.D1T1P1)
ip_obj.create_static_route(vars.D1, data.out_ip_addr_h,
"{}/{}".format(data.global_ip_addr_rt, data.global_ip_addr_mask),
shell=data.shell_vtysh, family=data.af_ipv4)
ip_obj.create_static_route(vars.D1, data.in1_ip_addr_h[0], "{}/{}".format(data.s_global_ip_rt, data.s_global_ip_mask))
tg_rt_int_handle = util_tg_routing_int_config(vars, tg1, tg2, tg_ph_1, tg_ph_2)
st.log("NAT Configuration")
nat_obj.config_nat_feature(vars.D1, 'enable')
util_nat_zone_config(vars, [vars.D1T1P1, vars.D1T1P2], [data.zone_1, data.zone_2], config=data.config_add)
nat_obj.config_nat_static(vars.D1, protocol=data.proto_all, global_ip=data.out_ip_addr_l[0],
local_ip=data.in1_ip_addr_h[0], config=data.config_add, nat_type=data.nat_type_dnat)
nat_obj.config_nat_static(vars.D1, protocol=data.proto_tcp, global_ip=data.out_ip_addr_l[1],
local_ip=data.in1_ip_addr_h[1],
local_port_id=data.tcp_src_local_port, global_port_id=data.tcp_src_global_port,
config=data.config_add, nat_type=data.nat_type_dnat)
nat_obj.config_nat_static(vars.D1, protocol=data.proto_udp, global_ip=data.in1_ip_addr_h[2],
local_ip=data.out_ip_addr_l[2],
local_port_id=data.udp_src_global_port, global_port_id=data.udp_src_local_port,
config=data.config_add, nat_type=data.nat_type_snat)
nat_obj.config_nat_static(vars.D1, protocol=data.proto_all, global_ip=data.s_global_ip, local_ip=data.s_local_ip,
config=data.config_add, nat_type=data.nat_type_snat)
nat_obj.config_nat_static(vars.D1,protocol=data.proto_all,global_ip=data.out_ip_addr_l[3],local_ip=data.in1_ip_addr_h[3],
config=data.config_add,nat_type=data.nat_type_dnat,twice_nat_id=data.twice_nat_id_1)
nat_obj.config_nat_static(vars.D1, protocol=data.proto_all, global_ip=data.global_ip_addr,
local_ip=data.test_ip_addr,
config=data.config_add, nat_type=data.nat_type_snat, twice_nat_id=data.twice_nat_id_1)
# dynamic NAT config
st.log("Creating NAT Pool-1")
nat_obj.config_nat_pool(vars.D1, pool_name=data.pool_name[0], global_ip_range=data.out_ip_range,
global_port_range= data.global_port_range, config=data.config_add)
nat_obj.config_nat_pool(vars.D1, pool_name="scale_pool", global_ip_range="125.56.90.23-125.56.90.30",
global_port_range="1001-8001", config=data.config_add)
st.log("Creating NAT Pool binding")
nat_obj.config_nat_pool_binding(vars.D1, binding_name=data.bind_name[0], pool_name=data.pool_name[0],
config=data.config_add)
st.log("Creating NAT Pool-2")
nat_obj.config_nat_pool(vars.D1, pool_name=data.pool_name[1], global_ip_range=data.out2_ip_range,
config=data.config_add)
st.log("Creating NAT Pool-2 binding")
nat_obj.config_nat_pool_binding(vars.D1, binding_name=data.bind_name[1], pool_name=data.pool_name[1],
config=data.config_add)
# nat acl for ingress traffic
acl_obj.create_acl_table(vars.D1, name=data.acl_table_in_nat_eg, stage="INGRESS", type=data.type,
description="ingress-acl", ports=[vars.D1T1P1])
acl_obj.create_acl_rule(vars.D1, table_name=data.acl_table_in_nat_eg, rule_name="rule-32", packet_action=data.packet_forward_action,
SRC_IP="{}/{}".format(data.in1_ip_addr_rt, data.in1_ip_addr_mask), priority='98', type=data.type, ip_protocol="4")
acl_obj.create_acl_rule(vars.D1, table_name=data.acl_table_in_nat_eg, rule_name="rule-33",
packet_action=data.packet_do_not_nat_action,
SRC_IP="{}/{}".format('14.1.0.1', data.mask), priority='97', type=data.type, ip_protocol="4")
# Checking arp table for debugging
arp_obj.show_arp(vars.D1)
ip_obj.show_ip_route(vars.D1)
# Clearing all interface counters for debugging purpose
intf_obj.clear_interface_counters(vars.D1)
tg_str_data = util_tg_stream_config(tg1, tg2, tg_ph_1, tg_ph_2)
