Merge branch 'main' into oreilly-main

Author: danarbaugh

dev/list-cloudcontrol/main.go

@@ -34,67 +34,74 @@ func main() {
 	mapping := resources.GetCloudControlMapping()
 
 	in := &cloudformation.ListTypesInput{
-		Type:             aws.String(cloudformation.RegistryTypeResource),
-		Visibility:       aws.String(cloudformation.VisibilityPublic),
-		ProvisioningType: aws.String(cloudformation.ProvisioningTypeFullyMutable),
-	}
+		Type:       aws.String(cloudformation.RegistryTypeResource),
+		Visibility: aws.String(cloudformation.VisibilityPublic),
 
-	err = cf.ListTypesPagesWithContext(ctx, in, func(out *cloudformation.ListTypesOutput, _ bool) bool {
-		if out == nil {
-			return true
-		}
-
-		for _, summary := range out.TypeSummaries {
-			if summary == nil {
-				continue
-			}
-
-			typeName := aws.StringValue(summary.TypeName)
-			color.New(color.Bold).Printf("%-55s", typeName)
-			if !strings.HasPrefix(typeName, "AWS::") {
-				color.HiBlack("does not have a valid prefix")
-				continue
-			}
-
-			describe, err := cf.DescribeType(&cloudformation.DescribeTypeInput{
-				Type:     aws.String(cloudformation.RegistryTypeResource),
-				TypeName: aws.String(typeName),
-			})
-			if err != nil {
-				color.New(color.FgRed).Println(err)
-				continue
-			}
-
-			var schema CFTypeSchema
-			err = json.Unmarshal([]byte(aws.StringValue(describe.Schema)), &schema)
-			if err != nil {
-				color.New(color.FgRed).Println(err)
-				continue
-			}
+		Filters: &cloudformation.TypeFilters{
+			TypeNamePrefix: aws.String("AWS::"),
+		},
+	}
 
-			_, canList := schema.Handlers["list"]
-			if !canList {
-				color.New(color.FgHiBlack).Println("does not support list")
-				continue
+	// Immutable objects don't have an `update` option, but can still be removed
+	for _, provisioningType := range []string{cloudformation.ProvisioningTypeFullyMutable, cloudformation.ProvisioningTypeImmutable} {
+		in.ProvisioningType = &provisioningType
+		err = cf.ListTypesPagesWithContext(ctx, in, func(out *cloudformation.ListTypesOutput, _ bool) bool {
+			if out == nil {
+				return true
 			}
 
-			resourceName, exists := mapping[typeName]
-			if exists && resourceName == typeName {
-				fmt.Print("is only covered by ")
-				color.New(color.FgGreen, color.Bold).Println(resourceName)
-				continue
-			} else if exists {
-				fmt.Print("is also covered by ")
-				color.New(color.FgBlue, color.Bold).Println(resourceName)
-				continue
+			for _, summary := range out.TypeSummaries {
+				if summary == nil {
+					continue
+				}
+
+				typeName := aws.StringValue(summary.TypeName)
+				color.New(color.Bold).Printf("%-55s", typeName)
+				if !strings.HasPrefix(typeName, "AWS::") {
+					color.HiBlack("does not have a valid prefix")
+					continue
+				}
+
+				describe, err := cf.DescribeType(&cloudformation.DescribeTypeInput{
+					Type:     aws.String(cloudformation.RegistryTypeResource),
+					TypeName: aws.String(typeName),
+				})
+				if err != nil {
+					color.New(color.FgRed).Println(err)
+					continue
+				}
+
+				var schema CFTypeSchema
+				err = json.Unmarshal([]byte(aws.StringValue(describe.Schema)), &schema)
+				if err != nil {
+					color.New(color.FgRed).Println(err)
+					continue
+				}
+
+				_, canList := schema.Handlers["list"]
+				if !canList {
+					color.New(color.FgHiBlack).Println("does not support list")
+					continue
+				}
+
+				resourceName, exists := mapping[typeName]
+				if exists && resourceName == typeName {
+					fmt.Print("is only covered by ")
+					color.New(color.FgGreen, color.Bold).Println(resourceName)
+					continue
+				} else if exists {
+					fmt.Print("is also covered by ")
+					color.New(color.FgBlue, color.Bold).Println(resourceName)
+					continue
+				}
+
+				color.New(color.FgYellow).Println("is not configured")
 			}
 
-			color.New(color.FgYellow).Println("is not configured")
+			return true
+		})
+		if err != nil {
+			logrus.Fatal(err)
 		}
-
-		return true
-	})
-	if err != nil {
-		logrus.Fatal(err)
 	}
 }

pkg/types/properties.go

@@ -85,6 +85,21 @@ func (p Properties) SetTagWithPrefix(prefix string, tagKey *string, tagValue int
 	return p.Set(keyStr, tagValue)
 }
 
+func (p Properties) SetPropertyWithPrefix(prefix string, propertyKey string, propertyValue interface{}) Properties {
+	keyStr := strings.TrimSpace(propertyKey)
+	prefix = strings.TrimSpace(prefix)
+
+	if keyStr == "" {
+		return p
+	}
+
+	if prefix != "" {
+		keyStr = fmt.Sprintf("%s:%s", prefix, keyStr)
+	}
+
+	return p.Set(keyStr, propertyValue)
+}
+
 func (p Properties) Get(key string) string {
 	value, ok := p[key]
 	if !ok {

pkg/types/properties_test.go

@@ -161,3 +161,41 @@ func TestPropertiesSetTagWithPrefix(t *testing.T) {
 		})
 	}
 }
+
+func TestPropertiesSetPropertiesWithPrefix(t *testing.T) {
+	cases := []struct {
+		name   string
+		prefix string
+		key    string
+		value  interface{}
+		want   string
+	}{
+		{
+			name:   "empty",
+			prefix: "",
+			key:    "OwnerID",
+			value:  aws.String("123456789012"),
+			want:   `[OwnerID: "123456789012"]`,
+		},
+		{
+			name:   "nonempty",
+			prefix: "igw",
+			key:    "OwnerID",
+			value:  aws.String("123456789012"),
+			want:   `[igw:OwnerID: "123456789012"]`,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			p := types.NewProperties()
+
+			p.SetPropertyWithPrefix(tc.prefix, tc.key, tc.value)
+			have := p.String()
+
+			if tc.want != have {
+				t.Errorf("'%s' != '%s'", tc.want, have)
+			}
+		})
+	}
+}

resources/apprunner-connection.go

@@ -0,0 +1,62 @@
+package resources
+
+import (
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/service/apprunner"
+	"github.com/rebuy-de/aws-nuke/v2/pkg/types"
+)
+
+type AppRunnerConnection struct {
+	svc            *apprunner.AppRunner
+	ConnectionArn  *string
+	ConnectionName *string
+}
+
+func init() {
+	register("AppRunnerConnection", ListAppRunnerConnections)
+}
+
+func ListAppRunnerConnections(sess *session.Session) ([]Resource, error) {
+	svc := apprunner.New(sess)
+	resources := []Resource{}
+
+	params := &apprunner.ListConnectionsInput{}
+
+	for {
+		resp, err := svc.ListConnections(params)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, item := range resp.ConnectionSummaryList {
+			resources = append(resources, &AppRunnerConnection{
+				svc:            svc,
+				ConnectionArn:  item.ConnectionArn,
+				ConnectionName: item.ConnectionName,
+			})
+		}
+
+		if resp.NextToken == nil {
+			break
+		}
+
+		params.NextToken = resp.NextToken
+	}
+
+	return resources, nil
+}
+
+func (f *AppRunnerConnection) Remove() error {
+	_, err := f.svc.DeleteConnection(&apprunner.DeleteConnectionInput{
+		ConnectionArn: f.ConnectionArn,
+	})
+
+	return err
+}
+
+func (f *AppRunnerConnection) Properties() types.Properties {
+	properties := types.NewProperties()
+	properties.Set("ConnectionArn", f.ConnectionArn)
+	properties.Set("ConnectionName", f.ConnectionName)
+	return properties
+}

resources/apprunner-service.go

@@ -0,0 +1,65 @@
+package resources
+
+import (
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/service/apprunner"
+	"github.com/rebuy-de/aws-nuke/v2/pkg/types"
+)
+
+type AppRunnerService struct {
+	svc         *apprunner.AppRunner
+	ServiceArn  *string
+	ServiceId   *string
+	ServiceName *string
+}
+
+func init() {
+	register("AppRunnerService", ListAppRunnerServices)
+}
+
+func ListAppRunnerServices(sess *session.Session) ([]Resource, error) {
+	svc := apprunner.New(sess)
+	resources := []Resource{}
+
+	params := &apprunner.ListServicesInput{}
+
+	for {
+		resp, err := svc.ListServices(params)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, item := range resp.ServiceSummaryList {
+			resources = append(resources, &AppRunnerService{
+				svc:         svc,
+				ServiceArn:  item.ServiceArn,
+				ServiceId:   item.ServiceId,
+				ServiceName: item.ServiceName,
+			})
+		}
+
+		if resp.NextToken == nil {
+			break
+		}
+
+		params.NextToken = resp.NextToken
+	}
+
+	return resources, nil
+}
+
+func (f *AppRunnerService) Remove() error {
+	_, err := f.svc.DeleteService(&apprunner.DeleteServiceInput{
+		ServiceArn: f.ServiceArn,
+	})
+
+	return err
+}
+
+func (f *AppRunnerService) Properties() types.Properties {
+	properties := types.NewProperties()
+	properties.Set("ServiceArn", f.ServiceArn)
+	properties.Set("ServiceId", f.ServiceId)
+	properties.Set("ServiceName", f.ServiceName)
+	return properties
+}

resources/cloudwatch-rum.go

@@ -0,0 +1,71 @@
+package resources
+
+import (
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/service/cloudwatchrum"
+	"github.com/rebuy-de/aws-nuke/v2/pkg/types"
+)
+
+type CloudWatchRumApp struct {
+	svc            *cloudwatchrum.CloudWatchRUM
+	appmonitorname *string
+	id             *string
+	state          *string
+}
+
+func init() {
+	register("CloudWatchRUMApp", ListCloudWatchRumApp)
+}
+
+func ListCloudWatchRumApp(sess *session.Session) ([]Resource, error) {
+	svc := cloudwatchrum.New(sess)
+	resources := []Resource{}
+
+	params := &cloudwatchrum.ListAppMonitorsInput{}
+
+	for {
+		output, err := svc.ListAppMonitors(params)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, appEntry := range output.AppMonitorSummaries {
+			resources = append(resources, &CloudWatchRumApp{
+				svc:            svc,
+				appmonitorname: appEntry.Name,
+				id:             appEntry.Id,
+				state:          appEntry.State,
+			})
+		}
+
+		if output.NextToken == nil {
+			break
+		}
+
+		params.NextToken = output.NextToken
+	}
+
+	return resources, nil
+}
+
+func (f *CloudWatchRumApp) Remove() error {
+
+	_, err := f.svc.DeleteAppMonitor(&cloudwatchrum.DeleteAppMonitorInput{
+		Name: f.appmonitorname,
+	})
+
+	return err
+}
+
+func (f *CloudWatchRumApp) Properties() types.Properties {
+	properties := types.NewProperties()
+	properties.Set("Name", *f.appmonitorname)
+	properties.Set("ID", *f.id)
+	properties.Set("State", *f.state)
+
+	return properties
+}
+
+func (f *CloudWatchRumApp) String() string {
+	return *f.appmonitorname
+}