def static_route_verify(): st.log("Ip address configuration verification") if not poll_wait(ip_obj.verify_interface_ip_address, 60, vars.D1, vars.D1T1P1, "{}/{}".format(data.ipv4_address, data.mask), family="ipv4"): st.report_fail("ip_routing_int_create_fail", vars.D1T1P1) else: st.log("Successfully added ipv4 address on TGen connected interface") st.log("static route configuration verification") if not poll_wait(ip_obj.verify_ip_route, 60, vars.D1, "ipv4", ip_address=data.ipv4_address_network, type="S"): st.error("Static route - {} information not exists.".format( data.ipv4_address_network)) st.report_fail("ip_static_route_create_fail", data.ipv4_address_network) else: st.log("creation of static route is successful")
def test_mgmt_vrf_static_dhcp(): config_ip_addr_interface(vars.D1, "eth0", mgmt_vrf.staticip, 20, mgmt_vrf.af_ipv4) if not poll_wait(verify_interface_ip_address, 10, vars.D1, "eth0", mgmt_vrf.staticip + '/20', family="ipv4", vrfname='mgmt'): st.log("IP Address not matched") delete_ip_interface(vars.D1, "eth0", mgmt_vrf.staticip, 20, mgmt_vrf.af_ipv4) st.report_fail("mgmt_vrf_static_dhcp", "failed") output = get_ifconfig(vars.D1, "eth0") if output[0]['broadcast'][0] == '0.0.0.0': st.log("Broadcast IP address not assigned") delete_ip_interface(vars.D1, "eth0", mgmt_vrf.staticip, 20, mgmt_vrf.af_ipv4) st.report_fail("test_case_failed") delete_ip_interface(vars.D1, "eth0", mgmt_vrf.staticip, 20, mgmt_vrf.af_ipv4) if not poll_wait(get_ifconfig_inet, 30, vars.D1, 'eth0'): st.log("IP Address not assigned to eth0 after dhcp") st.report_fail("mgmt_vrf_static_dhcp", "failed") st.report_pass("mgmt_vrf_static_dhcp", "successful")
def test_mgmt_vrf_tacacs(): tacacs_params = st.get_service_info(vars.D1, "tacacs") if not set_aaa_authentication_properties(vars.D1, 'failthrough', 'enable'): st.report_fail("authentication failthrough config fail") set_tacacs_server(vars.D1, 'add', tacacs_params.hosts[0].ip, tacacs_params.hosts[0].tcp_port, tacacs_params.hosts[0].timeout, tacacs_params.hosts[0].passkey, tacacs_params.hosts[0].auth_type, tacacs_params.hosts[0].priority, use_mgmt_vrf=True) if not verify_tacacs_server( vars.D1, tacacs_params.hosts[0].ip, tacacs_params.hosts[0].tcp_port, tacacs_params.hosts[0].timeout, tacacs_params.hosts[0].passkey, tacacs_params.hosts[0].auth_type, tacacs_params.hosts[0].priority): st.report_fail("Tacacs_server_configs_are_not_successful", tacacs_params.hosts[0].ip) set_aaa_authentication_properties(vars.D1, 'login', 'tacacs+ local') ip_addr = get_ifconfig_inet(vars.D1, 'eth0') if not ip_addr: st.report_fail('ip_verification_fail') if not poll_wait(connect_to_device, 10, ip_addr[0], mgmt_vrf.tacusername, mgmt_vrf.tacpassword, mgmt_vrf.protocol, mgmt_vrf.ssh_port): tacacs_cleanup(vars.D1, tacacs_params) st.report_fail("mgmt_vrf_tacacs", "failed") tacacs_cleanup(vars.D1, tacacs_params) st.report_pass("mgmt_vrf_tacacs", "successful")
def test_ft_erspan_portchannel_shut_noshut(): """ Author: Kanala Ramprakash Reddy ( [email protected]) TC1 FtOpSoSyErspanFn020: Verify that ERSPAN is working as expected after portchannel shut/no shut. :return: """ st.log("############### Test started to check ERSPAN status between multiple link flaps###############") st.log("Creating mirror session") mirror.create_session(vars.D1, session_name=data.mirror_session, gre_type=data.gre_type, dscp=data.dscp, ttl=data.ttl, queue=data.queue, src_ip=data.ip_T1D1P2, dst_ip=data.ip_T1D2P1) st.log("Creating ACL Policy") acl_dscp.config_classifier_table(vars.D1, enable='create', match_type="fields", class_name=data.acl_rule) acl_dscp.config_classifier_table(vars.D1, enable='yes', class_criteria="--src-ip", class_name=data.acl_rule, criteria_value=data.src_ip_mask, match_type="fields") acl_dscp.config_flow_update_table(vars.D1, policy_name=data.acl_table_name, flow='add', policy_type=data.type, class_name=data.acl_rule, priority_value=data.priority, description=data.description) acl_dscp.config_flow_update_table(vars.D1, policy_name=data.acl_table_name, flow='update', policy_type=data.type, class_name=data.acl_rule, priority_option='--mirror-session', priority_value=data.mirror_action) stream = data.tg1.tg_traffic_config(port_handle=data.tg_ph_1, mode='create', transmit_mode='continuous', length_mode='fixed', rate_pps=data.rate_pps, l2_encap='ethernet_ii', mac_src='00:0a:01:00:00:01', mac_dst=dut_mac, l3_protocol="ipv4", ip_src_addr=data.ip_T1D1P1, ip_dst_addr=data.ip_T1D1P2)['stream_id'] intf_obj.clear_interface_counters(vars.D1) st.log("Starting the traffic") data.tg1.tg_traffic_control(action='run', stream_handle=stream) for _ in range(5): intf_obj.interface_shutdown(vars.D1, [vars.D1D2P1], skip_verify=True) if not poll_wait(mirror.verify_session_all, 20, vars.D1, mirror_type="erspan", status="inactive", session_name=data.mirror_session): st.error("Mirror session status should be inactive after port shutdown") data.flag = 0 intf_obj.interface_noshutdown(vars.D1, [vars.D1D2P1], skip_verify=True) if not poll_wait(mirror.verify_session_all, 20, vars.D1, mirror_type="erspan", status="active", session_name=data.mirror_session): st.error("Mirror session status should be active after port startup") data.flag = 0 data.tg1.tg_traffic_control(action='stop', stream_handle=stream) if data.flag == 0: st.report_fail("test_case_failed") else: st.report_pass("test_case_passed")
def bgp_confed_pre_config(): st.banner("BGP CONFED CLASS CONFIG - START") bgp4nodelib.l3tc_vrfipv4v6_confed_bgp_config(config='yes') # BGP Neighbour Verification if not poll_wait(bgp4nodelib.l3tc_vrfipv4v6_address_confed_bgp_check, 10, config_type='all'): st.error("Neighbour is failed to Establish between DUTs") st.report_fail('test_case_failed') st.log( "Getting all topology info related to connectivity / TG and other parameters between duts" ) st.banner("BGP CONFED CLASS CONFIG - END")
def test_ft_tacacs_modify_server_parameters(): """ Author: Karthik Kumar Goud Battula([email protected]) This Testcase covers the below scenarios Scenario-1: Verify device behavior when TACACS+ application parameters (valid and invalid) are modified while traffic is running. Scenario-2: Verify that the key and timeout options default to global but may be specified to unique values on a per Server basis. Scenario-3: Verify that the NAS will stop communicating with the current server is the server is down after the duration of the configured server timeout or the default timeout value Scenario-4: Verify that Taccacs server key can be configured with more that 4 special characters """ invalid_l4_port = '59' invalid_pass_key = "key123" invalid_timeout = '10' invalid_ip_addr = '10.10.10.1' tacacs_params = st.get_service_info(vars.D1, "tacacs") tacacs_obj.set_tacacs_server(vars.D1, 'delete', tacacs_params.hosts[2].ip) tacacs_obj.set_tacacs_properties(vars.D1, 'passkey', 'secretstring') st.log("Configuring global tacacs server key with special characters") tacacs_obj.set_tacacs_properties(vars.D1, 'passkey', data.passkey) st.log( "Check client authentication by modifing ip address,timeout,passkey") tacacs_obj.set_tacacs_server(vars.D1, 'add', invalid_ip_addr, invalid_l4_port, invalid_timeout, invalid_pass_key, data.auth_type, data.priority_server2) st.log( "Trying to SSH to the device when TACACS+ server is configured with invalid parameters" ) if ssh_obj.connect_to_device(data.ip_address, data.username, data.password, data.protocol, data.ssh_port): st.log( "Deleting the TACACS+ server which is invalid for failed scenario") tacacs_obj.set_tacacs_server(vars.D1, 'delete', invalid_ip_addr) st.report_fail("Login_to_DUT_via_SSH_is_failed") st.log("Deleting the TACACS+ server which is invalid") tacacs_obj.set_tacacs_server(vars.D1, 'delete', invalid_ip_addr) st.log("Creating valid TACACS+ server") tacacs_obj.set_tacacs_server(vars.D1, 'add', data.tacacs_ser_ip_1, data.tcp_port, data.timeout, data.passkey, data.auth_type, data.priority) st.wait(2, "sync the tacacs server after config changes") st.log( "Trying to SSH to the device with TACACS+ server which is configured with the valid parameters" ) if not poll_wait(ssh_obj.connect_to_device, 10, data.ip_address, data.username, data.password, data.protocol, data.ssh_port): debug_info("test_ft_tacacs_modify_server_parameters", data.tacacs_ser_ip_1) st.report_fail("Login_to_DUT_via_SSH_is_failed") st.report_pass("test_case_passed")
def mgmt_vrf_prolog(): global vars vars = st.ensure_min_topology("D1") ip = mutils.ensure_service_params(vars.D1, "chef", "ip") username = mutils.ensure_service_params(vars.D1, "chef", "username") password = mutils.ensure_service_params(vars.D1, "chef", "password") st.log("Setting the date on DUT") if not sync_with_server_time(vars.D1, ip, username, password): st.log("Failed to set time") st.wait(mgmt_vrf.wait_time) mvrf.config(vars.D1) enable_ssh_in_user_vrf(vars.D1, config='add', vrf_name='mgmt') if not poll_wait(get_ifconfig_inet, 30, vars.D1, 'eth0'): st.log("IP Address not assigned to eth0 after prologue") mgmt_vrf_epilog() st.report_fail("mgmt_vrf_eth0_bind_fail")
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 config_ntp_server_on_config_db_file(dut, iplist): st.log("Configuring NTP servers in Config_db file") add_ntp_servers(dut, iplist=iplist) st.log("verifying ntp service status") if verify_ntp_service_status(vars.D1, 'active (running)'): st.log("ntpd is running") else: st.log("ntpd is exited and restarting ntp service") service_operations(vars.D1, 'ntp', action="restart") if not poll_wait( verify_ntp_server_details, 300, dut, iplist, remote=iplist): st.log("ip not matching") st.report_fail("operation_failed") if not verify_ntp_service_status( dut, 'active (running)', iteration=65, delay=2): st.log("ntp is exited") st.report_fail("operation_failed")
def mirror_action_config(): mirror_args = { "session_name": data.session_name, "gre_type": data.gre_type, "dscp": data.dscp, "ttl": data.ttl, "queue": data.queue, "src_ip": data.source_ip, "dst_ip": data.destination_ip } retval = mirror.create_session_table(vars.D1, **mirror_args) if not retval: st.log("Failed to create mirror session using json file.") st.report_fail("operation_failed") if not poll_wait(sconf_obj.verify_running_config, 60, vars.D1, "MIRROR_SESSION", "Mirror_Ses", "dst_ip", "15.1.1.2"): st.log("Failed to show mirror session details in running config.") st.report_fail("operation_failed")
def mirror_action_verify(): mirror_args = { "session_name": data.session_name, "gre_type": data.gre_type, "dscp": data.dscp, "ttl": data.ttl, "queue": data.queue, "src_ip": data.source_ip, "dst_ip": data.destination_ip } if not mirror.verify_session(vars.D1, **mirror_args): st.log("failed to show mirror session details after reboot.") st.report_fail("operation_failed") if not poll_wait(sconf_obj.verify_running_config, 60, vars.D1, "MIRROR_SESSION", "Mirror_Ses", "dst_ip", "15.1.1.2"): st.log( "failed to show mirror session details in running config after reboot." ) st.report_fail("operation_failed")
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 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 l3_performance_enhancements_module_hooks(request): global vars global tg_handler global tg global dut1 global dut2 global dut3 global dut4 global dut1_to_tg_port_1 global dut1_to_dut2_port_1 global dut2_to_dut1_port_1 global dut1_to_dut3_port_1 global dut3_to_dut1_port_1 global dut2_to_dut4_port_1 global dut4_to_dut2_port_1 global dut3_to_dut4_port_1 global dut4_to_dut3_port_1 global dut4_to_tg_port_1 global hwsku_under_test1 global hwsku_under_test2 global hwsku_under_test3 global hwsku_under_test4 global def_v4_route_count_d1 global def_v4_route_count_d4 global def_v6_route_count_d1 global def_v6_route_count_d4 # Min topology verification st.log("Ensuring minimum topology") vars = st.ensure_min_topology("D1D2:1", "D1D3:1", "D2D4:1", "D3D4:1", "D1T1:1", "D4T1:1") # Initialize TG and TG port handlers tg_handler = tgapi.get_handles(vars, [vars.T1D1P1, vars.T1D4P1]) tg = tg_handler["tg"] # Test setup details dut1 = vars.D1 dut2 = vars.D2 dut3 = vars.D3 dut4 = vars.D4 dut1_to_tg_port_1 = vars.D1T1P1 dut1_to_dut2_port_1 = vars.D1D2P1 dut2_to_dut1_port_1 = vars.D2D1P1 dut1_to_dut3_port_1 = vars.D1D3P1 dut3_to_dut1_port_1 = vars.D3D1P1 dut2_to_dut4_port_1 = vars.D2D4P1 dut4_to_dut2_port_1 = vars.D4D2P1 dut3_to_dut4_port_1 = vars.D3D4P1 dut4_to_dut3_port_1 = vars.D4D3P1 dut4_to_tg_port_1 = vars.D4T1P1 hwsku_under_test1 = basic_obj.get_hwsku(dut1) hwsku_under_test2 = basic_obj.get_hwsku(dut2) hwsku_under_test3 = basic_obj.get_hwsku(dut3) hwsku_under_test4 = basic_obj.get_hwsku(dut4) # Module Configuration st.log("L3 Performance Enhancements Module Configuration.") # Configuring v4/v6 routing interfaces on the DUT. st.log("Configuring IPv4 routing interfaces.") ipfeature.config_ip_addr_interface(dut1, dut1_to_tg_port_1, data.dut1_to_tg_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut1, dut1_to_dut2_port_1, data.dut1_to_dut2_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut1, dut1_to_dut3_port_1, data.dut1_to_dut3_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut2, dut2_to_dut1_port_1, data.dut2_to_dut1_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut2, dut2_to_dut4_port_1, data.dut2_to_dut4_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut3, dut3_to_dut1_port_1, data.dut3_to_dut1_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut3, dut3_to_dut4_port_1, data.dut3_to_dut4_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut4, dut4_to_dut2_port_1, data.dut4_to_dut2_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut4, dut4_to_dut3_port_1, data.dut4_to_dut3_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.config_ip_addr_interface(dut4, dut4_to_tg_port_1, data.dut4_to_tg_port_1_ip, data.ip_prefixlen, family="ipv4") st.log("Configuring IPv6 routing interfaces.") ipfeature.config_ipv6(dut1, action='enable') ipfeature.config_ip_addr_interface(dut1, dut1_to_tg_port_1, data.dut1_to_tg_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ip_addr_interface(dut1, dut1_to_dut2_port_1, data.dut1_to_dut2_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ip_addr_interface(dut1, dut1_to_dut3_port_1, data.dut1_to_dut3_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ipv6(dut2, action='enable') ipfeature.config_ip_addr_interface(dut2, dut2_to_dut1_port_1, data.dut2_to_dut1_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ip_addr_interface(dut2, dut2_to_dut4_port_1, data.dut2_to_dut4_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ipv6(dut3, action='enable') ipfeature.config_ip_addr_interface(dut3, dut3_to_dut1_port_1, data.dut3_to_dut1_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ip_addr_interface(dut3, dut3_to_dut4_port_1, data.dut3_to_dut4_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ipv6(dut4, action='enable') ipfeature.config_ip_addr_interface(dut4, dut4_to_dut2_port_1, data.dut4_to_dut2_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ip_addr_interface(dut4, dut4_to_dut3_port_1, data.dut4_to_dut3_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.config_ip_addr_interface(dut4, dut4_to_tg_port_1, data.dut4_to_tg_port_1_ip6, data.ipv6_prefixlen, family="ipv6") # Configuring BGP router and v4/v6 neighbors on the DUT. st.log("Configuring BGP routers.") bgpfeature.create_bgp_router(dut1, data.as_num_1, '') bgpfeature.create_bgp_router(dut2, data.as_num_2, '') bgpfeature.create_bgp_router(dut3, data.as_num_3, '') bgpfeature.create_bgp_router(dut4, data.as_num_4, '') st.log("Configuring BGP IPv4 neighbors.") bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.tg_to_dut1_port_1_ip, data.remote_as_num1) bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.dut2_to_dut1_port_1_ip, data.as_num_2) bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.dut3_to_dut1_port_1_ip, data.as_num_3) bgpfeature.create_bgp_neighbor(dut2, data.as_num_2, data.dut1_to_dut2_port_1_ip, data.as_num_1) bgpfeature.create_bgp_neighbor(dut2, data.as_num_2, data.dut4_to_dut2_port_1_ip, data.as_num_4) bgpfeature.create_bgp_neighbor(dut3, data.as_num_3, data.dut1_to_dut3_port_1_ip, data.as_num_1) bgpfeature.create_bgp_neighbor(dut3, data.as_num_3, data.dut4_to_dut3_port_1_ip, data.as_num_4) bgpfeature.create_bgp_neighbor(dut4, data.as_num_4, data.dut2_to_dut4_port_1_ip, data.as_num_2) bgpfeature.create_bgp_neighbor(dut4, data.as_num_4, data.dut3_to_dut4_port_1_ip, data.as_num_3) st.log("Configuring BGP IPv6 neighbors.") bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.tg_to_dut1_port_1_ip6, data.remote_as_num1, family="ipv6") bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.dut2_to_dut1_port_1_ip6, data.as_num_2, family="ipv6") bgpfeature.create_bgp_neighbor(dut1, data.as_num_1, data.dut3_to_dut1_port_1_ip6, data.as_num_3, family="ipv6") bgpfeature.create_bgp_neighbor(dut2, data.as_num_2, data.dut1_to_dut2_port_1_ip6, data.as_num_1, family="ipv6") bgpfeature.create_bgp_neighbor(dut2, data.as_num_2, data.dut4_to_dut2_port_1_ip6, data.as_num_4, family="ipv6") bgpfeature.create_bgp_neighbor(dut3, data.as_num_3, data.dut1_to_dut3_port_1_ip6, data.as_num_1, family="ipv6") bgpfeature.create_bgp_neighbor(dut3, data.as_num_3, data.dut4_to_dut3_port_1_ip6, data.as_num_4, family="ipv6") bgpfeature.create_bgp_neighbor(dut4, data.as_num_4, data.dut2_to_dut4_port_1_ip6, data.as_num_2, family="ipv6") bgpfeature.create_bgp_neighbor(dut4, data.as_num_4, data.dut3_to_dut4_port_1_ip6, data.as_num_3, family="ipv6") # st.log("Configuring BGP as-path multipath-relax.") bgpfeature.create_bgp_best_path(dut1, data.as_num_1, "as-path multipath-relax") bgpfeature.create_bgp_best_path(dut2, data.as_num_2, "as-path multipath-relax") bgpfeature.create_bgp_best_path(dut3, data.as_num_3, "as-path multipath-relax") bgpfeature.create_bgp_best_path(dut4, data.as_num_4, "as-path multipath-relax") # Get the default route count from DUT def_v4_route_count_d1 = asicapi.bcmcmd_route_count_hardware(dut1) def_v4_route_count_d4 = asicapi.bcmcmd_route_count_hardware(dut4) def_v6_route_count_d1 = asicapi.bcmcmd_ipv6_route_count_hardware(dut1) def_v6_route_count_d4 = asicapi.bcmcmd_ipv6_route_count_hardware(dut4) # Verifying the BGP neighborship st.wait(20) st.log("Verifying the BGP IPv4 neighborships.") if not poll_wait(bgpfeature.verify_bgp_summary, 120, dut1, neighbor=data.dut2_to_dut1_port_1_ip,state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut1_port_1_ip) if not poll_wait(bgpfeature.verify_bgp_summary, 120, dut1, neighbor=data.dut3_to_dut1_port_1_ip,state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut1_port_1_ip) if not poll_wait(bgpfeature.verify_bgp_summary, 120, dut2, neighbor=data.dut1_to_dut2_port_1_ip,state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut2_port_1_ip) if not poll_wait(bgpfeature.verify_bgp_summary, 120, dut2, neighbor=data.dut4_to_dut2_port_1_ip,state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut2_port_1_ip) # if not bgpfeature.verify_bgp_summary(dut1, neighbor=data.dut2_to_dut1_port_1_ip, state='Established'): # st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut1_port_1_ip) # if not bgpfeature.verify_bgp_summary(dut1, neighbor=data.dut3_to_dut1_port_1_ip, state='Established'): # st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut1_port_1_ip) # if not bgpfeature.verify_bgp_summary(dut2, neighbor=data.dut1_to_dut2_port_1_ip, state='Established'): # st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut2_port_1_ip) # if not bgpfeature.verify_bgp_summary(dut2, neighbor=data.dut4_to_dut2_port_1_ip, state='Established'): # st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut2_port_1_ip) if not bgpfeature.verify_bgp_summary(dut3, neighbor=data.dut1_to_dut3_port_1_ip, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut3_port_1_ip) if not bgpfeature.verify_bgp_summary(dut3, neighbor=data.dut4_to_dut3_port_1_ip, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut3_port_1_ip) if not bgpfeature.verify_bgp_summary(dut4, neighbor=data.dut2_to_dut4_port_1_ip, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut4_port_1_ip) if not bgpfeature.verify_bgp_summary(dut4, neighbor=data.dut3_to_dut4_port_1_ip, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut4_port_1_ip) st.log("Verifying the BGP IPv6 neighborships.") if not bgpfeature.verify_bgp_summary(dut1, family='ipv6', neighbor=data.dut2_to_dut1_port_1_ip6, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut1_port_1_ip6) if not bgpfeature.verify_bgp_summary(dut1, family='ipv6', neighbor=data.dut3_to_dut1_port_1_ip6, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut1_port_1_ip6) if not bgpfeature.verify_bgp_summary(dut2, family='ipv6', neighbor=data.dut1_to_dut2_port_1_ip6, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut2_port_1_ip6) if not bgpfeature.verify_bgp_summary(dut2, family='ipv6', neighbor=data.dut4_to_dut2_port_1_ip6, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut2_port_1_ip6) if not bgpfeature.verify_bgp_summary(dut3, family='ipv6', neighbor=data.dut1_to_dut3_port_1_ip6, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut1_to_dut3_port_1_ip6) if not bgpfeature.verify_bgp_summary(dut3, family='ipv6', neighbor=data.dut4_to_dut3_port_1_ip6, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut4_to_dut3_port_1_ip6) if not bgpfeature.verify_bgp_summary(dut4, family='ipv6', neighbor=data.dut2_to_dut4_port_1_ip6, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut2_to_dut4_port_1_ip6) if not bgpfeature.verify_bgp_summary(dut4, family='ipv6', neighbor=data.dut3_to_dut4_port_1_ip6, state='Established'): st.report_fail("bgp_ip_peer_establish_fail", data.dut3_to_dut4_port_1_ip6) yield # Module Cleanup st.log("L3 Performance Enhancements Module Cleanup.") st.log("Unconfiguring IPv4 routing interfaces.") ipfeature.delete_ip_interface(dut1, dut1_to_tg_port_1, data.dut1_to_tg_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut1, dut1_to_dut2_port_1, data.dut1_to_dut2_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut1, dut1_to_dut3_port_1, data.dut1_to_dut3_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut2, dut2_to_dut1_port_1, data.dut2_to_dut1_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut2, dut2_to_dut4_port_1, data.dut2_to_dut4_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut3, dut3_to_dut1_port_1, data.dut3_to_dut1_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut3, dut3_to_dut4_port_1, data.dut3_to_dut4_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut4, dut4_to_dut2_port_1, data.dut4_to_dut2_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut4, dut4_to_dut3_port_1, data.dut4_to_dut3_port_1_ip, data.ip_prefixlen, family="ipv4") ipfeature.delete_ip_interface(dut4, dut4_to_tg_port_1, data.dut4_to_tg_port_1_ip, data.ip_prefixlen, family="ipv4") st.log("Unconfiguring IPv6 routing interfaces.") ipfeature.delete_ip_interface(dut1, dut1_to_tg_port_1, data.dut1_to_tg_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.delete_ip_interface(dut1, dut1_to_dut2_port_1, data.dut1_to_dut2_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.delete_ip_interface(dut1, dut1_to_dut3_port_1, data.dut1_to_dut3_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.delete_ip_interface(dut2, dut2_to_dut1_port_1, data.dut2_to_dut1_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.delete_ip_interface(dut2, dut2_to_dut4_port_1, data.dut2_to_dut4_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.delete_ip_interface(dut3, dut3_to_dut1_port_1, data.dut3_to_dut1_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.delete_ip_interface(dut3, dut3_to_dut4_port_1, data.dut3_to_dut4_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.delete_ip_interface(dut4, dut4_to_dut2_port_1, data.dut4_to_dut2_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.delete_ip_interface(dut4, dut4_to_dut3_port_1, data.dut4_to_dut3_port_1_ip6, data.ipv6_prefixlen, family="ipv6") ipfeature.delete_ip_interface(dut4, dut4_to_tg_port_1, data.dut4_to_tg_port_1_ip6, data.ipv6_prefixlen, family="ipv6") st.log("Unconfiguring BGP IPv4 neighbors.") bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.tg_to_dut1_port_1_ip, data.remote_as_num1) bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.dut2_to_dut1_port_1_ip, data.as_num_2) bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.dut3_to_dut1_port_1_ip, data.as_num_3) bgpfeature.delete_bgp_neighbor(dut2, data.as_num_2, data.dut1_to_dut2_port_1_ip, data.as_num_1) bgpfeature.delete_bgp_neighbor(dut2, data.as_num_2, data.dut4_to_dut2_port_1_ip, data.as_num_4) bgpfeature.delete_bgp_neighbor(dut3, data.as_num_3, data.dut1_to_dut3_port_1_ip, data.as_num_1) bgpfeature.delete_bgp_neighbor(dut3, data.as_num_3, data.dut4_to_dut3_port_1_ip, data.as_num_4) bgpfeature.delete_bgp_neighbor(dut4, data.as_num_4, data.dut2_to_dut4_port_1_ip, data.as_num_2) bgpfeature.delete_bgp_neighbor(dut4, data.as_num_4, data.dut3_to_dut4_port_1_ip, data.as_num_3) st.log("Unconfiguring BGP IPv6 neighbors.") bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.tg_to_dut1_port_1_ip6, data.remote_as_num1) bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.dut2_to_dut1_port_1_ip6, data.as_num_2) bgpfeature.delete_bgp_neighbor(dut1, data.as_num_1, data.dut3_to_dut1_port_1_ip6, data.as_num_3) bgpfeature.delete_bgp_neighbor(dut2, data.as_num_2, data.dut1_to_dut2_port_1_ip6, data.as_num_1) bgpfeature.delete_bgp_neighbor(dut2, data.as_num_2, data.dut4_to_dut2_port_1_ip6, data.as_num_4) bgpfeature.delete_bgp_neighbor(dut3, data.as_num_3, data.dut1_to_dut3_port_1_ip6, data.as_num_1) bgpfeature.delete_bgp_neighbor(dut3, data.as_num_3, data.dut4_to_dut3_port_1_ip6, data.as_num_4) bgpfeature.delete_bgp_neighbor(dut4, data.as_num_4, data.dut2_to_dut4_port_1_ip6, data.as_num_2) bgpfeature.delete_bgp_neighbor(dut4, data.as_num_4, data.dut3_to_dut4_port_1_ip6, data.as_num_3) st.log("Unconfiguring BGP routers.") bgpfeature.cleanup_router_bgp(dut1) bgpfeature.cleanup_router_bgp(dut2) bgpfeature.cleanup_router_bgp(dut3) bgpfeature.cleanup_router_bgp(dut4)
def test_ft_vlan_save_config_warm_and_fast_reboot(): ''' Author: Sai Durga <*****@*****.**> This script covers the below scenarios ft_max_vlan_save_reload Verify the save and reload functionality with max vlan configuration. ft_max_vlan_fast_reload Verify the max vlan configuration is retained after fast-reboot. FtOpSoSwVlFn026 Verify that VLAN is present and traffic is not disturbed during and after warm reboot FtOpSoSysFRFn005 Verify the Fast-Reboot must disrupt control plane not more than 90 seconds (from sonic test suite -configuration tests) ft_reboot_fdb_fast_reboot Verify that the FDB entry is retained after fast reboot. ''' status = True msg_id = "max_vlan_config_retain_after_save_fast_warm_reboot" vlan_module_epilog() vlan_module_config(config='yes') st.log("Device name is : {}".format(sc_data.dut_platform)) st.log("Saving the MAX VLAN config on the device") reboot.config_save(vars.D1) st.log("Performing reboot and checking the VLAN configuration") st.reboot(vars.D1) st.log("Checking VLAN config after reboot") max_vlan_verify() st.log( "Sending traffic with 100 MAC,Checking FDB table updated with 100 MAC addresses and performing reboot and checking the VLAN configuration" ) tg.tg_traffic_control(action="reset", port_handle=tg_handler["tg_ph_list"]) tg_1 = tg.tg_traffic_config(port_handle=tg_handler["tg_ph_1"], mode='create', length_mode='fixed', frame_size=72, mac_src='00:01:00:00:00:01', mac_src_step='00:00:00:00:00:01', mac_src_mode='increment', mac_src_count=sc_data.mac_count, mac_dst='00:02:00:00:00:02', rate_pps=2000, l2_encap='ethernet_ii_vlan', vlan="enable", vlan_id=sc_data.vlan, transmit_mode='continuous') tg_info['tg1_stream_id'] = tg_1['stream_id'] tg.tg_traffic_control(action='run', stream_handle=tg_info['tg1_stream_id']) st.wait(2) tg.tg_traffic_control(action='stop', stream_handle=tg_info['tg1_stream_id']) if not poll_wait(mac_verify, 300): st.error("mac_address_verification_fail") st.log("Performing fast-reboot and checking the VLAN configuration") st.reboot(vars.D1, 'fast') st.log("Checking VLAN config after fast-reboot") max_vlan_verify() st.log("Sending traffic after fast reboot and checking the FDB table") tg.tg_traffic_control(action='run', stream_handle=tg_info['tg1_stream_id']) st.wait(2) tg.tg_traffic_control(action='stop', stream_handle=tg_info['tg1_stream_id']) if not poll_wait(mac_verify, 300): st.error("mac_address_verification_fail") st.log("Performing warm reboot and checking the traffic") ifapi.clear_interface_counters(vars.D1) st.wait(2) ifapi.show_interface_counters_all(vars.D1) st.wait(2) tg.tg_traffic_control(action='run', stream_handle=tg_info['tg1_stream_id']) st.wait(2) st.reboot(vars.D1, 'warm') st.log("Checking VLAN config after warm-reboot") max_vlan_verify() tg.tg_traffic_control(action='stop', stream_handle=tg_info['tg1_stream_id']) st.log("Checking traffic is forwarded without any loss after warm-reboot") st.log("Fetching TGen statistics") st.wait(2) ifapi.show_interface_counters_all(vars.D1) stats_tg1 = tgapi.get_traffic_stats(tg, mode="aggregate", port_handle=tg_handler["tg_ph_1"]) total_tx_tg1 = stats_tg1.tx.total_bytes stats_tg2 = tgapi.get_traffic_stats(tg, mode="aggregate", port_handle=tg_handler["tg_ph_2"]) total_rx_tg2 = stats_tg2.rx.total_bytes percentage_95_total_tx_tg1 = (95 * int(total_tx_tg1)) / 100 st.log("###############") st.log("Sent bytes: {} and Received bytes : {}".format( percentage_95_total_tx_tg1, total_rx_tg2)) st.log("##############") if int(percentage_95_total_tx_tg1) > int(total_rx_tg2): st.report_fail("traffic_transmission_failed", vars.T1D1P1) report_result(status, msg_id)
def poll_wait(method, timeout, *args, **kwargs): return base.poll_wait(method, timeout, *args, **kwargs)
def config_bgp_topology(config='yes'): st.banner( "{}Config BGP on devices".format('Un' if config != 'yes' else '')) if config == 'yes': thread_info = list() thread_info.append( utils.ExecAllFunc(bgpapi.config_bgp_multi_neigh_use_peergroup, vars.D1, local_asn=eh_data.local_asn, peer_grp_name=eh_data.peer_gp_namev4, remote_asn=eh_data.remote_asn, neigh_ip_list=eh_data.ipv4_nbr, family=eh_data.af_ipv4, activate=1)) thread_info.append( utils.ExecAllFunc(bgpapi.config_bgp_multi_neigh_use_peergroup, vars.D2, local_asn=eh_data.remote_asn, peer_grp_name=eh_data.peer_gp_namev4, remote_asn=eh_data.local_asn, neigh_ip_list=eh_data.ipv4_addr, family=eh_data.af_ipv4, activate=1)) thread_call(thread_info) thread_info = list() thread_info.append( utils.ExecAllFunc(bgpapi.config_bgp_multi_neigh_use_peergroup, vars.D1, local_asn=eh_data.local_asn, peer_grp_name=eh_data.peer_gp_namev6, remote_asn=eh_data.remote_asn, neigh_ip_list=eh_data.ipv6_nbr, family=eh_data.af_ipv6, activate=1, routemap=eh_data.route_map_name, routemap_dir='in')) thread_info.append( utils.ExecAllFunc(bgpapi.config_bgp_multi_neigh_use_peergroup, vars.D2, local_asn=eh_data.remote_asn, peer_grp_name=eh_data.peer_gp_namev6, remote_asn=eh_data.local_asn, neigh_ip_list=eh_data.ipv6_addr, family=eh_data.af_ipv6, activate=1, routemap=eh_data.route_map_name, routemap_dir='in')) thread_call(thread_info) if config == 'yes': if not utils.poll_wait(bgpapi.verify_bgp_summary, 30, vars.D1, family='ipv4', neighbor=[eh_data.ipv4_nbr], state='Established'): st.error( "BGP Neighbor failed to Establish between DUT and Partner") st.report_fail('operation_failed') if not utils.poll_wait(bgpapi.verify_bgp_summary, 30, vars.D1, family='ipv6', neighbor=[eh_data.ipv6_nbr], state='Established'): st.error( "BGP Neighbor failed to Establish between DUT and Partner") st.report_fail('operation_failed') else: bgpapi.cleanup_router_bgp(st.get_dut_names())
def test_vrf_bgp(): result = 0 ############################################################################################################################### st.log('######------Configure BGP on 100 VRFs-----######') for vrf, dut1_ip, dut2_ip, dut1_as, dut2_as in zip( vrf_list[899:1000], data.dut1_dut2_ip_list[899:1000], data.dut2_dut1_ip_list[899:1000], dut1_as_scale[0:100], dut2_as_scale[0:100]): dict1 = { 'vrf_name': vrf, 'router_id': dut1_router_id, 'local_as': dut1_as, 'neighbor': dut2_ip, 'remote_as': dut2_as, 'config_type_list': ['neighbor'] } dict2 = { 'vrf_name': vrf, 'router_id': dut2_router_id, 'local_as': dut2_as, 'neighbor': dut1_ip, 'remote_as': dut1_as, 'config_type_list': ['neighbor'] } parallel.exec_parallel(True, [data.dut1, data.dut2], bgp_api.config_bgp, [dict1, dict2]) dict1 = { 'vrf_name': vrf, 'local_as': dut1_as, 'neighbor': dut2_ip, 'remote_as': dut2_as, 'connect': '3', 'config_type_list': ['activate', 'nexthop_self', 'connect'] } dict2 = { 'vrf_name': vrf, 'local_as': dut2_as, 'neighbor': dut1_ip, 'remote_as': dut1_as, 'connect': '3', 'config_type_list': ['activate', 'nexthop_self', 'connect'] } parallel.exec_parallel(True, [data.dut1, data.dut2], bgp_api.config_bgp, [dict1, dict2]) ############################################################################################################################### st.log('######------Verify the BGP neighbors have come up -----######') if not utils.poll_wait(ip_bgp.verify_bgp_neighbor, 60, data.dut1, neighborip=data.dut2_dut1_ip_list[899], state='Established', vrf=vrf_list[899]): st.log('IPv4 BGP session on VRF-899 did not come up') result += 1 if not utils.poll_wait(ip_bgp.verify_bgp_neighbor, 60, data.dut1, neighborip=data.dut2_dut1_ip_list[950], state='Established', vrf=vrf_list[950]): st.log('IPv4 BGP session on VRF-950 did not come up') result += 1 ############################################################################################################################### st.log('######------Clear BGP and reverify -----######') bgp_api.clear_ip_bgp_vrf_vtysh(data.dut1, vrf_list[899], family='ipv4') st.log('######------Time taken for BGP to come up after clear -----######') st.wait(10) if not utils.poll_wait(ip_bgp.verify_bgp_neighbor, 60, data.dut1, neighborip=data.dut2_dut1_ip_list[899], state='Established', vrf=vrf_list[899]): st.log('IPv4 BGP session on VRF-899 did not come up') result += 1 ############################################################################################################################### if result == 0: st.report_pass('test_case_passed') else: st.log('BGP neighborship on 100 VRFs failed') st.report_fail('test_case_failed')