tunnel.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 ots

import (
	"context"
	"reflect"

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

// Provides an OTS tunnel resource.
//
// For information about OTS tunnel and how to use it, see [Tunnel overview](https://www.alibabacloud.com/help/en/tablestore/latest/tunnel-service-overview).
//
// > **NOTE:** Available in v1.172.0+.
//
// ## Example Usage
//
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-alicloud/sdk/go/alicloud/ots"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
//	"github.com/rhysmdnz/pulumi-alicloud/sdk/go/alicloud/ots"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			cfg := config.New(ctx, "")
//			name := "terraformtest"
//			if param := cfg.Get("name"); param != "" {
//				name = param
//			}
//			fooInstance, err := ots.NewInstance(ctx, "fooInstance", &ots.InstanceArgs{
//				Description: pulumi.String(name),
//				AccessedBy:  pulumi.String("Any"),
//				Tags: pulumi.AnyMap{
//					"Created": pulumi.Any("TF"),
//					"For":     pulumi.Any("acceptance test"),
//				},
//			})
//			if err != nil {
//				return err
//			}
//			fooTable, err := ots.NewTable(ctx, "fooTable", &ots.TableArgs{
//				InstanceName: fooInstance.Name,
//				TableName:    pulumi.String(name),
//				PrimaryKeys: ots.TablePrimaryKeyArray{
//					&ots.TablePrimaryKeyArgs{
//						Name: pulumi.String("pk1"),
//						Type: pulumi.String("Integer"),
//					},
//					&ots.TablePrimaryKeyArgs{
//						Name: pulumi.String("pk2"),
//						Type: pulumi.String("String"),
//					},
//					&ots.TablePrimaryKeyArgs{
//						Name: pulumi.String("pk3"),
//						Type: pulumi.String("Binary"),
//					},
//				},
//				TimeToLive:                -1,
//				MaxVersion:                pulumi.Int(1),
//				DeviationCellVersionInSec: pulumi.String("1"),
//			})
//			if err != nil {
//				return err
//			}
//			_, err = ots.NewTunnel(ctx, "fooTunnel", &ots.TunnelArgs{
//				InstanceName: fooInstance.Name,
//				TableName:    fooTable.TableName,
//				TunnelName:   pulumi.String(name),
//				TunnelType:   pulumi.String("BaseAndStream"),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
//
// ## Import
//
// OTS tunnel can be imported using id, e.g.
//
// ```sh
//
//	$ pulumi import alicloud:ots/tunnel:Tunnel foo <instance_name>:<table_name>:<tunnel_name>
//
// ```
type Tunnel struct {
	pulumi.CustomResourceState

	// The channels of OTS tunnel. Each element contains the following attributes:
	Channels TunnelChannelArrayOutput `pulumi:"channels"`
	// The creation time of the Tunnel.
	CreateTime pulumi.IntOutput `pulumi:"createTime"`
	// Whether the tunnel has expired.
	Expired pulumi.BoolOutput `pulumi:"expired"`
	// The name of the OTS instance in which table will located.
	InstanceName pulumi.StringOutput `pulumi:"instanceName"`
	// The name of the OTS table. If changed, a new table would be created.
	TableName pulumi.StringOutput `pulumi:"tableName"`
	// The tunnel id of the OTS which could not be changed.
	TunnelId pulumi.StringOutput `pulumi:"tunnelId"`
	// The name of the OTS tunnel. If changed, a new tunnel would be created.
	TunnelName pulumi.StringOutput `pulumi:"tunnelName"`
	// The latest consumption time of the tunnel, unix time in nanosecond.
	TunnelRpo pulumi.IntOutput `pulumi:"tunnelRpo"`
	// The stage of OTS tunnel, valid values: `InitBaseDataAndStreamShard`, `ProcessBaseData`, `ProcessStream`.
	TunnelStage pulumi.StringOutput `pulumi:"tunnelStage"`
	// The type of the OTS tunnel. Only `BaseAndStream`, `BaseData` or `Stream` is allowed.
	TunnelType pulumi.StringOutput `pulumi:"tunnelType"`
}

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

	if args.InstanceName == nil {
		return nil, errors.New("invalid value for required argument 'InstanceName'")
	}
	if args.TableName == nil {
		return nil, errors.New("invalid value for required argument 'TableName'")
	}
	if args.TunnelName == nil {
		return nil, errors.New("invalid value for required argument 'TunnelName'")
	}
	if args.TunnelType == nil {
		return nil, errors.New("invalid value for required argument 'TunnelType'")
	}
	opts = pkgResourceDefaultOpts(opts)
	var resource Tunnel
	err := ctx.RegisterResource("alicloud:ots/tunnel:Tunnel", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// GetTunnel gets an existing Tunnel 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 GetTunnel(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *TunnelState, opts ...pulumi.ResourceOption) (*Tunnel, error) {
	var resource Tunnel
	err := ctx.ReadResource("alicloud:ots/tunnel:Tunnel", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering Tunnel resources.
type tunnelState struct {
	// The channels of OTS tunnel. Each element contains the following attributes:
	Channels []TunnelChannel `pulumi:"channels"`
	// The creation time of the Tunnel.
	CreateTime *int `pulumi:"createTime"`
	// Whether the tunnel has expired.
	Expired *bool `pulumi:"expired"`
	// The name of the OTS instance in which table will located.
	InstanceName *string `pulumi:"instanceName"`
	// The name of the OTS table. If changed, a new table would be created.
	TableName *string `pulumi:"tableName"`
	// The tunnel id of the OTS which could not be changed.
	TunnelId *string `pulumi:"tunnelId"`
	// The name of the OTS tunnel. If changed, a new tunnel would be created.
	TunnelName *string `pulumi:"tunnelName"`
	// The latest consumption time of the tunnel, unix time in nanosecond.
	TunnelRpo *int `pulumi:"tunnelRpo"`
	// The stage of OTS tunnel, valid values: `InitBaseDataAndStreamShard`, `ProcessBaseData`, `ProcessStream`.
	TunnelStage *string `pulumi:"tunnelStage"`
	// The type of the OTS tunnel. Only `BaseAndStream`, `BaseData` or `Stream` is allowed.
	TunnelType *string `pulumi:"tunnelType"`
}

type TunnelState struct {
	// The channels of OTS tunnel. Each element contains the following attributes:
	Channels TunnelChannelArrayInput
	// The creation time of the Tunnel.
	CreateTime pulumi.IntPtrInput
	// Whether the tunnel has expired.
	Expired pulumi.BoolPtrInput
	// The name of the OTS instance in which table will located.
	InstanceName pulumi.StringPtrInput
	// The name of the OTS table. If changed, a new table would be created.
	TableName pulumi.StringPtrInput
	// The tunnel id of the OTS which could not be changed.
	TunnelId pulumi.StringPtrInput
	// The name of the OTS tunnel. If changed, a new tunnel would be created.
	TunnelName pulumi.StringPtrInput
	// The latest consumption time of the tunnel, unix time in nanosecond.
	TunnelRpo pulumi.IntPtrInput
	// The stage of OTS tunnel, valid values: `InitBaseDataAndStreamShard`, `ProcessBaseData`, `ProcessStream`.
	TunnelStage pulumi.StringPtrInput
	// The type of the OTS tunnel. Only `BaseAndStream`, `BaseData` or `Stream` is allowed.
	TunnelType pulumi.StringPtrInput
}

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

type tunnelArgs struct {
	// The name of the OTS instance in which table will located.
	InstanceName string `pulumi:"instanceName"`
	// The name of the OTS table. If changed, a new table would be created.
	TableName string `pulumi:"tableName"`
	// The name of the OTS tunnel. If changed, a new tunnel would be created.
	TunnelName string `pulumi:"tunnelName"`
	// The type of the OTS tunnel. Only `BaseAndStream`, `BaseData` or `Stream` is allowed.
	TunnelType string `pulumi:"tunnelType"`
}

// The set of arguments for constructing a Tunnel resource.
type TunnelArgs struct {
	// The name of the OTS instance in which table will located.
	InstanceName pulumi.StringInput
	// The name of the OTS table. If changed, a new table would be created.
	TableName pulumi.StringInput
	// The name of the OTS tunnel. If changed, a new tunnel would be created.
	TunnelName pulumi.StringInput
	// The type of the OTS tunnel. Only `BaseAndStream`, `BaseData` or `Stream` is allowed.
	TunnelType pulumi.StringInput
}

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

type TunnelInput interface {
	pulumi.Input

	ToTunnelOutput() TunnelOutput
	ToTunnelOutputWithContext(ctx context.Context) TunnelOutput
}

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

func (i *Tunnel) ToTunnelOutput() TunnelOutput {
	return i.ToTunnelOutputWithContext(context.Background())
}

func (i *Tunnel) ToTunnelOutputWithContext(ctx context.Context) TunnelOutput {
	return pulumi.ToOutputWithContext(ctx, i).(TunnelOutput)
}

// TunnelArrayInput is an input type that accepts TunnelArray and TunnelArrayOutput values.
// You can construct a concrete instance of `TunnelArrayInput` via:
//
//	TunnelArray{ TunnelArgs{...} }
type TunnelArrayInput interface {
	pulumi.Input

	ToTunnelArrayOutput() TunnelArrayOutput
	ToTunnelArrayOutputWithContext(context.Context) TunnelArrayOutput
}

type TunnelArray []TunnelInput

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

func (i TunnelArray) ToTunnelArrayOutput() TunnelArrayOutput {
	return i.ToTunnelArrayOutputWithContext(context.Background())
}

func (i TunnelArray) ToTunnelArrayOutputWithContext(ctx context.Context) TunnelArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(TunnelArrayOutput)
}

// TunnelMapInput is an input type that accepts TunnelMap and TunnelMapOutput values.
// You can construct a concrete instance of `TunnelMapInput` via:
//
//	TunnelMap{ "key": TunnelArgs{...} }
type TunnelMapInput interface {
	pulumi.Input

	ToTunnelMapOutput() TunnelMapOutput
	ToTunnelMapOutputWithContext(context.Context) TunnelMapOutput
}

type TunnelMap map[string]TunnelInput

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

func (i TunnelMap) ToTunnelMapOutput() TunnelMapOutput {
	return i.ToTunnelMapOutputWithContext(context.Background())
}

func (i TunnelMap) ToTunnelMapOutputWithContext(ctx context.Context) TunnelMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(TunnelMapOutput)
}

type TunnelOutput struct{ *pulumi.OutputState }

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

func (o TunnelOutput) ToTunnelOutput() TunnelOutput {
	return o
}

func (o TunnelOutput) ToTunnelOutputWithContext(ctx context.Context) TunnelOutput {
	return o
}

// The channels of OTS tunnel. Each element contains the following attributes:
func (o TunnelOutput) Channels() TunnelChannelArrayOutput {
	return o.ApplyT(func(v *Tunnel) TunnelChannelArrayOutput { return v.Channels }).(TunnelChannelArrayOutput)
}

// The creation time of the Tunnel.
func (o TunnelOutput) CreateTime() pulumi.IntOutput {
	return o.ApplyT(func(v *Tunnel) pulumi.IntOutput { return v.CreateTime }).(pulumi.IntOutput)
}

// Whether the tunnel has expired.
func (o TunnelOutput) Expired() pulumi.BoolOutput {
	return o.ApplyT(func(v *Tunnel) pulumi.BoolOutput { return v.Expired }).(pulumi.BoolOutput)
}

// The name of the OTS instance in which table will located.
func (o TunnelOutput) InstanceName() pulumi.StringOutput {
	return o.ApplyT(func(v *Tunnel) pulumi.StringOutput { return v.InstanceName }).(pulumi.StringOutput)
}

// The name of the OTS table. If changed, a new table would be created.
func (o TunnelOutput) TableName() pulumi.StringOutput {
	return o.ApplyT(func(v *Tunnel) pulumi.StringOutput { return v.TableName }).(pulumi.StringOutput)
}

// The tunnel id of the OTS which could not be changed.
func (o TunnelOutput) TunnelId() pulumi.StringOutput {
	return o.ApplyT(func(v *Tunnel) pulumi.StringOutput { return v.TunnelId }).(pulumi.StringOutput)
}

// The name of the OTS tunnel. If changed, a new tunnel would be created.
func (o TunnelOutput) TunnelName() pulumi.StringOutput {
	return o.ApplyT(func(v *Tunnel) pulumi.StringOutput { return v.TunnelName }).(pulumi.StringOutput)
}

// The latest consumption time of the tunnel, unix time in nanosecond.
func (o TunnelOutput) TunnelRpo() pulumi.IntOutput {
	return o.ApplyT(func(v *Tunnel) pulumi.IntOutput { return v.TunnelRpo }).(pulumi.IntOutput)
}

// The stage of OTS tunnel, valid values: `InitBaseDataAndStreamShard`, `ProcessBaseData`, `ProcessStream`.
func (o TunnelOutput) TunnelStage() pulumi.StringOutput {
	return o.ApplyT(func(v *Tunnel) pulumi.StringOutput { return v.TunnelStage }).(pulumi.StringOutput)
}

// The type of the OTS tunnel. Only `BaseAndStream`, `BaseData` or `Stream` is allowed.
func (o TunnelOutput) TunnelType() pulumi.StringOutput {
	return o.ApplyT(func(v *Tunnel) pulumi.StringOutput { return v.TunnelType }).(pulumi.StringOutput)
}

type TunnelArrayOutput struct{ *pulumi.OutputState }

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

func (o TunnelArrayOutput) ToTunnelArrayOutput() TunnelArrayOutput {
	return o
}

func (o TunnelArrayOutput) ToTunnelArrayOutputWithContext(ctx context.Context) TunnelArrayOutput {
	return o
}

func (o TunnelArrayOutput) Index(i pulumi.IntInput) TunnelOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Tunnel {
		return vs[0].([]*Tunnel)[vs[1].(int)]
	}).(TunnelOutput)
}

type TunnelMapOutput struct{ *pulumi.OutputState }

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

func (o TunnelMapOutput) ToTunnelMapOutput() TunnelMapOutput {
	return o
}

func (o TunnelMapOutput) ToTunnelMapOutputWithContext(ctx context.Context) TunnelMapOutput {
	return o
}

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

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*TunnelInput)(nil)).Elem(), &Tunnel{})
	pulumi.RegisterInputType(reflect.TypeOf((*TunnelArrayInput)(nil)).Elem(), TunnelArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*TunnelMapInput)(nil)).Elem(), TunnelMap{})
	pulumi.RegisterOutputType(TunnelOutput{})
	pulumi.RegisterOutputType(TunnelArrayOutput{})
	pulumi.RegisterOutputType(TunnelMapOutput{})
}