def test_route_map_multiple_seq_different_match_set_clause_p0(request): """ TC_35: Test multiple sequence numbers in a single route-map for different match/set clauses. """ tgen = get_topogen() # test case name tc_name = request.node.name write_test_header(tc_name) # Creating configuration from JSON reset_config_on_routers(tgen) for adt in ADDR_TYPES: # Create Static routes input_dict = { "r1": { "static_routes": [ { "network": NETWORK[adt][0], "no_of_ip": 1, "next_hop": NEXT_HOP[adt], } ] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) # Api call to redistribute static routes input_dict_1 = { "r1": { "bgp": { "address_family": { "ipv4": { "unicast": { "redistribute": [ {"redist_type": "static"}, {"redist_type": "connected"}, ] } }, "ipv6": { "unicast": { "redistribute": [ {"redist_type": "static"}, {"redist_type": "connected"}, ] } }, } } } } result = create_router_bgp(tgen, topo, input_dict_1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) # Create ip prefix list input_dict_2 = { "r3": { "prefix_lists": { "ipv4": { "pf_list_1_ipv4": [ {"seqid": 10, "network": "any", "action": "permit"} ] }, "ipv6": { "pf_list_1_ipv6": [ {"seqid": 100, "network": "any", "action": "permit"} ] }, } } } result = create_prefix_lists(tgen, input_dict_2) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) # Create route map for addr_type in ADDR_TYPES: input_dict_3 = { "r3": { "route_maps": { "rmap_match_pf_1_{}".format(addr_type): [ { "action": "permit", "match": { addr_type: { "prefix_lists": "pf_list_2_{}".format(addr_type) } }, "set": {"path": {"as_num": 500}}, }, { "action": "permit", "match": { addr_type: { "prefix_lists": "pf_list_2_{}".format(addr_type) } }, "set": { "locPrf": 150, }, }, { "action": "permit", "match": { addr_type: { "prefix_lists": "pf_list_1_{}".format(addr_type) } }, "set": {"metric": 50}, }, ] } } } result = create_route_maps(tgen, input_dict_3) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) # Configure neighbor for route map input_dict_4 = { "r3": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r1": { "dest_link": { "r3": { "route_maps": [ { "name": "rmap_match_pf_1_ipv4", "direction": "in", } ] } } }, "r4": { "dest_link": { "r3": { "route_maps": [ { "name": "rmap_match_pf_1_ipv4", "direction": "out", } ] } } }, } } }, "ipv6": { "unicast": { "neighbor": { "r1": { "dest_link": { "r3": { "route_maps": [ { "name": "rmap_match_pf_1_ipv6", "direction": "in", } ] } } }, "r4": { "dest_link": { "r3": { "route_maps": [ { "name": "rmap_match_pf_1_ipv6", "direction": "out", } ] } } }, } } }, } } } } result = create_router_bgp(tgen, topo, input_dict_4) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) for adt in ADDR_TYPES: # Verifying RIB routes dut = "r3" protocol = "bgp" input_dict = { "r3": { "route_maps": { "rmap_match_pf_list1": [ { "set": { "metric": 50, } } ], } } } static_routes = [NETWORK[adt][0]] time.sleep(2) result = verify_bgp_attributes( tgen, adt, dut, static_routes, "rmap_match_pf_list1", input_dict ) assert result is True, "Test case {} : Failed \n Error: {}".format( tc_name, result ) dut = "r4" result = verify_bgp_attributes( tgen, adt, dut, static_routes, "rmap_match_pf_list1", input_dict ) assert result is True, "Test case {} : Failed \n Error: {}".format( tc_name, result ) logger.info("Testcase " + tc_name + " :Passed \n")
def test_mroute_with_RP_default_route_all_nodes_p2(request): """ TC_50 Verify mroute when LHR,FHR,RP and transit routers reachable using default routes """ tgen = get_topogen() tc_name = request.node.name write_test_header(tc_name) # Creating configuration from JSON kill_iperf(tgen) clear_ip_mroute(tgen) reset_config_on_routers(tgen) clear_ip_pim_interface_traffic(tgen, topo) # Don"t run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) step("Remove c1-c2 connected link to simulate topo " "c1(LHR)---l1(RP)----r2---f1-----c2(FHR)") intf_c1_c2 = topo["routers"]["c1"]["links"]["c2"]["interface"] intf_c2_c1 = topo["routers"]["c2"]["links"]["c1"]["interface"] shutdown_bringup_interface(tgen, "c1", intf_c1_c2, False) shutdown_bringup_interface(tgen, "c2", intf_c2_c1, False) step("Enable the PIM on all the interfaces of FRR1, FRR2, FRR3") step("Enable IGMP of FRR1 interface and send IGMP joins " " from FRR1 node for group range (225.1.1.1-5)") intf_c1_i4 = topo["routers"]["c1"]["links"]["i4"]["interface"] input_dict = { "c1": { "igmp": { "interfaces": { intf_c1_i4: { "igmp": { "version": "2" } } } } } } result = create_igmp_config(tgen, topo, input_dict) assert result is True, "Testcase {}: Failed Error: {}".format( tc_name, result) input_join = {"i4": topo["routers"]["i4"]["links"]["c1"]["interface"]} for recvr, recvr_intf in input_join.items(): result = config_to_send_igmp_join_and_traffic(tgen, topo, tc_name, recvr, recvr_intf, GROUP_RANGE_1, join=True) assert result is True, "Testcase {}: Failed Error: {}".format( tc_name, result) result = iperfSendIGMPJoin(tgen, recvr, IGMP_JOIN_RANGE_1, join_interval=1) assert result is True, "Testcase {}: Failed Error: {}".format( tc_name, result) step("Configure static RP for (225.1.1.1-5) as R2") input_dict = { "l1": { "pim": { "rp": [{ "rp_addr": topo["routers"]["l1"]["links"]["lo"]["ipv4"].split("/")[0], "group_addr_range": GROUP_RANGE, }] } } } result = create_pim_config(tgen, topo, input_dict) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) step("Send traffic from C2 to all the groups ( 225.1.1.1 to 225.1.1.5)") input_src = {"i5": topo["routers"]["i5"]["links"]["c2"]["interface"]} for src, src_intf in input_src.items(): result = config_to_send_igmp_join_and_traffic(tgen, topo, tc_name, src, src_intf, GROUP_RANGE_1, traffic=True) assert result is True, "Testcase {}: Failed Error: {}".format( tc_name, result) result = iperfSendTraffic(tgen, src, IGMP_JOIN_RANGE_1, 32, 2500) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) source_i5 = topo["routers"]["i5"]["links"]["c2"]["ipv4"].split("/")[0] input_dict_starg = [{ "dut": "c1", "src_address": "*", "iif": topo["routers"]["c1"]["links"]["l1"]["interface"], "oil": topo["routers"]["c1"]["links"]["i4"]["interface"], }] input_dict_sg = [{ "dut": "c1", "src_address": source_i5, "iif": topo["routers"]["c1"]["links"]["l1"]["interface"], "oil": topo["routers"]["c1"]["links"]["i4"]["interface"], }] step("Verify mroutes and iff upstream") for data in input_dict_sg: result = verify_ip_mroutes( tgen, data["dut"], data["src_address"], IGMP_JOIN_RANGE_1, data["iif"], data["oil"], ) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) result = verify_upstream_iif(tgen, data["dut"], data["iif"], data["src_address"], IGMP_JOIN_RANGE_1) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) for data in input_dict_starg: result = verify_ip_mroutes( tgen, data["dut"], data["src_address"], IGMP_JOIN_RANGE_1, data["iif"], data["oil"], ) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) result = verify_upstream_iif(tgen, data["dut"], data["iif"], data["src_address"], IGMP_JOIN_RANGE_1) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) step("Delete static routes RP on all the nodes") input_dict = { "c2": { "static_routes": [{ "network": ["1.0.4.11/32"], "next_hop": "10.0.3.2", "delete": True }] }, "c1": { "static_routes": [{ "network": ["1.0.4.11/32"], "next_hop": "10.0.2.2", "delete": True }] }, "r2": { "static_routes": [{ "network": ["1.0.4.11/32"], "next_hop": "10.0.12.1", "delete": True }] }, "f1": { "static_routes": [{ "network": ["1.0.4.11/32"], "next_hop": "10.0.7.2", "delete": True }] }, } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} :Failed \n Error {}".format( tc_name, result) step("Verify RP info unknown after removing static route from c2 ") dut = "c2" rp_address = topo["routers"]["l1"]["links"]["lo"]["ipv4"].split("/")[0] SOURCE = "Static" result = verify_pim_rp_info(tgen, topo, dut, GROUP_RANGE_1, "Unknown", rp_address, SOURCE) assert result is True, "Testcase {} :Failed \n Error: {}".format( tc_name, result) for data in input_dict_starg: result = verify_ip_mroutes( tgen, data["dut"], data["src_address"], IGMP_JOIN_RANGE_1, data["iif"], data["oil"], expected=False, ) assert result is not True, "Testcase {} : Failed Error: {}".format( tc_name, result) result = verify_upstream_iif( tgen, data["dut"], data["iif"], data["src_address"], IGMP_JOIN_RANGE_1, expected=False, ) assert result is not True, "Testcase {} : Failed Error: {}".format( tc_name, result) step("Configure default routes on all the nodes") intf_f1_c2 = topo["routers"]["f1"]["links"]["c2"]["ipv4"].split("/")[0] intf_l1_c1 = topo["routers"]["l1"]["links"]["c1"]["ipv4"].split("/")[0] intf_l1_r2 = topo["routers"]["l1"]["links"]["r2"]["ipv4"].split("/")[0] intf_r2_f1 = topo["routers"]["r2"]["links"]["f1"]["ipv4"].split("/")[0] input_dict = { "c1": { "static_routes": [{ "network": "0.0.0.0/0", "next_hop": intf_l1_c1 }] }, "c2": { "static_routes": [{ "network": "0.0.0.0/0", "next_hop": intf_f1_c2 }] }, "r2": { "static_routes": [{ "network": "0.0.0.0/0", "next_hop": intf_l1_r2 }] }, "f1": { "static_routes": [{ "network": "0.0.0.0/0", "next_hop": intf_r2_f1 }] }, } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} :Failed \n Error {}".format( tc_name, result) step("applying ip nht config on c2") raw_config = { "c1": { "raw_config": ["ip nht resolve-via-default"] }, "c2": { "raw_config": ["ip nht resolve-via-default"] }, "r2": { "raw_config": ["ip nht resolve-via-default"] }, "f1": { "raw_config": ["ip nht resolve-via-default"] }, "l1": { "raw_config": ["ip nht resolve-via-default"] }, } result = apply_raw_config(tgen, raw_config) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) step("Verify RP info Not unknown after removing static route from c2 ") dut = "c2" step("Verify RP info is NOT unknown after removing static route from c2 ") result = verify_pim_rp_info(tgen, topo, dut, GROUP_RANGE_1, "Unknown", rp_address, SOURCE, expected=False) assert result is not True, "Testcase {} :Failed \n Error: {}".format( tc_name, result) step("Verify (s,g) populated after adding default route ") for data in input_dict_sg: result = verify_ip_mroutes( tgen, data["dut"], data["src_address"], IGMP_JOIN_RANGE_1, data["iif"], data["oil"], ) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) result = verify_upstream_iif(tgen, data["dut"], data["iif"], data["src_address"], IGMP_JOIN_RANGE_1) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) step("Verify (*,g) populated after adding default route ") for data in input_dict_starg: result = verify_ip_mroutes( tgen, data["dut"], data["src_address"], IGMP_JOIN_RANGE_1, data["iif"], data["oil"], ) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) result = verify_upstream_iif(tgen, data["dut"], data["iif"], data["src_address"], IGMP_JOIN_RANGE_1) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) write_test_footer(tc_name)
def test_ip_prefix_lists_out_permit(request): """ Create ip prefix list and test permit prefixes out direction """ tgen = get_topogen() if BGP_CONVERGENCE is not True: pytest.skip("skipped because of BGP Convergence failure") # test case name tc_name = request.node.name write_test_header(tc_name) # Creating configuration from JSON reset_config_on_routers(tgen) # Create Static routes input_dict = { "r1": { "static_routes": [ {"network": "10.0.20.1/32", "no_of_ip": 1, "next_hop": "10.0.0.2"} ] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Create Static routes input_dict_1 = { "r1": { "static_routes": [ {"network": "20.0.20.1/32", "no_of_ip": 1, "next_hop": "10.0.0.2"} ] } } result = create_static_routes(tgen, input_dict_1) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) input_dict_5 = { "r3": { "static_routes": [ {"network": "10.0.0.2/30", "no_of_ip": 1, "next_hop": "10.0.0.9"} ] } } result = create_static_routes(tgen, input_dict_5) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Api call to redistribute static routes # Create ip prefix list input_dict_2 = { "r1": { "prefix_lists": { "ipv4": { "pf_list_1": [ {"seqid": 10, "network": "20.0.20.1/32", "action": "permit"} ] } } } } result = create_prefix_lists(tgen, input_dict_2) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Configure prefix list to bgp neighbor # Configure bgp neighbor with prefix list input_dict_3 = { "r1": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r3": { "dest_link": { "r1": { "prefix_lists": [ { "name": "pf_list_1", "direction": "out", } ] } } } }, "redistribute": [ {"redist_type": "static"}, {"redist_type": "connected"}, ], } } } } } } result = create_router_bgp(tgen, topo, input_dict_3) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Verifying RIB routes dut = "r3" protocol = "bgp" result = verify_rib(tgen, "ipv4", dut, input_dict_1, protocol=protocol) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) result = verify_rib( tgen, "ipv4", dut, input_dict, protocol=protocol, expected=False ) assert ( result is not True ), "Testcase {} : Failed \n Error: Routes still" " present in RIB".format(tc_name) write_test_footer(tc_name)
def test_ospf_gr_helper_tc7_p1(request): """ Test ospf gr helper Verify helper when grace lsa is received with different configured value in process level (higher, lower, grace lsa timer above 1800) """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) global topo, intf, intf1, pkt step("Bring up the base config as per the topology") step("Configure DR priority as 99 in RR , DUT dr priority = 98 " "& reset ospf process in all the routers") step("Enable GR on RR and DUT with grace period on RR = 333" "and grace period on DUT = 300") reset_config_on_routers(tgen) ospf_covergence = verify_ospf_neighbor(tgen, topo, lan=True) assert ( ospf_covergence is True ), "OSPF is not after reset config \n Error:" " {}".format(ospf_covergence) ospf_gr_r0 = { "r0": { "ospf": { "graceful-restart": { "helper enable": [], "opaque": True } } } } result = create_router_ospf(tgen, topo, ospf_gr_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) ospf_gr_r1 = { "r1": { "ospf": { "graceful-restart": { "helper enable": [], "opaque": True } } } } result = create_router_ospf(tgen, topo, ospf_gr_r1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) input_dict = {"supportedGracePeriod": 1800} dut = "r0" result = verify_ospf_gr_helper(tgen, topo, dut, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Configure grace period = 1801 on RR and restart ospf .") grace_period_1801 = "01005e00000570708bd051ef080045c0005cbeb10000015907d111010101e00000050204004801010101000000009714000000000000000000000000000100010209030000000101010180000001c8e9002c000100040000016800020001010000000003000411010101" gracelsa_sent = scapy_send_raw_packet(tgen, topo, "r1", intf1, grace_period_1801) step("Verify R0 does not enter helper mode.") input_dict = {"activeRestarterCnt": 1} dut = "r0" result = verify_ospf_gr_helper(tgen, topo, dut, input_dict, expected=False) assert ( result is not True ), "Testcase {} : Failed. DUT entered helper role " " \n Error: {}".format( tc_name, result) delete_ospf() write_test_footer(tc_name)
def test_ospfv3_ecmp_tc16_p0(request): """ Verify OSPF ECMP. Verify OSPF ECMP with max path configured as 8 (ECMP configured at FRR level) """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) global topo step("Bring up the base config as per the topology") step("Configure 8 interfaces between R1 and R2 and enable ospf in area 0.") reset_config_on_routers(tgen) step("Verify that OSPF is up with 8 neighborship sessions.") dut = "r1" ospf_covergence = verify_ospf6_neighbor(tgen, topo, dut=dut) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence ) step("Configure a static route in R0 and redistribute in OSPF.") input_dict = { "r0": { "static_routes": [ { "network": NETWORK["ipv6"][0], "no_of_ip": 5, "next_hop": "Null0", } ] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) dut = "r0" red_static(dut) llip = get_llip("r0", "r1-link1") assert llip is not None, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Verify that route in R2 in stalled with 8 next hops.") nh = [] for item in range(1, 7): nh.append(llip) llip = get_llip("r0", "r1") assert llip is not None, "Testcase {} : Failed \n Error: {}".format(tc_name, result) nh2 = llip nh.append(nh2) dut = "r1" result = verify_ospf6_rib(tgen, dut, input_dict, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) protocol = "ospf" result = verify_rib(tgen, "ipv6", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("shut no shut all the interfaces on the remote router - R2") dut = "r1" for intfr in range(1, 7): intf = topo["routers"]["r1"]["links"]["r0-link{}".format(intfr)]["interface"] shutdown_bringup_interface(tgen, dut, intf, False) result = verify_ospf6_rib(tgen, dut, input_dict, next_hop=nh, expected=False) assert ( result is not True ), "Testcase {} : Failed \n Route present in OSPF RIB. Error: {}".format( tc_name, result ) protocol = "ospf" result = verify_rib( tgen, "ipv6", dut, input_dict, protocol=protocol, next_hop=nh, expected=False ) assert ( result is not True ), "Testcase {} : Failed \n Route present in RIB. Error: {}".format(tc_name, result) for intfr in range(1, 7): intf = topo["routers"]["r1"]["links"]["r0-link{}".format(intfr)]["interface"] shutdown_bringup_interface(tgen, dut, intf, True) result = verify_ospf6_rib(tgen, dut, input_dict, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) protocol = "ospf" result = verify_rib(tgen, "ipv6", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("shut no shut on all the interfaces on DUT (r1)") for intfr in range(1, 7): intf = topo["routers"]["r1"]["links"]["r0-link{}".format(intfr)]["interface"] shutdown_bringup_interface(tgen, dut, intf, False) for intfr in range(1, 7): intf = topo["routers"]["r1"]["links"]["r0-link{}".format(intfr)]["interface"] shutdown_bringup_interface(tgen, dut, intf, True) step( "Verify that all the neighbours are up and routes are installed" " with 8 next hop in ospf and ip route tables on R1." ) step("Verify that OSPF is up with 8 neighborship sessions.") dut = "r1" ospf_covergence = verify_ospf6_neighbor(tgen, topo, dut=dut) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence ) dut = "r1" result = verify_ospf6_rib(tgen, dut, input_dict, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) protocol = "ospf" result = verify_rib(tgen, "ipv6", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) write_test_footer(tc_name)
def test_ospf_lan_tc2_p0(request): """ OSPF IFSM -Verify state change events on DR / BDR / DR Other """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) global topo step("Bring up the base config as per the topology") reset_config_on_routers(tgen) step( "Verify that OSPF is subscribed to multi cast services " "(All SPF, all DR Routers)." ) step("Verify that interface is enabled in ospf.") dut = "r0" input_dict = { "r0": { "links": { "s1": { "ospf": { "priority": 98, "timerDeadSecs": 4, "area": "0.0.0.3", "mcastMemberOspfDesignatedRouters": True, "mcastMemberOspfAllRouters": True, "ospfEnabled": True, } } } } } result = verify_ospf_interface(tgen, topo, dut=dut, input_dict=input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Delete the ip address") topo1 = { "r0": { "links": { "r3": { "ipv4": topo["routers"]["r0"]["links"]["s1"]["ipv4"], "interface": topo["routers"]["r0"]["links"]["s1"]["interface"], "delete": True, } } } } result = create_interfaces_cfg(tgen, topo1) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Change the ip on the R0 interface") topo_modify_change_ip = deepcopy(topo) intf_ip = topo_modify_change_ip["routers"]["r0"]["links"]["s1"]["ipv4"] topo_modify_change_ip["routers"]["r0"]["links"]["s1"]["ipv4"] = str( IPv4Address(frr_unicode(intf_ip.split("/")[0])) + 3 ) + "/{}".format(intf_ip.split("/")[1]) build_config_from_json(tgen, topo_modify_change_ip, save_bkup=False) step("Verify that interface is enabled in ospf.") dut = "r0" input_dict = { "r0": { "links": { "s1": { "ospf": { "ipAddress": topo_modify_change_ip["routers"]["r0"]["links"][ "s1" ]["ipv4"].split("/")[0], "ipAddressPrefixlen": int( topo_modify_change_ip["routers"]["r0"]["links"]["s1"][ "ipv4" ].split("/")[1] ), } } } } } result = verify_ospf_interface(tgen, topo, dut=dut, input_dict=input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Modify the mask on the R0 interface") ip_addr = topo_modify_change_ip["routers"]["r0"]["links"]["s1"]["ipv4"] mask = topo_modify_change_ip["routers"]["r0"]["links"]["s1"]["ipv4"] step("Delete the ip address") topo1 = { "r0": { "links": { "r3": { "ipv4": ip_addr, "interface": topo["routers"]["r0"]["links"]["s1"]["interface"], "delete": True, } } } } result = create_interfaces_cfg(tgen, topo1) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Change the ip on the R0 interface") topo_modify_change_ip = deepcopy(topo) intf_ip = topo_modify_change_ip["routers"]["r0"]["links"]["s1"]["ipv4"] topo_modify_change_ip["routers"]["r0"]["links"]["s1"]["ipv4"] = str( IPv4Address(frr_unicode(intf_ip.split("/")[0])) + 3 ) + "/{}".format(int(intf_ip.split("/")[1]) + 1) build_config_from_json(tgen, topo_modify_change_ip, save_bkup=False) step("Verify that interface is enabled in ospf.") dut = "r0" input_dict = { "r0": { "links": { "s1": { "ospf": { "ipAddress": topo_modify_change_ip["routers"]["r0"]["links"][ "s1" ]["ipv4"].split("/")[0], "ipAddressPrefixlen": int( topo_modify_change_ip["routers"]["r0"]["links"]["s1"][ "ipv4" ].split("/")[1] ), } } } } } result = verify_ospf_interface(tgen, topo, dut=dut, input_dict=input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Change the area id on the interface") input_dict = { "r0": { "links": { "s1": { "interface": topo["routers"]["r0"]["links"]["s1"]["interface"], "ospf": {"area": "0.0.0.3"}, "delete": True, } } } } result = create_interfaces_cfg(tgen, input_dict) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) input_dict = { "r0": { "links": { "s1": { "interface": topo["routers"]["r0"]["links"]["s1"]["interface"], "ospf": {"area": "0.0.0.2"}, } } } } result = create_interfaces_cfg(tgen, input_dict) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) step("Verify that interface is enabled in ospf.") dut = "r0" input_dict = { "r0": {"links": {"s1": {"ospf": {"area": "0.0.0.2", "ospfEnabled": True}}}} } result = verify_ospf_interface(tgen, topo, dut=dut, input_dict=input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) write_test_footer(tc_name)
def test_ospf_gr_helper_tc2_p0(request): """ OSPF GR on Broadcast : Verify DUT enters Helper mode when neighbor sends grace lsa, helps RR to restart gracefully (RR = DR) """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) global topo, intf, intf1, pkt step("Bring up the base config as per the topology") step("Configure DR priority as 99 in RR , DUT dr priority = 98 " "& reset ospf process in all the routers") reset_config_on_routers(tgen) ospf_covergence = verify_ospf_neighbor(tgen, topo, lan=True) assert ( ospf_covergence is True ), "OSPF is not after reset config \n Error:" " {}".format(ospf_covergence) ospf_gr_r0 = { "r0": { "ospf": { "graceful-restart": { "helper enable": [], "opaque": True } } } } result = create_router_ospf(tgen, topo, ospf_gr_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) ospf_gr_r1 = { "r1": { "ospf": { "graceful-restart": { "helper enable": [], "opaque": True } } } } result = create_router_ospf(tgen, topo, ospf_gr_r1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that DUT enters into helper mode.") input_dict = {"activeRestarterCnt": 1} gracelsa_sent = False repeat = 0 dut = "r0" while not gracelsa_sent and repeat < Iters: gracelsa_sent = scapy_send_raw_packet(tgen, topo, "r1", intf1, pkt) result = verify_ospf_gr_helper(tgen, topo, dut, input_dict) if isinstance(result, str): repeat += 1 gracelsa_sent = False assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) delete_ospf() write_test_footer(tc_name)
def test_BGP_GR_TC_11_p0(request): """ Verify that selection-deferral timer sets the maximum time to avoid deadlock during which the best-path selection process is deferred, after a peer session was restarted """ tgen = get_topogen() tc_name = request.node.name write_test_header(tc_name) # Check router status check_router_status(tgen) # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) # Creating configuration from JSON reset_config_on_routers(tgen) logger.info("Verify EOR Sent after deferral timeout : BGP_GR_TC_11") # Configure graceful-restart input_dict = { "r1": { "bgp": { "graceful-restart": { "graceful-restart": True, "select-defer-time": GR_SELECT_DEFER_TIMER, }, "address_family": { "ipv4": { "unicast": { "neighbor": { "r2": {"dest_link": {"r1": {"graceful-restart": True}}}, "r3": {"dest_link": {"r1": {"graceful-restart": True}}}, } } }, "ipv6": { "unicast": { "neighbor": { "r2": {"dest_link": {"r1": {"graceful-restart": True}}}, "r3": {"dest_link": {"r1": {"graceful-restart": True}}}, } } }, }, } }, "r3": { "bgp": { "graceful-restart": {"disable-eor": True}, "address_family": { "ipv4": { "unicast": { "neighbor": { "r1": { "dest_link": { "r3": {"graceful-restart-helper": True} } } } } }, "ipv6": { "unicast": { "neighbor": { "r1": { "dest_link": { "r3": {"graceful-restart-helper": True} } } } } }, }, } }, } result = create_router_bgp(tgen, topo, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) for addr_type in ADDR_TYPES: clear_bgp(tgen, addr_type, "r1") clear_bgp(tgen, addr_type, "r3") result = verify_bgp_convergence_from_running_config(tgen, topo) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) for addr_type in ADDR_TYPES: result = verify_graceful_restart( tgen, topo, addr_type, input_dict, dut="r1", peer="r3" ) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying BGP RIB routes received from router R1 dut = "r1" input_dict_1 = {key: topo["routers"][key] for key in ["r3"]} result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying RIB routes result = verify_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) logger.info("R1 goes for reload") kill_router_daemons(tgen, "r1", ["bgpd"]) logger.info("Starting bgpd process") start_router_daemons(tgen, "r1", ["bgpd"]) logger.info("R1 is UP Now") for addr_type in ADDR_TYPES: # Verify EOR on restarting router result = verify_eor( tgen, topo, addr_type, input_dict, dut="r1", peer="r3", expected=False ) assert ( result is not True ), "Testcase {} : Failed \n " "r1: EOR is set to True\n Error: {}".format( tc_name, result ) logger.info( "Waiting for selection deferral timer({} sec).. ".format( GR_SELECT_DEFER_TIMER + 2 ) ) sleep(GR_SELECT_DEFER_TIMER + 2) for addr_type in ADDR_TYPES: # Verifying BGP RIB routes received from router R1 input_dict_1 = {key: topo["routers"][key] for key in ["r3"]} result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying RIB routes result = verify_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying EOR on restarting router result = verify_eor( tgen, topo, addr_type, input_dict, dut="r3", peer="r1", expected=False ) assert ( result is not True ), "Testcase {} : Failed \n " "r3: EOR is set to True\n Error: {}".format( tc_name, result ) write_test_footer(tc_name)
def test_BGP_GR_10_p2(request): """ Test Objective : Test GR scenarios on helper router by enabling Graceful Restart for multiple address families. """ tgen = get_topogen() tc_name = request.node.name write_test_header(tc_name) # Check router status check_router_status(tgen) # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) # Creating configuration from JSON reset_config_on_routers(tgen) step("Test Setup: [Helper Mode]R3-----R1[Restart Mode] initialized") # Configure graceful-restart input_dict = { "r1": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r3": { "dest_link": { "r1": { "next_hop_self": True, "graceful-restart": True, "activate": "ipv6", } } } } } }, "ipv6": { "unicast": { "neighbor": { "r3": { "dest_link": { "r1": { "next_hop_self": True, "graceful-restart": True, "activate": "ipv4", } } } } } }, } } }, "r3": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r1": { "dest_link": { "r3": { "graceful-restart-helper": True, "activate": "ipv6", } } } } } }, "ipv6": { "unicast": { "neighbor": { "r1": { "dest_link": { "r3": { "graceful-restart-helper": True, "activate": "ipv4", } } } } } }, } } }, } configure_gr_followed_by_clear(tgen, topo, input_dict, tc_name, dut="r1", peer="r3") for addr_type in ADDR_TYPES: step( "Verifying GR config and operational state for addr_type {}".format( addr_type ) ) result = verify_graceful_restart( tgen, topo, addr_type, input_dict, dut="r1", peer="r3" ) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying BGP RIB routes dut = "r3" input_topo = {key: topo["routers"][key] for key in ["r1"]} result = verify_bgp_rib(tgen, addr_type, dut, input_topo) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying RIB routes before shutting down BGPd daemon result = verify_rib(tgen, addr_type, dut, input_topo) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # verify multi address family result = verify_gr_address_family( tgen, topo, addr_type, "ipv4Unicast", dut="r1", peer="r3", ) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # verify multi address family result = verify_gr_address_family( tgen, topo, addr_type, "ipv6Unicast", dut="r1", peer="r3", ) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # verify multi address family result = verify_gr_address_family( tgen, topo, addr_type, "ipv4Unicast", dut="r3", peer="r1", ) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # verify multi address family result = verify_gr_address_family( tgen, topo, addr_type, "ipv6Unicast", dut="r3", peer="r1", ) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) step("Killing bgpd on r1") # Kill BGPd daemon on R1 kill_router_daemons(tgen, "r1", ["bgpd"]) for addr_type in ADDR_TYPES: # Verifying BGP RIB routes input_topo = {key: topo["routers"][key] for key in ["r1"]} result = verify_bgp_rib(tgen, addr_type, dut, input_topo) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying RIB routes before shutting down BGPd daemon result = verify_rib(tgen, addr_type, dut, input_topo) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) step("Starting bgpd on r1") # Start BGPd daemon on R1 start_router_daemons(tgen, "r1", ["bgpd"]) for addr_type in ADDR_TYPES: # Verifying BGP RIB routes input_topo = {key: topo["routers"][key] for key in ["r1"]} result = verify_bgp_rib(tgen, addr_type, dut, input_topo) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying RIB routes before shutting down BGPd daemon result = verify_rib(tgen, addr_type, dut, input_topo) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) write_test_footer(tc_name)
def test_BGP_GR_TC_1_2_p0(request): """ Verify that EOR message is sent out only after initial convergence Verify whether EOR message is received from all the peers after restart """ tgen = get_topogen() tc_name = request.node.name write_test_header(tc_name) # Check router status check_router_status(tgen) # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) # Creating configuration from JSON reset_config_on_routers(tgen) logger.info( "Verify EOR Sent and Received : BGP_GR_TC_1_2 >> " "BGP GR [Helper Mode]R3-----R1[Restart Mode] " ) # Configure graceful-restart input_dict = { "r3": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r1": { "dest_link": { "r3": {"graceful-restart-helper": True} } } } } }, "ipv6": { "unicast": { "neighbor": { "r1": { "dest_link": { "r3": {"graceful-restart-helper": True} } } } } }, } } }, "r1": { "bgp": { "graceful-restart": { "graceful-restart": True, "preserve-fw-state": True, }, "address_family": { "ipv4": { "unicast": { "neighbor": { "r3": {"dest_link": {"r1": {"graceful-restart": True}}} } } }, "ipv6": { "unicast": { "neighbor": { "r3": {"dest_link": {"r1": {"graceful-restart": True}}} } } }, }, } }, } configure_gr_followed_by_clear(tgen, topo, input_dict, tc_name, dut="r1", peer="r3") for addr_type in ADDR_TYPES: result = verify_graceful_restart( tgen, topo, addr_type, input_dict, dut="r1", peer="r3" ) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying BGP RIB routes received from router R3 dut = "r1" input_dict_1 = {key: topo["routers"][key] for key in ["r3"]} result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying RIB routes result = verify_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) logger.info("R1 goes for reload") kill_router_daemons(tgen, "r1", ["bgpd"]) for addr_type in ADDR_TYPES: # Verifying RIB routes input_dict_1 = {key: topo["routers"][key] for key in ["r3"]} # Verifying RIB routes result = verify_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) logger.info("Starting bgpd process") start_router_daemons(tgen, "r1", ["bgpd"]) logger.info("R1 is UP Now") for addr_type in ADDR_TYPES: result = verify_graceful_restart( tgen, topo, addr_type, input_dict, dut="r1", peer="r3" ) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying BGP RIB routes received from router R3 input_dict_1 = {key: topo["routers"][key] for key in ["r3"]} result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying RIB routes result = verify_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying EOR on restarting router result = verify_eor(tgen, topo, addr_type, input_dict, dut="r3", peer="r1") assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) write_test_footer(tc_name)
def test_BGP_GR_TC_3_p0(request): """ Verify the selection deferral timer functionality when EOR is not sent by the helper router """ tgen = get_topogen() tc_name = request.node.name write_test_header(tc_name) # Check router status check_router_status(tgen) # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) # Creating configuration from JSON reset_config_on_routers(tgen) logger.info( " Verify route download to RIB: BGP_GR_TC_3 >> " "BGP GR [Helper Mode]R1-----R2[Restart Mode] " ) # Configure graceful-restart input_dict = { "r1": { "bgp": { "graceful-restart": { "disable-eor": True, }, "address_family": { "ipv4": { "unicast": { "neighbor": { "r2": { "dest_link": { "r1": {"graceful-restart-helper": True} } } } } }, "ipv6": { "unicast": { "neighbor": { "r2": { "dest_link": { "r1": {"graceful-restart-helper": True} } } } } }, }, } }, "r2": { "bgp": { "graceful-restart": { "graceful-restart": True, "preserve-fw-state": True, "timer": {"select-defer-time": GR_SELECT_DEFER_TIMER}, }, "address_family": { "ipv4": { "unicast": { "neighbor": { "r1": {"dest_link": {"r2": {"graceful-restart": True}}} } } }, "ipv6": { "unicast": { "neighbor": { "r1": {"dest_link": {"r2": {"graceful-restart": True}}} } } }, }, } }, } configure_gr_followed_by_clear(tgen, topo, input_dict, tc_name, dut="r1", peer="r2") for addr_type in ADDR_TYPES: result = verify_graceful_restart( tgen, topo, addr_type, input_dict, dut="r1", peer="r2" ) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying BGP RIB routes received from router R1 dut = "r2" input_dict_1 = {key: topo["routers"][key] for key in ["r1"]} result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying RIB routes result = verify_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) logger.info("R2 goes for reload ") kill_router_daemons(tgen, "r2", ["bgpd"]) logger.info("R2 is about to come up now") start_router_daemons(tgen, "r2", ["bgpd"]) logger.info("R2 is UP Now") for addr_type in ADDR_TYPES: # Verifying BGP RIB routes received from router R1 input_dict_1 = {key: topo["routers"][key] for key in ["r1"]} result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verify EOR on restarting router result = verify_eor( tgen, topo, addr_type, input_dict, dut="r2", peer="r1", expected=False ) assert ( result is not True ), "Testcase {} : Failed \n " "r2: EOR is set to True\n Error: {}".format( tc_name, result ) logger.info( "Waiting for selection deferral timer({} sec)..".format(GR_SELECT_DEFER_TIMER) ) sleep(GR_SELECT_DEFER_TIMER) for addr_type in ADDR_TYPES: # Verifying RIB routes result = verify_rib(tgen, addr_type, "r2", input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) write_test_footer(tc_name)
def test_BGP_GR_18_p1(request): """ Test Objective : Verify that GR helper router deletes stale routes received from restarting node, if GR capability is not present in restarting node's OPEN message. """ tgen = get_topogen() tc_name = request.node.name write_test_header(tc_name) # Check router status check_router_status(tgen) # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) # Creating configuration from JSON reset_config_on_routers(tgen) logger.info( "[Step 1] : Test Setup " "[Helper Mode]R6-----R1[Restart Mode] initialized" ) # Configure graceful-restart and timers input_dict = { "r1": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r6": {"dest_link": {"r1": {"graceful-restart": True}}} } } }, "ipv6": { "unicast": { "neighbor": { "r6": {"dest_link": {"r1": {"graceful-restart": True}}} } } }, } } }, "r6": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r1": { "dest_link": { "r6": {"graceful-restart-helper": True} } } } } }, "ipv6": { "unicast": { "neighbor": { "r1": { "dest_link": { "r6": {"graceful-restart-helper": True} } } } } }, } } }, } configure_gr_followed_by_clear(tgen, topo, input_dict, tc_name, dut="r1", peer="r6") for addr_type in ADDR_TYPES: result = verify_graceful_restart( tgen, topo, addr_type, input_dict, dut="r1", peer="r6" ) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) logger.info( "[Step 2] : Test Setup " "[Helper Mode]R6-----R1[Restart Mode]" "--------R2[Helper Mode] initialized" ) # Configure graceful-restart and timers input_dict = { "r1": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r2": {"dest_link": {"r1": {"graceful-restart": True}}} } } }, "ipv6": { "unicast": { "neighbor": { "r2": {"dest_link": {"r1": {"graceful-restart": True}}} } } }, } } }, "r2": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r1": { "dest_link": { "r2": {"graceful-restart-helper": True} } } } } }, "ipv6": { "unicast": { "neighbor": { "r1": { "dest_link": { "r2": {"graceful-restart-helper": True} } } } } }, } } }, } configure_gr_followed_by_clear(tgen, topo, input_dict, tc_name, dut="r1", peer="r2") for addr_type in ADDR_TYPES: result = verify_graceful_restart( tgen, topo, addr_type, input_dict, dut="r1", peer="r2" ) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying BGP RIB routes dut = "r6" input_dict_1 = {key: topo["routers"][key] for key in ["r1"]} result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying RIB routes before shutting down BGPd daemon result = verify_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying BGP RIB routes dut = "r2" result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying RIB routes before shutting down BGPd daemon result = verify_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Kill BGPd daemon on R1 kill_router_daemons(tgen, "r1", ["bgpd"]) logger.info("[Step 3] : Configure R1 to prevent sending EOR") # Modify graceful-restart config to prevent sending EOR input_dict_3 = {"r1": {"bgp": {"graceful-restart": {"disable-eor": True}}}} result = modify_bgp_config_when_bgpd_down(tgen, topo, input_dict_3) # Modify configuration to delete routes network = {"ipv4": "101.0.20.1/32", "ipv6": "1::1/128"} for addr_type in ADDR_TYPES: input_dict_3 = { "r1": { "bgp": { "address_family": { addr_type: { "unicast": { "advertise_networks": [ { "network": network[addr_type], "no_of_network": 5, "delete": True, } ] } } } } } } result = modify_bgp_config_when_bgpd_down(tgen, topo, input_dict_3) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Modify graceful-restart config input_dict_3 = { "r1": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r2": { "dest_link": { "r1": {"graceful-restart-disable": True} } }, "r6": { "dest_link": { "r1": {"graceful-restart-disable": True} } }, } } }, "ipv6": { "unicast": { "neighbor": { "r2": { "dest_link": { "r1": {"graceful-restart-disable": True} } }, "r6": { "dest_link": { "r1": {"graceful-restart-disable": True} } }, } } }, } } } } result = modify_bgp_config_when_bgpd_down(tgen, topo, input_dict_3) assert result is True, "Testcase {} : Failed \n Error {}".format(tc_name, result) logger.info("[Step 4] : Bring up the BGPd daemon on R1 for 30" " seconds..") # Start BGPd daemon on R1 start_router_daemons(tgen, "r1", ["bgpd"]) for addr_type in ADDR_TYPES: # Verifying BGP RIB routes dut = "r6" input_dict_1 = {key: topo["routers"][key] for key in ["r1"]} result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1, expected=False) assert result is not True, ( "Testcase {} : Failed \n " "r6: routes are still present in BGP RIB\n Error: {}".format( tc_name, result ) ) logger.info(" Expected behavior: {}".format(result)) # Verifying RIB routes before shutting down BGPd daemon result = verify_rib(tgen, addr_type, dut, input_dict_1, expected=False) assert result is not True, ( "Testcase {} : Failed \n " "r6: routes are still present in ZEBRA\n Error: {}".format(tc_name, result) ) logger.info(" Expected behavior: {}".format(result)) # Verifying BGP RIB routes dut = "r2" result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1, expected=False) assert result is not True, ( "Testcase {} : Failed \n " "r2: routes are still present in BGP RIB\n Error: {}".format( tc_name, result ) ) logger.info(" Expected behavior: {}".format(result)) # Verifying RIB routes before shutting down BGPd daemon result = verify_rib(tgen, addr_type, dut, input_dict_1, expected=False) assert result is not True, ( "Testcase {} : Failed \n " "r6: routes are still present in ZEBRA\n Error: {}".format(tc_name, result) ) logger.info(" Expected behavior: {}".format(result)) write_test_footer(tc_name)
def test_ospf_cost_tc52_p0(request): """OSPF Cost - verifying ospf interface cost functionality""" tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() global topo step("Bring up the base config.") reset_config_on_routers(tgen) step("Configure ospf cost as 20 on interface between R0 and R1. " "Configure ospf cost as 30 between interface between R0 and R2.") r0_ospf_cost = { "r0": { "links": { "r1": { "ospf": { "cost": 20 } }, "r2": { "ospf": { "cost": 30 } } } } } result = config_ospf_interface(tgen, topo, r0_ospf_cost) assert result is True, "Testcase {} :Failed \n Error: {}".format( tc_name, result) step("Verify that cost is updated in the ospf interface between" " r0 and r1 as 30 and r0 and r2 as 20") dut = "r0" result = verify_ospf_interface(tgen, topo, dut=dut, input_dict=r0_ospf_cost) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Swap the costs between interfaces on r0, between r0 and r1 to 30" ", r0 and r2 to 20") r0_ospf_cost = { "r0": { "links": { "r1": { "ospf": { "cost": 30 } }, "r2": { "ospf": { "cost": 20 } } } } } result = config_ospf_interface(tgen, topo, r0_ospf_cost) assert result is True, "Testcase {} :Failed \n Error: {}".format( tc_name, result) step("Verify that cost is updated in the ospf interface between r0 " "and r1 as 30 and r0 and r2 as 20.") result = verify_ospf_interface(tgen, topo, dut=dut, input_dict=r0_ospf_cost) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step(" Un configure cost from the interface r0 - r1.") r0_ospf_cost = { "r0": { "links": { "r1": { "ospf": { "cost": 30, "del_action": True } } } } } result = config_ospf_interface(tgen, topo, r0_ospf_cost) assert result is True, "Testcase {} :Failed \n Error: {}".format( tc_name, result) input_dict = { "r0": { "links": { "r1": { "ospf": { "cost": 10 } }, "r2": { "ospf": { "cost": 20 } } } } } step("Verify that cost is updated in the ospf interface between r0" " and r1 as 10 and r0 and r2 as 20.") result = verify_ospf_interface(tgen, topo, dut=dut, input_dict=input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step(" Un configure cost from the interface r0 - r2.") r0_ospf_cost = { "r0": { "links": { "r2": { "ospf": { "cost": 20, "del_action": True } } } } } result = config_ospf_interface(tgen, topo, r0_ospf_cost) assert result is True, "Testcase {} :Failed \n Error: {}".format( tc_name, result) step("Verify that cost is updated in the ospf interface between r0" "and r1 as 10 and r0 and r2 as 10") input_dict = { "r0": { "links": { "r1": { "ospf": { "cost": 10 } }, "r2": { "ospf": { "cost": 10 } } } } } result = verify_ospf_interface(tgen, topo, dut=dut, input_dict=input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) write_test_footer(tc_name)
def test_route_map_set_only_no_match_p0(request): """ TC_37: Test add/remove route-maps with multiple set clauses and without any match statement.(Set only) """ tgen = get_topogen() # test case name tc_name = request.node.name write_test_header(tc_name) # Creating configuration from JSON reset_config_on_routers(tgen) for adt in ADDR_TYPES: # Create Static routes input_dict = { "r1": { "static_routes": [ { "network": NETWORK[adt][0], "no_of_ip": 1, "next_hop": NEXT_HOP[adt], } ] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) # Api call to redistribute static routes input_dict_1 = { "r1": { "bgp": { "address_family": { "ipv4": { "unicast": { "redistribute": [ {"redist_type": "static"}, {"redist_type": "connected"}, ] } }, "ipv6": { "unicast": { "redistribute": [ {"redist_type": "static"}, {"redist_type": "connected"}, ] } }, } } } } result = create_router_bgp(tgen, topo, input_dict_1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) # Create route map input_dict_3 = { "r3": { "route_maps": { "rmap_match_pf_1": [ { "action": "permit", "set": {"metric": 50, "locPrf": 150, "weight": 4000}, } ] } } } result = create_route_maps(tgen, input_dict_3) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) # Configure neighbor for route map input_dict_4 = { "r3": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r1": { "dest_link": { "r3": { "route_maps": [ { "name": "rmap_match_pf_1", "direction": "in", } ] } } }, "r4": { "dest_link": { "r3": { "route_maps": [ { "name": "rmap_match_pf_1", "direction": "out", } ] } } }, } } }, "ipv6": { "unicast": { "neighbor": { "r1": { "dest_link": { "r3": { "route_maps": [ { "name": "rmap_match_pf_1", "direction": "in", } ] } } }, "r4": { "dest_link": { "r3": { "route_maps": [ { "name": "rmap_match_pf_1", "direction": "out", } ] } } }, } } }, } } } } result = create_router_bgp(tgen, topo, input_dict_4) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) time.sleep(2) for adt in ADDR_TYPES: input_dict_4 = { "r3": { "route_maps": { "rmap_match_pf_1": [ { "action": "permit", "set": { "metric": 50, }, } ] } } } # Verifying RIB routes static_routes = [NETWORK[adt][0]] result = verify_bgp_attributes( tgen, adt, "r3", static_routes, "rmap_match_pf_1", input_dict_3 ) assert result is True, "Test case {} : Failed \n Error: {}".format( tc_name, result ) result = verify_bgp_attributes( tgen, adt, "r4", static_routes, "rmap_match_pf_1", input_dict_4 ) assert result is True, "Test case {} : Failed \n Error: {}".format( tc_name, result ) logger.info("Testcase " + tc_name + " :Passed \n")
def test_static_route_2nh_admin_dist_p0_tc_2_ebgp(request): """ Verify static route functionality with 2 next hop & different AD value. """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) reset_config_on_routers(tgen) NEXT_HOP_IP = populate_nh() step("Configure IPv4 static route (10.1.1.1) in R2 with next hop N1" "(28.1.1.2 ) AD 10 and N2 (29.1.1.2) AD 20 , Static route next-hop" "present on R1 \n ex :- ip route 10.1.1.1/24 28.1.1.2 10 & " "ip route 10.1.1.1/24 29.1.1.2 20") reset_config_on_routers(tgen) NEXT_HOP_IP = populate_nh() for addr_type in ADDR_TYPES: input_dict_4 = { "r2": { "static_routes": [ { "network": NETWORK2[addr_type], "next_hop": NEXT_HOP_IP["nh1"][addr_type], "admin_distance": 10, }, { "network": NETWORK2[addr_type], "next_hop": NEXT_HOP_IP["nh2"][addr_type], "admin_distance": 20, }, ] } } logger.info("Configure static routes") result = create_static_routes(tgen, input_dict_4) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("On R2, static route installed in RIB using " "show ip route with 2 next hop , lowest AD nexthop is active ") rte1_nh1 = { "r2": { "static_routes": [{ "network": NETWORK2[addr_type], "next_hop": NEXT_HOP_IP["nh1"][addr_type], "admin_distance": 10, }] } } nh = [NEXT_HOP_IP["nh1"][addr_type]] dut = "r2" protocol = "static" result = verify_rib(tgen, addr_type, dut, rte1_nh1, next_hop=nh, protocol=protocol, fib=True) assert result is True, "Testcase {} : Failed \nError: Routes is" "missing in RIB".format(tc_name) rte2_nh2 = { "r2": { "static_routes": [{ "network": NETWORK2[addr_type], "next_hop": NEXT_HOP_IP["nh2"][addr_type], "admin_distance": 20, }] } } nh = [NEXT_HOP_IP["nh2"][addr_type]] dut = "r2" protocol = "static" result = verify_rib( tgen, addr_type, dut, rte2_nh2, next_hop=nh, protocol=protocol, fib=True, expected=False, ) assert result is not True, "Testcase {} : Failed \nError: Routes is" "not active in RIB".format(tc_name) step("Configure IBGP IPv4 peering between R2 and R3 router.") step("Explicit route is added in R3 for R2 nexthop rechability") rt3_rtes = { "r3": { "static_routes": [ { "network": NEXT_HOP_IP["nh1"][addr_type] + "/32", "next_hop": topo["routers"]["r2"]["links"]["r3"][addr_type], }, { "network": NEXT_HOP_IP["nh2"][addr_type] + "/32", "next_hop": topo["routers"]["r2"]["links"]["r3"][addr_type], }, ] } } logger.info("Configure static routes") result = create_static_routes(tgen, rt3_rtes) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Configure redistribute static in BGP on R2 router") input_dict_2 = { "r2": { "bgp": { "address_family": { addr_type: { "unicast": { "redistribute": [{ "redist_type": "static" }] } } } } } } result = create_router_bgp(tgen, topo, input_dict_2) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Remove the static route configured with nexthop N1 from" "running config") rt1_nh1 = { "r2": { "static_routes": [{ "network": NETWORK[addr_type], "next_hop": NEXT_HOP_IP["nh1"][addr_type], "admin_distance": 10, "delete": True, }] } } logger.info("Configure static routes") result = create_static_routes(tgen, rt1_nh1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("On R2, after removing the static route with N1 , " "route become active with nexthop N2 and vice versa.") rte1_nh1 = { "r2": { "static_routes": [{ "network": NETWORK2[addr_type], "next_hop": NEXT_HOP_IP["nh1"][addr_type], "admin_distance": 10, }] } } nh = [NEXT_HOP_IP["nh1"][addr_type]] dut = "r2" protocol = "static" result = verify_rib( tgen, addr_type, dut, rte1_nh1, next_hop=nh, protocol=protocol, fib=True, expected=False, ) assert result is not True, "Testcase {} : Failed \nError: Routes is" "missing in RIB".format(tc_name) rte2_nh2 = { "r2": { "static_routes": [{ "network": NETWORK2[addr_type], "next_hop": NEXT_HOP_IP["nh2"][addr_type], "admin_distance": 20, }] } } nh = [NEXT_HOP_IP["nh2"][addr_type]] result = verify_rib(tgen, addr_type, dut, rte2_nh2, next_hop=nh, protocol=protocol, fib=True) assert result is True, "Testcase {} : Failed \nError: Routes is" "not active in RIB".format(tc_name) step("Configure the static route with nexthop N1") rte1_nh1 = { "r2": { "static_routes": [{ "network": NETWORK[addr_type], "next_hop": NEXT_HOP_IP["nh1"][addr_type], "admin_distance": 10, }] } } logger.info("Configure static routes") result = create_static_routes(tgen, rte1_nh1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Remove the static route configured with nexthop N2 from" "running config") rte2_nh2 = { "r2": { "static_routes": [{ "network": NETWORK[addr_type], "next_hop": NEXT_HOP_IP["nh2"][addr_type], "admin_distance": 20, "delete": True, }] } } logger.info("Configure static routes") result = create_static_routes(tgen, rte2_nh2) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("On R2, after removing the static route with N2 , " "route become active with nexthop N1 and vice versa.") nh = NEXT_HOP_IP["nh2"][addr_type] result = verify_rib( tgen, addr_type, dut, rte2_nh2, next_hop=nh, protocol=protocol, expected=False, ) assert result is not True, "Testcase {} : Failed \nError: Routes is" " still present in RIB".format(tc_name) nh = [NEXT_HOP_IP["nh1"][addr_type]] result = verify_rib(tgen, addr_type, dut, rte1_nh1, next_hop=nh, protocol=protocol) assert result is True, "Testcase {} : Failed \nError: Routes is" " missing in RIB".format(tc_name) step("Configure the static route with nexthop N2") rte2_nh2 = { "r2": { "static_routes": [{ "network": NETWORK[addr_type], "next_hop": NEXT_HOP_IP["nh2"][addr_type], "admin_distance": 20, }] } } logger.info("Configure static routes") result = create_static_routes(tgen, rte2_nh2) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Shut nexthop interface N1") intf = topo["routers"]["r2"]["links"]["r1-link0"]["interface"] shutdown_bringup_interface(tgen, dut, intf, False) step("after shut of nexthop N1 , route become active with nexthop N2") nh = NEXT_HOP_IP["nh1"][addr_type] result = verify_rib( tgen, addr_type, dut, rte1_nh1, next_hop=nh, protocol=protocol, expected=False, ) assert result is not True, "Testcase {} : Failed \nError: Routes is" " still present in RIB".format(tc_name) nh = [NEXT_HOP_IP["nh2"][addr_type]] result = verify_rib(tgen, addr_type, dut, rte2_nh2, next_hop=nh, protocol=protocol, fib=True) assert result is True, "Testcase {} : Failed \nError: Routes is" " missing in RIB".format(tc_name) step("No shut the nexthop interface N1") shutdown_bringup_interface(tgen, dut, intf, True) step("after shut of nexthop N1 , route become active " "with nexthop N2 and vice versa.") nh = [NEXT_HOP_IP["nh1"][addr_type]] result = verify_rib(tgen, addr_type, dut, rte1_nh1, next_hop=nh, protocol=protocol, fib=True) assert result is True, "Testcase {} : Failed \nError: Routes is" " missing in RIB".format(tc_name) step("Shut nexthop interface N2") intf = topo["routers"]["r2"]["links"]["r1-link1"]["interface"] shutdown_bringup_interface(tgen, dut, intf, False) step(" after shut of nexthop N1 , route become active with " "nexthop N2 and vice versa.") nh = NEXT_HOP_IP["nh2"][addr_type] result = verify_rib( tgen, addr_type, dut, rte2_nh2, next_hop=nh, protocol=protocol, expected=False, ) assert result is not True, "Testcase {} : Failed \nError: Routes is" " still present in RIB".format(tc_name) nh = [NEXT_HOP_IP["nh1"][addr_type]] result = verify_rib(tgen, addr_type, dut, rte1_nh1, next_hop=nh, protocol=protocol) assert result is True, "Testcase {} : Failed \nError: Routes is" " missing in RIB".format(tc_name) step("No shut nexthop interface N2") shutdown_bringup_interface(tgen, dut, intf, True) step("after shut of nexthop N1 , route become active " "with nexthop N2 and vice versa.") rte1_nh1 = { "r2": { "static_routes": [{ "network": NETWORK2[addr_type], "next_hop": NEXT_HOP_IP["nh1"][addr_type], "admin_distance": 10, }] } } nh = [NEXT_HOP_IP["nh1"][addr_type]] dut = "r2" protocol = "static" result = verify_rib(tgen, addr_type, dut, rte1_nh1, next_hop=nh, protocol=protocol, fib=True) assert result is True, "Testcase {} : Failed \nError: Routes is" "missing in RIB".format(tc_name) rte2_nh2 = { "r2": { "static_routes": [{ "network": NETWORK2[addr_type], "next_hop": NEXT_HOP_IP["nh2"][addr_type], "admin_distance": 20, }] } } nh = [NEXT_HOP_IP["nh2"][addr_type]] dut = "r2" protocol = "static" result = verify_rib( tgen, addr_type, dut, rte2_nh2, next_hop=nh, protocol=protocol, fib=True, expected=False, ) assert result is not True, "Testcase {} : Failed \nError: Routes is" "not active in RIB".format(tc_name) dut = "r3" protocol = "bgp" result = verify_rib( tgen, addr_type, dut, rte2_nh2, next_hop=nh, protocol=protocol, fib=True, expected=False, ) assert result is not True, "Testcase {} : Failed \nError: Routes is" "not active in RIB".format(tc_name) dut = "r2" step("Reload the FRR router") # stop/start -> restart FRR router and verify stop_router(tgen, "r2") start_router(tgen, "r2") step("After reload of FRR router , static route installed" " in RIB and FIB properly .") rte1_nh1 = { "r2": { "static_routes": [{ "network": NETWORK2[addr_type], "next_hop": NEXT_HOP_IP["nh1"][addr_type], "admin_distance": 10, }] } } nh = [NEXT_HOP_IP["nh1"][addr_type]] dut = "r2" protocol = "static" result = verify_rib(tgen, addr_type, dut, rte1_nh1, next_hop=nh, protocol=protocol, fib=True) assert result is True, "Testcase {} : Failed \nError: Routes is" "missing in RIB".format(tc_name) dut = "r3" protocol = "bgp" result = verify_bgp_rib(tgen, addr_type, dut, rte1_nh1, next_hop=nh) assert result is True, "Testcase {} : Failed \nError: Routes is" "missing in RIB".format(tc_name) rte2_nh2 = { "r2": { "static_routes": [{ "network": NETWORK2[addr_type], "next_hop": NEXT_HOP_IP["nh2"][addr_type], "admin_distance": 20, }] } } nh = [NEXT_HOP_IP["nh2"][addr_type]] dut = "r2" protocol = "static" result = verify_rib( tgen, addr_type, dut, rte2_nh2, next_hop=nh, protocol=protocol, fib=True, expected=False, ) assert result is not True, "Testcase {} : Failed \nError: Routes is" "not active in RIB".format(tc_name) dut = "r3" protocol = "bgp" result = verify_bgp_rib(tgen, addr_type, dut, rte2_nh2, next_hop=nh) assert result is True, "Testcase {} : Failed \nError: Routes is" "not active in RIB".format(tc_name) result = verify_rib( tgen, addr_type, dut, rte2_nh2, next_hop=nh, protocol=protocol, fib=True, expected=False, ) assert result is not True, "Testcase {} : Failed \nError: Routes is" "not active in RIB".format(tc_name) write_test_footer(tc_name)
def BGP_GR_16_p2(request): """ Test Objective : Verify BGP-GR feature when restarting node is a transit router for it's iBGP peers. """ tgen = get_topogen() tc_name = request.node.name write_test_header(tc_name) # Check router status check_router_status(tgen) # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) # Creating configuration from JSON reset_config_on_routers(tgen) logger.info( "[Step 1] : Test Setup " "[Helper Mode]R3-----R1[Restart Mode] initialized" ) # Configure graceful-restart and timers input_dict = { "r1": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r3": { "dest_link": { "r1": { "graceful-restart": True, "next_hop_self": True, } } } } } }, "ipv6": { "unicast": { "neighbor": { "r3": { "dest_link": { "r1": { "graceful-restart": True, "next_hop_self": True, } } } } } }, } } }, "r3": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r1": { "dest_link": { "r3": {"graceful-restart-helper": True} } } } } }, "ipv6": { "unicast": { "neighbor": { "r1": { "dest_link": { "r3": {"graceful-restart-helper": True} } } } } }, } } }, } configure_gr_followed_by_clear(tgen, topo, input_dict, tc_name, dut="r1", peer="r3") for addr_type in ADDR_TYPES: result = verify_graceful_restart( tgen, topo, addr_type, input_dict, dut="r1", peer="r3" ) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) logger.info( "[Step 2] : Test Setup " "[Helper Mode]R3-----R1[Restart Mode]" "--------R6[Helper Mode] initialized" ) # Configure graceful-restart and timers input_dict = { "r1": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r2": {"dest_link": {"r1": {"graceful-restart": True}}} } } }, "ipv6": { "unicast": { "neighbor": { "r2": {"dest_link": {"r1": {"graceful-restart": True}}} } } }, } } }, "r2": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r1": { "dest_link": { "r2": {"graceful-restart-helper": True} } } } } }, "ipv6": { "unicast": { "neighbor": { "r1": { "dest_link": { "r2": {"graceful-restart-helper": True} } } } } }, } } }, } configure_gr_followed_by_clear(tgen, topo, input_dict, tc_name, dut="r1", peer="r2") for addr_type in ADDR_TYPES: result = verify_graceful_restart( tgen, topo, addr_type, input_dict, dut="r1", peer="r2" ) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying BGP RIB routes dut = "r3" input_dict_1 = {key: topo["routers"][key] for key in ["r1"]} result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying RIB routes before shutting down BGPd daemon result = verify_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying BGP RIB routes input_dict_2 = {key: topo["routers"][key] for key in ["r2"]} result = verify_bgp_rib(tgen, addr_type, dut, input_dict_2) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying RIB routes before shutting down BGPd daemon result = verify_rib(tgen, addr_type, dut, input_dict_2) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Kill BGPd daemon on R1 kill_router_daemons(tgen, "r1", ["bgpd"]) for addr_type in ADDR_TYPES: # Verifying BGP RIB routes input_dict_1 = {key: topo["routers"][key] for key in ["r1"]} result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying RIB routes before shutting down BGPd daemon result = verify_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying BGP RIB routes input_dict_2 = {key: topo["routers"][key] for key in ["r2"]} result = verify_bgp_rib(tgen, addr_type, dut, input_dict_2) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying RIB routes before shutting down BGPd daemon result = verify_rib(tgen, addr_type, dut, input_dict_2) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Start BGPd daemon on R1 start_router_daemons(tgen, "r1", ["bgpd"]) for addr_type in ADDR_TYPES: # Verifying BGP RIB routes input_dict_1 = {key: topo["routers"][key] for key in ["r1"]} result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying RIB routes before shutting down BGPd daemon result = verify_rib(tgen, addr_type, dut, input_dict_1) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying BGP RIB routes input_dict_2 = {key: topo["routers"][key] for key in ["r2"]} result = verify_bgp_rib(tgen, addr_type, dut, input_dict_2) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) # Verifying RIB routes before shutting down BGPd daemon result = verify_rib(tgen, addr_type, dut, input_dict_2) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) result = verify_bgp_convergence_from_running_config(tgen, topo) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result ) write_test_footer(tc_name)
def test_ospf_lan_tc1_p0(request): """ OSPF Hello protocol - Verify DR BDR Elections """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) global topo step("Bring up the base config as per the topology") reset_config_on_routers(tgen) step("Verify that DR BDR DRother are elected in the LAN.") input_dict = { "r0": { "ospf": { "neighbors": { "r1": {"state": "Full", "role": "DR"}, "r2": {"state": "Full", "role": "DROther"}, "r3": {"state": "Full", "role": "DROther"}, } } } } dut = "r0" result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step( "Verify that all the routers are in FULL state with DR and BDR " "in the topology" ) input_dict = { "r1": { "ospf": { "neighbors": { "r0": {"state": "Full", "role": "Backup"}, "r2": {"state": "Full", "role": "DROther"}, "r3": {"state": "Full", "role": "DROther"}, } } } } dut = "r1" result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step( "Configure DR pririty 100 on R0 and clear ospf neighbors " "on all the routers." ) input_dict = { "r0": { "links": { "s1": { "interface": topo["routers"]["r0"]["links"]["s1"]["interface"], "ospf": {"priority": 100}, } } } } result = create_interfaces_cfg(tgen, input_dict) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) step("Clear ospf neighbours in all routers") for rtr in ["r0", "r1", "r2", "r3"]: clear_ospf(tgen, rtr) step("Verify that DR election is triggered and R0 is elected as DR") input_dict = { "r0": { "ospf": { "neighbors": { "r1": {"state": "Full", "role": "Backup"}, "r2": {"state": "Full", "role": "DROther"}, "r3": {"state": "Full", "role": "DROther"}, } } } } dut = "r0" result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step( "Configure DR pririty 150 on R0 and clear ospf neighbors " "on all the routers." ) input_dict = { "r0": { "links": { "s1": { "interface": topo["routers"]["r0"]["links"]["s1"]["interface"], "ospf": {"priority": 150}, } } } } result = create_interfaces_cfg(tgen, input_dict) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) step("Clear ospf neighbours in all routers") for rtr in ["r0", "r1"]: clear_ospf(tgen, rtr) step("Verify that DR election is triggered and R0 is elected as DR") input_dict = { "r0": { "ospf": { "neighbors": { "r1": {"state": "Full", "role": "Backup"}, "r2": {"state": "Full", "role": "DROther"}, "r3": {"state": "Full", "role": "DROther"}, } } } } dut = "r0" result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Configure DR priority 0 on R0 & Clear ospf nbrs on all the routers") input_dict = { "r0": { "links": { "s1": { "interface": topo["routers"]["r0"]["links"]["s1"]["interface"], "ospf": {"priority": 0}, } } } } result = create_interfaces_cfg(tgen, input_dict) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) step("Clear ospf neighbours in all routers") for rtr in ["r1"]: clear_ospf(tgen, rtr) step("Verify that DR election is triggered and R0 is elected as DRother") input_dict = { "r0": { "ospf": { "neighbors": { "r1": {"state": "Full", "role": "DR"}, "r2": {"state": "2-Way", "role": "DROther"}, "r3": {"state": "2-Way", "role": "DROther"}, } } } } dut = "r0" result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step( "Configure DR priority to default on R0 and Clear ospf neighbors" " on all the routers" ) input_dict = { "r0": { "links": { "s1": { "interface": topo["routers"]["r0"]["links"]["s1"]["interface"], "ospf": {"priority": 100}, } } } } result = create_interfaces_cfg(tgen, input_dict) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) step("Clear ospf neighbours in all routers") for rtr in ["r0", "r1"]: clear_ospf(tgen, rtr) step("Verify that DR election is triggered and R0 is elected as DR") input_dict = { "r0": { "ospf": { "neighbors": { "r1": {"state": "Full", "role": "Backup"}, "r2": {"state": "Full", "role": "DROther"}, "r3": {"state": "Full", "role": "DROther"}, } } } } dut = "r0" result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Shut interface on R0") dut = "r0" intf = topo["routers"]["r0"]["links"]["s1"]["interface"] shutdown_bringup_interface(tgen, dut, intf, False) result = verify_ospf_neighbor(tgen, topo, dut, lan=True, expected=False) assert result is not True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) step("No Shut interface on R0") dut = "r0" intf = topo["routers"]["r0"]["links"]["s1"]["interface"] shutdown_bringup_interface(tgen, dut, intf, True) input_dict = { "r0": { "ospf": { "neighbors": { "r1": {"state": "Full", "role": "DR"}, "r2": {"state": "Full", "role": "DROther"}, "r3": {"state": "Full", "role": "DROther"}, } } } } step("Verify that after no shut ospf neighbours are full on R0.") result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Clear ospf on DR router in the topology.") clear_ospf(tgen, "r0") step("Verify that BDR is getting promoted to DR after clear.") step("Verify that all the nbrs are in FULL state with the elected DR.") result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Change the ip on LAN intf on R0 to other ip from the same subnet.") topo_modify_change_ip = deepcopy(topo) intf_ip = topo_modify_change_ip["routers"]["r0"]["links"]["s1"]["ipv4"] topo_modify_change_ip["routers"]["r0"]["links"]["s1"]["ipv4"] = str( IPv4Address(frr_unicode(intf_ip.split("/")[0])) + 3 ) + "/{}".format(intf_ip.split("/")[1]) build_config_from_json(tgen, topo_modify_change_ip, save_bkup=False) step( "Verify that OSPF is in FULL state with other routers with " "newly configured IP." ) result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Change the ospf router id on the R0 and clear ip ospf interface.") change_rid = {"r0": {"ospf": {"router_id": "100.1.1.100"}}} result = create_router_ospf(tgen, topo, change_rid) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) topo["routers"]["r0"]["ospf"]["router_id"] = "100.1.1.100" step("Reload the FRR router") stop_router(tgen, "r0") start_router(tgen, "r0") step( "Verify that OSPF is in FULL state with other routers with" " newly configured router id." ) input_dict = { "r1": { "ospf": { "neighbors": { "r0": {"state": "Full", "role": "Backup"}, "r2": {"state": "Full", "role": "DROther"}, "r3": {"state": "Full", "role": "DROther"}, } } } } dut = "r1" result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Reconfigure the original router id and clear ip ospf interface.") change_rid = {"r0": {"ospf": {"router_id": "100.1.1.0"}}} result = create_router_ospf(tgen, topo, change_rid) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) topo["routers"]["r0"]["ospf"]["router_id"] = "100.1.1.0" step("Reload the FRR router") # stop/start -> restart FRR router and verify stop_router(tgen, "r0") start_router(tgen, "r0") step("Verify that OSPF is enabled with router id previously configured.") input_dict = { "r1": { "ospf": { "neighbors": { "r0": {"state": "Full", "role": "Backup"}, "r2": {"state": "Full", "role": "DROther"}, "r3": {"state": "Full", "role": "DROther"}, } } } } dut = "r1" result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) write_test_footer(tc_name)
def test_ospf_redistribution_tc6_p0(request): """Test OSPF inter area route calculations.""" tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) global topo step("Bring up the base config.") reset_config_on_routers(tgen) step("Verify that OSPF neighbors are FULL.") ospf_covergence = verify_ospf_neighbor(tgen, topo) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence ) step("verify intra area route is calculated for r0-r3 interface ip in R1") ip = topo["routers"]["r0"]["links"]["r3"]["ipv4"] ip_net = str(ipaddress.ip_interface(u"{}".format(ip)).network) nh = topo["routers"]["r0"]["links"]["r1"]["ipv4"].split("/")[0] input_dict = { "r1": {"static_routes": [{"network": ip_net, "no_of_ip": 1, "routeType": "N"}]} } dut = "r1" result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) protocol = "ospf" result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Delete the ip address on newly configured loopback of R0") topo1 = { "r0": { "links": { "r3": { "ipv4": topo["routers"]["r0"]["links"]["r3"]["ipv4"], "interface": topo["routers"]["r0"]["links"]["r3"]["interface"], "delete": True, } } } } result = create_interfaces_cfg(tgen, topo1) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) dut = "r1" for num in range(0, nretry): result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh, expected=False) if result is not True: break assert result is not True, ("Testcase {} : Failed \n " "r1: OSPF routes are present after deleting ip address of newly " "configured loopback of R0 \n Error: {}".format( tc_name, result )) protocol = "ospf" result = verify_rib( tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh, expected=False, ) assert result is not True, ("Testcase {} : Failed \n " "r1: OSPF routes are present in fib after deleting ip address of newly " "configured loopback of R0 \n Error: {}".format( tc_name, result )) step("Add back the deleted ip address on newly configured interface of R0") topo1 = { "r0": { "links": { "r3": { "ipv4": topo["routers"]["r0"]["links"]["r3"]["ipv4"], "interface": topo["routers"]["r0"]["links"]["r3"]["interface"], } } } } result = create_interfaces_cfg(tgen, topo1) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) dut = "r1" result = verify_ospf_rib(tgen, dut, input_dict, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) protocol = "ospf" result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Shut no shut interface on R0") dut = "r0" intf = topo["routers"]["r0"]["links"]["r3"]["interface"] shutdown_bringup_interface(tgen, dut, intf, False) step("un shut the OSPF interface on R0") dut = "r0" shutdown_bringup_interface(tgen, dut, intf, True) dut = "r1" result = verify_ospf_rib(tgen, dut, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) protocol = "ospf" result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) write_test_footer(tc_name)
def test_ospf_gr_helper_tc1_p0(request): """Verify by default helper support is disabled for FRR ospf""" tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) global topo, intf, intf1, pkt step("Bring up the base config as per the topology") reset_config_on_routers(tgen) ospf_covergence = verify_ospf_neighbor(tgen, topo, lan=True) assert ( ospf_covergence is True ), "OSPF is not after reset config \n Error:" " {}".format(ospf_covergence) step("Verify that GR helper route is disabled by default to the in" "the DUT.") input_dict = { "helperSupport": "Disabled", "strictLsaCheck": "Enabled", "restartSupoort": "Planned and Unplanned Restarts", "supportedGracePeriod": 1800, } dut = "r0" result = verify_ospf_gr_helper(tgen, topo, dut, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that DUT does not enter helper mode upon receiving the " "grace lsa.") # send grace lsa scapy_send_raw_packet(tgen, topo, "r1", intf1, pkt) input_dict = {"activeRestarterCnt": 1} dut = "r0" result = verify_ospf_gr_helper(tgen, topo, dut, input_dict, expected=False) assert ( result is not True ), "Testcase {} : Failed. DUT entered helper role " " \n Error: {}".format( tc_name, result) step("Configure graceful restart in the DUT") ospf_gr_r0 = { "r0": { "ospf": { "graceful-restart": { "helper enable": [], "opaque": True } } } } result = create_router_ospf(tgen, topo, ospf_gr_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that GR helper route is enabled in the DUT.") input_dict = { "helperSupport": "Enabled", "strictLsaCheck": "Enabled", "restartSupoort": "Planned and Unplanned Restarts", "supportedGracePeriod": 1800, } dut = "r0" result = verify_ospf_gr_helper(tgen, topo, dut, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) ospf_gr_r1 = { "r1": { "ospf": { "graceful-restart": { "helper enable": [], "opaque": True } } } } result = create_router_ospf(tgen, topo, ospf_gr_r1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Perform GR in RR.") step("Verify that DUT does enter helper mode upon receiving" " the grace lsa.") input_dict = {"activeRestarterCnt": 1} gracelsa_sent = False repeat = 0 dut = "r0" while not gracelsa_sent and repeat < Iters: gracelsa_sent = scapy_send_raw_packet(tgen, topo, "r1", intf1, pkt) result = verify_ospf_gr_helper(tgen, topo, dut, input_dict) if isinstance(result, str): repeat += 1 gracelsa_sent = False assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Unconfigure the GR helper command.") ospf_gr_r0 = { "r0": { "ospf": { "graceful-restart": { "helper enable": [], "opaque": True, "delete": True } } } } result = create_router_ospf(tgen, topo, ospf_gr_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) input_dict = {"helperSupport": "Disabled"} dut = "r0" result = verify_ospf_gr_helper(tgen, topo, dut, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Configure gr helper using the router id") ospf_gr_r0 = { "r0": { "ospf": { "graceful-restart": { "helper enable": ["1.1.1.1"], "opaque": True } } } } result = create_router_ospf(tgen, topo, ospf_gr_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that DUT does enter helper mode upon receiving" " the grace lsa.") input_dict = {"activeRestarterCnt": 1} gracelsa_sent = False repeat = 0 dut = "r0" while not gracelsa_sent and repeat < Iters: gracelsa_sent = scapy_send_raw_packet(tgen, topo, "r1", intf1, pkt) result = verify_ospf_gr_helper(tgen, topo, dut, input_dict) if isinstance(result, str): repeat += 1 gracelsa_sent = False assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Un Configure gr helper using the router id") ospf_gr_r0 = { "r0": { "ospf": { "graceful-restart": { "helper enable": ["1.1.1.1"], "opaque": True, "delete": True, } } } } result = create_router_ospf(tgen, topo, ospf_gr_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that GR helper router is disabled in the DUT for" " router id x.x.x.x") input_dict = {"enabledRouterIds": [{"routerId": "1.1.1.1"}]} dut = "r0" result = verify_ospf_gr_helper(tgen, topo, dut, input_dict, expected=False) assert ( result is not True ), "Testcase {} : Failed, Helper role enabled for RR\n Error: {}".format( tc_name, result) delete_ospf() write_test_footer(tc_name)
def test_ospf_redistribution_tc8_p1(request): """ Test OSPF redistribution of connected routes. Verify OSPF redistribution of connected routes when bgp multi hop neighbor is configured using ospf routes """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() global topo step("Bring up the base config.") step( "Configure loopback interface on all routers, and redistribut" "e connected routes into ospf" ) reset_config_on_routers(tgen) step( "verify that connected routes -loopback is found in all routers" "advertised/exchaged via ospf" ) for rtr in topo["routers"]: redistribute_ospf(tgen, topo, rtr, "static") redistribute_ospf(tgen, topo, rtr, "connected") for node in topo["routers"]: input_dict = { "r0": { "static_routes": [ { "network": topo["routers"][node]["links"]["lo"]["ipv4"], "no_of_ip": 1, } ] } } for rtr in topo["routers"]: result = verify_rib(tgen, "ipv4", rtr, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) step("Configure E BGP multi hop using the loopback addresses.") as_num = 100 for node in topo["routers"]: as_num += 1 topo["routers"][node].update( { "bgp": { "local_as": as_num, "address_family": {"ipv4": {"unicast": {"neighbor": {}}}}, } } ) for node in topo["routers"]: for rtr in topo["routers"]: if node is not rtr: topo["routers"][node]["bgp"]["address_family"]["ipv4"]["unicast"][ "neighbor" ].update( { rtr: { "dest_link": { "lo": {"source_link": "lo", "ebgp_multihop": 2} } } } ) result = create_router_bgp(tgen, topo, topo["routers"]) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Verify that BGP neighbor is ESTABLISHED") result = verify_bgp_convergence(tgen, topo) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) step( "Configure couple of static routes in R0 and " "Redistribute static routes in R1 bgp." ) for rtr in topo["routers"]: redistribute_ospf(tgen, topo, rtr, "static", delete=True) input_dict = { "r0": { "static_routes": [ { "network": NETWORK["ipv4"][0], "no_of_ip": 5, "next_hop": "Null0", } ] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) configure_bgp_on_r0 = { "r0": { "bgp": { "address_family": { "ipv4": {"unicast": {"redistribute": [{"redist_type": "static"}]}} } } } } result = create_router_bgp(tgen, topo, configure_bgp_on_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) protocol = "bgp" for rtr in ["r1", "r2", "r3"]: result = verify_rib(tgen, "ipv4", rtr, input_dict, protocol=protocol) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) step("Clear ospf neighbours in R0") for rtr in topo["routers"]: clear_ospf(tgen, rtr) step("Verify that OSPF neighbours are reset and forms new adjacencies.") # Api call verify whether OSPF is converged ospf_covergence = verify_ospf_neighbor(tgen, topo) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence ) step("Verify that BGP neighbours are reset and forms new adjacencies.") result = verify_bgp_convergence(tgen, topo) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) protocol = "bgp" for rtr in ["r1", "r2", "r3"]: result = verify_rib(tgen, "ipv4", rtr, input_dict, protocol=protocol) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) write_test_footer(tc_name)
def test_ospf_gr_helper_tc4_p1(request): """ OSPF GR on Broadcast : Verify DUT enters Helper mode when neighbor sends grace lsa, helps RR to restart gracefully (RR = DRother) """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) global topo, intf, intf1, pkt step("Bring up the base config as per the topology") step("Configure DR priority as 99 in RR , DUT dr priority = 98 " "& reset ospf process in all the routers") reset_config_on_routers(tgen) ospf_covergence = verify_ospf_neighbor(tgen, topo, lan=True) assert ( ospf_covergence is True ), "OSPF is not after reset config \n Error:" " {}".format(ospf_covergence) step("Configure DR pririty 100 on R0 and clear ospf neighbors " "on all the routers.") input_dict = { "r0": { "links": { sw_name: { "interface": topo["routers"]["r0"]["links"][sw_name]["interface"], "ospf": { "priority": 0 }, } } } } result = create_interfaces_cfg(tgen, input_dict) assert result is True, "Testcase {} :Failed \n Error: {}".format( tc_name, result) step("Clear ospf neighbours in all routers") for rtr in topo["routers"]: clear_ospf(tgen, rtr) step("Verify that DR election is triggered and R0 is elected as 2-Way") input_dict = { "r0": { "ospf": { "neighbors": { "r1": { "state": "Full", "role": "DR" }, "r2": { "state": "2-Way", "role": "DROther" }, "r3": { "state": "2-Way", "role": "DROther" }, } } } } dut = "r0" result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) ospf_gr_r0 = { "r0": { "ospf": { "graceful-restart": { "helper enable": [], "opaque": True } } } } result = create_router_ospf(tgen, topo, ospf_gr_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) ospf_gr_r1 = { "r1": { "ospf": { "graceful-restart": { "helper enable": [], "opaque": True } } } } result = create_router_ospf(tgen, topo, ospf_gr_r1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that DUT enters into helper mode.") input_dict = {"activeRestarterCnt": 1} gracelsa_sent = False repeat = 0 dut = "r0" while not gracelsa_sent and repeat < Iters: gracelsa_sent = scapy_send_raw_packet(tgen, topo, "r1", intf1, pkt) result = verify_ospf_gr_helper(tgen, topo, dut, input_dict) if isinstance(result, str): repeat += 1 gracelsa_sent = False assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) delete_ospf() write_test_footer(tc_name)
def test_BGP_GR_TC_8_p1(request): """ Test Objective : Verify that restarting nodes set "F" bit while sending the BGP open messages after it restarts, only when BGP GR is enabled. """ tgen = get_topogen() tc_name = request.node.name write_test_header(tc_name) # Check router status check_router_status(tgen) # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) # Creating configuration from JSON reset_config_on_routers(tgen) logger.info("[Phase 1] : Test Setup" " [Restart Mode]R1-----R2[Restart Mode] initialized ") # Configure graceful-restart input_dict = { "r1": { "bgp": { "graceful-restart": { "preserve-fw-state": True }, "address_family": { "ipv4": { "unicast": { "neighbor": { "r2": { "dest_link": { "r1-link1": { "graceful-restart": True } } } } } }, "ipv6": { "unicast": { "neighbor": { "r2": { "dest_link": { "r1-link1": { "graceful-restart": True } } } } } }, }, } }, "r2": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r1": { "dest_link": { "r2-link1": { "graceful-restart": True } } } } } }, "ipv6": { "unicast": { "neighbor": { "r1": { "dest_link": { "r2-link1": { "graceful-restart": True } } } } } }, } } }, } configure_gr_followed_by_clear(tgen, topo, input_dict, tc_name, dut="r1", peer="r2") for addr_type in ADDR_TYPES: result = verify_graceful_restart(tgen, topo, addr_type, input_dict, dut="r1", peer="r2") assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result) # Verifying BGP RIB routes dut = "r1" peer = "r2" next_hop = next_hop_per_address_family(tgen, dut, peer, addr_type, NEXT_HOP_IP_2) input_topo = {key: topo["routers"][key] for key in ["r2"]} result = verify_bgp_rib(tgen, addr_type, dut, input_topo, next_hop) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result) # Verifying RIB routes protocol = "bgp" result = verify_rib(tgen, addr_type, dut, input_topo, next_hop, protocol) assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result) logger.info("[Phase 2] : R1 goes for reload ") kill_router_daemons(tgen, "r1", ["bgpd"]) logger.info("[Phase 3] : R1 is about to come up now ") start_router_daemons(tgen, "r1", ["bgpd"]) logger.info("[Phase 4] : R2 is UP now, so time to collect GR stats ") for addr_type in ADDR_TYPES: result = verify_graceful_restart(tgen, topo, addr_type, input_dict, dut="r1", peer="r2") assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result) result = verify_r_bit(tgen, topo, addr_type, input_dict, dut="r2", peer="r1") assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result) result = verify_f_bit(tgen, topo, addr_type, input_dict, dut="r2", peer="r1") assert result is True, "Testcase {} : Failed \n Error {}".format( tc_name, result) write_test_footer(tc_name)
def test_ospf_gr_helper_tc8_p1(request): """ Test ospf gr helper Verify helper functionality when dut is helping RR and new grace lsa is received from RR. """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) global topo, intf, intf1, pkt step("Bring up the base config as per the topology") step("Enable GR") reset_config_on_routers(tgen) ospf_covergence = verify_ospf_neighbor(tgen, topo, lan=True) assert ( ospf_covergence is True ), "OSPF is not after reset config \n Error:" " {}".format(ospf_covergence) ospf_gr_r0 = { "r0": { "ospf": { "graceful-restart": { "helper enable": [], "opaque": True } } } } result = create_router_ospf(tgen, topo, ospf_gr_r0) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) ospf_gr_r1 = { "r1": { "ospf": { "graceful-restart": { "helper enable": [], "opaque": True } } } } result = create_router_ospf(tgen, topo, ospf_gr_r1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) input_dict = {"supportedGracePeriod": 1800} dut = "r0" result = verify_ospf_gr_helper(tgen, topo, dut, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify that DUT enters into helper mode.") input_dict = {"activeRestarterCnt": 1} gracelsa_sent = False repeat = 0 dut = "r0" while not gracelsa_sent and repeat < Iters: gracelsa_sent = scapy_send_raw_packet(tgen, topo, "r1", intf1, pkt) result = verify_ospf_gr_helper(tgen, topo, dut, input_dict) if isinstance(result, str): repeat += 1 gracelsa_sent = False assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Send the Grace LSA again to DUT when RR is in GR.") input_dict = {"activeRestarterCnt": 1} gracelsa_sent = False repeat = 0 dut = "r0" while not gracelsa_sent and repeat < Iters: gracelsa_sent = scapy_send_raw_packet(tgen, topo, "r1", intf1, pkt) result = verify_ospf_gr_helper(tgen, topo, dut, input_dict) if isinstance(result, str): repeat += 1 gracelsa_sent = False assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) delete_ospf() write_test_footer(tc_name)
def test_ospf_authentication_md5_tc29_p1(request): """ OSPF Authentication - Verify ospf authentication with MD5 authentication. """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() global topo step("Bring up the base config.") reset_config_on_routers(tgen) step( "Configure ospf with on R1 and R2, enable ospf on R1 interface " "connected to R2 with message-digest authentication using ip " "ospf authentication message-digest cmd." ) r1_ospf_auth = { "r1": { "links": { "r2": { "ospf": { "authentication": "message-digest", "authentication-key": "ospf", "message-digest-key": "10", } } } } } result = config_ospf_interface(tgen, topo, r1_ospf_auth) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) step("Verify that the neighbour is not FULL between R1 and R2.") # wait for dead time expiry. sleep(6) dut = "r1" ospf_covergence = verify_ospf_neighbor( tgen, topo, dut=dut, expected=False, attempts=3 ) assert ospf_covergence is not True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence ) step( "On R2 enable ospf on interface with message-digest authentication" " using ip ospf authentication message-digest password cmd." ) r2_ospf_auth = { "r2": { "links": { "r1": { "ospf": { "authentication": "message-digest", "authentication-key": "ospf", "message-digest-key": "10", } } } } } result = config_ospf_interface(tgen, topo, r2_ospf_auth) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) step( "Verify that the neighbour is FULL between R1 and R2 " "using show ip ospf neighbor cmd." ) dut = "r2" ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence ) step( "Disable message-digest authentication on R2 using no ip ospf " "authentication message-digest password cmd." ) r2_ospf_auth = { "r2": { "links": { "r1": { "ospf": { "authentication": "message-digest", "authentication-key": "ospf", "message-digest-key": "10", "del_action": True, } } } } } result = config_ospf_interface(tgen, topo, r2_ospf_auth) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) step("Verify on R1 ,nbr is deleted for R2 after dead interval expiry") # wait till the dead timer expiry sleep(6) dut = "r2" ospf_covergence = verify_ospf_neighbor( tgen, topo, dut=dut, expected=False, attempts=5 ) assert ospf_covergence is not True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence ) step("Again On R2 enable ospf on interface with message-digest auth") r2_ospf_auth = { "r2": { "links": { "r1": { "ospf": { "authentication": "message-digest", "authentication-key": "ospf", "message-digest-key": "10", } } } } } result = config_ospf_interface(tgen, topo, r2_ospf_auth) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) step( "Verify that the neighbour is FULL between R1 and R2 using" " show ip ospf neighbor cmd." ) dut = "r2" ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence ) step("Shut no shut interface on R1") dut = "r1" intf = topo["routers"]["r1"]["links"]["r2"]["interface"] shutdown_bringup_interface(tgen, dut, intf, False) dut = "r2" step( "Verify that the neighbour is not FULL between R1 and R2 using " "show ip ospf neighbor cmd." ) ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut, expected=False) assert ospf_covergence is not True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence ) dut = "r1" shutdown_bringup_interface(tgen, dut, intf, True) step( "Verify that the neighbour is FULL between R1 and R2 using " "show ip ospf neighbor cmd." ) dut = "r2" ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence ) step("Change Ip address on R1 and R2") topo_modify_change_ip = deepcopy(topo) intf_ip = topo_modify_change_ip["routers"]["r1"]["links"]["r2"]["ipv4"] topo_modify_change_ip["routers"]["r1"]["links"]["r2"]["ipv4"] = str( IPv4Address(unicode(intf_ip.split("/")[0])) + 3 ) + "/{}".format(intf_ip.split("/")[1]) build_config_from_json(tgen, topo_modify_change_ip, save_bkup=False) reset_config_on_routers(tgen, routerName="r1") dut = "r1" intf = topo["routers"]["r1"]["links"]["r2"]["interface"] shutdown_bringup_interface(tgen, dut, intf, False) shutdown_bringup_interface(tgen, dut, intf, True) clear_ospf(tgen, "r1") r1_ospf_auth = { "r1": { "links": { "r2": { "ospf": { "authentication": "message-digest", "authentication-key": "ospf", "message-digest-key": "10", } } } } } result = config_ospf_interface(tgen, topo, r1_ospf_auth) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) step( "Verify that the neighbour is FULL between R1 and R2 with new " "ip address using show ip ospf " ) dut = "r1" ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence ) write_test_footer(tc_name)
def test_ospfv3_ecmp_tc17_p0(request): """ Verify OSPF ECMP. Verify OSPF ECMP with max path configured as 2 (Edge having 2 uplink ports) """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) global topo step("Bring up the base config as per the topology") step("Configure 2 interfaces between R1 and R2 & enable ospf in area 0.") reset_config_on_routers(tgen) step("Verify that OSPF is up with 2 neighborship sessions.") dut = "r1" ospf_covergence = verify_ospf6_neighbor(tgen, topo, dut=dut) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence ) step("Configure a static route in R0 and redistribute in OSPF.") input_dict = { "r0": { "static_routes": [ { "network": NETWORK["ipv6"][0], "no_of_ip": 5, "next_hop": "Null0", } ] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) dut = "r0" red_static(dut) step("Verify that route in R2 in stalled with 2 next hops.") llip = get_llip("r0", "r1-link1") assert llip is not None, "Testcase {} : Failed \n Error: {}".format(tc_name, result) nh1 = llip llip = get_llip("r0", "r1") assert llip is not None, "Testcase {} : Failed \n Error: {}".format(tc_name, result) nh2 = llip nh = [nh1, nh2] dut = "r1" result = verify_ospf6_rib(tgen, dut, input_dict, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) protocol = "ospf" result = verify_rib(tgen, "ipv6", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Configure ECMP value as 1.") max_path = {"r1": {"ospf6": {"maximum-paths": 1}}} result = create_router_ospf(tgen, topo, max_path) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) result = verify_rib(tgen, "ipv6", dut, input_dict, protocol=protocol, next_hop=nh2) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) dut = "r1" max_path = {"r1": {"ospf6": {"maximum-paths": 2}}} result = create_router_ospf(tgen, topo, max_path) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) result = verify_rib(tgen, "ipv6", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) step("Configure cost on R0 as 100") r0_ospf_cost = {"r0": {"links": {"r1": {"ospf6": {"cost": 100}}}}} result = config_ospf6_interface(tgen, topo, r0_ospf_cost) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) dut = "r1" result = verify_ospf6_rib(tgen, dut, input_dict, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) protocol = "ospf" result = verify_rib(tgen, "ipv6", dut, input_dict, protocol=protocol, next_hop=nh) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) write_test_footer(tc_name)
def test_ospf_authentication_different_auths_tc30_p1(request): """ OSPF Authentication - Verify ospf authentication with different authentication methods. """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() global topo step("Bring up the base config.") reset_config_on_routers(tgen) step( "Configure ospf with on R1 and R2, enable ospf on R1 interface " "connected to R2 with message-digest authentication using ip " "ospf authentication message-digest cmd." ) r1_ospf_auth = { "r1": { "links": { "r2": { "ospf": { "authentication": "message-digest", "authentication-key": "ospf", "message-digest-key": "10", } } } } } result = config_ospf_interface(tgen, topo, r1_ospf_auth) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) # wait for dead timer expiry sleep(6) step("Verify that the neighbour is not FULL between R1 and R2.") dut = "r1" ospf_covergence = verify_ospf_neighbor( tgen, topo, dut=dut, expected=False, attempts=5 ) assert ospf_covergence is not True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence ) step( "On R2 enable ospf on interface with message-digest authentication" " using ip ospf authentication message-digest password cmd." ) r2_ospf_auth = { "r2": { "links": { "r1": { "ospf": { "authentication": "message-digest", "authentication-key": "ospf", "message-digest-key": "10", } } } } } result = config_ospf_interface(tgen, topo, r2_ospf_auth) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) step( "Verify that the neighbour is FULL between R1 and R2 " "using show ip ospf neighbor cmd." ) dut = "r2" ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence ) step(" Delete the configured password on both the routers.") r2_ospf_auth = { "r2": { "links": { "r1": { "ospf": { "authentication": "message-digest", "authentication-key": "ospf", "message-digest-key": "10", "del_action": True, } } } } } result = config_ospf_interface(tgen, topo, r2_ospf_auth) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) r1_ospf_auth = { "r1": { "links": { "r2": { "ospf": { "authentication": "message-digest", "authentication-key": "ospf", "message-digest-key": "10", "del_action": True, } } } } } result = config_ospf_interface(tgen, topo, r1_ospf_auth) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) step( "Verify that the deletion is successful and neighbour is FULL" " between R1 and R2 using show ip ospf neighbor cmd." ) dut = "r2" ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence ) step("Change the authentication type to simple password.") r1_ospf_auth = { "r1": { "links": { "r2": {"ospf": {"authentication": True, "authentication-key": "ospf"}} } } } result = config_ospf_interface(tgen, topo, r1_ospf_auth) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) r2_ospf_auth = { "r2": { "links": { "r1": {"ospf": {"authentication": True, "authentication-key": "ospf"}} } } } result = config_ospf_interface(tgen, topo, r2_ospf_auth) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) step( "Verify that the deletion is successful and neighbour is" " FULL between R1 and R2 using show ip " ) dut = "r2" ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence ) step("Change the password in simple password.") r1_ospf_auth = { "r1": { "links": { "r2": {"ospf": {"authentication": True, "authentication-key": "OSPFv4"}} } } } result = config_ospf_interface(tgen, topo, r1_ospf_auth) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) r2_ospf_auth = { "r2": { "links": { "r1": {"ospf": {"authentication": True, "authentication-key": "OSPFv4"}} } } } result = config_ospf_interface(tgen, topo, r2_ospf_auth) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) step( "Verify that the deletion is successful and neighbour is" " FULL between R1 and R2 using show ip " ) dut = "r2" ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence ) step("Delete the password authentication on the interface ") r1_ospf_auth = { "r1": { "links": { "r2": { "ospf": { "authentication": True, "authentication-key": "OSPFv4", "del_action": True, } } } } } result = config_ospf_interface(tgen, topo, r1_ospf_auth) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) r2_ospf_auth = { "r2": { "links": { "r1": { "ospf": { "authentication": True, "authentication-key": "OSPFv4", "del_action": True, } } } } } result = config_ospf_interface(tgen, topo, r2_ospf_auth) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) step( "Verify that the deletion is successful and neighbour is" " FULL between R1 and R2 using show ip " ) dut = "r2" ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence ) step("Enable Md5 authentication on the interface") r1_ospf_auth = { "r1": { "links": { "r2": { "ospf": { "authentication": "message-digest", "authentication-key": "ospf", "message-digest-key": "10", } } } } } result = config_ospf_interface(tgen, topo, r1_ospf_auth) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) r2_ospf_auth = { "r2": { "links": { "r1": { "ospf": { "authentication": "message-digest", "authentication-key": "ospf", "message-digest-key": "10", } } } } } result = config_ospf_interface(tgen, topo, r2_ospf_auth) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) step( "Verify that the neighbour is FULL between R1 and R2 using" " show ip ospf neighbor cmd." ) dut = "r2" ospf_covergence = verify_ospf_neighbor(tgen, topo, dut=dut) assert ospf_covergence is True, "setup_module :Failed \n Error:" " {}".format( ospf_covergence ) step("Change the MD5 authentication password") r1_ospf_auth = { "r1": { "links": { "r2": { "ospf": { "authentication": "message-digest", "authentication-key": "OSPFv4", "message-digest-key": "10", } } } } } result = config_ospf_interface(tgen, topo, r1_ospf_auth) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) r2_ospf_auth = { "r2": { "links": { "r1": { "ospf": { "authentication": "message-digest", "authentication-key": "OSPFv4", "message-digest-key": "10", } } } } } result = config_ospf_interface(tgen, topo, r2_ospf_auth) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result) write_test_footer(tc_name)
def test_PIM_hello_tx_rx_p1(request): """ TC_54 Verify received and transmit hello stats are getting cleared after PIM nbr reset """ tgen = get_topogen() tc_name = request.node.name write_test_header(tc_name) # Creating configuration from JSON kill_iperf(tgen) clear_ip_mroute(tgen) reset_config_on_routers(tgen) clear_ip_pim_interface_traffic(tgen, topo) # Don"t run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) step("Remove c1-c2 connected link to simulate topo " "c1(LHR)---l1(RP)----r2---f1-----c2(FHR)") intf_c1_c2 = topo["routers"]["c1"]["links"]["c2"]["interface"] intf_c2_c1 = topo["routers"]["c2"]["links"]["c1"]["interface"] shutdown_bringup_interface(tgen, "c1", intf_c1_c2, False) shutdown_bringup_interface(tgen, "c2", intf_c2_c1, False) step("Enable the PIM on all the interfaces of FRR1, FRR2, FRR3") step("Enable IGMP of FRR1 interface and send IGMP joins " " from FRR1 node for group range (225.1.1.1-5)") intf_c1_i4 = topo["routers"]["c1"]["links"]["i4"]["interface"] input_dict = { "c1": { "igmp": { "interfaces": { intf_c1_i4: { "igmp": { "version": "2" } } } } } } result = create_igmp_config(tgen, topo, input_dict) assert result is True, "Testcase {}: Failed Error: {}".format( tc_name, result) input_join = {"i4": topo["routers"]["i4"]["links"]["c1"]["interface"]} for recvr, recvr_intf in input_join.items(): result = config_to_send_igmp_join_and_traffic(tgen, topo, tc_name, recvr, recvr_intf, GROUP_RANGE_1, join=True) assert result is True, "Testcase {}: Failed Error: {}".format( tc_name, result) result = iperfSendIGMPJoin(tgen, recvr, IGMP_JOIN_RANGE_1, join_interval=1) assert result is True, "Testcase {}: Failed Error: {}".format( tc_name, result) step("Configure static RP for (225.1.1.1-5) as R2") input_dict = { "l1": { "pim": { "rp": [{ "rp_addr": topo["routers"]["l1"]["links"]["lo"]["ipv4"].split("/")[0], "group_addr_range": GROUP_RANGE, }] } } } result = create_pim_config(tgen, topo, input_dict) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) step( "Send Mcast traffic from C2 to all the groups ( 225.1.1.1 to 225.1.1.5)" ) input_src = {"i5": topo["routers"]["i5"]["links"]["c2"]["interface"]} for src, src_intf in input_src.items(): result = config_to_send_igmp_join_and_traffic(tgen, topo, tc_name, src, src_intf, GROUP_RANGE_1, traffic=True) assert result is True, "Testcase {}: Failed Error: {}".format( tc_name, result) result = iperfSendTraffic(tgen, src, IGMP_JOIN_RANGE_1, 32, 2500) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) source_i5 = topo["routers"]["i5"]["links"]["c2"]["ipv4"].split("/")[0] input_dict_starg = [{ "dut": "c1", "src_address": "*", "iif": topo["routers"]["c1"]["links"]["l1"]["interface"], "oil": topo["routers"]["c1"]["links"]["i4"]["interface"], }] input_dict_sg = [{ "dut": "c1", "src_address": source_i5, "iif": topo["routers"]["c1"]["links"]["l1"]["interface"], "oil": topo["routers"]["c1"]["links"]["i4"]["interface"], }] step( "(*,G) and (S,G) created on f1 and node verify using 'show ip mroute'") for data in input_dict_sg: result = verify_ip_mroutes( tgen, data["dut"], data["src_address"], IGMP_JOIN_RANGE_1, data["iif"], data["oil"], ) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) for data in input_dict_starg: result = verify_ip_mroutes( tgen, data["dut"], data["src_address"], IGMP_JOIN_RANGE_1, data["iif"], data["oil"], ) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) intf_l1_c1 = topo["routers"]["l1"]["links"]["c1"]["interface"] intf_c1_l1 = topo["routers"]["c1"]["links"]["l1"]["interface"] step("verify before stats on C1") state_dict = { "c1": { intf_c1_l1: ["helloTx", "helloRx"], } } c1_state_before = verify_pim_interface_traffic(tgen, state_dict) assert isinstance( c1_state_before, dict), "Testcase{} : Failed \n state_before is not dictionary \n " "Error: {}".format(tc_name, result) step( "Flap PIM nbr while doing interface c1-l1 interface shut from f1 side") shutdown_bringup_interface(tgen, "c1", intf_c1_l1, False) step( "After shut of local interface from c1 , verify rx/tx hello counters are cleared on c1 side" "verify using 'show ip pim interface traffic'") shutdown_bringup_interface(tgen, "c1", intf_c1_l1, True) step("verify stats after on c1") c1_state_after = verify_pim_interface_traffic(tgen, state_dict) assert isinstance( c1_state_after, dict), "Testcase{} : Failed \n state_before is not dictionary \n " "Error: {}".format(tc_name, result) step("verify stats not increamented on c1") result = verify_state_incremented(c1_state_before, c1_state_after) assert (result is not True ), "Testcase{} : Failed Error: {}" "stats incremented".format( tc_name, result) step("verify before stats on l1") l1_state_dict = { "l1": { intf_l1_c1: ["helloTx", "helloRx"], } } l1_state_before = verify_pim_interface_traffic(tgen, l1_state_dict) assert isinstance( l1_state_before, dict), "Testcase{} : Failed \n state_before is not dictionary \n " "Error: {}".format(tc_name, result) step("Flap PIM nbr while doing interface r2-c1 shut from r2 side") shutdown_bringup_interface(tgen, "l1", intf_l1_c1, False) step( "After shut the interface from r2 side , verify r2 side rx and tx of hello" "counters are resetted show ip pim interface traffic") shutdown_bringup_interface(tgen, "l1", intf_l1_c1, True) step("verify stats after on l1") l1_state_after = verify_pim_interface_traffic(tgen, l1_state_dict) assert isinstance( l1_state_after, dict), "Testcase{} : Failed \n state_before is not dictionary \n " "Error: {}".format(tc_name, result) step("verify stats not increamented on l1") result = verify_state_incremented(l1_state_before, l1_state_after) assert (result is not True ), "Testcase{} : Failed Error: {}" "stats incremented".format( tc_name, result) step("Reinit the dict") c1_state_before = {} l1_state_before = {} c1_state_after = {} l1_state_after = {} step("verify before stats on C1") state_dict = { "c1": { intf_c1_l1: ["helloTx", "helloRx"], } } c1_state_before = verify_pim_interface_traffic(tgen, state_dict) assert isinstance( c1_state_before, dict), "Testcase{} : Failed \n state_before is not dictionary \n " "Error: {}".format(tc_name, result) step("Flap c1-r2 pim nbr while changing ip address from c1 side") c1_l1_ip_subnet = topo["routers"]["c1"]["links"]["l1"]["ipv4"] raw_config = { "c1": { "raw_config": [ "interface {}".format(intf_c1_l1), "no ip address {}".format(c1_l1_ip_subnet), "ip address {}".format(NEW_ADDRESS_2_SUBNET), ] } } result = apply_raw_config(tgen, raw_config) assert result is True, "Testcase {} : Failed Error: {}".format( tc_name, result) step("verify stats after on c1") c1_state_after = verify_pim_interface_traffic(tgen, state_dict) assert isinstance( c1_state_after, dict), "Testcase{} : Failed \n state_before is not dictionary \n " "Error: {}".format(tc_name, result) step("verify stats not increamented on c1") result = verify_state_incremented(c1_state_before, c1_state_after) assert (result is not True ), "Testcase{} : Failed Error: {}" "stats incremented".format( tc_name, result) write_test_footer(tc_name)
def test_same_rte_from_bgp_static_p0_tc5_ebgp(request): """ Verify RIB status when same route advertise via BGP and static route """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don't run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) reset_config_on_routers(tgen) NEXT_HOP_IP = populate_nh() step("Configure EBGP IPv4 peering between R2 and R3 router.") step("Configure IPv4 static route (10.1.1.1/24) in R2 with next hop" "N1 (28.1.1.2 ) and N2 (29.1.1.2) , Static route next-hop present" "on R1") for addr_type in ADDR_TYPES: input_dict_4 = { "r2": { "static_routes": [ { "network": NETWORK[addr_type], "next_hop": NEXT_HOP_IP["nh1"][addr_type], }, { "network": NETWORK[addr_type], "next_hop": NEXT_HOP_IP["nh2"][addr_type], }, ] } } logger.info("Configure static routes") result = create_static_routes(tgen, input_dict_4) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Configure redistribute static in BGP.") for addr_type in ADDR_TYPES: input_dict_2 = { "r2": { "bgp": { "address_family": { addr_type: { "unicast": { "redistribute": [{ "redist_type": "static" }] } } } } } } result = create_router_bgp(tgen, topo, input_dict_2) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify on R3 , route receive on R3 BGP table ") dut = "r3" result = verify_bgp_rib(tgen, addr_type, dut, input_dict_4) assert result is True, "Testcase {} : Failed \nError: Route is" " still present in RIB".format(tc_name) step("Verify route installed in the RIB and FIB of R3") protocol = "bgp" result = verify_rib(tgen, addr_type, dut, input_dict_4, protocol=protocol) assert result is True, "Testcase {} : Failed \nError: Route is" " still present in RIB".format(tc_name) step("Configure 2 links/interfaces between R1 and R3 , keep one" "interface in shut (active) state and other interface in no shut" "(inactive) state") dut = "r3" intf = topo["routers"]["r3"]["links"]["r1-link0"]["interface"] shutdown_bringup_interface(tgen, dut, intf, False) step("Configure same static route (10.1.1.1/24) in R3 with inactive" "nexthop interface") step("Configure same static route 10.1.1.1/24) again in R3 with" "active nexthop interface") for addr_type in ADDR_TYPES: input_dict_4 = { "r3": { "static_routes": [ { "network": NETWORK[addr_type], "next_hop": topo["routers"]["r1"]["links"]["r3-link0"][addr_type], }, { "network": NETWORK[addr_type], "next_hop": topo["routers"]["r1"]["links"]["r3-link1"][addr_type], }, ] } } logger.info("Configure static routes") result = create_static_routes(tgen, input_dict_4) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("Verify when static route configure with inactive nexthop , " "verify BGP received route is active in the RIB and FIB") dut = "r3" result = verify_bgp_rib(tgen, addr_type, dut, input_dict_4) assert result is True, "Testcase {} : Failed \nError: Route is" " missing in BGP RIB".format(tc_name) protocol = "bgp" result = verify_rib(tgen, addr_type, dut, input_dict_4, protocol=protocol, fib=True) assert result is True, "Testcase {} : Failed \nError: Route is" " missing in RIB".format(tc_name) step("Remove the static route on R3 configured with active" "interface") for addr_type in ADDR_TYPES: input_dict_4 = { "r3": { "static_routes": [ { "network": NETWORK[addr_type], "next_hop": topo["routers"]["r1"]["links"]["r3-link0"][addr_type], "delete": True, }, { "network": NETWORK[addr_type], "next_hop": topo["routers"]["r1"]["links"]["r3-link1"][addr_type], "delete": True, }, ] } } logger.info("Configure static routes") result = create_static_routes(tgen, input_dict_4) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result) step("After removing the static route with active nexthop verify " "BGP received route is became active in RIB and FIB") dut = "r3" result = verify_bgp_rib(tgen, addr_type, dut, input_dict_4) assert result is True, "Testcase {} : Failed \nError: Route is" " missing in BGP RIB".format(tc_name) protocol = "bgp" result = verify_rib(tgen, addr_type, dut, input_dict_4, protocol=protocol, fib=True) assert result is True, "Testcase {} : Failed \nError: Route is" " missing in RIB".format(tc_name) write_test_footer(tc_name)
def test_modify_prefix_lists_in_deny_to_permit(request): """ Modify ip prefix list and test deny to permit prefixes IN direction """ tgen = get_topogen() if BGP_CONVERGENCE is not True: pytest.skip("skipped because of BGP Convergence failure") # test case name tc_name = request.node.name write_test_header(tc_name) # Creating configuration from JSON reset_config_on_routers(tgen) # Create Static Routes input_dict = { "r1": { "static_routes": [ {"network": "10.0.20.1/32", "no_of_ip": 9, "next_hop": "10.0.0.2"} ] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Api call to redistribute static routes # Create ip prefix list input_dict_1 = { "r3": { "prefix_lists": { "ipv4": { "pf_list_1": [ { "seqid": "10", "network": "10.0.0.0/8", "le": "32", "action": "deny", }, {"seqid": "11", "network": "any", "action": "permit"}, ] } } } } result = create_prefix_lists(tgen, input_dict_1) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Configure prefix list to bgp neighbor input_dict_2 = { "r1": { "bgp": { "address_family": { "ipv4": { "unicast": { "redistribute": [ {"redist_type": "static"}, {"redist_type": "connected"}, ] } } } } }, "r3": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r1": { "dest_link": { "r3": { "prefix_lists": [ {"name": "pf_list_1", "direction": "in"} ] } } } } } } } } }, } result = create_router_bgp(tgen, topo, input_dict_2) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Verifying RIB routes dut = "r3" protocol = "bgp" result = verify_rib( tgen, "ipv4", dut, input_dict, protocol=protocol, expected=False ) assert ( result is not True ), "Testcase {} : Failed \n Error: Routes still" " present in RIB".format(tc_name) # Modify ip prefix list input_dict_1 = { "r3": { "prefix_lists": { "ipv4": { "pf_list_1": [ { "seqid": "10", "network": "10.0.0.0/8", "le": "32", "action": "permit", } ] } } } } result = create_prefix_lists(tgen, input_dict_1) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Api call to clear bgp, so config changes would be reflected dut = "r3" result = clear_bgp_and_verify(tgen, topo, dut) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) # Verifying RIB routes dut = "r3" protocol = "bgp" result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol) assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result) write_test_footer(tc_name)
def test_route_map_with_action_values_combination_of_prefix_action_p0( request, prefix_action, rmap_action ): """ TC_36: Test permit/deny statements operation in route-maps with a permutation and combination of permit/deny in prefix-lists """ tc_name = request.node.name write_test_header(tc_name) tgen = get_topogen() # Don"t run this test if we have any failure. if tgen.routers_have_failure(): pytest.skip(tgen.errors) # Creating configuration from JSON reset_config_on_routers(tgen) for adt in ADDR_TYPES: # Create Static routes input_dict = { "r1": { "static_routes": [ { "network": NETWORK[adt][0], "no_of_ip": 9, "next_hop": NEXT_HOP[adt], } ] } } result = create_static_routes(tgen, input_dict) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) # Api call to redistribute static routes input_dict_1 = { "r1": { "bgp": { "local_as": 100, "address_family": { "ipv4": { "unicast": { "redistribute": [ {"redist_type": "static"}, {"redist_type": "connected"}, ] } }, "ipv6": { "unicast": { "redistribute": [ {"redist_type": "static"}, {"redist_type": "connected"}, ] } }, }, } } } result = create_router_bgp(tgen, topo, input_dict_1) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) # Permit in perfix list and route-map input_dict_2 = { "r3": { "prefix_lists": { "ipv4": { "pf_list_1_ipv4": [ {"seqid": 10, "network": "any", "action": prefix_action} ] }, "ipv6": { "pf_list_1_ipv6": [ {"seqid": 100, "network": "any", "action": prefix_action} ] }, } } } result = create_prefix_lists(tgen, input_dict_2) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) # Create route map for addr_type in ADDR_TYPES: input_dict_3 = { "r3": { "route_maps": { "rmap_match_pf_1_{}".format(addr_type): [ { "action": rmap_action, "match": { addr_type: { "prefix_lists": "pf_list_1_{}".format(addr_type) } }, } ] } } } result = create_route_maps(tgen, input_dict_3) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) # Configure neighbor for route map input_dict_7 = { "r3": { "bgp": { "address_family": { "ipv4": { "unicast": { "neighbor": { "r1": { "dest_link": { "r3": { "route_maps": [ { "name": "rmap_match_pf_1_ipv4", "direction": "in", } ] } } } } } }, "ipv6": { "unicast": { "neighbor": { "r1": { "dest_link": { "r3": { "route_maps": [ { "name": "rmap_match_pf_1_ipv6", "direction": "in", } ] } } } } } }, } } } } result = create_router_bgp(tgen, topo, input_dict_7) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result ) dut = "r3" protocol = "bgp" input_dict_2 = { "r1": { "static_routes": [ { "network": [NETWORK[adt][0]], "no_of_ip": 9, "next_hop": NEXT_HOP[adt], } ] } } # tgen.mininet_cli() if "deny" in [prefix_action, rmap_action]: result = verify_rib( tgen, adt, dut, input_dict_2, protocol=protocol, expected=False ) assert ( result is not True ), "Testcase {} : Failed \nRoutes are still present \n Error: {}".format( tc_name, result ) logger.info("Expected behaviour: {}".format(result)) else: result = verify_rib(tgen, adt, dut, input_dict_2, protocol=protocol) assert result is True, "Testcase {} : Failed \n Error: {}".format( tc_name, result )