fix: do not require all nics to have an ip

Add optional ip_wait_adapter_index on vsphere-iso and vsphere-clone for
environments where multiple NICs may receive routable addresses.

Signed-off-by: Ryan Johnson <ryan@tenthirtyam.org>

Author: tenthirtyam

.web-docs/components/builder/vsphere-clone/README.md

@@ -1113,6 +1113,11 @@ wget http://{{ .HTTPIP }}:{{ .HTTPPort }}/foo/bar/preseed.cfg
   * `0:0:0:0:0:0:0:0/0` - allow only ipv6 addresses
   * `192.168.1.0/24` - only allow ipv4 addresses from 192.168.1.1 to 192.168.1.254
 
+- `ip_wait_adapter_index` (\*int) - Wait for an IP on a specific network adapter, identified by its zero-based index.
+  For `vsphere-iso`, index `0` is the first `network_adapters` block (vSphere device `ethernet-0`).
+  For `vsphere-clone`, index follows the template's ethernet device order.
+  When unset, the build proceeds when any adapter has a matching IP (see `ip_wait_address`).
+
 <!-- End of code generated from the comments of the WaitIpConfig struct in builder/vsphere/common/step_wait_for_ip.go; -->
 
 

.web-docs/components/builder/vsphere-iso/README.md

@@ -1147,6 +1147,11 @@ JSON Example:
   * `0:0:0:0:0:0:0:0/0` - allow only ipv6 addresses
   * `192.168.1.0/24` - only allow ipv4 addresses from 192.168.1.1 to 192.168.1.254
 
+- `ip_wait_adapter_index` (\*int) - Wait for an IP on a specific network adapter, identified by its zero-based index.
+  For `vsphere-iso`, index `0` is the first `network_adapters` block (vSphere device `ethernet-0`).
+  For `vsphere-clone`, index follows the template's ethernet device order.
+  When unset, the build proceeds when any adapter has a matching IP (see `ip_wait_address`).
+
 <!-- End of code generated from the comments of the WaitIpConfig struct in builder/vsphere/common/step_wait_for_ip.go; -->
 
 

builder/vsphere/clone/config.hcl2spec.go

@@ -40,6 +40,11 @@ type WaitIpConfig struct {
 	// * `192.168.1.0/24` - only allow ipv4 addresses from 192.168.1.1 to 192.168.1.254
 	WaitAddress *string `mapstructure:"ip_wait_address"`
 	ipnet       *net.IPNet
+	// Wait for an IP on a specific network adapter, identified by its zero-based index.
+	// For `vsphere-iso`, index `0` is the first `network_adapters` block (vSphere device `ethernet-0`).
+	// For `vsphere-clone`, index follows the template's ethernet device order.
+	// When unset, the build proceeds when any adapter has a matching IP (see `ip_wait_address`).
+	AdapterIndex *int `mapstructure:"ip_wait_adapter_index"`
 
 	// WaitTimeout is a total timeout. If the virtual machine changes IP frequently, and does not settle down, wait
 	// until the timeout expires.
@@ -71,6 +76,10 @@ func (c *WaitIpConfig) Prepare() []error {
 		}
 	}
 
+	if c.AdapterIndex != nil && *c.AdapterIndex < 0 {
+		errs = append(errs, fmt.Errorf("ip_wait_adapter_index must be >= 0"))
+	}
+
 	return errs
 }
 
@@ -147,7 +156,7 @@ func doGetIp(vm *driver.VirtualMachineDriver, ctx context.Context, c *WaitIpConf
 		interval = 1 * time.Second
 	}
 loop:
-	ip, err := vm.WaitForIP(ctx, c.ipnet)
+	ip, err := vm.WaitForIP(ctx, c.ipnet, c.AdapterIndex)
 	if err != nil {
 		return "", err
 	}

builder/vsphere/common/step_wait_for_ip.go

@@ -0,0 +1,24 @@
+// © Broadcom. All Rights Reserved.
+// The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.
+// SPDX-License-Identifier: MPL-2.0
+
+package common
+
+import (
+	"testing"
+)
+
+func TestWaitIpConfig_Prepare_adapterIndex(t *testing.T) {
+	neg := -1
+	c := WaitIpConfig{AdapterIndex: &neg}
+	errs := c.Prepare()
+	if len(errs) != 1 {
+		t.Fatalf("expected 1 error, got %v", errs)
+	}
+
+	zero := 0
+	c = WaitIpConfig{AdapterIndex: &zero}
+	if errs := c.Prepare(); len(errs) != 0 {
+		t.Fatalf("unexpected errors: %v", errs)
+	}
+}

builder/vsphere/common/step_wait_for_ip.hcl2spec.go

@@ -11,6 +11,7 @@ import (
 	"log"
 	"net"
 	"reflect"
+	"sort"
 	"strconv"
 	"strings"
 	"time"
@@ -41,7 +42,7 @@ type VirtualMachine interface {
 	Reconfigure(spec types.VirtualMachineConfigSpec) error
 	Customize(spec types.CustomizationSpec) error
 	ResizeDisk(diskSize int64) ([]types.BaseVirtualDeviceConfigSpec, error)
-	WaitForIP(ctx context.Context, ipNet *net.IPNet) (string, error)
+	WaitForIP(ctx context.Context, ipNet *net.IPNet, adapterIndex *int) (string, error)
 	PowerOn() error
 	PowerOff() error
 	IsPoweredOff() (bool, error)
@@ -831,30 +832,136 @@ func (vm *VirtualMachineDriver) PowerOn() error {
 	return err
 }
 
-// WaitForIP waits for the virtual machine to get an IP address.
-func (vm *VirtualMachineDriver) WaitForIP(ctx context.Context, ipNet *net.IPNet) (string, error) {
-	netIP, err := vm.vm.WaitForNetIP(ctx, false)
+// WaitForIP waits for the virtual machine to get an IP address on a guest network adapter.
+// When adapterIndex is nil, returns when any ethernet adapter has a matching address (not all adapters).
+// When adapterIndex is set, waits only on ethernet-{index}.
+func (vm *VirtualMachineDriver) WaitForIP(ctx context.Context, ipNet *net.IPNet, adapterIndex *int) (string, error) {
+	if adapterIndex != nil {
+		device := fmt.Sprintf("ethernet-%d", *adapterIndex)
+		netIP, err := vm.vm.WaitForNetIP(ctx, false, device)
+		if err != nil {
+			return "", err
+		}
+		return selectIPFromNetIP(netIP, ipNet), nil
+	}
+
+	return vm.waitForAnyNetIP(ctx, ipNet)
+}
+
+func (vm *VirtualMachineDriver) waitForAnyNetIP(ctx context.Context, ipNet *net.IPNet) (string, error) {
+	macs, err := vm.waitForEthernetMACs(ctx)
 	if err != nil {
 		return "", err
 	}
 
-	for _, ips := range netIP {
-		for _, ip := range ips {
-			parseIP := net.ParseIP(ip)
-			if ipNet != nil && !ipNet.Contains(parseIP) {
-				// IP address is not in the expected range.
+	p := property.DefaultCollector(vm.vm.Client())
+	var ip string
+	err = property.Wait(ctx, p, vm.vm.Reference(), []string{"guest.net"}, func(pc []types.PropertyChange) bool {
+		netIP := guestNetIPFromPropertyChange(pc, macs, false)
+		if candidate := selectIPFromNetIP(netIP, ipNet); candidate != "" {
+			ip = candidate
+			return true
+		}
+		return false
+	})
+	if err != nil {
+		return "", err
+	}
+
+	return ip, nil
+}
+
+func (vm *VirtualMachineDriver) waitForEthernetMACs(ctx context.Context) (map[string][]string, error) {
+	macs := make(map[string][]string)
+	p := property.DefaultCollector(vm.vm.Client())
+
+	err := property.Wait(ctx, p, vm.vm.Reference(), []string{"config.hardware.device"}, func(pc []types.PropertyChange) bool {
+		for _, c := range pc {
+			if c.Op != types.PropertyChangeOpAssign {
 				continue
 			}
-			// Default to IPv4 if no IPNet is provided.
-			if ipNet == nil && parseIP.To4() == nil {
+
+			devices := object.VirtualDeviceList(c.Val.(types.ArrayOfVirtualDevice).VirtualDevice)
+			for _, d := range devices {
+				if nic, ok := d.(types.BaseVirtualEthernetCard); ok {
+					mac := strings.ToLower(nic.GetVirtualEthernetCard().MacAddress)
+					if mac == "" {
+						return false
+					}
+					macs[mac] = nil
+				}
+			}
+		}
+
+		return true
+	})
+
+	return macs, err
+}
+
+func guestNetIPFromPropertyChange(pc []types.PropertyChange, macs map[string][]string, v4 bool) map[string][]string {
+	netIP := make(map[string][]string, len(macs))
+	for mac := range macs {
+		netIP[mac] = nil
+	}
+
+	for _, c := range pc {
+		if c.Op != types.PropertyChangeOpAssign {
+			continue
+		}
+
+		nics := c.Val.(types.ArrayOfGuestNicInfo).GuestNicInfo
+		for _, nic := range nics {
+			mac := strings.ToLower(nic.MacAddress)
+			if mac == "" || nic.IpConfig == nil {
 				continue
 			}
-			return ip, nil
+
+			for _, addr := range nic.IpConfig.IpAddress {
+				if _, ok := macs[mac]; !ok {
+					continue
+				}
+				if v4 && net.ParseIP(addr.IpAddress).To4() == nil {
+					continue
+				}
+				netIP[mac] = append(netIP[mac], addr.IpAddress)
+			}
 		}
 	}
 
-	// Unable to find an IP address.
-	return "", nil
+	return netIP
+}
+
+func selectIPFromNetIP(netIP map[string][]string, ipNet *net.IPNet) string {
+	keys := make([]string, 0, len(netIP))
+	for mac := range netIP {
+		keys = append(keys, mac)
+	}
+	sort.Strings(keys)
+
+	for _, mac := range keys {
+		for _, ip := range netIP[mac] {
+			if ipMatchesFilter(ip, ipNet) {
+				return ip
+			}
+		}
+	}
+
+	return ""
+}
+
+func ipMatchesFilter(ip string, ipNet *net.IPNet) bool {
+	parseIP := net.ParseIP(ip)
+	if parseIP == nil {
+		return false
+	}
+	if ipNet != nil && !ipNet.Contains(parseIP) {
+		return false
+	}
+	if ipNet == nil && parseIP.To4() == nil {
+		return false
+	}
+	return true
 }
 
 // PowerOff stops the virtual machine and waits for the operation to complete.

builder/vsphere/common/step_wait_for_ip_test.go

@@ -242,7 +242,7 @@ func startAndStopCheck(t *testing.T, vm VirtualMachine, config *CloneConfig) {
 	stopper := startVM(t, vm, config.Name)
 	defer stopper()
 
-	switch ip, err := vm.WaitForIP(context.TODO(), nil); {
+	switch ip, err := vm.WaitForIP(context.TODO(), nil, nil); {
 	case err != nil:
 		t.Errorf("Cannot obtain IP address from created vm '%v': %v", config.Name, err)
 	case net.ParseIP(ip) == nil:

builder/vsphere/driver/vm.go

@@ -0,0 +1,74 @@
+// © Broadcom. All Rights Reserved.
+// The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.
+// SPDX-License-Identifier: MPL-2.0
+
+package driver
+
+import (
+	"net"
+	"testing"
+)
+
+func TestSelectIPFromNetIP(t *testing.T) {
+	_, cidr, err := net.ParseCIDR("192.168.1.0/24")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	tests := []struct {
+		name  string
+		netIP map[string][]string
+		ipNet *net.IPNet
+		want  string
+	}{
+		{
+			name: "first matching mac in sort order",
+			netIP: map[string][]string{
+				"00:00:00:00:00:02": {"10.0.0.5"},
+				"00:00:00:00:00:01": {"192.168.1.10"},
+			},
+			ipNet: cidr,
+			want:  "192.168.1.10",
+		},
+		{
+			name: "skip nic without ip",
+			netIP: map[string][]string{
+				"00:00:00:00:00:01": nil,
+				"00:00:00:00:00:02": {"192.168.1.20"},
+			},
+			ipNet: cidr,
+			want:  "192.168.1.20",
+		},
+		{
+			name:  "no match",
+			netIP: map[string][]string{"00:00:00:00:00:01": {"10.0.0.1"}},
+			ipNet: cidr,
+			want:  "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := selectIPFromNetIP(tt.netIP, tt.ipNet); got != tt.want {
+				t.Fatalf("selectIPFromNetIP() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestIpMatchesFilter(t *testing.T) {
+	_, cidr, _ := net.ParseCIDR("192.168.0.0/16")
+
+	if !ipMatchesFilter("192.168.1.1", cidr) {
+		t.Fatal("expected match in cidr")
+	}
+	if ipMatchesFilter("10.0.0.1", cidr) {
+		t.Fatal("expected no match outside cidr")
+	}
+	if !ipMatchesFilter("10.0.0.1", nil) {
+		t.Fatal("expected ipv4 match with nil ipNet")
+	}
+	if ipMatchesFilter("2001:db8::1", nil) {
+		t.Fatal("expected ipv6 skip with nil ipNet")
+	}
+}

builder/vsphere/driver/vm_clone_acc_test.go

@@ -155,7 +155,7 @@ func (vm *VirtualMachineMock) PowerOn() error {
 	return nil
 }
 
-func (vm *VirtualMachineMock) WaitForIP(ctx context.Context, ipNet *net.IPNet) (string, error) {
+func (vm *VirtualMachineMock) WaitForIP(ctx context.Context, ipNet *net.IPNet, adapterIndex *int) (string, error) {
 	return "", nil
 }