feat(server): improve private cloud host selection support (#307)

Author: kangasta

CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Add `host list` command for listing private cloud hosts.
+- Add `--host` argument to `server restart` command.
+- Add `--avoid-host` and `--host` arguments to `server start` command.
+
 ### Changed
 
 - Go version bump to 1.21

internal/commands/all/all.go

@@ -9,6 +9,7 @@ import (
 	databaseproperties "github.com/UpCloudLtd/upcloud-cli/v3/internal/commands/database/properties"
 	databasesession "github.com/UpCloudLtd/upcloud-cli/v3/internal/commands/database/session"
 	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands/gateway"
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands/host"
 	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands/ipaddress"
 	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands/kubernetes"
 	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands/kubernetes/nodegroup"
@@ -202,6 +203,10 @@ func BuildCommands(rootCmd *cobra.Command, conf *config.Config) {
 	commands.BuildCommand(gateway.DeleteCommand(), gatewayCommand.Cobra(), conf)
 	commands.BuildCommand(gateway.ListCommand(), gatewayCommand.Cobra(), conf)
 
+	// Host operations
+	hostCommand := commands.BuildCommand(host.BaseHostCommand(), rootCmd, conf)
+	commands.BuildCommand(host.ListCommand(), hostCommand.Cobra(), conf)
+
 	// Misc
 	commands.BuildCommand(
 		&root.VersionCommand{

internal/commands/host/host.go

@@ -0,0 +1,16 @@
+package host
+
+import (
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands"
+)
+
+// BaseHostCommand creates the base "host" command
+func BaseHostCommand() commands.Command {
+	return &hostCommand{
+		commands.New("host", "Manage private cloud hosts"),
+	}
+}
+
+type hostCommand struct {
+	*commands.BaseCommand
+}

internal/commands/host/list.go

@@ -0,0 +1,63 @@
+package host
+
+import (
+	"fmt"
+
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands"
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/format"
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/output"
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/ui"
+	"github.com/jedib0t/go-pretty/v6/text"
+)
+
+// ListCommand creates the "host list" command
+func ListCommand() commands.Command {
+	return &listCommand{
+		BaseCommand: commands.New("list", "List private cloud hosts", "upctl host list"),
+	}
+}
+
+type listCommand struct {
+	*commands.BaseCommand
+}
+
+// ExecuteWithoutArguments implements commands.NoArgumentCommand
+func (s *listCommand) ExecuteWithoutArguments(exec commands.Executor) (output.Output, error) {
+	svc := exec.All()
+	hosts, err := svc.GetHosts(exec.Context())
+	if err != nil {
+		return nil, err
+	}
+
+	rows := []output.TableRow{}
+	for _, h := range hosts.Hosts {
+		rows = append(rows, output.TableRow{
+			h.ID,
+			h.Description,
+			h.Zone,
+			h.WindowsEnabled,
+		})
+	}
+
+	return output.MarshaledWithHumanOutput{
+		Value: hosts,
+		Output: output.Table{
+			Columns: []output.TableColumn{
+				{Key: "id", Header: "ID", Format: formatID},
+				{Key: "description", Header: "Description"},
+				{Key: "zone", Header: "Zone"},
+				{Key: "windows_enabled", Header: "Windows enabled", Format: format.Boolean},
+			},
+			Rows: rows,
+		},
+	}, nil
+}
+
+func formatID(val interface{}) (text.Colors, string, error) {
+	id, ok := val.(int)
+	if !ok {
+		return nil, "", fmt.Errorf("cannot parse IP addresses from %T, expected int", val)
+	}
+
+	return ui.DefaultUUUIDColours, fmt.Sprintf("%d", id), nil
+}

internal/commands/server/create.go

@@ -256,14 +256,14 @@ func (s *createCommand) InitCommand() {
 	fs := &pflag.FlagSet{}
 	s.params = createParams{CreateServerRequest: request.CreateServerRequest{}}
 	def := defaultCreateParams
-	fs.IntVar(&s.params.AvoidHost, "avoid-host", def.AvoidHost, "Use this to make sure VMs do not reside on specific host. Refers to value from host -attribute. Useful when building HA-environments.")
+	fs.IntVar(&s.params.AvoidHost, "avoid-host", def.AvoidHost, avoidHostDescription)
 	fs.StringVar(&s.params.BootOrder, "boot-order", def.BootOrder, "The boot device order, disk / cdrom / network or comma separated combination.")
 	fs.IntVar(&s.params.CoreNumber, "cores", def.CoreNumber, "Number of cores. Only allowed if `plan` option is set to \"custom\".")
 	config.AddToggleFlag(fs, &s.createPassword, "create-password", def.createPassword, "Create an admin password.")
 	config.AddEnableOrDisableFlag(fs, &s.firewall, def.firewall, "firewall", "firewall")
 	config.AddEnableOrDisableFlag(fs, &s.metadata, def.metadata, "metadata", "metadata service")
 	config.AddEnableOrDisableFlag(fs, &s.remoteAccess, def.remoteAccess, "remote-access", "remote access")
-	fs.IntVar(&s.params.Host, "host", def.Host, "Use this to start a VM on a specific private cloud host. Refers to value from host -attribute. Only available in private clouds.")
+	fs.IntVar(&s.params.Host, "host", def.Host, hostDescription)
 	fs.StringVar(&s.params.Hostname, "hostname", def.Hostname, "Server hostname.")
 	fs.StringArrayVar(&s.params.labels, "label", def.labels, "Labels to describe the server in `key=value` format, multiple can be declared.\nUsage: --label env=dev\n\n--label owner=operations")
 	fs.IntVar(&s.params.MemoryAmount, "memory", def.MemoryAmount, "Memory amount in MiB. Only allowed if `plan` option is set to \"custom\".")

internal/commands/server/restart.go

@@ -32,6 +32,7 @@ type restartCommand struct {
 	completion.Server
 	WaitForServerToStart bool
 	StopType             string
+	Host                 int
 	TimeoutAction        string
 	Timeout              time.Duration
 }
@@ -43,6 +44,7 @@ func (s *restartCommand) InitCommand() {
 	// TODO: reimplement? does not seem to make sense to automagically destroy
 	// servers if restart fails..
 	flags.StringVar(&s.StopType, "stop-type", defaultStopType, "The type of stop operation. Available: soft, hard")
+	flags.IntVar(&s.Host, "host", 0, hostDescription)
 	s.AddFlags(flags)
 }
 
@@ -60,6 +62,7 @@ func (s *restartCommand) Execute(exec commands.Executor, uuid string) (output.Ou
 	res, err := svc.RestartServer(exec.Context(), &request.RestartServerRequest{
 		UUID:          uuid,
 		StopType:      s.StopType,
+		Host:          s.Host,
 		Timeout:       defaultRestartTimeout,
 		TimeoutAction: "ignore",
 	})

internal/commands/server/restart_test.go

@@ -68,6 +68,19 @@ func TestRestartCommand(t *testing.T) {
 				TimeoutAction: defaultRestartTimeoutAction,
 			},
 		},
+		{
+			name: "specify host",
+			args: []string{
+				"--host", "123456",
+			},
+			restartReq: request.RestartServerRequest{
+				UUID:          Server1.UUID,
+				Host:          123456,
+				StopType:      defaultStopType,
+				Timeout:       defaultRestartTimeout,
+				TimeoutAction: defaultRestartTimeoutAction,
+			},
+		},
 	} {
 		t.Run(test.name, func(t *testing.T) {
 			conf := config.New()

internal/commands/server/server.go

@@ -18,6 +18,9 @@ const (
 	defaultRestartTimeout       = time.Duration(120) * time.Second
 	defaultRestartTimeoutAction = request.RestartTimeoutActionIgnore
 	customPlan                  = "custom"
+
+	avoidHostDescription = "Host to avoid when scheduling the server. Use this to make sure VMs do not reside on specific host. Refers to value from `host` attribute. Useful when building HA-environments."
+	hostDescription      = "Schedule the server on a specific host. Refers to value from `host` attribute. Only available in private clouds."
 )
 
 // BaseServerCommand crestes the base "server" command

internal/commands/server/start.go

@@ -7,6 +7,7 @@ import (
 	"github.com/UpCloudLtd/upcloud-cli/v3/internal/completion"
 	"github.com/UpCloudLtd/upcloud-cli/v3/internal/output"
 	"github.com/UpCloudLtd/upcloud-cli/v3/internal/resolver"
+	"github.com/spf13/pflag"
 
 	"github.com/UpCloudLtd/upcloud-go-api/v8/upcloud/request"
 )
@@ -28,10 +29,18 @@ type startCommand struct {
 	*commands.BaseCommand
 	completion.Server
 	resolver.CachingServer
+	host      int
+	avoidHost int
 }
 
 // InitCommand implements Command.InitCommand
 func (s *startCommand) InitCommand() {
+	fs := &pflag.FlagSet{}
+
+	fs.IntVar(&s.avoidHost, "avoid-host", 0, avoidHostDescription)
+	fs.IntVar(&s.host, "host", 0, hostDescription)
+
+	s.AddFlags(fs)
 }
 
 // Execute implements commands.MultipleArgumentCommand
@@ -41,7 +50,9 @@ func (s *startCommand) Execute(exec commands.Executor, uuid string) (output.Outp
 	exec.PushProgressStarted(msg)
 
 	res, err := svc.StartServer(exec.Context(), &request.StartServerRequest{
-		UUID: uuid,
+		UUID:      uuid,
+		AvoidHost: s.avoidHost,
+		Host:      s.host,
 	})
 	if err != nil {
 		return commands.HandleError(exec, msg, err)

internal/commands/server/start_test.go

@@ -52,6 +52,22 @@ func TestStartCommand(t *testing.T) {
 				UUID: Server1.UUID,
 			},
 		},
+		{
+			name: "host argument",
+			args: []string{"--host", "123456"},
+			startReq: request.StartServerRequest{
+				UUID: Server1.UUID,
+				Host: 123456,
+			},
+		},
+		{
+			name: "avoid-host argument",
+			args: []string{"--avoid-host", "987654"},
+			startReq: request.StartServerRequest{
+				UUID:      Server1.UUID,
+				AvoidHost: 987654,
+			},
+		},
 	} {
 		t.Run(test.name, func(t *testing.T) {
 			conf := config.New()