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
)