tests/topotests/multicast_pim_bsm_topo2/test_mcast_pim_bsmp_02.py

   1 #!/usr/bin/env python
   2 # SPDX-License-Identifier: ISC
   3 #
   4 # Copyright (c) 2020 by VMware, Inc. ("VMware")
   5 # Used Copyright (c) 2018 by Network Device Education Foundation,
   6 # Inc. ("NetDEF") in this file.
   7 #
   8
   9 """
  10 Following tests are covered to test PIM BSM processing basic functionality:
  11
  12 Test steps
  13 - Create topology (setup module)
  14 - Bring up topology
  15
  16 Tests covered in this suite
  17 1. Verify (*,G) mroute detail on FRR router after BSM rp installed
  18 2. Verify group to RP updated correctly on FRR router, when BSR advertising
  19     the overlapping group address
  20 3. Verify group to RP info is updated correctly, when BSR advertising the
  21     same RP with different priority
  22 4. Verify group to RP mapping in FRR node when 2 BSR are present in the network
  23     and both are having same BSR priority
  24 5. Verify RP is selected based on hash function, when BSR advertising the group
  25     to RP mapping with same priority
  26 6. Verify fragmentation of bootstrap message
  27 7. Verify when candidate RP advertised with 32 mask length
  28     and contain all the contacts
  29 """
  30
  31 import os
  32 import sys
  33 import time
  34 import pytest
  35
  36 # Save the Current Working Directory to find configuration files.
  37 CWD = os.path.dirname(os.path.realpath(__file__))
  38 sys.path.append(os.path.join(CWD, "../"))
  39 sys.path.append(os.path.join(CWD, "../lib/"))
  40
  41 # Required to instantiate the topology builder class.
  42
  43 # pylint: disable=C0413
  44 # Import topogen and topotest helpers
  45 from lib.topogen import Topogen, get_topogen
  46
  47 from lib.common_config import (
  48     start_topology,
  49     write_test_header,
  50     write_test_footer,
  51     step,
  52     addKernelRoute,
  53     create_static_routes,
  54     reset_config_on_routers,
  55     run_frr_cmd,
  56     required_linux_kernel_version,
  57     verify_rib,
  58 )
  59
  60 from lib.pim import (
  61     add_rp_interfaces_and_pim_config,
  62     reconfig_interfaces,
  63     scapy_send_bsr_raw_packet,
  64     find_rp_from_bsrp_info,
  65     verify_pim_grp_rp_source,
  66     verify_pim_bsr,
  67     verify_mroutes,
  68     verify_join_state_and_timer,
  69     verify_pim_state,
  70     verify_upstream_iif,
  71     verify_igmp_groups,
  72     verify_pim_upstream_rpf,
  73     clear_mroute,
  74     clear_pim_interface_traffic,
  75     McastTesterHelper,
  76     verify_pim_neighbors,
  77 )
  78 from lib.topolog import logger
  79 from lib.topojson import build_config_from_json
  80
  81 pytestmark = [pytest.mark.pimd, pytest.mark.staticd]
  82
  83
  84 TOPOLOGY = """
  85
  86       b1_____
  87              |
  88              |
  89       s1-----f1-----i1-----l1----r1
  90              |
  91        ______|
  92       b2
  93
  94       b1 - BSR 1
  95       b2 - BSR 2
  96       s1 - Source
  97       f1 - FHR
  98       i1 - Intermediate Router (also RP)
  99       r1 - Receiver
 100
 101 """
 102 # Global variables
 103 NEXT_HOP1 = "70.0.0.1"
 104 NEXT_HOP2 = "65.0.0.1"
 105 BSR_IP_1 = "1.1.2.7"
 106 BSR_IP_2 = "10.2.1.1"
 107 BSR1_ADDR = "1.1.2.7/32"
 108 BSR2_ADDR = "10.2.1.1/32"
 109
 110
 111 def setup_module(mod):
 112     """
 113     Sets up the pytest environment
 114
 115     * `mod`: module name
 116     """
 117
 118     # Required linux kernel version for this suite to run.
 119     result = required_linux_kernel_version("4.15")
 120     if result is not True:
 121         pytest.skip("Kernel version should be >= 4.15")
 122
 123     testsuite_run_time = time.asctime(time.localtime(time.time()))
 124     logger.info("Testsuite start time: {}".format(testsuite_run_time))
 125     logger.info("=" * 40)
 126     logger.info("Master Topology: \n {}".format(TOPOLOGY))
 127
 128     logger.info("Running setup_module to create topology")
 129
 130     # This function initiates the topology build with Topogen...
 131     json_file = "{}/mcast_pim_bsmp_02.json".format(CWD)
 132     tgen = Topogen(json_file, mod.__name__)
 133     global topo
 134     topo = tgen.json_topo
 135     # ... and here it calls Mininet initialization functions.
 136
 137     # Starting topology, create tmp files which are loaded to routers
 138     #  to start daemons and then start routers
 139     start_topology(tgen)
 140
 141     # Don"t run this test if we have any failure.
 142     if tgen.routers_have_failure():
 143         pytest.skip(tgen.errors)
 144
 145     # Creating configuration from JSON
 146     build_config_from_json(tgen, topo)
 147
 148     # Verify PIM neighbors
 149     result = verify_pim_neighbors(tgen, topo)
 150     assert result is True, " Verify PIM neighbor: Failed Error: {}".format(result)
 151
 152     # XXX Replace this using "with McastTesterHelper()... " in each test if possible.
 153     global app_helper
 154     app_helper = McastTesterHelper(tgen)
 155
 156     logger.info("Running setup_module() done")
 157
 158
 159 def teardown_module():
 160     """Teardown the pytest environment"""
 161
 162     logger.info("Running teardown_module to delete topology")
 163
 164     tgen = get_topogen()
 165
 166     app_helper.cleanup()
 167
 168     # Stop toplogy and Remove tmp files
 169     tgen.stop_topology()
 170
 171     logger.info(
 172         "Testsuite end time: {}".format(time.asctime(time.localtime(time.time())))
 173     )
 174     logger.info("=" * 40)
 175
 176
 177 #####################################################
 178 #
 179 #   Local APIs
 180 #
 181 #####################################################
 182
 183
 184 def clear_bsrp_data(tgen, topo):
 185
 186     """
 187     clear bsm databas after test"
 188     Parameters
 189     ----------
 190     * `tgen`: topogen object
 191
 192     Usage
 193     -----
 194     result = clear_bsrp_data(tgen, topo)
 195     Returns
 196     -------
 197     errormsg(str) or True
 198     """
 199
 200     for dut in tgen.routers():
 201
 202         rnode = tgen.routers()[dut]
 203
 204         logger.info("[DUT: %s]: clear_bsrp_data")
 205
 206         run_frr_cmd(rnode, "clear ip pim bsr-data")
 207
 208     return True
 209
 210
 211 def pre_config_to_bsm(tgen, topo, tc_name, bsr, sender, receiver, fhr, rp, lhr, packet):
 212     """
 213     API to do required configuration to send and receive BSR packet
 214     """
 215
 216     # Re-configure interfaces as per BSR packet
 217     result = reconfig_interfaces(tgen, topo, bsr, fhr, packet)
 218     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 219
 220     # Create static routes
 221     if "bsr" in topo["routers"][bsr]["bsm"]["bsr_packets"][packet]:
 222         bsr_route = topo["routers"][bsr]["bsm"]["bsr_packets"][packet]["bsr"]
 223         next_hop = topo["routers"][bsr]["bsm"]["bsr_packets"][packet]["src_ip"].split(
 224             "/"
 225         )[0]
 226         next_hop_rp = topo["routers"][fhr]["links"][rp]["ipv4"].split("/")[0]
 227         next_hop_lhr = topo["routers"][rp]["links"][lhr]["ipv4"].split("/")[0]
 228
 229         # Add static routes
 230         input_dict = {
 231             rp: {"static_routes": [{"network": bsr_route, "next_hop": next_hop_rp}]},
 232             lhr: {"static_routes": [{"network": bsr_route, "next_hop": next_hop_lhr}]},
 233         }
 234
 235         result = create_static_routes(tgen, input_dict)
 236         assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 237
 238         # Verifying static routes are installed
 239         for dut, _nexthop in zip([rp, lhr], [next_hop_rp, next_hop_lhr]):
 240             input_routes = {dut: input_dict[dut]}
 241             result = verify_rib(
 242                 tgen, "ipv4", dut, input_routes, _nexthop, protocol="static"
 243             )
 244             assert result is True, "Testcase {} : Failed \n Error {}".format(
 245                 tc_name, result
 246             )
 247
 248     # Add kernel route for source
 249     group = topo["routers"][bsr]["bsm"]["bsr_packets"][packet]["pkt_dst"]
 250     bsr_interface = topo["routers"][bsr]["links"][fhr]["interface"]
 251     result = addKernelRoute(tgen, bsr, bsr_interface, group)
 252     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 253
 254     # RP Mapping
 255     rp_mapping = topo["routers"][bsr]["bsm"]["bsr_packets"][packet]["rp_mapping"]
 256
 257     # Add interfaces in RP for all the RPs
 258     result = add_rp_interfaces_and_pim_config(tgen, topo, "lo", rp, rp_mapping)
 259     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 260
 261     # Add kernel routes to sender and receiver
 262     for group, rp_list in rp_mapping.items():
 263         mask = group.split("/")[1]
 264         if int(mask) == 32:
 265             group = group.split("/")[0]
 266
 267         # Add kernel routes for sender
 268         s_interface = topo["routers"][sender]["links"][fhr]["interface"]
 269         result = addKernelRoute(tgen, sender, s_interface, group)
 270         assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 271
 272         # Add kernel routes for receiver
 273         r_interface = topo["routers"][receiver]["links"][lhr]["interface"]
 274         result = addKernelRoute(tgen, receiver, r_interface, group)
 275         assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 276
 277         # Add static routes for RPs in FHR and LHR
 278         next_hop_fhr = topo["routers"][rp]["links"][fhr]["ipv4"].split("/")[0]
 279         next_hop_lhr = topo["routers"][rp]["links"][lhr]["ipv4"].split("/")[0]
 280         input_dict = {
 281             fhr: {"static_routes": [{"network": rp_list, "next_hop": next_hop_fhr}]},
 282         }
 283         result = create_static_routes(tgen, input_dict)
 284         assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 285
 286         # Verifying static routes are installed
 287         result = verify_rib(
 288             tgen, "ipv4", fhr, input_dict, next_hop_fhr, protocol="static"
 289         )
 290         assert result is True, "Testcase {} : Failed \n Error {}".format(
 291             tc_name, result
 292         )
 293
 294         input_dict = {
 295             lhr: {"static_routes": [{"network": rp_list, "next_hop": next_hop_lhr}]},
 296         }
 297         result = create_static_routes(tgen, input_dict)
 298         assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 299
 300         # Verifying static routes are installed
 301         result = verify_rib(
 302             tgen, "ipv4", lhr, input_dict, next_hop_lhr, protocol="static"
 303         )
 304         assert result is True, "Testcase {} : Failed \n Error {}".format(
 305             tc_name, result
 306         )
 307
 308     return True
 309
 310
 311 #####################################################
 312 #
 313 #   Testcases
 314 #
 315 #####################################################
 316
 317
 318 def test_starg_mroute_p0(request):
 319     """
 320     1. Verify (*,G) mroute detail on FRR router after BSM rp installed
 321
 322     Topology used:
 323       b1_____
 324              |
 325              |
 326       s1-----f1-----i1-----l1----r1
 327              |
 328        ______|
 329       b2
 330
 331       b1 - BSR 1
 332       b2 - BSR 2
 333       s1 - Source
 334       f1 - FHR
 335       i1 - Intermediate Router (also RP)
 336       r1 - Receiver
 337
 338     """
 339
 340     tgen = get_topogen()
 341     tc_name = request.node.name
 342     write_test_header(tc_name)
 343
 344     # Don"t run this test if we have any failure.
 345     if tgen.routers_have_failure():
 346         pytest.skip(tgen.errors)
 347
 348     app_helper.stop_all_hosts()
 349     clear_mroute(tgen)
 350     reset_config_on_routers(tgen)
 351     clear_pim_interface_traffic(tgen, topo)
 352
 353     result = pre_config_to_bsm(
 354         tgen, topo, tc_name, "b1", "s1", "r1", "f1", "i1", "l1", "packet1"
 355     )
 356     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 357
 358     result = pre_config_to_bsm(
 359         tgen, topo, tc_name, "b2", "s1", "r1", "f1", "i1", "l1", "packet1"
 360     )
 361     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 362
 363     GROUP_ADDRESS = "226.1.1.1"
 364
 365     # Use scapy to send pre-defined packet from senser to receiver
 366     result = scapy_send_bsr_raw_packet(tgen, topo, "b1", "f1", "packet1")
 367     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 368
 369     bsr_ip = topo["routers"]["b1"]["bsm"]["bsr_packets"]["packet1"]["bsr"].split("/")[0]
 370     time.sleep(1)
 371
 372     result = app_helper.run_join("r1", GROUP_ADDRESS, "l1")
 373     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 374
 375     # Verify bsr state in FHR
 376     result = verify_pim_bsr(tgen, topo, "f1", bsr_ip)
 377     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 378
 379     # Check igmp groups
 380     step("Verify IGMP groups in LHR l1")
 381     dut = "l1"
 382     intf = "l1-r1-eth1"
 383     result = verify_igmp_groups(tgen, dut, intf, GROUP_ADDRESS)
 384     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 385
 386     group = "226.1.1.1/32"
 387     src_addr = "*"
 388
 389     # Find the elected rp from bsrp-info
 390     step("Find the elected rp from bsrp-info in LHR in l1")
 391     rp = find_rp_from_bsrp_info(tgen, dut, bsr_ip, group)
 392     assert rp is not {}, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 393
 394     # Check RP detail in LHR
 395     step("Verify RP in LHR in l1")
 396     result = verify_pim_grp_rp_source(tgen, topo, dut, group, "BSR", rp[group])
 397     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 398
 399     # Verify join state and join timer
 400     step("Verify join state and join timer in l1")
 401     iif = "l1-i1-eth0"
 402     result = verify_join_state_and_timer(tgen, dut, iif, src_addr, GROUP_ADDRESS)
 403     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 404
 405     # Verify upstream IIF interface
 406     step("Verify upstream IIF interface in l1")
 407     result = verify_upstream_iif(tgen, dut, iif, src_addr, GROUP_ADDRESS)
 408     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 409
 410     # Verify IIF/OIL in pim state
 411     oil = "l1-r1-eth1"
 412     result = verify_pim_state(tgen, dut, iif, oil, GROUP_ADDRESS)
 413     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 414
 415     # Verify ip mroute
 416     step("Verify ip mroute in l1")
 417     src_addr = "*"
 418     result = verify_mroutes(tgen, dut, src_addr, GROUP_ADDRESS, iif, oil)
 419     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 420
 421     # Remove the group rp mapping and send bsm
 422     step("Remove the grp-rp mapping by sending bsm with hold time 0 for grp-rp")
 423     result = scapy_send_bsr_raw_packet(tgen, topo, "b1", "f1", "packet2")
 424     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 425
 426     # Check RP unreachable
 427     step("Check RP unreachability in l1")
 428     iif = "Unknown"
 429     result = verify_upstream_iif(
 430         tgen, dut, iif, src_addr, GROUP_ADDRESS, joinState="NotJoined"
 431     )
 432     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 433
 434     # Verify that it is not installed
 435     step("Verify that iif is not installed in l1")
 436     iif = "<iif?>"
 437     result = verify_pim_state(tgen, dut, iif, oil, GROUP_ADDRESS, installed_fl=0)
 438     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 439
 440     # Verify mroute not installed
 441     step("Verify mroute not installed in l1")
 442     result = verify_mroutes(
 443         tgen, dut, src_addr, GROUP_ADDRESS, iif, oil, retry_timeout=20, expected=False
 444     )
 445     assert result is not True, (
 446         "Testcase {} : Failed \n "
 447         "Expected: [{}]: mroute (S, G) should not be installed \n "
 448         "Found: {}".format(tc_name, dut, result)
 449     )
 450
 451     # Send BSM again to configure rp
 452     step("Add back RP by sending BSM from b1")
 453     result = scapy_send_bsr_raw_packet(tgen, topo, "b1", "f1", "packet1")
 454     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 455
 456     # Verify that (*,G) installed in mroute again
 457     iif = "l1-i1-eth0"
 458     result = verify_mroutes(tgen, dut, src_addr, GROUP_ADDRESS, iif, oil)
 459     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 460
 461     step("clear  BSM database before moving to next case")
 462     clear_bsrp_data(tgen, topo)
 463
 464     write_test_footer(tc_name)
 465
 466
 467 def test_overlapping_group_p0(request):
 468     """
 469     Verify group to RP updated correctly on FRR router, when BSR advertising
 470     the overlapping group address
 471
 472     Topology used:
 473       b1_____
 474              |
 475              |
 476       s1-----f1-----i1-----l1----r1
 477              |
 478        ______|
 479       b2
 480
 481       b1 - BSR 1
 482       b2 - BSR 2
 483       s1 - Source
 484       f1 - FHR
 485       i1 - Intermediate Router (also RP)
 486       r1 - Receiver
 487
 488     """
 489
 490     tgen = get_topogen()
 491     tc_name = request.node.name
 492     write_test_header(tc_name)
 493
 494     # Don"t run this test if we have any failure.
 495     if tgen.routers_have_failure():
 496         pytest.skip(tgen.errors)
 497
 498     app_helper.stop_all_hosts()
 499     clear_mroute(tgen)
 500     reset_config_on_routers(tgen)
 501     clear_pim_interface_traffic(tgen, topo)
 502
 503     result = pre_config_to_bsm(
 504         tgen, topo, tc_name, "b1", "s1", "r1", "f1", "i1", "l1", "packet1"
 505     )
 506     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 507
 508     result = pre_config_to_bsm(
 509         tgen, topo, tc_name, "b2", "s1", "r1", "f1", "i1", "l1", "packet1"
 510     )
 511     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 512
 513     GROUP_ADDRESS = "225.1.1.1"
 514
 515     # Use scapy to send pre-defined packet from senser to receiver
 516     step("Send BSR packet from b1 to FHR")
 517     result = scapy_send_bsr_raw_packet(tgen, topo, "b1", "f1", "packet4")
 518     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 519
 520     bsr_ip = topo["routers"]["b1"]["bsm"]["bsr_packets"]["packet1"]["bsr"].split("/")[0]
 521     time.sleep(1)
 522
 523     result = app_helper.run_join("r1", GROUP_ADDRESS, "l1")
 524     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 525
 526     # Verify bsr state in FHR
 527     step("Verify if b1 is chosen as bsr in f1")
 528     result = verify_pim_bsr(tgen, topo, "f1", bsr_ip)
 529     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 530
 531     dut = "l1"
 532     group1 = "225.1.1.1/32"
 533     # Find the elected rp from bsrp-info fro group 225.1.1.1/32
 534     step("Find the elected rp from bsrp-info in LHR for 225.1.1.1/32")
 535     rp1 = find_rp_from_bsrp_info(tgen, dut, bsr_ip, group1)
 536     assert rp1 is not {}, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 537
 538     group2 = "225.1.1.0/24"
 539     # Find the elected rp from bsrp-info fro group 225.1.1.0/24
 540     step("Find the elected rp from bsrp-info in LHR for 225.1.1.0/24")
 541     rp2 = find_rp_from_bsrp_info(tgen, dut, bsr_ip, group2)
 542     assert rp2 is not {}, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 543
 544     iif = "l1-i1-eth0"
 545     # Verify upstream rpf for 225.1.1.1 is chosen as rp1
 546     step("Verify upstream rpf for 225.1.1.1 is chosen as rp1 in l1")
 547     result = verify_pim_upstream_rpf(tgen, topo, dut, iif, GROUP_ADDRESS, rp1)
 548     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 549
 550     # Send BSR packet from b1 with rp for 225.1.1.1/32 removed
 551     step("Send BSR packet from b1 with rp for 225.1.1.1/32 removed")
 552     result = scapy_send_bsr_raw_packet(tgen, topo, "b1", "f1", "packet5")
 553     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 554
 555     # Verify upstream rpf for 225.1.1.1 is chosen as rp1
 556     step("Verify upstream rpf for 225.1.1.1 is chosen as rp2 in l1")
 557     result = verify_pim_upstream_rpf(tgen, topo, dut, iif, GROUP_ADDRESS, rp2)
 558     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 559
 560     # Verify IIF/OIL in pim state
 561     step("Verify iif is installed after rp change in l1")
 562     oil = "l1-r1-eth1"
 563     result = verify_pim_state(tgen, dut, iif, oil, GROUP_ADDRESS)
 564     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 565
 566     step("clear  BSM database before moving to next case")
 567     clear_bsrp_data(tgen, topo)
 568
 569     write_test_footer(tc_name)
 570
 571
 572 def test_RP_priority_p0(request):
 573     """
 574     Verify group to RP info is updated correctly, when BSR advertising the
 575     same RP with different priority
 576
 577     Topology used:
 578       b1_____
 579              |
 580              |
 581       s1-----f1-----i1-----l1----r1
 582              |
 583        ______|
 584       b2
 585
 586       b1 - BSR 1
 587       b2 - BSR 2
 588       s1 - Source
 589       f1 - FHR
 590       i1 - Intermediate Router (also RP)
 591       r1 - Receiver
 592     """
 593
 594     tgen = get_topogen()
 595     tc_name = request.node.name
 596     write_test_header(tc_name)
 597
 598     # Don"t run this test if we have any failure.
 599     if tgen.routers_have_failure():
 600         pytest.skip(tgen.errors)
 601
 602     app_helper.stop_all_hosts()
 603     clear_mroute(tgen)
 604     reset_config_on_routers(tgen)
 605     clear_pim_interface_traffic(tgen, topo)
 606
 607     result = pre_config_to_bsm(
 608         tgen, topo, tc_name, "b1", "s1", "r1", "f1", "i1", "l1", "packet1"
 609     )
 610     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 611
 612     result = pre_config_to_bsm(
 613         tgen, topo, tc_name, "b2", "s1", "r1", "f1", "i1", "l1", "packet1"
 614     )
 615     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 616
 617     GROUP_ADDRESS = "225.1.1.1"
 618
 619     # Use scapy to send pre-defined packet from senser to receiver
 620     step("Send BSR packet from b1 to FHR")
 621     result = scapy_send_bsr_raw_packet(tgen, topo, "b1", "f1", "packet1")
 622     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 623
 624     bsr_ip = topo["routers"]["b1"]["bsm"]["bsr_packets"]["packet1"]["bsr"].split("/")[0]
 625     time.sleep(1)
 626
 627     result = app_helper.run_join("r1", GROUP_ADDRESS, "l1")
 628     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 629
 630     # Verify bsr state in FHR
 631     step("Verify if b1 is chosen as bsr in f1")
 632     result = verify_pim_bsr(tgen, topo, "f1", bsr_ip)
 633     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 634
 635     dut = "l1"
 636     group = "225.1.1.0/24"
 637     # Find the elected rp from bsrp-info
 638     step("Find the elected rp from bsrp-info in LHR l1")
 639     rp1 = find_rp_from_bsrp_info(tgen, dut, bsr_ip, group)
 640     assert rp1 is not {}, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 641
 642     # Check RP detail in LHR
 643     step("Verify RP in LHR l1")
 644     result = verify_pim_grp_rp_source(tgen, topo, dut, group, "BSR", rp1[group])
 645     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 646
 647     # Send BSR packet from b1 after deleting high prio rp for 225.1.1.0/24
 648     step("Send BSM from b1 to FHR deleting high prio rp for 225.1.1.0/24")
 649     result = scapy_send_bsr_raw_packet(tgen, topo, "b1", "f1", "packet6")
 650     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 651
 652     # Find the elected rp from bsrp-info
 653     step("Find the elected rp from bsrp-info in LHR l1")
 654     rp2 = find_rp_from_bsrp_info(tgen, dut, bsr_ip, group)
 655     assert rp2 is not {}, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 656     logger.info("RP old: {} RP2 new: {} ".format(rp1[group], rp2[group]))
 657
 658     # Verify is the rp is different now
 659     assert rp1[group] != rp2[group], "Testcase {} :Failed \n Error {}".format(
 660         tc_name, result
 661     )
 662
 663     rp_add1 = rp1[group]
 664     rp_add2 = rp2[group]
 665
 666     # Verify if that rp is installed
 667     step("Verify new RP in LHR installed")
 668     result = verify_pim_grp_rp_source(tgen, topo, dut, group, "BSR", rp_add2)
 669     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 670
 671     # Send BSR packet from b1 after putting back high prio rp for 225.1.1.0/24
 672     step("Send BSM from b1 to FHR put back old high prio rp for 225.1.1.0/24")
 673     result = scapy_send_bsr_raw_packet(tgen, topo, "b1", "f1", "packet1")
 674     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 675
 676     # Find the elected rp from bsrp-info
 677     step("Find the elected rp from bsrp-info in LHR")
 678     rp2 = find_rp_from_bsrp_info(tgen, dut, bsr_ip, group)
 679     assert rp2 is not {}, "Testcase {} :Failed \n Error : RP not Found".format(tc_name)
 680
 681     # Verify is the rp is different now
 682     step("Verify now old RP is elected again")
 683     assert (
 684         rp_add1 == rp2[group]
 685     ), "Testcase {} :Failed \n Error : rp expected {} rp received {}".format(
 686         tc_name, rp_add1, rp2[group] if group in rp2 else None
 687     )
 688
 689     # Verify if that rp is installed
 690     step("Verify new RP in LHR installed")
 691     result = verify_pim_grp_rp_source(tgen, topo, dut, group, "BSR", rp_add1)
 692     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 693
 694     step("clear  BSM database before moving to next case")
 695     clear_bsrp_data(tgen, topo)
 696
 697     write_test_footer(tc_name)
 698
 699
 700 def test_BSR_election_p0(request):
 701     """
 702     Verify group to RP mapping in FRR node when 2 BSR are present in the network
 703     and both are having same BSR priority
 704
 705     Topology used:
 706       b1_____
 707              |
 708              |
 709       s1-----f1-----i1-----l1----r1
 710              |
 711        ______|
 712       b2
 713
 714       b1 - BSR 1
 715       b2 - BSR 2
 716       s1 - Source
 717       f1 - FHR
 718       i1 - Intermediate Router (also RP)
 719       r1 - Receiver
 720
 721     """
 722
 723     tgen = get_topogen()
 724     tc_name = request.node.name
 725     write_test_header(tc_name)
 726
 727     app_helper.stop_all_hosts()
 728     clear_mroute(tgen)
 729     reset_config_on_routers(tgen)
 730     clear_pim_interface_traffic(tgen, topo)
 731
 732     # Don"t run this test if we have any failure.
 733     if tgen.routers_have_failure():
 734         pytest.skip(tgen.errors)
 735
 736     result = pre_config_to_bsm(
 737         tgen, topo, tc_name, "b1", "s1", "r1", "f1", "i1", "l1", "packet1"
 738     )
 739     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 740
 741     result = pre_config_to_bsm(
 742         tgen, topo, tc_name, "b2", "s1", "r1", "f1", "i1", "l1", "packet1"
 743     )
 744     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 745
 746     GROUP_ADDRESS = "225.1.1.1"
 747
 748     # Use scapy to send pre-defined packet from senser to receiver
 749     step("Send BSR packet from b1 to FHR")
 750     result = scapy_send_bsr_raw_packet(tgen, topo, "b1", "f1", "packet3")
 751     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 752
 753     bsr_ip1 = topo["routers"]["b1"]["bsm"]["bsr_packets"]["packet1"]["bsr"].split("/")[
 754         0
 755     ]
 756     time.sleep(1)
 757
 758     result = app_helper.run_join("r1", GROUP_ADDRESS, "l1")
 759     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 760
 761     # Verify bsr state in FHR
 762     step("Verify if b1 is chosen as bsr in f1")
 763     result = verify_pim_bsr(tgen, topo, "f1", bsr_ip1)
 764     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 765
 766     dut = "l1"
 767     group = "225.1.1.0/24"
 768     # Find the elected rp from bsrp-info
 769     step("Find the elected rp from bsrp-info in LHR in l1")
 770     rp = find_rp_from_bsrp_info(tgen, dut, bsr_ip1, group)
 771     assert rp is not {}, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 772
 773     # Check RP detail in LHR
 774     step("Verify RP in LHR l1")
 775     result = verify_pim_grp_rp_source(tgen, topo, dut, group, "BSR", rp[group])
 776     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 777
 778     # Send BSR packet from b2 with same priority
 779     step("Send BSR packet from b2 to FHR with same priority")
 780     result = scapy_send_bsr_raw_packet(tgen, topo, "b2", "f1", "packet1")
 781     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 782
 783     bsr_ip2 = topo["routers"]["b2"]["bsm"]["bsr_packets"]["packet2"]["bsr"].split("/")[
 784         0
 785     ]
 786     time.sleep(1)
 787
 788     logger.info("BSR b1:" + bsr_ip1 + " BSR b2:" + bsr_ip2)
 789     # Verify bsr state in FHR
 790     step("Verify if b2 is not chosen as bsr in f1")
 791     result = verify_pim_bsr(tgen, topo, "f1", bsr_ip2, expected=False)
 792     assert result is not True, (
 793         "Testcase {} : Failed \n "
 794         "Expected: [{}]: b2 should not be chosen as bsr \n "
 795         "Found: {}".format(tc_name, "f1", result)
 796     )
 797
 798     # Verify if b1 is still chosen as bsr
 799     step("Verify if b1 is still chosen as bsr in f1")
 800     result = verify_pim_bsr(tgen, topo, "f1", bsr_ip1)
 801     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 802
 803     # Verify if that rp is installed
 804     step("Verify that same RP in istalled in LHR l1")
 805     result = verify_pim_grp_rp_source(tgen, topo, dut, group, "BSR", rp[group])
 806     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 807
 808     step("clear  BSM database before moving to next case")
 809     clear_bsrp_data(tgen, topo)
 810
 811     write_test_footer(tc_name)
 812
 813
 814 def test_RP_hash_p0(request):
 815     """
 816     Verify RP is selected based on hash function, when BSR advertising the group
 817     to RP mapping with same priority
 818
 819     Topology used:
 820       b1_____
 821              |
 822              |
 823       s1-----f1-----i1-----l1----r1
 824              |
 825        ______|
 826       b2
 827
 828       b1 - BSR 1
 829       b2 - BSR 2
 830       s1 - Source
 831       f1 - FHR
 832       i1 - Intermediate Router (also RP)
 833       r1 - Receiver
 834
 835     """
 836
 837     tgen = get_topogen()
 838     tc_name = request.node.name
 839     write_test_header(tc_name)
 840
 841     # Don"t run this test if we have any failure.
 842     if tgen.routers_have_failure():
 843         pytest.skip(tgen.errors)
 844
 845     app_helper.stop_all_hosts()
 846     clear_mroute(tgen)
 847     reset_config_on_routers(tgen)
 848     clear_pim_interface_traffic(tgen, topo)
 849
 850     result = pre_config_to_bsm(
 851         tgen, topo, tc_name, "b1", "s1", "r1", "f1", "i1", "l1", "packet1"
 852     )
 853     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 854
 855     result = pre_config_to_bsm(
 856         tgen, topo, tc_name, "b2", "s1", "r1", "f1", "i1", "l1", "packet1"
 857     )
 858     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 859
 860     GROUP_ADDRESS = "225.1.1.1"
 861
 862     # Use scapy to send pre-defined packet from senser to receiver
 863     result = scapy_send_bsr_raw_packet(tgen, topo, "b1", "f1", "packet7")
 864     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 865
 866     bsr_ip = topo["routers"]["b1"]["bsm"]["bsr_packets"]["packet1"]["bsr"].split("/")[0]
 867     time.sleep(1)
 868
 869     result = app_helper.run_join("r1", GROUP_ADDRESS, "l1")
 870     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 871
 872     dut = "l1"
 873
 874     # Verify bsr state in FHR
 875     step("Verify if b1 chosen as BSR in f1")
 876     result = verify_pim_bsr(tgen, topo, "f1", bsr_ip)
 877     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 878
 879     group = "225.1.1.0/24"
 880
 881     # Find the elected rp from bsrp-info
 882     step("Find the elected rp from bsrp-info in LHR l1")
 883     rp = find_rp_from_bsrp_info(tgen, dut, bsr_ip, group)
 884     assert rp is not {}, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 885
 886     # Verify if RP with highest hash value is chosen
 887     step("Verify if RP(2.2.2.2) with highest hash value is chosen in l1")
 888     if rp[group] == "2.2.2.2":
 889         result = True
 890     else:
 891         result = "rp expected: 2.2.2.2 got:" + rp[group]
 892
 893     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 894
 895     # Check RP detail in LHR
 896     step("Verify RP in LHR")
 897     result = verify_pim_grp_rp_source(tgen, topo, dut, group, "BSR", rp[group])
 898     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 899
 900     step("clear  BSM database before moving to next case")
 901     clear_bsrp_data(tgen, topo)
 902
 903     write_test_footer(tc_name)
 904
 905
 906 def test_BSM_fragmentation_p1(request):
 907     """
 908     Verify fragmentation of bootstrap message
 909
 910     Topology used:
 911       b1_____
 912              |
 913              |
 914       s1-----f1-----i1-----l1----r1
 915              |
 916        ______|
 917       b2
 918
 919       b1 - BSR 1
 920       b2 - BSR 2
 921       s1 - Source
 922       f1 - FHR
 923       i1 - Intermediate Router (also RP)
 924       r1 - Receiver
 925
 926     """
 927
 928     tgen = get_topogen()
 929     tc_name = request.node.name
 930     write_test_header(tc_name)
 931
 932     # Don"t run this test if we have any failure.
 933     if tgen.routers_have_failure():
 934         pytest.skip(tgen.errors)
 935
 936     app_helper.stop_all_hosts()
 937     clear_mroute(tgen)
 938     reset_config_on_routers(tgen)
 939     clear_pim_interface_traffic(tgen, topo)
 940
 941     result = pre_config_to_bsm(
 942         tgen, topo, tc_name, "b1", "s1", "r1", "f1", "i1", "l1", "packet1"
 943     )
 944     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 945
 946     result = pre_config_to_bsm(
 947         tgen, topo, tc_name, "b2", "s1", "r1", "f1", "i1", "l1", "packet1"
 948     )
 949     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 950
 951     GROUP_ADDRESS = "225.1.1.1"
 952
 953     bsr_ip = topo["routers"]["b1"]["bsm"]["bsr_packets"]["packet1"]["bsr"].split("/")[0]
 954
 955     step("Send BSM and verify if all routers have same bsrp before fragment")
 956     result = scapy_send_bsr_raw_packet(tgen, topo, "b1", "f1", "packet1")
 957     # Verify bsr state in FHR
 958     step("Verify if b1 chosen as BSR in f1")
 959     result = verify_pim_bsr(tgen, topo, "f1", bsr_ip)
 960     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 961
 962     fhr_node = tgen.routers()["f1"]
 963     inter_node = tgen.routers()["i1"]
 964     lhr_node = tgen.routers()["l1"]
 965
 966     # Verify if bsrp list is same across f1, i1 and l1
 967     step("Verify if bsrp list is same across f1, i1 and l1")
 968     bsrp_f1 = fhr_node.vtysh_cmd("show ip pim bsrp-info json", isjson=True)
 969     logger.info("show_ip_pim_bsrp_info_json f1: \n %s", bsrp_f1)
 970     bsrp_i1 = inter_node.vtysh_cmd("show ip pim bsrp-info json", isjson=True)
 971     logger.info("show_ip_pim_bsrp_info_json i1: \n %s", bsrp_i1)
 972     bsrp_l1 = lhr_node.vtysh_cmd("show ip pim bsrp-info json", isjson=True)
 973     logger.info("show_ip_pim_bsrp_info_json l1: \n %s", bsrp_l1)
 974
 975     if bsrp_f1 == bsrp_l1:
 976         result = True
 977     else:
 978         result = "bsrp info in f1 is not same in l1"
 979
 980     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 981
 982     # set mtu of fhr(f1) to i1 interface to 100 so that bsm fragments
 983     step("set mtu of fhr(f1) to i1 interface to 100 so that bsm fragments")
 984     fhr_node.run("ip link set f1-i1-eth2 mtu 100")
 985     inter_node.run("ip link set i1-f1-eth0 mtu 100")
 986
 987     # Use scapy to send pre-defined packet from senser to receiver
 988     result = scapy_send_bsr_raw_packet(tgen, topo, "b1", "f1", "packet2")
 989     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 990
 991     result = app_helper.run_join("r1", GROUP_ADDRESS, "l1")
 992     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
 993
 994     # Verify bsr state in FHR
 995     step("Verify if b1 chosen as BSR")
 996     result = verify_pim_bsr(tgen, topo, "f1", bsr_ip)
 997     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
 998
 999     # Verify if bsrp list is same across f1, i1 and l1
1000     step("Verify if bsrp list is same across f1, i1 and l1 after fragmentation")
1001     bsrp_f1 = fhr_node.vtysh_cmd("show ip pim bsrp-info json", isjson=True)
1002     logger.info("show_ip_pim_bsrp_info_json f1: \n %s", bsrp_f1)
1003     bsrp_i1 = inter_node.vtysh_cmd("show ip pim bsrp-info json", isjson=True)
1004     logger.info("show_ip_pim_bsrp_info_json i1: \n %s", bsrp_i1)
1005     bsrp_l1 = lhr_node.vtysh_cmd("show ip pim bsrp-info json", isjson=True)
1006     logger.info("show_ip_pim_bsrp_info_json l1: \n %s", bsrp_l1)
1007
1008     if bsrp_f1 == bsrp_l1:
1009         result = True
1010     else:
1011         result = "bsrp info in f1 is not same in l1"
1012
1013     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
1014
1015     step("clear  BSM database before moving to next case")
1016     clear_bsrp_data(tgen, topo)
1017
1018     write_test_footer(tc_name)
1019
1020
1021 def test_RP_with_all_ip_octet_p1(request):
1022     """
1023     Verify when candidate RP advertised with 32 mask length
1024      and contain all the contacts
1025
1026     Topology used:
1027       b1_____
1028              |
1029              |
1030       s1-----f1-----i1-----l1----r1
1031              |
1032        ______|
1033       b2
1034
1035       b1 - BSR 1
1036       b2 - BSR 2
1037       s1 - Source
1038       f1 - FHR
1039       i1 - Intermediate Router (also RP)
1040       r1 - Receiver
1041
1042     """
1043
1044     tgen = get_topogen()
1045     tc_name = request.node.name
1046     write_test_header(tc_name)
1047
1048     # Don"t run this test if we have any failure.
1049     if tgen.routers_have_failure():
1050         pytest.skip(tgen.errors)
1051
1052     app_helper.stop_all_hosts()
1053     clear_mroute(tgen)
1054     reset_config_on_routers(tgen)
1055     clear_pim_interface_traffic(tgen, topo)
1056
1057     step("pre-configure BSM packet")
1058     result = pre_config_to_bsm(
1059         tgen, topo, tc_name, "b1", "s1", "r1", "f1", "i1", "l1", "packet1"
1060     )
1061     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
1062
1063     step("Send the IGMP group (225.100.100.100) from receiver connected to FRR")
1064     GROUP_ADDRESS = "225.200.100.100"
1065
1066     # Use scapy to send pre-defined packet from senser to receiver
1067     step("Configure cisco-1 as BSR1")
1068     result = scapy_send_bsr_raw_packet(tgen, topo, "b1", "f1", "packet8")
1069     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
1070
1071     bsr_ip = topo["routers"]["b1"]["bsm"]["bsr_packets"]["packet8"]["bsr"].split("/")[0]
1072     time.sleep(1)
1073
1074     result = app_helper.run_join("r1", GROUP_ADDRESS, "l1")
1075     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
1076
1077     dut = "l1"
1078     step(
1079         "Groups are shown with candidate RP with correct mask length 'show ip pim bsrp-info'"
1080     )
1081     step("Verify if b1 chosen as BSR in f1")
1082     result = verify_pim_bsr(tgen, topo, "f1", bsr_ip)
1083     assert result is True, "Testcase {} :Failed \n Error {}".format(tc_name, result)
1084
1085     group = topo["routers"]["b1"]["bsm"]["bsr_packets"]["packet9"]["group"]
1086     step("Find the elected rp from bsrp-info in LHR l1")
1087     rp = find_rp_from_bsrp_info(tgen, dut, bsr_ip, group)
1088     assert rp is not {}, "Testcase {} :Failed \n Error {}".format(tc_name, result)
1089
1090     step("Verify RP in LHR")
1091     result = verify_pim_grp_rp_source(tgen, topo, dut, group, "BSR", rp[group])
1092     assert result is True, "Testcase {}:Failed \n Error: {}".format(tc_name, result)
1093
1094     step("clear  BSM database before moving to next case")
1095     clear_bsrp_data(tgen, topo)
1096
1097     write_test_footer(tc_name)
1098
1099
1100 if __name__ == "__main__":
1101     args = ["-s"] + sys.argv[1:]
1102     sys.exit(pytest.main(args))