chore: aws added tag data function to get any type ofresource tags and match with a expected set of tags

this is now used within mac-pool request operation on remote mode...to get the fargate task spec to run request through it

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

Author: adrianriobo

cmd/mapt/cmd/aws/services/mac-pool.go

@@ -175,9 +175,10 @@ func request() *cobra.Command {
 
 			ctx := &maptContext.ContextArgs{
 				ResultsOutput: viper.GetString(params.ConnectionDetailsOutput),
-				Serverless:    viper.IsSet(params.Serverless),
 				Debug:         viper.IsSet(params.Debug),
 				DebugLevel:    viper.GetUint(params.DebugLevel),
+				Serverless:    viper.IsSet(params.Serverless),
+				Remote:        viper.IsSet(params.Remote),
 				Tags:          viper.GetStringMapString(params.Tags),
 			}
 
@@ -223,6 +224,7 @@ func request() *cobra.Command {
 	flagSet.StringP(awsParams.MACOSVersion, "", awsParams.MACOSVersion, awsParams.MACOSVersionDefault)
 	flagSet.StringP(params.Timeout, "", "", params.TimeoutDesc)
 	flagSet.Bool(params.Serverless, false, params.ServerlessDesc)
+	flagSet.Bool(params.Remote, false, params.RemoteDesc)
 	flagSet.AddFlagSet(params.GetGHActionsFlagset())
 	params.AddCirrusFlags(flagSet)
 	c.PersistentFlags().AddFlagSet(flagSet)
@@ -243,6 +245,7 @@ func release() *cobra.Command {
 					Debug:      viper.IsSet(params.Debug),
 					DebugLevel: viper.GetUint(params.DebugLevel),
 					Serverless: viper.IsSet(params.Serverless),
+					Remote:     viper.IsSet(params.Remote),
 				},
 				viper.GetString(awsParams.MACDHID)); err != nil {
 				logging.Error(err)
@@ -253,6 +256,7 @@ func release() *cobra.Command {
 	flagSet := pflag.NewFlagSet(awsParams.MACReleaseCmd, pflag.ExitOnError)
 	flagSet.StringP(awsParams.MACDHID, "", "", awsParams.MACDHIDDesc)
 	flagSet.Bool(params.Serverless, false, params.ServerlessDesc)
+	flagSet.Bool(params.Remote, false, params.RemoteDesc)
 	c.PersistentFlags().AddFlagSet(flagSet)
 	err := c.MarkPersistentFlagRequired(awsParams.MACDHID)
 	if err != nil {

cmd/mapt/cmd/constants/constants.go

@@ -77,10 +77,13 @@ const (
 	RhelVersionDefault string = "9.4"
 
 	// Serverless
-	Timeout        string = "timeout"
-	TimeoutDesc    string = "if timeout is set a serverless destroy actions will be set on the time according to the timeout. The Timeout value is a duration conforming to Go ParseDuration format."
+	Timeout     string = "timeout"
+	TimeoutDesc string = "if timeout is set a serverless destroy actions will be set on the time according to the timeout. The Timeout value is a duration conforming to Go ParseDuration format."
+	// TODO we should be able to know if it is being executed serverless just checking the ENVs??
 	Serverless     string = "serverless"
 	ServerlessDesc string = "if serverless is set the command will be executed as a serverless action."
+	Remote         string = "remote"
+	RemoteDesc     string = "if remote is set the command will be executed through the invocation of a serverless task"
 )
 
 func GetGHActionsFlagset() *pflag.FlagSet {

go.mod

@@ -23,6 +23,7 @@ require (
 	github.com/aws/aws-sdk-go-v2 v1.36.3
 	github.com/aws/aws-sdk-go-v2/config v1.29.14
 	github.com/aws/aws-sdk-go-v2/service/ec2 v1.211.3
+	github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi v1.26.3
 	github.com/aws/aws-sdk-go-v2/service/s3 v1.79.2
 	github.com/pulumi/pulumi-aws-native/sdk v1.27.0
 	github.com/pulumi/pulumi-aws/sdk/v6 v6.77.1

go.sum

@@ -75,6 +75,8 @@ github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.18.15 h1:moLQUoVq91Liq
 github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.18.15/go.mod h1:ZH34PJUc8ApjBIfgQCFvkWcUDBtl/WTD+uiYHjd8igA=
 github.com/aws/aws-sdk-go-v2/service/pricing v1.34.3 h1:vAv0hi3SWcc8cotkWRP4mPkmRbp/XqWKFyPW4Nwpzv0=
 github.com/aws/aws-sdk-go-v2/service/pricing v1.34.3/go.mod h1:giTP9ufzBQJRB6bc7P30PO8s35hCp6au5uM70zkohU4=
+github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi v1.26.3 h1:P87jejqS8WvQvRWyXlHUylt99VXt0y/WUIFuU6gBU7A=
+github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi v1.26.3/go.mod h1:cgPfPTC/V3JqwCKed7Q6d0FrgarV7ltz4Bz6S4Q+Dqk=
 github.com/aws/aws-sdk-go-v2/service/s3 v1.79.2 h1:tWUG+4wZqdMl/znThEk9tcCy8tTMxq8dW0JTgamohrY=
 github.com/aws/aws-sdk-go-v2/service/s3 v1.79.2/go.mod h1:U5SNqwhXB3Xe6F47kXvWihPl/ilGaEDe8HD/50Z9wxc=
 github.com/aws/aws-sdk-go-v2/service/sso v1.25.3 h1:1Gw+9ajCV1jogloEv1RRnvfRFia2cL6c9cuKV2Ps+G8=

pkg/manager/context/context.go

@@ -39,6 +39,8 @@ type ContextArgs struct {
 	// take into account that the name may change as the approach to get
 	// credentials from role is more general approach
 	Serverless bool
+	// If remote is set we will run the action through the serverless task spec
+	Remote bool
 	// integrations
 	GHRunnerArgs *github.GithubRunnerArgs
 	CirrusPWArgs *cirrus.PersistentWorkerArgs
@@ -52,6 +54,7 @@ type context struct {
 	debug                 bool
 	debugLevel            uint
 	serverless            bool
+	remote                bool
 	tags                  map[string]string
 	tagsAsPulumiStringMap pulumi.StringMap
 }
@@ -73,6 +76,7 @@ func Init(ca *ContextArgs, provider Provider) error {
 		debugLevel:    ca.DebugLevel,
 		tags:          ca.Tags,
 		serverless:    ca.Serverless,
+		remote:        ca.Remote,
 	}
 	addCommonTags()
 	// Init provider
@@ -107,6 +111,8 @@ func DebugLevel() uint { return mc.debugLevel }
 
 func IsServerless() bool { return mc.serverless }
 
+func IsRemote() bool { return mc.remote }
+
 // It will create a runID
 // if context has been intialized it will set it as the runID for the context
 // otherwise it will return the value (one time value)

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

@@ -61,7 +61,7 @@ func HouseKeeper(ctx *maptContext.ContextArgs, r *MacPoolRequestArgs) error {
 
 func Request(ctx *maptContext.ContextArgs, r *RequestMachineArgs) error {
 	// If remote run through serverless
-	if r.Remote {
+	if ctx.Remote {
 		return requestRemote(ctx, r)
 	}
 	return request(ctx, r)

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

@@ -2,17 +2,20 @@ 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"
 	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"
 )
 
 func request(ctx *maptContext.ContextArgs, r *RequestMachineArgs) error {
 	// If remote run through serverless
-	if r.Remote {
+	if maptContext.IsRemote() {
 		return requestRemote(ctx, r)
 	}
 	// First get full info on the pool and the next machine for request
@@ -55,6 +58,24 @@ func request(ctx *maptContext.ContextArgs, r *RequestMachineArgs) error {
 }
 
 func requestRemote(ctx *maptContext.ContextArgs, r *RequestMachineArgs) error {
+	if err := maptContext.Init(ctx); err != nil {
+		return err
+	}
+	rARNs, err := data.GetResourcesMatchingTags(
+		data.ResourceTypeECS,
+		requestTags(
+			r.PoolName,
+			r.Architecture,
+			r.OSVersion))
+	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
 	return fmt.Errorf("not implemented yet")
 }
 
@@ -72,15 +93,27 @@ func (r *MacPoolRequestArgs) createRequestTaskSpec() error {
 				r.PoolName,
 				r.Architecture,
 				r.OSVersion),
-			Tags: map[string]string{
-				macConstants.TagKeyArch:      r.Architecture,
-				macConstants.TagKeyOSVersion: r.OSVersion,
-				macConstants.TagKeyPoolName:  r.PoolName,
-			}})
+			Tags: requestTags(
+				r.PoolName,
+				r.Architecture,
+				r.OSVersion)})
 }
 
 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,6 +10,7 @@ const (
 	// https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-scheduled-rule-pattern.html#eb-rate-expressions
 	houseKeepingInterval = "27 minutes"
 
+	requestOperation    = "request"
 	requestCommandRegex = "aws mac-pool request --name %s --arch %s --version %s --serverless "
 	// requestTimeoutParam   = "--timeout "
 	// itCirrusPWTokenParam  = "--it-cirrus-pw-token "
@@ -44,8 +45,6 @@ type RequestMachineArgs struct {
 	OSVersion    string
 	// If timeout is set a severless scheduled task will be created to self destroy the resources
 	Timeout string
-	// If remote is set we will run the action through the serverless task spec
-	Remote bool
 }
 
 type ReleaseMachineArgs struct {

pkg/provider/aws/data/serverless.go

@@ -0,0 +1,55 @@
+package data
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi"
+	"github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi/types"
+	"github.com/redhat-developer/mapt/pkg/util"
+)
+
+const (
+	ResourceTypeECS = "ecs:task-definition"
+)
+
+var (
+	ErrorNoResourcesFound = fmt.Errorf("no resources matching tags")
+)
+
+// Return a list of arns for the type of resource which have all tags
+func GetResourcesMatchingTags(resourceType string, tags map[string]string) ([]string, error) {
+	cfg, err := getGlobalConfig()
+	if err != nil {
+		return nil, err
+	}
+	tagsClient := resourcegroupstaggingapi.NewFromConfig(cfg)
+	ro, err := tagsClient.GetResources(context.Background(),
+		&resourcegroupstaggingapi.GetResourcesInput{
+			ResourceTypeFilters: []string{resourceType},
+		})
+	if err != nil {
+		return nil, err
+	}
+	rFiltered := util.ArrayFilter(ro.ResourceTagMappingList,
+		func(r types.ResourceTagMapping) bool {
+			ft := util.ArrayFilter(r.Tags,
+				func(rt types.Tag) bool {
+					for k, v := range tags {
+						if *rt.Key == k && *rt.Value == v {
+							return true
+						}
+					}
+					return false
+				})
+			return len(tags) == len(ft)
+		})
+	if len(rFiltered) == 0 {
+		return nil, ErrorNoResourcesFound
+	}
+	return util.ArrayConvert(
+		rFiltered,
+		func(rt types.ResourceTagMapping) string {
+			return *rt.ResourceARN
+		}), nil
+}