def ipv6_link_local_config(action="add"):
if action == "add":
st.log("Creating VLAN and participating interfaces ...")
vlan_data = [{
"dut": [vars.D1],
"vlan_id": bgp_rst_data.vlan_id[0],
"tagged": [vars.D1D2P2]
}, {
"dut": [vars.D2],
"vlan_id": bgp_rst_data.vlan_id[0],
"tagged": [vars.D2D1P2]
}]
create_vlan_and_add_members(vlan_data)
st.log("Creating PortChannel and participating interfaces ...")
config_portchannel(vars.D1, vars.D2, bgp_rst_data.portchannel_name,
[vars.D1D2P3, vars.D1D2P4],
[vars.D2D1P3, vars.D2D1P4])
st.log("Enable IPV6 on physical interface on both the devices")
[_, exceptions] = exec_all(True, [[config_interface_ip6_link_local, vars.D1, ["Vlan{}".format(bgp_rst_data.vlan_id[0]), bgp_rst_data.portchannel_name]], \
[config_interface_ip6_link_local, vars.D2, ["Vlan{}".format(bgp_rst_data.vlan_id[0]), bgp_rst_data.portchannel_name]]])
ensure_no_exception(exceptions)
else:
[_, exceptions] = exec_all(True, [
[config_interface_ip6_link_local, vars.D1, [vars.D1D2P1, "Vlan{}".format(bgp_rst_data.vlan_id[0]), bgp_rst_data.portchannel_name], "disable"], \
[config_interface_ip6_link_local, vars.D2, [vars.D2D1P1, "Vlan{}".format(bgp_rst_data.vlan_id[0]), bgp_rst_data.portchannel_name], "disable"]])
ensure_no_exception(exceptions)
clear_portchannel_configuration([vars.D1, vars.D2])
clear_vlan_configuration([vars.D1, vars.D2])
def full_cleanup():
bgpapi.cleanup_router_bgp(st.get_dut_names())
ipapi.clear_ip_configuration(st.get_dut_names(),
thread=eh_data.thread_mode,
family='all')
vapi.clear_vlan_configuration(st.get_dut_names(),
thread=eh_data.thread_mode)
def pvst_elastic_function_hooks(request):
if st.get_func_name(request) == "test_ft_stp_loopguard_lag_interfaces":
vlan.clear_vlan_configuration(st.get_dut_names(), thread=False)
st.log('Creating port-channel and adding members in both DUTs')
portchannel.config_portchannel(vars.D1, vars.D2,
sc_data.portchannel_name,
sc_data.members_dut1,
sc_data.members_dut2, "add")
portchannel.config_portchannel(vars.D1, vars.D2,
sc_data.portchannel_name2,
sc_data.members_dut1_p2,
sc_data.members_dut2_p2, "add")
parallel.exec_all(
True, [[vlan.create_vlan_and_add_members, sc_data.vlan_pc_d1],
[vlan.create_vlan_and_add_members, sc_data.vlan_pc_d2]])
yield
if st.get_func_name(request) == "test_ft_stp_loopguard_lag_interfaces":
vlan.clear_vlan_configuration(st.get_dut_names(), thread=False)
portchannel.clear_portchannel_configuration([vars.D1, vars.D2])
parallel.exec_all(
True, [[vlan.create_vlan_and_add_members, sc_data.vlan_data_d1],
[vlan.create_vlan_and_add_members, sc_data.vlan_data_d2]])
parallel.exec_all(
True, [[vlan.create_vlan_and_add_members, sc_data.vlan1_data_d1],
[vlan.create_vlan_and_add_members, sc_data.vlan1_data_d2]])
def ndp_module_hooks(request):
vars = st.ensure_min_topology("D1T1:2")
# Initialize TG and TG port handlers
tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D1P2")
tg = tg_handler["tg"]
# Test setup details
data.my_dut_list = st.get_dut_names()
dut1 = data.my_dut_list[0]
# NDP module configuration
st.log("NDP module configuration.")
ip_obj.config_ip_addr_interface(dut1,
vars.D1T1P1,
data.local_ip6_addr[0],
64,
family=data.af_ipv6)
vlan_obj.create_vlan(dut1, data.vlan_1)
vlan_obj.add_vlan_member(dut1, data.vlan_1, vars.D1T1P2, True)
ip_obj.config_ip_addr_interface(dut1,
data.vlan_int_1,
data.local_ip6_addr[1],
64,
family=data.af_ipv6)
# TG ports reset
st.log("Resetting the TG ports")
tg.tg_traffic_control(action="reset", port_handle=tg_handler["tg_ph_list"])
# TG protocol interface creation
st.log("TG protocol interface creation")
h1 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_1"],
mode='config',
ipv6_intf_addr=data.neigh_ip6_addr_gw[0],
ipv6_prefix_length='64',
ipv6_gateway=data.local_ip6_addr[0],
src_mac_addr=data.tg_mac1,
arp_send_req='1',
count=data.count)
st.log("INTFCONF: " + str(h1))
h2 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_2"],
mode='config',
ipv6_intf_addr=data.neigh_ip6_addr_gw[1],
ipv6_prefix_length='64',
ipv6_gateway=data.local_ip6_addr[1],
src_mac_addr=data.tg_mac2,
arp_send_req='1',
vlan_id=data.vlan_1,
vlan=1,
count=data.count)
st.log("INTFCONF: " + str(h2))
yield
# NDP module cleanup
st.log("NDP module cleanup.")
ip_obj.clear_ip_configuration(dut1,
family="ipv6",
thread=data.clear_parallel)
vlan_obj.clear_vlan_configuration(dut1, thread=data.clear_parallel)
def bgp_fast_reboot_module_hooks(request):
global vars
vars = st.ensure_min_topology("D1D2:1", "D1T1:2")
if not st.is_feature_supported("bgp-neighbotship-performance", vars.D1):
data.neighborship_wait = 30
st.log("Enabling IPv6 mode globally")
ip_obj.config_ipv6(vars.D1, action='enable')
ip_obj.config_ipv6(vars.D2, action='enable')
st.log("Configuring ipv4 addresses on routing interfaces")
ipv4_ip_address_config()
st.log("Verifying ipv4 addresses on routing interfaces")
verify_ipv4_address_config()
if data.ipv6_support:
st.log("Configuring ipv6 addresses on routing interfaces")
ipv6_address_config()
st.log("Verifying ipv6 addresses on routing interfaces")
verify_ipv6_address_config()
st.log(
"Configuring IPV6 eBGP config between DUT1 and DUT2,iBGP config between DUT1 and TG2"
)
ipv6_bgp_config()
st.log(
"Configuring IPV4 eBGP config between DUT1 and DUT2,iBGP config between DUT1 and TG1"
)
ipv4_bgp_config()
if data.ipv6_support:
st.log("Configuring TG2 V6 iBGP config")
tg_bgpv6_config(vars, data.local_asn4, data.remote_asn4)
st.log("Configuring TG1 V4 iBGP config")
tg_bgp_config(vars, data.local_asn4, data.remote_asn4)
st.log(
"Verify IPV4 eBGP neighborship between D1 and D2 and iBGP neighborship between D1 and TG1"
)
verify_v4_bgp_neigborship()
if data.ipv6_support:
st.log(
"Verify IPV6 eBGP neighborship between D1 and D2 and iBGP neighborship between D1 and TG2"
)
verify_v6_bgp_neigborship()
yield
bgp_obj.cleanup_router_bgp(st.get_dut_names())
ip_obj.clear_ip_configuration(st.get_dut_names())
if data.ipv6_support:
ip_obj.clear_ip_configuration(st.get_dut_names(), 'ipv6')
vlan_obj.clear_vlan_configuration(st.get_dut_names())
portchannel_obj.clear_portchannel_configuration(st.get_dut_names())
def vlan_module_config(config='yes'):
if config == 'yes':
st.log("Creating max number of vlans")
max_vlan_create()
max_vlan_verify()
add_vlan_members()
else:
vlan.clear_vlan_configuration([vars.D1])
def vlan_module_epilog():
if st.is_feature_supported("strom-control", vars.D1):
interface_list = [vars.D1T1P1, vars.D1T1P2]
storm_control_type = ["broadcast", "unknown-multicast", "unknown-unicast"]
for interface in interface_list:
for stc_type in storm_control_type:
scapi.config(vars.D1, type=stc_type, action="del", interface_name=interface, bits_per_sec=sc_data.kbps)
vlan.clear_vlan_configuration(st.get_dut_names(), thread=False)
portchannel.clear_portchannel_configuration(st.get_dut_names(),thread=True)
def arp_module_hooks(request):
global vars, tg_handler, tg, dut1, d1_mac_addr, h1, h2
# Min topology verification
vars = st.ensure_min_topology("D1T1:2")
# Initialize TG and TG port handlers
tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D1P2")
tg = tg_handler["tg"]
# Test setup details
data.my_dut_list = st.get_dut_names()
dut1 = data.my_dut_list[0]
# Test variables
d1_mac_addr = mac.get_sbin_intf_mac(dut1, "eth0")
# ARP module configuration
st.log("ARP module configuration.")
ip_obj.config_ip_addr_interface(dut1, vars.D1T1P1, data.d1t1_ip_addr,
data.mask)
vlan_obj.create_vlan(dut1, data.vlan_1)
vlan_obj.add_vlan_member(dut1, data.vlan_1, vars.D1T1P2, True)
ip_obj.config_ip_addr_interface(dut1, data.vlan_int_1, data.d1t2_ip_addr,
data.mask)
# TG ports reset
st.log("Resetting the TG ports")
tg.tg_traffic_control(action="reset", port_handle=tg_handler["tg_ph_list"])
# TG protocol interface creation
st.log("TG protocol interface creation")
h1 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_1"],
mode='config',
intf_ip_addr=data.t1d1_ip_addr,
gateway=data.d1t1_ip_addr,
src_mac_addr=data.t1d1_mac_addr,
arp_send_req='1')
st.log("INTFCONF: " + str(h1))
h2 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_2"],
mode='config',
intf_ip_addr=data.t2d1_ip_addr,
gateway=data.d1t2_ip_addr,
src_mac_addr=data.t2d1_mac_addr,
arp_send_req='1',
vlan_id=data.vlan_1,
vlan=1)
st.log("INTFCONF: " + str(h2))
yield
# ARP module cleanup
st.log("ARP module cleanup.")
ip_obj.clear_ip_configuration(dut1,
family="ipv4",
thread=data.clear_parallel)
vlan_obj.clear_vlan_configuration(dut1, thread=data.clear_parallel)
def sf_module_prolog():
clear_vlan_configuration(vars.D1)
sf_data.vlan = str(random_vlan_list()[0])
create_vlan(vars.D1, sf_data.vlan)
add_vlan_member(vars.D1,
sf_data.vlan,
port_list=sf_data.port_list,
tagging_mode=True)
sf_data.tg, sf_data.tg_ph_list, sf_data.stream_sf_data = sf_tg_stream_config(
)
def vlan_module_hooks(request):
global vars
vars = st.ensure_min_topology("D1D2:2", "D1T1:2", "D2T1:2")
sc_data.version_data = basic_obj.show_version(vars.D1)
vlan_variables()
if not st.is_feature_supported("vlan-range", vars.D1):
sc_data.max_vlan = 100
[_, exceptions] = exec_all(True, [[config_tg_stream], [vlan_module_prolog]], first_on_main=True)
ensure_no_exception(exceptions)
yield
vlan.clear_vlan_configuration(st.get_dut_names(), thread=False)
def interface_module_hooks(request):
global vars
vars = st.ensure_min_topology("D1D2:2", "D1T1:2")
initialize_variables()
if not vlanapi.create_vlan(vars.D1, intf_data.vlan_id):
st.report_fail("vlan_create_fail", intf_data.vlan_id)
if not vlanapi.add_vlan_member(vars.D1, intf_data.vlan_id, [vars.D1T1P1, vars.D1T1P2]):
st.report_fail("vlan_untagged_member_fail", [vars.D1T1P1, vars.D1T1P2], intf_data.vlan_id)
st.log("Getting TG handlers")
_, intf_data.tg_ph_1 = tgapi.get_handle_byname("T1D1P1")
_, intf_data.tg_ph_2 = tgapi.get_handle_byname("T1D1P2")
intf_data.tg = tgapi.get_chassis(vars)
st.log("Reset and clear statistics of TG ports")
intf_data.tg.tg_traffic_control(action='reset', port_handle=[intf_data.tg_ph_1, intf_data.tg_ph_2])
intf_data.tg.tg_traffic_control(action='clear_stats', port_handle=[intf_data.tg_ph_1, intf_data.tg_ph_2])
st.log("Creating TG streams")
intf_data.streams = {}
stream = intf_data.tg.tg_traffic_config(port_handle=intf_data.tg_ph_1, mode='create', port_handle2=intf_data.tg_ph_2,
length_mode='fixed', rate_pps=100, frame_size=intf_data.mtu1,
l2_encap='ethernet_ii_vlan', transmit_mode='single_burst',
pkts_per_burst=100, vlan_id=intf_data.vlan_id,
mac_src=intf_data.source_mac, mac_dst=intf_data.destination_mac,
vlan="enable")
st.log('Stream output:{}'.format(stream))
intf_data.streams['mtu1'] = stream['stream_id']
stream = intf_data.tg.tg_traffic_config(port_handle=intf_data.tg_ph_1, mode='create', port_handle2=intf_data.tg_ph_2,
length_mode='fixed', rate_pps=100, frame_size=intf_data.mtu2,
l2_encap='ethernet_ii_vlan', transmit_mode='single_burst',
pkts_per_burst=100, vlan_id=intf_data.vlan_id,
mac_src=intf_data.source_mac, mac_dst=intf_data.destination_mac,
vlan="enable")
st.log('Stream output:{}'.format(stream))
intf_data.streams['mtu2'] = stream['stream_id']
stream = intf_data.tg.tg_traffic_config(port_handle=intf_data.tg_ph_1, mode='create',
length_mode='fixed', frame_size='5000',
transmit_mode='continuous')
st.log('Stream output:{}'.format(stream))
intf_data.streams['traffic_tg1'] = stream['stream_id']
stream = intf_data.tg.tg_traffic_config(port_handle=intf_data.tg_ph_2, mode='create',
length_mode='fixed', frame_size='5000',
transmit_mode='continuous')
st.log('Stream output:{}'.format(stream))
intf_data.streams['traffic_tg2'] = stream['stream_id']
yield
vlanapi.clear_vlan_configuration(st.get_dut_names(), thread=True)
# intf_data.tg.tg_traffic_control(action='stop', port_handle=[intf_data.tg_ph_1, intf_data.tg_ph_2])
intf_data.tg.tg_traffic_control(action='reset', port_handle=[intf_data.tg_ph_1, intf_data.tg_ph_2])
def l3fwd_func_hooks(request):
global vars
vars = st.get_testbed_vars()
st.log("PRE TSET : Cleanup call are started.")
ipfeature.clear_ip_configuration(st.get_dut_names())
ipfeature.clear_ip_configuration(st.get_dut_names(), 'ipv6')
vapi.clear_vlan_configuration(st.get_dut_names())
yield
st.log("POST TSET : Cleanup call are started.")
ipfeature.clear_ip_configuration(st.get_dut_names())
ipfeature.clear_ip_configuration(st.get_dut_names(), 'ipv6')
vapi.clear_vlan_configuration(st.get_dut_names())
def pre_test_l3_fwding():
# override from testbed
vars = st.get_testbed_vars()
data.my_dut_list = st.get_dut_names()
ipfeature.clear_ip_configuration(st.get_dut_names())
ipfeature.clear_ip_configuration(st.get_dut_names(),'ipv6')
vapi.clear_vlan_configuration(st.get_dut_names())
ipfeature.config_ip_addr_interface(vars.D1, vars.D1T1P1, data.d1t1_5_x_ip_addr, data.mask)
ipfeature.config_ip_addr_interface(vars.D1, vars.D1T1P2, data.d1t2_5_x_ip_addr, data.mask)
def bgp_save_reboot_module_hooks(request):
global vars
vars = st.ensure_min_topology("D1D2:1", "D1T1:2")
data.shell_vtysh = st.get_ui_type()
if data.shell_vtysh == "click":
data.shell_vtysh = "vtysh"
if not st.is_feature_supported("bgp-neighbotship-performance", vars.D1):
data.neighborship_wait = 30
st.log("Enabling IPv6 mode globally")
st.exec_each([vars.D1, vars.D2], ip_obj.config_ipv6, action='enable')
st.log("Configuring ipv4 addresses on routing interfaces")
st.exec_each([vars.D1, vars.D2], ipv4_ip_address_config)
st.log("Verifying ipv4 addresses on routing interfaces")
st.exec_each([vars.D1, vars.D2], verify_ipv4_address_config)
if data.ipv6_support:
st.log("Configuring ipv6 addresses on routing interfaces")
st.exec_each([vars.D1, vars.D2], ipv6_address_config)
st.log("Verifying ipv6 addresses on routing interfaces")
st.exec_each([vars.D1, vars.D2], verify_ipv6_address_config)
st.log(
"Configuring IPV6 eBGP config between DUT1 and DUT2,iBGP config between DUT1 and TG2"
)
st.exec_each([vars.D1, vars.D2], ipv6_bgp_config)
st.log(
"Configuring IPV4 eBGP config between DUT1 and DUT2,iBGP config between DUT1 and TG1"
)
st.exec_each([vars.D1, vars.D2], ipv4_bgp_config)
if data.ipv6_support:
st.log("Configuring TG2 V6 iBGP config")
tg_bgpv6_config(vars, data.local_asn4, data.remote_asn4)
st.log("Configuring TG1 V4 iBGP config")
tg_bgp_config(vars, data.local_asn4, data.remote_asn4)
yield
bgp_obj.cleanup_router_bgp(st.get_dut_names())
ip_obj.clear_ip_configuration(st.get_dut_names())
if data.ipv6_support:
ip_obj.clear_ip_configuration(st.get_dut_names(),
'ipv6',
skip_error_check=True)
vlan_obj.clear_vlan_configuration(st.get_dut_names())
portchannel_obj.clear_portchannel_configuration(st.get_dut_names())
def bum_clear_config():
interface_list = [vars.D1T1P1, vars.D1T1P2]
storm_control_type = ["broadcast", "unknown-multicast", "unknown-unicast"]
for interface in interface_list:
for stc_type in storm_control_type:
scapi.config(vars.D1,
type=stc_type,
action="del",
interface_name=interface,
bits_per_sec=data.kbps)
vlan.clear_vlan_configuration(st.get_dut_names(), thread=False)
portchannel.clear_portchannel_configuration(st.get_dut_names(),
thread=True)
def storm_control_module_hooks(request):
global vars
vars = st.ensure_min_topology("D1D2:2", "D1T1:2", "D2T1:2")
sc_data.version_data = basic_obj.show_version(vars.D1)
vlan_variables()
[out, exceptions] = exec_all(True,
[[config_tg_stream], [vlan_module_prolog]],
first_on_main=True)
ensure_no_exception(exceptions)
yield
vlan.clear_vlan_configuration(st.get_dut_names(),
thread=False,
cli_type="click")
def portchannel_module_hooks(request):
# add things at the start of this module
global vars
vars = st.ensure_min_topology("D1D2:4", "D1T1:1", "D2T1:1")
initialize_variables()
exec_all(
True,
[[static_port_channel_tg_config], [static_port_channel_dut_config]],
first_on_main=True)
yield
st.log('Module config Cleanup')
clear_vlan_configuration([vars.D1, vars.D2])
portchannelobj.clear_portchannel_configuration([vars.D1, vars.D2])
def reboot_module_hooks(request):
global vars
global data
data = SpyTestDict()
data.iter_count = 3
data.idle_sleep = 300
data.max_vlan = 4093
vars = st.get_testbed_vars()
vars = st.ensure_min_topology("D1")
vlan_obj.config_vlan_range(vars.D1,
"1 {}".format(data.max_vlan),
config='add')
yield
vlan_obj.clear_vlan_configuration(st.get_dut_names(), thread=False)
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 nat_post_config():
vars = st.get_testbed_vars()
util_nat_zone_config(vars, [vars.D1T1P1, vars.D1T1P2], [data.zone_1, data.zone_2], config=data.config_del)
nat_obj.clear_nat_config(vars.D1)
nat_obj.config_nat_feature(vars.D1, 'disable')
ip_obj.delete_static_route(vars.D1, data.out_ip_addr_h,
"{}/{}".format(data.global_ip_addr_rt, data.global_ip_addr_mask))
ip_obj.clear_ip_configuration(st.get_dut_names())
vlan_obj.clear_vlan_configuration(st.get_dut_names())
st.log("Cleaning up routing interfaces configured on TG")
tg1.tg_interface_config(port_handle=tg_ph_1, handle=tg_rt_int_handle[0]['handle'], mode='destroy')
tg1.tg_interface_config(port_handle=tg_ph_2, handle=tg_rt_int_handle[1]['handle'], mode='destroy')
tgapi.traffic_action_control(tg_handler, actions=['reset'])
def pvst_elastic_module_hooks(request):
global vars
vars = st.ensure_min_topology("D1D2:4", "D1T1:2", "D2T1:2")
vlan_variables()
vlan.clear_vlan_configuration(st.get_dut_names(), thread=False)
[_, exceptions] = exec_all(True,
[[config_tg_stream], [looguard_module_prolog]],
first_on_main=True)
ensure_no_exception(exceptions)
yield
stp.config_stp_in_parallel(sc_data.dut_list,
feature="rpvst",
mode="disable",
vlan=None)
vlan.clear_vlan_configuration(st.get_dut_names(), thread=False)
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 vlan_func_hooks(request):
bum_test_functions = [
"test_ft_stormcontrol_verification",
"test_ft_stormcontrol_portchannel_intf",
"test_ft_stormcontrol_incremental_bps_max_vlan",
"test_ft_stormcontrol_fast_reboot", "test_ft_stormcontrol_warm_reboot"
]
if st.get_func_name(request) in bum_test_functions:
platform_check()
if request.function.func_name == "test_ft_snmp_max_vlan_scale":
vlan.clear_vlan_configuration(st.get_dut_names(),
thread=False,
cli_type="click")
portchannel.clear_portchannel_configuration(st.get_dut_names(),
thread=True)
yield
def cmds_func_hooks(request):
yield
d1 = {'domain_id': 1, 'config': 'del', 'cli_type': 'click'}
putils.exec_parallel(True, [data.d1, data.d2], mclag.config_domain,
[d1, d1])
if st.get_func_name(request) == 'test_chef_evpn_vxlan_nvo':
evpn_cleanup()
bgp_cleanup()
ip_obj.clear_ip_configuration(st.get_dut_names(),
thread=data.clear_parallel)
vlan.clear_vlan_configuration(st.get_dut_names(),
thread=data.clear_parallel,
cli_type=data.cli_type)
clear_portchannel_configuration(st.get_dut_names(),
thread=data.clear_parallel,
cli_type=data.cli_type)
def tacacs_module_hooks(request):
# add things at the start of this module
global vars
vars = st.ensure_min_topology("D1")
tacacs_params = st.get_service_info(vars.D1, "tacacs")
st.log("Getting IP address of the device")
data.clear()
data.hosts = ensure_service_params(vars.D1, "tacacs", "hosts")
data.tacacs_ser_ip_1 = ensure_service_params(vars.D1, "tacacs", "hosts", 0, "ip")
data.tcp_port = ensure_service_params(vars.D1, "tacacs", "hosts", 0, "tcp_port")
data.passkey = ensure_service_params(vars.D1, "tacacs", "hosts", 0, "passkey")
data.priority = ensure_service_params(vars.D1, "tacacs", "hosts", 0, "priority")
data.timeout = ensure_service_params(vars.D1, "tacacs", "hosts", 0, "timeout")
data.auth_type = ensure_service_params(vars.D1, "tacacs", "hosts", 0, "auth_type")
data.tacacs_ser_ip_2 = ensure_service_params(vars.D1, "tacacs", "hosts", 1, "ip")
data.priority_server2 = ensure_service_params(vars.D1, "tacacs", "hosts", 1, "priority")
data.time_out = '10'
data.username = '******'
data.password = '******'
data.protocol = 'ssh'
data.ssh_port = '22'
data.login_type = "tacacs+"
data.failthrough_mode = 'enable'
data.local_username = '******'
data.local_password = '******'
data.local_password2 = 'broadcom'
data.username1 = 'test'
data.password1 = 'test'
data.rw_user = {'username': data.username, 'password': data.password, 'mode': 'rw'}
data.ro_username = ensure_service_params(vars.D1, "radius", "ro_user", "username")
ensure_device_ipaddress()
st.log("Configuring authentication login parameter as tacacs+ and local")
tacacs_obj.set_aaa_authentication_properties(vars.D1, 'login', 'tacacs+ local')
tacacs_obj.set_tacacs_server(vars.D1, 'add', data.tacacs_ser_ip_1, data.tcp_port, data.timeout, data.passkey,
data.auth_type, data.priority)
yield
config_default_tacacs_properties(vars.D1)
st.log("Deleting all TACACS+ servers from the device")
for i in range(0, 8):
tacacs_obj.set_tacacs_server(vars.D1, 'delete', tacacs_params.hosts[i].ip)
st.log("Making AAA parameters to default")
tacacs_obj.set_aaa_authentication_properties(vars.D1, 'login', 'default')
tacacs_obj.set_aaa_authentication_properties(vars.D1, 'failthrough', 'default')
clear_vlan_configuration([vars.D1])
def scheduling_module_config(config='yes'):
if config == 'yes':
st.debug("Configuring MAC age out time")
[output, exceptions] = exec_all(
True, [[config_mac_agetime, vars.D1, scheduling_data.ageout_time],
[config_mac_agetime, vars.D2, scheduling_data.ageout_time]])
ensure_no_exception(exceptions)
if not all(output):
st.report_fail("mac_aging_time_failed_config")
st.debug("Verifying MAC age out time")
[output, exceptions
] = exec_all(True,
[[get_mac_agetime, vars.D1], [get_mac_agetime, vars.D2]])
ensure_no_exception(exceptions)
if not ((int(output[0]) == scheduling_data.ageout_time) and
(int(output[1]) == scheduling_data.ageout_time)):
st.report_fail(
"msg", "MAC age out time is not configured as: {}".format(
scheduling_data.ageout_time))
st.debug("Create a vlan and add ports as tagged members to it")
if not create_vlan_and_add_members(
[{
"dut": [vars.D1],
"vlan_id": scheduling_data.vlan,
"tagged": [vars.D1T1P1, vars.D1T1P2, vars.D1D2P1]
}, {
"dut": [vars.D2],
"vlan_id": scheduling_data.vlan,
"tagged": [vars.D2T1P1, vars.D2T1P2, vars.D2D1P1]
}]):
st.report_fail(
"msg",
"Failed to add port as tagged members of VLAN: {}".format(
scheduling_data.vlan))
else:
# clearing scheduling and vlan config
clear_port_shaper(vars.D1,
port=vars.D1D2P1,
shaper_data=scheduling_data.policy_name,
qos_clear=True)
clear_vlan_configuration([vars.D1, vars.D2], thread=True)
scheduling_data.tg.tg_traffic_control(
action='stop', stream_handle=scheduling_data.streams.values())
def sanity_l3_func_hooks(request):
# add things at the start every test case
# use 'st.get_func_name(request)' to compare
# if any thing specific a particular test case
global vars
vars = st.ensure_min_topology("D1D2:1", "D1T1:1", "D2T1:1")
st.log("POST TEST : Cleanup call are started..")
ipfeature.clear_ip_configuration(st.get_dut_names(),
thread=data.clear_parallel)
ipfeature.clear_ip_configuration(st.get_dut_names(),
'ipv6',
thread=data.clear_parallel)
vapi.clear_vlan_configuration(st.get_dut_names(),
thread=data.clear_parallel)
portchannel_obj.clear_portchannel_configuration(st.get_dut_names(),
thread=data.clear_parallel)
pre_test_l3_fwding()
yield
post_test_l3_fwding()
def pvst_elastic_module_hooks(request):
global vars
global stp_ela
try:
vars = st.ensure_min_topology("D1D2:3", "D2D3:3", "D1D3:3")
lib_stp.init_cli_type()
stp_ela = stp_wrap.apply_and_verify_module_config(vars, stp_protocol)
st.log(stp_ela)
except Exception as e:
st.log(e)
st.report_fail("exception", e)
dut_list = stp_wrap.get_dut_list(vars)
for d in dut_list:
slog.clear_logging(d)
yield
stp.config_stp_in_parallel(dut_list, feature=stp_protocol, mode="disable")
vlan.clear_vlan_configuration(dut_list)
portchannel.clear_portchannel_configuration(dut_list)
stp_wrap.complete_data.clear()
def vlan_module_epilog():
if not st.is_community_build(vars.D1):
interface_list = [vars.D1T1P1, vars.D1T1P2]
storm_control_type = [
"broadcast", "unknown-multicast", "unknown-unicast"
]
for interface in interface_list:
for stc_type in storm_control_type:
scapi.config(vars.D1,
type=stc_type,
action="del",
interface_name=interface,
bits_per_sec=sc_data.kbps,
cli_type="click")
vlan.clear_vlan_configuration(st.get_dut_names(),
thread=False,
cli_type="click")
portchannel.clear_portchannel_configuration(st.get_dut_names(),
thread=True)
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)
