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