rdb: add human marshaller for instance (#1182)

Co-authored-by: Jerome Quere <[email protected]>

Author: remyleone

internal/human/marshal.go

@@ -169,8 +169,8 @@ func marshalStruct(value reflect.Value, opt *MarshalOpt) (string, error) {
 			// If type is a struct
 			// We loop through all struct field
 			data := [][]string(nil)
-			for i := 0; i < value.NumField(); i++ {
-				subData, err := marshal(value.Field(i), append(keys, value.Type().Field(i).Name))
+			for _, fieldIndex := range getStructFieldsIndex(value) {
+				subData, err := marshal(value.FieldByIndex(fieldIndex), append(keys, value.Type().FieldByIndex(fieldIndex).Name))
 				if err != nil {
 					return nil, err
 				}
@@ -207,6 +207,46 @@ func marshalStruct(value reflect.Value, opt *MarshalOpt) (string, error) {
 	return strings.TrimSpace(buffer.String()), nil
 }
 
+// getStructFieldsIndex will return a list of fieldIndex ([]int) sorted by their position in the Go struct.
+// This function will handle anonymous field and make sure that if a field is overwritten only the highest is returned.
+// You can use reflect GetFieldByIndex([]int) to get the correct field.
+func getStructFieldsIndex(v reflect.Value) [][]int {
+	// Using a map we make sure only the field with the highest order is returned for a given Name
+	found := map[string][]int{}
+
+	var recFunc func(v reflect.Value, parent []int)
+	recFunc = func(v reflect.Value, parent []int) {
+		for i := 0; i < v.NumField(); i++ {
+			field := v.Type().Field(i)
+			// If a field is anonymous we start recursive call
+			if field.Anonymous {
+				recFunc(v.Field(i), append(parent, i))
+			} else {
+				// else we add the field in the found map
+				found[field.Name] = append(parent, i)
+			}
+		}
+	}
+	recFunc(v, []int(nil))
+
+	result := [][]int(nil)
+	for _, value := range found {
+		result = append(result, value)
+	}
+
+	sort.Slice(result, func(i, j int) bool {
+		n := 0
+		for n < len(result[i]) && n < len(result[j]) {
+			if result[i][n] != result[j][n] {
+				return result[i][n] < result[j][n]
+			}
+		}
+		panic("this can never happen")
+	})
+
+	return result
+}
+
 func marshalSlice(slice reflect.Value, opt *MarshalOpt) (string, error) {
 	// Resole itemType and get rid of all pointer level if needed.
 	itemType := slice.Type().Elem()

internal/human/marshal_func.go

@@ -63,6 +63,38 @@ func init() {
 		v := i.(version.Version)
 		return v.String(), nil
 	})
+	marshalerFuncs.Store(reflect.TypeOf(scw.Duration{}), func(i interface{}, opt *MarshalOpt) (string, error) {
+		v := i.(scw.Duration)
+		const (
+			minutes = int64(60)
+			hours   = 60 * minutes
+			days    = 24 * hours
+		)
+		d := v.Seconds / days
+		h := (v.Seconds - d*days) / hours
+		m := (v.Seconds - (d*days + h*hours)) / minutes
+		s := v.Seconds % 60
+		res := []string(nil)
+		if d != 0 {
+			res = append(res, fmt.Sprintf("%d days", d))
+		}
+		if h != 0 {
+			res = append(res, fmt.Sprintf("%d hours", h))
+		}
+		if m != 0 {
+			res = append(res, fmt.Sprintf("%d minutes", m))
+		}
+		if s != 0 {
+			res = append(res, fmt.Sprintf("%d seconds", s))
+		}
+		if v.Nanos != 0 {
+			res = append(res, fmt.Sprintf("%d nanoseconds", v.Nanos))
+		}
+		if len(res) == 0 {
+			return "0 seconds", nil
+		}
+		return strings.Join(res, " "), nil
+	})
 }
 
 // TODO: implement the same logic as args.RegisterMarshalFunc(), where i must be a pointer

internal/human/marshal_test.go

@@ -40,6 +40,15 @@ type Human struct {
 	Acquaintances []*Acquaintance
 }
 
+type NestedAnonymous struct {
+	Name string
+}
+
+type Anonymous struct {
+	NestedAnonymous
+	Name string
+}
+
 type Stringer struct{}
 
 func (s Stringer) String() string {
@@ -51,7 +60,6 @@ func TestMarshal(t *testing.T) {
 		data   interface{}
 		opt    *MarshalOpt
 		result string
-		err    error
 	}
 
 	run := func(tc *testCase) func(*testing.T) {
@@ -95,7 +103,6 @@ func TestMarshal(t *testing.T) {
 			Stringer:    Stringer{},
 			StringerPtr: &Stringer{},
 		},
-		opt: nil,
 		result: `
 			String              This is a string
 			Int                 42
@@ -118,7 +125,6 @@ func TestMarshal(t *testing.T) {
 			Stringer            a stringer
 			StringerPtr         a stringer
 		`,
-		err: nil,
 	}))
 
 	t.Run("struct2", run(&testCase{
@@ -152,18 +158,25 @@ func TestMarshal(t *testing.T) {
 			Dr watson    Assistant
 			Mrs. Hudson  Landlady
 		`,
-		err: nil,
 	}))
 
 	t.Run("empty string", run(&testCase{
 		data:   "",
 		result: `-`,
-		err:    nil,
 	}))
 
 	t.Run("nil", run(&testCase{
 		data:   nil,
 		result: `-`,
-		err:    nil,
+	}))
+
+	t.Run("anonymous", run(&testCase{
+		data: &Anonymous{
+			NestedAnonymous: NestedAnonymous{
+				Name: "John",
+			},
+			Name: "Paul",
+		},
+		result: `Name  Paul`,
 	}))
 }

internal/namespaces/rdb/v1/custom.go

@@ -1,6 +1,10 @@
 package rdb
 
-import "github.com/scaleway/scaleway-cli/internal/core"
+import (
+	"github.com/scaleway/scaleway-cli/internal/core"
+	"github.com/scaleway/scaleway-cli/internal/human"
+	"github.com/scaleway/scaleway-sdk-go/api/rdb/v1"
+)
 
 var nodeTypes = []string{
 	"DB-DEV-S",
@@ -17,6 +21,9 @@ var nodeTypes = []string{
 func GetCommands() *core.Commands {
 	cmds := GetGeneratedCommands()
 
+	human.RegisterMarshalerFunc(rdb.Instance{}, instanceMarshalerFunc)
+	human.RegisterMarshalerFunc(rdb.BackupSchedule{}, backupScheduleMarshalerFunc)
+
 	cmds.Merge(core.NewCommands(
 		instanceWaitCommand(),
 	))

internal/namespaces/rdb/v1/custom_instance.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/scaleway/scaleway-cli/internal/core"
+	"github.com/scaleway/scaleway-cli/internal/human"
 	"github.com/scaleway/scaleway-sdk-go/api/rdb/v1"
 	"github.com/scaleway/scaleway-sdk-go/scw"
 )
@@ -19,6 +20,62 @@ type serverWaitRequest struct {
 	Region     scw.Region
 }
 
+func instanceMarshalerFunc(i interface{}, opt *human.MarshalOpt) (string, error) {
+	// To avoid recursion of human.Marshal we create a dummy type
+	type tmp rdb.Instance
+	instance := tmp(i.(rdb.Instance))
+
+	// Sections
+	opt.Sections = []*human.MarshalSection{
+		{
+			FieldName: "Endpoint",
+		},
+		{
+			FieldName: "Volume",
+		},
+		{
+			FieldName: "BackupSchedule",
+		},
+		{
+			FieldName: "Settings",
+		},
+	}
+
+	str, err := human.Marshal(instance, opt)
+	if err != nil {
+		return "", err
+	}
+
+	return str, nil
+}
+
+func backupScheduleMarshalerFunc(i interface{}, opt *human.MarshalOpt) (string, error) {
+	// To avoid recursion of human.Marshal we create a dummy type
+	type LocalBackupSchedule rdb.BackupSchedule
+	type tmp struct {
+		LocalBackupSchedule
+		Frequency *scw.Duration `json:"frequency"`
+		Retention *scw.Duration `json:"retention"`
+	}
+
+	backupSchedule := tmp{
+		LocalBackupSchedule: LocalBackupSchedule(i.(rdb.BackupSchedule)),
+		Frequency: &scw.Duration{
+			Seconds: int64(i.(rdb.BackupSchedule).Frequency) * 24 * 3600,
+		},
+		Retention: &scw.Duration{
+			Seconds: int64(i.(rdb.BackupSchedule).Retention) * 24 * 3600,
+		},
+	}
+
+	str, err := human.Marshal(backupSchedule, opt)
+	if err != nil {
+		return "", err
+	}
+
+	return str, nil
+}
+
 func instanceWaitCommand() *core.Command {
 	return &core.Command{
 		Short:     `Wait for an instance to reach a stable state`,

internal/namespaces/rdb/v1/custom_instance_create.go

@@ -2,6 +2,7 @@ package rdb
 
 import (
 	"context"
+	"strings"
 
 	"github.com/scaleway/scaleway-cli/internal/core"
 	"github.com/scaleway/scaleway-sdk-go/api/rdb/v1"
@@ -22,5 +23,12 @@ func instanceCreateBuilder(c *core.Command) *core.Command {
 		})
 	}
 
+	// Waiting for API to accept uppercase node-type
+	c.Interceptor = func(ctx context.Context, argsI interface{}, runner core.CommandRunner) (interface{}, error) {
+		args := argsI.(*rdb.CreateInstanceRequest)
+		args.NodeType = strings.ToLower(args.NodeType)
+		return runner(ctx, args)
+	}
+
 	return c
 }

internal/namespaces/rdb/v1/custom_instance_get_test.go

@@ -0,0 +1,21 @@
+package rdb
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/scaleway/scaleway-cli/internal/core"
+)
+
+func Test_GetInstance(t *testing.T) {
+	t.Run("Simple", core.Test(&core.TestConfig{
+		Commands: GetCommands(),
+		BeforeFunc: core.ExecStoreBeforeCmd(
+			"StartServer",
+			fmt.Sprintf("scw rdb instance create node-type=DB-DEV-S is-ha-cluster=false name=%s engine=%s user-name=%s password=%s --wait", name, engine, user, password),
+		),
+		Cmd:       "scw rdb instance get {{ .StartServer.ID }}",
+		Check:     core.TestCheckGolden(),
+		AfterFunc: core.ExecAfterCmd("scw rdb instance delete {{ .StartServer.ID }}"),
+	}))
+}

internal/namespaces/rdb/v1/testdata/test-clone-instance-simple.golden

@@ -1,33 +1,36 @@
 🎲🎲🎲 EXIT CODE: 0 🎲🎲🎲
 🟩🟩🟩 STDOUT️ 🟩🟩🟩️
-CreatedAt                 few seconds ago
-Volume.Type               lssd
-Volume.Size               25 GB
-Region                    fr-par
-ID                        2fe91a35-e819-4691-bae5-33613fc841dc
-Name                      foobar
-OrganizationID            951df375-e094-4d26-97c1-ba548eeb9c42
-Status                    ready
-Engine                    PostgreSQL-12
-Endpoint.IP               51.159.26.195
-Endpoint.Port             24332
-Settings.0.Name           work_mem
-Settings.0.Value          4
-Settings.1.Name           max_connections
-Settings.1.Value          100
-Settings.2.Name           effective_cache_size
-Settings.2.Value          1300
-Settings.3.Name           maintenance_work_mem
-Settings.3.Value          150
-Settings.4.Name           max_parallel_workers
-Settings.4.Value          0
-Settings.5.Name           max_parallel_workers_per_gather
-Settings.5.Value          0
-BackupSchedule.Frequency  24
-BackupSchedule.Retention  7
-BackupSchedule.Disabled   false
-IsHaCluster               false
-NodeType                  db-dev-m
+CreatedAt       few seconds ago
+Region          fr-par
+ID              2fe91a35-e819-4691-bae5-33613fc841dc
+Name            foobar
+OrganizationID  951df375-e094-4d26-97c1-ba548eeb9c42
+Status          ready
+Engine          PostgreSQL-12
+IsHaCluster     false
+NodeType        db-dev-m
+
+Endpoint:
+IP    51.159.26.195
+Port  24332
+
+Volume:
+Type  lssd
+Size  25 GB
+
+Backup Schedule:
+Disabled   false
+Frequency  24 days
+Retention  7 days
+
+Settings:
+NAME                             VALUE
+work_mem                         4
+max_connections                  100
+effective_cache_size             1300
+maintenance_work_mem             150
+max_parallel_workers             0
+max_parallel_workers_per_gather  0
 🟩🟩🟩 JSON STDOUT 🟩🟩🟩
 {
   "created_at": "1970-01-01T00:00:00.0Z",