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 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 tg_vrf_bgp(**kwargs):
dut1 = st.get_dut_names()[0]
dut2 = st.get_dut_names()[1]
if 'config' in kwargs:
config = kwargs['config']
else:
config = ''
if config == '':
st.log('######------Configure BGP in vrf -101 for TG interface------######')
for i in range(0,3):
bgp_obj.config_bgp(dut = dut1, vrf_name = data.vrf_name[i], router_id = data.dut1_router_id, local_as = data.dut1_as[i], neighbor = data.tg1_dut1_vrf_ip[i], remote_as = data.dut1_tg_as[i], config = 'yes', config_type_list =['neighbor','activate'])
st.log('######------Configure BGPv4+ in vrf-102 for TG interface ------######')
bgp_obj.config_bgp(dut = dut1, vrf_name = data.vrf_name[i], router_id = data.dut1_router_id, addr_family ='ipv6', local_as = data.dut1_as[i], neighbor = data.tg1_dut1_vrf_ipv6[i], remote_as = data.dut1_tg_as[i], config = 'yes', config_type_list =['neighbor','activate'])
bgp_obj.config_bgp(dut = dut1, vrf_name = data.vrf_name[i], local_as = data.dut1_as[i], addr_family ='ipv6', config_type_list=["routeMap"], routeMap='UseGlobal', diRection='in', neighbor=data.tg1_dut1_vrf_ipv6[i])
bgp_obj.config_bgp(dut = dut2, vrf_name = data.vrf_name[i], router_id = data.dut2_router_id, local_as = data.dut2_as[i], neighbor = data.tg1_dut2_vrf_ip[i], remote_as = data.dut2_tg_as[i], config = 'yes', config_type_list =['neighbor','activate'])
bgp_obj.config_bgp(dut = dut2, vrf_name = data.vrf_name[i], router_id = data.dut2_router_id, addr_family ='ipv6', local_as = data.dut2_as[i], neighbor = data.tg1_dut2_vrf_ipv6[i], remote_as = data.dut2_tg_as[i], config = 'yes', config_type_list =['neighbor','activate'])
bgp_obj.config_bgp(dut = dut2, vrf_name = data.vrf_name[i], local_as = data.dut2_as[i], addr_family ='ipv6', config_type_list=["routeMap"], routeMap='UseGlobal', diRection='in', neighbor=data.tg1_dut2_vrf_ipv6[i])
time.sleep(2)
'''
for i in range(0,3):
if not retry_api(bgp_obj.verify_bgp_summary,dut1,family='ipv4',shell="sonic",neighbor=data.tg1_dut1_vrf_ip[i], state='Established', vrf = data.vrf_name[i],delay=5,retry_count=5):
st.log("FAIL: BGP not up")
if not retry_api(bgp_obj.verify_bgp_summary,dut2,family='ipv6',shell="sonic",neighbor=data.tg1_dut2_vrf_ipv6[i], state='Established', vrf = data.vrf_name[i],delay=5,retry_count=5):
st.log("FAIL: BGPv6 not up")
'''
elif config == 'no':
for i in range(0,3):
bgp_obj.config_bgp(dut = dut1, local_as = data.dut1_as[i], vrf_name = data.vrf_name[i] ,config = 'no', removeBGP = 'yes', config_type_list = ["removeBGP"])
bgp_obj.config_bgp(dut = dut2, local_as = data.dut2_as[i], vrf_name = data.vrf_name[i] ,config = 'no', removeBGP = 'yes', config_type_list = ["removeBGP"])
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_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 bgp_rr_traffic_pre_config_cleanup():
st.banner("BGP RR WITH TRAFFIC CLASS CONFIG CLEANUP - START")
bgplib.l3tc_vrfipv4v6_address_leafspine_bgp_config(config='no',
rr_enable='true')
bgplib.l3tc_vrfipv4v6_address_leafspine_config_unconfig(config='no')
bgpapi.cleanup_router_bgp(st.get_dut_names())
ipapi.clear_ip_configuration(st.get_dut_names(), family='all', thread=True)
bgplib.l3tc_underlay_config_unconfig(config='no')
bgplib.l3tc_vrfipv4v6_address_leafspine_rr_tg_bgp_config(config='no',
rr_enable='true')
st.banner("BGP RR WITH TRAFFIC CLASS CONFIG CLEANUP - END")
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 tg_vrf_bind(**kwargs):
vars = st.get_testbed_vars()
dut1 = st.get_dut_names()[0]
dut2 = st.get_dut_names()[1]
if 'config' in kwargs:
config = kwargs['config']
else:
config = ''
if config == '':
st.log('######------Configure vlans on the PE--CE side-------######')
for i in range(3):
utils.exec_all(True, [[vlan_obj.create_vlan, vars.D1, data.dut1_tg1_vlan[i]], [vlan_obj.create_vlan, vars.D2, data.dut2_tg1_vlan[i]]])
utils.exec_all(True,[[vlan_obj.add_vlan_member,vars.D1,data.dut1_tg1_vlan[i],vars.D1T1P1,True,True], [vlan_obj.add_vlan_member,vars.D2,data.dut2_tg1_vlan[i],vars.D2T1P1,True,True]])
'''
vlan_obj.create_vlan(vars.D1, data.dut1_tg1_vlan[i]) # Vlan-1, VRF-101, port1
vlan_obj.add_vlan_member(vars.D1, data.dut1_tg1_vlan[i], vars.D1T1P1, True, True)
vlan_obj.create_vlan(vars.D2, data.dut2_tg1_vlan[i])
vlan_obj.add_vlan_member(vars.D2, data.dut2_tg1_vlan[i], vars.D2T1P1, True, True)
'''
st.log('######------Bind DUT1 <--> tg1 vlans to vrf, assign v4 and v6 address------######')
for vrf, vlan, ip, ipv6 in zip(data.vrf_name[0:3], data.dut1_tg1_vlan[0:3],data.dut1_tg1_vrf_ip[0:3], data.dut1_tg1_vrf_ipv6[0:3]):
vrf_api.bind_vrf_interface(dut = vars.D1, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True)
ipfeature.config_ip_addr_interface(vars.D1, 'Vlan'+vlan, ip, data.dut1_tg1_vrf_ip_subnet, 'ipv4')
ipfeature.config_ip_addr_interface(vars.D1, 'Vlan'+vlan, ipv6, data.dut1_tg1_vrf_ipv6_subnet, 'ipv6')
st.log('######------Bind DUT2 <--> tg1 vlans to vrf, assign v4 and v6 address------######')
for vrf, vlan,ip,ipv6 in zip(data.vrf_name[0:3], data.dut2_tg1_vlan[0:3], data.dut2_tg1_vrf_ip[0:3], data.dut2_tg1_vrf_ipv6[0:3]):
vrf_api.bind_vrf_interface(dut = vars.D2, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True)
ipfeature.config_ip_addr_interface(vars.D2, 'Vlan'+vlan, ip, data.dut2_tg1_vrf_ip_subnet, 'ipv4')
ipfeature.config_ip_addr_interface(vars.D2, 'Vlan'+vlan, ipv6, data.dut2_tg1_vrf_ipv6_subnet, 'ipv6')
else:
st.log('######------Unbind DUT1 <--> tg1port1 vlans to vrf, assign v4 and v6 address------######')
for vrf, vlan, ip, ipv6 in zip(data.vrf_name[0:3], data.dut1_tg1_vlan[0:3],data.dut1_tg1_vrf_ip[0:3], data.dut1_tg1_vrf_ipv6[0:3]):
ipfeature.delete_ip_interface(dut1, 'Vlan'+vlan, ip, data.dut1_tg1_vrf_ip_subnet, 'ipv4')
ipfeature.delete_ip_interface(dut1, 'Vlan'+vlan, ipv6, data.dut1_tg1_vrf_ipv6_subnet, 'ipv6')
vrf_api.bind_vrf_interface(dut = dut1, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True, config = 'no')
st.log('######------Unbind DUT2 <--> tg1 vlans to vrf, assign v4 and v6 address------######')
for vrf, vlan,ip,ipv6 in zip(data.vrf_name[0:3], data.dut2_tg1_vlan[0:3], data.dut2_tg1_vrf_ip[0:3], data.dut2_tg1_vrf_ipv6[0:3]):
ipfeature.delete_ip_interface(dut2, 'Vlan'+vlan, ip, data.dut2_tg1_vrf_ip_subnet, 'ipv4')
ipfeature.delete_ip_interface(dut2, 'Vlan'+vlan, ipv6, data.dut2_tg1_vrf_ipv6_subnet, 'ipv6')
vrf_api.bind_vrf_interface(dut = dut2, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True, config = 'no')
st.log('######------Unconfigure vlans on the PE--CE side -------######')
for i in range(3):
vlan_obj.delete_vlan_member(dut1, data.dut1_tg1_vlan[i], vars.D1T1P1, tagging_mode=True)
vlan_obj.delete_vlan(dut1, data.dut1_tg1_vlan[i]) # Vlan-1, VRF-101, port1
vlan_obj.delete_vlan_member(dut2, data.dut2_tg1_vlan[i], vars.D2T1P1, tagging_mode=True)
vlan_obj.delete_vlan(dut2, data.dut2_tg1_vlan[i])
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 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 apis_common_init(scope, ref=None):
"""
:param scope:
:type scope:
:param ref:
:type ref:
:return:
:rtype:
"""
from spytest import st, utils
if scope == "session":
return _api_common_session_begin()
if scope == "module":
st.debug("---- common module {} begin ----".format(ref))
elif scope == "function":
st.debug("---- common test {} begin ----".format(ref))
if not os.getenv("SPYTEST_SKIP_INIT_COMMANDS"):
def f(dut):
if st.get_device_type(dut) in ["sonic", "vsonic"]:
if not st.is_community_build():
st.show(dut,
"show system status",
skip_error_check=True,
skip_tmpl=True)
utils.exec_foreach(True, st.get_dut_names(), f)
def fill_alias():
alias = dict()
for dut in st.get_dut_names():
alias[dut] = st.get_device_alias(dut)
for tg in st.get_tg_names():
alias[tg] = st.get_device_alias(tg)
return alias
def arp_static_route_reboot_module_hooks(request):
# add things at the start of this module
init_vars()
initialize_variables()
get_parms()
global tg_handler
tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D1P2")
global tg
tg = tg_handler["tg"]
tg_ph_list = [tg_handler["tg_ph_1"], tg_handler["tg_ph_2"]]
st.log("configuring static route")
adding_static_route()
st.log("Getting ARP entry dynamically")
adding_dynamic_arp()
ip_obj.config_ip_addr_interface(vars.D1,
vars.D1T1P2,
data.ipv4_address_1,
data.mask,
family="ipv4",
config='add')
st.log("Configuring static ARP")
arp_obj.add_static_arp(vars.D1, data.static_arp_ip, data.static_arp_mac,
vars.D1T1P2)
st.log(
"Verifying static route entries before save and reboot/fast-reboot/warm-reboot"
)
static_route_verify()
st.log(
"Verifying dynamic ARP entries before save and reboot/fast-reboot/warm-reboot"
)
if not arp_obj.verify_arp(vars.D1, data.ipv4_address_ixia,
data.src_mac_addr, vars.D1T1P1):
st.report_fail("ARP_entry_dynamic_entry_fail", data.ipv4_address_ixia,
vars.D1)
else:
st.log("Verified that dynamic ARP entry is present in arp table")
st.log(
"Verifying static ARP entries before save and reboot/fast-reboot/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.log("Save the config on the DUT")
rb_obj.config_save(vars.D1)
st.log("saving config in vtysh mode to save static route")
rb_obj.config_save(vars.D1, shell="vtysh")
yield
# Below step will clear IP adresses configured on different interfaces in the device
ip_obj.clear_ip_configuration(st.get_dut_names())
#Below step will clear static route configured in the device
ip_obj.delete_static_route(vars.D1,
data.ipv4_address_ixia,
data.ipv4_address_network,
family='ipv4',
shell="vtysh")
#Below step will delete static arp entries configured in the device
arp_obj.delete_static_arp(vars.D1, data.static_arp_ip, vars.D1T1P2)
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 initialize_topology():
st.log(
"Script Starts Here!. Initialize.........................................................................................."
)
vars = st.ensure_min_topology("D1D2:4", "D2D3:4", "D1T1:2", "D3T1:2")
data.dut_list = st.get_dut_names()
data.dut1 = data.dut_list[0]
data.dut2 = data.dut_list[1]
data.dut3 = data.dut_list[2]
utils.exec_all(True,
[[bgp_obj.enable_docker_routing_config_mode, data.dut1],
[bgp_obj.enable_docker_routing_config_mode, data.dut2],
[bgp_obj.enable_docker_routing_config_mode, data.dut3]])
data.d1_d2_ports = [vars.D1D2P1, vars.D1D2P2, vars.D1D2P3, vars.D1D2P4]
data.d2_d1_ports = [vars.D2D1P1, vars.D2D1P2, vars.D2D1P3, vars.D2D1P4]
data.d2_d3_ports = [vars.D2D3P1, vars.D2D3P2, vars.D2D3P3, vars.D2D3P4]
data.d3_d2_ports = [vars.D3D2P1, vars.D3D2P2, vars.D3D2P3, vars.D3D2P4]
data.dut1_tg_ports = [vars.D1T1P1, vars.D1T1P2]
data.dut3_tg_ports = [vars.D3T1P1, vars.D3T1P2]
data.tg_dut1_ports = [vars.T1D1P1, vars.T1D1P2]
data.tg_dut3_ports = [vars.T1D3P1, vars.T1D3P2]
data.tg = tgen_obj_dict[vars['tgen_list'][0]]
data.tg_dut1_p1 = data.tg.get_port_handle(vars.T1D1P1)
data.tg_dut3_p1 = data.tg.get_port_handle(vars.T1D3P1)
data.tg_dut1_p2 = data.tg.get_port_handle(vars.T1D1P2)
data.tg_dut3_p2 = data.tg.get_port_handle(vars.T1D3P2)
data.d1_stream_list = {}
data.d1_stream_list_vrf = {}
data.d3_stream_list = {}
if 'ixia' in vars['tgen_list'][0]:
data.tgen_type = 'ixia'
data.delay_factor = 2
else:
data.tgen_type = 'stc'
data.delay_factor = 1
def initialize_topology():
st.log(
"Script Starts Here!. Initialize.........................................................................................."
)
#DUT topology variables
vars = st.ensure_min_topology("D1D2:4", "D1T1:2", "D2T1:2")
data.dut_list = st.get_dut_names()
data.dut1 = data.dut_list[0]
data.dut2 = data.dut_list[1]
data.d1_d2_ports = [vars.D1D2P1, vars.D1D2P2, vars.D1D2P3, vars.D1D2P4]
data.d2_d1_ports = [vars.D2D1P1, vars.D2D1P2, vars.D2D1P3, vars.D2D1P4]
#DUT-TG topology variables
data.dut1_tg_ports = [vars.D1T1P1, vars.D1T1P2]
data.dut2_tg_ports = [vars.D2T1P1, vars.D2T1P2]
data.tg_dut1_ports = [vars.T1D1P1, vars.T1D1P2]
data.tg_dut2_ports = [vars.T1D2P1, vars.T1D2P2]
data.tg = tgen_obj_dict[vars['tgen_list'][0]]
data.tg_dut1_p1 = data.tg.get_port_handle(vars.T1D1P1)
data.tg_dut2_p1 = data.tg.get_port_handle(vars.T1D2P1)
data.tg_dut1_p2 = data.tg.get_port_handle(vars.T1D1P2)
data.tg_dut2_p2 = data.tg.get_port_handle(vars.T1D2P2)
data.d1_stream_list = {}
data.d2_stream_list = {}
data.d1_gateway_mac = mac_obj.get_sbin_intf_mac(data.dut1,
data.dut1_tg_ports[0])
#TGEN delay
if 'ixia' in vars['tgen_list'][0]:
data.tgen_type = 'ixia'
data.delay_factor = 2
else:
data.tgen_type = 'stc'
data.delay_factor = 1
def post_test_l3_fwding():
vars = st.get_testbed_vars()
data.my_dut_list = st.get_dut_names()
ipfeature.delete_ip_interface(vars.D1, vars.D1T1P1, data.d1t1_5_x_ip_addr, data.mask)
ipfeature.delete_ip_interface(vars.D1, vars.D1T1P2, data.d1t2_5_x_ip_addr, data.mask)
def initialize_topology_vars():
vars = st.ensure_min_topology("D1D3:4", "D2D3:4", "D1D4:4", "D2D4:4",
"D3T1:1", "D4T1:1", "D1D2:1")
data.dut_list = st.get_dut_names()
data.dut1 = data.dut_list[0]
data.dut2 = data.dut_list[1]
data.dut3 = data.dut_list[2]
data.dut4 = data.dut_list[3]
for dut in vars.dut_list:
bgp_api.enable_docker_routing_config_mode(dut)
data.d1d2_ports = [vars.D1D2P1]
data.d2d1_ports = [vars.D2D1P1]
data.d1d3_ports = [vars.D1D3P1, vars.D1D3P2, vars.D1D3P3, vars.D1D3P4]
data.d1d4_ports = [vars.D1D4P1, vars.D1D4P2, vars.D1D4P3, vars.D1D4P4]
data.d2d3_ports = [vars.D2D3P1, vars.D2D3P2, vars.D2D3P3, vars.D2D3P4]
data.d2d4_ports = [vars.D2D4P1, vars.D2D4P2, vars.D2D4P3, vars.D2D4P4]
data.d3d1_ports = [vars.D3D1P1, vars.D3D1P2, vars.D3D1P3, vars.D3D1P4]
data.d3d2_ports = [vars.D3D2P1, vars.D3D2P2, vars.D3D2P3, vars.D3D2P4]
data.d4d1_ports = [vars.D4D1P1, vars.D4D1P2, vars.D4D1P3, vars.D4D1P4]
data.d4d2_ports = [vars.D4D2P1, vars.D4D2P2, vars.D4D2P3, vars.D4D2P4]
data.d4tg_ports = vars.D4T1P1
data.d3tg_ports = vars.D3T1P1
data.tg1 = tgen_obj_dict[vars['tgen_list'][0]]
data.tg2 = tgen_obj_dict[vars['tgen_list'][0]]
data.tgd3_ports = vars.T1D3P1
data.tgd4_ports = vars.T1D4P1
data.tg_dut3_p1 = data.tg1.get_port_handle(vars.T1D3P1)
data.tg_dut4_p1 = data.tg2.get_port_handle(vars.T1D4P1)
data.tg_handles = [data.tg_dut3_p1, data.tg_dut4_p1]
data.D4_tg_mac = basic_api.get_ifconfig(data.dut4,
data.d4tg_ports)[0]['mac']
if 'ixia' in vars['tgen_list'][0]:
data.delay_factor = 2
else:
data.delay_factor = 1
def nat_post_config():
vars = st.get_testbed_vars()
util_nat_zone_config(vars.D2, [vars.D2D1P1, vars.D2D3P1], [data.zone_1, data.zone_2], config=data.config_del)
nat_obj.clear_nat_config(vars.D2)
nat_obj.config_nat_feature(vars.D2, 'disable')
ip_obj.delete_static_route(vars.D1, data.d2d1_ip_addr,"{}/{}".format(data.d1_static_nw, data.ip_addr_mask))
ip_obj.delete_static_route(vars.D3, data.d2d3_ip_addr,"{}/{}".format(data.d3_static_nw, data.ip_addr_mask))
ip_obj.clear_ip_configuration(st.get_dut_names())
def test_reboot_dut():
"""
This test is to reload all the DUTs mentioned as part of TestBed file.
:return:
"""
for dut in st.get_dut_names():
st.reboot(dut)
st.report_pass("build_reboot_success")
def tg_links_status_1():
results = dict()
for dut in st.get_dut_names():
for local, partner, remote in st.get_tg_links(dut):
(tg, ph) = tgapi.get_handle_byname(None, tg=partner, port=remote)
name = "{}--{}".format(partner, remote)
results[name] = get_link_status(tg, ph)
return results
def duts_links_status(threads):
results = dict()
[rvs, exs] = utils.exec_foreach(threads, st.get_dut_names(),
dut_links_status)
for rv in rvs:
if rv:
results.update(rv)
return results
def tg_links_status_using_hltapi():
results = dict()
for dut in st.get_dut_names():
for _, partner, remote in st.get_tg_links(dut, native=use_native):
(tg, ph) = tgapi.get_handle_byname(None, tg=partner, port=remote)
name = "{}--{}".format(partner, remote)
results[name] = get_tg_link_status(tg, ph)
return results
def duts_links_status(hooks, threads):
results = dict()
[rvs, exps] = putils.exec_foreach2(threads, "trace", st.get_dut_names(),
dut_links_status, hooks)
for rv in rvs:
if rv:
results.update(rv)
return results, any(exps)
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)
