def test_ft_sytem_bootup_logging_debug():
"""
Author : Praveen Kumar Kota <*****@*****.**>
Testbed : D1 --- Mgmt Network
Verify that no unwanted logs are shown on DUT console with logging level "Debug".
"""
st.log("clearing the logging buffer")
if not log.clear_logging(vars.D1):
st.report_fail("failed_to_clear_logs", vars.D1)
st.log("enabling logging level as debug")
if not log.set_logging_severity(vars.D1, severity="Debug"):
st.report_fail("logging_severity_level_change_failed", vars.D1)
st.log("waiting the DUT to idle for sometime")
st.wait(data.idle_sleep)
log.set_logging_severity(vars.D1, severity="INFO")
platform = basic_obj.get_hwsku(vars.D1)
logs = ['in obtaining media setting for'
] if platform.lower() in ['accton-as9716-32d'] else []
if not log.check_for_logs_after_reboot(
vars.D1, 'Error', log_severity=['DEBUG', 'INFO'
], except_logs=logs):
st.report_fail("logs_are_getting_generated_after_reboot", vars.D1)
if not log.check_unwanted_logs_in_logging(vars.D1, user_filter=[]):
st.report_fail("logs_are_getting_generated_after_reboot", vars.D1)
st.report_pass("test_case_passed")
def test_dhcp_relay_warm_reboot():
#################################################
#
# Objective - Configure DHCP relay and verify if the configuration is retained after warm reboot.
#
#################################################
data.platform = basic_obj.get_hwsku(vars.D2)
data.constants = st.get_datastore(vars.D2, "constants", 'default')
st.log("OUTPUT:{}".format(data.constants))
if not data.platform.lower(
) in data.constants['WARM_REBOOT_SUPPORTED_PLATFORMS']:
st.report_fail('test_case_unsupported')
st.log("Performing Config save")
rb_obj.config_save(vars.D2)
st.log("Performing warm Reboot")
st.reboot(vars.D2, "warm")
if not basic_obj.poll_for_system_status(vars.D2, 'dhcp_relay.service', 120,
1):
st.report_fail("service_not_running", "dhcp-relay")
if not st.poll_wait(basic_obj.verify_service_status, 60, vars.D2,
"dhcp_relay"):
st.log("DHCP relay service not running")
st.log("Verifying DHCP Helper configuration post reboot")
check_dhcp_relay_config()
dhcp_relay_obj.dhcp_client_start(vars.D3, vars.D3D2P1)
if ip_obj.verify_interface_ip_address(vars.D3,
vars.D3D2P1,
data.pool_ip_address,
family="ipv4",
vrfname=''):
st.report_fail("IP_address_assignment_failed", vars.D3)
st.log(
"Successfully verified DHCP Helper configuration is retained after warm reboot"
)
st.report_pass("test_case_passed")
def vlan_variables():
global tg
global tg_handler,hw_constants_DUT
sc_data.cli_type_click = "click"
sc_data.cli_type= st.get_ui_type(vars.D1, cli_type="")
sc_data.vlan_list = random_vlan_list(count=2)
sc_data.vlan_id = str(sc_data.vlan_list[0])
sc_data.vlan = str(sc_data.vlan_list[1])
sc_data.kbps = 1000
sc_data.frame_size = 68
sc_data.rate_pps =5000
sc_data.packets = (sc_data.kbps*1024)/(sc_data.frame_size*8)
sc_data.bum_deviation = int(0.10 * sc_data.packets)
sc_data.lower_pkt_count = int(sc_data.packets - sc_data.bum_deviation)
sc_data.higher_pkt_count = int(sc_data.packets + sc_data.bum_deviation)
sc_data.max_vlan = 4093
sc_data.source_mac = "00:0A:01:00:00:01"
sc_data.source_mac1 = "00:0A:02:00:00:01"
sc_data.line_rate = 100
sc_data.wait_stream_run = 10
sc_data.wait_for_stats = 10
sc_data.free_port = st.get_free_ports(vars.D1)[0]
tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D1P2", "T1D2P1", "T1D2P2")
tg = tg_handler["tg"]
tg_info['tg_info'] = tg_handler
tg_info['vlan_id'] = sc_data.vlan
sc_data.vlan_id_start = 1
sc_data.mac_count = 100
sc_data.dut_platform = basic_obj.get_hwsku(vars.D1)
sc_data.vlan_data = [{"dut": [vars.D1], "vlan_id": sc_data.vlan, "tagged": [vars.D1T1P1, vars.D1T1P2]}]
hw_constants_DUT = st.get_datastore(vars.D1, "constants")
sc_data.warm_reboot_supported_platforms = hw_constants_DUT['WARM_REBOOT_SUPPORTED_PLATFORMS']
def global_vars_and_constants_init():
global vars
global tf_data
vars = st.ensure_min_topology('D1T1:4')
tf_data = SpyTestDict()
hw_constants = st.get_datastore(vars.D1, "constants")
scapi.get_running_config(vars.D1)
# Global Vars
tf_data.tg_port_list = [vars.T1D1P1, vars.T1D1P2, vars.T1D1P3, vars.T1D1P4]
tf_data.port_list = [vars.D1T1P1, vars.D1T1P2, vars.D1T1P3, vars.D1T1P4]
tf_data.platform = bcapi.get_hwsku(vars.D1).lower()
tf_data.unicast = 'unicast'
tf_data.multicast = 'multicast'
tf_data.tg_current_mode = tf_data.unicast
tf_data.queues_to_check = [
'COUNTERS_PG_NAME_MAP', 'COUNTERS_QUEUE_NAME_MAP'
]
tf_data.max_time_to_check_sys_maps = [150, 2] # Seconds
tf_data.traffic_duration = 3 # Seconds
tf_data.test_max_retries_count = 3
tf_data.need_debug_prints = True
# Common Constants
tf_data.pg_headroom_un_supported_platforms = hw_constants[
'THRESHOLD_FEATURE_PG_HEADROOM_UN_SUPPORTED_PLATFORMS']
tf_data.th3_platforms = hw_constants['TH3_PLATFORMS']
return tf_data
def global_vars_and_constants_init():
global tf_rest_data
global vars
vars = st.ensure_min_topology('D1')
tf_rest_data = SpyTestDict()
hw_constants = st.get_datastore(vars.D1, "constants")
tf_rest_data.all_ports = intapi.get_all_interfaces(vars.D1,
int_type='physical')
# Global Vars
tf_rest_data.platform = bcapi.get_hwsku(vars.D1)
tf_rest_data.show_version = bcapi.show_version(vars.D1)
tf_rest_data.feature = "bst"
tf_rest_data.configure_bst_thresholds = "configure-bst-thresholds"
tf_rest_data.configure_bst_multi_thresholds = "configure-bst-multi-thresholds"
tf_rest_data.get_bst_thresholds = "get-bst-thresholds"
tf_rest_data.clear_bst_thresholds = "clear-bst-thresholds"
tf_rest_data.queues_to_check = [
'COUNTERS_PG_NAME_MAP', 'COUNTERS_QUEUE_NAME_MAP'
]
tf_rest_data.max_time_to_check_sys_maps = [150, 2] # Seconds
tf_rest_data.default_threshold_value = 0 # Percentage
# Common Constants
tf_rest_data.pg_headroom_un_supported_platforms = \
hw_constants['THRESHOLD_FEATURE_PG_HEADROOM_UN_SUPPORTED_PLATFORMS']
tf_rest_data.build_product_info = hw_constants[
'BUILD_BROADCOM_CLOUD_ADVANCED'] + hw_constants[
'BUILD_BROADCOM_ENTERPRISE_ADVANCED']
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 is_supported_platform(dut):
name = get_hwsku(dut)
plt_str = name.split('-')
if (str(plt_str[1]) == "AS7712"):
return True
else:
return False
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 set_speed(dut, data, cli_type=""):
cli_type = st.get_ui_type(dut, cli_type=cli_type)
cli_type = 'klish' if cli_type in ['rest-patch', 'rest-put'] else cli_type
platform = basic.get_hwsku(dut)
ports_per_pg = 12 if platform in ["Accton-AS7326-56X"] else 4
non_portgroup_platforms = [
"Accton-AS7712-32X", "Quanta-IX8A-BWDE-56X", "AS5835-54X"
]
if not st.is_feature_supported("port-group", dut):
non_portgroup_platforms.append(platform)
ports_dict = dict()
port_name_dict = dict()
for index in range(0, len(data), 2):
port = st.get_other_names(
dut, [data[index]])[0] if "/" in data[index] else data[index]
port_name_dict[port] = data[index + 1]
id = re.search(r"\d+", port).group(0)
id = (int(int(id) / ports_per_pg)) + 1
ports_dict[str(id)] = data[index + 1]
st.debug("port-group speed data: {}".format(ports_dict))
commands = list()
if cli_type == 'click':
if platform not in non_portgroup_platforms:
commands = [
"config portgroup speed {} {}".format(index, speed)
for index, speed in ports_dict.items()
]
else:
commands = [
"portconfig -p {} -s {}".format(port, speed)
for port, speed in port_name_dict.items()
]
elif cli_type == 'klish':
if platform not in non_portgroup_platforms:
commands = [
"port-group {} speed {}".format(index, speed)
for index, speed in ports_dict.items()
]
else:
for port, speed in port_name_dict.items():
intf_details = get_interface_number_from_name(port)
if not intf_details:
st.error("Interface data not found for {} ".format(port))
continue
commands.append("interface {} {}".format(
intf_details["type"], intf_details["number"]))
commands.append("speed {}".format(speed))
commands.append("exit")
else:
st.error("Unsupported CLI_TYPE: {}".format(cli_type))
if commands:
st.config(dut, commands, type=cli_type)
return True
def global_vars_and_constants_init():
sf_data.clear()
sf_data.tg_port_list = [vars.T1D1P1, vars.T1D1P2, vars.T1D1P3, vars.T1D1P4]
sf_data.port_list = [vars.D1T1P1, vars.D1T1P2, vars.D1T1P3, vars.D1T1P4]
sf_data.default_snapshot_interval = 10
sf_data.snapshot_interval = 5
sf_data.telemetry_interval = 30
sf_data.default_telemetry_interval = 120
sf_data.unicast = 'unicast'
sf_data.multicast = 'multicast'
sf_data.cpu = 'cpu'
sf_data.periodic = 'periodic'
sf_data.dut_mac = get_ifconfig_ether(vars.D1, 'eth0')
sf_data.tg_current_mode = sf_data.unicast
sf_data.traffic_duration = 5
sf_data.initial_counter_value = 0
sf_data.PG = ['shared', 'headroom', 'unicast', 'multicast']
sf_data.group = ['priority-group', 'queue']
sf_data.table = ['watermark', 'persistent-watermark']
sf_data.platform = get_hwsku(vars.D1).lower()
sf_data.config_file = "buffers.json"
sf_data.device_j2_file = "buffers.json.j2"
sf_data.vlan1 = 1
sf_data.reload_interval = 70
sf_data.FMT = '%H:%M:%S'
sf_data.buffer_pool_tolerance = 2080
sf_data.percentage = ['--percentage', '-p']
sf_data.dot1p_to_tc_map_dict = {
'0': '0',
'1': '1',
'2': '2',
'3': '3',
'4': '4',
'5': '5',
'6': '6',
'7': '7'
}
sf_data.tc_to_pg_map_dict = {'0-7': '7'}
sf_data.obj_name = ['dot1p_tc_map', 'tc_pg_map']
sf_data.map_name = ['dot1p_to_tc_map', 'tc_to_pg_map']
sf_data.dot1p_tc_bind_map = {
'port': vars.D1T1P1,
'map': sf_data.map_name[0],
'obj_name': sf_data.obj_name[0]
}
sf_data.tc_pg_bind_map = {
'port': vars.D1T1P1,
'map': sf_data.map_name[1],
'obj_name': sf_data.obj_name[1]
}
sf_data.sflow_sample_rate = 256
return sf_data
def reboot_module_hooks(request):
global vars
data.iter_count = 3
data.idle_sleep = 300
data.max_vlan = 4093
vars = st.ensure_min_topology("D1")
if not st.is_feature_supported("vlan-range", vars.D1):
# limit the number of VLANS so reduce run time
data.max_vlan = 100
vlan_obj.config_vlan_range(vars.D1,
"1 {}".format(data.max_vlan),
config='add')
data.version_data = basic_obj.get_hwsku(vars.D1)
data.hw_constants_DUT = st.get_datastore(vars.D1, "constants")
yield
vlan_obj.clear_vlan_configuration(st.get_dut_names(), thread=False)
def test_ft_sys_soft_reboot_multiple_iter():
'''
Author : Sreenivasula Reddy <*****@*****.**>
'''
st.log("Performing save and soft-reboot")
reboot_obj.config_save(vars.D1)
st.log("Soft rebooting device for multiple iterations")
for each_iter in range(1, data.iter_count + 1):
st.log("Reload iteration number {}".format(each_iter))
st.log("About to reload the switch")
st.reboot(vars.D1, "fast")
intf_obj.poll_for_interfaces(vars.D1, iteration_count=180, delay=1)
st.log("After reload about to check 'show platform summary'")
if not basic_obj.get_hwsku(vars.D1):
st.report_fail("After_soft_reboot_DUT_access_fail", data.iter_count)
st.log("performing clearconfig operation")
reboot_obj.config_reload(vars.D1)
st.report_pass('test_case_passed')
def port_fec_no_fec(vars, speed, fec=["none", "rs"]):
"""
Author : Nagarjuna Suravarapu <[email protected]
By using this function we can pass parameters where we required (In my usage only fec parameter is changed )
and we can also reuse the code so that we can reduce the codes of line.
"""
if not isinstance(fec, list):
st.log("FEC is not matching the criteria ..")
st.report_fail("interface_is_down_on_dut", [vars.D1D2P1, vars.D1D2P2])
st.log("Observed that speed as {} on interface {}".format(speed, vars.D1D2P1))
if not st.poll_wait(intfapi.verify_interface_status, 20, vars.D1, [vars.D1D2P1, vars.D1D2P2], 'oper', 'up'):
st.report_fail("interface_is_down_on_dut", [vars.D1D2P1, vars.D1D2P2])
if not st.poll_wait(intfapi.verify_interface_status, 20, vars.D2, [vars.D2D1P1, vars.D2D1P2], 'oper', 'up'):
st.report_fail("interface_is_down_on_dut", [vars.D2D1P1, vars.D2D1P2])
if base_obj.get_hwsku(vars.D1).lower() in vars.constants[vars.D1]["TH3_PLATFORMS"]:
if speed not in ['400G', '400000']:
st.log("enabling the fec on Dut1")
st.log(" if the fec on both duts interfaces mismatch then the ports should be down")
intfapi.interface_properties_set(vars.D1, [vars.D1D2P1, vars.D1D2P2], "fec", fec[0], skip_error=False)
if not st.poll_wait(intfapi.verify_interface_status, 20, vars.D1, [vars.D1D2P1, vars.D1D2P2], 'oper', 'down'):
st.report_fail("interface_is_up_on_dut", [vars.D1D2P1, vars.D1D2P2])
if not st.poll_wait(intfapi.verify_interface_status, 20, vars.D2, [vars.D2D1P1, vars.D2D1P2], 'oper', 'down'):
st.report_fail("interface_is_up_on_dut", [vars.D2D1P1, vars.D2D1P2])
st.log("disabling the fec on Dut1")
intfapi.interface_properties_set(vars.D1, [vars.D1D2P1, vars.D1D2P2], "fec", fec[1], skip_error=False,
no_form=True)
if not st.poll_wait(intfapi.verify_interface_status, 20, vars.D1, [vars.D1D2P1, vars.D1D2P2], 'oper', 'up'):
st.report_fail("interface_is_down_on_dut", [vars.D1D2P1, vars.D1D2P2])
if not st.poll_wait(intfapi.verify_interface_status, 20, vars.D2, [vars.D2D1P1, vars.D2D1P2], 'oper', 'up'):
st.report_fail("interface_is_down_on_dut", [vars.D2D1P1, vars.D2D1P2])
else:
st.log("enabling the fec on Dut1")
st.log("if the fec on both duts interfaces mismatch then the ports should be down")
intfapi.interface_properties_set(vars.D1, [vars.D1D2P1, vars.D1D2P2], "fec", fec[1], skip_error=False)
if not st.poll_wait(intfapi.verify_interface_status, 20, vars.D1, [vars.D1D2P1, vars.D1D2P2], 'oper', 'down'):
st.report_fail("interface_is_up_on_dut", [vars.D1D2P1, vars.D1D2P2])
if not st.poll_wait(intfapi.verify_interface_status, 20, vars.D2, [vars.D2D1P1, vars.D2D1P2], 'oper', 'down'):
st.report_fail("interface_is_up_on_dut", [vars.D2D1P1, vars.D2D1P2])
st.log("disabling the fec on Dut1")
intfapi.interface_properties_set(vars.D1, [vars.D1D2P1, vars.D1D2P2], "fec", fec[0], skip_error=False)
if not st.poll_wait(intfapi.verify_interface_status, 20, vars.D1, [vars.D1D2P1, vars.D1D2P2], 'oper', 'up'):
st.report_fail("interface_is_down_on_dut", [vars.D1D2P1, vars.D1D2P2])
if not st.poll_wait(intfapi.verify_interface_status, 20, vars.D2, [vars.D2D1P1, vars.D2D1P2], 'oper', 'up'):
st.report_fail("interface_is_down_on_dut", [vars.D2D1P1, vars.D2D1P2])
def test_chef_evpn_vxlan_nvo():
for dut in [data.d2, data.d3]:
dut_type = get_hwsku(dut)
if "7326" in dut_type or "AS7726" in dut_type or "S5232f" in dut_type or "S5248f" in dut_type or "S5296f" in dut_type or "AS5835" in dut_type or "IX8A" in dut_type or "IX8" in dut_type:
st.log(
"platform {} can be used as leaf node for EVPN testing".format(
dut_type))
else:
st.error(
"expecting leaf node for EVPN testing to be \"7326\" or \"AS7726\" or \"S5232f\" or \"S5248f\" or \"S5296f\" or \"AS5835\" or \"IX8A\" or \"IX8\""
)
st.report_env_fail("platform_check_fail", dut)
chef_server.role_dir = os.path.join(chef_server.path, 'roles')
for file_name, role, node_name in zip(data.role_tc_list_evpn,
data.role_list_mc,
data.node_list_mc):
new_file_name = modify_role_jsonfile(file_name)
loc_lib.copy_role_file_to_chef_server(new_file_name)
st.log('{}, {}, {}'.format(file_name, role, node_name))
chef_evpn_obj.upload_role_chef_server(chef_server.ssh_obj,
chef_server.role_dir,
file_name=new_file_name)
run_list = 'role[{}],recipe[sonic::vlan],recipe[sonic::vxlan],recipe[sonic::interface],recipe[sonic::evpn_nvo],recipe[sonic::loopback],recipe[sonic::router],recipe[sonic::bgprouter]'.format(
role)
chef_evpn_obj.update_node_run_list(chef_server.ssh_obj, node_name,
run_list)
run_chef_all_nodes()
st.wait(data.wait)
if not verify_vxlan_tunnel_status(data.d2, '3.3.3.2', ['4.4.4.2'],
['oper_up']):
st.report_fail('test_case_failed')
if not verify_vxlan_tunnel_status(data.d3, '4.4.4.2', ['3.3.3.2'],
['oper_up']):
st.report_fail('test_case_failed')
st.report_pass('test_case_passed')
def l3_performance_enhancements_module_hooks(request):
global vars, tg_handler, tg, dut, dut_to_tg_port_1, dut_to_tg_port_2, cli_type
global hwsku_under_test, def_v4_route_count, def_v6_route_count
vars = st.ensure_min_topology("D1T1:2")
# Initialize TG and TG port handlers
tg_handler = tgapi.get_handles(vars, [vars.T1D1P1, vars.T1D1P2])
tg = tg_handler["tg"]
if tgapi.is_soft_tgen(vars):
data.test_bgp_route_count = 200
# Test setup details
dut = vars.D1
dut_to_tg_port_1 = vars.D1T1P1
dut_to_tg_port_2 = vars.D1T1P2
hwsku_under_test = basic_obj.get_hwsku(dut)
cli_type = st.get_ui_type(dut)
# Module Configuration
st.log("L3 Performance Enhancements Module Configuration.")
# Configuring v4/v6 routing interfaces on the DUT.
ipfeature.config_ipv6(dut, action='enable')
ipfeature.config_ip_addr_interface(dut,
dut_to_tg_port_1,
data.my_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.config_ip_addr_interface(dut,
dut_to_tg_port_1,
data.my_ipv6_addr,
data.ipv6_prefixlen,
family="ipv6")
ipfeature.config_ip_addr_interface(dut,
dut_to_tg_port_2,
data.intf_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.config_ip_addr_interface(dut,
dut_to_tg_port_2,
data.intf_ipv6_addr,
data.ipv6_prefixlen,
family="ipv6")
# Configuring BGP router and v4/v6 neighbors on the DUT.
bgpfeature.create_bgp_router(dut, data.as_num, '')
bgpfeature.create_bgp_neighbor(dut, data.as_num, data.neigh_ip_addr,
data.remote_as_num)
bgpfeature.create_bgp_neighbor(dut,
data.as_num,
data.neigh_ipv6_addr,
data.remote_as_num,
family="ipv6")
# Get the default route count from DUT
def_v4_route_count = asicapi.get_ipv4_route_count(dut)
def_v6_route_count = asicapi.get_ipv6_route_count(dut)
yield
# Module Cleanup
st.log("L3 Performance Enhancements Module Cleanup.")
ipfeature.delete_ip_interface(dut,
dut_to_tg_port_1,
data.my_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.delete_ip_interface(dut,
dut_to_tg_port_1,
data.my_ipv6_addr,
data.ipv6_prefixlen,
family="ipv6")
ipfeature.delete_ip_interface(dut,
dut_to_tg_port_2,
data.intf_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.delete_ip_interface(dut,
dut_to_tg_port_2,
data.intf_ipv6_addr,
data.ipv6_prefixlen,
family="ipv6")
bgpfeature.delete_bgp_neighbor(dut, data.as_num, data.neigh_ip_addr,
data.remote_as_num)
bgpfeature.delete_bgp_neighbor(dut, data.as_num, data.neigh_ipv6_addr,
data.remote_as_num)
bgpfeature.cleanup_router_bgp(dut)
def bgp_warm_reboot_module_hooks(request):
global vars, tg_handler, tg, dut, ctrl_start, ctrl_stop
global dut_to_tg_port_1, dut_to_tg_port_2, hwsku_under_test
initialize_variables()
vars = st.ensure_min_topology("D1T1:2")
# Initialize TG and TG port handlers
tg_handler = tgapi.get_handles(vars, [vars.T1D1P1, vars.T1D1P2])
tg = tg_handler["tg"]
ctrl_start = {'mode': 'start'}
ctrl_stop = {'mode': 'stop'}
# Test setup details
dut = vars.D1
dut_to_tg_port_1 = vars.D1T1P1
dut_to_tg_port_2 = vars.D1T1P2
hwsku_under_test = basic_obj.get_hwsku(dut)
# Configuring v4/v6 routing interfaces on the DUT.
ipfeature.clear_ip_configuration(st.get_dut_names())
ipfeature.clear_ip_configuration(st.get_dut_names(), 'ipv6')
ipfeature.config_ip_addr_interface(dut,
dut_to_tg_port_1,
data.my_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.config_ip_addr_interface(dut,
dut_to_tg_port_1,
data.my_ipv6_addr,
data.ipv6_prefixlen,
family="ipv6")
ipfeature.config_ip_addr_interface(dut,
dut_to_tg_port_2,
data.intf_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.config_ip_addr_interface(dut,
dut_to_tg_port_2,
data.intf_ipv6_addr,
data.ipv6_prefixlen,
family="ipv6")
# Configuring BGP router and v4/v6 neighbors on the DUT.
bgpfeature.create_bgp_router(dut, data.as_num, '')
bgpfeature.create_bgp_neighbor(dut, data.as_num, data.neigh_ip_addr,
data.remote_as_num)
bgpfeature.create_bgp_neighbor(dut,
data.as_num,
data.neigh_ipv6_addr,
data.remote_as_num,
family="ipv6")
yield
st.log("L3 Performance Enhancements Module Cleanup.")
ipfeature.delete_ip_interface(dut,
dut_to_tg_port_1,
data.my_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.delete_ip_interface(dut,
dut_to_tg_port_1,
data.my_ipv6_addr,
data.ipv6_prefixlen,
family="ipv6")
ipfeature.delete_ip_interface(dut,
dut_to_tg_port_2,
data.intf_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.delete_ip_interface(dut,
dut_to_tg_port_2,
data.intf_ipv6_addr,
data.ipv6_prefixlen,
family="ipv6")
bgpfeature.delete_bgp_neighbor(dut, data.as_num, data.neigh_ip_addr,
data.remote_as_num)
bgpfeature.delete_bgp_neighbor(dut, data.as_num, data.neigh_ipv6_addr,
data.remote_as_num)
bgpfeature.cleanup_router_bgp(dut)
def crm_ft_test_all():
data = SpyTestDict()
data.my_dut_list = st.get_dut_names()
if len(data.my_dut_list) < 1:
st.error("DUT Unavailable")
return False
data.D1 = data.my_dut_list[0]
data.fdb_count = 0
data.crm_polling_interval = 1
crm_obj.set_crm_clear_config(data.D1)
crm_obj.set_crm_polling_interval(data.D1, data.crm_polling_interval)
data.af_ipv4 = "ipv4"
data.af_ipv6 = "ipv6"
data.local_asn = 65001
data.router_id_1 = "110.110.110.1"
data.router_id_2 = "120.120.120.1"
data.remote_asn = 65007
data.loopback_1 = "66.66.66.66"
data.loopback_2 = "77.77.77.77"
data.tg_bgp6_route_prfix = "1001::1"
data.tg_bgp6_routes = '1100'
data.shell_sonic = 'vtysh'
data.used_counter = dict()
data.free_counter = dict()
data.resource_count_max = dict()
data.thresh_percent_low = dict()
data.thresh_percent_high = dict()
data.thresh_used_low = dict()
data.thresh_used_high = dict()
data.thresh_free_low = dict()
data.thresh_free_high = dict()
data.cur_thresh_type = dict()
data.cli_type = st.get_ui_type(data.D1)
family_list = crm_obj.crm_get_family_list(data.D1)
if base_obj.get_hwsku(
vars.D1).lower() in vars.constants[vars.D1]["TH3_PLATFORMS"]:
for family in family_list:
if family in ['dnat', 'snat']:
family_list.remove(family)
st.log("Verify CRM polling interval:")
st.wait(data.crm_polling_interval)
if not crm_obj.verify_crm_summary(
data.D1, pollinginterval=data.crm_polling_interval):
st.error('polling interval did not match with the configured value')
return False
st.log("Calculate Max resources:")
for family in family_list:
if family != 'acl_group_counter' and family != 'acl_group_entry' and family != 'all':
(data.used_counter[family],
data.free_counter[family]) = crm_obj.crm_get_resources_count(
data.D1, family)
data.resource_count_max[
family] = data.used_counter[family] + data.free_counter[family]
for family in family_list:
if family != 'acl_group_counter' and family != 'acl_group_entry' and family != 'all':
st.log('{} {}/{}/{}'.format(family, data.used_counter[family],
data.free_counter[family],
data.resource_count_max[family]))
data.routing_subnet = 24
data.dut_p1 = vars.T1D1P1
data.dut_p1_interface = vars.D1T1P1
data.dut_p1_ipaddr = '7.7.7.1'
data.dut_p1_ipaddr_subnet = 24
data.dut_p1_ipaddr_peer = '7.7.7.2'
data.adv_routes_cnt = 1000
data.adv_routes_prefix = "100.0.0.0"
data.neighbor_cnt = 100
data.dut_p2 = vars.T1D1P2
data.dut_p2_interface = vars.D1T1P2
data.dut_p2_ipaddr = '2001::1'
data.dut_p2_ipaddr_subnet = 64
data.dut_p2_ipaddr_peer = '2001::2'
data.adv_routes_cnt_v6 = 1000
data.adv_routes_prefix_v6 = '2121::0'
data.neighbor_cnt_v6 = 100
data.vlanid = 777
st.log('crminfo: VLAN ID {}'.format(data.vlanid))
crm_fdb_config(data)
crm_acl_config(data)
crm_bgp_config_v4(data.local_asn, data.remote_asn, data)
crm_ecmp_config(data)
if st.is_feature_supported("config-ipv6-command", data.D1):
crm_bgp_config_v6(data.local_asn, data.remote_asn, data)
verify_thresholds(data)
# debug trace
crm_obj.get_crm_resources(data.D1, "all")
global crm_test_status
crm_test_status = True
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)
def l3_performance_enhancements_module_hooks(request):
global vars
global tg_handler
global tg
global dut1
global dut2
global dut3
global dut4
global dut1_to_tg_port_1
global dut1_to_dut2_port_1
global dut2_to_dut1_port_1
global dut1_to_dut3_port_1
global dut3_to_dut1_port_1
global dut2_to_dut4_port_1
global dut4_to_dut2_port_1
global dut3_to_dut4_port_1
global dut4_to_dut3_port_1
global dut4_to_tg_port_1
global hwsku_under_test1
global hwsku_under_test2
global hwsku_under_test3
global hwsku_under_test4
global def_v4_route_count_d1
global def_v4_route_count_d4
global def_v6_route_count_d1
global def_v6_route_count_d4
# Min topology verification
st.log("Ensuring minimum topology")
vars = st.ensure_min_topology("D1D2:1", "D1D3:1", "D2D4:1", "D3D4:1", "D1T1:1", "D4T1:1")
# Initialize TG and TG port handlers
tg_handler = tgapi.get_handles(vars, [vars.T1D1P1, vars.T1D4P1])
tg = tg_handler["tg"]
# Test setup details
dut1 = vars.D1
dut2 = vars.D2
dut3 = vars.D3
dut4 = vars.D4
dut1_to_tg_port_1 = vars.D1T1P1
dut1_to_dut2_port_1 = vars.D1D2P1
dut2_to_dut1_port_1 = vars.D2D1P1
dut1_to_dut3_port_1 = vars.D1D3P1
dut3_to_dut1_port_1 = vars.D3D1P1
dut2_to_dut4_port_1 = vars.D2D4P1
dut4_to_dut2_port_1 = vars.D4D2P1
dut3_to_dut4_port_1 = vars.D3D4P1
dut4_to_dut3_port_1 = vars.D4D3P1
dut4_to_tg_port_1 = vars.D4T1P1
hwsku_under_test1 = basic_obj.get_hwsku(dut1)
hwsku_under_test2 = basic_obj.get_hwsku(dut2)
hwsku_under_test3 = basic_obj.get_hwsku(dut3)
hwsku_under_test4 = basic_obj.get_hwsku(dut4)
# Module Configuration
st.log("L3 Performance Enhancements Module Configuration.")
# Configuring v4/v6 routing interfaces on the DUT.
st.log("Configuring IPv4 routing interfaces.")
ipfeature.config_ip_addr_interface(dut1, dut1_to_tg_port_1, data.dut1_to_tg_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut1, dut1_to_dut2_port_1, data.dut1_to_dut2_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut1, dut1_to_dut3_port_1, data.dut1_to_dut3_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut2, dut2_to_dut1_port_1, data.dut2_to_dut1_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut2, dut2_to_dut4_port_1, data.dut2_to_dut4_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut3, dut3_to_dut1_port_1, data.dut3_to_dut1_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut3, dut3_to_dut4_port_1, data.dut3_to_dut4_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut4, dut4_to_dut2_port_1, data.dut4_to_dut2_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut4, dut4_to_dut3_port_1, data.dut4_to_dut3_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut4, dut4_to_tg_port_1, data.dut4_to_tg_port_1_ip, data.ip_prefixlen, family="ipv4")
st.log("Configuring IPv6 routing interfaces.")
ipfeature.config_ipv6(dut1, action='enable')
ipfeature.config_ip_addr_interface(dut1, dut1_to_tg_port_1, data.dut1_to_tg_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ip_addr_interface(dut1, dut1_to_dut2_port_1, data.dut1_to_dut2_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ip_addr_interface(dut1, dut1_to_dut3_port_1, data.dut1_to_dut3_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ipv6(dut2, action='enable')
ipfeature.config_ip_addr_interface(dut2, dut2_to_dut1_port_1, data.dut2_to_dut1_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ip_addr_interface(dut2, dut2_to_dut4_port_1, data.dut2_to_dut4_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ipv6(dut3, action='enable')
ipfeature.config_ip_addr_interface(dut3, dut3_to_dut1_port_1, data.dut3_to_dut1_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ip_addr_interface(dut3, dut3_to_dut4_port_1, data.dut3_to_dut4_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ipv6(dut4, action='enable')
ipfeature.config_ip_addr_interface(dut4, dut4_to_dut2_port_1, data.dut4_to_dut2_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ip_addr_interface(dut4, dut4_to_dut3_port_1, data.dut4_to_dut3_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ip_addr_interface(dut4, dut4_to_tg_port_1, data.dut4_to_tg_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
# Configuring BGP router and v4/v6 neighbors on the DUT.
st.log("Configuring BGP routers.")
bgpfeature.create_bgp_router(dut1, data.as_num_1, '')
bgpfeature.create_bgp_router(dut2, data.as_num_2, '')
bgpfeature.create_bgp_router(dut3, data.as_num_3, '')
bgpfeature.create_bgp_router(dut4, data.as_num_4, '')
st.log("Configuring BGP IPv4 neighbors.")
bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.tg_to_dut1_port_1_ip, data.remote_as_num1)
bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.dut2_to_dut1_port_1_ip, data.as_num_2)
bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.dut3_to_dut1_port_1_ip, data.as_num_3)
bgpfeature.create_bgp_neighbor(dut2, data.as_num_2, data.dut1_to_dut2_port_1_ip, data.as_num_1)
bgpfeature.create_bgp_neighbor(dut2, data.as_num_2, data.dut4_to_dut2_port_1_ip, data.as_num_4)
bgpfeature.create_bgp_neighbor(dut3, data.as_num_3, data.dut1_to_dut3_port_1_ip, data.as_num_1)
bgpfeature.create_bgp_neighbor(dut3, data.as_num_3, data.dut4_to_dut3_port_1_ip, data.as_num_4)
bgpfeature.create_bgp_neighbor(dut4, data.as_num_4, data.dut2_to_dut4_port_1_ip, data.as_num_2)
bgpfeature.create_bgp_neighbor(dut4, data.as_num_4, data.dut3_to_dut4_port_1_ip, data.as_num_3)
st.log("Configuring BGP IPv6 neighbors.")
bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.tg_to_dut1_port_1_ip6, data.remote_as_num1, family="ipv6")
bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.dut2_to_dut1_port_1_ip6, data.as_num_2, family="ipv6")
bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.dut3_to_dut1_port_1_ip6, data.as_num_3, family="ipv6")
bgpfeature.create_bgp_neighbor(dut2, data.as_num_2, data.dut1_to_dut2_port_1_ip6, data.as_num_1, family="ipv6")
bgpfeature.create_bgp_neighbor(dut2, data.as_num_2, data.dut4_to_dut2_port_1_ip6, data.as_num_4, family="ipv6")
bgpfeature.create_bgp_neighbor(dut3, data.as_num_3, data.dut1_to_dut3_port_1_ip6, data.as_num_1, family="ipv6")
bgpfeature.create_bgp_neighbor(dut3, data.as_num_3, data.dut4_to_dut3_port_1_ip6, data.as_num_4, family="ipv6")
bgpfeature.create_bgp_neighbor(dut4, data.as_num_4, data.dut2_to_dut4_port_1_ip6, data.as_num_2, family="ipv6")
bgpfeature.create_bgp_neighbor(dut4, data.as_num_4, data.dut3_to_dut4_port_1_ip6, data.as_num_3, family="ipv6")
# st.log("Configuring BGP as-path multipath-relax.")
bgpfeature.create_bgp_best_path(dut1, data.as_num_1, "as-path multipath-relax")
bgpfeature.create_bgp_best_path(dut2, data.as_num_2, "as-path multipath-relax")
bgpfeature.create_bgp_best_path(dut3, data.as_num_3, "as-path multipath-relax")
bgpfeature.create_bgp_best_path(dut4, data.as_num_4, "as-path multipath-relax")
# Get the default route count from DUT
def_v4_route_count_d1 = asicapi.bcmcmd_route_count_hardware(dut1)
def_v4_route_count_d4 = asicapi.bcmcmd_route_count_hardware(dut4)
def_v6_route_count_d1 = asicapi.bcmcmd_ipv6_route_count_hardware(dut1)
def_v6_route_count_d4 = asicapi.bcmcmd_ipv6_route_count_hardware(dut4)
# Verifying the BGP neighborship
st.wait(20)
st.log("Verifying the BGP IPv4 neighborships.")
if not poll_wait(bgpfeature.verify_bgp_summary, 120, dut1, neighbor=data.dut2_to_dut1_port_1_ip,state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut1_port_1_ip)
if not poll_wait(bgpfeature.verify_bgp_summary, 120, dut1, neighbor=data.dut3_to_dut1_port_1_ip,state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut1_port_1_ip)
if not poll_wait(bgpfeature.verify_bgp_summary, 120, dut2, neighbor=data.dut1_to_dut2_port_1_ip,state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut2_port_1_ip)
if not poll_wait(bgpfeature.verify_bgp_summary, 120, dut2, neighbor=data.dut4_to_dut2_port_1_ip,state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut2_port_1_ip)
# if not bgpfeature.verify_bgp_summary(dut1, neighbor=data.dut2_to_dut1_port_1_ip, state='Established'):
# st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut1_port_1_ip)
# if not bgpfeature.verify_bgp_summary(dut1, neighbor=data.dut3_to_dut1_port_1_ip, state='Established'):
# st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut1_port_1_ip)
# if not bgpfeature.verify_bgp_summary(dut2, neighbor=data.dut1_to_dut2_port_1_ip, state='Established'):
# st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut2_port_1_ip)
# if not bgpfeature.verify_bgp_summary(dut2, neighbor=data.dut4_to_dut2_port_1_ip, state='Established'):
# st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut2_port_1_ip)
if not bgpfeature.verify_bgp_summary(dut3, neighbor=data.dut1_to_dut3_port_1_ip, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut3_port_1_ip)
if not bgpfeature.verify_bgp_summary(dut3, neighbor=data.dut4_to_dut3_port_1_ip, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut3_port_1_ip)
if not bgpfeature.verify_bgp_summary(dut4, neighbor=data.dut2_to_dut4_port_1_ip, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut4_port_1_ip)
if not bgpfeature.verify_bgp_summary(dut4, neighbor=data.dut3_to_dut4_port_1_ip, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut4_port_1_ip)
st.log("Verifying the BGP IPv6 neighborships.")
if not bgpfeature.verify_bgp_summary(dut1, family='ipv6', neighbor=data.dut2_to_dut1_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut1_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut1, family='ipv6', neighbor=data.dut3_to_dut1_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut1_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut2, family='ipv6', neighbor=data.dut1_to_dut2_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut2_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut2, family='ipv6', neighbor=data.dut4_to_dut2_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut2_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut3, family='ipv6', neighbor=data.dut1_to_dut3_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut3_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut3, family='ipv6', neighbor=data.dut4_to_dut3_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut3_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut4, family='ipv6', neighbor=data.dut2_to_dut4_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut4_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut4, family='ipv6', neighbor=data.dut3_to_dut4_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut4_port_1_ip6)
yield
# Module Cleanup
st.log("L3 Performance Enhancements Module Cleanup.")
st.log("Unconfiguring IPv4 routing interfaces.")
ipfeature.delete_ip_interface(dut1, dut1_to_tg_port_1, data.dut1_to_tg_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut1, dut1_to_dut2_port_1, data.dut1_to_dut2_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut1, dut1_to_dut3_port_1, data.dut1_to_dut3_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut2, dut2_to_dut1_port_1, data.dut2_to_dut1_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut2, dut2_to_dut4_port_1, data.dut2_to_dut4_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut3, dut3_to_dut1_port_1, data.dut3_to_dut1_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut3, dut3_to_dut4_port_1, data.dut3_to_dut4_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut4, dut4_to_dut2_port_1, data.dut4_to_dut2_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut4, dut4_to_dut3_port_1, data.dut4_to_dut3_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut4, dut4_to_tg_port_1, data.dut4_to_tg_port_1_ip, data.ip_prefixlen, family="ipv4")
st.log("Unconfiguring IPv6 routing interfaces.")
ipfeature.delete_ip_interface(dut1, dut1_to_tg_port_1, data.dut1_to_tg_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut1, dut1_to_dut2_port_1, data.dut1_to_dut2_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut1, dut1_to_dut3_port_1, data.dut1_to_dut3_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut2, dut2_to_dut1_port_1, data.dut2_to_dut1_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut2, dut2_to_dut4_port_1, data.dut2_to_dut4_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut3, dut3_to_dut1_port_1, data.dut3_to_dut1_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut3, dut3_to_dut4_port_1, data.dut3_to_dut4_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut4, dut4_to_dut2_port_1, data.dut4_to_dut2_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut4, dut4_to_dut3_port_1, data.dut4_to_dut3_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut4, dut4_to_tg_port_1, data.dut4_to_tg_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
st.log("Unconfiguring BGP IPv4 neighbors.")
bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.tg_to_dut1_port_1_ip, data.remote_as_num1)
bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.dut2_to_dut1_port_1_ip, data.as_num_2)
bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.dut3_to_dut1_port_1_ip, data.as_num_3)
bgpfeature.delete_bgp_neighbor(dut2, data.as_num_2, data.dut1_to_dut2_port_1_ip, data.as_num_1)
bgpfeature.delete_bgp_neighbor(dut2, data.as_num_2, data.dut4_to_dut2_port_1_ip, data.as_num_4)
bgpfeature.delete_bgp_neighbor(dut3, data.as_num_3, data.dut1_to_dut3_port_1_ip, data.as_num_1)
bgpfeature.delete_bgp_neighbor(dut3, data.as_num_3, data.dut4_to_dut3_port_1_ip, data.as_num_4)
bgpfeature.delete_bgp_neighbor(dut4, data.as_num_4, data.dut2_to_dut4_port_1_ip, data.as_num_2)
bgpfeature.delete_bgp_neighbor(dut4, data.as_num_4, data.dut3_to_dut4_port_1_ip, data.as_num_3)
st.log("Unconfiguring BGP IPv6 neighbors.")
bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.tg_to_dut1_port_1_ip6, data.remote_as_num1)
bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.dut2_to_dut1_port_1_ip6, data.as_num_2)
bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.dut3_to_dut1_port_1_ip6, data.as_num_3)
bgpfeature.delete_bgp_neighbor(dut2, data.as_num_2, data.dut1_to_dut2_port_1_ip6, data.as_num_1)
bgpfeature.delete_bgp_neighbor(dut2, data.as_num_2, data.dut4_to_dut2_port_1_ip6, data.as_num_4)
bgpfeature.delete_bgp_neighbor(dut3, data.as_num_3, data.dut1_to_dut3_port_1_ip6, data.as_num_1)
bgpfeature.delete_bgp_neighbor(dut3, data.as_num_3, data.dut4_to_dut3_port_1_ip6, data.as_num_4)
bgpfeature.delete_bgp_neighbor(dut4, data.as_num_4, data.dut2_to_dut4_port_1_ip6, data.as_num_2)
bgpfeature.delete_bgp_neighbor(dut4, data.as_num_4, data.dut3_to_dut4_port_1_ip6, data.as_num_3)
st.log("Unconfiguring BGP routers.")
bgpfeature.cleanup_router_bgp(dut1)
bgpfeature.cleanup_router_bgp(dut2)
bgpfeature.cleanup_router_bgp(dut3)
bgpfeature.cleanup_router_bgp(dut4)
def global_vars_and_constants_init():
global eh_data, vars
eh_data = SpyTestDict()
vars = st.ensure_min_topology('D1D2:1', 'D1T1:2')
eh_data.platform = bsapi.get_hwsku(vars.D1).lower()
hw_constants = st.get_datastore(vars.D1, "constants", eh_data.platform)
if not hw_constants:
hw_constants = st.get_datastore(vars.D1, "constants")
# Falgs
eh_data.debug = True
eh_data.clear_logs = True
eh_data.thread_mode = True
eh_data.dut_list = [vars.D1, vars.D2]
eh_data.ping_delay = 5
eh_data.ping_retry = 1
eh_data.error_route_table = "ERROR_ROUTE_TABLE"
eh_data.error_neigh_table = "ERROR_NEIGH_TABLE"
eh_data.swss_rc_success = "SWSS_RC_SUCCESS"
eh_data.swss_rc_exists = "SWSS_RC_EXISTS"
eh_data.swss_rc_not_found = "SWSS_RC_NOT_FOUND"
eh_data.swss_rc_table_full = "SWSS_RC_TABLE_FULL"
eh_data.log_str_swss = "swss#orchagent:"
eh_data.log_str_bgp = "bgp#fpmsyncd:"
eh_data.route_not_install_flag = '#'
# Global vars
eh_data.ipv4_addr = "10.1.1.1"
eh_data.ipv4_nbr = "10.1.1.2"
eh_data.ipv4_mask = "255.255.255.0"
eh_data.ipv4_mask_len = '24'
eh_data.ipv6_addr = "2001::1"
eh_data.ipv6_nbr = "2001::2"
eh_data.ipv6_mask_len = '64'
eh_data.local_asn = '65400'
eh_data.remote_asn = '65007'
eh_data.tg_remote_asn = '65009'
eh_data.ipv4_route = "12.12.12.0"
eh_data.ipv4_route2 = "13.13.13.0"
eh_data.ipv6_route = "0600:0000:0000:0000:0000:0000:0000:0000"
eh_data.ipv6_route2 = "0700:0000:0000:0000:0000:0000:0000:0000"
eh_data.ipv6_route_mask = "600::0/64"
eh_data.ipv6_route2_mask = "700::0/64"
eh_data.ipv6_route_sf = "600::"
eh_data.ipv6_route2_sf = "700::"
eh_data.egr_intf = '100002'
eh_data.vrf = '0'
eh_data.loopback4_1 = "66.66.66.66"
eh_data.loopback4_2 = "77.77.77.77"
eh_data.loopback6_1 = "6666::6666"
eh_data.loopback6_2 = "7777::7777"
eh_data.af_ipv4 = "ipv4"
eh_data.af_ipv6 = "ipv6"
eh_data.shell_sonic = "sonic"
eh_data.shell_vtysh = "vtysh"
eh_data.route_map_name = 'error_handling_route_map'
eh_data.peer_gp_namev4 = 'error_handlingv4'
eh_data.tg_peer_gp_namev4 = 'tg_error_handlingv4'
eh_data.peer_gp_namev6 = 'error_handlingv6'
eh_data.tg_peer_gp_namev6 = 'tg_error_handlingv6'
eh_data.ipv4_nbr2 = "10.1.1.3"
eh_data.ipv6_nbr2 = "2001::3"
eh_data.ipv4_nbr2_mac = "00:00:00:00:00:01"
eh_data.ipv6_nbr2_mac = "00:00:00:00:00:02"
eh_data.ipv4_nbr3 = "10.1.1.4"
eh_data.ipv6_nbr3 = "2001::4"
eh_data.ipv4_nbr3_mac = "00:00:00:00:00:03"
eh_data.ipv6_nbr3_mac = "00:00:00:00:00:04"
# TG vars
eh_data.tg1_ipv4_addr = "20.1.1.1"
eh_data.tg1_ipv4_nbr = "20.1.1.2"
eh_data.tg1_ipv4_mask = "255.255.255.0"
eh_data.tg1_ipv4_mask_len = '24'
eh_data.tg1_ipv6_addr = "3001::1"
eh_data.tg1_ipv6_nbr = "3001::2"
eh_data.tg1_ipv6_mask_len = '64'
# Constants
eh_data.ipv4_max_routes = int(
hw_constants['MAX_IPV4_ROUTES_FOR_ERROR_HANDLING'])
st.log("MAX_IPV4_ROUTES_FOR_ERROR_HANDLING: {}".format(
eh_data.ipv4_max_routes))
eh_data.ipv6_max_routes = int(
hw_constants['MAX_IPV6_ROUTES_FOR_ERROR_HANDLING'])
st.log("MAX_IPV6_ROUTES_FOR_ERROR_HANDLING: {}".format(
eh_data.ipv6_max_routes))
eh_data.max_route_install_wait_time = 120
eh_data.bcmcmd_timeout = 600
eh_data.cli_type = st.get_ui_type(vars.D1)
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 get_parms():
data.platform = basic_obj.get_hwsku(vars.D1)
data.constants = st.get_datastore(vars.D1, "constants", "default")
def breakout(dut, data, undo=False, brk_verify=True, cli_type="", skip_error=False):
cli_type = st.get_ui_type(dut, cli_type=cli_type)
platform_check=False
cmds = []
cmds_1 =[]
dut_type=basic.get_hwsku(dut)
if dut_type:
if "9716" in dut_type or "IX9" in dut_type:
platform_check=True
data_port = list(data)
if cli_type == "klish":
for x in range(0,len(data_port),2):
res1 = get_interface_breakout_mode(dut, data_port[x], 'port')
if res1:
data_port[x] = 'port ' + res1[0]['port']
else:
st.error('Invalid interface, cannot breakout')
return False
for index in range(0, len(data_port), 2):
intf, opt = data_port[index].strip(), data_port[index+1].strip()
if not opt.endswith("G"): opt = "{}G".format(opt)
if intf in ['port 1/31','port 1/32'] and platform_check:
if intf == 'port 1/31':
intf1 = 'Ethernet240'
else:
intf1 = 'Ethernet248'
st.log("The platform used is {}, if the ports are 1/31 (Intf: Ethernet240) or 1/32 (Intf: Ethernet248) it will be broken into 8x10G by default".format(dut_type))
if undo:
cmds_1.append("config interface breakout {} 1x400G -y".format(intf1))
else:
cmds_1.append("config interface breakout {} 8x10G -y".format(intf1))
else:
if undo:
cmds.append("no interface breakout {}".format(intf))
else:
cmds.append("interface breakout {} mode {}".format(intf, opt))
elif cli_type == "click":
for index in range(0, len(data), 2):
intf, opt = data[index].strip(), data[index+1].strip()
if not opt.endswith("G"): opt = "{}G".format(opt)
if intf in ['Ethernet240','Ethernet248'] and platform_check:
st.log("The platform used is {}, if the ports are Ethernet240 or Ethernet248 it will be broken into 8x10G by default".format(dut_type))
if undo:
cmds.append("config interface breakout {} 1x400G -y -f".format(intf))
else:
cmds.append("config interface breakout {} 8x10G -y -f".format(intf))
else:
if undo:
cmds.append("config interface breakout {} 1x100G -y -f".format(intf))
else:
cmds.append("config interface breakout {} {} -y -f".format(intf, opt))
else:
st.error("Unsupported CLI TYPE {}".format(cli_type))
return False
if len(cmds_1) > 0:
st.config(dut, cmds_1, type='click', skip_error_check=skip_error)
try:
st.config(dut, cmds, type=cli_type, skip_error_check=skip_error)
except Exception as e:
st.log(e)
if brk_verify and cli_type == "klish" and not undo:
for index in range(0, len(data), 2):
intf, opt = data_port[index].strip(), data_port[index+1].strip()
if not opt.endswith("G"): opt = "{}G".format(opt)
intf = "Ethernet".join(intf.split("Ethernet"))
if retry_api(verify_dpb_status,dut,interface=intf,status='Completed',breakout_mode=opt,retry_count=12, delay=5):
st.log("Breakout of {} to speed {} is successful".format(intf,opt))
else:
st.error("Breakout is not successful for {} of speed {}, even after 60 seconds".format(intf,opt))
return False
return True
