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