1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package lexmodelsv2
4
5import (
6	"context"
7	"errors"
8	"fmt"
9	awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
10	"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
11	"github.com/aws/aws-sdk-go-v2/service/lexmodelsv2/types"
12	"github.com/aws/smithy-go/middleware"
13	smithytime "github.com/aws/smithy-go/time"
14	smithyhttp "github.com/aws/smithy-go/transport/http"
15	smithywaiter "github.com/aws/smithy-go/waiter"
16	"github.com/jmespath/go-jmespath"
17	"time"
18)
19
20// Provides metadata about a version of a bot.
21func (c *Client) DescribeBotVersion(ctx context.Context, params *DescribeBotVersionInput, optFns ...func(*Options)) (*DescribeBotVersionOutput, error) {
22	if params == nil {
23		params = &DescribeBotVersionInput{}
24	}
25
26	result, metadata, err := c.invokeOperation(ctx, "DescribeBotVersion", params, optFns, c.addOperationDescribeBotVersionMiddlewares)
27	if err != nil {
28		return nil, err
29	}
30
31	out := result.(*DescribeBotVersionOutput)
32	out.ResultMetadata = metadata
33	return out, nil
34}
35
36type DescribeBotVersionInput struct {
37
38	// The identifier of the bot containing the version to return metadata for.
39	//
40	// This member is required.
41	BotId *string
42
43	// The version of the bot to return metadata for.
44	//
45	// This member is required.
46	BotVersion *string
47
48	noSmithyDocumentSerde
49}
50
51type DescribeBotVersionOutput struct {
52
53	// The identifier of the bot that contains the version.
54	BotId *string
55
56	// The name of the bot that contains the version.
57	BotName *string
58
59	// The current status of the bot. When the status is Available, the bot version is
60	// ready for use.
61	BotStatus types.BotStatus
62
63	// The version of the bot to describe.
64	BotVersion *string
65
66	// A timestamp of the date and time that the bot version was created.
67	CreationDateTime *time.Time
68
69	// Data privacy settings for the bot version.
70	DataPrivacy *types.DataPrivacy
71
72	// The description specified for the bot.
73	Description *string
74
75	// If the botStatus is Failed, this contains a list of reasons that the version
76	// couldn't be built.
77	FailureReasons []string
78
79	// The number of seconds that a session with the bot remains active before it is
80	// discarded by Amazon Lex.
81	IdleSessionTTLInSeconds *int32
82
83	// The Amazon Resource Name (ARN) of an IAM role that has permission to access the
84	// bot version.
85	RoleArn *string
86
87	// Metadata pertaining to the operation's result.
88	ResultMetadata middleware.Metadata
89
90	noSmithyDocumentSerde
91}
92
93func (c *Client) addOperationDescribeBotVersionMiddlewares(stack *middleware.Stack, options Options) (err error) {
94	err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeBotVersion{}, middleware.After)
95	if err != nil {
96		return err
97	}
98	err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeBotVersion{}, middleware.After)
99	if err != nil {
100		return err
101	}
102	if err = addSetLoggerMiddleware(stack, options); err != nil {
103		return err
104	}
105	if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
106		return err
107	}
108	if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
109		return err
110	}
111	if err = addResolveEndpointMiddleware(stack, options); err != nil {
112		return err
113	}
114	if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
115		return err
116	}
117	if err = addRetryMiddlewares(stack, options); err != nil {
118		return err
119	}
120	if err = addHTTPSignerV4Middleware(stack, options); err != nil {
121		return err
122	}
123	if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
124		return err
125	}
126	if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
127		return err
128	}
129	if err = addClientUserAgent(stack); err != nil {
130		return err
131	}
132	if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
133		return err
134	}
135	if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
136		return err
137	}
138	if err = addOpDescribeBotVersionValidationMiddleware(stack); err != nil {
139		return err
140	}
141	if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeBotVersion(options.Region), middleware.Before); err != nil {
142		return err
143	}
144	if err = addRequestIDRetrieverMiddleware(stack); err != nil {
145		return err
146	}
147	if err = addResponseErrorMiddleware(stack); err != nil {
148		return err
149	}
150	if err = addRequestResponseLogging(stack, options); err != nil {
151		return err
152	}
153	return nil
154}
155
156// DescribeBotVersionAPIClient is a client that implements the DescribeBotVersion
157// operation.
158type DescribeBotVersionAPIClient interface {
159	DescribeBotVersion(context.Context, *DescribeBotVersionInput, ...func(*Options)) (*DescribeBotVersionOutput, error)
160}
161
162var _ DescribeBotVersionAPIClient = (*Client)(nil)
163
164// BotVersionAvailableWaiterOptions are waiter options for
165// BotVersionAvailableWaiter
166type BotVersionAvailableWaiterOptions struct {
167
168	// Set of options to modify how an operation is invoked. These apply to all
169	// operations invoked for this client. Use functional options on operation call to
170	// modify this list for per operation behavior.
171	APIOptions []func(*middleware.Stack) error
172
173	// MinDelay is the minimum amount of time to delay between retries. If unset,
174	// BotVersionAvailableWaiter will use default minimum delay of 10 seconds. Note
175	// that MinDelay must resolve to a value lesser than or equal to the MaxDelay.
176	MinDelay time.Duration
177
178	// MaxDelay is the maximum amount of time to delay between retries. If unset or set
179	// to zero, BotVersionAvailableWaiter will use default max delay of 120 seconds.
180	// Note that MaxDelay must resolve to value greater than or equal to the MinDelay.
181	MaxDelay time.Duration
182
183	// LogWaitAttempts is used to enable logging for waiter retry attempts
184	LogWaitAttempts bool
185
186	// Retryable is function that can be used to override the service defined
187	// waiter-behavior based on operation output, or returned error. This function is
188	// used by the waiter to decide if a state is retryable or a terminal state. By
189	// default service-modeled logic will populate this option. This option can thus be
190	// used to define a custom waiter state with fall-back to service-modeled waiter
191	// state mutators.The function returns an error in case of a failure state. In case
192	// of retry state, this function returns a bool value of true and nil error, while
193	// in case of success it returns a bool value of false and nil error.
194	Retryable func(context.Context, *DescribeBotVersionInput, *DescribeBotVersionOutput, error) (bool, error)
195}
196
197// BotVersionAvailableWaiter defines the waiters for BotVersionAvailable
198type BotVersionAvailableWaiter struct {
199	client DescribeBotVersionAPIClient
200
201	options BotVersionAvailableWaiterOptions
202}
203
204// NewBotVersionAvailableWaiter constructs a BotVersionAvailableWaiter.
205func NewBotVersionAvailableWaiter(client DescribeBotVersionAPIClient, optFns ...func(*BotVersionAvailableWaiterOptions)) *BotVersionAvailableWaiter {
206	options := BotVersionAvailableWaiterOptions{}
207	options.MinDelay = 10 * time.Second
208	options.MaxDelay = 120 * time.Second
209	options.Retryable = botVersionAvailableStateRetryable
210
211	for _, fn := range optFns {
212		fn(&options)
213	}
214	return &BotVersionAvailableWaiter{
215		client:  client,
216		options: options,
217	}
218}
219
220// Wait calls the waiter function for BotVersionAvailable waiter. The maxWaitDur is
221// the maximum wait duration the waiter will wait. The maxWaitDur is required and
222// must be greater than zero.
223func (w *BotVersionAvailableWaiter) Wait(ctx context.Context, params *DescribeBotVersionInput, maxWaitDur time.Duration, optFns ...func(*BotVersionAvailableWaiterOptions)) error {
224	if maxWaitDur <= 0 {
225		return fmt.Errorf("maximum wait time for waiter must be greater than zero")
226	}
227
228	options := w.options
229	for _, fn := range optFns {
230		fn(&options)
231	}
232
233	if options.MaxDelay <= 0 {
234		options.MaxDelay = 120 * time.Second
235	}
236
237	if options.MinDelay > options.MaxDelay {
238		return fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
239	}
240
241	ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
242	defer cancelFn()
243
244	logger := smithywaiter.Logger{}
245	remainingTime := maxWaitDur
246
247	var attempt int64
248	for {
249
250		attempt++
251		apiOptions := options.APIOptions
252		start := time.Now()
253
254		if options.LogWaitAttempts {
255			logger.Attempt = attempt
256			apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
257			apiOptions = append(apiOptions, logger.AddLogger)
258		}
259
260		out, err := w.client.DescribeBotVersion(ctx, params, func(o *Options) {
261			o.APIOptions = append(o.APIOptions, apiOptions...)
262		})
263
264		retryable, err := options.Retryable(ctx, params, out, err)
265		if err != nil {
266			return err
267		}
268		if !retryable {
269			return nil
270		}
271
272		remainingTime -= time.Since(start)
273		if remainingTime < options.MinDelay || remainingTime <= 0 {
274			break
275		}
276
277		// compute exponential backoff between waiter retries
278		delay, err := smithywaiter.ComputeDelay(
279			attempt, options.MinDelay, options.MaxDelay, remainingTime,
280		)
281		if err != nil {
282			return fmt.Errorf("error computing waiter delay, %w", err)
283		}
284
285		remainingTime -= delay
286		// sleep for the delay amount before invoking a request
287		if err := smithytime.SleepWithContext(ctx, delay); err != nil {
288			return fmt.Errorf("request cancelled while waiting, %w", err)
289		}
290	}
291	return fmt.Errorf("exceeded max wait time for BotVersionAvailable waiter")
292}
293
294func botVersionAvailableStateRetryable(ctx context.Context, input *DescribeBotVersionInput, output *DescribeBotVersionOutput, err error) (bool, error) {
295
296	if err == nil {
297		pathValue, err := jmespath.Search("botStatus", output)
298		if err != nil {
299			return false, fmt.Errorf("error evaluating waiter state: %w", err)
300		}
301
302		expectedValue := "Available"
303		value, ok := pathValue.(types.BotStatus)
304		if !ok {
305			return false, fmt.Errorf("waiter comparator expected types.BotStatus value, got %T", pathValue)
306		}
307
308		if string(value) == expectedValue {
309			return false, nil
310		}
311	}
312
313	if err == nil {
314		pathValue, err := jmespath.Search("botStatus", output)
315		if err != nil {
316			return false, fmt.Errorf("error evaluating waiter state: %w", err)
317		}
318
319		expectedValue := "Deleting"
320		value, ok := pathValue.(types.BotStatus)
321		if !ok {
322			return false, fmt.Errorf("waiter comparator expected types.BotStatus value, got %T", pathValue)
323		}
324
325		if string(value) == expectedValue {
326			return false, fmt.Errorf("waiter state transitioned to Failure")
327		}
328	}
329
330	if err == nil {
331		pathValue, err := jmespath.Search("botStatus", output)
332		if err != nil {
333			return false, fmt.Errorf("error evaluating waiter state: %w", err)
334		}
335
336		expectedValue := "Failed"
337		value, ok := pathValue.(types.BotStatus)
338		if !ok {
339			return false, fmt.Errorf("waiter comparator expected types.BotStatus value, got %T", pathValue)
340		}
341
342		if string(value) == expectedValue {
343			return false, fmt.Errorf("waiter state transitioned to Failure")
344		}
345	}
346
347	if err != nil {
348		var errorType *types.ResourceNotFoundException
349		if errors.As(err, &errorType) {
350			return true, nil
351		}
352	}
353
354	return true, nil
355}
356
357func newServiceMetadataMiddleware_opDescribeBotVersion(region string) *awsmiddleware.RegisterServiceMetadata {
358	return &awsmiddleware.RegisterServiceMetadata{
359		Region:        region,
360		ServiceID:     ServiceID,
361		SigningName:   "lex",
362		OperationName: "DescribeBotVersion",
363	}
364}
365