def ceta_31902_fixture(request, ip_module_hooks):
vlan_obj.create_vlan(vars.D1, [data.host1_vlan, data.host2_vlan])
vlan_obj.add_vlan_member(vars.D1,
data.host1_vlan, [vars.D1T1P3, vars.D1T1P4],
tagging_mode=True)
vlan_obj.add_vlan_member(vars.D1,
data.host2_vlan, [vars.D1T1P3, vars.D1T1P4],
tagging_mode=True)
ipfeature.config_ip_addr_interface(vars.D1,
"Vlan" + data.host1_vlan,
data.vlan1_ip,
24,
family=data.af_ipv4)
ipfeature.config_ip_addr_interface(vars.D1,
"Vlan" + data.host2_vlan,
data.vlan2_ip,
24,
family=data.af_ipv4)
yield
ipfeature.delete_ip_interface(vars.D1,
"Vlan" + data.host1_vlan,
data.vlan1_ip,
"24",
family="ipv4")
ipfeature.delete_ip_interface(vars.D1,
"Vlan" + data.host2_vlan,
data.vlan2_ip,
"24",
family="ipv4")
vlan_obj.delete_vlan_member(vars.D1, data.host1_vlan,
[vars.D1T1P3, vars.D1T1P4], True)
vlan_obj.delete_vlan_member(vars.D1, data.host2_vlan,
[vars.D1T1P3, vars.D1T1P4], True)
vlan_obj.delete_vlan(vars.D1, [data.host1_vlan, data.host2_vlan])
def erspan_post_config():
"""
Author: Lakshminarayana D ([email protected])
Using this post config at module level. So, applicable for all test cases which includes in this module.
:return: None
"""
# Unconfig ip address on DUT-1
for port, ip_addr, in zip(data.port_list_d1, data.ip_list_d1):
ip.delete_ip_interface(vars.D1, port, ip_addr, data.subnet_mask)
# Unconfig ip address on DUT-2
for port, ip_addr in zip(data.port_list_d2, data.ip_list_d2):
ip.delete_ip_interface(vars.D2, port, ip_addr, data.subnet_mask)
# Unconfig static route
_, network = ip.get_network_addr("{}/{}".format(data.ip_T1D2P1, data.subnet_mask))
ip.delete_static_route(vars.D1, data.ip_D2D1P1, network)
_, network = ip.get_network_addr("{}/{}".format(data.ip_T1D1P1, data.subnet_mask))
ip.delete_static_route(vars.D2, data.ip_D1D2P1, network)
# Unconfig mirror session
mirror.delete_session(vars.D1, data.session_name)
# Unconfig acl rule
acl_dscp.config_classifier_table(dut=vars.D1, enable="del", class_name=data.acl_rule)
# Unconfig acl table
acl_dscp.config_service_policy_table(dut=vars.D1, policy_kind='unbind', interface_name=vars.D1T1P1, stage='in',
service_policy_name=data.acl_table_name, policy_type=data.type)
acl_dscp.config_service_policy_table(dut=vars.D1, policy_kind='unbind', interface_name=vars.D1T1P2, stage='in',
service_policy_name=data.acl_table_name, policy_type=data.type)
acl_dscp.config_policy_table(dut=vars.D1, enable='del', policy_name=data.acl_table_name)
acl.delete_acl_table(vars.D1, acl_table_name="L3_IPV6_INGRESS", acl_type="L3V6")
def erspan_func_hooks(request):
# add things at the start every test case
# use 'request.node.name' to compare
# if any thing specific a particular test case
yield
# add things at the end every test case
# use 'request.node.name' to compare
# if any thing specific a particular test case
# Deleteing configured ACL rule at end of each test case
if st.get_func_name(request) != 'test_ft_erspan_config_upload_save_reload_reboot':
acl_dscp.config_flow_update_table(vars.D1, policy_name=data.acl_table_name, flow='del', policy_type=data.type,
class_name=data.acl_rule)
acl_dscp.config_classifier_table(dut=vars.D1, enable="del", class_name=data.acl_rule)
if 'test_ft_erspan_action_ethertype_dscp_tcp_flags_l4range' in request.node.name:
ip.delete_ip_interface(vars.D1, vars.D1T1P1, "2001:1::1", "64", family="ipv6")
ip.delete_ip_interface(vars.D1, vars.D1T1P2, "2001:2::1", "64", family="ipv6")
acl.delete_acl_rule(vars.D1, "L3_IPV6_INGRESS", "L3V6", "FWD_RULE1")
if st.get_func_name(request) == 'test_ft_erspan_action_encapsulation':
encap_list = ['0x88ee', '0x6558']
for encap in encap_list:
mirror.delete_session(vars.D1, "mirror_" + encap)
if st.get_func_name(request) == 'test_ft_erspan_portchannel_shut_noshut':
mirror.delete_session(vars.D1, data.mirror_session)
def copp_module_hooks(request):
global vars, tg, tg_ph_1, d1_p1, hw_constants, deviation_percentage, d1_p1_mac, copp_data, vlan_igmp, copp_data_pir
vars = st.ensure_min_topology("D1T1:1")
hw_constants = st.get_datastore(vars.D1, "constants", "default")
st.debug("hw_constants: {}".format(hw_constants))
tg, tg_ph_1 = tgapi.get_handle_byname("T1D1P1")
d1_p1 = vars.D1T1P1
vlan_igmp = 3188
vlan_obj.create_vlan(vars.D1, vlan_igmp)
deviation_percentage = 0.05
ret_val = copp_obj.get_copp_config(dut=vars.D1, table_name='all')
if ret_val:
copp_data = ret_val
else:
st.report_fail('module_config_failed',
'show copp config command failed')
copp_data_pir = copp_obj.set_copp_pir_config(vars.D1, config='get')
# Get the DUT mac address
d1_p1_mac = basic_obj.get_ifconfig(vars.D1, d1_p1)[0]['mac']
# Config the routing interface
ip_obj.config_ip_addr_interface(dut=vars.D1,
interface_name=d1_p1,
ip_address='1.1.1.2',
subnet='24')
yield
# Un-configure the routing interface
ip_obj.delete_ip_interface(dut=vars.D1,
interface_name=d1_p1,
ip_address='1.1.1.2',
subnet='24')
vlan_obj.delete_vlan(vars.D1, vlan_igmp)
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 copp_fixture_igmp(request, copp_module_hooks):
# copp fixture for igmp
ip_obj.delete_ip_interface(dut=vars.D1,
interface_name=d1_p1,
ip_address='1.1.1.2',
subnet='24')
vlan_obj.add_vlan_member(vars.D1, vlan_igmp, [vars.D1T1P1])
yield
st.log("### CLEANUP for copp igmp ###")
vlan_obj.delete_vlan_member(vars.D1, vlan_igmp, [vars.D1T1P1], "access")
ip_obj.config_ip_addr_interface(dut=vars.D1,
interface_name=d1_p1,
ip_address='1.1.1.2',
subnet='24')
def post_test_l3_fwding_v6():
vars = st.get_testbed_vars()
data.my_dut_list = st.get_dut_names()
ipfeature.delete_ip_interface(vars.D1,
vars.D1T1P1,
data.d1t1_ipv6_addr,
data.v6_mask,
family="ipv6")
ipfeature.delete_ip_interface(vars.D1,
vars.D1T1P2,
data.d1t2_ipv6_addr,
data.v6_mask,
family="ipv6")
def tg_vrf_bind2(**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_vlan2[i]], [vlan_obj.create_vlan, vars.D2, data.dut1_tg1_vlan2[i]]])
utils.exec_all(True,[[vlan_obj.add_vlan_member,vars.D1,data.dut1_tg1_vlan2[i],vars.D1T1P2,True,True], [vlan_obj.add_vlan_member,vars.D2,data.dut1_tg1_vlan2[i],vars.D2T1P2,True,True]])
'''
vlan_obj.create_vlan(vars.D1, data.dut1_tg1_vlan2[i]) # Vlan-1, VRF-101, port1
vlan_obj.add_vlan_member(vars.D1, data.dut1_tg1_vlan2[i], vars.D1T1P2, True, True)
vlan_obj.create_vlan(vars.D2, data.dut1_tg1_vlan2[i])
vlan_obj.add_vlan_member(vars.D2, data.dut1_tg1_vlan2[i], vars.D2T1P2, True, True)
'''
st.log('######------Bind DUT1 <--> tg1 vlans to vrf, assign v4 and v6 address------######')
for vrf, vlan, ipv6 in zip(data.vrf_name[0:3], data.dut1_tg1_vlan2[0:3], data.dut1_tg1_vrf_ipv6_2[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, ipv6, data.dut1_tg1_vrf_ipv6_subnet, 'ipv6')
st.log('######------Bind DUT2 <--> tg1 vlans to vrf, assign v4 and v6 address------######')
for vrf, vlan,ipv6 in zip(data.vrf_name[0:3], data.dut1_tg1_vlan2[0:3], data.dut2_tg1_vrf_ipv6_2[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, 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, ipv6 in zip(data.vrf_name[0:3], data.dut1_tg1_vlan2[0:3], data.dut1_tg1_vrf_ipv6_2[0:3]):
vrf_api.bind_vrf_interface(dut = dut1, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True, config = 'no')
ipfeature.delete_ip_interface(dut1, 'Vlan'+vlan, ipv6, data.dut1_tg1_vrf_ipv6_subnet, 'ipv6')
st.log('######------Unbind DUT2 <--> tg1 vlans to vrf, assign v4 and v6 address------######')
for vrf, vlan,ipv6 in zip(data.vrf_name[0:3], data.dut1_tg1_vlan2[0:3], data.dut2_tg1_vrf_ipv6_2[0:3]):
vrf_api.bind_vrf_interface(dut = dut2, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True, config = 'no')
ipfeature.delete_ip_interface(dut2, 'Vlan'+vlan, ipv6, data.dut2_tg1_vrf_ipv6_subnet, 'ipv6')
st.log('######------Unconfigure vlans on the PE--CE side -------######')
for i in range(3):
vlan_obj.delete_vlan_member(dut1, data.dut1_tg1_vlan2[i], vars.D1T1P2, tagging_mode=True)
vlan_obj.delete_vlan(dut1, data.dut1_tg1_vlan2[i]) # Vlan-1, VRF-101, port1
vlan_obj.delete_vlan_member(dut2, data.dut1_tg1_vlan2[i], vars.D2T1P2, tagging_mode=True)
vlan_obj.delete_vlan(dut2, data.dut1_tg1_vlan2[i])
def erspan_post_config():
"""
Author: Anil Kumar Kacharla<*****@*****.**>
Using this post config at module level. So, applicable for all test cases which includes in this module.
:return: None
"""
# Unconfig ip address on DUT-1
for port, ip_addr, in zip(data.port_list_d1, data.ip_list_d1):
ip.delete_ip_interface(data.dut1, port, ip_addr, data.subnet_mask)
# Unconfig ip address on DUT-2
for port, ip_addr in zip(data.port_list_d2, data.ip_list_d2):
ip.delete_ip_interface(data.dut2, port, ip_addr, data.subnet_mask)
# Unconfig static route
_, network = ip.get_network_addr("{}/{}".format(data.ip_T1D2P1,
data.subnet_mask))
ip.delete_static_route(data.dut1, data.ip_D2D1P1, network)
_, network = ip.get_network_addr("{}/{}".format(data.ip_T1D1P1,
data.subnet_mask))
ip.delete_static_route(data.dut2, data.ip_D1D2P1, network)
# Unconfig acl classifier
acl_dscp.config_flow_update_table(data.dut1,
policy_name=data.acl_table_name,
flow='del',
policy_type=data.type,
class_name=data.acl_rule)
acl_dscp.config_classifier_table(dut=data.dut1,
enable="del",
class_name=data.acl_rule)
# Unconfig acl policy
acl_dscp.config_service_policy_table(
dut=data.dut1,
policy_kind='unbind',
interface_name=vars.D1T1P1,
stage='in',
service_policy_name=data.acl_table_name,
policy_type=data.type)
acl_dscp.config_policy_table(dut=data.dut1,
enable='del',
policy_name=data.acl_table_name)
# Unconfig mirror session
mirror.delete_session(data.dut1, data.session_name)
def test_mgmt_vrf_static_dhcp():
config_ip_addr_interface(vars.D1, "eth0", mgmt_vrf.staticip, 20,
mgmt_vrf.af_ipv4)
if not poll_wait(verify_interface_ip_address,
10,
vars.D1,
"eth0",
mgmt_vrf.staticip + '/20',
family="ipv4",
vrfname='mgmt'):
st.log("IP Address not matched")
delete_ip_interface(vars.D1, "eth0", mgmt_vrf.staticip, 20,
mgmt_vrf.af_ipv4)
st.report_fail("mgmt_vrf_static_dhcp", "failed")
output = get_ifconfig(vars.D1, "eth0")
if output[0]['broadcast'][0] == '0.0.0.0':
st.log("Broadcast IP address not assigned")
delete_ip_interface(vars.D1, "eth0", mgmt_vrf.staticip, 20,
mgmt_vrf.af_ipv4)
st.report_fail("test_case_failed")
delete_ip_interface(vars.D1, "eth0", mgmt_vrf.staticip, 20,
mgmt_vrf.af_ipv4)
if not poll_wait(get_ifconfig_inet, 30, vars.D1, 'eth0'):
st.log("IP Address not assigned to eth0 after dhcp")
st.report_fail("mgmt_vrf_static_dhcp", "failed")
st.report_pass("mgmt_vrf_static_dhcp", "successful")
def verify_traffic_results(dut):
vars = st.get_testbed_vars()
tc_fail_flag = 0
member3 = vars.D2T1P3
member4 = vars.D2T1P4
res1 = True
dut1 = dut
v_range_t = str(data.tc6_xbase_vlan) + " " + str(data.tc6_xbase_vlan +
data.max_vlan_count - 1)
vapi.config_vlan_range_members(dut1, v_range_t, member3)
if (res1):
data.result[0] = True
(tg1, tg_ph_1, tg2, tg_ph_2) = get_handles_1()
clear_arp_entries(dut)
arpapi.show_arp(dut)
st.wait(15)
st.log("INTFCONF: " + str(member3))
st.log("INTFCONF: " + str(member4))
tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1)
tg2.tg_traffic_control(action='reset', port_handle=tg_ph_2)
h1 = tg1.tg_interface_config(port_handle=tg_ph_1,
mode='config',
intf_ip_addr='10.0.62.10',
gateway='10.0.62.1',
src_mac_addr='00:0a:01:00:00:01',
vlan='1',
vlan_id='61',
vlan_id_count=data.intf_count,
arp_send_req='1',
gateway_step='0.0.1.0',
intf_ip_addr_step='0.0.1.0',
vlan_id_step='1')
#pdb.set_trace()
edit_vid = 219
st.wait(15)
arpapi.show_arp(dut)
#END
if res1:
st.log("Interface Scaling Test Case 6.2 PASSED PING TEST")
dut1 = dut
# L3 INTF SCALING TEST CASE 1.2 START
result1 = verify_arp_entry(dut, edit_vid, data.tc6_xt1d1_ip_addr)
if result1:
st.log("Interface Scaling Test Case 6.2 PASSED ")
data.tc6_xresult[0] = True
data.tc6_xresult[1] = True
else:
tc_fail_flag = 1
st.log("Ping operation_failed")
#tg1.tg_interface_config(port_handle=tg_ph_1, handle=h1['handle'], mode='destroy')
# L3 INTF SCALING TEST CASE 1.2 END
# L3 INTF SCALING TEST CASE 1.3 START
clear_arp_entries(dut)
st.wait(15)
trigger_link_flap(dut1, member3)
tg1.tg_arp_control(handle=h1['handle'], arp_target='all')
st.wait(30)
arpapi.show_arp(dut)
#h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.0.62.10', gateway='10.0.62.1', src_mac_addr='00:0a:01:00:00:01', vlan='1', vlan_id='61', vlan_id_count=data.intf_count, arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0', vlan_id_step='1')
#st.wait(30)
result1 = verify_arp_entry(dut, edit_vid, data.tc6_xt1d1_ip_addr)
if result1:
st.log("Interface Scaling Test Case 6.3 PASSED ")
data.tc6_xresult[2] = True
else:
tc_fail_flag = 1
st.log("Ping operation_failed")
#tg1.tg_interface_config(port_handle=tg_ph_1, handle=h1['handle'], mode='destroy')
# L3 INTF SCALING TEST CASE 6.3 END
# L3 INTF SCALING TEST CASE 1.4 START
trigger_link_flap(dut1, member3)
st.wait(30)
tg1.tg_arp_control(handle=h1['handle'], arp_target='all')
#h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.0.62.10', gateway='10.0.62.1', src_mac_addr='00:0a:01:00:00:01', vlan='1', vlan_id='61', vlan_id_count=data.intf_count, arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0', vlan_id_step='1')
st.wait(30)
arpapi.show_arp(dut)
ipfeature.ping(dut1, data.tc6_xt1d1_ip_addr)
result1 = verify_arp_entry(dut, edit_vid, data.tc6_xt1d1_ip_addr)
if result1:
st.log("Interface Scaling Test Case 6.4 PASSED ")
data.tc6_xresult[3] = True
else:
st.log("Ping operation_failed")
tc_fail_flag = 1
# st.report_fail("Ping operation_failed")
#tg1.tg_interface_config(port_handle=tg_ph_1, handle=h1['handle'], mode='destroy')
# L3 INTF SCALING TEST CASE 1.4 END
# L3 INTF SCALING TEST CASE 1.5 START
verify_ip_from_vlan_interface(dut1, edit_vid)
ipfeature.delete_ip_interface(dut,
'Vlan' + str(edit_vid),
data.tc6_xd1t1_ip_addr,
subnet="24")
ipfeature.config_ip_addr_interface(dut,
'Vlan' + str(edit_vid),
data.tc6_xd1t1_ip_addr,
data.ip_prefixlen,
family="ipv4")
tg1.tg_arp_control(handle=h1['handle'], arp_target='all')
#h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.0.62.10', gateway='10.0.62.1', src_mac_addr='00:0a:01:00:00:01', vlan='1', vlan_id='61', vlan_id_count=data.intf_count, arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0', vlan_id_step='1')
st.wait(30)
arpapi.show_arp(dut)
ipfeature.ping(dut1, data.tc6_xt1d1_ip_addr)
result1 = verify_arp_entry(dut, edit_vid, data.tc6_xt1d1_ip_addr)
if result1:
st.log("Interface Scaling Test Case 6.5 PASSED ")
data.tc6_xresult[4] = True
else:
st.log("Ping operation_failed")
tc_fail_flag = 1
# st.report_fail("Ping operation_failed")
tg1.tg_interface_config(port_handle=tg_ph_1,
handle=h1['handle'],
mode='destroy')
if tc_fail_flag == 0:
st.log("Interface Scaling Test Case 6.1 6.2 6.3 6.4 6.5 PASSED")
st.report_pass("test_case_passed")
else:
st.log("IPV4 Route Scaling Test Case FAILURE Seen")
st.report_pass("operation_successful")
def config_ip(config='yes'):
if config == 'yes':
api_name = ip_api.config_ip_addr_interface
config_str = "Configure"
else:
api_name = ip_api.delete_ip_interface
config_str = "Delete"
hdrMsg("Bring-up the port on dut3 which is connected to dhcp server ")
interface_api.interface_operation(data.dut3,
data.dhcp_server_port,
operation="startup")
##########################################################################
hdrMsg(
"IP-config: {} IP address between dut2 interface {} and dut3 interface {}"
.format(config_str, data.d2d3_ports, data.d3d2_ports))
##########################################################################
utils.exec_all(True, [[
api_name, data.dut2, data.d2d3_ports[0], dut2_3_ip_list[0], mask_24
], [api_name, data.dut3, data.d3d2_ports[0], dut3_2_ip_list[0], mask_24]])
if config == 'yes':
st.banner('Install L2 DHCP rules on dhcp client device')
copp_api.bind_class_action_copp_policy(data.dut4,
classifier='copp-system-dhcpl2',
action_group='copp-system-dhcp')
##########################################################################
hdrMsg("Create loopback interfaces on dut1, dut2 and dut3")
##########################################################################
parallel.exec_parallel(True, [data.dut1, data.dut2, data.dut3],
ip_api.configure_loopback,
[{
'loopback_name': 'Loopback1'
}] * 3)
##########################################################################
hdrMsg("Loopback-config: {} IP address on Loopback interface".format(
config_str))
##########################################################################
utils.exec_all(True, [[
api_name, data.dut1, "Loopback1", dut1_loopback_ip_list[0], '32'
], [
api_name, data.dut2, "Loopback1", dut2_loopback_ip_list[0], '32'
], [api_name, data.dut3, "Loopback1", dut3_loopback_ip_list[0], '32']])
##########################################
hdrMsg("config required vlan to test on dut2 and dut4")
##########################################
utils.exec_all(True, [[vlan_api.create_vlan, data.dut2, ['100']],
[vlan_api.create_vlan, data.dut4, ['100']]])
vlan_api.create_vlan(data.dut4, ['200', '300'])
##########################################
hdrMsg("Add vlan members")
##########################################
utils.exec_all(True, [[
vlan_api.add_vlan_member, data.dut2, '100', data.d2d4_ports[0],
True
],
[
vlan_api.add_vlan_member, data.dut4, '100',
data.d4d2_ports[0], True
]])
#########################################################
hdrMsg("LAG-Config: Create portchannel on dut2 and dut4")
#########################################################
utils.exec_all(True,
[[pc.create_portchannel, data.dut2, ['PortChannel12']],
[pc.create_portchannel, data.dut4, ['PortChannel12']]])
#########################################################
hdrMsg("LAG-Config: add member ports to portchannel")
#########################################################
utils.exec_all(True, [[
pc.add_del_portchannel_member, data.dut2, 'PortChannel12',
data.d2d4_ports[2], 'add'
],
[
pc.add_del_portchannel_member, data.dut4,
'PortChannel12', data.d4d2_ports[2], 'add'
]])
#########################################################
hdrMsg("LAG-Config: Create portchannel on dut3 and dut1")
#########################################################
utils.exec_all(True,
[[pc.create_portchannel, data.dut3, ['PortChannel14']],
[pc.create_portchannel, data.dut1, ['PortChannel14']]])
#########################################################
hdrMsg("LAG-Config: add member ports to portchannel")
#########################################################
utils.exec_all(True, [[
pc.add_del_portchannel_member, data.dut3, 'PortChannel14',
data.d3d1_ports[0], 'add'
],
[
pc.add_del_portchannel_member, data.dut1,
'PortChannel14', data.d1d3_ports[0], 'add'
]])
ip_api.config_ip_addr_interface(data.dut2, 'Vlan100',
dut2_4_ip_list[0], mask_24)
ip_api.config_ip_addr_interface(data.dut2, data.d2d4_ports[1],
dut2_4_ip_list[1], mask_24)
ip_api.config_ip_addr_interface(data.dut2, 'PortChannel12',
dut2_4_ip_list[2], mask_24)
ip_api.config_ip_addr_interface(data.dut1,
'PortChannel14',
data.dhcp_server_ipv6,
mask_v6,
family='ipv6')
#########################################
hdrMsg("Add vlan members on DUT4")
#########################################
vlan_api.add_vlan_member(data.dut4, '200', data.d4d2_ports[1])
vlan_api.add_vlan_member(data.dut4, '300', 'PortChannel12')
st.exec_all([[create_static_route_dut2], [create_static_route_dut3]])
else:
st.banner('Remove L2 DHCP rules on dhcp client device')
copp_api.bind_class_action_copp_policy(data.dut4,
classifier='copp-system-dhcpl2',
action_group='copp-system-dhcp',
config='no')
##########################################################################
hdrMsg("Loopback-config: {} IP address on Loopback interface".format(
config_str))
##########################################################################
utils.exec_all(True, [[
api_name, data.dut1, "Loopback1", dut1_loopback_ip_list[0], '32'
], [
api_name, data.dut2, "Loopback1", dut2_loopback_ip_list[0], '32'
], [api_name, data.dut3, "Loopback1", dut3_loopback_ip_list[0], '32']])
##########################################################################
hdrMsg("Delete loopback interfaces on dut1, dut2 and dut3")
##########################################################################
parallel.exec_parallel(True, [data.dut1, data.dut2, data.dut3],
ip_api.configure_loopback, [{
'loopback_name': 'Loopback1',
'config': 'no'
}] * 3)
st.exec_all([[delete_static_route_dut2], [delete_static_route_dut3]])
hdrMsg(" Remove all ip configs on dut2")
ip_api.delete_ip_interface(data.dut2, 'Vlan100', dut2_4_ip_list[0],
mask_24)
ip_api.delete_ip_interface(data.dut2, data.d2d4_ports[1],
dut2_4_ip_list[1], mask_24)
ip_api.delete_ip_interface(data.dut2, 'PortChannel12',
dut2_4_ip_list[2], mask_24)
ip_api.delete_ip_interface(data.dut1,
'PortChannel14',
data.dhcp_server_ipv6,
mask_v6,
family='ipv6')
###########################################################
hdrMsg("LAG-unConfig: delete member ports to portchannel")
###########################################################
utils.exec_all(True, [[
pc.add_del_portchannel_member, data.dut2, 'PortChannel12',
data.d2d4_ports[2], 'del'
],
[
pc.add_del_portchannel_member, data.dut4,
'PortChannel12', data.d4d2_ports[2], 'del'
]])
utils.exec_all(True, [[
pc.add_del_portchannel_member, data.dut3, 'PortChannel14',
data.d3d1_ports[0], 'del'
],
[
pc.add_del_portchannel_member, data.dut1,
'PortChannel14', data.d1d3_ports[0], 'del'
]])
vlan_api.delete_vlan_member(data.dut4, '300', 'PortChannel12')
#######################################################
hdrMsg("LAG-UnConfig: Delete portchannel on dut2 and dut4")
#######################################################
utils.exec_all(True,
[[pc.delete_portchannel, data.dut2, ['PortChannel12']],
[pc.delete_portchannel, data.dut4, ['PortChannel12']]])
utils.exec_all(True,
[[pc.delete_portchannel, data.dut3, ['PortChannel14']],
[pc.delete_portchannel, data.dut1, ['PortChannel14']]])
########################################
hdrMsg("Delete vlan member ports")
########################################
utils.exec_all(True, [[
vlan_api.delete_vlan_member, data.dut2, '100', data.d2d4_ports[0],
True
],
[
vlan_api.delete_vlan_member, data.dut4,
'100', data.d4d2_ports[0], True
]])
vlan_api.delete_vlan_member(data.dut4, '200', data.d4d2_ports[1])
####################################
hdrMsg("Unconfig vlan fron dut2 and dut4")
###################################
utils.exec_all(True, [[vlan_api.delete_vlan, data.dut2, ['100']],
[vlan_api.delete_vlan, data.dut4, ['100']]])
vlan_api.delete_vlan(data.dut4, ['200', '300'])
def dut1_unconfig():
result = 0
st.log('On DUT1 unconfigure IP addresses on DUT - TG interfaces')
ip_obj.delete_ip_interface(data.dut1, data.dut1_tg_ports[0],
data.dut1_tg_ipv6[0], data.tg_ipv6_subnet,
'ipv6')
ip_obj.delete_ip_interface(data.dut1, data.dut1_tg_ports[0],
data.dut1_tg_ip[0], data.tg_ip_subnet, 'ipv4')
st.log(
'On DUT1 Unonfigure OSPF router ID, ospf network and add all the ospf interfaces'
)
result = ospf_obj.config_interface_ip_ospf_network_type(
data.dut1, data.d1_d2_ports[0], 'point-to-point', data.dut1_vrf[0],
'no')
result = ospf_obj.config_interface_ip_ospf_network_type(
data.dut1, 'Vlan' + data.dut1_dut2_vlan[0], 'point-to-point',
data.dut1_vrf[0], 'no')
result = ospf_obj.config_interface_ip_ospf_network_type(
data.dut1, data.portchannel, 'point-to-point', data.dut1_vrf[0], 'no')
result = ospf_obj.config_ospf_network(
data.dut1, data.dut1_loopback_ip[0] + '/' + data.ip_loopback_prefix, 0,
data.dut1_vrf[0], '', 'no')
result = ospf_obj.config_ospf_network(
data.dut1, data.dut1_loopback_ip[1] + '/' + data.ip_loopback_prefix, 0,
data.dut1_vrf[0], '', 'no')
result = ospf_obj.config_ospf_network(
data.dut1, data.dut1_loopback_ip[2] + '/' + data.ip_loopback_prefix, 0,
data.dut1_vrf[0], '', 'no')
result = ospf_obj.config_ospf_router_id(data.dut1,
data.dut1_ospf_router_id,
data.dut1_vrf[0], '', 'no')
st.banner('Unconfigure IPv4 and IPv6 addresses on the loopback interfaces')
result = ip_obj.delete_ip_interface(data.dut1, data.dut1_loopback[0],
data.dut1_loopback_ipv6[0],
data.ipv6_loopback_prefix, 'ipv6')
result = ip_obj.delete_ip_interface(data.dut1, data.dut1_loopback[0],
data.dut1_loopback_ip[0],
data.ip_loopback_prefix, 'ipv4')
result = ip_obj.delete_ip_interface(data.dut1, data.dut1_loopback[1],
data.dut1_loopback_ipv6[1],
data.ipv6_loopback_prefix, 'ipv6')
result = ip_obj.delete_ip_interface(data.dut1, data.dut1_loopback[1],
data.dut1_loopback_ip[1],
data.ip_loopback_prefix, 'ipv4')
result = ip_obj.delete_ip_interface(data.dut1, data.dut1_loopback[2],
data.dut1_loopback_ipv6[2],
data.ipv6_loopback_prefix, 'ipv6')
result = ip_obj.delete_ip_interface(data.dut1, data.dut1_loopback[2],
data.dut1_loopback_ip[2],
data.ip_loopback_prefix, 'ipv4')
st.log(
'On DUT1 unbind all the loopbacks, physical, vlan and portchannel interfaces to the VRF'
)
result = vrf_obj.bind_vrf_interface(
dut=data.dut1,
vrf_name=data.dut1_vrf[0],
intf_name=[
data.dut1_loopback[0], data.dut1_loopback[1],
data.dut1_loopback[2], data.d1_d2_ports[0],
'Vlan' + data.dut1_dut2_vlan[0], data.portchannel
],
config='no')
st.log('On DUT1 unconfigure vlan')
result = vlan_obj.delete_vlan_member(data.dut1_client,
data.dut1_dut2_vlan[0],
data.d1_d2_ports[1], True)
result = vlan_obj.create_vlan(data.dut1_client, data.dut1_dut2_vlan[0])
st.banner('Unconfigure portchannel on DUT1')
result = pc_obj.add_del_portchannel_member(
data.dut1_client, data.portchannel,
[data.d1_d2_ports[2], data.d1_d2_ports[3]], 'del')
result = pc_obj.delete_portchannel(data.dut1_client, data.portchannel)
st.log('On DUT1 unconfigure vrfs and loopbacks')
result = ip_obj.configure_loopback(data.dut1,
config='no',
loopback_name=[
data.dut1_loopback[0],
data.dut1_loopback[1],
data.dut1_loopback[2]
])
result = vrf_obj.config_vrf(dut=data.dut3_client,
vrf_name=data.dut1_vrf[0],
config='no')
return result
def test_dhcprelay_over_ipunn_001(dhcprelay_cleanup_fixture_001):
tc_list = ['FtOpSoRoDHCPRFt027','FtOpSoRoDHCPRFt028','FtOpSoRoDHCPRFt029','FtOpSoRoDHCPRFt030','FtOpSoRoDHCPRFt031','FtOpSoRoDHCPRFt032','FtOpSoRoDHCPRFt033','FtOpSoRoDHCPRFt034','FtOpSoRoDHCPRFt035','FtOpSoRoDHCPRFt036']
tc_result = True ;err_list=[]
final_result = 0
for tc,intf,client_intf,_,pool,pool_v6 in zip(tc_list[0:3],data.relay_port,data.client_port,data.client_port_ip,data.server_pool,data.server_pool_ipv6):
#################################################
hdrMsg("Step : Start DHCP on client side on interface {}".format(client_intf))
#################################################
dhcp_relay.dhcp_client_start(data.dut4, client_intf)
#################################################
hdrMsg("Step : Verify dhcp relay configuration under interface {}".format(intf))
#################################################
result = check_dhcp_relay_interface_config(data.dut2,interface=intf,server_ip=data.dhcp_server_ip)
if result is False:
err ="DHCP relay interface config incorrect for {}".format(intf)
tc_result=False;err_list.append(err);failMsg(err);final_result += 1;
st.report_tc_fail(tc,'test_case_failure_message',err)
#################################################
hdrMsg("Step : Verify dhcp clinet assigned ip address on expected subnet on {}".format(client_intf))
#################################################
result = check_dhcp_client(interface=client_intf,network_pool=pool)
if result is False:
err ="DHCP client ip address assignment failed for {}".format(client_intf)
tc_result=False;err_list.append(err);failMsg(err);final_result += 1;
st.report_tc_fail(tc,'test_case_failure_message',err)
#################################################
hdrMsg("Step : Verify dhcp relay statistics on {}" .format(intf))
#################################################
result = check_dhcp_relay_statistics(data.dut2,interface=intf)
if result is False:
err ="DHCP relay statistics check failed for {}".format(intf)
tc_result=False;err_list.append(err);failMsg(err);final_result += 1;
st.report_tc_fail(tc,'test_case_failure_message',err)
if tc_result is True:
st.report_tc_pass(tc,'tc_passed')
#################################################
hdrMsg("Step : Stop dhcp client and clear dhcp-relay statistics ")
#################################################
dhcp_relay.dhcp_client_stop(data.dut4, client_intf,skip_error_check=True)
dhcp_relay.clear_statistics(data.dut2, intf, family="ipv4")
#################################################
hdrMsg("Step : Verify dhcp relay statistics reset to 0")
#################################################
result = check_dhcp_relay_statistics(data.dut2,interface=intf,expected=0)
if result is False:
err ="DHCP relay statistics did not reset after clearing for {}".format(intf)
tc_result=False;err_list.append(err);failMsg(err);final_result += 1;
st.report_tc_fail(tc_list[6],'test_case_failure_message',err)
if tc_result:
st.report_tc_pass(tc_list[6], 'tc_passed')
killall_dhclient(data.dut4)
tc_result = True
#################################################
hdrMsg("Step : Configure src-intf suboption with loopback interface on all dhcp-relay enabled interfaces and start dhcp clients")
#################################################
for interface,src_intf in zip(data.relay_port, data.lb_src_intf_list):
dhcp_relay.dhcp_relay_option_config(data.dut2,src_interface=src_intf,interface=interface,option='src-intf')
for intf,client_intf,_,pool,pool_v6,src_intf in zip(data.relay_port,data.client_port,data.client_port_ip,data.server_pool,data.server_pool_ipv6,data.lb_src_intf_list):
dhcp_relay.dhcp_client_start(data.dut4, client_intf)
if client_intf == data.d4d2_ports[1]:
if 'ip_add_phy' in data.keys():
ip_api.delete_ip_interface(data.dut4, client_intf, data.ip_add_phy, '24',skip_error=True)
del data['ip_add_phy']
dhcp_relay.dhcp_client_start(data.dut4, client_intf)
#################################################
hdrMsg("Step : Verify src-intf option in detailed dhcp-relay for {}".format(intf))
#################################################
result = dhcp_relay.verify_dhcp_relay_detailed(data.dut2,interface=intf,src_interface=src_intf,link_select='disable',max_hop_count=10)
if result is False:
err = "Source-interface config failed on {}".format(intf)
tc_result = False; err_list.append(err);failMsg(err);final_result += 1;
st.report_tc_fail(tc_list[3],'test_case_failure_message', err)
#################################################
hdrMsg("Step : Verify dhcp client gets ip address assigned on expected subnet for {}".format(intf))
#################################################
result = check_dhcp_client(interface=client_intf,network_pool=pool)
if result is False:
err ="DHCP client ip address assignment failed for {} with source-interface".format(intf)
tc_result=False;err_list.append(err);failMsg(err);final_result += 1;
st.report_tc_fail(tc_list[3],'test_case_failure_message',err)
#################################################
hdrMsg("Step : Verify dhcp relay statistics on {}".format(intf))
#################################################
result = check_dhcp_relay_statistics(data.dut2,interface=intf)
if result is False:
err ="DHCP relay statistics check failed for {} with source-interface".format(intf)
tc_result=False;err_list.append(err);failMsg(err);final_result += 1;
st.report_tc_fail(tc_list[3],'test_case_failure_message',err)
#################################################
hdrMsg("Step : Stop all dhcp clients and clear dhcp-relay statistics on all interfaces ")
#################################################
dhcp_relay.dhcp_client_stop(data.dut4, client_intf,skip_error_check=True)
dhcp_relay.clear_statistics(data.dut2, intf, family="ipv4")
killall_dhclient(data.dut4)
if tc_result is True:
st.report_tc_pass(tc_list[3],'tc_passed')
tc_result = True
#################################################
hdrMsg("Step : Enable link-select suboption and restart dhcp clients on all client interfaces ")
#################################################
for interface in data.relay_port:
dhcp_relay.dhcp_relay_option_config(data.dut2,interface=interface,option='link-select')
for intf,client_intf,_,pool,pool_v6,src_intf in zip(data.relay_port,data.client_port,data.client_port_ip,data.server_pool,data.server_pool_ipv6,data.lb_src_intf_list):
dhcp_relay.dhcp_client_start(data.dut4, client_intf)
if client_intf == data.d4d2_ports[1]:
if 'ip_add_phy' in data.keys():
ip_api.delete_ip_interface(data.dut4, client_intf, data.ip_add_phy, '24',skip_error=True)
del data['ip_add_phy']
dhcp_relay.dhcp_client_start(data.dut4, client_intf)
#################################################
hdrMsg("Step : Verify link-select option enabled under detailed output for {}".format(intf))
#################################################
result = dhcp_relay.verify_dhcp_relay_detailed(data.dut2,interface=intf,src_interface=src_intf,link_select='enable')
if result is False:
err = "link state config failed on {}".format(intf)
tc_result = False; err_list.append(err);failMsg(err);final_result += 1;
st.report_tc_fail(tc_list[4],'test_case_failure_message', err)
#################################################
hdrMsg("Step : Verify client on interface {} obtain ip address on expected subnet ".format(intf))
#################################################
result = check_dhcp_client(interface=client_intf,network_pool=pool)
if result is False:
err ="DHCP client ip address assignment failed for {} with link-select".format(intf)
tc_result=False;err_list.append(err);failMsg(err);final_result += 1;
st.report_tc_fail(tc_list[4],'test_case_failure_message',err)
#################################################
hdrMsg("Step : Verify dhcp relay statistics on {}".format(intf))
#################################################
result = check_dhcp_relay_statistics(data.dut2,interface=intf)
if result is False:
err ="DHCP relay statistics check failed for {} with link-select".format(intf)
tc_result=False;err_list.append(err);failMsg(err);final_result += 1;
st.report_tc_fail(tc_list[4],'test_case_failure_message',err)
#################################################
hdrMsg("Step : Stop all dhcp clients and clear dhcp-relay statistics on all interfaces ")
#################################################
dhcp_relay.dhcp_client_stop(data.dut4, client_intf,skip_error_check=True)
dhcp_relay.clear_statistics(data.dut2, intf, family="ipv4")
if tc_result is True:
st.report_tc_pass(tc_list[4],'tc_passed')
killall_dhclient(data.dut4)
tc_result = True
#################################################
hdrMsg("Step: Configure max-hop-count suboption to 1 and restart dhcp clients on all client interfaces ")
#################################################
for interface in data.relay_port:
dhcp_relay.dhcp_relay_option_config(data.dut2,interface=interface,option='max-hop-count',max_hop_count=1)
for intf,client_intf,_,pool,pool_v6,src_intf in zip(data.relay_port,data.client_port,data.client_port_ip,data.server_pool,data.server_pool_ipv6,data.lb_src_intf_list):
dhcp_relay.dhcp_client_start(data.dut4, client_intf)
#################################################
hdrMsg("Step : Verify max-hop-count configuration on {}".format(intf))
#################################################
result = dhcp_relay.verify_dhcp_relay_detailed(data.dut2, interface=intf, src_interface=src_intf,ink_select='enable',max_hop_count=1)
if result is False:
err = "max-hop-count config failed on {}".format(intf)
tc_result = False;
err_list.append(err);failMsg(err);final_result += 1;
st.report_tc_fail(tc_list[5],'test_case_failure_message', err)
#################################################
hdrMsg("Step : Verify the client interface obtain ip address since packets will be Relay interface {} ".format(intf))
#################################################
result = check_dhcp_client(interface=client_intf, network_pool=pool)
if result is False:
err = "DHCH packets dropped for {} with max-hop-count set to 1".format(intf)
tc_result = False;
err_list.append(err);failMsg(err);final_result += 1;
st.report_tc_fail(tc_list[5],'test_case_failure_message', err)
killall_dhclient(data.dut4)
for intf, client_intf, _, pool, pool_v6, src_intf in zip(data.relay_port, data.client_port, data.client_port_ip,
data.server_pool, data.server_pool_ipv6,data.lb_src_intf_list):
#################################################
hdrMsg("Step : Change the max-hop-count to 15 on {} and restart dhcp clients".format(intf))
#################################################
dhcp_relay.dhcp_relay_option_config(data.dut2, interface=intf, option='max-hop-count', max_hop_count=15)
dhcp_relay.dhcp_client_start(data.dut4, client_intf)
#################################################
hdrMsg("Step : Verify max-hop-count configuration on {}".format(intf))
#################################################
result = dhcp_relay.verify_dhcp_relay_detailed(data.dut2, interface=intf, src_interface=src_intf,link_select='enable',max_hop_count=15)
if result is False:
err = "max-hop-count config failed on {}".format(intf)
tc_result = False;
err_list.append(err);failMsg(err);final_result += 1;
st.report_tc_fail(tc_list[5],'test_case_failure_message', err)
#################################################
hdrMsg("Step : Verify all clients gets ip address from server after changing max-hop-count {} ".format(intf))
#################################################
result = check_dhcp_client(interface=client_intf, network_pool=pool)
if result is False:
err = "IP address assignment failed for {} with max-hop-count set to 15".format(intf)
tc_result = False;
err_list.append(err);failMsg(err);final_result += 1;
st.report_tc_fail(tc_list[5], 'test_case_failure_message',err)
if tc_result is True:
st.report_tc_pass(tc_list[5],'tc_passed')
for interface,client_interface in zip(data.relay_port,data.client_port):
dhcp_relay.dhcp_client_stop(data.dut4, client_interface,skip_error_check=True)
if client_interface == data.d4d2_ports[1]:
if 'ip_add_phy' in data.keys():
dhcp_relay.dhcp_client_start(data.dut4, client_interface)
ip_api.delete_ip_interface(data.dut4, client_interface, data.ip_add_phy, '24', skip_error=True)
del data['ip_add_phy']
dhcp_relay.clear_statistics(data.dut2, interface, family="ipv4")
killall_dhclient(data.dut4)
tc_result = True
#############################################################
hdrMsg("Config Save")
#############################################################
bgp_api.enable_docker_routing_config_mode(data.dut2)
reboot_api.config_save(data.dut2)
reboot_api.config_save(data.dut2, 'vtysh')
for trigger,tc in zip(['config_reload','reboot','warmboot'],tc_list[7:]):
#############################################################
hdrMsg("Trigger : {}".format(trigger))
#############################################################
if trigger == 'reboot' : st.reboot(data.dut2, "fast")
if trigger == 'config_reload': reboot_api.config_reload(data.dut2)
if trigger == 'warmboot':
reboot_api.config_warm_restart(data.dut2,oper = "enable", tasks = ["system"])
st.reboot(data.dut2, "warm")
for intf,client_intf,_,pool,pool_v6,src_intf in zip(data.relay_port,data.client_port,data.client_port_ip,data.server_pool,data.server_pool_ipv6,data.lb_src_intf_list):
########################################################################
hdrMsg("Stopping and restart dhclient to renew ip address")
########################################################################
dhcp_relay.dhcp_client_start(data.dut4, client_intf)
#################################################
hdrMsg("Step : Verify max-hop-count configuration on {} after trigger {}".format(intf,trigger))
#################################################
result = dhcp_relay.verify_dhcp_relay_detailed(data.dut2, interface=intf, src_interface=src_intf,link_select='enable',max_hop_count=15)
if result is False:
err = "max-hop-count config failed on {} after {} ".format(intf,trigger)
tc_result = False;
err_list.append(err);failMsg(err);final_result += 1;
st.report_tc_fail(tc,'test_case_failure_message', err)
#################################################
hdrMsg("Step : Verify all clients gets ip address from server after changing max-hop-count {} after {} ".format(intf,trigger))
#################################################
result = check_dhcp_client(interface=client_intf, network_pool=pool)
if result is False:
err = "IP address assignment failed for {} after {}".format(intf,trigger)
tc_result = False;
err_list.append(err);failMsg(err);final_result += 1;
st.report_tc_fail(tc, 'test_case_failure_message',err)
##################################################
hdrMsg("Step: Stop dhclient")
##################################################
dhcp_relay.dhcp_client_stop(data.dut4, client_intf, skip_error_check=True)
if client_intf == data.d4d2_ports[1]:
if 'ip_add_phy' in data.keys():
dhcp_relay.dhcp_client_start(data.dut4, client_intf)
ip_api.delete_ip_interface(data.dut4, client_intf, data.ip_add_phy, '24', skip_error=True)
del data['ip_add_phy']
st.wait(5)
killall_dhclient(data.dut4)
if tc_result is True:
st.report_tc_pass(tc,'tc_passed')
if final_result != 0:
st.report_fail('test_case_failure_message',err_list)
else:
st.report_pass('test_case_passed')
def dut2_unconfig():
result = 0
st.log('On Configure IP addresses on DUT2 - TG interfaces')
result = ip_obj.delete_ip_interface(data.dut2, data.dut2_tg_ports[0],
data.dut2_tg_ipv6[0],
data.tg_ipv6_subnet, 'ipv6')
result = ip_obj.delete_ip_interface(data.dut2, data.dut2_tg_ports[0],
data.dut2_tg_ip[0], data.tg_ip_subnet,
'ipv4')
result = arp_obj.config_static_ndp(data.dut2,
data.tg_dut2_ipv6[0],
'00:00:33:33:33:02',
data.dut2_tg_ports[0],
operation="del")
result = arp_obj.delete_static_arp(data.dut2, data.tg_dut2_ip[0],
'00:00:33:33:33:01')
st.log(
'On DUT2 unconfigure OSPF router ID, ospf networks and add all the ospf interfaces'
)
result = ospf_obj.config_interface_ip_ospf_network_type(
data.dut2, data.d2_d1_ports[0], 'point-to-point', 'default', 'no')
result = ospf_obj.config_interface_ip_ospf_network_type(
data.dut2, 'Vlan' + data.dut1_dut2_vlan[0], 'point-to-point',
'default', 'no')
result = ospf_obj.config_interface_ip_ospf_network_type(
data.dut2, data.portchannel, 'point-to-point', 'default', 'no')
result = ospf_obj.config_ospf_network(
data.dut2, data.dut2_loopback_ip[0] + '/' + data.ip_loopback_prefix, 0,
'default', '', 'no')
result = ospf_obj.config_ospf_router_id(data.dut2,
data.dut2_ospf_router_id,
'default', '', 'no')
st.log(
'On DUT2 unconfigure loopback and remove IPv4 and IPv6 addresses on it'
)
result = ip_obj.delete_ip_interface(data.dut2_server,
data.dut2_loopback[0],
data.dut2_loopback_ipv6[0],
data.dut2_loopback_ipv6_subnet, 'ipv6')
result = ip_obj.delete_ip_interface(data.dut2_server,
data.dut2_loopback[0],
data.dut2_loopback_ip[0],
data.dut2_loopback_ip_subnet, 'ipv4')
result = ip_obj.configure_loopback(data.dut2_server,
config='no',
loopback_name=data.dut2_loopback[0])
st.log(
'On DUT2 unconfigure portchannel and remove IPv4 and IPv6 addresses on it'
)
result = ip_obj.delete_ip_interface(data.dut2_server, data.portchannel,
data.dut2_dut1_ipv6[2],
data.dut2_dut1_ipv6_subnet, 'ipv6')
result = ip_obj.delete_ip_interface(data.dut2_server, data.portchannel,
data.dut2_dut1_ip[2],
data.dut2_dut1_ip_subnet, 'ipv4')
result = pc_obj.add_del_portchannel_member(
data.dut2_server, data.portchannel,
[data.d2_d1_ports[2], data.d2_d1_ports[3]], 'del')
result = pc_obj.delete_portchannel(data.dut2_server, data.portchannel)
st.log('On DUT2 unconfigure vlan and remove IPv4 and IPv6 addresses on it')
result = ip_obj.delete_ip_interface(data.dut2,
'Vlan' + data.dut1_dut2_vlan[0],
data.dut2_dut1_ipv6[1],
data.dut2_dut1_ipv6_subnet, 'ipv6')
result = ip_obj.delete_ip_interface(data.dut2,
'Vlan' + data.dut1_dut2_vlan[0],
data.dut2_dut1_ip[1],
data.dut2_dut1_ip_subnet, 'ipv4')
result = vlan_obj.delete_vlan_member(data.dut2, data.dut1_dut2_vlan[0],
data.d2_d1_ports[1], True)
result = vlan_obj.delete_vlan(data.dut2, data.dut1_dut2_vlan[0])
st.log('On DUT2 remove IPv4 and IPv6 addresses on physical interface')
result = ip_obj.delete_ip_interface(data.dut2, data.d2_d1_ports[0],
data.dut2_dut1_ipv6[0],
data.dut2_dut1_ipv6_subnet, 'ipv6')
result = ip_obj.delete_ip_interface(data.dut2, data.d2_d1_ports[0],
data.dut2_dut1_ip[0],
data.dut2_dut1_ip_subnet, 'ipv4')
return result
def test_ft_ip_v4_v6_L2_L3_translation():
# Objective - Verify that L2 port to IPv4 L3 port transition and vice-versa is successful.
st.log("Checking IPv4 ping from {} to {} over routing interface".format(
vars.D1, vars.D2))
if not ipfeature.ping(
vars.D1, data.ip4_addr[7], family=data.af_ipv4, count=1):
st.report_fail("ping_fail", data.ip4_addr[6], data.ip4_addr[7])
st.log(
"Checking IPv6 ping from {} to {} over vlan routing interface".format(
vars.D1, vars.D2))
if not ipfeature.ping(
vars.D2, data.ip6_addr[6], family=data.af_ipv6, count=1):
st.report_fail("ping_fail", data.ip6_addr[7], data.ip6_addr[6])
st.log("L3 to L2 port transition")
st.log("Removing ipv4,ipv6 address from interface")
ipfeature.delete_ip_interface(vars.D1,
vars.D1D2P4,
data.ip4_addr[6],
24,
family=data.af_ipv4)
ipfeature.delete_ip_interface(vars.D2,
vars.D2D1P4,
data.ip4_addr[7],
24,
family=data.af_ipv4)
ipfeature.delete_ip_interface(vars.D1,
vars.D1D2P4,
data.ip6_addr[6],
96,
family=data.af_ipv6)
ipfeature.delete_ip_interface(vars.D2,
vars.D2D1P4,
data.ip6_addr[7],
96,
family=data.af_ipv6)
ipfeature.delete_ip_interface(vars.D1,
vars.D1T1P1,
data.ip4_addr[1],
24,
family=data.af_ipv4)
ipfeature.delete_ip_interface(vars.D2,
vars.D2T1P1,
data.ip4_addr[8],
24,
family=data.af_ipv4)
st.log("Removing the static routes")
ipfeature.delete_static_route(vars.D1,
data.ip4_addr[7],
data.static_ip_rt,
shell=data.shell_vtysh,
family=data.af_ipv4)
ipfeature.delete_static_route(vars.D1,
data.static_ip6_rt_drop,
data.static_ip6_rt,
shell=data.shell_vtysh,
family=data.af_ipv6)
st.log("Vlan creation and port association configuration")
vlan_obj.create_vlan(vars.D1, data.vlan_2)
st.log("Adding back to back connecting ports to vlan {}".format(
data.vlan_2))
vlan_obj.add_vlan_member(vars.D1,
data.vlan_2, [vars.D1D2P4],
tagging_mode=True)
vlan_obj.create_vlan(vars.D2, data.vlan_2)
vlan_obj.add_vlan_member(vars.D2,
data.vlan_2, [vars.D2D1P4],
tagging_mode=True)
st.log("Adding TG connecting ports to vlan {}".format(data.vlan_1))
vlan_obj.add_vlan_member(vars.D1,
data.vlan_2,
vars.D1T1P1,
tagging_mode=True)
vlan_obj.add_vlan_member(vars.D2,
data.vlan_2,
vars.D2T1P1,
tagging_mode=True)
tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D2P1")
tg.tg_traffic_control(action="reset", port_handle=tg_handler["tg_ph_list"])
tg.tg_traffic_control(action="clear_stats",
port_handle=tg_handler["tg_ph_list"])
tr2 = tg.tg_traffic_config(port_handle=tg_handler["tg_ph_2"],
mode='create',
rate_pps="2000",
mac_src_mode="fixed",
transmit_mode="single_burst",
pkts_per_burst=2000,
length_mode='fixed',
l2_encap='ethernet_ii_vlan',
vlan_id=data.vlan_2,
mac_dst_mode="fixed",
vlan="enable",
mac_src="00:a1:bb:cc:dd:01",
mac_dst="00:b1:bb:cc:dd:01")
st.log("TRAFCONF: " + str(tr2))
res = tg.tg_traffic_control(action='run', stream_handle=tr2['stream_id'])
tg.tg_traffic_control(action='stop', stream_handle=tr2['stream_id'])
st.wait(data.wait_tgstats)
st.log("TR_CTRL: " + str(res))
st.log("Fetching TGen statistics")
stats_tg1 = tgapi.get_traffic_stats(tg_handler["tg"],
mode="aggregate",
port_handle=tg_handler["tg_ph_2"])
total_tx_tg1 = stats_tg1.tx.total_packets
stats_tg2 = tgapi.get_traffic_stats(tg_handler["tg"],
mode="aggregate",
port_handle=tg_handler["tg_ph_1"])
total_rx_tg2 = stats_tg2.rx.total_packets
st.log("total_tx_tg1 = {}".format(total_tx_tg1))
total_tx_tg1_95_percentage = int(total_tx_tg1) * 0.95
st.log("total_tx_tg1_95_percentage= {}".format(total_tx_tg1_95_percentage))
st.log("total_rx_tg2 = {}".format(total_rx_tg2))
if int(total_tx_tg1_95_percentage) > int(total_rx_tg2):
st.report_fail("traffic_verification_failed")
st.log("Removing vlan configuration")
vlan_obj.delete_vlan_member(vars.D1, data.vlan_2,
[vars.D1D2P4, vars.D1T1P1], True)
vlan_obj.delete_vlan_member(vars.D2, data.vlan_2,
[vars.D2D1P4, vars.D2T1P1], True)
st.log("L2 to L3 port transition")
ipfeature.config_ip_addr_interface(vars.D1,
vars.D1D2P4,
data.ip4_addr[6],
24,
family=data.af_ipv4)
ipfeature.config_ip_addr_interface(vars.D2,
vars.D2D1P4,
data.ip4_addr[7],
24,
family=data.af_ipv4)
ipfeature.create_static_route(vars.D1,
data.ip4_addr[7],
data.static_ip_rt,
shell=data.shell_vtysh,
family=data.af_ipv4)
st.log("Checking IPv4 ping from {} to {} over routing interface".format(
vars.D1, vars.D2))
if not ipfeature.ping(
vars.D1, data.ip4_addr[7], family=data.af_ipv4, count=1):
st.report_fail("ping_fail", data.ip4_addr[6], data.ip4_addr[7])
ipfeature.config_ip_addr_interface(vars.D1,
vars.D1D2P4,
data.ip6_addr[6],
96,
family=data.af_ipv6)
ipfeature.config_ip_addr_interface(vars.D2,
vars.D2D1P4,
data.ip6_addr[7],
96,
family=data.af_ipv6)
ipfeature.create_static_route(vars.D1,
data.static_ip6_rt_drop,
data.static_ip6_rt,
shell=data.shell_vtysh,
family=data.af_ipv6)
st.log(
"Checking IPv6 ping from {} to {} over vlan routing interface".format(
vars.D1, vars.D2))
if not ipfeature.ping(
vars.D2, data.ip6_addr[6], family=data.af_ipv6, count=1):
st.report_fail("ping_fail", data.ip6_addr[7], data.ip6_addr[6])
st.report_pass("test_case_passed")
def test_ft_verify_interfaces_order():
'''
@author: Ramprakash Reddy ([email protected])
ipv4_intf_order : Verify order of interfaces in "show ip interfaces"
ipv6_intf_order : Verify order of interfaces in "show ipv6 interfaces'
Verify order of interfaces in "show ip/ipv6 interfaces" in sorted order or not
:return:
'''
flag = 1
st.log(
"This test is to ensure that interfaces are listed in sorted order by 'interface name' in 'show ip/ipv6 "
"interfaces'")
free_ports = st.get_free_ports(vars.D1)
if len(free_ports) < data.no_of_ports:
data.no_of_ports = len(free_ports)
req_ports = random.sample(free_ports, data.no_of_ports)
ipv4_addr = data.ip4_addr[11] + '/' + data.ipv4_mask
ipv6_addr = data.ip6_addr[0] + '/' + data.ipv6_mask
intf_list = []
for i in range(int(math.ceil(float(data.no_of_ports) / 2))):
_, ipv4_addr = ipfeature.increment_ip_addr(ipv4_addr, "network")
ipfeature.config_ip_addr_interface(vars.D1,
interface_name=req_ports[i],
ip_address=ipv4_addr.split('/')[0],
subnet=data.ipv4_mask,
family="ipv4")
for i in range(int(math.floor(float(data.no_of_ports) / 2))):
_, ipv6_addr = ipfeature.increment_ip_addr(ipv6_addr,
"network",
family="ipv6")
ipfeature.config_ip_addr_interface(
vars.D1,
interface_name=req_ports[
i + int(math.ceil(float(data.no_of_ports) / 2))],
ip_address=ipv6_addr.split('/')[0],
subnet=data.ipv6_mask,
family="ipv6")
output = ipfeature.get_interface_ip_address(vars.D1)
for each in output:
intf_list.append(each['interface'])
temp = lambda text: int(text) if text.isdigit() else text
alphanum_key = lambda key: [temp(c) for c in re.split('([0-9]+)', key)]
intf_list_sorted = sorted(intf_list, key=alphanum_key)
if intf_list == intf_list_sorted:
st.log("Ipv4 interfaces are in sorted order")
else:
st.error("Ipv4 interfaces are not in soretd order")
flag = 0
del intf_list[:]
del intf_list_sorted[:]
output = ipfeature.get_interface_ip_address(vars.D1, family="ipv6")
for each in output:
intf_list.append(each['interface'])
temp = lambda text: int(text) if text.isdigit() else text
alphanum_key = lambda key: [temp(c) for c in re.split('([0-9]+)', key)]
intf_list_sorted = sorted(intf_list, key=alphanum_key)
if intf_list == intf_list_sorted:
st.log("Ipv6 interfaces are in sorted order")
else:
st.error("Ipv6 interfaces are not in soretd order")
flag = 0
#Unconfig
ipv4_addr = data.ip4_addr[11] + '/' + data.ipv4_mask
ipv6_addr = data.ip6_addr[0] + '/' + data.ipv6_mask
for i in range(int(math.ceil(float(data.no_of_ports) / 2))):
_, ipv4_addr = ipfeature.increment_ip_addr(ipv4_addr, "network")
ipfeature.delete_ip_interface(vars.D1,
interface_name=req_ports[i],
ip_address=ipv4_addr.split('/')[0],
subnet=data.ipv4_mask,
family="ipv4")
for i in range(int(math.floor(float(data.no_of_ports) / 2))):
_, ipv6_addr = ipfeature.increment_ip_addr(ipv6_addr,
"network",
family="ipv6")
ipfeature.delete_ip_interface(
vars.D1,
interface_name=req_ports[
i + int(math.ceil(float(data.no_of_ports) / 2))],
ip_address=ipv6_addr.split('/')[0],
subnet=data.ipv6_mask,
family="ipv6")
if flag == 0:
st.report_fail("test_case_failed")
st.report_pass("test_case_passed")
def portchannel_func_hooks(request):
yield
if st.get_func_name(
request
) == 'test_ft_verify_static_portchannel_is_up_or_not_with_one_active_member':
portchannelobj.add_del_portchannel_member(vars.D1,
static_data.portchannel_name,
static_data.members_dut1[1:])
if st.get_func_name(
request
) == 'test_ft_verify_static_portchannel_is_up_with_active_members_when_no_lag_in_partner':
portchannelobj.create_portchannel(vars.D2,
static_data.portchannel_name,
static=True)
portchannelobj.add_del_portchannel_member(vars.D2,
static_data.portchannel_name,
static_data.members_dut2)
add_vlan_member(vars.D2,
static_data.vid,
static_data.portchannel_name,
tagging_mode=True)
if st.get_func_name(
request
) == 'test_ft_verify_fallback_is_configure_or_not_on_static_portchannel':
if portchannelobj.get_portchannel(vars.D1,
static_data.portchannel_name2):
portchannelobj.delete_portchannel(vars.D1,
static_data.portchannel_name2)
if st.get_func_name(
request
) == 'test_ft_verify_static_portchannel_del_from_ip_assigned_vlan':
st.wait(2)
ipobj.config_ip_addr_interface(vars.D1,
'Vlan{}'.format(static_data.vid),
static_data.ip41,
static_data.ip_mask,
config='remove')
portchannelobj.add_del_portchannel_member(vars.D1,
static_data.portchannel_name,
static_data.members_dut1)
if st.get_func_name(request) == 'test_ft_del_ip_assigned_portchannel':
if not portchannelobj.get_portchannel(vars.D1,
static_data.portchannel_name):
portchannelobj.create_portchannel(vars.D1,
static_data.portchannel_name,
static=True)
ipobj.delete_ip_interface(vars.D1,
static_data.portchannel_name,
static_data.ip41,
static_data.ip_mask,
skip_error=True)
portchannelobj.add_del_portchannel_member(vars.D1,
static_data.portchannel_name,
static_data.members_dut1)
exceptions = exec_all(True,
[[
add_vlan_member, vars.D1, static_data.vid,
static_data.portchannel_name, True
],
[
add_vlan_member, vars.D2, static_data.vid,
static_data.portchannel_name, True
]])[1]
ensure_no_exception(exceptions)
if st.get_func_name(
request
) == 'test_ft_verify_static_portchannel_l3_hash_sip_dip_l4port':
arpobj.delete_static_arp(vars.D2,
static_data.ip42,
interface=vars.D2T1P1,
mac=static_data.remote_mac2)
ipobj.clear_ip_configuration([vars.D1, vars.D2],
family='ipv4',
thread=True)
exceptions = exec_all(
True, [[
add_vlan_member, vars.D1, static_data.vid,
[static_data.portchannel_name, vars.D1T1P1], True
],
[
add_vlan_member, vars.D2, static_data.vid,
[static_data.portchannel_name, vars.D2T1P1], True
]])[1]
ensure_no_exception(exceptions)
if st.get_func_name(
request
) == 'test_ft_verify_static_portchannel_vlan_routing_l3_traffic':
arpobj.delete_static_arp(vars.D2,
static_data.ip42,
interface=vars.D2T1P1,
mac=static_data.remote_mac2)
ipobj.clear_ip_configuration([vars.D1, vars.D2],
family='ipv4',
thread=True)
exceptions = exec_all(True, [[
add_vlan_member, vars.D1, static_data.vid, vars.D1T1P1, True
], [add_vlan_member, vars.D2, static_data.vid, vars.D2T1P1, True]])[1]
ensure_no_exception(exceptions)
def test_ft_ping__v4_v6_after_ip_change_pc():
# Objective - Verify that ping is successful between L3 interfaces when Ip address is removed and new ip
# is assigned
st.log("In {} check portchannel is UP or not".format(vars.D2))
if not pc_obj.verify_portchannel_state(
vars.D2, data.port_channel, state="up"):
st.report_fail("portchannel_state_fail", data.port_channel, vars.D2,
"Up")
st.log(
"Checking IPv4 ping from {} to {} over portchannel routing interface".
format(vars.D1, vars.D2))
if not ipfeature.ping_poll(
vars.D1, data.ip4_addr[5], family=data.af_ipv4, iter=5, count=1):
st.report_fail("ping_fail", data.ip4_addr[4], data.ip4_addr[5])
st.log(
"Checking IPv6 ping from {} to {} over portchannel routing interface".
format(vars.D1, vars.D2))
if not ipfeature.ping_poll(
vars.D2, data.ip6_addr[4], family=data.af_ipv6, iter=5, count=1):
st.report_fail("ping_fail", data.ip6_addr[5], data.ip6_addr[4])
st.log("Removing the Ipv4 address on portchannel")
ipfeature.delete_ip_interface(vars.D1,
data.port_channel,
data.ip4_addr[4],
24,
family=data.af_ipv4)
ipfeature.delete_ip_interface(vars.D2,
data.port_channel,
data.ip4_addr[5],
24,
family=data.af_ipv4)
st.log("Removing the Ipv6 address on portchannel")
ipfeature.delete_ip_interface(vars.D1,
data.port_channel,
data.ip6_addr[4],
96,
family=data.af_ipv6)
ipfeature.delete_ip_interface(vars.D2,
data.port_channel,
data.ip6_addr[5],
96,
family=data.af_ipv6)
st.log("configuring new Ipv4 address on portchannel")
ipfeature.config_ip_addr_interface(vars.D1,
data.port_channel,
data.ip4_addr[10],
24,
family=data.af_ipv4)
ipfeature.config_ip_addr_interface(vars.D2,
data.port_channel,
data.ip4_addr[11],
24,
family=data.af_ipv4)
st.log("configuring new Ipv6 address on portchannel")
ipfeature.config_ip_addr_interface(vars.D1,
data.port_channel,
data.ip6_addr[10],
96,
family=data.af_ipv6)
ipfeature.config_ip_addr_interface(vars.D2,
data.port_channel,
data.ip6_addr[11],
96,
family=data.af_ipv6)
st.log(
"After Ipv4 address change, checking IPv4 ping from {} to {} over portchannel "
"routing interface".format(vars.D1, vars.D2))
if not ipfeature.ping_poll(
vars.D1, data.ip4_addr[11], family=data.af_ipv4, iter=5, count=1):
st.report_fail("ping_fail", data.ip4_addr[10], data.ip4_addr[11])
st.log(
"After Ipv6 address change, checking IPv6 ping from {} to {} over portchannel "
"routing interface".format(vars.D1, vars.D2))
if not ipfeature.ping_poll(
vars.D1, data.ip6_addr[11], family=data.af_ipv6, iter=5, count=1):
st.report_fail("ping_fail", data.ip6_addr[10], data.ip6_addr[11])
st.report_pass("test_case_passed")
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 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 dut1_unconfig(config=''):
st.banner('Unconfigure IPv4 and IPv6 addresses on the loopback interfaces')
ip_obj.delete_ip_interface(data.dut1_client, data.dut1_loopback[0],
data.dut1_loopback_ipv6[0],
data.dut1_loopback_ipv6_subnet, 'ipv6')
ip_obj.delete_ip_interface(data.dut1_client, data.dut1_loopback[0],
data.dut1_loopback_ip[0],
data.dut1_loopback_ip_subnet, 'ipv4')
ip_obj.configure_loopback(data.dut1_client,
config='no',
loopback_name=data.dut1_loopback[0])
st.banner('Unconfigure IPv4 and IPv6 addresses on portchannel of DUT1')
ip_obj.delete_ip_interface(data.dut1_client, data.portchannel,
data.dut1_dut2_ipv6[2],
data.dut1_dut2_ipv6_subnet, 'ipv6')
ip_obj.delete_ip_interface(data.dut1_client, data.portchannel,
data.dut1_dut2_ip[2], data.dut1_dut2_ip_subnet,
'ipv4')
pc_obj.add_del_portchannel_member(
data.dut1_client, data.portchannel,
[data.d1_d2_ports[2], data.d1_d2_ports[3]], 'del')
pc_obj.delete_portchannel(data.dut1_client, data.portchannel)
st.log('On DUT1 unconfigure vlan and IPv4 and IPv6 addresses on it')
ip_obj.delete_ip_interface(data.dut1_client,
'Vlan' + data.dut1_dut2_vlan[0],
data.dut1_dut2_ipv6[1],
data.dut1_dut2_ipv6_subnet, 'ipv6')
ip_obj.delete_ip_interface(data.dut1_client,
'Vlan' + data.dut1_dut2_vlan[0],
data.dut1_dut2_ip[1], data.dut1_dut2_ip_subnet,
'ipv4')
vlan_obj.delete_vlan_member(data.dut1_client, data.dut1_dut2_vlan[0],
data.d1_d2_ports[1], True)
vlan_obj.create_vlan(data.dut1_client, data.dut1_dut2_vlan[0])
st.banner(
'Unconfigure IPv4 and IPv6 addresses on physical interface of DUT1')
ip_obj.delete_ip_interface(data.dut1_client, data.d1_d2_ports[0],
data.dut1_dut2_ipv6[0],
data.dut1_dut2_ipv6_subnet, 'ipv6')
ip_obj.delete_ip_interface(data.dut1_client, data.d1_d2_ports[0],
data.dut1_dut2_ip[0], data.dut1_dut2_ip_subnet,
'ipv4')
st.log('Unconfigure IPv6 address on management interface of DUT1')
ip_obj.delete_ip_interface(data.dut1_client, data.mgmt_intf,
data.dut1_mgmt_ipv6[0],
data.dut1_mgmt_ipv6_subnet, 'ipv6')
return True
def test_l2_to_l3_port():
data.my_dut_list = st.get_dut_names()
dut1 = data.my_dut_list[0]
data.vlan = '10'
data.vlan_int = 'Vlan' + '10'
result_flag = 1
# configure from L3 to L2 port
vapi.create_vlan(dut1, data.vlan)
ipfeature.delete_ip_interface(dut1, vars.D1D2P1, data.d1d2_ip_addr,
data.mask)
ipfeature.delete_ip_interface(dut1,
vars.D1D2P1,
data.d1d2_ip_addr_v6,
data.mask_v6,
family='ipv6')
ipfeature.config_ip_addr_interface(dut1, data.vlan_int, data.d1d2_ip_addr,
data.mask)
ipfeature.config_ip_addr_interface(dut1,
data.vlan_int,
data.d1d2_ip_addr_v6,
data.mask_v6,
family='ipv6')
vapi.add_vlan_member(dut1, data.vlan, vars.D1D2P1, False)
if not vapi.verify_vlan_config(dut1, str(data.vlan), None, vars.D1D2P1):
result_flag = 0
ipfeature.get_interface_ip_address(dut1, family="ipv4")
ipfeature.get_interface_ip_address(dut1, family="ipv6")
result1 = ipfeature.ping(dut1, data.d2t1_ip_addr)
result2 = ipfeature.ping(dut1, data.d2t1_ip_addr_v6, 'ipv6')
if not result1 or not result2:
result_flag = 0
# Revert back from L2 to L3 port
vapi.delete_vlan_member(dut1, data.vlan, [vars.D1D2P1])
ipfeature.delete_ip_interface(dut1, data.vlan_int, data.d1d2_ip_addr,
data.mask)
ipfeature.delete_ip_interface(dut1,
data.vlan_int,
data.d1d2_ip_addr_v6,
data.mask_v6,
family='ipv6')
vapi.delete_vlan(dut1, [data.vlan])
ipfeature.config_ip_addr_interface(dut1, vars.D1D2P1, data.d1d2_ip_addr,
data.mask)
ipfeature.config_ip_addr_interface(dut1,
vars.D1D2P1,
data.d1d2_ip_addr_v6,
data.mask_v6,
family='ipv6')
waitapi.vsonic_ip_apply(vars.D1)
ping_result = ipfeature.ping(dut1, data.d2t1_ip_addr)
if ping_result and result_flag:
st.report_pass("operation_successful")
else:
st.report_fail("operation_failed")
def post_test_l3_fwding():
data.my_dut_list = st.get_dut_names()
dut1 = data.my_dut_list[0]
dut2 = data.my_dut_list[1]
ipfeature.delete_static_route(dut1, data.d2d1_ip_addr,
data.static_ip_list[1])
ipfeature.delete_static_route(dut2, data.d1d2_ip_addr,
data.static_ip_list[0])
ipfeature.delete_ip_interface(dut1, vars.D1T1P1, data.d1t1_ip_addr,
data.mask)
ipfeature.delete_ip_interface(dut1, vars.D1D2P1, data.d1d2_ip_addr,
data.mask)
ipfeature.delete_ip_interface(dut2, vars.D2D1P1, data.d2d1_ip_addr,
data.mask)
ipfeature.delete_ip_interface(dut2, vars.D2T1P1, data.d2t1_ip_addr,
data.mask)
ipfeature.delete_ip_interface(dut1,
vars.D1T1P1,
data.d1t1_ip_addr_v6,
data.mask_v6,
family='ipv6')
ipfeature.delete_ip_interface(dut1,
vars.D1D2P1,
data.d1d2_ip_addr_v6,
data.mask_v6,
family='ipv6')
ipfeature.delete_ip_interface(dut2,
vars.D2D1P1,
data.d2d1_ip_addr_v6,
data.mask_v6,
family='ipv6')
ipfeature.delete_ip_interface(dut2,
vars.D2T1P1,
data.d2t1_ip_addr_v6,
data.mask_v6,
family='ipv6')
vapi.show_vlan_config(dut1)
def dut2_unconfig(config=''):
st.log(
'On DUT2 unconfigure loopback and remove IPv4 and IPv6 addresses on it'
)
ip_obj.delete_ip_interface(data.dut2_server, data.dut2_loopback[0],
data.dut2_loopback_ipv6[0],
data.dut2_loopback_ipv6_subnet, 'ipv6')
ip_obj.delete_ip_interface(data.dut2_server, data.dut2_loopback[0],
data.dut2_loopback_ip[0],
data.dut2_loopback_ip_subnet, 'ipv4')
ip_obj.configure_loopback(data.dut2_server,
config='no',
loopback_name=data.dut2_loopback[0])
st.log(
'On DUT2 unconfigure portchannel and remove IPv4 and IPv6 addresses on it'
)
ip_obj.delete_ip_interface(data.dut2_server, data.portchannel,
data.dut2_dut1_ipv6[2],
data.dut2_dut1_ipv6_subnet, 'ipv6')
ip_obj.delete_ip_interface(data.dut2_server, data.portchannel,
data.dut2_dut1_ip[2], data.dut2_dut1_ip_subnet,
'ipv4')
pc_obj.add_del_portchannel_member(
data.dut2_server, data.portchannel,
[data.d2_d1_ports[2], data.d2_d1_ports[3]], 'del')
pc_obj.delete_portchannel(data.dut2_server, data.portchannel)
st.log('On DUT2 unconfigure vlan and remove IPv4 and IPv6 addresses on it')
ip_obj.delete_ip_interface(data.dut2_server,
'Vlan' + data.dut1_dut2_vlan[0],
data.dut2_dut1_ipv6[1],
data.dut2_dut1_ipv6_subnet, 'ipv6')
ip_obj.delete_ip_interface(data.dut2_server,
'Vlan' + data.dut1_dut2_vlan[0],
data.dut2_dut1_ip[1], data.dut2_dut1_ip_subnet,
'ipv4')
vlan_obj.delete_vlan_member(data.dut2_server, data.dut1_dut2_vlan[0],
data.d2_d1_ports[1], True)
vlan_obj.delete_vlan(data.dut2_server, data.dut1_dut2_vlan[0])
st.log('On DUT2 remove IPv4 and IPv6 addresses on physical interface')
ip_obj.delete_ip_interface(data.dut2_server, data.d2_d1_ports[0],
data.dut2_dut1_ipv6[0],
data.dut2_dut1_ipv6_subnet, 'ipv6')
ip_obj.delete_ip_interface(data.dut2_server, data.d2_d1_ports[0],
data.dut2_dut1_ip[0], data.dut2_dut1_ip_subnet,
'ipv4')
st.log('On DUT2 remove IPv4 and IPv6 addresses on management interface')
ip_obj.delete_ip_interface(data.dut2_server, data.mgmt_intf,
data.dut2_mgmt_ipv6[0],
data.dut2_mgmt_ipv6_subnet, 'ipv6')
return True
def create_l3_interface(dut, count, add, default_intf_count):
#Remove conflicting ip config from loopback0
#cmd = "config interface ip remove Loopback0 10.1.0.1/32"
#st.log(cmd)
if (add):
vapi.config_vlan_range(dut, "1 {}".format(count))
st.wait(10)
start_time = datetime.datetime.now()
for i in range(1, count + 1):
ip_addr = get_next_ip()
#vapi.add_vlan_member(dut, i, vars.D1T1P1, tagging_mode=True)
#st.log(ip_addr)
if (add):
ipfeature.config_ip_addr_interface(dut, "Vlan{}".format(i),
ip_addr, 24)
else:
ipfeature.delete_ip_interface(dut, "Vlan{}".format(i), ip_addr, 24)
# measure L3 interface create performance at various intervals
if (i == 128):
output = bcm_show(dut, 'bcmcmd "l3 intf show" | wc -l')
st.log(output)
curr_intf_count = parse_route_output(output)
if (curr_intf_count + default_intf_count >= 128):
end_time = datetime.datetime.now()
if (add):
st.log("Time taken for creating 128 L3 interfaces =" +
str(end_time - start_time))
else:
st.log("Time taken for deleting 128 L3 interfaces =" +
str(end_time - start_time))
data.result[0] = 1
elif (i == 256):
output = bcm_show(dut, 'bcmcmd "l3 intf show" | wc -l')
st.log(output)
curr_intf_count = parse_route_output(output)
if (curr_intf_count + default_intf_count >= 256):
end_time = datetime.datetime.now()
if (add):
st.log("Time taken for creating 256 L3 interfaces =" +
str(end_time - start_time))
else:
st.log("Time taken for deleting 256 L3 interfaces =" +
str(end_time - start_time))
data.result[1] = 1
elif (i == 512):
output = bcm_show(dut, 'bcmcmd "l3 intf show" | wc -l')
st.log(output)
curr_intf_count = parse_route_output(output)
if (curr_intf_count + default_intf_count >= 512):
end_time = datetime.datetime.now()
if (add):
st.log("Time taken for creating 512 L3 interfaces =" +
str(end_time - start_time))
else:
st.log("Time taken for deleting 512 L3 interfaces =" +
str(end_time - start_time))
data.result[2] = 1
elif (i == 1000):
output = bcm_show(dut, 'bcmcmd "l3 intf show" | wc -l')
st.log(output)
curr_intf_count = parse_route_output(output)
if (curr_intf_count + default_intf_count >= 1000):
end_time = datetime.datetime.now()
if (add):
st.log("Time taken for creating 1000 L3 interfaces =" +
str(end_time - start_time))
else:
st.log("Time taken for deleting 1000 L3 interfaces =" +
str(end_time - start_time))
data.result[3] = 1
output = bcm_show(dut, "time show ip interface")
st.log(output)
data.result[4] = 1
def l3_intf_scaling_tc_6_1_to_6_5():
(dut) = (data.dut)
vars = st.get_testbed_vars()
tc_fail_flag = 0
member3 = vars.D1T1P3
member4 = vars.D1T1P4
json_path = os.getcwd()
apply_file = True
res1 = True
json_apply_path = json_path+"/routing/th2-270_ve_config_db.json"
#st.apply_files(dut, ["$PWD/tests/routing/1k_ve_config_db.json"])
if apply_file is True:
st.apply_files(dut, [json_apply_path])
# L3 INTF SCALING TEST CASE 1.1 START
st.wait(30)
data.my_dut_list = st.get_dut_names()
#dut1 = data.my_dut_list[0]
#res1 = verify_ve_count(dut)
if (res1):
data.result[0] = True
# L3 traffic streams
#For now Spirent link with 100G is not working , so the below code from START to END just books spirent port, it will be rectified
# once infra team provides support for RS-FEC
#START
(tg1, tg_ph_1, tg2, tg_ph_2) = get_handles()
st.log("INTFCONF: "+str(member3))
st.log("INTFCONF: "+str(member4))
tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1)
tg2.tg_traffic_control(action='reset', port_handle=tg_ph_2)
h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.3.49.10', gateway='10.3.49.1', src_mac_addr='00:0a:01:00:00:01', vlan='1', vlan_id='305', vlan_id_count=data.intf_count, arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0', vlan_id_step='1')
#import pdb;pdb.set_trace()
edit_vid = 305
st.wait(15)
#END
if res1:
st.log("Interface Scaling Test Case 6.2 PASSED PING TEST")
st.log("INTFCONF: "+str(res1))
dut1 = dut
# L3 INTF SCALING TEST CASE 1.2 START
# For now ping for only one ip . We intend to use 10 ip for ping test
# As of now the ping goes to next connected one spirent host
#Once spirent works fine , the below ping/arp resolution will ping to spirent hosts
result1 = verify_arp_entry(dut, edit_vid, data.t1d1_ip_addr)
if result1:
st.log("Interface Scaling Test Case 6.2 PASSED ")
data.result[1] = True
else:
tc_fail_flag = 1
st.log("Ping operation_failed")
tg1.tg_interface_config(port_handle=tg_ph_1, handle=h1['handle'], mode='destroy')
# L3 INTF SCALING TEST CASE 1.2 END
# L3 INTF SCALING TEST CASE 1.3 START
clear_arp_entries(dut)
st.wait(15)
h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.3.49.10', gateway='10.3.49.1', src_mac_addr='00:0a:01:00:00:01', vlan='1', vlan_id='305', vlan_id_count=data.intf_count, arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0', vlan_id_step='1')
st.wait(30)
result1 = verify_arp_entry(dut, edit_vid, data.t1d1_ip_addr)
if result1:
st.log("Interface Scaling Test Case 6.3 PASSED ")
data.result[2] = True
else:
tc_fail_flag = 1
st.log("Ping operation_failed")
tg1.tg_interface_config(port_handle=tg_ph_1, handle=h1['handle'], mode='destroy')
# L3 INTF SCALING TEST CASE 6.3 END
# L3 INTF SCALING TEST CASE 1.4 START
trigger_link_flap(dut1, member3)
st.wait(30)
h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.3.49.10', gateway='10.3.49.1', src_mac_addr='00:0a:01:00:00:01', vlan='1', vlan_id='305', vlan_id_count=data.intf_count, arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0', vlan_id_step='1')
st.wait(30)
st.log("INTFCONF: "+str(res1))
ipfeature.ping(dut1, data.t1d1_ip_addr)
result1 = verify_arp_entry(dut, edit_vid, data.t1d1_ip_addr)
if result1:
st.log("Interface Scaling Test Case 6.4 PASSED ")
data.result[3] = True
else:
st.log("Ping operation_failed")
tc_fail_flag = 1
# st.report_fail("Ping operation_failed")
tg1.tg_interface_config(port_handle=tg_ph_1, handle=h1['handle'], mode='destroy')
# L3 INTF SCALING TEST CASE 1.4 END
# L3 INTF SCALING TEST CASE 1.5 START
verify_ip_from_vlan_interface(dut1, edit_vid)
ipfeature.delete_ip_interface(dut, 'Vlan'+str(edit_vid), data.d1t1_ip_addr, subnet="24")
ipfeature.config_ip_addr_interface(dut, 'Vlan'+str(edit_vid), data.d1t1_ip_addr, data.ip_prefixlen, family="ipv4")
h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.3.49.10', gateway='10.3.49.1', src_mac_addr='00:0a:01:00:00:01', vlan='1', vlan_id='305', vlan_id_count=data.intf_count, arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0', vlan_id_step='1')
st.wait(30)
st.log("INTFCONF: "+str(res1))
ipfeature.ping(dut1, data.t1d1_ip_addr)
result1 = verify_arp_entry(dut, edit_vid, data.t1d1_ip_addr)
if result1:
st.log("Interface Scaling Test Case 6.5 PASSED ")
data.result[4] = True
else:
st.log("Ping operation_failed")
tc_fail_flag = 1
# st.report_fail("Ping operation_failed")
tg1.tg_interface_config(port_handle=tg_ph_1, handle=h1['handle'], mode='destroy')
# L3 INTF SCALING TEST CASE 1.5 END
# L3 INTF SCALING TEST CASE 1.6 START
#ipfeature.delete_ip_interface(dut, 'Vlan'+str(edit_vid), data.d1t1_ip_addr, subnet="24")
#vapi.delete_vlan_member(dut, edit_vid, [vars.D2T1P1])
#vapi.delete_vlan(dut,[edit_vid])
# vapi.create_vlan(dut, [edit_vid])
#vapi.add_vlan_member(dut, edit_vid, [vars.D2T1P1], True)
#ipfeature.config_ip_addr_interface(dut, 'Vlan'+str(edit_vid), data.d1t1_ip_addr, data.ip_prefixlen, family="ipv4")
#st.wait(30)
#h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.3.49.10', gateway='10.3.49.1', src_mac_addr='00:0a:01:00:00:01', vlan='1', vlan_id='305', vlan_id_count=data.intf_count, arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0')
#res1=verify_ping(src_obj=tg1, port_handle=tg_ph_1, dev_handle=h1['handle'], dst_ip='10.3.49.1',\
# ping_count='6', exp_count='6')
#st.log("INTFCONF: "+str(res1))
#ipfeature.ping(dut1, data.t1d1_ip_addr)
#result1 = verify_arp_entry(dut, edit_vid, data.t1d1_ip_addr)
#if result1:
# st.log("Interface Scaling Test Case 6.6 PASSED ")
#else:
# st.log("Ping operation_failed")
# tc_fail_flag = 1
#json_apply_path = json_path+"/routing/td3_restore_config_db.json"
#st.apply_files(dut, ["$PWD/tests/routing/1k_ve_config_db.json"])
st.clear_config(dut1)
#tg1.tg_interface_config(port_handle=tg_ph_1, handle=h1['handle'], mode='destroy')
# L3 INTF SCALING TEST CASE 1.6 END
if tc_fail_flag == 0:
st.log("Interface Scaling Test Case 6.1 6.2 6.3 6.4 6.5 PASSED")
st.report_pass("test_case_passed")
else:
st.log("IPV4 Route Scaling Test Case FAILURE Seen");
st.report_fail("test_case_failed")
st.report_pass("operation_successful")
def measure_v4_route_scale_time(route_count, show_flag):
vars = st.get_testbed_vars()
dut = vars.D1
default_route = 0
#TG pumps 512k per sec so to make measure route install
#time more accurate we start from 600k + route_count
#base_route_count = 60000 + route_count
base_route_count = route_count
ipfeature.clear_ip_configuration(st.get_dut_names())
ipfeature.clear_ip_configuration(st.get_dut_names(), 'ipv6')
member3 = vars.D1T1P1
member4 = vars.D1T1P2
ipfeature.config_ip_addr_interface(dut,
member3,
data.my_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.config_ip_addr_interface(dut,
member4,
data.intf_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.get_interface_ip_address(dut, family="ipv4")
ipfeature.show_ip_route(dut)
interface_status_show(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)
(tg1, tg2, tg_ph_1, tg_ph_2) = get_handles()
tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1)
tg2.tg_traffic_control(action='reset', port_handle=tg_ph_2)
h1 = tg1.tg_interface_config(port_handle=tg_ph_1,
mode='config',
intf_ip_addr='10.10.10.2',
gateway='10.10.10.1',
src_mac_addr='00:0a:01:00:00:01',
arp_send_req='1')
st.log("INTFCONF: " + str(h1))
h2 = tg2.tg_interface_config(port_handle=tg_ph_2,
mode='config',
intf_ip_addr='20.20.20.2',
gateway='20.20.20.1',
arp_send_req='1')
st.log("INTFCONF: " + str(h2))
conf_var = {
'mode': 'enable',
'active_connect_enable': '1',
'local_as': '200',
'remote_as': '100',
'remote_ip_addr': '10.10.10.1'
}
route_var = {
'mode': 'add',
'num_routes': base_route_count,
'prefix': '121.1.1.0',
'as_path': 'as_seq:1'
}
ctrl_start = {'mode': 'start'}
ctrl_stop = {'mode': 'stop'}
# Configuring the BGP router.
bgp_rtr1 = tgapi.tg_bgp_config(tg=tg1,
handle=h1['handle'],
conf_var=conf_var,
route_var=route_var,
ctrl_var=ctrl_start)
st.log("BGP_HANDLE: " + str(bgp_rtr1))
# Verified at neighbor.
st.log("BGP neighborship established.")
st.wait(10)
tr1 = tg2.tg_traffic_config(
port_handle=tg_ph_2,
emulation_src_handle=h2['handle'],
emulation_dst_handle=bgp_rtr1['route'][0]['handle'],
circuit_endpoint_type='ipv4',
mode='create',
transmit_mode='continuous',
length_mode='fixed',
rate_pps=512000,
enable_stream_only_gen='0')
retval = bgpfeature.verify_bgp_summary(dut,
neighbor=data.neigh_ip_addr,
state='Established')
if retval is True:
output = bcm_show(dut, 'bcmcmd "l3 defip show" | wc -l')
st.log(output)
default_route = parse_route_output(output)
route_count += default_route
cmd = 'bcmcmd "l3 defip show" | wc -l'
measure_route_learn_time(dut, default_route, route_count, cmd)
if (show_flag):
cmd = "time show ip route"
bcm_show(dut, cmd)
data.result_14_3 = True
res = tg2.tg_traffic_control(action='stop', handle=tr1['stream_id'])
st.log("TR_CTRL: " + str(res))
tgapi.tg_bgp_config(tg=tg1,
handle=bgp_rtr1['conf']['handle'],
ctrl_var=ctrl_stop)
ipfeature.delete_ip_interface(dut,
member4,
data.intf_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.delete_ip_interface(dut,
member3,
data.my_ip_addr,
data.ip_prefixlen,
family="ipv4")
bgpfeature.delete_bgp_neighbor(dut, data.as_num, data.neigh_ip_addr,
data.remote_as_num)
delete_bgp_router(dut, '', data.as_num)
tg2.tg_traffic_control(action='reset', port_handle=tg_ph_2)
tg1.tg_interface_config(port_handle=tg_ph_1,
handle=h1['handle'],
mode='destroy')
tg2.tg_interface_config(port_handle=tg_ph_2,
handle=h2['handle'],
mode='destroy')
st.wait(20)
def test_unnumvrf_donar(fixture_unnumvrf_test_donar):
tc_list = [
'FtOpSoRoIPnumvrfFun007', 'FtOpSoRoIPnumvrfFun008',
'FtOpSoRoIPnumvrfFun009'
]
final_result = 0
result = True
error_list = []
st.banner('FtOpSoRoIPnumvrfFun007 -- to -- FtOpSoRoIPnumvrfFun009')
st.banner(
'Verify unnumbered interface for non default vrf after unbind and rebind vrf'
)
tc_result = True
st.log('Remove the unnumbered configuration on DUT1')
loc_lib.dut1_config_unnumbered('phy', 'no')
loc_lib.dut1_config_unnumbered('vlan', 'no')
loc_lib.dut1_config_unnumbered('pc', 'no')
st.log(
'Remove the OSPF configuration for the unnumbered interfaces on DUT1')
ospf_obj.config_interface_ip_ospf_network_type(data.dut1,
data.d1_d2_ports[0],
'point-to-point',
data.dut1_vrf[0], 'no')
ospf_obj.config_interface_ip_ospf_network_type(
data.dut1, 'Vlan' + data.dut1_dut2_vlan[0], 'point-to-point',
data.dut1_vrf[0], 'no')
ospf_obj.config_interface_ip_ospf_network_type(data.dut1, data.portchannel,
'point-to-point',
data.dut1_vrf[0], 'no')
st.log('Remove the IP addresses for the unnumbered interfaces on DUT1')
ip_obj.delete_ip_interface(data.dut1, data.dut1_loopback[2],
data.dut1_loopback_ip[2],
data.ip_loopback_prefix, "ipv4")
ip_obj.delete_ip_interface(data.dut1, data.dut1_loopback[1],
data.dut1_loopback_ip[1],
data.ip_loopback_prefix, "ipv4")
ip_obj.delete_ip_interface(data.dut1, data.dut1_loopback[0],
data.dut1_loopback_ip[0],
data.ip_loopback_prefix, "ipv4")
st.log('Remove the VRF binding for the unnumbered interfaces on DUT1')
vrf_obj.bind_vrf_interface(
dut=data.dut1,
vrf_name=[data.dut1_vrf[0], data.dut1_vrf[0], data.dut1_vrf[0]],
intf_name=[
data.d1_d2_ports[0], 'Vlan' + data.dut1_dut2_vlan[0],
data.portchannel
],
config='no')
st.log('Bind the back to the unnumbered interfaces on DUT1')
vrf_obj.bind_vrf_interface(
dut=data.dut1,
vrf_name=[data.dut1_vrf[0], data.dut1_vrf[0], data.dut1_vrf[0]],
intf_name=[
data.d1_d2_ports[0], 'Vlan' + data.dut1_dut2_vlan[0],
data.portchannel
],
config='yes')
st.banner('On DUT1 verify vrf bindings for all the interfaces')
output = vrf_obj.get_vrf_verbose(dut=data.dut1, vrfname=data.dut1_vrf[0])
if data.dut1_vrf[0] in output['vrfname']:
st.log('VRF configured on DUT1 is as expected', data.dut1_vrf[0])
else:
st.error('VRF name configured on DUT1 is as not expected',
data.dut1_vrf[0])
result = False
for value in output['interfaces']:
if data.dut1_tg_ports[0] or data.dut1_loopback[
0] or data.dut1_loopback[1] or data.dut1_loopback[
2] or data.d1_d2_ports[0] or 'Vlan' + data.dut1_dut2_vlan[
0] or data.portchannel == value:
st.log('Bind to VRF is as expected', value)
else:
st.error('Bind to VRF is not as expected', value)
result = False
if result is False:
error = "Unbind/Rebind of unnumbered interfaces failed"
tc_result = False
error_list.append(error)
if tc_result:
st.report_tc_pass(tc_list[0], 'tc_passed')
else:
final_result += 1
st.report_tc_fail(tc_list[0], 'test_case_failure_message', error)
st.banner(
'Verify unnumbered interface for non default vrf after adding and removing donar IP'
)
tc_result = True
st.log('On DUT1 configure back the ip addresses on the loopbacks')
ip_obj.config_ip_addr_interface(data.dut1, data.dut1_loopback[1],
data.dut1_loopback_ip[1],
data.ip_loopback_prefix, 'ipv4')
ip_obj.config_ip_addr_interface(data.dut1, data.dut1_loopback[2],
data.dut1_loopback_ip[2],
data.ip_loopback_prefix, 'ipv4')
st.log('On DUT1 add the interfaces back in the ospf network')
ospf_obj.config_interface_ip_ospf_network_type(
data.dut1, 'Vlan' + data.dut1_dut2_vlan[0], 'point-to-point',
data.dut1_vrf[0], 'yes')
ospf_obj.config_interface_ip_ospf_network_type(data.dut1, data.portchannel,
'point-to-point',
data.dut1_vrf[0], 'yes')
st.log(
'On DUT1 configure and verify portchannel and vlan as unnumbered interfaces'
)
loc_lib.dut1_config_unnumbered('vlan', '')
result = loc_lib.dut1_verify_unnumbered('vlan')
if result is False:
error = "Verification of unnumbered interfaces over vrf on a vlan failed after adding/removing the donar interface"
tc_result = False
error_list.append(error)
loc_lib.dut1_config_unnumbered('pc', '')
result = loc_lib.dut1_verify_unnumbered('pc')
if result is False:
error = "Verification of unnumbered interfaces over vrf on a portchannel failed after adding/removing the donar interface"
tc_result = False
error_list.append(error)
if tc_result:
st.report_tc_pass(tc_list[1], 'tc_passed')
else:
final_result += 1
st.report_tc_fail(tc_list[1], 'test_case_failure_message', error)
st.banner(
'Verify unnumbered interface for non default vrf after modifying the donar IP'
)
tc_result = True
st.log(
'On DUT1 modify the donar interface address, add them to the ospf network and configure the physical interface as unnumbered for the new donar IP'
)
ip_obj.config_ip_addr_interface(data.dut1, data.dut1_loopback[0],
data.dut1_loopback_ip[3],
data.ip_loopback_prefix, 'ipv4')
ospf_obj.config_interface_ip_ospf_network_type(data.dut1,
data.d1_d2_ports[0],
'point-to-point',
data.dut1_vrf[0], 'yes')
ospf_obj.config_ospf_network(
data.dut1, data.dut1_loopback_ip[3] + '/' + data.ip_loopback_prefix, 0,
data.dut1_vrf[0], '', 'yes')
ip_obj.config_unnumbered_interface(data.dut1,
family='ipv4',
action='add',
interface=data.d1_d2_ports[0],
loop_back=data.dut1_loopback[0])
st.log('Verify OSPF is up for all interfaces')
result = loc_lib.verify_ospf()
if result is False:
error = "OSPF neighbors are not up for all/some of the unnumbered interfaces"
tc_result = False
error_list.append(error)
result = ip_obj.verify_interface_ip_address(
data.dut1, data.d1_d2_ports[0],
data.dut1_loopback_ip[3] + '/' + data.ip_loopback_prefix, 'ipv4',
data.dut1_vrf[0], 'U')
if result is False:
error = "Verification of unnumbered interfaces over vrf on a physical interface failed after modifying the donar IP"
tc_result = False
error_list.append(error)
st.log(
'Shutting the other ports for traffic to take new configured donar address'
)
port_obj.shutdown(
data.dut1,
[data.d1_d2_ports[1], data.d1_d2_ports[2], data.d1_d2_ports[3]])
result = retry_api(ip_obj.verify_ip_route,
data.dut2,
type='O',
nexthop=data.dut1_loopback_ip[3],
interface=data.d2_d1_ports[0],
ip_address=data.dut1_loopback_ip[3] + '/' +
data.ip_loopback_prefix,
family="ipv4",
retry_count=7,
delay=5)
if result is False:
error = "IP routes on non-default vrf with new IP failed"
tc_result = False
error_list.append(error)
result = loc_lib.send_verify_traffic()
if result is False:
error = "Traffic over vrf on a physical interface failed after modifying the donar IP"
tc_result = False
error_list.append(error)
if tc_result:
st.report_tc_pass(tc_list[2], 'tc_passed')
else:
final_result += 1
st.report_tc_fail(tc_list[2], 'test_case_failure_message', error)
if final_result != 0:
st.report_fail('test_case_failure_message', error_list)
else:
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)
