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

import (
	"context"
	"reflect"

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

// Provides an EC2 instance state resource. This allows managing an instance power state.
//
// > **NOTE on Instance State Management:** AWS does not currently have an EC2 API operation to determine an instance has finished processing user data. As a result, this resource can interfere with user data processing. For example, this resource may stop an instance while the user data script is in mid run.
//
// ## 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/ec2transitgateway"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			ubuntu, err := ec2.LookupAmi(ctx, &ec2.LookupAmiArgs{
//				MostRecent: pulumi.BoolRef(true),
//				Filters: []ec2.GetAmiFilter{
//					{
//						Name: "name",
//						Values: []string{
//							"ubuntu/images/hvm-ssd/ubuntu-focal-20.04-amd64-server-*",
//						},
//					},
//					{
//						Name: "virtualization-type",
//						Values: []string{
//							"hvm",
//						},
//					},
//				},
//				Owners: []string{
//					"099720109477",
//				},
//			}, nil)
//			if err != nil {
//				return err
//			}
//			test, err := ec2.NewInstance(ctx, "test", &ec2.InstanceArgs{
//				Ami:          pulumi.String(ubuntu.Id),
//				InstanceType: pulumi.String(ec2.InstanceType_T3_Micro),
//				Tags: pulumi.StringMap{
//					"Name": pulumi.String("HelloWorld"),
//				},
//			})
//			if err != nil {
//				return err
//			}
//			_, err = ec2transitgateway.NewInstanceState(ctx, "test", &ec2transitgateway.InstanceStateArgs{
//				InstanceId: test.ID(),
//				State:      pulumi.String("stopped"),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ## Import
//
// Using `pulumi import`, import `aws_ec2_instance_state` using the `instance_id` attribute. For example:
//
// ```sh
// $ pulumi import aws:ec2transitgateway/instanceState:InstanceState test i-02cae6557dfcf2f96
// ```
type InstanceState struct {
	pulumi.CustomResourceState

	// Whether to request a forced stop when `state` is `stopped`. Otherwise (_i.e._, `state` is `running`), ignored. When an instance is forced to stop, it does not flush file system caches or file system metadata, and you must subsequently perform file system check and repair. Not recommended for Windows instances. Defaults to `false`.
	Force pulumi.BoolPtrOutput `pulumi:"force"`
	// ID of the instance.
	InstanceId pulumi.StringOutput `pulumi:"instanceId"`
	// State of the instance. Valid values are `stopped`, `running`.
	//
	// The following arguments are optional:
	State pulumi.StringOutput `pulumi:"state"`
}

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

	if args.InstanceId == nil {
		return nil, errors.New("invalid value for required argument 'InstanceId'")
	}
	if args.State == nil {
		return nil, errors.New("invalid value for required argument 'State'")
	}
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource InstanceState
	err := ctx.RegisterResource("aws:ec2transitgateway/instanceState:InstanceState", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

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

// Input properties used for looking up and filtering InstanceState resources.
type instanceStateState struct {
	// Whether to request a forced stop when `state` is `stopped`. Otherwise (_i.e._, `state` is `running`), ignored. When an instance is forced to stop, it does not flush file system caches or file system metadata, and you must subsequently perform file system check and repair. Not recommended for Windows instances. Defaults to `false`.
	Force *bool `pulumi:"force"`
	// ID of the instance.
	InstanceId *string `pulumi:"instanceId"`
	// State of the instance. Valid values are `stopped`, `running`.
	//
	// The following arguments are optional:
	State *string `pulumi:"state"`
}

type InstanceStateState struct {
	// Whether to request a forced stop when `state` is `stopped`. Otherwise (_i.e._, `state` is `running`), ignored. When an instance is forced to stop, it does not flush file system caches or file system metadata, and you must subsequently perform file system check and repair. Not recommended for Windows instances. Defaults to `false`.
	Force pulumi.BoolPtrInput
	// ID of the instance.
	InstanceId pulumi.StringPtrInput
	// State of the instance. Valid values are `stopped`, `running`.
	//
	// The following arguments are optional:
	State pulumi.StringPtrInput
}

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

type instanceStateArgs struct {
	// Whether to request a forced stop when `state` is `stopped`. Otherwise (_i.e._, `state` is `running`), ignored. When an instance is forced to stop, it does not flush file system caches or file system metadata, and you must subsequently perform file system check and repair. Not recommended for Windows instances. Defaults to `false`.
	Force *bool `pulumi:"force"`
	// ID of the instance.
	InstanceId string `pulumi:"instanceId"`
	// State of the instance. Valid values are `stopped`, `running`.
	//
	// The following arguments are optional:
	State string `pulumi:"state"`
}

// The set of arguments for constructing a InstanceState resource.
type InstanceStateArgs struct {
	// Whether to request a forced stop when `state` is `stopped`. Otherwise (_i.e._, `state` is `running`), ignored. When an instance is forced to stop, it does not flush file system caches or file system metadata, and you must subsequently perform file system check and repair. Not recommended for Windows instances. Defaults to `false`.
	Force pulumi.BoolPtrInput
	// ID of the instance.
	InstanceId pulumi.StringInput
	// State of the instance. Valid values are `stopped`, `running`.
	//
	// The following arguments are optional:
	State pulumi.StringInput
}

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

type InstanceStateInput interface {
	pulumi.Input

	ToInstanceStateOutput() InstanceStateOutput
	ToInstanceStateOutputWithContext(ctx context.Context) InstanceStateOutput
}

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

func (i *InstanceState) ToInstanceStateOutput() InstanceStateOutput {
	return i.ToInstanceStateOutputWithContext(context.Background())
}

func (i *InstanceState) ToInstanceStateOutputWithContext(ctx context.Context) InstanceStateOutput {
	return pulumi.ToOutputWithContext(ctx, i).(InstanceStateOutput)
}

// InstanceStateArrayInput is an input type that accepts InstanceStateArray and InstanceStateArrayOutput values.
// You can construct a concrete instance of `InstanceStateArrayInput` via:
//
//	InstanceStateArray{ InstanceStateArgs{...} }
type InstanceStateArrayInput interface {
	pulumi.Input

	ToInstanceStateArrayOutput() InstanceStateArrayOutput
	ToInstanceStateArrayOutputWithContext(context.Context) InstanceStateArrayOutput
}

type InstanceStateArray []InstanceStateInput

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

func (i InstanceStateArray) ToInstanceStateArrayOutput() InstanceStateArrayOutput {
	return i.ToInstanceStateArrayOutputWithContext(context.Background())
}

func (i InstanceStateArray) ToInstanceStateArrayOutputWithContext(ctx context.Context) InstanceStateArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(InstanceStateArrayOutput)
}

// InstanceStateMapInput is an input type that accepts InstanceStateMap and InstanceStateMapOutput values.
// You can construct a concrete instance of `InstanceStateMapInput` via:
//
//	InstanceStateMap{ "key": InstanceStateArgs{...} }
type InstanceStateMapInput interface {
	pulumi.Input

	ToInstanceStateMapOutput() InstanceStateMapOutput
	ToInstanceStateMapOutputWithContext(context.Context) InstanceStateMapOutput
}

type InstanceStateMap map[string]InstanceStateInput

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

func (i InstanceStateMap) ToInstanceStateMapOutput() InstanceStateMapOutput {
	return i.ToInstanceStateMapOutputWithContext(context.Background())
}

func (i InstanceStateMap) ToInstanceStateMapOutputWithContext(ctx context.Context) InstanceStateMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(InstanceStateMapOutput)
}

type InstanceStateOutput struct{ *pulumi.OutputState }

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

func (o InstanceStateOutput) ToInstanceStateOutput() InstanceStateOutput {
	return o
}

func (o InstanceStateOutput) ToInstanceStateOutputWithContext(ctx context.Context) InstanceStateOutput {
	return o
}

// Whether to request a forced stop when `state` is `stopped`. Otherwise (_i.e._, `state` is `running`), ignored. When an instance is forced to stop, it does not flush file system caches or file system metadata, and you must subsequently perform file system check and repair. Not recommended for Windows instances. Defaults to `false`.
func (o InstanceStateOutput) Force() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *InstanceState) pulumi.BoolPtrOutput { return v.Force }).(pulumi.BoolPtrOutput)
}

// ID of the instance.
func (o InstanceStateOutput) InstanceId() pulumi.StringOutput {
	return o.ApplyT(func(v *InstanceState) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput)
}

// State of the instance. Valid values are `stopped`, `running`.
//
// The following arguments are optional:
func (o InstanceStateOutput) State() pulumi.StringOutput {
	return o.ApplyT(func(v *InstanceState) pulumi.StringOutput { return v.State }).(pulumi.StringOutput)
}

type InstanceStateArrayOutput struct{ *pulumi.OutputState }

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

func (o InstanceStateArrayOutput) ToInstanceStateArrayOutput() InstanceStateArrayOutput {
	return o
}

func (o InstanceStateArrayOutput) ToInstanceStateArrayOutputWithContext(ctx context.Context) InstanceStateArrayOutput {
	return o
}

func (o InstanceStateArrayOutput) Index(i pulumi.IntInput) InstanceStateOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *InstanceState {
		return vs[0].([]*InstanceState)[vs[1].(int)]
	}).(InstanceStateOutput)
}

type InstanceStateMapOutput struct{ *pulumi.OutputState }

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

func (o InstanceStateMapOutput) ToInstanceStateMapOutput() InstanceStateMapOutput {
	return o
}

func (o InstanceStateMapOutput) ToInstanceStateMapOutputWithContext(ctx context.Context) InstanceStateMapOutput {
	return o
}

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

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*InstanceStateInput)(nil)).Elem(), &InstanceState{})
	pulumi.RegisterInputType(reflect.TypeOf((*InstanceStateArrayInput)(nil)).Elem(), InstanceStateArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*InstanceStateMapInput)(nil)).Elem(), InstanceStateMap{})
	pulumi.RegisterOutputType(InstanceStateOutput{})
	pulumi.RegisterOutputType(InstanceStateArrayOutput{})
	pulumi.RegisterOutputType(InstanceStateMapOutput{})
}