Added set-resources to the capsule CLI cmd

cmd/common/prompt.go

@@ -64,6 +64,11 @@ var ValidateBoolOpt = func(inp *textinput.TextInput) *textinput.TextInput {
 	return inp
 }
 
+var ValidateQuantityOpt = func(inp *textinput.TextInput) *textinput.TextInput {
+	inp.Validate = ValidateQuantity
+	return inp
+}
+
 var InputDefaultOpt = func(def string) GetInputOption {
 	return func(inp *textinput.TextInput) *textinput.TextInput {
 		inp.InitialValue = def
@@ -99,6 +104,7 @@ func PromptPassword(label string) (string, error) {
 
 func PromptSelect(label string, choices []string) (int, string, error) {
 	sp := selection.New(label, choices)
+	sp.Filter = nil
 	sp.PageSize = 4
 	choice, err := sp.RunPrompt()
 	if err != nil {

cmd/common/utils.go

@@ -2,6 +2,7 @@ package common
 
 import (
 	"context"
+	"math"
 	"net/mail"
 	"net/url"
 	"regexp"
@@ -19,6 +20,7 @@ import (
 	"github.com/rigdev/rig/pkg/uuid"
 	"google.golang.org/protobuf/encoding/protojson"
 	"google.golang.org/protobuf/reflect/protoreflect"
+	"k8s.io/apimachinery/pkg/api/resource"
 )
 
 var ValidateAll = func(input string) error {
@@ -93,6 +95,11 @@ var ValidateBool = func(s string) error {
 	return nil
 }
 
+var ValidateQuantity = func(s string) error {
+	_, err := resource.ParseQuantity(s)
+	return err
+}
+
 func parseBool(s string) (bool, error) {
 	switch s {
 	case "1", "t", "T", "true", "TRUE", "True", "y", "Y", "yes", "YES", "Yes":
@@ -250,3 +257,69 @@ func FormatField(s string) string {
 func ProtoToPrettyJson(m protoreflect.ProtoMessage) string {
 	return protojson.Format(m)
 }
+
+func FormatIntToSI(n uint64, decimals int) string {
+	scale := uint64(math.Pow10(decimals))
+	n = (n * scale) / scale
+
+	suffix := ""
+	scale = 1
+	if n < 1_000 {
+		scale = 1
+		suffix = ""
+	} else if n < 1_000_000 {
+		scale = 1_000
+		suffix = "k"
+	} else if n < 1_000_000_000 {
+		scale = 1_000_000
+		suffix = "M"
+	} else if n < 1_000_000_000_000 {
+		scale = 1_000_000_000
+		suffix = "G"
+	} else {
+		scale = 1_000_000_000_000
+		suffix = "T"
+	}
+
+	result := float64(n) / float64(scale)
+	return ToStringWithSignificantDigits(result, 3) + suffix
+}
+
+func ToStringWithSignificantDigits(f float64, digits int) string {
+	sign := ""
+	if f < 0 {
+		sign = "-"
+	}
+
+	ff := math.Abs(f)
+	exponent := int(math.Max(0, math.Ceil(math.Log10(ff))))
+	ff = math.Round((ff / math.Pow10(exponent)) * math.Pow10(digits))
+
+	s := strconv.FormatInt(int64(ff), 10)
+	if s == "0" {
+		return "0"
+	}
+
+	if len(s) < exponent {
+		return sign + s + strings.Repeat("0", exponent-len(s))
+	}
+
+	integerPart := s[:exponent]
+	if exponent == 0 {
+		integerPart = "0"
+	}
+
+	fractionalPart := s[exponent:]
+	if len(s) < digits {
+		fractionalPart = strings.Repeat("0", digits-len(s)) + fractionalPart
+	}
+
+	fractionIsOnlyZeros := strings.Count(fractionalPart, "0") == len(fractionalPart)
+	if fractionIsOnlyZeros {
+		fractionalPart = ""
+	} else {
+		fractionalPart = "." + fractionalPart
+	}
+
+	return sign + integerPart + fractionalPart
+}

cmd/common/utils_test.go

@@ -0,0 +1,149 @@
+package common
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_FormatIntToSI(t *testing.T) {
+	tests := []struct {
+		name string
+		n    uint64
+		d    int
+		s    string
+	}{
+		{
+			name: "< 1000",
+			n:    234,
+			d:    3,
+			s:    "234",
+		},
+		{
+			name: "k",
+			n:    43000,
+			d:    3,
+			s:    "43k",
+		},
+		{
+			name: "k, decimals",
+			n:    12345,
+			d:    3,
+			s:    "12.3k",
+		},
+		{
+			name: "M",
+			n:    12_000_000,
+			d:    3,
+			s:    "12M",
+		},
+		{
+			name: "M decimals",
+			n:    12_345_678,
+			d:    3,
+			s:    "12.3M",
+		},
+		{
+			name: "G",
+			n:    123_000_000_000,
+			d:    3,
+			s:    "123G",
+		},
+		{
+			name: "G round away decimals",
+			n:    123_456_000_000,
+			d:    3,
+			s:    "123G",
+		},
+		{
+			name: "T",
+			n:    1_456_000_000_000,
+			d:    3,
+			s:    "1.46T",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ss := FormatIntToSI(uint64(tt.n), tt.d)
+			assert.Equal(t, tt.s, ss)
+		})
+	}
+}
+
+func Test_ToStringWithSignificantDigits(t *testing.T) {
+	tests := []struct {
+		name string
+		f    float64
+		d    int
+		s    string
+	}{
+		{
+			name: "simple",
+			f:    123,
+			d:    3,
+			s:    "123",
+		},
+		{
+			name: "integer fewer digits",
+			f:    12,
+			d:    3,
+			s:    "12",
+		},
+		{
+			name: "fractional input not fractional output",
+			f:    123.456,
+			d:    3,
+			s:    "123",
+		},
+		{
+			name: "fractional input fractional output",
+			f:    123.456,
+			d:    4,
+			s:    "123.5",
+		},
+		{
+			name: "input less than 1",
+			f:    0.123456,
+			d:    3,
+			s:    "0.123",
+		},
+		{
+			name: "input less than 1 with zeros",
+			f:    0.0123456,
+			d:    3,
+			s:    "0.012",
+		},
+		{
+			name: "input larger than precision",
+			f:    12345,
+			d:    3,
+			s:    "12300",
+		},
+		{
+			name: "becomes zero",
+			f:    0.000123,
+			d:    3,
+			s:    "0",
+		},
+		{
+			name: "negative",
+			f:    -0.123456,
+			d:    3,
+			s:    "-0.123",
+		},
+		{
+			name: "negative integer",
+			f:    -123456,
+			d:    3,
+			s:    "-123000",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ss := ToStringWithSignificantDigits(tt.f, tt.d)
+			assert.Equal(t, tt.s, ss)
+		})
+	}
+}

cmd/rig/cmd/base/auth.go

@@ -26,7 +26,6 @@ var (
 
 func CheckAuth(cmd *cobra.Command, rc rig.Client, cfg *cmd_config.Config, logger *zap.Logger) error {
 	ctx := context.Background()
-
 	if _, ok := cmd.Annotations[OmitUser]; ok {
 		return nil
 	} else if uuid.UUID(cfg.GetCurrentAuth().UserID).IsNil() {