def test_confed_route_distribution_with_rmap(self): st.banner("Verify the behavior of Route-Maps over confederation peers") result = False network1 = '134.5.6.0/24' network2 = '134.5.7.0/24' network3 = '134.5.8.0' as_path = '200' access_list1 = 'test-access-list1' access_list2 = 'test-access-list2' access_list3 = 'test-access-list3' st.log( "Create access-lists and a route-map in DUT1, add to it permit, deny and AS-path prepending policies" ) # Create access-list test-access-list1 ipapi.config_access_list(topo['dut_list'][0], access_list1, network3 + '/24', 'permit', seq_num="1") # Create route-map and permit network3 ipapi.config_route_map_match_ip_address(topo['dut_list'][0], 'test-rmap', 'permit', '10', access_list1) # Add set option to prepend as-path 200 ipapi.config_route_map_set_aspath(topo['dut_list'][0], 'test-rmap', 'permit', '10', as_path) # Create access-list test-access-list2 ipapi.config_access_list(topo['dut_list'][0], access_list2, network1, 'deny', seq_num="2") # In route-map, deny network1 ipapi.config_route_map_match_ip_address(topo['dut_list'][0], 'test-rmap', 'deny', '20', access_list2) # Create access-list test-access-list3 ipapi.config_access_list(topo['dut_list'][0], access_list3, network2, 'permit', seq_num="3") # In route-map, permit network2 ipapi.config_route_map_match_ip_address(topo['dut_list'][0], 'test-rmap', 'permit', '30', access_list3) # Advertise three networks from leaf st.log( "Advertise the networks from DUT1 through BGP and associate with the route-map" ) bgpapi.advertise_bgp_network(topo['dut_list'][0], topo['D1_as'], network1, 'test-rmap', network_import_check=True) bgpapi.advertise_bgp_network(topo['dut_list'][0], topo['D1_as'], network2, 'test-rmap', network_import_check=True) bgpapi.advertise_bgp_network(topo['dut_list'][0], topo['D1_as'], network3 + '/24', 'test-rmap', network_import_check=True) st.log( "Verify in peer DUT2 the network configured in {} has the AS-path prepended" .format(access_list1)) # Verify that the neighbor has the as-path prepended output = bgpapi.show_bgp_ipvx_prefix(topo['dut_list'][1], prefix=network3, masklen=topo['D1_as']) for x in output: # type: basestring peer_asn = x['peerasn'] peer_asn = peer_asn.split() for each in peer_asn: if each == as_path: result = True if result: st.log("Pass: AS-Path {} found to be prepended with network {}/24". format(as_path, network3)) else: st.error( "Fail: AS-Path {} not found to be prepended".format(as_path)) # Verify that network1 is not present in ip route table st.log( "Verify that peer DUT2 not learnt the network configured as 'deny' in {}" .format(access_list2)) n1 = ipapi.verify_ip_route(topo['dut_list'][1], ip_address=network1) if n1 is False: result = result & True st.log("Pass: DUT2 did not learn network {}".format(network1)) else: result = result & False st.error("Fail: DUT2 learned the network {}".format(network1)) # Verify that network2 is present in ip route table st.log( "Verify that peer DUT2 learnt the network configured as 'permit' in {}" .format(access_list3)) n2 = ipapi.verify_ip_route(topo['dut_list'][1], ip_address=network2) if n2: result = result & True st.log("Pass: DUT2 learned the network {}".format(network2)) else: result = result & False st.error("Fail: DUT2 did not learn network {}".format(network2)) if not result: st.banner("Collecting techsupport") exec_all(True, [[ st.generate_tech_support, topo['dut_list'][0], "test_confed_route_distribution_with_rmap" ], [ st.generate_tech_support, topo['dut_list'][1], "test_confed_route_distribution_with_rmap" ]]) ipapi.config_route_map_mode(topo['dut_list'][0], 'test-rmap', 'permit', '10', config='no') # Clear applied configurations st.banner("Cleanup for TestFunction") ipapi.config_access_list(topo['dut_list'][0], 'test-access-list3', network2, 'permit', config='no', seq_num="3") ipapi.config_access_list(topo['dut_list'][0], 'test-access-list2', network1, 'deny', config='no', seq_num="2") ipapi.config_access_list(topo['dut_list'][0], 'test-access-list1', network3 + '/24', 'permit', config='no', seq_num="1") bgpapi.advertise_bgp_network(topo['dut_list'][0], topo['D1_as'], network1, 'test-rmap', config='no') bgpapi.advertise_bgp_network(topo['dut_list'][0], topo['D1_as'], network2, 'test-rmap', config='no') bgpapi.advertise_bgp_network(topo['dut_list'][0], topo['D1_as'], network3 + '/24', 'test-rmap', config='no') if result: st.report_pass("test_case_passed") else: st.report_fail("test_case_failed")
def test_ipv6_confed_with_rr(self): st.banner( "Verify Route Reflector behavior within a confederation of BGP v6 peers" ) st.banner( "Consider the right confederation iBGP AS and check Route Reflector functionality between the 3 iBGP Routers" ) network_ipv4 = '131.6.6.0/24' network_ipv6 = '3000:1::0/64' # iBGP AS is one of D2/D3/D4 ASN iBGP_as = topo['D2_as'] st.log("Advertise an IPv4 and an IPv6 network from DUT2 through BGP") bgpapi.config_bgp_network_advertise(topo['dut_list'][1], iBGP_as, network_ipv4, network_import_check=True) bgpapi.config_bgp_network_advertise(topo['dut_list'][1], iBGP_as, network_ipv6, addr_family='ipv6', config='yes', network_import_check=True) st.log( "Check the network on the 3rd iBGP peer DUT4 is not learnt because Route Reflector is not configured on peer DUT3" ) entries = bgpapi.get_ip_bgp_route(topo['dut_list'][3], family="ipv4", network=network_ipv4) entries1 = bgpapi.get_ip_bgp_route(topo['dut_list'][3], family="ipv6", network="3000:1::/64") if not entries and not entries1: st.log( "Pass: DUT4 did not learn routes without configuring Route Reflector on peer DUT3" ) else: st.error( "Fail: DUT4 learned route without configuring Route Reflector on peer DUT3" ) st.banner("Collecting techsupport") exec_all(True, [[ st.generate_tech_support, topo['dut_list'][1], "test_ipv6_confed_with_rr" ], [ st.generate_tech_support, topo['dut_list'][2], "test_ipv6_confed_with_rr" ], [ st.generate_tech_support, topo['dut_list'][3], "test_ipv6_confed_with_rr" ]]) # Clear applied configurations st.banner("Cleanup for TestFunction") bgpapi.config_bgp_network_advertise(topo['dut_list'][1], iBGP_as, network_ipv4, config='no') bgpapi.config_bgp_network_advertise(topo['dut_list'][1], iBGP_as, network_ipv6, addr_family='ipv6', config='no') st.report_fail("test_case_failed") st.log("Now configure Route Reflector on DUT3") bgpapi.create_bgp_route_reflector_client(topo.dut_list[2], iBGP_as, 'ipv4', topo['D3D4P1_neigh_ipv4'], 'yes') bgpapi.create_bgp_route_reflector_client(topo.dut_list[2], iBGP_as, 'ipv6', topo['D3D4P1_neigh_ipv6'], 'yes') st.wait(10) st.log("Now the routes should be learnt on the 3rd IBGP peer DUT4") entries2 = bgpapi.get_ip_bgp_route(topo['dut_list'][3], family="ipv4", network=network_ipv4) entries3 = bgpapi.get_ip_bgp_route(topo['dut_list'][3], family="ipv6", network="3000:1::/64") if entries2 and entries3: st.log("Pass: DUT4 learned the routes advertised by peer DUT2") else: st.error( "Fail: DUT4 did not learn the routes advertised by peer DUT2") st.banner("Collecting techsupport") exec_all(True, [[ st.generate_tech_support, topo['dut_list'][1], "test_ipv6_confed_with_rr" ], [ st.generate_tech_support, topo['dut_list'][2], "test_ipv6_confed_with_rr" ], [ st.generate_tech_support, topo['dut_list'][3], "test_ipv6_confed_with_rr" ]]) # Clear applied configurations st.banner("Cleanup for TestFunction") bgpapi.config_bgp_network_advertise(topo['dut_list'][1], iBGP_as, network_ipv4, config='no') bgpapi.config_bgp_network_advertise(topo['dut_list'][1], iBGP_as, network_ipv6, addr_family='ipv6', config='no') bgpapi.create_bgp_route_reflector_client(topo.dut_list[2], iBGP_as, 'ipv4', topo['D3D4P1_neigh_ipv4'], 'no') bgpapi.create_bgp_route_reflector_client(topo.dut_list[2], iBGP_as, 'ipv6', topo['D3D4P1_neigh_ipv6'], 'no') if entries2 and entries3: st.report_pass("test_case_passed") else: st.report_fail("test_case_failed")
def bgp_pre_config_cleanup(): st.banner("BGP MODULE CONFIG CLEANUP - START") bgp4nodelib.l3_ipv4v6_address_config_unconfig(config='no') st.banner("BGP MODULE CONFIG CLEANUP - END")
def bgp_confed_pre_config_cleanup(): st.banner("BGP CONFED CLASS CONFIG CLEANUP - START") bgp4nodelib.l3tc_vrfipv4v6_confed_bgp_config(config='no') st.banner("BGP RIF CLASS CONFIG CLEANUP - END")
def test_ipv6_confed_route_distribution(self): st.banner( "Verify the config of BGP v6 confederation and router advertisement" ) st.log( "Advertise a network from DUT1 and check if it is learnt on confederation peer DUT3" ) dut1_name = topo['dut_list'][0] dut3_name = topo['dut_list'][2] network_ipv4 = '131.5.6.0/24' network_ipv6 = '2000:1::0/64' # Advertise a network to peer bgpapi.config_bgp_network_advertise(dut1_name, topo['D1_as'], network_ipv4, network_import_check=True) bgpapi.config_bgp_network_advertise(dut1_name, topo['D1_as'], network_ipv6, addr_family='ipv6', config='yes', network_import_check=True) entries = bgpapi.get_ip_bgp_route(dut3_name, family="ipv4", network=network_ipv4) entries1 = bgpapi.get_ip_bgp_route(dut3_name, family="ipv6", network="2000:1::/64") if entries and entries1: st.log("Pass: Routes advertised by DUT1 found on DUT3") else: st.error("Fail: Route advertised by DUT1 not found on DUT3") st.banner("Collecting techsupport") exec_all(True, [[ st.generate_tech_support, topo['dut_list'][0], "test_ipv6_confed_route_distribution" ], [ st.generate_tech_support, topo['dut_list'][1], "test_ipv6_confed_route_distribution" ], [ st.generate_tech_support, topo['dut_list'][2], "test_ipv6_confed_route_distribution" ]]) # Clear applied configs st.banner("Cleanup for TestFunction") bgpapi.config_bgp_network_advertise(dut1_name, topo['D1_as'], network_ipv4, config='no') bgpapi.config_bgp_network_advertise(dut1_name, topo['D1_as'], network_ipv6, addr_family='ipv6', config='no') if entries and entries1: st.report_pass("test_case_passed") else: st.report_fail("test_case_failed")
def test_ft_l3_performance_enhancements_v4_bgp_session_failover_convergence_time( fixture_v4): ################# Author Details ################ # Name: Rakesh Kumar Vooturi # Email: [email protected] ################################################# # # Objective - FtOpSoRtPerfFn032 : Performance measurement for BGP Session Failover case # Measure time taken for the traffic ( corresponding to BGP routes ) to resume fully # (i.e RX rate = TX rate) after the BGP session flaps ( i.e BGP session goes down and then comes up # This is triggered using "clear ip bgp * " CLI command ). # ############### Test bed details ################ # TG --- DUT --- TG ################################################# # Configuring traffic stream on the TG interface tr1 = tg.tg_traffic_config( port_handle=tg_handler["tg_ph_2"], emulation_src_handle=h2['handle'], emulation_dst_handle=bgp_rtr1['route'][0]['handle'], circuit_endpoint_type='ipv4', mode='create', transmit_mode='continuous', length_mode='fixed', rate_pps=data.traffic_rate_pps, enable_stream_only_gen='0') # Verify the total route count using bcmcmd if not check_bcmcmd_route_count(dut, 50, "ipv4", def_v4_route_count, data.test_bgp_route_count): st.report_fail("route_table_not_updated_by_advertise_from_tg") # Verify the total route count count = verify_bgp_route_count(dut, family='ipv4', neighbor=data.neigh_ip_addr, state='Established') st.log("Route count: " + str(count)) if int(count) != int(data.test_bgp_route_count): st.report_fail("route_table_not_updated_by_advertise_from_tg") # Starting the TG traffic after clearing the DUT counters papi.clear_interface_counters(dut) tg.tg_traffic_control(action="run", handle=tr1['stream_id']) st.wait(25) # Verifying the BGP route count on the DUT if not check_intf_traffic_counters(dut, 20, "install"): st.report_fail("ingress_traffic_rate_not_matching_with_egress_rate") # Clearing the BGP session. st.log("Clearing the BGP session.") bgpfeature.clear_ip_bgp(dut) st.banner( "# Measuring Convergence time ( control plane + data plane ) taken for BGP session failover scenario on HWSKU {}" .format(hwsku_under_test)) # Taking the start time timestamp start_time = datetime.datetime.now() bgpfeature.config_bgp(dut=vars.D1, local_as=data.as_num, config='yes', neighbor=data.neigh_ip_addr, config_type_list=["connect"], connect='1') # Verify the total route count using bcmcmd if not check_bcmcmd_route_count(dut, 50, "ipv4", def_v4_route_count, data.test_bgp_route_count): st.report_fail("route_table_not_updated_by_advertise_from_tg") # Verify the total route count count = verify_bgp_route_count(dut, family='ipv4', neighbor=data.neigh_ip_addr, state='Established') st.log("Route count: " + str(count)) if int(count) != int(data.test_bgp_route_count): st.report_fail("route_table_not_updated_by_advertise_from_tg") # Taking the end time timestamp end_time = datetime.datetime.now() # Time taken for route installation st.log("Start Time: {}".format(start_time)) st.log("End Time: {}".format(end_time)) time_in_secs = end_time - start_time st.banner( "Convergence time ( control plane + data plane ) taken for BGP session failover scenario (After session up, time taken for BGP to re establish, learn and install the routes to hardware) on HWSKU {} = " .format(hwsku_under_test) + str(time_in_secs.seconds)) # Stopping the TG traffic tg.tg_traffic_control(action='stop', handle=tr1['stream_id']) st.report_pass("test_case_passed")
def test_ft_l3_performance_enhancements_v6_route_intstall_withdraw(fixture_v6): ################# Author Details ################ # Name: Rakesh Kumar Vooturi # Email: [email protected] ################################################# # # Objective - FtOpSoRtPerfFn042 : Performance measurement for IPv6 route installation in hardware # Measure time taken for routes to get installed into the hardware # (with fresh advertisement of routes ...but not due to any other trigger). # Objective - FtOpSoRtPerfFn043 : Performance measurement for IPv6 route withdraw in hardware # Measure time taken for routes to get removed from the hardware by stop advertising the Routes from neighbor. # ############### Test bed details ################ # TG --- DUT --- TG ################################################# # Withdraw the routes. ctrl1 = tg.tg_bgp_routes_control( handle=bgp_rtr2['conf']['handle'], route_handle=bgp_rtr2['route'][0]['handle'], mode='withdraw') st.log("TR_CTRL: " + str(ctrl1)) # Verify the total route count using bcmcmd if not check_bcmcmd_route_count(dut, 50, "ipv6", def_v6_route_count, 0): st.report_fail("route_table_not_cleared_by_withdraw_from_tg") # Verify the total route count count = verify_bgp_route_count(dut, family='ipv6', neighbor=data.neigh_ipv6_addr, state='Established') st.log("Route count: " + str(count)) if int(count) != 0: st.report_fail("route_table_not_cleared_by_withdraw_from_tg") if data.includeTraffic: # Configuring traffic stream on the TG interface tr2 = tg.tg_traffic_config( port_handle=tg_handler["tg_ph_2"], emulation_src_handle=h2['handle'], emulation_dst_handle=bgp_rtr2['route'][0]['handle'], circuit_endpoint_type='ipv6', mode='create', transmit_mode='continuous', length_mode='fixed', rate_pps=data.traffic_rate_pps, enable_stream_only_gen='0') # Starting the TG traffic after clearing the DUT counters papi.clear_interface_counters(dut) tg.tg_traffic_control(action="run", handle=tr2['stream_id']) st.banner( "# Measuring time taken for route installation of {} ipv6 routes on HWSKU {}" .format(data.test_bgp_route_count, hwsku_under_test)) # Taking the start time timestamp start_time = datetime.datetime.now() # Readvertise the routes. ctrl1 = tg.tg_bgp_routes_control( handle=bgp_rtr2['conf']['handle'], route_handle=bgp_rtr2['route'][0]['handle'], mode='readvertise') st.log("TR_CTRL: " + str(ctrl1)) # Verify the total route count using bcmcmd if not check_bcmcmd_route_count(dut, 50, "ipv6", def_v6_route_count, data.test_bgp_route_count): st.report_fail("route_table_not_updated_by_advertise_from_tg") if data.includeTraffic: st.wait(25) # Verifying the BGP route count on the DUT if not check_intf_traffic_counters(dut, 20, "install"): st.report_fail( "ingress_traffic_rate_not_matching_with_egress_rate") # Taking the end time timestamp end_time = datetime.datetime.now() # Verify the total route count count = verify_bgp_route_count(dut, family='ipv6', neighbor=data.neigh_ipv6_addr, state='Established') st.log("Route count: " + str(count)) if int(count) != int(data.test_bgp_route_count): st.report_fail("route_table_not_updated_by_advertise_from_tg") # Time taken for route installation st.log("Start Time: {}".format(start_time)) st.log("End Time: {}".format(end_time)) time_in_secs = end_time - start_time st.banner("Time taken for intsalling {} v6 routes on HWSKU {} = ".format( data.test_bgp_route_count, hwsku_under_test) + str(time_in_secs.seconds)) st.banner( "# Measuring time taken for route withdraw of {} ipv4 routes on HWSKU {}" .format(data.test_bgp_route_count, hwsku_under_test)) # Taking the start time timestamp start_time = datetime.datetime.now() # Withdraw the routes. ctrl1 = tg.tg_bgp_routes_control( handle=bgp_rtr2['conf']['handle'], route_handle=bgp_rtr2['route'][0]['handle'], mode='withdraw') st.log("TR_CTRL: " + str(ctrl1)) # Verify the total route count using bcmcmd if not check_bcmcmd_route_count(dut, 50, "ipv6", def_v6_route_count, 0): st.report_fail("route_table_not_cleared_by_withdraw_from_tg") if data.includeTraffic: # Verifying the BGP route count on the DUT if not check_intf_traffic_counters(dut, 20, "withdraw"): st.report_fail("egress_traffic_rate_not_zero") # Taking the end time timestamp end_time = datetime.datetime.now() # Verify the total route count count = verify_bgp_route_count(dut, family='ipv6', neighbor=data.neigh_ipv6_addr, state='Established') st.log("Route count: " + str(count)) if int(count) != 0: st.report_fail("route_table_not_cleared_by_withdraw_from_tg") # Time taken for route withdraw st.log("Start Time: {}".format(start_time)) st.log("End Time: {}".format(end_time)) time_in_secs = end_time - start_time st.banner("Time taken for withdrawing {} v6 routes on HWSKU {} = ".format( data.test_bgp_route_count, hwsku_under_test) + str(time_in_secs.seconds)) if data.includeTraffic: # Stopping the TG traffic tg.tg_traffic_control(action='stop', handle=tr2['stream_id']) st.report_pass("test_case_passed")
def verify_bum_traffic_mode(mode, tg_stream, skip_traffic_verify=False, duration=10): """ :param mode: :param tg_stream: :param skip_traffic_verify: :param duration: :return: """ if mode not in ["unknown-unicast", "unknown-multicast", "broadcast"]: st.log("Unsupported mode provided") return False st.banner("verifying {} traffic ".format(mode)) st.log("Clearing stats before sending traffic ...") tg.tg_traffic_control(action="clear_stats", port_handle=tg_handler["tg_ph_list"]) st.wait(2) if mode == 'broadcast': st.log("Enabling {} traffic ".format(mode)) tg.tg_traffic_config(port_handle=tg_handler["tg_ph_1"], mode='modify', duration=10, stream_id=tg_stream, mac_src="00:00:00:00:00:01", mac_dst="ff:ff:ff:ff:ff:ff", rate_pps=5000) elif mode == 'unknown-multicast': st.log("Enabling {} traffic ".format(mode)) tg.tg_traffic_config(port_handle=tg_handler["tg_ph_1"], mode='modify', duration=10, stream_id=tg_stream, mac_src="00:00:00:00:00:01", mac_dst="01:00:5e:01:02:03", rate_pps=5000) elif mode == 'unknown-unicast': st.log("Enabling {} traffic ".format(mode)) tg.tg_traffic_config(port_handle=tg_handler["tg_ph_1"], duration=10, mode='modify', stream_id=tg_stream, mac_src="00:00:00:00:00:01", mac_dst="00:00:00:00:00:02", rate_pps=5000) if not skip_traffic_verify: st.log("Starting of traffic from TGen") tg.tg_traffic_control(action='run', stream_handle=tg_stream, duration=10) st.wait(data.wait_stream_run) st.log("Stopping of traffic from TGen to get interface counters") tg.tg_traffic_control(action='stop', stream_handle=tg_stream) st.wait(data.wait_for_stats) 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"]) counter = tg_2_stats.rx.total_packets counter2 = tg_1_stats.tx.total_packets if counter2 == 0: st.report_fail("storm_control_traffic_verification_failed") counters_avg = counter / duration st.log("Average of counters are : {}".format(counters_avg)) st.log("Higher packet count value is : {}".format( data.higher_pkt_count)) st.log("Lower packet count value is : {}".format(data.lower_pkt_count)) if counters_avg > data.higher_pkt_count or counters_avg < data.lower_pkt_count: st.report_fail("storm_control_traffic_verification_failed") return True
def test_ft_tf_config_multi_threshold_rest(): """ Author : Prudvi Mangadu ([email protected]) """ tf_rest_support_checker() result = 1 e_pg_sh_port1, e_pg_sh_queue1, e_pg_sh_queue_name1, e_pg_sh_th_value1 = dut_port[ 0], 3, 'pg3', 59 _, _, e_pg_hr_queue_name1, e_pg_hr_th_value1 = dut_port[0], 3, 'pg3', 14 e_uc_port1, e_uc_queue1, e_uc_queue_name1, e_uc_th_value1 = dut_port[ 0], 4, 'uc4', 50 e_mc_port1, e_mc_queue1, e_mc_queue_name1, e_mc_th_value1 = dut_port[ 0], 1, 'mc1', 30 e_cpu_port1, e_cpu_queue1, e_cpu_queue_name1, e_cpu_th_value1 = 'CPU', 1, 'mc1', 10 set_rest_data = [{ "data": [{ "data": [[e_pg_sh_queue1, e_pg_sh_th_value1, e_pg_hr_th_value1]], "port": e_pg_sh_port1 }], "realm": "ingress-port-priority-group" }, { "data": [[e_uc_port1, e_uc_queue1, e_uc_th_value1]], "realm": "egress-uc-queue" }, { "data": [[e_mc_port1, e_mc_queue1, e_mc_th_value1]], "realm": "egress-mc-queue" }, { "data": [[e_cpu_queue1, e_cpu_th_value1]], "realm": "egress-cpu-queue" }] # REST SET st.banner("Configuring Threshold {} via REST".format( tf_rest_data.configure_bst_multi_thresholds)) if not rtapi.send_rest_request(vars.D1, tf_rest_data.feature, tf_rest_data.configure_bst_multi_thresholds, set_rest_data): st.error("Failed to SET {} via REST".format( tf_rest_data.configure_bst_multi_thresholds)) result = 0 else: st.log("--> Success: Configuring Threshold {} via REST".format( tf_rest_data.configure_bst_multi_thresholds)) # REST GET and Verify if not tf_config_common_call('REST_GET', e_pg_sh_th_value1, dut=vars.D1, threshold_type="priority-group", buffer_type='shared', index_name=e_pg_sh_queue_name1, port_alias=e_pg_sh_port1): result = 0 if not tf_config_common_call('REST_GET', e_pg_hr_th_value1, dut=vars.D1, threshold_type="priority-group", buffer_type='headroom', index_name=e_pg_hr_queue_name1, port_alias=e_pg_sh_port1): result = 0 if not tf_config_common_call('REST_GET', e_uc_th_value1, dut=vars.D1, threshold_type="queue", buffer_type='unicast', index_name=e_uc_queue_name1, port_alias=e_uc_port1): result = 0 if not tf_config_common_call('REST_GET', e_mc_th_value1, dut=vars.D1, threshold_type="queue", buffer_type='multicast', index_name=e_mc_queue_name1, port_alias=e_mc_port1): result = 0 if not tf_config_common_call('REST_GET', e_cpu_th_value1, dut=vars.D1, threshold_type="queue", buffer_type='multicast', index_name=e_cpu_queue_name1, port_alias=e_cpu_port1): result = 0 # CLI GET and Verify if not tf_config_common_call('CLI_GET', e_pg_sh_th_value1, dut=vars.D1, threshold_type="priority-group", buffer_type='shared', index_name=e_pg_sh_queue_name1, port_alias=e_pg_sh_port1): result = 0 if not tf_config_common_call('CLI_GET', e_pg_hr_th_value1, dut=vars.D1, threshold_type="priority-group", buffer_type='headroom', index_name=e_pg_hr_queue_name1, port_alias=e_pg_sh_port1): result = 0 if not tf_config_common_call('CLI_GET', e_uc_th_value1, dut=vars.D1, threshold_type="queue", buffer_type='unicast', index_name=e_uc_queue_name1, port_alias=e_uc_port1): result = 0 if not tf_config_common_call('CLI_GET', e_mc_th_value1, dut=vars.D1, threshold_type="queue", buffer_type='multicast', index_name=e_mc_queue_name1, port_alias=e_mc_port1): result = 0 if not tf_config_common_call('CLI_GET', e_cpu_th_value1, dut=vars.D1, threshold_type="queue", buffer_type='multicast', index_name=e_cpu_queue_name1, port_alias=e_cpu_port1): result = 0 # REST Clear if not tf_config_common_call('REST_CLEAR', 0, dut=vars.D1): result = 0 # REST GET and Verify if not tf_config_common_call('REST_GET', tf_rest_data.default_threshold_value, dut=vars.D1, threshold_type="priority-group", buffer_type='shared', index_name=e_pg_sh_queue_name1, port_alias=e_pg_sh_port1): result = 0 if not tf_config_common_call('REST_GET', tf_rest_data.default_threshold_value, dut=vars.D1, threshold_type="priority-group", buffer_type='headroom', index_name=e_pg_hr_queue_name1, port_alias=e_pg_sh_port1): result = 0 if not tf_config_common_call('REST_GET', tf_rest_data.default_threshold_value, dut=vars.D1, threshold_type="queue", buffer_type='unicast', index_name=e_uc_queue_name1, port_alias=e_uc_port1): result = 0 if not tf_config_common_call('REST_GET', tf_rest_data.default_threshold_value, dut=vars.D1, threshold_type="queue", buffer_type='multicast', index_name=e_mc_queue_name1, port_alias=e_mc_port1): result = 0 if not tf_config_common_call('REST_GET', tf_rest_data.default_threshold_value, dut=vars.D1, threshold_type="queue", buffer_type='multicast', index_name=e_cpu_queue_name1, port_alias=e_cpu_port1): result = 0 # CLI GET and Verify if not tf_config_common_call('CLI_GET', tf_rest_data.default_threshold_value, dut=vars.D1, threshold_type="priority-group", buffer_type='shared', index_name=e_pg_sh_queue_name1, port_alias=e_pg_sh_port1): result = 0 if not tf_config_common_call('CLI_GET', tf_rest_data.default_threshold_value, dut=vars.D1, threshold_type="priority-group", buffer_type='headroom', index_name=e_pg_hr_queue_name1, port_alias=e_pg_sh_port1): result = 0 if not tf_config_common_call('CLI_GET', tf_rest_data.default_threshold_value, dut=vars.D1, threshold_type="queue", buffer_type='unicast', index_name=e_uc_queue_name1, port_alias=e_uc_port1): result = 0 if not tf_config_common_call('CLI_GET', tf_rest_data.default_threshold_value, dut=vars.D1, threshold_type="queue", buffer_type='multicast', index_name=e_mc_queue_name1, port_alias=e_mc_port1): result = 0 if not tf_config_common_call('CLI_GET', tf_rest_data.default_threshold_value, dut=vars.D1, threshold_type="queue", buffer_type='multicast', index_name=e_cpu_queue_name1, port_alias=e_cpu_port1): result = 0 tf_unconfig() report_result(result)
def tf_config_common_call(call_type, th_value, **kwargs): """ Common function to make both CLI and REST threshold feature calls """ result2 = 1 dut = kwargs['dut'] if call_type != "REST_CLEAR": threshold_type = kwargs['threshold_type'] buffer_type = kwargs['buffer_type'] index_name = kwargs['index_name'] port_alias = kwargs['port_alias'] index = int(re.findall(r"\d+", kwargs['index_name'])[0]) if call_type == "REST_GET" or call_type == 'REST_GET_PORTS_CHECK': st.banner("Verifying Threshold {} {} config via REST".format( threshold_type, buffer_type)) if any("/" in interface for interface in make_list(port_alias)): port_alias = st.get_other_names(vars.D1, make_list(port_alias))[0] get_rest_data = tfapi.get_threshold_rest_data( threshold_type=threshold_type, buffer_type=buffer_type, port=port_alias) rv_data = rtapi.send_rest_request(dut, tf_rest_data.feature, tf_rest_data.get_bst_thresholds, get_rest_data) if not rv_data: st.error("Failed to GET Threshold {} {} via REST".format( threshold_type, buffer_type)) return 0 if rv_data: resp = json.loads(rv_data.text) if call_type == 'REST_GET_PORTS_CHECK': st.banner("Validating interfaces in {} {} REST Data ".format( threshold_type, buffer_type)) if not check_ports_from_rest_output(resp, threshold_type, buffer_type, tf_rest_data.all_ports): result2 = 0 if result2: st.log( "--> Success: Interface Validation of {} {} REST DATA" .format(threshold_type, buffer_type)) get_value = get_threshold_from_rest_output(resp, threshold_type, buffer_type, port_alias, index) if get_value is None: return 0 st.log( "REST GET Threshold Value {} {} on Port:{}, Index:{}".format( get_value, type(get_value), port_alias, index)) st.log("Configured Threshold Value {} {}".format( th_value, type(th_value))) if not get_value == int(th_value): st.error("Failed to Verify Threshold {} {} via REST".format( threshold_type, buffer_type)) return 0 st.log("--> Success: Verifying Threshold {} {} config via REST".format( threshold_type, buffer_type)) return 1 and result2 elif call_type == "REST_SET": st.banner("Configuring Threshold {} {} via REST".format( threshold_type, buffer_type)) if any("/" in interface for interface in make_list(port_alias)): port_alias = st.get_other_names(vars.D1, make_list(port_alias))[0] set_rest_data = tfapi.set_threshold_rest_data( threshold_type=threshold_type, port_alias=port_alias, index=index, buffer_type=buffer_type, value=th_value) if not rtapi.send_rest_request(dut, tf_rest_data.feature, tf_rest_data.configure_bst_thresholds, set_rest_data): st.error("Failed to SET Threshold {} {} via REST".format( threshold_type, buffer_type)) return 0 st.log("--> Success: Configuring Threshold {} {} via REST".format( threshold_type, buffer_type)) return 1 elif call_type == 'CLI_GET': st.banner("Verifying Threshold {} {} config via CLI".format( threshold_type, buffer_type)) api_data = { 'threshold_type': threshold_type, 'buffer_type': buffer_type, 'port_alias': port_alias, index_name: th_value } if not tfapi.verify_threshold(dut, **api_data): st.error("Failed to Verify Threshold {} {} via CLI".format( threshold_type, buffer_type)) return 0 st.log("--> Success: Verifying Threshold {} {} config via CLI".format( threshold_type, buffer_type)) return 1 elif call_type == 'REST_CLEAR': st.banner("Performing Clear BST thresholds via REST") if not rtapi.send_rest_request(dut, tf_rest_data.feature, tf_rest_data.clear_bst_thresholds, {}): st.error('REST: Clear BST thresholds call failed') return 0 st.log("--> Success: Performing Clear thresholds via REST") return 1 else: st.error("Unknown tf call_type : {}".format(call_type)) return 0