Merge pull request #70 from ksctl/feature/co2

Feature/co2

Author: dipankardas011

cmd/cli.go

@@ -40,7 +40,7 @@ type KsctlCommand struct {
 	menuDriven              cli.MenuDriven
 	KsctlConfig             *config.Config
 	telemetry               *telemetry.Telemetry
-	inMemInstanceTypesInReg map[string]provider.InstanceRegionOutput
+	inMemInstanceTypesInReg provider.InstancesRegionOutput
 }
 
 func New() (*KsctlCommand, error) {

cmd/create.go

@@ -17,9 +17,10 @@ package cmd
 import (
 	"fmt"
 	"os"
-	"slices"
 	"time"
 
+	"github.com/ksctl/ksctl/v2/pkg/provider/optimizer"
+
 	"github.com/fatih/color"
 	"github.com/ksctl/ksctl/v2/pkg/consts"
 	"github.com/ksctl/ksctl/v2/pkg/provider"
@@ -62,9 +63,57 @@ ksctl create --help
 	return cmd
 }
 
-func (k *KsctlCommand) metadataForSelfManagedCluster(
-	meta *controller.Metadata,
-) {
+type CliRecommendation struct {
+	isOptimizeInstanceRegionReady *optimizer.RecommendationAcrossRegions
+	errInRecommendation           error
+}
+
+func (k *KsctlCommand) CostOptimizeAcrossRegion(inp chan CliRecommendation, meta *controller.Metadata) {
+	ticker := time.NewTicker(2 * time.Second)
+	defer ticker.Stop()
+	for {
+		select {
+		case o := <-inp:
+			optimizeResp, errResp := o.isOptimizeInstanceRegionReady, o.errInRecommendation
+			if errResp != nil {
+				k.l.Warn(k.Ctx, "Failed to get the recommendation", "Reason", errResp)
+				return
+			}
+
+			if len(optimizeResp.RegionRecommendations) == 0 {
+				k.l.Success(k.Ctx, "✨ No recommendation available for the selected region")
+				return
+			}
+
+			k.PrintRecommendation(meta.ClusterType, optimizeResp)
+
+			availRegions := []string{"Don't change"}
+			for _, _o := range optimizeResp.RegionRecommendations {
+				availRegions = append(availRegions, _o.Region)
+			}
+
+			v, err := k.menuDriven.DropDownList(fmt.Sprintf("Region Switch. Currently set (%s)", meta.Region), availRegions,
+				cli.WithDefaultValue("Don't change"),
+			)
+			if err != nil {
+				k.l.Error("Skipping it becuase failed to get the region switch", "Reason", err)
+				return
+			}
+			if v == "Don't change" {
+				return
+			}
+
+			k.l.Print(k.Ctx, "changed the region", "from", color.HiRedString(meta.Region), "to", color.HiGreenString(v))
+			meta.Region = v
+
+			return
+		case <-ticker.C:
+			k.l.Print(k.Ctx, "Still optimizing instance types...")
+		}
+	}
+}
+
+func (k *KsctlCommand) metadataForSelfManagedCluster(meta *controller.Metadata) {
 	metaClient, err := controllerMeta.NewController(
 		k.Ctx,
 		k.l,
@@ -122,10 +171,29 @@ func (k *KsctlCommand) metadataForSelfManagedCluster(
 		meta.NoDS = v
 	}
 
-	isOptimizeInstanceRegionReady := make(chan []RecommendationSelfManagedCost)
+	var (
+		isOptimizeInstanceRegionReady chan CliRecommendation
+	)
+	isOptimizeInstanceRegionReady = make(chan CliRecommendation)
 
 	go func() {
-		isOptimizeInstanceRegionReady <- k.OptimizeSelfManagedInstanceTypesAcrossRegions(meta, allAvailRegions, cp, wp, etcd, lb)
+		res, err := metaClient.CostOptimizeAcrossRegions(
+			allAvailRegions, meta.Region,
+			controllerMeta.CostOptimizerInput{
+				ControlPlane:             cp,
+				WorkerPlane:              wp,
+				DataStorePlane:           etcd,
+				LoadBalancer:             lb,
+				CountOfControlPlaneNodes: meta.NoCP,
+				CountOfWorkerNodes:       meta.NoWP,
+				CountOfEtcdNodes:         meta.NoDS,
+			},
+		)
+
+		isOptimizeInstanceRegionReady <- CliRecommendation{
+			isOptimizeInstanceRegionReady: res,
+			errInRecommendation:           err,
+		}
 	}()
 
 	bootstrapVers, err := metaClient.ListAllBootstrapVersions()
@@ -172,52 +240,7 @@ func (k *KsctlCommand) metadataForSelfManagedCluster(
 		os.Exit(1)
 	}
 
-	func() {
-		ticker := time.NewTicker(2 * time.Second)
-		defer ticker.Stop()
-		for {
-			select {
-			case o := <-isOptimizeInstanceRegionReady:
-				k.PrintRecommendationSelfManagedCost(
-					o,
-					meta.NoCP,
-					meta.NoWP,
-					meta.NoDS,
-					cp.Sku,
-					wp.Sku,
-					etcd.Sku,
-					lb.Sku,
-				)
-				pos := slices.IndexFunc(o, func(i RecommendationSelfManagedCost) bool {
-					return i.region == meta.Region
-				})
-				o = append(o[:pos], o[pos+1:]...)
-
-				availRegions := []string{"Don't change"}
-				for _, _o := range o[:5] {
-					availRegions = append(availRegions, _o.region)
-				}
-
-				v, err := k.menuDriven.DropDownList(fmt.Sprintf("Region Switch. Currently set (%s)", meta.Region), availRegions,
-					cli.WithDefaultValue("Don't change"),
-				)
-				if err != nil {
-					k.l.Error("Skipping it becuase failed to get the region switch", "Reason", err)
-					return
-				}
-				if v == "Don't change" {
-					return
-				}
-
-				k.l.Print(k.Ctx, "changed the region", "from", color.HiRedString(meta.Region), "to", color.HiGreenString(v))
-				meta.Region = v
-
-				return
-			case <-ticker.C:
-				k.l.Print(k.Ctx, "Still optimizing instance types...")
-			}
-		}
-	}()
+	k.CostOptimizeAcrossRegion(isOptimizeInstanceRegionReady, meta)
 
 	managedCNI, defaultCNI, ksctlCNI, defaultKsctl, err := metaClient.ListBootstrapCNIs()
 	if err != nil {
@@ -271,9 +294,7 @@ func (k *KsctlCommand) metadataForSelfManagedCluster(
 	return
 }
 
-func (k *KsctlCommand) metadataForManagedCluster(
-	meta *controller.Metadata,
-) {
+func (k *KsctlCommand) metadataForManagedCluster(meta *controller.Metadata) {
 	metaClient, err := controllerMeta.NewController(
 		k.Ctx,
 		k.l,
@@ -295,7 +316,9 @@ func (k *KsctlCommand) metadataForManagedCluster(
 		meta.NoMP = v
 	}
 
-	isOptimizeInstanceRegionReady := make(chan []RecommendationManagedCost)
+	var (
+		isOptimizeInstanceRegionReady chan CliRecommendation
+	)
 
 	if meta.Provider != consts.CloudLocal {
 		allAvailRegions := k.handleRegionSelection(metaClient, meta)
@@ -327,8 +350,21 @@ func (k *KsctlCommand) metadataForManagedCluster(
 			offeringSelected = v
 		}
 
+		isOptimizeInstanceRegionReady = make(chan CliRecommendation)
+
 		go func() {
-			isOptimizeInstanceRegionReady <- k.OptimizeManagedOfferingsAcrossRegions(meta, allAvailRegions, listOfOfferings[offeringSelected], vm)
+			res, err := metaClient.CostOptimizeAcrossRegions(
+				allAvailRegions, meta.Region,
+				controllerMeta.CostOptimizerInput{
+					ManagedOffering:     listOfOfferings[offeringSelected],
+					ManagedPlane:        vm,
+					CountOfManagedNodes: meta.NoMP,
+				},
+			)
+			isOptimizeInstanceRegionReady <- CliRecommendation{
+				isOptimizeInstanceRegionReady: res,
+				errInRecommendation:           err,
+			}
 		}()
 
 		k.l.Print(k.Ctx, "Current Selection will cost you")
@@ -344,49 +380,7 @@ func (k *KsctlCommand) metadataForManagedCluster(
 			os.Exit(1)
 		}
 
-		func() {
-			ticker := time.NewTicker(2 * time.Second)
-			defer ticker.Stop()
-			for {
-				select {
-				case o := <-isOptimizeInstanceRegionReady:
-					k.PrintRecommendationManagedCost(
-						o,
-						meta.NoMP,
-						listOfOfferings[offeringSelected].Sku,
-						vm.Sku,
-					)
-
-					pos := slices.IndexFunc(o, func(i RecommendationManagedCost) bool {
-						return i.region == meta.Region
-					})
-					o = append(o[:pos], o[pos+1:]...)
-
-					availRegions := []string{"Don't change"}
-					for _, _o := range o[:5] {
-						availRegions = append(availRegions, _o.region)
-					}
-
-					v, err := k.menuDriven.DropDownList(fmt.Sprintf("Region Switch. Currently set (%s)", meta.Region), availRegions,
-						cli.WithDefaultValue("Don't change"),
-					)
-					if err != nil {
-						k.l.Error("Skipping it becuase failed to get the region switch", "Reason", err)
-						return
-					}
-					if v == "Don't change" {
-						return
-					}
-
-					k.l.Print(k.Ctx, "changed the region", "from", color.HiRedString(meta.Region), "to", color.HiGreenString(v))
-					meta.Region = v
-
-					return
-				case <-ticker.C:
-					k.l.Print(k.Ctx, "Still optimizing instance types...")
-				}
-			}
-		}()
+		k.CostOptimizeAcrossRegion(isOptimizeInstanceRegionReady, meta)
 	}
 
 	managedCNI, defaultCNI, ksctlCNI, defaultKsctl, err := metaClient.ListManagedCNIs()
@@ -452,3 +446,89 @@ func (k *KsctlCommand) metadataForManagedCluster(
 
 	return
 }
+
+func (k *KsctlCommand) PrintRecommendation(
+	clusterType consts.KsctlClusterType,
+	optimizations *optimizer.RecommendationAcrossRegions) {
+
+	k.l.Print(k.Ctx,
+		"Here is your recommendation",
+		"Parameter", "Region wise cost",
+	)
+
+	var headers []string
+	var data [][]string
+
+	if clusterType == consts.ClusterTypeMang {
+		headers = []string{
+			"Region",
+			"🏭 Direct Emission",
+			fmt.Sprintf("ControlPlane (%s)", optimizations.ManagedOffering),
+			fmt.Sprintf("WorkerPlane (%s)", optimizations.InstanceTypeWP),
+			"Total Monthly Cost",
+		}
+
+		for _, cost := range optimizations.RegionRecommendations {
+			total := cost.TotalCost
+			reg := cost.Region
+			managed := cost.ControlPlaneCost
+			worker := cost.WorkerPlaneCost
+
+			regEmissions := cost.Emissions
+			var emissions string
+			if regEmissions == nil {
+				emissions = "N/A"
+			} else {
+				emissions = fmt.Sprintf("%.2f %s", regEmissions.DirectCarbonIntensity, regEmissions.Unit)
+			}
+
+			data = append(data, []string{
+				reg,
+				emissions,
+				fmt.Sprintf("$%.2f X 1", managed),
+				fmt.Sprintf("$%.2f X %d", worker, optimizations.WorkerPlaneCount),
+				fmt.Sprintf("$%.2f", total),
+			})
+		}
+
+	} else if clusterType == consts.ClusterTypeSelfMang {
+		headers = []string{
+			"Region",
+			"🏭 Direct Emission",
+			fmt.Sprintf("ControlPlane (%s)", optimizations.InstanceTypeCP),
+			fmt.Sprintf("WorkerPlane (%s)", optimizations.InstanceTypeWP),
+			fmt.Sprintf("DatastorePlane (%s)", optimizations.InstanceTypeDS),
+			fmt.Sprintf("LoadBalancer (%s)", optimizations.InstanceTypeLB),
+			"Total Monthly Cost",
+		}
+
+		for _, cost := range optimizations.RegionRecommendations {
+			total := cost.TotalCost
+			reg := cost.Region
+			cp := cost.ControlPlaneCost
+			wp := cost.WorkerPlaneCost
+			ds := cost.DataStoreCost
+			lb := cost.LoadBalancerCost
+			regEmissions := cost.Emissions
+
+			var emissions string
+			if regEmissions == nil {
+				emissions = "N/A"
+			} else {
+				emissions = fmt.Sprintf("%.2f %s", regEmissions.DirectCarbonIntensity, regEmissions.Unit)
+			}
+
+			data = append(data, []string{
+				reg,
+				emissions,
+				fmt.Sprintf("$%.2f X %d", cp, optimizations.ControlPlaneCount),
+				fmt.Sprintf("$%.2f X %d", wp, optimizations.WorkerPlaneCount),
+				fmt.Sprintf("$%.2f X %d", ds, optimizations.DataStoreCount),
+				fmt.Sprintf("$%.2f X 1", lb),
+				fmt.Sprintf("$%.2f", total),
+			})
+		}
+	}
+
+	k.l.Table(k.Ctx, headers, data)
+}