tests/topotests/multicast_pim6_static_rp_topo1/test_multicast_pim6_static_rp2.py

   1 #!/usr/bin/env python
   2 # SPDX-License-Identifier: ISC
   3
   4 #
   5 # Copyright (c) 2022 by VMware, Inc. ("VMware")
   6 # Used Copyright (c) 2018 by Network Device Education Foundation,
   7 # Inc. ("NetDEF") in this file.
   8 #
   9
  10 """
  11 Following tests are covered to test Multicast basic functionality:
  12
  13 Topology:
  14
  15                  _______r2_____
  16                 |             |
  17       iperf     |             |     iperf
  18         r0-----r1-------------r3-----r5
  19                 |             |
  20                 |_____________|
  21                         r4
  22
  23 Test steps
  24 - Create topology (setup module)
  25 - Bring up topology
  26
  27 1. Configure multiple  groups (10 grps) with same RP address
  28 2. Verify IIF and OIL in updated in mroute when upstream interface
  29    configure as RP
  30 3. Verify RP info and (*,G) mroute after deleting the RP and shut /
  31     no shut the RPF interface.
  32 """
  33
  34 import os
  35 import sys
  36 import json
  37 import time
  38 import pytest
  39
  40 # Save the Current Working Directory to find configuration files.
  41 CWD = os.path.dirname(os.path.realpath(__file__))
  42 sys.path.append(os.path.join(CWD, "../"))
  43 sys.path.append(os.path.join(CWD, "../lib/"))
  44
  45 # Required to instantiate the topology builder class.
  46
  47 # pylint: disable=C0413
  48 # Import topogen and topotest helpers
  49 from lib.topogen import Topogen, get_topogen
  50
  51 from lib.common_config import (
  52     start_topology,
  53     write_test_header,
  54     write_test_footer,
  55     reset_config_on_routers,
  56     step,
  57     shutdown_bringup_interface,
  58     kill_router_daemons,
  59     start_router_daemons,
  60     create_static_routes,
  61     check_router_status,
  62     socat_send_mld_join,
  63     socat_send_pim6_traffic,
  64     kill_socat,
  65     create_debug_log_config,
  66 )
  67 from lib.pim import (
  68     create_pim_config,
  69     verify_upstream_iif,
  70     verify_join_state_and_timer,
  71     verify_mroutes,
  72     verify_pim_neighbors,
  73     verify_pim_interface_traffic,
  74     verify_pim_rp_info,
  75     verify_pim_state,
  76     clear_pim6_interface_traffic,
  77     clear_pim6_mroute,
  78     verify_pim6_neighbors,
  79     get_pim6_interface_traffic,
  80     clear_pim6_interfaces,
  81     verify_mld_groups,
  82 )
  83 from lib.topolog import logger
  84 from lib.topojson import build_topo_from_json, build_config_from_json
  85
  86 # Global variables
  87 GROUP_RANGE_1 = "ff08::/64"
  88 GROUP_ADDRESS_1 = "ff08::1"
  89 GROUP_RANGE_3 = "ffaa::/64"
  90 GROUP_ADDRESS_3 = "ffaa::1"
  91 GROUP_RANGE_LIST_1 = [
  92     "ffaa::1/128",
  93     "ffaa::2/128",
  94     "ffaa::3/128",
  95     "ffaa::4/128",
  96     "ffaa::5/128",
  97 ]
  98 GROUP_RANGE_LIST_2 = [
  99     "ffaa::6/128",
 100     "ffaa::7/128",
 101     "ffaa::8/128",
 102     "ffaa::9/128",
 103     "ffaa::10/128",
 104 ]
 105 GROUP_ADDRESS_LIST_1 = ["ffaa::1", "ffaa::2", "ffaa::3", "ffaa::4", "ffaa::5"]
 106 GROUP_ADDRESS_LIST_2 = ["ffaa::6", "ffaa::7", "ffaa::8", "ffaa::9", "ffaa::10"]
 107 STAR = "*"
 108 SOURCE = "Static"
 109 ASSERT_MSG = "Testcase {} : Failed Error: {}"
 110
 111 pytestmark = [pytest.mark.pim6d]
 112
 113
 114 def build_topo(tgen):
 115     """Build function"""
 116
 117     # Building topology from json file
 118     build_topo_from_json(tgen, TOPO)
 119
 120
 121 def setup_module(mod):
 122     """
 123     Sets up the pytest environment
 124
 125     * `mod`: module name
 126     """
 127
 128     testsuite_run_time = time.asctime(time.localtime(time.time()))
 129     logger.info("Testsuite start time: %s", testsuite_run_time)
 130     logger.info("=" * 40)
 131
 132     topology = """
 133
 134                  _______r2_____
 135                 |             |
 136       iperf     |             |     iperf
 137         r0-----r1-------------r3-----r5
 138                 |             |
 139                 |_____________|
 140                         r4
 141
 142     """
 143     logger.info("Master Topology: \n %s", topology)
 144
 145     logger.info("Running setup_module to create topology")
 146
 147     # This function initiates the topology build with Topogen...
 148     json_file = "{}/multicast_pim6_static_rp.json".format(CWD)
 149     tgen = Topogen(json_file, mod.__name__)
 150     global TOPO
 151     TOPO = tgen.json_topo
 152
 153     # ... and here it calls Mininet initialization functions.
 154
 155     # Starting topology, create tmp files which are loaded to routers
 156     #  to start daemons and then start routers
 157     start_topology(tgen)
 158
 159     # Don"t run this test if we have any failure.
 160     if tgen.routers_have_failure():
 161         pytest.skip(tgen.errors)
 162
 163     # Creating configuration from JSON
 164     build_config_from_json(tgen, TOPO)
 165
 166     # Verify PIM6 neighbors
 167     result = verify_pim6_neighbors(tgen, TOPO)
 168     assert result is True, "setup_module :Failed \n Error:" " {}".format(result)
 169
 170     logger.info("Running setup_module() done")
 171
 172
 173 def teardown_module():
 174     """Teardown the pytest environment"""
 175
 176     logger.info("Running teardown_module to delete topology")
 177     tgen = get_topogen()
 178
 179     # Stop toplogy and Remove tmp files
 180     tgen.stop_topology()
 181
 182     logger.info("Testsuite end time: %s", time.asctime(time.localtime(time.time())))
 183     logger.info("=" * 40)
 184
 185
 186 #####################################################
 187 #
 188 #   Local API
 189 #
 190 #####################################################
 191
 192
 193 def verify_state_incremented(state_before, state_after):
 194     """
 195     API to compare interface traffic state incrementing
 196
 197     Parameters
 198     ----------
 199     * `state_before` : State dictionary for any particular instance
 200     * `state_after` : State dictionary for any particular instance
 201     """
 202
 203     for router, state_data in state_before.items():
 204         for state, value in state_data.items():
 205             if state_before[router][state] >= state_after[router][state]:
 206                 errormsg = (
 207                     "[DUT: %s]: state %s value has not"
 208                     " incremented, Initial value: %s, "
 209                     "Current value: %s [FAILED!!]"
 210                     % (
 211                         router,
 212                         state,
 213                         state_before[router][state],
 214                         state_after[router][state],
 215                     )
 216                 )
 217                 return errormsg
 218
 219             logger.info(
 220                 "[DUT: %s]: State %s value is "
 221                 "incremented, Initial value: %s, Current value: %s"
 222                 " [PASSED!!]",
 223                 router,
 224                 state,
 225                 state_before[router][state],
 226                 state_after[router][state],
 227             )
 228
 229     return True
 230
 231
 232 #####################################################
 233 #
 234 #   Testcases
 235 #
 236 #####################################################
 237
 238
 239 def test_pim6_multiple_groups_same_RP_address_p2(request):
 240     """
 241     Configure multiple  groups (10 grps) with same RP address
 242
 243     Topology used:
 244                 ________r2_____
 245                 |             |
 246       iperf     |             |     iperf
 247         r0-----r1-------------r3-----r5
 248
 249     r1 : LHR
 250     r2 : RP
 251     r3 : FHR
 252     """
 253
 254     tgen = get_topogen()
 255     tc_name = request.node.name
 256     write_test_header(tc_name)
 257
 258     # Don"t run this test if we have any failure.
 259     if tgen.routers_have_failure():
 260         pytest.skip(tgen.errors)
 261
 262     step("Creating configuration from JSON")
 263     reset_config_on_routers(tgen)
 264
 265     input_dict = {
 266         "r1": {"debug": {"log_file": "r1_debug.log", "enable": ["pim6d"]}},
 267         "r2": {"debug": {"log_file": "r2_debug.log", "enable": ["pim6d"]}},
 268         "r3": {"debug": {"log_file": "r3_debug.log", "enable": ["pim6d"]}},
 269         "r4": {"debug": {"log_file": "r4_debug.log", "enable": ["pim6d"]}},
 270     }
 271
 272     result = create_debug_log_config(tgen, input_dict)
 273
 274     step("Enable MLD on r1 interface")
 275     step("Enable the PIM6 on all the interfaces of r1, r2, r3 and r4 routers")
 276     step("r2: Configure r2 as RP")
 277     input_dict = {
 278         "r2": {
 279             "pim6": {
 280                 "rp": [
 281                     {
 282                         "rp_addr": TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split(
 283                             "/"
 284                         )[0],
 285                         "group_addr_range": GROUP_RANGE_3,
 286                     }
 287                 ]
 288             }
 289         }
 290     }
 291
 292     result = create_pim_config(tgen, TOPO, input_dict)
 293     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 294
 295     step("r2: verify rp-info")
 296     dut = "r2"
 297     oif = "lo"
 298     rp_address = TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split("/")[0]
 299     result = verify_pim_rp_info(tgen, TOPO, dut, GROUP_RANGE_3, oif, rp_address, SOURCE)
 300     assert result is True, ASSERT_MSG.format(tc_name, result)
 301
 302     group_address_list = GROUP_ADDRESS_LIST_1 + GROUP_ADDRESS_LIST_2
 303     step("r0: Send MLD join for 10 groups")
 304     intf = TOPO["routers"]["r0"]["links"]["r1"]["interface"]
 305     intf_ip = TOPO["routers"]["r0"]["links"]["r1"]["ipv6"].split("/")[0]
 306     result = socat_send_mld_join(
 307         tgen, "r0", "UDP6-RECV", group_address_list, intf, intf_ip
 308     )
 309     assert result is True, "Testcase {}: Failed Error: {}".format(tc_name, result)
 310
 311     step("r1: Verify MLD groups")
 312     dut = "r1"
 313     intf_r1_r0 = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
 314     result = verify_mld_groups(tgen, dut, intf_r1_r0, group_address_list)
 315     assert result is True, ASSERT_MSG.format(tc_name, result)
 316
 317     step("r5: Send multicast traffic for group {}".format(group_address_list))
 318     intf = TOPO["routers"]["r5"]["links"]["r3"]["interface"]
 319     SOURCE_ADDRESS = TOPO["routers"]["r5"]["links"]["r3"]["ipv6"].split("/")[0]
 320     result = socat_send_pim6_traffic(tgen, "r5", "UDP6-SEND", group_address_list, intf)
 321     assert result is True, "Testcase {}: Failed Error: {}".format(tc_name, result)
 322
 323     step("r1: Verify (*, G) upstream IIF interface")
 324     dut = "r1"
 325     iif = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
 326     result = verify_upstream_iif(tgen, dut, iif, STAR, group_address_list)
 327     assert result is True, ASSERT_MSG.format(tc_name, result)
 328
 329     step("r1: Verify (*, G) upstream join state and join timer")
 330     result = verify_join_state_and_timer(
 331         tgen, dut, iif, STAR, group_address_list, addr_type="ipv6"
 332     )
 333     assert result is True, ASSERT_MSG.format(tc_name, result)
 334
 335     step("r1: Verify (*, G) ip mroutes")
 336     oif = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
 337     result = verify_mroutes(tgen, dut, STAR, group_address_list, iif, oif)
 338     assert result is True, ASSERT_MSG.format(tc_name, result)
 339
 340     step("r1: Verify (S, G) ip mroutes")
 341     iif = TOPO["routers"]["r1"]["links"]["r3"]["interface"]
 342     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, group_address_list, iif, oif)
 343     assert result is True, ASSERT_MSG.format(tc_name, result)
 344
 345     step("r1: Verify (S, G) upstream IIF interface")
 346     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, group_address_list)
 347     assert result is True, ASSERT_MSG.format(tc_name, result)
 348
 349     step("r1: Verify (S, G) upstream join state and join timer")
 350     result = verify_join_state_and_timer(
 351         tgen, dut, iif, SOURCE_ADDRESS, group_address_list, addr_type="ipv6"
 352     )
 353     assert result is True, ASSERT_MSG.format(tc_name, result)
 354
 355     step("r2: Verify (*, G) upstream IIF interface")
 356     dut = "r2"
 357     iif = "lo"
 358     result = verify_upstream_iif(tgen, dut, iif, STAR, group_address_list)
 359     assert result is True, ASSERT_MSG.format(tc_name, result)
 360
 361     step("r2: Verify (*, G) upstream join state and join timer")
 362     result = verify_join_state_and_timer(
 363         tgen, dut, iif, STAR, group_address_list, addr_type="ipv6"
 364     )
 365     assert result is True, ASSERT_MSG.format(tc_name, result)
 366
 367     step("r2: Verify (*, G) ip mroutes")
 368     oif = TOPO["routers"]["r2"]["links"]["r1"]["interface"]
 369     result = verify_mroutes(tgen, dut, STAR, group_address_list, iif, oif)
 370     assert result is True, ASSERT_MSG.format(tc_name, result)
 371
 372     step("r3: Verify (S, G) upstream IIF interface")
 373     dut = "r3"
 374     iif = TOPO["routers"]["r3"]["links"]["r5"]["interface"]
 375     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, group_address_list)
 376     assert result is True, ASSERT_MSG.format(tc_name, result)
 377
 378     step("r3: Verify (S, G) upstream join state and join timer")
 379     result = verify_join_state_and_timer(
 380         tgen,
 381         dut,
 382         iif,
 383         SOURCE_ADDRESS,
 384         group_address_list,
 385         addr_type="ipv6",
 386         expected=False,
 387     )
 388     assert result is not True, (
 389         "Testcase {} : Failed \n "
 390         "r3: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
 391             tc_name, result
 392         )
 393     )
 394
 395     step("r3: Verify (S, G) ip mroutes")
 396     oif = TOPO["routers"]["r3"]["links"]["r1"]["interface"]
 397     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, group_address_list, iif, oif)
 398     assert result is True, ASSERT_MSG.format(tc_name, result)
 399
 400     step("r2: Verify (S, G) upstream IIF interface")
 401     dut = "r2"
 402     iif = TOPO["routers"]["r2"]["links"]["r3"]["interface"]
 403     result = verify_upstream_iif(
 404         tgen, dut, iif, SOURCE_ADDRESS, group_address_list, joinState="NotJoined"
 405     )
 406     assert result is True, ASSERT_MSG.format(tc_name, result)
 407
 408     step("r2: Verify (S, G) upstream join state and join timer")
 409     result = verify_join_state_and_timer(
 410         tgen,
 411         dut,
 412         iif,
 413         SOURCE_ADDRESS,
 414         group_address_list,
 415         addr_type="ipv6",
 416         expected=False,
 417     )
 418     assert result is not True, (
 419         "Testcase {} : Failed \n "
 420         "r2: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
 421             tc_name, result
 422         )
 423     )
 424
 425     step("r2: Verify (S, G) ip mroutes")
 426     oif = "none"
 427     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, group_address_list, iif, oif)
 428     assert result is True, ASSERT_MSG.format(tc_name, result)
 429
 430     step("r1: Delete RP configuration")
 431     input_dict = {
 432         "r1": {
 433             "pim6": {
 434                 "rp": [
 435                     {
 436                         "rp_addr": TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split(
 437                             "/"
 438                         )[0],
 439                         "group_addr_range": GROUP_RANGE_3,
 440                         "delete": True,
 441                     }
 442                 ]
 443             }
 444         }
 445     }
 446
 447     result = create_pim_config(tgen, TOPO, input_dict)
 448     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 449
 450     step("r1: Shut the interface r1-r2-eth1 from R1 to R2")
 451     dut = "r1"
 452     intf = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
 453     shutdown_bringup_interface(tgen, dut, intf, False)
 454
 455     step("r1: No Shut the interface r1-r2-eth1 from R1 to R2")
 456     shutdown_bringup_interface(tgen, dut, intf, True)
 457
 458     step("r1: Configure RP")
 459     input_dict = {
 460         "r1": {
 461             "pim6": {
 462                 "rp": [
 463                     {
 464                         "rp_addr": TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split(
 465                             "/"
 466                         )[0],
 467                         "group_addr_range": GROUP_RANGE_3,
 468                     }
 469                 ]
 470             }
 471         }
 472     }
 473
 474     result = create_pim_config(tgen, TOPO, input_dict)
 475     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 476
 477     step("r1: Shut the interface r1-r0-eth0 from R1 to R2")
 478     intf = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
 479     shutdown_bringup_interface(tgen, dut, intf, False)
 480
 481     step("r1: No Shut the interface r1-r0-eth0 from R1 to R2")
 482     shutdown_bringup_interface(tgen, dut, intf, True)
 483
 484     step("r1: Verify (*, G) upstream IIF interface")
 485     dut = "r1"
 486     iif = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
 487     result = verify_upstream_iif(tgen, dut, iif, STAR, group_address_list)
 488     assert result is True, ASSERT_MSG.format(tc_name, result)
 489
 490     step("r1: Verify (*, G) upstream join state and join timer")
 491     result = verify_join_state_and_timer(
 492         tgen, dut, iif, STAR, group_address_list, addr_type="ipv6"
 493     )
 494     assert result is True, ASSERT_MSG.format(tc_name, result)
 495
 496     step("r1: Verify (*, G) ip mroutes")
 497     oif = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
 498     result = verify_mroutes(tgen, dut, STAR, group_address_list, iif, oif)
 499     assert result is True, ASSERT_MSG.format(tc_name, result)
 500
 501     step("r1: Verify (S, G) upstream IIF interface")
 502     iif = TOPO["routers"]["r1"]["links"]["r3"]["interface"]
 503     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, group_address_list)
 504     assert result is True, ASSERT_MSG.format(tc_name, result)
 505
 506     step("r1: Verify (S, G) upstream join state and join timer")
 507     result = verify_join_state_and_timer(
 508         tgen, dut, iif, SOURCE_ADDRESS, group_address_list, addr_type="ipv6"
 509     )
 510     assert result is True, ASSERT_MSG.format(tc_name, result)
 511
 512     step("r1: Verify (S, G) ip mroutes")
 513     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, group_address_list, iif, oif)
 514     assert result is True, ASSERT_MSG.format(tc_name, result)
 515
 516     step("r2: Verify (*, G) upstream IIF interface")
 517     dut = "r2"
 518     iif = "lo"
 519     result = verify_upstream_iif(tgen, dut, iif, STAR, group_address_list)
 520     assert result is True, ASSERT_MSG.format(tc_name, result)
 521
 522     step("r2: Verify (*, G) upstream join state and join timer")
 523     result = verify_join_state_and_timer(
 524         tgen, dut, iif, STAR, group_address_list, addr_type="ipv6"
 525     )
 526     assert result is True, ASSERT_MSG.format(tc_name, result)
 527
 528     step("r2: Verify (*, G) ip mroutes")
 529     oif = TOPO["routers"]["r2"]["links"]["r1"]["interface"]
 530     result = verify_mroutes(tgen, dut, STAR, group_address_list, iif, oif)
 531     assert result is True, ASSERT_MSG.format(tc_name, result)
 532
 533     step("r3: Verify (S, G) upstream IIF interface")
 534     dut = "r3"
 535     iif = TOPO["routers"]["r3"]["links"]["r5"]["interface"]
 536     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, group_address_list)
 537     assert result is True, ASSERT_MSG.format(tc_name, result)
 538
 539     step("r3: Verify (S, G) upstream join state and join timer")
 540     result = verify_join_state_and_timer(
 541         tgen,
 542         dut,
 543         iif,
 544         SOURCE_ADDRESS,
 545         group_address_list,
 546         addr_type="ipv6",
 547         expected=False,
 548     )
 549     assert result is not True, (
 550         "Testcase {} : Failed \n "
 551         "r3: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
 552             tc_name, result
 553         )
 554     )
 555
 556     step("r3: Verify (S, G) ip mroutes")
 557     oif = TOPO["routers"]["r3"]["links"]["r1"]["interface"]
 558     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, group_address_list, iif, oif)
 559     assert result is True, ASSERT_MSG.format(tc_name, result)
 560
 561     write_test_footer(tc_name)
 562
 563
 564 def test_pim6_multiple_groups_different_RP_address_p2(request):
 565     """
 566     Verify IIF and OIL in updated in mroute when upstream interface
 567     configure as RP
 568
 569     Topology used:
 570                 ________r2_____
 571                 |             |
 572       iperf     |             |     iperf
 573         r0-----r1-------------r3-----r5
 574                 |             |
 575                 |_____________|
 576                         r4
 577     r1 : LHR
 578     r2 & r4 : RP
 579     r3 : FHR
 580     """
 581
 582     tgen = get_topogen()
 583     tc_name = request.node.name
 584     write_test_header(tc_name)
 585
 586     # Don"t run this test if we have any failure.
 587     if tgen.routers_have_failure():
 588         pytest.skip(tgen.errors)
 589
 590     step("Creating configuration from JSON")
 591     reset_config_on_routers(tgen)
 592
 593     step("Enable MLD on r1 interface")
 594     step("Enable the PIM6 on all the interfaces of r1, r2, r3 and r4 routers")
 595     step("r2: Configure r2 as RP")
 596     step("r4: Configure r4 as RP")
 597     input_dict = {
 598         "r2": {
 599             "pim6": {
 600                 "rp": [
 601                     {
 602                         "rp_addr": TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split(
 603                             "/"
 604                         )[0],
 605                         "group_addr_range": GROUP_RANGE_LIST_1,
 606                     }
 607                 ]
 608             }
 609         },
 610         "r4": {
 611             "pim6": {
 612                 "rp": [
 613                     {
 614                         "rp_addr": TOPO["routers"]["r4"]["links"]["lo"]["ipv6"].split(
 615                             "/"
 616                         )[0],
 617                         "group_addr_range": GROUP_RANGE_LIST_2,
 618                     }
 619                 ]
 620             }
 621         },
 622     }
 623
 624     result = create_pim_config(tgen, TOPO, input_dict)
 625     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 626
 627     step("r2: Verify RP info")
 628     dut = "r2"
 629     oif = "lo"
 630     rp_address = TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split("/")[0]
 631     result = verify_pim_rp_info(
 632         tgen, TOPO, dut, GROUP_RANGE_LIST_1, oif, rp_address, SOURCE
 633     )
 634     assert result is True, ASSERT_MSG.format(tc_name, result)
 635
 636     step("r4: Verify RP info")
 637     dut = "r4"
 638     rp_address = TOPO["routers"]["r4"]["links"]["lo"]["ipv6"].split("/")[0]
 639     result = verify_pim_rp_info(
 640         tgen, TOPO, dut, GROUP_RANGE_LIST_2, oif, rp_address, SOURCE
 641     )
 642     assert result is True, ASSERT_MSG.format(tc_name, result)
 643
 644     group_address_list = GROUP_ADDRESS_LIST_1 + GROUP_ADDRESS_LIST_2
 645     step("r0: Send MLD join for 10 groups")
 646     intf = TOPO["routers"]["r0"]["links"]["r1"]["interface"]
 647     intf_ip = TOPO["routers"]["r0"]["links"]["r1"]["ipv6"].split("/")[0]
 648     result = socat_send_mld_join(
 649         tgen, "r0", "UDP6-RECV", group_address_list, intf, intf_ip
 650     )
 651     assert result is True, "Testcase {}: Failed Error: {}".format(tc_name, result)
 652
 653     step("r1: Verify MLD groups")
 654     dut = "r1"
 655     intf_r1_r0 = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
 656     result = verify_mld_groups(tgen, dut, intf_r1_r0, group_address_list)
 657     assert result is True, ASSERT_MSG.format(tc_name, result)
 658
 659     step("r5: Send multicast traffic for group {}".format(group_address_list))
 660     intf = TOPO["routers"]["r5"]["links"]["r3"]["interface"]
 661     SOURCE_ADDRESS = TOPO["routers"]["r5"]["links"]["r3"]["ipv6"].split("/")[0]
 662     result = socat_send_pim6_traffic(tgen, "r5", "UDP6-SEND", group_address_list, intf)
 663     assert result is True, "Testcase {}: Failed Error: {}".format(tc_name, result)
 664
 665     step("r1: Verify (*, G) upstream IIF interface")
 666     dut = "r1"
 667     iif1 = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
 668     iif2 = TOPO["routers"]["r1"]["links"]["r4"]["interface"]
 669
 670     for _iif, _group in zip([iif1, iif2], [GROUP_ADDRESS_LIST_1, GROUP_ADDRESS_LIST_2]):
 671         result = verify_upstream_iif(tgen, dut, _iif, STAR, _group)
 672         assert result is True, ASSERT_MSG.format(tc_name, result)
 673
 674         step("r1: Verify (*, G) upstream join state and join timer")
 675         result = verify_join_state_and_timer(
 676             tgen, dut, _iif, STAR, _group, addr_type="ipv6"
 677         )
 678         assert result is True, ASSERT_MSG.format(tc_name, result)
 679
 680     step("r1: Verify (*, G) ip mroutes")
 681     iif = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
 682     oif = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
 683     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_LIST_1, iif, oif)
 684     assert result is True, ASSERT_MSG.format(tc_name, result)
 685
 686     step("r1: Verify (S, G) upstream IIF interface")
 687     iif = TOPO["routers"]["r1"]["links"]["r3"]["interface"]
 688     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1)
 689     assert result is True, ASSERT_MSG.format(tc_name, result)
 690
 691     step("r1: Verify (S, G) upstream join state and join timer")
 692     result = verify_join_state_and_timer(
 693         tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, addr_type="ipv6"
 694     )
 695     assert result is True, ASSERT_MSG.format(tc_name, result)
 696
 697     step("r1: Verify (S, G) ip mroutes")
 698     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, iif, oif)
 699     assert result is True, ASSERT_MSG.format(tc_name, result)
 700
 701     step("r2: Verify (*, G) upstream IIF interface")
 702     dut = "r2"
 703     iif = "lo"
 704     result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_1)
 705     assert result is True, ASSERT_MSG.format(tc_name, result)
 706
 707     step("r2: Verify (*, G) upstream join state and join timer")
 708     result = verify_join_state_and_timer(
 709         tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_1, addr_type="ipv6"
 710     )
 711     assert result is True, ASSERT_MSG.format(tc_name, result)
 712
 713     step("r2: Verify (*, G) ip mroutes")
 714     oif = TOPO["routers"]["r2"]["links"]["r1"]["interface"]
 715     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_LIST_1, iif, oif)
 716     assert result is True, ASSERT_MSG.format(tc_name, result)
 717
 718     step("r2: Verify (S, G) upstream IIF interface")
 719     iif = TOPO["routers"]["r2"]["links"]["r3"]["interface"]
 720     result = verify_upstream_iif(
 721         tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, joinState="NotJoined"
 722     )
 723     assert result is True, ASSERT_MSG.format(tc_name, result)
 724
 725     step("r2: Verify (S, G) upstream join state and join timer")
 726     result = verify_join_state_and_timer(
 727         tgen,
 728         dut,
 729         iif,
 730         SOURCE_ADDRESS,
 731         GROUP_ADDRESS_LIST_1,
 732         addr_type="ipv6",
 733         expected=False,
 734     )
 735     assert result is not True, (
 736         "Testcase {} : Failed \n "
 737         "r2: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
 738             tc_name, result
 739         )
 740     )
 741
 742     step("r2: Verify (S, G) ip mroutes")
 743     oif = "none"
 744     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, iif, oif)
 745     assert result is True, ASSERT_MSG.format(tc_name, result)
 746
 747     step("r3: Verify (S, G) upstream IIF interface")
 748     dut = "r3"
 749     iif = TOPO["routers"]["r3"]["links"]["r5"]["interface"]
 750     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1)
 751     assert result is True, ASSERT_MSG.format(tc_name, result)
 752
 753     step("r3: Verify (S, G) upstream join state and join timer")
 754     result = verify_join_state_and_timer(
 755         tgen,
 756         dut,
 757         iif,
 758         SOURCE_ADDRESS,
 759         GROUP_ADDRESS_LIST_1,
 760         addr_type="ipv6",
 761         expected=False,
 762     )
 763     assert result is not True, (
 764         "Testcase {} : Failed \n "
 765         "r3: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
 766             tc_name, result
 767         )
 768     )
 769
 770     step("r3: Verify (S, G) ip mroutes")
 771     oif = TOPO["routers"]["r3"]["links"]["r1"]["interface"]
 772     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, iif, oif)
 773     assert result is True, ASSERT_MSG.format(tc_name, result)
 774
 775     step("r1: Verify (*, G) upstream IIF interface")
 776     dut = "r1"
 777     iif = TOPO["routers"]["r1"]["links"]["r4"]["interface"]
 778     result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_2)
 779     assert result is True, ASSERT_MSG.format(tc_name, result)
 780
 781     step("r1: Verify (*, G) upstream join state and join timer")
 782     result = verify_join_state_and_timer(
 783         tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_2, addr_type="ipv6"
 784     )
 785     assert result is True, ASSERT_MSG.format(tc_name, result)
 786
 787     step("r1: Verify (*, G) ip mroutes")
 788     oif = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
 789     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_LIST_2, iif, oif)
 790     assert result is True, ASSERT_MSG.format(tc_name, result)
 791
 792     step("r1: Verify (S, G) upstream IIF interface")
 793     iif = TOPO["routers"]["r1"]["links"]["r3"]["interface"]
 794     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2)
 795     assert result is True, ASSERT_MSG.format(tc_name, result)
 796
 797     step("r1: Verify (S, G) upstream join state and join timer")
 798     result = verify_join_state_and_timer(
 799         tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, addr_type="ipv6"
 800     )
 801     assert result is True, ASSERT_MSG.format(tc_name, result)
 802
 803     step("r1: Verify (S, G) ip mroutes")
 804     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, iif, oif)
 805     assert result is True, ASSERT_MSG.format(tc_name, result)
 806
 807     step("r4: Verify (*, G) upstream IIF interface")
 808     dut = "r4"
 809     iif = "lo"
 810     result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_2)
 811     assert result is True, ASSERT_MSG.format(tc_name, result)
 812
 813     step("r4: Verify (*, G) upstream join state and join timer")
 814     result = verify_join_state_and_timer(
 815         tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_2, addr_type="ipv6"
 816     )
 817     assert result is True, ASSERT_MSG.format(tc_name, result)
 818
 819     step("r4: Verify (*, G) ip mroutes")
 820     oif = TOPO["routers"]["r4"]["links"]["r1"]["interface"]
 821     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_LIST_2, iif, oif)
 822     assert result is True, ASSERT_MSG.format(tc_name, result)
 823
 824     step("r4: Verify (S, G) upstream IIF interface")
 825     iif = TOPO["routers"]["r4"]["links"]["r3"]["interface"]
 826     result = verify_upstream_iif(
 827         tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, joinState="NotJoined"
 828     )
 829     assert result is True, ASSERT_MSG.format(tc_name, result)
 830
 831     step("r4: Verify (S, G) upstream join state and join timer")
 832     result = verify_join_state_and_timer(
 833         tgen,
 834         dut,
 835         iif,
 836         SOURCE_ADDRESS,
 837         GROUP_ADDRESS_LIST_2,
 838         addr_type="ipv6",
 839         expected=False,
 840     )
 841     assert result is not True, (
 842         "Testcase {} : Failed \n "
 843         "r4: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
 844             tc_name, result
 845         )
 846     )
 847
 848     step("r4: Verify (S, G) ip mroutes")
 849     oif = "none"
 850     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, iif, oif)
 851     assert result is True, ASSERT_MSG.format(tc_name, result)
 852
 853     step("r3: Verify (S, G) upstream IIF interface")
 854     dut = "r3"
 855     iif = TOPO["routers"]["r3"]["links"]["r5"]["interface"]
 856     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2)
 857     assert result is True, ASSERT_MSG.format(tc_name, result)
 858
 859     step("r3: Verify (S, G) upstream join state and join timer")
 860     result = verify_join_state_and_timer(
 861         tgen,
 862         dut,
 863         iif,
 864         SOURCE_ADDRESS,
 865         GROUP_ADDRESS_LIST_2,
 866         addr_type="ipv6",
 867         expected=False,
 868     )
 869     assert result is not True, "Testcase {} :Failed \n Error: {}".format(
 870         tc_name, result
 871     )
 872
 873     step("r3: Verify (S, G) ip mroutes")
 874     oif = TOPO["routers"]["r3"]["links"]["r1"]["interface"]
 875     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, iif, oif)
 876     assert result is True, ASSERT_MSG.format(tc_name, result)
 877
 878     step("Delete RP configuration")
 879     input_dict = {
 880         "r2": {
 881             "pim6": {
 882                 "rp": [
 883                     {
 884                         "rp_addr": TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split(
 885                             "/"
 886                         )[0],
 887                         "group_addr_range": GROUP_RANGE_LIST_1,
 888                         "delete": True,
 889                     }
 890                 ]
 891             }
 892         },
 893         "r4": {
 894             "pim6": {
 895                 "rp": [
 896                     {
 897                         "rp_addr": TOPO["routers"]["r4"]["links"]["lo"]["ipv6"].split(
 898                             "/"
 899                         )[0],
 900                         "group_addr_range": GROUP_RANGE_LIST_2,
 901                         "delete": True,
 902                     }
 903                 ]
 904             }
 905         },
 906     }
 907
 908     result = create_pim_config(tgen, TOPO, input_dict)
 909     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 910
 911     step("r1, r2, r3, r4: Re-configure RP")
 912     input_dict = {
 913         "r2": {
 914             "pim6": {
 915                 "rp": [
 916                     {
 917                         "rp_addr": TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split(
 918                             "/"
 919                         )[0],
 920                         "group_addr_range": GROUP_RANGE_LIST_1,
 921                     }
 922                 ]
 923             }
 924         },
 925         "r4": {
 926             "pim6": {
 927                 "rp": [
 928                     {
 929                         "rp_addr": TOPO["routers"]["r4"]["links"]["lo"]["ipv6"].split(
 930                             "/"
 931                         )[0],
 932                         "group_addr_range": GROUP_RANGE_LIST_2,
 933                     }
 934                 ]
 935             }
 936         },
 937     }
 938
 939     result = create_pim_config(tgen, TOPO, input_dict)
 940     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
 941
 942     step("r1: Shut/No Shut the interfacesfrom R1 to R2, R4 and R0")
 943     dut = "r1"
 944     intf1 = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
 945     intf2 = TOPO["routers"]["r1"]["links"]["r4"]["interface"]
 946     intf3 = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
 947     for intf in [intf1, intf2, intf3]:
 948         shutdown_bringup_interface(tgen, dut, intf, False)
 949         shutdown_bringup_interface(tgen, dut, intf, True)
 950
 951     step("r1: Verify (*, G) upstream IIF interface")
 952     dut = "r1"
 953     iif = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
 954     result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_1)
 955     assert result is True, ASSERT_MSG.format(tc_name, result)
 956
 957     step("r1: Verify (*, G) upstream join state and join timer")
 958     result = verify_join_state_and_timer(
 959         tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_1, addr_type="ipv6"
 960     )
 961     assert result is True, ASSERT_MSG.format(tc_name, result)
 962
 963     step("r1: Verify (*, G) ip mroutes")
 964     oif = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
 965     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_LIST_1, iif, oif)
 966     assert result is True, ASSERT_MSG.format(tc_name, result)
 967
 968     step("r1: Verify (S, G) upstream IIF interface")
 969     iif = TOPO["routers"]["r1"]["links"]["r3"]["interface"]
 970     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1)
 971     assert result is True, ASSERT_MSG.format(tc_name, result)
 972
 973     step("r1: Verify (S, G) upstream join state and join timer")
 974     result = verify_join_state_and_timer(
 975         tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, addr_type="ipv6"
 976     )
 977     assert result is True, ASSERT_MSG.format(tc_name, result)
 978
 979     step("r1: Verify (S, G) ip mroutes")
 980     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, iif, oif)
 981     assert result is True, ASSERT_MSG.format(tc_name, result)
 982
 983     step("r2: Verify (*, G) upstream IIF interface")
 984     dut = "r2"
 985     iif = "lo"
 986     result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_1)
 987     assert result is True, ASSERT_MSG.format(tc_name, result)
 988
 989     step("r2: Verify (*, G) upstream join state and join timer")
 990     result = verify_join_state_and_timer(
 991         tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_1, addr_type="ipv6"
 992     )
 993     assert result is True, ASSERT_MSG.format(tc_name, result)
 994
 995     step("r2: Verify (*, G) ip mroutes")
 996     oif = TOPO["routers"]["r2"]["links"]["r1"]["interface"]
 997     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_LIST_1, iif, oif)
 998     assert result is True, ASSERT_MSG.format(tc_name, result)
 999
1000     step("r2: Verify (S, G) upstream IIF interface")
1001     iif = TOPO["routers"]["r2"]["links"]["r3"]["interface"]
1002     result = verify_upstream_iif(
1003         tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, joinState="NotJoined"
1004     )
1005     assert result is True, ASSERT_MSG.format(tc_name, result)
1006
1007     step("r2: Verify (S, G) upstream join state and join timer")
1008     result = verify_join_state_and_timer(
1009         tgen,
1010         dut,
1011         iif,
1012         SOURCE_ADDRESS,
1013         GROUP_ADDRESS_LIST_1,
1014         addr_type="ipv6",
1015         expected=False,
1016     )
1017     assert result is not True, (
1018         "Testcase {} : Failed \n "
1019         "r2: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
1020             tc_name, result
1021         )
1022     )
1023
1024     step("r2: Verify (S, G) ip mroutes")
1025     oif = "none"
1026     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, iif, oif)
1027     assert result is True, ASSERT_MSG.format(tc_name, result)
1028
1029     step("r3: Verify (S, G) upstream IIF interface")
1030     dut = "r3"
1031     iif = TOPO["routers"]["r3"]["links"]["r5"]["interface"]
1032     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1)
1033     assert result is True, ASSERT_MSG.format(tc_name, result)
1034
1035     step("r3: Verify (S, G) upstream join state and join timer")
1036     result = verify_join_state_and_timer(
1037         tgen,
1038         dut,
1039         iif,
1040         SOURCE_ADDRESS,
1041         GROUP_ADDRESS_LIST_1,
1042         addr_type="ipv6",
1043         expected=False,
1044     )
1045     assert result is not True, (
1046         "Testcase {} : Failed \n "
1047         "r3: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
1048             tc_name, result
1049         )
1050     )
1051
1052     step("r3: Verify (S, G) ip mroutes")
1053     oif = TOPO["routers"]["r3"]["links"]["r1"]["interface"]
1054     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_1, iif, oif)
1055     assert result is True, ASSERT_MSG.format(tc_name, result)
1056
1057     step("r1: Verify (*, G) upstream IIF interface")
1058     dut = "r1"
1059     iif = TOPO["routers"]["r1"]["links"]["r4"]["interface"]
1060     result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_2)
1061     assert result is True, ASSERT_MSG.format(tc_name, result)
1062
1063     step("r1: Verify (*, G) upstream join state and join timer")
1064     result = verify_join_state_and_timer(
1065         tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_2, addr_type="ipv6"
1066     )
1067     assert result is True, ASSERT_MSG.format(tc_name, result)
1068
1069     step("r1: Verify (*, G) ip mroutes")
1070     oif = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
1071     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_LIST_2, iif, oif)
1072     assert result is True, ASSERT_MSG.format(tc_name, result)
1073
1074     step("r1: Verify (S, G) upstream IIF interface")
1075     iif = TOPO["routers"]["r1"]["links"]["r3"]["interface"]
1076     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2)
1077     assert result is True, ASSERT_MSG.format(tc_name, result)
1078
1079     step("r1: Verify (S, G) upstream join state and join timer")
1080     result = verify_join_state_and_timer(
1081         tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, addr_type="ipv6"
1082     )
1083     assert result is True, ASSERT_MSG.format(tc_name, result)
1084
1085     step("r1: Verify (S, G) ip mroutes")
1086     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, iif, oif)
1087     assert result is True, ASSERT_MSG.format(tc_name, result)
1088
1089     step("r4: Verify (*, G) upstream IIF interface")
1090     dut = "r4"
1091     iif = "lo"
1092     result = verify_upstream_iif(tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_2)
1093     assert result is True, ASSERT_MSG.format(tc_name, result)
1094
1095     step("r4: Verify (*, G) upstream join state and join timer")
1096     result = verify_join_state_and_timer(
1097         tgen, dut, iif, STAR, GROUP_ADDRESS_LIST_2, addr_type="ipv6"
1098     )
1099     assert result is True, ASSERT_MSG.format(tc_name, result)
1100
1101     step("r4: Verify (*, G) ip mroutes")
1102     oif = TOPO["routers"]["r4"]["links"]["r1"]["interface"]
1103     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_LIST_2, iif, oif)
1104     assert result is True, ASSERT_MSG.format(tc_name, result)
1105
1106     step("r4: Verify (S, G) upstream IIF interface")
1107     iif = TOPO["routers"]["r4"]["links"]["r3"]["interface"]
1108     result = verify_upstream_iif(
1109         tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, joinState="NotJoined"
1110     )
1111     assert result is True, ASSERT_MSG.format(tc_name, result)
1112
1113     step("r4: Verify (S, G) upstream join state and join timer")
1114     result = verify_join_state_and_timer(
1115         tgen,
1116         dut,
1117         iif,
1118         SOURCE_ADDRESS,
1119         GROUP_ADDRESS_LIST_2,
1120         addr_type="ipv6",
1121         expected=False,
1122     )
1123     assert result is not True, (
1124         "Testcase {} : Failed \n "
1125         "r4: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
1126             tc_name, result
1127         )
1128     )
1129
1130     step("r4: Verify (S, G) ip mroutes")
1131     oif = "none"
1132     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, iif, oif)
1133     assert result is True, ASSERT_MSG.format(tc_name, result)
1134
1135     step("r3: Verify (S, G) upstream IIF interface")
1136     dut = "r3"
1137     iif = TOPO["routers"]["r3"]["links"]["r5"]["interface"]
1138     result = verify_upstream_iif(tgen, dut, iif, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2)
1139     assert result is True, ASSERT_MSG.format(tc_name, result)
1140
1141     step("r3: Verify (S, G) upstream join state and join timer")
1142     result = verify_join_state_and_timer(
1143         tgen,
1144         dut,
1145         iif,
1146         SOURCE_ADDRESS,
1147         GROUP_ADDRESS_LIST_2,
1148         addr_type="ipv6",
1149         expected=False,
1150     )
1151     assert result is not True, (
1152         "Testcase {} : Failed \n "
1153         "r3: (S,G) upstream state is joined and join timer is running\n Error: {}".format(
1154             tc_name, result
1155         )
1156     )
1157
1158     step("r3: Verify (S, G) ip mroutes")
1159     oif = TOPO["routers"]["r3"]["links"]["r1"]["interface"]
1160     result = verify_mroutes(tgen, dut, SOURCE_ADDRESS, GROUP_ADDRESS_LIST_2, iif, oif)
1161     assert result is True, ASSERT_MSG.format(tc_name, result)
1162
1163     write_test_footer(tc_name)
1164
1165
1166 def test_pim6_delete_RP_shut_noshut_upstream_interface_p1(request):
1167     """
1168     Verify RP info and (*,G) mroute after deleting the RP and shut /
1169     no shut the RPF interface.
1170
1171     Topology used:
1172                 ________r2_____
1173                 |             |
1174       iperf     |             |
1175         r0-----r1-------------r3
1176     """
1177
1178     tgen = get_topogen()
1179     tc_name = request.node.name
1180     write_test_header(tc_name)
1181
1182     # Don"t run this test if we have any failure.
1183     if tgen.routers_have_failure():
1184         pytest.skip(tgen.errors)
1185
1186     step("Creating configuration from JSON")
1187     reset_config_on_routers(tgen)
1188
1189     step("Enable MLD on r1 interface")
1190     step("Enable the PIM6 on all the interfaces of r1, r2, r3 and r4 routers")
1191     step("r2: Configure r2 as RP")
1192     input_dict = {
1193         "r2": {
1194             "pim6": {
1195                 "rp": [
1196                     {
1197                         "rp_addr": TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split(
1198                             "/"
1199                         )[0],
1200                         "group_addr_range": GROUP_RANGE_1,
1201                     }
1202                 ]
1203             }
1204         }
1205     }
1206
1207     result = create_pim_config(tgen, TOPO, input_dict)
1208     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1209
1210     step("r2: verify rp-info")
1211     dut = "r2"
1212     oif = "lo"
1213     rp_address = TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split("/")[0]
1214     result = verify_pim_rp_info(
1215         tgen, TOPO, dut, GROUP_ADDRESS_1, oif, rp_address, SOURCE
1216     )
1217     assert result is True, ASSERT_MSG.format(tc_name, result)
1218
1219     step("r0: Send MLD join")
1220     intf = TOPO["routers"]["r0"]["links"]["r1"]["interface"]
1221     intf_ip = TOPO["routers"]["r0"]["links"]["r1"]["ipv6"].split("/")[0]
1222     result = socat_send_mld_join(
1223         tgen, "r0", "UDP6-RECV", GROUP_ADDRESS_1, intf, intf_ip
1224     )
1225     assert result is True, "Testcase {}: Failed Error: {}".format(tc_name, result)
1226
1227     step("r1: Verify MLD groups")
1228     dut = "r1"
1229     intf_r1_r0 = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
1230     result = verify_mld_groups(tgen, dut, intf_r1_r0, GROUP_ADDRESS_1)
1231     assert result is True, ASSERT_MSG.format(tc_name, result)
1232
1233     step("r1: Verify (*, G) ip mroutes created")
1234     iif = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
1235     oif = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
1236     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_1, iif, oif)
1237     assert result is True, ASSERT_MSG.format(tc_name, result)
1238
1239     step("r2: Verify (*, G) ip mroutes created")
1240     dut = "r2"
1241     iif = "lo"
1242     oif = TOPO["routers"]["r2"]["links"]["r1"]["interface"]
1243     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_1, iif, oif)
1244     assert result is True, ASSERT_MSG.format(tc_name, result)
1245
1246     step("r1: Delete RP configuration")
1247     input_dict = {
1248         "r1": {
1249             "pim6": {
1250                 "rp": [
1251                     {
1252                         "rp_addr": TOPO["routers"]["r2"]["links"]["lo"]["ipv6"].split(
1253                             "/"
1254                         )[0],
1255                         "group_addr_range": GROUP_RANGE_1,
1256                         "delete": True,
1257                     }
1258                 ]
1259             }
1260         }
1261     }
1262
1263     result = create_pim_config(tgen, TOPO, input_dict)
1264     assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
1265
1266     step("r1: Shut/No Shut the interface r1-r2-eth1/r1-r0-eth0 from R1 to R2")
1267     dut = "r1"
1268     intf1 = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
1269     intf2 = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
1270     for intf in [intf1, intf2]:
1271         shutdown_bringup_interface(tgen, dut, intf, False)
1272         shutdown_bringup_interface(tgen, dut, intf, True)
1273
1274     step("r2: Shut the RP interface lo")
1275     dut = "r2"
1276     intf = "lo"
1277     shutdown_bringup_interface(tgen, dut, intf, False)
1278
1279     step("r1: Shut the interface r1-r2-eth1/r1-r3-eth2 towards RP")
1280     intf3 = TOPO["routers"]["r1"]["links"]["r3"]["interface"]
1281     for intf in [intf1, intf3]:
1282         shutdown_bringup_interface(tgen, dut, intf, False)
1283
1284     step("r1: Verify (*, G) ip mroutes cleared")
1285     dut = "r1"
1286     iif = TOPO["routers"]["r1"]["links"]["r2"]["interface"]
1287     oif = TOPO["routers"]["r1"]["links"]["r0"]["interface"]
1288     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_1, iif, oif, expected=False)
1289     assert result is not True, (
1290         "Testcase {} : Failed \n "
1291         "r1: (*,G) mroutes are not cleared after shut of R1 to R0 link\n Error: {}".format(
1292             tc_name, result
1293         )
1294     )
1295
1296     step("r2: Verify (*, G) ip mroutes cleared")
1297     dut = "r2"
1298     iif = "lo"
1299     oif = TOPO["routers"]["r2"]["links"]["r1"]["interface"]
1300     result = verify_mroutes(tgen, dut, STAR, GROUP_ADDRESS_1, iif, oif, expected=False)
1301     assert result is not True, (
1302         "Testcase {} : Failed \n "
1303         "r2: (*,G) mroutes are not cleared after shut of R1 to R0 link\n Error: {}".format(
1304             tc_name, result
1305         )
1306     )
1307
1308     write_test_footer(tc_name)
1309
1310
1311 if __name__ == "__main__":
1312     args = ["-s"] + sys.argv[1:]
1313     sys.exit(pytest.main(args))