def ipv6_link_local_config(action="add"): if action == "add": st.log("Creating VLAN and participating interfaces ...") vlan_data = [{ "dut": [vars.D1], "vlan_id": bgp_rst_data.vlan_id[0], "tagged": [vars.D1D2P2] }, { "dut": [vars.D2], "vlan_id": bgp_rst_data.vlan_id[0], "tagged": [vars.D2D1P2] }] create_vlan_and_add_members(vlan_data) st.log("Creating PortChannel and participating interfaces ...") config_portchannel(vars.D1, vars.D2, bgp_rst_data.portchannel_name, [vars.D1D2P3, vars.D1D2P4], [vars.D2D1P3, vars.D2D1P4]) st.log("Enable IPV6 on physical interface on both the devices") [_, exceptions] = exec_all(True, [[config_interface_ip6_link_local, vars.D1, ["Vlan{}".format(bgp_rst_data.vlan_id[0]), bgp_rst_data.portchannel_name]], \ [config_interface_ip6_link_local, vars.D2, ["Vlan{}".format(bgp_rst_data.vlan_id[0]), bgp_rst_data.portchannel_name]]]) ensure_no_exception(exceptions) else: [_, exceptions] = exec_all(True, [ [config_interface_ip6_link_local, vars.D1, [vars.D1D2P1, "Vlan{}".format(bgp_rst_data.vlan_id[0]), bgp_rst_data.portchannel_name], "disable"], \ [config_interface_ip6_link_local, vars.D2, [vars.D2D1P1, "Vlan{}".format(bgp_rst_data.vlan_id[0]), bgp_rst_data.portchannel_name], "disable"]]) ensure_no_exception(exceptions) clear_portchannel_configuration([vars.D1, vars.D2]) clear_vlan_configuration([vars.D1, vars.D2])
def test_ft_ipv6_link_local_static_rt_ecmp(): 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]]) 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"]) verify_traffic_hash(vars.D1,[vars.D1D2P1, vars.D1D2P2, vars.D1D2P3, vars.D1D2P4], 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("Traffic loss observed for ipv6 traffic forwarded via ipv6 link local next hop") result_flag = 1 if result_flag: st.report_fail("ip6_traffic_over_link_local_nh_fail") st.report_pass("test_case_passed")
def bgp_rst_epilogue(): st.banner("Routing interface un-configuration in both DUTs") [_, exceptions] = exec_all( True, [[dut1_routing_int_cfg, "del"], [dut2_routing_int_cfg, "del"]]) ensure_no_exception(exceptions) [_, exceptions] = exec_all(True, [[config_bgp_router_rst, vars.D1, bgp_rst_data.dut1_asn, "del"], \ [config_bgp_router_rst, vars.D2, bgp_rst_data.dut2_asn, "del"]]) ensure_no_exception(exceptions)
def test_ft_system_verify_traffic_through_port_channel_during_fast_reboot(): [output, exceptions] = exec_all(True, [[ po_obj.verify_portchannel_member, vars.D1, data.portchannel_name, data.members_dut1 ], [ po_obj.verify_portchannel_member, vars.D2, data.portchannel_name, data.members_dut2 ]]) if False in output: st.report_fail('portchannel_member_verification_failed', data.portchannel_name, vars.D1, data.members_dut1) ensure_no_exception(exceptions) exceptions = exec_all(True, [[ vlan_obj.add_vlan_member, vars.D1, data.vlan, data.portchannel_name, True ], [ vlan_obj.add_vlan_member, vars.D2, data.vlan, data.portchannel_name, True ]])[1] ensure_no_exception(exceptions) data.tg_handler["tg"].tg_traffic_config( mode='modify', stream_id=data.stream['stream_id'], transmit_mode='continuous', port_handle=data.tg_handler["tg_ph_1"]) st.log("performing Config save") rb_obj.config_save(vars.D1) data.tg_handler["tg"].tg_traffic_control( action='clear_stats', port_handle=[data.tg_handler["tg_ph_1"], data.tg_handler["tg_ph_3"]]) data.tg_handler["tg"].tg_traffic_control( action='run', stream_handle=data.stream['stream_id']) st.log("performing fast-reboot") st.reboot(vars.D1, 'fast') data.tg_handler["tg"].tg_traffic_control( action='stop', stream_handle=data.stream['stream_id']) loss_pkts_count = 26 * 100 stats_tg1 = tgapi.get_traffic_stats(data.tg_handler["tg"], mode="aggregate", port_handle=data.tg_handler["tg_ph_1"]) tx_pkts = stats_tg1.tx.total_packets stats_tg2 = tgapi.get_traffic_stats(data.tg_handler["tg"], mode="aggregate", port_handle=data.tg_handler["tg_ph_3"]) rx_pkts = stats_tg2.rx.total_packets st.log("Traffic sent from TGEN: {}".format(tx_pkts)) st.log("Traffic received on TGEN: {}".format(rx_pkts)) if not loss_pkts_count > int(tx_pkts) - int(rx_pkts): st.report_fail('data_traffic_loss_during_fast_reboot') st.report_pass("test_case_passed")
def test_ft_verify_static_portchannel_with_l2_traffic(): ''' Author: Venkatesh Terli <*****@*****.**> Scenario - 3.1.2 Verify that l2 traffic is forwarded Through the Static Port Channel. ''' st.log( 'Scenario - 3.1.2 Verify that l2 traffic is forwarded Through the Static Port Channel.' ) exceptions = exec_all(True, [[intfobj.clear_interface_counters, vars.D1], [intfobj.clear_interface_counters, vars.D2]])[1] ensure_no_exception(exceptions) static_data.tg.tg_traffic_control( action='run', stream_handle=[ static_data.streams['D1T1_SD_Mac_Hash1'], static_data.streams['D2T1_SD_Mac_Hash1'] ]) st.wait(5) static_data.tg.tg_traffic_control( action='stop', stream_handle=[ static_data.streams['D1T1_SD_Mac_Hash1'], static_data.streams['D2T1_SD_Mac_Hash1'] ]) verify_traffic_hashed_or_not( vars.D1, [vars.D1D2P1, vars.D1D2P2, vars.D1D2P3, vars.D1D2P4], 20, traffic_loss_verify=True, rx_port=vars.D1T1P1, tx_port=vars.D2T1P1, dut2=vars.D2) verify_traffic_hashed_or_not( vars.D2, [vars.D2D1P1, vars.D2D1P2, vars.D2D1P3, vars.D2D1P4], 20, traffic_loss_verify=True, rx_port=vars.D2T1P1, tx_port=vars.D1T1P1, dut2=vars.D1) [output, exceptions] = exec_all( True, [[get_mac_address_count, vars.D1, None, static_data.portchannel_name], [get_mac_address_count, vars.D2, None, static_data.portchannel_name]]) ensure_no_exception(exceptions) mac_count1, mac_count2 = output if int(mac_count1) < 100: st.report_fail('traffic_verification_fail', vars.D1) if int(mac_count2) < 100: st.report_fail('traffic_verification_fail', vars.D2) st.log('verified that traffic is successfully passing') st.report_pass('portchannel_l2_forwarding_success')
def dut_vlan_config(): st.log("creating vlan and participating TGEN ports") data.vlan = str(random_vlan_list()[0]) exceptions = exec_all(True, [[vlan_obj.create_vlan, vars.D1, data.vlan], [vlan_obj.create_vlan, vars.D2, data.vlan]])[1] ensure_no_exception(exceptions) exceptions = exec_all(True, [[ vlan_obj.add_vlan_member, vars.D1, data.vlan, [vars.D1T1P1, vars.D1T1P2], True ], [vlan_obj.add_vlan_member, vars.D2, data.vlan, [vars.D2T1P1], True]])[1] ensure_no_exception(exceptions)
def portchannel_module_hooks(request): # add things at the start of this module global vars vars = st.ensure_min_topology("D1D2:4", "D1T1:1", "D2T1:1") initialize_variables() exec_all( True, [[static_port_channel_tg_config], [static_port_channel_dut_config]], first_on_main=True) yield st.log('Module config Cleanup') clear_vlan_configuration([vars.D1, vars.D2]) portchannelobj.clear_portchannel_configuration([vars.D1, vars.D2])
def test_ft_ipv6_link_local_nh_change(): report_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']) st.log("Remove the vlan participation to bring down the Vlan routing intf") vlan_obj.delete_vlan_member(vars.D1, data.vlan_li[0], vars.D1D2P2, tagging_mode=True) vlan_obj.add_vlan_member(vars.D1, data.vlan_li[0], vars.D1D2P2, tagging_mode=True) if not ip_obj.get_link_local_addresses(vars.D1, data.vlan_in_1): st.error("ipv6 link local addr is not auto generated after remove and re add of vlan routing intf") report_flag = 1 pc_obj.add_del_portchannel_member(vars.D1, data.prt_chnl, [vars.D1D2P3, vars.D1D2P4], flag="del", skip_verify=True) pc_obj.add_del_portchannel_member(vars.D1, data.prt_chnl, [vars.D1D2P3, vars.D1D2P4], flag="add", skip_verify=True) if not ip_obj.get_link_local_addresses(vars.D1, data.prt_chnl): st.error("ipv6 link local addr is not auto generated for {} after remove and re add of members".format(data.prt_chnl)) report_flag = 1 if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = vars.D1D2P1): st.log("Ipv6 Ping over Link Local address via the Port based routing interface is failed.") report_flag = 1 if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = data.vlan_in_1): st.log("Ipv6 Ping over Link Local address via the Vlan based routing interface is failed.") report_flag =1 if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = data.prt_chnl): st.log("Ipv6 Ping over Link Local address via the Port Channel based routing interface is failed.") report_flag =1 utils.exec_all(True, [[get_mac, vars.D1] ,[get_mac, vars.D2]]) st.log("Checking the IPv6 traffic forwarding over ECMP next hops after remove and re adding of next hop interfaces") 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"]) ecmp_cntrs = verify_traffic_hash(vars.D1, [vars.D1D2P1, vars.D1D2P2, vars.D1D2P3, vars.D1D2P4], data.pkts_per_port) st.log("Counter stats on next hop interfaces - {}".format(ecmp_cntrs)) 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("After flap in next hop interfaces, traffic loss observed for ipv6 traffic forwarded via ipv6 link local next hop") report_flag = 1 if report_flag: st.report_fail("ip6_traffic_over_link_local_nh_fail") st.report_pass("test_case_passed")
def looguard_module_prolog(): parallel.exec_all( True, [[vlan.create_vlan_and_add_members, sc_data.vlan_data_d1], [vlan.create_vlan_and_add_members, sc_data.vlan_data_d2]]) parallel.exec_all( True, [[vlan.create_vlan_and_add_members, sc_data.vlan1_data_d1], [vlan.create_vlan_and_add_members, sc_data.vlan1_data_d2]]) stp.config_stp_in_parallel(sc_data.dut_list, feature="rpvst", mode="enable", vlan=None) stp.config_stp_vlan_parameters(vars.D2, sc_data.vlan, priority=0) stp.config_stp_vlan_parameters(vars.D2, sc_data.vlan1, priority=0) st.log("Wait for convergence") st.wait(10)
def test_ft_ipv6_link_local_vrf(): report_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']) st.log("Check the auto configured ipv6 link local address for VRF interface") if not ip_obj.get_link_local_addresses(vars.D1, data.vlan_in_2): st.log( "Ipv6 link local address is not auto generated for VRF binded vlan based routing interface {}".format(data.vlan_in_2)) report_flag = 1 ip_obj.show_ip_route(vars.D1, "ipv6", "sonic", data.vrf_name) st.log("binding the TG connected interface to VRF {}".format(data.vrf_name)) ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P1, data.tgd_ip6_addr_l[0], data.tg_ip6_addr_mask_l[0], "ipv6", 'remove') vrf_obj.bind_vrf_interface(vars.D1, vrf_name=data.vrf_name, intf_name=vars.D1T1P1, config='yes', skip_error=True) ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P1, data.tgd_ip6_addr_l[0],data.tg_ip6_addr_mask_l[0], "ipv6", 'add') 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"]) # 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]]) 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( "After flap in next hop interfaces, traffic loss observed for ipv6 traffic forwarded via ipv6 link local next hop") report_flag = 1 if report_flag: vrf_obj.bind_vrf_interface(vars.D1, vrf_name=data.vrf_name, intf_name=vars.D1T1P1, config='no', skip_error=True) ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P1, data.tgd_ip6_addr_l[0], data.tg_ip6_addr_mask_l[0], "ipv6", 'add') st.report_fail("ip6_traffic_over_link_local_nh_fail_vrf") ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P1, data.tgd_ip6_addr_l[0], data.tg_ip6_addr_mask_l[0], "ipv6", 'remove') vrf_obj.bind_vrf_interface(vars.D1, vrf_name=data.vrf_name, intf_name=vars.D1T1P1, config='no', skip_error=True) ip_obj.config_ip_addr_interface(vars.D1, vars.D1T1P1, data.tgd_ip6_addr_l[0],data.tg_ip6_addr_mask_l[0], "ipv6", 'add') st.report_pass("test_case_passed")
def bgp_rst_prologue(): global vars vars = st.ensure_min_topology("D1D2:4") st.banner("Routing interface configuration in both DUTs") [_, exceptions] = exec_all( True, [[dut1_routing_int_cfg, "add"], [dut2_routing_int_cfg, "add"]]) ensure_no_exception(exceptions)
def test_ft_bgp_rst001(): # """ # Validate the BGP IPv4 neighborship when configured through REST # :return: # """ [out, exceptions] = exec_all(True, [[config_bgp_router_rst, vars.D1, bgp_rst_data.dut1_asn, "add"], \ [config_bgp_router_rst, vars.D2, bgp_rst_data.dut2_asn, "add"]]) ensure_no_exception(exceptions) for each in out: if not each: st.report_fail("bgp_router_create_delete", "Creation", "REST", "FAILED") st.wait(5) dut1_data = { 'neigh_ip': bgp_rst_data.dut2_ip_l[0], 'local_asn': bgp_rst_data.dut1_asn, 'remote_asn': bgp_rst_data.dut2_asn, 'peer_type': "EXTERNAL", 'family': "ipv4", 'config': "add" } dut2_data = { 'neigh_ip': bgp_rst_data.dut1_ip_l[0], 'local_asn': bgp_rst_data.dut2_asn, 'remote_asn': bgp_rst_data.dut1_asn, 'peer_type': "EXTERNAL", 'family': "ipv4", 'config': "add" } exec_parallel(True, [vars.D1, vars.D2], config_bgp_neighbor_rst, [dut1_data, dut2_data]) for each in out: if not each: st.report_fail("bgp_neighbor_create_delete", "v4", "Creation", "REST", "FAILED") if not poll_wait(verify_bgp_neighbor_rst, 60, vars.D1, bgp_rst_data.dut2_ip_l[0]): st.report_fail("bgp_neighbor_create_delete", "v4", "Creation", "REST", "FAILED") [out, exceptions] = exec_all(True, [[bgp_neighbor_del_rst, vars.D1, bgp_rst_data.dut2_ip_l[0]] , \ [bgp_neighbor_del_rst, vars.D2, bgp_rst_data.dut1_ip_l[0]]]) ensure_no_exception(exceptions) for each in out: if not each: st.report_fail("bgp_neighbor_create_delete", "v4", "Delrtion", "REST", "FAILED") st.report_pass("bgp_neighbor_status", "v4", "Successful", "REST")
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 scheduling_module_config(config='yes'): if config == 'yes': st.debug("Configuring MAC age out time") [output, exceptions] = exec_all( True, [[config_mac_agetime, vars.D1, scheduling_data.ageout_time], [config_mac_agetime, vars.D2, scheduling_data.ageout_time]]) ensure_no_exception(exceptions) if not all(output): st.report_fail("mac_aging_time_failed_config") st.debug("Verifying MAC age out time") [output, exceptions ] = exec_all(True, [[get_mac_agetime, vars.D1], [get_mac_agetime, vars.D2]]) ensure_no_exception(exceptions) if not ((int(output[0]) == scheduling_data.ageout_time) and (int(output[1]) == scheduling_data.ageout_time)): st.report_fail( "msg", "MAC age out time is not configured as: {}".format( scheduling_data.ageout_time)) st.debug("Create a vlan and add ports as tagged members to it") if not create_vlan_and_add_members( [{ "dut": [vars.D1], "vlan_id": scheduling_data.vlan, "tagged": [vars.D1T1P1, vars.D1T1P2, vars.D1D2P1] }, { "dut": [vars.D2], "vlan_id": scheduling_data.vlan, "tagged": [vars.D2T1P1, vars.D2T1P2, vars.D2D1P1] }]): st.report_fail( "msg", "Failed to add port as tagged members of VLAN: {}".format( scheduling_data.vlan)) else: # clearing scheduling and vlan config clear_port_shaper(vars.D1, port=vars.D1D2P1, shaper_data=scheduling_data.policy_name, qos_clear=True) clear_vlan_configuration([vars.D1, vars.D2], thread=True) scheduling_data.tg.tg_traffic_control( action='stop', stream_handle=scheduling_data.streams.values())
def verify_traffic_hashed_or_not(dut, port_list, pkts_per_port, traffic_loss_verify=False, rx_port='', tx_port='', dut2=''): if traffic_loss_verify is True: [output, exceptions] = exec_all(True, [[intfobj.show_interface_counters_all, dut], [intfobj.show_interface_counters_all, dut2]]) ensure_no_exception(exceptions) static_data.intf_counters_1, static_data.intf_counters_2 = output else: static_data.intf_counters_1 = intfobj.show_interface_counters_all(dut) static_data.intf_count_dict = {} for port in port_list: for counter_dict in static_data.intf_counters_1: if counter_dict['iface'] == port: try: tx_ok_counter = counter_dict['tx_ok'].replace(',', '') static_data.intf_count_dict[port] = int( tx_ok_counter) if tx_ok_counter.isdigit() else 0 except Exception: st.report_fail('invalid_traffic_stats') if not (static_data.intf_count_dict[port] >= pkts_per_port): intfobj.show_interface_counters_detailed( vars.D1, vars.D1T1P1) st.report_fail("traffic_not_hashed", dut) if traffic_loss_verify is True: for counter_dict in static_data.intf_counters_1: if counter_dict['iface'] == rx_port: try: rx_ok_counter = counter_dict['rx_ok'].replace(',', '') static_data.rx_traffic = int( rx_ok_counter) if rx_ok_counter.isdigit() else 0 except Exception: st.report_fail('invalid_traffic_stats') break for counter_dict in static_data.intf_counters_2: if counter_dict['iface'] == tx_port: try: tx_ok_counter = counter_dict['tx_ok'].replace(',', '') static_data.tx_traffic = int( tx_ok_counter) if tx_ok_counter.isdigit() else 0 except Exception: st.report_fail('invalid_traffic_stats') break if not (static_data.tx_traffic >= 0.95 * static_data.rx_traffic): st.log("data.tx_traffic:{}".format(static_data.tx_traffic)) st.log("data.rx_traffic:{}".format(static_data.rx_traffic)) intfobj.show_interface_counters_detailed(vars.D1, vars.D1T1P1) st.report_fail('traffic_loss_observed') return True
def vlan_module_hooks(request): global vars vars = st.ensure_min_topology("D1D2:2", "D1T1:2", "D2T1:2") sc_data.version_data = basic_obj.show_version(vars.D1) vlan_variables() if not st.is_feature_supported("vlan-range", vars.D1): sc_data.max_vlan = 100 [_, exceptions] = exec_all(True, [[config_tg_stream], [vlan_module_prolog]], first_on_main=True) ensure_no_exception(exceptions) yield vlan.clear_vlan_configuration(st.get_dut_names(), thread=False)
def test_ft_bgp_rst003(): [_, exceptions] = exec_all(True, [ [config_interface_ip6_link_local, vars.D1, [vars.D1D2P1]], \ [config_interface_ip6_link_local, vars.D2, [vars.D2D1P1]]]) ensure_no_exception(exceptions) dut1_data = { 'neigh_ip': vars.D1D2P1, 'local_asn': bgp_rst_data.dut1_asn, 'remote_asn': bgp_rst_data.dut2_asn, 'peer_type': "EXTERNAL", 'family': "ipv6", 'config': "add" } dut2_data = { 'neigh_ip': vars.D2D1P1, 'local_asn': bgp_rst_data.dut2_asn, 'remote_asn': bgp_rst_data.dut1_asn, 'peer_type': "EXTERNAL", 'family': "ipv6", 'config': "add" } [out, exceptions] = exec_parallel(True, [vars.D1, vars.D2], config_bgp_neighbor_rst, [dut1_data, dut2_data]) ensure_no_exception(exceptions) for each in out: if not each: st.report_fail("bgp_neighbor_create_delete", "v6", "Creation", "REST", "FAILED") if not poll_wait(verify_bgp_neighbor_rst, 60, vars.D1, vars.D1D2P1): st.report_fail("bgp_neighbor_create_delete", "v6", "Creation", "REST", "FAILED") [out, exceptions] = exec_all(True, [[bgp_neighbor_del_rst, vars.D1, vars.D2D1P1], \ [bgp_neighbor_del_rst, vars.D2, vars.D1D2P1]]) ensure_no_exception(exceptions) for each in out: if not each: st.report_fail("bgp_neighbor_create_delete", "v6", "Delrtion", "REST", "FAILED") st.report_pass("bgp_neighbor_status", "v6", "Successful", "REST")
def pvst_elastic_function_hooks(request): if st.get_func_name(request) == "test_ft_stp_loopguard_lag_interfaces": vlan.clear_vlan_configuration(st.get_dut_names(), thread=False) st.log('Creating port-channel and adding members in both DUTs') portchannel.config_portchannel(vars.D1, vars.D2, sc_data.portchannel_name, sc_data.members_dut1, sc_data.members_dut2, "add") portchannel.config_portchannel(vars.D1, vars.D2, sc_data.portchannel_name2, sc_data.members_dut1_p2, sc_data.members_dut2_p2, "add") parallel.exec_all( True, [[vlan.create_vlan_and_add_members, sc_data.vlan_pc_d1], [vlan.create_vlan_and_add_members, sc_data.vlan_pc_d2]]) yield if st.get_func_name(request) == "test_ft_stp_loopguard_lag_interfaces": vlan.clear_vlan_configuration(st.get_dut_names(), thread=False) portchannel.clear_portchannel_configuration([vars.D1, vars.D2]) parallel.exec_all( True, [[vlan.create_vlan_and_add_members, sc_data.vlan_data_d1], [vlan.create_vlan_and_add_members, sc_data.vlan_data_d2]]) parallel.exec_all( True, [[vlan.create_vlan_and_add_members, sc_data.vlan1_data_d1], [vlan.create_vlan_and_add_members, sc_data.vlan1_data_d2]])
def bgp_rst_func_hooks(request): yield if st.get_func_name(request) == "test_ft_bgp_rst002": [_, exceptions] = exec_all( True, [[ config_ip_addr_rst, vars.D1, bgp_rst_data.dut1_ip6_l[0], bgp_rst_data.ip6_pre_len, vars.D1D2P1, "ipv6", "del" ], [ config_ip_addr_rst, vars.D2, bgp_rst_data.dut2_ip6_l[0], bgp_rst_data.ip6_pre_len, vars.D2D1P1, "ipv6", "del" ]]) ensure_no_exception(exceptions)
def test_ft_verify_static_portchannel_funtionality_after_save_and_reboot(): ''' Author: Venkatesh Terli <*****@*****.**> Scenario - 3.3.1 Verify that the Static LAG configuration should be retained after save and reboot. ''' st.log( 'Scenario - 3.3.1 Verify that the Static LAG configuration should be retained after save and reboot.' ) st.log("performing Config save and reboot") rbobj.config_save_reload([vars.D1, vars.D2]) st.wait(10) exceptions = exec_all(True, [[ portchannelobj.verify_portchannel_state, vars.D1, static_data.portchannel_name, "up" ], [ portchannelobj.verify_portchannel_state, vars.D2, static_data.portchannel_name, "up" ]])[1] ensure_no_exception(exceptions) exceptions = exec_all(True, [[intfobj.clear_interface_counters, vars.D1], [intfobj.clear_interface_counters, vars.D2]])[1] ensure_no_exception(exceptions) static_data.tg.tg_traffic_control( action='run', stream_handle=[static_data.streams['D1T1_SD_Mac_Hash1']]) st.wait(5) static_data.tg.tg_traffic_control( action='stop', stream_handle=[static_data.streams['D1T1_SD_Mac_Hash1']]) verify_traffic_hashed_or_not( vars.D1, [vars.D1D2P1, vars.D1D2P2, vars.D1D2P3, vars.D1D2P4], 20, traffic_loss_verify=True, rx_port=vars.D1T1P1, tx_port=vars.D2T1P1, dut2=vars.D2) st.report_pass('portchannel_functionality_after_save_and_reboot')
def storm_control_module_hooks(request): global vars vars = st.ensure_min_topology("D1D2:2", "D1T1:2", "D2T1:2") sc_data.version_data = basic_obj.show_version(vars.D1) vlan_variables() [out, exceptions] = exec_all(True, [[config_tg_stream], [vlan_module_prolog]], first_on_main=True) ensure_no_exception(exceptions) yield vlan.clear_vlan_configuration(st.get_dut_names(), thread=False, cli_type="click")
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 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_ipv6_link_local_ping(): report_flag = 0 if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = vars.D1D2P1): st.log("Ipv6 Ping over Link Local address via the Port based routing interface is failed.") report_flag = 1 if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = data.vlan_in_1): st.log("Ipv6 Ping over Link Local address via the Vlan based routing interface is failed.") report_flag =1 if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = data.prt_chnl): st.log("Ipv6 Ping over Link Local address via the Port Channel based routing interface is failed.") report_flag =1 # Get show ndp output utils.exec_all(True, [[arp_obj.show_ndp, vars.D1, None], [arp_obj.show_ndp, vars.D2, None]]) d1_int_li = [vars.D2D1P1, vars.D2D1P2, data.prt_chnl] intf_obj.interface_operation(vars.D2, [vars.D2D1P1, vars.D2D1P2, data.prt_chnl], operation="shutdown", skip_verify=True) st.log("Waiting for 10 sec after shutdown the interfaces") st.wait(10) intf_obj.interface_status_show(vars.D1, [vars.D2D1P1, vars.D2D1P2, data.prt_chnl]) intf_obj.interface_operation(vars.D2, [vars.D2D1P1, vars.D2D1P2, data.prt_chnl], operation="startup", skip_verify=True) st.log("Polling for interface status after no shutdown") for intf in d1_int_li: if not intf_obj.poll_for_interface_status(vars.D2, intf, "oper", "up", iteration=5, delay=1): st.error("Failed to startup interface {} on the DUT {}".format(intf, vars.D2)) report_flag = 0 if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = vars.D1D2P1): st.log("After shut no shut, Ipv6 Ping over Link Local address via the Port based routing interface is failed.") report_flag = 1 if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface=data.vlan_in_1): st.log("After shut no shut, Ipv6 Ping over Link Local address via the Vlan based routing interface is failed.") report_flag = 1 if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface=data.prt_chnl): st.log("After shut no shut, Ipv6 Ping over Link Local address via the Port Channel based routing interface is failed.") report_flag = 1 if report_flag: st.report_fail("ip6_ping_fail_over_link_local_addr") st.report_pass("test_case_passed")
def pvst_elastic_module_hooks(request): global vars vars = st.ensure_min_topology("D1D2:4", "D1T1:2", "D2T1:2") vlan_variables() vlan.clear_vlan_configuration(st.get_dut_names(), thread=False) [_, exceptions] = exec_all(True, [[config_tg_stream], [looguard_module_prolog]], first_on_main=True) ensure_no_exception(exceptions) yield stp.config_stp_in_parallel(sc_data.dut_list, feature="rpvst", mode="disable", vlan=None) vlan.clear_vlan_configuration(st.get_dut_names(), thread=False)
def ipv6_link_local_func_hooks(request): utils.exec_all(True, [[ip_obj.show_ip_route, vars.D1, "ipv6"], [ip_obj.show_ip_route, vars.D2, "ipv6"]]) yield if st.get_func_name(request) == 'test_ft_ipv6_link_local_warm_boot': ip_obj.create_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, "vtysh", 'ipv6', data.prt_chnl) tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"]) if st.get_func_name(request) == 'test_ft_ipv6_link_local_manual': utils.exec_all(True, [ [ip_obj.delete_static_route, vars.D1, data.ip6_manual_ll_addr[1], data.static_rt_manual, 'ipv6', "vtysh", data.prt_chnl], [ip_obj.delete_static_route, vars.D2, data.tg_ip6_addr_l[1], data.static_rt_manual, 'ipv6', "vtysh", vars.D2T1P1]]) utils.exec_all(True, [[ip_obj.config_ip_addr_interface, vars.D1, data.prt_chnl, data.ip6_manual_ll_addr[0], data.tg_ip6_addr_mask_l[0], "ipv6", 'remove'], [ip_obj.config_ip_addr_interface, vars.D2, data.prt_chnl, data.ip6_manual_ll_addr[1], data.tg_ip6_addr_mask_l[1], "ipv6", 'remove']]) utils.exec_all(True, [[ip_obj.config_interface_ip6_link_local, vars.D1, data.prt_chnl, 'enable'], [ip_obj.config_interface_ip6_link_local, vars.D2, data.prt_chnl, 'enable']]) ip_obj.create_static_route(vars.D1, d2_prt_link_local[0], data.static_rt, "vtysh", 'ipv6', data.prt_chnl)
def test_ft_del_ip_assigned_portchannel(): ''' Author: Venkatesh Terli <*****@*****.**> Scenario - 3.2.2 Verify that deletion of a Static Port Channel with IP address is assigned on it is not Successful. ''' st.log( 'Scenario - 3.2.2 Verify that deletion of a Static Port Channel with IP address is assigned on it is not Successful.' ) portchannelobj.delete_portchannel_member(vars.D1, static_data.portchannel_name, static_data.members_dut1) exceptions = exec_all(True, [ ExecAllFunc(delete_vlan_member, vars.D1, static_data.vid, static_data.portchannel_name, tagging_mode=True), ExecAllFunc(delete_vlan_member, vars.D2, static_data.vid, static_data.portchannel_name, tagging_mode=True) ])[1] ensure_no_exception(exceptions) ipobj.config_ip_addr_interface(vars.D1, static_data.portchannel_name, static_data.ip41, static_data.ip_mask) result = portchannelobj.delete_portchannel(vars.D1, static_data.portchannel_name, skip_error=True) cli_type = st.get_ui_type(vars.D1) if cli_type == 'click': if result: st.report_fail( 'msg', 'Allowed to delete PortChannel which is configured with IP address' ) else: if not result: st.report_fail( 'msg', 'Delete PortChannel which is configured with IP address is not allowed' ) st.report_pass('portchannel_delete_with_ip_configured_portchannel')
def verify_traffic_hash(dut, port_list, pkts_per_port, traffic_loss_verify=False, rx_port = '', tx_port = '', dut2 =''): if traffic_loss_verify: sub_list = [] sub_list.append([intf_obj.show_interface_counters_all, dut]) sub_list.append([intf_obj.show_interface_counters_all, dut2]) [output, exceptions] = utils.exec_all(True, sub_list) utils.ensure_no_exception(exceptions) data.int_cntr_1, data.int_cntr_2 = output else: data.int_cntr_1 = intf_obj.show_interface_counters_all(dut) data.intf_count_dict = {} for port in port_list: for counter_dict in iterable(data.int_cntr_1): if counter_dict['iface'] == port: try: data.intf_count_dict[port] = int(counter_dict['tx_ok'].replace(',','')) except Exception: st.report_fail('invalid_traffic_stats') if not (data.intf_count_dict[port] >= pkts_per_port): intf_obj.show_interface_counters_detailed(vars.D1, vars.D1T1P1) st.report_fail("traffic_not_hashed", dut) if traffic_loss_verify: for counter_dict in data.int_cntr_1: if counter_dict['iface'] == rx_port: try: data.rx_traffic = int(counter_dict['rx_ok'].replace(',', '')) except Exception: st.report_fail('invalid_traffic_stats') break for counter_dict in data.int_cntr_2: if counter_dict['iface'] == tx_port: try: data.tx_traffic = int(counter_dict['tx_ok'].replace(',', '')) except Exception: st.report_fail('invalid_traffic_stats') break if not (data.tx_traffic >= 0.95* data.rx_traffic): st.log("data.tx_traffic:{}".format(data.tx_traffic)) st.log("data.rx_traffic:{}".format(data.rx_traffic)) intf_obj.show_interface_counters_detailed(vars.D1, vars.D1T1P1) st.report_fail('traffic_loss_observed') return data.intf_count_dict
def test_ft_bgp_rst004(): dut1_data = { 'neigh_ip': "Vlan{}".format(bgp_rst_data.vlan_id[0]), 'local_asn': bgp_rst_data.dut1_asn, 'remote_asn': bgp_rst_data.dut2_asn, 'peer_type': "EXTERNAL", 'family': "ipv6", 'config': "add" } dut2_data = { 'neigh_ip': "Vlan{}".format(bgp_rst_data.vlan_id[0]), 'local_asn': bgp_rst_data.dut2_asn, 'remote_asn': bgp_rst_data.dut1_asn, 'peer_type': "EXTERNAL", 'family': "ipv6", 'config': "add" } [out, exceptions] = exec_parallel(True, [vars.D1, vars.D2], config_bgp_neighbor_rst, [dut1_data, dut2_data]) ensure_no_exception(exceptions) for each in out: if not each: st.report_fail("bgp_neighbor_create_delete", "v6", "Creation", "REST", "FAILED") if not poll_wait(verify_bgp_neighbor_rst, 60, vars.D1, "Vlan{}".format( bgp_rst_data.vlan_id[0])): st.report_fail("bgp_neighbor_create_delete", "v6", "Creation", "REST", "FAILED") [out, exceptions] = exec_all(True, [[bgp_neighbor_del_rst, vars.D1, "Vlan{}".format(bgp_rst_data.vlan_id[0])], \ [bgp_neighbor_del_rst, vars.D2, "Vlan{}".format(bgp_rst_data.vlan_id[0])]]) ensure_no_exception(exceptions) for each in out: if not each: st.report_fail("bgp_neighbor_create_delete", "v6", "Delrtion", "REST", "FAILED") st.report_pass("bgp_neighbor_status", "v6", "Successful", "REST")
def test_ft_control_plane_acl_icmp(): result = True [output, exceptions] = parallel.exec_all( True, [[st.get_mgmt_ip, vars.D1], [st.get_mgmt_ip, vars.D2]]) parallel.ensure_no_exception(exceptions) d1_ipaddress, d2_ipaddress = output d1_ipv6address = ip_obj.get_link_local_addresses( vars.D1, "eth0", cli_type='click' ) ##Passing parameter cli_type as click until the SONIC-32291 fixed if not d1_ipv6address: st.report_fail('dut_not_getting_ip_address') d1_ipv6address = d1_ipv6address[0] st.log("Creating acl rules to drop icmp packets") acl_config = acl_data.acl_json_config_control_plane_v2 st.log("ACL_DATA: {}".format(acl_config)) acl_obj.apply_acl_config(vars.D1, acl_config) acl_obj.show_acl_table(vars.D1) acl_obj.show_acl_rule(vars.D1) if ip_obj.ping(dut=vars.D2, addresses=d1_ipaddress): st.error( "ICMP ipv4 packets are not dropped with applied control plane acl rules." ) result = False st.report_tc_fail("ft_controlplane_acl_ipv4_icmp", "test_case_failed") if ip_obj.ping(dut=vars.D1, addresses=d1_ipv6address, interface="eth0", family="ipv6"): st.error( "ICMP ipv6 packets are not dropped with applied control plane acl rules." ) result = False st.report_tc_fail("ft_controlplane_acl_ipv6_icmp", "test_case_failed") change_acl_rules(acl_config, "L3_IPV4_ICMP|rule1", "SRC_IP", "{}/32".format(d2_ipaddress)) change_acl_rules(acl_config, "L3_IPV6_ICMP|rule1", "SRC_IPV6", "{}/128".format(d1_ipv6address)) acl_obj.acl_delete(vars.D1) acl_obj.apply_acl_config(vars.D1, acl_config) if not ip_obj.ping(dut=vars.D2, addresses=d1_ipaddress): st.error( "ICMP ipv4 packets are dropped with applied control plane acl rules." ) result = False st.report_tc_fail("ft_controlplane_acl_seq_priority", "test_case_failed") st.report_tc_fail("ft_controlplane_acl_ipv4_icmp_permit", "test_case_failed") if not ip_obj.ping( dut=vars.D1, addresses=d1_ipv6address, interface="eth0", family="ipv6"): st.error( "ICMP ipv6 packets are dropped with applied control plane acl rules." ) result = False st.report_tc_fail("ft_controlplane_acl_ipv6_icmp_permit", "test_case_failed") config_save(vars.D1) st.log('rebooting the device.') st.reboot(vars.D1, 'fast') if not ip_obj.ping(dut=vars.D2, addresses=d1_ipaddress): st.error( "control plane ipv4 acl functionality is failed after reboot.") st.report_tc_fail("ft_controlplane_acl_reboot", "test_case_failed") result = False if not ip_obj.ping( dut=vars.D1, addresses=d1_ipv6address, interface="eth0", family="ipv6"): st.error( "control plane ipv6 acl functionality is failed after reboot.") st.report_tc_fail("ft_controlplane_acl_reboot", "test_case_failed") result = False if not result: st.report_fail("test_case_failed") else: st.report_pass("test_case_passed")