github.com/pulumi/pulumi-aws/sdk/v6@v6.32.0/go/aws/sqs/redrivePolicy.go

// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package sqs

import (
	"context"
	"reflect"

	"errors"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/internal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

// Allows you to set a redrive policy of an SQS Queue
// while referencing ARN of the dead letter queue inside the redrive policy.
//
// This is useful when you want to set a dedicated
// dead letter queue for a standard or FIFO queue, but need
// the dead letter queue to exist before setting the redrive policy.
//
// ## Example Usage
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"encoding/json"
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/sqs"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			q, err := sqs.NewQueue(ctx, "q", &sqs.QueueArgs{
//				Name: pulumi.String("examplequeue"),
//			})
//			if err != nil {
//				return err
//			}
//			ddl, err := sqs.NewQueue(ctx, "ddl", &sqs.QueueArgs{
//				Name: pulumi.String("examplequeue-ddl"),
//				RedriveAllowPolicy: q.Arn.ApplyT(func(arn string) (pulumi.String, error) {
//					var _zero pulumi.String
//					tmpJSON0, err := json.Marshal(map[string]interface{}{
//						"redrivePermission": "byQueue",
//						"sourceQueueArns": []string{
//							arn,
//						},
//					})
//					if err != nil {
//						return _zero, err
//					}
//					json0 := string(tmpJSON0)
//					return pulumi.String(json0), nil
//				}).(pulumi.StringOutput),
//			})
//			if err != nil {
//				return err
//			}
//			_, err = sqs.NewRedrivePolicy(ctx, "q", &sqs.RedrivePolicyArgs{
//				QueueUrl: q.ID(),
//				RedrivePolicy: ddl.Arn.ApplyT(func(arn string) (pulumi.String, error) {
//					var _zero pulumi.String
//					tmpJSON1, err := json.Marshal(map[string]interface{}{
//						"deadLetterTargetArn": arn,
//						"maxReceiveCount":     4,
//					})
//					if err != nil {
//						return _zero, err
//					}
//					json1 := string(tmpJSON1)
//					return pulumi.String(json1), nil
//				}).(pulumi.StringOutput),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ## Import
//
// Using `pulumi import`, import SQS Queue Redrive Policies using the queue URL. For example:
//
// ```sh
// $ pulumi import aws:sqs/redrivePolicy:RedrivePolicy test https://queue.amazonaws.com/0123456789012/myqueue
// ```
type RedrivePolicy struct {
	pulumi.CustomResourceState

	// The URL of the SQS Queue to which to attach the policy
	QueueUrl pulumi.StringOutput `pulumi:"queueUrl"`
	// The JSON redrive policy for the SQS queue. Accepts two key/val pairs: `deadLetterTargetArn` and `maxReceiveCount`. Learn more in the [Amazon SQS dead-letter queues documentation](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html).
	RedrivePolicy pulumi.StringOutput `pulumi:"redrivePolicy"`
}

// NewRedrivePolicy registers a new resource with the given unique name, arguments, and options.
func NewRedrivePolicy(ctx *pulumi.Context,
	name string, args *RedrivePolicyArgs, opts ...pulumi.ResourceOption) (*RedrivePolicy, error) {
	if args == nil {
		return nil, errors.New("missing one or more required arguments")
	}

	if args.QueueUrl == nil {
		return nil, errors.New("invalid value for required argument 'QueueUrl'")
	}
	if args.RedrivePolicy == nil {
		return nil, errors.New("invalid value for required argument 'RedrivePolicy'")
	}
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource RedrivePolicy
	err := ctx.RegisterResource("aws:sqs/redrivePolicy:RedrivePolicy", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// GetRedrivePolicy gets an existing RedrivePolicy resource's state with the given name, ID, and optional
// state properties that are used to uniquely qualify the lookup (nil if not required).
func GetRedrivePolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RedrivePolicyState, opts ...pulumi.ResourceOption) (*RedrivePolicy, error) {
	var resource RedrivePolicy
	err := ctx.ReadResource("aws:sqs/redrivePolicy:RedrivePolicy", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering RedrivePolicy resources.
type redrivePolicyState struct {
	// The URL of the SQS Queue to which to attach the policy
	QueueUrl *string `pulumi:"queueUrl"`
	// The JSON redrive policy for the SQS queue. Accepts two key/val pairs: `deadLetterTargetArn` and `maxReceiveCount`. Learn more in the [Amazon SQS dead-letter queues documentation](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html).
	RedrivePolicy *string `pulumi:"redrivePolicy"`
}

type RedrivePolicyState struct {
	// The URL of the SQS Queue to which to attach the policy
	QueueUrl pulumi.StringPtrInput
	// The JSON redrive policy for the SQS queue. Accepts two key/val pairs: `deadLetterTargetArn` and `maxReceiveCount`. Learn more in the [Amazon SQS dead-letter queues documentation](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html).
	RedrivePolicy pulumi.StringPtrInput
}

func (RedrivePolicyState) ElementType() reflect.Type {
	return reflect.TypeOf((*redrivePolicyState)(nil)).Elem()
}

type redrivePolicyArgs struct {
	// The URL of the SQS Queue to which to attach the policy
	QueueUrl string `pulumi:"queueUrl"`
	// The JSON redrive policy for the SQS queue. Accepts two key/val pairs: `deadLetterTargetArn` and `maxReceiveCount`. Learn more in the [Amazon SQS dead-letter queues documentation](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html).
	RedrivePolicy string `pulumi:"redrivePolicy"`
}

// The set of arguments for constructing a RedrivePolicy resource.
type RedrivePolicyArgs struct {
	// The URL of the SQS Queue to which to attach the policy
	QueueUrl pulumi.StringInput
	// The JSON redrive policy for the SQS queue. Accepts two key/val pairs: `deadLetterTargetArn` and `maxReceiveCount`. Learn more in the [Amazon SQS dead-letter queues documentation](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html).
	RedrivePolicy pulumi.StringInput
}

func (RedrivePolicyArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*redrivePolicyArgs)(nil)).Elem()
}

type RedrivePolicyInput interface {
	pulumi.Input

	ToRedrivePolicyOutput() RedrivePolicyOutput
	ToRedrivePolicyOutputWithContext(ctx context.Context) RedrivePolicyOutput
}

func (*RedrivePolicy) ElementType() reflect.Type {
	return reflect.TypeOf((**RedrivePolicy)(nil)).Elem()
}

func (i *RedrivePolicy) ToRedrivePolicyOutput() RedrivePolicyOutput {
	return i.ToRedrivePolicyOutputWithContext(context.Background())
}

func (i *RedrivePolicy) ToRedrivePolicyOutputWithContext(ctx context.Context) RedrivePolicyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RedrivePolicyOutput)
}

// RedrivePolicyArrayInput is an input type that accepts RedrivePolicyArray and RedrivePolicyArrayOutput values.
// You can construct a concrete instance of `RedrivePolicyArrayInput` via:
//
//	RedrivePolicyArray{ RedrivePolicyArgs{...} }
type RedrivePolicyArrayInput interface {
	pulumi.Input

	ToRedrivePolicyArrayOutput() RedrivePolicyArrayOutput
	ToRedrivePolicyArrayOutputWithContext(context.Context) RedrivePolicyArrayOutput
}

type RedrivePolicyArray []RedrivePolicyInput

func (RedrivePolicyArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*RedrivePolicy)(nil)).Elem()
}

func (i RedrivePolicyArray) ToRedrivePolicyArrayOutput() RedrivePolicyArrayOutput {
	return i.ToRedrivePolicyArrayOutputWithContext(context.Background())
}

func (i RedrivePolicyArray) ToRedrivePolicyArrayOutputWithContext(ctx context.Context) RedrivePolicyArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RedrivePolicyArrayOutput)
}

// RedrivePolicyMapInput is an input type that accepts RedrivePolicyMap and RedrivePolicyMapOutput values.
// You can construct a concrete instance of `RedrivePolicyMapInput` via:
//
//	RedrivePolicyMap{ "key": RedrivePolicyArgs{...} }
type RedrivePolicyMapInput interface {
	pulumi.Input

	ToRedrivePolicyMapOutput() RedrivePolicyMapOutput
	ToRedrivePolicyMapOutputWithContext(context.Context) RedrivePolicyMapOutput
}

type RedrivePolicyMap map[string]RedrivePolicyInput

func (RedrivePolicyMap) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*RedrivePolicy)(nil)).Elem()
}

func (i RedrivePolicyMap) ToRedrivePolicyMapOutput() RedrivePolicyMapOutput {
	return i.ToRedrivePolicyMapOutputWithContext(context.Background())
}

func (i RedrivePolicyMap) ToRedrivePolicyMapOutputWithContext(ctx context.Context) RedrivePolicyMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RedrivePolicyMapOutput)
}

type RedrivePolicyOutput struct{ *pulumi.OutputState }

func (RedrivePolicyOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**RedrivePolicy)(nil)).Elem()
}

func (o RedrivePolicyOutput) ToRedrivePolicyOutput() RedrivePolicyOutput {
	return o
}

func (o RedrivePolicyOutput) ToRedrivePolicyOutputWithContext(ctx context.Context) RedrivePolicyOutput {
	return o
}

// The URL of the SQS Queue to which to attach the policy
func (o RedrivePolicyOutput) QueueUrl() pulumi.StringOutput {
	return o.ApplyT(func(v *RedrivePolicy) pulumi.StringOutput { return v.QueueUrl }).(pulumi.StringOutput)
}

// The JSON redrive policy for the SQS queue. Accepts two key/val pairs: `deadLetterTargetArn` and `maxReceiveCount`. Learn more in the [Amazon SQS dead-letter queues documentation](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html).
func (o RedrivePolicyOutput) RedrivePolicy() pulumi.StringOutput {
	return o.ApplyT(func(v *RedrivePolicy) pulumi.StringOutput { return v.RedrivePolicy }).(pulumi.StringOutput)
}

type RedrivePolicyArrayOutput struct{ *pulumi.OutputState }

func (RedrivePolicyArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*RedrivePolicy)(nil)).Elem()
}

func (o RedrivePolicyArrayOutput) ToRedrivePolicyArrayOutput() RedrivePolicyArrayOutput {
	return o
}

func (o RedrivePolicyArrayOutput) ToRedrivePolicyArrayOutputWithContext(ctx context.Context) RedrivePolicyArrayOutput {
	return o
}

func (o RedrivePolicyArrayOutput) Index(i pulumi.IntInput) RedrivePolicyOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RedrivePolicy {
		return vs[0].([]*RedrivePolicy)[vs[1].(int)]
	}).(RedrivePolicyOutput)
}

type RedrivePolicyMapOutput struct{ *pulumi.OutputState }

func (RedrivePolicyMapOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*RedrivePolicy)(nil)).Elem()
}

func (o RedrivePolicyMapOutput) ToRedrivePolicyMapOutput() RedrivePolicyMapOutput {
	return o
}

func (o RedrivePolicyMapOutput) ToRedrivePolicyMapOutputWithContext(ctx context.Context) RedrivePolicyMapOutput {
	return o
}

func (o RedrivePolicyMapOutput) MapIndex(k pulumi.StringInput) RedrivePolicyOutput {
	return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RedrivePolicy {
		return vs[0].(map[string]*RedrivePolicy)[vs[1].(string)]
	}).(RedrivePolicyOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*RedrivePolicyInput)(nil)).Elem(), &RedrivePolicy{})
	pulumi.RegisterInputType(reflect.TypeOf((*RedrivePolicyArrayInput)(nil)).Elem(), RedrivePolicyArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*RedrivePolicyMapInput)(nil)).Elem(), RedrivePolicyMap{})
	pulumi.RegisterOutputType(RedrivePolicyOutput{})
	pulumi.RegisterOutputType(RedrivePolicyArrayOutput{})
	pulumi.RegisterOutputType(RedrivePolicyMapOutput{})
}