1// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. 2 3package proton 4 5import ( 6 "time" 7 8 "github.com/aws/aws-sdk-go/aws" 9 "github.com/aws/aws-sdk-go/aws/request" 10) 11 12// WaitUntilEnvironmentDeployed uses the AWS Proton API operation 13// GetEnvironment to wait for a condition to be met before returning. 14// If the condition is not met within the max attempt window, an error will 15// be returned. 16func (c *Proton) WaitUntilEnvironmentDeployed(input *GetEnvironmentInput) error { 17 return c.WaitUntilEnvironmentDeployedWithContext(aws.BackgroundContext(), input) 18} 19 20// WaitUntilEnvironmentDeployedWithContext is an extended version of WaitUntilEnvironmentDeployed. 21// With the support for passing in a context and options to configure the 22// Waiter and the underlying request options. 23// 24// The context must be non-nil and will be used for request cancellation. If 25// the context is nil a panic will occur. In the future the SDK may create 26// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 27// for more information on using Contexts. 28func (c *Proton) WaitUntilEnvironmentDeployedWithContext(ctx aws.Context, input *GetEnvironmentInput, opts ...request.WaiterOption) error { 29 w := request.Waiter{ 30 Name: "WaitUntilEnvironmentDeployed", 31 MaxAttempts: 999, 32 Delay: request.ConstantWaiterDelay(5 * time.Second), 33 Acceptors: []request.WaiterAcceptor{ 34 { 35 State: request.SuccessWaiterState, 36 Matcher: request.PathWaiterMatch, Argument: "environment.deploymentStatus", 37 Expected: "SUCCEEDED", 38 }, 39 { 40 State: request.FailureWaiterState, 41 Matcher: request.PathWaiterMatch, Argument: "environment.deploymentStatus", 42 Expected: "FAILED", 43 }, 44 }, 45 Logger: c.Config.Logger, 46 NewRequest: func(opts []request.Option) (*request.Request, error) { 47 var inCpy *GetEnvironmentInput 48 if input != nil { 49 tmp := *input 50 inCpy = &tmp 51 } 52 req, _ := c.GetEnvironmentRequest(inCpy) 53 req.SetContext(ctx) 54 req.ApplyOptions(opts...) 55 return req, nil 56 }, 57 } 58 w.ApplyOptions(opts...) 59 60 return w.WaitWithContext(ctx) 61} 62 63// WaitUntilEnvironmentTemplateVersionRegistered uses the AWS Proton API operation 64// GetEnvironmentTemplateVersion to wait for a condition to be met before returning. 65// If the condition is not met within the max attempt window, an error will 66// be returned. 67func (c *Proton) WaitUntilEnvironmentTemplateVersionRegistered(input *GetEnvironmentTemplateVersionInput) error { 68 return c.WaitUntilEnvironmentTemplateVersionRegisteredWithContext(aws.BackgroundContext(), input) 69} 70 71// WaitUntilEnvironmentTemplateVersionRegisteredWithContext is an extended version of WaitUntilEnvironmentTemplateVersionRegistered. 72// With the support for passing in a context and options to configure the 73// Waiter and the underlying request options. 74// 75// The context must be non-nil and will be used for request cancellation. If 76// the context is nil a panic will occur. In the future the SDK may create 77// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 78// for more information on using Contexts. 79func (c *Proton) WaitUntilEnvironmentTemplateVersionRegisteredWithContext(ctx aws.Context, input *GetEnvironmentTemplateVersionInput, opts ...request.WaiterOption) error { 80 w := request.Waiter{ 81 Name: "WaitUntilEnvironmentTemplateVersionRegistered", 82 MaxAttempts: 150, 83 Delay: request.ConstantWaiterDelay(2 * time.Second), 84 Acceptors: []request.WaiterAcceptor{ 85 { 86 State: request.SuccessWaiterState, 87 Matcher: request.PathWaiterMatch, Argument: "environmentTemplateVersion.status", 88 Expected: "DRAFT", 89 }, 90 { 91 State: request.SuccessWaiterState, 92 Matcher: request.PathWaiterMatch, Argument: "environmentTemplateVersion.status", 93 Expected: "PUBLISHED", 94 }, 95 { 96 State: request.FailureWaiterState, 97 Matcher: request.PathWaiterMatch, Argument: "environmentTemplateVersion.status", 98 Expected: "REGISTRATION_FAILED", 99 }, 100 }, 101 Logger: c.Config.Logger, 102 NewRequest: func(opts []request.Option) (*request.Request, error) { 103 var inCpy *GetEnvironmentTemplateVersionInput 104 if input != nil { 105 tmp := *input 106 inCpy = &tmp 107 } 108 req, _ := c.GetEnvironmentTemplateVersionRequest(inCpy) 109 req.SetContext(ctx) 110 req.ApplyOptions(opts...) 111 return req, nil 112 }, 113 } 114 w.ApplyOptions(opts...) 115 116 return w.WaitWithContext(ctx) 117} 118 119// WaitUntilServiceCreated uses the AWS Proton API operation 120// GetService to wait for a condition to be met before returning. 121// If the condition is not met within the max attempt window, an error will 122// be returned. 123func (c *Proton) WaitUntilServiceCreated(input *GetServiceInput) error { 124 return c.WaitUntilServiceCreatedWithContext(aws.BackgroundContext(), input) 125} 126 127// WaitUntilServiceCreatedWithContext is an extended version of WaitUntilServiceCreated. 128// With the support for passing in a context and options to configure the 129// Waiter and the underlying request options. 130// 131// The context must be non-nil and will be used for request cancellation. If 132// the context is nil a panic will occur. In the future the SDK may create 133// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 134// for more information on using Contexts. 135func (c *Proton) WaitUntilServiceCreatedWithContext(ctx aws.Context, input *GetServiceInput, opts ...request.WaiterOption) error { 136 w := request.Waiter{ 137 Name: "WaitUntilServiceCreated", 138 MaxAttempts: 999, 139 Delay: request.ConstantWaiterDelay(5 * time.Second), 140 Acceptors: []request.WaiterAcceptor{ 141 { 142 State: request.SuccessWaiterState, 143 Matcher: request.PathWaiterMatch, Argument: "service.status", 144 Expected: "ACTIVE", 145 }, 146 { 147 State: request.FailureWaiterState, 148 Matcher: request.PathWaiterMatch, Argument: "service.status", 149 Expected: "CREATE_FAILED_CLEANUP_COMPLETE", 150 }, 151 { 152 State: request.FailureWaiterState, 153 Matcher: request.PathWaiterMatch, Argument: "service.status", 154 Expected: "CREATE_FAILED_CLEANUP_FAILED", 155 }, 156 { 157 State: request.FailureWaiterState, 158 Matcher: request.PathWaiterMatch, Argument: "service.status", 159 Expected: "CREATE_FAILED", 160 }, 161 }, 162 Logger: c.Config.Logger, 163 NewRequest: func(opts []request.Option) (*request.Request, error) { 164 var inCpy *GetServiceInput 165 if input != nil { 166 tmp := *input 167 inCpy = &tmp 168 } 169 req, _ := c.GetServiceRequest(inCpy) 170 req.SetContext(ctx) 171 req.ApplyOptions(opts...) 172 return req, nil 173 }, 174 } 175 w.ApplyOptions(opts...) 176 177 return w.WaitWithContext(ctx) 178} 179 180// WaitUntilServiceDeleted uses the AWS Proton API operation 181// GetService to wait for a condition to be met before returning. 182// If the condition is not met within the max attempt window, an error will 183// be returned. 184func (c *Proton) WaitUntilServiceDeleted(input *GetServiceInput) error { 185 return c.WaitUntilServiceDeletedWithContext(aws.BackgroundContext(), input) 186} 187 188// WaitUntilServiceDeletedWithContext is an extended version of WaitUntilServiceDeleted. 189// With the support for passing in a context and options to configure the 190// Waiter and the underlying request options. 191// 192// The context must be non-nil and will be used for request cancellation. If 193// the context is nil a panic will occur. In the future the SDK may create 194// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 195// for more information on using Contexts. 196func (c *Proton) WaitUntilServiceDeletedWithContext(ctx aws.Context, input *GetServiceInput, opts ...request.WaiterOption) error { 197 w := request.Waiter{ 198 Name: "WaitUntilServiceDeleted", 199 MaxAttempts: 999, 200 Delay: request.ConstantWaiterDelay(5 * time.Second), 201 Acceptors: []request.WaiterAcceptor{ 202 { 203 State: request.SuccessWaiterState, 204 Matcher: request.ErrorWaiterMatch, 205 Expected: "ResourceNotFoundException", 206 }, 207 { 208 State: request.FailureWaiterState, 209 Matcher: request.PathWaiterMatch, Argument: "service.status", 210 Expected: "DELETE_FAILED", 211 }, 212 }, 213 Logger: c.Config.Logger, 214 NewRequest: func(opts []request.Option) (*request.Request, error) { 215 var inCpy *GetServiceInput 216 if input != nil { 217 tmp := *input 218 inCpy = &tmp 219 } 220 req, _ := c.GetServiceRequest(inCpy) 221 req.SetContext(ctx) 222 req.ApplyOptions(opts...) 223 return req, nil 224 }, 225 } 226 w.ApplyOptions(opts...) 227 228 return w.WaitWithContext(ctx) 229} 230 231// WaitUntilServiceInstanceDeployed uses the AWS Proton API operation 232// GetServiceInstance to wait for a condition to be met before returning. 233// If the condition is not met within the max attempt window, an error will 234// be returned. 235func (c *Proton) WaitUntilServiceInstanceDeployed(input *GetServiceInstanceInput) error { 236 return c.WaitUntilServiceInstanceDeployedWithContext(aws.BackgroundContext(), input) 237} 238 239// WaitUntilServiceInstanceDeployedWithContext is an extended version of WaitUntilServiceInstanceDeployed. 240// With the support for passing in a context and options to configure the 241// Waiter and the underlying request options. 242// 243// The context must be non-nil and will be used for request cancellation. If 244// the context is nil a panic will occur. In the future the SDK may create 245// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 246// for more information on using Contexts. 247func (c *Proton) WaitUntilServiceInstanceDeployedWithContext(ctx aws.Context, input *GetServiceInstanceInput, opts ...request.WaiterOption) error { 248 w := request.Waiter{ 249 Name: "WaitUntilServiceInstanceDeployed", 250 MaxAttempts: 999, 251 Delay: request.ConstantWaiterDelay(5 * time.Second), 252 Acceptors: []request.WaiterAcceptor{ 253 { 254 State: request.SuccessWaiterState, 255 Matcher: request.PathWaiterMatch, Argument: "serviceInstance.deploymentStatus", 256 Expected: "SUCCEEDED", 257 }, 258 { 259 State: request.FailureWaiterState, 260 Matcher: request.PathWaiterMatch, Argument: "serviceInstance.deploymentStatus", 261 Expected: "FAILED", 262 }, 263 }, 264 Logger: c.Config.Logger, 265 NewRequest: func(opts []request.Option) (*request.Request, error) { 266 var inCpy *GetServiceInstanceInput 267 if input != nil { 268 tmp := *input 269 inCpy = &tmp 270 } 271 req, _ := c.GetServiceInstanceRequest(inCpy) 272 req.SetContext(ctx) 273 req.ApplyOptions(opts...) 274 return req, nil 275 }, 276 } 277 w.ApplyOptions(opts...) 278 279 return w.WaitWithContext(ctx) 280} 281 282// WaitUntilServicePipelineDeployed uses the AWS Proton API operation 283// GetService to wait for a condition to be met before returning. 284// If the condition is not met within the max attempt window, an error will 285// be returned. 286func (c *Proton) WaitUntilServicePipelineDeployed(input *GetServiceInput) error { 287 return c.WaitUntilServicePipelineDeployedWithContext(aws.BackgroundContext(), input) 288} 289 290// WaitUntilServicePipelineDeployedWithContext is an extended version of WaitUntilServicePipelineDeployed. 291// With the support for passing in a context and options to configure the 292// Waiter and the underlying request options. 293// 294// The context must be non-nil and will be used for request cancellation. If 295// the context is nil a panic will occur. In the future the SDK may create 296// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 297// for more information on using Contexts. 298func (c *Proton) WaitUntilServicePipelineDeployedWithContext(ctx aws.Context, input *GetServiceInput, opts ...request.WaiterOption) error { 299 w := request.Waiter{ 300 Name: "WaitUntilServicePipelineDeployed", 301 MaxAttempts: 360, 302 Delay: request.ConstantWaiterDelay(10 * time.Second), 303 Acceptors: []request.WaiterAcceptor{ 304 { 305 State: request.SuccessWaiterState, 306 Matcher: request.PathWaiterMatch, Argument: "service.pipeline.deploymentStatus", 307 Expected: "SUCCEEDED", 308 }, 309 { 310 State: request.FailureWaiterState, 311 Matcher: request.PathWaiterMatch, Argument: "service.pipeline.deploymentStatus", 312 Expected: "FAILED", 313 }, 314 }, 315 Logger: c.Config.Logger, 316 NewRequest: func(opts []request.Option) (*request.Request, error) { 317 var inCpy *GetServiceInput 318 if input != nil { 319 tmp := *input 320 inCpy = &tmp 321 } 322 req, _ := c.GetServiceRequest(inCpy) 323 req.SetContext(ctx) 324 req.ApplyOptions(opts...) 325 return req, nil 326 }, 327 } 328 w.ApplyOptions(opts...) 329 330 return w.WaitWithContext(ctx) 331} 332 333// WaitUntilServiceTemplateVersionRegistered uses the AWS Proton API operation 334// GetServiceTemplateVersion to wait for a condition to be met before returning. 335// If the condition is not met within the max attempt window, an error will 336// be returned. 337func (c *Proton) WaitUntilServiceTemplateVersionRegistered(input *GetServiceTemplateVersionInput) error { 338 return c.WaitUntilServiceTemplateVersionRegisteredWithContext(aws.BackgroundContext(), input) 339} 340 341// WaitUntilServiceTemplateVersionRegisteredWithContext is an extended version of WaitUntilServiceTemplateVersionRegistered. 342// With the support for passing in a context and options to configure the 343// Waiter and the underlying request options. 344// 345// The context must be non-nil and will be used for request cancellation. If 346// the context is nil a panic will occur. In the future the SDK may create 347// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 348// for more information on using Contexts. 349func (c *Proton) WaitUntilServiceTemplateVersionRegisteredWithContext(ctx aws.Context, input *GetServiceTemplateVersionInput, opts ...request.WaiterOption) error { 350 w := request.Waiter{ 351 Name: "WaitUntilServiceTemplateVersionRegistered", 352 MaxAttempts: 150, 353 Delay: request.ConstantWaiterDelay(2 * time.Second), 354 Acceptors: []request.WaiterAcceptor{ 355 { 356 State: request.SuccessWaiterState, 357 Matcher: request.PathWaiterMatch, Argument: "serviceTemplateVersion.status", 358 Expected: "DRAFT", 359 }, 360 { 361 State: request.SuccessWaiterState, 362 Matcher: request.PathWaiterMatch, Argument: "serviceTemplateVersion.status", 363 Expected: "PUBLISHED", 364 }, 365 { 366 State: request.FailureWaiterState, 367 Matcher: request.PathWaiterMatch, Argument: "serviceTemplateVersion.status", 368 Expected: "REGISTRATION_FAILED", 369 }, 370 }, 371 Logger: c.Config.Logger, 372 NewRequest: func(opts []request.Option) (*request.Request, error) { 373 var inCpy *GetServiceTemplateVersionInput 374 if input != nil { 375 tmp := *input 376 inCpy = &tmp 377 } 378 req, _ := c.GetServiceTemplateVersionRequest(inCpy) 379 req.SetContext(ctx) 380 req.ApplyOptions(opts...) 381 return req, nil 382 }, 383 } 384 w.ApplyOptions(opts...) 385 386 return w.WaitWithContext(ctx) 387} 388 389// WaitUntilServiceUpdated uses the AWS Proton API operation 390// GetService to wait for a condition to be met before returning. 391// If the condition is not met within the max attempt window, an error will 392// be returned. 393func (c *Proton) WaitUntilServiceUpdated(input *GetServiceInput) error { 394 return c.WaitUntilServiceUpdatedWithContext(aws.BackgroundContext(), input) 395} 396 397// WaitUntilServiceUpdatedWithContext is an extended version of WaitUntilServiceUpdated. 398// With the support for passing in a context and options to configure the 399// Waiter and the underlying request options. 400// 401// The context must be non-nil and will be used for request cancellation. If 402// the context is nil a panic will occur. In the future the SDK may create 403// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 404// for more information on using Contexts. 405func (c *Proton) WaitUntilServiceUpdatedWithContext(ctx aws.Context, input *GetServiceInput, opts ...request.WaiterOption) error { 406 w := request.Waiter{ 407 Name: "WaitUntilServiceUpdated", 408 MaxAttempts: 999, 409 Delay: request.ConstantWaiterDelay(5 * time.Second), 410 Acceptors: []request.WaiterAcceptor{ 411 { 412 State: request.SuccessWaiterState, 413 Matcher: request.PathWaiterMatch, Argument: "service.status", 414 Expected: "ACTIVE", 415 }, 416 { 417 State: request.FailureWaiterState, 418 Matcher: request.PathWaiterMatch, Argument: "service.status", 419 Expected: "UPDATE_FAILED_CLEANUP_COMPLETE", 420 }, 421 { 422 State: request.FailureWaiterState, 423 Matcher: request.PathWaiterMatch, Argument: "service.status", 424 Expected: "UPDATE_FAILED_CLEANUP_FAILED", 425 }, 426 { 427 State: request.FailureWaiterState, 428 Matcher: request.PathWaiterMatch, Argument: "service.status", 429 Expected: "UPDATE_FAILED", 430 }, 431 { 432 State: request.FailureWaiterState, 433 Matcher: request.PathWaiterMatch, Argument: "service.status", 434 Expected: "UPDATE_COMPLETE_CLEANUP_FAILED", 435 }, 436 }, 437 Logger: c.Config.Logger, 438 NewRequest: func(opts []request.Option) (*request.Request, error) { 439 var inCpy *GetServiceInput 440 if input != nil { 441 tmp := *input 442 inCpy = &tmp 443 } 444 req, _ := c.GetServiceRequest(inCpy) 445 req.SetContext(ctx) 446 req.ApplyOptions(opts...) 447 return req, nil 448 }, 449 } 450 w.ApplyOptions(opts...) 451 452 return w.WaitWithContext(ctx) 453} 454