def test_evpn_cli_json_available_p1(request):
"""
EVPN CLI output and JSON format validation.
"""
tgen = get_topogen()
tc_name = request.node.name
write_test_header(tc_name)
check_router_status(tgen)
reset_config_on_routers(tgen)
add_default_routes(tgen)
if tgen.routers_have_failure():
pytest.skip(tgen.errors)
step("Need to verify below CLIs and associated JSON format " "outputs:")
input_dict = {
"e1": {
"cli": [
"show evpn vni detail",
"show bgp l2vpn evpn all overlay",
"show bgp l2vpn evpn vni",
]
}
}
result = verify_cli_json(tgen, input_dict)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
write_test_footer(tc_name)
def test_ospfv3_nssa_tc26_p0(request):
"""Verify that ospf non back bone area can be configured as NSSA area"""
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():
check_router_status(tgen)
global topo
step("Bring up the base config as per the topology")
step("Configure ospf area 2 on r0 , r1 & r4, make the area 2 as NSSA area")
reset_config_on_routers(tgen)
input_dict = {
"r2": {
"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)
step("Redistribute static route in R2 ospf.")
dut = "r2"
red_static(dut)
step("Verify that Type 5 LSA is originated by R2.")
dut = "r0"
protocol = "ospf6"
result = verify_rib(tgen, "ipv6", dut, input_dict, protocol=protocol)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
step("Un configure redistribute command in R4")
dut = "r2"
red_static(dut, config=False)
input_dict = {
"r1": {
"static_routes": [{
"network": NETWORK["ipv6"][0],
"no_of_ip": 1,
"routeType": "Network"
}]
}
}
step("Configure area 0 on interface of r2 connecting to r1")
input_dict = {
"r2": {
"links": {
"r1": {
"interface":
topo["routers"]["r2"]["links"]["r1"]["interface"],
"ospf6": {
"area": "0.0.0.2"
},
"delete": True,
}
}
}
}
result = create_interfaces_cfg(tgen, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result)
input_dict = {
"r2": {
"links": {
"r1": {
"interface":
topo["routers"]["r2"]["links"]["r1"]["interface"],
"ospf6": {
"area": "0.0.0.0"
},
}
}
}
}
result = create_interfaces_cfg(tgen, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result)
step("verify that ospf neighbor goes down between r2 and r1.")
result = verify_ospf6_neighbor(tgen, topo, dut="r2", expected=False)
assert (result is not True
), "Testcase {} : Failed \n Nbrs are not down" "Error: {}".format(
tc_name, result)
step("Now configure area 0 on interface of r1 connecting to r2.")
input_dict = {
"r1": {
"links": {
"r2": {
"interface":
topo["routers"]["r1"]["links"]["r2"]["interface"],
"ospf6": {
"area": "0.0.0.2"
},
"delete": True,
}
}
}
}
result = create_interfaces_cfg(tgen, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result)
input_dict = {
"r1": {
"links": {
"r2": {
"interface":
topo["routers"]["r1"]["links"]["r2"]["interface"],
"ospf6": {
"area": "0.0.0.0"
},
}
}
}
}
result = create_interfaces_cfg(tgen, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result)
step("Verify that ospf neighbour comes up between r2 and r1.")
result = verify_ospf6_neighbor(tgen, topo, dut="r2")
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
step("Configure area 2 on interface of r2 connecting to r1.")
input_dict = {
"r2": {
"links": {
"r1": {
"interface":
topo["routers"]["r2"]["links"]["r1"]["interface"],
"ospf6": {
"area": "0.0.0.0"
},
"delete": True,
}
}
}
}
result = create_interfaces_cfg(tgen, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result)
input_dict = {
"r2": {
"links": {
"r1": {
"interface":
topo["routers"]["r2"]["links"]["r1"]["interface"],
"ospf6": {
"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 ospf neighbor goes down between r2 and r1.")
result = verify_ospf6_neighbor(tgen, topo, dut="r2", expected=False)
assert (result is not True
), "Testcase {} : Failed \n Nbrs are not down" "Error: {}".format(
tc_name, result)
step("Now configure area 2 on interface of r1 connecting to r2.")
input_dict = {
"r1": {
"links": {
"r2": {
"interface":
topo["routers"]["r1"]["links"]["r2"]["interface"],
"ospf6": {
"area": "0.0.0.0"
},
"delete": True,
}
}
}
}
result = create_interfaces_cfg(tgen, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result)
input_dict = {
"r1": {
"links": {
"r2": {
"interface":
topo["routers"]["r1"]["links"]["r2"]["interface"],
"ospf6": {
"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 ospf neighbour comes up between r2 and r1.")
result = verify_ospf6_neighbor(tgen, topo, dut="r2")
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
write_test_footer(tc_name)
def test_BGP_GR_chaos_29_p1(request):
"""
Test Objective : Change timers on the fly, and
verify if it takes immediate effect.
"""
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(
" Test Case : test_BGP_GR_chaos_29"
" BGP GR [Helper Mode]R3-----R1[Restart Mode]"
" and [restart-time 150]R1 initialized"
)
# Configure graceful-restart and timers
input_dict = {
"r1": {
"bgp": {
"graceful-restart": {"timer": {"restart-time": GR_RESTART_TIMER}},
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r3": {"dest_link": {"r1": {"graceful-restart": True}}}
}
}
},
"ipv6": {
"unicast": {
"neighbor": {
"r3": {"dest_link": {"r1": {"graceful-restart": 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
)
# Verify graceful-restart timers
input_dict_2 = {
"r1": {
"bgp": {
"graceful-restart": {"timer": {"restart-time": GR_RESTART_TIMER + 5}}
}
}
}
result = create_router_bgp(tgen, topo, input_dict_2)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
for addr_type in ADDR_TYPES:
input_dict_2 = {
"r1": {
"bgp": {
"graceful-restart": {"timer": {"restart-time": GR_RESTART_TIMER}}
}
}
}
result = verify_graceful_restart_timers(
tgen, topo, addr_type, input_dict_2, dut="r3", peer="r1"
)
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result
)
for addr_type in ADDR_TYPES:
# Verifying BGP RIB routes before shutting down BGPd daemon
dut = "r3"
input_dict = {key: topo["routers"][key] for key in ["r1"]}
result = verify_bgp_rib(tgen, addr_type, dut, input_dict)
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)
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result
)
logger.info("[Step 2] : Kill BGPd daemon on R1..")
# Kill BGPd daemon on R1
kill_router_daemons(tgen, "r1", ["bgpd"])
logger.info("[Step 3] : Wait for {} seconds..".format(GR_RESTART_TIMER))
# Waiting for GR_RESTART_TIMER
sleep(GR_RESTART_TIMER)
for addr_type in ADDR_TYPES:
# Verifying BGP RIB routes before shutting down BGPd daemon
input_dict = {key: topo["routers"][key] for key in ["r1"]}
result = verify_bgp_rib(tgen, addr_type, dut, input_dict, expected=False)
assert result is not True, (
"Testcase {} : Failed \n "
"r3: 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, expected=False)
assert result is not True, (
"Testcase {} : Failed \n "
"r3: routes are still present in ZEBRA\n Error: {}".format(tc_name, result)
)
logger.info(" Expected behavior: {}".format(result))
logger.info("[Step 4] : Start BGPd daemon on R1..")
# Start BGPd daemon on R1
start_router_daemons(tgen, "r1", ["bgpd"])
write_test_footer(tc_name)
def test_BGP_GR_26_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)
logger.info(
"[Step 1] : 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": {
"graceful-restart": True,
"next_hop_self": True,
"activate": "ipv6",
}
}
}
}
}
},
"ipv6": {
"unicast": {
"neighbor": {
"r3": {
"dest_link": {
"r1": {
"graceful-restart": True,
"next_hop_self": 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:
result = verify_graceful_restart(
tgen, topo, addr_type, input_dict, dut="r3", peer="r1"
)
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
)
# 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
)
# 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
)
# 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
)
write_test_footer(tc_name)
def test_RT_verification_auto_p0(request):
"""
RT verification(auto)
"""
tgen = get_topogen()
tc_name = request.node.name
write_test_header(tc_name)
check_router_status(tgen)
reset_config_on_routers(tgen)
add_default_routes(tgen)
if tgen.routers_have_failure():
pytest.skip(tgen.errors)
step(
"Advertise overlapping prefixes from VNFs R1 and R2 in all VRFs "
"RED, GREEN and BLUE 100.1.1.1/32 and 100::100/128"
)
for addr_type in ADDR_TYPES:
input_dict_1 = {
"r1": {
"static_routes": [
{
"network": NETWORK4_1[addr_type],
"next_hop": NEXT_HOP_IP[addr_type],
"vrf": "RED",
}
]
},
"r2": {
"static_routes": [
{
"network": NETWORK4_1[addr_type],
"next_hop": NEXT_HOP_IP[addr_type],
"vrf": "BLUE",
},
{
"network": NETWORK4_1[addr_type],
"next_hop": NEXT_HOP_IP[addr_type],
"vrf": "GREEN",
},
]
},
}
result = create_static_routes(tgen, input_dict_1)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
step(
"Verify that Edge-1 receives same prefixes in all 3 VRFs via "
"corresponding next-hop in associated VRF sh bgp vrf all"
)
for addr_type in ADDR_TYPES:
input_routes = {
"r1": {
"static_routes": [
{
"network": NETWORK4_1[addr_type],
"next_hop": NEXT_HOP_IP[addr_type],
"vrf": "RED",
}
]
},
"r2": {
"static_routes": [
{
"network": NETWORK4_1[addr_type],
"next_hop": NEXT_HOP_IP[addr_type],
"vrf": "BLUE",
},
{
"network": NETWORK4_1[addr_type],
"next_hop": NEXT_HOP_IP[addr_type],
"vrf": "GREEN",
},
]
},
}
result = verify_rib(tgen, addr_type, "e1", input_routes)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
step(
"Configure 4-byte local AS number on Edge-1 and establish EVPN "
"neighborship with DCG-1 & DCG-2."
)
topo_local = deepcopy(topo)
step("Delete BGP config for vrf RED.")
input_dict_vni = {
"e1": {
"vrfs": [
{"name": "RED", "no_vni": VNI_1},
{"name": "BLUE", "no_vni": VNI_2},
{"name": "GREEN", "no_vni": VNI_3},
]
}
}
result = create_vrf_cfg(tgen, topo, input_dict=input_dict_vni)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
input_dict_2 = {}
for dut in ["e1"]:
temp = {dut: {"bgp": []}}
input_dict_2.update(temp)
INDEX = [0, 1, 2, 3]
VRFS = ["RED", "BLUE", "GREEN", None]
AS_NUM = [100, 100, 100, 100]
for index, vrf, as_num in zip(INDEX, VRFS, AS_NUM):
topo_local["routers"][dut]["bgp"][index]["local_as"] = 4294967293
if vrf:
temp[dut]["bgp"].append(
{"local_as": as_num, "vrf": vrf, "delete": True}
)
else:
temp[dut]["bgp"].append({"local_as": as_num, "delete": True})
result = create_router_bgp(tgen, topo, input_dict_2)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
result = create_router_bgp(tgen, topo_local["routers"])
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
input_dict_vni = {
"e1": {
"vrfs": [
{"name": "RED", "vni": VNI_1},
{"name": "BLUE", "vni": VNI_2},
{"name": "GREEN", "vni": VNI_3},
]
}
}
result = create_vrf_cfg(tgen, topo, input_dict=input_dict_vni)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
step(
"Verify that all overlapping prefixes across different VRFs are "
"advertised in EVPN with unique RD value(auto derived)."
)
step(
"Verify that FRR uses only the lower 2 bytes of ASN+VNI for auto "
"derived RT value."
)
for addr_type in ADDR_TYPES:
input_routes_1 = {
"r1": {"static_routes": [{"network": NETWORK4_1[addr_type], "vrf": "RED"}]}
}
input_routes_2 = {
"r2": {"static_routes": [{"network": NETWORK4_1[addr_type], "vrf": "BLUE"}]}
}
input_routes_3 = {
"r2": {
"static_routes": [{"network": NETWORK4_1[addr_type], "vrf": "GREEN"}]
}
}
result = verify_attributes_for_evpn_routes(
tgen, topo, "e1", input_routes_1, rd="auto", rd_peer="e1"
)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result
)
result = verify_attributes_for_evpn_routes(
tgen, topo, "e1", input_routes_1, rt="auto", rt_peer="e1"
)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result
)
result = verify_attributes_for_evpn_routes(
tgen, topo, "e1", input_routes_2, rd="auto", rd_peer="e1"
)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result
)
result = verify_attributes_for_evpn_routes(
tgen, topo, "e1", input_routes_2, rt="auto", rt_peer="e1"
)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result
)
result = verify_attributes_for_evpn_routes(
tgen, topo, "e1", input_routes_3, rd="auto", rd_peer="e1"
)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result
)
result = verify_attributes_for_evpn_routes(
tgen, topo, "e1", input_routes_3, rt="auto", rt_peer="e1"
)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result
)
step(
"Verify that DCG-1(iBGP peer) automatically imports the prefixes"
" from EVPN address-family to respective VRFs."
)
step(
"Verify if DCG-2(eBGP peer) automatically imports the prefixes "
"from EVPN address-family to respective VRFs or not."
)
for addr_type in ADDR_TYPES:
input_routes = {
"r1": {
"static_routes": [
{
"network": NETWORK4_1[addr_type],
"next_hop": NEXT_HOP_IP[addr_type],
"vrf": "RED",
}
]
},
"r2": {
"static_routes": [
{
"network": NETWORK4_1[addr_type],
"next_hop": NEXT_HOP_IP[addr_type],
"vrf": "BLUE",
},
{
"network": NETWORK4_1[addr_type],
"next_hop": NEXT_HOP_IP[addr_type],
"vrf": "GREEN",
},
]
},
}
result = verify_rib(tgen, addr_type, "d1", input_routes)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
result = verify_rib(tgen, addr_type, "d2", input_routes)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
step(
"Change the VNI number for all 3 VRFs on Edge-1 as:"
"RED : 75400, GREEN: 75500, BLUE: 75600"
)
input_dict_vni = {
"e1": {
"vrfs": [
{"name": "RED", "no_vni": VNI_1},
{"name": "BLUE", "no_vni": VNI_2},
{"name": "GREEN", "no_vni": VNI_3},
]
}
}
result = create_vrf_cfg(tgen, topo, input_dict=input_dict_vni)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
input_dict_vni = {
"e1": {
"vrfs": [
{"name": "RED", "vni": 75400},
{"name": "BLUE", "vni": 75500},
{"name": "GREEN", "vni": 75600},
]
}
}
result = create_vrf_cfg(tgen, topo, input_dict=input_dict_vni)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
step("Delete configured vxlan")
dut = "e1"
vxlan_input = {
dut: {
"vxlan": [
{
"vxlan_name": VXLAN["vxlan_name"],
"vxlan_id": VXLAN["vxlan_id"],
"dstport": VXLAN["dstport"],
"local_addr": VXLAN["local_addr"][dut],
"learning": VXLAN["learning"],
"delete": True,
}
]
}
}
result = configure_vxlan(tgen, vxlan_input)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
step("Configured vxlan")
VXLAN["vxlan_id"] = [75400, 75500, 75600]
vxlan_input = {
dut: {
"vxlan": [
{
"vxlan_name": VXLAN["vxlan_name"],
"vxlan_id": VXLAN["vxlan_id"],
"dstport": VXLAN["dstport"],
"local_addr": VXLAN["local_addr"][dut],
"learning": VXLAN["learning"],
}
]
}
}
result = configure_vxlan(tgen, vxlan_input)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
step("Configure bridge interface")
brctl_input = {
dut: {
"brctl": [
{
"brctl_name": BRCTL["brctl_name"],
"addvxlan": BRCTL["addvxlan"],
"vrf": BRCTL["vrf"],
"stp": BRCTL["stp"],
}
]
}
}
result = configure_brctl(tgen, topo, brctl_input)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
step(
"Verify on Edge-1 that auto derived RT value has changed for "
"each VRF based on VNI number.."
)
input_dict = {
"e1": {
"vrfs": [
{"RED": {"vni": 75400}},
{"BLUE": {"vni": 75500}},
{"GREEN": {"vni": 75600}},
]
}
}
result = verify_vrf_vni(tgen, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
step(
"Verify on Edge-1 that auto derived RT value has changed for "
"each VRF based on VNI number."
)
for addr_type in ADDR_TYPES:
input_routes = {
"r1": {"static_routes": [{"network": NETWORK4_1[addr_type], "vrf": "RED"}]}
}
result = verify_attributes_for_evpn_routes(
tgen, topo, "e1", input_routes, rt="auto", rt_peer="e1"
)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result
)
step(
"Verify on DCG-2 that prefixes are not imported from EVPN "
"address-family to VRFs as RT values are different on sending("
"edge-1) and receiving(DCG-2) end."
)
for addr_type in ADDR_TYPES:
input_routes = {
"r1": {"static_routes": [{"network": NETWORK4_1[addr_type], "vrf": "RED"}]}
}
result = verify_rib(tgen, addr_type, "d2", input_routes, expected=False)
assert result is not True, "Testcase {} :Failed \n "
"Routes are still present: {}".format(tc_name, result)
logger.info("Expected Behavior: {}".format(result))
step(
"Revert back to original VNI number for all 3 VRFs on Edge-1 "
"as: RED : 75100, GREEN: 75200, BLUE: 75300"
)
input_dict_vni = {
"e1": {
"vrfs": [
{"name": "RED", "no_vni": 75400},
{"name": "BLUE", "no_vni": 75500},
{"name": "GREEN", "no_vni": 75600},
]
}
}
result = create_vrf_cfg(tgen, topo, input_dict=input_dict_vni)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
input_dict_vni = {
"e1": {
"vrfs": [
{"name": "RED", "vni": VNI_1},
{"name": "BLUE", "vni": VNI_2},
{"name": "GREEN", "vni": VNI_3},
]
}
}
result = create_vrf_cfg(tgen, topo, input_dict=input_dict_vni)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
step("Delete configured vxlan")
dut = "e1"
vxlan_input = {
dut: {
"vxlan": [
{
"vxlan_name": VXLAN["vxlan_name"],
"vxlan_id": VXLAN["vxlan_id"],
"dstport": VXLAN["dstport"],
"local_addr": VXLAN["local_addr"][dut],
"learning": VXLAN["learning"],
"delete": True,
}
]
}
}
result = configure_vxlan(tgen, vxlan_input)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
step("Configured vxlan")
VXLAN["vxlan_id"] = [75100, 75200, 75300]
vxlan_input = {
dut: {
"vxlan": [
{
"vxlan_name": VXLAN["vxlan_name"],
"vxlan_id": VXLAN["vxlan_id"],
"dstport": VXLAN["dstport"],
"local_addr": VXLAN["local_addr"][dut],
"learning": VXLAN["learning"],
}
]
}
}
result = configure_vxlan(tgen, vxlan_input)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
step("Configure bridge interface")
brctl_input = {
dut: {
"brctl": [
{
"brctl_name": BRCTL["brctl_name"],
"addvxlan": BRCTL["addvxlan"],
"vrf": BRCTL["vrf"],
"stp": BRCTL["stp"],
}
]
}
}
result = configure_brctl(tgen, topo, brctl_input)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
step(
"Verify on Edge-1 that auto derived RT value has changed for "
"each VRF based on VNI number."
)
step(
"Verify that DCG-1(iBGP peer) automatically imports the prefixes"
" from EVPN address-family to respective VRFs."
)
for addr_type in ADDR_TYPES:
input_routes = {
"r1": {"static_routes": [{"network": NETWORK4_1[addr_type], "vrf": "RED"}]}
}
result = verify_attributes_for_evpn_routes(
tgen, topo, "e1", input_routes, rt="auto", rt_peer="e1"
)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result
)
result = verify_rib(tgen, addr_type, "d1", input_routes)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result
)
step("Test with smaller VNI numbers (1-75000)")
input_dict_vni = {"e1": {"vrfs": [{"name": "RED", "no_vni": VNI_1}]}}
result = create_vrf_cfg(tgen, topo, input_dict=input_dict_vni)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
input_dict_vni = {"e1": {"vrfs": [{"name": "RED", "vni": 111}]}}
result = create_vrf_cfg(tgen, topo, input_dict=input_dict_vni)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
step(
"Verify that DCG-2 receives EVPN prefixes along with auto "
"derived RT values(based on smaller VNI numbers)"
)
for addr_type in ADDR_TYPES:
input_routes_1 = {
"r1": {"static_routes": [{"network": NETWORK4_1[addr_type], "vrf": "RED"}]}
}
result = verify_attributes_for_evpn_routes(
tgen, topo, "d2", input_routes_1, rt="auto", rt_peer="e1", expected=False
)
assert result is not True, "Testcase {} :Failed \n "
"Malfaromed Auto-RT value accepted: {}".format(tc_name, result)
logger.info("Expected Behavior: {}".format(result))
step("Configure VNI number more than boundary limit (16777215)")
input_dict_vni = {"e1": {"vrfs": [{"name": "RED", "no_vni": 111}]}}
result = create_vrf_cfg(tgen, topo, input_dict=input_dict_vni)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
input_dict_vni = {"e1": {"vrfs": [{"name": "RED", "vni": 16777215}]}}
result = create_vrf_cfg(tgen, topo, input_dict=input_dict_vni)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
step("CLI error for malformed VNI.")
input_dict = {
"e1": {
"vrfs": [{"RED": {"vni": 16777215, "routerMac": "None", "state": "Down"}}]
}
}
result = verify_vrf_vni(tgen, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
for addr_type in ADDR_TYPES:
input_routes_1 = {
"r1": {"static_routes": [{"network": NETWORK4_1[addr_type], "vrf": "RED"}]}
}
result = verify_attributes_for_evpn_routes(
tgen, topo, "d2", input_routes_1, rt="auto", rt_peer="e1", expected=False
)
assert result is not True, "Testcase {} :Failed \n "
"Malfaromed Auto-RT value accepted: {}".format(tc_name, result)
logger.info("Expected Behavior: {}".format(result))
step("Un-configure VNI number more than boundary limit (16777215)")
input_dict_vni = {"e1": {"vrfs": [{"name": "RED", "no_vni": 16777215}]}}
result = create_vrf_cfg(tgen, topo, input_dict=input_dict_vni)
assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
write_test_footer(tc_name)
def test_verify_overlay_index_p1(request):
"""
In absence of an overlay index all IP-Prefixes(RT-5)
are advertised with default values for below parameters:
--> Ethernet Tag ID = GW IP address = ESI=0
"""
tgen = get_topogen()
tc_name = request.node.name
write_test_header(tc_name)
check_router_status(tgen)
reset_config_on_routers(tgen)
add_default_routes(tgen)
if tgen.routers_have_failure():
pytest.skip(tgen.errors)
step("Following steps are taken care in base config:")
step(
"Configure BGP neighborship for both address families"
"(IPv4 & IPv6) between Edge-1 and VFN routers(R1 and R2)"
)
step(
"Advertise prefixes from VNF routers R1 and R2 in associated "
"VRFs for both address-family."
)
step("Advertise VRF routes as in EVPN address family from Edge-1 " "router.")
for addr_type in ADDR_TYPES:
input_dict_1 = {
"r1": {
"static_routes": [
{
"network": NETWORK1_1[addr_type],
"next_hop": NEXT_HOP_IP[addr_type],
"vrf": "RED",
}
]
},
"r2": {
"static_routes": [
{
"network": NETWORK2_1[addr_type],
"next_hop": NEXT_HOP_IP[addr_type],
"vrf": "BLUE",
},
{
"network": NETWORK3_1[addr_type],
"next_hop": NEXT_HOP_IP[addr_type],
"vrf": "GREEN",
},
]
},
}
result = create_static_routes(tgen, input_dict_1)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
step("Verify: Prefixes are received in all VRFs on Edge-1 router.")
for addr_type in ADDR_TYPES:
input_routes = {key: topo["routers"][key] for key in ["r1"]}
result = verify_rib(tgen, addr_type, "e1", input_routes)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result
)
for addr_type in ADDR_TYPES:
input_routes = {key: topo["routers"][key] for key in ["r2"]}
result = verify_rib(tgen, addr_type, "e1", input_routes)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result
)
step(
"Verify that EVPN routes, received on DCG-1 and DCG-2 do not "
"carry any overlay index and these indexes are set to default "
"value=0. "
)
for addr_type in ADDR_TYPES:
input_routes = {key: topo["routers"][key] for key in ["r1"]}
result = verify_attributes_for_evpn_routes(
tgen, topo, "d1", input_routes, ethTag=0
)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result
)
result = verify_attributes_for_evpn_routes(
tgen, topo, "d2", input_routes, ethTag=0
)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result
)
write_test_footer(tc_name)
def test_bgp_best_path_with_dynamic_import_p0(request):
"""
TC6_FUNC_6:
1.5.6. Verify BGP best path selection algorithm works fine when
routes are imported from ISR to default vrf and vice versa.
"""
tgen = get_topogen()
tc_name = request.node.name
write_test_header(tc_name)
build_config_from_json(tgen, topo)
if tgen.routers_have_failure():
check_router_status(tgen)
for addr_type in ADDR_TYPES:
step("Redistribute configured static routes into BGP process"
" on R1/R2 and R3")
input_dict_1 = {}
DUT = ["r1", "r2", "r3", "r4"]
VRFS = ["ISR", "ISR", "default", "default"]
AS_NUM = [100, 100, 300, 400]
for dut, vrf, as_num in zip(DUT, VRFS, AS_NUM):
temp = {dut: {"bgp": []}}
input_dict_1.update(temp)
temp[dut]["bgp"].append({
"local_as": as_num,
"vrf": vrf,
"address_family": {
addr_type: {
"unicast": {
"redistribute": [{
"redist_type": "static"
}]
}
}
},
})
result = create_router_bgp(tgen, topo, input_dict_1)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result)
for addr_type in ADDR_TYPES:
step("Import from default vrf into vrf ISR on R1 and R2 as below")
input_dict_vrf = {}
DUT = ["r1", "r2"]
VRFS = ["ISR", "ISR"]
AS_NUM = [100, 100]
for dut, vrf, as_num in zip(DUT, VRFS, AS_NUM):
temp = {dut: {"bgp": []}}
input_dict_vrf.update(temp)
temp[dut]["bgp"].append({
"local_as": as_num,
"vrf": vrf,
"address_family": {
addr_type: {
"unicast": {
"import": {
"vrf": "default"
}
}
}
},
})
result = create_router_bgp(tgen, topo, input_dict_vrf)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
input_dict_default = {}
DUT = ["r1", "r2"]
VRFS = ["default", "default"]
AS_NUM = [100, 100]
for dut, vrf, as_num in zip(DUT, VRFS, AS_NUM):
temp = {dut: {"bgp": []}}
input_dict_default.update(temp)
temp[dut]["bgp"].append({
"local_as": as_num,
"vrf": vrf,
"address_family": {
addr_type: {
"unicast": {
"import": {
"vrf": "ISR"
}
}
}
},
})
result = create_router_bgp(tgen, topo, input_dict_default)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
step("Verify ECMP/Next-hop/Imported routes Vs Locally originated "
"routes/eBGP routes vs iBGP routes --already covered in almost"
" all tests")
for addr_type in ADDR_TYPES:
step("Verify Pre-emption")
input_routes_r3 = {
"r3": {
"static_routes": [{
"network": [NETWORK3_3[addr_type]]
}]
}
}
intf_r3_r1 = topo["routers"]["r3"]["links"]["r1-link1"]["interface"]
intf_r4_r1 = topo["routers"]["r4"]["links"]["r1-link1"]["interface"]
if addr_type == "ipv6" and "link_local" in PREFERRED_NEXT_HOP:
nh_r3_r1 = get_frr_ipv6_linklocal(tgen, "r3", intf=intf_r3_r1)
nh_r4_r1 = get_frr_ipv6_linklocal(tgen, "r4", intf=intf_r4_r1)
else:
nh_r3_r1 = topo["routers"]["r3"]["links"]["r1-link1"][
addr_type].split("/")[0]
nh_r4_r1 = topo["routers"]["r4"]["links"]["r1-link1"][
addr_type].split("/")[0]
result = verify_bgp_rib(tgen,
addr_type,
"r1",
input_routes_r3,
next_hop=[nh_r4_r1])
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result)
step("Shutdown interface connected to r1 from r4:")
shutdown_bringup_interface(tgen, "r4", intf_r4_r1, False)
for addr_type in ADDR_TYPES:
input_routes_r3 = {
"r3": {
"static_routes": [{
"network": [NETWORK3_3[addr_type]]
}]
}
}
intf_r3_r1 = topo["routers"]["r3"]["links"]["r1-link1"]["interface"]
intf_r4_r1 = topo["routers"]["r4"]["links"]["r1-link1"]["interface"]
if addr_type == "ipv6" and "link_local" in PREFERRED_NEXT_HOP:
nh_r3_r1 = get_frr_ipv6_linklocal(tgen, "r3", intf=intf_r3_r1)
nh_r4_r1 = get_frr_ipv6_linklocal(tgen, "r4", intf=intf_r4_r1)
else:
nh_r3_r1 = topo["routers"]["r3"]["links"]["r1-link1"][
addr_type].split("/")[0]
nh_r4_r1 = topo["routers"]["r4"]["links"]["r1-link1"][
addr_type].split("/")[0]
step("Verify next-hop is changed")
result = verify_bgp_rib(tgen,
addr_type,
"r1",
input_routes_r3,
next_hop=[nh_r3_r1])
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result)
step("Bringup interface connected to r1 from r4:")
shutdown_bringup_interface(tgen, "r4", intf_r4_r1, True)
for addr_type in ADDR_TYPES:
input_routes_r3 = {
"r3": {
"static_routes": [{
"network": [NETWORK3_3[addr_type]]
}]
}
}
intf_r3_r1 = topo["routers"]["r3"]["links"]["r1-link1"]["interface"]
intf_r4_r1 = topo["routers"]["r4"]["links"]["r1-link1"]["interface"]
if addr_type == "ipv6" and "link_local" in PREFERRED_NEXT_HOP:
nh_r3_r1 = get_frr_ipv6_linklocal(tgen, "r3", intf=intf_r3_r1)
nh_r4_r1 = get_frr_ipv6_linklocal(tgen, "r4", intf=intf_r4_r1)
else:
nh_r3_r1 = topo["routers"]["r3"]["links"]["r1-link1"][
addr_type].split("/")[0]
nh_r4_r1 = topo["routers"]["r4"]["links"]["r1-link1"][
addr_type].split("/")[0]
step("Verify next-hop is not chnaged aftr shutdown:")
result = verify_bgp_rib(tgen,
addr_type,
"r1",
input_routes_r3,
next_hop=[nh_r3_r1])
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result)
step("Active-Standby scenario(as-path prepend and Local pref)")
for addr_type in ADDR_TYPES:
step("Create prefix-list")
input_dict_pf = {
"r1": {
"prefix_lists": {
addr_type: {
"pf_ls_{}".format(addr_type): [{
"seqid":
10,
"network":
NETWORK3_4[addr_type],
"action":
"permit",
}]
}
}
}
}
result = create_prefix_lists(tgen, input_dict_pf)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
for addr_type in ADDR_TYPES:
step("Create route-map to match prefix-list and set localpref 500")
input_dict_rm = {
"r1": {
"route_maps": {
"rmap_PATH1_{}".format(addr_type): [{
"action": "permit",
"seq_id": 10,
"match": {
addr_type: {
"prefix_lists": "pf_ls_{}".format(addr_type)
}
},
"set": {
"locPrf": 500
},
}]
}
}
}
result = create_route_maps(tgen, input_dict_rm)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
step("Create route-map to match prefix-list and set localpref 600")
input_dict_rm = {
"r1": {
"route_maps": {
"rmap_PATH2_{}".format(addr_type): [{
"action": "permit",
"seq_id": 20,
"match": {
addr_type: {
"prefix_lists": "pf_ls_{}".format(addr_type)
}
},
"set": {
"locPrf": 600
},
}]
}
}
}
result = create_route_maps(tgen, input_dict_rm)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
input_dict_rma = {
"r1": {
"bgp": [{
"local_as": "100",
"address_family": {
addr_type: {
"unicast": {
"neighbor": {
"r3": {
"dest_link": {
"r1-link1": {
"route_maps": [{
"name":
"rmap_PATH1_{}".format(
addr_type),
"direction":
"in",
}]
}
}
},
"r4": {
"dest_link": {
"r1-link1": {
"route_maps": [{
"name":
"rmap_PATH2_{}".format(
addr_type),
"direction":
"in",
}]
}
}
},
}
}
}
},
}]
}
}
result = create_router_bgp(tgen, topo, input_dict_rma)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
dut = "r1"
attribute = "locPrf"
for addr_type in ADDR_TYPES:
step("Verify bestpath is installed as per highest localpref")
input_routes_r3 = {
"r3": {
"static_routes": [{
"network": [NETWORK3_3[addr_type], NETWORK3_4[addr_type]]
}]
}
}
result = verify_best_path_as_per_bgp_attribute(tgen, addr_type, dut,
input_routes_r3,
attribute)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
for addr_type in ADDR_TYPES:
step("Create route-map to match prefix-list and set localpref 700")
input_dict_rm = {
"r1": {
"route_maps": {
"rmap_PATH1_{}".format(addr_type): [{
"action": "permit",
"seq_id": 10,
"match": {
addr_type: {
"prefix_lists": "pf_ls_{}".format(addr_type)
}
},
"set": {
"locPrf": 700
},
}]
}
}
}
result = create_route_maps(tgen, input_dict_rm)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
for addr_type in ADDR_TYPES:
step("Verify bestpath is changed as per highest localpref")
input_routes_r3 = {
"r3": {
"static_routes": [{
"network": [NETWORK3_3[addr_type], NETWORK3_4[addr_type]]
}]
}
}
result = verify_best_path_as_per_bgp_attribute(tgen, addr_type, dut,
input_routes_r3,
attribute)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
for addr_type in ADDR_TYPES:
step("Create route-map to match prefix-list and set as-path prepend")
input_dict_rm = {
"r1": {
"route_maps": {
"rmap_PATH2_{}".format(addr_type): [{
"action": "permit",
"seq_id": 20,
"match": {
addr_type: {
"prefix_lists": "pf_ls_{}".format(addr_type)
}
},
"set": {
"localpref": 700,
"path": {
"as_num": "111",
"as_action": "prepend"
},
},
}]
}
}
}
result = create_route_maps(tgen, input_dict_rm)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
attribute = "path"
for addr_type in ADDR_TYPES:
step("Verify bestpath is changed as per shortest as-path")
input_routes_r3 = {
"r3": {
"static_routes": [{
"network": [NETWORK3_3[addr_type], NETWORK3_4[addr_type]]
}]
}
}
result = verify_best_path_as_per_bgp_attribute(tgen, addr_type, dut,
input_routes_r3,
attribute)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
write_test_footer(tc_name)
def test_pimv6_add_delete_static_RP_p0(request):
"""
TC_1: Verify upstream interfaces(IIF) and join state are updated
properly after adding and deleting the static RP
TC_2: Verify IIF and OIL in "show ip pim state" updated properly
after adding and deleting the static RP
TC_3: (*, G) Mroute entry are cleared when static RP gets deleted
TC_4: Verify (*,G) prune is send towards the RP after deleting the
static RP
TOPOlogy used:
r0------r1-----r2
iperf DUT RP
"""
tgen = get_topogen()
tc_name = request.node.name
write_test_header(tc_name)
# Don"t run this test if we have any failure.
if tgen.routers_have_failure():
check_router_status(tgen)
step("Shut link b/w R1 and R3 and R1 and R4 as per tescase topology")
intf_r1_r3 = TOPO["routers"]["r1"]["links"]["r3"]["interface"]
intf_r1_r4 = TOPO["routers"]["r1"]["links"]["r4"]["interface"]
for intf in [intf_r1_r3, intf_r1_r4]:
shutdown_bringup_interface(tgen, "r1", intf, ifaceaction=False)
step("Enable PIM between r1 and r2")
step("Enable MLD on r1 interface and send IGMP " "join (FF08::1) to r1")
step("Configure r2 loopback interface as RP")
input_dict = {
"r2": {
"pim6": {
"rp": [{
"rp_addr":
TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split("/")[0],
"group_addr_range":
GROUP_RANGE_V6,
}]
}
}
}
result = create_pim_config(tgen, TOPO, input_dict)
assert result is True, "Testcase {} : Failed Error: {}".format(
tc_name, result)
step("Verify show ip pim interface traffic without any mld join")
state_dict = {
"r1": {
TOPO["routers"]["r1"]["links"]["r2"]["interface"]: ["pruneTx"]
}
}
state_before = verify_pim_interface_traffic(tgen,
state_dict,
addr_type="ipv6")
assert isinstance(
state_before, dict
), "Testcase{} : Failed \n state_before is not dictionary \n " "Error: {}".format(
tc_name, result)
step("send mld join (FF08::1) to R1")
intf = TOPO["routers"]["r0"]["links"]["r1"]["interface"]
intf_ip = TOPO["routers"]["r0"]["links"]["r1"]["ipv6"].split("/")[0]
result = socat_send_igmp_join_traffic(tgen,
"r0",
"UDP6-RECV",
IGMP_JOIN_V6,
intf,
intf_ip,
join=True)
assert result is True, "Testcase {}: Failed Error: {}".format(
tc_name, result)
step("r1: Verify RP info")
dut = "r1"
oif = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
iif = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
rp_address = TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split("/")[0]
result = verify_pim_rp_info(tgen, TOPO, dut, GROUP_RANGE_V6, oif,
rp_address, SOURCE)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result)
step("r1: Verify upstream IIF interface")
result = verify_upstream_iif(tgen, dut, oif, STAR, IGMP_JOIN_V6)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result)
step("r1: Verify upstream join state and join timer")
result = verify_join_state_and_timer(tgen, dut, oif, STAR, IGMP_JOIN_V6)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result)
step("r1: Verify PIM state")
result = verify_pim_state(tgen, dut, oif, iif, IGMP_JOIN_V6)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result)
step("r1: Verify ip mroutes")
result = verify_mroutes(tgen, dut, STAR, IGMP_JOIN_V6, oif, iif)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result)
step("r1: Delete RP configuration")
input_dict = {
"r2": {
"pim6": {
"rp": [{
"rp_addr":
TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split("/")[0],
"group_addr_range":
GROUP_RANGE_V6,
"delete":
True,
}]
}
}
}
result = create_pim_config(tgen, TOPO, input_dict)
assert result is True, "Testcase {} : Failed Error: {}".format(
tc_name, result)
step("r1: Verify RP info")
result = verify_pim_rp_info(tgen,
TOPO,
dut,
GROUP_RANGE_V6,
oif,
rp_address,
SOURCE,
expected=False)
assert (
result is not True
), "Testcase {} :Failed \n " "RP: {} info is still present \n Error: {}".format(
tc_name, rp_address, result)
step("r1: Verify upstream IIF interface")
result = verify_upstream_iif(tgen,
dut,
oif,
STAR,
IGMP_JOIN_V6,
expected=False)
assert result is not True, (
"Testcase {} :Failed \n "
"Upstream ({}, {}) is still in join state \n Error: {}".format(
tc_name, STAR, IGMP_JOIN_V6, result))
step("r1: Verify upstream join state and join timer")
result = verify_join_state_and_timer(tgen,
dut,
oif,
STAR,
IGMP_JOIN_V6,
expected=False)
assert result is not True, (
"Testcase {} :Failed \n "
"Upstream ({}, {}) timer is still running \n Error: {}".format(
tc_name, STAR, IGMP_JOIN_V6, result))
step("r1: Verify PIM state")
result = verify_pim_state(tgen,
dut,
oif,
iif,
IGMP_JOIN_V6,
expected=False)
assert result is not True, (
"Testcase {} :Failed \n "
"PIM state for group: {} is still Active \n Error: {}".format(
tc_name, IGMP_JOIN_V6, result))
step("r1: Verify ip mroutes")
result = verify_mroutes(tgen,
dut,
STAR,
IGMP_JOIN_V6,
oif,
iif,
expected=False)
assert result is not True, (
"Testcase {} :Failed \n "
"mroute ({}, {}) is still present \n Error: {}".format(
tc_name, STAR, IGMP_JOIN_V6, result))
step("r1: Verify show ip pim interface traffic without any IGMP join")
state_after = verify_pim_interface_traffic(tgen,
state_dict,
addr_type="ipv6")
assert isinstance(
state_after, dict
), "Testcase{} : Failed \n state_before is not dictionary \n " "Error: {}".format(
tc_name, result)
result = verify_state_incremented(state_before, state_after)
assert result is True, "Testcase{} : Failed Error: {}".format(
tc_name, result)
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 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_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_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_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_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 ospfv3_nssa_tc27_p0(request):
"""
OSPF NSSA.
Verify that ospf NSSA area DUT is capable receiving & processing
Type7 N2 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():
check_router_status(tgen)
global topo
step("Bring up the base config as per the topology")
step("Configure ospf area 2 on r0 , r1 & r4, make the area 2 as NSSA area")
reset_config_on_routers(tgen)
input_dict = {
"r2": {
"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)
step("Redistribute static route in R2 ospf.")
dut = "r2"
red_static(dut)
step("Verify that Type 5 LSA is originated by R2.")
dut = "r0"
protocol = "ospf6"
result = verify_rib(tgen, "ipv6", dut, input_dict, protocol=protocol)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
step("Un configure redistribute command in R4")
dut = "r2"
red_static(dut, config=False)
input_dict = {
"r1": {
"static_routes": [{
"network": NETWORK["ipv6"][0],
"no_of_ip": 1,
"routeType": "Network"
}]
}
}
dut = "r0"
result = verify_ospf6_rib(tgen, dut, input_dict, expected=False)
assert result is not True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
result = verify_rib(tgen,
"ipv6",
dut,
input_dict,
protocol=protocol,
expected=False)
assert result is not True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
write_test_footer(tc_name)
def test_dynamic_import_ecmp_imported_routed_diffrent_vrfs_p0(request):
"""
Verify ECMP for imported routes from different VRFs.
"""
tgen = get_topogen()
tc_name = request.node.name
write_test_header(tc_name)
if tgen.routers_have_failure():
check_router_status(tgen)
reset_config_on_routers(tgen)
step("Configure same static routes in tenant vrfs RED and GREEN on router "
"R3 and redistribute in respective BGP process")
for vrf_name in ["RED", "GREEN"]:
for addr_type in ADDR_TYPES:
if vrf_name == "GREEN":
next_hop_vrf = topo["routers"]["r1"]["links"]["r3-link3"][
addr_type].split("/")[0]
else:
next_hop_vrf = topo["routers"]["r2"]["links"]["r3-link1"][
addr_type].split("/")[0]
static_routes = {
"r3": {
"static_routes": [{
"network": [NETWORK1_1[addr_type]],
"next_hop": next_hop_vrf,
"vrf": vrf_name
}]
}
}
result = create_static_routes(tgen, static_routes)
assert result is True, "Testcase {} :Failed \n Error: {}". \
format(tc_name, result)
step("Redistribute static route on BGP VRF : {}".format(vrf_name))
temp = {}
for addr_type in ADDR_TYPES:
temp.update({
addr_type: {
"unicast": {
"redistribute": [{
"redist_type": "static"
}]
}
}
})
redist_dict = {
"r3": {
"bgp": [{
"vrf": vrf_name,
"local_as": 3,
"address_family": temp
}]
}
}
result = create_router_bgp(tgen, topo, redist_dict)
assert result is True, "Testcase {} :Failed \n Error: {}". \
format(tc_name, result)
step("Verify that configured static routes are installed in respective "
"BGP table for vrf RED & GREEN")
for vrf_name in ["RED", "GREEN"]:
for addr_type in ADDR_TYPES:
if vrf_name == "GREEN":
next_hop_vrf = topo["routers"]["r1"]["links"]["r3-link3"][
addr_type].split("/")[0]
else:
next_hop_vrf = topo["routers"]["r2"]["links"]["r3-link1"][
addr_type].split("/")[0]
static_routes = {
"r3": {
"static_routes": [{
"network": [NETWORK1_1[addr_type]],
"vrf": vrf_name
}]
}
}
result = verify_bgp_rib(tgen,
addr_type,
"r3",
static_routes,
next_hop=next_hop_vrf)
assert result is True, "Testcase {} : Failed \n Error {}". \
format(tc_name, result)
result = verify_rib(tgen,
addr_type,
"r3",
static_routes,
next_hop=next_hop_vrf)
assert result is True, "Testcase {} : Failed \n Error {}". \
format(tc_name, result)
step("Import vrf RED and GREEN into default vrf and Configure ECMP")
bgp_val = []
for vrf_name in ["RED", "GREEN"]:
temp = {}
for addr_type in ADDR_TYPES:
temp.update({
addr_type: {
"unicast": {
"import": {
"vrf": vrf_name
},
"maximum_paths": {
"ebgp": 2
}
}
}
})
bgp_val.append({"local_as": 3, "address_family": temp})
import_dict = {"r3": {"bgp": bgp_val}}
result = create_router_bgp(tgen, topo, import_dict)
assert result is True, "Testcase {} :Failed \n Error: {}". \
format(tc_name, result)
step("Configure bgp bestpath on router r3")
r3_raw_config = {
"r3": {
"raw_config":
["router bgp 3", "bgp bestpath as-path multipath-relax"]
}
}
result = apply_raw_config(tgen, r3_raw_config)
assert result is True, "Testcase {} :Failed \n Error: {}". \
format(tc_name, result)
step("Verify that routes are imported with two different next-hop vrfs "
"and IPs. Additionally R3 must do ECMP for both the routes.")
for addr_type in ADDR_TYPES:
next_hop_vrf = [
topo["routers"]["r2"]["links"]["r3-link1"][addr_type]. \
split("/")[0],
topo["routers"]["r1"]["links"]["r3-link3"][addr_type]. \
split("/")[0]
]
static_routes = {
"r3": {
"static_routes": [{
"network": [NETWORK1_1[addr_type]],
}]
}
}
result = verify_bgp_rib(tgen,
addr_type,
"r3",
static_routes,
next_hop=next_hop_vrf)
assert result is True, "Testcase {} : Failed \n Error {}". \
format(tc_name, result)
result = verify_rib(tgen,
addr_type,
"r3",
static_routes,
next_hop=next_hop_vrf)
assert result is True, "Testcase {} : Failed \n Error {}". \
format(tc_name, result)
step("Now change the next-hop of static routes in vrf RED and GREEN to "
"same IP address")
for addr_type in ADDR_TYPES:
next_hop_vrf = topo["routers"]["r1"]["links"]["r3-link3"][
addr_type].split("/")[0]
static_routes = {
"r3": {
"static_routes": [{
"network": [NETWORK1_1[addr_type]],
"next_hop": next_hop_vrf,
"vrf": "RED"
}, {
"network": [NETWORK1_1[addr_type]],
"next_hop":
topo["routers"]["r2"]["links"]["r3-link1"]
[addr_type].split("/")[0],
"vrf":
"RED",
"delete":
True
}]
}
}
result = create_static_routes(tgen, static_routes)
assert result is True, "Testcase {} :Failed \n Error: {}". \
format(tc_name, result)
step("Verify that now routes are imported with two different next-hop "
"vrfs but same IPs. Additionally R3 must do ECMP for both the routes")
for addr_type in ADDR_TYPES:
next_hop_vrf = [
topo["routers"]["r1"]["links"]["r3-link3"][addr_type].\
split("/")[0],
topo["routers"]["r1"]["links"]["r3-link3"][addr_type]. \
split("/")[0]
]
static_routes = {
"r3": {
"static_routes": [{
"network": [NETWORK1_1[addr_type]],
}]
}
}
result = verify_bgp_rib(tgen,
addr_type,
"r3",
static_routes,
next_hop=next_hop_vrf)
assert result is True, "Testcase {} : Failed \n Error {}". \
format(tc_name, result)
result = verify_rib(tgen,
addr_type,
"r3",
static_routes,
next_hop=next_hop_vrf)
assert result is True, "Testcase {} : Failed \n Error {}". \
format(tc_name, result)
write_test_footer(tc_name)
def test_locally_imported_routes_selected_as_bestpath_over_ebgp_imported_routes_p0(
request):
"""
Verify ECMP for imported routes from different VRFs.
"""
tgen = get_topogen()
tc_name = request.node.name
write_test_header(tc_name)
if tgen.routers_have_failure():
check_router_status(tgen)
reset_config_on_routers(tgen)
step(
"Configure same static routes on R2 and R3 vrfs and redistribute in BGP "
"for GREEN and RED vrf instances")
for dut, network in zip(
["r2", "r3"], [[NETWORK1_1, NETWORK1_2], [NETWORK1_1, NETWORK1_2]]):
for vrf_name, network_vrf in zip(["RED", "GREEN"], network):
step("Configure static route for VRF : {} on {}".format(
vrf_name, dut))
for addr_type in ADDR_TYPES:
static_routes = {
dut: {
"static_routes": [{
"network": [network_vrf[addr_type]],
"next_hop": "blackhole",
"vrf": vrf_name
}]
}
}
result = create_static_routes(tgen, static_routes)
assert result is True, "Testcase {} :Failed \n Error: {}". \
format(tc_name, result)
for dut, as_num in zip(["r2", "r3"], ["2", "3"]):
for vrf_name in ["RED", "GREEN"]:
step("Redistribute static route on BGP VRF : {}".format(vrf_name))
temp = {}
for addr_type in ADDR_TYPES:
temp.update({
addr_type: {
"unicast": {
"redistribute": [{
"redist_type": "static"
}]
}
}
})
redist_dict = {
dut: {
"bgp": [{
"vrf": vrf_name,
"local_as": as_num,
"address_family": temp
}]
}
}
result = create_router_bgp(tgen, topo, redist_dict)
assert result is True, "Testcase {} :Failed \n Error: {}". \
format(tc_name, result)
step("Verify that R2 and R3 has installed redistributed routes in default "
"and RED vrfs and GREEN respectively:")
for dut, network in zip(
["r2", "r3"], [[NETWORK1_1, NETWORK1_2], [NETWORK1_1, NETWORK1_2]]):
for vrf_name, network_vrf in zip(["RED", "GREEN"], network):
for addr_type in ADDR_TYPES:
static_routes = {
dut: {
"static_routes": [{
"network": [network_vrf[addr_type]],
"next_hop": "blackhole",
"vrf": vrf_name
}]
}
}
result = verify_bgp_rib(tgen, addr_type, dut, static_routes)
assert result is True, "Testcase {} : Failed \n Error {}". \
format(tc_name, result)
step("Import vrf RED's route in vrf GREEN on R3")
temp = {}
for addr_type in ADDR_TYPES:
temp.update({addr_type: {"unicast": {"import": {"vrf": "RED"}}}})
import_dict = {
"r3": {
"bgp": [{
"vrf": "GREEN",
"local_as": 3,
"address_family": temp
}]
}
}
result = create_router_bgp(tgen, topo, import_dict)
assert result is True, "Testcase {} :Failed \n Error: {}". \
format(tc_name, result)
step("Verify that locally imported routes are installed over eBGP imported"
" routes from VRF RED into VRF GREEN")
for addr_type in ADDR_TYPES:
static_routes = {
"r3": {
"static_routes": [{
"network": [NETWORK1_2[addr_type]],
"next_hop": "blackhole",
"vrf": "GREEN"
}]
}
}
input_routes = {
"r3": {
addr_type: [{
"network": NETWORK1_2[addr_type],
"bestpath": BESTPATH[addr_type],
"vrf": "GREEN"
}]
}
}
result = verify_bgp_bestpath(tgen, addr_type, input_routes)
assert result is True, "Testcase {} : Failed \n Error {}". \
format(tc_name, result)
result = verify_rib(tgen, addr_type, "r3", static_routes)
assert result is True, "Testcase {} : Failed \n Error {}". \
format(tc_name, result)
write_test_footer(tc_name)
def test_mroute_when_transit_router_present_between_rp_and_source_dr_p1(request):
"""
Verify mroutes when transit router present between RP and Source DR
"""
tgen = get_topogen()
tc_name = request.node.name
write_test_header(tc_name)
# Creating configuration from JSON
app_helper.stop_all_hosts()
clear_mroute(tgen)
check_router_status(tgen)
reset_config_on_routers(tgen)
clear_pim_interface_traffic(tgen, topo)
# Don"t run this test if we have any failure.
if tgen.routers_have_failure():
pytest.skip(tgen.errors)
result = pre_config_for_source_dr_tests(tgen, topo, tc_name, "r1", "r2")
assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
step("Taken care in base config: Add router R6 between RP and R1 , R2")
step("R1 is the DR, mroute and upstream created on R1")
vlan_intf_r1_s1 = "{}.{}".format(intf_r1_s1, VLAN_1)
input_dict_dr = {
"r1": {
"pim": {
"interfaces": {vlan_intf_r1_s1: {"drAddress": SAME_VLAN_IP_2["ip"]}}
}
}
}
result = verify_pim_config(tgen, input_dict_dr)
assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
step("On R1 Mroute OIL towards R6, upstream in join Rej Prune state")
source_i1 = SAME_VLAN_IP_4["ip"]
input_dict_r1 = [
{
"dut": "r1",
"src_address": source_i1,
"oil": topo["routers"]["r1"]["links"]["r6"]["interface"],
"iif": "{}.{}".format(
topo["routers"]["r1"]["links"]["s1"]["interface"], VLAN_1
),
}
]
for data in input_dict_r1:
result = verify_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(
"R5 have mroute created and traffic is received, verify using "
"'show ip mroute json' 'show ip multicast json'"
)
input_dict_r5 = [
{
"dut": "r5",
"src_address": "*",
"iif": topo["routers"]["r5"]["links"]["r4"]["interface"],
"oil": topo["routers"]["r5"]["links"]["i2"]["interface"],
},
{
"dut": "r5",
"src_address": source_i1,
"iif": topo["routers"]["r5"]["links"]["r4"]["interface"],
"oil": topo["routers"]["r5"]["links"]["i2"]["interface"],
},
]
for data in input_dict_r5:
result = verify_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)
input_dict_traffic_r5 = {
"r5": {
"traffic_received": [topo["routers"]["r5"]["links"]["r4"]["interface"]],
"traffic_sent": [topo["routers"]["r5"]["links"]["i2"]["interface"]],
}
}
result = verify_multicast_traffic(tgen, input_dict_traffic_r5)
assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
step("Make R2 as DR configuring higher priority value")
raw_config = {
"r1": {
"raw_config": [
"interface {}.{}".format(intf_r1_s1, VLAN_1),
"no ip address {}/{}".format(
SAME_VLAN_IP_2["ip"], SAME_VLAN_IP_1["cidr"]
),
"ip address {}/{}".format(SAME_VLAN_IP_1["ip"], SAME_VLAN_IP_1["cidr"]),
]
},
"r2": {
"raw_config": [
"interface {}.{}".format(intf_r2_s1, VLAN_1),
"no ip address {}/{}".format(
SAME_VLAN_IP_1["ip"], SAME_VLAN_IP_1["cidr"]
),
"ip address {}/{}".format(SAME_VLAN_IP_2["ip"], SAME_VLAN_IP_2["cidr"]),
]
},
}
result = apply_raw_config(tgen, raw_config)
assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
step("R2 is the DR, mroute and upstream created on R2")
vlan_intf_r2_s1 = "{}.{}".format(intf_r2_s1, VLAN_1)
input_dict_dr = {
"r2": {
"pim": {
"interfaces": {vlan_intf_r2_s1: {"drAddress": SAME_VLAN_IP_2["ip"]}}
}
}
}
result = verify_pim_config(tgen, input_dict_dr)
assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
step(
"R5 have mroute created and traffic is received, verify using "
"'show ip mroute json' 'show ip multicast json'"
)
for data in input_dict_r5:
result = verify_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_multicast_traffic(tgen, input_dict_traffic_r5)
assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
write_test_footer(tc_name)
def test_pim_source_dr_functionality_while_rebooting_dr_non_dr_nodes_p1(
request):
"""
Verify mroute while rebooting DR /Non DR nodes( r1, r2 , r3 on all the nodes)
"""
tgen = get_topogen()
tc_name = request.node.name
write_test_header(tc_name)
# Creating configuration from JSON
app_helper.stop_all_hosts()
clear_mroute(tgen)
check_router_status(tgen)
reset_config_on_routers(tgen)
clear_pim_interface_traffic(tgen, topo)
# Don"t run this test if we have any failure.
if tgen.routers_have_failure():
pytest.skip(tgen.errors)
result = pre_config_for_source_dr_tests(tgen, topo, tc_name, "r1", "r3")
assert result is True, "Testcase {} : Failed Error: {}".format(
tc_name, result)
step("R1 is the DR , verify using 'show ip pim interface json'")
vlan_intf_r1_s1 = "{}.{}".format(intf_r1_s1, VLAN_1)
input_dict_dr = {
"r1": {
"pim": {
"interfaces": {
vlan_intf_r1_s1: {
"drAddress": SAME_VLAN_IP_3["ip"]
}
}
}
}
}
result = verify_pim_config(tgen, input_dict_dr)
assert result is True, "Testcase {} : Failed Error: {}".format(
tc_name, result)
step(
"R2 is transit router for R3 to reach R4, mroute should have (s, g) mroute with "
"OIL towards R4, using 'show ip mroute json'")
step("R2 (s, g) upstream should be in join state verify using "
"'show ip pim upstream json'")
step(
"R1 has (S, G) mroute with NONE OIL and upstream as not joined, verify using "
"'show ip mroute json' 'show ip pim upstream json'")
source_i1 = SAME_VLAN_IP_4["ip"]
input_dict_r1_r2 = [
{
"dut":
"r1",
"src_address":
source_i1,
"oil":
"none",
"iif":
"{}.{}".format(topo["routers"]["r1"]["links"]["s1"]["interface"],
VLAN_1),
},
{
"dut":
"r2",
"src_address":
source_i1,
"oil":
topo["routers"]["r2"]["links"]["r4"]["interface"],
"iif":
"{}.{}".format(topo["routers"]["r2"]["links"]["s1"]["interface"],
VLAN_1),
},
]
for data in input_dict_r1_r2:
result = verify_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)
if data["dut"] == "r2":
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)
else:
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 \n "
"Upstream is still joined state \n Error: {}".format(
tc_name, result))
step("Reboot R3 node")
stop_router(tgen, "r3")
step(
"After reboot of R3 verify R1 became DR, using 'show ip pim interface json'"
)
result = verify_pim_config(tgen, input_dict_dr)
assert result is True, "Testcase {} : Failed Error: {}".format(
tc_name, result)
step("R3 should not have any mroute and upstream")
step(
"R2 has mroute with OIL towards R4 /R1 , verify using 'show ip mroute'"
)
step(
"R2 has upstream with Join RejP state verify using 'show ip pim upstream json'"
)
step("R1 has mroute with none OIL and upstream with Not Join")
for data in input_dict_r1_r2:
result = verify_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)
if data["dut"] == "r2":
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)
else:
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 \n "
"Upstream is still joined state \n Error: {}".format(
tc_name, result))
step("Reboot R2 node")
stop_router(tgen, "r2")
step(
"After reboot of R2, R1 became DR verify using 'show ip pim interface json'"
)
result = verify_pim_config(tgen, input_dict_dr)
assert result is True, "Testcase {} : Failed Error: {}".format(
tc_name, result)
step("R3 and R2 should not have any mroute and upstream , verify using "
"'show ip mroute json' 'show ip pim upstream json'")
step(
"R1 has mroute created with OIL towards R4 , using 'show ip mroute json'"
)
step(
"R1 has upstream with Join Rej Prune , verify using 'show ip pim upstream json'"
)
for data in input_dict_r1_r2:
if data["dut"] == "r1":
result = verify_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,
expected=False,
)
assert result is not True, (
"Testcase {} : Failed \n "
"Upstream is still joined state \n Error: {}".format(
tc_name, result))
step("Reboot R1 node using FRR stop")
stop_router(tgen, "r1")
step("After stop of all the routers, verify upstream and mroutes should "
"not present in any of them")
for data in input_dict_r1_r2:
result = verify_mroutes(
tgen,
data["dut"],
data["src_address"],
IGMP_JOIN_RANGE_1,
data["iif"],
data["oil"],
expected=False,
)
assert (
result is not True
), "Testcase {} : Failed \n " "mroutes are still present \n Error: {}".format(
tc_name, result)
step("start FRR for all the nodes")
start_router(tgen, "r1")
start_router(tgen, "r2")
start_router(tgen, "r3")
step("After start of all the routers, R1 became DR")
result = verify_pim_config(tgen, input_dict_dr)
assert result is True, "Testcase {} : Failed Error: {}".format(
tc_name, result)
for data in input_dict_r1_r2:
result = verify_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)
if data["dut"] == "r2":
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_configuring_igmp_local_join_on_reciever_dr_non_dr_nodes_p1(request):
"""
Configure IGMP local join on DR and non DR
"""
tgen = get_topogen()
tc_name = request.node.name
write_test_header(tc_name)
# Creating configuration from JSON
app_helper.stop_all_hosts()
clear_mroute(tgen)
check_router_status(tgen)
reset_config_on_routers(tgen)
clear_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("Configure IGMP and PIM on switch connected receiver nodes")
step("Configure PIM on all upstream interfaces")
step("Configure link between R1, R2 ,R3 and receiver on" " same vlan")
step("Make sure R1 is DR initially configuring highest IP on R1 and R2 "
"second highest, R1 is lower")
intf_r1_s1 = topo["routers"]["r1"]["links"]["s1"]["interface"]
intf_r1_s1_addr = topo["routers"]["r1"]["links"]["s1"]["ipv4"]
intf_r2_s1 = topo["routers"]["r2"]["links"]["s1"]["interface"]
intf_r2_s1_addr = topo["routers"]["r2"]["links"]["s1"]["ipv4"]
intf_i1_s1 = topo["routers"]["i1"]["links"]["s1"]["interface"]
intf_i1_s1_addr = topo["routers"]["i1"]["links"]["s1"]["ipv4"]
vlan_input = {
"r1": {
"vlan": {
VLAN_1: [{
intf_r1_s1: {
"ip": SAME_VLAN_IP_1["ip"],
"subnet": SAME_VLAN_IP_1["subnet"],
}
}]
}
},
"r2": {
"vlan": {
VLAN_1: [{
intf_r2_s1: {
"ip": SAME_VLAN_IP_2["ip"],
"subnet": SAME_VLAN_IP_2["subnet"],
}
}]
}
},
"i1": {
"vlan": {
VLAN_1: [{
intf_i1_s1: {
"ip": SAME_VLAN_IP_4["ip"],
"subnet": SAME_VLAN_IP_4["subnet"],
}
}]
}
},
}
add_interfaces_to_vlan(tgen, vlan_input)
raw_config = {
"r1": {
"raw_config": [
"interface {}".format(intf_r1_s1),
"no ip address {}".format(intf_r1_s1_addr),
"no ip pim",
]
},
"r2": {
"raw_config": [
"interface {}".format(intf_r2_s1),
"no ip address {}".format(intf_r2_s1_addr),
"no ip pim",
]
},
"i1": {
"raw_config": [
"interface {}".format(intf_i1_s1),
"no ip address {}".format(intf_i1_s1_addr),
]
},
}
result = apply_raw_config(tgen, raw_config)
assert result is True, "Testcase {} : Failed Error: {}".format(
tc_name, result)
raw_config = {
"r1": {
"raw_config": [
"interface {}.{}".format(intf_r1_s1, VLAN_1),
"ip address {}/{}".format(SAME_VLAN_IP_1["ip"],
SAME_VLAN_IP_1["cidr"]),
"ip pim",
"ip igmp",
"ip igmp version 2",
]
},
"r2": {
"raw_config": [
"interface {}.{}".format(intf_r2_s1, VLAN_1),
"ip address {}/{}".format(SAME_VLAN_IP_2["ip"],
SAME_VLAN_IP_2["cidr"]),
"ip pim",
"ip igmp",
"ip igmp version 2",
]
},
"i1": {
"raw_config": [
"interface {}.{}".format(intf_i1_s1, VLAN_1),
"ip address {}/{}".format(SAME_VLAN_IP_4["ip"],
SAME_VLAN_IP_4["cidr"]),
]
},
}
result = apply_raw_config(tgen, raw_config)
assert result is True, "Testcase {} : Failed Error: {}".format(
tc_name, result)
for dut, intf in zip(["r1", "r2"], [intf_r1_s1, intf_r2_s1]):
raw_config = {
dut: {
"raw_config": [
"interface {}.{}".format(intf, VLAN_1),
"ip pim hello {} {}".format(HELLO_TIMER, HOLD_TIMER),
]
}
}
result = apply_raw_config(tgen, raw_config)
assert result is True, "Testcase {} : Failed Error: {}".format(
tc_name, result)
step("Configure R4 as RP on all the nodes for group range 224.0.0.0/24")
input_dict = {
"r4": {
"pim": {
"rp": [{
"rp_addr":
topo["routers"]["r4"]["links"]["lo"]["ipv4"].split("/")[0],
"group_addr_range":
GROUP_RANGE_1 + GROUP_RANGE_3,
}]
}
}
}
result = create_pim_config(tgen, topo, input_dict)
assert result is True, "Testcase {} : Failed Error: {}".format(
tc_name, result)
step("Send IGMP local join for groups 226.1.1.1 to 226.1.1.5")
vlan_intf_r1_s1 = "{}.{}".format(intf_r1_s1, VLAN_1)
input_dict = {
"r1": {
"igmp": {
"interfaces": {
vlan_intf_r1_s1: {
"igmp": {
"version": "2",
"join": IGMP_JOIN_RANGE_1
}
}
}
}
}
}
result = create_igmp_config(tgen, topo, input_dict)
assert result is True, "Testcase {}: Failed Error: {}".format(
tc_name, result)
step("Enable OSPF between all the nodes")
step("Configure local join on R1 for group range (227.1.1.1)")
vlan_intf_r1_s1 = "{}.{}".format(intf_r1_s1, VLAN_1)
input_dict = {
"r1": {
"igmp": {
"interfaces": {
vlan_intf_r1_s1: {
"igmp": {
"version": "2",
"join": IGMP_JOIN_RANGE_3
}
}
}
}
}
}
result = create_igmp_config(tgen, topo, input_dict)
assert result is True, "Testcase {}: Failed Error: {}".format(
tc_name, result)
step("Start traffic from R4 connected source")
input_src = {"i2": topo["routers"]["i2"]["links"]["r5"]["interface"]}
result = app_helper.run_traffic("i2",
IGMP_JOIN_RANGE_1 + IGMP_JOIN_RANGE_3,
"r5")
assert result is True, "Testcase {} : Failed Error: {}".format(
tc_name, result)
step("R1, R2 and R2 has IGMP groups for 226.x.x.x and 227.1.1.1 groups")
intf_r1_s1 = "{}.{}".format(
topo["routers"]["r1"]["links"]["s1"]["interface"], VLAN_1)
intf_r2_s1 = "{}.{}".format(
topo["routers"]["r2"]["links"]["s1"]["interface"], VLAN_1)
for dut, intf in zip(["r1", "r2"], [intf_r1_s1, intf_r2_s1]):
result = verify_igmp_groups(tgen, dut, intf,
IGMP_JOIN_RANGE_1 + IGMP_JOIN_RANGE_3)
assert result is True, "Testcase {} : Failed Error: {}".format(
tc_name, result)
step("R1 is DR, R2 has 226.x.x.x and 227.1.1.1 (*,G) mroute with SC flag")
step("(S,G) mroute for 226.1.1.1 group present on R2")
source_i2 = topo["routers"]["i2"]["links"]["r5"]["ipv4"].split("/")[0]
input_dict_r2 = [{
"dut":
"r2",
"src_address":
"*",
"iif":
topo["routers"]["r2"]["links"]["r4"]["interface"],
"oil":
"{}.{}".format(topo["routers"]["r2"]["links"]["s1"]["interface"],
VLAN_1),
}]
for data in input_dict_r2:
result = verify_mroutes(
tgen,
data["dut"],
data["src_address"],
IGMP_JOIN_RANGE_1 + IGMP_JOIN_RANGE_3,
data["iif"],
data["oil"],
)
assert result is True, "Testcase {} : Failed Error: {}".format(
tc_name, result)
for dut, flag in zip(["r2"], ["SC"]):
step("{} has (*,G) flag as {}".format(dut, flag))
result = verify_multicast_flag_state(tgen, dut, "*", IGMP_JOIN_RANGE_1,
flag)
assert result is True, "Testcase {} : Failed Error: {}".format(
tc_name, result)
step("Delete local join from DR node")
for _join in IGMP_JOIN_RANGE_3:
input_dict = {
"r1": {
"igmp": {
"interfaces": {
vlan_intf_r1_s1: {
"igmp": {
"join": [_join],
"delete_attr": True,
}
}
}
}
}
}
result = create_igmp_config(tgen, topo, input_dict)
assert result is True, "Testcase {}: Failed Error: {}".format(
tc_name, result)
step(
"After removing local join 227.1.1.1 group removed from IGMP join "
"of R1, R2 node , using 'show ip igmp groups json'")
for dut, intf in zip(["r1", "r2"], [intf_r1_s1, intf_r2_s1]):
result = verify_igmp_groups(tgen,
dut,
intf,
IGMP_JOIN_RANGE_3,
expected=False)
assert result is not True, (
"Testcase {} : Failed \n "
"IGMP groups are still present \n Error: {}".format(
tc_name, result))
step("(*,G) mroute for 227.1.1.1 group removed from R1 node")
step(
"After remove of local join from R1 and R2 node verify (*,G) and (S,G) "
"mroutes should not present on R1, R2 and R3 nodes")
for data in input_dict_r2:
result = verify_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_mroutes(
tgen,
data["dut"],
data["src_address"],
IGMP_JOIN_RANGE_3,
data["iif"],
data["oil"],
expected=False,
)
assert (
result is not True
), "Testcase {} : Failed \n " "mroutes are still present \n Error: {}".format(
tc_name, result)
step("Configure local join on R2 for group range (227.1.1.1)")
input_dict = {
"r2": {
"igmp": {
"interfaces": {
intf_r2_s1: {
"igmp": {
"version": "2",
"join": IGMP_JOIN_RANGE_3
}
}
}
}
}
}
result = create_igmp_config(tgen, topo, input_dict)
assert result is True, "Testcase {}: Failed Error: {}".format(
tc_name, result)
step(
"After configuring local join on R2 non DR node, IGMP groups for 26.x.x.x and "
"227.1.1.1 present on all the nodes")
for dut, intf in zip(["r1", "r2"], [intf_r1_s1, intf_r2_s1]):
result = verify_igmp_groups(tgen, dut, intf,
IGMP_JOIN_RANGE_1 + IGMP_JOIN_RANGE_3)
assert result is True, "Testcase {} : Failed Error: {}".format(
tc_name, result)
step("R2 has 227.1.1.1 (*,G) mroute with SC flag")
for dut, flag in zip(["r2"], ["SC"]):
step("{} has (*,G) flag as {}".format(dut, flag))
result = verify_multicast_flag_state(tgen, dut, "*", IGMP_JOIN_RANGE_3,
flag)
assert result is True, "Testcase {} : Failed Error: {}".format(
tc_name, result)
step("Configure local join on R1 for group range (227.1.1.1)")
input_dict = {
"r1": {
"igmp": {
"interfaces": {
vlan_intf_r1_s1: {
"igmp": {
"version": "2",
"join": IGMP_JOIN_RANGE_3
}
}
}
}
}
}
result = create_igmp_config(tgen, topo, input_dict)
assert result is True, "Testcase {}: Failed Error: {}".format(
tc_name, result)
step(
"After configuring 227.1.1.1 on R1 node, verify no change on IGMP groups on all the nodes"
)
for dut, intf in zip(["r1", "r2"], [intf_r1_s1, intf_r2_s1]):
result = verify_igmp_groups(tgen, dut, intf,
IGMP_JOIN_RANGE_1 + IGMP_JOIN_RANGE_3)
assert result is True, "Testcase {} : Failed Error: {}".format(
tc_name, result)
step("R2 has 227.1.1.1 (*,G) mroute with SC flag")
step("r2 has (*,G) flag as SC")
result = verify_multicast_flag_state(tgen, "r2", "*", IGMP_JOIN_RANGE_3,
"SC")
assert result is True, "Testcase {} : Failed Error: {}".format(
tc_name, result)
step("R1 should not have (*,G) join and (S,G) join present")
input_dict_r1 = [
{
"dut":
"r1",
"src_address":
"*",
"iif":
topo["routers"]["r1"]["links"]["r4"]["interface"],
"oil":
"{}.{}".format(topo["routers"]["r1"]["links"]["s1"]["interface"],
VLAN_1),
},
{
"dut":
"r1",
"src_address":
source_i2,
"iif":
topo["routers"]["r1"]["links"]["r4"]["interface"],
"oil":
"{}.{}".format(topo["routers"]["r1"]["links"]["s1"]["interface"],
VLAN_1),
},
]
for data in input_dict_r1:
result = verify_mroutes(
tgen,
data["dut"],
data["src_address"],
IGMP_JOIN_RANGE_1 + IGMP_JOIN_RANGE_3,
data["iif"],
data["oil"],
expected=False,
)
assert (
result is not True
), "Testcase {} : Failed \n " "mroutes are still present \n Error: {}".format(
tc_name, result)
step("Remove local join from DR and Non DR node")
input_dict = {
"r1": {
"igmp": {
"interfaces": {
vlan_intf_r1_s1: {
"igmp": {
"version": "2",
"join": IGMP_JOIN_RANGE_3,
"delete_attr": True,
}
}
}
}
},
"r2": {
"igmp": {
"interfaces": {
intf_r2_s1: {
"igmp": {
"version": "2",
"join": IGMP_JOIN_RANGE_3,
"delete_attr": True,
}
}
}
}
},
}
result = create_igmp_config(tgen, topo, input_dict)
assert result is True, "Testcase {}: Failed Error: {}".format(
tc_name, result)
step(
"After remove of local join from R1 and R2 node verify (*,G) and (S,G) mroutes "
"should not present on R1, R2 nodes")
for data in input_dict_r1:
result = verify_mroutes(
tgen,
data["dut"],
data["src_address"],
IGMP_JOIN_RANGE_1 + IGMP_JOIN_RANGE_3,
data["iif"],
data["oil"],
expected=False,
)
assert (
result is not True
), "Testcase {} : Failed \n " "mroutes are still present \n Error: {}".format(
tc_name, result)
for data in input_dict_r2:
result = verify_mroutes(
tgen,
data["dut"],
data["src_address"],
IGMP_JOIN_RANGE_1 + IGMP_JOIN_RANGE_3,
data["iif"],
data["oil"],
expected=False,
)
assert (
result is not True
), "Testcase {} : Failed \n " "mroutes are still present \n Error: {}".format(
tc_name, result)
write_test_footer(tc_name)
def test_modify_route_map_match_set_clauses_p1(request):
"""
TC13_CHAOS_4:
1.5.13. Verify that Changing route-map configurations(match/set clauses) on
the fly it takes immediate effect.
"""
tgen = get_topogen()
tc_name = request.node.name
write_test_header(tc_name)
build_config_from_json(tgen, topo)
if tgen.routers_have_failure():
check_router_status(tgen)
for addr_type in ADDR_TYPES:
step("Configure route-map to set community attribute for a specific"
"prefix on R1 in vrf ISR")
input_dict_pf = {
"r1": {
"prefix_lists": {
addr_type: {
"pflist_ABC_{}".format(addr_type): [{
"seqid":
10,
"network":
NETWORK1_1[addr_type],
"action":
"permit",
}]
}
}
}
}
result = create_prefix_lists(tgen, input_dict_pf)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
input_dict_cl = {
"r1": {
"bgp_community_lists": [{
"community_type": "expanded",
"action": "permit",
"name": "COMM",
"value": "100:100",
}]
}
}
result = create_bgp_community_lists(tgen, input_dict_cl)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
for addr_type in ADDR_TYPES:
input_dict_rm = {
"r1": {
"route_maps": {
"rmap_XYZ_{}".format(addr_type): [{
"action": "permit",
"match": {
addr_type: {
"prefix_lists":
"pflist_ABC_{}".format(addr_type)
}
},
"set": {
"community": {
"num": "100:100"
}
},
}]
}
}
}
result = create_route_maps(tgen, input_dict_rm)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
for addr_type in ADDR_TYPES:
step("Apply this route-map on R1 to vrf ISR while redistributing the"
" prefixes into BGP")
input_dict_1 = {}
DUT = ["r1"]
VRFS = ["ISR"]
AS_NUM = [100]
for dut, vrf, as_num in zip(DUT, VRFS, AS_NUM):
temp = {dut: {"bgp": []}}
input_dict_1.update(temp)
temp[dut]["bgp"].append({
"local_as": as_num,
"vrf": vrf,
"address_family": {
addr_type: {
"unicast": {
"redistribute": [{
"redist_type": "static",
"attribute": {
"route-map":
"rmap_XYZ_{}".format(addr_type)
},
}]
}
}
},
})
result = create_router_bgp(tgen, topo, input_dict_1)
assert result is True, "Testcase {} :Failed \n Error: {}".format(
tc_name, result)
for addr_type in ADDR_TYPES:
step("Configure another route-map for filtering the prefixes based on"
" community attribute while importing into default vrf")
input_dict_rm = {
"r1": {
"route_maps": {
"rmap_IMP_{}".format(addr_type): [{
"action": "permit",
"seq_id": 10,
"match": {
"community_list": {
"id": "COMM"
}
},
"set": {
"community": {
"num": "none"
}
},
}]
}
}
}
result = create_route_maps(tgen, input_dict_rm)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
for addr_type in ADDR_TYPES:
step("Apply the route-map while Importing vrf ISR's prefixes into "
"default vrf on router R1:")
input_dict_isr = {}
DUT = ["r1"]
VRFS = ["default"]
AS_NUM = [100]
for dut, vrf, as_num in zip(DUT, VRFS, AS_NUM):
temp = {dut: {"bgp": []}}
input_dict_isr.update(temp)
temp[dut]["bgp"].append({
"local_as": as_num,
"vrf": vrf,
"address_family": {
addr_type: {
"unicast": {
"import": {
"vrf": "ISR"
}
}
}
},
})
temp[dut]["bgp"].append({
"local_as": as_num,
"vrf": vrf,
"address_family": {
addr_type: {
"unicast": {
"import": {
"vrf":
"route-map rmap_IMP_{}".format(addr_type)
}
}
}
},
})
result = create_router_bgp(tgen, topo, input_dict_isr)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
for addr_type in ADDR_TYPES:
step("Verify on R1 that only prefixes with community value 100:100"
"in vrf ISR are imported to vrf default. While importing, the"
" community value has been stripped off:")
input_routes_r1 = {
"r1": {
"static_routes": [{
"network": [NETWORK1_1[addr_type]],
"vrf": "default"
}]
}
}
result = verify_bgp_rib(tgen, addr_type, "r1", input_routes_r1)
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result)
for addr_type in ADDR_TYPES:
step("Add set clause in route-map IMP:")
input_dict_rm = {
"r1": {
"route_maps": {
"rmap_IMP_{}".format(addr_type): [{
"action": "permit",
"seq_id": 10,
"match": {
"community_list": {
"id": "COMM"
}
},
"set": {
"large_community": {
"num": "100:100:100"
},
"locPrf": 500,
"path": {
"as_num": "100 100",
"as_action": "prepend"
},
},
}]
}
}
}
result = create_route_maps(tgen, input_dict_rm)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
for addr_type in ADDR_TYPES:
step("Verify that as we continue adding different attributes "
"step-by-step in route-map IMP those attributes gets "
"attached to prefixes:")
input_routes_r1 = {
"r1": {
"static_routes": [{
"network": [NETWORK1_1[addr_type]],
"vrf": "default"
}]
}
}
input_dict_comm = {"largeCommunity": "100:100:100"}
result = verify_bgp_community(tgen, addr_type, dut,
[NETWORK1_1[addr_type]], input_dict_comm)
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result)
input_rmap = {
"r1": {
"route_maps": {
"rmap_IMP_{}".format(addr_type): [{
"set": {
"locPrf": 500
}
}]
}
}
}
result = verify_bgp_attributes(
tgen,
addr_type,
"r1",
[NETWORK1_1[addr_type]],
rmap_name="rmap_IMP_{}".format(addr_type),
input_dict=input_rmap,
)
assert result is True, "Testcase : Failed \n Error: {}".format(
tc_name, result)
step("Change community-list to match a different value then " "100:100.")
input_dict_cl = {
"r1": {
"bgp_community_lists": [{
"community_type": "expanded",
"action": "permit",
"name": "COMM",
"value": "100:100",
"delete": True,
}]
}
}
result = create_bgp_community_lists(tgen, input_dict_cl)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result)
for addr_type in ADDR_TYPES:
input_routes_r1 = {
"r1": {
"static_routes": [{
"network": [NETWORK1_1[addr_type]],
"vrf": "default"
}]
}
}
result = verify_bgp_rib(tgen,
addr_type,
"r1",
input_routes_r1,
expected=False)
assert (
result is not True
), "Testcase {} : Failed \n Error : Routes are still " "present {}".format(
tc_name, result)
write_test_footer(tc_name)
def BGP_GR_TC_7_p1(request):
"""
Verify that BGP restarting node deletes all the routes received from peer
if BGP Graceful capability is not present in BGP Open message from the
peer
"""
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_7 >> "
"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 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"])
# Change the configuration on router R1
input_dict_2 = {
"r3": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r1": {
"dest_link": {
"r3": {"graceful-restart-disable": True}
}
}
}
}
},
"ipv6": {
"unicast": {
"neighbor": {
"r1": {
"dest_link": {
"r3": {"graceful-restart-disable": True}
}
}
}
}
},
}
}
}
}
result = create_router_bgp(tgen, topo, input_dict_2)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
# Change the configuration on R1
network = {"ipv4": "103.0.20.1/32", "ipv6": "3::1/128"}
for addr_type in ADDR_TYPES:
input_dict_2 = {
"r3": {
"bgp": {
"address_family": {
addr_type: {
"unicast": {
"advertise_networks": [
{
"network": network[addr_type],
"no_of_network": 5,
"delete": True,
}
]
}
}
}
}
}
}
result = create_router_bgp(tgen, topo, input_dict_2)
assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
logger.info("R1 is about to come up now")
start_router_daemons(tgen, "r1", ["bgpd"])
logger.info("R1 is UP Now")
# Wait for RIB stale timeout
logger.info("Verify routes are not present" "in restart router")
for addr_type in ADDR_TYPES:
# Verifying RIB routes
dut = "r1"
input_dict_1 = {key: topo["routers"][key] for key in ["r3"]}
result = verify_rib(tgen, addr_type, dut, input_dict_1, expected=False)
assert result is not True, (
"Testcase {} : Failed \n "
"r1: routes are still present in ZEBRA\n Error: {}".format(tc_name, result)
)
write_test_footer(tc_name)
def test_BGP_GR_chaos_34_1_p1(request):
"""
Test Objective : Restarting node doesn't preserve forwarding
state, helper router should not keep the stale entries.
"""
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(
" Test Case : test_BGP_GR_chaos_31 "
"BGP GR "
"[Restart Mode]R1---R3[Helper Mode]"
)
# Configure graceful-restart
input_dict = {
"r1": {
"bgp": {
"graceful-restart": {
"preserve-fw-state": True,
"timer": {"restart-time": GR_RESTART_TIMER},
},
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r3": {"dest_link": {"r1": {"graceful-restart": True}}}
}
}
},
"ipv6": {
"unicast": {
"neighbor": {
"r3": {"dest_link": {"r1": {"graceful-restart": 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
)
# Verifying BGP RIB routes after starting BGPd daemon
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
result = verify_rib(tgen, addr_type, dut, input_dict_1)
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result
)
logger.info(
"[Step 1] : Remove the preserve-fw-state command"
" from restarting node R1's config"
)
# Configure graceful-restart to set f-bit as False
input_dict_2 = {"r1": {"bgp": {"graceful-restart": {"preserve-fw-state": False}}}}
result = create_router_bgp(tgen, topo, input_dict_2)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
logger.info("[Step 2] : Reset the session between R1 and R3..")
# Reset sessions
for addr_type in ADDR_TYPES:
clear_bgp(tgen, addr_type, "r1")
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:
# Verify f-bit after starting BGPd daemon
result = verify_f_bit(
tgen, topo, addr_type, input_dict_2, "r3", "r1", expected=False
)
assert (
result is not True
), "Testcase {} : Failed \n " "r3: F-bit is set to True\n Error: {}".format(
tc_name, result
)
logger.info(" Expected behavior: {}".format(result))
logger.info("[Step 3] : Kill BGPd daemon on R1..")
# Kill BGPd daemon on R1
kill_router_daemons(tgen, "r1", ["bgpd"])
# Waiting for GR_RESTART_TIMER
logger.info("Waiting for {} sec..".format(GR_RESTART_TIMER))
sleep(GR_RESTART_TIMER)
for addr_type in ADDR_TYPES:
# Verifying BGP RIB routes
input_dict = {key: topo["routers"][key] for key in ["r1"]}
result = verify_bgp_rib(tgen, addr_type, dut, input_dict, expected=False)
assert result is not True, (
"Testcase {} : Failed \n "
"r3: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result
)
)
logger.info(" Expected behavior: {}".format(result))
# Verifying RIB routes
result = verify_rib(tgen, addr_type, dut, input_dict, expected=False)
assert result is not True, (
"Testcase {} : Failed \n "
"r3: routes are still present in ZEBRA\n Error: {}".format(tc_name, result)
)
logger.info(" Expected behavior: {}".format(result))
# Start BGPd daemon on R1
start_router_daemons(tgen, "r1", ["bgpd"])
write_test_footer(tc_name)
def test_BGP_GR_chaos_32_p1(request):
"""
Test Objective : Restarting node is connected to multiple helper
nodes, one of them doesn't send EOR to restarting router. Verify
that only after SDT restarting node send EOR to all helper peers
excluding the prefixes originated by faulty 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(
" Test Case : test_BGP_GR_chaos_32 "
"BGP GR "
"[Restart Mode]R1---R3&R5[Helper Mode]"
)
logger.info(
"[Step 1] : Change the mode on R1 be a restarting" " node on global level"
)
# Configure graceful-restart
input_dict = {
"r1": {
"bgp": {
"graceful-restart": {"graceful-restart": True},
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r3": {"dest_link": {"r1": {"next_hop_self": True}}},
"r5": {"dest_link": {"r1": {"graceful-restart": True}}},
}
}
},
"ipv6": {
"unicast": {
"neighbor": {
"r3": {"dest_link": {"r1": {"next_hop_self": True}}},
"r5": {"dest_link": {"r1": {"graceful-restart": True}}},
}
}
},
},
}
},
"r5": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r1": {
"dest_link": {
"r5": {"graceful-restart-helper": True}
}
}
}
}
},
"ipv6": {
"unicast": {
"neighbor": {
"r1": {
"dest_link": {
"r5": {"graceful-restart-helper": True}
}
}
}
}
},
}
}
},
}
configure_gr_followed_by_clear(tgen, topo, input_dict, tc_name, dut="r1", peer="r5")
for addr_type in ADDR_TYPES:
result = verify_graceful_restart(
tgen, topo, addr_type, input_dict, dut="r1", peer="r5"
)
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result
)
# Verifying BGP RIB routes after starting BGPd daemon
dut = "r3"
input_dict_1 = {key: topo["routers"][key] for key in ["r5"]}
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("[Step 2] : Kill BGPd daemon on R1..")
# Kill BGPd daemon on R1
kill_router_daemons(tgen, "r1", ["bgpd"])
logger.info("[Step 3] : Withdraw all the advertised prefixes from R5")
# Api call to delete advertised networks
network = {"ipv4": "105.0.20.1/32", "ipv6": "5::1/128"}
for addr_type in ADDR_TYPES:
input_dict_2 = {
"r5": {
"bgp": {
"address_family": {
addr_type: {
"unicast": {
"advertise_networks": [
{
"network": network[addr_type],
"no_of_network": 5,
"delete": True,
}
]
}
}
}
}
}
}
result = create_router_bgp(tgen, topo, input_dict_2)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
logger.info(
"[Step 4] : Stop the helper router R5 from sending EOR" " message using CLI"
)
# Modify graceful-restart config to prevent sending EOR
input_dict_3 = {"r5": {"bgp": {"graceful-restart": {"disable-eor": True}}}}
result = create_router_bgp(tgen, topo, input_dict_3)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
logger.info("[Step 5] : Bring up the BGPd daemon on R1..")
# Start BGPd daemon on R1
start_router_daemons(tgen, "r1", ["bgpd"])
for addr_type in ADDR_TYPES:
# Verify EOR is disabled
result = verify_eor(
tgen, topo, addr_type, input_dict_3, dut="r5", peer="r1", expected=False
)
assert (
result is not True
), "Testcase {} : Failed \n " "r5: EOR is set to TRUE\n Error: {}".format(
tc_name, result
)
logger.info(" Expected behavior: {}".format(result))
# Verifying BGP RIB routes after starting BGPd daemon
input_dict_1 = {key: topo["routers"][key] for key in ["r5"]}
result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1, expected=False)
assert result is not True, (
"Testcase {} : Failed \n "
"r3: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result
)
)
logger.info(" Expected behavior: {}".format(result))
# Verifying RIB routes
result = verify_rib(tgen, addr_type, dut, input_dict_1, expected=False)
assert result is not True, (
"Testcase {} : Failed \n "
"r3: 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_BGP_GR_chaos_34_2_p1(request):
"""
Test Objective : Restarting node doesn't preserve the forwarding
state verify the behaviour on helper node, if it still keeps the
stale routes.
"""
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(
" Test Case : test_BGP_GR_chaos_34 "
"BGP GR "
"[Restart Mode]R1---R3[Helper Mode]"
)
logger.info("[Step 1] : Configure restarting" " router R1 to prevent ")
logger.info("[Step 2] : Reset the session" " between R1 and R3..")
# Configure graceful-restart
input_dict = {
"r1": {
"bgp": {
"graceful-restart": {"preserve-fw-state": True, "disable-eor": True},
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r3": {"dest_link": {"r1": {"graceful-restart": True}}}
}
}
},
"ipv6": {
"unicast": {
"neighbor": {
"r3": {"dest_link": {"r1": {"graceful-restart": 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
)
# Verify f-bit before killing BGPd daemon
result = verify_f_bit(tgen, topo, addr_type, input_dict, "r3", "r1")
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result
)
# Verifying BGP RIB routes after starting BGPd daemon
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
result = verify_rib(tgen, addr_type, dut, input_dict_1)
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result
)
logger.info("[Step 3] : Kill BGPd daemon on R1..")
# Kill BGPd daemon on R1
kill_router_daemons(tgen, "r1", ["bgpd"])
logger.info("[Step 4] : Withdraw/delete the prefixes " "originated from R1..")
# Api call to delete advertised networks
network = {"ipv4": "101.0.20.1/32", "ipv6": "1::1/128"}
for addr_type in ADDR_TYPES:
input_dict_2 = {
"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_2)
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result
)
logger.info("[Step 5] : Remove the CLI from R1's config to " "set the F-bit..")
# Modify graceful-restart config not to set f-bit
# and write to /etc/frr
input_dict_2 = {"r1": {"bgp": {"graceful-restart": {"preserve-fw-state": False}}}}
result = modify_bgp_config_when_bgpd_down(tgen, topo, input_dict_2)
assert result is True, "Testcase {} : Failed \n Error {}".format(tc_name, result)
logger.info("[Step 6] : Bring up the BGPd daemon on R1 again..")
# Start BGPd daemon on R1
start_router_daemons(tgen, "r1", ["bgpd"])
for addr_type in ADDR_TYPES:
# Verify f-bit after starting BGPd daemon
result = verify_f_bit(
tgen, topo, addr_type, input_dict, "r3", "r1", expected=False
)
assert (
result is not True
), "Testcase {} : Failed \n " "r3: F-bit is set to True\n Error: {}".format(
tc_name, result
)
logger.info(" Expected behavior: {}".format(result))
# Verifying BGP RIB routes after starting BGPd daemon
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 "
"r3: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result
)
)
logger.info(" Expected behavior: {}".format(result))
# Verifying RIB routes
result = verify_rib(tgen, addr_type, dut, input_dict_1, expected=False)
assert result is not True, (
"Testcase {} : Failed \n "
"r3: 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_BGP_GR_chaos_37_p1(request):
"""
Test Objective : Verify if helper node restarts before sending the
EOR message, restarting node doesn't wait until stale path timer
expiry to do the best path selection and sends an EOR
"""
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(
" Test Case : test_BGP_GR_chaos_37 "
"BGP GR "
"[Restart Mode]R1---R3[Helper Mode]"
)
logger.info(
"[Step 1] : Configure restarting router R3 to prevent " "sending an EOR.."
)
logger.info("[Step 2] : Reset the session between R3 and R1..")
# Configure graceful-restart
input_dict = {
"r1": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r3": {"dest_link": {"r1": {"graceful-restart": True}}}
}
}
},
"ipv6": {
"unicast": {
"neighbor": {
"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}
}
}
}
}
},
},
}
},
}
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
)
# Verify EOR is disabled
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
)
logger.info(" Expected behavior: {}".format(result))
# Verifying BGP RIB routes after starting BGPd daemon
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("[Step 3] : Kill BGPd daemon on R1..")
# Kill BGPd daemon on R1
kill_router_daemons(tgen, "r1", ["bgpd"])
logger.info("[Step 4] : Start BGPd daemon on R1..")
# Start BGPd daemon on R1
start_router_daemons(tgen, "r1", ["bgpd"])
logger.info("[Step 5] : Kill BGPd daemon on R3..")
# Kill BGPd daemon on R3
kill_router_daemons(tgen, "r3", ["bgpd"])
# Modify graceful-restart config to prevent sending EOR
input_dict_2 = {"r3": {"bgp": {"graceful-restart": {"disable-eor": True}}}}
result = modify_bgp_config_when_bgpd_down(tgen, topo, input_dict_2)
assert result is True, "Testcase {} : Failed \n Error {}".format(tc_name, result)
logger.info("[Step 6] : Start BGPd daemon on R3..")
# Start BGPd daemon on R3
start_router_daemons(tgen, "r3", ["bgpd"])
for addr_type in ADDR_TYPES:
# Verify r_bit
result = verify_r_bit(tgen, topo, addr_type, input_dict, dut="r1", peer="r3")
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result
)
# Verifying RIB routes
input_dict_1 = {key: topo["routers"][key] for key in ["r3"]}
result = verify_rib(tgen, addr_type, dut, input_dict_1)
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result
)
# Verify EOR is send from R1 to R3
input_dict_3 = {"r1": {"bgp": {"graceful-restart": {"disable-eor": True}}}}
result = verify_eor(
tgen, topo, addr_type, input_dict_3, 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
)
write_test_footer(tc_name)
def test_BGP_GR_chaos_28_p1(request):
"""
Test Objective : Verify if helper node goes down before restarting
node comes up online, helper node sets the R-bit to avoid dead-lock
till SDT expiry.
"""
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(
"Test Case: test_BGP_GR_chaos_28 :"
"[Helper Mode]R3-----R1[Restart Mode] initialized"
)
# Configure graceful-restart
input_dict = {
"r1": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r3": {"dest_link": {"r1": {"graceful-restart": True}}}
}
}
},
"ipv6": {
"unicast": {
"neighbor": {
"r3": {"dest_link": {"r1": {"graceful-restart": 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 1] : Kill BGPd daemon on R1..")
# Kill BGPd daemon on R1
kill_router_daemons(tgen, "r1", ["bgpd"])
logger.info("[Step 2] : Kill BGPd daemon on R3..")
# Kill BGPd daemon on R3
kill_router_daemons(tgen, "r3", ["bgpd"])
logger.info("[Step 3] : Start BGPd daemon on R1..")
# Start BGPd daemon on R1
start_router_daemons(tgen, "r1", ["bgpd"])
logger.info("[Step 4] : Start BGPd daemon on R3..")
# Start BGPd daemon on R3
start_router_daemons(tgen, "r3", ["bgpd"])
# Verify r_bit
for addr_type in ADDR_TYPES:
result = verify_r_bit(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_chaos_30_p1(request):
"""
Test Objective : Restarting node removes stale routes from Zebra
after receiving an EOR from 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(
" Test Case : test_BGP_GR_chaos_30 "
"BGP GR [Helper Mode]R3-----R1[Restart Mode] "
)
# Configure graceful-restart and timers
input_dict = {
"r1": {
"bgp": {
"graceful-restart": {"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}}}
}
}
},
},
}
},
"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
)
for addr_type in ADDR_TYPES:
# Verifying BGP RIB routes before shutting down BGPd daemon
dut = "r1"
input_dict = {key: topo["routers"][key] for key in ["r3"]}
result = verify_bgp_rib(tgen, addr_type, dut, input_dict)
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)
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result
)
logger.info("[Step 2] : Kill BGPd daemon on R1..")
# Kill BGPd daemon on R1
kill_router_daemons(tgen, "r1", ["bgpd"])
logger.info("[Step 3] : Withdraw advertised prefixes from R3...")
# Api call to delete advertised networks
network = {"ipv4": "103.0.20.1/32", "ipv6": "3::1/128"}
for addr_type in ADDR_TYPES:
input_dict = {
"r3": {
"bgp": {
"address_family": {
addr_type: {
"unicast": {
"advertise_networks": [
{
"network": network[addr_type],
"no_of_network": 5,
"delete": True,
}
]
}
}
}
}
}
}
result = create_router_bgp(tgen, topo, input_dict)
assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result
)
logger.info("[Step 4] : Start BGPd daemon on R1..")
# Start BGPd daemon on R1
start_router_daemons(tgen, "r1", ["bgpd"])
for addr_type in ADDR_TYPES:
# Verifying BGP RIB routes before shutting down BGPd daemon
input_dict = {key: topo["routers"][key] for key in ["r3"]}
result = verify_bgp_rib(tgen, addr_type, dut, input_dict, expected=False)
assert result is not True, (
"Testcase {} : Failed \n "
"r1: 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, expected=False)
assert result is not True, (
"Testcase {} : Failed \n "
"r1: 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_BGP_GR_chaos_33_p1(request):
"""
Test Objective : Helper router receives same prefixes from two
different routers (GR-restarting and GR-disabled). Keeps the
stale entry only for GR-restarting node(next-hop is correct).
"""
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(
" Test Case : test_BGP_GR_chaos_33 "
"BGP GR "
"[Restart Mode]R1--R3[Helper Mode]--R4[Disabled Mode]"
)
# Configure graceful-restart
input_dict = {
"r1": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r3": {"dest_link": {"r1": {"graceful-restart": True}}}
}
}
},
"ipv6": {
"unicast": {
"neighbor": {
"r3": {"dest_link": {"r1": {"graceful-restart": 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}
}
}
}
}
},
}
}
},
"r4": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"neighbor": {
"r3": {
"dest_link": {
"r4": {"graceful-restart-disable": True}
}
}
}
}
},
"ipv6": {
"unicast": {
"neighbor": {
"r3": {
"dest_link": {
"r4": {"graceful-restart-disable": 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] : Advertise same networks from R1 and R4..")
# Api call to delete advertised networks
input_dict_2 = {
"r1": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"advertise_networks": [
{
"network": "200.0.20.1/32",
"no_of_network": 2,
}
]
}
},
"ipv6": {
"unicast": {
"advertise_networks": [
{"network": "2001::1/128", "no_of_network": 2}
]
}
},
}
}
},
"r4": {
"bgp": {
"address_family": {
"ipv4": {
"unicast": {
"advertise_networks": [
{"network": "200.0.20.1/32", "no_of_network": 2}
]
}
},
"ipv6": {
"unicast": {
"advertise_networks": [
{"network": "2001::1/128", "no_of_network": 2}
]
}
},
}
}
},
}
result = create_router_bgp(tgen, topo, input_dict_2)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
for addr_type in ADDR_TYPES:
# Verifying RIB routes
dut = "r3"
peer1 = "r1"
peer2 = "r4"
intf1 = topo["routers"][peer1]["links"][dut]["interface"]
intf2 = topo["routers"][peer2]["links"][dut]["interface"]
if addr_type == "ipv4":
next_hop_4 = NEXT_HOP_4
result = verify_rib(tgen, addr_type, dut, input_dict_2, next_hop_4)
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result
)
if addr_type == "ipv6":
if "link_local" in PREFERRED_NEXT_HOP:
next_hop1 = get_frr_ipv6_linklocal(tgen, peer1, intf=intf1)
next_hop2 = get_frr_ipv6_linklocal(tgen, peer2, intf=intf2)
next_hop_6 = [next_hop1, next_hop2]
else:
next_hop_6 = NEXT_HOP_6
result = verify_rib(tgen, addr_type, dut, input_dict_2, next_hop_6)
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result
)
logger.info("[Step 3] : Kill BGPd daemon on R1 and R4..")
# Kill BGPd daemon on R1
kill_router_daemons(tgen, "r1", ["bgpd"])
# Kill BGPd daemon on R4
kill_router_daemons(tgen, "r4", ["bgpd"])
for addr_type in ADDR_TYPES:
# Verifying RIB routes
next_hop_6 = ["fd00:0:0:1::1"]
if addr_type == "ipv4":
next_hop_4 = NEXT_HOP_4[0]
result = verify_rib(tgen, addr_type, dut, input_dict_2, next_hop_4)
assert result is True, "Testcase {} : Failed \n Error {}".format(
tc_name, result
)
if addr_type == "ipv6":
if "link_local" in PREFERRED_NEXT_HOP:
next_hop_6 = get_frr_ipv6_linklocal(tgen, peer1, intf=intf1)
else:
next_hop_6 = NEXT_HOP_6[0]
result = verify_rib(tgen, addr_type, dut, input_dict_2, next_hop_6)
# Verifying RIB routes
if addr_type == "ipv4":
next_hop_4 = NEXT_HOP_4[1]
result = verify_rib(
tgen, addr_type, dut, input_dict_2, next_hop_4, expected=False
)
assert result is not True, (
"Testcase {} : Failed \n "
"r3: routes are still present in BGP RIB\n Error: {}".format(
tc_name, result
)
)
logger.info(" Expected behavior: {}".format(result))
if addr_type == "ipv6":
if "link_local" in PREFERRED_NEXT_HOP:
next_hop_6 = get_frr_ipv6_linklocal(tgen, peer2, intf=intf2)
else:
next_hop_6 = NEXT_HOP_6[1]
result = verify_rib(
tgen, addr_type, dut, input_dict_2, next_hop_6, expected=False
)
assert result is not True, (
"Testcase {} : Failed \n "
"r3: routes are still present in ZEBRA\n Error: {}".format(
tc_name, result
)
)
logger.info(" Expected behavior: {}".format(result))
logger.info("[Step 4] : Start BGPd daemon on R1 and R4..")
# Start BGPd daemon on R1
start_router_daemons(tgen, "r1", ["bgpd"])
# Start BGPd daemon on R4
start_router_daemons(tgen, "r4", ["bgpd"])
write_test_footer(tc_name)
def test_bgp_gr_stale_routes(request):
tgen = get_topogen()
tc_name = request.node.name
write_test_header(tc_name)
step("Verify the router failures")
if tgen.routers_have_failure():
check_router_status(tgen)
step("Creating 5 static Routes in Router R3 with NULL0 as Next hop")
for addr_type in ADDR_TYPES:
input_dict_1 = {
"r3": {
"static_routes": [{
"network": [NETWORK1_1[addr_type]] + [NETWORK1_2[addr_type]],
"next_hop": NEXT_HOP_IP[addr_type]
},
{
"network": [NETWORK2_1[addr_type]] + [NETWORK2_2[addr_type]],
"next_hop": NEXT_HOP_IP[addr_type]
},
{
"network": [NETWORK3_1[addr_type]] + [NETWORK3_2[addr_type]],
"next_hop": NEXT_HOP_IP[addr_type]
},
{
"network": [NETWORK4_1[addr_type]] + [NETWORK4_2[addr_type]],
"next_hop": NEXT_HOP_IP[addr_type]
},
{
"network": [NETWORK5_1[addr_type]] + [NETWORK5_2[addr_type]],
"next_hop": NEXT_HOP_IP[addr_type]
}]
}
}
result = create_static_routes(tgen, input_dict_1)
assert result is True, 'Testcase {} : Failed \n Error: {}'.format(
tc_name, result)
step("verifying Created Route at R3 in VRF default")
for addr_type in ADDR_TYPES:
dut = 'r3'
input_dict_1= {'r3': topo['routers']['r3']}
result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1)
assert result is True, \
"Testcase {} :Failed \n Error {}". \
format(tc_name, result)
#done
step("verifying Created Route at R2 in VRF default")
for addr_type in ADDR_TYPES:
dut = 'r2'
input_dict_1= {'r2': topo['routers']['r2']}
result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1)
assert result is True, \
"Testcase {} :Failed \n Error {}". \
format(tc_name, result)
step("importing vrf RED on R2 under Address Family")
for addr_type in ADDR_TYPES:
input_import_vrf={
"r2": {
"bgp": [
{
"local_as": 200,
"vrf": "RED",
"address_family": {addr_type: {"unicast": {"import": {"vrf": "default"}}}},
}
]
}
}
result = create_router_bgp(tgen, topo,input_import_vrf)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
#done
step("verifying static Routes at R2 in VRF RED")
for addr_type in ADDR_TYPES:
dut = 'r2'
input_dict_1= {'r2': topo['routers']['r2']}
result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1)
assert result is True, \
"Testcase {} :Failed \n Error {}". \
format(tc_name, result)
step("verifying static Routes at R1 in VRF RED")
for addr_type in ADDR_TYPES:
dut = 'r1'
input_dict_1= {'r1': topo['routers']['r1']}
result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1)
assert result is True, \
"Testcase {} :Failed \n Error {}". \
format(tc_name, result)
step("Configuring Graceful restart at R2 and R3 ")
input_dict = {
"r2": {
"bgp": {
"local_as": "200",
"graceful-restart": {
"graceful-restart": True,
}
}
},
"r3": {
"bgp": {
"local_as": "300",
"graceful-restart": {
"graceful-restart": True
}
}
}
}
configure_gr_followed_by_clear(tgen, topo, input_dict, tc_name,dut='r2', peer='r3')
step("verify Graceful restart at R2")
for addr_type in ADDR_TYPES:
result = verify_graceful_restart(tgen, topo, addr_type, input_dict,
dut='r2', peer='r3')
assert result is True, \
"Testcase {} :Failed \n Error {}". \
format(tc_name, result)
step("verify Graceful restart at R3")
for addr_type in ADDR_TYPES:
result = verify_graceful_restart(tgen, topo, addr_type, input_dict,
dut='r3', peer='r2')
assert result is True, \
"Testcase {} :Failed \n Error {}". \
format(tc_name, result)
step("Configuring Graceful-restart-disable at R3")
input_dict = {
"r2": {
"bgp": {
"local_as": "200",
"graceful-restart": {
"graceful-restart": False,
}
}
},
"r3": {
"bgp": {
"local_as": "300",
"graceful-restart": {
"graceful-restart": False
}
}
}
}
configure_gr_followed_by_clear(tgen, topo, input_dict, tc_name,dut='r3', peer='r2')
step("Verify Graceful-restart-disable at R3")
for addr_type in ADDR_TYPES:
result = verify_graceful_restart(tgen, topo, addr_type, input_dict,
dut='r3', peer='r2')
assert result is True, \
"Testcase {} :Failed \n Error {}". \
format(tc_name, result)
for iteration in range(5):
step("graceful-restart-disable:True at R3")
input_dict = {
"r3": {
"bgp": {
"graceful-restart": {
"graceful-restart-disable": True,
}
}
}
}
configure_gr_followed_by_clear(tgen, topo, input_dict, tc_name,
dut='r3', peer='r2')
step("Verifying Routes at R2 on enabling GRD")
dut = 'r2'
for addr_type in ADDR_TYPES:
input_dict_1= {'r2': topo['routers']['r2']}
result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1)
assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
step("Verify stale Routes in Router R2 enabling GRD")
for addr_type in ADDR_TYPES:
dut = "r2"
protocol = "bgp"
verify_nh_for_static_rtes = {
"r3": {
"static_routes": [
{
"network": [NETWORK1_1[addr_type]],
"no_of_ip": 2,
"vrf": "RED"
}
]
}
}
bgp_rib_next_hops = verify_stale_routes_list(
tgen, addr_type, dut, verify_nh_for_static_rtes)
assert (len(bgp_rib_next_hops)== 1) is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, bgp_rib_next_hops,expected=True)
step("graceful-restart-disable:False at R3")
input_dict = {
"r3": {
"bgp": {
"graceful-restart": {
"graceful-restart-disable": False,
}
}
}
}
configure_gr_followed_by_clear(tgen, topo, input_dict, tc_name,
dut='r3', peer='r2')
step("Verifying Routes at R2 on disabling GRD")
dut = 'r2'
for addr_type in ADDR_TYPES:
input_dict_1= {'r2': topo['routers']['r2']}
result = verify_bgp_rib(tgen, addr_type, dut, input_dict_1)
assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
step("Verify stale Routes in Router R2 on disabling GRD")
for addr_type in ADDR_TYPES:
dut = "r2"
protocol = "bgp"
verify_nh_for_static_rtes = {
"r3": {
"static_routes": [
{
"network": [NETWORK1_1[addr_type]],
"no_of_ip": 2,
"vrf": "RED"
}
]
}
}
bgp_rib_next_hops = verify_stale_routes_list(tgen, addr_type, dut, verify_nh_for_static_rtes)
stale_route_status=len(bgp_rib_next_hops)== 1
assert stale_route_status is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, stale_route_status,expected=True)
write_test_footer(tc_name)