..

Author: zeeshanlakhani

dpd-client/tests/integration_tests/mcast.rs

@@ -599,7 +599,6 @@ async fn test_internal_ipv6_validation() {
     assert_eq!(updated.tag, Some("updated_tag".to_string()));
     assert_eq!(updated.ext_fwding.vlan_id, None);
 
-    // Cleanup
     cleanup_test_group(switch, created.group_ip).await;
 }
 
@@ -685,7 +684,6 @@ async fn test_vlan_propagation_to_internal() {
         "Admin-scoped group bitmap should have VLAN 42 from external group"
     );
 
-    // Cleanup
     cleanup_test_group(switch, created_admin.group_ip).await;
     cleanup_test_group(switch, created_external.group_ip).await;
 }
@@ -695,7 +693,6 @@ async fn test_vlan_propagation_to_internal() {
 async fn test_group_api_lifecycle() {
     let switch = &*get_switch().await;
 
-    // Create admin-scoped IPv6 group for underlay replication infrastructure
     let egress1 = PhysPort(28);
     let internal_multicast_ip = IpAddr::V6(MULTICAST_NAT_IP);
     let underlay_group = create_test_multicast_group(
@@ -1330,7 +1327,6 @@ async fn test_api_invalid_combinations() {
         ),
     }
 
-    // Cleanup
     cleanup_test_group(switch, created_ipv4.group_ip).await;
     cleanup_test_group(switch, created_non_admin.group_ip).await;
     cleanup_test_group(switch, internal_multicast_ip).await;
@@ -2024,7 +2020,6 @@ async fn test_encapped_multicast_geneve_mcast_tag_to_external_members(
         .await
         .unwrap();
 
-    // Run the test
     let result = switch.packet_test(vec![test_pkt], expected_pkts);
 
     check_counter_incremented(
@@ -2163,7 +2158,6 @@ async fn test_encapped_multicast_geneve_mcast_tag_to_underlay_members(
         .await
         .unwrap();
 
-    // Run the test
     let result = switch.packet_test(vec![test_pkt], expected_pkts);
 
     check_counter_incremented(
@@ -2320,7 +2314,6 @@ async fn test_encapped_multicast_geneve_mcast_tag_to_underlay_and_external_membe
         .await
         .unwrap();
 
-    // Run the test
     let result = switch.packet_test(vec![test_pkt], expected_pkts);
 
     check_counter_incremented(
@@ -3844,6 +3837,288 @@ async fn test_multicast_reset_all_tables() -> TestResult {
     Ok(())
 }
 
+#[tokio::test]
+#[ignore]
+async fn test_multicast_group_id_recycling() -> TestResult {
+    let switch = &*get_switch().await;
+
+    let egress = PhysPort(28);
+    let internal_multicast_ip = IpAddr::V6(MULTICAST_NAT_IP);
+    let underlay_group = create_test_multicast_group(
+        switch,
+        internal_multicast_ip,
+        Some("recycling_test_underlay"),
+        &[(egress, types::Direction::Underlay)],
+        None,
+        false,
+        None,
+    )
+    .await;
+
+    let group_ip1 = IpAddr::V4(MULTICAST_TEST_IPV4);
+    let nat_target = create_nat_target_ipv4();
+    let external_create1 = types::MulticastGroupCreateExternalEntry {
+        group_ip: group_ip1,
+        tag: Some("recycling_test_1".to_string()),
+        nat_target: nat_target.clone(),
+        vlan_id: 10,
+        sources: None,
+        ports: vec![],
+    };
+
+    let created_group1 = switch
+        .multicast_group_create_external(&external_create1)
+        .await?;
+
+    let first_external_id = created_group1.external_group_id;
+    let first_underlay_id = created_group1.underlay_group_id;
+
+    switch.multicast_group_delete(&group_ip1).await?;
+
+    let group_ip2 = IpAddr::V4(Ipv4Addr::new(224, 0, 0, 100));
+    let external_create2 = types::MulticastGroupCreateExternalEntry {
+        group_ip: group_ip2,
+        tag: Some("recycling_test_2".to_string()),
+        nat_target: nat_target.clone(),
+        vlan_id: 10,
+        sources: None,
+        ports: vec![],
+    };
+
+    let created_group2 = switch
+        .multicast_group_create_external(&external_create2)
+        .await?;
+
+    assert!(
+        created_group2.external_group_id.is_some(),
+        "Second group should have external group ID"
+    );
+    assert!(
+        created_group2.underlay_group_id.is_some(),
+        "Second group should have underlay group ID"
+    );
+
+    let group_ip3 = IpAddr::V4(Ipv4Addr::new(224, 0, 0, 101));
+    let external_create3 = types::MulticastGroupCreateExternalEntry {
+        group_ip: group_ip3,
+        tag: Some("recycling_test_3".to_string()),
+        nat_target: nat_target.clone(),
+        vlan_id: 10,
+        sources: None,
+        ports: vec![],
+    };
+
+    let created_group3 = switch
+        .multicast_group_create_external(&external_create3)
+        .await?;
+
+    assert!(
+        created_group3.external_group_id.is_some(),
+        "Third group should have external group ID"
+    );
+    assert!(
+        created_group3.underlay_group_id.is_some(),
+        "Third group should have underlay group ID"
+    );
+
+    cleanup_test_group(switch, group_ip2).await;
+    cleanup_test_group(switch, group_ip3).await;
+    cleanup_test_group(switch, internal_multicast_ip).await;
+
+    Ok(())
+}
+
+#[tokio::test]
+#[ignore]
+async fn test_multicast_group_id_reuse() -> TestResult {
+    let switch = &*get_switch().await;
+
+    let egress = PhysPort(29);
+    let internal_multicast_ip = IpAddr::V6(MULTICAST_NAT_IP);
+    let underlay_group = create_test_multicast_group(
+        switch,
+        internal_multicast_ip,
+        Some("id_reuse_test_underlay"),
+        &[(egress, types::Direction::Underlay)],
+        None,
+        false,
+        None,
+    )
+    .await;
+
+    let mut deleted_external_ids = Vec::new();
+    let mut deleted_underlay_ids = Vec::new();
+
+    for i in 0..5 {
+        let group_ip = IpAddr::V4(Ipv4Addr::new(224, 0, 0, 50 + i));
+        let nat_target = create_nat_target_ipv4();
+        let external_create = types::MulticastGroupCreateExternalEntry {
+            group_ip,
+            tag: Some(format!("id_reuse_test_{}", i)),
+            nat_target,
+            vlan_id: 10,
+            sources: None,
+            ports: vec![],
+        };
+
+        let created_group = switch
+            .multicast_group_create_external(&external_create)
+            .await?;
+
+        if let Some(external_id) = created_group.external_group_id {
+            deleted_external_ids.push(external_id);
+        }
+        if let Some(underlay_id) = created_group.underlay_group_id {
+            deleted_underlay_ids.push(underlay_id);
+        }
+
+        switch.multicast_group_delete(&group_ip).await?;
+    }
+
+    let new_group_ip = IpAddr::V4(Ipv4Addr::new(224, 0, 0, 200));
+    let nat_target = create_nat_target_ipv4();
+    let new_external_create = types::MulticastGroupCreateExternalEntry {
+        group_ip: new_group_ip,
+        tag: Some("id_reuse_verification".to_string()),
+        nat_target,
+        vlan_id: 10,
+        sources: None,
+        ports: vec![],
+    };
+
+    let new_created_group = switch
+        .multicast_group_create_external(&new_external_create)
+        .await?;
+
+    if let Some(new_external_id) = new_created_group.external_group_id {
+        assert!(
+            deleted_external_ids.contains(&new_external_id),
+            "New group should reuse a deleted external group ID, got {}, expected one of {:?}",
+            new_external_id,
+            deleted_external_ids
+        );
+    } else {
+        panic!("New group should have an external group ID");
+    }
+
+    if let Some(new_underlay_id) = new_created_group.underlay_group_id {
+        assert!(
+            deleted_underlay_ids.contains(&new_underlay_id),
+            "New group should reuse a deleted underlay group ID, got {}, expected one of {:?}",
+            new_underlay_id,
+            deleted_underlay_ids
+        );
+    } else {
+        panic!("New group should have an underlay group ID");
+    }
+
+    cleanup_test_group(switch, new_group_ip).await;
+    cleanup_test_group(switch, internal_multicast_ip).await;
+
+    Ok(())
+}
+
+#[tokio::test]
+#[ignore]
+async fn test_multicast_group_id_pool_exhaustion_recovery() -> TestResult {
+    let switch = &*get_switch().await;
+
+    let egress = PhysPort(30);
+    let internal_multicast_ip = IpAddr::V6(MULTICAST_NAT_IP);
+    let underlay_group = create_test_multicast_group(
+        switch,
+        internal_multicast_ip,
+        Some("pool_exhaustion_test_underlay"),
+        &[(egress, types::Direction::Underlay)],
+        None,
+        false,
+        None,
+    )
+    .await;
+
+    let mut created_groups = Vec::new();
+    let num_groups = 10;
+
+    for i in 0..num_groups {
+        let group_ip = IpAddr::V4(Ipv4Addr::new(224, 0, 1, i as u8));
+        let nat_target = create_nat_target_ipv4();
+        let external_create = types::MulticastGroupCreateExternalEntry {
+            group_ip,
+            tag: Some(format!("pool_test_{}", i)),
+            nat_target,
+            vlan_id: 10,
+            sources: None,
+            ports: vec![],
+        };
+
+        let created_group = switch
+            .multicast_group_create_external(&external_create)
+            .await?;
+
+        created_groups.push((group_ip, created_group));
+    }
+
+    assert_eq!(
+        created_groups.len(),
+        num_groups,
+        "Should have created {} groups",
+        num_groups
+    );
+
+    let groups_to_delete = &created_groups[0..num_groups / 2];
+    for (group_ip, _) in groups_to_delete {
+        switch.multicast_group_delete(group_ip).await?;
+    }
+
+    let mut new_groups = Vec::new();
+    for i in 0..num_groups / 2 {
+        let group_ip = IpAddr::V4(Ipv4Addr::new(224, 0, 2, i as u8));
+        let nat_target = create_nat_target_ipv4();
+        let external_create = types::MulticastGroupCreateExternalEntry {
+            group_ip,
+            tag: Some(format!("pool_recovery_test_{}", i)),
+            nat_target,
+            vlan_id: 10,
+            sources: None,
+            ports: vec![],
+        };
+
+        let created_group = switch
+            .multicast_group_create_external(&external_create)
+            .await?;
+
+        new_groups.push((group_ip, created_group));
+    }
+
+    assert_eq!(
+        new_groups.len(),
+        num_groups / 2,
+        "Should have created {} new groups after pool recovery",
+        num_groups / 2
+    );
+
+    for (_, group) in &new_groups {
+        assert!(
+            group.external_group_id.is_some(),
+            "New group should have external group ID"
+        );
+        assert!(
+            group.underlay_group_id.is_some(),
+            "New group should have underlay group ID"
+        );
+    }
+
+    for (group_ip, _) in &created_groups[num_groups / 2..] {
+        cleanup_test_group(switch, *group_ip).await;
+    }
+    for (group_ip, _) in &new_groups {
+        cleanup_test_group(switch, *group_ip).await;
+    }
+    cleanup_test_group(switch, internal_multicast_ip).await;
+
+    Ok(())
+}
+
 #[tokio::test]
 #[ignore]
 async fn test_multicast_vlan_translation_not_possible() -> TestResult {
@@ -4335,7 +4610,6 @@ async fn test_external_group_nat_target_validation() {
         "External group should have no members"
     );
 
-    // Cleanup
     cleanup_test_group(switch, created_admin.group_ip).await;
     cleanup_test_group(switch, created_external.group_ip).await;
 }