1// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. 2 3package elbv2 4 5import ( 6 "fmt" 7 "time" 8 9 "github.com/aws/aws-sdk-go/aws" 10 "github.com/aws/aws-sdk-go/aws/awsutil" 11 "github.com/aws/aws-sdk-go/aws/request" 12) 13 14const opAddListenerCertificates = "AddListenerCertificates" 15 16// AddListenerCertificatesRequest generates a "aws/request.Request" representing the 17// client's request for the AddListenerCertificates operation. The "output" return 18// value will be populated with the request's response once the request completes 19// successfuly. 20// 21// Use "Send" method on the returned Request to send the API call to the service. 22// the "output" return value is not valid until after Send returns without error. 23// 24// See AddListenerCertificates for more information on using the AddListenerCertificates 25// API call, and error handling. 26// 27// This method is useful when you want to inject custom logic or configuration 28// into the SDK's request lifecycle. Such as custom headers, or retry logic. 29// 30// 31// // Example sending a request using the AddListenerCertificatesRequest method. 32// req, resp := client.AddListenerCertificatesRequest(params) 33// 34// err := req.Send() 35// if err == nil { // resp is now filled 36// fmt.Println(resp) 37// } 38// 39// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/AddListenerCertificates 40func (c *ELBV2) AddListenerCertificatesRequest(input *AddListenerCertificatesInput) (req *request.Request, output *AddListenerCertificatesOutput) { 41 op := &request.Operation{ 42 Name: opAddListenerCertificates, 43 HTTPMethod: "POST", 44 HTTPPath: "/", 45 } 46 47 if input == nil { 48 input = &AddListenerCertificatesInput{} 49 } 50 51 output = &AddListenerCertificatesOutput{} 52 req = c.newRequest(op, input, output) 53 return 54} 55 56// AddListenerCertificates API operation for Elastic Load Balancing. 57// 58// Adds the specified certificate to the specified secure listener. 59// 60// If the certificate was already added, the call is successful but the certificate 61// is not added again. 62// 63// To list the certificates for your listener, use DescribeListenerCertificates. 64// To remove certificates from your listener, use RemoveListenerCertificates. 65// 66// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 67// with awserr.Error's Code and Message methods to get detailed information about 68// the error. 69// 70// See the AWS API reference guide for Elastic Load Balancing's 71// API operation AddListenerCertificates for usage and error information. 72// 73// Returned Error Codes: 74// * ErrCodeListenerNotFoundException "ListenerNotFound" 75// The specified listener does not exist. 76// 77// * ErrCodeTooManyCertificatesException "TooManyCertificates" 78// You've reached the limit on the number of certificates per load balancer. 79// 80// * ErrCodeCertificateNotFoundException "CertificateNotFound" 81// The specified certificate does not exist. 82// 83// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/AddListenerCertificates 84func (c *ELBV2) AddListenerCertificates(input *AddListenerCertificatesInput) (*AddListenerCertificatesOutput, error) { 85 req, out := c.AddListenerCertificatesRequest(input) 86 return out, req.Send() 87} 88 89// AddListenerCertificatesWithContext is the same as AddListenerCertificates with the addition of 90// the ability to pass a context and additional request options. 91// 92// See AddListenerCertificates for details on how to use this API operation. 93// 94// The context must be non-nil and will be used for request cancellation. If 95// the context is nil a panic will occur. In the future the SDK may create 96// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 97// for more information on using Contexts. 98func (c *ELBV2) AddListenerCertificatesWithContext(ctx aws.Context, input *AddListenerCertificatesInput, opts ...request.Option) (*AddListenerCertificatesOutput, error) { 99 req, out := c.AddListenerCertificatesRequest(input) 100 req.SetContext(ctx) 101 req.ApplyOptions(opts...) 102 return out, req.Send() 103} 104 105const opAddTags = "AddTags" 106 107// AddTagsRequest generates a "aws/request.Request" representing the 108// client's request for the AddTags operation. The "output" return 109// value will be populated with the request's response once the request completes 110// successfuly. 111// 112// Use "Send" method on the returned Request to send the API call to the service. 113// the "output" return value is not valid until after Send returns without error. 114// 115// See AddTags for more information on using the AddTags 116// API call, and error handling. 117// 118// This method is useful when you want to inject custom logic or configuration 119// into the SDK's request lifecycle. Such as custom headers, or retry logic. 120// 121// 122// // Example sending a request using the AddTagsRequest method. 123// req, resp := client.AddTagsRequest(params) 124// 125// err := req.Send() 126// if err == nil { // resp is now filled 127// fmt.Println(resp) 128// } 129// 130// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/AddTags 131func (c *ELBV2) AddTagsRequest(input *AddTagsInput) (req *request.Request, output *AddTagsOutput) { 132 op := &request.Operation{ 133 Name: opAddTags, 134 HTTPMethod: "POST", 135 HTTPPath: "/", 136 } 137 138 if input == nil { 139 input = &AddTagsInput{} 140 } 141 142 output = &AddTagsOutput{} 143 req = c.newRequest(op, input, output) 144 return 145} 146 147// AddTags API operation for Elastic Load Balancing. 148// 149// Adds the specified tags to the specified Elastic Load Balancing resource. 150// You can tag your Application Load Balancers, Network Load Balancers, and 151// your target groups. 152// 153// Each tag consists of a key and an optional value. If a resource already has 154// a tag with the same key, AddTags updates its value. 155// 156// To list the current tags for your resources, use DescribeTags. To remove 157// tags from your resources, use RemoveTags. 158// 159// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 160// with awserr.Error's Code and Message methods to get detailed information about 161// the error. 162// 163// See the AWS API reference guide for Elastic Load Balancing's 164// API operation AddTags for usage and error information. 165// 166// Returned Error Codes: 167// * ErrCodeDuplicateTagKeysException "DuplicateTagKeys" 168// A tag key was specified more than once. 169// 170// * ErrCodeTooManyTagsException "TooManyTags" 171// You've reached the limit on the number of tags per load balancer. 172// 173// * ErrCodeLoadBalancerNotFoundException "LoadBalancerNotFound" 174// The specified load balancer does not exist. 175// 176// * ErrCodeTargetGroupNotFoundException "TargetGroupNotFound" 177// The specified target group does not exist. 178// 179// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/AddTags 180func (c *ELBV2) AddTags(input *AddTagsInput) (*AddTagsOutput, error) { 181 req, out := c.AddTagsRequest(input) 182 return out, req.Send() 183} 184 185// AddTagsWithContext is the same as AddTags with the addition of 186// the ability to pass a context and additional request options. 187// 188// See AddTags for details on how to use this API operation. 189// 190// The context must be non-nil and will be used for request cancellation. If 191// the context is nil a panic will occur. In the future the SDK may create 192// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 193// for more information on using Contexts. 194func (c *ELBV2) AddTagsWithContext(ctx aws.Context, input *AddTagsInput, opts ...request.Option) (*AddTagsOutput, error) { 195 req, out := c.AddTagsRequest(input) 196 req.SetContext(ctx) 197 req.ApplyOptions(opts...) 198 return out, req.Send() 199} 200 201const opCreateListener = "CreateListener" 202 203// CreateListenerRequest generates a "aws/request.Request" representing the 204// client's request for the CreateListener operation. The "output" return 205// value will be populated with the request's response once the request completes 206// successfuly. 207// 208// Use "Send" method on the returned Request to send the API call to the service. 209// the "output" return value is not valid until after Send returns without error. 210// 211// See CreateListener for more information on using the CreateListener 212// API call, and error handling. 213// 214// This method is useful when you want to inject custom logic or configuration 215// into the SDK's request lifecycle. Such as custom headers, or retry logic. 216// 217// 218// // Example sending a request using the CreateListenerRequest method. 219// req, resp := client.CreateListenerRequest(params) 220// 221// err := req.Send() 222// if err == nil { // resp is now filled 223// fmt.Println(resp) 224// } 225// 226// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/CreateListener 227func (c *ELBV2) CreateListenerRequest(input *CreateListenerInput) (req *request.Request, output *CreateListenerOutput) { 228 op := &request.Operation{ 229 Name: opCreateListener, 230 HTTPMethod: "POST", 231 HTTPPath: "/", 232 } 233 234 if input == nil { 235 input = &CreateListenerInput{} 236 } 237 238 output = &CreateListenerOutput{} 239 req = c.newRequest(op, input, output) 240 return 241} 242 243// CreateListener API operation for Elastic Load Balancing. 244// 245// Creates a listener for the specified Application Load Balancer or Network 246// Load Balancer. 247// 248// To update a listener, use ModifyListener. When you are finished with a listener, 249// you can delete it using DeleteListener. If you are finished with both the 250// listener and the load balancer, you can delete them both using DeleteLoadBalancer. 251// 252// This operation is idempotent, which means that it completes at most one time. 253// If you attempt to create multiple listeners with the same settings, each 254// call succeeds. 255// 256// For more information, see Listeners for Your Application Load Balancers (http://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html) 257// in the Application Load Balancers Guide and Listeners for Your Network Load 258// Balancers (http://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-listeners.html) 259// in the Network Load Balancers Guide. 260// 261// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 262// with awserr.Error's Code and Message methods to get detailed information about 263// the error. 264// 265// See the AWS API reference guide for Elastic Load Balancing's 266// API operation CreateListener for usage and error information. 267// 268// Returned Error Codes: 269// * ErrCodeDuplicateListenerException "DuplicateListener" 270// A listener with the specified port already exists. 271// 272// * ErrCodeTooManyListenersException "TooManyListeners" 273// You've reached the limit on the number of listeners per load balancer. 274// 275// * ErrCodeTooManyCertificatesException "TooManyCertificates" 276// You've reached the limit on the number of certificates per load balancer. 277// 278// * ErrCodeLoadBalancerNotFoundException "LoadBalancerNotFound" 279// The specified load balancer does not exist. 280// 281// * ErrCodeTargetGroupNotFoundException "TargetGroupNotFound" 282// The specified target group does not exist. 283// 284// * ErrCodeTargetGroupAssociationLimitException "TargetGroupAssociationLimit" 285// You've reached the limit on the number of load balancers per target group. 286// 287// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 288// The requested configuration is not valid. 289// 290// * ErrCodeIncompatibleProtocolsException "IncompatibleProtocols" 291// The specified configuration is not valid with this protocol. 292// 293// * ErrCodeSSLPolicyNotFoundException "SSLPolicyNotFound" 294// The specified SSL policy does not exist. 295// 296// * ErrCodeCertificateNotFoundException "CertificateNotFound" 297// The specified certificate does not exist. 298// 299// * ErrCodeUnsupportedProtocolException "UnsupportedProtocol" 300// The specified protocol is not supported. 301// 302// * ErrCodeTooManyRegistrationsForTargetIdException "TooManyRegistrationsForTargetId" 303// You've reached the limit on the number of times a target can be registered 304// with a load balancer. 305// 306// * ErrCodeTooManyTargetsException "TooManyTargets" 307// You've reached the limit on the number of targets. 308// 309// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/CreateListener 310func (c *ELBV2) CreateListener(input *CreateListenerInput) (*CreateListenerOutput, error) { 311 req, out := c.CreateListenerRequest(input) 312 return out, req.Send() 313} 314 315// CreateListenerWithContext is the same as CreateListener with the addition of 316// the ability to pass a context and additional request options. 317// 318// See CreateListener for details on how to use this API operation. 319// 320// The context must be non-nil and will be used for request cancellation. If 321// the context is nil a panic will occur. In the future the SDK may create 322// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 323// for more information on using Contexts. 324func (c *ELBV2) CreateListenerWithContext(ctx aws.Context, input *CreateListenerInput, opts ...request.Option) (*CreateListenerOutput, error) { 325 req, out := c.CreateListenerRequest(input) 326 req.SetContext(ctx) 327 req.ApplyOptions(opts...) 328 return out, req.Send() 329} 330 331const opCreateLoadBalancer = "CreateLoadBalancer" 332 333// CreateLoadBalancerRequest generates a "aws/request.Request" representing the 334// client's request for the CreateLoadBalancer operation. The "output" return 335// value will be populated with the request's response once the request completes 336// successfuly. 337// 338// Use "Send" method on the returned Request to send the API call to the service. 339// the "output" return value is not valid until after Send returns without error. 340// 341// See CreateLoadBalancer for more information on using the CreateLoadBalancer 342// API call, and error handling. 343// 344// This method is useful when you want to inject custom logic or configuration 345// into the SDK's request lifecycle. Such as custom headers, or retry logic. 346// 347// 348// // Example sending a request using the CreateLoadBalancerRequest method. 349// req, resp := client.CreateLoadBalancerRequest(params) 350// 351// err := req.Send() 352// if err == nil { // resp is now filled 353// fmt.Println(resp) 354// } 355// 356// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/CreateLoadBalancer 357func (c *ELBV2) CreateLoadBalancerRequest(input *CreateLoadBalancerInput) (req *request.Request, output *CreateLoadBalancerOutput) { 358 op := &request.Operation{ 359 Name: opCreateLoadBalancer, 360 HTTPMethod: "POST", 361 HTTPPath: "/", 362 } 363 364 if input == nil { 365 input = &CreateLoadBalancerInput{} 366 } 367 368 output = &CreateLoadBalancerOutput{} 369 req = c.newRequest(op, input, output) 370 return 371} 372 373// CreateLoadBalancer API operation for Elastic Load Balancing. 374// 375// Creates an Application Load Balancer or a Network Load Balancer. 376// 377// When you create a load balancer, you can specify security groups, public 378// subnets, IP address type, and tags. Otherwise, you could do so later using 379// SetSecurityGroups, SetSubnets, SetIpAddressType, and AddTags. 380// 381// To create listeners for your load balancer, use CreateListener. To describe 382// your current load balancers, see DescribeLoadBalancers. When you are finished 383// with a load balancer, you can delete it using DeleteLoadBalancer. 384// 385// For limit information, see Limits for Your Application Load Balancer (http://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-limits.html) 386// in the Application Load Balancers Guide and Limits for Your Network Load 387// Balancer (http://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-limits.html) 388// in the Network Load Balancers Guide. 389// 390// This operation is idempotent, which means that it completes at most one time. 391// If you attempt to create multiple load balancers with the same settings, 392// each call succeeds. 393// 394// For more information, see Application Load Balancers (http://docs.aws.amazon.com/elasticloadbalancing/latest/application/application-load-balancers.html) 395// in the Application Load Balancers Guide and Network Load Balancers (http://docs.aws.amazon.com/elasticloadbalancing/latest/network/network-load-balancers.html) 396// in the Network Load Balancers Guide. 397// 398// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 399// with awserr.Error's Code and Message methods to get detailed information about 400// the error. 401// 402// See the AWS API reference guide for Elastic Load Balancing's 403// API operation CreateLoadBalancer for usage and error information. 404// 405// Returned Error Codes: 406// * ErrCodeDuplicateLoadBalancerNameException "DuplicateLoadBalancerName" 407// A load balancer with the specified name already exists. 408// 409// * ErrCodeTooManyLoadBalancersException "TooManyLoadBalancers" 410// You've reached the limit on the number of load balancers for your AWS account. 411// 412// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 413// The requested configuration is not valid. 414// 415// * ErrCodeSubnetNotFoundException "SubnetNotFound" 416// The specified subnet does not exist. 417// 418// * ErrCodeInvalidSubnetException "InvalidSubnet" 419// The specified subnet is out of available addresses. 420// 421// * ErrCodeInvalidSecurityGroupException "InvalidSecurityGroup" 422// The specified security group does not exist. 423// 424// * ErrCodeInvalidSchemeException "InvalidScheme" 425// The requested scheme is not valid. 426// 427// * ErrCodeTooManyTagsException "TooManyTags" 428// You've reached the limit on the number of tags per load balancer. 429// 430// * ErrCodeDuplicateTagKeysException "DuplicateTagKeys" 431// A tag key was specified more than once. 432// 433// * ErrCodeResourceInUseException "ResourceInUse" 434// A specified resource is in use. 435// 436// * ErrCodeAllocationIdNotFoundException "AllocationIdNotFound" 437// The specified allocation ID does not exist. 438// 439// * ErrCodeAvailabilityZoneNotSupportedException "AvailabilityZoneNotSupported" 440// The specified Availability Zone is not supported. 441// 442// * ErrCodeOperationNotPermittedException "OperationNotPermitted" 443// This operation is not allowed. 444// 445// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/CreateLoadBalancer 446func (c *ELBV2) CreateLoadBalancer(input *CreateLoadBalancerInput) (*CreateLoadBalancerOutput, error) { 447 req, out := c.CreateLoadBalancerRequest(input) 448 return out, req.Send() 449} 450 451// CreateLoadBalancerWithContext is the same as CreateLoadBalancer with the addition of 452// the ability to pass a context and additional request options. 453// 454// See CreateLoadBalancer for details on how to use this API operation. 455// 456// The context must be non-nil and will be used for request cancellation. If 457// the context is nil a panic will occur. In the future the SDK may create 458// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 459// for more information on using Contexts. 460func (c *ELBV2) CreateLoadBalancerWithContext(ctx aws.Context, input *CreateLoadBalancerInput, opts ...request.Option) (*CreateLoadBalancerOutput, error) { 461 req, out := c.CreateLoadBalancerRequest(input) 462 req.SetContext(ctx) 463 req.ApplyOptions(opts...) 464 return out, req.Send() 465} 466 467const opCreateRule = "CreateRule" 468 469// CreateRuleRequest generates a "aws/request.Request" representing the 470// client's request for the CreateRule operation. The "output" return 471// value will be populated with the request's response once the request completes 472// successfuly. 473// 474// Use "Send" method on the returned Request to send the API call to the service. 475// the "output" return value is not valid until after Send returns without error. 476// 477// See CreateRule for more information on using the CreateRule 478// API call, and error handling. 479// 480// This method is useful when you want to inject custom logic or configuration 481// into the SDK's request lifecycle. Such as custom headers, or retry logic. 482// 483// 484// // Example sending a request using the CreateRuleRequest method. 485// req, resp := client.CreateRuleRequest(params) 486// 487// err := req.Send() 488// if err == nil { // resp is now filled 489// fmt.Println(resp) 490// } 491// 492// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/CreateRule 493func (c *ELBV2) CreateRuleRequest(input *CreateRuleInput) (req *request.Request, output *CreateRuleOutput) { 494 op := &request.Operation{ 495 Name: opCreateRule, 496 HTTPMethod: "POST", 497 HTTPPath: "/", 498 } 499 500 if input == nil { 501 input = &CreateRuleInput{} 502 } 503 504 output = &CreateRuleOutput{} 505 req = c.newRequest(op, input, output) 506 return 507} 508 509// CreateRule API operation for Elastic Load Balancing. 510// 511// Creates a rule for the specified listener. The listener must be associated 512// with an Application Load Balancer. 513// 514// Rules are evaluated in priority order, from the lowest value to the highest 515// value. When the condition for a rule is met, the specified action is taken. 516// If no conditions are met, the action for the default rule is taken. For more 517// information, see Listener Rules (http://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#listener-rules) 518// in the Application Load Balancers Guide. 519// 520// To view your current rules, use DescribeRules. To update a rule, use ModifyRule. 521// To set the priorities of your rules, use SetRulePriorities. To delete a rule, 522// use DeleteRule. 523// 524// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 525// with awserr.Error's Code and Message methods to get detailed information about 526// the error. 527// 528// See the AWS API reference guide for Elastic Load Balancing's 529// API operation CreateRule for usage and error information. 530// 531// Returned Error Codes: 532// * ErrCodePriorityInUseException "PriorityInUse" 533// The specified priority is in use. 534// 535// * ErrCodeTooManyTargetGroupsException "TooManyTargetGroups" 536// You've reached the limit on the number of target groups for your AWS account. 537// 538// * ErrCodeTooManyRulesException "TooManyRules" 539// You've reached the limit on the number of rules per load balancer. 540// 541// * ErrCodeTargetGroupAssociationLimitException "TargetGroupAssociationLimit" 542// You've reached the limit on the number of load balancers per target group. 543// 544// * ErrCodeIncompatibleProtocolsException "IncompatibleProtocols" 545// The specified configuration is not valid with this protocol. 546// 547// * ErrCodeListenerNotFoundException "ListenerNotFound" 548// The specified listener does not exist. 549// 550// * ErrCodeTargetGroupNotFoundException "TargetGroupNotFound" 551// The specified target group does not exist. 552// 553// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 554// The requested configuration is not valid. 555// 556// * ErrCodeTooManyRegistrationsForTargetIdException "TooManyRegistrationsForTargetId" 557// You've reached the limit on the number of times a target can be registered 558// with a load balancer. 559// 560// * ErrCodeTooManyTargetsException "TooManyTargets" 561// You've reached the limit on the number of targets. 562// 563// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/CreateRule 564func (c *ELBV2) CreateRule(input *CreateRuleInput) (*CreateRuleOutput, error) { 565 req, out := c.CreateRuleRequest(input) 566 return out, req.Send() 567} 568 569// CreateRuleWithContext is the same as CreateRule with the addition of 570// the ability to pass a context and additional request options. 571// 572// See CreateRule for details on how to use this API operation. 573// 574// The context must be non-nil and will be used for request cancellation. If 575// the context is nil a panic will occur. In the future the SDK may create 576// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 577// for more information on using Contexts. 578func (c *ELBV2) CreateRuleWithContext(ctx aws.Context, input *CreateRuleInput, opts ...request.Option) (*CreateRuleOutput, error) { 579 req, out := c.CreateRuleRequest(input) 580 req.SetContext(ctx) 581 req.ApplyOptions(opts...) 582 return out, req.Send() 583} 584 585const opCreateTargetGroup = "CreateTargetGroup" 586 587// CreateTargetGroupRequest generates a "aws/request.Request" representing the 588// client's request for the CreateTargetGroup operation. The "output" return 589// value will be populated with the request's response once the request completes 590// successfuly. 591// 592// Use "Send" method on the returned Request to send the API call to the service. 593// the "output" return value is not valid until after Send returns without error. 594// 595// See CreateTargetGroup for more information on using the CreateTargetGroup 596// API call, and error handling. 597// 598// This method is useful when you want to inject custom logic or configuration 599// into the SDK's request lifecycle. Such as custom headers, or retry logic. 600// 601// 602// // Example sending a request using the CreateTargetGroupRequest method. 603// req, resp := client.CreateTargetGroupRequest(params) 604// 605// err := req.Send() 606// if err == nil { // resp is now filled 607// fmt.Println(resp) 608// } 609// 610// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/CreateTargetGroup 611func (c *ELBV2) CreateTargetGroupRequest(input *CreateTargetGroupInput) (req *request.Request, output *CreateTargetGroupOutput) { 612 op := &request.Operation{ 613 Name: opCreateTargetGroup, 614 HTTPMethod: "POST", 615 HTTPPath: "/", 616 } 617 618 if input == nil { 619 input = &CreateTargetGroupInput{} 620 } 621 622 output = &CreateTargetGroupOutput{} 623 req = c.newRequest(op, input, output) 624 return 625} 626 627// CreateTargetGroup API operation for Elastic Load Balancing. 628// 629// Creates a target group. 630// 631// To register targets with the target group, use RegisterTargets. To update 632// the health check settings for the target group, use ModifyTargetGroup. To 633// monitor the health of targets in the target group, use DescribeTargetHealth. 634// 635// To route traffic to the targets in a target group, specify the target group 636// in an action using CreateListener or CreateRule. 637// 638// To delete a target group, use DeleteTargetGroup. 639// 640// This operation is idempotent, which means that it completes at most one time. 641// If you attempt to create multiple target groups with the same settings, each 642// call succeeds. 643// 644// For more information, see Target Groups for Your Application Load Balancers 645// (http://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html) 646// in the Application Load Balancers Guide or Target Groups for Your Network 647// Load Balancers (http://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html) 648// in the Network Load Balancers Guide. 649// 650// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 651// with awserr.Error's Code and Message methods to get detailed information about 652// the error. 653// 654// See the AWS API reference guide for Elastic Load Balancing's 655// API operation CreateTargetGroup for usage and error information. 656// 657// Returned Error Codes: 658// * ErrCodeDuplicateTargetGroupNameException "DuplicateTargetGroupName" 659// A target group with the specified name already exists. 660// 661// * ErrCodeTooManyTargetGroupsException "TooManyTargetGroups" 662// You've reached the limit on the number of target groups for your AWS account. 663// 664// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 665// The requested configuration is not valid. 666// 667// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/CreateTargetGroup 668func (c *ELBV2) CreateTargetGroup(input *CreateTargetGroupInput) (*CreateTargetGroupOutput, error) { 669 req, out := c.CreateTargetGroupRequest(input) 670 return out, req.Send() 671} 672 673// CreateTargetGroupWithContext is the same as CreateTargetGroup with the addition of 674// the ability to pass a context and additional request options. 675// 676// See CreateTargetGroup for details on how to use this API operation. 677// 678// The context must be non-nil and will be used for request cancellation. If 679// the context is nil a panic will occur. In the future the SDK may create 680// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 681// for more information on using Contexts. 682func (c *ELBV2) CreateTargetGroupWithContext(ctx aws.Context, input *CreateTargetGroupInput, opts ...request.Option) (*CreateTargetGroupOutput, error) { 683 req, out := c.CreateTargetGroupRequest(input) 684 req.SetContext(ctx) 685 req.ApplyOptions(opts...) 686 return out, req.Send() 687} 688 689const opDeleteListener = "DeleteListener" 690 691// DeleteListenerRequest generates a "aws/request.Request" representing the 692// client's request for the DeleteListener operation. The "output" return 693// value will be populated with the request's response once the request completes 694// successfuly. 695// 696// Use "Send" method on the returned Request to send the API call to the service. 697// the "output" return value is not valid until after Send returns without error. 698// 699// See DeleteListener for more information on using the DeleteListener 700// API call, and error handling. 701// 702// This method is useful when you want to inject custom logic or configuration 703// into the SDK's request lifecycle. Such as custom headers, or retry logic. 704// 705// 706// // Example sending a request using the DeleteListenerRequest method. 707// req, resp := client.DeleteListenerRequest(params) 708// 709// err := req.Send() 710// if err == nil { // resp is now filled 711// fmt.Println(resp) 712// } 713// 714// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DeleteListener 715func (c *ELBV2) DeleteListenerRequest(input *DeleteListenerInput) (req *request.Request, output *DeleteListenerOutput) { 716 op := &request.Operation{ 717 Name: opDeleteListener, 718 HTTPMethod: "POST", 719 HTTPPath: "/", 720 } 721 722 if input == nil { 723 input = &DeleteListenerInput{} 724 } 725 726 output = &DeleteListenerOutput{} 727 req = c.newRequest(op, input, output) 728 return 729} 730 731// DeleteListener API operation for Elastic Load Balancing. 732// 733// Deletes the specified listener. 734// 735// Alternatively, your listener is deleted when you delete the load balancer 736// it is attached to using DeleteLoadBalancer. 737// 738// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 739// with awserr.Error's Code and Message methods to get detailed information about 740// the error. 741// 742// See the AWS API reference guide for Elastic Load Balancing's 743// API operation DeleteListener for usage and error information. 744// 745// Returned Error Codes: 746// * ErrCodeListenerNotFoundException "ListenerNotFound" 747// The specified listener does not exist. 748// 749// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DeleteListener 750func (c *ELBV2) DeleteListener(input *DeleteListenerInput) (*DeleteListenerOutput, error) { 751 req, out := c.DeleteListenerRequest(input) 752 return out, req.Send() 753} 754 755// DeleteListenerWithContext is the same as DeleteListener with the addition of 756// the ability to pass a context and additional request options. 757// 758// See DeleteListener for details on how to use this API operation. 759// 760// The context must be non-nil and will be used for request cancellation. If 761// the context is nil a panic will occur. In the future the SDK may create 762// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 763// for more information on using Contexts. 764func (c *ELBV2) DeleteListenerWithContext(ctx aws.Context, input *DeleteListenerInput, opts ...request.Option) (*DeleteListenerOutput, error) { 765 req, out := c.DeleteListenerRequest(input) 766 req.SetContext(ctx) 767 req.ApplyOptions(opts...) 768 return out, req.Send() 769} 770 771const opDeleteLoadBalancer = "DeleteLoadBalancer" 772 773// DeleteLoadBalancerRequest generates a "aws/request.Request" representing the 774// client's request for the DeleteLoadBalancer operation. The "output" return 775// value will be populated with the request's response once the request completes 776// successfuly. 777// 778// Use "Send" method on the returned Request to send the API call to the service. 779// the "output" return value is not valid until after Send returns without error. 780// 781// See DeleteLoadBalancer for more information on using the DeleteLoadBalancer 782// API call, and error handling. 783// 784// This method is useful when you want to inject custom logic or configuration 785// into the SDK's request lifecycle. Such as custom headers, or retry logic. 786// 787// 788// // Example sending a request using the DeleteLoadBalancerRequest method. 789// req, resp := client.DeleteLoadBalancerRequest(params) 790// 791// err := req.Send() 792// if err == nil { // resp is now filled 793// fmt.Println(resp) 794// } 795// 796// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DeleteLoadBalancer 797func (c *ELBV2) DeleteLoadBalancerRequest(input *DeleteLoadBalancerInput) (req *request.Request, output *DeleteLoadBalancerOutput) { 798 op := &request.Operation{ 799 Name: opDeleteLoadBalancer, 800 HTTPMethod: "POST", 801 HTTPPath: "/", 802 } 803 804 if input == nil { 805 input = &DeleteLoadBalancerInput{} 806 } 807 808 output = &DeleteLoadBalancerOutput{} 809 req = c.newRequest(op, input, output) 810 return 811} 812 813// DeleteLoadBalancer API operation for Elastic Load Balancing. 814// 815// Deletes the specified Application Load Balancer or Network Load Balancer 816// and its attached listeners. 817// 818// You can't delete a load balancer if deletion protection is enabled. If the 819// load balancer does not exist or has already been deleted, the call succeeds. 820// 821// Deleting a load balancer does not affect its registered targets. For example, 822// your EC2 instances continue to run and are still registered to their target 823// groups. If you no longer need these EC2 instances, you can stop or terminate 824// them. 825// 826// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 827// with awserr.Error's Code and Message methods to get detailed information about 828// the error. 829// 830// See the AWS API reference guide for Elastic Load Balancing's 831// API operation DeleteLoadBalancer for usage and error information. 832// 833// Returned Error Codes: 834// * ErrCodeLoadBalancerNotFoundException "LoadBalancerNotFound" 835// The specified load balancer does not exist. 836// 837// * ErrCodeOperationNotPermittedException "OperationNotPermitted" 838// This operation is not allowed. 839// 840// * ErrCodeResourceInUseException "ResourceInUse" 841// A specified resource is in use. 842// 843// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DeleteLoadBalancer 844func (c *ELBV2) DeleteLoadBalancer(input *DeleteLoadBalancerInput) (*DeleteLoadBalancerOutput, error) { 845 req, out := c.DeleteLoadBalancerRequest(input) 846 return out, req.Send() 847} 848 849// DeleteLoadBalancerWithContext is the same as DeleteLoadBalancer with the addition of 850// the ability to pass a context and additional request options. 851// 852// See DeleteLoadBalancer for details on how to use this API operation. 853// 854// The context must be non-nil and will be used for request cancellation. If 855// the context is nil a panic will occur. In the future the SDK may create 856// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 857// for more information on using Contexts. 858func (c *ELBV2) DeleteLoadBalancerWithContext(ctx aws.Context, input *DeleteLoadBalancerInput, opts ...request.Option) (*DeleteLoadBalancerOutput, error) { 859 req, out := c.DeleteLoadBalancerRequest(input) 860 req.SetContext(ctx) 861 req.ApplyOptions(opts...) 862 return out, req.Send() 863} 864 865const opDeleteRule = "DeleteRule" 866 867// DeleteRuleRequest generates a "aws/request.Request" representing the 868// client's request for the DeleteRule operation. The "output" return 869// value will be populated with the request's response once the request completes 870// successfuly. 871// 872// Use "Send" method on the returned Request to send the API call to the service. 873// the "output" return value is not valid until after Send returns without error. 874// 875// See DeleteRule for more information on using the DeleteRule 876// API call, and error handling. 877// 878// This method is useful when you want to inject custom logic or configuration 879// into the SDK's request lifecycle. Such as custom headers, or retry logic. 880// 881// 882// // Example sending a request using the DeleteRuleRequest method. 883// req, resp := client.DeleteRuleRequest(params) 884// 885// err := req.Send() 886// if err == nil { // resp is now filled 887// fmt.Println(resp) 888// } 889// 890// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DeleteRule 891func (c *ELBV2) DeleteRuleRequest(input *DeleteRuleInput) (req *request.Request, output *DeleteRuleOutput) { 892 op := &request.Operation{ 893 Name: opDeleteRule, 894 HTTPMethod: "POST", 895 HTTPPath: "/", 896 } 897 898 if input == nil { 899 input = &DeleteRuleInput{} 900 } 901 902 output = &DeleteRuleOutput{} 903 req = c.newRequest(op, input, output) 904 return 905} 906 907// DeleteRule API operation for Elastic Load Balancing. 908// 909// Deletes the specified rule. 910// 911// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 912// with awserr.Error's Code and Message methods to get detailed information about 913// the error. 914// 915// See the AWS API reference guide for Elastic Load Balancing's 916// API operation DeleteRule for usage and error information. 917// 918// Returned Error Codes: 919// * ErrCodeRuleNotFoundException "RuleNotFound" 920// The specified rule does not exist. 921// 922// * ErrCodeOperationNotPermittedException "OperationNotPermitted" 923// This operation is not allowed. 924// 925// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DeleteRule 926func (c *ELBV2) DeleteRule(input *DeleteRuleInput) (*DeleteRuleOutput, error) { 927 req, out := c.DeleteRuleRequest(input) 928 return out, req.Send() 929} 930 931// DeleteRuleWithContext is the same as DeleteRule with the addition of 932// the ability to pass a context and additional request options. 933// 934// See DeleteRule for details on how to use this API operation. 935// 936// The context must be non-nil and will be used for request cancellation. If 937// the context is nil a panic will occur. In the future the SDK may create 938// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 939// for more information on using Contexts. 940func (c *ELBV2) DeleteRuleWithContext(ctx aws.Context, input *DeleteRuleInput, opts ...request.Option) (*DeleteRuleOutput, error) { 941 req, out := c.DeleteRuleRequest(input) 942 req.SetContext(ctx) 943 req.ApplyOptions(opts...) 944 return out, req.Send() 945} 946 947const opDeleteTargetGroup = "DeleteTargetGroup" 948 949// DeleteTargetGroupRequest generates a "aws/request.Request" representing the 950// client's request for the DeleteTargetGroup operation. The "output" return 951// value will be populated with the request's response once the request completes 952// successfuly. 953// 954// Use "Send" method on the returned Request to send the API call to the service. 955// the "output" return value is not valid until after Send returns without error. 956// 957// See DeleteTargetGroup for more information on using the DeleteTargetGroup 958// API call, and error handling. 959// 960// This method is useful when you want to inject custom logic or configuration 961// into the SDK's request lifecycle. Such as custom headers, or retry logic. 962// 963// 964// // Example sending a request using the DeleteTargetGroupRequest method. 965// req, resp := client.DeleteTargetGroupRequest(params) 966// 967// err := req.Send() 968// if err == nil { // resp is now filled 969// fmt.Println(resp) 970// } 971// 972// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DeleteTargetGroup 973func (c *ELBV2) DeleteTargetGroupRequest(input *DeleteTargetGroupInput) (req *request.Request, output *DeleteTargetGroupOutput) { 974 op := &request.Operation{ 975 Name: opDeleteTargetGroup, 976 HTTPMethod: "POST", 977 HTTPPath: "/", 978 } 979 980 if input == nil { 981 input = &DeleteTargetGroupInput{} 982 } 983 984 output = &DeleteTargetGroupOutput{} 985 req = c.newRequest(op, input, output) 986 return 987} 988 989// DeleteTargetGroup API operation for Elastic Load Balancing. 990// 991// Deletes the specified target group. 992// 993// You can delete a target group if it is not referenced by any actions. Deleting 994// a target group also deletes any associated health checks. 995// 996// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 997// with awserr.Error's Code and Message methods to get detailed information about 998// the error. 999// 1000// See the AWS API reference guide for Elastic Load Balancing's 1001// API operation DeleteTargetGroup for usage and error information. 1002// 1003// Returned Error Codes: 1004// * ErrCodeResourceInUseException "ResourceInUse" 1005// A specified resource is in use. 1006// 1007// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DeleteTargetGroup 1008func (c *ELBV2) DeleteTargetGroup(input *DeleteTargetGroupInput) (*DeleteTargetGroupOutput, error) { 1009 req, out := c.DeleteTargetGroupRequest(input) 1010 return out, req.Send() 1011} 1012 1013// DeleteTargetGroupWithContext is the same as DeleteTargetGroup with the addition of 1014// the ability to pass a context and additional request options. 1015// 1016// See DeleteTargetGroup for details on how to use this API operation. 1017// 1018// The context must be non-nil and will be used for request cancellation. If 1019// the context is nil a panic will occur. In the future the SDK may create 1020// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1021// for more information on using Contexts. 1022func (c *ELBV2) DeleteTargetGroupWithContext(ctx aws.Context, input *DeleteTargetGroupInput, opts ...request.Option) (*DeleteTargetGroupOutput, error) { 1023 req, out := c.DeleteTargetGroupRequest(input) 1024 req.SetContext(ctx) 1025 req.ApplyOptions(opts...) 1026 return out, req.Send() 1027} 1028 1029const opDeregisterTargets = "DeregisterTargets" 1030 1031// DeregisterTargetsRequest generates a "aws/request.Request" representing the 1032// client's request for the DeregisterTargets operation. The "output" return 1033// value will be populated with the request's response once the request completes 1034// successfuly. 1035// 1036// Use "Send" method on the returned Request to send the API call to the service. 1037// the "output" return value is not valid until after Send returns without error. 1038// 1039// See DeregisterTargets for more information on using the DeregisterTargets 1040// API call, and error handling. 1041// 1042// This method is useful when you want to inject custom logic or configuration 1043// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1044// 1045// 1046// // Example sending a request using the DeregisterTargetsRequest method. 1047// req, resp := client.DeregisterTargetsRequest(params) 1048// 1049// err := req.Send() 1050// if err == nil { // resp is now filled 1051// fmt.Println(resp) 1052// } 1053// 1054// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DeregisterTargets 1055func (c *ELBV2) DeregisterTargetsRequest(input *DeregisterTargetsInput) (req *request.Request, output *DeregisterTargetsOutput) { 1056 op := &request.Operation{ 1057 Name: opDeregisterTargets, 1058 HTTPMethod: "POST", 1059 HTTPPath: "/", 1060 } 1061 1062 if input == nil { 1063 input = &DeregisterTargetsInput{} 1064 } 1065 1066 output = &DeregisterTargetsOutput{} 1067 req = c.newRequest(op, input, output) 1068 return 1069} 1070 1071// DeregisterTargets API operation for Elastic Load Balancing. 1072// 1073// Deregisters the specified targets from the specified target group. After 1074// the targets are deregistered, they no longer receive traffic from the load 1075// balancer. 1076// 1077// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1078// with awserr.Error's Code and Message methods to get detailed information about 1079// the error. 1080// 1081// See the AWS API reference guide for Elastic Load Balancing's 1082// API operation DeregisterTargets for usage and error information. 1083// 1084// Returned Error Codes: 1085// * ErrCodeTargetGroupNotFoundException "TargetGroupNotFound" 1086// The specified target group does not exist. 1087// 1088// * ErrCodeInvalidTargetException "InvalidTarget" 1089// The specified target does not exist, is not in the same VPC as the target 1090// group, or has an unsupported instance type. 1091// 1092// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DeregisterTargets 1093func (c *ELBV2) DeregisterTargets(input *DeregisterTargetsInput) (*DeregisterTargetsOutput, error) { 1094 req, out := c.DeregisterTargetsRequest(input) 1095 return out, req.Send() 1096} 1097 1098// DeregisterTargetsWithContext is the same as DeregisterTargets with the addition of 1099// the ability to pass a context and additional request options. 1100// 1101// See DeregisterTargets for details on how to use this API operation. 1102// 1103// The context must be non-nil and will be used for request cancellation. If 1104// the context is nil a panic will occur. In the future the SDK may create 1105// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1106// for more information on using Contexts. 1107func (c *ELBV2) DeregisterTargetsWithContext(ctx aws.Context, input *DeregisterTargetsInput, opts ...request.Option) (*DeregisterTargetsOutput, error) { 1108 req, out := c.DeregisterTargetsRequest(input) 1109 req.SetContext(ctx) 1110 req.ApplyOptions(opts...) 1111 return out, req.Send() 1112} 1113 1114const opDescribeAccountLimits = "DescribeAccountLimits" 1115 1116// DescribeAccountLimitsRequest generates a "aws/request.Request" representing the 1117// client's request for the DescribeAccountLimits operation. The "output" return 1118// value will be populated with the request's response once the request completes 1119// successfuly. 1120// 1121// Use "Send" method on the returned Request to send the API call to the service. 1122// the "output" return value is not valid until after Send returns without error. 1123// 1124// See DescribeAccountLimits for more information on using the DescribeAccountLimits 1125// API call, and error handling. 1126// 1127// This method is useful when you want to inject custom logic or configuration 1128// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1129// 1130// 1131// // Example sending a request using the DescribeAccountLimitsRequest method. 1132// req, resp := client.DescribeAccountLimitsRequest(params) 1133// 1134// err := req.Send() 1135// if err == nil { // resp is now filled 1136// fmt.Println(resp) 1137// } 1138// 1139// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeAccountLimits 1140func (c *ELBV2) DescribeAccountLimitsRequest(input *DescribeAccountLimitsInput) (req *request.Request, output *DescribeAccountLimitsOutput) { 1141 op := &request.Operation{ 1142 Name: opDescribeAccountLimits, 1143 HTTPMethod: "POST", 1144 HTTPPath: "/", 1145 } 1146 1147 if input == nil { 1148 input = &DescribeAccountLimitsInput{} 1149 } 1150 1151 output = &DescribeAccountLimitsOutput{} 1152 req = c.newRequest(op, input, output) 1153 return 1154} 1155 1156// DescribeAccountLimits API operation for Elastic Load Balancing. 1157// 1158// Describes the current Elastic Load Balancing resource limits for your AWS 1159// account. 1160// 1161// For more information, see Limits for Your Application Load Balancers (http://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-limits.html) 1162// in the Application Load Balancer Guide or Limits for Your Network Load Balancers 1163// (http://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-limits.html) 1164// in the Network Load Balancers Guide. 1165// 1166// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1167// with awserr.Error's Code and Message methods to get detailed information about 1168// the error. 1169// 1170// See the AWS API reference guide for Elastic Load Balancing's 1171// API operation DescribeAccountLimits for usage and error information. 1172// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeAccountLimits 1173func (c *ELBV2) DescribeAccountLimits(input *DescribeAccountLimitsInput) (*DescribeAccountLimitsOutput, error) { 1174 req, out := c.DescribeAccountLimitsRequest(input) 1175 return out, req.Send() 1176} 1177 1178// DescribeAccountLimitsWithContext is the same as DescribeAccountLimits with the addition of 1179// the ability to pass a context and additional request options. 1180// 1181// See DescribeAccountLimits for details on how to use this API operation. 1182// 1183// The context must be non-nil and will be used for request cancellation. If 1184// the context is nil a panic will occur. In the future the SDK may create 1185// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1186// for more information on using Contexts. 1187func (c *ELBV2) DescribeAccountLimitsWithContext(ctx aws.Context, input *DescribeAccountLimitsInput, opts ...request.Option) (*DescribeAccountLimitsOutput, error) { 1188 req, out := c.DescribeAccountLimitsRequest(input) 1189 req.SetContext(ctx) 1190 req.ApplyOptions(opts...) 1191 return out, req.Send() 1192} 1193 1194const opDescribeListenerCertificates = "DescribeListenerCertificates" 1195 1196// DescribeListenerCertificatesRequest generates a "aws/request.Request" representing the 1197// client's request for the DescribeListenerCertificates operation. The "output" return 1198// value will be populated with the request's response once the request completes 1199// successfuly. 1200// 1201// Use "Send" method on the returned Request to send the API call to the service. 1202// the "output" return value is not valid until after Send returns without error. 1203// 1204// See DescribeListenerCertificates for more information on using the DescribeListenerCertificates 1205// API call, and error handling. 1206// 1207// This method is useful when you want to inject custom logic or configuration 1208// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1209// 1210// 1211// // Example sending a request using the DescribeListenerCertificatesRequest method. 1212// req, resp := client.DescribeListenerCertificatesRequest(params) 1213// 1214// err := req.Send() 1215// if err == nil { // resp is now filled 1216// fmt.Println(resp) 1217// } 1218// 1219// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeListenerCertificates 1220func (c *ELBV2) DescribeListenerCertificatesRequest(input *DescribeListenerCertificatesInput) (req *request.Request, output *DescribeListenerCertificatesOutput) { 1221 op := &request.Operation{ 1222 Name: opDescribeListenerCertificates, 1223 HTTPMethod: "POST", 1224 HTTPPath: "/", 1225 } 1226 1227 if input == nil { 1228 input = &DescribeListenerCertificatesInput{} 1229 } 1230 1231 output = &DescribeListenerCertificatesOutput{} 1232 req = c.newRequest(op, input, output) 1233 return 1234} 1235 1236// DescribeListenerCertificates API operation for Elastic Load Balancing. 1237// 1238// Describes the certificates for the specified secure listener. 1239// 1240// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1241// with awserr.Error's Code and Message methods to get detailed information about 1242// the error. 1243// 1244// See the AWS API reference guide for Elastic Load Balancing's 1245// API operation DescribeListenerCertificates for usage and error information. 1246// 1247// Returned Error Codes: 1248// * ErrCodeListenerNotFoundException "ListenerNotFound" 1249// The specified listener does not exist. 1250// 1251// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeListenerCertificates 1252func (c *ELBV2) DescribeListenerCertificates(input *DescribeListenerCertificatesInput) (*DescribeListenerCertificatesOutput, error) { 1253 req, out := c.DescribeListenerCertificatesRequest(input) 1254 return out, req.Send() 1255} 1256 1257// DescribeListenerCertificatesWithContext is the same as DescribeListenerCertificates with the addition of 1258// the ability to pass a context and additional request options. 1259// 1260// See DescribeListenerCertificates for details on how to use this API operation. 1261// 1262// The context must be non-nil and will be used for request cancellation. If 1263// the context is nil a panic will occur. In the future the SDK may create 1264// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1265// for more information on using Contexts. 1266func (c *ELBV2) DescribeListenerCertificatesWithContext(ctx aws.Context, input *DescribeListenerCertificatesInput, opts ...request.Option) (*DescribeListenerCertificatesOutput, error) { 1267 req, out := c.DescribeListenerCertificatesRequest(input) 1268 req.SetContext(ctx) 1269 req.ApplyOptions(opts...) 1270 return out, req.Send() 1271} 1272 1273const opDescribeListeners = "DescribeListeners" 1274 1275// DescribeListenersRequest generates a "aws/request.Request" representing the 1276// client's request for the DescribeListeners operation. The "output" return 1277// value will be populated with the request's response once the request completes 1278// successfuly. 1279// 1280// Use "Send" method on the returned Request to send the API call to the service. 1281// the "output" return value is not valid until after Send returns without error. 1282// 1283// See DescribeListeners for more information on using the DescribeListeners 1284// API call, and error handling. 1285// 1286// This method is useful when you want to inject custom logic or configuration 1287// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1288// 1289// 1290// // Example sending a request using the DescribeListenersRequest method. 1291// req, resp := client.DescribeListenersRequest(params) 1292// 1293// err := req.Send() 1294// if err == nil { // resp is now filled 1295// fmt.Println(resp) 1296// } 1297// 1298// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeListeners 1299func (c *ELBV2) DescribeListenersRequest(input *DescribeListenersInput) (req *request.Request, output *DescribeListenersOutput) { 1300 op := &request.Operation{ 1301 Name: opDescribeListeners, 1302 HTTPMethod: "POST", 1303 HTTPPath: "/", 1304 Paginator: &request.Paginator{ 1305 InputTokens: []string{"Marker"}, 1306 OutputTokens: []string{"NextMarker"}, 1307 LimitToken: "", 1308 TruncationToken: "", 1309 }, 1310 } 1311 1312 if input == nil { 1313 input = &DescribeListenersInput{} 1314 } 1315 1316 output = &DescribeListenersOutput{} 1317 req = c.newRequest(op, input, output) 1318 return 1319} 1320 1321// DescribeListeners API operation for Elastic Load Balancing. 1322// 1323// Describes the specified listeners or the listeners for the specified Application 1324// Load Balancer or Network Load Balancer. You must specify either a load balancer 1325// or one or more listeners. 1326// 1327// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1328// with awserr.Error's Code and Message methods to get detailed information about 1329// the error. 1330// 1331// See the AWS API reference guide for Elastic Load Balancing's 1332// API operation DescribeListeners for usage and error information. 1333// 1334// Returned Error Codes: 1335// * ErrCodeListenerNotFoundException "ListenerNotFound" 1336// The specified listener does not exist. 1337// 1338// * ErrCodeLoadBalancerNotFoundException "LoadBalancerNotFound" 1339// The specified load balancer does not exist. 1340// 1341// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeListeners 1342func (c *ELBV2) DescribeListeners(input *DescribeListenersInput) (*DescribeListenersOutput, error) { 1343 req, out := c.DescribeListenersRequest(input) 1344 return out, req.Send() 1345} 1346 1347// DescribeListenersWithContext is the same as DescribeListeners with the addition of 1348// the ability to pass a context and additional request options. 1349// 1350// See DescribeListeners for details on how to use this API operation. 1351// 1352// The context must be non-nil and will be used for request cancellation. If 1353// the context is nil a panic will occur. In the future the SDK may create 1354// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1355// for more information on using Contexts. 1356func (c *ELBV2) DescribeListenersWithContext(ctx aws.Context, input *DescribeListenersInput, opts ...request.Option) (*DescribeListenersOutput, error) { 1357 req, out := c.DescribeListenersRequest(input) 1358 req.SetContext(ctx) 1359 req.ApplyOptions(opts...) 1360 return out, req.Send() 1361} 1362 1363// DescribeListenersPages iterates over the pages of a DescribeListeners operation, 1364// calling the "fn" function with the response data for each page. To stop 1365// iterating, return false from the fn function. 1366// 1367// See DescribeListeners method for more information on how to use this operation. 1368// 1369// Note: This operation can generate multiple requests to a service. 1370// 1371// // Example iterating over at most 3 pages of a DescribeListeners operation. 1372// pageNum := 0 1373// err := client.DescribeListenersPages(params, 1374// func(page *DescribeListenersOutput, lastPage bool) bool { 1375// pageNum++ 1376// fmt.Println(page) 1377// return pageNum <= 3 1378// }) 1379// 1380func (c *ELBV2) DescribeListenersPages(input *DescribeListenersInput, fn func(*DescribeListenersOutput, bool) bool) error { 1381 return c.DescribeListenersPagesWithContext(aws.BackgroundContext(), input, fn) 1382} 1383 1384// DescribeListenersPagesWithContext same as DescribeListenersPages except 1385// it takes a Context and allows setting request options on the pages. 1386// 1387// The context must be non-nil and will be used for request cancellation. If 1388// the context is nil a panic will occur. In the future the SDK may create 1389// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1390// for more information on using Contexts. 1391func (c *ELBV2) DescribeListenersPagesWithContext(ctx aws.Context, input *DescribeListenersInput, fn func(*DescribeListenersOutput, bool) bool, opts ...request.Option) error { 1392 p := request.Pagination{ 1393 NewRequest: func() (*request.Request, error) { 1394 var inCpy *DescribeListenersInput 1395 if input != nil { 1396 tmp := *input 1397 inCpy = &tmp 1398 } 1399 req, _ := c.DescribeListenersRequest(inCpy) 1400 req.SetContext(ctx) 1401 req.ApplyOptions(opts...) 1402 return req, nil 1403 }, 1404 } 1405 1406 cont := true 1407 for p.Next() && cont { 1408 cont = fn(p.Page().(*DescribeListenersOutput), !p.HasNextPage()) 1409 } 1410 return p.Err() 1411} 1412 1413const opDescribeLoadBalancerAttributes = "DescribeLoadBalancerAttributes" 1414 1415// DescribeLoadBalancerAttributesRequest generates a "aws/request.Request" representing the 1416// client's request for the DescribeLoadBalancerAttributes operation. The "output" return 1417// value will be populated with the request's response once the request completes 1418// successfuly. 1419// 1420// Use "Send" method on the returned Request to send the API call to the service. 1421// the "output" return value is not valid until after Send returns without error. 1422// 1423// See DescribeLoadBalancerAttributes for more information on using the DescribeLoadBalancerAttributes 1424// API call, and error handling. 1425// 1426// This method is useful when you want to inject custom logic or configuration 1427// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1428// 1429// 1430// // Example sending a request using the DescribeLoadBalancerAttributesRequest method. 1431// req, resp := client.DescribeLoadBalancerAttributesRequest(params) 1432// 1433// err := req.Send() 1434// if err == nil { // resp is now filled 1435// fmt.Println(resp) 1436// } 1437// 1438// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeLoadBalancerAttributes 1439func (c *ELBV2) DescribeLoadBalancerAttributesRequest(input *DescribeLoadBalancerAttributesInput) (req *request.Request, output *DescribeLoadBalancerAttributesOutput) { 1440 op := &request.Operation{ 1441 Name: opDescribeLoadBalancerAttributes, 1442 HTTPMethod: "POST", 1443 HTTPPath: "/", 1444 } 1445 1446 if input == nil { 1447 input = &DescribeLoadBalancerAttributesInput{} 1448 } 1449 1450 output = &DescribeLoadBalancerAttributesOutput{} 1451 req = c.newRequest(op, input, output) 1452 return 1453} 1454 1455// DescribeLoadBalancerAttributes API operation for Elastic Load Balancing. 1456// 1457// Describes the attributes for the specified Application Load Balancer or Network 1458// Load Balancer. 1459// 1460// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1461// with awserr.Error's Code and Message methods to get detailed information about 1462// the error. 1463// 1464// See the AWS API reference guide for Elastic Load Balancing's 1465// API operation DescribeLoadBalancerAttributes for usage and error information. 1466// 1467// Returned Error Codes: 1468// * ErrCodeLoadBalancerNotFoundException "LoadBalancerNotFound" 1469// The specified load balancer does not exist. 1470// 1471// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeLoadBalancerAttributes 1472func (c *ELBV2) DescribeLoadBalancerAttributes(input *DescribeLoadBalancerAttributesInput) (*DescribeLoadBalancerAttributesOutput, error) { 1473 req, out := c.DescribeLoadBalancerAttributesRequest(input) 1474 return out, req.Send() 1475} 1476 1477// DescribeLoadBalancerAttributesWithContext is the same as DescribeLoadBalancerAttributes with the addition of 1478// the ability to pass a context and additional request options. 1479// 1480// See DescribeLoadBalancerAttributes for details on how to use this API operation. 1481// 1482// The context must be non-nil and will be used for request cancellation. If 1483// the context is nil a panic will occur. In the future the SDK may create 1484// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1485// for more information on using Contexts. 1486func (c *ELBV2) DescribeLoadBalancerAttributesWithContext(ctx aws.Context, input *DescribeLoadBalancerAttributesInput, opts ...request.Option) (*DescribeLoadBalancerAttributesOutput, error) { 1487 req, out := c.DescribeLoadBalancerAttributesRequest(input) 1488 req.SetContext(ctx) 1489 req.ApplyOptions(opts...) 1490 return out, req.Send() 1491} 1492 1493const opDescribeLoadBalancers = "DescribeLoadBalancers" 1494 1495// DescribeLoadBalancersRequest generates a "aws/request.Request" representing the 1496// client's request for the DescribeLoadBalancers operation. The "output" return 1497// value will be populated with the request's response once the request completes 1498// successfuly. 1499// 1500// Use "Send" method on the returned Request to send the API call to the service. 1501// the "output" return value is not valid until after Send returns without error. 1502// 1503// See DescribeLoadBalancers for more information on using the DescribeLoadBalancers 1504// API call, and error handling. 1505// 1506// This method is useful when you want to inject custom logic or configuration 1507// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1508// 1509// 1510// // Example sending a request using the DescribeLoadBalancersRequest method. 1511// req, resp := client.DescribeLoadBalancersRequest(params) 1512// 1513// err := req.Send() 1514// if err == nil { // resp is now filled 1515// fmt.Println(resp) 1516// } 1517// 1518// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeLoadBalancers 1519func (c *ELBV2) DescribeLoadBalancersRequest(input *DescribeLoadBalancersInput) (req *request.Request, output *DescribeLoadBalancersOutput) { 1520 op := &request.Operation{ 1521 Name: opDescribeLoadBalancers, 1522 HTTPMethod: "POST", 1523 HTTPPath: "/", 1524 Paginator: &request.Paginator{ 1525 InputTokens: []string{"Marker"}, 1526 OutputTokens: []string{"NextMarker"}, 1527 LimitToken: "", 1528 TruncationToken: "", 1529 }, 1530 } 1531 1532 if input == nil { 1533 input = &DescribeLoadBalancersInput{} 1534 } 1535 1536 output = &DescribeLoadBalancersOutput{} 1537 req = c.newRequest(op, input, output) 1538 return 1539} 1540 1541// DescribeLoadBalancers API operation for Elastic Load Balancing. 1542// 1543// Describes the specified load balancers or all of your load balancers. 1544// 1545// To describe the listeners for a load balancer, use DescribeListeners. To 1546// describe the attributes for a load balancer, use DescribeLoadBalancerAttributes. 1547// 1548// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1549// with awserr.Error's Code and Message methods to get detailed information about 1550// the error. 1551// 1552// See the AWS API reference guide for Elastic Load Balancing's 1553// API operation DescribeLoadBalancers for usage and error information. 1554// 1555// Returned Error Codes: 1556// * ErrCodeLoadBalancerNotFoundException "LoadBalancerNotFound" 1557// The specified load balancer does not exist. 1558// 1559// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeLoadBalancers 1560func (c *ELBV2) DescribeLoadBalancers(input *DescribeLoadBalancersInput) (*DescribeLoadBalancersOutput, error) { 1561 req, out := c.DescribeLoadBalancersRequest(input) 1562 return out, req.Send() 1563} 1564 1565// DescribeLoadBalancersWithContext is the same as DescribeLoadBalancers with the addition of 1566// the ability to pass a context and additional request options. 1567// 1568// See DescribeLoadBalancers for details on how to use this API operation. 1569// 1570// The context must be non-nil and will be used for request cancellation. If 1571// the context is nil a panic will occur. In the future the SDK may create 1572// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1573// for more information on using Contexts. 1574func (c *ELBV2) DescribeLoadBalancersWithContext(ctx aws.Context, input *DescribeLoadBalancersInput, opts ...request.Option) (*DescribeLoadBalancersOutput, error) { 1575 req, out := c.DescribeLoadBalancersRequest(input) 1576 req.SetContext(ctx) 1577 req.ApplyOptions(opts...) 1578 return out, req.Send() 1579} 1580 1581// DescribeLoadBalancersPages iterates over the pages of a DescribeLoadBalancers operation, 1582// calling the "fn" function with the response data for each page. To stop 1583// iterating, return false from the fn function. 1584// 1585// See DescribeLoadBalancers method for more information on how to use this operation. 1586// 1587// Note: This operation can generate multiple requests to a service. 1588// 1589// // Example iterating over at most 3 pages of a DescribeLoadBalancers operation. 1590// pageNum := 0 1591// err := client.DescribeLoadBalancersPages(params, 1592// func(page *DescribeLoadBalancersOutput, lastPage bool) bool { 1593// pageNum++ 1594// fmt.Println(page) 1595// return pageNum <= 3 1596// }) 1597// 1598func (c *ELBV2) DescribeLoadBalancersPages(input *DescribeLoadBalancersInput, fn func(*DescribeLoadBalancersOutput, bool) bool) error { 1599 return c.DescribeLoadBalancersPagesWithContext(aws.BackgroundContext(), input, fn) 1600} 1601 1602// DescribeLoadBalancersPagesWithContext same as DescribeLoadBalancersPages except 1603// it takes a Context and allows setting request options on the pages. 1604// 1605// The context must be non-nil and will be used for request cancellation. If 1606// the context is nil a panic will occur. In the future the SDK may create 1607// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1608// for more information on using Contexts. 1609func (c *ELBV2) DescribeLoadBalancersPagesWithContext(ctx aws.Context, input *DescribeLoadBalancersInput, fn func(*DescribeLoadBalancersOutput, bool) bool, opts ...request.Option) error { 1610 p := request.Pagination{ 1611 NewRequest: func() (*request.Request, error) { 1612 var inCpy *DescribeLoadBalancersInput 1613 if input != nil { 1614 tmp := *input 1615 inCpy = &tmp 1616 } 1617 req, _ := c.DescribeLoadBalancersRequest(inCpy) 1618 req.SetContext(ctx) 1619 req.ApplyOptions(opts...) 1620 return req, nil 1621 }, 1622 } 1623 1624 cont := true 1625 for p.Next() && cont { 1626 cont = fn(p.Page().(*DescribeLoadBalancersOutput), !p.HasNextPage()) 1627 } 1628 return p.Err() 1629} 1630 1631const opDescribeRules = "DescribeRules" 1632 1633// DescribeRulesRequest generates a "aws/request.Request" representing the 1634// client's request for the DescribeRules operation. The "output" return 1635// value will be populated with the request's response once the request completes 1636// successfuly. 1637// 1638// Use "Send" method on the returned Request to send the API call to the service. 1639// the "output" return value is not valid until after Send returns without error. 1640// 1641// See DescribeRules for more information on using the DescribeRules 1642// API call, and error handling. 1643// 1644// This method is useful when you want to inject custom logic or configuration 1645// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1646// 1647// 1648// // Example sending a request using the DescribeRulesRequest method. 1649// req, resp := client.DescribeRulesRequest(params) 1650// 1651// err := req.Send() 1652// if err == nil { // resp is now filled 1653// fmt.Println(resp) 1654// } 1655// 1656// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeRules 1657func (c *ELBV2) DescribeRulesRequest(input *DescribeRulesInput) (req *request.Request, output *DescribeRulesOutput) { 1658 op := &request.Operation{ 1659 Name: opDescribeRules, 1660 HTTPMethod: "POST", 1661 HTTPPath: "/", 1662 } 1663 1664 if input == nil { 1665 input = &DescribeRulesInput{} 1666 } 1667 1668 output = &DescribeRulesOutput{} 1669 req = c.newRequest(op, input, output) 1670 return 1671} 1672 1673// DescribeRules API operation for Elastic Load Balancing. 1674// 1675// Describes the specified rules or the rules for the specified listener. You 1676// must specify either a listener or one or more rules. 1677// 1678// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1679// with awserr.Error's Code and Message methods to get detailed information about 1680// the error. 1681// 1682// See the AWS API reference guide for Elastic Load Balancing's 1683// API operation DescribeRules for usage and error information. 1684// 1685// Returned Error Codes: 1686// * ErrCodeListenerNotFoundException "ListenerNotFound" 1687// The specified listener does not exist. 1688// 1689// * ErrCodeRuleNotFoundException "RuleNotFound" 1690// The specified rule does not exist. 1691// 1692// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeRules 1693func (c *ELBV2) DescribeRules(input *DescribeRulesInput) (*DescribeRulesOutput, error) { 1694 req, out := c.DescribeRulesRequest(input) 1695 return out, req.Send() 1696} 1697 1698// DescribeRulesWithContext is the same as DescribeRules with the addition of 1699// the ability to pass a context and additional request options. 1700// 1701// See DescribeRules for details on how to use this API operation. 1702// 1703// The context must be non-nil and will be used for request cancellation. If 1704// the context is nil a panic will occur. In the future the SDK may create 1705// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1706// for more information on using Contexts. 1707func (c *ELBV2) DescribeRulesWithContext(ctx aws.Context, input *DescribeRulesInput, opts ...request.Option) (*DescribeRulesOutput, error) { 1708 req, out := c.DescribeRulesRequest(input) 1709 req.SetContext(ctx) 1710 req.ApplyOptions(opts...) 1711 return out, req.Send() 1712} 1713 1714const opDescribeSSLPolicies = "DescribeSSLPolicies" 1715 1716// DescribeSSLPoliciesRequest generates a "aws/request.Request" representing the 1717// client's request for the DescribeSSLPolicies operation. The "output" return 1718// value will be populated with the request's response once the request completes 1719// successfuly. 1720// 1721// Use "Send" method on the returned Request to send the API call to the service. 1722// the "output" return value is not valid until after Send returns without error. 1723// 1724// See DescribeSSLPolicies for more information on using the DescribeSSLPolicies 1725// API call, and error handling. 1726// 1727// This method is useful when you want to inject custom logic or configuration 1728// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1729// 1730// 1731// // Example sending a request using the DescribeSSLPoliciesRequest method. 1732// req, resp := client.DescribeSSLPoliciesRequest(params) 1733// 1734// err := req.Send() 1735// if err == nil { // resp is now filled 1736// fmt.Println(resp) 1737// } 1738// 1739// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeSSLPolicies 1740func (c *ELBV2) DescribeSSLPoliciesRequest(input *DescribeSSLPoliciesInput) (req *request.Request, output *DescribeSSLPoliciesOutput) { 1741 op := &request.Operation{ 1742 Name: opDescribeSSLPolicies, 1743 HTTPMethod: "POST", 1744 HTTPPath: "/", 1745 } 1746 1747 if input == nil { 1748 input = &DescribeSSLPoliciesInput{} 1749 } 1750 1751 output = &DescribeSSLPoliciesOutput{} 1752 req = c.newRequest(op, input, output) 1753 return 1754} 1755 1756// DescribeSSLPolicies API operation for Elastic Load Balancing. 1757// 1758// Describes the specified policies or all policies used for SSL negotiation. 1759// 1760// For more information, see Security Policies (http://docs.aws.amazon.com/elasticloadbalancing/latest/application/create-https-listener.html#describe-ssl-policies) 1761// in the Application Load Balancers Guide. 1762// 1763// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1764// with awserr.Error's Code and Message methods to get detailed information about 1765// the error. 1766// 1767// See the AWS API reference guide for Elastic Load Balancing's 1768// API operation DescribeSSLPolicies for usage and error information. 1769// 1770// Returned Error Codes: 1771// * ErrCodeSSLPolicyNotFoundException "SSLPolicyNotFound" 1772// The specified SSL policy does not exist. 1773// 1774// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeSSLPolicies 1775func (c *ELBV2) DescribeSSLPolicies(input *DescribeSSLPoliciesInput) (*DescribeSSLPoliciesOutput, error) { 1776 req, out := c.DescribeSSLPoliciesRequest(input) 1777 return out, req.Send() 1778} 1779 1780// DescribeSSLPoliciesWithContext is the same as DescribeSSLPolicies with the addition of 1781// the ability to pass a context and additional request options. 1782// 1783// See DescribeSSLPolicies for details on how to use this API operation. 1784// 1785// The context must be non-nil and will be used for request cancellation. If 1786// the context is nil a panic will occur. In the future the SDK may create 1787// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1788// for more information on using Contexts. 1789func (c *ELBV2) DescribeSSLPoliciesWithContext(ctx aws.Context, input *DescribeSSLPoliciesInput, opts ...request.Option) (*DescribeSSLPoliciesOutput, error) { 1790 req, out := c.DescribeSSLPoliciesRequest(input) 1791 req.SetContext(ctx) 1792 req.ApplyOptions(opts...) 1793 return out, req.Send() 1794} 1795 1796const opDescribeTags = "DescribeTags" 1797 1798// DescribeTagsRequest generates a "aws/request.Request" representing the 1799// client's request for the DescribeTags operation. The "output" return 1800// value will be populated with the request's response once the request completes 1801// successfuly. 1802// 1803// Use "Send" method on the returned Request to send the API call to the service. 1804// the "output" return value is not valid until after Send returns without error. 1805// 1806// See DescribeTags for more information on using the DescribeTags 1807// API call, and error handling. 1808// 1809// This method is useful when you want to inject custom logic or configuration 1810// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1811// 1812// 1813// // Example sending a request using the DescribeTagsRequest method. 1814// req, resp := client.DescribeTagsRequest(params) 1815// 1816// err := req.Send() 1817// if err == nil { // resp is now filled 1818// fmt.Println(resp) 1819// } 1820// 1821// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeTags 1822func (c *ELBV2) DescribeTagsRequest(input *DescribeTagsInput) (req *request.Request, output *DescribeTagsOutput) { 1823 op := &request.Operation{ 1824 Name: opDescribeTags, 1825 HTTPMethod: "POST", 1826 HTTPPath: "/", 1827 } 1828 1829 if input == nil { 1830 input = &DescribeTagsInput{} 1831 } 1832 1833 output = &DescribeTagsOutput{} 1834 req = c.newRequest(op, input, output) 1835 return 1836} 1837 1838// DescribeTags API operation for Elastic Load Balancing. 1839// 1840// Describes the tags for the specified resources. You can describe the tags 1841// for one or more Application Load Balancers, Network Load Balancers, and target 1842// groups. 1843// 1844// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1845// with awserr.Error's Code and Message methods to get detailed information about 1846// the error. 1847// 1848// See the AWS API reference guide for Elastic Load Balancing's 1849// API operation DescribeTags for usage and error information. 1850// 1851// Returned Error Codes: 1852// * ErrCodeLoadBalancerNotFoundException "LoadBalancerNotFound" 1853// The specified load balancer does not exist. 1854// 1855// * ErrCodeTargetGroupNotFoundException "TargetGroupNotFound" 1856// The specified target group does not exist. 1857// 1858// * ErrCodeListenerNotFoundException "ListenerNotFound" 1859// The specified listener does not exist. 1860// 1861// * ErrCodeRuleNotFoundException "RuleNotFound" 1862// The specified rule does not exist. 1863// 1864// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeTags 1865func (c *ELBV2) DescribeTags(input *DescribeTagsInput) (*DescribeTagsOutput, error) { 1866 req, out := c.DescribeTagsRequest(input) 1867 return out, req.Send() 1868} 1869 1870// DescribeTagsWithContext is the same as DescribeTags with the addition of 1871// the ability to pass a context and additional request options. 1872// 1873// See DescribeTags for details on how to use this API operation. 1874// 1875// The context must be non-nil and will be used for request cancellation. If 1876// the context is nil a panic will occur. In the future the SDK may create 1877// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1878// for more information on using Contexts. 1879func (c *ELBV2) DescribeTagsWithContext(ctx aws.Context, input *DescribeTagsInput, opts ...request.Option) (*DescribeTagsOutput, error) { 1880 req, out := c.DescribeTagsRequest(input) 1881 req.SetContext(ctx) 1882 req.ApplyOptions(opts...) 1883 return out, req.Send() 1884} 1885 1886const opDescribeTargetGroupAttributes = "DescribeTargetGroupAttributes" 1887 1888// DescribeTargetGroupAttributesRequest generates a "aws/request.Request" representing the 1889// client's request for the DescribeTargetGroupAttributes operation. The "output" return 1890// value will be populated with the request's response once the request completes 1891// successfuly. 1892// 1893// Use "Send" method on the returned Request to send the API call to the service. 1894// the "output" return value is not valid until after Send returns without error. 1895// 1896// See DescribeTargetGroupAttributes for more information on using the DescribeTargetGroupAttributes 1897// API call, and error handling. 1898// 1899// This method is useful when you want to inject custom logic or configuration 1900// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1901// 1902// 1903// // Example sending a request using the DescribeTargetGroupAttributesRequest method. 1904// req, resp := client.DescribeTargetGroupAttributesRequest(params) 1905// 1906// err := req.Send() 1907// if err == nil { // resp is now filled 1908// fmt.Println(resp) 1909// } 1910// 1911// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeTargetGroupAttributes 1912func (c *ELBV2) DescribeTargetGroupAttributesRequest(input *DescribeTargetGroupAttributesInput) (req *request.Request, output *DescribeTargetGroupAttributesOutput) { 1913 op := &request.Operation{ 1914 Name: opDescribeTargetGroupAttributes, 1915 HTTPMethod: "POST", 1916 HTTPPath: "/", 1917 } 1918 1919 if input == nil { 1920 input = &DescribeTargetGroupAttributesInput{} 1921 } 1922 1923 output = &DescribeTargetGroupAttributesOutput{} 1924 req = c.newRequest(op, input, output) 1925 return 1926} 1927 1928// DescribeTargetGroupAttributes API operation for Elastic Load Balancing. 1929// 1930// Describes the attributes for the specified target group. 1931// 1932// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1933// with awserr.Error's Code and Message methods to get detailed information about 1934// the error. 1935// 1936// See the AWS API reference guide for Elastic Load Balancing's 1937// API operation DescribeTargetGroupAttributes for usage and error information. 1938// 1939// Returned Error Codes: 1940// * ErrCodeTargetGroupNotFoundException "TargetGroupNotFound" 1941// The specified target group does not exist. 1942// 1943// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeTargetGroupAttributes 1944func (c *ELBV2) DescribeTargetGroupAttributes(input *DescribeTargetGroupAttributesInput) (*DescribeTargetGroupAttributesOutput, error) { 1945 req, out := c.DescribeTargetGroupAttributesRequest(input) 1946 return out, req.Send() 1947} 1948 1949// DescribeTargetGroupAttributesWithContext is the same as DescribeTargetGroupAttributes with the addition of 1950// the ability to pass a context and additional request options. 1951// 1952// See DescribeTargetGroupAttributes for details on how to use this API operation. 1953// 1954// The context must be non-nil and will be used for request cancellation. If 1955// the context is nil a panic will occur. In the future the SDK may create 1956// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1957// for more information on using Contexts. 1958func (c *ELBV2) DescribeTargetGroupAttributesWithContext(ctx aws.Context, input *DescribeTargetGroupAttributesInput, opts ...request.Option) (*DescribeTargetGroupAttributesOutput, error) { 1959 req, out := c.DescribeTargetGroupAttributesRequest(input) 1960 req.SetContext(ctx) 1961 req.ApplyOptions(opts...) 1962 return out, req.Send() 1963} 1964 1965const opDescribeTargetGroups = "DescribeTargetGroups" 1966 1967// DescribeTargetGroupsRequest generates a "aws/request.Request" representing the 1968// client's request for the DescribeTargetGroups operation. The "output" return 1969// value will be populated with the request's response once the request completes 1970// successfuly. 1971// 1972// Use "Send" method on the returned Request to send the API call to the service. 1973// the "output" return value is not valid until after Send returns without error. 1974// 1975// See DescribeTargetGroups for more information on using the DescribeTargetGroups 1976// API call, and error handling. 1977// 1978// This method is useful when you want to inject custom logic or configuration 1979// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1980// 1981// 1982// // Example sending a request using the DescribeTargetGroupsRequest method. 1983// req, resp := client.DescribeTargetGroupsRequest(params) 1984// 1985// err := req.Send() 1986// if err == nil { // resp is now filled 1987// fmt.Println(resp) 1988// } 1989// 1990// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeTargetGroups 1991func (c *ELBV2) DescribeTargetGroupsRequest(input *DescribeTargetGroupsInput) (req *request.Request, output *DescribeTargetGroupsOutput) { 1992 op := &request.Operation{ 1993 Name: opDescribeTargetGroups, 1994 HTTPMethod: "POST", 1995 HTTPPath: "/", 1996 Paginator: &request.Paginator{ 1997 InputTokens: []string{"Marker"}, 1998 OutputTokens: []string{"NextMarker"}, 1999 LimitToken: "", 2000 TruncationToken: "", 2001 }, 2002 } 2003 2004 if input == nil { 2005 input = &DescribeTargetGroupsInput{} 2006 } 2007 2008 output = &DescribeTargetGroupsOutput{} 2009 req = c.newRequest(op, input, output) 2010 return 2011} 2012 2013// DescribeTargetGroups API operation for Elastic Load Balancing. 2014// 2015// Describes the specified target groups or all of your target groups. By default, 2016// all target groups are described. Alternatively, you can specify one of the 2017// following to filter the results: the ARN of the load balancer, the names 2018// of one or more target groups, or the ARNs of one or more target groups. 2019// 2020// To describe the targets for a target group, use DescribeTargetHealth. To 2021// describe the attributes of a target group, use DescribeTargetGroupAttributes. 2022// 2023// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2024// with awserr.Error's Code and Message methods to get detailed information about 2025// the error. 2026// 2027// See the AWS API reference guide for Elastic Load Balancing's 2028// API operation DescribeTargetGroups for usage and error information. 2029// 2030// Returned Error Codes: 2031// * ErrCodeLoadBalancerNotFoundException "LoadBalancerNotFound" 2032// The specified load balancer does not exist. 2033// 2034// * ErrCodeTargetGroupNotFoundException "TargetGroupNotFound" 2035// The specified target group does not exist. 2036// 2037// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeTargetGroups 2038func (c *ELBV2) DescribeTargetGroups(input *DescribeTargetGroupsInput) (*DescribeTargetGroupsOutput, error) { 2039 req, out := c.DescribeTargetGroupsRequest(input) 2040 return out, req.Send() 2041} 2042 2043// DescribeTargetGroupsWithContext is the same as DescribeTargetGroups with the addition of 2044// the ability to pass a context and additional request options. 2045// 2046// See DescribeTargetGroups for details on how to use this API operation. 2047// 2048// The context must be non-nil and will be used for request cancellation. If 2049// the context is nil a panic will occur. In the future the SDK may create 2050// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2051// for more information on using Contexts. 2052func (c *ELBV2) DescribeTargetGroupsWithContext(ctx aws.Context, input *DescribeTargetGroupsInput, opts ...request.Option) (*DescribeTargetGroupsOutput, error) { 2053 req, out := c.DescribeTargetGroupsRequest(input) 2054 req.SetContext(ctx) 2055 req.ApplyOptions(opts...) 2056 return out, req.Send() 2057} 2058 2059// DescribeTargetGroupsPages iterates over the pages of a DescribeTargetGroups operation, 2060// calling the "fn" function with the response data for each page. To stop 2061// iterating, return false from the fn function. 2062// 2063// See DescribeTargetGroups method for more information on how to use this operation. 2064// 2065// Note: This operation can generate multiple requests to a service. 2066// 2067// // Example iterating over at most 3 pages of a DescribeTargetGroups operation. 2068// pageNum := 0 2069// err := client.DescribeTargetGroupsPages(params, 2070// func(page *DescribeTargetGroupsOutput, lastPage bool) bool { 2071// pageNum++ 2072// fmt.Println(page) 2073// return pageNum <= 3 2074// }) 2075// 2076func (c *ELBV2) DescribeTargetGroupsPages(input *DescribeTargetGroupsInput, fn func(*DescribeTargetGroupsOutput, bool) bool) error { 2077 return c.DescribeTargetGroupsPagesWithContext(aws.BackgroundContext(), input, fn) 2078} 2079 2080// DescribeTargetGroupsPagesWithContext same as DescribeTargetGroupsPages except 2081// it takes a Context and allows setting request options on the pages. 2082// 2083// The context must be non-nil and will be used for request cancellation. If 2084// the context is nil a panic will occur. In the future the SDK may create 2085// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2086// for more information on using Contexts. 2087func (c *ELBV2) DescribeTargetGroupsPagesWithContext(ctx aws.Context, input *DescribeTargetGroupsInput, fn func(*DescribeTargetGroupsOutput, bool) bool, opts ...request.Option) error { 2088 p := request.Pagination{ 2089 NewRequest: func() (*request.Request, error) { 2090 var inCpy *DescribeTargetGroupsInput 2091 if input != nil { 2092 tmp := *input 2093 inCpy = &tmp 2094 } 2095 req, _ := c.DescribeTargetGroupsRequest(inCpy) 2096 req.SetContext(ctx) 2097 req.ApplyOptions(opts...) 2098 return req, nil 2099 }, 2100 } 2101 2102 cont := true 2103 for p.Next() && cont { 2104 cont = fn(p.Page().(*DescribeTargetGroupsOutput), !p.HasNextPage()) 2105 } 2106 return p.Err() 2107} 2108 2109const opDescribeTargetHealth = "DescribeTargetHealth" 2110 2111// DescribeTargetHealthRequest generates a "aws/request.Request" representing the 2112// client's request for the DescribeTargetHealth operation. The "output" return 2113// value will be populated with the request's response once the request completes 2114// successfuly. 2115// 2116// Use "Send" method on the returned Request to send the API call to the service. 2117// the "output" return value is not valid until after Send returns without error. 2118// 2119// See DescribeTargetHealth for more information on using the DescribeTargetHealth 2120// API call, and error handling. 2121// 2122// This method is useful when you want to inject custom logic or configuration 2123// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2124// 2125// 2126// // Example sending a request using the DescribeTargetHealthRequest method. 2127// req, resp := client.DescribeTargetHealthRequest(params) 2128// 2129// err := req.Send() 2130// if err == nil { // resp is now filled 2131// fmt.Println(resp) 2132// } 2133// 2134// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeTargetHealth 2135func (c *ELBV2) DescribeTargetHealthRequest(input *DescribeTargetHealthInput) (req *request.Request, output *DescribeTargetHealthOutput) { 2136 op := &request.Operation{ 2137 Name: opDescribeTargetHealth, 2138 HTTPMethod: "POST", 2139 HTTPPath: "/", 2140 } 2141 2142 if input == nil { 2143 input = &DescribeTargetHealthInput{} 2144 } 2145 2146 output = &DescribeTargetHealthOutput{} 2147 req = c.newRequest(op, input, output) 2148 return 2149} 2150 2151// DescribeTargetHealth API operation for Elastic Load Balancing. 2152// 2153// Describes the health of the specified targets or all of your targets. 2154// 2155// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2156// with awserr.Error's Code and Message methods to get detailed information about 2157// the error. 2158// 2159// See the AWS API reference guide for Elastic Load Balancing's 2160// API operation DescribeTargetHealth for usage and error information. 2161// 2162// Returned Error Codes: 2163// * ErrCodeInvalidTargetException "InvalidTarget" 2164// The specified target does not exist, is not in the same VPC as the target 2165// group, or has an unsupported instance type. 2166// 2167// * ErrCodeTargetGroupNotFoundException "TargetGroupNotFound" 2168// The specified target group does not exist. 2169// 2170// * ErrCodeHealthUnavailableException "HealthUnavailable" 2171// The health of the specified targets could not be retrieved due to an internal 2172// error. 2173// 2174// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeTargetHealth 2175func (c *ELBV2) DescribeTargetHealth(input *DescribeTargetHealthInput) (*DescribeTargetHealthOutput, error) { 2176 req, out := c.DescribeTargetHealthRequest(input) 2177 return out, req.Send() 2178} 2179 2180// DescribeTargetHealthWithContext is the same as DescribeTargetHealth with the addition of 2181// the ability to pass a context and additional request options. 2182// 2183// See DescribeTargetHealth for details on how to use this API operation. 2184// 2185// The context must be non-nil and will be used for request cancellation. If 2186// the context is nil a panic will occur. In the future the SDK may create 2187// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2188// for more information on using Contexts. 2189func (c *ELBV2) DescribeTargetHealthWithContext(ctx aws.Context, input *DescribeTargetHealthInput, opts ...request.Option) (*DescribeTargetHealthOutput, error) { 2190 req, out := c.DescribeTargetHealthRequest(input) 2191 req.SetContext(ctx) 2192 req.ApplyOptions(opts...) 2193 return out, req.Send() 2194} 2195 2196const opModifyListener = "ModifyListener" 2197 2198// ModifyListenerRequest generates a "aws/request.Request" representing the 2199// client's request for the ModifyListener operation. The "output" return 2200// value will be populated with the request's response once the request completes 2201// successfuly. 2202// 2203// Use "Send" method on the returned Request to send the API call to the service. 2204// the "output" return value is not valid until after Send returns without error. 2205// 2206// See ModifyListener for more information on using the ModifyListener 2207// API call, and error handling. 2208// 2209// This method is useful when you want to inject custom logic or configuration 2210// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2211// 2212// 2213// // Example sending a request using the ModifyListenerRequest method. 2214// req, resp := client.ModifyListenerRequest(params) 2215// 2216// err := req.Send() 2217// if err == nil { // resp is now filled 2218// fmt.Println(resp) 2219// } 2220// 2221// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/ModifyListener 2222func (c *ELBV2) ModifyListenerRequest(input *ModifyListenerInput) (req *request.Request, output *ModifyListenerOutput) { 2223 op := &request.Operation{ 2224 Name: opModifyListener, 2225 HTTPMethod: "POST", 2226 HTTPPath: "/", 2227 } 2228 2229 if input == nil { 2230 input = &ModifyListenerInput{} 2231 } 2232 2233 output = &ModifyListenerOutput{} 2234 req = c.newRequest(op, input, output) 2235 return 2236} 2237 2238// ModifyListener API operation for Elastic Load Balancing. 2239// 2240// Modifies the specified properties of the specified listener. 2241// 2242// Any properties that you do not specify retain their current values. However, 2243// changing the protocol from HTTPS to HTTP removes the security policy and 2244// SSL certificate properties. If you change the protocol from HTTP to HTTPS, 2245// you must add the security policy and server certificate. 2246// 2247// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2248// with awserr.Error's Code and Message methods to get detailed information about 2249// the error. 2250// 2251// See the AWS API reference guide for Elastic Load Balancing's 2252// API operation ModifyListener for usage and error information. 2253// 2254// Returned Error Codes: 2255// * ErrCodeDuplicateListenerException "DuplicateListener" 2256// A listener with the specified port already exists. 2257// 2258// * ErrCodeTooManyListenersException "TooManyListeners" 2259// You've reached the limit on the number of listeners per load balancer. 2260// 2261// * ErrCodeTooManyCertificatesException "TooManyCertificates" 2262// You've reached the limit on the number of certificates per load balancer. 2263// 2264// * ErrCodeListenerNotFoundException "ListenerNotFound" 2265// The specified listener does not exist. 2266// 2267// * ErrCodeTargetGroupNotFoundException "TargetGroupNotFound" 2268// The specified target group does not exist. 2269// 2270// * ErrCodeTargetGroupAssociationLimitException "TargetGroupAssociationLimit" 2271// You've reached the limit on the number of load balancers per target group. 2272// 2273// * ErrCodeIncompatibleProtocolsException "IncompatibleProtocols" 2274// The specified configuration is not valid with this protocol. 2275// 2276// * ErrCodeSSLPolicyNotFoundException "SSLPolicyNotFound" 2277// The specified SSL policy does not exist. 2278// 2279// * ErrCodeCertificateNotFoundException "CertificateNotFound" 2280// The specified certificate does not exist. 2281// 2282// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 2283// The requested configuration is not valid. 2284// 2285// * ErrCodeUnsupportedProtocolException "UnsupportedProtocol" 2286// The specified protocol is not supported. 2287// 2288// * ErrCodeTooManyRegistrationsForTargetIdException "TooManyRegistrationsForTargetId" 2289// You've reached the limit on the number of times a target can be registered 2290// with a load balancer. 2291// 2292// * ErrCodeTooManyTargetsException "TooManyTargets" 2293// You've reached the limit on the number of targets. 2294// 2295// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/ModifyListener 2296func (c *ELBV2) ModifyListener(input *ModifyListenerInput) (*ModifyListenerOutput, error) { 2297 req, out := c.ModifyListenerRequest(input) 2298 return out, req.Send() 2299} 2300 2301// ModifyListenerWithContext is the same as ModifyListener with the addition of 2302// the ability to pass a context and additional request options. 2303// 2304// See ModifyListener for details on how to use this API operation. 2305// 2306// The context must be non-nil and will be used for request cancellation. If 2307// the context is nil a panic will occur. In the future the SDK may create 2308// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2309// for more information on using Contexts. 2310func (c *ELBV2) ModifyListenerWithContext(ctx aws.Context, input *ModifyListenerInput, opts ...request.Option) (*ModifyListenerOutput, error) { 2311 req, out := c.ModifyListenerRequest(input) 2312 req.SetContext(ctx) 2313 req.ApplyOptions(opts...) 2314 return out, req.Send() 2315} 2316 2317const opModifyLoadBalancerAttributes = "ModifyLoadBalancerAttributes" 2318 2319// ModifyLoadBalancerAttributesRequest generates a "aws/request.Request" representing the 2320// client's request for the ModifyLoadBalancerAttributes operation. The "output" return 2321// value will be populated with the request's response once the request completes 2322// successfuly. 2323// 2324// Use "Send" method on the returned Request to send the API call to the service. 2325// the "output" return value is not valid until after Send returns without error. 2326// 2327// See ModifyLoadBalancerAttributes for more information on using the ModifyLoadBalancerAttributes 2328// API call, and error handling. 2329// 2330// This method is useful when you want to inject custom logic or configuration 2331// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2332// 2333// 2334// // Example sending a request using the ModifyLoadBalancerAttributesRequest method. 2335// req, resp := client.ModifyLoadBalancerAttributesRequest(params) 2336// 2337// err := req.Send() 2338// if err == nil { // resp is now filled 2339// fmt.Println(resp) 2340// } 2341// 2342// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/ModifyLoadBalancerAttributes 2343func (c *ELBV2) ModifyLoadBalancerAttributesRequest(input *ModifyLoadBalancerAttributesInput) (req *request.Request, output *ModifyLoadBalancerAttributesOutput) { 2344 op := &request.Operation{ 2345 Name: opModifyLoadBalancerAttributes, 2346 HTTPMethod: "POST", 2347 HTTPPath: "/", 2348 } 2349 2350 if input == nil { 2351 input = &ModifyLoadBalancerAttributesInput{} 2352 } 2353 2354 output = &ModifyLoadBalancerAttributesOutput{} 2355 req = c.newRequest(op, input, output) 2356 return 2357} 2358 2359// ModifyLoadBalancerAttributes API operation for Elastic Load Balancing. 2360// 2361// Modifies the specified attributes of the specified Application Load Balancer 2362// or Network Load Balancer. 2363// 2364// If any of the specified attributes can't be modified as requested, the call 2365// fails. Any existing attributes that you do not modify retain their current 2366// values. 2367// 2368// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2369// with awserr.Error's Code and Message methods to get detailed information about 2370// the error. 2371// 2372// See the AWS API reference guide for Elastic Load Balancing's 2373// API operation ModifyLoadBalancerAttributes for usage and error information. 2374// 2375// Returned Error Codes: 2376// * ErrCodeLoadBalancerNotFoundException "LoadBalancerNotFound" 2377// The specified load balancer does not exist. 2378// 2379// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 2380// The requested configuration is not valid. 2381// 2382// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/ModifyLoadBalancerAttributes 2383func (c *ELBV2) ModifyLoadBalancerAttributes(input *ModifyLoadBalancerAttributesInput) (*ModifyLoadBalancerAttributesOutput, error) { 2384 req, out := c.ModifyLoadBalancerAttributesRequest(input) 2385 return out, req.Send() 2386} 2387 2388// ModifyLoadBalancerAttributesWithContext is the same as ModifyLoadBalancerAttributes with the addition of 2389// the ability to pass a context and additional request options. 2390// 2391// See ModifyLoadBalancerAttributes for details on how to use this API operation. 2392// 2393// The context must be non-nil and will be used for request cancellation. If 2394// the context is nil a panic will occur. In the future the SDK may create 2395// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2396// for more information on using Contexts. 2397func (c *ELBV2) ModifyLoadBalancerAttributesWithContext(ctx aws.Context, input *ModifyLoadBalancerAttributesInput, opts ...request.Option) (*ModifyLoadBalancerAttributesOutput, error) { 2398 req, out := c.ModifyLoadBalancerAttributesRequest(input) 2399 req.SetContext(ctx) 2400 req.ApplyOptions(opts...) 2401 return out, req.Send() 2402} 2403 2404const opModifyRule = "ModifyRule" 2405 2406// ModifyRuleRequest generates a "aws/request.Request" representing the 2407// client's request for the ModifyRule operation. The "output" return 2408// value will be populated with the request's response once the request completes 2409// successfuly. 2410// 2411// Use "Send" method on the returned Request to send the API call to the service. 2412// the "output" return value is not valid until after Send returns without error. 2413// 2414// See ModifyRule for more information on using the ModifyRule 2415// API call, and error handling. 2416// 2417// This method is useful when you want to inject custom logic or configuration 2418// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2419// 2420// 2421// // Example sending a request using the ModifyRuleRequest method. 2422// req, resp := client.ModifyRuleRequest(params) 2423// 2424// err := req.Send() 2425// if err == nil { // resp is now filled 2426// fmt.Println(resp) 2427// } 2428// 2429// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/ModifyRule 2430func (c *ELBV2) ModifyRuleRequest(input *ModifyRuleInput) (req *request.Request, output *ModifyRuleOutput) { 2431 op := &request.Operation{ 2432 Name: opModifyRule, 2433 HTTPMethod: "POST", 2434 HTTPPath: "/", 2435 } 2436 2437 if input == nil { 2438 input = &ModifyRuleInput{} 2439 } 2440 2441 output = &ModifyRuleOutput{} 2442 req = c.newRequest(op, input, output) 2443 return 2444} 2445 2446// ModifyRule API operation for Elastic Load Balancing. 2447// 2448// Modifies the specified rule. 2449// 2450// Any existing properties that you do not modify retain their current values. 2451// 2452// To modify the default action, use ModifyListener. 2453// 2454// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2455// with awserr.Error's Code and Message methods to get detailed information about 2456// the error. 2457// 2458// See the AWS API reference guide for Elastic Load Balancing's 2459// API operation ModifyRule for usage and error information. 2460// 2461// Returned Error Codes: 2462// * ErrCodeTargetGroupAssociationLimitException "TargetGroupAssociationLimit" 2463// You've reached the limit on the number of load balancers per target group. 2464// 2465// * ErrCodeIncompatibleProtocolsException "IncompatibleProtocols" 2466// The specified configuration is not valid with this protocol. 2467// 2468// * ErrCodeRuleNotFoundException "RuleNotFound" 2469// The specified rule does not exist. 2470// 2471// * ErrCodeOperationNotPermittedException "OperationNotPermitted" 2472// This operation is not allowed. 2473// 2474// * ErrCodeTooManyRegistrationsForTargetIdException "TooManyRegistrationsForTargetId" 2475// You've reached the limit on the number of times a target can be registered 2476// with a load balancer. 2477// 2478// * ErrCodeTooManyTargetsException "TooManyTargets" 2479// You've reached the limit on the number of targets. 2480// 2481// * ErrCodeTargetGroupNotFoundException "TargetGroupNotFound" 2482// The specified target group does not exist. 2483// 2484// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/ModifyRule 2485func (c *ELBV2) ModifyRule(input *ModifyRuleInput) (*ModifyRuleOutput, error) { 2486 req, out := c.ModifyRuleRequest(input) 2487 return out, req.Send() 2488} 2489 2490// ModifyRuleWithContext is the same as ModifyRule with the addition of 2491// the ability to pass a context and additional request options. 2492// 2493// See ModifyRule for details on how to use this API operation. 2494// 2495// The context must be non-nil and will be used for request cancellation. If 2496// the context is nil a panic will occur. In the future the SDK may create 2497// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2498// for more information on using Contexts. 2499func (c *ELBV2) ModifyRuleWithContext(ctx aws.Context, input *ModifyRuleInput, opts ...request.Option) (*ModifyRuleOutput, error) { 2500 req, out := c.ModifyRuleRequest(input) 2501 req.SetContext(ctx) 2502 req.ApplyOptions(opts...) 2503 return out, req.Send() 2504} 2505 2506const opModifyTargetGroup = "ModifyTargetGroup" 2507 2508// ModifyTargetGroupRequest generates a "aws/request.Request" representing the 2509// client's request for the ModifyTargetGroup operation. The "output" return 2510// value will be populated with the request's response once the request completes 2511// successfuly. 2512// 2513// Use "Send" method on the returned Request to send the API call to the service. 2514// the "output" return value is not valid until after Send returns without error. 2515// 2516// See ModifyTargetGroup for more information on using the ModifyTargetGroup 2517// API call, and error handling. 2518// 2519// This method is useful when you want to inject custom logic or configuration 2520// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2521// 2522// 2523// // Example sending a request using the ModifyTargetGroupRequest method. 2524// req, resp := client.ModifyTargetGroupRequest(params) 2525// 2526// err := req.Send() 2527// if err == nil { // resp is now filled 2528// fmt.Println(resp) 2529// } 2530// 2531// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/ModifyTargetGroup 2532func (c *ELBV2) ModifyTargetGroupRequest(input *ModifyTargetGroupInput) (req *request.Request, output *ModifyTargetGroupOutput) { 2533 op := &request.Operation{ 2534 Name: opModifyTargetGroup, 2535 HTTPMethod: "POST", 2536 HTTPPath: "/", 2537 } 2538 2539 if input == nil { 2540 input = &ModifyTargetGroupInput{} 2541 } 2542 2543 output = &ModifyTargetGroupOutput{} 2544 req = c.newRequest(op, input, output) 2545 return 2546} 2547 2548// ModifyTargetGroup API operation for Elastic Load Balancing. 2549// 2550// Modifies the health checks used when evaluating the health state of the targets 2551// in the specified target group. 2552// 2553// To monitor the health of the targets, use DescribeTargetHealth. 2554// 2555// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2556// with awserr.Error's Code and Message methods to get detailed information about 2557// the error. 2558// 2559// See the AWS API reference guide for Elastic Load Balancing's 2560// API operation ModifyTargetGroup for usage and error information. 2561// 2562// Returned Error Codes: 2563// * ErrCodeTargetGroupNotFoundException "TargetGroupNotFound" 2564// The specified target group does not exist. 2565// 2566// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 2567// The requested configuration is not valid. 2568// 2569// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/ModifyTargetGroup 2570func (c *ELBV2) ModifyTargetGroup(input *ModifyTargetGroupInput) (*ModifyTargetGroupOutput, error) { 2571 req, out := c.ModifyTargetGroupRequest(input) 2572 return out, req.Send() 2573} 2574 2575// ModifyTargetGroupWithContext is the same as ModifyTargetGroup with the addition of 2576// the ability to pass a context and additional request options. 2577// 2578// See ModifyTargetGroup for details on how to use this API operation. 2579// 2580// The context must be non-nil and will be used for request cancellation. If 2581// the context is nil a panic will occur. In the future the SDK may create 2582// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2583// for more information on using Contexts. 2584func (c *ELBV2) ModifyTargetGroupWithContext(ctx aws.Context, input *ModifyTargetGroupInput, opts ...request.Option) (*ModifyTargetGroupOutput, error) { 2585 req, out := c.ModifyTargetGroupRequest(input) 2586 req.SetContext(ctx) 2587 req.ApplyOptions(opts...) 2588 return out, req.Send() 2589} 2590 2591const opModifyTargetGroupAttributes = "ModifyTargetGroupAttributes" 2592 2593// ModifyTargetGroupAttributesRequest generates a "aws/request.Request" representing the 2594// client's request for the ModifyTargetGroupAttributes operation. The "output" return 2595// value will be populated with the request's response once the request completes 2596// successfuly. 2597// 2598// Use "Send" method on the returned Request to send the API call to the service. 2599// the "output" return value is not valid until after Send returns without error. 2600// 2601// See ModifyTargetGroupAttributes for more information on using the ModifyTargetGroupAttributes 2602// API call, and error handling. 2603// 2604// This method is useful when you want to inject custom logic or configuration 2605// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2606// 2607// 2608// // Example sending a request using the ModifyTargetGroupAttributesRequest method. 2609// req, resp := client.ModifyTargetGroupAttributesRequest(params) 2610// 2611// err := req.Send() 2612// if err == nil { // resp is now filled 2613// fmt.Println(resp) 2614// } 2615// 2616// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/ModifyTargetGroupAttributes 2617func (c *ELBV2) ModifyTargetGroupAttributesRequest(input *ModifyTargetGroupAttributesInput) (req *request.Request, output *ModifyTargetGroupAttributesOutput) { 2618 op := &request.Operation{ 2619 Name: opModifyTargetGroupAttributes, 2620 HTTPMethod: "POST", 2621 HTTPPath: "/", 2622 } 2623 2624 if input == nil { 2625 input = &ModifyTargetGroupAttributesInput{} 2626 } 2627 2628 output = &ModifyTargetGroupAttributesOutput{} 2629 req = c.newRequest(op, input, output) 2630 return 2631} 2632 2633// ModifyTargetGroupAttributes API operation for Elastic Load Balancing. 2634// 2635// Modifies the specified attributes of the specified target group. 2636// 2637// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2638// with awserr.Error's Code and Message methods to get detailed information about 2639// the error. 2640// 2641// See the AWS API reference guide for Elastic Load Balancing's 2642// API operation ModifyTargetGroupAttributes for usage and error information. 2643// 2644// Returned Error Codes: 2645// * ErrCodeTargetGroupNotFoundException "TargetGroupNotFound" 2646// The specified target group does not exist. 2647// 2648// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 2649// The requested configuration is not valid. 2650// 2651// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/ModifyTargetGroupAttributes 2652func (c *ELBV2) ModifyTargetGroupAttributes(input *ModifyTargetGroupAttributesInput) (*ModifyTargetGroupAttributesOutput, error) { 2653 req, out := c.ModifyTargetGroupAttributesRequest(input) 2654 return out, req.Send() 2655} 2656 2657// ModifyTargetGroupAttributesWithContext is the same as ModifyTargetGroupAttributes with the addition of 2658// the ability to pass a context and additional request options. 2659// 2660// See ModifyTargetGroupAttributes for details on how to use this API operation. 2661// 2662// The context must be non-nil and will be used for request cancellation. If 2663// the context is nil a panic will occur. In the future the SDK may create 2664// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2665// for more information on using Contexts. 2666func (c *ELBV2) ModifyTargetGroupAttributesWithContext(ctx aws.Context, input *ModifyTargetGroupAttributesInput, opts ...request.Option) (*ModifyTargetGroupAttributesOutput, error) { 2667 req, out := c.ModifyTargetGroupAttributesRequest(input) 2668 req.SetContext(ctx) 2669 req.ApplyOptions(opts...) 2670 return out, req.Send() 2671} 2672 2673const opRegisterTargets = "RegisterTargets" 2674 2675// RegisterTargetsRequest generates a "aws/request.Request" representing the 2676// client's request for the RegisterTargets operation. The "output" return 2677// value will be populated with the request's response once the request completes 2678// successfuly. 2679// 2680// Use "Send" method on the returned Request to send the API call to the service. 2681// the "output" return value is not valid until after Send returns without error. 2682// 2683// See RegisterTargets for more information on using the RegisterTargets 2684// API call, and error handling. 2685// 2686// This method is useful when you want to inject custom logic or configuration 2687// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2688// 2689// 2690// // Example sending a request using the RegisterTargetsRequest method. 2691// req, resp := client.RegisterTargetsRequest(params) 2692// 2693// err := req.Send() 2694// if err == nil { // resp is now filled 2695// fmt.Println(resp) 2696// } 2697// 2698// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/RegisterTargets 2699func (c *ELBV2) RegisterTargetsRequest(input *RegisterTargetsInput) (req *request.Request, output *RegisterTargetsOutput) { 2700 op := &request.Operation{ 2701 Name: opRegisterTargets, 2702 HTTPMethod: "POST", 2703 HTTPPath: "/", 2704 } 2705 2706 if input == nil { 2707 input = &RegisterTargetsInput{} 2708 } 2709 2710 output = &RegisterTargetsOutput{} 2711 req = c.newRequest(op, input, output) 2712 return 2713} 2714 2715// RegisterTargets API operation for Elastic Load Balancing. 2716// 2717// Registers the specified targets with the specified target group. 2718// 2719// You can register targets by instance ID or by IP address. If the target is 2720// an EC2 instance, it must be in the running state when you register it. 2721// 2722// By default, the load balancer routes requests to registered targets using 2723// the protocol and port for the target group. Alternatively, you can override 2724// the port for a target when you register it. You can register each EC2 instance 2725// or IP address with the same target group multiple times using different ports. 2726// 2727// With a Network Load Balancer, you cannot register instances by instance ID 2728// if they have the following instance types: C1, CC1, CC2, CG1, CG2, CR1, CS1, 2729// G1, G2, HI1, HS1, M1, M2, M3, and T1. You can register instances of these 2730// types by IP address. 2731// 2732// To remove a target from a target group, use DeregisterTargets. 2733// 2734// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2735// with awserr.Error's Code and Message methods to get detailed information about 2736// the error. 2737// 2738// See the AWS API reference guide for Elastic Load Balancing's 2739// API operation RegisterTargets for usage and error information. 2740// 2741// Returned Error Codes: 2742// * ErrCodeTargetGroupNotFoundException "TargetGroupNotFound" 2743// The specified target group does not exist. 2744// 2745// * ErrCodeTooManyTargetsException "TooManyTargets" 2746// You've reached the limit on the number of targets. 2747// 2748// * ErrCodeInvalidTargetException "InvalidTarget" 2749// The specified target does not exist, is not in the same VPC as the target 2750// group, or has an unsupported instance type. 2751// 2752// * ErrCodeTooManyRegistrationsForTargetIdException "TooManyRegistrationsForTargetId" 2753// You've reached the limit on the number of times a target can be registered 2754// with a load balancer. 2755// 2756// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/RegisterTargets 2757func (c *ELBV2) RegisterTargets(input *RegisterTargetsInput) (*RegisterTargetsOutput, error) { 2758 req, out := c.RegisterTargetsRequest(input) 2759 return out, req.Send() 2760} 2761 2762// RegisterTargetsWithContext is the same as RegisterTargets with the addition of 2763// the ability to pass a context and additional request options. 2764// 2765// See RegisterTargets for details on how to use this API operation. 2766// 2767// The context must be non-nil and will be used for request cancellation. If 2768// the context is nil a panic will occur. In the future the SDK may create 2769// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2770// for more information on using Contexts. 2771func (c *ELBV2) RegisterTargetsWithContext(ctx aws.Context, input *RegisterTargetsInput, opts ...request.Option) (*RegisterTargetsOutput, error) { 2772 req, out := c.RegisterTargetsRequest(input) 2773 req.SetContext(ctx) 2774 req.ApplyOptions(opts...) 2775 return out, req.Send() 2776} 2777 2778const opRemoveListenerCertificates = "RemoveListenerCertificates" 2779 2780// RemoveListenerCertificatesRequest generates a "aws/request.Request" representing the 2781// client's request for the RemoveListenerCertificates operation. The "output" return 2782// value will be populated with the request's response once the request completes 2783// successfuly. 2784// 2785// Use "Send" method on the returned Request to send the API call to the service. 2786// the "output" return value is not valid until after Send returns without error. 2787// 2788// See RemoveListenerCertificates for more information on using the RemoveListenerCertificates 2789// API call, and error handling. 2790// 2791// This method is useful when you want to inject custom logic or configuration 2792// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2793// 2794// 2795// // Example sending a request using the RemoveListenerCertificatesRequest method. 2796// req, resp := client.RemoveListenerCertificatesRequest(params) 2797// 2798// err := req.Send() 2799// if err == nil { // resp is now filled 2800// fmt.Println(resp) 2801// } 2802// 2803// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/RemoveListenerCertificates 2804func (c *ELBV2) RemoveListenerCertificatesRequest(input *RemoveListenerCertificatesInput) (req *request.Request, output *RemoveListenerCertificatesOutput) { 2805 op := &request.Operation{ 2806 Name: opRemoveListenerCertificates, 2807 HTTPMethod: "POST", 2808 HTTPPath: "/", 2809 } 2810 2811 if input == nil { 2812 input = &RemoveListenerCertificatesInput{} 2813 } 2814 2815 output = &RemoveListenerCertificatesOutput{} 2816 req = c.newRequest(op, input, output) 2817 return 2818} 2819 2820// RemoveListenerCertificates API operation for Elastic Load Balancing. 2821// 2822// Removes the specified certificate from the specified secure listener. 2823// 2824// You can't remove the default certificate for a listener. To replace the default 2825// certificate, call ModifyListener. 2826// 2827// To list the certificates for your listener, use DescribeListenerCertificates. 2828// 2829// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2830// with awserr.Error's Code and Message methods to get detailed information about 2831// the error. 2832// 2833// See the AWS API reference guide for Elastic Load Balancing's 2834// API operation RemoveListenerCertificates for usage and error information. 2835// 2836// Returned Error Codes: 2837// * ErrCodeListenerNotFoundException "ListenerNotFound" 2838// The specified listener does not exist. 2839// 2840// * ErrCodeOperationNotPermittedException "OperationNotPermitted" 2841// This operation is not allowed. 2842// 2843// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/RemoveListenerCertificates 2844func (c *ELBV2) RemoveListenerCertificates(input *RemoveListenerCertificatesInput) (*RemoveListenerCertificatesOutput, error) { 2845 req, out := c.RemoveListenerCertificatesRequest(input) 2846 return out, req.Send() 2847} 2848 2849// RemoveListenerCertificatesWithContext is the same as RemoveListenerCertificates with the addition of 2850// the ability to pass a context and additional request options. 2851// 2852// See RemoveListenerCertificates for details on how to use this API operation. 2853// 2854// The context must be non-nil and will be used for request cancellation. If 2855// the context is nil a panic will occur. In the future the SDK may create 2856// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2857// for more information on using Contexts. 2858func (c *ELBV2) RemoveListenerCertificatesWithContext(ctx aws.Context, input *RemoveListenerCertificatesInput, opts ...request.Option) (*RemoveListenerCertificatesOutput, error) { 2859 req, out := c.RemoveListenerCertificatesRequest(input) 2860 req.SetContext(ctx) 2861 req.ApplyOptions(opts...) 2862 return out, req.Send() 2863} 2864 2865const opRemoveTags = "RemoveTags" 2866 2867// RemoveTagsRequest generates a "aws/request.Request" representing the 2868// client's request for the RemoveTags operation. The "output" return 2869// value will be populated with the request's response once the request completes 2870// successfuly. 2871// 2872// Use "Send" method on the returned Request to send the API call to the service. 2873// the "output" return value is not valid until after Send returns without error. 2874// 2875// See RemoveTags for more information on using the RemoveTags 2876// API call, and error handling. 2877// 2878// This method is useful when you want to inject custom logic or configuration 2879// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2880// 2881// 2882// // Example sending a request using the RemoveTagsRequest method. 2883// req, resp := client.RemoveTagsRequest(params) 2884// 2885// err := req.Send() 2886// if err == nil { // resp is now filled 2887// fmt.Println(resp) 2888// } 2889// 2890// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/RemoveTags 2891func (c *ELBV2) RemoveTagsRequest(input *RemoveTagsInput) (req *request.Request, output *RemoveTagsOutput) { 2892 op := &request.Operation{ 2893 Name: opRemoveTags, 2894 HTTPMethod: "POST", 2895 HTTPPath: "/", 2896 } 2897 2898 if input == nil { 2899 input = &RemoveTagsInput{} 2900 } 2901 2902 output = &RemoveTagsOutput{} 2903 req = c.newRequest(op, input, output) 2904 return 2905} 2906 2907// RemoveTags API operation for Elastic Load Balancing. 2908// 2909// Removes the specified tags from the specified Elastic Load Balancing resource. 2910// 2911// To list the current tags for your resources, use DescribeTags. 2912// 2913// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2914// with awserr.Error's Code and Message methods to get detailed information about 2915// the error. 2916// 2917// See the AWS API reference guide for Elastic Load Balancing's 2918// API operation RemoveTags for usage and error information. 2919// 2920// Returned Error Codes: 2921// * ErrCodeLoadBalancerNotFoundException "LoadBalancerNotFound" 2922// The specified load balancer does not exist. 2923// 2924// * ErrCodeTargetGroupNotFoundException "TargetGroupNotFound" 2925// The specified target group does not exist. 2926// 2927// * ErrCodeListenerNotFoundException "ListenerNotFound" 2928// The specified listener does not exist. 2929// 2930// * ErrCodeRuleNotFoundException "RuleNotFound" 2931// The specified rule does not exist. 2932// 2933// * ErrCodeTooManyTagsException "TooManyTags" 2934// You've reached the limit on the number of tags per load balancer. 2935// 2936// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/RemoveTags 2937func (c *ELBV2) RemoveTags(input *RemoveTagsInput) (*RemoveTagsOutput, error) { 2938 req, out := c.RemoveTagsRequest(input) 2939 return out, req.Send() 2940} 2941 2942// RemoveTagsWithContext is the same as RemoveTags with the addition of 2943// the ability to pass a context and additional request options. 2944// 2945// See RemoveTags for details on how to use this API operation. 2946// 2947// The context must be non-nil and will be used for request cancellation. If 2948// the context is nil a panic will occur. In the future the SDK may create 2949// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2950// for more information on using Contexts. 2951func (c *ELBV2) RemoveTagsWithContext(ctx aws.Context, input *RemoveTagsInput, opts ...request.Option) (*RemoveTagsOutput, error) { 2952 req, out := c.RemoveTagsRequest(input) 2953 req.SetContext(ctx) 2954 req.ApplyOptions(opts...) 2955 return out, req.Send() 2956} 2957 2958const opSetIpAddressType = "SetIpAddressType" 2959 2960// SetIpAddressTypeRequest generates a "aws/request.Request" representing the 2961// client's request for the SetIpAddressType operation. The "output" return 2962// value will be populated with the request's response once the request completes 2963// successfuly. 2964// 2965// Use "Send" method on the returned Request to send the API call to the service. 2966// the "output" return value is not valid until after Send returns without error. 2967// 2968// See SetIpAddressType for more information on using the SetIpAddressType 2969// API call, and error handling. 2970// 2971// This method is useful when you want to inject custom logic or configuration 2972// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2973// 2974// 2975// // Example sending a request using the SetIpAddressTypeRequest method. 2976// req, resp := client.SetIpAddressTypeRequest(params) 2977// 2978// err := req.Send() 2979// if err == nil { // resp is now filled 2980// fmt.Println(resp) 2981// } 2982// 2983// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/SetIpAddressType 2984func (c *ELBV2) SetIpAddressTypeRequest(input *SetIpAddressTypeInput) (req *request.Request, output *SetIpAddressTypeOutput) { 2985 op := &request.Operation{ 2986 Name: opSetIpAddressType, 2987 HTTPMethod: "POST", 2988 HTTPPath: "/", 2989 } 2990 2991 if input == nil { 2992 input = &SetIpAddressTypeInput{} 2993 } 2994 2995 output = &SetIpAddressTypeOutput{} 2996 req = c.newRequest(op, input, output) 2997 return 2998} 2999 3000// SetIpAddressType API operation for Elastic Load Balancing. 3001// 3002// Sets the type of IP addresses used by the subnets of the specified Application 3003// Load Balancer or Network Load Balancer. 3004// 3005// Note that Network Load Balancers must use ipv4. 3006// 3007// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3008// with awserr.Error's Code and Message methods to get detailed information about 3009// the error. 3010// 3011// See the AWS API reference guide for Elastic Load Balancing's 3012// API operation SetIpAddressType for usage and error information. 3013// 3014// Returned Error Codes: 3015// * ErrCodeLoadBalancerNotFoundException "LoadBalancerNotFound" 3016// The specified load balancer does not exist. 3017// 3018// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 3019// The requested configuration is not valid. 3020// 3021// * ErrCodeInvalidSubnetException "InvalidSubnet" 3022// The specified subnet is out of available addresses. 3023// 3024// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/SetIpAddressType 3025func (c *ELBV2) SetIpAddressType(input *SetIpAddressTypeInput) (*SetIpAddressTypeOutput, error) { 3026 req, out := c.SetIpAddressTypeRequest(input) 3027 return out, req.Send() 3028} 3029 3030// SetIpAddressTypeWithContext is the same as SetIpAddressType with the addition of 3031// the ability to pass a context and additional request options. 3032// 3033// See SetIpAddressType for details on how to use this API operation. 3034// 3035// The context must be non-nil and will be used for request cancellation. If 3036// the context is nil a panic will occur. In the future the SDK may create 3037// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3038// for more information on using Contexts. 3039func (c *ELBV2) SetIpAddressTypeWithContext(ctx aws.Context, input *SetIpAddressTypeInput, opts ...request.Option) (*SetIpAddressTypeOutput, error) { 3040 req, out := c.SetIpAddressTypeRequest(input) 3041 req.SetContext(ctx) 3042 req.ApplyOptions(opts...) 3043 return out, req.Send() 3044} 3045 3046const opSetRulePriorities = "SetRulePriorities" 3047 3048// SetRulePrioritiesRequest generates a "aws/request.Request" representing the 3049// client's request for the SetRulePriorities operation. The "output" return 3050// value will be populated with the request's response once the request completes 3051// successfuly. 3052// 3053// Use "Send" method on the returned Request to send the API call to the service. 3054// the "output" return value is not valid until after Send returns without error. 3055// 3056// See SetRulePriorities for more information on using the SetRulePriorities 3057// API call, and error handling. 3058// 3059// This method is useful when you want to inject custom logic or configuration 3060// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3061// 3062// 3063// // Example sending a request using the SetRulePrioritiesRequest method. 3064// req, resp := client.SetRulePrioritiesRequest(params) 3065// 3066// err := req.Send() 3067// if err == nil { // resp is now filled 3068// fmt.Println(resp) 3069// } 3070// 3071// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/SetRulePriorities 3072func (c *ELBV2) SetRulePrioritiesRequest(input *SetRulePrioritiesInput) (req *request.Request, output *SetRulePrioritiesOutput) { 3073 op := &request.Operation{ 3074 Name: opSetRulePriorities, 3075 HTTPMethod: "POST", 3076 HTTPPath: "/", 3077 } 3078 3079 if input == nil { 3080 input = &SetRulePrioritiesInput{} 3081 } 3082 3083 output = &SetRulePrioritiesOutput{} 3084 req = c.newRequest(op, input, output) 3085 return 3086} 3087 3088// SetRulePriorities API operation for Elastic Load Balancing. 3089// 3090// Sets the priorities of the specified rules. 3091// 3092// You can reorder the rules as long as there are no priority conflicts in the 3093// new order. Any existing rules that you do not specify retain their current 3094// priority. 3095// 3096// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3097// with awserr.Error's Code and Message methods to get detailed information about 3098// the error. 3099// 3100// See the AWS API reference guide for Elastic Load Balancing's 3101// API operation SetRulePriorities for usage and error information. 3102// 3103// Returned Error Codes: 3104// * ErrCodeRuleNotFoundException "RuleNotFound" 3105// The specified rule does not exist. 3106// 3107// * ErrCodePriorityInUseException "PriorityInUse" 3108// The specified priority is in use. 3109// 3110// * ErrCodeOperationNotPermittedException "OperationNotPermitted" 3111// This operation is not allowed. 3112// 3113// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/SetRulePriorities 3114func (c *ELBV2) SetRulePriorities(input *SetRulePrioritiesInput) (*SetRulePrioritiesOutput, error) { 3115 req, out := c.SetRulePrioritiesRequest(input) 3116 return out, req.Send() 3117} 3118 3119// SetRulePrioritiesWithContext is the same as SetRulePriorities with the addition of 3120// the ability to pass a context and additional request options. 3121// 3122// See SetRulePriorities for details on how to use this API operation. 3123// 3124// The context must be non-nil and will be used for request cancellation. If 3125// the context is nil a panic will occur. In the future the SDK may create 3126// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3127// for more information on using Contexts. 3128func (c *ELBV2) SetRulePrioritiesWithContext(ctx aws.Context, input *SetRulePrioritiesInput, opts ...request.Option) (*SetRulePrioritiesOutput, error) { 3129 req, out := c.SetRulePrioritiesRequest(input) 3130 req.SetContext(ctx) 3131 req.ApplyOptions(opts...) 3132 return out, req.Send() 3133} 3134 3135const opSetSecurityGroups = "SetSecurityGroups" 3136 3137// SetSecurityGroupsRequest generates a "aws/request.Request" representing the 3138// client's request for the SetSecurityGroups operation. The "output" return 3139// value will be populated with the request's response once the request completes 3140// successfuly. 3141// 3142// Use "Send" method on the returned Request to send the API call to the service. 3143// the "output" return value is not valid until after Send returns without error. 3144// 3145// See SetSecurityGroups for more information on using the SetSecurityGroups 3146// API call, and error handling. 3147// 3148// This method is useful when you want to inject custom logic or configuration 3149// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3150// 3151// 3152// // Example sending a request using the SetSecurityGroupsRequest method. 3153// req, resp := client.SetSecurityGroupsRequest(params) 3154// 3155// err := req.Send() 3156// if err == nil { // resp is now filled 3157// fmt.Println(resp) 3158// } 3159// 3160// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/SetSecurityGroups 3161func (c *ELBV2) SetSecurityGroupsRequest(input *SetSecurityGroupsInput) (req *request.Request, output *SetSecurityGroupsOutput) { 3162 op := &request.Operation{ 3163 Name: opSetSecurityGroups, 3164 HTTPMethod: "POST", 3165 HTTPPath: "/", 3166 } 3167 3168 if input == nil { 3169 input = &SetSecurityGroupsInput{} 3170 } 3171 3172 output = &SetSecurityGroupsOutput{} 3173 req = c.newRequest(op, input, output) 3174 return 3175} 3176 3177// SetSecurityGroups API operation for Elastic Load Balancing. 3178// 3179// Associates the specified security groups with the specified Application Load 3180// Balancer. The specified security groups override the previously associated 3181// security groups. 3182// 3183// Note that you can't specify a security group for a Network Load Balancer. 3184// 3185// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3186// with awserr.Error's Code and Message methods to get detailed information about 3187// the error. 3188// 3189// See the AWS API reference guide for Elastic Load Balancing's 3190// API operation SetSecurityGroups for usage and error information. 3191// 3192// Returned Error Codes: 3193// * ErrCodeLoadBalancerNotFoundException "LoadBalancerNotFound" 3194// The specified load balancer does not exist. 3195// 3196// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 3197// The requested configuration is not valid. 3198// 3199// * ErrCodeInvalidSecurityGroupException "InvalidSecurityGroup" 3200// The specified security group does not exist. 3201// 3202// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/SetSecurityGroups 3203func (c *ELBV2) SetSecurityGroups(input *SetSecurityGroupsInput) (*SetSecurityGroupsOutput, error) { 3204 req, out := c.SetSecurityGroupsRequest(input) 3205 return out, req.Send() 3206} 3207 3208// SetSecurityGroupsWithContext is the same as SetSecurityGroups with the addition of 3209// the ability to pass a context and additional request options. 3210// 3211// See SetSecurityGroups for details on how to use this API operation. 3212// 3213// The context must be non-nil and will be used for request cancellation. If 3214// the context is nil a panic will occur. In the future the SDK may create 3215// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3216// for more information on using Contexts. 3217func (c *ELBV2) SetSecurityGroupsWithContext(ctx aws.Context, input *SetSecurityGroupsInput, opts ...request.Option) (*SetSecurityGroupsOutput, error) { 3218 req, out := c.SetSecurityGroupsRequest(input) 3219 req.SetContext(ctx) 3220 req.ApplyOptions(opts...) 3221 return out, req.Send() 3222} 3223 3224const opSetSubnets = "SetSubnets" 3225 3226// SetSubnetsRequest generates a "aws/request.Request" representing the 3227// client's request for the SetSubnets operation. The "output" return 3228// value will be populated with the request's response once the request completes 3229// successfuly. 3230// 3231// Use "Send" method on the returned Request to send the API call to the service. 3232// the "output" return value is not valid until after Send returns without error. 3233// 3234// See SetSubnets for more information on using the SetSubnets 3235// API call, and error handling. 3236// 3237// This method is useful when you want to inject custom logic or configuration 3238// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3239// 3240// 3241// // Example sending a request using the SetSubnetsRequest method. 3242// req, resp := client.SetSubnetsRequest(params) 3243// 3244// err := req.Send() 3245// if err == nil { // resp is now filled 3246// fmt.Println(resp) 3247// } 3248// 3249// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/SetSubnets 3250func (c *ELBV2) SetSubnetsRequest(input *SetSubnetsInput) (req *request.Request, output *SetSubnetsOutput) { 3251 op := &request.Operation{ 3252 Name: opSetSubnets, 3253 HTTPMethod: "POST", 3254 HTTPPath: "/", 3255 } 3256 3257 if input == nil { 3258 input = &SetSubnetsInput{} 3259 } 3260 3261 output = &SetSubnetsOutput{} 3262 req = c.newRequest(op, input, output) 3263 return 3264} 3265 3266// SetSubnets API operation for Elastic Load Balancing. 3267// 3268// Enables the Availability Zone for the specified public subnets for the specified 3269// Application Load Balancer. The specified subnets replace the previously enabled 3270// subnets. 3271// 3272// Note that you can't change the subnets for a Network Load Balancer. 3273// 3274// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3275// with awserr.Error's Code and Message methods to get detailed information about 3276// the error. 3277// 3278// See the AWS API reference guide for Elastic Load Balancing's 3279// API operation SetSubnets for usage and error information. 3280// 3281// Returned Error Codes: 3282// * ErrCodeLoadBalancerNotFoundException "LoadBalancerNotFound" 3283// The specified load balancer does not exist. 3284// 3285// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 3286// The requested configuration is not valid. 3287// 3288// * ErrCodeSubnetNotFoundException "SubnetNotFound" 3289// The specified subnet does not exist. 3290// 3291// * ErrCodeInvalidSubnetException "InvalidSubnet" 3292// The specified subnet is out of available addresses. 3293// 3294// * ErrCodeAllocationIdNotFoundException "AllocationIdNotFound" 3295// The specified allocation ID does not exist. 3296// 3297// * ErrCodeAvailabilityZoneNotSupportedException "AvailabilityZoneNotSupported" 3298// The specified Availability Zone is not supported. 3299// 3300// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/SetSubnets 3301func (c *ELBV2) SetSubnets(input *SetSubnetsInput) (*SetSubnetsOutput, error) { 3302 req, out := c.SetSubnetsRequest(input) 3303 return out, req.Send() 3304} 3305 3306// SetSubnetsWithContext is the same as SetSubnets with the addition of 3307// the ability to pass a context and additional request options. 3308// 3309// See SetSubnets for details on how to use this API operation. 3310// 3311// The context must be non-nil and will be used for request cancellation. If 3312// the context is nil a panic will occur. In the future the SDK may create 3313// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3314// for more information on using Contexts. 3315func (c *ELBV2) SetSubnetsWithContext(ctx aws.Context, input *SetSubnetsInput, opts ...request.Option) (*SetSubnetsOutput, error) { 3316 req, out := c.SetSubnetsRequest(input) 3317 req.SetContext(ctx) 3318 req.ApplyOptions(opts...) 3319 return out, req.Send() 3320} 3321 3322// Information about an action. 3323type Action struct { 3324 _ struct{} `type:"structure"` 3325 3326 // The Amazon Resource Name (ARN) of the target group. 3327 // 3328 // TargetGroupArn is a required field 3329 TargetGroupArn *string `type:"string" required:"true"` 3330 3331 // The type of action. 3332 // 3333 // Type is a required field 3334 Type *string `type:"string" required:"true" enum:"ActionTypeEnum"` 3335} 3336 3337// String returns the string representation 3338func (s Action) String() string { 3339 return awsutil.Prettify(s) 3340} 3341 3342// GoString returns the string representation 3343func (s Action) GoString() string { 3344 return s.String() 3345} 3346 3347// Validate inspects the fields of the type to determine if they are valid. 3348func (s *Action) Validate() error { 3349 invalidParams := request.ErrInvalidParams{Context: "Action"} 3350 if s.TargetGroupArn == nil { 3351 invalidParams.Add(request.NewErrParamRequired("TargetGroupArn")) 3352 } 3353 if s.Type == nil { 3354 invalidParams.Add(request.NewErrParamRequired("Type")) 3355 } 3356 3357 if invalidParams.Len() > 0 { 3358 return invalidParams 3359 } 3360 return nil 3361} 3362 3363// SetTargetGroupArn sets the TargetGroupArn field's value. 3364func (s *Action) SetTargetGroupArn(v string) *Action { 3365 s.TargetGroupArn = &v 3366 return s 3367} 3368 3369// SetType sets the Type field's value. 3370func (s *Action) SetType(v string) *Action { 3371 s.Type = &v 3372 return s 3373} 3374 3375type AddListenerCertificatesInput struct { 3376 _ struct{} `type:"structure"` 3377 3378 // The certificate to add. You can specify one certificate per call. 3379 // 3380 // Certificates is a required field 3381 Certificates []*Certificate `type:"list" required:"true"` 3382 3383 // The Amazon Resource Name (ARN) of the listener. 3384 // 3385 // ListenerArn is a required field 3386 ListenerArn *string `type:"string" required:"true"` 3387} 3388 3389// String returns the string representation 3390func (s AddListenerCertificatesInput) String() string { 3391 return awsutil.Prettify(s) 3392} 3393 3394// GoString returns the string representation 3395func (s AddListenerCertificatesInput) GoString() string { 3396 return s.String() 3397} 3398 3399// Validate inspects the fields of the type to determine if they are valid. 3400func (s *AddListenerCertificatesInput) Validate() error { 3401 invalidParams := request.ErrInvalidParams{Context: "AddListenerCertificatesInput"} 3402 if s.Certificates == nil { 3403 invalidParams.Add(request.NewErrParamRequired("Certificates")) 3404 } 3405 if s.ListenerArn == nil { 3406 invalidParams.Add(request.NewErrParamRequired("ListenerArn")) 3407 } 3408 3409 if invalidParams.Len() > 0 { 3410 return invalidParams 3411 } 3412 return nil 3413} 3414 3415// SetCertificates sets the Certificates field's value. 3416func (s *AddListenerCertificatesInput) SetCertificates(v []*Certificate) *AddListenerCertificatesInput { 3417 s.Certificates = v 3418 return s 3419} 3420 3421// SetListenerArn sets the ListenerArn field's value. 3422func (s *AddListenerCertificatesInput) SetListenerArn(v string) *AddListenerCertificatesInput { 3423 s.ListenerArn = &v 3424 return s 3425} 3426 3427type AddListenerCertificatesOutput struct { 3428 _ struct{} `type:"structure"` 3429 3430 // Information about the certificates. 3431 Certificates []*Certificate `type:"list"` 3432} 3433 3434// String returns the string representation 3435func (s AddListenerCertificatesOutput) String() string { 3436 return awsutil.Prettify(s) 3437} 3438 3439// GoString returns the string representation 3440func (s AddListenerCertificatesOutput) GoString() string { 3441 return s.String() 3442} 3443 3444// SetCertificates sets the Certificates field's value. 3445func (s *AddListenerCertificatesOutput) SetCertificates(v []*Certificate) *AddListenerCertificatesOutput { 3446 s.Certificates = v 3447 return s 3448} 3449 3450type AddTagsInput struct { 3451 _ struct{} `type:"structure"` 3452 3453 // The Amazon Resource Name (ARN) of the resource. 3454 // 3455 // ResourceArns is a required field 3456 ResourceArns []*string `type:"list" required:"true"` 3457 3458 // The tags. Each resource can have a maximum of 10 tags. 3459 // 3460 // Tags is a required field 3461 Tags []*Tag `min:"1" type:"list" required:"true"` 3462} 3463 3464// String returns the string representation 3465func (s AddTagsInput) String() string { 3466 return awsutil.Prettify(s) 3467} 3468 3469// GoString returns the string representation 3470func (s AddTagsInput) GoString() string { 3471 return s.String() 3472} 3473 3474// Validate inspects the fields of the type to determine if they are valid. 3475func (s *AddTagsInput) Validate() error { 3476 invalidParams := request.ErrInvalidParams{Context: "AddTagsInput"} 3477 if s.ResourceArns == nil { 3478 invalidParams.Add(request.NewErrParamRequired("ResourceArns")) 3479 } 3480 if s.Tags == nil { 3481 invalidParams.Add(request.NewErrParamRequired("Tags")) 3482 } 3483 if s.Tags != nil && len(s.Tags) < 1 { 3484 invalidParams.Add(request.NewErrParamMinLen("Tags", 1)) 3485 } 3486 if s.Tags != nil { 3487 for i, v := range s.Tags { 3488 if v == nil { 3489 continue 3490 } 3491 if err := v.Validate(); err != nil { 3492 invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams)) 3493 } 3494 } 3495 } 3496 3497 if invalidParams.Len() > 0 { 3498 return invalidParams 3499 } 3500 return nil 3501} 3502 3503// SetResourceArns sets the ResourceArns field's value. 3504func (s *AddTagsInput) SetResourceArns(v []*string) *AddTagsInput { 3505 s.ResourceArns = v 3506 return s 3507} 3508 3509// SetTags sets the Tags field's value. 3510func (s *AddTagsInput) SetTags(v []*Tag) *AddTagsInput { 3511 s.Tags = v 3512 return s 3513} 3514 3515type AddTagsOutput struct { 3516 _ struct{} `type:"structure"` 3517} 3518 3519// String returns the string representation 3520func (s AddTagsOutput) String() string { 3521 return awsutil.Prettify(s) 3522} 3523 3524// GoString returns the string representation 3525func (s AddTagsOutput) GoString() string { 3526 return s.String() 3527} 3528 3529// Information about an Availability Zone. 3530type AvailabilityZone struct { 3531 _ struct{} `type:"structure"` 3532 3533 // [Network Load Balancers] The static IP address. 3534 LoadBalancerAddresses []*LoadBalancerAddress `type:"list"` 3535 3536 // The ID of the subnet. 3537 SubnetId *string `type:"string"` 3538 3539 // The name of the Availability Zone. 3540 ZoneName *string `type:"string"` 3541} 3542 3543// String returns the string representation 3544func (s AvailabilityZone) String() string { 3545 return awsutil.Prettify(s) 3546} 3547 3548// GoString returns the string representation 3549func (s AvailabilityZone) GoString() string { 3550 return s.String() 3551} 3552 3553// SetLoadBalancerAddresses sets the LoadBalancerAddresses field's value. 3554func (s *AvailabilityZone) SetLoadBalancerAddresses(v []*LoadBalancerAddress) *AvailabilityZone { 3555 s.LoadBalancerAddresses = v 3556 return s 3557} 3558 3559// SetSubnetId sets the SubnetId field's value. 3560func (s *AvailabilityZone) SetSubnetId(v string) *AvailabilityZone { 3561 s.SubnetId = &v 3562 return s 3563} 3564 3565// SetZoneName sets the ZoneName field's value. 3566func (s *AvailabilityZone) SetZoneName(v string) *AvailabilityZone { 3567 s.ZoneName = &v 3568 return s 3569} 3570 3571// Information about an SSL server certificate. 3572type Certificate struct { 3573 _ struct{} `type:"structure"` 3574 3575 // The Amazon Resource Name (ARN) of the certificate. 3576 CertificateArn *string `type:"string"` 3577 3578 // Indicates whether the certificate is the default certificate. 3579 IsDefault *bool `type:"boolean"` 3580} 3581 3582// String returns the string representation 3583func (s Certificate) String() string { 3584 return awsutil.Prettify(s) 3585} 3586 3587// GoString returns the string representation 3588func (s Certificate) GoString() string { 3589 return s.String() 3590} 3591 3592// SetCertificateArn sets the CertificateArn field's value. 3593func (s *Certificate) SetCertificateArn(v string) *Certificate { 3594 s.CertificateArn = &v 3595 return s 3596} 3597 3598// SetIsDefault sets the IsDefault field's value. 3599func (s *Certificate) SetIsDefault(v bool) *Certificate { 3600 s.IsDefault = &v 3601 return s 3602} 3603 3604// Information about a cipher used in a policy. 3605type Cipher struct { 3606 _ struct{} `type:"structure"` 3607 3608 // The name of the cipher. 3609 Name *string `type:"string"` 3610 3611 // The priority of the cipher. 3612 Priority *int64 `type:"integer"` 3613} 3614 3615// String returns the string representation 3616func (s Cipher) String() string { 3617 return awsutil.Prettify(s) 3618} 3619 3620// GoString returns the string representation 3621func (s Cipher) GoString() string { 3622 return s.String() 3623} 3624 3625// SetName sets the Name field's value. 3626func (s *Cipher) SetName(v string) *Cipher { 3627 s.Name = &v 3628 return s 3629} 3630 3631// SetPriority sets the Priority field's value. 3632func (s *Cipher) SetPriority(v int64) *Cipher { 3633 s.Priority = &v 3634 return s 3635} 3636 3637type CreateListenerInput struct { 3638 _ struct{} `type:"structure"` 3639 3640 // [HTTPS listeners] The SSL server certificate. You must provide exactly one 3641 // certificate. 3642 Certificates []*Certificate `type:"list"` 3643 3644 // The default action for the listener. For Application Load Balancers, the 3645 // protocol of the specified target group must be HTTP or HTTPS. For Network 3646 // Load Balancers, the protocol of the specified target group must be TCP. 3647 // 3648 // DefaultActions is a required field 3649 DefaultActions []*Action `type:"list" required:"true"` 3650 3651 // The Amazon Resource Name (ARN) of the load balancer. 3652 // 3653 // LoadBalancerArn is a required field 3654 LoadBalancerArn *string `type:"string" required:"true"` 3655 3656 // The port on which the load balancer is listening. 3657 // 3658 // Port is a required field 3659 Port *int64 `min:"1" type:"integer" required:"true"` 3660 3661 // The protocol for connections from clients to the load balancer. For Application 3662 // Load Balancers, the supported protocols are HTTP and HTTPS. For Network Load 3663 // Balancers, the supported protocol is TCP. 3664 // 3665 // Protocol is a required field 3666 Protocol *string `type:"string" required:"true" enum:"ProtocolEnum"` 3667 3668 // [HTTPS listeners] The security policy that defines which ciphers and protocols 3669 // are supported. The default is the current predefined security policy. 3670 SslPolicy *string `type:"string"` 3671} 3672 3673// String returns the string representation 3674func (s CreateListenerInput) String() string { 3675 return awsutil.Prettify(s) 3676} 3677 3678// GoString returns the string representation 3679func (s CreateListenerInput) GoString() string { 3680 return s.String() 3681} 3682 3683// Validate inspects the fields of the type to determine if they are valid. 3684func (s *CreateListenerInput) Validate() error { 3685 invalidParams := request.ErrInvalidParams{Context: "CreateListenerInput"} 3686 if s.DefaultActions == nil { 3687 invalidParams.Add(request.NewErrParamRequired("DefaultActions")) 3688 } 3689 if s.LoadBalancerArn == nil { 3690 invalidParams.Add(request.NewErrParamRequired("LoadBalancerArn")) 3691 } 3692 if s.Port == nil { 3693 invalidParams.Add(request.NewErrParamRequired("Port")) 3694 } 3695 if s.Port != nil && *s.Port < 1 { 3696 invalidParams.Add(request.NewErrParamMinValue("Port", 1)) 3697 } 3698 if s.Protocol == nil { 3699 invalidParams.Add(request.NewErrParamRequired("Protocol")) 3700 } 3701 if s.DefaultActions != nil { 3702 for i, v := range s.DefaultActions { 3703 if v == nil { 3704 continue 3705 } 3706 if err := v.Validate(); err != nil { 3707 invalidParams.AddNested(fmt.Sprintf("%s[%v]", "DefaultActions", i), err.(request.ErrInvalidParams)) 3708 } 3709 } 3710 } 3711 3712 if invalidParams.Len() > 0 { 3713 return invalidParams 3714 } 3715 return nil 3716} 3717 3718// SetCertificates sets the Certificates field's value. 3719func (s *CreateListenerInput) SetCertificates(v []*Certificate) *CreateListenerInput { 3720 s.Certificates = v 3721 return s 3722} 3723 3724// SetDefaultActions sets the DefaultActions field's value. 3725func (s *CreateListenerInput) SetDefaultActions(v []*Action) *CreateListenerInput { 3726 s.DefaultActions = v 3727 return s 3728} 3729 3730// SetLoadBalancerArn sets the LoadBalancerArn field's value. 3731func (s *CreateListenerInput) SetLoadBalancerArn(v string) *CreateListenerInput { 3732 s.LoadBalancerArn = &v 3733 return s 3734} 3735 3736// SetPort sets the Port field's value. 3737func (s *CreateListenerInput) SetPort(v int64) *CreateListenerInput { 3738 s.Port = &v 3739 return s 3740} 3741 3742// SetProtocol sets the Protocol field's value. 3743func (s *CreateListenerInput) SetProtocol(v string) *CreateListenerInput { 3744 s.Protocol = &v 3745 return s 3746} 3747 3748// SetSslPolicy sets the SslPolicy field's value. 3749func (s *CreateListenerInput) SetSslPolicy(v string) *CreateListenerInput { 3750 s.SslPolicy = &v 3751 return s 3752} 3753 3754type CreateListenerOutput struct { 3755 _ struct{} `type:"structure"` 3756 3757 // Information about the listener. 3758 Listeners []*Listener `type:"list"` 3759} 3760 3761// String returns the string representation 3762func (s CreateListenerOutput) String() string { 3763 return awsutil.Prettify(s) 3764} 3765 3766// GoString returns the string representation 3767func (s CreateListenerOutput) GoString() string { 3768 return s.String() 3769} 3770 3771// SetListeners sets the Listeners field's value. 3772func (s *CreateListenerOutput) SetListeners(v []*Listener) *CreateListenerOutput { 3773 s.Listeners = v 3774 return s 3775} 3776 3777type CreateLoadBalancerInput struct { 3778 _ struct{} `type:"structure"` 3779 3780 // [Application Load Balancers] The type of IP addresses used by the subnets 3781 // for your load balancer. The possible values are ipv4 (for IPv4 addresses) 3782 // and dualstack (for IPv4 and IPv6 addresses). Internal load balancers must 3783 // use ipv4. 3784 IpAddressType *string `type:"string" enum:"IpAddressType"` 3785 3786 // The name of the load balancer. 3787 // 3788 // This name must be unique per region per account, can have a maximum of 32 3789 // characters, must contain only alphanumeric characters or hyphens, and must 3790 // not begin or end with a hyphen. 3791 // 3792 // Name is a required field 3793 Name *string `type:"string" required:"true"` 3794 3795 // The nodes of an Internet-facing load balancer have public IP addresses. The 3796 // DNS name of an Internet-facing load balancer is publicly resolvable to the 3797 // public IP addresses of the nodes. Therefore, Internet-facing load balancers 3798 // can route requests from clients over the Internet. 3799 // 3800 // The nodes of an internal load balancer have only private IP addresses. The 3801 // DNS name of an internal load balancer is publicly resolvable to the private 3802 // IP addresses of the nodes. Therefore, internal load balancers can only route 3803 // requests from clients with access to the VPC for the load balancer. 3804 // 3805 // The default is an Internet-facing load balancer. 3806 Scheme *string `type:"string" enum:"LoadBalancerSchemeEnum"` 3807 3808 // [Application Load Balancers] The IDs of the security groups for the load 3809 // balancer. 3810 SecurityGroups []*string `type:"list"` 3811 3812 // The IDs of the public subnets. You can specify only one subnet per Availability 3813 // Zone. You must specify either subnets or subnet mappings. 3814 // 3815 // [Application Load Balancers] You must specify subnets from at least two Availability 3816 // Zones. You cannot specify Elastic IP addresses for your subnets. 3817 // 3818 // [Network Load Balancers] You can specify subnets from one or more Availability 3819 // Zones. You can specify one Elastic IP address per subnet. 3820 SubnetMappings []*SubnetMapping `type:"list"` 3821 3822 // The IDs of the public subnets. You can specify only one subnet per Availability 3823 // Zone. You must specify either subnets or subnet mappings. 3824 // 3825 // [Application Load Balancers] You must specify subnets from at least two Availability 3826 // Zones. 3827 // 3828 // [Network Load Balancers] You can specify subnets from one or more Availability 3829 // Zones. 3830 Subnets []*string `type:"list"` 3831 3832 // One or more tags to assign to the load balancer. 3833 Tags []*Tag `min:"1" type:"list"` 3834 3835 // The type of load balancer. The default is application. 3836 Type *string `type:"string" enum:"LoadBalancerTypeEnum"` 3837} 3838 3839// String returns the string representation 3840func (s CreateLoadBalancerInput) String() string { 3841 return awsutil.Prettify(s) 3842} 3843 3844// GoString returns the string representation 3845func (s CreateLoadBalancerInput) GoString() string { 3846 return s.String() 3847} 3848 3849// Validate inspects the fields of the type to determine if they are valid. 3850func (s *CreateLoadBalancerInput) Validate() error { 3851 invalidParams := request.ErrInvalidParams{Context: "CreateLoadBalancerInput"} 3852 if s.Name == nil { 3853 invalidParams.Add(request.NewErrParamRequired("Name")) 3854 } 3855 if s.Tags != nil && len(s.Tags) < 1 { 3856 invalidParams.Add(request.NewErrParamMinLen("Tags", 1)) 3857 } 3858 if s.Tags != nil { 3859 for i, v := range s.Tags { 3860 if v == nil { 3861 continue 3862 } 3863 if err := v.Validate(); err != nil { 3864 invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams)) 3865 } 3866 } 3867 } 3868 3869 if invalidParams.Len() > 0 { 3870 return invalidParams 3871 } 3872 return nil 3873} 3874 3875// SetIpAddressType sets the IpAddressType field's value. 3876func (s *CreateLoadBalancerInput) SetIpAddressType(v string) *CreateLoadBalancerInput { 3877 s.IpAddressType = &v 3878 return s 3879} 3880 3881// SetName sets the Name field's value. 3882func (s *CreateLoadBalancerInput) SetName(v string) *CreateLoadBalancerInput { 3883 s.Name = &v 3884 return s 3885} 3886 3887// SetScheme sets the Scheme field's value. 3888func (s *CreateLoadBalancerInput) SetScheme(v string) *CreateLoadBalancerInput { 3889 s.Scheme = &v 3890 return s 3891} 3892 3893// SetSecurityGroups sets the SecurityGroups field's value. 3894func (s *CreateLoadBalancerInput) SetSecurityGroups(v []*string) *CreateLoadBalancerInput { 3895 s.SecurityGroups = v 3896 return s 3897} 3898 3899// SetSubnetMappings sets the SubnetMappings field's value. 3900func (s *CreateLoadBalancerInput) SetSubnetMappings(v []*SubnetMapping) *CreateLoadBalancerInput { 3901 s.SubnetMappings = v 3902 return s 3903} 3904 3905// SetSubnets sets the Subnets field's value. 3906func (s *CreateLoadBalancerInput) SetSubnets(v []*string) *CreateLoadBalancerInput { 3907 s.Subnets = v 3908 return s 3909} 3910 3911// SetTags sets the Tags field's value. 3912func (s *CreateLoadBalancerInput) SetTags(v []*Tag) *CreateLoadBalancerInput { 3913 s.Tags = v 3914 return s 3915} 3916 3917// SetType sets the Type field's value. 3918func (s *CreateLoadBalancerInput) SetType(v string) *CreateLoadBalancerInput { 3919 s.Type = &v 3920 return s 3921} 3922 3923type CreateLoadBalancerOutput struct { 3924 _ struct{} `type:"structure"` 3925 3926 // Information about the load balancer. 3927 LoadBalancers []*LoadBalancer `type:"list"` 3928} 3929 3930// String returns the string representation 3931func (s CreateLoadBalancerOutput) String() string { 3932 return awsutil.Prettify(s) 3933} 3934 3935// GoString returns the string representation 3936func (s CreateLoadBalancerOutput) GoString() string { 3937 return s.String() 3938} 3939 3940// SetLoadBalancers sets the LoadBalancers field's value. 3941func (s *CreateLoadBalancerOutput) SetLoadBalancers(v []*LoadBalancer) *CreateLoadBalancerOutput { 3942 s.LoadBalancers = v 3943 return s 3944} 3945 3946type CreateRuleInput struct { 3947 _ struct{} `type:"structure"` 3948 3949 // An action. Each action has the type forward and specifies a target group. 3950 // 3951 // Actions is a required field 3952 Actions []*Action `type:"list" required:"true"` 3953 3954 // The conditions. Each condition specifies a field name and a single value. 3955 // 3956 // If the field name is host-header, you can specify a single host name (for 3957 // example, my.example.com). A host name is case insensitive, can be up to 128 3958 // characters in length, and can contain any of the following characters. Note 3959 // that you can include up to three wildcard characters. 3960 // 3961 // * A-Z, a-z, 0-9 3962 // 3963 // * - . 3964 // 3965 // * * (matches 0 or more characters) 3966 // 3967 // * ? (matches exactly 1 character) 3968 // 3969 // If the field name is path-pattern, you can specify a single path pattern. 3970 // A path pattern is case sensitive, can be up to 128 characters in length, 3971 // and can contain any of the following characters. Note that you can include 3972 // up to three wildcard characters. 3973 // 3974 // * A-Z, a-z, 0-9 3975 // 3976 // * _ - . $ / ~ " ' @ : + 3977 // 3978 // * & (using &) 3979 // 3980 // * * (matches 0 or more characters) 3981 // 3982 // * ? (matches exactly 1 character) 3983 // 3984 // Conditions is a required field 3985 Conditions []*RuleCondition `type:"list" required:"true"` 3986 3987 // The Amazon Resource Name (ARN) of the listener. 3988 // 3989 // ListenerArn is a required field 3990 ListenerArn *string `type:"string" required:"true"` 3991 3992 // The priority for the rule. A listener can't have multiple rules with the 3993 // same priority. 3994 // 3995 // Priority is a required field 3996 Priority *int64 `min:"1" type:"integer" required:"true"` 3997} 3998 3999// String returns the string representation 4000func (s CreateRuleInput) String() string { 4001 return awsutil.Prettify(s) 4002} 4003 4004// GoString returns the string representation 4005func (s CreateRuleInput) GoString() string { 4006 return s.String() 4007} 4008 4009// Validate inspects the fields of the type to determine if they are valid. 4010func (s *CreateRuleInput) Validate() error { 4011 invalidParams := request.ErrInvalidParams{Context: "CreateRuleInput"} 4012 if s.Actions == nil { 4013 invalidParams.Add(request.NewErrParamRequired("Actions")) 4014 } 4015 if s.Conditions == nil { 4016 invalidParams.Add(request.NewErrParamRequired("Conditions")) 4017 } 4018 if s.ListenerArn == nil { 4019 invalidParams.Add(request.NewErrParamRequired("ListenerArn")) 4020 } 4021 if s.Priority == nil { 4022 invalidParams.Add(request.NewErrParamRequired("Priority")) 4023 } 4024 if s.Priority != nil && *s.Priority < 1 { 4025 invalidParams.Add(request.NewErrParamMinValue("Priority", 1)) 4026 } 4027 if s.Actions != nil { 4028 for i, v := range s.Actions { 4029 if v == nil { 4030 continue 4031 } 4032 if err := v.Validate(); err != nil { 4033 invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Actions", i), err.(request.ErrInvalidParams)) 4034 } 4035 } 4036 } 4037 4038 if invalidParams.Len() > 0 { 4039 return invalidParams 4040 } 4041 return nil 4042} 4043 4044// SetActions sets the Actions field's value. 4045func (s *CreateRuleInput) SetActions(v []*Action) *CreateRuleInput { 4046 s.Actions = v 4047 return s 4048} 4049 4050// SetConditions sets the Conditions field's value. 4051func (s *CreateRuleInput) SetConditions(v []*RuleCondition) *CreateRuleInput { 4052 s.Conditions = v 4053 return s 4054} 4055 4056// SetListenerArn sets the ListenerArn field's value. 4057func (s *CreateRuleInput) SetListenerArn(v string) *CreateRuleInput { 4058 s.ListenerArn = &v 4059 return s 4060} 4061 4062// SetPriority sets the Priority field's value. 4063func (s *CreateRuleInput) SetPriority(v int64) *CreateRuleInput { 4064 s.Priority = &v 4065 return s 4066} 4067 4068type CreateRuleOutput struct { 4069 _ struct{} `type:"structure"` 4070 4071 // Information about the rule. 4072 Rules []*Rule `type:"list"` 4073} 4074 4075// String returns the string representation 4076func (s CreateRuleOutput) String() string { 4077 return awsutil.Prettify(s) 4078} 4079 4080// GoString returns the string representation 4081func (s CreateRuleOutput) GoString() string { 4082 return s.String() 4083} 4084 4085// SetRules sets the Rules field's value. 4086func (s *CreateRuleOutput) SetRules(v []*Rule) *CreateRuleOutput { 4087 s.Rules = v 4088 return s 4089} 4090 4091type CreateTargetGroupInput struct { 4092 _ struct{} `type:"structure"` 4093 4094 // The approximate amount of time, in seconds, between health checks of an individual 4095 // target. For Application Load Balancers, the range is 5 to 300 seconds. For 4096 // Network Load Balancers, the supported values are 10 or 30 seconds. The default 4097 // is 30 seconds. 4098 HealthCheckIntervalSeconds *int64 `min:"5" type:"integer"` 4099 4100 // [HTTP/HTTPS health checks] The ping path that is the destination on the targets 4101 // for health checks. The default is /. 4102 HealthCheckPath *string `min:"1" type:"string"` 4103 4104 // The port the load balancer uses when performing health checks on targets. 4105 // The default is traffic-port, which is the port on which each target receives 4106 // traffic from the load balancer. 4107 HealthCheckPort *string `type:"string"` 4108 4109 // The protocol the load balancer uses when performing health checks on targets. 4110 // The TCP protocol is supported only if the protocol of the target group is 4111 // TCP. For Application Load Balancers, the default is HTTP. For Network Load 4112 // Balancers, the default is TCP. 4113 HealthCheckProtocol *string `type:"string" enum:"ProtocolEnum"` 4114 4115 // The amount of time, in seconds, during which no response from a target means 4116 // a failed health check. For Application Load Balancers, the range is 2 to 4117 // 60 seconds and the default is 5 seconds. For Network Load Balancers, this 4118 // is 10 seconds for TCP and HTTPS health checks and 6 seconds for HTTP health 4119 // checks. 4120 HealthCheckTimeoutSeconds *int64 `min:"2" type:"integer"` 4121 4122 // The number of consecutive health checks successes required before considering 4123 // an unhealthy target healthy. For Application Load Balancers, the default 4124 // is 5. For Network Load Balancers, the default is 3. 4125 HealthyThresholdCount *int64 `min:"2" type:"integer"` 4126 4127 // [HTTP/HTTPS health checks] The HTTP codes to use when checking for a successful 4128 // response from a target. 4129 Matcher *Matcher `type:"structure"` 4130 4131 // The name of the target group. 4132 // 4133 // This name must be unique per region per account, can have a maximum of 32 4134 // characters, must contain only alphanumeric characters or hyphens, and must 4135 // not begin or end with a hyphen. 4136 // 4137 // Name is a required field 4138 Name *string `type:"string" required:"true"` 4139 4140 // The port on which the targets receive traffic. This port is used unless you 4141 // specify a port override when registering the target. 4142 // 4143 // Port is a required field 4144 Port *int64 `min:"1" type:"integer" required:"true"` 4145 4146 // The protocol to use for routing traffic to the targets. For Application Load 4147 // Balancers, the supported protocols are HTTP and HTTPS. For Network Load Balancers, 4148 // the supported protocol is TCP. 4149 // 4150 // Protocol is a required field 4151 Protocol *string `type:"string" required:"true" enum:"ProtocolEnum"` 4152 4153 // The type of target that you must specify when registering targets with this 4154 // target group. The possible values are instance (targets are specified by 4155 // instance ID) or ip (targets are specified by IP address). The default is 4156 // instance. Note that you can't specify targets for a target group using both 4157 // instance IDs and IP addresses. 4158 // 4159 // If the target type is ip, specify IP addresses from the subnets of the virtual 4160 // private cloud (VPC) for the target group, the RFC 1918 range (10.0.0.0/8, 4161 // 172.16.0.0/12, and 192.168.0.0/16), and the RFC 6598 range (100.64.0.0/10). 4162 // You can't specify publicly routable IP addresses. 4163 TargetType *string `type:"string" enum:"TargetTypeEnum"` 4164 4165 // The number of consecutive health check failures required before considering 4166 // a target unhealthy. For Application Load Balancers, the default is 2. For 4167 // Network Load Balancers, this value must be the same as the healthy threshold 4168 // count. 4169 UnhealthyThresholdCount *int64 `min:"2" type:"integer"` 4170 4171 // The identifier of the virtual private cloud (VPC). 4172 // 4173 // VpcId is a required field 4174 VpcId *string `type:"string" required:"true"` 4175} 4176 4177// String returns the string representation 4178func (s CreateTargetGroupInput) String() string { 4179 return awsutil.Prettify(s) 4180} 4181 4182// GoString returns the string representation 4183func (s CreateTargetGroupInput) GoString() string { 4184 return s.String() 4185} 4186 4187// Validate inspects the fields of the type to determine if they are valid. 4188func (s *CreateTargetGroupInput) Validate() error { 4189 invalidParams := request.ErrInvalidParams{Context: "CreateTargetGroupInput"} 4190 if s.HealthCheckIntervalSeconds != nil && *s.HealthCheckIntervalSeconds < 5 { 4191 invalidParams.Add(request.NewErrParamMinValue("HealthCheckIntervalSeconds", 5)) 4192 } 4193 if s.HealthCheckPath != nil && len(*s.HealthCheckPath) < 1 { 4194 invalidParams.Add(request.NewErrParamMinLen("HealthCheckPath", 1)) 4195 } 4196 if s.HealthCheckTimeoutSeconds != nil && *s.HealthCheckTimeoutSeconds < 2 { 4197 invalidParams.Add(request.NewErrParamMinValue("HealthCheckTimeoutSeconds", 2)) 4198 } 4199 if s.HealthyThresholdCount != nil && *s.HealthyThresholdCount < 2 { 4200 invalidParams.Add(request.NewErrParamMinValue("HealthyThresholdCount", 2)) 4201 } 4202 if s.Name == nil { 4203 invalidParams.Add(request.NewErrParamRequired("Name")) 4204 } 4205 if s.Port == nil { 4206 invalidParams.Add(request.NewErrParamRequired("Port")) 4207 } 4208 if s.Port != nil && *s.Port < 1 { 4209 invalidParams.Add(request.NewErrParamMinValue("Port", 1)) 4210 } 4211 if s.Protocol == nil { 4212 invalidParams.Add(request.NewErrParamRequired("Protocol")) 4213 } 4214 if s.UnhealthyThresholdCount != nil && *s.UnhealthyThresholdCount < 2 { 4215 invalidParams.Add(request.NewErrParamMinValue("UnhealthyThresholdCount", 2)) 4216 } 4217 if s.VpcId == nil { 4218 invalidParams.Add(request.NewErrParamRequired("VpcId")) 4219 } 4220 if s.Matcher != nil { 4221 if err := s.Matcher.Validate(); err != nil { 4222 invalidParams.AddNested("Matcher", err.(request.ErrInvalidParams)) 4223 } 4224 } 4225 4226 if invalidParams.Len() > 0 { 4227 return invalidParams 4228 } 4229 return nil 4230} 4231 4232// SetHealthCheckIntervalSeconds sets the HealthCheckIntervalSeconds field's value. 4233func (s *CreateTargetGroupInput) SetHealthCheckIntervalSeconds(v int64) *CreateTargetGroupInput { 4234 s.HealthCheckIntervalSeconds = &v 4235 return s 4236} 4237 4238// SetHealthCheckPath sets the HealthCheckPath field's value. 4239func (s *CreateTargetGroupInput) SetHealthCheckPath(v string) *CreateTargetGroupInput { 4240 s.HealthCheckPath = &v 4241 return s 4242} 4243 4244// SetHealthCheckPort sets the HealthCheckPort field's value. 4245func (s *CreateTargetGroupInput) SetHealthCheckPort(v string) *CreateTargetGroupInput { 4246 s.HealthCheckPort = &v 4247 return s 4248} 4249 4250// SetHealthCheckProtocol sets the HealthCheckProtocol field's value. 4251func (s *CreateTargetGroupInput) SetHealthCheckProtocol(v string) *CreateTargetGroupInput { 4252 s.HealthCheckProtocol = &v 4253 return s 4254} 4255 4256// SetHealthCheckTimeoutSeconds sets the HealthCheckTimeoutSeconds field's value. 4257func (s *CreateTargetGroupInput) SetHealthCheckTimeoutSeconds(v int64) *CreateTargetGroupInput { 4258 s.HealthCheckTimeoutSeconds = &v 4259 return s 4260} 4261 4262// SetHealthyThresholdCount sets the HealthyThresholdCount field's value. 4263func (s *CreateTargetGroupInput) SetHealthyThresholdCount(v int64) *CreateTargetGroupInput { 4264 s.HealthyThresholdCount = &v 4265 return s 4266} 4267 4268// SetMatcher sets the Matcher field's value. 4269func (s *CreateTargetGroupInput) SetMatcher(v *Matcher) *CreateTargetGroupInput { 4270 s.Matcher = v 4271 return s 4272} 4273 4274// SetName sets the Name field's value. 4275func (s *CreateTargetGroupInput) SetName(v string) *CreateTargetGroupInput { 4276 s.Name = &v 4277 return s 4278} 4279 4280// SetPort sets the Port field's value. 4281func (s *CreateTargetGroupInput) SetPort(v int64) *CreateTargetGroupInput { 4282 s.Port = &v 4283 return s 4284} 4285 4286// SetProtocol sets the Protocol field's value. 4287func (s *CreateTargetGroupInput) SetProtocol(v string) *CreateTargetGroupInput { 4288 s.Protocol = &v 4289 return s 4290} 4291 4292// SetTargetType sets the TargetType field's value. 4293func (s *CreateTargetGroupInput) SetTargetType(v string) *CreateTargetGroupInput { 4294 s.TargetType = &v 4295 return s 4296} 4297 4298// SetUnhealthyThresholdCount sets the UnhealthyThresholdCount field's value. 4299func (s *CreateTargetGroupInput) SetUnhealthyThresholdCount(v int64) *CreateTargetGroupInput { 4300 s.UnhealthyThresholdCount = &v 4301 return s 4302} 4303 4304// SetVpcId sets the VpcId field's value. 4305func (s *CreateTargetGroupInput) SetVpcId(v string) *CreateTargetGroupInput { 4306 s.VpcId = &v 4307 return s 4308} 4309 4310type CreateTargetGroupOutput struct { 4311 _ struct{} `type:"structure"` 4312 4313 // Information about the target group. 4314 TargetGroups []*TargetGroup `type:"list"` 4315} 4316 4317// String returns the string representation 4318func (s CreateTargetGroupOutput) String() string { 4319 return awsutil.Prettify(s) 4320} 4321 4322// GoString returns the string representation 4323func (s CreateTargetGroupOutput) GoString() string { 4324 return s.String() 4325} 4326 4327// SetTargetGroups sets the TargetGroups field's value. 4328func (s *CreateTargetGroupOutput) SetTargetGroups(v []*TargetGroup) *CreateTargetGroupOutput { 4329 s.TargetGroups = v 4330 return s 4331} 4332 4333type DeleteListenerInput struct { 4334 _ struct{} `type:"structure"` 4335 4336 // The Amazon Resource Name (ARN) of the listener. 4337 // 4338 // ListenerArn is a required field 4339 ListenerArn *string `type:"string" required:"true"` 4340} 4341 4342// String returns the string representation 4343func (s DeleteListenerInput) String() string { 4344 return awsutil.Prettify(s) 4345} 4346 4347// GoString returns the string representation 4348func (s DeleteListenerInput) GoString() string { 4349 return s.String() 4350} 4351 4352// Validate inspects the fields of the type to determine if they are valid. 4353func (s *DeleteListenerInput) Validate() error { 4354 invalidParams := request.ErrInvalidParams{Context: "DeleteListenerInput"} 4355 if s.ListenerArn == nil { 4356 invalidParams.Add(request.NewErrParamRequired("ListenerArn")) 4357 } 4358 4359 if invalidParams.Len() > 0 { 4360 return invalidParams 4361 } 4362 return nil 4363} 4364 4365// SetListenerArn sets the ListenerArn field's value. 4366func (s *DeleteListenerInput) SetListenerArn(v string) *DeleteListenerInput { 4367 s.ListenerArn = &v 4368 return s 4369} 4370 4371type DeleteListenerOutput struct { 4372 _ struct{} `type:"structure"` 4373} 4374 4375// String returns the string representation 4376func (s DeleteListenerOutput) String() string { 4377 return awsutil.Prettify(s) 4378} 4379 4380// GoString returns the string representation 4381func (s DeleteListenerOutput) GoString() string { 4382 return s.String() 4383} 4384 4385type DeleteLoadBalancerInput struct { 4386 _ struct{} `type:"structure"` 4387 4388 // The Amazon Resource Name (ARN) of the load balancer. 4389 // 4390 // LoadBalancerArn is a required field 4391 LoadBalancerArn *string `type:"string" required:"true"` 4392} 4393 4394// String returns the string representation 4395func (s DeleteLoadBalancerInput) String() string { 4396 return awsutil.Prettify(s) 4397} 4398 4399// GoString returns the string representation 4400func (s DeleteLoadBalancerInput) GoString() string { 4401 return s.String() 4402} 4403 4404// Validate inspects the fields of the type to determine if they are valid. 4405func (s *DeleteLoadBalancerInput) Validate() error { 4406 invalidParams := request.ErrInvalidParams{Context: "DeleteLoadBalancerInput"} 4407 if s.LoadBalancerArn == nil { 4408 invalidParams.Add(request.NewErrParamRequired("LoadBalancerArn")) 4409 } 4410 4411 if invalidParams.Len() > 0 { 4412 return invalidParams 4413 } 4414 return nil 4415} 4416 4417// SetLoadBalancerArn sets the LoadBalancerArn field's value. 4418func (s *DeleteLoadBalancerInput) SetLoadBalancerArn(v string) *DeleteLoadBalancerInput { 4419 s.LoadBalancerArn = &v 4420 return s 4421} 4422 4423type DeleteLoadBalancerOutput struct { 4424 _ struct{} `type:"structure"` 4425} 4426 4427// String returns the string representation 4428func (s DeleteLoadBalancerOutput) String() string { 4429 return awsutil.Prettify(s) 4430} 4431 4432// GoString returns the string representation 4433func (s DeleteLoadBalancerOutput) GoString() string { 4434 return s.String() 4435} 4436 4437type DeleteRuleInput struct { 4438 _ struct{} `type:"structure"` 4439 4440 // The Amazon Resource Name (ARN) of the rule. 4441 // 4442 // RuleArn is a required field 4443 RuleArn *string `type:"string" required:"true"` 4444} 4445 4446// String returns the string representation 4447func (s DeleteRuleInput) String() string { 4448 return awsutil.Prettify(s) 4449} 4450 4451// GoString returns the string representation 4452func (s DeleteRuleInput) GoString() string { 4453 return s.String() 4454} 4455 4456// Validate inspects the fields of the type to determine if they are valid. 4457func (s *DeleteRuleInput) Validate() error { 4458 invalidParams := request.ErrInvalidParams{Context: "DeleteRuleInput"} 4459 if s.RuleArn == nil { 4460 invalidParams.Add(request.NewErrParamRequired("RuleArn")) 4461 } 4462 4463 if invalidParams.Len() > 0 { 4464 return invalidParams 4465 } 4466 return nil 4467} 4468 4469// SetRuleArn sets the RuleArn field's value. 4470func (s *DeleteRuleInput) SetRuleArn(v string) *DeleteRuleInput { 4471 s.RuleArn = &v 4472 return s 4473} 4474 4475type DeleteRuleOutput struct { 4476 _ struct{} `type:"structure"` 4477} 4478 4479// String returns the string representation 4480func (s DeleteRuleOutput) String() string { 4481 return awsutil.Prettify(s) 4482} 4483 4484// GoString returns the string representation 4485func (s DeleteRuleOutput) GoString() string { 4486 return s.String() 4487} 4488 4489type DeleteTargetGroupInput struct { 4490 _ struct{} `type:"structure"` 4491 4492 // The Amazon Resource Name (ARN) of the target group. 4493 // 4494 // TargetGroupArn is a required field 4495 TargetGroupArn *string `type:"string" required:"true"` 4496} 4497 4498// String returns the string representation 4499func (s DeleteTargetGroupInput) String() string { 4500 return awsutil.Prettify(s) 4501} 4502 4503// GoString returns the string representation 4504func (s DeleteTargetGroupInput) GoString() string { 4505 return s.String() 4506} 4507 4508// Validate inspects the fields of the type to determine if they are valid. 4509func (s *DeleteTargetGroupInput) Validate() error { 4510 invalidParams := request.ErrInvalidParams{Context: "DeleteTargetGroupInput"} 4511 if s.TargetGroupArn == nil { 4512 invalidParams.Add(request.NewErrParamRequired("TargetGroupArn")) 4513 } 4514 4515 if invalidParams.Len() > 0 { 4516 return invalidParams 4517 } 4518 return nil 4519} 4520 4521// SetTargetGroupArn sets the TargetGroupArn field's value. 4522func (s *DeleteTargetGroupInput) SetTargetGroupArn(v string) *DeleteTargetGroupInput { 4523 s.TargetGroupArn = &v 4524 return s 4525} 4526 4527type DeleteTargetGroupOutput struct { 4528 _ struct{} `type:"structure"` 4529} 4530 4531// String returns the string representation 4532func (s DeleteTargetGroupOutput) String() string { 4533 return awsutil.Prettify(s) 4534} 4535 4536// GoString returns the string representation 4537func (s DeleteTargetGroupOutput) GoString() string { 4538 return s.String() 4539} 4540 4541type DeregisterTargetsInput struct { 4542 _ struct{} `type:"structure"` 4543 4544 // The Amazon Resource Name (ARN) of the target group. 4545 // 4546 // TargetGroupArn is a required field 4547 TargetGroupArn *string `type:"string" required:"true"` 4548 4549 // The targets. If you specified a port override when you registered a target, 4550 // you must specify both the target ID and the port when you deregister it. 4551 // 4552 // Targets is a required field 4553 Targets []*TargetDescription `type:"list" required:"true"` 4554} 4555 4556// String returns the string representation 4557func (s DeregisterTargetsInput) String() string { 4558 return awsutil.Prettify(s) 4559} 4560 4561// GoString returns the string representation 4562func (s DeregisterTargetsInput) GoString() string { 4563 return s.String() 4564} 4565 4566// Validate inspects the fields of the type to determine if they are valid. 4567func (s *DeregisterTargetsInput) Validate() error { 4568 invalidParams := request.ErrInvalidParams{Context: "DeregisterTargetsInput"} 4569 if s.TargetGroupArn == nil { 4570 invalidParams.Add(request.NewErrParamRequired("TargetGroupArn")) 4571 } 4572 if s.Targets == nil { 4573 invalidParams.Add(request.NewErrParamRequired("Targets")) 4574 } 4575 if s.Targets != nil { 4576 for i, v := range s.Targets { 4577 if v == nil { 4578 continue 4579 } 4580 if err := v.Validate(); err != nil { 4581 invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Targets", i), err.(request.ErrInvalidParams)) 4582 } 4583 } 4584 } 4585 4586 if invalidParams.Len() > 0 { 4587 return invalidParams 4588 } 4589 return nil 4590} 4591 4592// SetTargetGroupArn sets the TargetGroupArn field's value. 4593func (s *DeregisterTargetsInput) SetTargetGroupArn(v string) *DeregisterTargetsInput { 4594 s.TargetGroupArn = &v 4595 return s 4596} 4597 4598// SetTargets sets the Targets field's value. 4599func (s *DeregisterTargetsInput) SetTargets(v []*TargetDescription) *DeregisterTargetsInput { 4600 s.Targets = v 4601 return s 4602} 4603 4604type DeregisterTargetsOutput struct { 4605 _ struct{} `type:"structure"` 4606} 4607 4608// String returns the string representation 4609func (s DeregisterTargetsOutput) String() string { 4610 return awsutil.Prettify(s) 4611} 4612 4613// GoString returns the string representation 4614func (s DeregisterTargetsOutput) GoString() string { 4615 return s.String() 4616} 4617 4618type DescribeAccountLimitsInput struct { 4619 _ struct{} `type:"structure"` 4620 4621 // The marker for the next set of results. (You received this marker from a 4622 // previous call.) 4623 Marker *string `type:"string"` 4624 4625 // The maximum number of results to return with this call. 4626 PageSize *int64 `min:"1" type:"integer"` 4627} 4628 4629// String returns the string representation 4630func (s DescribeAccountLimitsInput) String() string { 4631 return awsutil.Prettify(s) 4632} 4633 4634// GoString returns the string representation 4635func (s DescribeAccountLimitsInput) GoString() string { 4636 return s.String() 4637} 4638 4639// Validate inspects the fields of the type to determine if they are valid. 4640func (s *DescribeAccountLimitsInput) Validate() error { 4641 invalidParams := request.ErrInvalidParams{Context: "DescribeAccountLimitsInput"} 4642 if s.PageSize != nil && *s.PageSize < 1 { 4643 invalidParams.Add(request.NewErrParamMinValue("PageSize", 1)) 4644 } 4645 4646 if invalidParams.Len() > 0 { 4647 return invalidParams 4648 } 4649 return nil 4650} 4651 4652// SetMarker sets the Marker field's value. 4653func (s *DescribeAccountLimitsInput) SetMarker(v string) *DescribeAccountLimitsInput { 4654 s.Marker = &v 4655 return s 4656} 4657 4658// SetPageSize sets the PageSize field's value. 4659func (s *DescribeAccountLimitsInput) SetPageSize(v int64) *DescribeAccountLimitsInput { 4660 s.PageSize = &v 4661 return s 4662} 4663 4664type DescribeAccountLimitsOutput struct { 4665 _ struct{} `type:"structure"` 4666 4667 // Information about the limits. 4668 Limits []*Limit `type:"list"` 4669 4670 // The marker to use when requesting the next set of results. If there are no 4671 // additional results, the string is empty. 4672 NextMarker *string `type:"string"` 4673} 4674 4675// String returns the string representation 4676func (s DescribeAccountLimitsOutput) String() string { 4677 return awsutil.Prettify(s) 4678} 4679 4680// GoString returns the string representation 4681func (s DescribeAccountLimitsOutput) GoString() string { 4682 return s.String() 4683} 4684 4685// SetLimits sets the Limits field's value. 4686func (s *DescribeAccountLimitsOutput) SetLimits(v []*Limit) *DescribeAccountLimitsOutput { 4687 s.Limits = v 4688 return s 4689} 4690 4691// SetNextMarker sets the NextMarker field's value. 4692func (s *DescribeAccountLimitsOutput) SetNextMarker(v string) *DescribeAccountLimitsOutput { 4693 s.NextMarker = &v 4694 return s 4695} 4696 4697type DescribeListenerCertificatesInput struct { 4698 _ struct{} `type:"structure"` 4699 4700 // The Amazon Resource Names (ARN) of the listener. 4701 // 4702 // ListenerArn is a required field 4703 ListenerArn *string `type:"string" required:"true"` 4704 4705 // The marker for the next set of results. (You received this marker from a 4706 // previous call.) 4707 Marker *string `type:"string"` 4708 4709 // The maximum number of results to return with this call. 4710 PageSize *int64 `min:"1" type:"integer"` 4711} 4712 4713// String returns the string representation 4714func (s DescribeListenerCertificatesInput) String() string { 4715 return awsutil.Prettify(s) 4716} 4717 4718// GoString returns the string representation 4719func (s DescribeListenerCertificatesInput) GoString() string { 4720 return s.String() 4721} 4722 4723// Validate inspects the fields of the type to determine if they are valid. 4724func (s *DescribeListenerCertificatesInput) Validate() error { 4725 invalidParams := request.ErrInvalidParams{Context: "DescribeListenerCertificatesInput"} 4726 if s.ListenerArn == nil { 4727 invalidParams.Add(request.NewErrParamRequired("ListenerArn")) 4728 } 4729 if s.PageSize != nil && *s.PageSize < 1 { 4730 invalidParams.Add(request.NewErrParamMinValue("PageSize", 1)) 4731 } 4732 4733 if invalidParams.Len() > 0 { 4734 return invalidParams 4735 } 4736 return nil 4737} 4738 4739// SetListenerArn sets the ListenerArn field's value. 4740func (s *DescribeListenerCertificatesInput) SetListenerArn(v string) *DescribeListenerCertificatesInput { 4741 s.ListenerArn = &v 4742 return s 4743} 4744 4745// SetMarker sets the Marker field's value. 4746func (s *DescribeListenerCertificatesInput) SetMarker(v string) *DescribeListenerCertificatesInput { 4747 s.Marker = &v 4748 return s 4749} 4750 4751// SetPageSize sets the PageSize field's value. 4752func (s *DescribeListenerCertificatesInput) SetPageSize(v int64) *DescribeListenerCertificatesInput { 4753 s.PageSize = &v 4754 return s 4755} 4756 4757type DescribeListenerCertificatesOutput struct { 4758 _ struct{} `type:"structure"` 4759 4760 // Information about the certificates. 4761 Certificates []*Certificate `type:"list"` 4762 4763 // The marker to use when requesting the next set of results. If there are no 4764 // additional results, the string is empty. 4765 NextMarker *string `type:"string"` 4766} 4767 4768// String returns the string representation 4769func (s DescribeListenerCertificatesOutput) String() string { 4770 return awsutil.Prettify(s) 4771} 4772 4773// GoString returns the string representation 4774func (s DescribeListenerCertificatesOutput) GoString() string { 4775 return s.String() 4776} 4777 4778// SetCertificates sets the Certificates field's value. 4779func (s *DescribeListenerCertificatesOutput) SetCertificates(v []*Certificate) *DescribeListenerCertificatesOutput { 4780 s.Certificates = v 4781 return s 4782} 4783 4784// SetNextMarker sets the NextMarker field's value. 4785func (s *DescribeListenerCertificatesOutput) SetNextMarker(v string) *DescribeListenerCertificatesOutput { 4786 s.NextMarker = &v 4787 return s 4788} 4789 4790type DescribeListenersInput struct { 4791 _ struct{} `type:"structure"` 4792 4793 // The Amazon Resource Names (ARN) of the listeners. 4794 ListenerArns []*string `type:"list"` 4795 4796 // The Amazon Resource Name (ARN) of the load balancer. 4797 LoadBalancerArn *string `type:"string"` 4798 4799 // The marker for the next set of results. (You received this marker from a 4800 // previous call.) 4801 Marker *string `type:"string"` 4802 4803 // The maximum number of results to return with this call. 4804 PageSize *int64 `min:"1" type:"integer"` 4805} 4806 4807// String returns the string representation 4808func (s DescribeListenersInput) String() string { 4809 return awsutil.Prettify(s) 4810} 4811 4812// GoString returns the string representation 4813func (s DescribeListenersInput) GoString() string { 4814 return s.String() 4815} 4816 4817// Validate inspects the fields of the type to determine if they are valid. 4818func (s *DescribeListenersInput) Validate() error { 4819 invalidParams := request.ErrInvalidParams{Context: "DescribeListenersInput"} 4820 if s.PageSize != nil && *s.PageSize < 1 { 4821 invalidParams.Add(request.NewErrParamMinValue("PageSize", 1)) 4822 } 4823 4824 if invalidParams.Len() > 0 { 4825 return invalidParams 4826 } 4827 return nil 4828} 4829 4830// SetListenerArns sets the ListenerArns field's value. 4831func (s *DescribeListenersInput) SetListenerArns(v []*string) *DescribeListenersInput { 4832 s.ListenerArns = v 4833 return s 4834} 4835 4836// SetLoadBalancerArn sets the LoadBalancerArn field's value. 4837func (s *DescribeListenersInput) SetLoadBalancerArn(v string) *DescribeListenersInput { 4838 s.LoadBalancerArn = &v 4839 return s 4840} 4841 4842// SetMarker sets the Marker field's value. 4843func (s *DescribeListenersInput) SetMarker(v string) *DescribeListenersInput { 4844 s.Marker = &v 4845 return s 4846} 4847 4848// SetPageSize sets the PageSize field's value. 4849func (s *DescribeListenersInput) SetPageSize(v int64) *DescribeListenersInput { 4850 s.PageSize = &v 4851 return s 4852} 4853 4854type DescribeListenersOutput struct { 4855 _ struct{} `type:"structure"` 4856 4857 // Information about the listeners. 4858 Listeners []*Listener `type:"list"` 4859 4860 // The marker to use when requesting the next set of results. If there are no 4861 // additional results, the string is empty. 4862 NextMarker *string `type:"string"` 4863} 4864 4865// String returns the string representation 4866func (s DescribeListenersOutput) String() string { 4867 return awsutil.Prettify(s) 4868} 4869 4870// GoString returns the string representation 4871func (s DescribeListenersOutput) GoString() string { 4872 return s.String() 4873} 4874 4875// SetListeners sets the Listeners field's value. 4876func (s *DescribeListenersOutput) SetListeners(v []*Listener) *DescribeListenersOutput { 4877 s.Listeners = v 4878 return s 4879} 4880 4881// SetNextMarker sets the NextMarker field's value. 4882func (s *DescribeListenersOutput) SetNextMarker(v string) *DescribeListenersOutput { 4883 s.NextMarker = &v 4884 return s 4885} 4886 4887type DescribeLoadBalancerAttributesInput struct { 4888 _ struct{} `type:"structure"` 4889 4890 // The Amazon Resource Name (ARN) of the load balancer. 4891 // 4892 // LoadBalancerArn is a required field 4893 LoadBalancerArn *string `type:"string" required:"true"` 4894} 4895 4896// String returns the string representation 4897func (s DescribeLoadBalancerAttributesInput) String() string { 4898 return awsutil.Prettify(s) 4899} 4900 4901// GoString returns the string representation 4902func (s DescribeLoadBalancerAttributesInput) GoString() string { 4903 return s.String() 4904} 4905 4906// Validate inspects the fields of the type to determine if they are valid. 4907func (s *DescribeLoadBalancerAttributesInput) Validate() error { 4908 invalidParams := request.ErrInvalidParams{Context: "DescribeLoadBalancerAttributesInput"} 4909 if s.LoadBalancerArn == nil { 4910 invalidParams.Add(request.NewErrParamRequired("LoadBalancerArn")) 4911 } 4912 4913 if invalidParams.Len() > 0 { 4914 return invalidParams 4915 } 4916 return nil 4917} 4918 4919// SetLoadBalancerArn sets the LoadBalancerArn field's value. 4920func (s *DescribeLoadBalancerAttributesInput) SetLoadBalancerArn(v string) *DescribeLoadBalancerAttributesInput { 4921 s.LoadBalancerArn = &v 4922 return s 4923} 4924 4925type DescribeLoadBalancerAttributesOutput struct { 4926 _ struct{} `type:"structure"` 4927 4928 // Information about the load balancer attributes. 4929 Attributes []*LoadBalancerAttribute `type:"list"` 4930} 4931 4932// String returns the string representation 4933func (s DescribeLoadBalancerAttributesOutput) String() string { 4934 return awsutil.Prettify(s) 4935} 4936 4937// GoString returns the string representation 4938func (s DescribeLoadBalancerAttributesOutput) GoString() string { 4939 return s.String() 4940} 4941 4942// SetAttributes sets the Attributes field's value. 4943func (s *DescribeLoadBalancerAttributesOutput) SetAttributes(v []*LoadBalancerAttribute) *DescribeLoadBalancerAttributesOutput { 4944 s.Attributes = v 4945 return s 4946} 4947 4948type DescribeLoadBalancersInput struct { 4949 _ struct{} `type:"structure"` 4950 4951 // The Amazon Resource Names (ARN) of the load balancers. You can specify up 4952 // to 20 load balancers in a single call. 4953 LoadBalancerArns []*string `type:"list"` 4954 4955 // The marker for the next set of results. (You received this marker from a 4956 // previous call.) 4957 Marker *string `type:"string"` 4958 4959 // The names of the load balancers. 4960 Names []*string `type:"list"` 4961 4962 // The maximum number of results to return with this call. 4963 PageSize *int64 `min:"1" type:"integer"` 4964} 4965 4966// String returns the string representation 4967func (s DescribeLoadBalancersInput) String() string { 4968 return awsutil.Prettify(s) 4969} 4970 4971// GoString returns the string representation 4972func (s DescribeLoadBalancersInput) GoString() string { 4973 return s.String() 4974} 4975 4976// Validate inspects the fields of the type to determine if they are valid. 4977func (s *DescribeLoadBalancersInput) Validate() error { 4978 invalidParams := request.ErrInvalidParams{Context: "DescribeLoadBalancersInput"} 4979 if s.PageSize != nil && *s.PageSize < 1 { 4980 invalidParams.Add(request.NewErrParamMinValue("PageSize", 1)) 4981 } 4982 4983 if invalidParams.Len() > 0 { 4984 return invalidParams 4985 } 4986 return nil 4987} 4988 4989// SetLoadBalancerArns sets the LoadBalancerArns field's value. 4990func (s *DescribeLoadBalancersInput) SetLoadBalancerArns(v []*string) *DescribeLoadBalancersInput { 4991 s.LoadBalancerArns = v 4992 return s 4993} 4994 4995// SetMarker sets the Marker field's value. 4996func (s *DescribeLoadBalancersInput) SetMarker(v string) *DescribeLoadBalancersInput { 4997 s.Marker = &v 4998 return s 4999} 5000 5001// SetNames sets the Names field's value. 5002func (s *DescribeLoadBalancersInput) SetNames(v []*string) *DescribeLoadBalancersInput { 5003 s.Names = v 5004 return s 5005} 5006 5007// SetPageSize sets the PageSize field's value. 5008func (s *DescribeLoadBalancersInput) SetPageSize(v int64) *DescribeLoadBalancersInput { 5009 s.PageSize = &v 5010 return s 5011} 5012 5013type DescribeLoadBalancersOutput struct { 5014 _ struct{} `type:"structure"` 5015 5016 // Information about the load balancers. 5017 LoadBalancers []*LoadBalancer `type:"list"` 5018 5019 // The marker to use when requesting the next set of results. If there are no 5020 // additional results, the string is empty. 5021 NextMarker *string `type:"string"` 5022} 5023 5024// String returns the string representation 5025func (s DescribeLoadBalancersOutput) String() string { 5026 return awsutil.Prettify(s) 5027} 5028 5029// GoString returns the string representation 5030func (s DescribeLoadBalancersOutput) GoString() string { 5031 return s.String() 5032} 5033 5034// SetLoadBalancers sets the LoadBalancers field's value. 5035func (s *DescribeLoadBalancersOutput) SetLoadBalancers(v []*LoadBalancer) *DescribeLoadBalancersOutput { 5036 s.LoadBalancers = v 5037 return s 5038} 5039 5040// SetNextMarker sets the NextMarker field's value. 5041func (s *DescribeLoadBalancersOutput) SetNextMarker(v string) *DescribeLoadBalancersOutput { 5042 s.NextMarker = &v 5043 return s 5044} 5045 5046type DescribeRulesInput struct { 5047 _ struct{} `type:"structure"` 5048 5049 // The Amazon Resource Name (ARN) of the listener. 5050 ListenerArn *string `type:"string"` 5051 5052 // The marker for the next set of results. (You received this marker from a 5053 // previous call.) 5054 Marker *string `type:"string"` 5055 5056 // The maximum number of results to return with this call. 5057 PageSize *int64 `min:"1" type:"integer"` 5058 5059 // The Amazon Resource Names (ARN) of the rules. 5060 RuleArns []*string `type:"list"` 5061} 5062 5063// String returns the string representation 5064func (s DescribeRulesInput) String() string { 5065 return awsutil.Prettify(s) 5066} 5067 5068// GoString returns the string representation 5069func (s DescribeRulesInput) GoString() string { 5070 return s.String() 5071} 5072 5073// Validate inspects the fields of the type to determine if they are valid. 5074func (s *DescribeRulesInput) Validate() error { 5075 invalidParams := request.ErrInvalidParams{Context: "DescribeRulesInput"} 5076 if s.PageSize != nil && *s.PageSize < 1 { 5077 invalidParams.Add(request.NewErrParamMinValue("PageSize", 1)) 5078 } 5079 5080 if invalidParams.Len() > 0 { 5081 return invalidParams 5082 } 5083 return nil 5084} 5085 5086// SetListenerArn sets the ListenerArn field's value. 5087func (s *DescribeRulesInput) SetListenerArn(v string) *DescribeRulesInput { 5088 s.ListenerArn = &v 5089 return s 5090} 5091 5092// SetMarker sets the Marker field's value. 5093func (s *DescribeRulesInput) SetMarker(v string) *DescribeRulesInput { 5094 s.Marker = &v 5095 return s 5096} 5097 5098// SetPageSize sets the PageSize field's value. 5099func (s *DescribeRulesInput) SetPageSize(v int64) *DescribeRulesInput { 5100 s.PageSize = &v 5101 return s 5102} 5103 5104// SetRuleArns sets the RuleArns field's value. 5105func (s *DescribeRulesInput) SetRuleArns(v []*string) *DescribeRulesInput { 5106 s.RuleArns = v 5107 return s 5108} 5109 5110type DescribeRulesOutput struct { 5111 _ struct{} `type:"structure"` 5112 5113 // The marker to use when requesting the next set of results. If there are no 5114 // additional results, the string is empty. 5115 NextMarker *string `type:"string"` 5116 5117 // Information about the rules. 5118 Rules []*Rule `type:"list"` 5119} 5120 5121// String returns the string representation 5122func (s DescribeRulesOutput) String() string { 5123 return awsutil.Prettify(s) 5124} 5125 5126// GoString returns the string representation 5127func (s DescribeRulesOutput) GoString() string { 5128 return s.String() 5129} 5130 5131// SetNextMarker sets the NextMarker field's value. 5132func (s *DescribeRulesOutput) SetNextMarker(v string) *DescribeRulesOutput { 5133 s.NextMarker = &v 5134 return s 5135} 5136 5137// SetRules sets the Rules field's value. 5138func (s *DescribeRulesOutput) SetRules(v []*Rule) *DescribeRulesOutput { 5139 s.Rules = v 5140 return s 5141} 5142 5143type DescribeSSLPoliciesInput struct { 5144 _ struct{} `type:"structure"` 5145 5146 // The marker for the next set of results. (You received this marker from a 5147 // previous call.) 5148 Marker *string `type:"string"` 5149 5150 // The names of the policies. 5151 Names []*string `type:"list"` 5152 5153 // The maximum number of results to return with this call. 5154 PageSize *int64 `min:"1" type:"integer"` 5155} 5156 5157// String returns the string representation 5158func (s DescribeSSLPoliciesInput) String() string { 5159 return awsutil.Prettify(s) 5160} 5161 5162// GoString returns the string representation 5163func (s DescribeSSLPoliciesInput) GoString() string { 5164 return s.String() 5165} 5166 5167// Validate inspects the fields of the type to determine if they are valid. 5168func (s *DescribeSSLPoliciesInput) Validate() error { 5169 invalidParams := request.ErrInvalidParams{Context: "DescribeSSLPoliciesInput"} 5170 if s.PageSize != nil && *s.PageSize < 1 { 5171 invalidParams.Add(request.NewErrParamMinValue("PageSize", 1)) 5172 } 5173 5174 if invalidParams.Len() > 0 { 5175 return invalidParams 5176 } 5177 return nil 5178} 5179 5180// SetMarker sets the Marker field's value. 5181func (s *DescribeSSLPoliciesInput) SetMarker(v string) *DescribeSSLPoliciesInput { 5182 s.Marker = &v 5183 return s 5184} 5185 5186// SetNames sets the Names field's value. 5187func (s *DescribeSSLPoliciesInput) SetNames(v []*string) *DescribeSSLPoliciesInput { 5188 s.Names = v 5189 return s 5190} 5191 5192// SetPageSize sets the PageSize field's value. 5193func (s *DescribeSSLPoliciesInput) SetPageSize(v int64) *DescribeSSLPoliciesInput { 5194 s.PageSize = &v 5195 return s 5196} 5197 5198type DescribeSSLPoliciesOutput struct { 5199 _ struct{} `type:"structure"` 5200 5201 // The marker to use when requesting the next set of results. If there are no 5202 // additional results, the string is empty. 5203 NextMarker *string `type:"string"` 5204 5205 // Information about the policies. 5206 SslPolicies []*SslPolicy `type:"list"` 5207} 5208 5209// String returns the string representation 5210func (s DescribeSSLPoliciesOutput) String() string { 5211 return awsutil.Prettify(s) 5212} 5213 5214// GoString returns the string representation 5215func (s DescribeSSLPoliciesOutput) GoString() string { 5216 return s.String() 5217} 5218 5219// SetNextMarker sets the NextMarker field's value. 5220func (s *DescribeSSLPoliciesOutput) SetNextMarker(v string) *DescribeSSLPoliciesOutput { 5221 s.NextMarker = &v 5222 return s 5223} 5224 5225// SetSslPolicies sets the SslPolicies field's value. 5226func (s *DescribeSSLPoliciesOutput) SetSslPolicies(v []*SslPolicy) *DescribeSSLPoliciesOutput { 5227 s.SslPolicies = v 5228 return s 5229} 5230 5231type DescribeTagsInput struct { 5232 _ struct{} `type:"structure"` 5233 5234 // The Amazon Resource Names (ARN) of the resources. 5235 // 5236 // ResourceArns is a required field 5237 ResourceArns []*string `type:"list" required:"true"` 5238} 5239 5240// String returns the string representation 5241func (s DescribeTagsInput) String() string { 5242 return awsutil.Prettify(s) 5243} 5244 5245// GoString returns the string representation 5246func (s DescribeTagsInput) GoString() string { 5247 return s.String() 5248} 5249 5250// Validate inspects the fields of the type to determine if they are valid. 5251func (s *DescribeTagsInput) Validate() error { 5252 invalidParams := request.ErrInvalidParams{Context: "DescribeTagsInput"} 5253 if s.ResourceArns == nil { 5254 invalidParams.Add(request.NewErrParamRequired("ResourceArns")) 5255 } 5256 5257 if invalidParams.Len() > 0 { 5258 return invalidParams 5259 } 5260 return nil 5261} 5262 5263// SetResourceArns sets the ResourceArns field's value. 5264func (s *DescribeTagsInput) SetResourceArns(v []*string) *DescribeTagsInput { 5265 s.ResourceArns = v 5266 return s 5267} 5268 5269type DescribeTagsOutput struct { 5270 _ struct{} `type:"structure"` 5271 5272 // Information about the tags. 5273 TagDescriptions []*TagDescription `type:"list"` 5274} 5275 5276// String returns the string representation 5277func (s DescribeTagsOutput) String() string { 5278 return awsutil.Prettify(s) 5279} 5280 5281// GoString returns the string representation 5282func (s DescribeTagsOutput) GoString() string { 5283 return s.String() 5284} 5285 5286// SetTagDescriptions sets the TagDescriptions field's value. 5287func (s *DescribeTagsOutput) SetTagDescriptions(v []*TagDescription) *DescribeTagsOutput { 5288 s.TagDescriptions = v 5289 return s 5290} 5291 5292type DescribeTargetGroupAttributesInput struct { 5293 _ struct{} `type:"structure"` 5294 5295 // The Amazon Resource Name (ARN) of the target group. 5296 // 5297 // TargetGroupArn is a required field 5298 TargetGroupArn *string `type:"string" required:"true"` 5299} 5300 5301// String returns the string representation 5302func (s DescribeTargetGroupAttributesInput) String() string { 5303 return awsutil.Prettify(s) 5304} 5305 5306// GoString returns the string representation 5307func (s DescribeTargetGroupAttributesInput) GoString() string { 5308 return s.String() 5309} 5310 5311// Validate inspects the fields of the type to determine if they are valid. 5312func (s *DescribeTargetGroupAttributesInput) Validate() error { 5313 invalidParams := request.ErrInvalidParams{Context: "DescribeTargetGroupAttributesInput"} 5314 if s.TargetGroupArn == nil { 5315 invalidParams.Add(request.NewErrParamRequired("TargetGroupArn")) 5316 } 5317 5318 if invalidParams.Len() > 0 { 5319 return invalidParams 5320 } 5321 return nil 5322} 5323 5324// SetTargetGroupArn sets the TargetGroupArn field's value. 5325func (s *DescribeTargetGroupAttributesInput) SetTargetGroupArn(v string) *DescribeTargetGroupAttributesInput { 5326 s.TargetGroupArn = &v 5327 return s 5328} 5329 5330type DescribeTargetGroupAttributesOutput struct { 5331 _ struct{} `type:"structure"` 5332 5333 // Information about the target group attributes 5334 Attributes []*TargetGroupAttribute `type:"list"` 5335} 5336 5337// String returns the string representation 5338func (s DescribeTargetGroupAttributesOutput) String() string { 5339 return awsutil.Prettify(s) 5340} 5341 5342// GoString returns the string representation 5343func (s DescribeTargetGroupAttributesOutput) GoString() string { 5344 return s.String() 5345} 5346 5347// SetAttributes sets the Attributes field's value. 5348func (s *DescribeTargetGroupAttributesOutput) SetAttributes(v []*TargetGroupAttribute) *DescribeTargetGroupAttributesOutput { 5349 s.Attributes = v 5350 return s 5351} 5352 5353type DescribeTargetGroupsInput struct { 5354 _ struct{} `type:"structure"` 5355 5356 // The Amazon Resource Name (ARN) of the load balancer. 5357 LoadBalancerArn *string `type:"string"` 5358 5359 // The marker for the next set of results. (You received this marker from a 5360 // previous call.) 5361 Marker *string `type:"string"` 5362 5363 // The names of the target groups. 5364 Names []*string `type:"list"` 5365 5366 // The maximum number of results to return with this call. 5367 PageSize *int64 `min:"1" type:"integer"` 5368 5369 // The Amazon Resource Names (ARN) of the target groups. 5370 TargetGroupArns []*string `type:"list"` 5371} 5372 5373// String returns the string representation 5374func (s DescribeTargetGroupsInput) String() string { 5375 return awsutil.Prettify(s) 5376} 5377 5378// GoString returns the string representation 5379func (s DescribeTargetGroupsInput) GoString() string { 5380 return s.String() 5381} 5382 5383// Validate inspects the fields of the type to determine if they are valid. 5384func (s *DescribeTargetGroupsInput) Validate() error { 5385 invalidParams := request.ErrInvalidParams{Context: "DescribeTargetGroupsInput"} 5386 if s.PageSize != nil && *s.PageSize < 1 { 5387 invalidParams.Add(request.NewErrParamMinValue("PageSize", 1)) 5388 } 5389 5390 if invalidParams.Len() > 0 { 5391 return invalidParams 5392 } 5393 return nil 5394} 5395 5396// SetLoadBalancerArn sets the LoadBalancerArn field's value. 5397func (s *DescribeTargetGroupsInput) SetLoadBalancerArn(v string) *DescribeTargetGroupsInput { 5398 s.LoadBalancerArn = &v 5399 return s 5400} 5401 5402// SetMarker sets the Marker field's value. 5403func (s *DescribeTargetGroupsInput) SetMarker(v string) *DescribeTargetGroupsInput { 5404 s.Marker = &v 5405 return s 5406} 5407 5408// SetNames sets the Names field's value. 5409func (s *DescribeTargetGroupsInput) SetNames(v []*string) *DescribeTargetGroupsInput { 5410 s.Names = v 5411 return s 5412} 5413 5414// SetPageSize sets the PageSize field's value. 5415func (s *DescribeTargetGroupsInput) SetPageSize(v int64) *DescribeTargetGroupsInput { 5416 s.PageSize = &v 5417 return s 5418} 5419 5420// SetTargetGroupArns sets the TargetGroupArns field's value. 5421func (s *DescribeTargetGroupsInput) SetTargetGroupArns(v []*string) *DescribeTargetGroupsInput { 5422 s.TargetGroupArns = v 5423 return s 5424} 5425 5426type DescribeTargetGroupsOutput struct { 5427 _ struct{} `type:"structure"` 5428 5429 // The marker to use when requesting the next set of results. If there are no 5430 // additional results, the string is empty. 5431 NextMarker *string `type:"string"` 5432 5433 // Information about the target groups. 5434 TargetGroups []*TargetGroup `type:"list"` 5435} 5436 5437// String returns the string representation 5438func (s DescribeTargetGroupsOutput) String() string { 5439 return awsutil.Prettify(s) 5440} 5441 5442// GoString returns the string representation 5443func (s DescribeTargetGroupsOutput) GoString() string { 5444 return s.String() 5445} 5446 5447// SetNextMarker sets the NextMarker field's value. 5448func (s *DescribeTargetGroupsOutput) SetNextMarker(v string) *DescribeTargetGroupsOutput { 5449 s.NextMarker = &v 5450 return s 5451} 5452 5453// SetTargetGroups sets the TargetGroups field's value. 5454func (s *DescribeTargetGroupsOutput) SetTargetGroups(v []*TargetGroup) *DescribeTargetGroupsOutput { 5455 s.TargetGroups = v 5456 return s 5457} 5458 5459type DescribeTargetHealthInput struct { 5460 _ struct{} `type:"structure"` 5461 5462 // The Amazon Resource Name (ARN) of the target group. 5463 // 5464 // TargetGroupArn is a required field 5465 TargetGroupArn *string `type:"string" required:"true"` 5466 5467 // The targets. 5468 Targets []*TargetDescription `type:"list"` 5469} 5470 5471// String returns the string representation 5472func (s DescribeTargetHealthInput) String() string { 5473 return awsutil.Prettify(s) 5474} 5475 5476// GoString returns the string representation 5477func (s DescribeTargetHealthInput) GoString() string { 5478 return s.String() 5479} 5480 5481// Validate inspects the fields of the type to determine if they are valid. 5482func (s *DescribeTargetHealthInput) Validate() error { 5483 invalidParams := request.ErrInvalidParams{Context: "DescribeTargetHealthInput"} 5484 if s.TargetGroupArn == nil { 5485 invalidParams.Add(request.NewErrParamRequired("TargetGroupArn")) 5486 } 5487 if s.Targets != nil { 5488 for i, v := range s.Targets { 5489 if v == nil { 5490 continue 5491 } 5492 if err := v.Validate(); err != nil { 5493 invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Targets", i), err.(request.ErrInvalidParams)) 5494 } 5495 } 5496 } 5497 5498 if invalidParams.Len() > 0 { 5499 return invalidParams 5500 } 5501 return nil 5502} 5503 5504// SetTargetGroupArn sets the TargetGroupArn field's value. 5505func (s *DescribeTargetHealthInput) SetTargetGroupArn(v string) *DescribeTargetHealthInput { 5506 s.TargetGroupArn = &v 5507 return s 5508} 5509 5510// SetTargets sets the Targets field's value. 5511func (s *DescribeTargetHealthInput) SetTargets(v []*TargetDescription) *DescribeTargetHealthInput { 5512 s.Targets = v 5513 return s 5514} 5515 5516type DescribeTargetHealthOutput struct { 5517 _ struct{} `type:"structure"` 5518 5519 // Information about the health of the targets. 5520 TargetHealthDescriptions []*TargetHealthDescription `type:"list"` 5521} 5522 5523// String returns the string representation 5524func (s DescribeTargetHealthOutput) String() string { 5525 return awsutil.Prettify(s) 5526} 5527 5528// GoString returns the string representation 5529func (s DescribeTargetHealthOutput) GoString() string { 5530 return s.String() 5531} 5532 5533// SetTargetHealthDescriptions sets the TargetHealthDescriptions field's value. 5534func (s *DescribeTargetHealthOutput) SetTargetHealthDescriptions(v []*TargetHealthDescription) *DescribeTargetHealthOutput { 5535 s.TargetHealthDescriptions = v 5536 return s 5537} 5538 5539// Information about an Elastic Load Balancing resource limit for your AWS account. 5540type Limit struct { 5541 _ struct{} `type:"structure"` 5542 5543 // The maximum value of the limit. 5544 Max *string `type:"string"` 5545 5546 // The name of the limit. The possible values are: 5547 // 5548 // * application-load-balancers 5549 // 5550 // * listeners-per-application-load-balancer 5551 // 5552 // * listeners-per-network-load-balancer 5553 // 5554 // * network-load-balancers 5555 // 5556 // * rules-per-application-load-balancer 5557 // 5558 // * target-groups 5559 // 5560 // * targets-per-application-load-balancer 5561 // 5562 // * targets-per-availability-zone-per-network-load-balancer 5563 // 5564 // * targets-per-network-load-balancer 5565 Name *string `type:"string"` 5566} 5567 5568// String returns the string representation 5569func (s Limit) String() string { 5570 return awsutil.Prettify(s) 5571} 5572 5573// GoString returns the string representation 5574func (s Limit) GoString() string { 5575 return s.String() 5576} 5577 5578// SetMax sets the Max field's value. 5579func (s *Limit) SetMax(v string) *Limit { 5580 s.Max = &v 5581 return s 5582} 5583 5584// SetName sets the Name field's value. 5585func (s *Limit) SetName(v string) *Limit { 5586 s.Name = &v 5587 return s 5588} 5589 5590// Information about a listener. 5591type Listener struct { 5592 _ struct{} `type:"structure"` 5593 5594 // The SSL server certificate. You must provide a certificate if the protocol 5595 // is HTTPS. 5596 Certificates []*Certificate `type:"list"` 5597 5598 // The default actions for the listener. 5599 DefaultActions []*Action `type:"list"` 5600 5601 // The Amazon Resource Name (ARN) of the listener. 5602 ListenerArn *string `type:"string"` 5603 5604 // The Amazon Resource Name (ARN) of the load balancer. 5605 LoadBalancerArn *string `type:"string"` 5606 5607 // The port on which the load balancer is listening. 5608 Port *int64 `min:"1" type:"integer"` 5609 5610 // The protocol for connections from clients to the load balancer. 5611 Protocol *string `type:"string" enum:"ProtocolEnum"` 5612 5613 // The security policy that defines which ciphers and protocols are supported. 5614 // The default is the current predefined security policy. 5615 SslPolicy *string `type:"string"` 5616} 5617 5618// String returns the string representation 5619func (s Listener) String() string { 5620 return awsutil.Prettify(s) 5621} 5622 5623// GoString returns the string representation 5624func (s Listener) GoString() string { 5625 return s.String() 5626} 5627 5628// SetCertificates sets the Certificates field's value. 5629func (s *Listener) SetCertificates(v []*Certificate) *Listener { 5630 s.Certificates = v 5631 return s 5632} 5633 5634// SetDefaultActions sets the DefaultActions field's value. 5635func (s *Listener) SetDefaultActions(v []*Action) *Listener { 5636 s.DefaultActions = v 5637 return s 5638} 5639 5640// SetListenerArn sets the ListenerArn field's value. 5641func (s *Listener) SetListenerArn(v string) *Listener { 5642 s.ListenerArn = &v 5643 return s 5644} 5645 5646// SetLoadBalancerArn sets the LoadBalancerArn field's value. 5647func (s *Listener) SetLoadBalancerArn(v string) *Listener { 5648 s.LoadBalancerArn = &v 5649 return s 5650} 5651 5652// SetPort sets the Port field's value. 5653func (s *Listener) SetPort(v int64) *Listener { 5654 s.Port = &v 5655 return s 5656} 5657 5658// SetProtocol sets the Protocol field's value. 5659func (s *Listener) SetProtocol(v string) *Listener { 5660 s.Protocol = &v 5661 return s 5662} 5663 5664// SetSslPolicy sets the SslPolicy field's value. 5665func (s *Listener) SetSslPolicy(v string) *Listener { 5666 s.SslPolicy = &v 5667 return s 5668} 5669 5670// Information about a load balancer. 5671type LoadBalancer struct { 5672 _ struct{} `type:"structure"` 5673 5674 // The Availability Zones for the load balancer. 5675 AvailabilityZones []*AvailabilityZone `type:"list"` 5676 5677 // The ID of the Amazon Route 53 hosted zone associated with the load balancer. 5678 CanonicalHostedZoneId *string `type:"string"` 5679 5680 // The date and time the load balancer was created. 5681 CreatedTime *time.Time `type:"timestamp" timestampFormat:"iso8601"` 5682 5683 // The public DNS name of the load balancer. 5684 DNSName *string `type:"string"` 5685 5686 // The type of IP addresses used by the subnets for your load balancer. The 5687 // possible values are ipv4 (for IPv4 addresses) and dualstack (for IPv4 and 5688 // IPv6 addresses). 5689 IpAddressType *string `type:"string" enum:"IpAddressType"` 5690 5691 // The Amazon Resource Name (ARN) of the load balancer. 5692 LoadBalancerArn *string `type:"string"` 5693 5694 // The name of the load balancer. 5695 LoadBalancerName *string `type:"string"` 5696 5697 // The nodes of an Internet-facing load balancer have public IP addresses. The 5698 // DNS name of an Internet-facing load balancer is publicly resolvable to the 5699 // public IP addresses of the nodes. Therefore, Internet-facing load balancers 5700 // can route requests from clients over the Internet. 5701 // 5702 // The nodes of an internal load balancer have only private IP addresses. The 5703 // DNS name of an internal load balancer is publicly resolvable to the private 5704 // IP addresses of the nodes. Therefore, internal load balancers can only route 5705 // requests from clients with access to the VPC for the load balancer. 5706 Scheme *string `type:"string" enum:"LoadBalancerSchemeEnum"` 5707 5708 // The IDs of the security groups for the load balancer. 5709 SecurityGroups []*string `type:"list"` 5710 5711 // The state of the load balancer. 5712 State *LoadBalancerState `type:"structure"` 5713 5714 // The type of load balancer. 5715 Type *string `type:"string" enum:"LoadBalancerTypeEnum"` 5716 5717 // The ID of the VPC for the load balancer. 5718 VpcId *string `type:"string"` 5719} 5720 5721// String returns the string representation 5722func (s LoadBalancer) String() string { 5723 return awsutil.Prettify(s) 5724} 5725 5726// GoString returns the string representation 5727func (s LoadBalancer) GoString() string { 5728 return s.String() 5729} 5730 5731// SetAvailabilityZones sets the AvailabilityZones field's value. 5732func (s *LoadBalancer) SetAvailabilityZones(v []*AvailabilityZone) *LoadBalancer { 5733 s.AvailabilityZones = v 5734 return s 5735} 5736 5737// SetCanonicalHostedZoneId sets the CanonicalHostedZoneId field's value. 5738func (s *LoadBalancer) SetCanonicalHostedZoneId(v string) *LoadBalancer { 5739 s.CanonicalHostedZoneId = &v 5740 return s 5741} 5742 5743// SetCreatedTime sets the CreatedTime field's value. 5744func (s *LoadBalancer) SetCreatedTime(v time.Time) *LoadBalancer { 5745 s.CreatedTime = &v 5746 return s 5747} 5748 5749// SetDNSName sets the DNSName field's value. 5750func (s *LoadBalancer) SetDNSName(v string) *LoadBalancer { 5751 s.DNSName = &v 5752 return s 5753} 5754 5755// SetIpAddressType sets the IpAddressType field's value. 5756func (s *LoadBalancer) SetIpAddressType(v string) *LoadBalancer { 5757 s.IpAddressType = &v 5758 return s 5759} 5760 5761// SetLoadBalancerArn sets the LoadBalancerArn field's value. 5762func (s *LoadBalancer) SetLoadBalancerArn(v string) *LoadBalancer { 5763 s.LoadBalancerArn = &v 5764 return s 5765} 5766 5767// SetLoadBalancerName sets the LoadBalancerName field's value. 5768func (s *LoadBalancer) SetLoadBalancerName(v string) *LoadBalancer { 5769 s.LoadBalancerName = &v 5770 return s 5771} 5772 5773// SetScheme sets the Scheme field's value. 5774func (s *LoadBalancer) SetScheme(v string) *LoadBalancer { 5775 s.Scheme = &v 5776 return s 5777} 5778 5779// SetSecurityGroups sets the SecurityGroups field's value. 5780func (s *LoadBalancer) SetSecurityGroups(v []*string) *LoadBalancer { 5781 s.SecurityGroups = v 5782 return s 5783} 5784 5785// SetState sets the State field's value. 5786func (s *LoadBalancer) SetState(v *LoadBalancerState) *LoadBalancer { 5787 s.State = v 5788 return s 5789} 5790 5791// SetType sets the Type field's value. 5792func (s *LoadBalancer) SetType(v string) *LoadBalancer { 5793 s.Type = &v 5794 return s 5795} 5796 5797// SetVpcId sets the VpcId field's value. 5798func (s *LoadBalancer) SetVpcId(v string) *LoadBalancer { 5799 s.VpcId = &v 5800 return s 5801} 5802 5803// Information about a static IP address for a load balancer. 5804type LoadBalancerAddress struct { 5805 _ struct{} `type:"structure"` 5806 5807 // [Network Load Balancers] The allocation ID of the Elastic IP address. 5808 AllocationId *string `type:"string"` 5809 5810 // The static IP address. 5811 IpAddress *string `type:"string"` 5812} 5813 5814// String returns the string representation 5815func (s LoadBalancerAddress) String() string { 5816 return awsutil.Prettify(s) 5817} 5818 5819// GoString returns the string representation 5820func (s LoadBalancerAddress) GoString() string { 5821 return s.String() 5822} 5823 5824// SetAllocationId sets the AllocationId field's value. 5825func (s *LoadBalancerAddress) SetAllocationId(v string) *LoadBalancerAddress { 5826 s.AllocationId = &v 5827 return s 5828} 5829 5830// SetIpAddress sets the IpAddress field's value. 5831func (s *LoadBalancerAddress) SetIpAddress(v string) *LoadBalancerAddress { 5832 s.IpAddress = &v 5833 return s 5834} 5835 5836// Information about a load balancer attribute. 5837type LoadBalancerAttribute struct { 5838 _ struct{} `type:"structure"` 5839 5840 // The name of the attribute. 5841 // 5842 // * access_logs.s3.enabled - [Application Load Balancers] Indicates whether 5843 // access logs stored in Amazon S3 are enabled. The value is true or false. 5844 // 5845 // * access_logs.s3.bucket - [Application Load Balancers] The name of the 5846 // S3 bucket for the access logs. This attribute is required if access logs 5847 // in Amazon S3 are enabled. The bucket must exist in the same region as 5848 // the load balancer and have a bucket policy that grants Elastic Load Balancing 5849 // permission to write to the bucket. 5850 // 5851 // * access_logs.s3.prefix - [Application Load Balancers] The prefix for 5852 // the location in the S3 bucket. If you don't specify a prefix, the access 5853 // logs are stored in the root of the bucket. 5854 // 5855 // * deletion_protection.enabled - Indicates whether deletion protection 5856 // is enabled. The value is true or false. 5857 // 5858 // * idle_timeout.timeout_seconds - [Application Load Balancers] The idle 5859 // timeout value, in seconds. The valid range is 1-4000. The default is 60 5860 // seconds. 5861 // 5862 // * load_balancing.cross_zone.enabled - [Network Load Balancers] Indicates 5863 // whether cross-zone load balancing is enabled. The value is true or false. 5864 // The default is false. 5865 // 5866 // * routing.http2.enabled - [Application Load Balancers] Indicates whether 5867 // HTTP/2 is enabled. The value is true or false. The default is true. 5868 Key *string `type:"string"` 5869 5870 // The value of the attribute. 5871 Value *string `type:"string"` 5872} 5873 5874// String returns the string representation 5875func (s LoadBalancerAttribute) String() string { 5876 return awsutil.Prettify(s) 5877} 5878 5879// GoString returns the string representation 5880func (s LoadBalancerAttribute) GoString() string { 5881 return s.String() 5882} 5883 5884// SetKey sets the Key field's value. 5885func (s *LoadBalancerAttribute) SetKey(v string) *LoadBalancerAttribute { 5886 s.Key = &v 5887 return s 5888} 5889 5890// SetValue sets the Value field's value. 5891func (s *LoadBalancerAttribute) SetValue(v string) *LoadBalancerAttribute { 5892 s.Value = &v 5893 return s 5894} 5895 5896// Information about the state of the load balancer. 5897type LoadBalancerState struct { 5898 _ struct{} `type:"structure"` 5899 5900 // The state code. The initial state of the load balancer is provisioning. After 5901 // the load balancer is fully set up and ready to route traffic, its state is 5902 // active. If the load balancer could not be set up, its state is failed. 5903 Code *string `type:"string" enum:"LoadBalancerStateEnum"` 5904 5905 // A description of the state. 5906 Reason *string `type:"string"` 5907} 5908 5909// String returns the string representation 5910func (s LoadBalancerState) String() string { 5911 return awsutil.Prettify(s) 5912} 5913 5914// GoString returns the string representation 5915func (s LoadBalancerState) GoString() string { 5916 return s.String() 5917} 5918 5919// SetCode sets the Code field's value. 5920func (s *LoadBalancerState) SetCode(v string) *LoadBalancerState { 5921 s.Code = &v 5922 return s 5923} 5924 5925// SetReason sets the Reason field's value. 5926func (s *LoadBalancerState) SetReason(v string) *LoadBalancerState { 5927 s.Reason = &v 5928 return s 5929} 5930 5931// Information to use when checking for a successful response from a target. 5932type Matcher struct { 5933 _ struct{} `type:"structure"` 5934 5935 // The HTTP codes. 5936 // 5937 // For Application Load Balancers, you can specify values between 200 and 499, 5938 // and the default value is 200. You can specify multiple values (for example, 5939 // "200,202") or a range of values (for example, "200-299"). 5940 // 5941 // For Network Load Balancers, this is 200 to 399. 5942 // 5943 // HttpCode is a required field 5944 HttpCode *string `type:"string" required:"true"` 5945} 5946 5947// String returns the string representation 5948func (s Matcher) String() string { 5949 return awsutil.Prettify(s) 5950} 5951 5952// GoString returns the string representation 5953func (s Matcher) GoString() string { 5954 return s.String() 5955} 5956 5957// Validate inspects the fields of the type to determine if they are valid. 5958func (s *Matcher) Validate() error { 5959 invalidParams := request.ErrInvalidParams{Context: "Matcher"} 5960 if s.HttpCode == nil { 5961 invalidParams.Add(request.NewErrParamRequired("HttpCode")) 5962 } 5963 5964 if invalidParams.Len() > 0 { 5965 return invalidParams 5966 } 5967 return nil 5968} 5969 5970// SetHttpCode sets the HttpCode field's value. 5971func (s *Matcher) SetHttpCode(v string) *Matcher { 5972 s.HttpCode = &v 5973 return s 5974} 5975 5976type ModifyListenerInput struct { 5977 _ struct{} `type:"structure"` 5978 5979 // The default SSL server certificate. 5980 Certificates []*Certificate `type:"list"` 5981 5982 // The default action. For Application Load Balancers, the protocol of the specified 5983 // target group must be HTTP or HTTPS. For Network Load Balancers, the protocol 5984 // of the specified target group must be TCP. 5985 DefaultActions []*Action `type:"list"` 5986 5987 // The Amazon Resource Name (ARN) of the listener. 5988 // 5989 // ListenerArn is a required field 5990 ListenerArn *string `type:"string" required:"true"` 5991 5992 // The port for connections from clients to the load balancer. 5993 Port *int64 `min:"1" type:"integer"` 5994 5995 // The protocol for connections from clients to the load balancer. Application 5996 // Load Balancers support HTTP and HTTPS and Network Load Balancers support 5997 // TCP. 5998 Protocol *string `type:"string" enum:"ProtocolEnum"` 5999 6000 // The security policy that defines which protocols and ciphers are supported. 6001 // For more information, see Security Policies (http://docs.aws.amazon.com/elasticloadbalancing/latest/application/create-https-listener.html#describe-ssl-policies) 6002 // in the Application Load Balancers Guide. 6003 SslPolicy *string `type:"string"` 6004} 6005 6006// String returns the string representation 6007func (s ModifyListenerInput) String() string { 6008 return awsutil.Prettify(s) 6009} 6010 6011// GoString returns the string representation 6012func (s ModifyListenerInput) GoString() string { 6013 return s.String() 6014} 6015 6016// Validate inspects the fields of the type to determine if they are valid. 6017func (s *ModifyListenerInput) Validate() error { 6018 invalidParams := request.ErrInvalidParams{Context: "ModifyListenerInput"} 6019 if s.ListenerArn == nil { 6020 invalidParams.Add(request.NewErrParamRequired("ListenerArn")) 6021 } 6022 if s.Port != nil && *s.Port < 1 { 6023 invalidParams.Add(request.NewErrParamMinValue("Port", 1)) 6024 } 6025 if s.DefaultActions != nil { 6026 for i, v := range s.DefaultActions { 6027 if v == nil { 6028 continue 6029 } 6030 if err := v.Validate(); err != nil { 6031 invalidParams.AddNested(fmt.Sprintf("%s[%v]", "DefaultActions", i), err.(request.ErrInvalidParams)) 6032 } 6033 } 6034 } 6035 6036 if invalidParams.Len() > 0 { 6037 return invalidParams 6038 } 6039 return nil 6040} 6041 6042// SetCertificates sets the Certificates field's value. 6043func (s *ModifyListenerInput) SetCertificates(v []*Certificate) *ModifyListenerInput { 6044 s.Certificates = v 6045 return s 6046} 6047 6048// SetDefaultActions sets the DefaultActions field's value. 6049func (s *ModifyListenerInput) SetDefaultActions(v []*Action) *ModifyListenerInput { 6050 s.DefaultActions = v 6051 return s 6052} 6053 6054// SetListenerArn sets the ListenerArn field's value. 6055func (s *ModifyListenerInput) SetListenerArn(v string) *ModifyListenerInput { 6056 s.ListenerArn = &v 6057 return s 6058} 6059 6060// SetPort sets the Port field's value. 6061func (s *ModifyListenerInput) SetPort(v int64) *ModifyListenerInput { 6062 s.Port = &v 6063 return s 6064} 6065 6066// SetProtocol sets the Protocol field's value. 6067func (s *ModifyListenerInput) SetProtocol(v string) *ModifyListenerInput { 6068 s.Protocol = &v 6069 return s 6070} 6071 6072// SetSslPolicy sets the SslPolicy field's value. 6073func (s *ModifyListenerInput) SetSslPolicy(v string) *ModifyListenerInput { 6074 s.SslPolicy = &v 6075 return s 6076} 6077 6078type ModifyListenerOutput struct { 6079 _ struct{} `type:"structure"` 6080 6081 // Information about the modified listeners. 6082 Listeners []*Listener `type:"list"` 6083} 6084 6085// String returns the string representation 6086func (s ModifyListenerOutput) String() string { 6087 return awsutil.Prettify(s) 6088} 6089 6090// GoString returns the string representation 6091func (s ModifyListenerOutput) GoString() string { 6092 return s.String() 6093} 6094 6095// SetListeners sets the Listeners field's value. 6096func (s *ModifyListenerOutput) SetListeners(v []*Listener) *ModifyListenerOutput { 6097 s.Listeners = v 6098 return s 6099} 6100 6101type ModifyLoadBalancerAttributesInput struct { 6102 _ struct{} `type:"structure"` 6103 6104 // The load balancer attributes. 6105 // 6106 // Attributes is a required field 6107 Attributes []*LoadBalancerAttribute `type:"list" required:"true"` 6108 6109 // The Amazon Resource Name (ARN) of the load balancer. 6110 // 6111 // LoadBalancerArn is a required field 6112 LoadBalancerArn *string `type:"string" required:"true"` 6113} 6114 6115// String returns the string representation 6116func (s ModifyLoadBalancerAttributesInput) String() string { 6117 return awsutil.Prettify(s) 6118} 6119 6120// GoString returns the string representation 6121func (s ModifyLoadBalancerAttributesInput) GoString() string { 6122 return s.String() 6123} 6124 6125// Validate inspects the fields of the type to determine if they are valid. 6126func (s *ModifyLoadBalancerAttributesInput) Validate() error { 6127 invalidParams := request.ErrInvalidParams{Context: "ModifyLoadBalancerAttributesInput"} 6128 if s.Attributes == nil { 6129 invalidParams.Add(request.NewErrParamRequired("Attributes")) 6130 } 6131 if s.LoadBalancerArn == nil { 6132 invalidParams.Add(request.NewErrParamRequired("LoadBalancerArn")) 6133 } 6134 6135 if invalidParams.Len() > 0 { 6136 return invalidParams 6137 } 6138 return nil 6139} 6140 6141// SetAttributes sets the Attributes field's value. 6142func (s *ModifyLoadBalancerAttributesInput) SetAttributes(v []*LoadBalancerAttribute) *ModifyLoadBalancerAttributesInput { 6143 s.Attributes = v 6144 return s 6145} 6146 6147// SetLoadBalancerArn sets the LoadBalancerArn field's value. 6148func (s *ModifyLoadBalancerAttributesInput) SetLoadBalancerArn(v string) *ModifyLoadBalancerAttributesInput { 6149 s.LoadBalancerArn = &v 6150 return s 6151} 6152 6153type ModifyLoadBalancerAttributesOutput struct { 6154 _ struct{} `type:"structure"` 6155 6156 // Information about the load balancer attributes. 6157 Attributes []*LoadBalancerAttribute `type:"list"` 6158} 6159 6160// String returns the string representation 6161func (s ModifyLoadBalancerAttributesOutput) String() string { 6162 return awsutil.Prettify(s) 6163} 6164 6165// GoString returns the string representation 6166func (s ModifyLoadBalancerAttributesOutput) GoString() string { 6167 return s.String() 6168} 6169 6170// SetAttributes sets the Attributes field's value. 6171func (s *ModifyLoadBalancerAttributesOutput) SetAttributes(v []*LoadBalancerAttribute) *ModifyLoadBalancerAttributesOutput { 6172 s.Attributes = v 6173 return s 6174} 6175 6176type ModifyRuleInput struct { 6177 _ struct{} `type:"structure"` 6178 6179 // The actions. The target group must use the HTTP or HTTPS protocol. 6180 Actions []*Action `type:"list"` 6181 6182 // The conditions. 6183 Conditions []*RuleCondition `type:"list"` 6184 6185 // The Amazon Resource Name (ARN) of the rule. 6186 // 6187 // RuleArn is a required field 6188 RuleArn *string `type:"string" required:"true"` 6189} 6190 6191// String returns the string representation 6192func (s ModifyRuleInput) String() string { 6193 return awsutil.Prettify(s) 6194} 6195 6196// GoString returns the string representation 6197func (s ModifyRuleInput) GoString() string { 6198 return s.String() 6199} 6200 6201// Validate inspects the fields of the type to determine if they are valid. 6202func (s *ModifyRuleInput) Validate() error { 6203 invalidParams := request.ErrInvalidParams{Context: "ModifyRuleInput"} 6204 if s.RuleArn == nil { 6205 invalidParams.Add(request.NewErrParamRequired("RuleArn")) 6206 } 6207 if s.Actions != nil { 6208 for i, v := range s.Actions { 6209 if v == nil { 6210 continue 6211 } 6212 if err := v.Validate(); err != nil { 6213 invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Actions", i), err.(request.ErrInvalidParams)) 6214 } 6215 } 6216 } 6217 6218 if invalidParams.Len() > 0 { 6219 return invalidParams 6220 } 6221 return nil 6222} 6223 6224// SetActions sets the Actions field's value. 6225func (s *ModifyRuleInput) SetActions(v []*Action) *ModifyRuleInput { 6226 s.Actions = v 6227 return s 6228} 6229 6230// SetConditions sets the Conditions field's value. 6231func (s *ModifyRuleInput) SetConditions(v []*RuleCondition) *ModifyRuleInput { 6232 s.Conditions = v 6233 return s 6234} 6235 6236// SetRuleArn sets the RuleArn field's value. 6237func (s *ModifyRuleInput) SetRuleArn(v string) *ModifyRuleInput { 6238 s.RuleArn = &v 6239 return s 6240} 6241 6242type ModifyRuleOutput struct { 6243 _ struct{} `type:"structure"` 6244 6245 // Information about the rule. 6246 Rules []*Rule `type:"list"` 6247} 6248 6249// String returns the string representation 6250func (s ModifyRuleOutput) String() string { 6251 return awsutil.Prettify(s) 6252} 6253 6254// GoString returns the string representation 6255func (s ModifyRuleOutput) GoString() string { 6256 return s.String() 6257} 6258 6259// SetRules sets the Rules field's value. 6260func (s *ModifyRuleOutput) SetRules(v []*Rule) *ModifyRuleOutput { 6261 s.Rules = v 6262 return s 6263} 6264 6265type ModifyTargetGroupAttributesInput struct { 6266 _ struct{} `type:"structure"` 6267 6268 // The attributes. 6269 // 6270 // Attributes is a required field 6271 Attributes []*TargetGroupAttribute `type:"list" required:"true"` 6272 6273 // The Amazon Resource Name (ARN) of the target group. 6274 // 6275 // TargetGroupArn is a required field 6276 TargetGroupArn *string `type:"string" required:"true"` 6277} 6278 6279// String returns the string representation 6280func (s ModifyTargetGroupAttributesInput) String() string { 6281 return awsutil.Prettify(s) 6282} 6283 6284// GoString returns the string representation 6285func (s ModifyTargetGroupAttributesInput) GoString() string { 6286 return s.String() 6287} 6288 6289// Validate inspects the fields of the type to determine if they are valid. 6290func (s *ModifyTargetGroupAttributesInput) Validate() error { 6291 invalidParams := request.ErrInvalidParams{Context: "ModifyTargetGroupAttributesInput"} 6292 if s.Attributes == nil { 6293 invalidParams.Add(request.NewErrParamRequired("Attributes")) 6294 } 6295 if s.TargetGroupArn == nil { 6296 invalidParams.Add(request.NewErrParamRequired("TargetGroupArn")) 6297 } 6298 6299 if invalidParams.Len() > 0 { 6300 return invalidParams 6301 } 6302 return nil 6303} 6304 6305// SetAttributes sets the Attributes field's value. 6306func (s *ModifyTargetGroupAttributesInput) SetAttributes(v []*TargetGroupAttribute) *ModifyTargetGroupAttributesInput { 6307 s.Attributes = v 6308 return s 6309} 6310 6311// SetTargetGroupArn sets the TargetGroupArn field's value. 6312func (s *ModifyTargetGroupAttributesInput) SetTargetGroupArn(v string) *ModifyTargetGroupAttributesInput { 6313 s.TargetGroupArn = &v 6314 return s 6315} 6316 6317type ModifyTargetGroupAttributesOutput struct { 6318 _ struct{} `type:"structure"` 6319 6320 // Information about the attributes. 6321 Attributes []*TargetGroupAttribute `type:"list"` 6322} 6323 6324// String returns the string representation 6325func (s ModifyTargetGroupAttributesOutput) String() string { 6326 return awsutil.Prettify(s) 6327} 6328 6329// GoString returns the string representation 6330func (s ModifyTargetGroupAttributesOutput) GoString() string { 6331 return s.String() 6332} 6333 6334// SetAttributes sets the Attributes field's value. 6335func (s *ModifyTargetGroupAttributesOutput) SetAttributes(v []*TargetGroupAttribute) *ModifyTargetGroupAttributesOutput { 6336 s.Attributes = v 6337 return s 6338} 6339 6340type ModifyTargetGroupInput struct { 6341 _ struct{} `type:"structure"` 6342 6343 // The approximate amount of time, in seconds, between health checks of an individual 6344 // target. For Application Load Balancers, the range is 5 to 300 seconds. For 6345 // Network Load Balancers, the supported values are 10 or 30 seconds. 6346 HealthCheckIntervalSeconds *int64 `min:"5" type:"integer"` 6347 6348 // [HTTP/HTTPS health checks] The ping path that is the destination for the 6349 // health check request. 6350 HealthCheckPath *string `min:"1" type:"string"` 6351 6352 // The port the load balancer uses when performing health checks on targets. 6353 HealthCheckPort *string `type:"string"` 6354 6355 // The protocol the load balancer uses when performing health checks on targets. 6356 // The TCP protocol is supported only if the protocol of the target group is 6357 // TCP. 6358 HealthCheckProtocol *string `type:"string" enum:"ProtocolEnum"` 6359 6360 // [HTTP/HTTPS health checks] The amount of time, in seconds, during which no 6361 // response means a failed health check. 6362 HealthCheckTimeoutSeconds *int64 `min:"2" type:"integer"` 6363 6364 // The number of consecutive health checks successes required before considering 6365 // an unhealthy target healthy. 6366 HealthyThresholdCount *int64 `min:"2" type:"integer"` 6367 6368 // [HTTP/HTTPS health checks] The HTTP codes to use when checking for a successful 6369 // response from a target. 6370 Matcher *Matcher `type:"structure"` 6371 6372 // The Amazon Resource Name (ARN) of the target group. 6373 // 6374 // TargetGroupArn is a required field 6375 TargetGroupArn *string `type:"string" required:"true"` 6376 6377 // The number of consecutive health check failures required before considering 6378 // the target unhealthy. For Network Load Balancers, this value must be the 6379 // same as the healthy threshold count. 6380 UnhealthyThresholdCount *int64 `min:"2" type:"integer"` 6381} 6382 6383// String returns the string representation 6384func (s ModifyTargetGroupInput) String() string { 6385 return awsutil.Prettify(s) 6386} 6387 6388// GoString returns the string representation 6389func (s ModifyTargetGroupInput) GoString() string { 6390 return s.String() 6391} 6392 6393// Validate inspects the fields of the type to determine if they are valid. 6394func (s *ModifyTargetGroupInput) Validate() error { 6395 invalidParams := request.ErrInvalidParams{Context: "ModifyTargetGroupInput"} 6396 if s.HealthCheckIntervalSeconds != nil && *s.HealthCheckIntervalSeconds < 5 { 6397 invalidParams.Add(request.NewErrParamMinValue("HealthCheckIntervalSeconds", 5)) 6398 } 6399 if s.HealthCheckPath != nil && len(*s.HealthCheckPath) < 1 { 6400 invalidParams.Add(request.NewErrParamMinLen("HealthCheckPath", 1)) 6401 } 6402 if s.HealthCheckTimeoutSeconds != nil && *s.HealthCheckTimeoutSeconds < 2 { 6403 invalidParams.Add(request.NewErrParamMinValue("HealthCheckTimeoutSeconds", 2)) 6404 } 6405 if s.HealthyThresholdCount != nil && *s.HealthyThresholdCount < 2 { 6406 invalidParams.Add(request.NewErrParamMinValue("HealthyThresholdCount", 2)) 6407 } 6408 if s.TargetGroupArn == nil { 6409 invalidParams.Add(request.NewErrParamRequired("TargetGroupArn")) 6410 } 6411 if s.UnhealthyThresholdCount != nil && *s.UnhealthyThresholdCount < 2 { 6412 invalidParams.Add(request.NewErrParamMinValue("UnhealthyThresholdCount", 2)) 6413 } 6414 if s.Matcher != nil { 6415 if err := s.Matcher.Validate(); err != nil { 6416 invalidParams.AddNested("Matcher", err.(request.ErrInvalidParams)) 6417 } 6418 } 6419 6420 if invalidParams.Len() > 0 { 6421 return invalidParams 6422 } 6423 return nil 6424} 6425 6426// SetHealthCheckIntervalSeconds sets the HealthCheckIntervalSeconds field's value. 6427func (s *ModifyTargetGroupInput) SetHealthCheckIntervalSeconds(v int64) *ModifyTargetGroupInput { 6428 s.HealthCheckIntervalSeconds = &v 6429 return s 6430} 6431 6432// SetHealthCheckPath sets the HealthCheckPath field's value. 6433func (s *ModifyTargetGroupInput) SetHealthCheckPath(v string) *ModifyTargetGroupInput { 6434 s.HealthCheckPath = &v 6435 return s 6436} 6437 6438// SetHealthCheckPort sets the HealthCheckPort field's value. 6439func (s *ModifyTargetGroupInput) SetHealthCheckPort(v string) *ModifyTargetGroupInput { 6440 s.HealthCheckPort = &v 6441 return s 6442} 6443 6444// SetHealthCheckProtocol sets the HealthCheckProtocol field's value. 6445func (s *ModifyTargetGroupInput) SetHealthCheckProtocol(v string) *ModifyTargetGroupInput { 6446 s.HealthCheckProtocol = &v 6447 return s 6448} 6449 6450// SetHealthCheckTimeoutSeconds sets the HealthCheckTimeoutSeconds field's value. 6451func (s *ModifyTargetGroupInput) SetHealthCheckTimeoutSeconds(v int64) *ModifyTargetGroupInput { 6452 s.HealthCheckTimeoutSeconds = &v 6453 return s 6454} 6455 6456// SetHealthyThresholdCount sets the HealthyThresholdCount field's value. 6457func (s *ModifyTargetGroupInput) SetHealthyThresholdCount(v int64) *ModifyTargetGroupInput { 6458 s.HealthyThresholdCount = &v 6459 return s 6460} 6461 6462// SetMatcher sets the Matcher field's value. 6463func (s *ModifyTargetGroupInput) SetMatcher(v *Matcher) *ModifyTargetGroupInput { 6464 s.Matcher = v 6465 return s 6466} 6467 6468// SetTargetGroupArn sets the TargetGroupArn field's value. 6469func (s *ModifyTargetGroupInput) SetTargetGroupArn(v string) *ModifyTargetGroupInput { 6470 s.TargetGroupArn = &v 6471 return s 6472} 6473 6474// SetUnhealthyThresholdCount sets the UnhealthyThresholdCount field's value. 6475func (s *ModifyTargetGroupInput) SetUnhealthyThresholdCount(v int64) *ModifyTargetGroupInput { 6476 s.UnhealthyThresholdCount = &v 6477 return s 6478} 6479 6480type ModifyTargetGroupOutput struct { 6481 _ struct{} `type:"structure"` 6482 6483 // Information about the target group. 6484 TargetGroups []*TargetGroup `type:"list"` 6485} 6486 6487// String returns the string representation 6488func (s ModifyTargetGroupOutput) String() string { 6489 return awsutil.Prettify(s) 6490} 6491 6492// GoString returns the string representation 6493func (s ModifyTargetGroupOutput) GoString() string { 6494 return s.String() 6495} 6496 6497// SetTargetGroups sets the TargetGroups field's value. 6498func (s *ModifyTargetGroupOutput) SetTargetGroups(v []*TargetGroup) *ModifyTargetGroupOutput { 6499 s.TargetGroups = v 6500 return s 6501} 6502 6503type RegisterTargetsInput struct { 6504 _ struct{} `type:"structure"` 6505 6506 // The Amazon Resource Name (ARN) of the target group. 6507 // 6508 // TargetGroupArn is a required field 6509 TargetGroupArn *string `type:"string" required:"true"` 6510 6511 // The targets. 6512 // 6513 // Targets is a required field 6514 Targets []*TargetDescription `type:"list" required:"true"` 6515} 6516 6517// String returns the string representation 6518func (s RegisterTargetsInput) String() string { 6519 return awsutil.Prettify(s) 6520} 6521 6522// GoString returns the string representation 6523func (s RegisterTargetsInput) GoString() string { 6524 return s.String() 6525} 6526 6527// Validate inspects the fields of the type to determine if they are valid. 6528func (s *RegisterTargetsInput) Validate() error { 6529 invalidParams := request.ErrInvalidParams{Context: "RegisterTargetsInput"} 6530 if s.TargetGroupArn == nil { 6531 invalidParams.Add(request.NewErrParamRequired("TargetGroupArn")) 6532 } 6533 if s.Targets == nil { 6534 invalidParams.Add(request.NewErrParamRequired("Targets")) 6535 } 6536 if s.Targets != nil { 6537 for i, v := range s.Targets { 6538 if v == nil { 6539 continue 6540 } 6541 if err := v.Validate(); err != nil { 6542 invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Targets", i), err.(request.ErrInvalidParams)) 6543 } 6544 } 6545 } 6546 6547 if invalidParams.Len() > 0 { 6548 return invalidParams 6549 } 6550 return nil 6551} 6552 6553// SetTargetGroupArn sets the TargetGroupArn field's value. 6554func (s *RegisterTargetsInput) SetTargetGroupArn(v string) *RegisterTargetsInput { 6555 s.TargetGroupArn = &v 6556 return s 6557} 6558 6559// SetTargets sets the Targets field's value. 6560func (s *RegisterTargetsInput) SetTargets(v []*TargetDescription) *RegisterTargetsInput { 6561 s.Targets = v 6562 return s 6563} 6564 6565type RegisterTargetsOutput struct { 6566 _ struct{} `type:"structure"` 6567} 6568 6569// String returns the string representation 6570func (s RegisterTargetsOutput) String() string { 6571 return awsutil.Prettify(s) 6572} 6573 6574// GoString returns the string representation 6575func (s RegisterTargetsOutput) GoString() string { 6576 return s.String() 6577} 6578 6579type RemoveListenerCertificatesInput struct { 6580 _ struct{} `type:"structure"` 6581 6582 // The certificate to remove. You can specify one certificate per call. 6583 // 6584 // Certificates is a required field 6585 Certificates []*Certificate `type:"list" required:"true"` 6586 6587 // The Amazon Resource Name (ARN) of the listener. 6588 // 6589 // ListenerArn is a required field 6590 ListenerArn *string `type:"string" required:"true"` 6591} 6592 6593// String returns the string representation 6594func (s RemoveListenerCertificatesInput) String() string { 6595 return awsutil.Prettify(s) 6596} 6597 6598// GoString returns the string representation 6599func (s RemoveListenerCertificatesInput) GoString() string { 6600 return s.String() 6601} 6602 6603// Validate inspects the fields of the type to determine if they are valid. 6604func (s *RemoveListenerCertificatesInput) Validate() error { 6605 invalidParams := request.ErrInvalidParams{Context: "RemoveListenerCertificatesInput"} 6606 if s.Certificates == nil { 6607 invalidParams.Add(request.NewErrParamRequired("Certificates")) 6608 } 6609 if s.ListenerArn == nil { 6610 invalidParams.Add(request.NewErrParamRequired("ListenerArn")) 6611 } 6612 6613 if invalidParams.Len() > 0 { 6614 return invalidParams 6615 } 6616 return nil 6617} 6618 6619// SetCertificates sets the Certificates field's value. 6620func (s *RemoveListenerCertificatesInput) SetCertificates(v []*Certificate) *RemoveListenerCertificatesInput { 6621 s.Certificates = v 6622 return s 6623} 6624 6625// SetListenerArn sets the ListenerArn field's value. 6626func (s *RemoveListenerCertificatesInput) SetListenerArn(v string) *RemoveListenerCertificatesInput { 6627 s.ListenerArn = &v 6628 return s 6629} 6630 6631type RemoveListenerCertificatesOutput struct { 6632 _ struct{} `type:"structure"` 6633} 6634 6635// String returns the string representation 6636func (s RemoveListenerCertificatesOutput) String() string { 6637 return awsutil.Prettify(s) 6638} 6639 6640// GoString returns the string representation 6641func (s RemoveListenerCertificatesOutput) GoString() string { 6642 return s.String() 6643} 6644 6645type RemoveTagsInput struct { 6646 _ struct{} `type:"structure"` 6647 6648 // The Amazon Resource Name (ARN) of the resource. 6649 // 6650 // ResourceArns is a required field 6651 ResourceArns []*string `type:"list" required:"true"` 6652 6653 // The tag keys for the tags to remove. 6654 // 6655 // TagKeys is a required field 6656 TagKeys []*string `type:"list" required:"true"` 6657} 6658 6659// String returns the string representation 6660func (s RemoveTagsInput) String() string { 6661 return awsutil.Prettify(s) 6662} 6663 6664// GoString returns the string representation 6665func (s RemoveTagsInput) GoString() string { 6666 return s.String() 6667} 6668 6669// Validate inspects the fields of the type to determine if they are valid. 6670func (s *RemoveTagsInput) Validate() error { 6671 invalidParams := request.ErrInvalidParams{Context: "RemoveTagsInput"} 6672 if s.ResourceArns == nil { 6673 invalidParams.Add(request.NewErrParamRequired("ResourceArns")) 6674 } 6675 if s.TagKeys == nil { 6676 invalidParams.Add(request.NewErrParamRequired("TagKeys")) 6677 } 6678 6679 if invalidParams.Len() > 0 { 6680 return invalidParams 6681 } 6682 return nil 6683} 6684 6685// SetResourceArns sets the ResourceArns field's value. 6686func (s *RemoveTagsInput) SetResourceArns(v []*string) *RemoveTagsInput { 6687 s.ResourceArns = v 6688 return s 6689} 6690 6691// SetTagKeys sets the TagKeys field's value. 6692func (s *RemoveTagsInput) SetTagKeys(v []*string) *RemoveTagsInput { 6693 s.TagKeys = v 6694 return s 6695} 6696 6697type RemoveTagsOutput struct { 6698 _ struct{} `type:"structure"` 6699} 6700 6701// String returns the string representation 6702func (s RemoveTagsOutput) String() string { 6703 return awsutil.Prettify(s) 6704} 6705 6706// GoString returns the string representation 6707func (s RemoveTagsOutput) GoString() string { 6708 return s.String() 6709} 6710 6711// Information about a rule. 6712type Rule struct { 6713 _ struct{} `type:"structure"` 6714 6715 // The actions. 6716 Actions []*Action `type:"list"` 6717 6718 // The conditions. 6719 Conditions []*RuleCondition `type:"list"` 6720 6721 // Indicates whether this is the default rule. 6722 IsDefault *bool `type:"boolean"` 6723 6724 // The priority. 6725 Priority *string `type:"string"` 6726 6727 // The Amazon Resource Name (ARN) of the rule. 6728 RuleArn *string `type:"string"` 6729} 6730 6731// String returns the string representation 6732func (s Rule) String() string { 6733 return awsutil.Prettify(s) 6734} 6735 6736// GoString returns the string representation 6737func (s Rule) GoString() string { 6738 return s.String() 6739} 6740 6741// SetActions sets the Actions field's value. 6742func (s *Rule) SetActions(v []*Action) *Rule { 6743 s.Actions = v 6744 return s 6745} 6746 6747// SetConditions sets the Conditions field's value. 6748func (s *Rule) SetConditions(v []*RuleCondition) *Rule { 6749 s.Conditions = v 6750 return s 6751} 6752 6753// SetIsDefault sets the IsDefault field's value. 6754func (s *Rule) SetIsDefault(v bool) *Rule { 6755 s.IsDefault = &v 6756 return s 6757} 6758 6759// SetPriority sets the Priority field's value. 6760func (s *Rule) SetPriority(v string) *Rule { 6761 s.Priority = &v 6762 return s 6763} 6764 6765// SetRuleArn sets the RuleArn field's value. 6766func (s *Rule) SetRuleArn(v string) *Rule { 6767 s.RuleArn = &v 6768 return s 6769} 6770 6771// Information about a condition for a rule. 6772type RuleCondition struct { 6773 _ struct{} `type:"structure"` 6774 6775 // The name of the field. The possible values are host-header and path-pattern. 6776 Field *string `type:"string"` 6777 6778 // The condition value. 6779 // 6780 // If the field name is host-header, you can specify a single host name (for 6781 // example, my.example.com). A host name is case insensitive, can be up to 128 6782 // characters in length, and can contain any of the following characters. Note 6783 // that you can include up to three wildcard characters. 6784 // 6785 // * A-Z, a-z, 0-9 6786 // 6787 // * - . 6788 // 6789 // * * (matches 0 or more characters) 6790 // 6791 // * ? (matches exactly 1 character) 6792 // 6793 // If the field name is path-pattern, you can specify a single path pattern 6794 // (for example, /img/*). A path pattern is case sensitive, can be up to 128 6795 // characters in length, and can contain any of the following characters. Note 6796 // that you can include up to three wildcard characters. 6797 // 6798 // * A-Z, a-z, 0-9 6799 // 6800 // * _ - . $ / ~ " ' @ : + 6801 // 6802 // * & (using &) 6803 // 6804 // * * (matches 0 or more characters) 6805 // 6806 // * ? (matches exactly 1 character) 6807 Values []*string `type:"list"` 6808} 6809 6810// String returns the string representation 6811func (s RuleCondition) String() string { 6812 return awsutil.Prettify(s) 6813} 6814 6815// GoString returns the string representation 6816func (s RuleCondition) GoString() string { 6817 return s.String() 6818} 6819 6820// SetField sets the Field field's value. 6821func (s *RuleCondition) SetField(v string) *RuleCondition { 6822 s.Field = &v 6823 return s 6824} 6825 6826// SetValues sets the Values field's value. 6827func (s *RuleCondition) SetValues(v []*string) *RuleCondition { 6828 s.Values = v 6829 return s 6830} 6831 6832// Information about the priorities for the rules for a listener. 6833type RulePriorityPair struct { 6834 _ struct{} `type:"structure"` 6835 6836 // The rule priority. 6837 Priority *int64 `min:"1" type:"integer"` 6838 6839 // The Amazon Resource Name (ARN) of the rule. 6840 RuleArn *string `type:"string"` 6841} 6842 6843// String returns the string representation 6844func (s RulePriorityPair) String() string { 6845 return awsutil.Prettify(s) 6846} 6847 6848// GoString returns the string representation 6849func (s RulePriorityPair) GoString() string { 6850 return s.String() 6851} 6852 6853// Validate inspects the fields of the type to determine if they are valid. 6854func (s *RulePriorityPair) Validate() error { 6855 invalidParams := request.ErrInvalidParams{Context: "RulePriorityPair"} 6856 if s.Priority != nil && *s.Priority < 1 { 6857 invalidParams.Add(request.NewErrParamMinValue("Priority", 1)) 6858 } 6859 6860 if invalidParams.Len() > 0 { 6861 return invalidParams 6862 } 6863 return nil 6864} 6865 6866// SetPriority sets the Priority field's value. 6867func (s *RulePriorityPair) SetPriority(v int64) *RulePriorityPair { 6868 s.Priority = &v 6869 return s 6870} 6871 6872// SetRuleArn sets the RuleArn field's value. 6873func (s *RulePriorityPair) SetRuleArn(v string) *RulePriorityPair { 6874 s.RuleArn = &v 6875 return s 6876} 6877 6878type SetIpAddressTypeInput struct { 6879 _ struct{} `type:"structure"` 6880 6881 // The IP address type. The possible values are ipv4 (for IPv4 addresses) and 6882 // dualstack (for IPv4 and IPv6 addresses). Internal load balancers must use 6883 // ipv4. 6884 // 6885 // IpAddressType is a required field 6886 IpAddressType *string `type:"string" required:"true" enum:"IpAddressType"` 6887 6888 // The Amazon Resource Name (ARN) of the load balancer. 6889 // 6890 // LoadBalancerArn is a required field 6891 LoadBalancerArn *string `type:"string" required:"true"` 6892} 6893 6894// String returns the string representation 6895func (s SetIpAddressTypeInput) String() string { 6896 return awsutil.Prettify(s) 6897} 6898 6899// GoString returns the string representation 6900func (s SetIpAddressTypeInput) GoString() string { 6901 return s.String() 6902} 6903 6904// Validate inspects the fields of the type to determine if they are valid. 6905func (s *SetIpAddressTypeInput) Validate() error { 6906 invalidParams := request.ErrInvalidParams{Context: "SetIpAddressTypeInput"} 6907 if s.IpAddressType == nil { 6908 invalidParams.Add(request.NewErrParamRequired("IpAddressType")) 6909 } 6910 if s.LoadBalancerArn == nil { 6911 invalidParams.Add(request.NewErrParamRequired("LoadBalancerArn")) 6912 } 6913 6914 if invalidParams.Len() > 0 { 6915 return invalidParams 6916 } 6917 return nil 6918} 6919 6920// SetIpAddressType sets the IpAddressType field's value. 6921func (s *SetIpAddressTypeInput) SetIpAddressType(v string) *SetIpAddressTypeInput { 6922 s.IpAddressType = &v 6923 return s 6924} 6925 6926// SetLoadBalancerArn sets the LoadBalancerArn field's value. 6927func (s *SetIpAddressTypeInput) SetLoadBalancerArn(v string) *SetIpAddressTypeInput { 6928 s.LoadBalancerArn = &v 6929 return s 6930} 6931 6932type SetIpAddressTypeOutput struct { 6933 _ struct{} `type:"structure"` 6934 6935 // The IP address type. 6936 IpAddressType *string `type:"string" enum:"IpAddressType"` 6937} 6938 6939// String returns the string representation 6940func (s SetIpAddressTypeOutput) String() string { 6941 return awsutil.Prettify(s) 6942} 6943 6944// GoString returns the string representation 6945func (s SetIpAddressTypeOutput) GoString() string { 6946 return s.String() 6947} 6948 6949// SetIpAddressType sets the IpAddressType field's value. 6950func (s *SetIpAddressTypeOutput) SetIpAddressType(v string) *SetIpAddressTypeOutput { 6951 s.IpAddressType = &v 6952 return s 6953} 6954 6955type SetRulePrioritiesInput struct { 6956 _ struct{} `type:"structure"` 6957 6958 // The rule priorities. 6959 // 6960 // RulePriorities is a required field 6961 RulePriorities []*RulePriorityPair `type:"list" required:"true"` 6962} 6963 6964// String returns the string representation 6965func (s SetRulePrioritiesInput) String() string { 6966 return awsutil.Prettify(s) 6967} 6968 6969// GoString returns the string representation 6970func (s SetRulePrioritiesInput) GoString() string { 6971 return s.String() 6972} 6973 6974// Validate inspects the fields of the type to determine if they are valid. 6975func (s *SetRulePrioritiesInput) Validate() error { 6976 invalidParams := request.ErrInvalidParams{Context: "SetRulePrioritiesInput"} 6977 if s.RulePriorities == nil { 6978 invalidParams.Add(request.NewErrParamRequired("RulePriorities")) 6979 } 6980 if s.RulePriorities != nil { 6981 for i, v := range s.RulePriorities { 6982 if v == nil { 6983 continue 6984 } 6985 if err := v.Validate(); err != nil { 6986 invalidParams.AddNested(fmt.Sprintf("%s[%v]", "RulePriorities", i), err.(request.ErrInvalidParams)) 6987 } 6988 } 6989 } 6990 6991 if invalidParams.Len() > 0 { 6992 return invalidParams 6993 } 6994 return nil 6995} 6996 6997// SetRulePriorities sets the RulePriorities field's value. 6998func (s *SetRulePrioritiesInput) SetRulePriorities(v []*RulePriorityPair) *SetRulePrioritiesInput { 6999 s.RulePriorities = v 7000 return s 7001} 7002 7003type SetRulePrioritiesOutput struct { 7004 _ struct{} `type:"structure"` 7005 7006 // Information about the rules. 7007 Rules []*Rule `type:"list"` 7008} 7009 7010// String returns the string representation 7011func (s SetRulePrioritiesOutput) String() string { 7012 return awsutil.Prettify(s) 7013} 7014 7015// GoString returns the string representation 7016func (s SetRulePrioritiesOutput) GoString() string { 7017 return s.String() 7018} 7019 7020// SetRules sets the Rules field's value. 7021func (s *SetRulePrioritiesOutput) SetRules(v []*Rule) *SetRulePrioritiesOutput { 7022 s.Rules = v 7023 return s 7024} 7025 7026type SetSecurityGroupsInput struct { 7027 _ struct{} `type:"structure"` 7028 7029 // The Amazon Resource Name (ARN) of the load balancer. 7030 // 7031 // LoadBalancerArn is a required field 7032 LoadBalancerArn *string `type:"string" required:"true"` 7033 7034 // The IDs of the security groups. 7035 // 7036 // SecurityGroups is a required field 7037 SecurityGroups []*string `type:"list" required:"true"` 7038} 7039 7040// String returns the string representation 7041func (s SetSecurityGroupsInput) String() string { 7042 return awsutil.Prettify(s) 7043} 7044 7045// GoString returns the string representation 7046func (s SetSecurityGroupsInput) GoString() string { 7047 return s.String() 7048} 7049 7050// Validate inspects the fields of the type to determine if they are valid. 7051func (s *SetSecurityGroupsInput) Validate() error { 7052 invalidParams := request.ErrInvalidParams{Context: "SetSecurityGroupsInput"} 7053 if s.LoadBalancerArn == nil { 7054 invalidParams.Add(request.NewErrParamRequired("LoadBalancerArn")) 7055 } 7056 if s.SecurityGroups == nil { 7057 invalidParams.Add(request.NewErrParamRequired("SecurityGroups")) 7058 } 7059 7060 if invalidParams.Len() > 0 { 7061 return invalidParams 7062 } 7063 return nil 7064} 7065 7066// SetLoadBalancerArn sets the LoadBalancerArn field's value. 7067func (s *SetSecurityGroupsInput) SetLoadBalancerArn(v string) *SetSecurityGroupsInput { 7068 s.LoadBalancerArn = &v 7069 return s 7070} 7071 7072// SetSecurityGroups sets the SecurityGroups field's value. 7073func (s *SetSecurityGroupsInput) SetSecurityGroups(v []*string) *SetSecurityGroupsInput { 7074 s.SecurityGroups = v 7075 return s 7076} 7077 7078type SetSecurityGroupsOutput struct { 7079 _ struct{} `type:"structure"` 7080 7081 // The IDs of the security groups associated with the load balancer. 7082 SecurityGroupIds []*string `type:"list"` 7083} 7084 7085// String returns the string representation 7086func (s SetSecurityGroupsOutput) String() string { 7087 return awsutil.Prettify(s) 7088} 7089 7090// GoString returns the string representation 7091func (s SetSecurityGroupsOutput) GoString() string { 7092 return s.String() 7093} 7094 7095// SetSecurityGroupIds sets the SecurityGroupIds field's value. 7096func (s *SetSecurityGroupsOutput) SetSecurityGroupIds(v []*string) *SetSecurityGroupsOutput { 7097 s.SecurityGroupIds = v 7098 return s 7099} 7100 7101type SetSubnetsInput struct { 7102 _ struct{} `type:"structure"` 7103 7104 // The Amazon Resource Name (ARN) of the load balancer. 7105 // 7106 // LoadBalancerArn is a required field 7107 LoadBalancerArn *string `type:"string" required:"true"` 7108 7109 // The IDs of the public subnets. You must specify subnets from at least two 7110 // Availability Zones. You can specify only one subnet per Availability Zone. 7111 // You must specify either subnets or subnet mappings. 7112 // 7113 // You cannot specify Elastic IP addresses for your subnets. 7114 SubnetMappings []*SubnetMapping `type:"list"` 7115 7116 // The IDs of the public subnets. You must specify subnets from at least two 7117 // Availability Zones. You can specify only one subnet per Availability Zone. 7118 // You must specify either subnets or subnet mappings. 7119 // 7120 // Subnets is a required field 7121 Subnets []*string `type:"list" required:"true"` 7122} 7123 7124// String returns the string representation 7125func (s SetSubnetsInput) String() string { 7126 return awsutil.Prettify(s) 7127} 7128 7129// GoString returns the string representation 7130func (s SetSubnetsInput) GoString() string { 7131 return s.String() 7132} 7133 7134// Validate inspects the fields of the type to determine if they are valid. 7135func (s *SetSubnetsInput) Validate() error { 7136 invalidParams := request.ErrInvalidParams{Context: "SetSubnetsInput"} 7137 if s.LoadBalancerArn == nil { 7138 invalidParams.Add(request.NewErrParamRequired("LoadBalancerArn")) 7139 } 7140 if s.Subnets == nil { 7141 invalidParams.Add(request.NewErrParamRequired("Subnets")) 7142 } 7143 7144 if invalidParams.Len() > 0 { 7145 return invalidParams 7146 } 7147 return nil 7148} 7149 7150// SetLoadBalancerArn sets the LoadBalancerArn field's value. 7151func (s *SetSubnetsInput) SetLoadBalancerArn(v string) *SetSubnetsInput { 7152 s.LoadBalancerArn = &v 7153 return s 7154} 7155 7156// SetSubnetMappings sets the SubnetMappings field's value. 7157func (s *SetSubnetsInput) SetSubnetMappings(v []*SubnetMapping) *SetSubnetsInput { 7158 s.SubnetMappings = v 7159 return s 7160} 7161 7162// SetSubnets sets the Subnets field's value. 7163func (s *SetSubnetsInput) SetSubnets(v []*string) *SetSubnetsInput { 7164 s.Subnets = v 7165 return s 7166} 7167 7168type SetSubnetsOutput struct { 7169 _ struct{} `type:"structure"` 7170 7171 // Information about the subnet and Availability Zone. 7172 AvailabilityZones []*AvailabilityZone `type:"list"` 7173} 7174 7175// String returns the string representation 7176func (s SetSubnetsOutput) String() string { 7177 return awsutil.Prettify(s) 7178} 7179 7180// GoString returns the string representation 7181func (s SetSubnetsOutput) GoString() string { 7182 return s.String() 7183} 7184 7185// SetAvailabilityZones sets the AvailabilityZones field's value. 7186func (s *SetSubnetsOutput) SetAvailabilityZones(v []*AvailabilityZone) *SetSubnetsOutput { 7187 s.AvailabilityZones = v 7188 return s 7189} 7190 7191// Information about a policy used for SSL negotiation. 7192type SslPolicy struct { 7193 _ struct{} `type:"structure"` 7194 7195 // The ciphers. 7196 Ciphers []*Cipher `type:"list"` 7197 7198 // The name of the policy. 7199 Name *string `type:"string"` 7200 7201 // The protocols. 7202 SslProtocols []*string `type:"list"` 7203} 7204 7205// String returns the string representation 7206func (s SslPolicy) String() string { 7207 return awsutil.Prettify(s) 7208} 7209 7210// GoString returns the string representation 7211func (s SslPolicy) GoString() string { 7212 return s.String() 7213} 7214 7215// SetCiphers sets the Ciphers field's value. 7216func (s *SslPolicy) SetCiphers(v []*Cipher) *SslPolicy { 7217 s.Ciphers = v 7218 return s 7219} 7220 7221// SetName sets the Name field's value. 7222func (s *SslPolicy) SetName(v string) *SslPolicy { 7223 s.Name = &v 7224 return s 7225} 7226 7227// SetSslProtocols sets the SslProtocols field's value. 7228func (s *SslPolicy) SetSslProtocols(v []*string) *SslPolicy { 7229 s.SslProtocols = v 7230 return s 7231} 7232 7233// Information about a subnet mapping. 7234type SubnetMapping struct { 7235 _ struct{} `type:"structure"` 7236 7237 // [Network Load Balancers] The allocation ID of the Elastic IP address. 7238 AllocationId *string `type:"string"` 7239 7240 // The ID of the subnet. 7241 SubnetId *string `type:"string"` 7242} 7243 7244// String returns the string representation 7245func (s SubnetMapping) String() string { 7246 return awsutil.Prettify(s) 7247} 7248 7249// GoString returns the string representation 7250func (s SubnetMapping) GoString() string { 7251 return s.String() 7252} 7253 7254// SetAllocationId sets the AllocationId field's value. 7255func (s *SubnetMapping) SetAllocationId(v string) *SubnetMapping { 7256 s.AllocationId = &v 7257 return s 7258} 7259 7260// SetSubnetId sets the SubnetId field's value. 7261func (s *SubnetMapping) SetSubnetId(v string) *SubnetMapping { 7262 s.SubnetId = &v 7263 return s 7264} 7265 7266// Information about a tag. 7267type Tag struct { 7268 _ struct{} `type:"structure"` 7269 7270 // The key of the tag. 7271 // 7272 // Key is a required field 7273 Key *string `min:"1" type:"string" required:"true"` 7274 7275 // The value of the tag. 7276 Value *string `type:"string"` 7277} 7278 7279// String returns the string representation 7280func (s Tag) String() string { 7281 return awsutil.Prettify(s) 7282} 7283 7284// GoString returns the string representation 7285func (s Tag) GoString() string { 7286 return s.String() 7287} 7288 7289// Validate inspects the fields of the type to determine if they are valid. 7290func (s *Tag) Validate() error { 7291 invalidParams := request.ErrInvalidParams{Context: "Tag"} 7292 if s.Key == nil { 7293 invalidParams.Add(request.NewErrParamRequired("Key")) 7294 } 7295 if s.Key != nil && len(*s.Key) < 1 { 7296 invalidParams.Add(request.NewErrParamMinLen("Key", 1)) 7297 } 7298 7299 if invalidParams.Len() > 0 { 7300 return invalidParams 7301 } 7302 return nil 7303} 7304 7305// SetKey sets the Key field's value. 7306func (s *Tag) SetKey(v string) *Tag { 7307 s.Key = &v 7308 return s 7309} 7310 7311// SetValue sets the Value field's value. 7312func (s *Tag) SetValue(v string) *Tag { 7313 s.Value = &v 7314 return s 7315} 7316 7317// The tags associated with a resource. 7318type TagDescription struct { 7319 _ struct{} `type:"structure"` 7320 7321 // The Amazon Resource Name (ARN) of the resource. 7322 ResourceArn *string `type:"string"` 7323 7324 // Information about the tags. 7325 Tags []*Tag `min:"1" type:"list"` 7326} 7327 7328// String returns the string representation 7329func (s TagDescription) String() string { 7330 return awsutil.Prettify(s) 7331} 7332 7333// GoString returns the string representation 7334func (s TagDescription) GoString() string { 7335 return s.String() 7336} 7337 7338// SetResourceArn sets the ResourceArn field's value. 7339func (s *TagDescription) SetResourceArn(v string) *TagDescription { 7340 s.ResourceArn = &v 7341 return s 7342} 7343 7344// SetTags sets the Tags field's value. 7345func (s *TagDescription) SetTags(v []*Tag) *TagDescription { 7346 s.Tags = v 7347 return s 7348} 7349 7350// Information about a target. 7351type TargetDescription struct { 7352 _ struct{} `type:"structure"` 7353 7354 // An Availability Zone or all. This determines whether the target receives 7355 // traffic from the load balancer nodes in the specified Availability Zone or 7356 // from all enabled Availability Zones for the load balancer. 7357 // 7358 // This parameter is not supported if the target type of the target group is 7359 // instance. If the IP address is in a subnet of the VPC for the target group, 7360 // the Availability Zone is automatically detected and this parameter is optional. 7361 // If the IP address is outside the VPC, this parameter is required. 7362 // 7363 // With an Application Load Balancer, if the IP address is outside the VPC for 7364 // the target group, the only supported value is all. 7365 AvailabilityZone *string `type:"string"` 7366 7367 // The ID of the target. If the target type of the target group is instance, 7368 // specify an instance ID. If the target type is ip, specify an IP address. 7369 // 7370 // Id is a required field 7371 Id *string `type:"string" required:"true"` 7372 7373 // The port on which the target is listening. 7374 Port *int64 `min:"1" type:"integer"` 7375} 7376 7377// String returns the string representation 7378func (s TargetDescription) String() string { 7379 return awsutil.Prettify(s) 7380} 7381 7382// GoString returns the string representation 7383func (s TargetDescription) GoString() string { 7384 return s.String() 7385} 7386 7387// Validate inspects the fields of the type to determine if they are valid. 7388func (s *TargetDescription) Validate() error { 7389 invalidParams := request.ErrInvalidParams{Context: "TargetDescription"} 7390 if s.Id == nil { 7391 invalidParams.Add(request.NewErrParamRequired("Id")) 7392 } 7393 if s.Port != nil && *s.Port < 1 { 7394 invalidParams.Add(request.NewErrParamMinValue("Port", 1)) 7395 } 7396 7397 if invalidParams.Len() > 0 { 7398 return invalidParams 7399 } 7400 return nil 7401} 7402 7403// SetAvailabilityZone sets the AvailabilityZone field's value. 7404func (s *TargetDescription) SetAvailabilityZone(v string) *TargetDescription { 7405 s.AvailabilityZone = &v 7406 return s 7407} 7408 7409// SetId sets the Id field's value. 7410func (s *TargetDescription) SetId(v string) *TargetDescription { 7411 s.Id = &v 7412 return s 7413} 7414 7415// SetPort sets the Port field's value. 7416func (s *TargetDescription) SetPort(v int64) *TargetDescription { 7417 s.Port = &v 7418 return s 7419} 7420 7421// Information about a target group. 7422type TargetGroup struct { 7423 _ struct{} `type:"structure"` 7424 7425 // The approximate amount of time, in seconds, between health checks of an individual 7426 // target. 7427 HealthCheckIntervalSeconds *int64 `min:"5" type:"integer"` 7428 7429 // The destination for the health check request. 7430 HealthCheckPath *string `min:"1" type:"string"` 7431 7432 // The port to use to connect with the target. 7433 HealthCheckPort *string `type:"string"` 7434 7435 // The protocol to use to connect with the target. 7436 HealthCheckProtocol *string `type:"string" enum:"ProtocolEnum"` 7437 7438 // The amount of time, in seconds, during which no response means a failed health 7439 // check. 7440 HealthCheckTimeoutSeconds *int64 `min:"2" type:"integer"` 7441 7442 // The number of consecutive health checks successes required before considering 7443 // an unhealthy target healthy. 7444 HealthyThresholdCount *int64 `min:"2" type:"integer"` 7445 7446 // The Amazon Resource Names (ARN) of the load balancers that route traffic 7447 // to this target group. 7448 LoadBalancerArns []*string `type:"list"` 7449 7450 // The HTTP codes to use when checking for a successful response from a target. 7451 Matcher *Matcher `type:"structure"` 7452 7453 // The port on which the targets are listening. 7454 Port *int64 `min:"1" type:"integer"` 7455 7456 // The protocol to use for routing traffic to the targets. 7457 Protocol *string `type:"string" enum:"ProtocolEnum"` 7458 7459 // The Amazon Resource Name (ARN) of the target group. 7460 TargetGroupArn *string `type:"string"` 7461 7462 // The name of the target group. 7463 TargetGroupName *string `type:"string"` 7464 7465 // The type of target that you must specify when registering targets with this 7466 // target group. The possible values are instance (targets are specified by 7467 // instance ID) or ip (targets are specified by IP address). 7468 TargetType *string `type:"string" enum:"TargetTypeEnum"` 7469 7470 // The number of consecutive health check failures required before considering 7471 // the target unhealthy. 7472 UnhealthyThresholdCount *int64 `min:"2" type:"integer"` 7473 7474 // The ID of the VPC for the targets. 7475 VpcId *string `type:"string"` 7476} 7477 7478// String returns the string representation 7479func (s TargetGroup) String() string { 7480 return awsutil.Prettify(s) 7481} 7482 7483// GoString returns the string representation 7484func (s TargetGroup) GoString() string { 7485 return s.String() 7486} 7487 7488// SetHealthCheckIntervalSeconds sets the HealthCheckIntervalSeconds field's value. 7489func (s *TargetGroup) SetHealthCheckIntervalSeconds(v int64) *TargetGroup { 7490 s.HealthCheckIntervalSeconds = &v 7491 return s 7492} 7493 7494// SetHealthCheckPath sets the HealthCheckPath field's value. 7495func (s *TargetGroup) SetHealthCheckPath(v string) *TargetGroup { 7496 s.HealthCheckPath = &v 7497 return s 7498} 7499 7500// SetHealthCheckPort sets the HealthCheckPort field's value. 7501func (s *TargetGroup) SetHealthCheckPort(v string) *TargetGroup { 7502 s.HealthCheckPort = &v 7503 return s 7504} 7505 7506// SetHealthCheckProtocol sets the HealthCheckProtocol field's value. 7507func (s *TargetGroup) SetHealthCheckProtocol(v string) *TargetGroup { 7508 s.HealthCheckProtocol = &v 7509 return s 7510} 7511 7512// SetHealthCheckTimeoutSeconds sets the HealthCheckTimeoutSeconds field's value. 7513func (s *TargetGroup) SetHealthCheckTimeoutSeconds(v int64) *TargetGroup { 7514 s.HealthCheckTimeoutSeconds = &v 7515 return s 7516} 7517 7518// SetHealthyThresholdCount sets the HealthyThresholdCount field's value. 7519func (s *TargetGroup) SetHealthyThresholdCount(v int64) *TargetGroup { 7520 s.HealthyThresholdCount = &v 7521 return s 7522} 7523 7524// SetLoadBalancerArns sets the LoadBalancerArns field's value. 7525func (s *TargetGroup) SetLoadBalancerArns(v []*string) *TargetGroup { 7526 s.LoadBalancerArns = v 7527 return s 7528} 7529 7530// SetMatcher sets the Matcher field's value. 7531func (s *TargetGroup) SetMatcher(v *Matcher) *TargetGroup { 7532 s.Matcher = v 7533 return s 7534} 7535 7536// SetPort sets the Port field's value. 7537func (s *TargetGroup) SetPort(v int64) *TargetGroup { 7538 s.Port = &v 7539 return s 7540} 7541 7542// SetProtocol sets the Protocol field's value. 7543func (s *TargetGroup) SetProtocol(v string) *TargetGroup { 7544 s.Protocol = &v 7545 return s 7546} 7547 7548// SetTargetGroupArn sets the TargetGroupArn field's value. 7549func (s *TargetGroup) SetTargetGroupArn(v string) *TargetGroup { 7550 s.TargetGroupArn = &v 7551 return s 7552} 7553 7554// SetTargetGroupName sets the TargetGroupName field's value. 7555func (s *TargetGroup) SetTargetGroupName(v string) *TargetGroup { 7556 s.TargetGroupName = &v 7557 return s 7558} 7559 7560// SetTargetType sets the TargetType field's value. 7561func (s *TargetGroup) SetTargetType(v string) *TargetGroup { 7562 s.TargetType = &v 7563 return s 7564} 7565 7566// SetUnhealthyThresholdCount sets the UnhealthyThresholdCount field's value. 7567func (s *TargetGroup) SetUnhealthyThresholdCount(v int64) *TargetGroup { 7568 s.UnhealthyThresholdCount = &v 7569 return s 7570} 7571 7572// SetVpcId sets the VpcId field's value. 7573func (s *TargetGroup) SetVpcId(v string) *TargetGroup { 7574 s.VpcId = &v 7575 return s 7576} 7577 7578// Information about a target group attribute. 7579type TargetGroupAttribute struct { 7580 _ struct{} `type:"structure"` 7581 7582 // The name of the attribute. 7583 // 7584 // * deregistration_delay.timeout_seconds - The amount time for Elastic Load 7585 // Balancing to wait before changing the state of a deregistering target 7586 // from draining to unused. The range is 0-3600 seconds. The default value 7587 // is 300 seconds. 7588 // 7589 // * proxy_protocol_v2.enabled - [Network Load Balancers] Indicates whether 7590 // Proxy Protocol version 2 is enabled. 7591 // 7592 // * stickiness.enabled - [Application Load Balancers] Indicates whether 7593 // sticky sessions are enabled. The value is true or false. 7594 // 7595 // * stickiness.type - [Application Load Balancers] The type of sticky sessions. 7596 // The possible value is lb_cookie. 7597 // 7598 // * stickiness.lb_cookie.duration_seconds - [Application Load Balancers] 7599 // The time period, in seconds, during which requests from a client should 7600 // be routed to the same target. After this time period expires, the load 7601 // balancer-generated cookie is considered stale. The range is 1 second to 7602 // 1 week (604800 seconds). The default value is 1 day (86400 seconds). 7603 Key *string `type:"string"` 7604 7605 // The value of the attribute. 7606 Value *string `type:"string"` 7607} 7608 7609// String returns the string representation 7610func (s TargetGroupAttribute) String() string { 7611 return awsutil.Prettify(s) 7612} 7613 7614// GoString returns the string representation 7615func (s TargetGroupAttribute) GoString() string { 7616 return s.String() 7617} 7618 7619// SetKey sets the Key field's value. 7620func (s *TargetGroupAttribute) SetKey(v string) *TargetGroupAttribute { 7621 s.Key = &v 7622 return s 7623} 7624 7625// SetValue sets the Value field's value. 7626func (s *TargetGroupAttribute) SetValue(v string) *TargetGroupAttribute { 7627 s.Value = &v 7628 return s 7629} 7630 7631// Information about the current health of a target. 7632type TargetHealth struct { 7633 _ struct{} `type:"structure"` 7634 7635 // A description of the target health that provides additional details. If the 7636 // state is healthy, a description is not provided. 7637 Description *string `type:"string"` 7638 7639 // The reason code. If the target state is healthy, a reason code is not provided. 7640 // 7641 // If the target state is initial, the reason code can be one of the following 7642 // values: 7643 // 7644 // * Elb.RegistrationInProgress - The target is in the process of being registered 7645 // with the load balancer. 7646 // 7647 // * Elb.InitialHealthChecking - The load balancer is still sending the target 7648 // the minimum number of health checks required to determine its health status. 7649 // 7650 // If the target state is unhealthy, the reason code can be one of the following 7651 // values: 7652 // 7653 // * Target.ResponseCodeMismatch - The health checks did not return an expected 7654 // HTTP code. 7655 // 7656 // * Target.Timeout - The health check requests timed out. 7657 // 7658 // * Target.FailedHealthChecks - The health checks failed because the connection 7659 // to the target timed out, the target response was malformed, or the target 7660 // failed the health check for an unknown reason. 7661 // 7662 // * Elb.InternalError - The health checks failed due to an internal error. 7663 // 7664 // If the target state is unused, the reason code can be one of the following 7665 // values: 7666 // 7667 // * Target.NotRegistered - The target is not registered with the target 7668 // group. 7669 // 7670 // * Target.NotInUse - The target group is not used by any load balancer 7671 // or the target is in an Availability Zone that is not enabled for its load 7672 // balancer. 7673 // 7674 // * Target.IpUnusable - The target IP address is reserved for use by a load 7675 // balancer. 7676 // 7677 // * Target.InvalidState - The target is in the stopped or terminated state. 7678 // 7679 // If the target state is draining, the reason code can be the following value: 7680 // 7681 // * Target.DeregistrationInProgress - The target is in the process of being 7682 // deregistered and the deregistration delay period has not expired. 7683 Reason *string `type:"string" enum:"TargetHealthReasonEnum"` 7684 7685 // The state of the target. 7686 State *string `type:"string" enum:"TargetHealthStateEnum"` 7687} 7688 7689// String returns the string representation 7690func (s TargetHealth) String() string { 7691 return awsutil.Prettify(s) 7692} 7693 7694// GoString returns the string representation 7695func (s TargetHealth) GoString() string { 7696 return s.String() 7697} 7698 7699// SetDescription sets the Description field's value. 7700func (s *TargetHealth) SetDescription(v string) *TargetHealth { 7701 s.Description = &v 7702 return s 7703} 7704 7705// SetReason sets the Reason field's value. 7706func (s *TargetHealth) SetReason(v string) *TargetHealth { 7707 s.Reason = &v 7708 return s 7709} 7710 7711// SetState sets the State field's value. 7712func (s *TargetHealth) SetState(v string) *TargetHealth { 7713 s.State = &v 7714 return s 7715} 7716 7717// Information about the health of a target. 7718type TargetHealthDescription struct { 7719 _ struct{} `type:"structure"` 7720 7721 // The port to use to connect with the target. 7722 HealthCheckPort *string `type:"string"` 7723 7724 // The description of the target. 7725 Target *TargetDescription `type:"structure"` 7726 7727 // The health information for the target. 7728 TargetHealth *TargetHealth `type:"structure"` 7729} 7730 7731// String returns the string representation 7732func (s TargetHealthDescription) String() string { 7733 return awsutil.Prettify(s) 7734} 7735 7736// GoString returns the string representation 7737func (s TargetHealthDescription) GoString() string { 7738 return s.String() 7739} 7740 7741// SetHealthCheckPort sets the HealthCheckPort field's value. 7742func (s *TargetHealthDescription) SetHealthCheckPort(v string) *TargetHealthDescription { 7743 s.HealthCheckPort = &v 7744 return s 7745} 7746 7747// SetTarget sets the Target field's value. 7748func (s *TargetHealthDescription) SetTarget(v *TargetDescription) *TargetHealthDescription { 7749 s.Target = v 7750 return s 7751} 7752 7753// SetTargetHealth sets the TargetHealth field's value. 7754func (s *TargetHealthDescription) SetTargetHealth(v *TargetHealth) *TargetHealthDescription { 7755 s.TargetHealth = v 7756 return s 7757} 7758 7759const ( 7760 // ActionTypeEnumForward is a ActionTypeEnum enum value 7761 ActionTypeEnumForward = "forward" 7762) 7763 7764const ( 7765 // IpAddressTypeIpv4 is a IpAddressType enum value 7766 IpAddressTypeIpv4 = "ipv4" 7767 7768 // IpAddressTypeDualstack is a IpAddressType enum value 7769 IpAddressTypeDualstack = "dualstack" 7770) 7771 7772const ( 7773 // LoadBalancerSchemeEnumInternetFacing is a LoadBalancerSchemeEnum enum value 7774 LoadBalancerSchemeEnumInternetFacing = "internet-facing" 7775 7776 // LoadBalancerSchemeEnumInternal is a LoadBalancerSchemeEnum enum value 7777 LoadBalancerSchemeEnumInternal = "internal" 7778) 7779 7780const ( 7781 // LoadBalancerStateEnumActive is a LoadBalancerStateEnum enum value 7782 LoadBalancerStateEnumActive = "active" 7783 7784 // LoadBalancerStateEnumProvisioning is a LoadBalancerStateEnum enum value 7785 LoadBalancerStateEnumProvisioning = "provisioning" 7786 7787 // LoadBalancerStateEnumActiveImpaired is a LoadBalancerStateEnum enum value 7788 LoadBalancerStateEnumActiveImpaired = "active_impaired" 7789 7790 // LoadBalancerStateEnumFailed is a LoadBalancerStateEnum enum value 7791 LoadBalancerStateEnumFailed = "failed" 7792) 7793 7794const ( 7795 // LoadBalancerTypeEnumApplication is a LoadBalancerTypeEnum enum value 7796 LoadBalancerTypeEnumApplication = "application" 7797 7798 // LoadBalancerTypeEnumNetwork is a LoadBalancerTypeEnum enum value 7799 LoadBalancerTypeEnumNetwork = "network" 7800) 7801 7802const ( 7803 // ProtocolEnumHttp is a ProtocolEnum enum value 7804 ProtocolEnumHttp = "HTTP" 7805 7806 // ProtocolEnumHttps is a ProtocolEnum enum value 7807 ProtocolEnumHttps = "HTTPS" 7808 7809 // ProtocolEnumTcp is a ProtocolEnum enum value 7810 ProtocolEnumTcp = "TCP" 7811) 7812 7813const ( 7814 // TargetHealthReasonEnumElbRegistrationInProgress is a TargetHealthReasonEnum enum value 7815 TargetHealthReasonEnumElbRegistrationInProgress = "Elb.RegistrationInProgress" 7816 7817 // TargetHealthReasonEnumElbInitialHealthChecking is a TargetHealthReasonEnum enum value 7818 TargetHealthReasonEnumElbInitialHealthChecking = "Elb.InitialHealthChecking" 7819 7820 // TargetHealthReasonEnumTargetResponseCodeMismatch is a TargetHealthReasonEnum enum value 7821 TargetHealthReasonEnumTargetResponseCodeMismatch = "Target.ResponseCodeMismatch" 7822 7823 // TargetHealthReasonEnumTargetTimeout is a TargetHealthReasonEnum enum value 7824 TargetHealthReasonEnumTargetTimeout = "Target.Timeout" 7825 7826 // TargetHealthReasonEnumTargetFailedHealthChecks is a TargetHealthReasonEnum enum value 7827 TargetHealthReasonEnumTargetFailedHealthChecks = "Target.FailedHealthChecks" 7828 7829 // TargetHealthReasonEnumTargetNotRegistered is a TargetHealthReasonEnum enum value 7830 TargetHealthReasonEnumTargetNotRegistered = "Target.NotRegistered" 7831 7832 // TargetHealthReasonEnumTargetNotInUse is a TargetHealthReasonEnum enum value 7833 TargetHealthReasonEnumTargetNotInUse = "Target.NotInUse" 7834 7835 // TargetHealthReasonEnumTargetDeregistrationInProgress is a TargetHealthReasonEnum enum value 7836 TargetHealthReasonEnumTargetDeregistrationInProgress = "Target.DeregistrationInProgress" 7837 7838 // TargetHealthReasonEnumTargetInvalidState is a TargetHealthReasonEnum enum value 7839 TargetHealthReasonEnumTargetInvalidState = "Target.InvalidState" 7840 7841 // TargetHealthReasonEnumTargetIpUnusable is a TargetHealthReasonEnum enum value 7842 TargetHealthReasonEnumTargetIpUnusable = "Target.IpUnusable" 7843 7844 // TargetHealthReasonEnumElbInternalError is a TargetHealthReasonEnum enum value 7845 TargetHealthReasonEnumElbInternalError = "Elb.InternalError" 7846) 7847 7848const ( 7849 // TargetHealthStateEnumInitial is a TargetHealthStateEnum enum value 7850 TargetHealthStateEnumInitial = "initial" 7851 7852 // TargetHealthStateEnumHealthy is a TargetHealthStateEnum enum value 7853 TargetHealthStateEnumHealthy = "healthy" 7854 7855 // TargetHealthStateEnumUnhealthy is a TargetHealthStateEnum enum value 7856 TargetHealthStateEnumUnhealthy = "unhealthy" 7857 7858 // TargetHealthStateEnumUnused is a TargetHealthStateEnum enum value 7859 TargetHealthStateEnumUnused = "unused" 7860 7861 // TargetHealthStateEnumDraining is a TargetHealthStateEnum enum value 7862 TargetHealthStateEnumDraining = "draining" 7863 7864 // TargetHealthStateEnumUnavailable is a TargetHealthStateEnum enum value 7865 TargetHealthStateEnumUnavailable = "unavailable" 7866) 7867 7868const ( 7869 // TargetTypeEnumInstance is a TargetTypeEnum enum value 7870 TargetTypeEnumInstance = "instance" 7871 7872 // TargetTypeEnumIp is a TargetTypeEnum enum value 7873 TargetTypeEnumIp = "ip" 7874) 7875