networkutils: update RDMA network creation

- Only use a single MRDMA net/subnet for each MRDMA NIC.
- Handle the unique naming scheme and stack requirements for `metal` RDMA networks.

PiperOrigin-RevId: 951585553

Author: a-r-n

utils/networkutils/networkutils.go

@@ -244,20 +244,20 @@ func daisyNetworkForIRDMANIC(index int, project string, zone string, isMetal boo
 		Network: compute.Network{
 			Name:           fmt.Sprintf("irdma-network-%d", index),
 			Mtu:            int64(imagetest.JumboFramesMTU),
-			NetworkProfile: fmt.Sprintf("https://www.googleapis.com/compute/v1/projects/%s/global/networkProfiles/%s-vpc-falcon", project, zone),
+			NetworkProfile: fmt.Sprintf("projects/%s/global/networkProfiles/%s-vpc-falcon", project, zone),
 		},
 		AutoCreateSubnetworks: new(bool),
 	}
 }
 
 func daisyNetworkForMRDMANIC(index int, project string, zone string, isMetal bool) *daisy.Network {
-	networkProfile := fmt.Sprintf("https://www.googleapis.com/compute/v1/projects/%s/global/networkProfiles/%s-vpc-roce", project, zone)
+	networkProfile := fmt.Sprintf("projects/%s/global/networkProfiles/%s-vpc-roce", project, zone)
 	if isMetal {
 		networkProfile += "-metal"
 	}
 	return &daisy.Network{
 		Network: compute.Network{
-			Name:           fmt.Sprintf("mrdma-network-%d", index),
+			Name:           "mrdma-network",
 			Mtu:            int64(imagetest.JumboFramesMTU),
 			NetworkProfile: networkProfile,
 		},
@@ -297,13 +297,27 @@ func regionFromZone(zone string) (string, error) {
 	return strings.Join(parts[:2], "-"), nil
 }
 
-func daisySubnet(index int, zone string) (*daisy.Subnetwork, error) {
-	netPrefix, err := subnetPrefix(index)
+func daisySubnet(daisyNetwork *daisy.Network, index int, zone string) (*daisy.Subnetwork, error) {
+	region, err := regionFromZone(zone)
 	if err != nil {
 		return nil, err
 	}
 
-	region, err := regionFromZone(zone)
+	if strings.HasSuffix(daisyNetwork.NetworkProfile, "-metal") {
+		return &daisy.Subnetwork{
+			Subnetwork: compute.Subnetwork{
+				Name:           fmt.Sprintf("default-subnet-1-%s", daisyNetwork.Name),
+				StackType:      "IPV6_ONLY",
+				Ipv6AccessType: "INTERNAL",
+				Region:         region,
+			},
+			Resource: daisy.Resource{
+				NoCleanup: true,
+			},
+		}, nil
+	}
+
+	netPrefix, err := subnetPrefix(index)
 	if err != nil {
 		return nil, err
 	}
@@ -341,32 +355,43 @@ type CreateMachineWithNetworksOptions struct {
 // It registers the networks and subnetwork creations with the test workflow.
 func CreateMachineWithNetworks(t *imagetest.TestWorkflow, o *CreateMachineWithNetworksOptions) (*daisy.Instance, error) {
 	m := &daisy.Instance{}
+	createdNetworks := make(map[string]*imagetest.Network)
+	createdSubnetworks := make(map[string]bool)
 
 	for nicIndex, nicType := range o.NicTypes {
 		daisyNetwork, err := daisyNetworkForNIC(nicType, nicIndex, o.Project, o.Zone, imagetest.IsMetal(o.MachineType))
 		if err != nil {
 			return nil, fmt.Errorf("building daisy network: %w", err)
 		}
 
-		daisySubnet, err := daisySubnet(nicIndex, o.Zone)
-		if err != nil {
-			return nil, fmt.Errorf("building daisy subnetwork: %w", err)
+		citNetwork, ok := createdNetworks[daisyNetwork.Name]
+		if !ok {
+			citNetwork, err = t.CreateNetworkFromDaisyNetwork(daisyNetwork)
+			if err != nil {
+				return nil, fmt.Errorf("creating network: %w", err)
+			}
+			createdNetworks[daisyNetwork.Name] = citNetwork
 		}
 
-		citNetwork, err := t.CreateNetworkFromDaisyNetwork(daisyNetwork)
+		daisySub, err := daisySubnet(daisyNetwork, nicIndex, o.Zone)
 		if err != nil {
-			return nil, fmt.Errorf("creating network: %w", err)
+			return nil, fmt.Errorf("building daisy subnetwork: %w", err)
 		}
 
-		if _, err = citNetwork.CreateSubnetworkFromDaisySubnetwork(daisySubnet); err != nil {
-			return nil, fmt.Errorf("creating subnetwork: %w", err)
+		if !createdSubnetworks[daisySub.Name] {
+			if _, err = citNetwork.CreateSubnetworkFromDaisySubnetwork(daisySub); err != nil {
+				return nil, fmt.Errorf("creating subnetwork: %w", err)
+			}
+			createdSubnetworks[daisySub.Name] = true
 		}
 
 		m.NetworkInterfaces = append(m.NetworkInterfaces, &compute.NetworkInterface{
-			NicType:       nicType,
-			Network:       daisyNetwork.Name,
-			Subnetwork:    daisySubnet.Name,
-			AccessConfigs: accessConfigsForNIC(nicType),
+			NicType:        nicType,
+			Network:        daisyNetwork.Name,
+			Subnetwork:     daisySub.Name,
+			StackType:      daisySub.StackType,
+			Ipv6AccessType: daisySub.Ipv6AccessType,
+			AccessConfigs:  accessConfigsForNIC(nicType),
 		})
 	}
 

utils/networkutils/networkutils_test.go

@@ -481,7 +481,7 @@ func TestDaisyNetworkForNIC(t *testing.T) {
 				Network: compute.Network{
 					Name:           "irdma-network-0",
 					Mtu:            8896,
-					NetworkProfile: "https://www.googleapis.com/compute/v1/projects/test-project/global/networkProfiles/us-central1-a-vpc-falcon",
+					NetworkProfile: "projects/test-project/global/networkProfiles/us-central1-a-vpc-falcon",
 				},
 				AutoCreateSubnetworks: new(bool),
 			},
@@ -494,9 +494,9 @@ func TestDaisyNetworkForNIC(t *testing.T) {
 			zone:    "europe-central2-a",
 			want: &daisy.Network{
 				Network: compute.Network{
-					Name:           "mrdma-network-0",
+					Name:           "mrdma-network",
 					Mtu:            8896,
-					NetworkProfile: "https://www.googleapis.com/compute/v1/projects/test-project/global/networkProfiles/europe-central2-a-vpc-roce",
+					NetworkProfile: "projects/test-project/global/networkProfiles/europe-central2-a-vpc-roce",
 				},
 				AutoCreateSubnetworks: new(bool),
 			},
@@ -510,9 +510,9 @@ func TestDaisyNetworkForNIC(t *testing.T) {
 			isMetal: true,
 			want: &daisy.Network{
 				Network: compute.Network{
-					Name:           "mrdma-network-0",
+					Name:           "mrdma-network",
 					Mtu:            8896,
-					NetworkProfile: "https://www.googleapis.com/compute/v1/projects/test-project/global/networkProfiles/asia-southeast2-b-vpc-roce-metal",
+					NetworkProfile: "projects/test-project/global/networkProfiles/asia-southeast2-b-vpc-roce-metal",
 				},
 				AutoCreateSubnetworks: new(bool),
 			},
@@ -534,16 +534,18 @@ func TestDaisyNetworkForNIC(t *testing.T) {
 
 func TestDaisySubnet(t *testing.T) {
 	cases := []struct {
-		name    string
-		index   int
-		zone    string
-		want    *daisy.Subnetwork
-		wantErr bool
+		name         string
+		daisyNetwork *daisy.Network
+		index        int
+		zone         string
+		want         *daisy.Subnetwork
+		wantErr      bool
 	}{
 		{
-			name:  "index 0",
-			index: 0,
-			zone:  "us-central1-a",
+			name:         "general purpose subnet",
+			daisyNetwork: &daisy.Network{Network: compute.Network{Name: "net-0"}},
+			index:        0,
+			zone:         "us-central1-a",
 			want: &daisy.Subnetwork{
 				Subnetwork: compute.Subnetwork{
 					Name:        "subnet-0",
@@ -553,9 +555,10 @@ func TestDaisySubnet(t *testing.T) {
 			},
 		},
 		{
-			name:  "index 1",
-			index: 1,
-			zone:  "europe-west1-b",
+			name:         "index 1",
+			daisyNetwork: &daisy.Network{Network: compute.Network{Name: "net-1"}},
+			index:        1,
+			zone:         "europe-west1-b",
 			want: &daisy.Subnetwork{
 				Subnetwork: compute.Subnetwork{
 					Name:        "subnet-1",
@@ -565,26 +568,60 @@ func TestDaisySubnet(t *testing.T) {
 			},
 		},
 		{
-			name:    "index too low",
-			index:   -1,
-			wantErr: true,
+			name:         "MRDMA metal NetworkProfile subnet",
+			daisyNetwork: &daisy.Network{Network: compute.Network{Name: "mrdma-network", NetworkProfile: "projects/p/global/networkProfiles/zone-vpc-roce-metal"}},
+			index:        0,
+			zone:         "us-central1-a",
+			want: &daisy.Subnetwork{
+				Subnetwork: compute.Subnetwork{
+					Name:           "default-subnet-1-mrdma-network",
+					StackType:      "IPV6_ONLY",
+					Ipv6AccessType: "INTERNAL",
+					Region:         "us-central1",
+				},
+				Resource: daisy.Resource{
+					NoCleanup: true,
+				},
+			},
 		},
 		{
-			name:    "index too high",
-			index:   256,
-			wantErr: true,
+			name:         "MRDMA virtual NetworkProfile subnet",
+			daisyNetwork: &daisy.Network{Network: compute.Network{Name: "mrdma-network", NetworkProfile: "projects/p/global/networkProfiles/zone-vpc-roce"}},
+			index:        0,
+			zone:         "us-central1-a",
+			want: &daisy.Subnetwork{
+				Subnetwork: compute.Subnetwork{
+					Name:        "subnet-0",
+					IpCidrRange: "10.0.0.0/24",
+					Region:      "us-central1",
+				},
+			},
+		},
+		{
+			name:         "index too low",
+			daisyNetwork: &daisy.Network{Network: compute.Network{Name: "net-0"}},
+			index:        -1,
+			zone:         "us-central1-a",
+			wantErr:      true,
+		},
+		{
+			name:         "index too high",
+			daisyNetwork: &daisy.Network{Network: compute.Network{Name: "net-0"}},
+			index:        256,
+			zone:         "us-central1-a",
+			wantErr:      true,
 		},
 	}
 
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			got, err := daisySubnet(tc.index, tc.zone)
+			got, err := daisySubnet(tc.daisyNetwork, tc.index, tc.zone)
 			if (err != nil) != tc.wantErr {
-				t.Errorf("daisySubnet(%d, %q) returned error %v, wantErr %t", tc.index, tc.zone, err, tc.wantErr)
+				t.Errorf("daisySubnet(%v, %d, %q) returned error %v, wantErr %t", tc.daisyNetwork, tc.index, tc.zone, err, tc.wantErr)
 				return
 			}
 			if diff := diffDaisy(got, tc.want); diff != "" {
-				t.Errorf("daisySubnet(%d, %q) = doesn't match expectations: diff (-got +want):\n%s", tc.index, tc.zone, diff)
+				t.Errorf("daisySubnet(%v, %d, %q) = doesn't match expectations: diff (-got +want):\n%s", tc.daisyNetwork, tc.index, tc.zone, diff)
 			}
 		})
 	}