def get_duts_mac_address(duts):
"""
This is used to get the Duts and its mac addresses mapping
:param duts: List of DUTs
:return : Duts and its mac addresses mapping
"""
duts_mac_addresses = {}
cmd = "show platform syseeprom"
for dut in duts:
if st.is_vsonic(dut):
mac = basic.get_ifconfig_ether(dut)
duts_mac_addresses[dut] = mac
continue
eeprom_details = st.show(dut, cmd, skip_error_check=True)
if not eeprom_details:
iteration = 3
for i in range(1, iteration + 1):
st.wait(2)
eeprom_details = st.show(dut, cmd, skip_error_check=True)
if eeprom_details:
break
if not eeprom_details and i >= iteration + 1:
st.log("EEPROM data not found for {}".format(dut))
st.report_fail("eeprom_data_not_found", dut)
st.log("EEPROM DETAILS -- {}".format(eeprom_details))
if eeprom_details:
for data in eeprom_details:
if "tlv_name" in data and data[
"tlv_name"] == "Base MAC Address":
duts_mac_addresses[dut] = data["value"].replace(":", "")
st.log("DUT MAC ADDRESS -- {}".format(duts_mac_addresses))
return duts_mac_addresses
def global_vars_and_constants_init():
sf_data.clear()
sf_data.tg_port_list = [vars.T1D1P1, vars.T1D1P2, vars.T1D1P3, vars.T1D1P4]
sf_data.port_list = [vars.D1T1P1, vars.D1T1P2, vars.D1T1P3, vars.D1T1P4]
sf_data.default_snapshot_interval = 10
sf_data.snapshot_interval = 5
sf_data.telemetry_interval = 30
sf_data.default_telemetry_interval = 120
sf_data.unicast = 'unicast'
sf_data.multicast = 'multicast'
sf_data.cpu = 'cpu'
sf_data.periodic = 'periodic'
sf_data.dut_mac = get_ifconfig_ether(vars.D1, 'eth0')
sf_data.tg_current_mode = sf_data.unicast
sf_data.traffic_duration = 5
sf_data.initial_counter_value = 0
sf_data.PG = ['shared', 'headroom', 'unicast', 'multicast']
sf_data.group = ['priority-group', 'queue']
sf_data.table = ['watermark', 'persistent-watermark']
sf_data.platform = get_hwsku(vars.D1).lower()
sf_data.config_file = "buffers.json"
sf_data.device_j2_file = "buffers.json.j2"
sf_data.vlan1 = 1
sf_data.reload_interval = 70
sf_data.FMT = '%H:%M:%S'
sf_data.buffer_pool_tolerance = 2080
sf_data.percentage = ['--percentage', '-p']
sf_data.dot1p_to_tc_map_dict = {
'0': '0',
'1': '1',
'2': '2',
'3': '3',
'4': '4',
'5': '5',
'6': '6',
'7': '7'
}
sf_data.tc_to_pg_map_dict = {'0-7': '7'}
sf_data.obj_name = ['dot1p_tc_map', 'tc_pg_map']
sf_data.map_name = ['dot1p_to_tc_map', 'tc_to_pg_map']
sf_data.dot1p_tc_bind_map = {
'port': vars.D1T1P1,
'map': sf_data.map_name[0],
'obj_name': sf_data.obj_name[0]
}
sf_data.tc_pg_bind_map = {
'port': vars.D1T1P1,
'map': sf_data.map_name[1],
'obj_name': sf_data.obj_name[1]
}
sf_data.sflow_sample_rate = 256
return sf_data
def test_ft_snmp_dot1d_base_bridge_address():
"""
Author : Prasad Darnasi<*****@*****.**>
Verify that the dot1dBaseBridgeAddress Object functions properly.
Reference Test Bed : D1 --- Mgmt Network
"""
get_snmp_output = snmp_obj.walk_snmp_operation(
ipaddress=ipaddress,
oid=data.oid_dot1d_Base_Bridge_Address,
community_name=data.ro_community)
mac_address = basic_obj.get_ifconfig_ether(vars.D1, 'eth0')
if not str(mac_address) in get_snmp_output[0]:
st.report_fail("snmp_output_failed", "dot1dBaseBridgeAddress")
st.report_pass("test_case_passed")
def get_params():
pddf_data.base_mac_address = baapi.get_ifconfig_ether(vars.D1, "eth0")
pddf_data.platform_name_summary = baapi.get_platform_summary(vars.D1)
pddf_data.platform_hwsku = pddf_data.platform_name_summary["hwsku"].lower()
platform_check()
pddf_data.platform_name = pddf_data.platform_name_summary["platform"]
pddf_data.serial_number = baapi.show_version(vars.D1)['serial_number']
pddf_data.platform_constants = st.get_datastore(vars.D1, "constants",
pddf_data.platform_hwsku)
pddf_data.fan_list = pddf_data.platform_constants.get(
"PDDF_FANS_LIST", None)
pddf_data.psu_list = pddf_data.platform_constants.get(
"PDDF_PSU_LIST", None)
pddf_data.thermal_list = pddf_data.platform_constants.get(
"PDDF_THERMAL_LIST", None)
pddf_data.manufacturer = pddf_data.platform_constants.get(
"Manufacturer", None)
if not all([
pddf_data.fan_list, pddf_data.psu_list, pddf_data.thermal_list,
pddf_data.manufacturer
]):
st.report_env_fail("pddf_get_constanc_fail", pddf_data.feature,
pddf_data.platform_hwsku)
pddf_data.up_port_list = intapi.get_up_interfaces(vars.D1)
if not pddf_data.up_port_list:
st.report_env_fail("up_interface_not_found", pddf_data.feature)
pddf_data.up_port = get_sfpytils_supported_up_interface()
if any("/" in interface
for interface in make_list(pddf_data.up_port_list)):
pddf_data.up_port_list = st.get_other_names(
vars.D1, make_list(pddf_data.up_port_list))
pddf_data.alias_up_port = st.get_other_names(
vars.D1, make_list(pddf_data.up_port))[0]
else:
pddf_data.alias_up_port = pddf_data.up_port
#Removed Warm reboot as it's not supported in Buzznik+
pddf_data.reboot_cause_dict = {
'warm': 'warm-reboot',
'fast': 'fast-reboot',
'normal': "issued 'reboot'"
}
pddf_data.reboot_type = random.sample(pddf_data.reboot_cause_dict.keys(),
k=1)[0]
if pddf_data.platform_hwsku not in pddf_data.hw_constants[
'WARM_REBOOT_SUPPORTED_PLATFORMS']:
pddf_data.reboot_cause_dict.pop('warm')
pddf_data.reboot_type = random.sample(
pddf_data.reboot_cause_dict.keys(), k=1)[0]
def test_ft_ip_static_route_traffic_forward():
# Objective - Verify the Ipv4 traffic forwarding over IPv4 static route.
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.")
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:
st.report_fail("traffic_verification_failed")
st.report_pass("test_case_passed")
def erspan_module_hooks(request):
# add things at the start of this module
global vars, h1, h2, h3, h1_ipv6, h2_ipv6, dut_mac
# Ensure Min topology and read the port details.
vars = st.ensure_min_topology("D1D2:1", "D1T1:2", "D2T1:1")
data.tg1, data.tg_ph_1 = tgapi.get_handle_byname("T1D1P1")
data.tg2, data.tg_ph_2 = tgapi.get_handle_byname("T1D1P2")
data.tg3, data.tg_ph_3 = tgapi.get_handle_byname("T1D2P1")
data.port_list_d1 = [vars.D1T1P1, vars.D1T1P2, vars.D1D2P1]
data.port_list_d2 = [vars.D2D1P1, vars.D2T1P1]
# Applying Module configuration
erspan_pre_config()
st.log("######Verifying Pre_Configurtion on DUT#######")
if not erspan_pre_config_verify():
st.report_fail("module_config_verification_failed")
dut_mac = basic.get_ifconfig_ether(vars.D1, vars.D1T1P1)
if not dut_mac:
st.log("Unable to get MAC address of {}".format(vars.D1T1P1))
st.report_fail("module_config_failed"," for erspan")
# Creating IPv4 routing interfaces on TG ports
h1=data.tg1.tg_interface_config(port_handle=data.tg_ph_1, mode='config', intf_ip_addr=data.ip_T1D1P1,
gateway=data.ip_D1T1P1, netmask=data.sub_mask, count=3, arp_send_req='1')
h2=data.tg2.tg_interface_config(port_handle=data.tg_ph_2, mode='config', intf_ip_addr=data.ip_T1D1P2,
gateway=data.ip_D1T1P2, netmask=data.sub_mask, count=3, arp_send_req='1')
h3=data.tg3.tg_interface_config(port_handle=data.tg_ph_3, mode='config', intf_ip_addr=data.ip_T1D2P1,
gateway=data.ip_D2T1P1, netmask=data.sub_mask, count=3, arp_send_req='1')
# Creating IPv6 routing interfaces on TG ports
h1_ipv6 = data.tg1.tg_interface_config(port_handle=data.tg_ph_1, mode='config', ipv6_intf_addr='2001:1::100',
ipv6_prefix_length='64', ipv6_gateway='2001:1::1',
src_mac_addr='00:0a:01:00:00:01', arp_send_req='1')
h2_ipv6 = data.tg2.tg_interface_config(port_handle=data.tg_ph_2, mode='config', ipv6_intf_addr='2001:2::100',
ipv6_prefix_length='64', ipv6_gateway='2001:2::1',
src_mac_addr='00:0b:01:00:00:01', arp_send_req='1')
yield
# add things at the end of this module"
erspan_post_config()
data.tg1.tg_interface_config(port_handle=data.tg_ph_1, handle=h1['handle'], mode='destroy')
data.tg2.tg_interface_config(port_handle=data.tg_ph_2, handle=h2['handle'], mode='destroy')
data.tg3.tg_interface_config(port_handle=data.tg_ph_3, handle=h3['handle'], mode='destroy')
data.tg1.tg_interface_config(port_handle=data.tg_ph_1, handle=h1_ipv6['handle'], mode='destroy')
data.tg2.tg_interface_config(port_handle=data.tg_ph_2, handle=h2_ipv6['handle'], mode='destroy')
def static_port_channel_dut_config():
static_data.dut1_rt_int_mac = get_ifconfig_ether(vars.D1, vars.D1T1P1)
static_data.members_dut1 = [
vars.D1D2P1, vars.D1D2P2, vars.D1D2P3, vars.D1D2P4
]
static_data.members_dut2 = [
vars.D2D1P1, vars.D2D1P2, vars.D2D1P3, vars.D2D1P4
]
st.log('Creating port-channel and adding members in both DUTs')
dict1 = {
'portchannel_list': [static_data.portchannel_name],
'static': True
}
dict2 = {
'portchannel_list': [static_data.portchannel_name],
'static': True
}
exceptions = exec_parallel(True, [vars.D1, vars.D2],
portchannelobj.create_portchannel,
[dict1, dict2])[1]
ensure_no_exception(exceptions)
dict1 = {
'portchannel': static_data.portchannel_name,
'members': static_data.members_dut1
}
dict2 = {
'portchannel': static_data.portchannel_name,
'members': static_data.members_dut2
}
exceptions = exec_parallel(True, [vars.D1, vars.D2],
portchannelobj.add_del_portchannel_member,
[dict1, dict2])[1]
ensure_no_exception(exceptions)
st.log('Creating random VLAN in both the DUTs')
exceptions = exec_all(True, [[create_vlan, vars.D1, static_data.vid],
[create_vlan, vars.D2, static_data.vid]])[1]
ensure_no_exception(exceptions)
st.log(
'Adding Port-Channel and TGen connected ports as tagged members to the random VLAN'
)
exceptions = \
exec_all(True, [[add_vlan_member, vars.D1, static_data.vid, [static_data.portchannel_name, vars.D1T1P1], True],
[add_vlan_member, vars.D2, static_data.vid, [static_data.portchannel_name, vars.D2T1P1], True]])[1]
ensure_no_exception(exceptions)
def tg_stream_config():
for action in ['reset']:
data.tg1.tg_traffic_control(action=action, port_handle=data.tg_ph_1)
data.tg2.tg_traffic_control(action=action, port_handle=data.tg_ph_2)
# Configuring ipv4 traffic stream on TG-1
data.stream = {}
stream = data.tg1.tg_traffic_config(port_handle=data.tg_ph_1,
mode='create',
transmit_mode='continuous',
length_mode='fixed',
rate_pps=data.rate_pps,
l2_encap='ethernet_ii',
mac_src='00:0a:01:00:00:01',
mac_dst=basic.get_ifconfig_ether(
data.dut1, vars.D1T1P1),
l3_protocol="ipv4",
ip_src_addr=data.ip_T1D1P1,
ip_dst_addr=data.ip_T1D1P2,
mac_discovery_gw=data.ip_D1T1P1)
data.stream = stream['stream_id']
ex_ratio = 0.98
# Fields needed for collecting aggregate stats
traffic_details = {
'1': {
'tx_ports': [vars.T1D1P1],
'tx_obj': [data.tg1],
'exp_ratio': [1],
'rx_ports': [vars.T1D1P2],
'rx_obj': [data.tg2],
'stream_list': [data.stream],
},
'2': {
'tx_ports': [vars.T1D1P1],
'tx_obj': [data.tg1],
'exp_ratio': [ex_ratio],
'rx_ports': [vars.T1D2P1],
'rx_obj': [data.tg3],
'stream_list': [data.stream],
}
}
data.traffic_details = traffic_details
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 test_ft_bgp_unnumbered_traffic():
"""
# ################ Author Details ################
# Name: Sesha Reddy Koilkonda
# Email: [email protected]
# ################################################
:return:
"""
utils_obj.banner_log('FtOtSoRtBgpUnFn021')
(tg1, tg2, tg_ph_1, tg_ph_2) = get_handles()
dut1_mac = basic_obj.get_ifconfig_ether(vars.D1, vars.D1T1P1)
h1 = tg1.tg_interface_config(port_handle=tg_ph_1,
mode='config',
intf_ip_addr=data.tg_ip4_addr_l[0],
gateway=data.tgd_ip4_addr_l[0],
src_mac_addr='00:0a:01:00:00:01',
arp_send_req='1')
h2 = tg2.tg_interface_config(port_handle=tg_ph_2,
mode='config',
intf_ip_addr=data.tg_ip4_addr_l[1],
gateway=data.tgd_ip4_addr_l[1],
src_mac_addr='00:0a:01:00:00:01',
arp_send_req='1')
# Advertise a network to peer
network = '55.1.1.0/24'
bgp_obj.advertise_bgp_network(vars.D2, data.d2_local_as, network)
stream_tg1 = tg1.tg_traffic_config(port_handle=tg_ph_1,
mode='create',
transmit_mode="single_burst",
length_mode='fixed',
pkts_per_burst=1000,
mac_src='00.00.00.11.12.53',
mac_dst=dut1_mac,
l3_protocol='ipv4',
ip_src_addr=data.tg_ip4_addr_l[0],
ip_dst_addr=data.tg_ip4_addr_l[1],
port_handle2=tg_ph_2)
stream_id = stream_tg1['stream_id']
tg1.tg_traffic_control(action='run', stream_handle=stream_id)
st.wait(5)
tg1.tg_traffic_control(action='stop', stream_handle=stream_id)
traffic_details = {
'1': {
'tx_ports': [vars.T1D1P1],
'tx_obj': [tg1],
'exp_ratio': [1],
'rx_ports': [vars.T1D2P1],
'rx_obj': [tg2],
'stream_list': [(stream_id)],
}
}
# verify statistics
aggrResult = validate_tgen_traffic(traffic_details=traffic_details,
mode='aggregate',
comp_type='packet_count')
tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1)
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')
bgp_obj.advertise_bgp_network(vars.D2,
data.d2_local_as,
network,
config='no')
if aggrResult:
st.log("IPv4 traffic over BGPv6 unnumbered neighbour is passed")
st.report_pass("test_case_passed")
else:
st.error("IPv4 traffic over BGPv6 unnumbered neighbour is failed.")
st.report_fail("test_case_failed")
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 test_ft_l3_fwding():
"""
Testcase : verify the basic L3 traffic validation
Author : Praveen Kumar Kota <*****@*****.**>
"""
sub_intf = 0
operation_tg1 = {
"openconfig-if-ip:config": {
"ip": "192.168.1.1",
"prefix-length": 24
}
}
operation_tg2 = {
"openconfig-if-ip:config": {
"ip": "192.168.2.1",
"prefix-length": 24
}
}
rest_urls = st.get_datastore(vars.D1, "rest_urls")
url = rest_urls['ip_config'].format(vars.D1T1P1, sub_intf,
data.ip4_addr_t1)
url2 = rest_urls['ip_config'].format(vars.D1T1P2, sub_intf,
data.ip4_addr_t2)
config_rest(vars.D1,
http_method="rest-patch",
rest_url=url,
json_data=operation_tg1)
get_rest(vars.D1, rest_url=url)
config_rest(vars.D1,
http_method="rest-patch",
rest_url=url2,
json_data=operation_tg2)
get_rest(vars.D1, rest_url=url2)
h1 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_1"],
mode='config',
intf_ip_addr=data.ip4_addr_t1_tg,
gateway=data.ip4_addr_t1,
src_mac_addr=data.tg_mac1,
arp_send_req='1')
tg.tg_interface_config(port_handle=tg_handler["tg_ph_2"],
mode='config',
intf_ip_addr=data.ip4_addr_t2_tg,
gateway=data.ip4_addr_t2,
src_mac_addr=data.tg_mac2,
arp_send_req='1')
res = tgapi.verify_ping(src_obj=tg,
port_handle=tg_handler["tg_ph_1"],
dev_handle=h1['handle'],
dst_ip=data.ip4_addr_t2_tg,
ping_count='1',
exp_count='1')
if res:
st.log("Ping succeeded.")
else:
st.warn("Ping failed.")
dut_rt_int_mac1 = basic_obj.get_ifconfig_ether(vars.D1, vars.D1T1P1)
tr1 = tg.tg_traffic_config(port_handle=tg_handler["tg_ph_1"], mode='create', transmit_mode='single_burst',
pkts_per_burst=1000, length_mode='fixed', rate_pps=1000, l3_protocol='ipv4', mac_src=data.tg_mac1, \
mac_dst=dut_rt_int_mac1, ip_src_addr=data.ip4_addr_t1_tg, ip_dst_addr=data.ip4_addr_t2_tg)
ifapi.clear_interface_counters(vars.D1, interface_type="all")
ifapi.show_interface_counters_all(vars.D1)
tg.tg_traffic_control(action='run', stream_handle=tr1['stream_id'])
st.wait(2)
tg.tg_traffic_control(action='stop', stream_handle=tr1['stream_id'])
st.wait(2)
ifapi.show_interface_counters_all(vars.D1)
tg_1_stats = tgapi.get_traffic_stats(tg,
mode='aggregate',
port_handle=tg_handler["tg_ph_1"])
tg_2_stats = tgapi.get_traffic_stats(tg,
mode='aggregate',
port_handle=tg_handler["tg_ph_2"])
counter1 = tg_2_stats.rx.total_packets
counter2 = tg_1_stats.tx.total_packets
if not counter1 >= counter2:
ifapi.show_interface_counters_all(vars.D1)
st.report_fail("test_case_failed")
st.report_pass("test_case_passed")
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()
