def config_to_send_igmp_join_and_traffic(tgen,
topo,
tc_name,
iperf,
iperf_intf,
GROUP_RANGE,
join=False,
traffic=False):
"""
API to do pre-configuration to send IGMP join and multicast
traffic
parameters:
-----------
* `tgen`: topogen object
* `topo`: input json data
* `tc_name`: caller test case name
* `iperf`: router running iperf
* `iperf_intf`: interface name router running iperf
* `GROUP_RANGE`: group range
* `join`: IGMP join, default False
* `traffic`: multicast traffic, default False
"""
if join:
# Add route to kernal
result = addKernelRoute(tgen, iperf, iperf_intf, GROUP_RANGE)
assert result is True, "Testcase {}: Failed Error: {}".format(
tc_name, result)
if traffic:
# Add route to kernal
result = addKernelRoute(tgen, iperf, iperf_intf, GROUP_RANGE)
assert result is True, "Testcase {}: Failed Error: {}".format(
tc_name, result)
router_list = tgen.routers()
for router in router_list.keys():
if router == iperf:
continue
rnode = router_list[router]
rnode.run("echo 2 > /proc/sys/net/ipv4/conf/all/rp_filter")
for router in topo["routers"].keys():
if "static_routes" in topo["routers"][router]:
static_routes = topo["routers"][router]["static_routes"]
for static_route in static_routes:
network = static_route["network"]
next_hop = static_route["next_hop"]
if type(network) is not list:
network = [network]
return True
def pre_config_to_bsm(tgen, topo, tc_name, bsr, sender, receiver, fhr, rp, lhr,
packet):
"""
API to do required configuration to send and receive BSR packet
"""
# Re-configure interfaces as per BSR packet
result = reconfig_interfaces(tgen, topo, bsr, fhr, packet)
assert result is True, "Testcase {} :Failed \n Error {}".format(
tc_name, result)
# Create static routes
if "bsr" in topo["routers"][bsr]["bsm"]["bsr_packets"][packet]:
bsr_route = topo["routers"][bsr]["bsm"]["bsr_packets"][packet]["bsr"]
next_hop = topo["routers"][bsr]["bsm"]["bsr_packets"][packet][
"src_ip"].split("/")[0]
next_hop_rp = topo["routers"][fhr]["links"][rp]["ipv4"].split("/")[0]
next_hop_lhr = topo["routers"][rp]["links"][lhr]["ipv4"].split("/")[0]
# Add static routes
input_dict = {
fhr: {
"static_routes": [{
"network": bsr_route,
"next_hop": next_hop
}]
},
rp: {
"static_routes": [{
"network": bsr_route,
"next_hop": next_hop_rp
}]
},
lhr: {
"static_routes": [{
"network": bsr_route,
"next_hop": next_hop_lhr
}]
},
}
result = create_static_routes(tgen, input_dict)
assert result is True, "Testcase {} :Failed \n Error {}".format(
tc_name, result)
# Add kernal route for source
group = topo["routers"][bsr]["bsm"]["bsr_packets"][packet]["pkt_dst"]
bsr_interface = topo["routers"][bsr]["links"][fhr]["interface"]
result = addKernelRoute(tgen, bsr, bsr_interface, group)
assert result is True, "Testcase {} :Failed \n Error {}".format(
tc_name, result)
# RP Mapping
rp_mapping = topo["routers"][bsr]["bsm"]["bsr_packets"][packet][
"rp_mapping"]
# Add interfaces in RP for all the RPs
result = add_rp_interfaces_and_pim_config(tgen, topo, "lo", rp, rp_mapping)
assert result is True, "Testcase {} :Failed \n Error {}".format(
tc_name, result)
# Add kernal routes to sender and receiver
for group, rp_list in rp_mapping.items():
mask = group.split("/")[1]
if int(mask) == 32:
group = group.split("/")[0]
# Add kernal routes for sender
s_interface = topo["routers"][sender]["links"][fhr]["interface"]
result = addKernelRoute(tgen, sender, s_interface, group)
assert result is True, "Testcase {} :Failed \n Error {}".format(
tc_name, result)
# Add kernal routes for receiver
r_interface = topo["routers"][receiver]["links"][lhr]["interface"]
result = addKernelRoute(tgen, receiver, r_interface, group)
assert result is True, "Testcase {} :Failed \n Error {}".format(
tc_name, result)
# Add static routes for RPs in FHR and LHR
next_hop_fhr = topo["routers"][rp]["links"][fhr]["ipv4"].split("/")[0]
next_hop_lhr = topo["routers"][rp]["links"][lhr]["ipv4"].split("/")[0]
input_dict = {
fhr: {
"static_routes": [{
"network": rp_list,
"next_hop": next_hop_fhr
}]
},
}
result = create_static_routes(tgen, input_dict)
assert result is True, "Testcase {} :Failed \n Error {}".format(
tc_name, result)
input_dict = {
lhr: {
"static_routes": [{
"network": rp_list,
"next_hop": next_hop_lhr
}]
},
}
result = create_static_routes(tgen, input_dict)
assert result is True, "Testcase {} :Failed \n Error {}".format(
tc_name, result)
return True
def test_bgp_with_loopback_with_same_subnet_p1(request):
"""
Verify routes not installed in zebra when /32 routes received
with loopback BGP session subnet
"""
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)
step("Delete BGP seesion created initially")
input_dict_r1 = {
"r1": {"bgp": {"delete": True}},
"r2": {"bgp": {"delete": True}},
"r3": {"bgp": {"delete": True}},
"r4": {"bgp": {"delete": True}},
}
result = create_router_bgp(tgen, topo, input_dict_r1)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
step("Create BGP session over loop address")
topo_modify = deepcopy(topo)
for routerN in sorted(topo["routers"].keys()):
for addr_type in ADDR_TYPES:
for bgp_neighbor in topo_modify["routers"][routerN]["bgp"][
"address_family"
][addr_type]["unicast"]["neighbor"].keys():
# Adding ['source_link'] = 'lo' key:value pair
topo_modify["routers"][routerN]["bgp"]["address_family"][addr_type][
"unicast"
]["neighbor"][bgp_neighbor]["dest_link"] = {
"lo": {"source_link": "lo", "ebgp_multihop": 2}
}
result = create_router_bgp(tgen, topo_modify["routers"])
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
step("Disable IPv6 BGP nbr from ipv4 address family")
raw_config = {
"r1": {
"raw_config": [
"router bgp {}".format(topo["routers"]["r1"]["bgp"]["local_as"]),
"address-family ipv4 unicast",
"no neighbor {} activate".format(
topo["routers"]["r2"]["links"]["lo"]["ipv6"].split("/")[0]
),
"no neighbor {} activate".format(
topo["routers"]["r3"]["links"]["lo"]["ipv6"].split("/")[0]
),
]
},
"r2": {
"raw_config": [
"router bgp {}".format(topo["routers"]["r2"]["bgp"]["local_as"]),
"address-family ipv4 unicast",
"no neighbor {} activate".format(
topo["routers"]["r1"]["links"]["lo"]["ipv6"].split("/")[0]
),
"no neighbor {} activate".format(
topo["routers"]["r3"]["links"]["lo"]["ipv6"].split("/")[0]
),
]
},
"r3": {
"raw_config": [
"router bgp {}".format(topo["routers"]["r3"]["bgp"]["local_as"]),
"address-family ipv4 unicast",
"no neighbor {} activate".format(
topo["routers"]["r1"]["links"]["lo"]["ipv6"].split("/")[0]
),
"no neighbor {} activate".format(
topo["routers"]["r2"]["links"]["lo"]["ipv6"].split("/")[0]
),
"no neighbor {} activate".format(
topo["routers"]["r4"]["links"]["lo"]["ipv6"].split("/")[0]
),
]
},
"r4": {
"raw_config": [
"router bgp {}".format(topo["routers"]["r4"]["bgp"]["local_as"]),
"address-family ipv4 unicast",
"no neighbor {} activate".format(
topo["routers"]["r3"]["links"]["lo"]["ipv6"].split("/")[0]
),
]
},
}
step("Configure kernel routes")
result = apply_raw_config(tgen, raw_config)
assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
r1_ipv4_lo = topo["routers"]["r1"]["links"]["lo"]["ipv4"]
r1_ipv6_lo = topo["routers"]["r1"]["links"]["lo"]["ipv6"]
r2_ipv4_lo = topo["routers"]["r2"]["links"]["lo"]["ipv4"]
r2_ipv6_lo = topo["routers"]["r2"]["links"]["lo"]["ipv6"]
r3_ipv4_lo = topo["routers"]["r3"]["links"]["lo"]["ipv4"]
r3_ipv6_lo = topo["routers"]["r3"]["links"]["lo"]["ipv6"]
r4_ipv4_lo = topo["routers"]["r4"]["links"]["lo"]["ipv4"]
r4_ipv6_lo = topo["routers"]["r4"]["links"]["lo"]["ipv6"]
r1_r2 = topo["routers"]["r1"]["links"]["r2"]["ipv6"].split("/")[0]
r2_r1 = topo["routers"]["r2"]["links"]["r1"]["ipv6"].split("/")[0]
r1_r3 = topo["routers"]["r1"]["links"]["r3"]["ipv6"].split("/")[0]
r3_r1 = topo["routers"]["r3"]["links"]["r1"]["ipv6"].split("/")[0]
r2_r3 = topo["routers"]["r2"]["links"]["r3"]["ipv6"].split("/")[0]
r3_r2 = topo["routers"]["r3"]["links"]["r2"]["ipv6"].split("/")[0]
r3_r4 = topo["routers"]["r3"]["links"]["r4"]["ipv6"].split("/")[0]
r4_r3 = topo["routers"]["r4"]["links"]["r3"]["ipv6"].split("/")[0]
r1_r2_ipv4 = topo["routers"]["r1"]["links"]["r2"]["ipv4"].split("/")[0]
r2_r1_ipv4 = topo["routers"]["r2"]["links"]["r1"]["ipv4"].split("/")[0]
r1_r3_ipv4 = topo["routers"]["r1"]["links"]["r3"]["ipv4"].split("/")[0]
r3_r1_ipv4 = topo["routers"]["r3"]["links"]["r1"]["ipv4"].split("/")[0]
r2_r3_ipv4 = topo["routers"]["r2"]["links"]["r3"]["ipv4"].split("/")[0]
r3_r2_ipv4 = topo["routers"]["r3"]["links"]["r2"]["ipv4"].split("/")[0]
r3_r4_ipv4 = topo["routers"]["r3"]["links"]["r4"]["ipv4"].split("/")[0]
r4_r3_ipv4 = topo["routers"]["r4"]["links"]["r3"]["ipv4"].split("/")[0]
r1_r2_intf = topo["routers"]["r1"]["links"]["r2"]["interface"]
r2_r1_intf = topo["routers"]["r2"]["links"]["r1"]["interface"]
r1_r3_intf = topo["routers"]["r1"]["links"]["r3"]["interface"]
r3_r1_intf = topo["routers"]["r3"]["links"]["r1"]["interface"]
r2_r3_intf = topo["routers"]["r2"]["links"]["r3"]["interface"]
r3_r2_intf = topo["routers"]["r3"]["links"]["r2"]["interface"]
r3_r4_intf = topo["routers"]["r3"]["links"]["r4"]["interface"]
r4_r3_intf = topo["routers"]["r4"]["links"]["r3"]["interface"]
ipv4_list = [
("r1", r1_r2_intf, r2_ipv4_loopback),
("r1", r1_r3_intf, r3_ipv4_loopback),
("r2", r2_r1_intf, r1_ipv4_loopback),
("r2", r2_r3_intf, r3_ipv4_loopback),
("r3", r3_r1_intf, r1_ipv4_loopback),
("r3", r3_r2_intf, r2_ipv4_loopback),
("r3", r3_r4_intf, r4_ipv4_loopback),
("r4", r4_r3_intf, r3_ipv4_loopback),
]
ipv6_list = [
("r1", r1_r2_intf, r2_ipv6_loopback, r2_r1),
("r1", r1_r3_intf, r3_ipv6_loopback, r3_r1),
("r2", r2_r1_intf, r1_ipv6_loopback, r1_r2),
("r2", r2_r3_intf, r3_ipv6_loopback, r3_r2),
("r3", r3_r1_intf, r1_ipv6_loopback, r1_r3),
("r3", r3_r2_intf, r2_ipv6_loopback, r2_r3),
("r3", r3_r4_intf, r4_ipv6_loopback, r4_r3),
("r4", r4_r3_intf, r3_ipv6_loopback, r3_r4),
]
for dut, intf, loop_addr in ipv4_list:
result = addKernelRoute(tgen, dut, intf, loop_addr)
assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
for dut, intf, loop_addr, next_hop in ipv6_list:
result = addKernelRoute(tgen, dut, intf, loop_addr, next_hop)
assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
step("Configure static routes")
input_dict = {
"r1": {
"static_routes": [
{"network": r2_ipv4_loopback, "next_hop": r2_r1_ipv4},
{"network": r3_ipv4_loopback, "next_hop": r3_r1_ipv4},
{"network": r2_ipv6_loopback, "next_hop": r2_r1},
{"network": r3_ipv6_loopback, "next_hop": r3_r1},
]
},
"r2": {
"static_routes": [
{"network": r1_ipv4_loopback, "next_hop": r1_r2_ipv4},
{"network": r3_ipv4_loopback, "next_hop": r3_r2_ipv4},
{"network": r1_ipv6_loopback, "next_hop": r1_r2},
{"network": r3_ipv6_loopback, "next_hop": r3_r2},
]
},
"r3": {
"static_routes": [
{"network": r1_ipv4_loopback, "next_hop": r1_r3_ipv4},
{"network": r2_ipv4_loopback, "next_hop": r2_r3_ipv4},
{"network": r4_ipv4_loopback, "next_hop": r4_r3_ipv4},
{"network": r1_ipv6_loopback, "next_hop": r1_r3},
{"network": r2_ipv6_loopback, "next_hop": r2_r3},
{"network": r4_ipv6_loopback, "next_hop": r4_r3},
]
},
"r4": {
"static_routes": [
{"network": r3_ipv4_loopback, "next_hop": r3_r4_ipv4},
{"network": r3_ipv6_loopback, "next_hop": r3_r4},
]
},
}
result = create_static_routes(tgen, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
step("Verify BGP session convergence")
result = verify_bgp_convergence(tgen, topo_modify)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
step("Configure redistribute connected on R2 and R4")
input_dict_1 = {
"r2": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {"redistribute": [{"redist_type": "connected"}]}
},
"ipv6": {
"unicast": {"redistribute": [{"redist_type": "connected"}]}
},
}
}
},
"r4": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {"redistribute": [{"redist_type": "connected"}]}
},
"ipv6": {
"unicast": {"redistribute": [{"redist_type": "connected"}]}
},
}
}
},
}
result = create_router_bgp(tgen, topo, input_dict_1)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
step("Verify Ipv4 and Ipv6 network installed in R1 RIB but not in FIB")
input_dict_r1 = {
"r1": {
"static_routes": [
{"network": "1.0.2.17/32"},
{"network": "2001:db8:f::2:17/128"},
]
}
}
dut = "r1"
protocol = "bgp"
for addr_type in ADDR_TYPES:
result = verify_fib_routes(
tgen, addr_type, dut, input_dict_r1, expected=False
) # pylint: disable=E1123
assert result is not True, (
"Testcase {} : Failed \n".format(tc_name)
+ "Expected behavior: routes should not present in fib \n"
+ "Error: {}".format(result)
)
step("Verify Ipv4 and Ipv6 network installed in r3 RIB but not in FIB")
input_dict_r3 = {
"r3": {
"static_routes": [
{"network": "1.0.4.17/32"},
{"network": "2001:db8:f::4:17/128"},
]
}
}
dut = "r3"
protocol = "bgp"
for addr_type in ADDR_TYPES:
result = verify_fib_routes(
tgen, addr_type, dut, input_dict_r1, expected=False
) # pylint: disable=E1123
assert result is not True, (
"Testcase {} : Failed \n".format(tc_name)
+ "Expected behavior: routes should not present in fib \n"
+ "Error: {}".format(result)
)
write_test_footer(tc_name)
def test_ibgp_loopback_nbr_p1(request):
"""
Verify Extended capability nexthop with loopback interface.
Verify IPv4 routes are advertised and withdrawn when IPv6 IBGP
session established using loopback interface
"""
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
topo1 = deepcopy(topo)
reset_config_on_routers(tgen)
step("Configure IPv6 global address between R1 and R2")
step(
"Configure loopback on R1 and R2 and establish EBGP session "
"between R1 and R2 over loopback global ip"
)
step("Configure static route on R1 and R2 for loopback reachability")
step("Enable cap ext nh on r1 and r2 and activate in ipv4 addr family")
for routerN in ["r1", "r2"]:
for addr_type in ["ipv6"]:
for bgp_neighbor in topo1["routers"][routerN]["bgp"]["address_family"][
addr_type
]["unicast"]["neighbor"].keys():
# Adding ['source_link'] = 'lo' key:value pair
if bgp_neighbor == "r1" or bgp_neighbor == "r2":
topo1["routers"][routerN]["bgp"]["address_family"][addr_type][
"unicast"
]["neighbor"][bgp_neighbor]["dest_link"] = {
"lo": {
"source_link": "lo",
"ebgp_multihop": 2,
"capability": "extended-nexthop",
"activate": "ipv4",
}
}
# Creating configuration from JSON
build_config_from_json(tgen, topo1, save_bkup=False)
configure_bgp_on_r1 = {
"r1": {
"bgp": {
"address_family": {
"ipv6": {
"unicast": {
"neighbor": {
"r2": {
"dest_link": {"r1-link0": {"deactivate": "ipv6"}}
}
}
}
}
}
}
}
}
result = create_router_bgp(tgen, topo1, configure_bgp_on_r1)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
configure_bgp_on_r2 = {
"r2": {
"bgp": {
"address_family": {
"ipv6": {
"unicast": {
"neighbor": {
"r1": {
"dest_link": {"r2-link0": {"deactivate": "ipv6"}}
}
}
}
}
}
}
}
}
result = create_router_bgp(tgen, topo1, configure_bgp_on_r2)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
configure_bgp_on_r1 = {
"r1": {
"bgp": {
"address_family": {
"ipv6": {
"unicast": {
"neighbor": {
"r2": {
"dest_link": {"r1-link0": {"deactivate": "ipv4"}}
}
}
}
}
}
}
}
}
result = create_router_bgp(tgen, topo1, configure_bgp_on_r1)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
configure_bgp_on_r2 = {
"r2": {
"bgp": {
"address_family": {
"ipv6": {
"unicast": {
"neighbor": {
"r1": {
"dest_link": {"r2-link0": {"deactivate": "ipv4"}}
}
}
}
}
}
}
}
}
result = create_router_bgp(tgen, topo1, configure_bgp_on_r2)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
r2_lo_v4 = topo["routers"]["r2"]["links"]["lo"]["ipv4"]
r2_lo_v6 = topo["routers"]["r2"]["links"]["lo"]["ipv6"]
r1_lo_v4 = topo["routers"]["r1"]["links"]["lo"]["ipv4"]
r1_lo_v6 = topo["routers"]["r1"]["links"]["lo"]["ipv6"]
r1_r2_intf = topo["routers"]["r1"]["links"]["r2-link0"]["interface"]
r2_r1_intf = topo["routers"]["r2"]["links"]["r1-link0"]["interface"]
r1_r2_v6_nh = topo["routers"]["r1"]["links"]["r2-link0"]["ipv6"].split("/")[0]
r2_r1_v6_nh = topo["routers"]["r2"]["links"]["r1-link0"]["ipv6"].split("/")[0]
ipv4_list = [("r1", r1_r2_intf, [r2_lo_v4]), ("r2", r2_r1_intf, [r1_lo_v4])]
ipv6_list = [
("r1", r1_r2_intf, [r2_lo_v6], r2_r1_v6_nh),
("r2", r2_r1_intf, [r1_lo_v6], r1_r2_v6_nh),
]
for dut, intf, loop_addr in ipv4_list:
result = addKernelRoute(tgen, dut, intf, loop_addr)
# assert result is True, "Testcase {}:Failed \n Error: {}". \
# format(tc_name, result)
for dut, intf, loop_addr, next_hop in ipv6_list:
result = addKernelRoute(tgen, dut, intf, loop_addr, next_hop)
# assert result is True, "Testcase {}:Failed \n Error: {}". \
# format(tc_name, result)
r2_lo_v4 = topo["routers"]["r2"]["links"]["lo"]["ipv4"]
r2_lo_v6 = topo["routers"]["r2"]["links"]["lo"]["ipv6"]
r1_lo_v4 = topo["routers"]["r1"]["links"]["lo"]["ipv4"]
r1_lo_v6 = topo["routers"]["r1"]["links"]["lo"]["ipv6"]
r1_r2_intf = topo["routers"]["r1"]["links"]["r2-link0"]["interface"]
r2_r1_intf = topo["routers"]["r2"]["links"]["r1-link0"]["interface"]
r1_r2_v6_nh = topo["routers"]["r1"]["links"]["r2-link0"]["ipv6"].split("/")[0]
r2_r1_v6_nh = topo["routers"]["r2"]["links"]["r1-link0"]["ipv6"].split("/")[0]
r1_r2_v4_nh = topo["routers"]["r1"]["links"]["r2-link0"]["ipv4"].split("/")[0]
r2_r1_v4_nh = topo["routers"]["r2"]["links"]["r1-link0"]["ipv4"].split("/")[0]
input_dict = {
"r1": {
"static_routes": [
{"network": r2_lo_v4, "next_hop": r2_r1_v4_nh},
{"network": r2_lo_v6, "next_hop": r2_r1_v6_nh},
]
},
"r2": {
"static_routes": [
{"network": r1_lo_v4, "next_hop": r1_r2_v4_nh},
{"network": r1_lo_v6, "next_hop": r1_r2_v6_nh},
]
},
}
result = create_static_routes(tgen, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
# Api call verify whether BGP is converged
result = verify_bgp_convergence(tgen, topo1)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
step("Enable cap ext nh on r1 and r2 and activate in ipv4 addr family")
configure_bgp_on_r1 = {
"r1": {
"default_ipv4_unicast": False,
"bgp": {
"address_family": {
"ipv6": {
"unicast": {
"neighbor": {
"r2": {
"dest_link": {
"lo": {
"activate": "ipv4",
"capability": "extended-nexthop",
}
}
}
}
}
}
}
},
}
}
result = create_router_bgp(tgen, topo1, configure_bgp_on_r1)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
configure_bgp_on_r2 = {
"r2": {
"default_ipv4_unicast": False,
"bgp": {
"address_family": {
"ipv6": {
"unicast": {
"neighbor": {
"r1": {
"dest_link": {
"lo": {
"activate": "ipv4",
"capability": "extended-nexthop",
}
}
}
}
}
}
}
},
}
}
result = create_router_bgp(tgen, topo1, configure_bgp_on_r2)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
step("Verify bgp convergence.")
bgp_convergence = verify_bgp_convergence(tgen, topo1)
assert bgp_convergence is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, bgp_convergence
)
step("Configure 2 IPv4 static" " routes on R1, Nexthop as different links of R0")
for rte in range(0, NO_OF_RTES):
# Create Static routes
input_dict = {
"r1": {
"static_routes": [
{
"network": NETWORK["ipv4"][rte],
"no_of_ip": 1,
"next_hop": NEXT_HOP["ipv4"][rte],
}
]
}
}
result = create_static_routes(tgen, input_dict)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
step(
"Advertise static routes from IPv4 unicast family and IPv6 "
"unicast family respectively from R1 using red static cmd "
"Advertise loopback from IPv4 unicast family using network command "
"from R1"
)
configure_bgp_on_r1 = {
"r1": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"redistribute": [{"redist_type": "static"}],
"advertise_networks": [
{"network": NETWORK_CMD_IP, "no_of_network": 1}
],
}
}
}
}
}
}
result = create_router_bgp(tgen, topo1, configure_bgp_on_r1)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
step(
"IPv4 routes advertised using static and network command are "
" received on R2 BGP and routing table , "
"verify using show ip bgp, show ip route for IPv4 routes ."
)
gllip = (topo1["routers"]["r1"]["links"]["lo"]["ipv6"].split("/")[0]).lower()
assert gllip is not None, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
dut = "r2"
protocol = "bgp"
verify_nh_for_static_rtes = {
"r1": {
"static_routes": [
{
"network": NETWORK["ipv4"][0],
"no_of_ip": NO_OF_RTES,
"next_hop": gllip,
}
]
}
}
bgp_rib = verify_bgp_rib(
tgen, "ipv4", dut, verify_nh_for_static_rtes, next_hop=gllip
)
assert bgp_rib is True, "Testcase {} : Failed \n Error: {}".format(tc_name, bgp_rib)
result = verify_rib(
tgen, "ipv4", dut, verify_nh_for_static_rtes, next_hop=gllip, protocol=protocol
)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
verify_nh_for_nw_rtes = {
"r1": {
"static_routes": [
{"network": NETWORK_CMD_IP, "no_of_ip": 1, "next_hop": gllip}
]
}
}
bgp_rib = verify_bgp_rib(tgen, "ipv4", dut, verify_nh_for_nw_rtes, next_hop=gllip)
assert bgp_rib is True, "Testcase {} : Failed \n Error: {}".format(tc_name, bgp_rib)
result = verify_rib(
tgen, "ipv4", dut, verify_nh_for_nw_rtes, next_hop=gllip, protocol=protocol
)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
step(
"Remove IPv4 routes advertised using network command"
" from R1 and advertise again"
)
configure_bgp_on_r1 = {
"r1": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"redistribute": [{"redist_type": "static"}],
"advertise_networks": [
{
"network": NETWORK_CMD_IP,
"no_of_network": 1,
"delete": True,
}
],
}
}
}
}
}
}
result = create_router_bgp(tgen, topo1, configure_bgp_on_r1)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
configure_bgp_on_r1 = {
"r1": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"redistribute": [{"redist_type": "static"}],
"advertise_networks": [
{
"network": NETWORK_CMD_IP,
"no_of_network": 1,
}
],
}
}
}
}
}
}
result = create_router_bgp(tgen, topo1, configure_bgp_on_r1)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
step(
"After removing IPv4 routes from network command , routes which are "
"advertised using redistribute static are still present in the on "
"R2 , verify using show ip bgp and show ip route"
)
verify_nh_for_nw_rtes = {
"r1": {
"static_routes": [
{"network": NETWORK_CMD_IP, "no_of_ip": 1, "next_hop": gllip}
]
}
}
bgp_rib = verify_bgp_rib(tgen, "ipv4", dut, verify_nh_for_nw_rtes, next_hop=gllip)
assert bgp_rib is True, "Testcase {} : Failed \n Error: {}".format(tc_name, bgp_rib)
result = verify_rib(
tgen, "ipv4", dut, verify_nh_for_nw_rtes, next_hop=gllip, protocol=protocol
)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
step(
"Remove IPv4 routes advertised using redistribute static"
" command from R1 and advertise again"
)
configure_bgp_on_r1 = {
"r1": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"redistribute": [{"redist_type": "static", "delete": True}]
}
}
}
}
}
}
result = create_router_bgp(tgen, topo1, configure_bgp_on_r1)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
configure_bgp_on_r1 = {
"r1": {
"bgp": {
"address_family": {
"ipv4": {"unicast": {"redistribute": [{"redist_type": "static"}]}}
}
}
}
}
result = create_router_bgp(tgen, topo1, configure_bgp_on_r1)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
step(
"After removing IPv4 routes from redistribute static , routes which"
" are advertised using network are still present in the on R2 , "
"verify using show ip bgp and show ip route"
)
verify_nh_for_nw_rtes = {
"r1": {
"static_routes": [
{"network": NETWORK_CMD_IP, "no_of_ip": 1, "next_hop": gllip}
]
}
}
bgp_rib = verify_bgp_rib(tgen, "ipv4", dut, verify_nh_for_nw_rtes, next_hop=gllip)
assert bgp_rib is True, "Testcase {} : Failed \n Error: {}".format(tc_name, bgp_rib)
result = verify_rib(
tgen, "ipv4", dut, verify_nh_for_nw_rtes, next_hop=gllip, protocol=protocol
)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
write_test_footer(tc_name)