def ipv6_bgp_config(dut):
st.log("Creating the eBGP ipv6 neighbors", dut=dut)
if dut == vars.D1:
bgp_obj.create_bgp_router(vars.D1, data.local_asn4, data.router_id_1)
bgp_obj.config_address_family_redistribute(vars.D1, data.local_asn4,
data.af_ipv6, "unicast",
"connected")
bgp_obj.create_bgp_neighbor(dut=vars.D1,
local_asn=data.local_asn4,
neighbor_ip=data.neigh_ip6_addr,
remote_asn=data.remote_asn4,
family=data.af_ipv6)
else:
bgp_obj.create_bgp_router(vars.D2, data.remote_asn4, data.router_id_2)
bgp_obj.config_address_family_redistribute(vars.D2, data.remote_asn4,
data.af_ipv6, "unicast",
"connected")
bgp_obj.create_bgp_neighbor(dut=vars.D2,
local_asn=data.remote_asn4,
neighbor_ip=data.local_ip6_addr,
remote_asn=data.local_asn4,
family=data.af_ipv6)
if dut == vars.D1:
st.log("Creating the iBGP ipv6 neighbors with TG2", dut=dut)
bgp_obj.create_bgp_router(vars.D1, data.local_asn4, data.router_id_1)
bgp_obj.create_bgp_neighbor(dut=vars.D1,
local_asn=data.local_asn4,
neighbor_ip='2001::100',
remote_asn=data.local_asn4,
family=data.af_ipv6)
def ipv4_bgp_config():
st.log("Creating the eBGP ipv4 neighbors in {}".format(vars.D1))
bgp_obj.create_bgp_router(vars.D1, data.local_asn4, data.router_id_1)
bgp_obj.config_address_family_redistribute(vars.D1, data.local_asn4,
data.af_ipv4, "unicast",
"connected")
bgp_obj.create_bgp_neighbor(dut=vars.D1,
local_asn=data.local_asn4,
neighbor_ip=data.neigh_ip_addr,
remote_asn=data.remote_asn4,
family=data.af_ipv4)
st.log("Creating the eBGP ipv4 neighbors in {}".format(vars.D2))
bgp_obj.create_bgp_router(vars.D2, data.remote_asn4, data.router_id_2)
bgp_obj.config_address_family_redistribute(vars.D2, data.remote_asn4,
data.af_ipv4, "unicast",
"connected")
bgp_obj.create_bgp_neighbor(dut=vars.D2,
local_asn=data.remote_asn4,
neighbor_ip=data.local_ip_addr,
remote_asn=data.local_asn4,
family=data.af_ipv4)
st.log("Creating the iBGP ipv4 neighbors with TG1 {}".format(vars.D1T1P1))
bgp_obj.create_bgp_router(vars.D1, data.local_asn4, data.router_id_1)
bgp_obj.config_address_family_redistribute(vars.D1, data.local_asn4,
data.af_ipv4, "unicast",
"connected")
bgp_obj.create_bgp_neighbor(dut=vars.D1,
local_asn=data.local_asn4,
neighbor_ip=data.t1d1_ip_addr,
remote_asn=data.local_asn4,
family=data.af_ipv4)
def dut_bgpv6(local_asn, remote_asn, data=[]):
st.log("Creating the ipv6 routing interfaces in {}".format(vars.D1))
ipfeature.config_ip_addr_interface(data.D1,
data.dut_p2_interface,
data.dut_p2_ipaddr,
data.dut_p2_ipaddr_subnet,
family="ipv6")
if not ipfeature.verify_interface_ip_address(
data.D1,
data.dut_p2_interface,
data.dut_p2_ipaddr + '/' + str(data.dut_p2_ipaddr_subnet),
family="ipv6"):
st.report_fail('ip6_routing_int_create_fail', data.dut_p2_ipaddr)
bgp_obj.create_bgp_router(data.D1, data.local_asn, data.router_id_1)
bgp_obj.create_bgp_neighbor(dut=data.D1,
local_asn=data.local_asn,
neighbor_ip=data.dut_p2_ipaddr_peer,
remote_asn=data.remote_asn,
family="ipv6")
st.log("Waiting for the ecrm_bgp_config_v6 neighbors to get Established")
st.wait(10)
def bgp_warm_reboot_module_hooks(request):
global vars, tg_handler, tg, dut, ctrl_start, ctrl_stop
global dut_to_tg_port_1, dut_to_tg_port_2, hwsku_under_test
initialize_variables()
vars = st.ensure_min_topology("D1T1:2")
# Initialize TG and TG port handlers
tg_handler = tgapi.get_handles(vars, [vars.T1D1P1, vars.T1D1P2])
tg = tg_handler["tg"]
ctrl_start = {'mode': 'start'}
ctrl_stop = {'mode': 'stop'}
# Test setup details
dut = vars.D1
dut_to_tg_port_1 = vars.D1T1P1
dut_to_tg_port_2 = vars.D1T1P2
hwsku_under_test = basic_obj.get_hwsku(dut)
# Configuring v4/v6 routing interfaces on the DUT.
ipfeature.clear_ip_configuration(st.get_dut_names())
ipfeature.clear_ip_configuration(st.get_dut_names(), 'ipv6')
ipfeature.config_ip_addr_interface(dut,
dut_to_tg_port_1,
data.my_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.config_ip_addr_interface(dut,
dut_to_tg_port_1,
data.my_ipv6_addr,
data.ipv6_prefixlen,
family="ipv6")
ipfeature.config_ip_addr_interface(dut,
dut_to_tg_port_2,
data.intf_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.config_ip_addr_interface(dut,
dut_to_tg_port_2,
data.intf_ipv6_addr,
data.ipv6_prefixlen,
family="ipv6")
# Configuring BGP router and v4/v6 neighbors on the DUT.
bgpfeature.create_bgp_router(dut, data.as_num, '')
bgpfeature.create_bgp_neighbor(dut, data.as_num, data.neigh_ip_addr,
data.remote_as_num)
bgpfeature.create_bgp_neighbor(dut,
data.as_num,
data.neigh_ipv6_addr,
data.remote_as_num,
family="ipv6")
yield
st.log("L3 Performance Enhancements Module Cleanup.")
ipfeature.delete_ip_interface(dut,
dut_to_tg_port_1,
data.my_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.delete_ip_interface(dut,
dut_to_tg_port_1,
data.my_ipv6_addr,
data.ipv6_prefixlen,
family="ipv6")
ipfeature.delete_ip_interface(dut,
dut_to_tg_port_2,
data.intf_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.delete_ip_interface(dut,
dut_to_tg_port_2,
data.intf_ipv6_addr,
data.ipv6_prefixlen,
family="ipv6")
bgpfeature.delete_bgp_neighbor(dut, data.as_num, data.neigh_ip_addr,
data.remote_as_num)
bgpfeature.delete_bgp_neighbor(dut, data.as_num, data.neigh_ipv6_addr,
data.remote_as_num)
bgpfeature.cleanup_router_bgp(dut)
def create_v6_route(route_count):
vars = st.get_testbed_vars()
dut = vars.D1
ipfeature.show_ip_route(dut, family='ipv6')
ipfeature.get_interface_ip_address(dut, family='ipv6')
bgpfeature.create_bgp_router(dut, data.as_num, '')
bgpfeature.create_bgp_neighbor(dut,
data.as_num,
data.ip6_addr[0],
data.remote_as_num,
family="ipv6")
create_bgp_neighbor_route_map_config(dut, data.as_num, data.ip6_addr[0],
data.routemap)
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.D1T1P1)
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.")
bgp_conf = tg.tg_emulation_bgp_config(handle=h1['handle'],
mode='enable',
ip_version='6',
active_connect_enable='1',
local_as=data.as_num,
remote_as=data.remote_as_num,
remote_ipv6_addr=data.ip6_addr[1])
tg.tg_emulation_bgp_route_config(handle=bgp_conf['handle'],
mode='add',
ip_version='6',
num_routes=route_count,
prefix='3300:1::',
as_path='as_seq:1')
tg.tg_emulation_bgp_control(handle=bgp_conf['handle'], mode='start')
# Configuring the BGP router.
st.log("BGP neighborship established.")
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:
return False
else:
return True
def create_v4_route(route_count):
vars = st.get_testbed_vars()
dut = vars.D1
ipfeature.show_ip_route(dut)
ipfeature.get_interface_ip_address(dut)
intf_obj.interface_status_show(dut)
bgpfeature.create_bgp_router(dut, data.as_num, '')
bgpfeature.create_bgp_neighbor(dut, data.as_num, data.ip4_addr[0],
data.remote_as_num)
tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D2P1")
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.D1T1P1)
h1 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_1"], mode='config', intf_ip_addr=data.ip4_addr[0], \
gateway=data.ip4_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', intf_ip_addr=data.ip4_addr[9], \
gateway=data.ip4_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.ip4_addr[1], \
ping_count='1', exp_count='1')
if res:
st.log("Ping succeeded.")
else:
st.warn("Ping failed.")
conf_var = {
'mode': 'enable',
'active_connect_enable': '1',
'local_as': '200',
'remote_as': '100',
'remote_ip_addr': data.ip4_addr[1]
}
route_var = {
'mode': 'add',
'num_routes': route_count,
'prefix': '121.1.1.0',
'as_path': 'as_seq:1'
}
ctrl_start = {'mode': 'start'}
# Configuring the BGP router.
bgp_rtr1 = tgapi.tg_bgp_config(tg=tg,
handle=h1['handle'],
conf_var=conf_var,
route_var=route_var,
ctrl_var=ctrl_start)
st.log("BGP_HANDLE: " + str(bgp_rtr1))
st.log(
"waiting for 10 sec to get the BGP neighbor started before going for another TG operation"
)
st.wait(10)
# Verified at neighbor.
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='ipv4', mac_src=data.tg_mac1, \
mac_dst=dut_rt_int_mac1, ip_src_addr=data.ip4_addr[0],
ip_dst_addr=data.ip4_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.T1D1P1],
'tx_obj': [tg_handler["tg"]],
'exp_ratio': [1],
'rx_ports': [vars.T1D2P1],
'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:
return False
return True
def l3_max_route_max_path_scaling_tc(max_paths, max_routes, use_config_file, family="ipv4"):
(dut) = (data.dut)
#count = 0
data.my_dut_list = st.get_dut_names()
dut1 = data.my_dut_list[0]
dut2 = data.my_dut_list[1]
#intf_ip_addr = data.dut1_start_ip_addr
#intf_ip_addr2 = data.start_ip_addr2
#nexthop = data.nexthop_start_ip_addr
vrf_flag = False
member_dut1 = vars.D1T1P1
member_dut2 = vars.D2T1P1
# L3 INTF SCALING TEST CASE 1.1 START
#json_path = os.getcwd()
apply_file = False
if apply_file is False:
ipfeature.clear_ip_configuration(st.get_dut_names())
vapi.clear_vlan_configuration(st.get_dut_names())
st.banner("Started doing the needed config.")
cmd = "config vlan range add 2 129"
st.config(dut, cmd)
st.config(dut2, cmd)
command = "config vlan member add 2 {}".format(member_dut1)
st.config(dut, command)
command = "config vlan member add 2 {}".format(member_dut2)
st.config(dut2, command)
max_vlan = max_paths/4
base_vlan = 3
max_vlan = max_vlan - base_vlan
v_range_t = str(base_vlan) + " " + str(base_vlan + max_vlan )
vapi.config_vlan_range_members(dut1, v_range_t, data.dut1_ports[0])
vapi.config_vlan_range_members(dut2, v_range_t, data.dut2_ports[0])
base_range = 1
max_range = 4
max_vlan = max_paths/4
incr_vlan = max_paths/4
for index in range(base_range, max_range):
base_vlan = max_vlan + 1
max_vlan = max_vlan + incr_vlan
#max_vlan = max_vlan + 32
v_range_t = str(base_vlan) + " " + str(max_vlan)
vapi.config_vlan_range_members(dut1, v_range_t, data.dut1_ports[index])
vapi.config_vlan_range_members(dut2, v_range_t, data.dut2_ports[index])
ip_addr = data.dut1_start_ip_addr
ip_addr2 = data.dut2_start_ip_addr
v6_ip_addr = data.v6_start_ip_addr
v6_ip_addr2 = data.v6_new_dut2_start_ip_addr
ix_vlan_val = 2
#command = "config interface ip add "+ "Vlan" + str(data.vlan_val) + " " + ip_addr+'/24'
if family == "ipv4":
command1 = "config interface ip add "+ "Vlan" + str(ix_vlan_val) + " " + ip_addr
command2 = "config interface ip add "+ "Vlan" + str(ix_vlan_val) + " " + ip_addr2
else:
command1 = "config interface ip add "+ "Vlan" + str(ix_vlan_val) + " " + v6_ip_addr
command2 = "config interface ip add "+ "Vlan" + str(ix_vlan_val) + " " + v6_ip_addr2
st.config(dut1, command1)
st.config(dut2, command2)
ip_addr2 = data.dut2_start_ip_addr
base_vlan = 3
max_vlan = max_paths + 1
#max_vlan = 130
for index in range(base_vlan, max_vlan):
if family == "ipv4":
(_, ip_addr) = ipfeature.increment_ip_addr(ip_addr, "network")
(_, ip_addr2) = ipfeature.increment_ip_addr(ip_addr2, "network")
command = "config interface ip add "+ "Vlan" + str(index) + " " + ip_addr
command_dut2 = "config interface ip add "+ "Vlan" + str(index) + " " + ip_addr2
else:
v6_tok = str(hex(index)[2:])
v6_ip_addr = "2100:0:" + v6_tok + "::1/64"
v6_ip_addr2 = "2100:0:" + v6_tok + "::2/64"
command = "config interface ip add "+ "Vlan" + str(index) + " " + v6_ip_addr
command_dut2 = "config interface ip add "+ "Vlan" + str(index) + " " + v6_ip_addr2
st.config(dut, command)
st.config(dut2, command_dut2)
(tg1, tg_ph_1, tg2, tg_ph_2) = get_handles_2()
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.2.2', gateway='10.2.2.1', arp_send_req='1')
#h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.2.2.2', gateway='10.2.2.1', src_mac_addr='00:0a:01:00:00:01', vlan='1', vlan_id='2', arp_send_req='1', gateway_step='0.0.1.0', intf_ip_addr_step='0.0.1.0', vlan_id_step='1')
if family == "ipv4":
h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr='10.2.2.3',
gateway='10.2.2.1', src_mac_addr='00:0a:01:00:00:01', vlan='1', vlan_id='2', arp_send_req='1')
arp_obj.show_arp(dut)
h2=tg1.tg_interface_config(port_handle=tg_ph_2, mode='config', intf_ip_addr='10.2.2.4',
gateway='10.2.2.2', src_mac_addr='00:0b:01:00:00:01', vlan='1', vlan_id='2', arp_send_req='1')
arp_obj.show_arp(dut2)
else:
h1=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', ipv6_intf_addr='2100:0:2::3',
ipv6_gateway='2100:0:2::1', src_mac_addr='00:0a:01:00:00:01', vlan='1', vlan_id='2', arp_send_req='1')
st.show(dut, "show ndp")
arp_obj.show_arp(dut)
h2=tg1.tg_interface_config(port_handle=tg_ph_2, mode='config', ipv6_intf_addr='2200:0:2::4',
ipv6_gateway='2200:0:2::2', src_mac_addr='00:0b:01:00:00:01', vlan='1', vlan_id='2', arp_send_req='1')
st.show(dut2, "show ndp")
arp_obj.show_arp(dut2)
if family == "ipv4":
bgpfeature.create_bgp_router(dut, data.as_num, '')
bgpfeature.create_bgp_router(dut2, data.new_as_num, '')
dut1_neigh_ip_addr = data.neigh_ip_addr
dut2_neigh_ip_addr = data.dut1_start_ip_addr
#formatted_dut1_neigh_ip_addr = dut1_neigh_ip_addr.replace("/24","")
#formatted_dut2_neigh_ip_addr = dut2_neigh_ip_addr.replace("/24","")
formatted_dut1_neigh_ip_addr = "10.2.2.3"
bgpfeature.create_bgp_neighbor(dut, data.as_num, formatted_dut1_neigh_ip_addr, data.remote_as_num)
(_, dut1_neigh_ip_addr) = ipfeature.increment_ip_addr(dut1_neigh_ip_addr, "network")
(_, dut2_neigh_ip_addr) = ipfeature.increment_ip_addr(dut2_neigh_ip_addr, "network")
base_vlan = 3
max_vlan = max_paths + 1
#max_vlan = 130
# The below neighbor config is for inter dut links ibgp
for index in range(base_vlan, max_vlan):
formatted_dut1_neigh_ip_addr = dut1_neigh_ip_addr.replace("/24","")
bgpfeature.create_bgp_neighbor(dut, data.as_num, formatted_dut1_neigh_ip_addr, data.new_as_num)
(_, dut1_neigh_ip_addr) = ipfeature.increment_ip_addr(dut1_neigh_ip_addr, "network")
formatted_dut2_neigh_ip_addr = dut2_neigh_ip_addr.replace("/24","")
bgpfeature.create_bgp_neighbor(dut2, data.new_as_num, formatted_dut2_neigh_ip_addr, data.as_num)
(_, dut2_neigh_ip_addr) = ipfeature.increment_ip_addr(dut2_neigh_ip_addr, "network")
conf_var = { 'mode' : 'enable',
'active_connect_enable' : '1',
'local_as' : '200',
'remote_as' : '100',
'remote_ip_addr' : '10.2.2.1'
}
max_route_str = str(max_routes)
route_var = { 'mode' : 'add',
'num_routes' : max_route_str,
'prefix' : '121.1.1.0',
'as_path' : 'as_seq:1'
}
#'num_routes' : '30000',
ctrl_start = { 'mode' : 'start'}
ctrl_stop = { 'mode' : 'stop'}
# Configuring the BGP router.
bgp_rtr1 = tgapi.tg_bgp_config(tg = tg1,
handle = h1['handle'],
conf_var = conf_var,
route_var = route_var,
ctrl_var = ctrl_start)
st.log("BGP_HANDLE: "+str(bgp_rtr1))
# Verified at neighbor.
st.log("BGP neighborship established.")
st.wait(10)
def f1(d):
st.show(d, "show bgp ipv4 summary", type='vtysh')
st.show(d, "show interface status")
st.show(d, "show ip route | head -1000")
arp_obj.show_arp(d)
st.banner("ARP entries before traffic is initiated on Dut1 and Dut2")
st.exec_each([dut, dut2], f1)
#Port Counters
tr1=tg2.tg_traffic_config(port_handle=tg_ph_2, emulation_src_handle=h2['handle'], emulation_dst_handle=bgp_rtr1['route'][0]['handle'], circuit_endpoint_type='ipv4', mode='create', transmit_mode='continuous', length_mode='fixed', rate_pps=512000, enable_stream_only_gen='0')
else:
v6_dut1_neigh_ip_addr = "2100:0:2::3"
create_bgp_neighbor_route_map_config(dut, data.as_num, v6_dut1_neigh_ip_addr, data.routemap, vrf_flag)
create_bgp_neighbor_route_map_config(dut2, data.new_as_num, v6_dut1_neigh_ip_addr, data.routemap, vrf_flag)
bgpfeature.create_bgp_router(dut, data.as_num, '')
create_bgp_neighbor_config(dut, data.as_num, v6_dut1_neigh_ip_addr, data.remote_as_num, data.routemap)
#link_bgp_neighbor_to_routemap(dut, data.as_num, v6_dut1_neigh_ip_addr, data.routemap, vrf_flag)
bgpfeature.create_bgp_router(dut2, data.new_as_num, '')
base_vlan = 3
max_vlan = max_paths + 1
for index in range(base_vlan, max_vlan):
v6_tok = str(hex(index)[2:])
v6_dut1_neigh_ip_addr = "2100:0:" + v6_tok + "::2"
v6_dut2_neigh_ip_addr2 = "2100:0:" + v6_tok + "::1"
create_bgp_neighbor_config(dut, data.as_num, v6_dut1_neigh_ip_addr, data.new_as_num, data.routemap)
create_bgp_neighbor_config(dut2, data.new_as_num, v6_dut2_neigh_ip_addr2, data.as_num, data.routemap)
#bgpfeature.create_bgp_neighbor(dut, data.as_num, v6_dut1_neigh_ip_addr, data.new_as_num, family="ipv6")
#bgpfeature.create_bgp_neighbor(dut2, data.new_as_num, v6_dut2_neigh_ip_addr2, data.as_num, family="ipv6")
bgp_conf=tg2.tg_emulation_bgp_config(handle=h1['handle'], mode='enable', ip_version='6',
active_connect_enable='1', local_as='200', remote_as='100', remote_ipv6_addr='2100:0:2::1')
max_route_str = str(max_routes)
bgp_route=tg2.tg_emulation_bgp_route_config(handle=bgp_conf['handle'], mode='add', ip_version='6',
num_routes=max_route_str, prefix='3300:0:0:2::1', as_path='as_seq:1')
tg2.tg_emulation_bgp_control(handle=bgp_conf['handle'], mode='start')
def f1(d):
st.show(d, "show run bgp")
st.show(d, "show ndp")
st.show(d, "show bgp ipv6 summary", type='vtysh')
st.show(d, "show ipv6 route | head -1000")
arp_obj.show_arp(d)
st.banner("ARP entries before traffic is initiated on Dut1 and Dut2")
st.exec_each([dut, dut2], f1)
tr1=tg2.tg_traffic_config(port_handle=tg_ph_2, emulation_src_handle=h2['handle'],
emulation_dst_handle=bgp_route['handle'], circuit_endpoint_type='ipv6', mode='create',
transmit_mode='continuous', length_mode='fixed', rate_pps=512000, enable_stream_only_gen='0')
#tr1=tg1.tg_traffic_config(port_handle=tg_ph_2, mac_src='00:11:01:00:00:01', mac_dst='80:a2:35:97:eb:c1',
# ipv6_dst_mode='increment', ipv6_dst_count=200, ipv6_dst_step='::1',ipv6_src_addr='2200:0:2::5',
# ipv6_dst_addr='3300:0:0:2::1', l3_protocol='ipv6', l2_encap='ethernet_ii_vlan', vlan_id='2',
# 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'])
ret1 = check_inter_dut_intf_traffic_counters()
ret2 = check_end_to_end_intf_traffic_counters()
tg2.tg_traffic_control(action='stop', handle=tr1['stream_id'])
st.banner("ARP entries in both DUT's after traffic is stopped")
st.exec_each([dut, dut2], arp_obj.show_arp)
tg1.tg_traffic_control(action='reset',port_handle=tg_ph_2)
if family == "ipv4":
tgapi.tg_bgp_config(tg = tg1, handle = bgp_rtr1['conf']['handle'], ctrl_var=ctrl_stop)
else:
tg1.tg_emulation_bgp_control(handle=bgp_conf['handle'], mode='stop')
tg1.tg_interface_config(port_handle=tg_ph_1, handle=h1['handle'], mode='destroy')
tg1.tg_interface_config(port_handle=tg_ph_2, handle=h2['handle'], mode='destroy')
#import pdb;pdb.set_trace()
if apply_file is False:
ip_addr = data.dut1_start_ip_addr
ip_addr2 = data.dut2_start_ip_addr
st.log("Un-Config previously config")
base_range = 2
max_range = max_paths + 1
for index in range(base_range, max_range):
if family == "ipv4":
command1 = "config interface ip remove "+ "Vlan" + str(index) + " " + ip_addr
command2 = "config interface ip remove "+ "Vlan" + str(index) + " " + ip_addr2
(_, ip_addr) = ipfeature.increment_ip_addr(ip_addr, "network")
(_, ip_addr2) = ipfeature.increment_ip_addr(ip_addr2, "network")
else:
v6_tok = str(hex(index)[2:])
if index == 2:
v6_ip_addr2 = "2200:0:" + v6_tok + "::2/64"
else:
v6_ip_addr2 = "2100:0:" + v6_tok + "::2/64"
v6_ip_addr = "2100:0:" + v6_tok + "::1/64"
command1 = "config interface ip remove "+ "Vlan" + str(index) + " " + v6_ip_addr
command2 = "config interface ip remove "+ "Vlan" + str(index) + " " + v6_ip_addr2
st.config(dut, command1)
st.config(dut2, command2)
max_vlan = max_paths/4
base_vlan = 3
max_vlan = max_vlan - base_vlan
v_range_t = str(base_vlan) + " " + str(base_vlan + max_vlan )
vapi.config_vlan_range_members(dut1, v_range_t, data.dut1_ports[0], config='del')
vapi.config_vlan_range_members(dut2, v_range_t, data.dut2_ports[0], config='del')
base_range = 1
max_range = 4
max_vlan = max_paths/4
incr_vlan = max_paths/4
for index in range(base_range, max_range):
base_vlan = max_vlan + 1
#max_vlan = max_vlan + 32
max_vlan = max_vlan + incr_vlan
v_range_t = str(base_vlan) + " " + str(max_vlan)
vapi.config_vlan_range_members(dut1, v_range_t, data.dut1_ports[index], config='del')
vapi.config_vlan_range_members(dut2, v_range_t, data.dut2_ports[index], config='del')
cmd = "config vlan range del 2 129"
st.config(dut, cmd)
my_cmd = "no router bgp {}".format(data.as_num)
st.vtysh_config(dut, my_cmd)
my_cmd = "no router bgp {}".format(data.new_as_num)
st.vtysh_config(dut2, my_cmd)
st.debug("ret1: {} , ret2: {}".format(ret1, ret2))
if ret1 is True and ret2 is True:
ret = True
st.log("Test Case PASSED")
else:
ret = False
st.log("Test Case FAILED")
st.log("operation_successful")
return ret
def measure_v4_route_scale_time(route_count, show_flag):
vars = st.get_testbed_vars()
dut = vars.D1
default_route = 0
#TG pumps 512k per sec so to make measure route install
#time more accurate we start from 600k + route_count
#base_route_count = 60000 + route_count
base_route_count = route_count
ipfeature.clear_ip_configuration(st.get_dut_names())
ipfeature.clear_ip_configuration(st.get_dut_names(), 'ipv6')
member3 = vars.D1T1P1
member4 = vars.D1T1P2
ipfeature.config_ip_addr_interface(dut,
member3,
data.my_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.config_ip_addr_interface(dut,
member4,
data.intf_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.get_interface_ip_address(dut, family="ipv4")
ipfeature.show_ip_route(dut)
interface_status_show(dut)
bgpfeature.create_bgp_router(dut, data.as_num, '')
bgpfeature.create_bgp_neighbor(dut, data.as_num, data.neigh_ip_addr,
data.remote_as_num)
(tg1, tg2, tg_ph_1, tg_ph_2) = get_handles()
tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1)
tg2.tg_traffic_control(action='reset', port_handle=tg_ph_2)
h1 = tg1.tg_interface_config(port_handle=tg_ph_1,
mode='config',
intf_ip_addr='10.10.10.2',
gateway='10.10.10.1',
src_mac_addr='00:0a:01:00:00:01',
arp_send_req='1')
st.log("INTFCONF: " + str(h1))
h2 = tg2.tg_interface_config(port_handle=tg_ph_2,
mode='config',
intf_ip_addr='20.20.20.2',
gateway='20.20.20.1',
arp_send_req='1')
st.log("INTFCONF: " + str(h2))
conf_var = {
'mode': 'enable',
'active_connect_enable': '1',
'local_as': '200',
'remote_as': '100',
'remote_ip_addr': '10.10.10.1'
}
route_var = {
'mode': 'add',
'num_routes': base_route_count,
'prefix': '121.1.1.0',
'as_path': 'as_seq:1'
}
ctrl_start = {'mode': 'start'}
ctrl_stop = {'mode': 'stop'}
# Configuring the BGP router.
bgp_rtr1 = tgapi.tg_bgp_config(tg=tg1,
handle=h1['handle'],
conf_var=conf_var,
route_var=route_var,
ctrl_var=ctrl_start)
st.log("BGP_HANDLE: " + str(bgp_rtr1))
# Verified at neighbor.
st.log("BGP neighborship established.")
st.wait(10)
tr1 = tg2.tg_traffic_config(
port_handle=tg_ph_2,
emulation_src_handle=h2['handle'],
emulation_dst_handle=bgp_rtr1['route'][0]['handle'],
circuit_endpoint_type='ipv4',
mode='create',
transmit_mode='continuous',
length_mode='fixed',
rate_pps=512000,
enable_stream_only_gen='0')
retval = bgpfeature.verify_bgp_summary(dut,
neighbor=data.neigh_ip_addr,
state='Established')
if retval is True:
output = bcm_show(dut, 'bcmcmd "l3 defip show" | wc -l')
st.log(output)
default_route = parse_route_output(output)
route_count += default_route
cmd = 'bcmcmd "l3 defip show" | wc -l'
measure_route_learn_time(dut, default_route, route_count, cmd)
if (show_flag):
cmd = "time show ip route"
bcm_show(dut, cmd)
data.result_14_3 = True
res = tg2.tg_traffic_control(action='stop', handle=tr1['stream_id'])
st.log("TR_CTRL: " + str(res))
tgapi.tg_bgp_config(tg=tg1,
handle=bgp_rtr1['conf']['handle'],
ctrl_var=ctrl_stop)
ipfeature.delete_ip_interface(dut,
member4,
data.intf_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.delete_ip_interface(dut,
member3,
data.my_ip_addr,
data.ip_prefixlen,
family="ipv4")
bgpfeature.delete_bgp_neighbor(dut, data.as_num, data.neigh_ip_addr,
data.remote_as_num)
delete_bgp_router(dut, '', data.as_num)
tg2.tg_traffic_control(action='reset', port_handle=tg_ph_2)
tg1.tg_interface_config(port_handle=tg_ph_1,
handle=h1['handle'],
mode='destroy')
tg2.tg_interface_config(port_handle=tg_ph_2,
handle=h2['handle'],
mode='destroy')
st.wait(20)
def measure_v6_route_learning_time(route_count):
vars = st.get_testbed_vars()
dut = vars.D1
ipfeature.clear_ip_configuration(st.get_dut_names())
ipfeature.clear_ip_configuration(st.get_dut_names(), 'ipv6')
member3 = vars.D1T1P1
member4 = vars.D1T1P2
ipfeature.config_ip_addr_interface(dut,
member3,
data.my_ipv6_addr,
data.ipv6_prefixlen,
family="ipv6")
ipfeature.config_ip_addr_interface(dut,
member4,
data.intf_ipv6_addr,
data.ipv6_prefixlen,
family="ipv6")
ipfeature.get_interface_ip_address(dut, family="ipv6")
ipfeature.show_ip_route(dut, family="ipv6")
bgpfeature.create_bgp_router(dut, data.as_num, '')
bgpfeature.create_bgp_neighbor(dut,
data.as_num,
data.neigh_ipv6_addr,
data.remote_as_num,
family="ipv6")
create_bgp_neighbor_route_map_config(dut, data.as_num,
data.neigh_ipv6_addr, data.routemap)
(tg1, tg2, tg_ph_1, tg_ph_2) = get_handles()
tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1)
tg2.tg_traffic_control(action='reset', port_handle=tg_ph_2)
h1 = tg1.tg_interface_config(port_handle=tg_ph_1,
mode='config',
ipv6_intf_addr='2000::2',
ipv6_prefix_length='64',
ipv6_gateway='2000::1',
src_mac_addr='00:0a:01:00:00:01',
arp_send_req='1')
st.log("INTFCONF: " + str(h1))
h2 = tg2.tg_interface_config(port_handle=tg_ph_2,
mode='config',
ipv6_intf_addr='2200::2',
ipv6_prefix_length='64',
ipv6_gateway='2200::1',
arp_send_req='1')
st.log("INTFCONF: " + str(h2))
bgp_conf = tg1.tg_emulation_bgp_config(handle=h1['handle'],
mode='enable',
ip_version='6',
active_connect_enable='1',
local_as='200',
remote_as='100',
remote_ipv6_addr='2000::1')
bgp_route = tg1.tg_emulation_bgp_route_config(handle=bgp_conf['handle'],
mode='add',
ip_version='6',
num_routes=route_count,
prefix='3300:1::',
as_path='as_seq:1')
tg1.tg_emulation_bgp_control(handle=bgp_conf['handle'], mode='start')
# Configuring the BGP router.
st.log("BGP neighborship established.")
tr2 = tg2.tg_traffic_config(port_handle=tg_ph_2,
emulation_src_handle=h2['handle'],
emulation_dst_handle=bgp_route['handle'],
circuit_endpoint_type='ipv6',
mode='create',
transmit_mode='continuous',
length_mode='fixed',
rate_pps=512000,
enable_stream_only_gen='0')
tg2.tg_traffic_control(action='run', handle=tr2['stream_id'])
output = bcm_show(dut, 'bcmcmd "l3 ip6route show" | wc -l')
default_route = parse_route_output(output)
#Assume default route as current number of routes in the system
#and measure route_count perforamnce on top of it
route_count += default_route
cmd = 'bcmcmd "l3 ip6route show" | wc -l'
measure_route_learn_time(dut, default_route, route_count, cmd)
res = tg2.tg_traffic_control(action='stop', handle=tr2['stream_id'])
st.log("TR_CTRL: " + str(res))
# Withdraw the routes.
st.wait(10)
bgp_ctrl = tg1.tg_emulation_bgp_control(handle=bgp_conf['handle'],
mode='stop')
st.log("BGPCTRL: " + str(bgp_ctrl))
tg2.tg_traffic_control(action='reset', port_handle=tg_ph_2)
st.wait(50)
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')
def l3_performance_enhancements_module_hooks(request):
global vars
global tg_handler
global tg
global dut1
global dut2
global dut3
global dut4
global dut1_to_tg_port_1
global dut1_to_dut2_port_1
global dut2_to_dut1_port_1
global dut1_to_dut3_port_1
global dut3_to_dut1_port_1
global dut2_to_dut4_port_1
global dut4_to_dut2_port_1
global dut3_to_dut4_port_1
global dut4_to_dut3_port_1
global dut4_to_tg_port_1
global hwsku_under_test1
global hwsku_under_test2
global hwsku_under_test3
global hwsku_under_test4
global def_v4_route_count_d1
global def_v4_route_count_d4
global def_v6_route_count_d1
global def_v6_route_count_d4
# Min topology verification
st.log("Ensuring minimum topology")
vars = st.ensure_min_topology("D1D2:1", "D1D3:1", "D2D4:1", "D3D4:1", "D1T1:1", "D4T1:1")
# Initialize TG and TG port handlers
tg_handler = tgapi.get_handles(vars, [vars.T1D1P1, vars.T1D4P1])
tg = tg_handler["tg"]
# Test setup details
dut1 = vars.D1
dut2 = vars.D2
dut3 = vars.D3
dut4 = vars.D4
dut1_to_tg_port_1 = vars.D1T1P1
dut1_to_dut2_port_1 = vars.D1D2P1
dut2_to_dut1_port_1 = vars.D2D1P1
dut1_to_dut3_port_1 = vars.D1D3P1
dut3_to_dut1_port_1 = vars.D3D1P1
dut2_to_dut4_port_1 = vars.D2D4P1
dut4_to_dut2_port_1 = vars.D4D2P1
dut3_to_dut4_port_1 = vars.D3D4P1
dut4_to_dut3_port_1 = vars.D4D3P1
dut4_to_tg_port_1 = vars.D4T1P1
hwsku_under_test1 = basic_obj.get_hwsku(dut1)
hwsku_under_test2 = basic_obj.get_hwsku(dut2)
hwsku_under_test3 = basic_obj.get_hwsku(dut3)
hwsku_under_test4 = basic_obj.get_hwsku(dut4)
# Module Configuration
st.log("L3 Performance Enhancements Module Configuration.")
# Configuring v4/v6 routing interfaces on the DUT.
st.log("Configuring IPv4 routing interfaces.")
ipfeature.config_ip_addr_interface(dut1, dut1_to_tg_port_1, data.dut1_to_tg_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut1, dut1_to_dut2_port_1, data.dut1_to_dut2_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut1, dut1_to_dut3_port_1, data.dut1_to_dut3_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut2, dut2_to_dut1_port_1, data.dut2_to_dut1_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut2, dut2_to_dut4_port_1, data.dut2_to_dut4_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut3, dut3_to_dut1_port_1, data.dut3_to_dut1_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut3, dut3_to_dut4_port_1, data.dut3_to_dut4_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut4, dut4_to_dut2_port_1, data.dut4_to_dut2_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut4, dut4_to_dut3_port_1, data.dut4_to_dut3_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.config_ip_addr_interface(dut4, dut4_to_tg_port_1, data.dut4_to_tg_port_1_ip, data.ip_prefixlen, family="ipv4")
st.log("Configuring IPv6 routing interfaces.")
ipfeature.config_ipv6(dut1, action='enable')
ipfeature.config_ip_addr_interface(dut1, dut1_to_tg_port_1, data.dut1_to_tg_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ip_addr_interface(dut1, dut1_to_dut2_port_1, data.dut1_to_dut2_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ip_addr_interface(dut1, dut1_to_dut3_port_1, data.dut1_to_dut3_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ipv6(dut2, action='enable')
ipfeature.config_ip_addr_interface(dut2, dut2_to_dut1_port_1, data.dut2_to_dut1_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ip_addr_interface(dut2, dut2_to_dut4_port_1, data.dut2_to_dut4_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ipv6(dut3, action='enable')
ipfeature.config_ip_addr_interface(dut3, dut3_to_dut1_port_1, data.dut3_to_dut1_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ip_addr_interface(dut3, dut3_to_dut4_port_1, data.dut3_to_dut4_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ipv6(dut4, action='enable')
ipfeature.config_ip_addr_interface(dut4, dut4_to_dut2_port_1, data.dut4_to_dut2_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ip_addr_interface(dut4, dut4_to_dut3_port_1, data.dut4_to_dut3_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.config_ip_addr_interface(dut4, dut4_to_tg_port_1, data.dut4_to_tg_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
# Configuring BGP router and v4/v6 neighbors on the DUT.
st.log("Configuring BGP routers.")
bgpfeature.create_bgp_router(dut1, data.as_num_1, '')
bgpfeature.create_bgp_router(dut2, data.as_num_2, '')
bgpfeature.create_bgp_router(dut3, data.as_num_3, '')
bgpfeature.create_bgp_router(dut4, data.as_num_4, '')
st.log("Configuring BGP IPv4 neighbors.")
bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.tg_to_dut1_port_1_ip, data.remote_as_num1)
bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.dut2_to_dut1_port_1_ip, data.as_num_2)
bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.dut3_to_dut1_port_1_ip, data.as_num_3)
bgpfeature.create_bgp_neighbor(dut2, data.as_num_2, data.dut1_to_dut2_port_1_ip, data.as_num_1)
bgpfeature.create_bgp_neighbor(dut2, data.as_num_2, data.dut4_to_dut2_port_1_ip, data.as_num_4)
bgpfeature.create_bgp_neighbor(dut3, data.as_num_3, data.dut1_to_dut3_port_1_ip, data.as_num_1)
bgpfeature.create_bgp_neighbor(dut3, data.as_num_3, data.dut4_to_dut3_port_1_ip, data.as_num_4)
bgpfeature.create_bgp_neighbor(dut4, data.as_num_4, data.dut2_to_dut4_port_1_ip, data.as_num_2)
bgpfeature.create_bgp_neighbor(dut4, data.as_num_4, data.dut3_to_dut4_port_1_ip, data.as_num_3)
st.log("Configuring BGP IPv6 neighbors.")
bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.tg_to_dut1_port_1_ip6, data.remote_as_num1, family="ipv6")
bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.dut2_to_dut1_port_1_ip6, data.as_num_2, family="ipv6")
bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.dut3_to_dut1_port_1_ip6, data.as_num_3, family="ipv6")
bgpfeature.create_bgp_neighbor(dut2, data.as_num_2, data.dut1_to_dut2_port_1_ip6, data.as_num_1, family="ipv6")
bgpfeature.create_bgp_neighbor(dut2, data.as_num_2, data.dut4_to_dut2_port_1_ip6, data.as_num_4, family="ipv6")
bgpfeature.create_bgp_neighbor(dut3, data.as_num_3, data.dut1_to_dut3_port_1_ip6, data.as_num_1, family="ipv6")
bgpfeature.create_bgp_neighbor(dut3, data.as_num_3, data.dut4_to_dut3_port_1_ip6, data.as_num_4, family="ipv6")
bgpfeature.create_bgp_neighbor(dut4, data.as_num_4, data.dut2_to_dut4_port_1_ip6, data.as_num_2, family="ipv6")
bgpfeature.create_bgp_neighbor(dut4, data.as_num_4, data.dut3_to_dut4_port_1_ip6, data.as_num_3, family="ipv6")
# st.log("Configuring BGP as-path multipath-relax.")
bgpfeature.create_bgp_best_path(dut1, data.as_num_1, "as-path multipath-relax")
bgpfeature.create_bgp_best_path(dut2, data.as_num_2, "as-path multipath-relax")
bgpfeature.create_bgp_best_path(dut3, data.as_num_3, "as-path multipath-relax")
bgpfeature.create_bgp_best_path(dut4, data.as_num_4, "as-path multipath-relax")
# Get the default route count from DUT
def_v4_route_count_d1 = asicapi.bcmcmd_route_count_hardware(dut1)
def_v4_route_count_d4 = asicapi.bcmcmd_route_count_hardware(dut4)
def_v6_route_count_d1 = asicapi.bcmcmd_ipv6_route_count_hardware(dut1)
def_v6_route_count_d4 = asicapi.bcmcmd_ipv6_route_count_hardware(dut4)
# Verifying the BGP neighborship
st.wait(20)
st.log("Verifying the BGP IPv4 neighborships.")
if not poll_wait(bgpfeature.verify_bgp_summary, 120, dut1, neighbor=data.dut2_to_dut1_port_1_ip,state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut1_port_1_ip)
if not poll_wait(bgpfeature.verify_bgp_summary, 120, dut1, neighbor=data.dut3_to_dut1_port_1_ip,state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut1_port_1_ip)
if not poll_wait(bgpfeature.verify_bgp_summary, 120, dut2, neighbor=data.dut1_to_dut2_port_1_ip,state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut2_port_1_ip)
if not poll_wait(bgpfeature.verify_bgp_summary, 120, dut2, neighbor=data.dut4_to_dut2_port_1_ip,state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut2_port_1_ip)
# if not bgpfeature.verify_bgp_summary(dut1, neighbor=data.dut2_to_dut1_port_1_ip, state='Established'):
# st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut1_port_1_ip)
# if not bgpfeature.verify_bgp_summary(dut1, neighbor=data.dut3_to_dut1_port_1_ip, state='Established'):
# st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut1_port_1_ip)
# if not bgpfeature.verify_bgp_summary(dut2, neighbor=data.dut1_to_dut2_port_1_ip, state='Established'):
# st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut2_port_1_ip)
# if not bgpfeature.verify_bgp_summary(dut2, neighbor=data.dut4_to_dut2_port_1_ip, state='Established'):
# st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut2_port_1_ip)
if not bgpfeature.verify_bgp_summary(dut3, neighbor=data.dut1_to_dut3_port_1_ip, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut3_port_1_ip)
if not bgpfeature.verify_bgp_summary(dut3, neighbor=data.dut4_to_dut3_port_1_ip, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut3_port_1_ip)
if not bgpfeature.verify_bgp_summary(dut4, neighbor=data.dut2_to_dut4_port_1_ip, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut4_port_1_ip)
if not bgpfeature.verify_bgp_summary(dut4, neighbor=data.dut3_to_dut4_port_1_ip, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut4_port_1_ip)
st.log("Verifying the BGP IPv6 neighborships.")
if not bgpfeature.verify_bgp_summary(dut1, family='ipv6', neighbor=data.dut2_to_dut1_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut1_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut1, family='ipv6', neighbor=data.dut3_to_dut1_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut1_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut2, family='ipv6', neighbor=data.dut1_to_dut2_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut2_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut2, family='ipv6', neighbor=data.dut4_to_dut2_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut2_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut3, family='ipv6', neighbor=data.dut1_to_dut3_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut3_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut3, family='ipv6', neighbor=data.dut4_to_dut3_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut3_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut4, family='ipv6', neighbor=data.dut2_to_dut4_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut4_port_1_ip6)
if not bgpfeature.verify_bgp_summary(dut4, family='ipv6', neighbor=data.dut3_to_dut4_port_1_ip6, state='Established'):
st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut4_port_1_ip6)
yield
# Module Cleanup
st.log("L3 Performance Enhancements Module Cleanup.")
st.log("Unconfiguring IPv4 routing interfaces.")
ipfeature.delete_ip_interface(dut1, dut1_to_tg_port_1, data.dut1_to_tg_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut1, dut1_to_dut2_port_1, data.dut1_to_dut2_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut1, dut1_to_dut3_port_1, data.dut1_to_dut3_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut2, dut2_to_dut1_port_1, data.dut2_to_dut1_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut2, dut2_to_dut4_port_1, data.dut2_to_dut4_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut3, dut3_to_dut1_port_1, data.dut3_to_dut1_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut3, dut3_to_dut4_port_1, data.dut3_to_dut4_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut4, dut4_to_dut2_port_1, data.dut4_to_dut2_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut4, dut4_to_dut3_port_1, data.dut4_to_dut3_port_1_ip, data.ip_prefixlen, family="ipv4")
ipfeature.delete_ip_interface(dut4, dut4_to_tg_port_1, data.dut4_to_tg_port_1_ip, data.ip_prefixlen, family="ipv4")
st.log("Unconfiguring IPv6 routing interfaces.")
ipfeature.delete_ip_interface(dut1, dut1_to_tg_port_1, data.dut1_to_tg_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut1, dut1_to_dut2_port_1, data.dut1_to_dut2_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut1, dut1_to_dut3_port_1, data.dut1_to_dut3_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut2, dut2_to_dut1_port_1, data.dut2_to_dut1_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut2, dut2_to_dut4_port_1, data.dut2_to_dut4_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut3, dut3_to_dut1_port_1, data.dut3_to_dut1_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut3, dut3_to_dut4_port_1, data.dut3_to_dut4_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut4, dut4_to_dut2_port_1, data.dut4_to_dut2_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut4, dut4_to_dut3_port_1, data.dut4_to_dut3_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
ipfeature.delete_ip_interface(dut4, dut4_to_tg_port_1, data.dut4_to_tg_port_1_ip6, data.ipv6_prefixlen, family="ipv6")
st.log("Unconfiguring BGP IPv4 neighbors.")
bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.tg_to_dut1_port_1_ip, data.remote_as_num1)
bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.dut2_to_dut1_port_1_ip, data.as_num_2)
bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.dut3_to_dut1_port_1_ip, data.as_num_3)
bgpfeature.delete_bgp_neighbor(dut2, data.as_num_2, data.dut1_to_dut2_port_1_ip, data.as_num_1)
bgpfeature.delete_bgp_neighbor(dut2, data.as_num_2, data.dut4_to_dut2_port_1_ip, data.as_num_4)
bgpfeature.delete_bgp_neighbor(dut3, data.as_num_3, data.dut1_to_dut3_port_1_ip, data.as_num_1)
bgpfeature.delete_bgp_neighbor(dut3, data.as_num_3, data.dut4_to_dut3_port_1_ip, data.as_num_4)
bgpfeature.delete_bgp_neighbor(dut4, data.as_num_4, data.dut2_to_dut4_port_1_ip, data.as_num_2)
bgpfeature.delete_bgp_neighbor(dut4, data.as_num_4, data.dut3_to_dut4_port_1_ip, data.as_num_3)
st.log("Unconfiguring BGP IPv6 neighbors.")
bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.tg_to_dut1_port_1_ip6, data.remote_as_num1)
bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.dut2_to_dut1_port_1_ip6, data.as_num_2)
bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.dut3_to_dut1_port_1_ip6, data.as_num_3)
bgpfeature.delete_bgp_neighbor(dut2, data.as_num_2, data.dut1_to_dut2_port_1_ip6, data.as_num_1)
bgpfeature.delete_bgp_neighbor(dut2, data.as_num_2, data.dut4_to_dut2_port_1_ip6, data.as_num_4)
bgpfeature.delete_bgp_neighbor(dut3, data.as_num_3, data.dut1_to_dut3_port_1_ip6, data.as_num_1)
bgpfeature.delete_bgp_neighbor(dut3, data.as_num_3, data.dut4_to_dut3_port_1_ip6, data.as_num_4)
bgpfeature.delete_bgp_neighbor(dut4, data.as_num_4, data.dut2_to_dut4_port_1_ip6, data.as_num_2)
bgpfeature.delete_bgp_neighbor(dut4, data.as_num_4, data.dut3_to_dut4_port_1_ip6, data.as_num_3)
st.log("Unconfiguring BGP routers.")
bgpfeature.cleanup_router_bgp(dut1)
bgpfeature.cleanup_router_bgp(dut2)
bgpfeature.cleanup_router_bgp(dut3)
bgpfeature.cleanup_router_bgp(dut4)
def l3tc_vrfipv4v6_confed_bgp_config(config='yes',
vrf_type='all',
config_type='all'):
"""
:param config:
:param vrf_type:
:param config_type:
:return:
"""
st.banner("{}Configuring BGP with 4-node confederation topology.".format(
'Un' if config != 'yes' else ''))
#Confedration topo:
#DUT1 in sub-AS1 (AS1 = 24)
#DUT2, DUT3, DUT 4 in sub-AS2 (AS2 = 35)
#IBGP AS = 100
config = 'add' if config == 'yes' else 'remove'
leftconfed_as = 24
rightconfed_as = 35
iBGP_as = 100
topo['D1_as'] = 24
topo['D2_as'] = 35
topo['D3_as'] = 35
topo['D4_as'] = 35
result = True
if config == 'add':
if config_type == 'ipv4' or config_type == 'all':
#Confederation config for DUT1
dut = topo['dut_list'][0]
neighbor = topo['D1D2P1_neigh_ipv4']
bgpapi.config_bgp(dut,
local_as=leftconfed_as,
config='yes',
conf_peers=rightconfed_as,
conf_identf=iBGP_as,
remote_as=rightconfed_as,
config_type_list=["neighbor"],
neighbor=neighbor)
#Confederation config for DUT2
dut = topo['dut_list'][1]
neighbor = topo['D2D3P1_neigh_ipv4']
bgpapi.config_bgp(dut,
local_as=rightconfed_as,
config='yes',
conf_peers=leftconfed_as,
conf_identf=iBGP_as,
remote_as=rightconfed_as,
config_type_list=["neighbor"],
neighbor=neighbor)
bgpapi.create_bgp_neighbor(dut, rightconfed_as,
topo['D2D1P1_neigh_ipv4'],
leftconfed_as)
#Confederation config for DUT3
dut = topo['dut_list'][2]
neighbor = topo['D3D4P1_neigh_ipv4']
bgpapi.config_bgp(dut,
local_as=rightconfed_as,
config='yes',
conf_peers=leftconfed_as,
conf_identf=iBGP_as,
remote_as=rightconfed_as,
config_type_list=["neighbor"],
neighbor=neighbor)
bgpapi.create_bgp_neighbor(dut, rightconfed_as,
topo['D3D2P1_neigh_ipv4'],
rightconfed_as)
#Confederation config for DUT4
dut = topo['dut_list'][3]
neighbor = topo['D4D3P1_neigh_ipv4']
bgpapi.config_bgp(dut,
local_as=rightconfed_as,
config='yes',
conf_peers=leftconfed_as,
conf_identf=iBGP_as,
remote_as=rightconfed_as,
config_type_list=["neighbor"],
neighbor=neighbor)
if config_type == 'ipv6' or config_type == 'all':
#Confederation config for DUT1
dut = topo['dut_list'][0]
neighbor = topo['D1D2P1_neigh_ipv6']
bgpapi.config_bgp(dut,
local_as=leftconfed_as,
config='yes',
addr_family='ipv6',
conf_peers=rightconfed_as,
conf_identf=iBGP_as,
remote_as=rightconfed_as,
config_type_list=["neighbor", "activate"],
neighbor=neighbor)
#Confederation config for DUT2
dut = topo['dut_list'][1]
neighbor = topo['D2D3P1_neigh_ipv6']
bgpapi.config_bgp(dut,
local_as=rightconfed_as,
config='yes',
addr_family='ipv6',
conf_peers=leftconfed_as,
conf_identf=iBGP_as,
remote_as=rightconfed_as,
config_type_list=["neighbor", "activate"],
neighbor=neighbor)
bgpapi.create_bgp_neighbor(dut,
rightconfed_as,
topo['D2D1P1_neigh_ipv6'],
leftconfed_as,
family="ipv6")
#Confederation config for DUT3
dut = topo['dut_list'][2]
neighbor = topo['D3D4P1_neigh_ipv6']
bgpapi.config_bgp(dut,
local_as=rightconfed_as,
config='yes',
addr_family='ipv6',
conf_peers=leftconfed_as,
conf_identf=iBGP_as,
remote_as=rightconfed_as,
config_type_list=["neighbor", "activate"],
neighbor=neighbor)
bgpapi.create_bgp_neighbor(dut,
rightconfed_as,
topo['D3D2P1_neigh_ipv6'],
rightconfed_as,
family="ipv6")
#Confederation config for DUT4
dut = topo['dut_list'][3]
neighbor = topo['D4D3P1_neigh_ipv6']
bgpapi.config_bgp(dut,
local_as=rightconfed_as,
config='yes',
addr_family='ipv6',
conf_peers=leftconfed_as,
conf_identf=iBGP_as,
remote_as=rightconfed_as,
config_type_list=["neighbor", "activate"],
neighbor=neighbor)
else:
bgpapi.cleanup_router_bgp(topo['dut_list'])
return result
def l3_performance_enhancements_module_hooks(request):
global vars, tg_handler, tg, dut, dut_to_tg_port_1, dut_to_tg_port_2, cli_type
global hwsku_under_test, def_v4_route_count, def_v6_route_count
vars = st.ensure_min_topology("D1T1:2")
# Initialize TG and TG port handlers
tg_handler = tgapi.get_handles(vars, [vars.T1D1P1, vars.T1D1P2])
tg = tg_handler["tg"]
if tgapi.is_soft_tgen(vars):
data.test_bgp_route_count = 200
# Test setup details
dut = vars.D1
dut_to_tg_port_1 = vars.D1T1P1
dut_to_tg_port_2 = vars.D1T1P2
hwsku_under_test = basic_obj.get_hwsku(dut)
cli_type = st.get_ui_type(dut)
# Module Configuration
st.log("L3 Performance Enhancements Module Configuration.")
# Configuring v4/v6 routing interfaces on the DUT.
ipfeature.config_ipv6(dut, action='enable')
ipfeature.config_ip_addr_interface(dut,
dut_to_tg_port_1,
data.my_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.config_ip_addr_interface(dut,
dut_to_tg_port_1,
data.my_ipv6_addr,
data.ipv6_prefixlen,
family="ipv6")
ipfeature.config_ip_addr_interface(dut,
dut_to_tg_port_2,
data.intf_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.config_ip_addr_interface(dut,
dut_to_tg_port_2,
data.intf_ipv6_addr,
data.ipv6_prefixlen,
family="ipv6")
# Configuring BGP router and v4/v6 neighbors on the DUT.
bgpfeature.create_bgp_router(dut, data.as_num, '')
bgpfeature.create_bgp_neighbor(dut, data.as_num, data.neigh_ip_addr,
data.remote_as_num)
bgpfeature.create_bgp_neighbor(dut,
data.as_num,
data.neigh_ipv6_addr,
data.remote_as_num,
family="ipv6")
# Get the default route count from DUT
def_v4_route_count = asicapi.get_ipv4_route_count(dut)
def_v6_route_count = asicapi.get_ipv6_route_count(dut)
yield
# Module Cleanup
st.log("L3 Performance Enhancements Module Cleanup.")
ipfeature.delete_ip_interface(dut,
dut_to_tg_port_1,
data.my_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.delete_ip_interface(dut,
dut_to_tg_port_1,
data.my_ipv6_addr,
data.ipv6_prefixlen,
family="ipv6")
ipfeature.delete_ip_interface(dut,
dut_to_tg_port_2,
data.intf_ip_addr,
data.ip_prefixlen,
family="ipv4")
ipfeature.delete_ip_interface(dut,
dut_to_tg_port_2,
data.intf_ipv6_addr,
data.ipv6_prefixlen,
family="ipv6")
bgpfeature.delete_bgp_neighbor(dut, data.as_num, data.neigh_ip_addr,
data.remote_as_num)
bgpfeature.delete_bgp_neighbor(dut, data.as_num, data.neigh_ipv6_addr,
data.remote_as_num)
bgpfeature.cleanup_router_bgp(dut)
