Use table for cluster pricing (#775)

Author: vishalbollu

cli/cmd/lib_cluster_config.go

@@ -27,6 +27,7 @@ import (
 	cr "github.com/cortexlabs/cortex/pkg/lib/configreader"
 	"github.com/cortexlabs/cortex/pkg/lib/errors"
 	"github.com/cortexlabs/cortex/pkg/lib/files"
+	"github.com/cortexlabs/cortex/pkg/lib/pointer"
 	"github.com/cortexlabs/cortex/pkg/lib/prompt"
 	"github.com/cortexlabs/cortex/pkg/lib/sets/strset"
 	s "github.com/cortexlabs/cortex/pkg/lib/strings"
@@ -282,54 +283,78 @@ func getClusterUpdateConfig(cachedClusterConfig clusterconfig.Config, awsCreds A
 }
 
 func confirmInstallClusterConfig(clusterConfig *clusterconfig.Config, awsCreds AWSCredentials, awsClient *aws.Client) {
-	var spotPrice float64
-	if clusterConfig.Spot != nil && *clusterConfig.Spot {
-		var err error
-		spotPrice, err = awsClient.SpotInstancePrice(*clusterConfig.Region, *clusterConfig.InstanceType)
-		if err != nil {
-			spotPrice = 0
-		}
-	}
-
 	operatorInstancePrice := aws.InstanceMetadatas[*clusterConfig.Region]["t3.medium"].Price
 	operatorEBSPrice := aws.EBSMetadatas[*clusterConfig.Region].Price * 20 / 30 / 24
 	elbPrice := aws.ELBMetadatas[*clusterConfig.Region].Price
 	natPrice := aws.NATMetadatas[*clusterConfig.Region].Price
-
-	fmt.Printf("cortex will use your %s aws access key id to provision the following resources in the %s region of your aws account:\n\n", s.MaskString(awsCreds.AWSAccessKeyID, 4), *clusterConfig.Region)
-	fmt.Printf("￮ an s3 bucket named %s\n", *clusterConfig.Bucket)
-	fmt.Printf("￮ a cloudwatch log group named %s\n", clusterConfig.LogGroup)
-	fmt.Printf("￮ an eks cluster named %s ($0.20 per hour)\n", clusterConfig.ClusterName)
-	fmt.Printf("￮ a t3.medium ec2 instance for the operator (%s per hour)\n", s.DollarsMaxPrecision(operatorInstancePrice))
-	fmt.Printf("￮ a 20gb ebs volume for the operator (%s per hour)\n", s.DollarsAndTenthsOfCents(operatorEBSPrice))
-	fmt.Printf("￮ an elb for the operator and an elb for apis (%s per hour each)\n", s.DollarsMaxPrecision(elbPrice))
-	fmt.Printf("￮ a nat gateway (%s per hour)\n", s.DollarsMaxPrecision(natPrice))
-	fmt.Println(workloadInstancesStr(clusterConfig, spotPrice))
-
-	fmt.Println()
-
 	apiInstancePrice := aws.InstanceMetadatas[*clusterConfig.Region][*clusterConfig.InstanceType].Price
 	apiEBSPrice := aws.EBSMetadatas[*clusterConfig.Region].Price * float64(clusterConfig.InstanceVolumeSize) / 30 / 24
 	fixedPrice := 0.20 + operatorInstancePrice + operatorEBSPrice + 2*elbPrice + natPrice
 	totalMinPrice := fixedPrice + float64(*clusterConfig.MinInstances)*(apiInstancePrice+apiEBSPrice)
 	totalMaxPrice := fixedPrice + float64(*clusterConfig.MaxInstances)*(apiInstancePrice+apiEBSPrice)
 
+	fmt.Printf("aws access key id %s will be used to provision a cluster (%s) in %s:\n\n", s.MaskString(awsCreds.AWSAccessKeyID, 4), clusterConfig.ClusterName, *clusterConfig.Region)
+
+	headers := []table.Header{
+		{Title: "aws resource"},
+		{Title: "cost per hour"},
+	}
+
+	rows := [][]interface{}{}
+	rows = append(rows, []interface{}{"1 eks cluster", "$0.20"})
+	rows = append(rows, []interface{}{"1 20gb ebs volume for the operator", s.DollarsAndTenthsOfCents(operatorEBSPrice)})
+	rows = append(rows, []interface{}{"1 t3.medium for the operator", s.DollarsMaxPrecision(operatorInstancePrice)})
+	rows = append(rows, []interface{}{"1 nat gateway", s.DollarsMaxPrecision(natPrice)})
+	rows = append(rows, []interface{}{"2 elastic load balancers", s.DollarsMaxPrecision(elbPrice) + " each"})
+
+	instanceStr := "instances"
+	volumeStr := "volumes"
+	if *clusterConfig.MinInstances == 1 && *clusterConfig.MaxInstances == 1 {
+		instanceStr = "instance"
+		volumeStr = "volume"
+	}
+	workerInstanceStr := fmt.Sprintf("%d - %d %s %s for your apis", *clusterConfig.MinInstances, *clusterConfig.MaxInstances, *clusterConfig.InstanceType, instanceStr)
+	ebsInstanceStr := fmt.Sprintf("%d - %d %dgb ebs %s for your apis", *clusterConfig.MinInstances, *clusterConfig.MaxInstances, clusterConfig.InstanceVolumeSize, volumeStr)
+	if *clusterConfig.MinInstances == *clusterConfig.MaxInstances {
+		workerInstanceStr = fmt.Sprintf("%d %s %s for your apis", *clusterConfig.MinInstances, *clusterConfig.InstanceType, instanceStr)
+		ebsInstanceStr = fmt.Sprintf("%d %dgb ebs %s for your apis", *clusterConfig.MinInstances, clusterConfig.InstanceVolumeSize, volumeStr)
+	}
+
+	workerPriceStr := s.DollarsMaxPrecision(apiInstancePrice) + " each"
 	spotSuffix := ""
 	if clusterConfig.Spot != nil && *clusterConfig.Spot {
-		spotSuffix = " (on-demand pricing)"
+		spotPrice, err := awsClient.SpotInstancePrice(*clusterConfig.Region, *clusterConfig.InstanceType)
+		if err == nil {
+			workerPriceStr += " (spot pricing unavailable)"
+		}
+		if spotPrice != 0 {
+			workerPriceStr = fmt.Sprintf("%s - %s each (varies based on spot price)", s.DollarsMaxPrecision(spotPrice), s.DollarsMaxPrecision(apiInstancePrice))
+		}
+		spotSuffix = " (assuming 100% on-demand instances, will be less if spot instances are available)"
 	}
 
+	rows = append(rows, []interface{}{ebsInstanceStr, s.DollarsAndTenthsOfCents(apiEBSPrice) + " each"})
+	rows = append(rows, []interface{}{workerInstanceStr, workerPriceStr})
+
+	items := table.Table{
+		Headers: headers,
+		Rows:    rows,
+	}
+	fmt.Println(items.MustFormat(&table.Opts{Sort: pointer.Bool(false)}))
+
 	if *clusterConfig.MinInstances == *clusterConfig.MaxInstances {
 		fmt.Printf("this cluster will cost %s per hour%s\n\n", s.DollarsAndCents(totalMaxPrice), spotSuffix)
 	} else {
 		fmt.Printf("this cluster will cost %s - %s per hour based on the cluster size%s\n\n", s.DollarsAndCents(totalMinPrice), s.DollarsAndCents(totalMaxPrice), spotSuffix)
 	}
 
-	if clusterConfig.Spot != nil && *clusterConfig.Spot && clusterConfig.SpotConfig.OnDemandBackup != nil && *clusterConfig.SpotConfig.OnDemandBackup {
+	fmt.Printf("cortex will also create an s3 bucket (%s) and a cloudwatch log group (%s)\n\n", *clusterConfig.Bucket, clusterConfig.LogGroup)
+
+	if clusterConfig.Spot != nil && *clusterConfig.Spot && clusterConfig.SpotConfig.OnDemandBackup != nil && !*clusterConfig.SpotConfig.OnDemandBackup {
 		if *clusterConfig.SpotConfig.OnDemandBaseCapacity == 0 && *clusterConfig.SpotConfig.OnDemandPercentageAboveBaseCapacity == 0 {
-			fmt.Printf("WARNING: you've disabled on-demand instances (%s=0 and %s=0); spot instances are not guaranteed to be available so please take that into account for production clusters; see https://cortex.dev/v/%s/cluster-management/spot-instances for more information\n", clusterconfig.OnDemandBaseCapacityKey, clusterconfig.OnDemandPercentageAboveBaseCapacityKey, consts.CortexVersionMinor)
+			fmt.Printf("warning: you've disabled on-demand instances (%s=0 and %s=0); spot instances are not guaranteed to be available so please take that into account for production clusters; see https://cortex.dev/v/%s/cluster-management/spot-instances for more information\n", clusterconfig.OnDemandBaseCapacityKey, clusterconfig.OnDemandPercentageAboveBaseCapacityKey, consts.CortexVersionMinor)
 		} else {
-			fmt.Printf("WARNING: you've enabled spot instances; spot instances are not guaranteed to be available so please take that into account for production clusters; see https://cortex.dev/v/%s/cluster-management/spot-instances for more information\n", consts.CortexVersionMinor)
+			fmt.Printf("warning: you've enabled spot instances; spot instances are not guaranteed to be available so please take that into account for production clusters; see https://cortex.dev/v/%s/cluster-management/spot-instances for more information\n", consts.CortexVersionMinor)
 		}
 		fmt.Println()
 	}
@@ -468,38 +493,3 @@ func clusterConfigConfirmaionStr(clusterConfig clusterconfig.Config, awsCreds AW
 
 	return items.String()
 }
-
-func workloadInstancesStr(clusterConfig *clusterconfig.Config, spotPrice float64) string {
-	instanceRangeStr := fmt.Sprintf("an autoscaling group of %d - %d", *clusterConfig.MinInstances, *clusterConfig.MaxInstances)
-	volumeRangeStr := fmt.Sprintf("%d - %d", *clusterConfig.MinInstances, *clusterConfig.MaxInstances)
-	if *clusterConfig.MinInstances == *clusterConfig.MaxInstances {
-		instanceRangeStr = s.Int64(*clusterConfig.MinInstances)
-		volumeRangeStr = s.Int64(*clusterConfig.MinInstances)
-	}
-
-	instancesStr := "instances"
-	volumesStr := "volumes"
-	if *clusterConfig.MinInstances == 1 && *clusterConfig.MaxInstances == 1 {
-		instancesStr = "instance"
-		volumesStr = "volume"
-	}
-
-	instanceTypeStr := *clusterConfig.InstanceType
-	instancePrice := aws.InstanceMetadatas[*clusterConfig.Region][*clusterConfig.InstanceType].Price
-	instancePriceStr := fmt.Sprintf("(%s per hour each)", s.DollarsMaxPrecision(instancePrice))
-
-	if clusterConfig.Spot != nil && *clusterConfig.Spot {
-		instanceTypeStr = s.StrsOr(clusterConfig.SpotConfig.InstanceDistribution)
-		spotPriceStr := "spot pricing not available"
-		if spotPrice != 0 {
-			spotPriceStr = fmt.Sprintf("~%s per hour spot", s.DollarsMaxPrecision(spotPrice))
-		}
-		instancePriceStr = fmt.Sprintf("(%s: %s per hour on-demand, %s)", *clusterConfig.InstanceType, s.DollarsMaxPrecision(instancePrice), spotPriceStr)
-	}
-
-	ebsPrice := aws.EBSMetadatas[*clusterConfig.Region].Price * float64(clusterConfig.InstanceVolumeSize) / 30 / 24
-
-	str := fmt.Sprintf("￮ %s %s ec2 %s for apis %s\n", instanceRangeStr, instanceTypeStr, instancesStr, instancePriceStr)
-	str += fmt.Sprintf("￮ %s %dgb ebs %s, one for each api instance (%s per hour each)", volumeRangeStr, clusterConfig.InstanceVolumeSize, volumesStr, s.DollarsAndTenthsOfCents(ebsPrice))
-	return str
-}

pkg/lib/table/table.go

@@ -23,6 +23,7 @@ import (
 
 	"github.com/cortexlabs/cortex/pkg/lib/console"
 	"github.com/cortexlabs/cortex/pkg/lib/errors"
+	"github.com/cortexlabs/cortex/pkg/lib/pointer"
 	"github.com/cortexlabs/cortex/pkg/lib/slices"
 	s "github.com/cortexlabs/cortex/pkg/lib/strings"
 )
@@ -40,6 +41,26 @@ type Header struct {
 	Hidden   bool
 }
 
+type Opts struct {
+	Sort *bool // default is true
+}
+
+func mergeTableOptions(options ...*Opts) Opts {
+	mergedOpts := Opts{}
+
+	for _, opt := range options {
+		if opt != nil && opt.Sort != nil {
+			mergedOpts.Sort = opt.Sort
+		}
+	}
+
+	if mergedOpts.Sort == nil {
+		mergedOpts.Sort = pointer.Bool(true)
+	}
+
+	return mergedOpts
+}
+
 func validate(t Table) error {
 	numCols := len(t.Headers)
 
@@ -72,15 +93,16 @@ func (t *Table) MustPrint() {
 }
 
 // Return the error message as a string
-func (t *Table) MustFormat() string {
-	str, err := t.Format()
+func (t *Table) MustFormat(opts ...*Opts) string {
+	str, err := t.Format(opts...)
 	if err != nil {
 		return "error: " + errors.Message(err)
 	}
 	return str
 }
 
-func (t *Table) Format() (string, error) {
+func (t *Table) Format(opts ...*Opts) (string, error) {
+	mergedOpts := mergeTableOptions(opts...)
 	if err := validate(*t); err != nil {
 		return "", err
 	}
@@ -156,7 +178,9 @@ func (t *Table) Format() (string, error) {
 		rowStrs[rowNum] = rowStr
 	}
 
-	sort.Strings(rowStrs)
+	if *mergedOpts.Sort {
+		sort.Strings(rowStrs)
+	}
 
 	return headerStr + "\n" + strings.Join(rowStrs, "\n") + "\n", nil
 }