def arp_static_route_reboot_module_hooks(request):
# add things at the start of this module
init_vars()
initialize_variables()
get_parms()
global tg_handler
tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D1P2")
global tg
tg = tg_handler["tg"]
tg_ph_list = [tg_handler["tg_ph_1"], tg_handler["tg_ph_2"]]
st.log("configuring static route")
adding_static_route()
st.log("Getting ARP entry dynamically")
adding_dynamic_arp()
ip_obj.config_ip_addr_interface(vars.D1,
vars.D1T1P2,
data.ipv4_address_1,
data.mask,
family="ipv4",
config='add')
st.log("Configuring static ARP")
arp_obj.add_static_arp(vars.D1, data.static_arp_ip, data.static_arp_mac,
vars.D1T1P2)
st.log(
"Verifying static route entries before save and reboot/fast-reboot/warm-reboot"
)
static_route_verify()
st.log(
"Verifying dynamic ARP entries before save and reboot/fast-reboot/warm-reboot"
)
if not arp_obj.verify_arp(vars.D1, data.ipv4_address_ixia,
data.src_mac_addr, vars.D1T1P1):
st.report_fail("ARP_entry_dynamic_entry_fail", data.ipv4_address_ixia,
vars.D1)
else:
st.log("Verified that dynamic ARP entry is present in arp table")
st.log(
"Verifying static ARP entries before save and reboot/fast-reboot/warm-reboot"
)
if not arp_obj.verify_arp(vars.D1, data.static_arp_ip, data.static_arp_mac,
""):
st.report_fail("static_arp_create_fail", vars.D1)
else:
st.log("Verified that static ARP entry is present in arp table")
st.log("Save the config on the DUT")
rb_obj.config_save(vars.D1)
st.log("saving config in vtysh mode to save static route")
rb_obj.config_save(vars.D1, shell="vtysh")
yield
# Below step will clear IP adresses configured on different interfaces in the device
ip_obj.clear_ip_configuration(st.get_dut_names())
#Below step will clear static route configured in the device
ip_obj.delete_static_route(vars.D1,
data.ipv4_address_ixia,
data.ipv4_address_network,
family='ipv4',
shell="vtysh")
#Below step will delete static arp entries configured in the device
arp_obj.delete_static_arp(vars.D1, data.static_arp_ip, vars.D1T1P2)
def 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 nat_post_config():
vars = st.get_testbed_vars()
util_nat_zone_config(vars.D2, [vars.D2D1P1, vars.D2D3P1], [data.zone_1, data.zone_2], config=data.config_del)
nat_obj.clear_nat_config(vars.D2)
nat_obj.config_nat_feature(vars.D2, 'disable')
ip_obj.delete_static_route(vars.D1, data.d2d1_ip_addr,"{}/{}".format(data.d1_static_nw, data.ip_addr_mask))
ip_obj.delete_static_route(vars.D3, data.d2d3_ip_addr,"{}/{}".format(data.d3_static_nw, data.ip_addr_mask))
ip_obj.clear_ip_configuration(st.get_dut_names())
def test_ft_ipv6_link_local_manual():
result_flag = 0
st.log("Clearing all interface counters")
utils.exec_all(True, [[intf_obj.clear_interface_counters, vars.D1], [intf_obj.clear_interface_counters, vars.D2]])
st.log("clearing TG stats")
tgapi.traffic_action_control(tg_handler, actions=['clear_stats'])
ip_obj.delete_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, 'ipv6', "vtysh", data.prt_chnl)
utils.exec_all(True, [[ip_obj.config_interface_ip6_link_local,vars.D1, data.prt_chnl, 'disable'],
[ip_obj.config_interface_ip6_link_local,vars.D2, data.prt_chnl, 'disable']])
utils.exec_all(True, [[ip_obj.config_ip_addr_interface, vars.D1, data.prt_chnl, data.ip6_manual_ll_addr[0], data.tg_ip6_addr_mask_l[0], "ipv6", 'add'],
[ip_obj.config_ip_addr_interface, vars.D2, data.prt_chnl, data.ip6_manual_ll_addr[1], data.tg_ip6_addr_mask_l[1], "ipv6", 'add']])
utils.exec_all(True, [
[ip_obj.create_static_route, vars.D1, data.ip6_manual_ll_addr[1], data.static_rt_manual, "vtysh", 'ipv6', data.prt_chnl],
[ip_obj.create_static_route, vars.D2, data.tg_ip6_addr_l[1], data.static_rt_manual, "vtysh", 'ipv6', vars.D2T1P1]])
utils.exec_all(True, [[ip_obj.get_interface_ip_address, vars.D1, None, "ipv6"],
[ip_obj.get_interface_ip_address, vars.D2, None, "ipv6"]])
st.log("Get show ipv6 route output")
utils.exec_all(True, [[ip_obj.show_ip_route, vars.D1, "ipv6", "sonic", None],
[ip_obj.show_ip_route, vars.D2, "ipv6", "sonic", None]])
tg1.tg_traffic_config(mode='modify', stream_id=tg_str_data[1]["tg1_ipv6_data_str_id_1"],
ipv6_dst_addr=data.static_rt_manual_ip)
if not poll_verify_interface_ip_address(vars.D1, data.prt_chnl, ["{}%{}/64".format(data.ip6_manual_ll_addr[0], data.prt_chnl), "{}/64".format(data.ip6_manual_ll_addr[0])],10):
result_flag = 1
if not ip_obj.ping(vars.D1, data.ip6_manual_ll_addr[1], family='ipv6', interface = data.prt_chnl):
st.log("Ipv6 Ping over manual ipv6 Link Local address via the Port Channel based routing interface is failed.")
result_flag =1
tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"])
st.wait(1)
tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"])
tgapi.traffic_action_control(tg_handler, actions=['clear_stats'])
tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"])
st.wait(data.pkts_tx_time)
tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"])
traffic_details = {
'1': {
'tx_ports': [vars.T1D1P1],
'tx_obj': [tg1],
'exp_ratio': [1],
'rx_ports': [vars.T1D2P1],
'rx_obj': [tg2],
}
}
filter_result = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type='packet_count')
if not filter_result:
st.log("traffic loss observed for ipv6 traffic forwarded via ipv6 link local next hop")
result_flag = 1
if result_flag:
st.log("Show command for debugging purpose in case of failures")
utils.exec_all(True, [[intf_obj.show_interface_counters_all, vars.D1],
[intf_obj.show_interface_counters_all, vars.D2]])
st.report_fail("ip6_traffic_over_link_local_nh_fail_manual")
st.report_pass("test_case_passed")
def dhcp_server_unconfig():
dut = data.dut1
hdrMsg("Stoping the dhcp server on dut1")
#st.config(dut, "systemctl stop isc-dhcp-server")
basic_api.service_operations_by_systemctl(dut,
operation='stop',
service='isc-dhcp-server')
for ip in route_list:
ip_api.delete_static_route(dut,
next_hop=dut3_loopback_ip_list[0],
static_ip=ip)
def delete_static_route_dut2():
##########################################################
hdrMsg("Delete static route on dut2 ")
##########################################################
ip_api.delete_static_route(data.dut2,
next_hop=dut3_2_ip_list[0],
static_ip='{}/32'.format(
dut1_loopback_ip_list[0]))
ip_api.delete_static_route(data.dut2,
next_hop=dut3_2_ip_list[0],
static_ip='{}/32'.format(
dut3_loopback_ip_list[0]))
def nat_post_config():
vars = st.get_testbed_vars()
util_nat_zone_config(vars, [vars.D1T1P1, vars.D1T1P2], [data.zone_1, data.zone_2], config=data.config_del)
nat_obj.clear_nat_config(vars.D1)
nat_obj.config_nat_feature(vars.D1, 'disable')
ip_obj.delete_static_route(vars.D1, data.out_ip_addr_h,
"{}/{}".format(data.global_ip_addr_rt, data.global_ip_addr_mask))
ip_obj.clear_ip_configuration(st.get_dut_names())
vlan_obj.clear_vlan_configuration(st.get_dut_names())
st.log("Cleaning up routing interfaces configured on TG")
tg1.tg_interface_config(port_handle=tg_ph_1, handle=tg_rt_int_handle[0]['handle'], mode='destroy')
tg1.tg_interface_config(port_handle=tg_ph_2, handle=tg_rt_int_handle[1]['handle'], mode='destroy')
tgapi.traffic_action_control(tg_handler, actions=['reset'])
def test_ft_bgp_ebgp_multihop_4byteASN():
"""
Verify the functioning of ebgp multihop command with 4 byte ASN
"""
#On DUT1 and DUT3, create BGP with 4byte ASN
dut1_as = 6500001
dut1 = topo['dut_list'][0]
dut3_as = 6500002
dut3 = topo['dut_list'][2]
#Configure bgp on DUT1 and add DUT3 as neighbor with ebgp-multihop ttl set to 5
bgpapi.config_bgp(dut1,
local_as=dut1_as,
neighbor=topo['D3D2P1_ipv4'],
remote_as=dut3_as,
config_type_list=["neighbor", "ebgp_mhop"],
ebgp_mhop='5')
#Add static route to DUT3 neighbor
ipapi.create_static_route(dut1, topo['D1D2P1_neigh_ipv4'],
"{}/24".format(topo['D3D2P1_ipv4']))
#Configure bgp on DUT3 and add DUT1 as neighbor with ebgp-multihop ttl set to 5
bgpapi.config_bgp(dut3,
local_as=dut3_as,
neighbor=topo['D1D2P1_ipv4'],
remote_as=dut1_as,
config_type_list=["neighbor", "ebgp_mhop"],
ebgp_mhop='5')
#Add static route to DUT1 neighbor
ipapi.create_static_route(dut3, topo['D3D2P1_neigh_ipv4'],
"{}/24".format(topo['D1D2P1_ipv4']))
result = bgpapi.verify_bgp_summary(dut1,
family='ipv4',
neighbor=topo['D3D2P1_ipv4'],
state='Established')
#Clear applied configs
bgpapi.cleanup_router_bgp(dut1)
bgpapi.cleanup_router_bgp(dut3)
ipapi.delete_static_route(dut1, topo['D1D2P1_neigh_ipv4'],
"{}/24".format(topo['D3D2P1_ipv4']))
ipapi.delete_static_route(dut3, topo['D3D2P1_neigh_ipv4'],
"{}/24".format(topo['D1D2P1_ipv4']))
if result:
st.report_pass("test_case_passed")
else:
st.report_fail("test_case_failed")
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 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 test_ft_ipv6_link_local_warm_boot():
result_flag=0
ip_obj.delete_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, 'ipv6', "vtysh", data.prt_chnl)
st.log("Clearing all interface counters")
utils.exec_all(True, [[intf_obj.clear_interface_counters, vars.D1], [intf_obj.clear_interface_counters, vars.D2]])
utils.exec_all(True, [[ip_obj.show_ip_route, vars.D1, "ipv6", "sonic", None],
[ip_obj.show_ip_route, vars.D2, "ipv6", "sonic", None]])
tg1.tg_traffic_config(mode='modify', stream_id=tg_str_data[1]["tg1_ipv6_data_str_id_1"],
ipv6_dst_addr=data.static_rt_ip)
st.log("clearing TG stats")
tgapi.traffic_action_control(tg_handler, actions=['clear_stats'])
tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"])
st.log("Performing warm-reboot, while ipv6 traffic is forwarding via link local next hops ")
st.reboot(vars.D1, 'warm')
tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"])
verify_traffic_hash(vars.D1,[vars.D1D2P1, vars.D1D2P2], data.pkts_per_port)
traffic_details = {
'1': {
'tx_ports': [vars.T1D1P1],
'tx_obj': [tg1],
'exp_ratio': [1],
'rx_ports': [vars.T1D2P1],
'rx_obj': [tg2],
}
}
filter_result = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type='packet_count')
if not filter_result:
st.log("During Warm boot, traffic loss observed for ipv6 traffic forwarded via ipv6 link local next hop")
result_flag = 1
if result_flag:
utils.exec_all(True, [[ip_obj.get_interface_ip_address, vars.D1, None, "ipv6"],
[ip_obj.get_interface_ip_address, vars.D2, None, "ipv6"]])
utils.exec_all(True, [[ip_obj.show_ip_route, vars.D1, "ipv6", "sonic", None],
[ip_obj.show_ip_route, vars.D2, "ipv6", "sonic", None]])
utils.exec_all(True, [[intf_obj.show_interface_counters_all, vars.D1],
[intf_obj.show_interface_counters_all, vars.D2]])
st.report_fail("ip6_traffic_over_link_local_nh_fail")
st.report_pass("test_case_passed")
def delete_static_route_dut3():
##########################################################
hdrMsg("Delete static route on dut3 ")
##########################################################
ip_api.delete_static_route(data.dut3,
next_hop=dut2_3_ip_list[0],
static_ip='{}'.format(route_list[0]))
ip_api.delete_static_route(data.dut3,
next_hop=dut2_3_ip_list[0],
static_ip='{}'.format(route_list[1]))
ip_api.delete_static_route(data.dut3,
next_hop=dut2_3_ip_list[0],
static_ip='{}'.format(route_list[3]))
ip_api.delete_static_route(data.dut3,
next_hop=dut2_3_ip_list[0],
static_ip='{}'.format(route_list[4]))
def clear_module_configuration():
print_log("Clearing module configuration")
# delete Ipv4 address
print_log("Delete ip address configuration:")
ip_obj.clear_ip_configuration([vars.D1, vars.D2], family='ipv4')
# delete Ipv6 address
ip_obj.clear_ip_configuration([vars.D1, vars.D2], family='ipv6')
# delete ipv4 static routes
ip_obj.delete_static_route(vars.D1, data.ipv4_portchannel_D2, data.ipv4_network_D2, shell="vtysh",
family="ipv4")
ip_obj.delete_static_route(vars.D2, data.ipv4_portchannel_D1, data.ipv4_network_D1, shell="vtysh",
family="ipv4")
# delete ipv6 static routes
ip_obj.delete_static_route(vars.D1, data.ipv6_portchannel_D2, data.ipv6_network_D2, shell="vtysh",
family="ipv6")
ip_obj.delete_static_route(vars.D2, data.ipv6_portchannel_D1, data.ipv6_network_D1, shell="vtysh",
family="ipv6")
# delete port channel members
print_log("Deleting members from port channel:")
utils.exec_all(True, [
utils.ExecAllFunc(pc_obj.delete_portchannel_member, vars.D1, data.portChannelName, data.dut1_lag_members),
utils.ExecAllFunc(pc_obj.delete_portchannel_member, vars.D2, data.portChannelName, data.dut2_lag_members),
])
# delete port channel
print_log("Deleting port channel configuration:")
utils.exec_all(True, [
utils.ExecAllFunc(pc_obj.delete_portchannel, vars.D1, data.portChannelName),
utils.ExecAllFunc(pc_obj.delete_portchannel, vars.D2, data.portChannelName),
])
# delete acl tables and rules
print_log("Deleting ACLs:")
[_, exceptions] = utils.exec_all(True, [[acl_obj.acl_delete, vars.D1], [acl_obj.acl_delete, vars.D2]])
ensure_no_exception(exceptions)
#Clear static arp entries
print_log("Clearing ARP entries")
arp_obj.clear_arp_table(vars.D1)
arp_obj.clear_arp_table(vars.D2)
#Clear static ndp entries
print_log("Clearing NDP entries")
arp_obj.clear_ndp_table(vars.D1)
arp_obj.clear_ndp_table(vars.D2)
def ipv6_link_local_post_config():
vars = st.get_testbed_vars()
st.log("Static route cleanup")
utils.exec_all(True, [
[ip_obj.delete_static_route, vars.D1, d2_prt_link_local[0], data.static_rt, 'ipv6', "vtysh", vars.D1D2P1],
[ip_obj.delete_static_route, vars.D2, data.tg_ip6_addr_l[1], data.static_rt, 'ipv6', "vtysh", vars.D2T1P1]])
ip_obj.delete_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, 'ipv6',"vtysh", data.vlan_in_1)
ip_obj.delete_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, 'ipv6',"vtysh", data.prt_chnl)
ip_obj.delete_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, 'ipv6', "vtysh", data.vlan_in_2, vrf=data.vrf_name)
vrf_obj.config_vrf(vars.D1, vrf_name=data.vrf_name, config='no')
st.log("Disabling ipv6 link local")
utils.exec_all(True, [[ip_obj.config_interface_ip6_link_local, vars.D1, d1_int_ipv6_list, 'disable'],
[ip_obj.config_interface_ip6_link_local, vars.D2, d2_int_ipv6_list, 'disable']])
ip_obj.clear_ip_configuration(st.get_dut_names(), family = 'ipv6')
st.log("Vlan and Port Channel clean up")
vlan_obj.clear_vlan_configuration(st.get_dut_names())
pc_obj.clear_portchannel_configuration(st.get_dut_names())
st.log("Cleaning up routing interfaces configured on TG")
st.log("Stopping the TG traffic again, if in case of any failures in test function misses the stop operation")
tgapi.traffic_action_control(tg_handler, actions=['reset'])
tg1.tg_interface_config(port_handle=tg_ph_1, handle=tg_rt_int_handle[0]['handle'], mode='destroy')
tg2.tg_interface_config(port_handle=tg_ph_2, handle=tg_rt_int_handle[1]['handle'], mode='destroy')
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 ip_module_hooks(request):
global vars, tg_handler, tg
# Min topology verification
st.log("Ensuring minimum topology")
vars = st.ensure_min_topology("D1T1:4", "D2T1:2", "D1D2:4")
# Initialize TG and TG port handlers
tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D1P2", "T1D2P1",
"T1D2P2")
tg = tg_handler["tg"]
# IP module configuration
st.log("Vlan routing configuration on D1D2P1,D2D1P1")
vlan_obj.create_vlan(vars.D1, data.vlan_1)
vlan_obj.add_vlan_member(vars.D1,
data.vlan_1, [vars.D1D2P1],
tagging_mode=True)
vlan_obj.create_vlan(vars.D2, data.vlan_1)
vlan_obj.add_vlan_member(vars.D2,
data.vlan_1, [vars.D2D1P1],
tagging_mode=True)
ipfeature.config_ip_addr_interface(vars.D1,
data.vlan_int_1,
data.ip4_addr[2],
24,
family=data.af_ipv4)
ipfeature.config_ip_addr_interface(vars.D1,
data.vlan_int_1,
data.ip6_addr[2],
96,
family=data.af_ipv6)
ipfeature.config_ip_addr_interface(vars.D2,
data.vlan_int_1,
data.ip4_addr[3],
24,
family=data.af_ipv4)
ipfeature.config_ip_addr_interface(vars.D2,
data.vlan_int_1,
data.ip6_addr[3],
96,
family=data.af_ipv6)
st.log("Port routing configuration on port-channel")
data.dut1_pc_members = [vars.D1D2P2, vars.D1D2P3]
data.dut2_pc_members = [vars.D2D1P2, vars.D2D1P3]
pc_obj.create_portchannel(vars.D1, data.port_channel)
pc_obj.add_portchannel_member(vars.D1, data.port_channel,
data.dut1_pc_members)
pc_obj.create_portchannel(vars.D2, data.port_channel)
pc_obj.add_portchannel_member(vars.D2, data.port_channel,
data.dut2_pc_members)
ipfeature.config_ip_addr_interface(vars.D1,
data.port_channel,
data.ip4_addr[4],
24,
family=data.af_ipv4)
ipfeature.config_ip_addr_interface(vars.D2,
data.port_channel,
data.ip4_addr[5],
24,
family=data.af_ipv4)
ipfeature.config_ip_addr_interface(vars.D1,
data.port_channel,
data.ip6_addr[4],
96,
family=data.af_ipv6)
ipfeature.config_ip_addr_interface(vars.D2,
data.port_channel,
data.ip6_addr[5],
96,
family=data.af_ipv6)
st.log("port routing configuration on D1D2P4,D2D1P4")
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.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)
st.log("configuring the dut1 ports connected to TGen with ip addresses")
ipfeature.config_ip_addr_interface(vars.D1,
vars.D1T1P1,
data.ip4_addr[1],
24,
family=data.af_ipv4)
ipfeature.config_ip_addr_interface(vars.D1,
vars.D1T1P2,
data.ip6_addr[1],
96,
family=data.af_ipv6)
ipfeature.create_static_route(vars.D1,
data.ip6_addr[7],
data.static_ip6_rt,
shell=data.shell_vtysh,
family=data.af_ipv6)
ipfeature.create_static_route(vars.D1,
data.ip4_addr[7],
data.static_ip_rt,
shell=data.shell_vtysh,
family=data.af_ipv4)
st.log("configuring the dut2 ports connected to TGen with ip addresses")
ipfeature.config_ip_addr_interface(vars.D2,
vars.D2T1P1,
data.ip4_addr[8],
24,
family=data.af_ipv4)
ipfeature.config_ip_addr_interface(vars.D2,
vars.D2T1P2,
data.ip6_addr[8],
96,
family=data.af_ipv6)
yield
ipfeature.clear_ip_configuration(st.get_dut_names())
ipfeature.clear_ip_configuration(st.get_dut_names(), 'ipv6')
vlan_obj.clear_vlan_configuration(st.get_dut_names())
pc_obj.clear_portchannel_configuration(st.get_dut_names())
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)
def test_ft_ip6_static_route_traffic_forward_blackhole():
# Objective - Verify the Ipv6 traffic forwarding over static route.
tg_handler = tgapi.get_handles_byname("T1D1P2", "T1D2P2")
tg = tg_handler["tg"]
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"])
dut_rt_int_mac1 = basic_obj.get_ifconfig_ether(vars.D1, vars.D1T1P2)
h1 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_1"], mode='config', ipv6_intf_addr=data.ip6_addr[0], \
ipv6_prefix_length='64', ipv6_gateway=data.ip6_addr[1],
src_mac_addr=data.tg_mac1, arp_send_req='1')
st.log("INTFCONF: " + str(h1))
h2 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_2"], mode='config', ipv6_intf_addr=data.ip6_addr[9], \
ipv6_prefix_length='64', ipv6_gateway=data.ip6_addr[8],
src_mac_addr=data.tg_mac2, arp_send_req='1')
st.log("INTFCONF: " + str(h2))
# Ping from tgen to DUT.
res = tgapi.verify_ping(src_obj=tg, port_handle=tg_handler["tg_ph_1"], dev_handle=h1['handle'], dst_ip=data.ip6_addr[1], \
ping_count='1', exp_count='1')
if res:
st.log("Ping succeeded.")
else:
st.warn("Ping failed.")
tr1 = tg.tg_traffic_config(port_handle=tg_handler["tg_ph_1"], mode='create', transmit_mode='single_burst',
pkts_per_burst=2000, \
length_mode='fixed', rate_pps=2000, l3_protocol='ipv6', mac_src=data.tg_mac1, \
mac_dst=dut_rt_int_mac1, ipv6_src_addr=data.ip6_addr[0],
ipv6_dst_addr=data.ip6_addr[9])
st.log("TRAFCONF: " + str(tr1))
res = tg.tg_traffic_control(action='run', stream_handle=tr1['stream_id'])
st.log("TR_CTRL: " + str(res))
tg.tg_traffic_control(action='stop', stream_handle=tr1['stream_id'])
st.log("Checking the stats and verifying the traffic flow")
traffic_details = {
'1': {
'tx_ports': [vars.T1D1P2],
'tx_obj': [tg_handler["tg"]],
'exp_ratio': [1],
'rx_ports': [vars.T1D2P2],
'rx_obj': [tg_handler["tg"]],
}
}
# verify statistics
aggrResult = tgapi.validate_tgen_traffic(traffic_details=traffic_details,
mode='aggregate',
comp_type='packet_count')
if not aggrResult:
st.report_fail("traffic_verification_failed")
ipfeature.delete_static_route(vars.D1,
data.ip6_addr[7],
data.static_ip6_rt,
shell=data.shell_vtysh,
family=data.af_ipv6)
st.log("Create a static route with nexthop as blackhole")
ipfeature.create_static_route(vars.D1,
data.static_ip6_rt_drop,
data.static_ip6_rt,
shell=data.shell_vtysh,
family=data.af_ipv6)
tg.tg_traffic_control(action="clear_stats",
port_handle=tg_handler["tg_ph_list"])
res = tg.tg_traffic_control(action='run', stream_handle=tr1['stream_id'])
st.log("TR_CTRL: " + str(res))
tg.tg_traffic_control(action='stop', stream_handle=tr1['stream_id'])
st.log("Checking the stats and verifying the traffic flow")
traffic_details = {
'1': {
'tx_ports': [vars.T1D1P2],
'tx_obj': [tg_handler["tg"]],
'exp_ratio': [1],
'rx_ports': [vars.T1D2P2],
'rx_obj': [tg_handler["tg"]],
}
}
# verify statistics
aggrResult = tgapi.validate_tgen_traffic(traffic_details=traffic_details,
mode='aggregate',
comp_type='packet_count')
if aggrResult:
st.report_fail("traffic_verification_failed")
st.report_pass("test_case_passed")
def f3():
ip_obj.delete_static_route(data.d3, data.d3_d4_intf_1_ip, '4.4.4.0/30', family='ipv4', shell="vtysh")
ip_obj.delete_static_route(data.d3, data.d3_d4_vlan_1_ip, '4.4.4.0/30', family='ipv4', shell="vtysh")
ip_obj.delete_static_route(data.d3, data.d2_d3_pc_1_ip, '2.2.2.0/30', family='ipv4', shell="vtysh")
def test_fuctPBR_02():
global description
global descriptionv6
global vars
vars = st.get_testbed_vars()
final_result = True
description = 'IPv4_ACL_redirect_NH'
descriptionv6 = 'IPv6_ACL_redirect_NH'
st.log(
'This test covers StSoSeConf014 StSoSeConf015 StSoSeVer014 StSoSeVer015'
)
st.log('creating IPv4 static route')
ipfeature.create_static_route(dut1,
static_ip=srpIP,
next_hop=nextHop_ip,
shell='')
ipfeature.create_static_route(dut1,
static_ip=srpIPv6,
next_hop=nextHop_ipv6,
shell='',
family='ipv6')
st.log(
'creating IPv4 ACL table and binding to the ports in Ingress direction'
)
acl_obj.create_acl_table(dut1,
name=acl_table_name,
stage=stage,
type=type,
description=description,
ports=[r1_tg_ports1])
acl_obj.create_acl_table(dut1,
name=acl_table_namev6,
stage=stage,
type=typev6,
description=descriptionv6,
ports=[r1_tg_ports1])
st.log(
'Creating ACL rules with src_ip dst_ip port and action as forward drop'
)
acl_obj.create_acl_rule(dut1,
table_name=acl_table_name,
rule_name=rule_list[0],
priority=priority_list[0],
packet_action=pktAction + nextHop_ip + '|' +
r1_tg_ports2,
SRC_IP="{}/{}".format(srpIP, maskACL),
DST_IP="{}/{}".format(dstIP, maskACL))
acl_obj.create_acl_rule(dut1,
table_name=acl_table_name,
rule_name=rule_list[9],
priority=priority_list[9],
packet_action='drop',
IP_TYPE='ipv4any')
acl_obj.create_acl_rule(dut1,
table_name=acl_table_namev6,
rule_name=rule_list[0],
priority=priority_list[0],
packet_action=pktAction + nextHop_ipv6 + '|' +
r1_tg_ports2,
SRC_IPV6="{}/{}".format(srpIPv6, '128'),
DST_IPV6="{}/{}".format(dstIPv6, '128'))
acl_obj.create_acl_rule(dut1,
table_name=acl_table_namev6,
rule_name=rule_list[9],
priority=priority_list[9],
packet_action='drop',
IP_TYPE='ipv6any')
#acl_obj.create_acl_rule(dut1, table_name=acl_table_name, rule_name=rule_list[0],priority=priority_list[0], packet_action=pktAction+nextHop_ip+'|'+r1_tg_ports2, SRC_IP="{}/{}".format(srpIP, maskACL),DST_IP="{}/{}".format(dstIP, maskACL))
start_stop_traffic(tg1, tg2, tg_dut1_p1_handle, tg_dut1_p2_handle)
traffic_details = {
'1': {
'tx_ports': [vars.T1D1P1],
'tx_obj': [tg1],
'exp_ratio': [[1, 0, 1, 0]],
'rx_ports': [vars.T1D1P2],
'rx_obj': [tg2],
'stream_list': [[stream_id1, stream_id2, stream_id3, stream_id4]]
}
}
test1 = tgapi.validate_tgen_traffic(traffic_details=traffic_details,
mode='streamblock',
comp_type='packet_count')
if test1 is False:
st.error("Traffic Verification Failed")
final_result = False
t1 = acl_obj.verify_acl_stats(dut1,
table_name=acl_table_name,
rule_name=rule_list[0],
packet_count=expCount)
t2 = acl_obj.verify_acl_stats(dut1,
table_name=acl_table_name,
rule_name=rule_list[9],
packet_count=expCount)
t3 = acl_obj.verify_acl_stats(dut1,
table_name=acl_table_namev6,
rule_name=rule_list[0],
packet_count=expCount)
t4 = acl_obj.verify_acl_stats(dut1,
table_name=acl_table_namev6,
rule_name=rule_list[9],
packet_count=int(expCount) + 16)
if False in list(set([t1, t2, t3, t4])):
tc = [t1, t2, t3, t4].index(False)
print("TC failed for rule : " + str((tc + 1)))
st.error("ACL stats validation Failed")
final_result = False
else:
st.log('ACL stats validation Passed')
st.log('Deleting IPv4/v6 static route')
ipfeature.delete_static_route(dut1,
static_ip=srpIP,
next_hop=nextHop_ip,
shell='')
ipfeature.delete_static_route(dut1,
static_ip=srpIPv6,
next_hop=nextHop_ipv6,
shell='',
family='ipv6')
st.log('Removing the ACL table config')
acl_obj.delete_acl_table(dut=dut1, acl_table_name=acl_table_name)
acl_obj.delete_acl_table(dut=dut1, acl_table_name=acl_table_namev6)
if final_result:
st.log(
"PBR-Test:Validation of PBR REDIRECT_TO_Next-Hop interface Passed")
st.report_pass('test_case_passed')
else:
st.error(
"PBR-Test : Validation of PBR REDIRECT_TO_Next-Hop interface failed"
)
st.report_fail('test_case_failed')
def f4():
ip_obj.delete_static_route(data.d4, data.d4_d3_intf_1_ip, '3.3.3.0/30', family='ipv4', shell="vtysh")
ip_obj.delete_static_route(data.d4, data.d4_d3_vlan_1_ip, '3.3.3.0/30', family='ipv4', shell="vtysh")
ip_obj.delete_static_route(data.d4, data.d1_d4_pc_1_ip, '1.1.1.0/30', family='ipv4', shell="vtysh")
def test_ft_bgp_ebgp_multihop_4byteASN():
"""
Verify the functioning of ebgp multihop command with 4 byte ASN
"""
# On DUT1 and DUT3, create BGP with 4byte ASN
dut1_as = 6500001
dut1 = topo['dut_list'][0]
dut3_as = 6500002
dut3 = topo['dut_list'][2]
result = 0
wait_timer = 150
st.banner("Verify the ebgp multihop functionality with 4 byte AS Number")
# Configure bgp on DUT1 and configure DUT3 as neighbor with ebgp-multihop ttl set to 5
st.log(
"Configure eBGP on DUT1 with Neighbor as DUT3 with multihop set to maximum hops of 5"
)
bgpapi.config_bgp(dut1,
local_as=dut1_as,
neighbor=topo['D3D2P1_ipv4'],
remote_as=dut3_as,
config_type_list=["neighbor", "ebgp_mhop"],
ebgp_mhop='5')
# Add static route towards neighbor DUT3
st.log("Add static route towards DUT3")
ipapi.create_static_route(dut1, topo['D1D2P1_neigh_ipv4'],
"{}/24".format(topo['D3D2P1_ipv4']))
# Configure bgp on DUT3 and configure DUT1 as neighbor with ebgp-multihop ttl set to 5
st.log(
"Configure eBGP on DUT3 with DUT1 as Neighbor with multihop set to maximum hops of 5"
)
bgpapi.config_bgp(dut3,
local_as=dut3_as,
neighbor=topo['D1D2P1_ipv4'],
remote_as=dut1_as,
config_type_list=["neighbor", "ebgp_mhop"],
ebgp_mhop='5')
# Add static route towards neighbor DUT1
st.log("Add static route towards DUT1")
ipapi.create_static_route(dut3, topo['D3D2P1_neigh_ipv4'],
"{}/24".format(topo['D1D2P1_ipv4']))
st.log("Verify BGP neighborship on DUT1")
#result = bgpapi.verify_bgp_summary(dut1, family='ipv4', neighbor=topo['D3D2P1_ipv4'], state='Established')
if not utils.poll_wait(bgpapi.verify_bgp_summary,
wait_timer,
dut1,
family='ipv4',
neighbor=topo['D3D2P1_ipv4'],
state='Established'):
st.log("Failed to form BGP eBGP multihop peering with 4byte ASN")
result += 1
if result == 0:
st.log("Pass: BGP neighborship established between DUT1 and DUT3")
else:
st.error(
"Fail: BGP neighborship not established between DUT1 and DUT3")
st.banner("Collecting techsupport")
exec_all(True, [[
st.generate_tech_support, topo['dut_list'][0],
"test_ft_bgp_ebgp_multihop_4byteASN"
],
[
st.generate_tech_support, topo['dut_list'][1],
"test_ft_bgp_ebgp_multihop_4byteASN"
],
[
st.generate_tech_support, topo['dut_list'][2],
"test_ft_bgp_ebgp_multihop_4byteASN"
]])
#Clear applied configs
st.banner("Cleanup for TestFunction")
bgpapi.cleanup_router_bgp(dut1)
bgpapi.cleanup_router_bgp(dut3)
ipapi.delete_static_route(dut1, topo['D1D2P1_neigh_ipv4'],
"{}/24".format(topo['D3D2P1_ipv4']))
ipapi.delete_static_route(dut3, topo['D3D2P1_neigh_ipv4'],
"{}/24".format(topo['D1D2P1_ipv4']))
if result == 0:
st.report_pass("test_case_passed")
else:
st.report_fail("test_case_failed")
