github.com/pulumi/pulumi-aws/sdk/v6@v6.32.0/go/aws/ec2/proxyProtocolPolicy.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 ec2

import (
	"context"
	"reflect"

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

// Provides a proxy protocol policy, which allows an ELB to carry a client connection information to a backend.
//
// ## Example Usage
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/elb"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			lb, err := elb.NewLoadBalancer(ctx, "lb", &elb.LoadBalancerArgs{
//				Name: pulumi.String("test-lb"),
//				AvailabilityZones: pulumi.StringArray{
//					pulumi.String("us-east-1a"),
//				},
//				Listeners: elb.LoadBalancerListenerArray{
//					&elb.LoadBalancerListenerArgs{
//						InstancePort:     pulumi.Int(25),
//						InstanceProtocol: pulumi.String("tcp"),
//						LbPort:           pulumi.Int(25),
//						LbProtocol:       pulumi.String("tcp"),
//					},
//					&elb.LoadBalancerListenerArgs{
//						InstancePort:     pulumi.Int(587),
//						InstanceProtocol: pulumi.String("tcp"),
//						LbPort:           pulumi.Int(587),
//						LbProtocol:       pulumi.String("tcp"),
//					},
//				},
//			})
//			if err != nil {
//				return err
//			}
//			_, err = ec2.NewProxyProtocolPolicy(ctx, "smtp", &ec2.ProxyProtocolPolicyArgs{
//				LoadBalancer: lb.Name,
//				InstancePorts: pulumi.StringArray{
//					pulumi.String("25"),
//					pulumi.String("587"),
//				},
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
type ProxyProtocolPolicy struct {
	pulumi.CustomResourceState

	// List of instance ports to which the policy
	// should be applied. This can be specified if the protocol is SSL or TCP.
	InstancePorts pulumi.StringArrayOutput `pulumi:"instancePorts"`
	// The load balancer to which the policy
	// should be attached.
	LoadBalancer pulumi.StringOutput `pulumi:"loadBalancer"`
}

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

	if args.InstancePorts == nil {
		return nil, errors.New("invalid value for required argument 'InstancePorts'")
	}
	if args.LoadBalancer == nil {
		return nil, errors.New("invalid value for required argument 'LoadBalancer'")
	}
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource ProxyProtocolPolicy
	err := ctx.RegisterResource("aws:ec2/proxyProtocolPolicy:ProxyProtocolPolicy", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// GetProxyProtocolPolicy gets an existing ProxyProtocolPolicy 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 GetProxyProtocolPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ProxyProtocolPolicyState, opts ...pulumi.ResourceOption) (*ProxyProtocolPolicy, error) {
	var resource ProxyProtocolPolicy
	err := ctx.ReadResource("aws:ec2/proxyProtocolPolicy:ProxyProtocolPolicy", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering ProxyProtocolPolicy resources.
type proxyProtocolPolicyState struct {
	// List of instance ports to which the policy
	// should be applied. This can be specified if the protocol is SSL or TCP.
	InstancePorts []string `pulumi:"instancePorts"`
	// The load balancer to which the policy
	// should be attached.
	LoadBalancer *string `pulumi:"loadBalancer"`
}

type ProxyProtocolPolicyState struct {
	// List of instance ports to which the policy
	// should be applied. This can be specified if the protocol is SSL or TCP.
	InstancePorts pulumi.StringArrayInput
	// The load balancer to which the policy
	// should be attached.
	LoadBalancer pulumi.StringPtrInput
}

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

type proxyProtocolPolicyArgs struct {
	// List of instance ports to which the policy
	// should be applied. This can be specified if the protocol is SSL or TCP.
	InstancePorts []string `pulumi:"instancePorts"`
	// The load balancer to which the policy
	// should be attached.
	LoadBalancer string `pulumi:"loadBalancer"`
}

// The set of arguments for constructing a ProxyProtocolPolicy resource.
type ProxyProtocolPolicyArgs struct {
	// List of instance ports to which the policy
	// should be applied. This can be specified if the protocol is SSL or TCP.
	InstancePorts pulumi.StringArrayInput
	// The load balancer to which the policy
	// should be attached.
	LoadBalancer pulumi.StringInput
}

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

type ProxyProtocolPolicyInput interface {
	pulumi.Input

	ToProxyProtocolPolicyOutput() ProxyProtocolPolicyOutput
	ToProxyProtocolPolicyOutputWithContext(ctx context.Context) ProxyProtocolPolicyOutput
}

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

func (i *ProxyProtocolPolicy) ToProxyProtocolPolicyOutput() ProxyProtocolPolicyOutput {
	return i.ToProxyProtocolPolicyOutputWithContext(context.Background())
}

func (i *ProxyProtocolPolicy) ToProxyProtocolPolicyOutputWithContext(ctx context.Context) ProxyProtocolPolicyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ProxyProtocolPolicyOutput)
}

// ProxyProtocolPolicyArrayInput is an input type that accepts ProxyProtocolPolicyArray and ProxyProtocolPolicyArrayOutput values.
// You can construct a concrete instance of `ProxyProtocolPolicyArrayInput` via:
//
//	ProxyProtocolPolicyArray{ ProxyProtocolPolicyArgs{...} }
type ProxyProtocolPolicyArrayInput interface {
	pulumi.Input

	ToProxyProtocolPolicyArrayOutput() ProxyProtocolPolicyArrayOutput
	ToProxyProtocolPolicyArrayOutputWithContext(context.Context) ProxyProtocolPolicyArrayOutput
}

type ProxyProtocolPolicyArray []ProxyProtocolPolicyInput

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

func (i ProxyProtocolPolicyArray) ToProxyProtocolPolicyArrayOutput() ProxyProtocolPolicyArrayOutput {
	return i.ToProxyProtocolPolicyArrayOutputWithContext(context.Background())
}

func (i ProxyProtocolPolicyArray) ToProxyProtocolPolicyArrayOutputWithContext(ctx context.Context) ProxyProtocolPolicyArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ProxyProtocolPolicyArrayOutput)
}

// ProxyProtocolPolicyMapInput is an input type that accepts ProxyProtocolPolicyMap and ProxyProtocolPolicyMapOutput values.
// You can construct a concrete instance of `ProxyProtocolPolicyMapInput` via:
//
//	ProxyProtocolPolicyMap{ "key": ProxyProtocolPolicyArgs{...} }
type ProxyProtocolPolicyMapInput interface {
	pulumi.Input

	ToProxyProtocolPolicyMapOutput() ProxyProtocolPolicyMapOutput
	ToProxyProtocolPolicyMapOutputWithContext(context.Context) ProxyProtocolPolicyMapOutput
}

type ProxyProtocolPolicyMap map[string]ProxyProtocolPolicyInput

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

func (i ProxyProtocolPolicyMap) ToProxyProtocolPolicyMapOutput() ProxyProtocolPolicyMapOutput {
	return i.ToProxyProtocolPolicyMapOutputWithContext(context.Background())
}

func (i ProxyProtocolPolicyMap) ToProxyProtocolPolicyMapOutputWithContext(ctx context.Context) ProxyProtocolPolicyMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ProxyProtocolPolicyMapOutput)
}

type ProxyProtocolPolicyOutput struct{ *pulumi.OutputState }

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

func (o ProxyProtocolPolicyOutput) ToProxyProtocolPolicyOutput() ProxyProtocolPolicyOutput {
	return o
}

func (o ProxyProtocolPolicyOutput) ToProxyProtocolPolicyOutputWithContext(ctx context.Context) ProxyProtocolPolicyOutput {
	return o
}

// List of instance ports to which the policy
// should be applied. This can be specified if the protocol is SSL or TCP.
func (o ProxyProtocolPolicyOutput) InstancePorts() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *ProxyProtocolPolicy) pulumi.StringArrayOutput { return v.InstancePorts }).(pulumi.StringArrayOutput)
}

// The load balancer to which the policy
// should be attached.
func (o ProxyProtocolPolicyOutput) LoadBalancer() pulumi.StringOutput {
	return o.ApplyT(func(v *ProxyProtocolPolicy) pulumi.StringOutput { return v.LoadBalancer }).(pulumi.StringOutput)
}

type ProxyProtocolPolicyArrayOutput struct{ *pulumi.OutputState }

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

func (o ProxyProtocolPolicyArrayOutput) ToProxyProtocolPolicyArrayOutput() ProxyProtocolPolicyArrayOutput {
	return o
}

func (o ProxyProtocolPolicyArrayOutput) ToProxyProtocolPolicyArrayOutputWithContext(ctx context.Context) ProxyProtocolPolicyArrayOutput {
	return o
}

func (o ProxyProtocolPolicyArrayOutput) Index(i pulumi.IntInput) ProxyProtocolPolicyOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ProxyProtocolPolicy {
		return vs[0].([]*ProxyProtocolPolicy)[vs[1].(int)]
	}).(ProxyProtocolPolicyOutput)
}

type ProxyProtocolPolicyMapOutput struct{ *pulumi.OutputState }

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

func (o ProxyProtocolPolicyMapOutput) ToProxyProtocolPolicyMapOutput() ProxyProtocolPolicyMapOutput {
	return o
}

func (o ProxyProtocolPolicyMapOutput) ToProxyProtocolPolicyMapOutputWithContext(ctx context.Context) ProxyProtocolPolicyMapOutput {
	return o
}

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

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*ProxyProtocolPolicyInput)(nil)).Elem(), &ProxyProtocolPolicy{})
	pulumi.RegisterInputType(reflect.TypeOf((*ProxyProtocolPolicyArrayInput)(nil)).Elem(), ProxyProtocolPolicyArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ProxyProtocolPolicyMapInput)(nil)).Elem(), ProxyProtocolPolicyMap{})
	pulumi.RegisterOutputType(ProxyProtocolPolicyOutput{})
	pulumi.RegisterOutputType(ProxyProtocolPolicyArrayOutput{})
	pulumi.RegisterOutputType(ProxyProtocolPolicyMapOutput{})
}