..

Author: zeeshanlakhani

dpd-client/tests/integration_tests/mcast.rs

@@ -3842,52 +3842,46 @@ async fn test_multicast_reset_all_tables() -> TestResult {
 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 (port_id, link_id) = switch.link_id(PhysPort(28)).unwrap();
 
-    let group_ip1 = IpAddr::V4(MULTICAST_TEST_IPV4);
-    let nat_target = create_nat_target_ipv4();
-    let external_create1 = types::MulticastGroupCreateExternalEntry {
+    let group_ip1: Ipv6Addr = "ff04::100".parse().unwrap();
+    let internal_create1 = types::MulticastGroupCreateEntry {
         group_ip: group_ip1,
         tag: Some("recycling_test_1".to_string()),
-        nat_target: nat_target.clone(),
-        vlan_id: Some(10),
         sources: None,
+        members: vec![types::MulticastGroupMember {
+            port_id,
+            link_id,
+            direction: types::Direction::External,
+        }],
     };
 
     let created_group1 = switch
         .client
-        .multicast_group_create_external(&external_create1)
+        .multicast_group_create(&internal_create1)
         .await?
         .into_inner();
 
     let first_external_id = created_group1.external_group_id;
     let first_underlay_id = created_group1.underlay_group_id;
 
-    switch.client.multicast_group_delete(&group_ip1).await?;
+    switch.client.multicast_group_delete(&group_ip1.into()).await?;
 
-    let group_ip2 = IpAddr::V4(Ipv4Addr::new(224, 0, 1, 100));
-    let external_create2 = types::MulticastGroupCreateExternalEntry {
+    let group_ip2: Ipv6Addr = "ff04::101".parse().unwrap();
+    let internal_create2 = types::MulticastGroupCreateEntry {
         group_ip: group_ip2,
         tag: Some("recycling_test_2".to_string()),
-        nat_target: nat_target.clone(),
-        vlan_id: Some(10),
         sources: None,
+        members: vec![types::MulticastGroupMember {
+            port_id,
+            link_id,
+            direction: types::Direction::External,
+        }],
     };
 
     let created_group2 = switch
         .client
-        .multicast_group_create_external(&external_create2)
+        .multicast_group_create(&internal_create2)
         .await?
         .into_inner();
 
@@ -3896,22 +3890,25 @@ async fn test_multicast_group_id_recycling() -> TestResult {
         "Second group should have external group ID"
     );
     assert!(
-        created_group2.underlay_group_id.is_some(),
-        "Second group should have underlay group ID"
+        created_group2.underlay_group_id.is_none(),
+        "Second group should not have underlay group ID"
     );
 
-    let group_ip3 = IpAddr::V4(Ipv4Addr::new(224, 0, 1, 101));
-    let external_create3 = types::MulticastGroupCreateExternalEntry {
+    let group_ip3: Ipv6Addr = "ff04::102".parse().unwrap();
+    let internal_create3 = types::MulticastGroupCreateEntry {
         group_ip: group_ip3,
         tag: Some("recycling_test_3".to_string()),
-        nat_target: nat_target.clone(),
-        vlan_id: Some(10),
         sources: None,
+        members: vec![types::MulticastGroupMember {
+            port_id,
+            link_id,
+            direction: types::Direction::External,
+        }],
     };
 
     let created_group3 = switch
         .client
-        .multicast_group_create_external(&external_create3)
+        .multicast_group_create(&internal_create3)
         .await?
         .into_inner();
 
@@ -3920,13 +3917,12 @@ async fn test_multicast_group_id_recycling() -> TestResult {
         "Third group should have external group ID"
     );
     assert!(
-        created_group3.underlay_group_id.is_some(),
-        "Third group should have underlay group ID"
+        created_group3.underlay_group_id.is_none(),
+        "Third group should not 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;
+    cleanup_test_group(switch, group_ip2.into()).await;
+    cleanup_test_group(switch, group_ip3.into()).await;
 
     Ok(())
 }
@@ -3936,62 +3932,51 @@ async fn test_multicast_group_id_recycling() -> TestResult {
 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 (port_id, link_id) = switch.link_id(PhysPort(29)).unwrap();
 
     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, 1, 50 + i));
-        let nat_target = create_nat_target_ipv4();
-        let external_create = types::MulticastGroupCreateExternalEntry {
+        let group_ip: Ipv6Addr = format!("ff04::{}", 200 + i).parse().unwrap();
+        let internal_create = types::MulticastGroupCreateEntry {
             group_ip,
             tag: Some(format!("id_reuse_test_{}", i)),
-            nat_target,
-            vlan_id: Some(10),
             sources: None,
+            members: vec![types::MulticastGroupMember {
+                port_id,
+                link_id,
+                direction: types::Direction::External,
+            }],
         };
 
         let created_group = switch
             .client
-            .multicast_group_create_external(&external_create)
+            .multicast_group_create(&internal_create)
             .await?
             .into_inner();
 
         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.client.multicast_group_delete(&group_ip).await?;
+        switch.client.multicast_group_delete(&group_ip.into()).await?;
     }
 
-    let new_group_ip = IpAddr::V4(Ipv4Addr::new(224, 0, 1, 200));
-    let nat_target = create_nat_target_ipv4();
-    let new_external_create = types::MulticastGroupCreateExternalEntry {
+    let new_group_ip: Ipv6Addr = "ff04::300".parse().unwrap();
+    let new_internal_create = types::MulticastGroupCreateEntry {
         group_ip: new_group_ip,
         tag: Some("id_reuse_verification".to_string()),
-        nat_target,
-        vlan_id: Some(10),
         sources: None,
+        members: vec![types::MulticastGroupMember {
+            port_id,
+            link_id,
+            direction: types::Direction::External,
+        }],
     };
 
     let new_created_group = switch
         .client
-        .multicast_group_create_external(&new_external_create)
+        .multicast_group_create(&new_internal_create)
         .await?
         .into_inner();
 
@@ -4006,19 +3991,7 @@ async fn test_multicast_group_id_reuse() -> TestResult {
         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;
+    cleanup_test_group(switch, new_group_ip.into()).await;
 
     Ok(())
 }
@@ -4028,36 +4001,27 @@ async fn test_multicast_group_id_reuse() -> TestResult {
 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 (port_id, link_id) = switch.link_id(PhysPort(30)).unwrap();
 
     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, 2, 10 + i as u8));
-        let nat_target = create_nat_target_ipv4();
-        let external_create = types::MulticastGroupCreateExternalEntry {
+        let group_ip: Ipv6Addr = format!("ff04::{}", 400 + i).parse().unwrap();
+        let internal_create = types::MulticastGroupCreateEntry {
             group_ip,
             tag: Some(format!("pool_test_{}", i)),
-            nat_target,
-            vlan_id: Some(10),
             sources: None,
+            members: vec![types::MulticastGroupMember {
+                port_id,
+                link_id,
+                direction: types::Direction::External,
+            }],
         };
 
         let created_group = switch
             .client
-            .multicast_group_create_external(&external_create)
+            .multicast_group_create(&internal_create)
             .await?
             .into_inner();
 
@@ -4073,24 +4037,26 @@ async fn test_multicast_group_id_pool_exhaustion_recovery() -> TestResult {
 
     let groups_to_delete = &created_groups[0..num_groups / 2];
     for (group_ip, _) in groups_to_delete {
-        switch.client.multicast_group_delete(group_ip).await?;
+        switch.client.multicast_group_delete(&(*group_ip).into()).await?;
     }
 
     let mut new_groups = Vec::new();
     for i in 0..num_groups / 2 {
-        let group_ip = IpAddr::V4(Ipv4Addr::new(224, 0, 3, 10 + i as u8));
-        let nat_target = create_nat_target_ipv4();
-        let external_create = types::MulticastGroupCreateExternalEntry {
+        let group_ip: Ipv6Addr = format!("ff04::{}", 500 + i).parse().unwrap();
+        let internal_create = types::MulticastGroupCreateEntry {
             group_ip,
             tag: Some(format!("pool_recovery_test_{}", i)),
-            nat_target,
-            vlan_id: Some(10),
             sources: None,
+            members: vec![types::MulticastGroupMember {
+                port_id,
+                link_id,
+                direction: types::Direction::External,
+            }],
         };
 
         let created_group = switch
             .client
-            .multicast_group_create_external(&external_create)
+            .multicast_group_create(&internal_create)
             .await?
             .into_inner();
 
@@ -4110,18 +4076,17 @@ async fn test_multicast_group_id_pool_exhaustion_recovery() -> TestResult {
             "New group should have external group ID"
         );
         assert!(
-            group.underlay_group_id.is_some(),
-            "New group should have underlay group ID"
+            group.underlay_group_id.is_none(),
+            "New group should not have underlay group ID"
         );
     }
 
     for (group_ip, _) in &created_groups[num_groups / 2..] {
-        cleanup_test_group(switch, *group_ip).await;
+        cleanup_test_group(switch, (*group_ip).into()).await;
     }
     for (group_ip, _) in &new_groups {
-        cleanup_test_group(switch, *group_ip).await;
+        cleanup_test_group(switch, (*group_ip).into()).await;
     }
-    cleanup_test_group(switch, internal_multicast_ip).await;
 
     Ok(())
 }