On-Demand and Spot Price Retrieval Filters w/ a Cache (#73)

* Fetch pricing for ondemand instances and spot w/ cache implementation

* remove unnecessary caps on flag docs and clarified sum var name in ec2pricing

Author: bwagner5

README.md

@@ -79,50 +79,64 @@ $ export AWS_REGION="us-east-1"
 ```
 $ ec2-instance-selector --memory 4 --vcpus 2 --cpu-architecture x86_64 -r us-east-1
 c5.large
+c5a.large
+c5ad.large
 c5d.large
 t2.medium
 t3.medium
 t3a.medium
 ```
 
-**Find instance types that support 100GB/s networking**
+**Find instance types that support 100GB/s networking that can be purchased as spot instances**
 ```
-$ ec2-instance-selector --network-performance 100 -r us-east-1
+$ ec2-instance-selector --network-performance 100 --usage-class spot -r us-east-1
 c5n.18xlarge
 c5n.metal
+c6gn.16xlarge
+g4dn.metal
 i3en.24xlarge
 i3en.metal
 inf1.24xlarge
 m5dn.24xlarge
+m5dn.metal
 m5n.24xlarge
+m5n.metal
+m5zn.12xlarge
+m5zn.metal
 p3dn.24xlarge
+p4d.24xlarge
 r5dn.24xlarge
+r5dn.metal
 r5n.24xlarge
+r5n.metal
 ```
 
 **Short Table Output**
 ```
 $ ec2-instance-selector --memory 4 --vcpus 2 --cpu-architecture x86_64 -r us-east-1 -o table
 Instance Type        VCPUs        Mem (GiB)
 -------------        -----        ---------
-c5.large             2            4.000
-c5d.large            2            4.000
-t2.medium            2            4.000
-t3.medium            2            4.000
-t3a.medium           2            4.000
+c5.large             2            4
+c5a.large            2            4
+c5ad.large           2            4
+c5d.large            2            4
+t2.medium            2            4
+t3.medium            2            4
+t3a.medium           2            4
 ```
 
 **Wide Table Output**
 ```
 $ ec2-instance-selector --memory 4 --vcpus 2 --cpu-architecture x86_64 -r us-east-1 -o table-wide
-Instance Type  VCPUs   Mem (GiB)  Hypervisor  Current Gen  Hibernation Support  CPU Arch      Network Performance  ENIs    GPUs    
--------------  -----   ---------  ----------  -----------  -------------------  --------      -------------------  ----    ----    
-c5.large       2       4.000      nitro       true         true                 x86_64        Up to 10 Gigabit     3       0       
-c5a.large      2       4.000      nitro       true         false                x86_64        Up to 10 Gigabit     3       0       
-c5d.large      2       4.000      nitro       true         false                x86_64        Up to 10 Gigabit     3       0       
-t2.medium      2       4.000      xen         true         true                 i386, x86_64  Low to Moderate      3       0       
-t3.medium      2       4.000      nitro       true         false                x86_64        Up to 5 Gigabit      3       0       
-t3a.medium     2       4.000      nitro       true         false                x86_64        Up to 5 Gigabit      3       0     
+Instance Type  VCPUs   Mem (GiB)  Hypervisor  Current Gen  Hibernation Support  CPU Arch      Network Performance  ENIs    GPUs    GPU Mem (GiB)  GPU Info  On-Demand Price/Hr
+-------------  -----   ---------  ----------  -----------  -------------------  --------      -------------------  ----    ----    -------------  --------  ------------------
+c5.large       2       4          nitro       true         true                 x86_64        Up to 10 Gigabit     3       0       0                        -No Price Filter Specified-
+c5a.large      2       4          nitro       true         false                x86_64        Up to 10 Gigabit     3       0       0                        -No Price Filter Specified-
+c5ad.large     2       4          nitro       true         false                x86_64        Up to 10 Gigabit     3       0       0                        -No Price Filter Specified-
+c5d.large      2       4          nitro       true         false                x86_64        Up to 10 Gigabit     3       0       0                        -No Price Filter Specified-
+t2.medium      2       4          xen         true         true                 i386, x86_64  Low to Moderate      3       0       0                        -No Price Filter Specified-
+t3.medium      2       4          nitro       true         true                 x86_64        Up to 5 Gigabit      3       0       0                        -No Price Filter Specified-
+t3a.medium     2       4          nitro       true         true                 x86_64        Up to 5 Gigabit      3       0       0                        -No Price Filter Specified-  
 ```
 
 **All CLI Options**
@@ -171,23 +185,28 @@ Filter Flags:
       --network-performance-max int       Maximum Bandwidth in Gib/s of network performance (Example: 100) If --network-performance-min is not specified, the lower bound will be 0
       --network-performance-min int       Minimum Bandwidth in Gib/s of network performance (Example: 100) If --network-performance-max is not specified, the upper bound will be infinity
       --placement-group-strategy string   Placement group strategy: [cluster, partition, spread]
+      --price-per-hour float              Price/hour in USD (Example: 0.09) (sets --price-per-hour-min and -max to the same value)
+      --price-per-hour-max float          Maximum Price/hour in USD (Example: 0.09) If --price-per-hour-min is not specified, the lower bound will be 0
+      --price-per-hour-min float          Minimum Price/hour in USD (Example: 0.09) If --price-per-hour-max is not specified, the upper bound will be infinity
       --root-device-type string           Supported root device types: [ebs or instance-store]
   -u, --usage-class string                Usage class: [spot or on-demand]
   -c, --vcpus int                         Number of vcpus available to the instance type. (sets --vcpus-min and -max to the same value)
       --vcpus-max int                     Maximum Number of vcpus available to the instance type. If --vcpus-min is not specified, the lower bound will be 0
       --vcpus-min int                     Minimum Number of vcpus available to the instance type. If --vcpus-max is not specified, the upper bound will be infinity
       --vcpus-to-memory-ratio string      The ratio of vcpus to GiBs of memory. (Example: 1:2)
+      --virtualization-type string        Virtualization Type supported: [hvm or pv]
 
 
 Suite Flags:
       --base-instance-type string   Instance Type used to retrieve similarly spec'd instance types
       --flexible                    Retrieves a group of instance types spanning multiple generations based on opinionated defaults and user overridden resource filters
+      --service string              Filter instance types based on service support (Example: eks, eks-20201211, or emr-5.20.0)
 
 
 Global Flags:
   -h, --help              Help
       --max-results int   The maximum number of instance types that match your criteria to return (default 20)
-  -o, --output string     Specify the output format (table, table-wide)
+  -o, --output string     Specify the output format (table, table-wide, one-line)
       --profile string    AWS CLI profile to use for credentials and config
   -r, --region string     AWS Region to use for API requests (NOTE: if not passed in, uses AWS SDK default precedence)
   -v, --verbose           Verbose - will print out full instance specs
@@ -267,7 +286,7 @@ func main() {
 $ git clone https://github.com/aws/amazon-ec2-instance-selector.git
 $ cd amazon-ec2-instance-selector/
 $ go run cmd/examples/example1.go
-[c1.medium c3.large c4.large c5.large c5d.large t2.medium t3.medium t3.micro t3.small t3a.medium t3a.micro t3a.small]
+[c4.large c5.large c5a.large c5d.large t2.medium t3.medium t3.small t3a.medium t3a.small]
 ```
 
 ## Building

cmd/main.go

@@ -69,6 +69,7 @@ const (
 	allowList              = "allow-list"
 	denyList               = "deny-list"
 	virtualizationType     = "virtualization-type"
+	pricePerHour           = "price-per-hour"
 )
 
 // Aggregate Filter Flags
@@ -142,6 +143,7 @@ Full docs can be found at github.com/aws/amazon-` + binName
 	cli.RegexFlag(allowList, nil, nil, "List of allowed instance types to select from w/ regex syntax (Example: m[3-5]\\.*)")
 	cli.RegexFlag(denyList, nil, nil, "List of instance types which should be excluded w/ regex syntax (Example: m[1-2]\\.*)")
 	cli.StringOptionsFlag(virtualizationType, nil, nil, "Virtualization Type supported: [hvm or pv]", []string{"hvm", "paravirtual", "pv"})
+	cli.Float64MinMaxRangeFlags(pricePerHour, nil, nil, "Price/hour in USD (Example: 0.09)")
 
 	// Suite Flags - higher level aggregate filters that return opinionated result
 
@@ -183,6 +185,13 @@ Full docs can be found at github.com/aws/amazon-` + binName
 	flags[region] = sess.Config.Region
 
 	instanceSelector := selector.New(sess)
+	if _, ok := flags[pricePerHour]; ok {
+		if flags[usageClass] == nil || *flags[usageClass].(*string) == "on-demand" {
+			instanceSelector.EC2Pricing.HydrateOndemandCache()
+		} else {
+			instanceSelector.EC2Pricing.HydrateSpotCache(30)
+		}
+	}
 
 	filters := selector.Filters{
 		VCpusRange:             cli.IntRangeMe(flags[vcpus]),
@@ -212,6 +221,7 @@ Full docs can be found at github.com/aws/amazon-` + binName
 		Flexible:               cli.BoolMe(flags[flexible]),
 		Service:                cli.StringMe(flags[service]),
 		VirtualizationType:     cli.StringMe(flags[virtualizationType]),
+		PricePerHour:           cli.Float64RangeMe(flags[pricePerHour]),
 	}
 
 	if flags[verbose] != nil {

pkg/cli/cli.go

@@ -16,6 +16,7 @@ package cli
 
 import (
 	"fmt"
+	"math"
 	"os"
 	"reflect"
 	"strings"
@@ -185,6 +186,10 @@ func (cl *CommandLineInterface) SetUntouchedFlagValuesToNil() error {
 				if v.Quantity == 0 {
 					cl.Flags[f.Name] = nil
 				}
+			case *float64:
+				if reflect.ValueOf(*v).IsZero() {
+					cl.Flags[f.Name] = nil
+				}
 			case *string:
 				if reflect.ValueOf(*v).IsZero() {
 					cl.Flags[f.Name] = nil
@@ -231,6 +236,8 @@ func (cl *CommandLineInterface) ProcessRangeFilterFlags() error {
 				cl.Flags[rangeHelperMin] = cl.IntMe(0)
 			case *bytequantity.ByteQuantity:
 				cl.Flags[rangeHelperMin] = cl.ByteQuantityMe(bytequantity.ByteQuantity{Quantity: 0})
+			case *float64:
+				cl.Flags[rangeHelperMin] = cl.Float64Me(0.0)
 			default:
 				return fmt.Errorf("Unable to set %s", rangeHelperMax)
 			}
@@ -240,6 +247,8 @@ func (cl *CommandLineInterface) ProcessRangeFilterFlags() error {
 				cl.Flags[rangeHelperMax] = cl.IntMe(maxInt)
 			case *bytequantity.ByteQuantity:
 				cl.Flags[rangeHelperMax] = cl.ByteQuantityMe(bytequantity.ByteQuantity{Quantity: maxUint64})
+			case *float64:
+				cl.Flags[rangeHelperMax] = cl.Float64Me(math.MaxFloat64)
 			default:
 				return fmt.Errorf("Unable to set %s", rangeHelperMin)
 			}
@@ -256,6 +265,11 @@ func (cl *CommandLineInterface) ProcessRangeFilterFlags() error {
 				LowerBound: *cl.ByteQuantityMe(cl.Flags[rangeHelperMin]),
 				UpperBound: *cl.ByteQuantityMe(cl.Flags[rangeHelperMax]),
 			}
+		case *float64:
+			cl.Flags[flagName] = &selector.Float64RangeFilter{
+				LowerBound: *cl.Float64Me(cl.Flags[rangeHelperMin]),
+				UpperBound: *cl.Float64Me(cl.Flags[rangeHelperMax]),
+			}
 		}
 	}
 	return nil

pkg/cli/cli_test.go

@@ -159,7 +159,7 @@ func TestParseFlags_IntRange(t *testing.T) {
 	h.Ok(t, err)
 	flagMinOutput = flags[flagMinArg].(*int)
 	flagMaxOutput = flags[flagMaxArg].(*int)
-	h.Assert(t, *flagMinOutput == 10 && *flagMaxOutput == 500, "Flag %s max should have been parsed from cmdline and min set to 0", flagArg)
+	h.Assert(t, *flagMinOutput == 10 && *flagMaxOutput == 500, "Flag %s min and max should have been parsed from cmdline", flagArg)
 }
 
 func TestParseFlags_IntRangeErr(t *testing.T) {
@@ -222,6 +222,53 @@ func TestParseFlags_ByteQuantityRange(t *testing.T) {
 	h.Assert(t, flagType == bqRangeFilterType, "%s should be of type %v, instead got %v", flagArg, bqRangeFilterType, flagType)
 }
 
+func TestParseFlags_Float64Range(t *testing.T) {
+	flagName := "test-flag"
+	flagMinArg := fmt.Sprintf("%s-%s", flagName, "min")
+	flagMaxArg := fmt.Sprintf("%s-%s", flagName, "max")
+	flagArg := fmt.Sprintf("--%s", flagName)
+
+	// Root set Min and Max to the same val
+	cli := getTestCLI()
+	cli.Float64MinMaxRangeFlags(flagName, nil, nil, "Test")
+	os.Args = []string{"ec2-instance-selector", flagArg, "5.1"}
+	flags, err := cli.ParseFlags()
+	h.Ok(t, err)
+	flagMinOutput := flags[flagMinArg].(*float64)
+	flagMaxOutput := flags[flagMaxArg].(*float64)
+	h.Assert(t, *flagMinOutput == 5.1 && *flagMaxOutput == 5.1, "Flag %s min and max should have been parsed to the same number", flagArg)
+
+	// Min is set to a val and max is set to maxInt
+	cli = getTestCLI()
+	cli.Float64MinMaxRangeFlags(flagName, nil, nil, "Test")
+	os.Args = []string{"ec2-instance-selector", "--" + flagMinArg, "5.1"}
+	flags, err = cli.ParseFlags()
+	h.Ok(t, err)
+	flagMinOutput = flags[flagMinArg].(*float64)
+	flagMaxOutput = flags[flagMaxArg].(*float64)
+	h.Assert(t, *flagMinOutput == 5.1 && *flagMaxOutput == math.MaxFloat64, "Flag %s min should have been parsed from cmdline and max set to math.MaxFloat64", flagArg)
+
+	// Max is set to a val and min is set to 0
+	cli = getTestCLI()
+	cli.Float64MinMaxRangeFlags(flagName, nil, nil, "Test")
+	os.Args = []string{"ec2-instance-selector", "--" + flagMaxArg, "5.1"}
+	flags, err = cli.ParseFlags()
+	h.Ok(t, err)
+	flagMinOutput = flags[flagMinArg].(*float64)
+	flagMaxOutput = flags[flagMaxArg].(*float64)
+	h.Assert(t, *flagMinOutput == 0.0 && *flagMaxOutput == 5.1, "Flag %s max should have been parsed from cmdline and min set to 0.0", flagArg)
+
+	// Min and Max are set to separate values
+	cli = getTestCLI()
+	cli.Float64MinMaxRangeFlags(flagName, nil, nil, "Test")
+	os.Args = []string{"ec2-instance-selector", "--" + flagMinArg, "10.1", "--" + flagMaxArg, "500.1"}
+	flags, err = cli.ParseFlags()
+	h.Ok(t, err)
+	flagMinOutput = flags[flagMinArg].(*float64)
+	flagMaxOutput = flags[flagMaxArg].(*float64)
+	h.Assert(t, *flagMinOutput == 10.1 && *flagMaxOutput == 500.1, "Flag %s min and max should have been parsed from cmdline", flagArg)
+}
+
 func TestParseAndValidateFlags_ByteQuantityRange(t *testing.T) {
 	flagName := "test-flag"
 	flagMinArg := fmt.Sprintf("%s-%s", flagName, "min")