chore: aws mac pool added struct for running release remotely

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

Author: adrianriobo

pkg/provider/aws/action/fedora/fedora.go

@@ -249,7 +249,9 @@ func (r *Request) deploy(ctx *pulumi.Context) error {
 	ctx.Export(fmt.Sprintf("%s-%s", r.Prefix, outputHost),
 		c.GetHostIP(!r.Airgap))
 	if len(r.Timeout) > 0 {
-		if err = serverless.OneTimeDelayedTask(ctx,
+		if err = serverless.OneTimeDelayedTask(
+			ctx,
+			fmt.Sprintf("fedora-timeout-%s", maptContext.RunID()),
 			r.region, r.Prefix,
 			awsFedoraDedicatedID,
 			fmt.Sprintf("aws %s destroy --project-name %s --backed-url %s --serverless",

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

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	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/modules/serverless"
 	"github.com/redhat-developer/mapt/pkg/util/logging"
 )
@@ -14,7 +15,7 @@ import (
 func houseKeeper(ctx *maptContext.ContextArgs, r *MacPoolRequestArgs) error {
 	// Create mapt Context, this is a special case where we need change the context
 	// based on the operation
-	if err := maptContext.Init(ctx); err != nil {
+	if err := maptContext.Init(ctx, aws.Provider()); err != nil {
 		return err
 	}
 
@@ -52,6 +53,10 @@ func houseKeeper(ctx *maptContext.ContextArgs, r *MacPoolRequestArgs) error {
 func (r *MacPoolRequestArgs) scheduleHouseKeeper() error {
 	return serverless.Create(
 		&serverless.ServerlessArgs{
+			ContainerName: fmt.Sprintf("housekeeper-%s-%s-%s",
+				r.PoolName,
+				r.Architecture,
+				r.OSVersion),
 			Command: houseKeepingCommand(
 				r.PoolName,
 				r.Architecture,

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

@@ -34,7 +34,13 @@ func Create(ctx *maptContext.ContextArgs, r *MacPoolRequestArgs) error {
 	if err := r.scheduleHouseKeeper(); err != nil {
 		return err
 	}
-	if err := r.createRequestTaskSpec(); err != nil {
+	if err := requestTaskSpec(r); err != nil {
+		return err
+	}
+	if err := releaseTaskSpec(
+		r.PoolName,
+		r.Architecture,
+		r.OSVersion); err != nil {
 		return err
 	}
 	return r.requestReleaserAccount()
@@ -68,6 +74,10 @@ func Request(ctx *maptContext.ContextArgs, r *RequestMachineArgs) error {
 }
 
 func Release(ctx *maptContext.ContextArgs, hostID string) error {
+	// If remote run through serverless
+	if ctx.Remote {
+		return releaseRemote(ctx, hostID)
+	}
 	return macUtil.Release(ctx, hostID)
 }
 

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

@@ -0,0 +1,51 @@
+package macpool
+
+import (
+	"fmt"
+
+	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"
+	macHost "github.com/redhat-developer/mapt/pkg/provider/aws/modules/mac/host"
+	"github.com/redhat-developer/mapt/pkg/provider/aws/modules/serverless"
+	"github.com/redhat-developer/mapt/pkg/util/logging"
+)
+
+func releaseRemote(ctx *maptContext.ContextArgs, hostID string) error {
+	if err := maptContext.Init(ctx, aws.Provider()); err != nil {
+		return err
+	}
+	// Get host as context will be fullfilled with info coming from the tags on the host
+	host, err := data.GetDedicatedHost(hostID)
+	if err != nil {
+		return err
+	}
+	hi := macHost.GetHostInformation(*host)
+	tARN, err := serverlessTaskARN(
+		*hi.PoolName,
+		*hi.Arch,
+		*hi.OSVersion,
+		releaseOperation)
+	if err != nil {
+		return err
+	}
+	logging.Debugf("Got ARN for task spec %s", *tARN)
+	return fmt.Errorf("not implemented yet")
+}
+
+func releaseTaskSpec(poolName, arch, osVersion string) error {
+	name := serverlessName(
+		poolName,
+		arch,
+		osVersion, releaseOperation)
+	return serverless.Create(
+		&serverless.ServerlessArgs{
+			ContainerName: name,
+			Command:       releaseCommand,
+			LogGroupName:  name,
+			Tags: serverlessTags(
+				poolName,
+				arch,
+				osVersion,
+				releaseOperation)})
+}

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

@@ -2,22 +2,16 @@ package macpool
 
 import (
 	"fmt"
-	"strings"
 
 	maptContext "github.com/redhat-developer/mapt/pkg/manager/context"
-	"github.com/redhat-developer/mapt/pkg/provider/aws/data"
-	macConstants "github.com/redhat-developer/mapt/pkg/provider/aws/modules/mac/constants"
-	macHost "github.com/redhat-developer/mapt/pkg/provider/aws/modules/mac/host"
+	"github.com/redhat-developer/mapt/pkg/provider/aws"
 	macMachine "github.com/redhat-developer/mapt/pkg/provider/aws/modules/mac/machine"
 	"github.com/redhat-developer/mapt/pkg/provider/aws/modules/serverless"
 	"github.com/redhat-developer/mapt/pkg/provider/aws/services/tag"
+	"github.com/redhat-developer/mapt/pkg/util/logging"
 )
 
 func request(ctx *maptContext.ContextArgs, r *RequestMachineArgs) error {
-	// If remote run through serverless
-	if maptContext.IsRemote() {
-		return requestRemote(ctx, r)
-	}
 	// First get full info on the pool and the next machine for request
 	p, err := getPool(r.PoolName, r.Architecture, r.OSVersion)
 	if err != nil {
@@ -31,16 +25,15 @@ func request(ctx *maptContext.ContextArgs, r *RequestMachineArgs) error {
 	// Create mapt Context
 	ctx.ProjectName = *hi.ProjectName
 	ctx.BackedURL = *hi.BackedURL
-	if err := maptContext.Init(ctx); err != nil {
+	if err := maptContext.Init(ctx, aws.Provider()); err != nil {
 		return err
 	}
 
 	mr := macMachine.Request{
-		Prefix:               *hi.Prefix,
-		Version:              *hi.OSVersion,
-		Architecture:         *hi.Arch,
-		SetupGHActionsRunner: r.SetupGHActionsRunner,
-		Timeout:              r.Timeout,
+		Prefix:       *hi.Prefix,
+		Version:      *hi.OSVersion,
+		Architecture: *hi.Arch,
+		Timeout:      r.Timeout,
 	}
 
 	// TODO here we would change based on the integration-mode requested
@@ -58,62 +51,46 @@ func request(ctx *maptContext.ContextArgs, r *RequestMachineArgs) error {
 }
 
 func requestRemote(ctx *maptContext.ContextArgs, r *RequestMachineArgs) error {
-	if err := maptContext.Init(ctx); err != nil {
+	if err := maptContext.Init(ctx, aws.Provider()); err != nil {
 		return err
 	}
-	rARNs, err := data.GetResourcesMatchingTags(
-		data.ResourceTypeECS,
-		requestTags(
-			r.PoolName,
-			r.Architecture,
-			r.OSVersion))
+	tARN, err := serverlessTaskARN(r.PoolName,
+		r.Architecture,
+		r.OSVersion,
+		requestOperation)
 	if err != nil {
 		return err
 	}
-	if len(rARNs) > 1 {
-		return fmt.Errorf(
-			"should be only one task spec matching tags. Found %s",
-			strings.Join(rARNs, ","))
-	}
-	// We got the arn value for the task
+	logging.Debugf("Got ARN for task spec %s", *tARN)
 	return fmt.Errorf("not implemented yet")
 }
 
 // Run serverless operation request
 // check how we will call it from the request?
 // may add tags and find or add arn to stack?
-func (r *MacPoolRequestArgs) createRequestTaskSpec() error {
+func requestTaskSpec(r *MacPoolRequestArgs) error {
+	name := serverlessName(
+		r.PoolName,
+		r.Architecture,
+		r.OSVersion,
+		requestOperation)
 	return serverless.Create(
 		&serverless.ServerlessArgs{
+			ContainerName: name,
 			Command: requestCommand(
 				r.PoolName,
 				r.Architecture,
 				r.OSVersion),
-			LogGroupName: fmt.Sprintf("%s-%s-%s-request",
-				r.PoolName,
-				r.Architecture,
-				r.OSVersion),
-			Tags: requestTags(
+			LogGroupName: name,
+			Tags: serverlessTags(
 				r.PoolName,
 				r.Architecture,
-				r.OSVersion)})
+				r.OSVersion,
+				requestOperation)})
 }
 
 func requestCommand(poolName, arch, osVersion string) string {
 	cmd := fmt.Sprintf(requestCommandRegex,
 		poolName, arch, osVersion)
 	return cmd
 }
-
-// Return the map of tags wich should identify unique
-// resquest operation spec for a pool
-func requestTags(poolName, arch, osVersion string) (m map[string]string) {
-	poolID := macHost.PoolID{
-		PoolName:  poolName,
-		Arch:      arch,
-		OSVersion: osVersion,
-	}
-	m = poolID.AsTags()
-	m[macConstants.TagKeyPoolOperationName] = requestOperation
-	return
-}

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

@@ -10,11 +10,13 @@ const (
 	// https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-scheduled-rule-pattern.html#eb-rate-expressions
 	houseKeepingInterval = "27 minutes"
 
-	requestOperation    = "request"
+	requestOperation    = "mac-pool-request"
 	requestCommandRegex = "aws mac-pool request --name %s --arch %s --version %s --serverless "
 	// requestTimeoutParam   = "--timeout "
 	// itCirrusPWTokenParam  = "--it-cirrus-pw-token "
 	// itCirrusPWLabelsParam = "--it-cirrus-pw-labels "
+	releaseOperation = "mac-pool-release"
+	releaseCommand   = "aws mac-pool release --serverless "
 )
 
 type MacPoolRequestArgs struct {

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

@@ -0,0 +1,52 @@
+package macpool
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/redhat-developer/mapt/pkg/provider/aws/data"
+	macConstants "github.com/redhat-developer/mapt/pkg/provider/aws/modules/mac/constants"
+	macHost "github.com/redhat-developer/mapt/pkg/provider/aws/modules/mac/host"
+)
+
+// this is a business identificator to assing to resources related to the serverless management
+func serverlessName(poolName, arch, osVersion, operation string) string {
+	return fmt.Sprintf("%s-%s-%s-%s",
+		operation,
+		poolName,
+		arch,
+		osVersion)
+}
+
+func serverlessTaskARN(poolName, arch, osVersion, operation string) (*string, error) {
+	rARNs, err := data.GetResourcesMatchingTags(
+		data.ResourceTypeECS,
+		serverlessTags(
+			poolName,
+			arch,
+			osVersion,
+			operation))
+	if err != nil {
+		return nil, err
+	}
+	if len(rARNs) > 1 {
+		return nil, fmt.Errorf(
+			"should be only one task spec matching tags. Found %s",
+			strings.Join(rARNs, ","))
+	}
+	return &rARNs[0], nil
+
+}
+
+// Return the map of tags wich should identify unique
+// resquest operation spec for a pool
+func serverlessTags(poolName, arch, osVersion, operation string) (m map[string]string) {
+	poolID := macHost.PoolID{
+		PoolName:  poolName,
+		Arch:      arch,
+		OSVersion: osVersion,
+	}
+	m = poolID.AsTags()
+	m[macConstants.TagKeyPoolOperationName] = operation
+	return
+}

pkg/provider/aws/action/rhel/rhel.go

@@ -245,7 +245,9 @@ func (r *Request) deploy(ctx *pulumi.Context) error {
 	ctx.Export(fmt.Sprintf("%s-%s", r.Prefix, outputHost),
 		c.GetHostIP(!r.Airgap))
 	if len(r.Timeout) > 0 {
-		if err = serverless.OneTimeDelayedTask(ctx,
+		if err = serverless.OneTimeDelayedTask(
+			ctx,
+			fmt.Sprintf("rhel-timeout-%s", maptContext.RunID()),
 			r.region, r.Prefix,
 			awsRHELDedicatedID,
 			fmt.Sprintf("aws %s destroy --project-name %s --backed-url %s --serverless",

pkg/provider/aws/action/windows/windows.go

@@ -280,7 +280,9 @@ func (r *Request) deploy(ctx *pulumi.Context) error {
 	ctx.Export(fmt.Sprintf("%s-%s", r.Prefix, outputHost),
 		c.GetHostIP(!r.Airgap))
 	if len(r.Timeout) > 0 {
-		if err = serverless.OneTimeDelayedTask(ctx,
+		if err = serverless.OneTimeDelayedTask(
+			ctx,
+			fmt.Sprintf("windows-timeout-%s", maptContext.RunID()),
 			r.region, r.Prefix,
 			awsWindowsDedicatedID,
 			fmt.Sprintf("aws %s destroy --project-name %s --backed-url %s --serverless",

pkg/provider/aws/modules/mac/host/util.go

@@ -55,7 +55,7 @@ func GetMatchingHostsInStateInformation(matchingTags map[string]string, state *e
 	}
 	var r []*mac.HostInformation
 	for _, dh := range hosts {
-		if state == nil || (state != nil && dh.State == *state) {
+		if state == nil || dh.State == *state {
 			r = append(r, GetHostInformation(dh))
 		}
 	}
@@ -83,6 +83,7 @@ func GetHostInformation(h ec2Types.Host) *mac.HostInformation {
 		RunID:       getTagValue(h.Tags, maptContext.TagKeyRunID),
 		Region:      &region,
 		Host:        &h,
+		PoolName:    getTagValue(h.Tags, macConstants.TagKeyPoolName),
 	}
 }