feat(gateway): add commands for list & delete (#289)

Author: SCK48

CHANGELOG.md

@@ -7,6 +7,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+- Add `gateway` commands (`delete`, `list`) for Network gateway management.
+
 ## [3.3.0] - 2024-01-23
 
 ### Added

internal/commands/all/all.go

@@ -8,6 +8,7 @@ import (
 	databaseindex "github.com/UpCloudLtd/upcloud-cli/v3/internal/commands/database/index"
 	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/ipaddress"
 	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands/kubernetes"
 	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands/kubernetes/nodegroup"
@@ -188,6 +189,11 @@ func BuildCommands(rootCmd *cobra.Command, conf *config.Config) {
 	commands.BuildCommand(objectstorage.ListCommand(), objectStorageCommand.Cobra(), conf)
 	commands.BuildCommand(objectstorage.ShowCommand(), objectStorageCommand.Cobra(), conf)
 
+	// Network Gateway operations
+	gatewayCommand := commands.BuildCommand(gateway.BasegatewayCommand(), rootCmd, conf)
+	commands.BuildCommand(gateway.DeleteCommand(), gatewayCommand.Cobra(), conf)
+	commands.BuildCommand(gateway.ListCommand(), gatewayCommand.Cobra(), conf)
+
 	// Misc
 	commands.BuildCommand(
 		&root.VersionCommand{

internal/commands/gateway/delete.go

@@ -0,0 +1,48 @@
+package gateway
+
+import (
+	"fmt"
+
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands"
+	"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/UpCloudLtd/upcloud-go-api/v6/upcloud/request"
+)
+
+// DeleteCommand creates the "gateway delete" command
+func DeleteCommand() commands.Command {
+	return &deleteCommand{
+		BaseCommand: commands.New(
+			"delete",
+			"Delete a gateway",
+			"upctl gateway delete 8abc8009-4325-4b23-4321-b1232cd81231",
+			"upctl gateway delete my-gateway",
+		),
+	}
+}
+
+type deleteCommand struct {
+	*commands.BaseCommand
+	resolver.CachingGateway
+	completion.Gateway
+}
+
+// Execute implements commands.MultipleArgumentCommand
+func (c *deleteCommand) Execute(exec commands.Executor, arg string) (output.Output, error) {
+	svc := exec.All()
+	msg := fmt.Sprintf("Deleting gateway %v", arg)
+	exec.PushProgressStarted(msg)
+
+	err := svc.DeleteGateway(exec.Context(), &request.DeleteGatewayRequest{
+		UUID: arg,
+	})
+	if err != nil {
+		return commands.HandleError(exec, msg, err)
+	}
+
+	exec.PushProgressSuccess(msg)
+
+	return output.None{}, nil
+}

internal/commands/gateway/delete_test.go

@@ -0,0 +1,53 @@
+package gateway
+
+import (
+	"testing"
+
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands"
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/config"
+	smock "github.com/UpCloudLtd/upcloud-cli/v3/internal/mock"
+
+	"github.com/UpCloudLtd/upcloud-go-api/v6/upcloud"
+	"github.com/UpCloudLtd/upcloud-go-api/v6/upcloud/request"
+	"github.com/gemalto/flume"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestDeleteCommand(t *testing.T) {
+	targetMethod := "DeleteGateway"
+
+	gateway := upcloud.Gateway{
+		Name: "test-gateway",
+		UUID: "17fbd082-30b0-11eb-adc1-0242ac120003",
+	}
+
+	for _, test := range []struct {
+		name  string
+		arg   string
+		error string
+		req   request.DeleteGatewayRequest
+	}{
+		{
+			name: "delete with UUID",
+			arg:  gateway.UUID,
+			req:  request.DeleteGatewayRequest{UUID: gateway.UUID},
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			mService := smock.Service{}
+			mService.On(targetMethod, &test.req).Return(nil)
+
+			conf := config.New()
+			c := commands.BuildCommand(DeleteCommand(), nil, conf)
+
+			_, err := c.(commands.MultipleArgumentCommand).Execute(commands.NewExecutor(conf, &mService, flume.New("test")), test.arg)
+
+			if test.error != "" {
+				assert.EqualError(t, err, test.error)
+			} else {
+				assert.NoError(t, err)
+				mService.AssertNumberOfCalls(t, targetMethod, 1)
+			}
+		})
+	}
+}

internal/commands/gateway/gateway.go

@@ -0,0 +1,16 @@
+package gateway
+
+import (
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands"
+)
+
+// BasegatewayCommand creates the base "gateway" command
+func BasegatewayCommand() commands.Command {
+	return &gatewayCommand{
+		commands.New("gateway", "Manage gateways"),
+	}
+}
+
+type gatewayCommand struct {
+	*commands.BaseCommand
+}

internal/commands/gateway/list.go

@@ -0,0 +1,72 @@
+package gateway
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands"
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/output"
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/ui"
+	"github.com/UpCloudLtd/upcloud-go-api/v6/upcloud"
+	"github.com/jedib0t/go-pretty/v6/text"
+)
+
+// ListCommand creates the "gateway list" command
+func ListCommand() commands.Command {
+	return &listCommand{
+		BaseCommand: commands.New("list", "List gateways", "upctl gateway list"),
+	}
+}
+
+type listCommand struct {
+	*commands.BaseCommand
+}
+
+// ExecuteWithoutArguments implements commands.NoArgumentCommand
+func (c *listCommand) ExecuteWithoutArguments(exec commands.Executor) (output.Output, error) {
+	svc := exec.All()
+	gateways, err := svc.GetGateways(exec.Context())
+	if err != nil {
+		return nil, err
+	}
+
+	rows := []output.TableRow{}
+	for _, gtw := range gateways {
+		rows = append(rows, output.TableRow{
+			gtw.UUID,
+			gtw.Name,
+			gtw.Routers,
+			gtw.OperationalState,
+			gtw.Zone,
+		})
+	}
+
+	// For JSON and YAML output, passthrough API response
+	return output.MarshaledWithHumanOutput{
+		Value: gateways,
+		Output: output.Table{
+			Columns: []output.TableColumn{
+				{Key: "uuid", Header: "UUID", Colour: ui.DefaultUUUIDColours},
+				{Key: "name", Header: "Name"},
+				{Key: "routers", Header: "Routers", Format: formatRouters},
+				{Key: "status", Header: "Status"},
+				{Key: "zone", Header: "Zone"},
+			},
+			Rows: rows,
+		},
+	}, nil
+}
+
+func formatRouters(val interface{}) (text.Colors, string, error) {
+	routers, ok := val.([]upcloud.GatewayRouter)
+	if !ok {
+		return nil, "", fmt.Errorf("cannot parse routers from %T, expected []upcloud.GatewayRouter", val)
+	}
+
+	var rows []string
+	for _, rt := range routers {
+		rows = append(rows, ui.DefaultUUUIDColours.Sprint(rt.UUID))
+	}
+
+	return nil, strings.Join(rows, ",\n"), nil
+}

internal/completion/gateway.go

@@ -0,0 +1,28 @@
+package completion
+
+import (
+	"context"
+
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/service"
+	"github.com/spf13/cobra"
+)
+
+// Gateway implements argument completion for gateways, by uuid or name.
+type Gateway struct{}
+
+// make sure LoadBalancer implements the interface
+var _ Provider = Gateway{}
+
+// CompleteArgument implements completion.Provider
+func (s Gateway) CompleteArgument(ctx context.Context, svc service.AllServices, toComplete string) ([]string, cobra.ShellCompDirective) {
+	gateways, err := svc.GetGateways(ctx)
+	if err != nil {
+		return None(toComplete)
+	}
+	var vals []string
+	for _, gtw := range gateways {
+		vals = append(vals, gtw.UUID, gtw.Name)
+	}
+
+	return MatchStringPrefix(vals, toComplete, true), cobra.ShellCompDirectiveNoFileComp
+}

internal/mock/mock.go

@@ -65,6 +65,7 @@ var (
 	_ service.Kubernetes           = &Service{}
 	_ service.ServerGroup          = &Service{}
 	_ service.ManagedObjectStorage = &Service{}
+	_ service.Gateway              = &Service{}
 )
 
 // GetServerConfigurations implements service.Server.GetServerConfigurations
@@ -1208,3 +1209,45 @@ func (m *Service) RevokePermission(ctx context.Context, r *request.RevokePermiss
 	}
 	return nil
 }
+
+// GetGateways implements service.Gateway.GetGateways
+func (m *Service) GetGateways(_ context.Context, f ...request.QueryFilter) ([]upcloud.Gateway, error) {
+	args := m.Called(f)
+	if args[0] == nil {
+		return nil, args.Error(1)
+	}
+	return args[0].([]upcloud.Gateway), args.Error(1)
+}
+
+// DeleteGateway implements service.Gateway.DeleteGateway
+func (m *Service) DeleteGateway(_ context.Context, r *request.DeleteGatewayRequest) error {
+	args := m.Called(r)
+	return args.Error(0)
+}
+
+// CreateGateway implements service.Gateway.CreateGateway
+func (m *Service) CreateGateway(_ context.Context, r *request.CreateGatewayRequest) (*upcloud.Gateway, error) {
+	args := m.Called(r)
+	if args[0] == nil {
+		return nil, args.Error(1)
+	}
+	return args[0].(*upcloud.Gateway), args.Error(1)
+}
+
+// GetGateway implements service.Gateway.GetGateway
+func (m *Service) GetGateway(_ context.Context, r *request.GetGatewayRequest) (*upcloud.Gateway, error) {
+	args := m.Called(r)
+	if args[0] == nil {
+		return nil, args.Error(1)
+	}
+	return args[0].(*upcloud.Gateway), args.Error(1)
+}
+
+// ModifyGateway implements service.Gateway.ModifyGateway
+func (m *Service) ModifyGateway(_ context.Context, r *request.ModifyGatewayRequest) (*upcloud.Gateway, error) {
+	args := m.Called(r)
+	if args[0] == nil {
+		return nil, args.Error(1)
+	}
+	return args[0].(*upcloud.Gateway), args.Error(1)
+}

internal/resolver/gateway.go

@@ -0,0 +1,41 @@
+package resolver
+
+import (
+	"context"
+
+	internal "github.com/UpCloudLtd/upcloud-cli/v3/internal/service"
+)
+
+// CachingGatewayimplements resolver for gateways, caching the results
+type CachingGateway struct{}
+
+// make sure we implement the ResolutionProvider interface
+var _ ResolutionProvider = CachingGateway{}
+
+// Get implements ResolutionProvider.Get
+func (s CachingGateway) Get(ctx context.Context, svc internal.AllServices) (Resolver, error) {
+	gateways, err := svc.GetGateways(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return func(arg string) (uuid string, err error) {
+		rv := ""
+		for _, gtw := range gateways {
+			if MatchArgWithWhitespace(arg, gtw.Name) || gtw.UUID == arg {
+				if rv != "" {
+					return "", AmbiguousResolutionError(arg)
+				}
+				rv = gtw.UUID
+			}
+		}
+		if rv != "" {
+			return rv, nil
+		}
+		return "", NotFoundError(arg)
+	}, nil
+}
+
+// PositionalArgumentHelp implements resolver.ResolutionProvider
+func (s CachingGateway) PositionalArgumentHelp() string {
+	return helpUUIDTitle
+}