REVIEW action mac-pool to use old create and destroy

Signed-off-by: Adrian Riobo <[email protected]>

Author: adrianriobo

pkg/provider/aws/action/mac-pool/mac-pool.go

@@ -1,16 +1,21 @@
 package macpool
 
 import (
+	"fmt"
 	"os"
+	"strings"
 
 	"github.com/pulumi/pulumi/sdk/v3/go/auto"
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 	"github.com/redhat-developer/mapt/pkg/manager"
 	maptContext "github.com/redhat-developer/mapt/pkg/manager/context"
 	"github.com/redhat-developer/mapt/pkg/provider/aws"
+	"github.com/redhat-developer/mapt/pkg/provider/aws/data"
+	dedicatedhost "github.com/redhat-developer/mapt/pkg/provider/aws/modules/ec2/compute/dedicated-host"
 	"github.com/redhat-developer/mapt/pkg/provider/aws/modules/iam"
 	macPool "github.com/redhat-developer/mapt/pkg/provider/aws/modules/mac/pool"
 	macUtil "github.com/redhat-developer/mapt/pkg/provider/aws/modules/mac/util"
+	"github.com/redhat-developer/mapt/pkg/provider/aws/services/ec2/compute"
 	"github.com/redhat-developer/mapt/pkg/util/logging"
 	resourcesUtil "github.com/redhat-developer/mapt/pkg/util/resources"
 )
@@ -20,12 +25,83 @@ const (
 	awsMacPoolID = "amp"
 )
 
+func Create(ctx *maptContext.ContextArgs, r *PoolRequestArgs) error {
+	if err := maptContext.Init(ctx, aws.Provider()); err != nil {
+		return err
+	}
+	re := os.Getenv("AWS_DEFAULT_REGION")
+	it := "c5.xlarge"
+	hostId, azId, err := dedicatedHost(&re, &it, nil)
+	if err != nil {
+		return err
+	}
+	dhArgs := dedicatedhost.DedicatedHostArgs{
+		Region:       &re,
+		AzId:         azId,
+		InstanceType: &it,
+		HostId:       hostId,
+		Import:       true,
+		UnProtect:    false,
+	}
+	backerUrl := maptContext.BackedURL()
+	_, err = dedicatedhost.Create(&backerUrl, false, &dhArgs)
+	if err != nil {
+		return err
+	}
+	dhArgs.Import = false
+	dhArgs.UnProtect = true
+	_, err = dedicatedhost.Create(&backerUrl, false, &dhArgs)
+	return err
+}
+
+func Destroy(ctx *maptContext.ContextArgs) (err error) {
+	// Create mapt Context
+	if err := maptContext.Init(ctx, aws.Provider()); err != nil {
+		return err
+	}
+
+	return dedicatedhost.Destroy(nil)
+}
+
+func dedicatedHost(region, instanceType *string, tags map[string]string) (hostId *string, azId *string, err error) {
+	azs := data.GetAvailabilityZones(*region)
+	var isOffered bool
+	for i := 0; !isOffered && i < len(azs); i++ {
+		isOffered, err = data.IsInstanceTypeOfferedByAZ(*region, *instanceType, azs[i])
+		if err != nil {
+			return
+		}
+		if !isOffered {
+			logging.Debugf("Instancetype %s is not offered at %s", *instanceType, azs[i])
+			continue
+		}
+		hostId, err = compute.DedicatedHost(region, &azs[i], instanceType, tags)
+		if err != nil {
+			if isCapacityError(err) {
+				isOffered = false
+				continue
+			}
+		}
+		azId = &azs[i]
+		return
+	}
+	if hostId == nil {
+		return nil, nil, fmt.Errorf("no capacity across the region")
+	}
+	return
+}
+
+func isCapacityError(err error) bool {
+	return strings.Contains(err.Error(), "Insufficient") ||
+		strings.Contains(err.Error(), "capacity")
+}
+
 // Create works as an orchestrator for create n machines based on offered capacity
 // if pool already exists just change the params for the HouseKeeper
 // also the HouseKeep will take care of regulate the capacity
 
 // Even if we want to destroy the pool we will set params to max size 0
-func Create(ctx *maptContext.ContextArgs, r *PoolRequestArgs) error {
+func CreateOld(ctx *maptContext.ContextArgs, r *PoolRequestArgs) error {
 	// Create mapt Context
 	if err := maptContext.Init(ctx, aws.Provider()); err != nil {
 		return err
@@ -41,7 +117,7 @@ func Create(ctx *maptContext.ContextArgs, r *PoolRequestArgs) error {
 	return r.results(sr)
 }
 
-func Destroy(ctx *maptContext.ContextArgs) (err error) {
+func DestroyOld(ctx *maptContext.ContextArgs) (err error) {
 	logging.Debug("Run mac pool destroy")
 	// Create mapt Context
 	if err := maptContext.Init(ctx, aws.Provider()); err != nil {

pkg/provider/aws/modules/ec2/compute/dedicated-host/dedicated-host.go

@@ -0,0 +1,138 @@
+package dedicatedhost
+
+import (
+	"fmt"
+
+	ec2Types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
+	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
+	"github.com/pulumi/pulumi/sdk/v3/go/auto"
+	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+	"github.com/redhat-developer/mapt/pkg/manager"
+	maptContext "github.com/redhat-developer/mapt/pkg/manager/context"
+	"github.com/redhat-developer/mapt/pkg/provider/aws"
+	awsConstants "github.com/redhat-developer/mapt/pkg/provider/aws/constants"
+	"github.com/redhat-developer/mapt/pkg/provider/aws/data"
+	"github.com/redhat-developer/mapt/pkg/provider/util/output"
+	"github.com/redhat-developer/mapt/pkg/util/logging"
+	resourcesUtil "github.com/redhat-developer/mapt/pkg/util/resources"
+)
+
+const (
+	// mapt internal ID for the component: dedicated host
+	awsDH = "adh"
+
+	outputDedicatedHostID = "adhDedicatedHostID"
+	outputDedicatedHostAZ = "adhDedicatedHostAZ"
+	outputRegion          = "adhRegion"
+)
+
+var (
+	defaultPrefix       = "mapt"
+	maptDHDefaultPrefix = "mapt-dh"
+)
+
+type DedicatedHostArgs struct {
+	Prefix       *string
+	Region       *string
+	AzId         *string
+	InstanceType *string
+	HostId       *string
+	Tags         map[string]string
+	Import       bool
+	UnProtect    bool
+}
+
+func Create(backedURL *string, exportOutputs bool, args *DedicatedHostArgs) (*ec2Types.Host, error) {
+	if args.Prefix == nil {
+		args.Prefix = &defaultPrefix
+	}
+	cs := manager.Stack{
+		StackName:   maptContext.StackNameByProject(maptDHDefaultPrefix),
+		ProjectName: fmt.Sprintf("%s-%s", *args.Prefix, maptContext.ProjectName()),
+		BackedURL:   *backedURL,
+		ProviderCredentials: aws.GetClouProviderCredentials(
+			map[string]string{
+				awsConstants.CONFIG_AWS_REGION: *args.Region}),
+		DeployFunc: args.deploy,
+	}
+	sr, err := manager.UpStack(cs)
+	if err != nil {
+		return nil, err
+	}
+	dhID, _, err := manageResultsDedicatedHost(sr, *args.Prefix, exportOutputs)
+	if err != nil {
+		return nil, err
+	}
+	logging.Debugf("mac dedicated host with host id %s has been created successfully", *dhID)
+	return data.GetDedicatedHost(*dhID)
+}
+
+func Destroy(prefix *string) (err error) {
+	logging.Debug("Destroy dedicated host resources")
+	if prefix == nil {
+		prefix = &defaultPrefix
+	}
+	return aws.DestroyStack(
+		aws.DestroyStackRequest{
+			ProjectName: fmt.Sprintf("%s-%s",
+				*prefix,
+				maptContext.ProjectName()),
+			Stackname: maptContext.StackNameByProject(maptDHDefaultPrefix),
+		})
+}
+
+// this function will create the dedicated host resource
+func (r *DedicatedHostArgs) deploy(ctx *pulumi.Context) (err error) {
+	ctx.Export(fmt.Sprintf("%s-%s", *r.Prefix, outputRegion), pulumi.String(*r.Region))
+	opts := maptContext.CommonOptions(ctx)
+	// Dedicated host will be created through sdk and then
+	// imported to be a pulumi managed resource
+	// also resource will be destroyed by pulumi
+	if r.Import {
+		opts = append(opts, pulumi.Import(pulumi.ID(*r.HostId)))
+	}
+	if r.UnProtect {
+		opts = append(opts, pulumi.Protect(false))
+	}
+	dha := &ec2.DedicatedHostArgs{
+		AutoPlacement:    pulumi.String("off"),
+		AvailabilityZone: pulumi.String(*r.AzId),
+		InstanceType:     pulumi.String(*r.InstanceType),
+	}
+	if r.Tags != nil {
+		dha.Tags = maptContext.ResourceTagsWithCustom(r.Tags)
+	}
+	dh, err := ec2.NewDedicatedHost(ctx,
+		resourcesUtil.GetResourceName(*r.Prefix, awsDH, "dh"),
+		dha, opts...)
+	if err != nil {
+		return err
+	}
+	ctx.Export(fmt.Sprintf("%s-%s", *r.Prefix, outputDedicatedHostID),
+		dh.ID())
+	ctx.Export(fmt.Sprintf("%s-%s", *r.Prefix, outputDedicatedHostAZ),
+		pulumi.String(*r.AzId))
+	return nil
+}
+
+// results for dedicated host it will return dedicatedhost ID and dedicatedhost AZ
+// also write results to files on the target folder
+func manageResultsDedicatedHost(
+	stackResult auto.UpResult, prefix string, export bool) (*string, *string, error) {
+	if export {
+		if err := output.Write(stackResult, maptContext.GetResultsOutputPath(), map[string]string{
+			fmt.Sprintf("%s-%s", prefix, outputDedicatedHostID): "dedicated_host_id",
+		}); err != nil {
+			return nil, nil, err
+		}
+	}
+	dhID, ok := stackResult.Outputs[fmt.Sprintf("%s-%s", prefix, outputDedicatedHostID)].Value.(string)
+	if !ok {
+		return nil, nil, fmt.Errorf("error getting dedicated host ID")
+	}
+	dhAZ, ok := stackResult.Outputs[fmt.Sprintf("%s-%s", prefix, outputDedicatedHostAZ)].Value.(string)
+	if !ok {
+		return nil, nil, fmt.Errorf("error getting dedicated host AZ")
+	}
+	return &dhID, &dhAZ, nil
+}