fix(builder): refactor network_interfaces handling (#23)

- drop public IPv4 requirement during build
- new `default` IP address flag to select used interface/IP during build
- new `wait_boot` flag adds ability to wait N time for server to boot up and start all services
- add `none` communicator support
- support for IPv6 interfaces

Author: peknur

CHANGELOG.md

@@ -6,11 +6,16 @@ See updating [Changelog example here](https://keepachangelog.com/en/1.0.0/)
 ## [Unreleased]
 
 ### Added
--  add new template name param 
+- add new template name param 
+- new `default` IP address flag to select used interface/IP during build
+- new `wait_boot` flag adds ability to wait N time for server to boot up and start all services
+- add `none` communicator support
+- support for IPv6 interfaces
 
 ### Changed
 - update README file
 - update acceptance test to embed HCL2 configs 
+- drop public IPv4 interface requirement
 
 ### Fixed
 - fix network interface config

Makefile

@@ -20,7 +20,7 @@ test:
 
 test_integration: build
 	cp $(BINARY) builder/upcloud/
-	PACKER_ACC=1 go test -count 1 -v ./...  -timeout=120m
+	PACKER_ACC=1 go test -count 1 -v $(TESTARGS) ./...  -timeout=120m
 
 lint:
 	go vet .
@@ -49,6 +49,7 @@ generate: fmt install-packer-sdc
 	$(PACKER_SDC_RENDER_DOCS)
 
 fmt:
+	packer fmt builder/upcloud/test-fixtures/hcl2
 	packer fmt example/
 	packer fmt -recursive docs-partials/
 

builder/upcloud/builder.go

@@ -68,11 +68,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			Config:        &b.config,
 			GeneratedData: generatedData,
 		},
-		&communicator.StepConnect{
-			Config:    &b.config.Comm,
-			Host:      sshHostCallback,
-			SSHConfig: b.config.Comm.SSHConfigFunc(),
-		},
+		b.communicatorStep(),
 		&commonsteps.StepProvision{},
 		&commonsteps.StepCleanupTempKeys{
 			Comm: &b.config.Comm,
@@ -111,3 +107,21 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 
 	return artifact, nil
 }
+
+// CommunicatorStep returns step based on communicator type
+// We currently support only SSH communicator but 'none' type
+// can also be used for e.g. testing purposes
+func (b *Builder) communicatorStep() multistep.Step {
+	switch b.config.Comm.Type {
+	case "none":
+		return &communicator.StepConnect{
+			Config: &b.config.Comm,
+		}
+	default:
+		return &communicator.StepConnect{
+			Config:    &b.config.Comm,
+			Host:      sshHostCallback,
+			SSHConfig: b.config.Comm.SSHConfigFunc(),
+		}
+	}
+}

builder/upcloud/builder_acc_test.go

@@ -87,6 +87,9 @@ var testBuilderStorageUuidHcl string
 //go:embed test-fixtures/hcl2/storage-name.pkr.hcl
 var testBuilderStorageNameHcl string
 
+//go:embed test-fixtures/hcl2/network_interfaces.pkr.hcl
+var testBuilderNetworkInterfacesHcl string
+
 func TestBuilderAcc_default_hcl(t *testing.T) {
 	testAccPreCheck(t)
 	testCase := &acctest.PluginTestCase{
@@ -120,6 +123,28 @@ func TestBuilderAcc_storageName_hcl(t *testing.T) {
 	acctest.TestPlugin(t, testCase)
 }
 
+func TestBuilderAcc_network_interfaces(t *testing.T) {
+	testAccPreCheck(t)
+	testCase := &acctest.PluginTestCase{
+		Name:     t.Name(),
+		Template: testBuilderNetworkInterfacesHcl,
+		Check: func(buildCommand *exec.Cmd, logfile string) error {
+			re := regexp.MustCompile(`upcloud.network_interfaces: Selecting default ip '10.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}' as Server IP`)
+			log, err := readLog(logfile)
+			if err != nil {
+				return err
+			}
+			fmt.Println(log)
+			if !re.MatchString(log) {
+				return fmt.Errorf("Unable find default utility network IP from the log %s", logfile)
+			}
+			return nil
+		},
+		Teardown: teardown(t.Name()),
+	}
+	acctest.TestPlugin(t, testCase)
+}
+
 func testAccPreCheck(t *testing.T) {
 	if v := os.Getenv("UPCLOUD_API_USER"); v == "" {
 		t.Skip("UPCLOUD_API_USER must be set for acceptance tests")

builder/upcloud/config.go

@@ -16,11 +16,17 @@ import (
 	"github.com/hashicorp/packer-plugin-sdk/template/interpolate"
 )
 
+type InterfaceType string
+
 const (
-	DefaultTemplatePrefix = "custom-image"
-	DefaultSSHUsername    = "root"
-	DefaultStorageSize    = 25
-	DefaultTimeout        = 5 * time.Minute
+	DefaultTemplatePrefix               = "custom-image"
+	DefaultSSHUsername                  = "root"
+	DefaultCommunicator                 = "ssh"
+	DefaultStorageSize                  = 25
+	DefaultTimeout                      = 5 * time.Minute
+	InterfaceTypePublic   InterfaceType = upcloud.IPAddressAccessPublic
+	InterfaceTypeUtility  InterfaceType = upcloud.IPAddressAccessUtility
+	InterfaceTypePrivate  InterfaceType = upcloud.IPAddressAccessPrivate
 )
 
 var (
@@ -38,13 +44,24 @@ var (
 
 // for config type convertion
 type NetworkInterface struct {
+	// List of IP Addresses
 	IPAddresses []IPAddress `mapstructure:"ip_addresses"`
-	Type        string      `mapstructure:"type"`
-	Network     string      `mapstructure:"network,omitempty"`
+
+	// Network type (e.g. public, utility, private)
+	Type InterfaceType `mapstructure:"type"`
+
+	// Network UUID when connecting private network
+	Network string `mapstructure:"network,omitempty"`
 }
 
 type IPAddress struct {
-	Family  string `mapstructure:"family"`
+	// Default IP address. When set to `true` SSH communicator will connect to this IP after boot.
+	Default bool `mapstructure:"default"`
+
+	// IP address family (IPv4 or IPv6)
+	Family string `mapstructure:"family"`
+
+	// IP address. Note that at the moment using floating IPs is not supported.
 	Address string `mapstructure:"address,omitempty"`
 }
 
@@ -89,6 +106,9 @@ type Config struct {
 	// The amount of time to wait for resource state changes. Defaults to `5m`.
 	Timeout time.Duration `mapstructure:"state_timeout_duration"`
 
+	// The amount of time to wait after booting the server. Defaults to '0s'
+	BootWait time.Duration `mapstructure:"boot_wait"`
+
 	// The array of extra zones (locations) where created templates should be cloned.
 	// Note that default `state_timeout_duration` is not enough for cloning, better to increase a value depending on storage size.
 	CloneZones []string `mapstructure:"clone_zones"`
@@ -105,6 +125,18 @@ type Config struct {
 	ctx interpolate.Context
 }
 
+// DefaultIPaddress returns default IP address and its type (public,private,utility)
+func (c *Config) DefaultIPaddress() (*IPAddress, InterfaceType) {
+	for _, iface := range c.NetworkInterfaces {
+		for _, addr := range iface.IPAddresses {
+			if addr.Default {
+				return &addr, iface.Type
+			}
+		}
+	}
+	return nil, ""
+}
+
 func (c *Config) Prepare(raws ...interface{}) ([]string, error) {
 	err := config.Decode(c, &config.DecodeOpts{
 		Interpolate:        true,
@@ -130,7 +162,11 @@ func (c *Config) Prepare(raws ...interface{}) ([]string, error) {
 		c.Timeout = DefaultTimeout
 	}
 
-	if c.Comm.SSHUsername == "" {
+	if c.Comm.Type == "" {
+		c.Comm.Type = DefaultCommunicator
+	}
+
+	if c.Comm.Type == "ssh" && c.Comm.SSHUsername == "" {
 		c.Comm.SSHUsername = DefaultSSHUsername
 	}
 

builder/upcloud/config.hcl2spec.go

@@ -3,6 +3,7 @@ package upcloud
 import (
 	"context"
 	"fmt"
+	"time"
 
 	"github.com/UpCloudLtd/packer-plugin-upcloud/internal/driver"
 	"github.com/hashicorp/packer-plugin-sdk/multistep"
@@ -52,23 +53,36 @@ func (s *StepCreateServer) Run(_ context.Context, state multistep.StateBag) mult
 		return stepHaltWithError(state, err)
 	}
 
-	serverUuid := response.UUID
-	serverTitle := response.Title
-	serverIp, err := getServerIp(response)
-	if err != nil {
-		return stepHaltWithError(state, err)
+	ui.Say(fmt.Sprintf("Server %q created and in 'started' state", response.Title))
+
+	addr, infType := s.Config.DefaultIPaddress()
+	if addr != nil {
+		if addr.Address == "" {
+			addr, err = findIPAddressByType(response.IPAddresses, infType)
+			if err != nil {
+				return stepHaltWithError(state, err)
+			}
+		}
+		ui.Say(fmt.Sprintf("Selecting default ip '%s' as Server IP", addr.Address))
+	} else {
+		addr, err = findIPAddressByType(response.IPAddresses, InterfaceTypePublic)
+		if err != nil {
+			return stepHaltWithError(state, err)
+		}
+		ui.Say(fmt.Sprintf("Auto-selecting ip '%s' as Server IP", addr.Address))
 	}
 
-	ui.Say(fmt.Sprintf("Server %q created and in 'started' state", serverTitle))
-
-	state.Put("server_uuid", serverUuid)
-	state.Put("server_title", serverTitle)
-	state.Put("server_ip", serverIp)
-
-	s.GeneratedData.Put("ServerUUID", serverUuid)
-	s.GeneratedData.Put("ServerTitle", serverTitle)
-	s.GeneratedData.Put("ServerSize", serverIp)
+	state.Put("server_ip_address", addr)
+	state.Put("server_uuid", response.UUID)
+	state.Put("server_title", response.Title)
 
+	s.GeneratedData.Put("ServerUUID", response.UUID)
+	s.GeneratedData.Put("ServerTitle", response.Title)
+	s.GeneratedData.Put("ServerSize", response.Plan)
+	if s.Config.BootWait > 0 {
+		ui.Say(fmt.Sprintf("Waitig boot: %s", s.Config.BootWait.String()))
+		time.Sleep(s.Config.BootWait)
+	}
 	return multistep.ActionContinue
 }
 

builder/upcloud/step_create_server.go

@@ -0,0 +1,27 @@
+source "upcloud" "network_interfaces" {
+  storage_name = "Debian GNU/Linux 11 (Bullseye)"
+  storage_size = 10
+  zone         = "nl-ams1"
+
+  network_interfaces {
+    ip_addresses {
+      family = "IPv4"
+    }
+    type = "public"
+  }
+
+  network_interfaces {
+    ip_addresses {
+      default = true
+      family  = "IPv4"
+    }
+    type = "utility"
+  }
+
+  communicator = "none"
+  boot_wait    = "1m"
+}
+
+build {
+  sources = ["source.upcloud.network_interfaces"]
+}

builder/upcloud/test-fixtures/hcl2/network_interfaces.pkr.hcl

@@ -1,6 +1,7 @@
 package upcloud
 
 import (
+	"errors"
 	"fmt"
 	"time"
 
@@ -18,23 +19,43 @@ func stepHaltWithError(state multistep.StateBag, err error) multistep.StepAction
 	return multistep.ActionHalt
 }
 
-// parse public ip from server details
-func getServerIp(details *upcloud.ServerDetails) (string, error) {
-	for _, ipAddress := range details.IPAddresses {
-		if ipAddress.Access == upcloud.IPAddressAccessPublic && ipAddress.Family == upcloud.IPAddressFamilyIPv4 {
-			return ipAddress.Address, nil
+// Find IP address by type from list of IP addresses
+func findIPAddressByType(addrs upcloud.IPAddressSlice, infType InterfaceType) (*IPAddress, error) {
+	var ipv6 *IPAddress
+	for _, ipAddress := range addrs {
+		if ipAddress.Access == string(infType) {
+			switch ipAddress.Family {
+			case upcloud.IPAddressFamilyIPv4:
+				// prefer IPv4 over IPv6 - return first matching IPv4 interface if found
+				return &IPAddress{Address: ipAddress.Address, Family: ipAddress.Family}, nil
+			case upcloud.IPAddressFamilyIPv6:
+				// not returning IPv6 because there might be IPv4 address comming up in the slice
+				ipv6 = &IPAddress{Address: ipAddress.Address, Family: ipAddress.Family}
+			}
 		}
 	}
-	return "", fmt.Errorf("Unable to find the public IPv4 address of the server")
+	// return IPv6 if found
+	if ipv6 != nil {
+		return ipv6, nil
+	}
+	return nil, fmt.Errorf("Unable to find '%s' IP address", infType)
 }
 
 func getNowString() string {
 	return time.Now().Format("20060102-150405")
 }
 
-// sshHostCallback retrieves the public IPv4 address of the server
+// sshHostCallback returns server's IP addresss.
+// Note that IPv6 address needs to be enclosed in square brackets
 func sshHostCallback(state multistep.StateBag) (string, error) {
-	return state.Get("server_ip").(string), nil
+	addr, ok := state.Get("server_ip_address").(*IPAddress)
+	if !ok || addr == nil {
+		return "", errors.New("unable to get server_ip_address from state")
+	}
+	if addr.Family == upcloud.IPAddressFamilyIPv6 {
+		return fmt.Sprintf("[%s]", addr.Address), nil
+	}
+	return addr.Address, nil
 }
 
 func convertNetworkTypes(rawNetworking []NetworkInterface) []request.CreateServerInterface {
@@ -46,7 +67,7 @@ func convertNetworkTypes(rawNetworking []NetworkInterface) []request.CreateServe
 		}
 		networking = append(networking, request.CreateServerInterface{
 			IPAddresses: ips,
-			Type:        iface.Type,
+			Type:        string(iface.Type),
 			Network:     iface.Network,
 		})
 	}