poolV1.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 loadbalancer

import (
	"context"
	"reflect"

	"github.com/pkg/errors"
	"github.com/pulumi/pulumi/sdk/v2/go/pulumi"
)

// Manages a V1 load balancer pool resource within OpenStack.
//
// ## Example Usage
//
// ```go
// package main
//
// import (
// 	"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/loadbalancer"
// 	"github.com/pulumi/pulumi/sdk/v2/go/pulumi"
// )
//
// func main() {
// 	pulumi.Run(func(ctx *pulumi.Context) error {
// 		_, err := loadbalancer.NewPoolV1(ctx, "pool1", &loadbalancer.PoolV1Args{
// 			LbMethod:   pulumi.String("ROUND_ROBIN"),
// 			LbProvider: pulumi.String("haproxy"),
// 			MonitorIds: pulumi.StringArray{
// 				pulumi.String("67890"),
// 			},
// 			Protocol: pulumi.String("HTTP"),
// 			SubnetId: pulumi.String("12345"),
// 		})
// 		if err != nil {
// 			return err
// 		}
// 		return nil
// 	})
// }
// ```
// ## Complete Load Balancing Stack Example
//
// ```go
// package main
//
// import (
// 	"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/compute"
// 	"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/loadbalancer"
// 	"github.com/pulumi/pulumi-openstack/sdk/v2/go/openstack/networking"
// 	"github.com/pulumi/pulumi/sdk/v2/go/pulumi"
// )
//
// func main() {
// 	pulumi.Run(func(ctx *pulumi.Context) error {
// 		network1, err := networking.NewNetwork(ctx, "network1", &networking.NetworkArgs{
// 			AdminStateUp: pulumi.Bool(true),
// 		})
// 		if err != nil {
// 			return err
// 		}
// 		subnet1, err := networking.NewSubnet(ctx, "subnet1", &networking.SubnetArgs{
// 			Cidr:      pulumi.String("192.168.199.0/24"),
// 			IpVersion: pulumi.Int(4),
// 			NetworkId: network1.ID(),
// 		})
// 		if err != nil {
// 			return err
// 		}
// 		secgroup1, err := compute.NewSecGroup(ctx, "secgroup1", &compute.SecGroupArgs{
// 			Description: pulumi.String("Rules for secgroup_1"),
// 			Rules: compute.SecGroupRuleArray{
// 				&compute.SecGroupRuleArgs{
// 					Cidr:       pulumi.String("0.0.0.0/0"),
// 					FromPort:   pulumi.Int(-1),
// 					IpProtocol: pulumi.String("icmp"),
// 					ToPort:     pulumi.Int(-1),
// 				},
// 				&compute.SecGroupRuleArgs{
// 					Cidr:       pulumi.String("0.0.0.0/0"),
// 					FromPort:   pulumi.Int(80),
// 					IpProtocol: pulumi.String("tcp"),
// 					ToPort:     pulumi.Int(80),
// 				},
// 			},
// 		})
// 		if err != nil {
// 			return err
// 		}
// 		instance1, err := compute.NewInstance(ctx, "instance1", &compute.InstanceArgs{
// 			Networks: compute.InstanceNetworkArray{
// 				&compute.InstanceNetworkArgs{
// 					Uuid: network1.ID(),
// 				},
// 			},
// 			SecurityGroups: pulumi.Array{
// 				pulumi.String("default"),
// 				secgroup1.Name,
// 			},
// 		})
// 		if err != nil {
// 			return err
// 		}
// 		instance2, err := compute.NewInstance(ctx, "instance2", &compute.InstanceArgs{
// 			Networks: compute.InstanceNetworkArray{
// 				&compute.InstanceNetworkArgs{
// 					Uuid: network1.ID(),
// 				},
// 			},
// 			SecurityGroups: pulumi.Array{
// 				pulumi.String("default"),
// 				secgroup1.Name,
// 			},
// 		})
// 		if err != nil {
// 			return err
// 		}
// 		monitor1, err := loadbalancer.NewMonitorV1(ctx, "monitor1", &loadbalancer.MonitorV1Args{
// 			AdminStateUp: pulumi.String("true"),
// 			Delay:        pulumi.Int(30),
// 			MaxRetries:   pulumi.Int(3),
// 			Timeout:      pulumi.Int(5),
// 			Type:         pulumi.String("TCP"),
// 		})
// 		if err != nil {
// 			return err
// 		}
// 		pool1, err := loadbalancer.NewPoolV1(ctx, "pool1", &loadbalancer.PoolV1Args{
// 			LbMethod: pulumi.String("ROUND_ROBIN"),
// 			MonitorIds: pulumi.StringArray{
// 				monitor1.ID(),
// 			},
// 			Protocol: pulumi.String("TCP"),
// 			SubnetId: subnet1.ID(),
// 		})
// 		if err != nil {
// 			return err
// 		}
// 		_, err = loadbalancer.NewMemberV1(ctx, "member1", &loadbalancer.MemberV1Args{
// 			Address: instance1.AccessIpV4,
// 			PoolId:  pool1.ID(),
// 			Port:    pulumi.Int(80),
// 		})
// 		if err != nil {
// 			return err
// 		}
// 		_, err = loadbalancer.NewMemberV1(ctx, "member2", &loadbalancer.MemberV1Args{
// 			Address: instance2.AccessIpV4,
// 			PoolId:  pool1.ID(),
// 			Port:    pulumi.Int(80),
// 		})
// 		if err != nil {
// 			return err
// 		}
// 		_, err = loadbalancer.NewVip(ctx, "vip1", &loadbalancer.VipArgs{
// 			PoolId:   pool1.ID(),
// 			Port:     pulumi.Int(80),
// 			Protocol: pulumi.String("TCP"),
// 			SubnetId: subnet1.ID(),
// 		})
// 		if err != nil {
// 			return err
// 		}
// 		return nil
// 	})
// }
// ```
//
// ## Notes
//
// The `member` block is deprecated in favor of the `loadbalancer.MemberV1` resource.
//
// ## Import
//
// Load Balancer Pools can be imported using the `id`, e.g.
//
// ```sh
//  $ pulumi import openstack:loadbalancer/poolV1:PoolV1 pool_1 b255e6ba-02ad-43e6-8951-3428ca26b713
// ```
type PoolV1 struct {
	pulumi.CustomResourceState

	// The algorithm used to distribute load between the
	// members of the pool. The current specification supports 'ROUND_ROBIN' and
	// 'LEAST_CONNECTIONS' as valid values for this attribute.
	LbMethod pulumi.StringOutput `pulumi:"lbMethod"`
	// The backend load balancing provider. For example:
	// `haproxy`, `F5`, etc.
	LbProvider pulumi.StringOutput `pulumi:"lbProvider"`
	// A list of IDs of monitors to associate with the
	// pool.
	MonitorIds pulumi.StringArrayOutput `pulumi:"monitorIds"`
	// The name of the pool. Changing this updates the name of
	// the existing pool.
	Name pulumi.StringOutput `pulumi:"name"`
	// The protocol used by the pool members, you can use
	// either 'TCP, 'HTTP', or 'HTTPS'. Changing this creates a new pool.
	Protocol pulumi.StringOutput `pulumi:"protocol"`
	// The region in which to obtain the V2 Networking client.
	// A Networking client is needed to create an LB pool. If omitted, the
	// `region` argument of the provider is used. Changing this creates a new
	// LB pool.
	Region pulumi.StringOutput `pulumi:"region"`
	// The network on which the members of the pool will be
	// located. Only members that are on this network can be added to the pool.
	// Changing this creates a new pool.
	SubnetId pulumi.StringOutput `pulumi:"subnetId"`
	// The owner of the member. Required if admin wants to
	// create a pool member for another tenant. Changing this creates a new member.
	TenantId pulumi.StringOutput `pulumi:"tenantId"`
}

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

	if args.LbMethod == nil {
		return nil, errors.New("invalid value for required argument 'LbMethod'")
	}
	if args.Protocol == nil {
		return nil, errors.New("invalid value for required argument 'Protocol'")
	}
	if args.SubnetId == nil {
		return nil, errors.New("invalid value for required argument 'SubnetId'")
	}
	var resource PoolV1
	err := ctx.RegisterResource("openstack:loadbalancer/poolV1:PoolV1", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// GetPoolV1 gets an existing PoolV1 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 GetPoolV1(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *PoolV1State, opts ...pulumi.ResourceOption) (*PoolV1, error) {
	var resource PoolV1
	err := ctx.ReadResource("openstack:loadbalancer/poolV1:PoolV1", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering PoolV1 resources.
type poolV1State struct {
	// The algorithm used to distribute load between the
	// members of the pool. The current specification supports 'ROUND_ROBIN' and
	// 'LEAST_CONNECTIONS' as valid values for this attribute.
	LbMethod *string `pulumi:"lbMethod"`
	// The backend load balancing provider. For example:
	// `haproxy`, `F5`, etc.
	LbProvider *string `pulumi:"lbProvider"`
	// A list of IDs of monitors to associate with the
	// pool.
	MonitorIds []string `pulumi:"monitorIds"`
	// The name of the pool. Changing this updates the name of
	// the existing pool.
	Name *string `pulumi:"name"`
	// The protocol used by the pool members, you can use
	// either 'TCP, 'HTTP', or 'HTTPS'. Changing this creates a new pool.
	Protocol *string `pulumi:"protocol"`
	// The region in which to obtain the V2 Networking client.
	// A Networking client is needed to create an LB pool. If omitted, the
	// `region` argument of the provider is used. Changing this creates a new
	// LB pool.
	Region *string `pulumi:"region"`
	// The network on which the members of the pool will be
	// located. Only members that are on this network can be added to the pool.
	// Changing this creates a new pool.
	SubnetId *string `pulumi:"subnetId"`
	// The owner of the member. Required if admin wants to
	// create a pool member for another tenant. Changing this creates a new member.
	TenantId *string `pulumi:"tenantId"`
}

type PoolV1State struct {
	// The algorithm used to distribute load between the
	// members of the pool. The current specification supports 'ROUND_ROBIN' and
	// 'LEAST_CONNECTIONS' as valid values for this attribute.
	LbMethod pulumi.StringPtrInput
	// The backend load balancing provider. For example:
	// `haproxy`, `F5`, etc.
	LbProvider pulumi.StringPtrInput
	// A list of IDs of monitors to associate with the
	// pool.
	MonitorIds pulumi.StringArrayInput
	// The name of the pool. Changing this updates the name of
	// the existing pool.
	Name pulumi.StringPtrInput
	// The protocol used by the pool members, you can use
	// either 'TCP, 'HTTP', or 'HTTPS'. Changing this creates a new pool.
	Protocol pulumi.StringPtrInput
	// The region in which to obtain the V2 Networking client.
	// A Networking client is needed to create an LB pool. If omitted, the
	// `region` argument of the provider is used. Changing this creates a new
	// LB pool.
	Region pulumi.StringPtrInput
	// The network on which the members of the pool will be
	// located. Only members that are on this network can be added to the pool.
	// Changing this creates a new pool.
	SubnetId pulumi.StringPtrInput
	// The owner of the member. Required if admin wants to
	// create a pool member for another tenant. Changing this creates a new member.
	TenantId pulumi.StringPtrInput
}

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

type poolV1Args struct {
	// The algorithm used to distribute load between the
	// members of the pool. The current specification supports 'ROUND_ROBIN' and
	// 'LEAST_CONNECTIONS' as valid values for this attribute.
	LbMethod string `pulumi:"lbMethod"`
	// The backend load balancing provider. For example:
	// `haproxy`, `F5`, etc.
	LbProvider *string `pulumi:"lbProvider"`
	// A list of IDs of monitors to associate with the
	// pool.
	MonitorIds []string `pulumi:"monitorIds"`
	// The name of the pool. Changing this updates the name of
	// the existing pool.
	Name *string `pulumi:"name"`
	// The protocol used by the pool members, you can use
	// either 'TCP, 'HTTP', or 'HTTPS'. Changing this creates a new pool.
	Protocol string `pulumi:"protocol"`
	// The region in which to obtain the V2 Networking client.
	// A Networking client is needed to create an LB pool. If omitted, the
	// `region` argument of the provider is used. Changing this creates a new
	// LB pool.
	Region *string `pulumi:"region"`
	// The network on which the members of the pool will be
	// located. Only members that are on this network can be added to the pool.
	// Changing this creates a new pool.
	SubnetId string `pulumi:"subnetId"`
	// The owner of the member. Required if admin wants to
	// create a pool member for another tenant. Changing this creates a new member.
	TenantId *string `pulumi:"tenantId"`
}

// The set of arguments for constructing a PoolV1 resource.
type PoolV1Args struct {
	// The algorithm used to distribute load between the
	// members of the pool. The current specification supports 'ROUND_ROBIN' and
	// 'LEAST_CONNECTIONS' as valid values for this attribute.
	LbMethod pulumi.StringInput
	// The backend load balancing provider. For example:
	// `haproxy`, `F5`, etc.
	LbProvider pulumi.StringPtrInput
	// A list of IDs of monitors to associate with the
	// pool.
	MonitorIds pulumi.StringArrayInput
	// The name of the pool. Changing this updates the name of
	// the existing pool.
	Name pulumi.StringPtrInput
	// The protocol used by the pool members, you can use
	// either 'TCP, 'HTTP', or 'HTTPS'. Changing this creates a new pool.
	Protocol pulumi.StringInput
	// The region in which to obtain the V2 Networking client.
	// A Networking client is needed to create an LB pool. If omitted, the
	// `region` argument of the provider is used. Changing this creates a new
	// LB pool.
	Region pulumi.StringPtrInput
	// The network on which the members of the pool will be
	// located. Only members that are on this network can be added to the pool.
	// Changing this creates a new pool.
	SubnetId pulumi.StringInput
	// The owner of the member. Required if admin wants to
	// create a pool member for another tenant. Changing this creates a new member.
	TenantId pulumi.StringPtrInput
}

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

type PoolV1Input interface {
	pulumi.Input

	ToPoolV1Output() PoolV1Output
	ToPoolV1OutputWithContext(ctx context.Context) PoolV1Output
}

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

func (i *PoolV1) ToPoolV1Output() PoolV1Output {
	return i.ToPoolV1OutputWithContext(context.Background())
}

func (i *PoolV1) ToPoolV1OutputWithContext(ctx context.Context) PoolV1Output {
	return pulumi.ToOutputWithContext(ctx, i).(PoolV1Output)
}

func (i *PoolV1) ToPoolV1PtrOutput() PoolV1PtrOutput {
	return i.ToPoolV1PtrOutputWithContext(context.Background())
}

func (i *PoolV1) ToPoolV1PtrOutputWithContext(ctx context.Context) PoolV1PtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolV1PtrOutput)
}

type PoolV1PtrInput interface {
	pulumi.Input

	ToPoolV1PtrOutput() PoolV1PtrOutput
	ToPoolV1PtrOutputWithContext(ctx context.Context) PoolV1PtrOutput
}

type poolV1PtrType PoolV1Args

func (*poolV1PtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**PoolV1)(nil))
}

func (i *poolV1PtrType) ToPoolV1PtrOutput() PoolV1PtrOutput {
	return i.ToPoolV1PtrOutputWithContext(context.Background())
}

func (i *poolV1PtrType) ToPoolV1PtrOutputWithContext(ctx context.Context) PoolV1PtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolV1PtrOutput)
}

// PoolV1ArrayInput is an input type that accepts PoolV1Array and PoolV1ArrayOutput values.
// You can construct a concrete instance of `PoolV1ArrayInput` via:
//
//          PoolV1Array{ PoolV1Args{...} }
type PoolV1ArrayInput interface {
	pulumi.Input

	ToPoolV1ArrayOutput() PoolV1ArrayOutput
	ToPoolV1ArrayOutputWithContext(context.Context) PoolV1ArrayOutput
}

type PoolV1Array []PoolV1Input

func (PoolV1Array) ElementType() reflect.Type {
	return reflect.TypeOf(([]*PoolV1)(nil))
}

func (i PoolV1Array) ToPoolV1ArrayOutput() PoolV1ArrayOutput {
	return i.ToPoolV1ArrayOutputWithContext(context.Background())
}

func (i PoolV1Array) ToPoolV1ArrayOutputWithContext(ctx context.Context) PoolV1ArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolV1ArrayOutput)
}

// PoolV1MapInput is an input type that accepts PoolV1Map and PoolV1MapOutput values.
// You can construct a concrete instance of `PoolV1MapInput` via:
//
//          PoolV1Map{ "key": PoolV1Args{...} }
type PoolV1MapInput interface {
	pulumi.Input

	ToPoolV1MapOutput() PoolV1MapOutput
	ToPoolV1MapOutputWithContext(context.Context) PoolV1MapOutput
}

type PoolV1Map map[string]PoolV1Input

func (PoolV1Map) ElementType() reflect.Type {
	return reflect.TypeOf((map[string]*PoolV1)(nil))
}

func (i PoolV1Map) ToPoolV1MapOutput() PoolV1MapOutput {
	return i.ToPoolV1MapOutputWithContext(context.Background())
}

func (i PoolV1Map) ToPoolV1MapOutputWithContext(ctx context.Context) PoolV1MapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolV1MapOutput)
}

type PoolV1Output struct {
	*pulumi.OutputState
}

func (PoolV1Output) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolV1)(nil))
}

func (o PoolV1Output) ToPoolV1Output() PoolV1Output {
	return o
}

func (o PoolV1Output) ToPoolV1OutputWithContext(ctx context.Context) PoolV1Output {
	return o
}

func (o PoolV1Output) ToPoolV1PtrOutput() PoolV1PtrOutput {
	return o.ToPoolV1PtrOutputWithContext(context.Background())
}

func (o PoolV1Output) ToPoolV1PtrOutputWithContext(ctx context.Context) PoolV1PtrOutput {
	return o.ApplyT(func(v PoolV1) *PoolV1 {
		return &v
	}).(PoolV1PtrOutput)
}

type PoolV1PtrOutput struct {
	*pulumi.OutputState
}

func (PoolV1PtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PoolV1)(nil))
}

func (o PoolV1PtrOutput) ToPoolV1PtrOutput() PoolV1PtrOutput {
	return o
}

func (o PoolV1PtrOutput) ToPoolV1PtrOutputWithContext(ctx context.Context) PoolV1PtrOutput {
	return o
}

type PoolV1ArrayOutput struct{ *pulumi.OutputState }

func (PoolV1ArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]PoolV1)(nil))
}

func (o PoolV1ArrayOutput) ToPoolV1ArrayOutput() PoolV1ArrayOutput {
	return o
}

func (o PoolV1ArrayOutput) ToPoolV1ArrayOutputWithContext(ctx context.Context) PoolV1ArrayOutput {
	return o
}

func (o PoolV1ArrayOutput) Index(i pulumi.IntInput) PoolV1Output {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) PoolV1 {
		return vs[0].([]PoolV1)[vs[1].(int)]
	}).(PoolV1Output)
}

type PoolV1MapOutput struct{ *pulumi.OutputState }

func (PoolV1MapOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]PoolV1)(nil))
}

func (o PoolV1MapOutput) ToPoolV1MapOutput() PoolV1MapOutput {
	return o
}

func (o PoolV1MapOutput) ToPoolV1MapOutputWithContext(ctx context.Context) PoolV1MapOutput {
	return o
}

func (o PoolV1MapOutput) MapIndex(k pulumi.StringInput) PoolV1Output {
	return pulumi.All(o, k).ApplyT(func(vs []interface{}) PoolV1 {
		return vs[0].(map[string]PoolV1)[vs[1].(string)]
	}).(PoolV1Output)
}

func init() {
	pulumi.RegisterOutputType(PoolV1Output{})
	pulumi.RegisterOutputType(PoolV1PtrOutput{})
	pulumi.RegisterOutputType(PoolV1ArrayOutput{})
	pulumi.RegisterOutputType(PoolV1MapOutput{})
}