update cli and selector pkg to byte quantity for memory filters

Author: bwagner5

cmd/examples/example1.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 
+	"github.com/aws/amazon-ec2-instance-selector/pkg/bytequantity"
 	"github.com/aws/amazon-ec2-instance-selector/pkg/selector"
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/session"
@@ -27,10 +28,10 @@ func main() {
 		LowerBound: 2,
 		UpperBound: 4,
 	}
-	// Instantiate a float64 range filter to specify min and max memory in GiB
-	memoryRange := selector.Float64RangeFilter{
-		LowerBound: 1.0,
-		UpperBound: 4.0,
+	// Instantiate a byte quantity range filter to specify min and max memory in GiB
+	memoryRange := selector.ByteQuantityRangeFilter{
+		LowerBound: bytequantity.FromGiB(2),
+		UpperBound: bytequantity.FromGiB(4),
 	}
 	// Create a string for the CPU Architecture so that it can be passed as a pointer
 	// when creating the Filter struct

cmd/main.go

@@ -116,11 +116,11 @@ Full docs can be found at github.com/aws/amazon-` + binName
 	// Filter Flags - These will be grouped at the top of the help flags
 
 	cli.IntMinMaxRangeFlags(vcpus, cli.StringMe("c"), nil, "Number of vcpus available to the instance type.")
-	cli.Float64MinMaxRangeFlags(memory, cli.StringMe("m"), nil, "Amount of Memory available in GiB (Example: 4)")
+	cli.ByteQuantityMinMaxRangeFlags(memory, cli.StringMe("m"), nil, "Amount of Memory available in GiB (Example: 4)")
 	cli.RatioFlag(vcpusToMemoryRatio, nil, nil, "The ratio of vcpus to memory in MiB. (Example: 1:2)")
 	cli.StringFlag(cpuArchitecture, cli.StringMe("a"), nil, "CPU architecture [x86_64, i386, or arm64]", nil)
 	cli.IntMinMaxRangeFlags(gpus, cli.StringMe("g"), nil, "Total Number of GPUs (Example: 4)")
-	cli.Float64MinMaxRangeFlags(gpuMemoryTotal, nil, nil, "Number of GPUs' total memory in GiB (Example: 4)")
+	cli.ByteQuantityMinMaxRangeFlags(gpuMemoryTotal, nil, nil, "Number of GPUs' total memory in GiB (Example: 4)")
 	cli.StringFlag(placementGroupStrategy, nil, nil, "Placement group strategy: [cluster, partition, spread]", nil)
 	cli.StringFlag(usageClass, cli.StringMe("u"), nil, "Usage class: [spot or on-demand]", nil)
 	cli.StringFlag(rootDeviceType, nil, nil, "Supported root device types: [ebs or instance-store]", nil)
@@ -189,11 +189,11 @@ Full docs can be found at github.com/aws/amazon-` + binName
 
 	filters := selector.Filters{
 		VCpusRange:             cli.IntRangeMe(flags[vcpus]),
-		MemoryRange:            cli.Float64RangeMe(flags[memory]),
+		MemoryRange:            cli.ByteQuantityRangeMe(flags[memory]),
 		VCpusToMemoryRatio:     cli.Float64Me(flags[vcpusToMemoryRatio]),
 		CPUArchitecture:        cli.StringMe(flags[cpuArchitecture]),
 		GpusRange:              cli.IntRangeMe(flags[gpus]),
-		GpuMemoryRange:         cli.Float64RangeMe(flags[gpuMemoryTotal]),
+		GpuMemoryRange:         cli.ByteQuantityRangeMe(flags[gpuMemoryTotal]),
 		PlacementGroupStrategy: cli.StringMe(flags[placementGroupStrategy]),
 		UsageClass:             cli.StringMe(flags[usageClass]),
 		RootDeviceType:         cli.StringMe(flags[rootDeviceType]),

pkg/cli/cli.go

@@ -20,6 +20,7 @@ import (
 	"reflect"
 	"strings"
 
+	"github.com/aws/amazon-ec2-instance-selector/pkg/bytequantity"
 	"github.com/aws/amazon-ec2-instance-selector/pkg/selector"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
@@ -42,6 +43,7 @@ func New(binaryName string, shortUsage string, longUsage, examples string, run r
 		nilDefaults: map[string]bool{},
 		rangeFlags:  map[string]bool{},
 		validators:  map[string]validator{},
+		processors:  map[string]processor{},
 		suiteFlags:  pflag.NewFlagSet("suite", pflag.ExitOnError),
 	}
 }
@@ -52,24 +54,23 @@ func (cl *CommandLineInterface) ParseFlags() (map[string]interface{}, error) {
 	// Remove Suite Flags so that args only include Config and Filter Flags
 	cl.Command.SetArgs(removeIntersectingArgs(cl.suiteFlags))
 	// This parses Config and Filter flags only
-	err := cl.Command.Execute()
-	if err != nil {
+	if err := cl.Command.Execute(); err != nil {
 		return nil, err
 	}
+
 	// Remove Config and Filter flags so that only suite flags are parsed
-	err = cl.suiteFlags.Parse(removeIntersectingArgs(cl.Command.Flags()))
-	if err != nil {
+	if err := cl.suiteFlags.Parse(removeIntersectingArgs(cl.Command.Flags())); err != nil {
 		return nil, err
 	}
+
 	// Add suite flags to Command flagset so that other processing can occur
 	// This has to be done after usage is printed so that the flagsets can be grouped properly when printed
 	cl.Command.Flags().AddFlagSet(cl.suiteFlags)
-	err = cl.SetUntouchedFlagValuesToNil()
-	if err != nil {
+	if err := cl.SetUntouchedFlagValuesToNil(); err != nil {
 		return nil, err
 	}
-	err = cl.ProcessRangeFilterFlags()
-	if err != nil {
+
+	if err := cl.ProcessFlags(); err != nil {
 		return nil, err
 	}
 	return cl.Flags, nil
@@ -82,13 +83,29 @@ func (cl *CommandLineInterface) ParseAndValidateFlags() (map[string]interface{},
 	if err != nil {
 		return nil, err
 	}
-	err = cl.ValidateFlags()
-	if err != nil {
+	if err := cl.ValidateFlags(); err != nil {
 		return nil, err
 	}
 	return flags, nil
 }
 
+// ProcessFlags iterates through any registered processors and executes them
+// Processors are executed before validators
+func (cl *CommandLineInterface) ProcessFlags() error {
+	for flagName, processorFn := range cl.processors {
+		if processorFn == nil {
+			continue
+		}
+		if err := processorFn(cl.Flags[flagName]); err != nil {
+			return err
+		}
+	}
+	if err := cl.ProcessRangeFilterFlags(); err != nil {
+		return err
+	}
+	return nil
+}
+
 // ValidateFlags iterates through any registered validators and executes them
 func (cl *CommandLineInterface) ValidateFlags() error {
 	for flagName, validationFn := range cl.validators {
@@ -164,8 +181,8 @@ func (cl *CommandLineInterface) SetUntouchedFlagValuesToNil() error {
 				if reflect.ValueOf(*v).IsZero() {
 					cl.Flags[f.Name] = nil
 				}
-			case *float64:
-				if reflect.ValueOf(*v).IsZero() {
+			case *bytequantity.ByteQuantity:
+				if v.Quantity == 0 {
 					cl.Flags[f.Name] = nil
 				}
 			case *string:
@@ -212,15 +229,19 @@ func (cl *CommandLineInterface) ProcessRangeFilterFlags() error {
 			switch cl.Flags[rangeHelperMax].(type) {
 			case *int:
 				cl.Flags[rangeHelperMin] = cl.IntMe(0)
-			case *float64:
-				cl.Flags[rangeHelperMin] = cl.Float64Me(0)
+			case *bytequantity.ByteQuantity:
+				cl.Flags[rangeHelperMin] = cl.ByteQuantityMe(bytequantity.ByteQuantity{Quantity: 0})
+			default:
+				return fmt.Errorf("Unable to set %s", rangeHelperMax)
 			}
 		} else if cl.Flags[rangeHelperMax] == nil {
 			switch cl.Flags[rangeHelperMin].(type) {
 			case *int:
 				cl.Flags[rangeHelperMax] = cl.IntMe(maxInt)
-			case *float64:
-				cl.Flags[rangeHelperMax] = cl.Float64Me(maxFloat64)
+			case *bytequantity.ByteQuantity:
+				cl.Flags[rangeHelperMax] = cl.ByteQuantityMe(bytequantity.ByteQuantity{Quantity: maxUint64})
+			default:
+				return fmt.Errorf("Unable to set %s", rangeHelperMin)
 			}
 		}
 
@@ -230,13 +251,12 @@ func (cl *CommandLineInterface) ProcessRangeFilterFlags() error {
 				LowerBound: *cl.IntMe(cl.Flags[rangeHelperMin]),
 				UpperBound: *cl.IntMe(cl.Flags[rangeHelperMax]),
 			}
-		case *float64:
-			cl.Flags[flagName] = &selector.Float64RangeFilter{
-				LowerBound: *cl.Float64Me(cl.Flags[rangeHelperMin]),
-				UpperBound: *cl.Float64Me(cl.Flags[rangeHelperMax]),
+		case *bytequantity.ByteQuantity:
+			cl.Flags[flagName] = &selector.ByteQuantityRangeFilter{
+				LowerBound: *cl.ByteQuantityMe(cl.Flags[rangeHelperMin]),
+				UpperBound: *cl.ByteQuantityMe(cl.Flags[rangeHelperMax]),
 			}
 		}
-
 	}
 	return nil
 }