proxyProtocolPolicy.go

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

package ec2

import (
	"context"
	"reflect"

	"github.com/pkg/errors"
	"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
//
// ```go
// package main
//
// import (
// 	"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/ec2"
// 	"github.com/pulumi/pulumi-aws/sdk/v4/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{
// 			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
// 	})
// }
// ```
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'")
	}
	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))
}

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

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

func (i *ProxyProtocolPolicy) ToProxyProtocolPolicyPtrOutput() ProxyProtocolPolicyPtrOutput {
	return i.ToProxyProtocolPolicyPtrOutputWithContext(context.Background())
}

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

type ProxyProtocolPolicyPtrInput interface {
	pulumi.Input

	ToProxyProtocolPolicyPtrOutput() ProxyProtocolPolicyPtrOutput
	ToProxyProtocolPolicyPtrOutputWithContext(ctx context.Context) ProxyProtocolPolicyPtrOutput
}

type proxyProtocolPolicyPtrType ProxyProtocolPolicyArgs

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

func (i *proxyProtocolPolicyPtrType) ToProxyProtocolPolicyPtrOutput() ProxyProtocolPolicyPtrOutput {
	return i.ToProxyProtocolPolicyPtrOutputWithContext(context.Background())
}

func (i *proxyProtocolPolicyPtrType) ToProxyProtocolPolicyPtrOutputWithContext(ctx context.Context) ProxyProtocolPolicyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ProxyProtocolPolicyPtrOutput)
}

// 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))
}

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))
}

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))
}

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

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

func (o ProxyProtocolPolicyOutput) ToProxyProtocolPolicyPtrOutput() ProxyProtocolPolicyPtrOutput {
	return o.ToProxyProtocolPolicyPtrOutputWithContext(context.Background())
}

func (o ProxyProtocolPolicyOutput) ToProxyProtocolPolicyPtrOutputWithContext(ctx context.Context) ProxyProtocolPolicyPtrOutput {
	return o.ApplyT(func(v ProxyProtocolPolicy) *ProxyProtocolPolicy {
		return &v
	}).(ProxyProtocolPolicyPtrOutput)
}

type ProxyProtocolPolicyPtrOutput struct {
	*pulumi.OutputState
}

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

func (o ProxyProtocolPolicyPtrOutput) ToProxyProtocolPolicyPtrOutput() ProxyProtocolPolicyPtrOutput {
	return o
}

func (o ProxyProtocolPolicyPtrOutput) ToProxyProtocolPolicyPtrOutputWithContext(ctx context.Context) ProxyProtocolPolicyPtrOutput {
	return o
}

type ProxyProtocolPolicyArrayOutput struct{ *pulumi.OutputState }

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

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))
}

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.RegisterOutputType(ProxyProtocolPolicyOutput{})
	pulumi.RegisterOutputType(ProxyProtocolPolicyPtrOutput{})
	pulumi.RegisterOutputType(ProxyProtocolPolicyArrayOutput{})
	pulumi.RegisterOutputType(ProxyProtocolPolicyMapOutput{})
}