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()