| // Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. |
| |
| package ec2 |
| |
| import ( |
| "time" |
| |
| "github.com/aws/aws-sdk-go/aws" |
| "github.com/aws/aws-sdk-go/aws/request" |
| ) |
| |
| // WaitUntilBundleTaskComplete uses the Amazon EC2 API operation |
| // DescribeBundleTasks to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilBundleTaskComplete(input *DescribeBundleTasksInput) error { |
| return c.WaitUntilBundleTaskCompleteWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilBundleTaskCompleteWithContext is an extended version of WaitUntilBundleTaskComplete. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilBundleTaskCompleteWithContext(ctx aws.Context, input *DescribeBundleTasksInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilBundleTaskComplete", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "BundleTasks[].State", |
| Expected: "complete", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "BundleTasks[].State", |
| Expected: "failed", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeBundleTasksInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeBundleTasksRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilConversionTaskCancelled uses the Amazon EC2 API operation |
| // DescribeConversionTasks to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilConversionTaskCancelled(input *DescribeConversionTasksInput) error { |
| return c.WaitUntilConversionTaskCancelledWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilConversionTaskCancelledWithContext is an extended version of WaitUntilConversionTaskCancelled. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilConversionTaskCancelledWithContext(ctx aws.Context, input *DescribeConversionTasksInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilConversionTaskCancelled", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "ConversionTasks[].State", |
| Expected: "cancelled", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeConversionTasksInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeConversionTasksRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilConversionTaskCompleted uses the Amazon EC2 API operation |
| // DescribeConversionTasks to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilConversionTaskCompleted(input *DescribeConversionTasksInput) error { |
| return c.WaitUntilConversionTaskCompletedWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilConversionTaskCompletedWithContext is an extended version of WaitUntilConversionTaskCompleted. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilConversionTaskCompletedWithContext(ctx aws.Context, input *DescribeConversionTasksInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilConversionTaskCompleted", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "ConversionTasks[].State", |
| Expected: "completed", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "ConversionTasks[].State", |
| Expected: "cancelled", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "ConversionTasks[].State", |
| Expected: "cancelling", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeConversionTasksInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeConversionTasksRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilConversionTaskDeleted uses the Amazon EC2 API operation |
| // DescribeConversionTasks to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilConversionTaskDeleted(input *DescribeConversionTasksInput) error { |
| return c.WaitUntilConversionTaskDeletedWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilConversionTaskDeletedWithContext is an extended version of WaitUntilConversionTaskDeleted. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilConversionTaskDeletedWithContext(ctx aws.Context, input *DescribeConversionTasksInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilConversionTaskDeleted", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "ConversionTasks[].State", |
| Expected: "deleted", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeConversionTasksInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeConversionTasksRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilCustomerGatewayAvailable uses the Amazon EC2 API operation |
| // DescribeCustomerGateways to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilCustomerGatewayAvailable(input *DescribeCustomerGatewaysInput) error { |
| return c.WaitUntilCustomerGatewayAvailableWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilCustomerGatewayAvailableWithContext is an extended version of WaitUntilCustomerGatewayAvailable. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilCustomerGatewayAvailableWithContext(ctx aws.Context, input *DescribeCustomerGatewaysInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilCustomerGatewayAvailable", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "CustomerGateways[].State", |
| Expected: "available", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "CustomerGateways[].State", |
| Expected: "deleted", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "CustomerGateways[].State", |
| Expected: "deleting", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeCustomerGatewaysInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeCustomerGatewaysRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilExportTaskCancelled uses the Amazon EC2 API operation |
| // DescribeExportTasks to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilExportTaskCancelled(input *DescribeExportTasksInput) error { |
| return c.WaitUntilExportTaskCancelledWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilExportTaskCancelledWithContext is an extended version of WaitUntilExportTaskCancelled. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilExportTaskCancelledWithContext(ctx aws.Context, input *DescribeExportTasksInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilExportTaskCancelled", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "ExportTasks[].State", |
| Expected: "cancelled", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeExportTasksInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeExportTasksRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilExportTaskCompleted uses the Amazon EC2 API operation |
| // DescribeExportTasks to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilExportTaskCompleted(input *DescribeExportTasksInput) error { |
| return c.WaitUntilExportTaskCompletedWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilExportTaskCompletedWithContext is an extended version of WaitUntilExportTaskCompleted. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilExportTaskCompletedWithContext(ctx aws.Context, input *DescribeExportTasksInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilExportTaskCompleted", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "ExportTasks[].State", |
| Expected: "completed", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeExportTasksInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeExportTasksRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilImageAvailable uses the Amazon EC2 API operation |
| // DescribeImages to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilImageAvailable(input *DescribeImagesInput) error { |
| return c.WaitUntilImageAvailableWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilImageAvailableWithContext is an extended version of WaitUntilImageAvailable. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilImageAvailableWithContext(ctx aws.Context, input *DescribeImagesInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilImageAvailable", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "Images[].State", |
| Expected: "available", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "Images[].State", |
| Expected: "failed", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeImagesInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeImagesRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilImageExists uses the Amazon EC2 API operation |
| // DescribeImages to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilImageExists(input *DescribeImagesInput) error { |
| return c.WaitUntilImageExistsWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilImageExistsWithContext is an extended version of WaitUntilImageExists. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilImageExistsWithContext(ctx aws.Context, input *DescribeImagesInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilImageExists", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathWaiterMatch, Argument: "length(Images[]) > `0`", |
| Expected: true, |
| }, |
| { |
| State: request.RetryWaiterState, |
| Matcher: request.ErrorWaiterMatch, |
| Expected: "InvalidAMIID.NotFound", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeImagesInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeImagesRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilInstanceExists uses the Amazon EC2 API operation |
| // DescribeInstances to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilInstanceExists(input *DescribeInstancesInput) error { |
| return c.WaitUntilInstanceExistsWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilInstanceExistsWithContext is an extended version of WaitUntilInstanceExists. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilInstanceExistsWithContext(ctx aws.Context, input *DescribeInstancesInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilInstanceExists", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(5 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathWaiterMatch, Argument: "length(Reservations[]) > `0`", |
| Expected: true, |
| }, |
| { |
| State: request.RetryWaiterState, |
| Matcher: request.ErrorWaiterMatch, |
| Expected: "InvalidInstanceID.NotFound", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeInstancesInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeInstancesRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilInstanceRunning uses the Amazon EC2 API operation |
| // DescribeInstances to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilInstanceRunning(input *DescribeInstancesInput) error { |
| return c.WaitUntilInstanceRunningWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilInstanceRunningWithContext is an extended version of WaitUntilInstanceRunning. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilInstanceRunningWithContext(ctx aws.Context, input *DescribeInstancesInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilInstanceRunning", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "Reservations[].Instances[].State.Name", |
| Expected: "running", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "Reservations[].Instances[].State.Name", |
| Expected: "shutting-down", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "Reservations[].Instances[].State.Name", |
| Expected: "terminated", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "Reservations[].Instances[].State.Name", |
| Expected: "stopping", |
| }, |
| { |
| State: request.RetryWaiterState, |
| Matcher: request.ErrorWaiterMatch, |
| Expected: "InvalidInstanceID.NotFound", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeInstancesInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeInstancesRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilInstanceStatusOk uses the Amazon EC2 API operation |
| // DescribeInstanceStatus to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilInstanceStatusOk(input *DescribeInstanceStatusInput) error { |
| return c.WaitUntilInstanceStatusOkWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilInstanceStatusOkWithContext is an extended version of WaitUntilInstanceStatusOk. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilInstanceStatusOkWithContext(ctx aws.Context, input *DescribeInstanceStatusInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilInstanceStatusOk", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "InstanceStatuses[].InstanceStatus.Status", |
| Expected: "ok", |
| }, |
| { |
| State: request.RetryWaiterState, |
| Matcher: request.ErrorWaiterMatch, |
| Expected: "InvalidInstanceID.NotFound", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeInstanceStatusInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeInstanceStatusRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilInstanceStopped uses the Amazon EC2 API operation |
| // DescribeInstances to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilInstanceStopped(input *DescribeInstancesInput) error { |
| return c.WaitUntilInstanceStoppedWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilInstanceStoppedWithContext is an extended version of WaitUntilInstanceStopped. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilInstanceStoppedWithContext(ctx aws.Context, input *DescribeInstancesInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilInstanceStopped", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "Reservations[].Instances[].State.Name", |
| Expected: "stopped", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "Reservations[].Instances[].State.Name", |
| Expected: "pending", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "Reservations[].Instances[].State.Name", |
| Expected: "terminated", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeInstancesInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeInstancesRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilInstanceTerminated uses the Amazon EC2 API operation |
| // DescribeInstances to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilInstanceTerminated(input *DescribeInstancesInput) error { |
| return c.WaitUntilInstanceTerminatedWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilInstanceTerminatedWithContext is an extended version of WaitUntilInstanceTerminated. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilInstanceTerminatedWithContext(ctx aws.Context, input *DescribeInstancesInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilInstanceTerminated", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "Reservations[].Instances[].State.Name", |
| Expected: "terminated", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "Reservations[].Instances[].State.Name", |
| Expected: "pending", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "Reservations[].Instances[].State.Name", |
| Expected: "stopping", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeInstancesInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeInstancesRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilKeyPairExists uses the Amazon EC2 API operation |
| // DescribeKeyPairs to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilKeyPairExists(input *DescribeKeyPairsInput) error { |
| return c.WaitUntilKeyPairExistsWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilKeyPairExistsWithContext is an extended version of WaitUntilKeyPairExists. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilKeyPairExistsWithContext(ctx aws.Context, input *DescribeKeyPairsInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilKeyPairExists", |
| MaxAttempts: 6, |
| Delay: request.ConstantWaiterDelay(5 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathWaiterMatch, Argument: "length(KeyPairs[].KeyName) > `0`", |
| Expected: true, |
| }, |
| { |
| State: request.RetryWaiterState, |
| Matcher: request.ErrorWaiterMatch, |
| Expected: "InvalidKeyPair.NotFound", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeKeyPairsInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeKeyPairsRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilNatGatewayAvailable uses the Amazon EC2 API operation |
| // DescribeNatGateways to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilNatGatewayAvailable(input *DescribeNatGatewaysInput) error { |
| return c.WaitUntilNatGatewayAvailableWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilNatGatewayAvailableWithContext is an extended version of WaitUntilNatGatewayAvailable. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilNatGatewayAvailableWithContext(ctx aws.Context, input *DescribeNatGatewaysInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilNatGatewayAvailable", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "NatGateways[].State", |
| Expected: "available", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "NatGateways[].State", |
| Expected: "failed", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "NatGateways[].State", |
| Expected: "deleting", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "NatGateways[].State", |
| Expected: "deleted", |
| }, |
| { |
| State: request.RetryWaiterState, |
| Matcher: request.ErrorWaiterMatch, |
| Expected: "NatGatewayNotFound", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeNatGatewaysInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeNatGatewaysRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilNetworkInterfaceAvailable uses the Amazon EC2 API operation |
| // DescribeNetworkInterfaces to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilNetworkInterfaceAvailable(input *DescribeNetworkInterfacesInput) error { |
| return c.WaitUntilNetworkInterfaceAvailableWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilNetworkInterfaceAvailableWithContext is an extended version of WaitUntilNetworkInterfaceAvailable. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilNetworkInterfaceAvailableWithContext(ctx aws.Context, input *DescribeNetworkInterfacesInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilNetworkInterfaceAvailable", |
| MaxAttempts: 10, |
| Delay: request.ConstantWaiterDelay(20 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "NetworkInterfaces[].Status", |
| Expected: "available", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.ErrorWaiterMatch, |
| Expected: "InvalidNetworkInterfaceID.NotFound", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeNetworkInterfacesInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeNetworkInterfacesRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilPasswordDataAvailable uses the Amazon EC2 API operation |
| // GetPasswordData to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilPasswordDataAvailable(input *GetPasswordDataInput) error { |
| return c.WaitUntilPasswordDataAvailableWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilPasswordDataAvailableWithContext is an extended version of WaitUntilPasswordDataAvailable. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilPasswordDataAvailableWithContext(ctx aws.Context, input *GetPasswordDataInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilPasswordDataAvailable", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathWaiterMatch, Argument: "length(PasswordData) > `0`", |
| Expected: true, |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *GetPasswordDataInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.GetPasswordDataRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilSnapshotCompleted uses the Amazon EC2 API operation |
| // DescribeSnapshots to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilSnapshotCompleted(input *DescribeSnapshotsInput) error { |
| return c.WaitUntilSnapshotCompletedWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilSnapshotCompletedWithContext is an extended version of WaitUntilSnapshotCompleted. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilSnapshotCompletedWithContext(ctx aws.Context, input *DescribeSnapshotsInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilSnapshotCompleted", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "Snapshots[].State", |
| Expected: "completed", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeSnapshotsInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeSnapshotsRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilSpotInstanceRequestFulfilled uses the Amazon EC2 API operation |
| // DescribeSpotInstanceRequests to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilSpotInstanceRequestFulfilled(input *DescribeSpotInstanceRequestsInput) error { |
| return c.WaitUntilSpotInstanceRequestFulfilledWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilSpotInstanceRequestFulfilledWithContext is an extended version of WaitUntilSpotInstanceRequestFulfilled. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilSpotInstanceRequestFulfilledWithContext(ctx aws.Context, input *DescribeSpotInstanceRequestsInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilSpotInstanceRequestFulfilled", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "SpotInstanceRequests[].Status.Code", |
| Expected: "fulfilled", |
| }, |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "SpotInstanceRequests[].Status.Code", |
| Expected: "request-canceled-and-instance-running", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "SpotInstanceRequests[].Status.Code", |
| Expected: "schedule-expired", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "SpotInstanceRequests[].Status.Code", |
| Expected: "canceled-before-fulfillment", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "SpotInstanceRequests[].Status.Code", |
| Expected: "bad-parameters", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "SpotInstanceRequests[].Status.Code", |
| Expected: "system-error", |
| }, |
| { |
| State: request.RetryWaiterState, |
| Matcher: request.ErrorWaiterMatch, |
| Expected: "InvalidSpotInstanceRequestID.NotFound", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeSpotInstanceRequestsInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeSpotInstanceRequestsRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilSubnetAvailable uses the Amazon EC2 API operation |
| // DescribeSubnets to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilSubnetAvailable(input *DescribeSubnetsInput) error { |
| return c.WaitUntilSubnetAvailableWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilSubnetAvailableWithContext is an extended version of WaitUntilSubnetAvailable. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilSubnetAvailableWithContext(ctx aws.Context, input *DescribeSubnetsInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilSubnetAvailable", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "Subnets[].State", |
| Expected: "available", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeSubnetsInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeSubnetsRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilSystemStatusOk uses the Amazon EC2 API operation |
| // DescribeInstanceStatus to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilSystemStatusOk(input *DescribeInstanceStatusInput) error { |
| return c.WaitUntilSystemStatusOkWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilSystemStatusOkWithContext is an extended version of WaitUntilSystemStatusOk. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilSystemStatusOkWithContext(ctx aws.Context, input *DescribeInstanceStatusInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilSystemStatusOk", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "InstanceStatuses[].SystemStatus.Status", |
| Expected: "ok", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeInstanceStatusInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeInstanceStatusRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilVolumeAvailable uses the Amazon EC2 API operation |
| // DescribeVolumes to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilVolumeAvailable(input *DescribeVolumesInput) error { |
| return c.WaitUntilVolumeAvailableWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilVolumeAvailableWithContext is an extended version of WaitUntilVolumeAvailable. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilVolumeAvailableWithContext(ctx aws.Context, input *DescribeVolumesInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilVolumeAvailable", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "Volumes[].State", |
| Expected: "available", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "Volumes[].State", |
| Expected: "deleted", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeVolumesInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeVolumesRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilVolumeDeleted uses the Amazon EC2 API operation |
| // DescribeVolumes to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilVolumeDeleted(input *DescribeVolumesInput) error { |
| return c.WaitUntilVolumeDeletedWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilVolumeDeletedWithContext is an extended version of WaitUntilVolumeDeleted. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilVolumeDeletedWithContext(ctx aws.Context, input *DescribeVolumesInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilVolumeDeleted", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "Volumes[].State", |
| Expected: "deleted", |
| }, |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.ErrorWaiterMatch, |
| Expected: "InvalidVolume.NotFound", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeVolumesInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeVolumesRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilVolumeInUse uses the Amazon EC2 API operation |
| // DescribeVolumes to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilVolumeInUse(input *DescribeVolumesInput) error { |
| return c.WaitUntilVolumeInUseWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilVolumeInUseWithContext is an extended version of WaitUntilVolumeInUse. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilVolumeInUseWithContext(ctx aws.Context, input *DescribeVolumesInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilVolumeInUse", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "Volumes[].State", |
| Expected: "in-use", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "Volumes[].State", |
| Expected: "deleted", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeVolumesInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeVolumesRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilVpcAvailable uses the Amazon EC2 API operation |
| // DescribeVpcs to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilVpcAvailable(input *DescribeVpcsInput) error { |
| return c.WaitUntilVpcAvailableWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilVpcAvailableWithContext is an extended version of WaitUntilVpcAvailable. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilVpcAvailableWithContext(ctx aws.Context, input *DescribeVpcsInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilVpcAvailable", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "Vpcs[].State", |
| Expected: "available", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeVpcsInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeVpcsRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilVpcExists uses the Amazon EC2 API operation |
| // DescribeVpcs to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilVpcExists(input *DescribeVpcsInput) error { |
| return c.WaitUntilVpcExistsWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilVpcExistsWithContext is an extended version of WaitUntilVpcExists. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilVpcExistsWithContext(ctx aws.Context, input *DescribeVpcsInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilVpcExists", |
| MaxAttempts: 5, |
| Delay: request.ConstantWaiterDelay(1 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.StatusWaiterMatch, |
| Expected: 200, |
| }, |
| { |
| State: request.RetryWaiterState, |
| Matcher: request.ErrorWaiterMatch, |
| Expected: "InvalidVpcID.NotFound", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeVpcsInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeVpcsRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilVpcPeeringConnectionDeleted uses the Amazon EC2 API operation |
| // DescribeVpcPeeringConnections to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilVpcPeeringConnectionDeleted(input *DescribeVpcPeeringConnectionsInput) error { |
| return c.WaitUntilVpcPeeringConnectionDeletedWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilVpcPeeringConnectionDeletedWithContext is an extended version of WaitUntilVpcPeeringConnectionDeleted. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilVpcPeeringConnectionDeletedWithContext(ctx aws.Context, input *DescribeVpcPeeringConnectionsInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilVpcPeeringConnectionDeleted", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "VpcPeeringConnections[].Status.Code", |
| Expected: "deleted", |
| }, |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.ErrorWaiterMatch, |
| Expected: "InvalidVpcPeeringConnectionID.NotFound", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeVpcPeeringConnectionsInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeVpcPeeringConnectionsRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilVpcPeeringConnectionExists uses the Amazon EC2 API operation |
| // DescribeVpcPeeringConnections to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilVpcPeeringConnectionExists(input *DescribeVpcPeeringConnectionsInput) error { |
| return c.WaitUntilVpcPeeringConnectionExistsWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilVpcPeeringConnectionExistsWithContext is an extended version of WaitUntilVpcPeeringConnectionExists. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilVpcPeeringConnectionExistsWithContext(ctx aws.Context, input *DescribeVpcPeeringConnectionsInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilVpcPeeringConnectionExists", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.StatusWaiterMatch, |
| Expected: 200, |
| }, |
| { |
| State: request.RetryWaiterState, |
| Matcher: request.ErrorWaiterMatch, |
| Expected: "InvalidVpcPeeringConnectionID.NotFound", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeVpcPeeringConnectionsInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeVpcPeeringConnectionsRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilVpnConnectionAvailable uses the Amazon EC2 API operation |
| // DescribeVpnConnections to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilVpnConnectionAvailable(input *DescribeVpnConnectionsInput) error { |
| return c.WaitUntilVpnConnectionAvailableWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilVpnConnectionAvailableWithContext is an extended version of WaitUntilVpnConnectionAvailable. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilVpnConnectionAvailableWithContext(ctx aws.Context, input *DescribeVpnConnectionsInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilVpnConnectionAvailable", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "VpnConnections[].State", |
| Expected: "available", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "VpnConnections[].State", |
| Expected: "deleting", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "VpnConnections[].State", |
| Expected: "deleted", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeVpnConnectionsInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeVpnConnectionsRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |
| |
| // WaitUntilVpnConnectionDeleted uses the Amazon EC2 API operation |
| // DescribeVpnConnections to wait for a condition to be met before returning. |
| // If the condition is not met within the max attempt window, an error will |
| // be returned. |
| func (c *EC2) WaitUntilVpnConnectionDeleted(input *DescribeVpnConnectionsInput) error { |
| return c.WaitUntilVpnConnectionDeletedWithContext(aws.BackgroundContext(), input) |
| } |
| |
| // WaitUntilVpnConnectionDeletedWithContext is an extended version of WaitUntilVpnConnectionDeleted. |
| // With the support for passing in a context and options to configure the |
| // Waiter and the underlying request options. |
| // |
| // The context must be non-nil and will be used for request cancellation. If |
| // the context is nil a panic will occur. In the future the SDK may create |
| // sub-contexts for http.Requests. See https://golang.org/pkg/context/ |
| // for more information on using Contexts. |
| func (c *EC2) WaitUntilVpnConnectionDeletedWithContext(ctx aws.Context, input *DescribeVpnConnectionsInput, opts ...request.WaiterOption) error { |
| w := request.Waiter{ |
| Name: "WaitUntilVpnConnectionDeleted", |
| MaxAttempts: 40, |
| Delay: request.ConstantWaiterDelay(15 * time.Second), |
| Acceptors: []request.WaiterAcceptor{ |
| { |
| State: request.SuccessWaiterState, |
| Matcher: request.PathAllWaiterMatch, Argument: "VpnConnections[].State", |
| Expected: "deleted", |
| }, |
| { |
| State: request.FailureWaiterState, |
| Matcher: request.PathAnyWaiterMatch, Argument: "VpnConnections[].State", |
| Expected: "pending", |
| }, |
| }, |
| Logger: c.Config.Logger, |
| NewRequest: func(opts []request.Option) (*request.Request, error) { |
| var inCpy *DescribeVpnConnectionsInput |
| if input != nil { |
| tmp := *input |
| inCpy = &tmp |
| } |
| req, _ := c.DescribeVpnConnectionsRequest(inCpy) |
| req.SetContext(ctx) |
| req.ApplyOptions(opts...) |
| return req, nil |
| }, |
| } |
| w.ApplyOptions(opts...) |
| |
| return w.WaitWithContext(ctx) |
| } |