def erspan_pre_config():
"""
Author: Lakshminarayana D ([email protected])
Using this pre config at module level. So, applicable for all test cases which includes in this module.
:return: None
"""
# IP address configuration on DUT-1
for port, ip_addr, in zip(data.port_list_d1, data.ip_list_d1):
ip.config_ip_addr_interface(vars.D1, port, ip_addr, data.subnet_mask)
# IP address configuration on DUT-2
for port, ip_addr in zip(data.port_list_d2, data.ip_list_d2):
ip.config_ip_addr_interface(vars.D2, port, ip_addr, data.subnet_mask)
# Create static route
_, network = ip.get_network_addr("{}/{}".format(data.ip_T1D2P1, data.subnet_mask))
ip.create_static_route(vars.D1, data.ip_D2D1P1, network)
_, network = ip.get_network_addr("{}/{}".format(data.ip_T1D1P1, data.subnet_mask))
ip.create_static_route(vars.D2, data.ip_D1D2P1, network)
# creation and verification of Monitor session
mirror.create_session(vars.D1, session_name=data.session_name, src_ip=data.ip_D1T1P1,
dst_ip=data.ip_T1D2P1, gre_type=data.gre_type, dscp=data.dscp,
ttl=data.ttl, queue=data.queue)
# creation and verification of ACL Policy
acl_dscp.config_policy_table(vars.D1, enable='create', policy_name=data.acl_table_name, policy_type=data.type)
acl_dscp.config_service_policy_table(vars.D1, policy_kind="bind", interface_name=vars.D1T1P1, stage='in',
service_policy_name=data.acl_table_name, policy_type=data.type)
acl_dscp.config_service_policy_table(vars.D1, policy_kind="bind", interface_name=vars.D1T1P2, stage='in',
policy_type=data.type, service_policy_name=data.acl_table_name)
acl.create_acl_table(vars.D1, name="L3_IPV6_INGRESS", stage=data.stage, type="L3V6",
description="L3_IPV6_INGRESS", ports=[vars.D1T1P1])
def nat_pre_config():
global vars
vars = st.ensure_min_topology("D1D2:1", "D2D3:1")
platform = basic_obj.get_hwsku(vars.D2)
common_constants = st.get_datastore(vars.D2, "constants", "default")
if platform.lower() in common_constants['TH3_PLATFORMS']:
st.error("NAT is not supported for this platform {}".format(platform))
st.report_unsupported('NAT_unsupported_platform',platform)
ip_obj.config_ip_addr_interface(vars.D1, vars.D1D2P1, data.d1d2_ip_addr, data.ip_addr_mask, family=data.af_ipv4)
ip_obj.config_ip_addr_interface(vars.D2, vars.D2D1P1, data.d2d1_ip_addr, data.ip_addr_mask, family=data.af_ipv4)
ip_obj.config_ip_addr_interface(vars.D2, vars.D2D3P1, data.d2d3_ip_addr, data.ip_addr_mask, family=data.af_ipv4)
ip_obj.config_ip_addr_interface(vars.D3, vars.D3D2P1, data.d3d2_ip_addr, data.ip_addr_mask, family=data.af_ipv4)
ip_obj.create_static_route(vars.D1, data.d2d1_ip_addr,"{}/{}".format(data.d1_static_nw, data.ip_addr_mask),
shell=data.shell_vtysh, family=data.af_ipv4)
ip_obj.create_static_route(vars.D3, data.d2d3_ip_addr, "{}/{}".format(data.d3_static_nw, data.ip_addr_mask),
shell=data.shell_vtysh, family=data.af_ipv4)
st.log("NAT Configuration")
nat_obj.config_nat_feature(vars.D2, 'enable')
util_nat_zone_config(vars.D2, [vars.D2D1P1, vars.D2D3P1], [data.zone_1, data.zone_2], config=data.config_add)
st.log("Creating NAT Pool")
nat_obj.config_nat_pool(vars.D2, pool_name=data.pool_name[0], global_ip_range=data.d2d1_ip_addr,
global_port_range=data.global_port_range, config=data.config_add)
st.log("Creating NAT Pool binding")
nat_obj.config_nat_pool_binding(vars.D2, binding_name=data.bind_name[0], pool_name=data.pool_name[0],
config=data.config_add)
utils.exec_all(True, [[ip_obj.show_ip_route, vars.D1], [ip_obj.show_ip_route, vars.D2]])
ip_obj.show_ip_route(vars.D3)
def dut2_static_route_config():
st.log("config static route in DUT2")
ip.create_static_route(dut=acl_dict["dut_list"][1],
next_hop=acl_dict["dut3"]["ip_addr_list"][0],
static_ip=acl_dict["dut3"]["prefix_list"][2])
ip.create_static_route(dut=acl_dict["dut_list"][1],
next_hop=acl_dict["dut1"]["ip_addr_list"][0],
static_ip=acl_dict["dut1"]["prefix_list"][2])
def dhcp_server_config():
'''
1. Install dhcp package
2. Update dhcp files - dhcpd6.conf dhcpd.conf isc-dhcp-server
3. Add static routes
4.Restart dhcp process
'''
hdrMsg("Installing and configuring the dhcp server on dut1")
dut = data.dut1
copy_files_to_dut(st.get_mgmt_ip(dut))
# st.config(dut,'sudo mv /tmp/'+data.dhcp_files[0]+' /etc/default/'+server_filename,skip_error_check=True)
# st.config(dut,'sudo mv /tmp/'+data.dhcp_files[1]+' /etc/dhcp/',skip_error_check=True)
# st.config(dut,'sudo mv /tmp/'+data.dhcp_files[2]+' /etc/dhcp/',skip_error_check=True)
basic_api.move_file_to_local_path(dut,
'/tmp/' + data.dhcp_files[0],
'/etc/default/' + server_filename,
sudo=True,
skip_error_check=True)
basic_api.move_file_to_local_path(dut,
'/tmp/' + data.dhcp_files[1],
'/etc/dhcp/',
sudo=True,
skip_error_check=True)
basic_api.move_file_to_local_path(dut,
'/tmp/' + data.dhcp_files[2],
'/etc/dhcp/',
sudo=True,
skip_error_check=True)
for ip in route_list:
ip_api.create_static_route(dut,
next_hop=dut3_loopback_ip_list[0],
static_ip=ip)
basic_api.deploy_package(dut, mode='update')
basic_api.deploy_package(dut,
options='-o Dpkg::Options::=\"--force-confold\"',
packane_name='isc-dhcp-server',
mode='install',
skip_verify_package=True)
#st.config(dut, "systemctl restart isc-dhcp-server")
st.wait(2)
ps_aux = basic_api.get_ps_aux(data.dut1, "dhcpd")
if len(ps_aux) > 1:
hdrMsg("dhcp server is up and running in dut1")
return True
#st.config(dut, "systemctl restart isc-dhcp-server")
basic_api.service_operations_by_systemctl(dut,
operation='restart',
service='isc-dhcp-server')
ps_aux = basic_api.get_ps_aux(data.dut1, "dhcpd")
st.wait(2)
if len(ps_aux) < 1:
hdrMsg("dhcp server is not up and running in dut1")
return False
return True
def dut1_config(config=''):
st.log('On DUT1 physical interface IPv4 and IPv6 addresses on it')
ip_obj.config_ip_addr_interface(data.dut1_client, data.d1_d2_ports[0],
data.dut1_dut2_ipv6[0],
data.dut1_dut2_ipv6_subnet, 'ipv6')
ip_obj.config_ip_addr_interface(data.dut1_client, data.d1_d2_ports[0],
data.dut1_dut2_ip[0],
data.dut1_dut2_ip_subnet, 'ipv4')
st.log('On DUT1 configure vlan and IPv4 and IPv6 addresses on it')
vlan_obj.create_vlan(data.dut1_client, data.dut1_dut2_vlan[0])
vlan_obj.add_vlan_member(data.dut1_client, data.dut1_dut2_vlan[0],
data.d1_d2_ports[1], True, True)
ip_obj.config_ip_addr_interface(data.dut1_client,
'Vlan' + data.dut1_dut2_vlan[0],
data.dut1_dut2_ipv6[1],
data.dut1_dut2_ipv6_subnet, 'ipv6')
ip_obj.config_ip_addr_interface(data.dut1_client,
'Vlan' + data.dut1_dut2_vlan[0],
data.dut1_dut2_ip[1],
data.dut1_dut2_ip_subnet, 'ipv4')
st.log('On DUT1 configure portchannel and IPv4 and IPv6 addresses on it')
pc_obj.create_portchannel(data.dut1_client, data.portchannel)
pc_obj.add_portchannel_member(data.dut1_client, data.portchannel,
[data.d1_d2_ports[2], data.d1_d2_ports[3]])
ip_obj.config_ip_addr_interface(data.dut1_client, data.portchannel,
data.dut1_dut2_ipv6[2],
data.dut1_dut2_ipv6_subnet, 'ipv6')
ip_obj.config_ip_addr_interface(data.dut1_client, data.portchannel,
data.dut1_dut2_ip[2],
data.dut1_dut2_ip_subnet, 'ipv4')
st.log('On DUT1 configure loopback and IPv4 and IPv6 addresses on it')
ip_obj.configure_loopback(data.dut1_client,
config='yes',
loopback_name=data.dut1_loopback[0])
ip_obj.config_ip_addr_interface(data.dut1_client, data.dut1_loopback[0],
data.dut1_loopback_ipv6[0],
data.dut1_loopback_ipv6_subnet, 'ipv6')
ip_obj.config_ip_addr_interface(data.dut1_client, data.dut1_loopback[0],
data.dut1_loopback_ip[0],
data.dut1_loopback_ip_subnet, 'ipv4')
st.log('IPv4 and IPv6 static routes for loopback reachability')
ip_obj.create_static_route(data.dut1_client,
data.dut2_dut1_ip[0],
data.dut2_loopback_ip[0] + '/32',
family='ipv4')
ip_obj.create_static_route(data.dut1_client,
data.dut2_dut1_ipv6[0],
data.dut2_loopback_ipv6[0] + '/128',
family='ipv6')
return True
def dut2_static_route_v6_config():
st.log("config IPv6 static route in DUT2")
ip.create_static_route(dut=acl_dict["dut_list"][1],
next_hop=acl_dict["dut3"]["ipv6_addr_list"][0],
static_ip=acl_dict["dut3"]["prefix_v6_list"][2],
family="ipv6")
ip.create_static_route(dut=acl_dict["dut_list"][1],
next_hop=acl_dict["dut1"]["ipv6_addr_list"][0],
static_ip=acl_dict["dut1"]["prefix_v6_list"][2],
family="ipv6")
def config_static_route(dut, nhp, ip, shell, af, action):
st.log("Creating a {} static route {} with Neighbor {}".format(
af, ip, nhp))
if action == "add":
ipapi.create_static_route(dut,
next_hop=nhp,
static_ip=ip,
shell=shell,
family=af)
if not ipapi.verify_ip_route(dut, af, ip):
st.report_fail('ip_routing_int_create_fail', dut)
def create_static_route_dut2():
##########################################################
hdrMsg("Create static route on dut2 ")
##########################################################
ip_api.create_static_route(data.dut2,
next_hop=dut3_2_ip_list[0],
static_ip='{}/32'.format(
dut1_loopback_ip_list[0]))
ip_api.create_static_route(data.dut2,
next_hop=dut3_2_ip_list[0],
static_ip='{}/32'.format(
dut3_loopback_ip_list[0]))
def crm_ecmp_config(data=[]):
route = "200.0.0.0"
partner_base2 = "7.7.7.2"
stroute = route
for _ in range(0, 4):
_, stroute = increment_ip_addr(stroute, data.routing_subnet)
_, partner_base2 = increment_ip_addr(partner_base2, 31)
partner = partner_base2
for _ in range(0, 50):
_, partner = increment_ip_addr(partner, 31)
ipfeature.create_static_route(data.D1,
static_ip="{}/{}".format(
stroute, data.routing_subnet),
next_hop=partner)
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 adding_static_route():
st.log("About to add ipv4 address on TGen connected interface")
ip_obj.config_ip_addr_interface(vars.D1,
vars.D1T1P1,
data.ipv4_address,
data.mask,
family="ipv4",
config='add')
st.log("Enabling docker routing config mode to split")
bgp_obj.enable_docker_routing_config_mode(vars.D1)
st.log("configuring static route via vtysh mode")
ip_obj.create_static_route(vars.D1,
data.ipv4_address_tgen,
data.ipv4_address_network,
shell="vtysh",
family="ipv4")
def ipv6_link_local_func_hooks(request):
utils.exec_all(True, [[ip_obj.show_ip_route, vars.D1, "ipv6"], [ip_obj.show_ip_route, vars.D2, "ipv6"]])
yield
if st.get_func_name(request) == 'test_ft_ipv6_link_local_warm_boot':
ip_obj.create_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, "vtysh", 'ipv6', data.prt_chnl)
tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"])
if st.get_func_name(request) == 'test_ft_ipv6_link_local_manual':
utils.exec_all(True, [
[ip_obj.delete_static_route, vars.D1, data.ip6_manual_ll_addr[1], data.static_rt_manual, 'ipv6', "vtysh",
data.prt_chnl],
[ip_obj.delete_static_route, vars.D2, data.tg_ip6_addr_l[1], data.static_rt_manual, 'ipv6', "vtysh", vars.D2T1P1]])
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", 'remove'],
[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", 'remove']])
utils.exec_all(True, [[ip_obj.config_interface_ip6_link_local, vars.D1, data.prt_chnl, 'enable'],
[ip_obj.config_interface_ip6_link_local, vars.D2, data.prt_chnl, 'enable']])
ip_obj.create_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, "vtysh", 'ipv6', data.prt_chnl)
def pre_test_l3_fwding():
# override from testbed
data.my_dut_list = st.get_dut_names()
if len(data.my_dut_list) < 2:
st.report_fail("operation_failed")
return
dut1 = data.my_dut_list[0]
dut2 = data.my_dut_list[1]
if not verifyPortStatus():
st.report_fail("operation_failed")
ipfeature.config_ip_addr_interface(dut1, vars.D1T1P1, data.d1t1_ip_addr,
data.mask)
ipfeature.config_ip_addr_interface(dut1, vars.D1D2P1, data.d1d2_ip_addr,
data.mask)
ipfeature.config_ip_addr_interface(dut2, vars.D2D1P1, data.d2d1_ip_addr,
data.mask)
ipfeature.config_ip_addr_interface(dut2, vars.D2T1P1, data.d2t1_ip_addr,
data.mask)
ipfeature.create_static_route(dut1, data.d2d1_ip_addr,
data.static_ip_list[1])
ipfeature.create_static_route(dut2, data.d1d2_ip_addr,
data.static_ip_list[0])
# ipv6
ipfeature.config_ip_addr_interface(dut1,
vars.D1T1P1,
data.d1t1_ip_addr_v6,
data.mask_v6,
family='ipv6')
ipfeature.config_ip_addr_interface(dut1,
vars.D1D2P1,
data.d1d2_ip_addr_v6,
data.mask_v6,
family='ipv6')
ipfeature.config_ip_addr_interface(dut2,
vars.D2D1P1,
data.d2d1_ip_addr_v6,
data.mask_v6,
family='ipv6')
ipfeature.config_ip_addr_interface(dut2,
vars.D2T1P1,
data.d2t1_ip_addr_v6,
data.mask_v6,
family='ipv6')
ipfeature.create_static_route(dut1,
data.d2d1_ip_addr_v6,
data.static_ipv6_list[1],
family='ipv6')
ipfeature.create_static_route(dut2,
data.d1d2_ip_addr_v6,
data.static_ipv6_list[0],
family='ipv6')
def create_static_route_dut3():
##########################################################
hdrMsg("Create static route on dut3 ")
##########################################################
ip_api.create_static_route(data.dut3,
next_hop=dut2_3_ip_list[0],
static_ip='{}'.format(route_list[0]))
ip_api.create_static_route(data.dut3,
next_hop=dut2_3_ip_list[0],
static_ip='{}'.format(route_list[1]))
ip_api.create_static_route(data.dut3,
next_hop=dut2_3_ip_list[0],
static_ip='{}'.format(route_list[3]))
ip_api.create_static_route(data.dut3,
next_hop=dut2_3_ip_list[0],
static_ip='{}'.format(route_list[4]))
def ipv6_link_local_pre_config():
global vars
vars = st.ensure_min_topology("D1D2:4", "D1T1:1", "D2T1:1")
global tg_handler, tg1, tg2, tg_ph_1, tg_ph_2, tg_str_data, dut1_rt_int_mac, dut2_rt_int_mac, \
tg_rt_int_handle, d1_prt_link_local, d2_prt_link_local, d1_int_ipv6_list, d2_int_ipv6_list
tg_handler = util_tg_init(vars, [vars.T1D1P1, vars.T1D2P1])
tg1 = tg_handler["tg"]
tg2 = tg_handler["tg"]
tg_ph_1 = tg_handler["tg_ph_1"]
tg_ph_2 = tg_handler["tg_ph_2"]
st.log("For debugging purpose, checking 'running config' before proceeding for module config")
utils.exec_all(True, [[sc_obj.get_running_config, vars.D1], [sc_obj.get_running_config, vars.D2]])
st.log("For debugging purpose, checking 'routing interfaces' before proceeding for module config")
utils.exec_all(True, [[ip_obj.get_interface_ip_address, vars.D1, None, "ipv6"], [ip_obj.get_interface_ip_address, vars.D2, None, "ipv6"]])
pc_obj.config_portchannel(vars.D1, vars.D2, data.prt_chnl, [vars.D1D2P3, vars.D1D2P4],
[vars.D2D1P3, vars.D2D1P4], config='add', thread=True)
st.log("Vlan config")
utils.exec_all(True, [[vlan_obj.create_vlan, vars.D1, [data.vlan_li[0], data.vlan_li[1]]],
[vlan_obj.create_vlan, vars.D2, [data.vlan_li[0], data.vlan_li[1]]]])
utils.exec_all(True, [
[vlan_mem_cfg, vars.D1, [[data.vlan_li[0], vars.D1D2P2, True], [data.vlan_li[1], vars.D1D2P2, True]]],
[vlan_mem_cfg, vars.D2, [[data.vlan_li[0], vars.D2D1P2, True], [data.vlan_li[1], vars.D2D1P2, True]]]])
st.log("VRF Config and binding 2nd vlan routing interface to that VRF")
vrf_obj.config_vrf(vars.D1, vrf_name=data.vrf_name, config='yes')
vrf_obj.bind_vrf_interface(vars.D1, vrf_name=data.vrf_name, intf_name=data.vlan_in_2, config='yes', skip_error=True)
st.log("Enabling ipv6 link local")
d1_int_ipv6_list =[vars.D1D2P1, data.vlan_in_1, data.vlan_in_2,data.prt_chnl]
d2_int_ipv6_list = [vars.D2D1P1, data.vlan_in_1, data.vlan_in_2, data.prt_chnl]
utils.exec_all(True, [[ip_obj.config_interface_ip6_link_local, vars.D1,d1_int_ipv6_list, 'enable'],
[ip_obj.config_interface_ip6_link_local, vars.D2,d2_int_ipv6_list, 'enable']])
st.log("TG connected int ipv6 address config")
utils.exec_all(True, [[ip_obj.config_ip_addr_interface, vars.D1, vars.D1T1P1, data.tgd_ip6_addr_l[0],
data.tg_ip6_addr_mask_l[0],"ipv6",'add'], [ip_obj.config_ip_addr_interface, vars.D2,
vars.D2T1P1, data.tgd_ip6_addr_l[1],
data.tg_ip6_addr_mask_l[1],"ipv6",'add']])
st.log("Get DUT mac address")
[rt_int_mac, exceptions] = utils.exec_all(True, [[basic_obj.get_ifconfig_ether, vars.D1, vars.D1D2P1],
[basic_obj.get_ifconfig_ether, vars.D2, vars.D2D1P1]])
utils.ensure_no_exception(exceptions)
dut1_rt_int_mac = rt_int_mac[0]
dut2_rt_int_mac = rt_int_mac[1]
st.log("Get DUT link local addresses")
[rt_link_local_addr, exceptions] = utils.exec_all(True, [[ip_obj.get_link_local_addresses, vars.D1, vars.D1D2P1],
[ip_obj.get_link_local_addresses, vars.D2, vars.D2D1P1]])
utils.ensure_no_exception(exceptions)
d1_prt_link_local = rt_link_local_addr[0]
d2_prt_link_local = rt_link_local_addr[1]
if not d1_prt_link_local or not d2_prt_link_local:
st.log("DUT Link Local Address are empty")
st.report_fail("link_local_address_not_found")
st.log("Routing interface config in TG")
tg_rt_int_handle = util_tg_routing_int_config(vars, tg1, tg2, tg_ph_1, tg_ph_2)
st.log("Doing ping to the TG ipv6 address to resolve the next hop")
utils.exec_all(True, [[ip_obj.ping, vars.D1, data.tgd_ip6_addr_l[0], 'ipv6'],[ip_obj.ping, vars.D2, data.tgd_ip6_addr_l[1], 'ipv6']])
st.log("Get show ndp output")
utils.exec_all(True, [[arp_obj.show_ndp, vars.D1, None],[arp_obj.show_ndp, vars.D2, None]])
st.log("Static route config")
utils.exec_all(True, [[ip_obj.create_static_route, vars.D1, d2_prt_link_local[0], data.static_rt, "vtysh", 'ipv6', vars.D1D2P1],
[ip_obj.create_static_route, vars.D2, data.tg_ip6_addr_l[1], data.static_rt, "vtysh", 'ipv6', vars.D2T1P1]])
ip_obj.create_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, "vtysh", 'ipv6', data.vlan_in_1)
ip_obj.create_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, "vtysh", 'ipv6', data.prt_chnl)
ip_obj.create_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, "vtysh", 'ipv6', data.vlan_in_2, vrf=data.vrf_name)
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]])
ip_obj.show_ip_route(vars.D1, "ipv6", "sonic", data.vrf_name)
st.log("TG Stream config")
tg_str_data = util_tg_stream_config(tg1, tg2, tg_ph_1, tg_ph_2)
st.log("Clearing all interface counters for debugging purpose")
utils.exec_all(True, [[intf_obj.clear_interface_counters, vars.D1], [intf_obj.clear_interface_counters, vars.D2]])
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 nat_pre_config():
global vars
vars = st.ensure_min_topology("D1T1:2")
platform = basic_obj.get_hwsku(vars.D1)
common_constants = st.get_datastore(vars.D1, "constants", "default")
if platform.lower() in common_constants['TH3_PLATFORMS']:
st.error("NAT is not supported for this platform {}".format(platform))
st.report_unsupported('NAT_unsupported_platform',platform)
global tg_handler, tg1, tg2, tg_ph_1, tg_ph_2, dut1_rt_int_mac, tg_str_data, tg_rt_int_handle
tg_handler = util_tg_init(vars, [vars.T1D1P1, vars.T1D1P2])
tg1 = tg_handler["tg"]
tg2 = tg_handler["tg"]
tg_ph_1 = tg_handler["tg_ph_1"]
tg_ph_2 = tg_handler["tg_ph_2"]
ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P1, data.in1_ip_addr, data.in1_ip_addr_mask, family=data.af_ipv4)
ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P2, data.out_ip_addr_l[0], data.out_ip_addr_mask, family=data.af_ipv4)
dut1_rt_int_mac = basic_obj.get_ifconfig_ether(vars.D1, vars.D1T1P1)
ip_obj.create_static_route(vars.D1, data.out_ip_addr_h,
"{}/{}".format(data.global_ip_addr_rt, data.global_ip_addr_mask),
shell=data.shell_vtysh, family=data.af_ipv4)
ip_obj.create_static_route(vars.D1, data.in1_ip_addr_h[0], "{}/{}".format(data.s_global_ip_rt, data.s_global_ip_mask))
tg_rt_int_handle = util_tg_routing_int_config(vars, tg1, tg2, tg_ph_1, tg_ph_2)
st.log("NAT Configuration")
nat_obj.config_nat_feature(vars.D1, 'enable')
util_nat_zone_config(vars, [vars.D1T1P1, vars.D1T1P2], [data.zone_1, data.zone_2], config=data.config_add)
nat_obj.config_nat_static(vars.D1, protocol=data.proto_all, global_ip=data.out_ip_addr_l[0],
local_ip=data.in1_ip_addr_h[0], config=data.config_add, nat_type=data.nat_type_dnat)
nat_obj.config_nat_static(vars.D1, protocol=data.proto_tcp, global_ip=data.out_ip_addr_l[1],
local_ip=data.in1_ip_addr_h[1],
local_port_id=data.tcp_src_local_port, global_port_id=data.tcp_src_global_port,
config=data.config_add, nat_type=data.nat_type_dnat)
nat_obj.config_nat_static(vars.D1, protocol=data.proto_udp, global_ip=data.in1_ip_addr_h[2],
local_ip=data.out_ip_addr_l[2],
local_port_id=data.udp_src_global_port, global_port_id=data.udp_src_local_port,
config=data.config_add, nat_type=data.nat_type_snat)
nat_obj.config_nat_static(vars.D1, protocol=data.proto_all, global_ip=data.s_global_ip, local_ip=data.s_local_ip,
config=data.config_add, nat_type=data.nat_type_snat)
nat_obj.config_nat_static(vars.D1,protocol=data.proto_all,global_ip=data.out_ip_addr_l[3],local_ip=data.in1_ip_addr_h[3],
config=data.config_add,nat_type=data.nat_type_dnat,twice_nat_id=data.twice_nat_id_1)
nat_obj.config_nat_static(vars.D1, protocol=data.proto_all, global_ip=data.global_ip_addr,
local_ip=data.test_ip_addr,
config=data.config_add, nat_type=data.nat_type_snat, twice_nat_id=data.twice_nat_id_1)
# dynamic NAT config
st.log("Creating NAT Pool-1")
nat_obj.config_nat_pool(vars.D1, pool_name=data.pool_name[0], global_ip_range=data.out_ip_range,
global_port_range= data.global_port_range, config=data.config_add)
nat_obj.config_nat_pool(vars.D1, pool_name="scale_pool", global_ip_range="125.56.90.23-125.56.90.30",
global_port_range="1001-8001", config=data.config_add)
st.log("Creating NAT Pool binding")
nat_obj.config_nat_pool_binding(vars.D1, binding_name=data.bind_name[0], pool_name=data.pool_name[0],
config=data.config_add)
st.log("Creating NAT Pool-2")
nat_obj.config_nat_pool(vars.D1, pool_name=data.pool_name[1], global_ip_range=data.out2_ip_range,
config=data.config_add)
st.log("Creating NAT Pool-2 binding")
nat_obj.config_nat_pool_binding(vars.D1, binding_name=data.bind_name[1], pool_name=data.pool_name[1],
config=data.config_add)
# nat acl for ingress traffic
acl_obj.create_acl_table(vars.D1, name=data.acl_table_in_nat_eg, stage="INGRESS", type=data.type,
description="ingress-acl", ports=[vars.D1T1P1])
acl_obj.create_acl_rule(vars.D1, table_name=data.acl_table_in_nat_eg, rule_name="rule-32", packet_action=data.packet_forward_action,
SRC_IP="{}/{}".format(data.in1_ip_addr_rt, data.in1_ip_addr_mask), priority='98', type=data.type, ip_protocol="4")
acl_obj.create_acl_rule(vars.D1, table_name=data.acl_table_in_nat_eg, rule_name="rule-33",
packet_action=data.packet_do_not_nat_action,
SRC_IP="{}/{}".format('14.1.0.1', data.mask), priority='97', type=data.type, ip_protocol="4")
# Checking arp table for debugging
arp_obj.show_arp(vars.D1)
ip_obj.show_ip_route(vars.D1)
# Clearing all interface counters for debugging purpose
intf_obj.clear_interface_counters(vars.D1)
tg_str_data = util_tg_stream_config(tg1, tg2, tg_ph_1, tg_ph_2)
def dut3_config(config=''):
st.log('On DUT3 physical interface IPv4 and IPv6 addresses on it')
vrf_obj.config_vrf(dut=data.dut3_client,
vrf_name=data.dut3_vrf_phy,
config='yes')
vrf_obj.bind_vrf_interface(dut=data.dut3_client,
vrf_name=data.dut3_vrf_phy,
intf_name=data.d3_d2_ports[0],
config='yes')
ip_obj.config_ip_addr_interface(data.dut3_client, data.d3_d2_ports[0],
data.dut3_dut2_ipv6[0],
data.dut3_dut2_ipv6_subnet, 'ipv6')
ip_obj.config_ip_addr_interface(data.dut3_client, data.d3_d2_ports[0],
data.dut3_dut2_ip[0],
data.dut3_dut2_ip_subnet, 'ipv4')
vlan_obj.create_vlan(data.dut3_client, data.dut2_dut3_vlan[0])
vlan_obj.add_vlan_member(data.dut3_client, data.dut2_dut3_vlan[0],
data.d3_d2_ports[1], True, True)
st.log('On DUT3 configure vlan and IPv4 and IPv6 addresses on it')
vrf_obj.config_vrf(dut=data.dut3_client,
vrf_name=data.dut3_vrf_vlan,
config='yes')
vrf_obj.bind_vrf_interface(dut=data.dut3_client,
vrf_name=data.dut3_vrf_vlan,
intf_name='Vlan' + data.dut2_dut3_vlan[0],
config='yes')
ip_obj.config_ip_addr_interface(data.dut3_client,
'Vlan' + data.dut2_dut3_vlan[0],
data.dut3_dut2_ipv6[1],
data.dut3_dut2_ipv6_subnet, 'ipv6')
ip_obj.config_ip_addr_interface(data.dut3_client,
'Vlan' + data.dut2_dut3_vlan[0],
data.dut3_dut2_ip[1],
data.dut3_dut2_ip_subnet, 'ipv4')
st.log('On DUT3 configure portchannel and IPv4 and IPv6 addresses on it')
pc_obj.create_portchannel(data.dut3_client, data.portchannel_2)
pc_obj.add_portchannel_member(data.dut3_client, data.portchannel_2,
[data.d3_d2_ports[2], data.d3_d2_ports[3]])
vrf_obj.config_vrf(dut=data.dut3_client,
vrf_name=data.dut3_vrf_pc,
config='yes')
vrf_obj.bind_vrf_interface(dut=data.dut3_client,
vrf_name=data.dut3_vrf_pc,
intf_name=data.portchannel_2,
config='yes')
ip_obj.config_ip_addr_interface(data.dut3_client, data.portchannel_2,
data.dut3_dut2_ipv6[2],
data.dut3_dut2_ipv6_subnet, 'ipv6')
ip_obj.config_ip_addr_interface(data.dut3_client, data.portchannel_2,
data.dut3_dut2_ip[2],
data.dut3_dut2_ip_subnet, 'ipv4')
st.log('On DUT3 configure loopback and IPv4 and IPv6 addresses on it')
ip_obj.configure_loopback(data.dut3_client,
config='yes',
loopback_name=data.dut3_loopback[1])
vrf_obj.config_vrf(dut=data.dut3_client,
vrf_name=data.dut3_vrf_phy,
config='yes')
vrf_obj.bind_vrf_interface(dut=data.dut3_client,
vrf_name=data.dut3_vrf_phy,
intf_name=data.dut3_loopback[1],
config='yes')
ip_obj.config_ip_addr_interface(data.dut3_client, data.dut3_loopback[1],
data.dut3_loopback_ipv6[1],
data.dut3_loopback_ipv6_subnet, 'ipv6')
ip_obj.config_ip_addr_interface(data.dut3_client, data.dut3_loopback[1],
data.dut3_loopback_ip[1],
data.dut3_loopback_ip_subnet, 'ipv4')
st.log('IPv4 and IPv6 static routes for loopback reachability')
ip_obj.create_static_route(data.dut3_client,
data.dut2_dut3_ip[0],
data.dut2_loopback_ip[1] + '/32',
family='ipv4',
interface=data.d3_d2_ports[0],
vrf=data.dut3_vrf_phy)
ip_obj.create_static_route(data.dut3_client,
data.dut2_dut3_ipv6[0],
data.dut2_loopback_ipv6[1] + '/128',
family='ipv6',
interface=data.d3_d2_ports[0],
vrf=data.dut3_vrf_phy)
return True
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 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")
def erspan_pre_config():
"""
Author: Anil Kumar Kacharla<*****@*****.**>
Using this pre config at module level. So, applicable for all test cases which includes in this module.
:return: None
"""
# IP address configuration on DUT-1
for port, ip_addr, in zip(data.port_list_d1, data.ip_list_d1):
ip.config_ip_addr_interface(data.dut1, port, ip_addr, data.subnet_mask)
# IP address configuration on DUT-2
for port, ip_addr in zip(data.port_list_d2, data.ip_list_d2):
ip.config_ip_addr_interface(data.dut2, port, ip_addr, data.subnet_mask)
# Create static route
_, network = ip.get_network_addr("{}/{}".format(data.ip_T1D2P1,
data.subnet_mask))
ip.create_static_route(data.dut1, data.ip_D2D1P1, network)
_, network = ip.get_network_addr("{}/{}".format(data.ip_T1D1P1,
data.subnet_mask))
ip.create_static_route(data.dut2, data.ip_D1D2P1, network)
# creation and verification of Monitor session
mirror.create_session(data.dut1,
session_name=data.session_name,
src_ip=data.ip_D1T1P1,
dst_ip=data.ip_T1D2P1,
gre_type=data.gre_type,
dscp=data.dscp,
ttl=data.ttl,
queue=data.queue)
# creation and verification of ACL policy
acl_dscp.config_policy_table(vars.D1,
enable='create',
policy_name=data.acl_table_name,
policy_type=data.type)
acl_dscp.config_service_policy_table(
vars.D1,
policy_kind="bind",
interface_name=vars.D1T1P1,
stage='in',
service_policy_name=data.acl_table_name,
policy_type=data.type)
# creation and verification of ACL classifier
acl_dscp.config_classifier_table(vars.D1,
enable='create',
match_type="fields",
class_name=data.acl_rule)
acl_dscp.config_classifier_table(data.dut1,
enable='yes',
class_criteria=['--src-ip'],
class_name=data.acl_rule,
criteria_value=[data.src_ip_mask],
match_type="fields")
acl_dscp.config_flow_update_table(data.dut1,
policy_name=data.acl_table_name,
flow='add',
class_name=data.acl_rule,
priority_value=data.priority,
description=data.description,
policy_type=data.type)
acl_dscp.config_flow_update_table(data.dut1,
policy_name=data.acl_table_name,
flow='update',
policy_type=data.type,
class_name=data.acl_rule,
priority_option='--mirror-session',
priority_value=data.mirror_action)
def l3_ecmp_scaling_tc(max_ecmp, use_config_file):
(dut) = (data.dut)
count = 0
#intf_ip_addr = data.start_ip_addr
#intf_ip_addr2 = data.start_ip_addr2
nexthop = data.nexthop_start_ip_addr
member3 = vars.D1T1P3
member4 = vars.D1T1P4
# L3 INTF SCALING TEST CASE 1.1 START
json_path = os.getcwd()
apply_file = False
if use_config_file is True:
apply_file = True
json_apply_path = json_path+"/routing/128_ecmp_config_db.json"
#frr_apply_path = json_path+"/routing/64_ecmp_sr_config.frr"
if apply_file is True:
st.apply_files(dut, [json_apply_path])
#st.apply_files(dut, [json_apply_path, frr_apply_path])
max_range = data.base_val+max_ecmp
base_range = data.base_val
if apply_file is False:
ipfeature.clear_ip_configuration(st.get_dut_names())
command = "config vlan add {}".format(data.vlan_val)
st.config(dut, command)
command = "config vlan member add {} {}".format(data.vlan_val, member3)
st.config(dut, command)
ip_addr = data.start_ip_addr
#command = "config interface ip add "+ "Vlan" + str(data.vlan_val) + " " + ip_addr+'/24'
command = "config interface ip add "+ "Vlan" + str(data.vlan_val) + " " + ip_addr
st.config(dut, command)
for index in range(base_range, max_range):
command = "config vlan add {}".format(index)
st.config(dut, command)
command = "config vlan member add {} {}".format(index, member3)
st.config(dut, command)
(_, ip_addr) = ipfeature.increment_ip_addr(ip_addr, "network")
command = "config interface ip add "+ "Vlan" + str(index) + " " + ip_addr
st.config(dut, command)
tg_vlan = 101
command = "config vlan member del {} {}".format(tg_vlan, member3)
st.config(dut, command)
command = "config vlan member add {} {}".format(tg_vlan, member4)
st.config(dut, command)
for index in range(base_range, max_range):
#vapi.add_member(dut, data.vlans[index], member, True)
(_, nexthop) = ipfeature.increment_ip_addr(nexthop, "network")
nexthop1 = nexthop
formatted_next_hop = nexthop1.replace("/32","")
ipfeature.create_static_route(dut, formatted_next_hop, data.static_route)
# L3 INTF SCALING TEST CASE 1.1 END
data.my_dut_list = st.get_dut_names()
dut1 = data.my_dut_list[0]
# 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()
#import pdb;pdb.set_trace()
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.2.101.10', gateway='10.2.101.1', count='8', gateway_step='0.0.1.0', netmask='255.255.255.0', vlan='1', vlan_id='101', vlan_id_count='8', intf_ip_addr_step='0.0.1.0', arp_send_req='1')
#h2=tg2.tg_interface_config(port_handle=tg_ph_2, mode='config', intf_ip_addr='10.2.109.10', gateway='10.2.109.1', count='8', gateway_step='0.0.1.0', netmask='255.255.255.0', vlan='1', vlan_id='109', vlan_id_count='7', intf_ip_addr_step='0.0.1.0', arp_send_req='1')
vid_count = max_ecmp-1
h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.2.102.10', gateway='10.2.102.1', src_mac_addr='00:0c:01:00:00:01', vlan='1', vlan_id='102', count=vid_count, arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0')
h2=tg1.tg_interface_config(port_handle=tg_ph_2, mode='config', intf_ip_addr='10.2.101.10', gateway='10.2.101.1', src_mac_addr='00:0d:01:00:00:01', vlan='1', vlan_id='101', arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0')
#h2=tg1.tg_interface_config(port_handle=tg_ph_2, mode='config', intf_ip_addr='10.2.109.10', gateway='10.2.109.1', src_mac_addr='00:0c:01:00:00:01', vlan='1', vlan_id='109', vlan_id_count='8', arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0')
h3=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.2.100.10', gateway='10.2.100.1', netmask='255.255.255.0', vlan='1', vlan_id='100', arp_send_req='1')
#tr1=tg1.tg_traffic_config(port_handle=tg_ph_1, emulation_src_handle=h3['handle'], ip_dst_addr='200.1.0.1', ip_dst_mode='increment', ip_dst_count='200', ip_dst_step='0.0.0.1', l3_protocol='ipv4', circuit_endpoint_type='ipv4', mode='create', transmit_mode='continuous', length_mode='fixed', rate_pps=512000, enable_stream_only_gen='1')
asicapi.dump_l3_egress(dut)
tr1=tg1.tg_traffic_config(port_handle=tg_ph_1, mac_src='00:11:01:00:00:01', mac_dst='b8:6a:97:fd:b6:06', ip_dst_mode='increment', ip_dst_count=200, ip_dst_step='0.0.0.1',ip_src_addr='10.2.100.10', ip_dst_addr='200.1.0.1', l3_protocol='ipv4', l2_encap='ethernet_ii_vlan', vlan_id='100', vlan='enable', mode='create', transmit_mode='continuous', length_mode='fixed', rate_pps=512000, enable_stream_only_gen='1')
tg2.tg_traffic_control(action='run', handle=tr1['stream_id'])
count = 0
#Port Counters
st.wait(20)
st.show(dut, "show arp")
#Port Counters
ret = check_intf_traffic_counters()
if ret is True:
count = count+1
st.log("Test Case 1.14 PASSED")
tg1.tg_interface_config(port_handle=tg_ph_2, handle=h2['handle'], mode='destroy')
h4=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.2.101.10', gateway='10.2.101.1', src_mac_addr='00:0e:01:00:00:01', vlan='1', vlan_id='101', arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0')
tg_vlan = 101
command = "config vlan member del {} {}".format(tg_vlan, member4)
st.config(dut, command)
command = "config vlan member add {} {}".format(tg_vlan, member3)
st.config(dut, command)
tg_intf_ip_addr = data.tg_start_ip_addr
max_range = data.base_val+max_ecmp
base_range = data.base_val+1
for index in range(base_range, max_range):
data.thresh = 4
command = "config vlan member del {} {}".format(index, member3)
st.config(dut, command)
command = "config vlan member add {} {}".format(index, member4)
st.config(dut, command)
(_, tg_intf_ip_addr) = ipfeature.increment_ip_addr(tg_intf_ip_addr, "network")
tg_intf_ip_addr_x = tg_intf_ip_addr;
tg_formatted_intf_addr = tg_intf_ip_addr_x.replace("/24","")
tg_formatted_gw_addr = tg_intf_ip_addr_x.replace("10/24","1")
#ping_formatted_gw_addr = tg_intf_ip_addr_x.replace("10/24","1")
tg_vlan=index
st.log("tg_vlan: "+str(tg_vlan))
st.log("tg_formatted_gw_addr: "+str(tg_formatted_gw_addr))
st.log("tg_formatted_intf_addr: "+str(tg_formatted_intf_addr))
h2=tg1.tg_interface_config(port_handle=tg_ph_2, mode='config', intf_ip_addr=tg_formatted_intf_addr, gateway=tg_formatted_gw_addr, src_mac_addr='00:0a:01:00:00:01', vlan='1', vlan_id=tg_vlan, vlan_id_count='1', arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0')
st.wait(3)
#output = st.show(dut, "show arp")
#Port Counters
ret = check_intf_traffic_counters()
if ret is True:
count = count+1
st.log("Test Case 1.14 PASSED")
else:
st.log('Traffic test Failed')
tg1.tg_interface_config(port_handle=tg_ph_2, handle=h2['handle'], mode='destroy')
command = "config vlan member del {} {}".format(index, member4)
st.config(dut, command)
command = "config vlan member add {} {}".format(index, member3)
st.config(dut, command)
#res1=verify_ping(src_obj=tg1, port_handle=tg_ph_1, dev_handle=h1['handle'], dst_ip=ping_formatted_gw_addr,\
# ping_count='6', exp_count='6')
#tg1.tg_traffic_config(mode='create', transmit_mode='continuous', length_mode='fixed', rate_pps=30,
# mac_src='00:00:00:00:00:01', mac_dst='00:00:00:00:00:02', ip_src_addr ='11.11.11.2',
# ip_dst_addr = '11.11.12.2')
tg2.tg_traffic_control(action='stop', handle=tr1['stream_id'])
asicapi.dump_l3_egress(dut)
tg1.tg_interface_config(port_handle=tg_ph_1, handle=h1['handle'], mode='destroy')
tg1.tg_interface_config(port_handle=tg_ph_1, handle=h3['handle'], mode='destroy')
tg1.tg_interface_config(port_handle=tg_ph_1, handle=h4['handle'], mode='destroy')
#import pdb;pdb.set_trace()
if use_config_file is True:
st.clear_config(dut1)
# This code will not be needed if apply_file is True as config gets cleared already
if apply_file is False:
ip_addr = data.start_ip_addr
base_range = data.base_val - 1
#max_range = data.base_val+max_ecmp-1
max_range = data.base_val+max_ecmp
for index in range(base_range, max_range):
command = "config interface ip remove "+ "Vlan" + str(index) + " " + ip_addr
st.config(dut, command)
command = "config vlan member del {} {}".format(index, member3)
st.config(dut, command)
command = "config vlan del {}".format(index)
st.config(dut, command)
(_, ip_addr) = ipfeature.increment_ip_addr(ip_addr, "network")
#del_vlan = max_range
#command = "config interface ip remove "+ "Vlan" + str(del_vlan) + " " + ip_addr
#st.config(dut, command)
#command = "config vlan member del {} {}".format(del_vlan, member4)
#st.config(dut, command)
#command = "config vlan del {}".format(del_vlan)
#st.config(dut, command)
ret = False
st.log("count: "+str(count))
if count >= data.thresh:
ret = True
st.log("Test Case PASSED")
else:
ret = False
st.log("Test Case FAILED")
st.log("operation_successful")
return ret
def acl_v4_module_hooks(request):
# initialize topology
initialize_topology()
# apply module configuration
apply_module_configuration()
acl_config1 = acl_data.acl_json_config_v4_l3_traffic
add_port_to_acl_table(acl_config1, 'L3_IPV4_INGRESS', vars.D1T1P1)
acl_config2 = acl_data.acl_json_config_v6_l3_traffic
add_port_to_acl_table(acl_config2, 'L3_IPV6_INGRESS', vars.D2T1P1)
# creating ACL tables and rules
print_log('Creating ACL tables and rules')
utils.exec_all(True, [
utils.ExecAllFunc(acl_obj.apply_acl_config, vars.D1, acl_config1),
utils.ExecAllFunc(acl_obj.apply_acl_config, vars.D2, acl_config2),
])
# create streams
data.mac1 = basic_obj.get_ifconfig_ether(vars.D1, vars.D1T1P1)
data.mac2 = basic_obj.get_ifconfig_ether(vars.D2, vars.D2T1P1)
print_log('Creating streams')
create_streams("tg1", "tg2", acl_config1['ACL_RULE'], "L3_IPV4_INGRESS", \
mac_src="00:0a:01:00:00:01", mac_dst=data.mac1)
create_streams("tg1", "tg2", acl_config2['ACL_RULE'], "L3_IPV6_EGRESS", \
mac_src="00:0a:01:00:00:01", mac_dst="00:0a:01:00:11:02")
create_streams("tg2", "tg1", acl_config2['ACL_RULE'], "L3_IPV6_INGRESS", \
mac_src="00:0a:01:00:11:02", mac_dst=data.mac2)
create_streams("tg2", "tg1", acl_config1['ACL_RULE'], "L3_IPV4_EGRESS", \
mac_src="00:0a:01:00:11:02", mac_dst="00:0a:01:00:00:01")
print_log('Completed module configuration')
st.log("Configuring ipv4 address on ixia connected interfaces and portchannels present on both the DUTs")
ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P1, data.ipv4_address_D1, 24, family="ipv4", config='add')
ip_obj.config_ip_addr_interface(vars.D2, vars.D2T1P1, data.ipv4_address_D2, 24, family="ipv4", config='add')
ip_obj.config_ip_addr_interface(vars.D1, data.portChannelName, data.ipv4_portchannel_D1, 24, family="ipv4",
config='add')
ip_obj.config_ip_addr_interface(vars.D2, data.portChannelName, data.ipv4_portchannel_D2, 24, family="ipv4",
config='add')
st.log("Configuring ipv6 address on ixia connected interfaces and portchannels present on both the DUTs")
ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P1, data.ipv6_address_D1, 64, family="ipv6", config='add')
ip_obj.config_ip_addr_interface(vars.D2, vars.D2T1P1, data.ipv6_address_D2, 64, family="ipv6", config='add')
ip_obj.config_ip_addr_interface(vars.D1, data.portChannelName, data.ipv6_portchannel_D1, 64, family="ipv6",
config='add')
ip_obj.config_ip_addr_interface(vars.D2, data.portChannelName, data.ipv6_portchannel_D2, 64, family="ipv6",
config='add')
st.log("configuring ipv4 static routes on both the DUTs")
ip_obj.create_static_route(vars.D1, data.ipv4_portchannel_D2, data.ipv4_network_D2, shell="vtysh",
family="ipv4")
ip_obj.create_static_route(vars.D2, data.ipv4_portchannel_D1, data.ipv4_network_D1, shell="vtysh",
family="ipv4")
st.log("configuring ipv6 static routes on both the DUTs")
ip_obj.create_static_route(vars.D1, data.ipv6_portchannel_D2, data.ipv6_network_D2, shell="vtysh",
family="ipv6")
ip_obj.create_static_route(vars.D2, data.ipv6_portchannel_D1, data.ipv6_network_D1, shell="vtysh",
family="ipv6")
st.log("configuring static arp entries")
arp_obj.add_static_arp(vars.D1, "1.1.1.2", "00:0a:01:00:00:01", vars.D1T1P1)
arp_obj.add_static_arp(vars.D2, "2.2.2.2", "00:0a:01:00:11:02", vars.D2T1P1)
arp_obj.add_static_arp(vars.D2, "2.2.2.4", "00:0a:01:00:11:02", vars.D2T1P1)
arp_obj.add_static_arp(vars.D1, "1.1.1.4", "00:0a:01:00:00:01", vars.D1T1P1)
arp_obj.add_static_arp(vars.D2, "2.2.2.5", "00:0a:01:00:11:02", vars.D2T1P1)
arp_obj.add_static_arp(vars.D1, "1.1.1.5", "00:0a:01:00:00:01", vars.D1T1P1)
arp_obj.add_static_arp(vars.D2, "2.2.2.6", "00:0a:01:00:11:02", vars.D2T1P1)
arp_obj.add_static_arp(vars.D1, "1.1.1.6", "00:0a:01:00:00:01", vars.D1T1P1)
arp_obj.show_arp(vars.D1)
arp_obj.show_arp(vars.D2)
st.log("configuring static ndp entries")
arp_obj.config_static_ndp(vars.D1, "1001::2", "00:0a:01:00:00:01", vars.D1T1P1, operation="add")
arp_obj.config_static_ndp(vars.D2, "2001::2", "00:0a:01:00:11:02", vars.D2T1P1, operation="add")
arp_obj.show_ndp(vars.D1)
arp_obj.show_ndp(vars.D2)
yield
clear_module_configuration()
def test_l3_ecmp_4paths_on_bo_tc():
(dut) = (data.dut)
#count = 0
#intf_ip_addr = data.start_ip_addr
#intf_ip_addr2 = data.start_ip_addr2
#nexthop = data.nexthop_start_ip_addr
nexthop = "10.2.101.10/32"
member1 = vars.D1T1P1
member2 = vars.D1T1P2
member3 = vars.D1T1P3
member4 = vars.D1T1P4
apply_file = False
ipfeature.clear_ip_configuration([dut])
max_range = data.base_val+4
base_range = data.base_val-1
if apply_file is False:
command = "config vlan range add 100 105"
st.config(dut, command)
command = "config vlan member add 100 {}".format(member4)
st.config(dut, command)
command = "config vlan member add 101 {}".format(member1)
st.config(dut, command)
command = "config vlan member add 102 {}".format(member2)
st.config(dut, command)
command = "config vlan member add 103 {}".format(member3)
st.config(dut, command)
command = "config vlan member add 104 {}".format(member4)
st.config(dut, command)
#ip_addr = data.start_ip_addr
ip_addr = "10.2.100.1/24"
for index in range(base_range, max_range):
command = "config interface ip add "+ "Vlan" + str(index) + " " + ip_addr
st.config(dut, command)
(_, ip_addr) = ipfeature.increment_ip_addr(ip_addr, "network")
base_range = data.base_val
max_range = data.base_val+3
for index in range(base_range, max_range):
(_, nexthop) = ipfeature.increment_ip_addr(nexthop, "network")
nexthop1 = nexthop
formatted_next_hop = nexthop1.replace("/32","")
ipfeature.create_static_route(dut, formatted_next_hop, data.static_route)
data.my_dut_list = st.get_dut_names()
#dut1 = data.my_dut_list[0]
(tg1, tg_ph_1, tg2, tg_ph_2, tg3, tg_ph_3, tg4, tg_ph_4) = get_handles_1()
tg1.tg_traffic_control(action='reset',port_handle=tg_ph_1)
tg2.tg_traffic_control(action='reset',port_handle=tg_ph_2)
tg2.tg_traffic_control(action='reset',port_handle=tg_ph_3)
tg2.tg_traffic_control(action='reset',port_handle=tg_ph_4)
h0=tg4.tg_interface_config(port_handle=tg_ph_4, mode='config',
intf_ip_addr='10.2.100.10', gateway='10.2.100.1',
src_mac_addr='00:0d:01:00:00:01', vlan='1', vlan_id='100',
arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0')
h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config',
intf_ip_addr='10.2.101.10', gateway='10.2.101.1',
src_mac_addr='00:0d:02:00:00:01', vlan='1', vlan_id='101',
arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0')
h2=tg2.tg_interface_config(port_handle=tg_ph_2, mode='config',
intf_ip_addr='10.2.102.10', gateway='10.2.102.1',
src_mac_addr='00:0c:01:00:00:01', vlan='1', vlan_id='102',
arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0')
h3=tg3.tg_interface_config(port_handle=tg_ph_3, mode='config',
intf_ip_addr='10.2.103.10', gateway='10.2.103.1',
src_mac_addr='00:0c:02:00:00:01', vlan='1', vlan_id='103',
arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0')
h4=tg4.tg_interface_config(port_handle=tg_ph_4, mode='config',
intf_ip_addr='10.2.104.10', gateway='10.2.104.1',
src_mac_addr='00:0a:02:00:00:01', vlan='1', vlan_id='104',
arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0')
mac_eth = macapi.get_sbin_intf_mac(vars.D1,'eth0')
tr1=tg4.tg_traffic_config(port_handle=tg_ph_4, mac_src='00:11:01:00:00:01',
mac_dst=mac_eth, ip_dst_mode='increment', ip_dst_count=200,
ip_dst_step='0.0.0.1',ip_src_addr='10.2.100.10', ip_dst_addr='200.1.0.1',
l3_protocol='ipv4', l2_encap='ethernet_ii_vlan', vlan_id='100',
vlan='enable', mode='create', transmit_mode='continuous', length_mode='fixed',
rate_pps=512000, enable_stream_only_gen='1')
tg2.tg_traffic_control(action='run', handle=tr1['stream_id'])
#count = 0
#Port Counters
st.wait(20)
st.show(dut, "show arp")
#Port Counters
ret = check_intf_traffic_bo_counters()
if ret is True:
st.log("Test Case PASSED")
tg2.tg_traffic_control(action='stop', handle=tr1['stream_id'])
tg1.tg_interface_config(port_handle=tg_ph_1, handle=h0['handle'], mode='destroy')
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')
tg3.tg_interface_config(port_handle=tg_ph_3, handle=h3['handle'], mode='destroy')
tg4.tg_interface_config(port_handle=tg_ph_4, handle=h4['handle'], mode='destroy')
if apply_file is False:
base_range = data.base_val-1
ip_addr = data.start_ip_addr
max_range = data.base_val+4
for index in range(base_range, max_range):
command = "config interface ip remove "+ "Vlan" + str(index) + " " + ip_addr
st.config(dut, command)
(_, ip_addr) = ipfeature.increment_ip_addr(ip_addr, "network")
command = "config vlan member del 100 {}".format(member4)
st.config(dut, command)
command = "config vlan member del 101 {}".format(member1)
st.config(dut, command)
command = "config vlan member del 102 {}".format(member2)
st.config(dut, command)
command = "config vlan member del 103 {}".format(member3)
st.config(dut, command)
command = "config vlan member del 104 {}".format(member4)
st.config(dut, command)
command = "config vlan range del 100 105"
st.config(dut, command)
if ret is True:
st.log("Test Case PASSED")
st.report_pass("operation_successful")
else:
st.log("Test Case FAILED")
st.report_fail("operation_failed")
