1// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. 2 3package elb 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 "github.com/aws/aws-sdk-go/private/protocol" 13 "github.com/aws/aws-sdk-go/private/protocol/query" 14) 15 16const opAddTags = "AddTags" 17 18// AddTagsRequest generates a "aws/request.Request" representing the 19// client's request for the AddTags operation. The "output" return 20// value will be populated with the request's response once the request completes 21// successfully. 22// 23// Use "Send" method on the returned Request to send the API call to the service. 24// the "output" return value is not valid until after Send returns without error. 25// 26// See AddTags for more information on using the AddTags 27// API call, and error handling. 28// 29// This method is useful when you want to inject custom logic or configuration 30// into the SDK's request lifecycle. Such as custom headers, or retry logic. 31// 32// 33// // Example sending a request using the AddTagsRequest method. 34// req, resp := client.AddTagsRequest(params) 35// 36// err := req.Send() 37// if err == nil { // resp is now filled 38// fmt.Println(resp) 39// } 40// 41// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/AddTags 42func (c *ELB) AddTagsRequest(input *AddTagsInput) (req *request.Request, output *AddTagsOutput) { 43 op := &request.Operation{ 44 Name: opAddTags, 45 HTTPMethod: "POST", 46 HTTPPath: "/", 47 } 48 49 if input == nil { 50 input = &AddTagsInput{} 51 } 52 53 output = &AddTagsOutput{} 54 req = c.newRequest(op, input, output) 55 req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 56 return 57} 58 59// AddTags API operation for Elastic Load Balancing. 60// 61// Adds the specified tags to the specified load balancer. Each load balancer 62// can have a maximum of 10 tags. 63// 64// Each tag consists of a key and an optional value. If a tag with the same 65// key is already associated with the load balancer, AddTags updates its value. 66// 67// For more information, see Tag Your Classic Load Balancer (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/add-remove-tags.html) 68// in the Classic Load Balancers Guide. 69// 70// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 71// with awserr.Error's Code and Message methods to get detailed information about 72// the error. 73// 74// See the AWS API reference guide for Elastic Load Balancing's 75// API operation AddTags for usage and error information. 76// 77// Returned Error Codes: 78// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 79// The specified load balancer does not exist. 80// 81// * ErrCodeTooManyTagsException "TooManyTags" 82// The quota for the number of tags that can be assigned to a load balancer 83// has been reached. 84// 85// * ErrCodeDuplicateTagKeysException "DuplicateTagKeys" 86// A tag key was specified more than once. 87// 88// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/AddTags 89func (c *ELB) AddTags(input *AddTagsInput) (*AddTagsOutput, error) { 90 req, out := c.AddTagsRequest(input) 91 return out, req.Send() 92} 93 94// AddTagsWithContext is the same as AddTags with the addition of 95// the ability to pass a context and additional request options. 96// 97// See AddTags for details on how to use this API operation. 98// 99// The context must be non-nil and will be used for request cancellation. If 100// the context is nil a panic will occur. In the future the SDK may create 101// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 102// for more information on using Contexts. 103func (c *ELB) AddTagsWithContext(ctx aws.Context, input *AddTagsInput, opts ...request.Option) (*AddTagsOutput, error) { 104 req, out := c.AddTagsRequest(input) 105 req.SetContext(ctx) 106 req.ApplyOptions(opts...) 107 return out, req.Send() 108} 109 110const opApplySecurityGroupsToLoadBalancer = "ApplySecurityGroupsToLoadBalancer" 111 112// ApplySecurityGroupsToLoadBalancerRequest generates a "aws/request.Request" representing the 113// client's request for the ApplySecurityGroupsToLoadBalancer operation. The "output" return 114// value will be populated with the request's response once the request completes 115// successfully. 116// 117// Use "Send" method on the returned Request to send the API call to the service. 118// the "output" return value is not valid until after Send returns without error. 119// 120// See ApplySecurityGroupsToLoadBalancer for more information on using the ApplySecurityGroupsToLoadBalancer 121// API call, and error handling. 122// 123// This method is useful when you want to inject custom logic or configuration 124// into the SDK's request lifecycle. Such as custom headers, or retry logic. 125// 126// 127// // Example sending a request using the ApplySecurityGroupsToLoadBalancerRequest method. 128// req, resp := client.ApplySecurityGroupsToLoadBalancerRequest(params) 129// 130// err := req.Send() 131// if err == nil { // resp is now filled 132// fmt.Println(resp) 133// } 134// 135// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/ApplySecurityGroupsToLoadBalancer 136func (c *ELB) ApplySecurityGroupsToLoadBalancerRequest(input *ApplySecurityGroupsToLoadBalancerInput) (req *request.Request, output *ApplySecurityGroupsToLoadBalancerOutput) { 137 op := &request.Operation{ 138 Name: opApplySecurityGroupsToLoadBalancer, 139 HTTPMethod: "POST", 140 HTTPPath: "/", 141 } 142 143 if input == nil { 144 input = &ApplySecurityGroupsToLoadBalancerInput{} 145 } 146 147 output = &ApplySecurityGroupsToLoadBalancerOutput{} 148 req = c.newRequest(op, input, output) 149 return 150} 151 152// ApplySecurityGroupsToLoadBalancer API operation for Elastic Load Balancing. 153// 154// Associates one or more security groups with your load balancer in a virtual 155// private cloud (VPC). The specified security groups override the previously 156// associated security groups. 157// 158// For more information, see Security Groups for Load Balancers in a VPC (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-security-groups.html#elb-vpc-security-groups) 159// in the Classic Load Balancers Guide. 160// 161// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 162// with awserr.Error's Code and Message methods to get detailed information about 163// the error. 164// 165// See the AWS API reference guide for Elastic Load Balancing's 166// API operation ApplySecurityGroupsToLoadBalancer for usage and error information. 167// 168// Returned Error Codes: 169// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 170// The specified load balancer does not exist. 171// 172// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 173// The requested configuration change is not valid. 174// 175// * ErrCodeInvalidSecurityGroupException "InvalidSecurityGroup" 176// One or more of the specified security groups do not exist. 177// 178// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/ApplySecurityGroupsToLoadBalancer 179func (c *ELB) ApplySecurityGroupsToLoadBalancer(input *ApplySecurityGroupsToLoadBalancerInput) (*ApplySecurityGroupsToLoadBalancerOutput, error) { 180 req, out := c.ApplySecurityGroupsToLoadBalancerRequest(input) 181 return out, req.Send() 182} 183 184// ApplySecurityGroupsToLoadBalancerWithContext is the same as ApplySecurityGroupsToLoadBalancer with the addition of 185// the ability to pass a context and additional request options. 186// 187// See ApplySecurityGroupsToLoadBalancer for details on how to use this API operation. 188// 189// The context must be non-nil and will be used for request cancellation. If 190// the context is nil a panic will occur. In the future the SDK may create 191// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 192// for more information on using Contexts. 193func (c *ELB) ApplySecurityGroupsToLoadBalancerWithContext(ctx aws.Context, input *ApplySecurityGroupsToLoadBalancerInput, opts ...request.Option) (*ApplySecurityGroupsToLoadBalancerOutput, error) { 194 req, out := c.ApplySecurityGroupsToLoadBalancerRequest(input) 195 req.SetContext(ctx) 196 req.ApplyOptions(opts...) 197 return out, req.Send() 198} 199 200const opAttachLoadBalancerToSubnets = "AttachLoadBalancerToSubnets" 201 202// AttachLoadBalancerToSubnetsRequest generates a "aws/request.Request" representing the 203// client's request for the AttachLoadBalancerToSubnets operation. The "output" return 204// value will be populated with the request's response once the request completes 205// successfully. 206// 207// Use "Send" method on the returned Request to send the API call to the service. 208// the "output" return value is not valid until after Send returns without error. 209// 210// See AttachLoadBalancerToSubnets for more information on using the AttachLoadBalancerToSubnets 211// API call, and error handling. 212// 213// This method is useful when you want to inject custom logic or configuration 214// into the SDK's request lifecycle. Such as custom headers, or retry logic. 215// 216// 217// // Example sending a request using the AttachLoadBalancerToSubnetsRequest method. 218// req, resp := client.AttachLoadBalancerToSubnetsRequest(params) 219// 220// err := req.Send() 221// if err == nil { // resp is now filled 222// fmt.Println(resp) 223// } 224// 225// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/AttachLoadBalancerToSubnets 226func (c *ELB) AttachLoadBalancerToSubnetsRequest(input *AttachLoadBalancerToSubnetsInput) (req *request.Request, output *AttachLoadBalancerToSubnetsOutput) { 227 op := &request.Operation{ 228 Name: opAttachLoadBalancerToSubnets, 229 HTTPMethod: "POST", 230 HTTPPath: "/", 231 } 232 233 if input == nil { 234 input = &AttachLoadBalancerToSubnetsInput{} 235 } 236 237 output = &AttachLoadBalancerToSubnetsOutput{} 238 req = c.newRequest(op, input, output) 239 return 240} 241 242// AttachLoadBalancerToSubnets API operation for Elastic Load Balancing. 243// 244// Adds one or more subnets to the set of configured subnets for the specified 245// load balancer. 246// 247// The load balancer evenly distributes requests across all registered subnets. 248// For more information, see Add or Remove Subnets for Your Load Balancer in 249// a VPC (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-manage-subnets.html) 250// in the Classic Load Balancers Guide. 251// 252// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 253// with awserr.Error's Code and Message methods to get detailed information about 254// the error. 255// 256// See the AWS API reference guide for Elastic Load Balancing's 257// API operation AttachLoadBalancerToSubnets for usage and error information. 258// 259// Returned Error Codes: 260// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 261// The specified load balancer does not exist. 262// 263// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 264// The requested configuration change is not valid. 265// 266// * ErrCodeSubnetNotFoundException "SubnetNotFound" 267// One or more of the specified subnets do not exist. 268// 269// * ErrCodeInvalidSubnetException "InvalidSubnet" 270// The specified VPC has no associated Internet gateway. 271// 272// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/AttachLoadBalancerToSubnets 273func (c *ELB) AttachLoadBalancerToSubnets(input *AttachLoadBalancerToSubnetsInput) (*AttachLoadBalancerToSubnetsOutput, error) { 274 req, out := c.AttachLoadBalancerToSubnetsRequest(input) 275 return out, req.Send() 276} 277 278// AttachLoadBalancerToSubnetsWithContext is the same as AttachLoadBalancerToSubnets with the addition of 279// the ability to pass a context and additional request options. 280// 281// See AttachLoadBalancerToSubnets for details on how to use this API operation. 282// 283// The context must be non-nil and will be used for request cancellation. If 284// the context is nil a panic will occur. In the future the SDK may create 285// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 286// for more information on using Contexts. 287func (c *ELB) AttachLoadBalancerToSubnetsWithContext(ctx aws.Context, input *AttachLoadBalancerToSubnetsInput, opts ...request.Option) (*AttachLoadBalancerToSubnetsOutput, error) { 288 req, out := c.AttachLoadBalancerToSubnetsRequest(input) 289 req.SetContext(ctx) 290 req.ApplyOptions(opts...) 291 return out, req.Send() 292} 293 294const opConfigureHealthCheck = "ConfigureHealthCheck" 295 296// ConfigureHealthCheckRequest generates a "aws/request.Request" representing the 297// client's request for the ConfigureHealthCheck operation. The "output" return 298// value will be populated with the request's response once the request completes 299// successfully. 300// 301// Use "Send" method on the returned Request to send the API call to the service. 302// the "output" return value is not valid until after Send returns without error. 303// 304// See ConfigureHealthCheck for more information on using the ConfigureHealthCheck 305// API call, and error handling. 306// 307// This method is useful when you want to inject custom logic or configuration 308// into the SDK's request lifecycle. Such as custom headers, or retry logic. 309// 310// 311// // Example sending a request using the ConfigureHealthCheckRequest method. 312// req, resp := client.ConfigureHealthCheckRequest(params) 313// 314// err := req.Send() 315// if err == nil { // resp is now filled 316// fmt.Println(resp) 317// } 318// 319// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/ConfigureHealthCheck 320func (c *ELB) ConfigureHealthCheckRequest(input *ConfigureHealthCheckInput) (req *request.Request, output *ConfigureHealthCheckOutput) { 321 op := &request.Operation{ 322 Name: opConfigureHealthCheck, 323 HTTPMethod: "POST", 324 HTTPPath: "/", 325 } 326 327 if input == nil { 328 input = &ConfigureHealthCheckInput{} 329 } 330 331 output = &ConfigureHealthCheckOutput{} 332 req = c.newRequest(op, input, output) 333 return 334} 335 336// ConfigureHealthCheck API operation for Elastic Load Balancing. 337// 338// Specifies the health check settings to use when evaluating the health state 339// of your EC2 instances. 340// 341// For more information, see Configure Health Checks for Your Load Balancer 342// (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-healthchecks.html) 343// in the Classic Load Balancers Guide. 344// 345// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 346// with awserr.Error's Code and Message methods to get detailed information about 347// the error. 348// 349// See the AWS API reference guide for Elastic Load Balancing's 350// API operation ConfigureHealthCheck for usage and error information. 351// 352// Returned Error Codes: 353// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 354// The specified load balancer does not exist. 355// 356// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/ConfigureHealthCheck 357func (c *ELB) ConfigureHealthCheck(input *ConfigureHealthCheckInput) (*ConfigureHealthCheckOutput, error) { 358 req, out := c.ConfigureHealthCheckRequest(input) 359 return out, req.Send() 360} 361 362// ConfigureHealthCheckWithContext is the same as ConfigureHealthCheck with the addition of 363// the ability to pass a context and additional request options. 364// 365// See ConfigureHealthCheck for details on how to use this API operation. 366// 367// The context must be non-nil and will be used for request cancellation. If 368// the context is nil a panic will occur. In the future the SDK may create 369// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 370// for more information on using Contexts. 371func (c *ELB) ConfigureHealthCheckWithContext(ctx aws.Context, input *ConfigureHealthCheckInput, opts ...request.Option) (*ConfigureHealthCheckOutput, error) { 372 req, out := c.ConfigureHealthCheckRequest(input) 373 req.SetContext(ctx) 374 req.ApplyOptions(opts...) 375 return out, req.Send() 376} 377 378const opCreateAppCookieStickinessPolicy = "CreateAppCookieStickinessPolicy" 379 380// CreateAppCookieStickinessPolicyRequest generates a "aws/request.Request" representing the 381// client's request for the CreateAppCookieStickinessPolicy operation. The "output" return 382// value will be populated with the request's response once the request completes 383// successfully. 384// 385// Use "Send" method on the returned Request to send the API call to the service. 386// the "output" return value is not valid until after Send returns without error. 387// 388// See CreateAppCookieStickinessPolicy for more information on using the CreateAppCookieStickinessPolicy 389// API call, and error handling. 390// 391// This method is useful when you want to inject custom logic or configuration 392// into the SDK's request lifecycle. Such as custom headers, or retry logic. 393// 394// 395// // Example sending a request using the CreateAppCookieStickinessPolicyRequest method. 396// req, resp := client.CreateAppCookieStickinessPolicyRequest(params) 397// 398// err := req.Send() 399// if err == nil { // resp is now filled 400// fmt.Println(resp) 401// } 402// 403// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/CreateAppCookieStickinessPolicy 404func (c *ELB) CreateAppCookieStickinessPolicyRequest(input *CreateAppCookieStickinessPolicyInput) (req *request.Request, output *CreateAppCookieStickinessPolicyOutput) { 405 op := &request.Operation{ 406 Name: opCreateAppCookieStickinessPolicy, 407 HTTPMethod: "POST", 408 HTTPPath: "/", 409 } 410 411 if input == nil { 412 input = &CreateAppCookieStickinessPolicyInput{} 413 } 414 415 output = &CreateAppCookieStickinessPolicyOutput{} 416 req = c.newRequest(op, input, output) 417 req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 418 return 419} 420 421// CreateAppCookieStickinessPolicy API operation for Elastic Load Balancing. 422// 423// Generates a stickiness policy with sticky session lifetimes that follow that 424// of an application-generated cookie. This policy can be associated only with 425// HTTP/HTTPS listeners. 426// 427// This policy is similar to the policy created by CreateLBCookieStickinessPolicy, 428// except that the lifetime of the special Elastic Load Balancing cookie, AWSELB, 429// follows the lifetime of the application-generated cookie specified in the 430// policy configuration. The load balancer only inserts a new stickiness cookie 431// when the application response includes a new application cookie. 432// 433// If the application cookie is explicitly removed or expires, the session stops 434// being sticky until a new application cookie is issued. 435// 436// For more information, see Application-Controlled Session Stickiness (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-sticky-sessions.html#enable-sticky-sessions-application) 437// in the Classic Load Balancers Guide. 438// 439// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 440// with awserr.Error's Code and Message methods to get detailed information about 441// the error. 442// 443// See the AWS API reference guide for Elastic Load Balancing's 444// API operation CreateAppCookieStickinessPolicy for usage and error information. 445// 446// Returned Error Codes: 447// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 448// The specified load balancer does not exist. 449// 450// * ErrCodeDuplicatePolicyNameException "DuplicatePolicyName" 451// A policy with the specified name already exists for this load balancer. 452// 453// * ErrCodeTooManyPoliciesException "TooManyPolicies" 454// The quota for the number of policies for this load balancer has been reached. 455// 456// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 457// The requested configuration change is not valid. 458// 459// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/CreateAppCookieStickinessPolicy 460func (c *ELB) CreateAppCookieStickinessPolicy(input *CreateAppCookieStickinessPolicyInput) (*CreateAppCookieStickinessPolicyOutput, error) { 461 req, out := c.CreateAppCookieStickinessPolicyRequest(input) 462 return out, req.Send() 463} 464 465// CreateAppCookieStickinessPolicyWithContext is the same as CreateAppCookieStickinessPolicy with the addition of 466// the ability to pass a context and additional request options. 467// 468// See CreateAppCookieStickinessPolicy for details on how to use this API operation. 469// 470// The context must be non-nil and will be used for request cancellation. If 471// the context is nil a panic will occur. In the future the SDK may create 472// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 473// for more information on using Contexts. 474func (c *ELB) CreateAppCookieStickinessPolicyWithContext(ctx aws.Context, input *CreateAppCookieStickinessPolicyInput, opts ...request.Option) (*CreateAppCookieStickinessPolicyOutput, error) { 475 req, out := c.CreateAppCookieStickinessPolicyRequest(input) 476 req.SetContext(ctx) 477 req.ApplyOptions(opts...) 478 return out, req.Send() 479} 480 481const opCreateLBCookieStickinessPolicy = "CreateLBCookieStickinessPolicy" 482 483// CreateLBCookieStickinessPolicyRequest generates a "aws/request.Request" representing the 484// client's request for the CreateLBCookieStickinessPolicy operation. The "output" return 485// value will be populated with the request's response once the request completes 486// successfully. 487// 488// Use "Send" method on the returned Request to send the API call to the service. 489// the "output" return value is not valid until after Send returns without error. 490// 491// See CreateLBCookieStickinessPolicy for more information on using the CreateLBCookieStickinessPolicy 492// API call, and error handling. 493// 494// This method is useful when you want to inject custom logic or configuration 495// into the SDK's request lifecycle. Such as custom headers, or retry logic. 496// 497// 498// // Example sending a request using the CreateLBCookieStickinessPolicyRequest method. 499// req, resp := client.CreateLBCookieStickinessPolicyRequest(params) 500// 501// err := req.Send() 502// if err == nil { // resp is now filled 503// fmt.Println(resp) 504// } 505// 506// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/CreateLBCookieStickinessPolicy 507func (c *ELB) CreateLBCookieStickinessPolicyRequest(input *CreateLBCookieStickinessPolicyInput) (req *request.Request, output *CreateLBCookieStickinessPolicyOutput) { 508 op := &request.Operation{ 509 Name: opCreateLBCookieStickinessPolicy, 510 HTTPMethod: "POST", 511 HTTPPath: "/", 512 } 513 514 if input == nil { 515 input = &CreateLBCookieStickinessPolicyInput{} 516 } 517 518 output = &CreateLBCookieStickinessPolicyOutput{} 519 req = c.newRequest(op, input, output) 520 req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 521 return 522} 523 524// CreateLBCookieStickinessPolicy API operation for Elastic Load Balancing. 525// 526// Generates a stickiness policy with sticky session lifetimes controlled by 527// the lifetime of the browser (user-agent) or a specified expiration period. 528// This policy can be associated only with HTTP/HTTPS listeners. 529// 530// When a load balancer implements this policy, the load balancer uses a special 531// cookie to track the instance for each request. When the load balancer receives 532// a request, it first checks to see if this cookie is present in the request. 533// If so, the load balancer sends the request to the application server specified 534// in the cookie. If not, the load balancer sends the request to a server that 535// is chosen based on the existing load-balancing algorithm. 536// 537// A cookie is inserted into the response for binding subsequent requests from 538// the same user to that server. The validity of the cookie is based on the 539// cookie expiration time, which is specified in the policy configuration. 540// 541// For more information, see Duration-Based Session Stickiness (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-sticky-sessions.html#enable-sticky-sessions-duration) 542// in the Classic Load Balancers Guide. 543// 544// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 545// with awserr.Error's Code and Message methods to get detailed information about 546// the error. 547// 548// See the AWS API reference guide for Elastic Load Balancing's 549// API operation CreateLBCookieStickinessPolicy for usage and error information. 550// 551// Returned Error Codes: 552// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 553// The specified load balancer does not exist. 554// 555// * ErrCodeDuplicatePolicyNameException "DuplicatePolicyName" 556// A policy with the specified name already exists for this load balancer. 557// 558// * ErrCodeTooManyPoliciesException "TooManyPolicies" 559// The quota for the number of policies for this load balancer has been reached. 560// 561// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 562// The requested configuration change is not valid. 563// 564// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/CreateLBCookieStickinessPolicy 565func (c *ELB) CreateLBCookieStickinessPolicy(input *CreateLBCookieStickinessPolicyInput) (*CreateLBCookieStickinessPolicyOutput, error) { 566 req, out := c.CreateLBCookieStickinessPolicyRequest(input) 567 return out, req.Send() 568} 569 570// CreateLBCookieStickinessPolicyWithContext is the same as CreateLBCookieStickinessPolicy with the addition of 571// the ability to pass a context and additional request options. 572// 573// See CreateLBCookieStickinessPolicy for details on how to use this API operation. 574// 575// The context must be non-nil and will be used for request cancellation. If 576// the context is nil a panic will occur. In the future the SDK may create 577// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 578// for more information on using Contexts. 579func (c *ELB) CreateLBCookieStickinessPolicyWithContext(ctx aws.Context, input *CreateLBCookieStickinessPolicyInput, opts ...request.Option) (*CreateLBCookieStickinessPolicyOutput, error) { 580 req, out := c.CreateLBCookieStickinessPolicyRequest(input) 581 req.SetContext(ctx) 582 req.ApplyOptions(opts...) 583 return out, req.Send() 584} 585 586const opCreateLoadBalancer = "CreateLoadBalancer" 587 588// CreateLoadBalancerRequest generates a "aws/request.Request" representing the 589// client's request for the CreateLoadBalancer operation. The "output" return 590// value will be populated with the request's response once the request completes 591// successfully. 592// 593// Use "Send" method on the returned Request to send the API call to the service. 594// the "output" return value is not valid until after Send returns without error. 595// 596// See CreateLoadBalancer for more information on using the CreateLoadBalancer 597// API call, and error handling. 598// 599// This method is useful when you want to inject custom logic or configuration 600// into the SDK's request lifecycle. Such as custom headers, or retry logic. 601// 602// 603// // Example sending a request using the CreateLoadBalancerRequest method. 604// req, resp := client.CreateLoadBalancerRequest(params) 605// 606// err := req.Send() 607// if err == nil { // resp is now filled 608// fmt.Println(resp) 609// } 610// 611// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/CreateLoadBalancer 612func (c *ELB) CreateLoadBalancerRequest(input *CreateLoadBalancerInput) (req *request.Request, output *CreateLoadBalancerOutput) { 613 op := &request.Operation{ 614 Name: opCreateLoadBalancer, 615 HTTPMethod: "POST", 616 HTTPPath: "/", 617 } 618 619 if input == nil { 620 input = &CreateLoadBalancerInput{} 621 } 622 623 output = &CreateLoadBalancerOutput{} 624 req = c.newRequest(op, input, output) 625 return 626} 627 628// CreateLoadBalancer API operation for Elastic Load Balancing. 629// 630// Creates a Classic Load Balancer. 631// 632// You can add listeners, security groups, subnets, and tags when you create 633// your load balancer, or you can add them later using CreateLoadBalancerListeners, 634// ApplySecurityGroupsToLoadBalancer, AttachLoadBalancerToSubnets, and AddTags. 635// 636// To describe your current load balancers, see DescribeLoadBalancers. When 637// you are finished with a load balancer, you can delete it using DeleteLoadBalancer. 638// 639// You can create up to 20 load balancers per region per account. You can request 640// an increase for the number of load balancers for your account. For more information, 641// see Limits for Your Classic Load Balancer (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-limits.html) 642// in the Classic Load Balancers Guide. 643// 644// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 645// with awserr.Error's Code and Message methods to get detailed information about 646// the error. 647// 648// See the AWS API reference guide for Elastic Load Balancing's 649// API operation CreateLoadBalancer for usage and error information. 650// 651// Returned Error Codes: 652// * ErrCodeDuplicateAccessPointNameException "DuplicateLoadBalancerName" 653// The specified load balancer name already exists for this account. 654// 655// * ErrCodeTooManyAccessPointsException "TooManyLoadBalancers" 656// The quota for the number of load balancers has been reached. 657// 658// * ErrCodeCertificateNotFoundException "CertificateNotFound" 659// The specified ARN does not refer to a valid SSL certificate in AWS Identity 660// and Access Management (IAM) or AWS Certificate Manager (ACM). Note that if 661// you recently uploaded the certificate to IAM, this error might indicate that 662// the certificate is not fully available yet. 663// 664// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 665// The requested configuration change is not valid. 666// 667// * ErrCodeSubnetNotFoundException "SubnetNotFound" 668// One or more of the specified subnets do not exist. 669// 670// * ErrCodeInvalidSubnetException "InvalidSubnet" 671// The specified VPC has no associated Internet gateway. 672// 673// * ErrCodeInvalidSecurityGroupException "InvalidSecurityGroup" 674// One or more of the specified security groups do not exist. 675// 676// * ErrCodeInvalidSchemeException "InvalidScheme" 677// The specified value for the schema is not valid. You can only specify a scheme 678// for load balancers in a VPC. 679// 680// * ErrCodeTooManyTagsException "TooManyTags" 681// The quota for the number of tags that can be assigned to a load balancer 682// has been reached. 683// 684// * ErrCodeDuplicateTagKeysException "DuplicateTagKeys" 685// A tag key was specified more than once. 686// 687// * ErrCodeUnsupportedProtocolException "UnsupportedProtocol" 688// The specified protocol or signature version is not supported. 689// 690// * ErrCodeOperationNotPermittedException "OperationNotPermitted" 691// This operation is not allowed. 692// 693// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/CreateLoadBalancer 694func (c *ELB) CreateLoadBalancer(input *CreateLoadBalancerInput) (*CreateLoadBalancerOutput, error) { 695 req, out := c.CreateLoadBalancerRequest(input) 696 return out, req.Send() 697} 698 699// CreateLoadBalancerWithContext is the same as CreateLoadBalancer with the addition of 700// the ability to pass a context and additional request options. 701// 702// See CreateLoadBalancer for details on how to use this API operation. 703// 704// The context must be non-nil and will be used for request cancellation. If 705// the context is nil a panic will occur. In the future the SDK may create 706// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 707// for more information on using Contexts. 708func (c *ELB) CreateLoadBalancerWithContext(ctx aws.Context, input *CreateLoadBalancerInput, opts ...request.Option) (*CreateLoadBalancerOutput, error) { 709 req, out := c.CreateLoadBalancerRequest(input) 710 req.SetContext(ctx) 711 req.ApplyOptions(opts...) 712 return out, req.Send() 713} 714 715const opCreateLoadBalancerListeners = "CreateLoadBalancerListeners" 716 717// CreateLoadBalancerListenersRequest generates a "aws/request.Request" representing the 718// client's request for the CreateLoadBalancerListeners operation. The "output" return 719// value will be populated with the request's response once the request completes 720// successfully. 721// 722// Use "Send" method on the returned Request to send the API call to the service. 723// the "output" return value is not valid until after Send returns without error. 724// 725// See CreateLoadBalancerListeners for more information on using the CreateLoadBalancerListeners 726// API call, and error handling. 727// 728// This method is useful when you want to inject custom logic or configuration 729// into the SDK's request lifecycle. Such as custom headers, or retry logic. 730// 731// 732// // Example sending a request using the CreateLoadBalancerListenersRequest method. 733// req, resp := client.CreateLoadBalancerListenersRequest(params) 734// 735// err := req.Send() 736// if err == nil { // resp is now filled 737// fmt.Println(resp) 738// } 739// 740// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/CreateLoadBalancerListeners 741func (c *ELB) CreateLoadBalancerListenersRequest(input *CreateLoadBalancerListenersInput) (req *request.Request, output *CreateLoadBalancerListenersOutput) { 742 op := &request.Operation{ 743 Name: opCreateLoadBalancerListeners, 744 HTTPMethod: "POST", 745 HTTPPath: "/", 746 } 747 748 if input == nil { 749 input = &CreateLoadBalancerListenersInput{} 750 } 751 752 output = &CreateLoadBalancerListenersOutput{} 753 req = c.newRequest(op, input, output) 754 req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 755 return 756} 757 758// CreateLoadBalancerListeners API operation for Elastic Load Balancing. 759// 760// Creates one or more listeners for the specified load balancer. If a listener 761// with the specified port does not already exist, it is created; otherwise, 762// the properties of the new listener must match the properties of the existing 763// listener. 764// 765// For more information, see Listeners for Your Classic Load Balancer (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-listener-config.html) 766// in the Classic Load Balancers Guide. 767// 768// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 769// with awserr.Error's Code and Message methods to get detailed information about 770// the error. 771// 772// See the AWS API reference guide for Elastic Load Balancing's 773// API operation CreateLoadBalancerListeners for usage and error information. 774// 775// Returned Error Codes: 776// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 777// The specified load balancer does not exist. 778// 779// * ErrCodeDuplicateListenerException "DuplicateListener" 780// A listener already exists for the specified load balancer name and port, 781// but with a different instance port, protocol, or SSL certificate. 782// 783// * ErrCodeCertificateNotFoundException "CertificateNotFound" 784// The specified ARN does not refer to a valid SSL certificate in AWS Identity 785// and Access Management (IAM) or AWS Certificate Manager (ACM). Note that if 786// you recently uploaded the certificate to IAM, this error might indicate that 787// the certificate is not fully available yet. 788// 789// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 790// The requested configuration change is not valid. 791// 792// * ErrCodeUnsupportedProtocolException "UnsupportedProtocol" 793// The specified protocol or signature version is not supported. 794// 795// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/CreateLoadBalancerListeners 796func (c *ELB) CreateLoadBalancerListeners(input *CreateLoadBalancerListenersInput) (*CreateLoadBalancerListenersOutput, error) { 797 req, out := c.CreateLoadBalancerListenersRequest(input) 798 return out, req.Send() 799} 800 801// CreateLoadBalancerListenersWithContext is the same as CreateLoadBalancerListeners with the addition of 802// the ability to pass a context and additional request options. 803// 804// See CreateLoadBalancerListeners for details on how to use this API operation. 805// 806// The context must be non-nil and will be used for request cancellation. If 807// the context is nil a panic will occur. In the future the SDK may create 808// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 809// for more information on using Contexts. 810func (c *ELB) CreateLoadBalancerListenersWithContext(ctx aws.Context, input *CreateLoadBalancerListenersInput, opts ...request.Option) (*CreateLoadBalancerListenersOutput, error) { 811 req, out := c.CreateLoadBalancerListenersRequest(input) 812 req.SetContext(ctx) 813 req.ApplyOptions(opts...) 814 return out, req.Send() 815} 816 817const opCreateLoadBalancerPolicy = "CreateLoadBalancerPolicy" 818 819// CreateLoadBalancerPolicyRequest generates a "aws/request.Request" representing the 820// client's request for the CreateLoadBalancerPolicy operation. The "output" return 821// value will be populated with the request's response once the request completes 822// successfully. 823// 824// Use "Send" method on the returned Request to send the API call to the service. 825// the "output" return value is not valid until after Send returns without error. 826// 827// See CreateLoadBalancerPolicy for more information on using the CreateLoadBalancerPolicy 828// API call, and error handling. 829// 830// This method is useful when you want to inject custom logic or configuration 831// into the SDK's request lifecycle. Such as custom headers, or retry logic. 832// 833// 834// // Example sending a request using the CreateLoadBalancerPolicyRequest method. 835// req, resp := client.CreateLoadBalancerPolicyRequest(params) 836// 837// err := req.Send() 838// if err == nil { // resp is now filled 839// fmt.Println(resp) 840// } 841// 842// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/CreateLoadBalancerPolicy 843func (c *ELB) CreateLoadBalancerPolicyRequest(input *CreateLoadBalancerPolicyInput) (req *request.Request, output *CreateLoadBalancerPolicyOutput) { 844 op := &request.Operation{ 845 Name: opCreateLoadBalancerPolicy, 846 HTTPMethod: "POST", 847 HTTPPath: "/", 848 } 849 850 if input == nil { 851 input = &CreateLoadBalancerPolicyInput{} 852 } 853 854 output = &CreateLoadBalancerPolicyOutput{} 855 req = c.newRequest(op, input, output) 856 req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 857 return 858} 859 860// CreateLoadBalancerPolicy API operation for Elastic Load Balancing. 861// 862// Creates a policy with the specified attributes for the specified load balancer. 863// 864// Policies are settings that are saved for your load balancer and that can 865// be applied to the listener or the application server, depending on the policy 866// type. 867// 868// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 869// with awserr.Error's Code and Message methods to get detailed information about 870// the error. 871// 872// See the AWS API reference guide for Elastic Load Balancing's 873// API operation CreateLoadBalancerPolicy for usage and error information. 874// 875// Returned Error Codes: 876// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 877// The specified load balancer does not exist. 878// 879// * ErrCodePolicyTypeNotFoundException "PolicyTypeNotFound" 880// One or more of the specified policy types do not exist. 881// 882// * ErrCodeDuplicatePolicyNameException "DuplicatePolicyName" 883// A policy with the specified name already exists for this load balancer. 884// 885// * ErrCodeTooManyPoliciesException "TooManyPolicies" 886// The quota for the number of policies for this load balancer has been reached. 887// 888// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 889// The requested configuration change is not valid. 890// 891// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/CreateLoadBalancerPolicy 892func (c *ELB) CreateLoadBalancerPolicy(input *CreateLoadBalancerPolicyInput) (*CreateLoadBalancerPolicyOutput, error) { 893 req, out := c.CreateLoadBalancerPolicyRequest(input) 894 return out, req.Send() 895} 896 897// CreateLoadBalancerPolicyWithContext is the same as CreateLoadBalancerPolicy with the addition of 898// the ability to pass a context and additional request options. 899// 900// See CreateLoadBalancerPolicy for details on how to use this API operation. 901// 902// The context must be non-nil and will be used for request cancellation. If 903// the context is nil a panic will occur. In the future the SDK may create 904// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 905// for more information on using Contexts. 906func (c *ELB) CreateLoadBalancerPolicyWithContext(ctx aws.Context, input *CreateLoadBalancerPolicyInput, opts ...request.Option) (*CreateLoadBalancerPolicyOutput, error) { 907 req, out := c.CreateLoadBalancerPolicyRequest(input) 908 req.SetContext(ctx) 909 req.ApplyOptions(opts...) 910 return out, req.Send() 911} 912 913const opDeleteLoadBalancer = "DeleteLoadBalancer" 914 915// DeleteLoadBalancerRequest generates a "aws/request.Request" representing the 916// client's request for the DeleteLoadBalancer operation. The "output" return 917// value will be populated with the request's response once the request completes 918// successfully. 919// 920// Use "Send" method on the returned Request to send the API call to the service. 921// the "output" return value is not valid until after Send returns without error. 922// 923// See DeleteLoadBalancer for more information on using the DeleteLoadBalancer 924// API call, and error handling. 925// 926// This method is useful when you want to inject custom logic or configuration 927// into the SDK's request lifecycle. Such as custom headers, or retry logic. 928// 929// 930// // Example sending a request using the DeleteLoadBalancerRequest method. 931// req, resp := client.DeleteLoadBalancerRequest(params) 932// 933// err := req.Send() 934// if err == nil { // resp is now filled 935// fmt.Println(resp) 936// } 937// 938// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DeleteLoadBalancer 939func (c *ELB) DeleteLoadBalancerRequest(input *DeleteLoadBalancerInput) (req *request.Request, output *DeleteLoadBalancerOutput) { 940 op := &request.Operation{ 941 Name: opDeleteLoadBalancer, 942 HTTPMethod: "POST", 943 HTTPPath: "/", 944 } 945 946 if input == nil { 947 input = &DeleteLoadBalancerInput{} 948 } 949 950 output = &DeleteLoadBalancerOutput{} 951 req = c.newRequest(op, input, output) 952 req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 953 return 954} 955 956// DeleteLoadBalancer API operation for Elastic Load Balancing. 957// 958// Deletes the specified load balancer. 959// 960// If you are attempting to recreate a load balancer, you must reconfigure all 961// settings. The DNS name associated with a deleted load balancer are no longer 962// usable. The name and associated DNS record of the deleted load balancer no 963// longer exist and traffic sent to any of its IP addresses is no longer delivered 964// to your instances. 965// 966// If the load balancer does not exist or has already been deleted, the call 967// to DeleteLoadBalancer still succeeds. 968// 969// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 970// with awserr.Error's Code and Message methods to get detailed information about 971// the error. 972// 973// See the AWS API reference guide for Elastic Load Balancing's 974// API operation DeleteLoadBalancer for usage and error information. 975// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DeleteLoadBalancer 976func (c *ELB) DeleteLoadBalancer(input *DeleteLoadBalancerInput) (*DeleteLoadBalancerOutput, error) { 977 req, out := c.DeleteLoadBalancerRequest(input) 978 return out, req.Send() 979} 980 981// DeleteLoadBalancerWithContext is the same as DeleteLoadBalancer with the addition of 982// the ability to pass a context and additional request options. 983// 984// See DeleteLoadBalancer for details on how to use this API operation. 985// 986// The context must be non-nil and will be used for request cancellation. If 987// the context is nil a panic will occur. In the future the SDK may create 988// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 989// for more information on using Contexts. 990func (c *ELB) DeleteLoadBalancerWithContext(ctx aws.Context, input *DeleteLoadBalancerInput, opts ...request.Option) (*DeleteLoadBalancerOutput, error) { 991 req, out := c.DeleteLoadBalancerRequest(input) 992 req.SetContext(ctx) 993 req.ApplyOptions(opts...) 994 return out, req.Send() 995} 996 997const opDeleteLoadBalancerListeners = "DeleteLoadBalancerListeners" 998 999// DeleteLoadBalancerListenersRequest generates a "aws/request.Request" representing the 1000// client's request for the DeleteLoadBalancerListeners operation. The "output" return 1001// value will be populated with the request's response once the request completes 1002// successfully. 1003// 1004// Use "Send" method on the returned Request to send the API call to the service. 1005// the "output" return value is not valid until after Send returns without error. 1006// 1007// See DeleteLoadBalancerListeners for more information on using the DeleteLoadBalancerListeners 1008// API call, and error handling. 1009// 1010// This method is useful when you want to inject custom logic or configuration 1011// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1012// 1013// 1014// // Example sending a request using the DeleteLoadBalancerListenersRequest method. 1015// req, resp := client.DeleteLoadBalancerListenersRequest(params) 1016// 1017// err := req.Send() 1018// if err == nil { // resp is now filled 1019// fmt.Println(resp) 1020// } 1021// 1022// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DeleteLoadBalancerListeners 1023func (c *ELB) DeleteLoadBalancerListenersRequest(input *DeleteLoadBalancerListenersInput) (req *request.Request, output *DeleteLoadBalancerListenersOutput) { 1024 op := &request.Operation{ 1025 Name: opDeleteLoadBalancerListeners, 1026 HTTPMethod: "POST", 1027 HTTPPath: "/", 1028 } 1029 1030 if input == nil { 1031 input = &DeleteLoadBalancerListenersInput{} 1032 } 1033 1034 output = &DeleteLoadBalancerListenersOutput{} 1035 req = c.newRequest(op, input, output) 1036 req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1037 return 1038} 1039 1040// DeleteLoadBalancerListeners API operation for Elastic Load Balancing. 1041// 1042// Deletes the specified listeners from the specified load balancer. 1043// 1044// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1045// with awserr.Error's Code and Message methods to get detailed information about 1046// the error. 1047// 1048// See the AWS API reference guide for Elastic Load Balancing's 1049// API operation DeleteLoadBalancerListeners for usage and error information. 1050// 1051// Returned Error Codes: 1052// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 1053// The specified load balancer does not exist. 1054// 1055// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DeleteLoadBalancerListeners 1056func (c *ELB) DeleteLoadBalancerListeners(input *DeleteLoadBalancerListenersInput) (*DeleteLoadBalancerListenersOutput, error) { 1057 req, out := c.DeleteLoadBalancerListenersRequest(input) 1058 return out, req.Send() 1059} 1060 1061// DeleteLoadBalancerListenersWithContext is the same as DeleteLoadBalancerListeners with the addition of 1062// the ability to pass a context and additional request options. 1063// 1064// See DeleteLoadBalancerListeners for details on how to use this API operation. 1065// 1066// The context must be non-nil and will be used for request cancellation. If 1067// the context is nil a panic will occur. In the future the SDK may create 1068// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1069// for more information on using Contexts. 1070func (c *ELB) DeleteLoadBalancerListenersWithContext(ctx aws.Context, input *DeleteLoadBalancerListenersInput, opts ...request.Option) (*DeleteLoadBalancerListenersOutput, error) { 1071 req, out := c.DeleteLoadBalancerListenersRequest(input) 1072 req.SetContext(ctx) 1073 req.ApplyOptions(opts...) 1074 return out, req.Send() 1075} 1076 1077const opDeleteLoadBalancerPolicy = "DeleteLoadBalancerPolicy" 1078 1079// DeleteLoadBalancerPolicyRequest generates a "aws/request.Request" representing the 1080// client's request for the DeleteLoadBalancerPolicy operation. The "output" return 1081// value will be populated with the request's response once the request completes 1082// successfully. 1083// 1084// Use "Send" method on the returned Request to send the API call to the service. 1085// the "output" return value is not valid until after Send returns without error. 1086// 1087// See DeleteLoadBalancerPolicy for more information on using the DeleteLoadBalancerPolicy 1088// API call, and error handling. 1089// 1090// This method is useful when you want to inject custom logic or configuration 1091// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1092// 1093// 1094// // Example sending a request using the DeleteLoadBalancerPolicyRequest method. 1095// req, resp := client.DeleteLoadBalancerPolicyRequest(params) 1096// 1097// err := req.Send() 1098// if err == nil { // resp is now filled 1099// fmt.Println(resp) 1100// } 1101// 1102// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DeleteLoadBalancerPolicy 1103func (c *ELB) DeleteLoadBalancerPolicyRequest(input *DeleteLoadBalancerPolicyInput) (req *request.Request, output *DeleteLoadBalancerPolicyOutput) { 1104 op := &request.Operation{ 1105 Name: opDeleteLoadBalancerPolicy, 1106 HTTPMethod: "POST", 1107 HTTPPath: "/", 1108 } 1109 1110 if input == nil { 1111 input = &DeleteLoadBalancerPolicyInput{} 1112 } 1113 1114 output = &DeleteLoadBalancerPolicyOutput{} 1115 req = c.newRequest(op, input, output) 1116 req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1117 return 1118} 1119 1120// DeleteLoadBalancerPolicy API operation for Elastic Load Balancing. 1121// 1122// Deletes the specified policy from the specified load balancer. This policy 1123// must not be enabled for any listeners. 1124// 1125// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1126// with awserr.Error's Code and Message methods to get detailed information about 1127// the error. 1128// 1129// See the AWS API reference guide for Elastic Load Balancing's 1130// API operation DeleteLoadBalancerPolicy for usage and error information. 1131// 1132// Returned Error Codes: 1133// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 1134// The specified load balancer does not exist. 1135// 1136// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 1137// The requested configuration change is not valid. 1138// 1139// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DeleteLoadBalancerPolicy 1140func (c *ELB) DeleteLoadBalancerPolicy(input *DeleteLoadBalancerPolicyInput) (*DeleteLoadBalancerPolicyOutput, error) { 1141 req, out := c.DeleteLoadBalancerPolicyRequest(input) 1142 return out, req.Send() 1143} 1144 1145// DeleteLoadBalancerPolicyWithContext is the same as DeleteLoadBalancerPolicy with the addition of 1146// the ability to pass a context and additional request options. 1147// 1148// See DeleteLoadBalancerPolicy for details on how to use this API operation. 1149// 1150// The context must be non-nil and will be used for request cancellation. If 1151// the context is nil a panic will occur. In the future the SDK may create 1152// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1153// for more information on using Contexts. 1154func (c *ELB) DeleteLoadBalancerPolicyWithContext(ctx aws.Context, input *DeleteLoadBalancerPolicyInput, opts ...request.Option) (*DeleteLoadBalancerPolicyOutput, error) { 1155 req, out := c.DeleteLoadBalancerPolicyRequest(input) 1156 req.SetContext(ctx) 1157 req.ApplyOptions(opts...) 1158 return out, req.Send() 1159} 1160 1161const opDeregisterInstancesFromLoadBalancer = "DeregisterInstancesFromLoadBalancer" 1162 1163// DeregisterInstancesFromLoadBalancerRequest generates a "aws/request.Request" representing the 1164// client's request for the DeregisterInstancesFromLoadBalancer operation. The "output" return 1165// value will be populated with the request's response once the request completes 1166// successfully. 1167// 1168// Use "Send" method on the returned Request to send the API call to the service. 1169// the "output" return value is not valid until after Send returns without error. 1170// 1171// See DeregisterInstancesFromLoadBalancer for more information on using the DeregisterInstancesFromLoadBalancer 1172// API call, and error handling. 1173// 1174// This method is useful when you want to inject custom logic or configuration 1175// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1176// 1177// 1178// // Example sending a request using the DeregisterInstancesFromLoadBalancerRequest method. 1179// req, resp := client.DeregisterInstancesFromLoadBalancerRequest(params) 1180// 1181// err := req.Send() 1182// if err == nil { // resp is now filled 1183// fmt.Println(resp) 1184// } 1185// 1186// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DeregisterInstancesFromLoadBalancer 1187func (c *ELB) DeregisterInstancesFromLoadBalancerRequest(input *DeregisterInstancesFromLoadBalancerInput) (req *request.Request, output *DeregisterInstancesFromLoadBalancerOutput) { 1188 op := &request.Operation{ 1189 Name: opDeregisterInstancesFromLoadBalancer, 1190 HTTPMethod: "POST", 1191 HTTPPath: "/", 1192 } 1193 1194 if input == nil { 1195 input = &DeregisterInstancesFromLoadBalancerInput{} 1196 } 1197 1198 output = &DeregisterInstancesFromLoadBalancerOutput{} 1199 req = c.newRequest(op, input, output) 1200 return 1201} 1202 1203// DeregisterInstancesFromLoadBalancer API operation for Elastic Load Balancing. 1204// 1205// Deregisters the specified instances from the specified load balancer. After 1206// the instance is deregistered, it no longer receives traffic from the load 1207// balancer. 1208// 1209// You can use DescribeLoadBalancers to verify that the instance is deregistered 1210// from the load balancer. 1211// 1212// For more information, see Register or De-Register EC2 Instances (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-deregister-register-instances.html) 1213// in the Classic Load Balancers Guide. 1214// 1215// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1216// with awserr.Error's Code and Message methods to get detailed information about 1217// the error. 1218// 1219// See the AWS API reference guide for Elastic Load Balancing's 1220// API operation DeregisterInstancesFromLoadBalancer for usage and error information. 1221// 1222// Returned Error Codes: 1223// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 1224// The specified load balancer does not exist. 1225// 1226// * ErrCodeInvalidEndPointException "InvalidInstance" 1227// The specified endpoint is not valid. 1228// 1229// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DeregisterInstancesFromLoadBalancer 1230func (c *ELB) DeregisterInstancesFromLoadBalancer(input *DeregisterInstancesFromLoadBalancerInput) (*DeregisterInstancesFromLoadBalancerOutput, error) { 1231 req, out := c.DeregisterInstancesFromLoadBalancerRequest(input) 1232 return out, req.Send() 1233} 1234 1235// DeregisterInstancesFromLoadBalancerWithContext is the same as DeregisterInstancesFromLoadBalancer with the addition of 1236// the ability to pass a context and additional request options. 1237// 1238// See DeregisterInstancesFromLoadBalancer for details on how to use this API operation. 1239// 1240// The context must be non-nil and will be used for request cancellation. If 1241// the context is nil a panic will occur. In the future the SDK may create 1242// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1243// for more information on using Contexts. 1244func (c *ELB) DeregisterInstancesFromLoadBalancerWithContext(ctx aws.Context, input *DeregisterInstancesFromLoadBalancerInput, opts ...request.Option) (*DeregisterInstancesFromLoadBalancerOutput, error) { 1245 req, out := c.DeregisterInstancesFromLoadBalancerRequest(input) 1246 req.SetContext(ctx) 1247 req.ApplyOptions(opts...) 1248 return out, req.Send() 1249} 1250 1251const opDescribeAccountLimits = "DescribeAccountLimits" 1252 1253// DescribeAccountLimitsRequest generates a "aws/request.Request" representing the 1254// client's request for the DescribeAccountLimits operation. The "output" return 1255// value will be populated with the request's response once the request completes 1256// successfully. 1257// 1258// Use "Send" method on the returned Request to send the API call to the service. 1259// the "output" return value is not valid until after Send returns without error. 1260// 1261// See DescribeAccountLimits for more information on using the DescribeAccountLimits 1262// API call, and error handling. 1263// 1264// This method is useful when you want to inject custom logic or configuration 1265// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1266// 1267// 1268// // Example sending a request using the DescribeAccountLimitsRequest method. 1269// req, resp := client.DescribeAccountLimitsRequest(params) 1270// 1271// err := req.Send() 1272// if err == nil { // resp is now filled 1273// fmt.Println(resp) 1274// } 1275// 1276// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DescribeAccountLimits 1277func (c *ELB) DescribeAccountLimitsRequest(input *DescribeAccountLimitsInput) (req *request.Request, output *DescribeAccountLimitsOutput) { 1278 op := &request.Operation{ 1279 Name: opDescribeAccountLimits, 1280 HTTPMethod: "POST", 1281 HTTPPath: "/", 1282 } 1283 1284 if input == nil { 1285 input = &DescribeAccountLimitsInput{} 1286 } 1287 1288 output = &DescribeAccountLimitsOutput{} 1289 req = c.newRequest(op, input, output) 1290 return 1291} 1292 1293// DescribeAccountLimits API operation for Elastic Load Balancing. 1294// 1295// Describes the current Elastic Load Balancing resource limits for your AWS 1296// account. 1297// 1298// For more information, see Limits for Your Classic Load Balancer (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-limits.html) 1299// in the Classic Load Balancers Guide. 1300// 1301// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1302// with awserr.Error's Code and Message methods to get detailed information about 1303// the error. 1304// 1305// See the AWS API reference guide for Elastic Load Balancing's 1306// API operation DescribeAccountLimits for usage and error information. 1307// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DescribeAccountLimits 1308func (c *ELB) DescribeAccountLimits(input *DescribeAccountLimitsInput) (*DescribeAccountLimitsOutput, error) { 1309 req, out := c.DescribeAccountLimitsRequest(input) 1310 return out, req.Send() 1311} 1312 1313// DescribeAccountLimitsWithContext is the same as DescribeAccountLimits with the addition of 1314// the ability to pass a context and additional request options. 1315// 1316// See DescribeAccountLimits for details on how to use this API operation. 1317// 1318// The context must be non-nil and will be used for request cancellation. If 1319// the context is nil a panic will occur. In the future the SDK may create 1320// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1321// for more information on using Contexts. 1322func (c *ELB) DescribeAccountLimitsWithContext(ctx aws.Context, input *DescribeAccountLimitsInput, opts ...request.Option) (*DescribeAccountLimitsOutput, error) { 1323 req, out := c.DescribeAccountLimitsRequest(input) 1324 req.SetContext(ctx) 1325 req.ApplyOptions(opts...) 1326 return out, req.Send() 1327} 1328 1329const opDescribeInstanceHealth = "DescribeInstanceHealth" 1330 1331// DescribeInstanceHealthRequest generates a "aws/request.Request" representing the 1332// client's request for the DescribeInstanceHealth operation. The "output" return 1333// value will be populated with the request's response once the request completes 1334// successfully. 1335// 1336// Use "Send" method on the returned Request to send the API call to the service. 1337// the "output" return value is not valid until after Send returns without error. 1338// 1339// See DescribeInstanceHealth for more information on using the DescribeInstanceHealth 1340// API call, and error handling. 1341// 1342// This method is useful when you want to inject custom logic or configuration 1343// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1344// 1345// 1346// // Example sending a request using the DescribeInstanceHealthRequest method. 1347// req, resp := client.DescribeInstanceHealthRequest(params) 1348// 1349// err := req.Send() 1350// if err == nil { // resp is now filled 1351// fmt.Println(resp) 1352// } 1353// 1354// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DescribeInstanceHealth 1355func (c *ELB) DescribeInstanceHealthRequest(input *DescribeInstanceHealthInput) (req *request.Request, output *DescribeInstanceHealthOutput) { 1356 op := &request.Operation{ 1357 Name: opDescribeInstanceHealth, 1358 HTTPMethod: "POST", 1359 HTTPPath: "/", 1360 } 1361 1362 if input == nil { 1363 input = &DescribeInstanceHealthInput{} 1364 } 1365 1366 output = &DescribeInstanceHealthOutput{} 1367 req = c.newRequest(op, input, output) 1368 return 1369} 1370 1371// DescribeInstanceHealth API operation for Elastic Load Balancing. 1372// 1373// Describes the state of the specified instances with respect to the specified 1374// load balancer. If no instances are specified, the call describes the state 1375// of all instances that are currently registered with the load balancer. If 1376// instances are specified, their state is returned even if they are no longer 1377// registered with the load balancer. The state of terminated instances is not 1378// returned. 1379// 1380// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1381// with awserr.Error's Code and Message methods to get detailed information about 1382// the error. 1383// 1384// See the AWS API reference guide for Elastic Load Balancing's 1385// API operation DescribeInstanceHealth for usage and error information. 1386// 1387// Returned Error Codes: 1388// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 1389// The specified load balancer does not exist. 1390// 1391// * ErrCodeInvalidEndPointException "InvalidInstance" 1392// The specified endpoint is not valid. 1393// 1394// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DescribeInstanceHealth 1395func (c *ELB) DescribeInstanceHealth(input *DescribeInstanceHealthInput) (*DescribeInstanceHealthOutput, error) { 1396 req, out := c.DescribeInstanceHealthRequest(input) 1397 return out, req.Send() 1398} 1399 1400// DescribeInstanceHealthWithContext is the same as DescribeInstanceHealth with the addition of 1401// the ability to pass a context and additional request options. 1402// 1403// See DescribeInstanceHealth for details on how to use this API operation. 1404// 1405// The context must be non-nil and will be used for request cancellation. If 1406// the context is nil a panic will occur. In the future the SDK may create 1407// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1408// for more information on using Contexts. 1409func (c *ELB) DescribeInstanceHealthWithContext(ctx aws.Context, input *DescribeInstanceHealthInput, opts ...request.Option) (*DescribeInstanceHealthOutput, error) { 1410 req, out := c.DescribeInstanceHealthRequest(input) 1411 req.SetContext(ctx) 1412 req.ApplyOptions(opts...) 1413 return out, req.Send() 1414} 1415 1416const opDescribeLoadBalancerAttributes = "DescribeLoadBalancerAttributes" 1417 1418// DescribeLoadBalancerAttributesRequest generates a "aws/request.Request" representing the 1419// client's request for the DescribeLoadBalancerAttributes operation. The "output" return 1420// value will be populated with the request's response once the request completes 1421// successfully. 1422// 1423// Use "Send" method on the returned Request to send the API call to the service. 1424// the "output" return value is not valid until after Send returns without error. 1425// 1426// See DescribeLoadBalancerAttributes for more information on using the DescribeLoadBalancerAttributes 1427// API call, and error handling. 1428// 1429// This method is useful when you want to inject custom logic or configuration 1430// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1431// 1432// 1433// // Example sending a request using the DescribeLoadBalancerAttributesRequest method. 1434// req, resp := client.DescribeLoadBalancerAttributesRequest(params) 1435// 1436// err := req.Send() 1437// if err == nil { // resp is now filled 1438// fmt.Println(resp) 1439// } 1440// 1441// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DescribeLoadBalancerAttributes 1442func (c *ELB) DescribeLoadBalancerAttributesRequest(input *DescribeLoadBalancerAttributesInput) (req *request.Request, output *DescribeLoadBalancerAttributesOutput) { 1443 op := &request.Operation{ 1444 Name: opDescribeLoadBalancerAttributes, 1445 HTTPMethod: "POST", 1446 HTTPPath: "/", 1447 } 1448 1449 if input == nil { 1450 input = &DescribeLoadBalancerAttributesInput{} 1451 } 1452 1453 output = &DescribeLoadBalancerAttributesOutput{} 1454 req = c.newRequest(op, input, output) 1455 return 1456} 1457 1458// DescribeLoadBalancerAttributes API operation for Elastic Load Balancing. 1459// 1460// Describes the attributes for the specified load balancer. 1461// 1462// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1463// with awserr.Error's Code and Message methods to get detailed information about 1464// the error. 1465// 1466// See the AWS API reference guide for Elastic Load Balancing's 1467// API operation DescribeLoadBalancerAttributes for usage and error information. 1468// 1469// Returned Error Codes: 1470// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 1471// The specified load balancer does not exist. 1472// 1473// * ErrCodeLoadBalancerAttributeNotFoundException "LoadBalancerAttributeNotFound" 1474// The specified load balancer attribute does not exist. 1475// 1476// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DescribeLoadBalancerAttributes 1477func (c *ELB) DescribeLoadBalancerAttributes(input *DescribeLoadBalancerAttributesInput) (*DescribeLoadBalancerAttributesOutput, error) { 1478 req, out := c.DescribeLoadBalancerAttributesRequest(input) 1479 return out, req.Send() 1480} 1481 1482// DescribeLoadBalancerAttributesWithContext is the same as DescribeLoadBalancerAttributes with the addition of 1483// the ability to pass a context and additional request options. 1484// 1485// See DescribeLoadBalancerAttributes for details on how to use this API operation. 1486// 1487// The context must be non-nil and will be used for request cancellation. If 1488// the context is nil a panic will occur. In the future the SDK may create 1489// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1490// for more information on using Contexts. 1491func (c *ELB) DescribeLoadBalancerAttributesWithContext(ctx aws.Context, input *DescribeLoadBalancerAttributesInput, opts ...request.Option) (*DescribeLoadBalancerAttributesOutput, error) { 1492 req, out := c.DescribeLoadBalancerAttributesRequest(input) 1493 req.SetContext(ctx) 1494 req.ApplyOptions(opts...) 1495 return out, req.Send() 1496} 1497 1498const opDescribeLoadBalancerPolicies = "DescribeLoadBalancerPolicies" 1499 1500// DescribeLoadBalancerPoliciesRequest generates a "aws/request.Request" representing the 1501// client's request for the DescribeLoadBalancerPolicies operation. The "output" return 1502// value will be populated with the request's response once the request completes 1503// successfully. 1504// 1505// Use "Send" method on the returned Request to send the API call to the service. 1506// the "output" return value is not valid until after Send returns without error. 1507// 1508// See DescribeLoadBalancerPolicies for more information on using the DescribeLoadBalancerPolicies 1509// API call, and error handling. 1510// 1511// This method is useful when you want to inject custom logic or configuration 1512// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1513// 1514// 1515// // Example sending a request using the DescribeLoadBalancerPoliciesRequest method. 1516// req, resp := client.DescribeLoadBalancerPoliciesRequest(params) 1517// 1518// err := req.Send() 1519// if err == nil { // resp is now filled 1520// fmt.Println(resp) 1521// } 1522// 1523// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DescribeLoadBalancerPolicies 1524func (c *ELB) DescribeLoadBalancerPoliciesRequest(input *DescribeLoadBalancerPoliciesInput) (req *request.Request, output *DescribeLoadBalancerPoliciesOutput) { 1525 op := &request.Operation{ 1526 Name: opDescribeLoadBalancerPolicies, 1527 HTTPMethod: "POST", 1528 HTTPPath: "/", 1529 } 1530 1531 if input == nil { 1532 input = &DescribeLoadBalancerPoliciesInput{} 1533 } 1534 1535 output = &DescribeLoadBalancerPoliciesOutput{} 1536 req = c.newRequest(op, input, output) 1537 return 1538} 1539 1540// DescribeLoadBalancerPolicies API operation for Elastic Load Balancing. 1541// 1542// Describes the specified policies. 1543// 1544// If you specify a load balancer name, the action returns the descriptions 1545// of all policies created for the load balancer. If you specify a policy name 1546// associated with your load balancer, the action returns the description of 1547// that policy. If you don't specify a load balancer name, the action returns 1548// descriptions of the specified sample policies, or descriptions of all sample 1549// policies. The names of the sample policies have the ELBSample- prefix. 1550// 1551// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1552// with awserr.Error's Code and Message methods to get detailed information about 1553// the error. 1554// 1555// See the AWS API reference guide for Elastic Load Balancing's 1556// API operation DescribeLoadBalancerPolicies for usage and error information. 1557// 1558// Returned Error Codes: 1559// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 1560// The specified load balancer does not exist. 1561// 1562// * ErrCodePolicyNotFoundException "PolicyNotFound" 1563// One or more of the specified policies do not exist. 1564// 1565// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DescribeLoadBalancerPolicies 1566func (c *ELB) DescribeLoadBalancerPolicies(input *DescribeLoadBalancerPoliciesInput) (*DescribeLoadBalancerPoliciesOutput, error) { 1567 req, out := c.DescribeLoadBalancerPoliciesRequest(input) 1568 return out, req.Send() 1569} 1570 1571// DescribeLoadBalancerPoliciesWithContext is the same as DescribeLoadBalancerPolicies with the addition of 1572// the ability to pass a context and additional request options. 1573// 1574// See DescribeLoadBalancerPolicies for details on how to use this API operation. 1575// 1576// The context must be non-nil and will be used for request cancellation. If 1577// the context is nil a panic will occur. In the future the SDK may create 1578// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1579// for more information on using Contexts. 1580func (c *ELB) DescribeLoadBalancerPoliciesWithContext(ctx aws.Context, input *DescribeLoadBalancerPoliciesInput, opts ...request.Option) (*DescribeLoadBalancerPoliciesOutput, error) { 1581 req, out := c.DescribeLoadBalancerPoliciesRequest(input) 1582 req.SetContext(ctx) 1583 req.ApplyOptions(opts...) 1584 return out, req.Send() 1585} 1586 1587const opDescribeLoadBalancerPolicyTypes = "DescribeLoadBalancerPolicyTypes" 1588 1589// DescribeLoadBalancerPolicyTypesRequest generates a "aws/request.Request" representing the 1590// client's request for the DescribeLoadBalancerPolicyTypes operation. The "output" return 1591// value will be populated with the request's response once the request completes 1592// successfully. 1593// 1594// Use "Send" method on the returned Request to send the API call to the service. 1595// the "output" return value is not valid until after Send returns without error. 1596// 1597// See DescribeLoadBalancerPolicyTypes for more information on using the DescribeLoadBalancerPolicyTypes 1598// API call, and error handling. 1599// 1600// This method is useful when you want to inject custom logic or configuration 1601// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1602// 1603// 1604// // Example sending a request using the DescribeLoadBalancerPolicyTypesRequest method. 1605// req, resp := client.DescribeLoadBalancerPolicyTypesRequest(params) 1606// 1607// err := req.Send() 1608// if err == nil { // resp is now filled 1609// fmt.Println(resp) 1610// } 1611// 1612// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DescribeLoadBalancerPolicyTypes 1613func (c *ELB) DescribeLoadBalancerPolicyTypesRequest(input *DescribeLoadBalancerPolicyTypesInput) (req *request.Request, output *DescribeLoadBalancerPolicyTypesOutput) { 1614 op := &request.Operation{ 1615 Name: opDescribeLoadBalancerPolicyTypes, 1616 HTTPMethod: "POST", 1617 HTTPPath: "/", 1618 } 1619 1620 if input == nil { 1621 input = &DescribeLoadBalancerPolicyTypesInput{} 1622 } 1623 1624 output = &DescribeLoadBalancerPolicyTypesOutput{} 1625 req = c.newRequest(op, input, output) 1626 return 1627} 1628 1629// DescribeLoadBalancerPolicyTypes API operation for Elastic Load Balancing. 1630// 1631// Describes the specified load balancer policy types or all load balancer policy 1632// types. 1633// 1634// The description of each type indicates how it can be used. For example, some 1635// policies can be used only with layer 7 listeners, some policies can be used 1636// only with layer 4 listeners, and some policies can be used only with your 1637// EC2 instances. 1638// 1639// You can use CreateLoadBalancerPolicy to create a policy configuration for 1640// any of these policy types. Then, depending on the policy type, use either 1641// SetLoadBalancerPoliciesOfListener or SetLoadBalancerPoliciesForBackendServer 1642// to set the policy. 1643// 1644// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1645// with awserr.Error's Code and Message methods to get detailed information about 1646// the error. 1647// 1648// See the AWS API reference guide for Elastic Load Balancing's 1649// API operation DescribeLoadBalancerPolicyTypes for usage and error information. 1650// 1651// Returned Error Codes: 1652// * ErrCodePolicyTypeNotFoundException "PolicyTypeNotFound" 1653// One or more of the specified policy types do not exist. 1654// 1655// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DescribeLoadBalancerPolicyTypes 1656func (c *ELB) DescribeLoadBalancerPolicyTypes(input *DescribeLoadBalancerPolicyTypesInput) (*DescribeLoadBalancerPolicyTypesOutput, error) { 1657 req, out := c.DescribeLoadBalancerPolicyTypesRequest(input) 1658 return out, req.Send() 1659} 1660 1661// DescribeLoadBalancerPolicyTypesWithContext is the same as DescribeLoadBalancerPolicyTypes with the addition of 1662// the ability to pass a context and additional request options. 1663// 1664// See DescribeLoadBalancerPolicyTypes for details on how to use this API operation. 1665// 1666// The context must be non-nil and will be used for request cancellation. If 1667// the context is nil a panic will occur. In the future the SDK may create 1668// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1669// for more information on using Contexts. 1670func (c *ELB) DescribeLoadBalancerPolicyTypesWithContext(ctx aws.Context, input *DescribeLoadBalancerPolicyTypesInput, opts ...request.Option) (*DescribeLoadBalancerPolicyTypesOutput, error) { 1671 req, out := c.DescribeLoadBalancerPolicyTypesRequest(input) 1672 req.SetContext(ctx) 1673 req.ApplyOptions(opts...) 1674 return out, req.Send() 1675} 1676 1677const opDescribeLoadBalancers = "DescribeLoadBalancers" 1678 1679// DescribeLoadBalancersRequest generates a "aws/request.Request" representing the 1680// client's request for the DescribeLoadBalancers operation. The "output" return 1681// value will be populated with the request's response once the request completes 1682// successfully. 1683// 1684// Use "Send" method on the returned Request to send the API call to the service. 1685// the "output" return value is not valid until after Send returns without error. 1686// 1687// See DescribeLoadBalancers for more information on using the DescribeLoadBalancers 1688// API call, and error handling. 1689// 1690// This method is useful when you want to inject custom logic or configuration 1691// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1692// 1693// 1694// // Example sending a request using the DescribeLoadBalancersRequest method. 1695// req, resp := client.DescribeLoadBalancersRequest(params) 1696// 1697// err := req.Send() 1698// if err == nil { // resp is now filled 1699// fmt.Println(resp) 1700// } 1701// 1702// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DescribeLoadBalancers 1703func (c *ELB) DescribeLoadBalancersRequest(input *DescribeLoadBalancersInput) (req *request.Request, output *DescribeLoadBalancersOutput) { 1704 op := &request.Operation{ 1705 Name: opDescribeLoadBalancers, 1706 HTTPMethod: "POST", 1707 HTTPPath: "/", 1708 Paginator: &request.Paginator{ 1709 InputTokens: []string{"Marker"}, 1710 OutputTokens: []string{"NextMarker"}, 1711 LimitToken: "", 1712 TruncationToken: "", 1713 }, 1714 } 1715 1716 if input == nil { 1717 input = &DescribeLoadBalancersInput{} 1718 } 1719 1720 output = &DescribeLoadBalancersOutput{} 1721 req = c.newRequest(op, input, output) 1722 return 1723} 1724 1725// DescribeLoadBalancers API operation for Elastic Load Balancing. 1726// 1727// Describes the specified the load balancers. If no load balancers are specified, 1728// the call describes all of your load balancers. 1729// 1730// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1731// with awserr.Error's Code and Message methods to get detailed information about 1732// the error. 1733// 1734// See the AWS API reference guide for Elastic Load Balancing's 1735// API operation DescribeLoadBalancers for usage and error information. 1736// 1737// Returned Error Codes: 1738// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 1739// The specified load balancer does not exist. 1740// 1741// * ErrCodeDependencyThrottleException "DependencyThrottle" 1742// A request made by Elastic Load Balancing to another service exceeds the maximum 1743// request rate permitted for your account. 1744// 1745// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DescribeLoadBalancers 1746func (c *ELB) DescribeLoadBalancers(input *DescribeLoadBalancersInput) (*DescribeLoadBalancersOutput, error) { 1747 req, out := c.DescribeLoadBalancersRequest(input) 1748 return out, req.Send() 1749} 1750 1751// DescribeLoadBalancersWithContext is the same as DescribeLoadBalancers with the addition of 1752// the ability to pass a context and additional request options. 1753// 1754// See DescribeLoadBalancers for details on how to use this API operation. 1755// 1756// The context must be non-nil and will be used for request cancellation. If 1757// the context is nil a panic will occur. In the future the SDK may create 1758// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1759// for more information on using Contexts. 1760func (c *ELB) DescribeLoadBalancersWithContext(ctx aws.Context, input *DescribeLoadBalancersInput, opts ...request.Option) (*DescribeLoadBalancersOutput, error) { 1761 req, out := c.DescribeLoadBalancersRequest(input) 1762 req.SetContext(ctx) 1763 req.ApplyOptions(opts...) 1764 return out, req.Send() 1765} 1766 1767// DescribeLoadBalancersPages iterates over the pages of a DescribeLoadBalancers operation, 1768// calling the "fn" function with the response data for each page. To stop 1769// iterating, return false from the fn function. 1770// 1771// See DescribeLoadBalancers method for more information on how to use this operation. 1772// 1773// Note: This operation can generate multiple requests to a service. 1774// 1775// // Example iterating over at most 3 pages of a DescribeLoadBalancers operation. 1776// pageNum := 0 1777// err := client.DescribeLoadBalancersPages(params, 1778// func(page *elb.DescribeLoadBalancersOutput, lastPage bool) bool { 1779// pageNum++ 1780// fmt.Println(page) 1781// return pageNum <= 3 1782// }) 1783// 1784func (c *ELB) DescribeLoadBalancersPages(input *DescribeLoadBalancersInput, fn func(*DescribeLoadBalancersOutput, bool) bool) error { 1785 return c.DescribeLoadBalancersPagesWithContext(aws.BackgroundContext(), input, fn) 1786} 1787 1788// DescribeLoadBalancersPagesWithContext same as DescribeLoadBalancersPages except 1789// it takes a Context and allows setting request options on the pages. 1790// 1791// The context must be non-nil and will be used for request cancellation. If 1792// the context is nil a panic will occur. In the future the SDK may create 1793// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1794// for more information on using Contexts. 1795func (c *ELB) DescribeLoadBalancersPagesWithContext(ctx aws.Context, input *DescribeLoadBalancersInput, fn func(*DescribeLoadBalancersOutput, bool) bool, opts ...request.Option) error { 1796 p := request.Pagination{ 1797 NewRequest: func() (*request.Request, error) { 1798 var inCpy *DescribeLoadBalancersInput 1799 if input != nil { 1800 tmp := *input 1801 inCpy = &tmp 1802 } 1803 req, _ := c.DescribeLoadBalancersRequest(inCpy) 1804 req.SetContext(ctx) 1805 req.ApplyOptions(opts...) 1806 return req, nil 1807 }, 1808 } 1809 1810 for p.Next() { 1811 if !fn(p.Page().(*DescribeLoadBalancersOutput), !p.HasNextPage()) { 1812 break 1813 } 1814 } 1815 1816 return p.Err() 1817} 1818 1819const opDescribeTags = "DescribeTags" 1820 1821// DescribeTagsRequest generates a "aws/request.Request" representing the 1822// client's request for the DescribeTags operation. The "output" return 1823// value will be populated with the request's response once the request completes 1824// successfully. 1825// 1826// Use "Send" method on the returned Request to send the API call to the service. 1827// the "output" return value is not valid until after Send returns without error. 1828// 1829// See DescribeTags for more information on using the DescribeTags 1830// API call, and error handling. 1831// 1832// This method is useful when you want to inject custom logic or configuration 1833// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1834// 1835// 1836// // Example sending a request using the DescribeTagsRequest method. 1837// req, resp := client.DescribeTagsRequest(params) 1838// 1839// err := req.Send() 1840// if err == nil { // resp is now filled 1841// fmt.Println(resp) 1842// } 1843// 1844// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DescribeTags 1845func (c *ELB) DescribeTagsRequest(input *DescribeTagsInput) (req *request.Request, output *DescribeTagsOutput) { 1846 op := &request.Operation{ 1847 Name: opDescribeTags, 1848 HTTPMethod: "POST", 1849 HTTPPath: "/", 1850 } 1851 1852 if input == nil { 1853 input = &DescribeTagsInput{} 1854 } 1855 1856 output = &DescribeTagsOutput{} 1857 req = c.newRequest(op, input, output) 1858 return 1859} 1860 1861// DescribeTags API operation for Elastic Load Balancing. 1862// 1863// Describes the tags associated with the specified load balancers. 1864// 1865// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1866// with awserr.Error's Code and Message methods to get detailed information about 1867// the error. 1868// 1869// See the AWS API reference guide for Elastic Load Balancing's 1870// API operation DescribeTags for usage and error information. 1871// 1872// Returned Error Codes: 1873// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 1874// The specified load balancer does not exist. 1875// 1876// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DescribeTags 1877func (c *ELB) DescribeTags(input *DescribeTagsInput) (*DescribeTagsOutput, error) { 1878 req, out := c.DescribeTagsRequest(input) 1879 return out, req.Send() 1880} 1881 1882// DescribeTagsWithContext is the same as DescribeTags with the addition of 1883// the ability to pass a context and additional request options. 1884// 1885// See DescribeTags for details on how to use this API operation. 1886// 1887// The context must be non-nil and will be used for request cancellation. If 1888// the context is nil a panic will occur. In the future the SDK may create 1889// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1890// for more information on using Contexts. 1891func (c *ELB) DescribeTagsWithContext(ctx aws.Context, input *DescribeTagsInput, opts ...request.Option) (*DescribeTagsOutput, error) { 1892 req, out := c.DescribeTagsRequest(input) 1893 req.SetContext(ctx) 1894 req.ApplyOptions(opts...) 1895 return out, req.Send() 1896} 1897 1898const opDetachLoadBalancerFromSubnets = "DetachLoadBalancerFromSubnets" 1899 1900// DetachLoadBalancerFromSubnetsRequest generates a "aws/request.Request" representing the 1901// client's request for the DetachLoadBalancerFromSubnets operation. The "output" return 1902// value will be populated with the request's response once the request completes 1903// successfully. 1904// 1905// Use "Send" method on the returned Request to send the API call to the service. 1906// the "output" return value is not valid until after Send returns without error. 1907// 1908// See DetachLoadBalancerFromSubnets for more information on using the DetachLoadBalancerFromSubnets 1909// API call, and error handling. 1910// 1911// This method is useful when you want to inject custom logic or configuration 1912// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1913// 1914// 1915// // Example sending a request using the DetachLoadBalancerFromSubnetsRequest method. 1916// req, resp := client.DetachLoadBalancerFromSubnetsRequest(params) 1917// 1918// err := req.Send() 1919// if err == nil { // resp is now filled 1920// fmt.Println(resp) 1921// } 1922// 1923// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DetachLoadBalancerFromSubnets 1924func (c *ELB) DetachLoadBalancerFromSubnetsRequest(input *DetachLoadBalancerFromSubnetsInput) (req *request.Request, output *DetachLoadBalancerFromSubnetsOutput) { 1925 op := &request.Operation{ 1926 Name: opDetachLoadBalancerFromSubnets, 1927 HTTPMethod: "POST", 1928 HTTPPath: "/", 1929 } 1930 1931 if input == nil { 1932 input = &DetachLoadBalancerFromSubnetsInput{} 1933 } 1934 1935 output = &DetachLoadBalancerFromSubnetsOutput{} 1936 req = c.newRequest(op, input, output) 1937 return 1938} 1939 1940// DetachLoadBalancerFromSubnets API operation for Elastic Load Balancing. 1941// 1942// Removes the specified subnets from the set of configured subnets for the 1943// load balancer. 1944// 1945// After a subnet is removed, all EC2 instances registered with the load balancer 1946// in the removed subnet go into the OutOfService state. Then, the load balancer 1947// balances the traffic among the remaining routable subnets. 1948// 1949// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1950// with awserr.Error's Code and Message methods to get detailed information about 1951// the error. 1952// 1953// See the AWS API reference guide for Elastic Load Balancing's 1954// API operation DetachLoadBalancerFromSubnets for usage and error information. 1955// 1956// Returned Error Codes: 1957// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 1958// The specified load balancer does not exist. 1959// 1960// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 1961// The requested configuration change is not valid. 1962// 1963// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DetachLoadBalancerFromSubnets 1964func (c *ELB) DetachLoadBalancerFromSubnets(input *DetachLoadBalancerFromSubnetsInput) (*DetachLoadBalancerFromSubnetsOutput, error) { 1965 req, out := c.DetachLoadBalancerFromSubnetsRequest(input) 1966 return out, req.Send() 1967} 1968 1969// DetachLoadBalancerFromSubnetsWithContext is the same as DetachLoadBalancerFromSubnets with the addition of 1970// the ability to pass a context and additional request options. 1971// 1972// See DetachLoadBalancerFromSubnets for details on how to use this API operation. 1973// 1974// The context must be non-nil and will be used for request cancellation. If 1975// the context is nil a panic will occur. In the future the SDK may create 1976// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1977// for more information on using Contexts. 1978func (c *ELB) DetachLoadBalancerFromSubnetsWithContext(ctx aws.Context, input *DetachLoadBalancerFromSubnetsInput, opts ...request.Option) (*DetachLoadBalancerFromSubnetsOutput, error) { 1979 req, out := c.DetachLoadBalancerFromSubnetsRequest(input) 1980 req.SetContext(ctx) 1981 req.ApplyOptions(opts...) 1982 return out, req.Send() 1983} 1984 1985const opDisableAvailabilityZonesForLoadBalancer = "DisableAvailabilityZonesForLoadBalancer" 1986 1987// DisableAvailabilityZonesForLoadBalancerRequest generates a "aws/request.Request" representing the 1988// client's request for the DisableAvailabilityZonesForLoadBalancer operation. The "output" return 1989// value will be populated with the request's response once the request completes 1990// successfully. 1991// 1992// Use "Send" method on the returned Request to send the API call to the service. 1993// the "output" return value is not valid until after Send returns without error. 1994// 1995// See DisableAvailabilityZonesForLoadBalancer for more information on using the DisableAvailabilityZonesForLoadBalancer 1996// API call, and error handling. 1997// 1998// This method is useful when you want to inject custom logic or configuration 1999// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2000// 2001// 2002// // Example sending a request using the DisableAvailabilityZonesForLoadBalancerRequest method. 2003// req, resp := client.DisableAvailabilityZonesForLoadBalancerRequest(params) 2004// 2005// err := req.Send() 2006// if err == nil { // resp is now filled 2007// fmt.Println(resp) 2008// } 2009// 2010// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DisableAvailabilityZonesForLoadBalancer 2011func (c *ELB) DisableAvailabilityZonesForLoadBalancerRequest(input *DisableAvailabilityZonesForLoadBalancerInput) (req *request.Request, output *DisableAvailabilityZonesForLoadBalancerOutput) { 2012 op := &request.Operation{ 2013 Name: opDisableAvailabilityZonesForLoadBalancer, 2014 HTTPMethod: "POST", 2015 HTTPPath: "/", 2016 } 2017 2018 if input == nil { 2019 input = &DisableAvailabilityZonesForLoadBalancerInput{} 2020 } 2021 2022 output = &DisableAvailabilityZonesForLoadBalancerOutput{} 2023 req = c.newRequest(op, input, output) 2024 return 2025} 2026 2027// DisableAvailabilityZonesForLoadBalancer API operation for Elastic Load Balancing. 2028// 2029// Removes the specified Availability Zones from the set of Availability Zones 2030// for the specified load balancer in EC2-Classic or a default VPC. 2031// 2032// For load balancers in a non-default VPC, use DetachLoadBalancerFromSubnets. 2033// 2034// There must be at least one Availability Zone registered with a load balancer 2035// at all times. After an Availability Zone is removed, all instances registered 2036// with the load balancer that are in the removed Availability Zone go into 2037// the OutOfService state. Then, the load balancer attempts to equally balance 2038// the traffic among its remaining Availability Zones. 2039// 2040// For more information, see Add or Remove Availability Zones (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-disable-az.html) 2041// in the Classic Load Balancers Guide. 2042// 2043// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2044// with awserr.Error's Code and Message methods to get detailed information about 2045// the error. 2046// 2047// See the AWS API reference guide for Elastic Load Balancing's 2048// API operation DisableAvailabilityZonesForLoadBalancer for usage and error information. 2049// 2050// Returned Error Codes: 2051// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 2052// The specified load balancer does not exist. 2053// 2054// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 2055// The requested configuration change is not valid. 2056// 2057// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/DisableAvailabilityZonesForLoadBalancer 2058func (c *ELB) DisableAvailabilityZonesForLoadBalancer(input *DisableAvailabilityZonesForLoadBalancerInput) (*DisableAvailabilityZonesForLoadBalancerOutput, error) { 2059 req, out := c.DisableAvailabilityZonesForLoadBalancerRequest(input) 2060 return out, req.Send() 2061} 2062 2063// DisableAvailabilityZonesForLoadBalancerWithContext is the same as DisableAvailabilityZonesForLoadBalancer with the addition of 2064// the ability to pass a context and additional request options. 2065// 2066// See DisableAvailabilityZonesForLoadBalancer for details on how to use this API operation. 2067// 2068// The context must be non-nil and will be used for request cancellation. If 2069// the context is nil a panic will occur. In the future the SDK may create 2070// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2071// for more information on using Contexts. 2072func (c *ELB) DisableAvailabilityZonesForLoadBalancerWithContext(ctx aws.Context, input *DisableAvailabilityZonesForLoadBalancerInput, opts ...request.Option) (*DisableAvailabilityZonesForLoadBalancerOutput, error) { 2073 req, out := c.DisableAvailabilityZonesForLoadBalancerRequest(input) 2074 req.SetContext(ctx) 2075 req.ApplyOptions(opts...) 2076 return out, req.Send() 2077} 2078 2079const opEnableAvailabilityZonesForLoadBalancer = "EnableAvailabilityZonesForLoadBalancer" 2080 2081// EnableAvailabilityZonesForLoadBalancerRequest generates a "aws/request.Request" representing the 2082// client's request for the EnableAvailabilityZonesForLoadBalancer operation. The "output" return 2083// value will be populated with the request's response once the request completes 2084// successfully. 2085// 2086// Use "Send" method on the returned Request to send the API call to the service. 2087// the "output" return value is not valid until after Send returns without error. 2088// 2089// See EnableAvailabilityZonesForLoadBalancer for more information on using the EnableAvailabilityZonesForLoadBalancer 2090// API call, and error handling. 2091// 2092// This method is useful when you want to inject custom logic or configuration 2093// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2094// 2095// 2096// // Example sending a request using the EnableAvailabilityZonesForLoadBalancerRequest method. 2097// req, resp := client.EnableAvailabilityZonesForLoadBalancerRequest(params) 2098// 2099// err := req.Send() 2100// if err == nil { // resp is now filled 2101// fmt.Println(resp) 2102// } 2103// 2104// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/EnableAvailabilityZonesForLoadBalancer 2105func (c *ELB) EnableAvailabilityZonesForLoadBalancerRequest(input *EnableAvailabilityZonesForLoadBalancerInput) (req *request.Request, output *EnableAvailabilityZonesForLoadBalancerOutput) { 2106 op := &request.Operation{ 2107 Name: opEnableAvailabilityZonesForLoadBalancer, 2108 HTTPMethod: "POST", 2109 HTTPPath: "/", 2110 } 2111 2112 if input == nil { 2113 input = &EnableAvailabilityZonesForLoadBalancerInput{} 2114 } 2115 2116 output = &EnableAvailabilityZonesForLoadBalancerOutput{} 2117 req = c.newRequest(op, input, output) 2118 return 2119} 2120 2121// EnableAvailabilityZonesForLoadBalancer API operation for Elastic Load Balancing. 2122// 2123// Adds the specified Availability Zones to the set of Availability Zones for 2124// the specified load balancer in EC2-Classic or a default VPC. 2125// 2126// For load balancers in a non-default VPC, use AttachLoadBalancerToSubnets. 2127// 2128// The load balancer evenly distributes requests across all its registered Availability 2129// Zones that contain instances. For more information, see Add or Remove Availability 2130// Zones (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-disable-az.html) 2131// in the Classic Load Balancers Guide. 2132// 2133// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2134// with awserr.Error's Code and Message methods to get detailed information about 2135// the error. 2136// 2137// See the AWS API reference guide for Elastic Load Balancing's 2138// API operation EnableAvailabilityZonesForLoadBalancer for usage and error information. 2139// 2140// Returned Error Codes: 2141// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 2142// The specified load balancer does not exist. 2143// 2144// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/EnableAvailabilityZonesForLoadBalancer 2145func (c *ELB) EnableAvailabilityZonesForLoadBalancer(input *EnableAvailabilityZonesForLoadBalancerInput) (*EnableAvailabilityZonesForLoadBalancerOutput, error) { 2146 req, out := c.EnableAvailabilityZonesForLoadBalancerRequest(input) 2147 return out, req.Send() 2148} 2149 2150// EnableAvailabilityZonesForLoadBalancerWithContext is the same as EnableAvailabilityZonesForLoadBalancer with the addition of 2151// the ability to pass a context and additional request options. 2152// 2153// See EnableAvailabilityZonesForLoadBalancer for details on how to use this API operation. 2154// 2155// The context must be non-nil and will be used for request cancellation. If 2156// the context is nil a panic will occur. In the future the SDK may create 2157// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2158// for more information on using Contexts. 2159func (c *ELB) EnableAvailabilityZonesForLoadBalancerWithContext(ctx aws.Context, input *EnableAvailabilityZonesForLoadBalancerInput, opts ...request.Option) (*EnableAvailabilityZonesForLoadBalancerOutput, error) { 2160 req, out := c.EnableAvailabilityZonesForLoadBalancerRequest(input) 2161 req.SetContext(ctx) 2162 req.ApplyOptions(opts...) 2163 return out, req.Send() 2164} 2165 2166const opModifyLoadBalancerAttributes = "ModifyLoadBalancerAttributes" 2167 2168// ModifyLoadBalancerAttributesRequest generates a "aws/request.Request" representing the 2169// client's request for the ModifyLoadBalancerAttributes operation. The "output" return 2170// value will be populated with the request's response once the request completes 2171// successfully. 2172// 2173// Use "Send" method on the returned Request to send the API call to the service. 2174// the "output" return value is not valid until after Send returns without error. 2175// 2176// See ModifyLoadBalancerAttributes for more information on using the ModifyLoadBalancerAttributes 2177// API call, and error handling. 2178// 2179// This method is useful when you want to inject custom logic or configuration 2180// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2181// 2182// 2183// // Example sending a request using the ModifyLoadBalancerAttributesRequest method. 2184// req, resp := client.ModifyLoadBalancerAttributesRequest(params) 2185// 2186// err := req.Send() 2187// if err == nil { // resp is now filled 2188// fmt.Println(resp) 2189// } 2190// 2191// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/ModifyLoadBalancerAttributes 2192func (c *ELB) ModifyLoadBalancerAttributesRequest(input *ModifyLoadBalancerAttributesInput) (req *request.Request, output *ModifyLoadBalancerAttributesOutput) { 2193 op := &request.Operation{ 2194 Name: opModifyLoadBalancerAttributes, 2195 HTTPMethod: "POST", 2196 HTTPPath: "/", 2197 } 2198 2199 if input == nil { 2200 input = &ModifyLoadBalancerAttributesInput{} 2201 } 2202 2203 output = &ModifyLoadBalancerAttributesOutput{} 2204 req = c.newRequest(op, input, output) 2205 return 2206} 2207 2208// ModifyLoadBalancerAttributes API operation for Elastic Load Balancing. 2209// 2210// Modifies the attributes of the specified load balancer. 2211// 2212// You can modify the load balancer attributes, such as AccessLogs, ConnectionDraining, 2213// and CrossZoneLoadBalancing by either enabling or disabling them. Or, you 2214// can modify the load balancer attribute ConnectionSettings by specifying an 2215// idle connection timeout value for your load balancer. 2216// 2217// For more information, see the following in the Classic Load Balancers Guide: 2218// 2219// * Cross-Zone Load Balancing (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-disable-crosszone-lb.html) 2220// 2221// * Connection Draining (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/config-conn-drain.html) 2222// 2223// * Access Logs (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/access-log-collection.html) 2224// 2225// * Idle Connection Timeout (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/config-idle-timeout.html) 2226// 2227// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2228// with awserr.Error's Code and Message methods to get detailed information about 2229// the error. 2230// 2231// See the AWS API reference guide for Elastic Load Balancing's 2232// API operation ModifyLoadBalancerAttributes for usage and error information. 2233// 2234// Returned Error Codes: 2235// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 2236// The specified load balancer does not exist. 2237// 2238// * ErrCodeLoadBalancerAttributeNotFoundException "LoadBalancerAttributeNotFound" 2239// The specified load balancer attribute does not exist. 2240// 2241// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 2242// The requested configuration change is not valid. 2243// 2244// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/ModifyLoadBalancerAttributes 2245func (c *ELB) ModifyLoadBalancerAttributes(input *ModifyLoadBalancerAttributesInput) (*ModifyLoadBalancerAttributesOutput, error) { 2246 req, out := c.ModifyLoadBalancerAttributesRequest(input) 2247 return out, req.Send() 2248} 2249 2250// ModifyLoadBalancerAttributesWithContext is the same as ModifyLoadBalancerAttributes with the addition of 2251// the ability to pass a context and additional request options. 2252// 2253// See ModifyLoadBalancerAttributes for details on how to use this API operation. 2254// 2255// The context must be non-nil and will be used for request cancellation. If 2256// the context is nil a panic will occur. In the future the SDK may create 2257// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2258// for more information on using Contexts. 2259func (c *ELB) ModifyLoadBalancerAttributesWithContext(ctx aws.Context, input *ModifyLoadBalancerAttributesInput, opts ...request.Option) (*ModifyLoadBalancerAttributesOutput, error) { 2260 req, out := c.ModifyLoadBalancerAttributesRequest(input) 2261 req.SetContext(ctx) 2262 req.ApplyOptions(opts...) 2263 return out, req.Send() 2264} 2265 2266const opRegisterInstancesWithLoadBalancer = "RegisterInstancesWithLoadBalancer" 2267 2268// RegisterInstancesWithLoadBalancerRequest generates a "aws/request.Request" representing the 2269// client's request for the RegisterInstancesWithLoadBalancer operation. The "output" return 2270// value will be populated with the request's response once the request completes 2271// successfully. 2272// 2273// Use "Send" method on the returned Request to send the API call to the service. 2274// the "output" return value is not valid until after Send returns without error. 2275// 2276// See RegisterInstancesWithLoadBalancer for more information on using the RegisterInstancesWithLoadBalancer 2277// API call, and error handling. 2278// 2279// This method is useful when you want to inject custom logic or configuration 2280// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2281// 2282// 2283// // Example sending a request using the RegisterInstancesWithLoadBalancerRequest method. 2284// req, resp := client.RegisterInstancesWithLoadBalancerRequest(params) 2285// 2286// err := req.Send() 2287// if err == nil { // resp is now filled 2288// fmt.Println(resp) 2289// } 2290// 2291// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/RegisterInstancesWithLoadBalancer 2292func (c *ELB) RegisterInstancesWithLoadBalancerRequest(input *RegisterInstancesWithLoadBalancerInput) (req *request.Request, output *RegisterInstancesWithLoadBalancerOutput) { 2293 op := &request.Operation{ 2294 Name: opRegisterInstancesWithLoadBalancer, 2295 HTTPMethod: "POST", 2296 HTTPPath: "/", 2297 } 2298 2299 if input == nil { 2300 input = &RegisterInstancesWithLoadBalancerInput{} 2301 } 2302 2303 output = &RegisterInstancesWithLoadBalancerOutput{} 2304 req = c.newRequest(op, input, output) 2305 return 2306} 2307 2308// RegisterInstancesWithLoadBalancer API operation for Elastic Load Balancing. 2309// 2310// Adds the specified instances to the specified load balancer. 2311// 2312// The instance must be a running instance in the same network as the load balancer 2313// (EC2-Classic or the same VPC). If you have EC2-Classic instances and a load 2314// balancer in a VPC with ClassicLink enabled, you can link the EC2-Classic 2315// instances to that VPC and then register the linked EC2-Classic instances 2316// with the load balancer in the VPC. 2317// 2318// Note that RegisterInstanceWithLoadBalancer completes when the request has 2319// been registered. Instance registration takes a little time to complete. To 2320// check the state of the registered instances, use DescribeLoadBalancers or 2321// DescribeInstanceHealth. 2322// 2323// After the instance is registered, it starts receiving traffic and requests 2324// from the load balancer. Any instance that is not in one of the Availability 2325// Zones registered for the load balancer is moved to the OutOfService state. 2326// If an Availability Zone is added to the load balancer later, any instances 2327// registered with the load balancer move to the InService state. 2328// 2329// To deregister instances from a load balancer, use DeregisterInstancesFromLoadBalancer. 2330// 2331// For more information, see Register or De-Register EC2 Instances (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-deregister-register-instances.html) 2332// in the Classic Load Balancers Guide. 2333// 2334// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2335// with awserr.Error's Code and Message methods to get detailed information about 2336// the error. 2337// 2338// See the AWS API reference guide for Elastic Load Balancing's 2339// API operation RegisterInstancesWithLoadBalancer for usage and error information. 2340// 2341// Returned Error Codes: 2342// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 2343// The specified load balancer does not exist. 2344// 2345// * ErrCodeInvalidEndPointException "InvalidInstance" 2346// The specified endpoint is not valid. 2347// 2348// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/RegisterInstancesWithLoadBalancer 2349func (c *ELB) RegisterInstancesWithLoadBalancer(input *RegisterInstancesWithLoadBalancerInput) (*RegisterInstancesWithLoadBalancerOutput, error) { 2350 req, out := c.RegisterInstancesWithLoadBalancerRequest(input) 2351 return out, req.Send() 2352} 2353 2354// RegisterInstancesWithLoadBalancerWithContext is the same as RegisterInstancesWithLoadBalancer with the addition of 2355// the ability to pass a context and additional request options. 2356// 2357// See RegisterInstancesWithLoadBalancer for details on how to use this API operation. 2358// 2359// The context must be non-nil and will be used for request cancellation. If 2360// the context is nil a panic will occur. In the future the SDK may create 2361// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2362// for more information on using Contexts. 2363func (c *ELB) RegisterInstancesWithLoadBalancerWithContext(ctx aws.Context, input *RegisterInstancesWithLoadBalancerInput, opts ...request.Option) (*RegisterInstancesWithLoadBalancerOutput, error) { 2364 req, out := c.RegisterInstancesWithLoadBalancerRequest(input) 2365 req.SetContext(ctx) 2366 req.ApplyOptions(opts...) 2367 return out, req.Send() 2368} 2369 2370const opRemoveTags = "RemoveTags" 2371 2372// RemoveTagsRequest generates a "aws/request.Request" representing the 2373// client's request for the RemoveTags operation. The "output" return 2374// value will be populated with the request's response once the request completes 2375// successfully. 2376// 2377// Use "Send" method on the returned Request to send the API call to the service. 2378// the "output" return value is not valid until after Send returns without error. 2379// 2380// See RemoveTags for more information on using the RemoveTags 2381// API call, and error handling. 2382// 2383// This method is useful when you want to inject custom logic or configuration 2384// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2385// 2386// 2387// // Example sending a request using the RemoveTagsRequest method. 2388// req, resp := client.RemoveTagsRequest(params) 2389// 2390// err := req.Send() 2391// if err == nil { // resp is now filled 2392// fmt.Println(resp) 2393// } 2394// 2395// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/RemoveTags 2396func (c *ELB) RemoveTagsRequest(input *RemoveTagsInput) (req *request.Request, output *RemoveTagsOutput) { 2397 op := &request.Operation{ 2398 Name: opRemoveTags, 2399 HTTPMethod: "POST", 2400 HTTPPath: "/", 2401 } 2402 2403 if input == nil { 2404 input = &RemoveTagsInput{} 2405 } 2406 2407 output = &RemoveTagsOutput{} 2408 req = c.newRequest(op, input, output) 2409 req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 2410 return 2411} 2412 2413// RemoveTags API operation for Elastic Load Balancing. 2414// 2415// Removes one or more tags from the specified load balancer. 2416// 2417// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2418// with awserr.Error's Code and Message methods to get detailed information about 2419// the error. 2420// 2421// See the AWS API reference guide for Elastic Load Balancing's 2422// API operation RemoveTags for usage and error information. 2423// 2424// Returned Error Codes: 2425// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 2426// The specified load balancer does not exist. 2427// 2428// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/RemoveTags 2429func (c *ELB) RemoveTags(input *RemoveTagsInput) (*RemoveTagsOutput, error) { 2430 req, out := c.RemoveTagsRequest(input) 2431 return out, req.Send() 2432} 2433 2434// RemoveTagsWithContext is the same as RemoveTags with the addition of 2435// the ability to pass a context and additional request options. 2436// 2437// See RemoveTags for details on how to use this API operation. 2438// 2439// The context must be non-nil and will be used for request cancellation. If 2440// the context is nil a panic will occur. In the future the SDK may create 2441// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2442// for more information on using Contexts. 2443func (c *ELB) RemoveTagsWithContext(ctx aws.Context, input *RemoveTagsInput, opts ...request.Option) (*RemoveTagsOutput, error) { 2444 req, out := c.RemoveTagsRequest(input) 2445 req.SetContext(ctx) 2446 req.ApplyOptions(opts...) 2447 return out, req.Send() 2448} 2449 2450const opSetLoadBalancerListenerSSLCertificate = "SetLoadBalancerListenerSSLCertificate" 2451 2452// SetLoadBalancerListenerSSLCertificateRequest generates a "aws/request.Request" representing the 2453// client's request for the SetLoadBalancerListenerSSLCertificate operation. The "output" return 2454// value will be populated with the request's response once the request completes 2455// successfully. 2456// 2457// Use "Send" method on the returned Request to send the API call to the service. 2458// the "output" return value is not valid until after Send returns without error. 2459// 2460// See SetLoadBalancerListenerSSLCertificate for more information on using the SetLoadBalancerListenerSSLCertificate 2461// API call, and error handling. 2462// 2463// This method is useful when you want to inject custom logic or configuration 2464// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2465// 2466// 2467// // Example sending a request using the SetLoadBalancerListenerSSLCertificateRequest method. 2468// req, resp := client.SetLoadBalancerListenerSSLCertificateRequest(params) 2469// 2470// err := req.Send() 2471// if err == nil { // resp is now filled 2472// fmt.Println(resp) 2473// } 2474// 2475// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/SetLoadBalancerListenerSSLCertificate 2476func (c *ELB) SetLoadBalancerListenerSSLCertificateRequest(input *SetLoadBalancerListenerSSLCertificateInput) (req *request.Request, output *SetLoadBalancerListenerSSLCertificateOutput) { 2477 op := &request.Operation{ 2478 Name: opSetLoadBalancerListenerSSLCertificate, 2479 HTTPMethod: "POST", 2480 HTTPPath: "/", 2481 } 2482 2483 if input == nil { 2484 input = &SetLoadBalancerListenerSSLCertificateInput{} 2485 } 2486 2487 output = &SetLoadBalancerListenerSSLCertificateOutput{} 2488 req = c.newRequest(op, input, output) 2489 req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 2490 return 2491} 2492 2493// SetLoadBalancerListenerSSLCertificate API operation for Elastic Load Balancing. 2494// 2495// Sets the certificate that terminates the specified listener's SSL connections. 2496// The specified certificate replaces any prior certificate that was used on 2497// the same load balancer and port. 2498// 2499// For more information about updating your SSL certificate, see Replace the 2500// SSL Certificate for Your Load Balancer (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-update-ssl-cert.html) 2501// in the Classic Load Balancers Guide. 2502// 2503// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2504// with awserr.Error's Code and Message methods to get detailed information about 2505// the error. 2506// 2507// See the AWS API reference guide for Elastic Load Balancing's 2508// API operation SetLoadBalancerListenerSSLCertificate for usage and error information. 2509// 2510// Returned Error Codes: 2511// * ErrCodeCertificateNotFoundException "CertificateNotFound" 2512// The specified ARN does not refer to a valid SSL certificate in AWS Identity 2513// and Access Management (IAM) or AWS Certificate Manager (ACM). Note that if 2514// you recently uploaded the certificate to IAM, this error might indicate that 2515// the certificate is not fully available yet. 2516// 2517// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 2518// The specified load balancer does not exist. 2519// 2520// * ErrCodeListenerNotFoundException "ListenerNotFound" 2521// The load balancer does not have a listener configured at the specified port. 2522// 2523// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 2524// The requested configuration change is not valid. 2525// 2526// * ErrCodeUnsupportedProtocolException "UnsupportedProtocol" 2527// The specified protocol or signature version is not supported. 2528// 2529// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/SetLoadBalancerListenerSSLCertificate 2530func (c *ELB) SetLoadBalancerListenerSSLCertificate(input *SetLoadBalancerListenerSSLCertificateInput) (*SetLoadBalancerListenerSSLCertificateOutput, error) { 2531 req, out := c.SetLoadBalancerListenerSSLCertificateRequest(input) 2532 return out, req.Send() 2533} 2534 2535// SetLoadBalancerListenerSSLCertificateWithContext is the same as SetLoadBalancerListenerSSLCertificate with the addition of 2536// the ability to pass a context and additional request options. 2537// 2538// See SetLoadBalancerListenerSSLCertificate for details on how to use this API operation. 2539// 2540// The context must be non-nil and will be used for request cancellation. If 2541// the context is nil a panic will occur. In the future the SDK may create 2542// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2543// for more information on using Contexts. 2544func (c *ELB) SetLoadBalancerListenerSSLCertificateWithContext(ctx aws.Context, input *SetLoadBalancerListenerSSLCertificateInput, opts ...request.Option) (*SetLoadBalancerListenerSSLCertificateOutput, error) { 2545 req, out := c.SetLoadBalancerListenerSSLCertificateRequest(input) 2546 req.SetContext(ctx) 2547 req.ApplyOptions(opts...) 2548 return out, req.Send() 2549} 2550 2551const opSetLoadBalancerPoliciesForBackendServer = "SetLoadBalancerPoliciesForBackendServer" 2552 2553// SetLoadBalancerPoliciesForBackendServerRequest generates a "aws/request.Request" representing the 2554// client's request for the SetLoadBalancerPoliciesForBackendServer operation. The "output" return 2555// value will be populated with the request's response once the request completes 2556// successfully. 2557// 2558// Use "Send" method on the returned Request to send the API call to the service. 2559// the "output" return value is not valid until after Send returns without error. 2560// 2561// See SetLoadBalancerPoliciesForBackendServer for more information on using the SetLoadBalancerPoliciesForBackendServer 2562// API call, and error handling. 2563// 2564// This method is useful when you want to inject custom logic or configuration 2565// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2566// 2567// 2568// // Example sending a request using the SetLoadBalancerPoliciesForBackendServerRequest method. 2569// req, resp := client.SetLoadBalancerPoliciesForBackendServerRequest(params) 2570// 2571// err := req.Send() 2572// if err == nil { // resp is now filled 2573// fmt.Println(resp) 2574// } 2575// 2576// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/SetLoadBalancerPoliciesForBackendServer 2577func (c *ELB) SetLoadBalancerPoliciesForBackendServerRequest(input *SetLoadBalancerPoliciesForBackendServerInput) (req *request.Request, output *SetLoadBalancerPoliciesForBackendServerOutput) { 2578 op := &request.Operation{ 2579 Name: opSetLoadBalancerPoliciesForBackendServer, 2580 HTTPMethod: "POST", 2581 HTTPPath: "/", 2582 } 2583 2584 if input == nil { 2585 input = &SetLoadBalancerPoliciesForBackendServerInput{} 2586 } 2587 2588 output = &SetLoadBalancerPoliciesForBackendServerOutput{} 2589 req = c.newRequest(op, input, output) 2590 req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 2591 return 2592} 2593 2594// SetLoadBalancerPoliciesForBackendServer API operation for Elastic Load Balancing. 2595// 2596// Replaces the set of policies associated with the specified port on which 2597// the EC2 instance is listening with a new set of policies. At this time, only 2598// the back-end server authentication policy type can be applied to the instance 2599// ports; this policy type is composed of multiple public key policies. 2600// 2601// Each time you use SetLoadBalancerPoliciesForBackendServer to enable the policies, 2602// use the PolicyNames parameter to list the policies that you want to enable. 2603// 2604// You can use DescribeLoadBalancers or DescribeLoadBalancerPolicies to verify 2605// that the policy is associated with the EC2 instance. 2606// 2607// For more information about enabling back-end instance authentication, see 2608// Configure Back-end Instance Authentication (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-create-https-ssl-load-balancer.html#configure_backendauth_clt) 2609// in the Classic Load Balancers Guide. For more information about Proxy Protocol, 2610// see Configure Proxy Protocol Support (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-proxy-protocol.html) 2611// in the Classic Load Balancers Guide. 2612// 2613// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2614// with awserr.Error's Code and Message methods to get detailed information about 2615// the error. 2616// 2617// See the AWS API reference guide for Elastic Load Balancing's 2618// API operation SetLoadBalancerPoliciesForBackendServer for usage and error information. 2619// 2620// Returned Error Codes: 2621// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 2622// The specified load balancer does not exist. 2623// 2624// * ErrCodePolicyNotFoundException "PolicyNotFound" 2625// One or more of the specified policies do not exist. 2626// 2627// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 2628// The requested configuration change is not valid. 2629// 2630// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/SetLoadBalancerPoliciesForBackendServer 2631func (c *ELB) SetLoadBalancerPoliciesForBackendServer(input *SetLoadBalancerPoliciesForBackendServerInput) (*SetLoadBalancerPoliciesForBackendServerOutput, error) { 2632 req, out := c.SetLoadBalancerPoliciesForBackendServerRequest(input) 2633 return out, req.Send() 2634} 2635 2636// SetLoadBalancerPoliciesForBackendServerWithContext is the same as SetLoadBalancerPoliciesForBackendServer with the addition of 2637// the ability to pass a context and additional request options. 2638// 2639// See SetLoadBalancerPoliciesForBackendServer for details on how to use this API operation. 2640// 2641// The context must be non-nil and will be used for request cancellation. If 2642// the context is nil a panic will occur. In the future the SDK may create 2643// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2644// for more information on using Contexts. 2645func (c *ELB) SetLoadBalancerPoliciesForBackendServerWithContext(ctx aws.Context, input *SetLoadBalancerPoliciesForBackendServerInput, opts ...request.Option) (*SetLoadBalancerPoliciesForBackendServerOutput, error) { 2646 req, out := c.SetLoadBalancerPoliciesForBackendServerRequest(input) 2647 req.SetContext(ctx) 2648 req.ApplyOptions(opts...) 2649 return out, req.Send() 2650} 2651 2652const opSetLoadBalancerPoliciesOfListener = "SetLoadBalancerPoliciesOfListener" 2653 2654// SetLoadBalancerPoliciesOfListenerRequest generates a "aws/request.Request" representing the 2655// client's request for the SetLoadBalancerPoliciesOfListener operation. The "output" return 2656// value will be populated with the request's response once the request completes 2657// successfully. 2658// 2659// Use "Send" method on the returned Request to send the API call to the service. 2660// the "output" return value is not valid until after Send returns without error. 2661// 2662// See SetLoadBalancerPoliciesOfListener for more information on using the SetLoadBalancerPoliciesOfListener 2663// API call, and error handling. 2664// 2665// This method is useful when you want to inject custom logic or configuration 2666// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2667// 2668// 2669// // Example sending a request using the SetLoadBalancerPoliciesOfListenerRequest method. 2670// req, resp := client.SetLoadBalancerPoliciesOfListenerRequest(params) 2671// 2672// err := req.Send() 2673// if err == nil { // resp is now filled 2674// fmt.Println(resp) 2675// } 2676// 2677// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/SetLoadBalancerPoliciesOfListener 2678func (c *ELB) SetLoadBalancerPoliciesOfListenerRequest(input *SetLoadBalancerPoliciesOfListenerInput) (req *request.Request, output *SetLoadBalancerPoliciesOfListenerOutput) { 2679 op := &request.Operation{ 2680 Name: opSetLoadBalancerPoliciesOfListener, 2681 HTTPMethod: "POST", 2682 HTTPPath: "/", 2683 } 2684 2685 if input == nil { 2686 input = &SetLoadBalancerPoliciesOfListenerInput{} 2687 } 2688 2689 output = &SetLoadBalancerPoliciesOfListenerOutput{} 2690 req = c.newRequest(op, input, output) 2691 req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 2692 return 2693} 2694 2695// SetLoadBalancerPoliciesOfListener API operation for Elastic Load Balancing. 2696// 2697// Replaces the current set of policies for the specified load balancer port 2698// with the specified set of policies. 2699// 2700// To enable back-end server authentication, use SetLoadBalancerPoliciesForBackendServer. 2701// 2702// For more information about setting policies, see Update the SSL Negotiation 2703// Configuration (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/ssl-config-update.html), 2704// Duration-Based Session Stickiness (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-sticky-sessions.html#enable-sticky-sessions-duration), 2705// and Application-Controlled Session Stickiness (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-sticky-sessions.html#enable-sticky-sessions-application) 2706// in the Classic Load Balancers Guide. 2707// 2708// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2709// with awserr.Error's Code and Message methods to get detailed information about 2710// the error. 2711// 2712// See the AWS API reference guide for Elastic Load Balancing's 2713// API operation SetLoadBalancerPoliciesOfListener for usage and error information. 2714// 2715// Returned Error Codes: 2716// * ErrCodeAccessPointNotFoundException "LoadBalancerNotFound" 2717// The specified load balancer does not exist. 2718// 2719// * ErrCodePolicyNotFoundException "PolicyNotFound" 2720// One or more of the specified policies do not exist. 2721// 2722// * ErrCodeListenerNotFoundException "ListenerNotFound" 2723// The load balancer does not have a listener configured at the specified port. 2724// 2725// * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest" 2726// The requested configuration change is not valid. 2727// 2728// See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancing-2012-06-01/SetLoadBalancerPoliciesOfListener 2729func (c *ELB) SetLoadBalancerPoliciesOfListener(input *SetLoadBalancerPoliciesOfListenerInput) (*SetLoadBalancerPoliciesOfListenerOutput, error) { 2730 req, out := c.SetLoadBalancerPoliciesOfListenerRequest(input) 2731 return out, req.Send() 2732} 2733 2734// SetLoadBalancerPoliciesOfListenerWithContext is the same as SetLoadBalancerPoliciesOfListener with the addition of 2735// the ability to pass a context and additional request options. 2736// 2737// See SetLoadBalancerPoliciesOfListener for details on how to use this API operation. 2738// 2739// The context must be non-nil and will be used for request cancellation. If 2740// the context is nil a panic will occur. In the future the SDK may create 2741// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2742// for more information on using Contexts. 2743func (c *ELB) SetLoadBalancerPoliciesOfListenerWithContext(ctx aws.Context, input *SetLoadBalancerPoliciesOfListenerInput, opts ...request.Option) (*SetLoadBalancerPoliciesOfListenerOutput, error) { 2744 req, out := c.SetLoadBalancerPoliciesOfListenerRequest(input) 2745 req.SetContext(ctx) 2746 req.ApplyOptions(opts...) 2747 return out, req.Send() 2748} 2749 2750// Information about the AccessLog attribute. 2751type AccessLog struct { 2752 _ struct{} `type:"structure"` 2753 2754 // The interval for publishing the access logs. You can specify an interval 2755 // of either 5 minutes or 60 minutes. 2756 // 2757 // Default: 60 minutes 2758 EmitInterval *int64 `type:"integer"` 2759 2760 // Specifies whether access logs are enabled for the load balancer. 2761 // 2762 // Enabled is a required field 2763 Enabled *bool `type:"boolean" required:"true"` 2764 2765 // The name of the Amazon S3 bucket where the access logs are stored. 2766 S3BucketName *string `type:"string"` 2767 2768 // The logical hierarchy you created for your Amazon S3 bucket, for example 2769 // my-bucket-prefix/prod. If the prefix is not provided, the log is placed at 2770 // the root level of the bucket. 2771 S3BucketPrefix *string `type:"string"` 2772} 2773 2774// String returns the string representation 2775func (s AccessLog) String() string { 2776 return awsutil.Prettify(s) 2777} 2778 2779// GoString returns the string representation 2780func (s AccessLog) GoString() string { 2781 return s.String() 2782} 2783 2784// Validate inspects the fields of the type to determine if they are valid. 2785func (s *AccessLog) Validate() error { 2786 invalidParams := request.ErrInvalidParams{Context: "AccessLog"} 2787 if s.Enabled == nil { 2788 invalidParams.Add(request.NewErrParamRequired("Enabled")) 2789 } 2790 2791 if invalidParams.Len() > 0 { 2792 return invalidParams 2793 } 2794 return nil 2795} 2796 2797// SetEmitInterval sets the EmitInterval field's value. 2798func (s *AccessLog) SetEmitInterval(v int64) *AccessLog { 2799 s.EmitInterval = &v 2800 return s 2801} 2802 2803// SetEnabled sets the Enabled field's value. 2804func (s *AccessLog) SetEnabled(v bool) *AccessLog { 2805 s.Enabled = &v 2806 return s 2807} 2808 2809// SetS3BucketName sets the S3BucketName field's value. 2810func (s *AccessLog) SetS3BucketName(v string) *AccessLog { 2811 s.S3BucketName = &v 2812 return s 2813} 2814 2815// SetS3BucketPrefix sets the S3BucketPrefix field's value. 2816func (s *AccessLog) SetS3BucketPrefix(v string) *AccessLog { 2817 s.S3BucketPrefix = &v 2818 return s 2819} 2820 2821// Contains the parameters for AddTags. 2822type AddTagsInput struct { 2823 _ struct{} `type:"structure"` 2824 2825 // The name of the load balancer. You can specify one load balancer only. 2826 // 2827 // LoadBalancerNames is a required field 2828 LoadBalancerNames []*string `type:"list" required:"true"` 2829 2830 // The tags. 2831 // 2832 // Tags is a required field 2833 Tags []*Tag `min:"1" type:"list" required:"true"` 2834} 2835 2836// String returns the string representation 2837func (s AddTagsInput) String() string { 2838 return awsutil.Prettify(s) 2839} 2840 2841// GoString returns the string representation 2842func (s AddTagsInput) GoString() string { 2843 return s.String() 2844} 2845 2846// Validate inspects the fields of the type to determine if they are valid. 2847func (s *AddTagsInput) Validate() error { 2848 invalidParams := request.ErrInvalidParams{Context: "AddTagsInput"} 2849 if s.LoadBalancerNames == nil { 2850 invalidParams.Add(request.NewErrParamRequired("LoadBalancerNames")) 2851 } 2852 if s.Tags == nil { 2853 invalidParams.Add(request.NewErrParamRequired("Tags")) 2854 } 2855 if s.Tags != nil && len(s.Tags) < 1 { 2856 invalidParams.Add(request.NewErrParamMinLen("Tags", 1)) 2857 } 2858 if s.Tags != nil { 2859 for i, v := range s.Tags { 2860 if v == nil { 2861 continue 2862 } 2863 if err := v.Validate(); err != nil { 2864 invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams)) 2865 } 2866 } 2867 } 2868 2869 if invalidParams.Len() > 0 { 2870 return invalidParams 2871 } 2872 return nil 2873} 2874 2875// SetLoadBalancerNames sets the LoadBalancerNames field's value. 2876func (s *AddTagsInput) SetLoadBalancerNames(v []*string) *AddTagsInput { 2877 s.LoadBalancerNames = v 2878 return s 2879} 2880 2881// SetTags sets the Tags field's value. 2882func (s *AddTagsInput) SetTags(v []*Tag) *AddTagsInput { 2883 s.Tags = v 2884 return s 2885} 2886 2887// Contains the output of AddTags. 2888type AddTagsOutput struct { 2889 _ struct{} `type:"structure"` 2890} 2891 2892// String returns the string representation 2893func (s AddTagsOutput) String() string { 2894 return awsutil.Prettify(s) 2895} 2896 2897// GoString returns the string representation 2898func (s AddTagsOutput) GoString() string { 2899 return s.String() 2900} 2901 2902// This data type is reserved. 2903type AdditionalAttribute struct { 2904 _ struct{} `type:"structure"` 2905 2906 // This parameter is reserved. 2907 Key *string `type:"string"` 2908 2909 // This parameter is reserved. 2910 Value *string `type:"string"` 2911} 2912 2913// String returns the string representation 2914func (s AdditionalAttribute) String() string { 2915 return awsutil.Prettify(s) 2916} 2917 2918// GoString returns the string representation 2919func (s AdditionalAttribute) GoString() string { 2920 return s.String() 2921} 2922 2923// SetKey sets the Key field's value. 2924func (s *AdditionalAttribute) SetKey(v string) *AdditionalAttribute { 2925 s.Key = &v 2926 return s 2927} 2928 2929// SetValue sets the Value field's value. 2930func (s *AdditionalAttribute) SetValue(v string) *AdditionalAttribute { 2931 s.Value = &v 2932 return s 2933} 2934 2935// Information about a policy for application-controlled session stickiness. 2936type AppCookieStickinessPolicy struct { 2937 _ struct{} `type:"structure"` 2938 2939 // The name of the application cookie used for stickiness. 2940 CookieName *string `type:"string"` 2941 2942 // The mnemonic name for the policy being created. The name must be unique within 2943 // a set of policies for this load balancer. 2944 PolicyName *string `type:"string"` 2945} 2946 2947// String returns the string representation 2948func (s AppCookieStickinessPolicy) String() string { 2949 return awsutil.Prettify(s) 2950} 2951 2952// GoString returns the string representation 2953func (s AppCookieStickinessPolicy) GoString() string { 2954 return s.String() 2955} 2956 2957// SetCookieName sets the CookieName field's value. 2958func (s *AppCookieStickinessPolicy) SetCookieName(v string) *AppCookieStickinessPolicy { 2959 s.CookieName = &v 2960 return s 2961} 2962 2963// SetPolicyName sets the PolicyName field's value. 2964func (s *AppCookieStickinessPolicy) SetPolicyName(v string) *AppCookieStickinessPolicy { 2965 s.PolicyName = &v 2966 return s 2967} 2968 2969// Contains the parameters for ApplySecurityGroupsToLoadBalancer. 2970type ApplySecurityGroupsToLoadBalancerInput struct { 2971 _ struct{} `type:"structure"` 2972 2973 // The name of the load balancer. 2974 // 2975 // LoadBalancerName is a required field 2976 LoadBalancerName *string `type:"string" required:"true"` 2977 2978 // The IDs of the security groups to associate with the load balancer. Note 2979 // that you cannot specify the name of the security group. 2980 // 2981 // SecurityGroups is a required field 2982 SecurityGroups []*string `type:"list" required:"true"` 2983} 2984 2985// String returns the string representation 2986func (s ApplySecurityGroupsToLoadBalancerInput) String() string { 2987 return awsutil.Prettify(s) 2988} 2989 2990// GoString returns the string representation 2991func (s ApplySecurityGroupsToLoadBalancerInput) GoString() string { 2992 return s.String() 2993} 2994 2995// Validate inspects the fields of the type to determine if they are valid. 2996func (s *ApplySecurityGroupsToLoadBalancerInput) Validate() error { 2997 invalidParams := request.ErrInvalidParams{Context: "ApplySecurityGroupsToLoadBalancerInput"} 2998 if s.LoadBalancerName == nil { 2999 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 3000 } 3001 if s.SecurityGroups == nil { 3002 invalidParams.Add(request.NewErrParamRequired("SecurityGroups")) 3003 } 3004 3005 if invalidParams.Len() > 0 { 3006 return invalidParams 3007 } 3008 return nil 3009} 3010 3011// SetLoadBalancerName sets the LoadBalancerName field's value. 3012func (s *ApplySecurityGroupsToLoadBalancerInput) SetLoadBalancerName(v string) *ApplySecurityGroupsToLoadBalancerInput { 3013 s.LoadBalancerName = &v 3014 return s 3015} 3016 3017// SetSecurityGroups sets the SecurityGroups field's value. 3018func (s *ApplySecurityGroupsToLoadBalancerInput) SetSecurityGroups(v []*string) *ApplySecurityGroupsToLoadBalancerInput { 3019 s.SecurityGroups = v 3020 return s 3021} 3022 3023// Contains the output of ApplySecurityGroupsToLoadBalancer. 3024type ApplySecurityGroupsToLoadBalancerOutput struct { 3025 _ struct{} `type:"structure"` 3026 3027 // The IDs of the security groups associated with the load balancer. 3028 SecurityGroups []*string `type:"list"` 3029} 3030 3031// String returns the string representation 3032func (s ApplySecurityGroupsToLoadBalancerOutput) String() string { 3033 return awsutil.Prettify(s) 3034} 3035 3036// GoString returns the string representation 3037func (s ApplySecurityGroupsToLoadBalancerOutput) GoString() string { 3038 return s.String() 3039} 3040 3041// SetSecurityGroups sets the SecurityGroups field's value. 3042func (s *ApplySecurityGroupsToLoadBalancerOutput) SetSecurityGroups(v []*string) *ApplySecurityGroupsToLoadBalancerOutput { 3043 s.SecurityGroups = v 3044 return s 3045} 3046 3047// Contains the parameters for AttachLoaBalancerToSubnets. 3048type AttachLoadBalancerToSubnetsInput struct { 3049 _ struct{} `type:"structure"` 3050 3051 // The name of the load balancer. 3052 // 3053 // LoadBalancerName is a required field 3054 LoadBalancerName *string `type:"string" required:"true"` 3055 3056 // The IDs of the subnets to add. You can add only one subnet per Availability 3057 // Zone. 3058 // 3059 // Subnets is a required field 3060 Subnets []*string `type:"list" required:"true"` 3061} 3062 3063// String returns the string representation 3064func (s AttachLoadBalancerToSubnetsInput) String() string { 3065 return awsutil.Prettify(s) 3066} 3067 3068// GoString returns the string representation 3069func (s AttachLoadBalancerToSubnetsInput) GoString() string { 3070 return s.String() 3071} 3072 3073// Validate inspects the fields of the type to determine if they are valid. 3074func (s *AttachLoadBalancerToSubnetsInput) Validate() error { 3075 invalidParams := request.ErrInvalidParams{Context: "AttachLoadBalancerToSubnetsInput"} 3076 if s.LoadBalancerName == nil { 3077 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 3078 } 3079 if s.Subnets == nil { 3080 invalidParams.Add(request.NewErrParamRequired("Subnets")) 3081 } 3082 3083 if invalidParams.Len() > 0 { 3084 return invalidParams 3085 } 3086 return nil 3087} 3088 3089// SetLoadBalancerName sets the LoadBalancerName field's value. 3090func (s *AttachLoadBalancerToSubnetsInput) SetLoadBalancerName(v string) *AttachLoadBalancerToSubnetsInput { 3091 s.LoadBalancerName = &v 3092 return s 3093} 3094 3095// SetSubnets sets the Subnets field's value. 3096func (s *AttachLoadBalancerToSubnetsInput) SetSubnets(v []*string) *AttachLoadBalancerToSubnetsInput { 3097 s.Subnets = v 3098 return s 3099} 3100 3101// Contains the output of AttachLoadBalancerToSubnets. 3102type AttachLoadBalancerToSubnetsOutput struct { 3103 _ struct{} `type:"structure"` 3104 3105 // The IDs of the subnets attached to the load balancer. 3106 Subnets []*string `type:"list"` 3107} 3108 3109// String returns the string representation 3110func (s AttachLoadBalancerToSubnetsOutput) String() string { 3111 return awsutil.Prettify(s) 3112} 3113 3114// GoString returns the string representation 3115func (s AttachLoadBalancerToSubnetsOutput) GoString() string { 3116 return s.String() 3117} 3118 3119// SetSubnets sets the Subnets field's value. 3120func (s *AttachLoadBalancerToSubnetsOutput) SetSubnets(v []*string) *AttachLoadBalancerToSubnetsOutput { 3121 s.Subnets = v 3122 return s 3123} 3124 3125// Information about the configuration of an EC2 instance. 3126type BackendServerDescription struct { 3127 _ struct{} `type:"structure"` 3128 3129 // The port on which the EC2 instance is listening. 3130 InstancePort *int64 `min:"1" type:"integer"` 3131 3132 // The names of the policies enabled for the EC2 instance. 3133 PolicyNames []*string `type:"list"` 3134} 3135 3136// String returns the string representation 3137func (s BackendServerDescription) String() string { 3138 return awsutil.Prettify(s) 3139} 3140 3141// GoString returns the string representation 3142func (s BackendServerDescription) GoString() string { 3143 return s.String() 3144} 3145 3146// SetInstancePort sets the InstancePort field's value. 3147func (s *BackendServerDescription) SetInstancePort(v int64) *BackendServerDescription { 3148 s.InstancePort = &v 3149 return s 3150} 3151 3152// SetPolicyNames sets the PolicyNames field's value. 3153func (s *BackendServerDescription) SetPolicyNames(v []*string) *BackendServerDescription { 3154 s.PolicyNames = v 3155 return s 3156} 3157 3158// Contains the parameters for ConfigureHealthCheck. 3159type ConfigureHealthCheckInput struct { 3160 _ struct{} `type:"structure"` 3161 3162 // The configuration information. 3163 // 3164 // HealthCheck is a required field 3165 HealthCheck *HealthCheck `type:"structure" required:"true"` 3166 3167 // The name of the load balancer. 3168 // 3169 // LoadBalancerName is a required field 3170 LoadBalancerName *string `type:"string" required:"true"` 3171} 3172 3173// String returns the string representation 3174func (s ConfigureHealthCheckInput) String() string { 3175 return awsutil.Prettify(s) 3176} 3177 3178// GoString returns the string representation 3179func (s ConfigureHealthCheckInput) GoString() string { 3180 return s.String() 3181} 3182 3183// Validate inspects the fields of the type to determine if they are valid. 3184func (s *ConfigureHealthCheckInput) Validate() error { 3185 invalidParams := request.ErrInvalidParams{Context: "ConfigureHealthCheckInput"} 3186 if s.HealthCheck == nil { 3187 invalidParams.Add(request.NewErrParamRequired("HealthCheck")) 3188 } 3189 if s.LoadBalancerName == nil { 3190 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 3191 } 3192 if s.HealthCheck != nil { 3193 if err := s.HealthCheck.Validate(); err != nil { 3194 invalidParams.AddNested("HealthCheck", err.(request.ErrInvalidParams)) 3195 } 3196 } 3197 3198 if invalidParams.Len() > 0 { 3199 return invalidParams 3200 } 3201 return nil 3202} 3203 3204// SetHealthCheck sets the HealthCheck field's value. 3205func (s *ConfigureHealthCheckInput) SetHealthCheck(v *HealthCheck) *ConfigureHealthCheckInput { 3206 s.HealthCheck = v 3207 return s 3208} 3209 3210// SetLoadBalancerName sets the LoadBalancerName field's value. 3211func (s *ConfigureHealthCheckInput) SetLoadBalancerName(v string) *ConfigureHealthCheckInput { 3212 s.LoadBalancerName = &v 3213 return s 3214} 3215 3216// Contains the output of ConfigureHealthCheck. 3217type ConfigureHealthCheckOutput struct { 3218 _ struct{} `type:"structure"` 3219 3220 // The updated health check. 3221 HealthCheck *HealthCheck `type:"structure"` 3222} 3223 3224// String returns the string representation 3225func (s ConfigureHealthCheckOutput) String() string { 3226 return awsutil.Prettify(s) 3227} 3228 3229// GoString returns the string representation 3230func (s ConfigureHealthCheckOutput) GoString() string { 3231 return s.String() 3232} 3233 3234// SetHealthCheck sets the HealthCheck field's value. 3235func (s *ConfigureHealthCheckOutput) SetHealthCheck(v *HealthCheck) *ConfigureHealthCheckOutput { 3236 s.HealthCheck = v 3237 return s 3238} 3239 3240// Information about the ConnectionDraining attribute. 3241type ConnectionDraining struct { 3242 _ struct{} `type:"structure"` 3243 3244 // Specifies whether connection draining is enabled for the load balancer. 3245 // 3246 // Enabled is a required field 3247 Enabled *bool `type:"boolean" required:"true"` 3248 3249 // The maximum time, in seconds, to keep the existing connections open before 3250 // deregistering the instances. 3251 Timeout *int64 `type:"integer"` 3252} 3253 3254// String returns the string representation 3255func (s ConnectionDraining) String() string { 3256 return awsutil.Prettify(s) 3257} 3258 3259// GoString returns the string representation 3260func (s ConnectionDraining) GoString() string { 3261 return s.String() 3262} 3263 3264// Validate inspects the fields of the type to determine if they are valid. 3265func (s *ConnectionDraining) Validate() error { 3266 invalidParams := request.ErrInvalidParams{Context: "ConnectionDraining"} 3267 if s.Enabled == nil { 3268 invalidParams.Add(request.NewErrParamRequired("Enabled")) 3269 } 3270 3271 if invalidParams.Len() > 0 { 3272 return invalidParams 3273 } 3274 return nil 3275} 3276 3277// SetEnabled sets the Enabled field's value. 3278func (s *ConnectionDraining) SetEnabled(v bool) *ConnectionDraining { 3279 s.Enabled = &v 3280 return s 3281} 3282 3283// SetTimeout sets the Timeout field's value. 3284func (s *ConnectionDraining) SetTimeout(v int64) *ConnectionDraining { 3285 s.Timeout = &v 3286 return s 3287} 3288 3289// Information about the ConnectionSettings attribute. 3290type ConnectionSettings struct { 3291 _ struct{} `type:"structure"` 3292 3293 // The time, in seconds, that the connection is allowed to be idle (no data 3294 // has been sent over the connection) before it is closed by the load balancer. 3295 // 3296 // IdleTimeout is a required field 3297 IdleTimeout *int64 `min:"1" type:"integer" required:"true"` 3298} 3299 3300// String returns the string representation 3301func (s ConnectionSettings) String() string { 3302 return awsutil.Prettify(s) 3303} 3304 3305// GoString returns the string representation 3306func (s ConnectionSettings) GoString() string { 3307 return s.String() 3308} 3309 3310// Validate inspects the fields of the type to determine if they are valid. 3311func (s *ConnectionSettings) Validate() error { 3312 invalidParams := request.ErrInvalidParams{Context: "ConnectionSettings"} 3313 if s.IdleTimeout == nil { 3314 invalidParams.Add(request.NewErrParamRequired("IdleTimeout")) 3315 } 3316 if s.IdleTimeout != nil && *s.IdleTimeout < 1 { 3317 invalidParams.Add(request.NewErrParamMinValue("IdleTimeout", 1)) 3318 } 3319 3320 if invalidParams.Len() > 0 { 3321 return invalidParams 3322 } 3323 return nil 3324} 3325 3326// SetIdleTimeout sets the IdleTimeout field's value. 3327func (s *ConnectionSettings) SetIdleTimeout(v int64) *ConnectionSettings { 3328 s.IdleTimeout = &v 3329 return s 3330} 3331 3332// Contains the parameters for CreateAppCookieStickinessPolicy. 3333type CreateAppCookieStickinessPolicyInput struct { 3334 _ struct{} `type:"structure"` 3335 3336 // The name of the application cookie used for stickiness. 3337 // 3338 // CookieName is a required field 3339 CookieName *string `type:"string" required:"true"` 3340 3341 // The name of the load balancer. 3342 // 3343 // LoadBalancerName is a required field 3344 LoadBalancerName *string `type:"string" required:"true"` 3345 3346 // The name of the policy being created. Policy names must consist of alphanumeric 3347 // characters and dashes (-). This name must be unique within the set of policies 3348 // for this load balancer. 3349 // 3350 // PolicyName is a required field 3351 PolicyName *string `type:"string" required:"true"` 3352} 3353 3354// String returns the string representation 3355func (s CreateAppCookieStickinessPolicyInput) String() string { 3356 return awsutil.Prettify(s) 3357} 3358 3359// GoString returns the string representation 3360func (s CreateAppCookieStickinessPolicyInput) GoString() string { 3361 return s.String() 3362} 3363 3364// Validate inspects the fields of the type to determine if they are valid. 3365func (s *CreateAppCookieStickinessPolicyInput) Validate() error { 3366 invalidParams := request.ErrInvalidParams{Context: "CreateAppCookieStickinessPolicyInput"} 3367 if s.CookieName == nil { 3368 invalidParams.Add(request.NewErrParamRequired("CookieName")) 3369 } 3370 if s.LoadBalancerName == nil { 3371 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 3372 } 3373 if s.PolicyName == nil { 3374 invalidParams.Add(request.NewErrParamRequired("PolicyName")) 3375 } 3376 3377 if invalidParams.Len() > 0 { 3378 return invalidParams 3379 } 3380 return nil 3381} 3382 3383// SetCookieName sets the CookieName field's value. 3384func (s *CreateAppCookieStickinessPolicyInput) SetCookieName(v string) *CreateAppCookieStickinessPolicyInput { 3385 s.CookieName = &v 3386 return s 3387} 3388 3389// SetLoadBalancerName sets the LoadBalancerName field's value. 3390func (s *CreateAppCookieStickinessPolicyInput) SetLoadBalancerName(v string) *CreateAppCookieStickinessPolicyInput { 3391 s.LoadBalancerName = &v 3392 return s 3393} 3394 3395// SetPolicyName sets the PolicyName field's value. 3396func (s *CreateAppCookieStickinessPolicyInput) SetPolicyName(v string) *CreateAppCookieStickinessPolicyInput { 3397 s.PolicyName = &v 3398 return s 3399} 3400 3401// Contains the output for CreateAppCookieStickinessPolicy. 3402type CreateAppCookieStickinessPolicyOutput struct { 3403 _ struct{} `type:"structure"` 3404} 3405 3406// String returns the string representation 3407func (s CreateAppCookieStickinessPolicyOutput) String() string { 3408 return awsutil.Prettify(s) 3409} 3410 3411// GoString returns the string representation 3412func (s CreateAppCookieStickinessPolicyOutput) GoString() string { 3413 return s.String() 3414} 3415 3416// Contains the parameters for CreateLBCookieStickinessPolicy. 3417type CreateLBCookieStickinessPolicyInput struct { 3418 _ struct{} `type:"structure"` 3419 3420 // The time period, in seconds, after which the cookie should be considered 3421 // stale. If you do not specify this parameter, the default value is 0, which 3422 // indicates that the sticky session should last for the duration of the browser 3423 // session. 3424 CookieExpirationPeriod *int64 `type:"long"` 3425 3426 // The name of the load balancer. 3427 // 3428 // LoadBalancerName is a required field 3429 LoadBalancerName *string `type:"string" required:"true"` 3430 3431 // The name of the policy being created. Policy names must consist of alphanumeric 3432 // characters and dashes (-). This name must be unique within the set of policies 3433 // for this load balancer. 3434 // 3435 // PolicyName is a required field 3436 PolicyName *string `type:"string" required:"true"` 3437} 3438 3439// String returns the string representation 3440func (s CreateLBCookieStickinessPolicyInput) String() string { 3441 return awsutil.Prettify(s) 3442} 3443 3444// GoString returns the string representation 3445func (s CreateLBCookieStickinessPolicyInput) GoString() string { 3446 return s.String() 3447} 3448 3449// Validate inspects the fields of the type to determine if they are valid. 3450func (s *CreateLBCookieStickinessPolicyInput) Validate() error { 3451 invalidParams := request.ErrInvalidParams{Context: "CreateLBCookieStickinessPolicyInput"} 3452 if s.LoadBalancerName == nil { 3453 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 3454 } 3455 if s.PolicyName == nil { 3456 invalidParams.Add(request.NewErrParamRequired("PolicyName")) 3457 } 3458 3459 if invalidParams.Len() > 0 { 3460 return invalidParams 3461 } 3462 return nil 3463} 3464 3465// SetCookieExpirationPeriod sets the CookieExpirationPeriod field's value. 3466func (s *CreateLBCookieStickinessPolicyInput) SetCookieExpirationPeriod(v int64) *CreateLBCookieStickinessPolicyInput { 3467 s.CookieExpirationPeriod = &v 3468 return s 3469} 3470 3471// SetLoadBalancerName sets the LoadBalancerName field's value. 3472func (s *CreateLBCookieStickinessPolicyInput) SetLoadBalancerName(v string) *CreateLBCookieStickinessPolicyInput { 3473 s.LoadBalancerName = &v 3474 return s 3475} 3476 3477// SetPolicyName sets the PolicyName field's value. 3478func (s *CreateLBCookieStickinessPolicyInput) SetPolicyName(v string) *CreateLBCookieStickinessPolicyInput { 3479 s.PolicyName = &v 3480 return s 3481} 3482 3483// Contains the output for CreateLBCookieStickinessPolicy. 3484type CreateLBCookieStickinessPolicyOutput struct { 3485 _ struct{} `type:"structure"` 3486} 3487 3488// String returns the string representation 3489func (s CreateLBCookieStickinessPolicyOutput) String() string { 3490 return awsutil.Prettify(s) 3491} 3492 3493// GoString returns the string representation 3494func (s CreateLBCookieStickinessPolicyOutput) GoString() string { 3495 return s.String() 3496} 3497 3498// Contains the parameters for CreateLoadBalancer. 3499type CreateLoadBalancerInput struct { 3500 _ struct{} `type:"structure"` 3501 3502 // One or more Availability Zones from the same region as the load balancer. 3503 // 3504 // You must specify at least one Availability Zone. 3505 // 3506 // You can add more Availability Zones after you create the load balancer using 3507 // EnableAvailabilityZonesForLoadBalancer. 3508 AvailabilityZones []*string `type:"list"` 3509 3510 // The listeners. 3511 // 3512 // For more information, see Listeners for Your Classic Load Balancer (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-listener-config.html) 3513 // in the Classic Load Balancers Guide. 3514 // 3515 // Listeners is a required field 3516 Listeners []*Listener `type:"list" required:"true"` 3517 3518 // The name of the load balancer. 3519 // 3520 // This name must be unique within your set of load balancers for the region, 3521 // must have a maximum of 32 characters, must contain only alphanumeric characters 3522 // or hyphens, and cannot begin or end with a hyphen. 3523 // 3524 // LoadBalancerName is a required field 3525 LoadBalancerName *string `type:"string" required:"true"` 3526 3527 // The type of a load balancer. Valid only for load balancers in a VPC. 3528 // 3529 // By default, Elastic Load Balancing creates an Internet-facing load balancer 3530 // with a DNS name that resolves to public IP addresses. For more information 3531 // about Internet-facing and Internal load balancers, see Load Balancer Scheme 3532 // (http://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/how-elastic-load-balancing-works.html#load-balancer-scheme) 3533 // in the Elastic Load Balancing User Guide. 3534 // 3535 // Specify internal to create a load balancer with a DNS name that resolves 3536 // to private IP addresses. 3537 Scheme *string `type:"string"` 3538 3539 // The IDs of the security groups to assign to the load balancer. 3540 SecurityGroups []*string `type:"list"` 3541 3542 // The IDs of the subnets in your VPC to attach to the load balancer. Specify 3543 // one subnet per Availability Zone specified in AvailabilityZones. 3544 Subnets []*string `type:"list"` 3545 3546 // A list of tags to assign to the load balancer. 3547 // 3548 // For more information about tagging your load balancer, see Tag Your Classic 3549 // Load Balancer (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/add-remove-tags.html) 3550 // in the Classic Load Balancers Guide. 3551 Tags []*Tag `min:"1" type:"list"` 3552} 3553 3554// String returns the string representation 3555func (s CreateLoadBalancerInput) String() string { 3556 return awsutil.Prettify(s) 3557} 3558 3559// GoString returns the string representation 3560func (s CreateLoadBalancerInput) GoString() string { 3561 return s.String() 3562} 3563 3564// Validate inspects the fields of the type to determine if they are valid. 3565func (s *CreateLoadBalancerInput) Validate() error { 3566 invalidParams := request.ErrInvalidParams{Context: "CreateLoadBalancerInput"} 3567 if s.Listeners == nil { 3568 invalidParams.Add(request.NewErrParamRequired("Listeners")) 3569 } 3570 if s.LoadBalancerName == nil { 3571 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 3572 } 3573 if s.Tags != nil && len(s.Tags) < 1 { 3574 invalidParams.Add(request.NewErrParamMinLen("Tags", 1)) 3575 } 3576 if s.Listeners != nil { 3577 for i, v := range s.Listeners { 3578 if v == nil { 3579 continue 3580 } 3581 if err := v.Validate(); err != nil { 3582 invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Listeners", i), err.(request.ErrInvalidParams)) 3583 } 3584 } 3585 } 3586 if s.Tags != nil { 3587 for i, v := range s.Tags { 3588 if v == nil { 3589 continue 3590 } 3591 if err := v.Validate(); err != nil { 3592 invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams)) 3593 } 3594 } 3595 } 3596 3597 if invalidParams.Len() > 0 { 3598 return invalidParams 3599 } 3600 return nil 3601} 3602 3603// SetAvailabilityZones sets the AvailabilityZones field's value. 3604func (s *CreateLoadBalancerInput) SetAvailabilityZones(v []*string) *CreateLoadBalancerInput { 3605 s.AvailabilityZones = v 3606 return s 3607} 3608 3609// SetListeners sets the Listeners field's value. 3610func (s *CreateLoadBalancerInput) SetListeners(v []*Listener) *CreateLoadBalancerInput { 3611 s.Listeners = v 3612 return s 3613} 3614 3615// SetLoadBalancerName sets the LoadBalancerName field's value. 3616func (s *CreateLoadBalancerInput) SetLoadBalancerName(v string) *CreateLoadBalancerInput { 3617 s.LoadBalancerName = &v 3618 return s 3619} 3620 3621// SetScheme sets the Scheme field's value. 3622func (s *CreateLoadBalancerInput) SetScheme(v string) *CreateLoadBalancerInput { 3623 s.Scheme = &v 3624 return s 3625} 3626 3627// SetSecurityGroups sets the SecurityGroups field's value. 3628func (s *CreateLoadBalancerInput) SetSecurityGroups(v []*string) *CreateLoadBalancerInput { 3629 s.SecurityGroups = v 3630 return s 3631} 3632 3633// SetSubnets sets the Subnets field's value. 3634func (s *CreateLoadBalancerInput) SetSubnets(v []*string) *CreateLoadBalancerInput { 3635 s.Subnets = v 3636 return s 3637} 3638 3639// SetTags sets the Tags field's value. 3640func (s *CreateLoadBalancerInput) SetTags(v []*Tag) *CreateLoadBalancerInput { 3641 s.Tags = v 3642 return s 3643} 3644 3645// Contains the parameters for CreateLoadBalancerListeners. 3646type CreateLoadBalancerListenersInput struct { 3647 _ struct{} `type:"structure"` 3648 3649 // The listeners. 3650 // 3651 // Listeners is a required field 3652 Listeners []*Listener `type:"list" required:"true"` 3653 3654 // The name of the load balancer. 3655 // 3656 // LoadBalancerName is a required field 3657 LoadBalancerName *string `type:"string" required:"true"` 3658} 3659 3660// String returns the string representation 3661func (s CreateLoadBalancerListenersInput) String() string { 3662 return awsutil.Prettify(s) 3663} 3664 3665// GoString returns the string representation 3666func (s CreateLoadBalancerListenersInput) GoString() string { 3667 return s.String() 3668} 3669 3670// Validate inspects the fields of the type to determine if they are valid. 3671func (s *CreateLoadBalancerListenersInput) Validate() error { 3672 invalidParams := request.ErrInvalidParams{Context: "CreateLoadBalancerListenersInput"} 3673 if s.Listeners == nil { 3674 invalidParams.Add(request.NewErrParamRequired("Listeners")) 3675 } 3676 if s.LoadBalancerName == nil { 3677 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 3678 } 3679 if s.Listeners != nil { 3680 for i, v := range s.Listeners { 3681 if v == nil { 3682 continue 3683 } 3684 if err := v.Validate(); err != nil { 3685 invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Listeners", i), err.(request.ErrInvalidParams)) 3686 } 3687 } 3688 } 3689 3690 if invalidParams.Len() > 0 { 3691 return invalidParams 3692 } 3693 return nil 3694} 3695 3696// SetListeners sets the Listeners field's value. 3697func (s *CreateLoadBalancerListenersInput) SetListeners(v []*Listener) *CreateLoadBalancerListenersInput { 3698 s.Listeners = v 3699 return s 3700} 3701 3702// SetLoadBalancerName sets the LoadBalancerName field's value. 3703func (s *CreateLoadBalancerListenersInput) SetLoadBalancerName(v string) *CreateLoadBalancerListenersInput { 3704 s.LoadBalancerName = &v 3705 return s 3706} 3707 3708// Contains the parameters for CreateLoadBalancerListener. 3709type CreateLoadBalancerListenersOutput struct { 3710 _ struct{} `type:"structure"` 3711} 3712 3713// String returns the string representation 3714func (s CreateLoadBalancerListenersOutput) String() string { 3715 return awsutil.Prettify(s) 3716} 3717 3718// GoString returns the string representation 3719func (s CreateLoadBalancerListenersOutput) GoString() string { 3720 return s.String() 3721} 3722 3723// Contains the output for CreateLoadBalancer. 3724type CreateLoadBalancerOutput struct { 3725 _ struct{} `type:"structure"` 3726 3727 // The DNS name of the load balancer. 3728 DNSName *string `type:"string"` 3729} 3730 3731// String returns the string representation 3732func (s CreateLoadBalancerOutput) String() string { 3733 return awsutil.Prettify(s) 3734} 3735 3736// GoString returns the string representation 3737func (s CreateLoadBalancerOutput) GoString() string { 3738 return s.String() 3739} 3740 3741// SetDNSName sets the DNSName field's value. 3742func (s *CreateLoadBalancerOutput) SetDNSName(v string) *CreateLoadBalancerOutput { 3743 s.DNSName = &v 3744 return s 3745} 3746 3747// Contains the parameters for CreateLoadBalancerPolicy. 3748type CreateLoadBalancerPolicyInput struct { 3749 _ struct{} `type:"structure"` 3750 3751 // The name of the load balancer. 3752 // 3753 // LoadBalancerName is a required field 3754 LoadBalancerName *string `type:"string" required:"true"` 3755 3756 // The policy attributes. 3757 PolicyAttributes []*PolicyAttribute `type:"list"` 3758 3759 // The name of the load balancer policy to be created. This name must be unique 3760 // within the set of policies for this load balancer. 3761 // 3762 // PolicyName is a required field 3763 PolicyName *string `type:"string" required:"true"` 3764 3765 // The name of the base policy type. To get the list of policy types, use DescribeLoadBalancerPolicyTypes. 3766 // 3767 // PolicyTypeName is a required field 3768 PolicyTypeName *string `type:"string" required:"true"` 3769} 3770 3771// String returns the string representation 3772func (s CreateLoadBalancerPolicyInput) String() string { 3773 return awsutil.Prettify(s) 3774} 3775 3776// GoString returns the string representation 3777func (s CreateLoadBalancerPolicyInput) GoString() string { 3778 return s.String() 3779} 3780 3781// Validate inspects the fields of the type to determine if they are valid. 3782func (s *CreateLoadBalancerPolicyInput) Validate() error { 3783 invalidParams := request.ErrInvalidParams{Context: "CreateLoadBalancerPolicyInput"} 3784 if s.LoadBalancerName == nil { 3785 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 3786 } 3787 if s.PolicyName == nil { 3788 invalidParams.Add(request.NewErrParamRequired("PolicyName")) 3789 } 3790 if s.PolicyTypeName == nil { 3791 invalidParams.Add(request.NewErrParamRequired("PolicyTypeName")) 3792 } 3793 3794 if invalidParams.Len() > 0 { 3795 return invalidParams 3796 } 3797 return nil 3798} 3799 3800// SetLoadBalancerName sets the LoadBalancerName field's value. 3801func (s *CreateLoadBalancerPolicyInput) SetLoadBalancerName(v string) *CreateLoadBalancerPolicyInput { 3802 s.LoadBalancerName = &v 3803 return s 3804} 3805 3806// SetPolicyAttributes sets the PolicyAttributes field's value. 3807func (s *CreateLoadBalancerPolicyInput) SetPolicyAttributes(v []*PolicyAttribute) *CreateLoadBalancerPolicyInput { 3808 s.PolicyAttributes = v 3809 return s 3810} 3811 3812// SetPolicyName sets the PolicyName field's value. 3813func (s *CreateLoadBalancerPolicyInput) SetPolicyName(v string) *CreateLoadBalancerPolicyInput { 3814 s.PolicyName = &v 3815 return s 3816} 3817 3818// SetPolicyTypeName sets the PolicyTypeName field's value. 3819func (s *CreateLoadBalancerPolicyInput) SetPolicyTypeName(v string) *CreateLoadBalancerPolicyInput { 3820 s.PolicyTypeName = &v 3821 return s 3822} 3823 3824// Contains the output of CreateLoadBalancerPolicy. 3825type CreateLoadBalancerPolicyOutput struct { 3826 _ struct{} `type:"structure"` 3827} 3828 3829// String returns the string representation 3830func (s CreateLoadBalancerPolicyOutput) String() string { 3831 return awsutil.Prettify(s) 3832} 3833 3834// GoString returns the string representation 3835func (s CreateLoadBalancerPolicyOutput) GoString() string { 3836 return s.String() 3837} 3838 3839// Information about the CrossZoneLoadBalancing attribute. 3840type CrossZoneLoadBalancing struct { 3841 _ struct{} `type:"structure"` 3842 3843 // Specifies whether cross-zone load balancing is enabled for the load balancer. 3844 // 3845 // Enabled is a required field 3846 Enabled *bool `type:"boolean" required:"true"` 3847} 3848 3849// String returns the string representation 3850func (s CrossZoneLoadBalancing) String() string { 3851 return awsutil.Prettify(s) 3852} 3853 3854// GoString returns the string representation 3855func (s CrossZoneLoadBalancing) GoString() string { 3856 return s.String() 3857} 3858 3859// Validate inspects the fields of the type to determine if they are valid. 3860func (s *CrossZoneLoadBalancing) Validate() error { 3861 invalidParams := request.ErrInvalidParams{Context: "CrossZoneLoadBalancing"} 3862 if s.Enabled == nil { 3863 invalidParams.Add(request.NewErrParamRequired("Enabled")) 3864 } 3865 3866 if invalidParams.Len() > 0 { 3867 return invalidParams 3868 } 3869 return nil 3870} 3871 3872// SetEnabled sets the Enabled field's value. 3873func (s *CrossZoneLoadBalancing) SetEnabled(v bool) *CrossZoneLoadBalancing { 3874 s.Enabled = &v 3875 return s 3876} 3877 3878// Contains the parameters for DeleteLoadBalancer. 3879type DeleteLoadBalancerInput struct { 3880 _ struct{} `type:"structure"` 3881 3882 // The name of the load balancer. 3883 // 3884 // LoadBalancerName is a required field 3885 LoadBalancerName *string `type:"string" required:"true"` 3886} 3887 3888// String returns the string representation 3889func (s DeleteLoadBalancerInput) String() string { 3890 return awsutil.Prettify(s) 3891} 3892 3893// GoString returns the string representation 3894func (s DeleteLoadBalancerInput) GoString() string { 3895 return s.String() 3896} 3897 3898// Validate inspects the fields of the type to determine if they are valid. 3899func (s *DeleteLoadBalancerInput) Validate() error { 3900 invalidParams := request.ErrInvalidParams{Context: "DeleteLoadBalancerInput"} 3901 if s.LoadBalancerName == nil { 3902 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 3903 } 3904 3905 if invalidParams.Len() > 0 { 3906 return invalidParams 3907 } 3908 return nil 3909} 3910 3911// SetLoadBalancerName sets the LoadBalancerName field's value. 3912func (s *DeleteLoadBalancerInput) SetLoadBalancerName(v string) *DeleteLoadBalancerInput { 3913 s.LoadBalancerName = &v 3914 return s 3915} 3916 3917// Contains the parameters for DeleteLoadBalancerListeners. 3918type DeleteLoadBalancerListenersInput struct { 3919 _ struct{} `type:"structure"` 3920 3921 // The name of the load balancer. 3922 // 3923 // LoadBalancerName is a required field 3924 LoadBalancerName *string `type:"string" required:"true"` 3925 3926 // The client port numbers of the listeners. 3927 // 3928 // LoadBalancerPorts is a required field 3929 LoadBalancerPorts []*int64 `type:"list" required:"true"` 3930} 3931 3932// String returns the string representation 3933func (s DeleteLoadBalancerListenersInput) String() string { 3934 return awsutil.Prettify(s) 3935} 3936 3937// GoString returns the string representation 3938func (s DeleteLoadBalancerListenersInput) GoString() string { 3939 return s.String() 3940} 3941 3942// Validate inspects the fields of the type to determine if they are valid. 3943func (s *DeleteLoadBalancerListenersInput) Validate() error { 3944 invalidParams := request.ErrInvalidParams{Context: "DeleteLoadBalancerListenersInput"} 3945 if s.LoadBalancerName == nil { 3946 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 3947 } 3948 if s.LoadBalancerPorts == nil { 3949 invalidParams.Add(request.NewErrParamRequired("LoadBalancerPorts")) 3950 } 3951 3952 if invalidParams.Len() > 0 { 3953 return invalidParams 3954 } 3955 return nil 3956} 3957 3958// SetLoadBalancerName sets the LoadBalancerName field's value. 3959func (s *DeleteLoadBalancerListenersInput) SetLoadBalancerName(v string) *DeleteLoadBalancerListenersInput { 3960 s.LoadBalancerName = &v 3961 return s 3962} 3963 3964// SetLoadBalancerPorts sets the LoadBalancerPorts field's value. 3965func (s *DeleteLoadBalancerListenersInput) SetLoadBalancerPorts(v []*int64) *DeleteLoadBalancerListenersInput { 3966 s.LoadBalancerPorts = v 3967 return s 3968} 3969 3970// Contains the output of DeleteLoadBalancerListeners. 3971type DeleteLoadBalancerListenersOutput struct { 3972 _ struct{} `type:"structure"` 3973} 3974 3975// String returns the string representation 3976func (s DeleteLoadBalancerListenersOutput) String() string { 3977 return awsutil.Prettify(s) 3978} 3979 3980// GoString returns the string representation 3981func (s DeleteLoadBalancerListenersOutput) GoString() string { 3982 return s.String() 3983} 3984 3985// Contains the output of DeleteLoadBalancer. 3986type DeleteLoadBalancerOutput struct { 3987 _ struct{} `type:"structure"` 3988} 3989 3990// String returns the string representation 3991func (s DeleteLoadBalancerOutput) String() string { 3992 return awsutil.Prettify(s) 3993} 3994 3995// GoString returns the string representation 3996func (s DeleteLoadBalancerOutput) GoString() string { 3997 return s.String() 3998} 3999 4000// Contains the parameters for DeleteLoadBalancerPolicy. 4001type DeleteLoadBalancerPolicyInput struct { 4002 _ struct{} `type:"structure"` 4003 4004 // The name of the load balancer. 4005 // 4006 // LoadBalancerName is a required field 4007 LoadBalancerName *string `type:"string" required:"true"` 4008 4009 // The name of the policy. 4010 // 4011 // PolicyName is a required field 4012 PolicyName *string `type:"string" required:"true"` 4013} 4014 4015// String returns the string representation 4016func (s DeleteLoadBalancerPolicyInput) String() string { 4017 return awsutil.Prettify(s) 4018} 4019 4020// GoString returns the string representation 4021func (s DeleteLoadBalancerPolicyInput) GoString() string { 4022 return s.String() 4023} 4024 4025// Validate inspects the fields of the type to determine if they are valid. 4026func (s *DeleteLoadBalancerPolicyInput) Validate() error { 4027 invalidParams := request.ErrInvalidParams{Context: "DeleteLoadBalancerPolicyInput"} 4028 if s.LoadBalancerName == nil { 4029 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 4030 } 4031 if s.PolicyName == nil { 4032 invalidParams.Add(request.NewErrParamRequired("PolicyName")) 4033 } 4034 4035 if invalidParams.Len() > 0 { 4036 return invalidParams 4037 } 4038 return nil 4039} 4040 4041// SetLoadBalancerName sets the LoadBalancerName field's value. 4042func (s *DeleteLoadBalancerPolicyInput) SetLoadBalancerName(v string) *DeleteLoadBalancerPolicyInput { 4043 s.LoadBalancerName = &v 4044 return s 4045} 4046 4047// SetPolicyName sets the PolicyName field's value. 4048func (s *DeleteLoadBalancerPolicyInput) SetPolicyName(v string) *DeleteLoadBalancerPolicyInput { 4049 s.PolicyName = &v 4050 return s 4051} 4052 4053// Contains the output of DeleteLoadBalancerPolicy. 4054type DeleteLoadBalancerPolicyOutput struct { 4055 _ struct{} `type:"structure"` 4056} 4057 4058// String returns the string representation 4059func (s DeleteLoadBalancerPolicyOutput) String() string { 4060 return awsutil.Prettify(s) 4061} 4062 4063// GoString returns the string representation 4064func (s DeleteLoadBalancerPolicyOutput) GoString() string { 4065 return s.String() 4066} 4067 4068// Contains the parameters for DeregisterInstancesFromLoadBalancer. 4069type DeregisterInstancesFromLoadBalancerInput struct { 4070 _ struct{} `type:"structure"` 4071 4072 // The IDs of the instances. 4073 // 4074 // Instances is a required field 4075 Instances []*Instance `type:"list" required:"true"` 4076 4077 // The name of the load balancer. 4078 // 4079 // LoadBalancerName is a required field 4080 LoadBalancerName *string `type:"string" required:"true"` 4081} 4082 4083// String returns the string representation 4084func (s DeregisterInstancesFromLoadBalancerInput) String() string { 4085 return awsutil.Prettify(s) 4086} 4087 4088// GoString returns the string representation 4089func (s DeregisterInstancesFromLoadBalancerInput) GoString() string { 4090 return s.String() 4091} 4092 4093// Validate inspects the fields of the type to determine if they are valid. 4094func (s *DeregisterInstancesFromLoadBalancerInput) Validate() error { 4095 invalidParams := request.ErrInvalidParams{Context: "DeregisterInstancesFromLoadBalancerInput"} 4096 if s.Instances == nil { 4097 invalidParams.Add(request.NewErrParamRequired("Instances")) 4098 } 4099 if s.LoadBalancerName == nil { 4100 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 4101 } 4102 4103 if invalidParams.Len() > 0 { 4104 return invalidParams 4105 } 4106 return nil 4107} 4108 4109// SetInstances sets the Instances field's value. 4110func (s *DeregisterInstancesFromLoadBalancerInput) SetInstances(v []*Instance) *DeregisterInstancesFromLoadBalancerInput { 4111 s.Instances = v 4112 return s 4113} 4114 4115// SetLoadBalancerName sets the LoadBalancerName field's value. 4116func (s *DeregisterInstancesFromLoadBalancerInput) SetLoadBalancerName(v string) *DeregisterInstancesFromLoadBalancerInput { 4117 s.LoadBalancerName = &v 4118 return s 4119} 4120 4121// Contains the output of DeregisterInstancesFromLoadBalancer. 4122type DeregisterInstancesFromLoadBalancerOutput struct { 4123 _ struct{} `type:"structure"` 4124 4125 // The remaining instances registered with the load balancer. 4126 Instances []*Instance `type:"list"` 4127} 4128 4129// String returns the string representation 4130func (s DeregisterInstancesFromLoadBalancerOutput) String() string { 4131 return awsutil.Prettify(s) 4132} 4133 4134// GoString returns the string representation 4135func (s DeregisterInstancesFromLoadBalancerOutput) GoString() string { 4136 return s.String() 4137} 4138 4139// SetInstances sets the Instances field's value. 4140func (s *DeregisterInstancesFromLoadBalancerOutput) SetInstances(v []*Instance) *DeregisterInstancesFromLoadBalancerOutput { 4141 s.Instances = v 4142 return s 4143} 4144 4145type DescribeAccountLimitsInput struct { 4146 _ struct{} `type:"structure"` 4147 4148 // The marker for the next set of results. (You received this marker from a 4149 // previous call.) 4150 Marker *string `type:"string"` 4151 4152 // The maximum number of results to return with this call. 4153 PageSize *int64 `min:"1" type:"integer"` 4154} 4155 4156// String returns the string representation 4157func (s DescribeAccountLimitsInput) String() string { 4158 return awsutil.Prettify(s) 4159} 4160 4161// GoString returns the string representation 4162func (s DescribeAccountLimitsInput) GoString() string { 4163 return s.String() 4164} 4165 4166// Validate inspects the fields of the type to determine if they are valid. 4167func (s *DescribeAccountLimitsInput) Validate() error { 4168 invalidParams := request.ErrInvalidParams{Context: "DescribeAccountLimitsInput"} 4169 if s.PageSize != nil && *s.PageSize < 1 { 4170 invalidParams.Add(request.NewErrParamMinValue("PageSize", 1)) 4171 } 4172 4173 if invalidParams.Len() > 0 { 4174 return invalidParams 4175 } 4176 return nil 4177} 4178 4179// SetMarker sets the Marker field's value. 4180func (s *DescribeAccountLimitsInput) SetMarker(v string) *DescribeAccountLimitsInput { 4181 s.Marker = &v 4182 return s 4183} 4184 4185// SetPageSize sets the PageSize field's value. 4186func (s *DescribeAccountLimitsInput) SetPageSize(v int64) *DescribeAccountLimitsInput { 4187 s.PageSize = &v 4188 return s 4189} 4190 4191type DescribeAccountLimitsOutput struct { 4192 _ struct{} `type:"structure"` 4193 4194 // Information about the limits. 4195 Limits []*Limit `type:"list"` 4196 4197 // The marker to use when requesting the next set of results. If there are no 4198 // additional results, the string is empty. 4199 NextMarker *string `type:"string"` 4200} 4201 4202// String returns the string representation 4203func (s DescribeAccountLimitsOutput) String() string { 4204 return awsutil.Prettify(s) 4205} 4206 4207// GoString returns the string representation 4208func (s DescribeAccountLimitsOutput) GoString() string { 4209 return s.String() 4210} 4211 4212// SetLimits sets the Limits field's value. 4213func (s *DescribeAccountLimitsOutput) SetLimits(v []*Limit) *DescribeAccountLimitsOutput { 4214 s.Limits = v 4215 return s 4216} 4217 4218// SetNextMarker sets the NextMarker field's value. 4219func (s *DescribeAccountLimitsOutput) SetNextMarker(v string) *DescribeAccountLimitsOutput { 4220 s.NextMarker = &v 4221 return s 4222} 4223 4224// Contains the parameters for DescribeInstanceHealth. 4225type DescribeInstanceHealthInput struct { 4226 _ struct{} `type:"structure"` 4227 4228 // The IDs of the instances. 4229 Instances []*Instance `type:"list"` 4230 4231 // The name of the load balancer. 4232 // 4233 // LoadBalancerName is a required field 4234 LoadBalancerName *string `type:"string" required:"true"` 4235} 4236 4237// String returns the string representation 4238func (s DescribeInstanceHealthInput) String() string { 4239 return awsutil.Prettify(s) 4240} 4241 4242// GoString returns the string representation 4243func (s DescribeInstanceHealthInput) GoString() string { 4244 return s.String() 4245} 4246 4247// Validate inspects the fields of the type to determine if they are valid. 4248func (s *DescribeInstanceHealthInput) Validate() error { 4249 invalidParams := request.ErrInvalidParams{Context: "DescribeInstanceHealthInput"} 4250 if s.LoadBalancerName == nil { 4251 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 4252 } 4253 4254 if invalidParams.Len() > 0 { 4255 return invalidParams 4256 } 4257 return nil 4258} 4259 4260// SetInstances sets the Instances field's value. 4261func (s *DescribeInstanceHealthInput) SetInstances(v []*Instance) *DescribeInstanceHealthInput { 4262 s.Instances = v 4263 return s 4264} 4265 4266// SetLoadBalancerName sets the LoadBalancerName field's value. 4267func (s *DescribeInstanceHealthInput) SetLoadBalancerName(v string) *DescribeInstanceHealthInput { 4268 s.LoadBalancerName = &v 4269 return s 4270} 4271 4272// Contains the output for DescribeInstanceHealth. 4273type DescribeInstanceHealthOutput struct { 4274 _ struct{} `type:"structure"` 4275 4276 // Information about the health of the instances. 4277 InstanceStates []*InstanceState `type:"list"` 4278} 4279 4280// String returns the string representation 4281func (s DescribeInstanceHealthOutput) String() string { 4282 return awsutil.Prettify(s) 4283} 4284 4285// GoString returns the string representation 4286func (s DescribeInstanceHealthOutput) GoString() string { 4287 return s.String() 4288} 4289 4290// SetInstanceStates sets the InstanceStates field's value. 4291func (s *DescribeInstanceHealthOutput) SetInstanceStates(v []*InstanceState) *DescribeInstanceHealthOutput { 4292 s.InstanceStates = v 4293 return s 4294} 4295 4296// Contains the parameters for DescribeLoadBalancerAttributes. 4297type DescribeLoadBalancerAttributesInput struct { 4298 _ struct{} `type:"structure"` 4299 4300 // The name of the load balancer. 4301 // 4302 // LoadBalancerName is a required field 4303 LoadBalancerName *string `type:"string" required:"true"` 4304} 4305 4306// String returns the string representation 4307func (s DescribeLoadBalancerAttributesInput) String() string { 4308 return awsutil.Prettify(s) 4309} 4310 4311// GoString returns the string representation 4312func (s DescribeLoadBalancerAttributesInput) GoString() string { 4313 return s.String() 4314} 4315 4316// Validate inspects the fields of the type to determine if they are valid. 4317func (s *DescribeLoadBalancerAttributesInput) Validate() error { 4318 invalidParams := request.ErrInvalidParams{Context: "DescribeLoadBalancerAttributesInput"} 4319 if s.LoadBalancerName == nil { 4320 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 4321 } 4322 4323 if invalidParams.Len() > 0 { 4324 return invalidParams 4325 } 4326 return nil 4327} 4328 4329// SetLoadBalancerName sets the LoadBalancerName field's value. 4330func (s *DescribeLoadBalancerAttributesInput) SetLoadBalancerName(v string) *DescribeLoadBalancerAttributesInput { 4331 s.LoadBalancerName = &v 4332 return s 4333} 4334 4335// Contains the output of DescribeLoadBalancerAttributes. 4336type DescribeLoadBalancerAttributesOutput struct { 4337 _ struct{} `type:"structure"` 4338 4339 // Information about the load balancer attributes. 4340 LoadBalancerAttributes *LoadBalancerAttributes `type:"structure"` 4341} 4342 4343// String returns the string representation 4344func (s DescribeLoadBalancerAttributesOutput) String() string { 4345 return awsutil.Prettify(s) 4346} 4347 4348// GoString returns the string representation 4349func (s DescribeLoadBalancerAttributesOutput) GoString() string { 4350 return s.String() 4351} 4352 4353// SetLoadBalancerAttributes sets the LoadBalancerAttributes field's value. 4354func (s *DescribeLoadBalancerAttributesOutput) SetLoadBalancerAttributes(v *LoadBalancerAttributes) *DescribeLoadBalancerAttributesOutput { 4355 s.LoadBalancerAttributes = v 4356 return s 4357} 4358 4359// Contains the parameters for DescribeLoadBalancerPolicies. 4360type DescribeLoadBalancerPoliciesInput struct { 4361 _ struct{} `type:"structure"` 4362 4363 // The name of the load balancer. 4364 LoadBalancerName *string `type:"string"` 4365 4366 // The names of the policies. 4367 PolicyNames []*string `type:"list"` 4368} 4369 4370// String returns the string representation 4371func (s DescribeLoadBalancerPoliciesInput) String() string { 4372 return awsutil.Prettify(s) 4373} 4374 4375// GoString returns the string representation 4376func (s DescribeLoadBalancerPoliciesInput) GoString() string { 4377 return s.String() 4378} 4379 4380// SetLoadBalancerName sets the LoadBalancerName field's value. 4381func (s *DescribeLoadBalancerPoliciesInput) SetLoadBalancerName(v string) *DescribeLoadBalancerPoliciesInput { 4382 s.LoadBalancerName = &v 4383 return s 4384} 4385 4386// SetPolicyNames sets the PolicyNames field's value. 4387func (s *DescribeLoadBalancerPoliciesInput) SetPolicyNames(v []*string) *DescribeLoadBalancerPoliciesInput { 4388 s.PolicyNames = v 4389 return s 4390} 4391 4392// Contains the output of DescribeLoadBalancerPolicies. 4393type DescribeLoadBalancerPoliciesOutput struct { 4394 _ struct{} `type:"structure"` 4395 4396 // Information about the policies. 4397 PolicyDescriptions []*PolicyDescription `type:"list"` 4398} 4399 4400// String returns the string representation 4401func (s DescribeLoadBalancerPoliciesOutput) String() string { 4402 return awsutil.Prettify(s) 4403} 4404 4405// GoString returns the string representation 4406func (s DescribeLoadBalancerPoliciesOutput) GoString() string { 4407 return s.String() 4408} 4409 4410// SetPolicyDescriptions sets the PolicyDescriptions field's value. 4411func (s *DescribeLoadBalancerPoliciesOutput) SetPolicyDescriptions(v []*PolicyDescription) *DescribeLoadBalancerPoliciesOutput { 4412 s.PolicyDescriptions = v 4413 return s 4414} 4415 4416// Contains the parameters for DescribeLoadBalancerPolicyTypes. 4417type DescribeLoadBalancerPolicyTypesInput struct { 4418 _ struct{} `type:"structure"` 4419 4420 // The names of the policy types. If no names are specified, describes all policy 4421 // types defined by Elastic Load Balancing. 4422 PolicyTypeNames []*string `type:"list"` 4423} 4424 4425// String returns the string representation 4426func (s DescribeLoadBalancerPolicyTypesInput) String() string { 4427 return awsutil.Prettify(s) 4428} 4429 4430// GoString returns the string representation 4431func (s DescribeLoadBalancerPolicyTypesInput) GoString() string { 4432 return s.String() 4433} 4434 4435// SetPolicyTypeNames sets the PolicyTypeNames field's value. 4436func (s *DescribeLoadBalancerPolicyTypesInput) SetPolicyTypeNames(v []*string) *DescribeLoadBalancerPolicyTypesInput { 4437 s.PolicyTypeNames = v 4438 return s 4439} 4440 4441// Contains the output of DescribeLoadBalancerPolicyTypes. 4442type DescribeLoadBalancerPolicyTypesOutput struct { 4443 _ struct{} `type:"structure"` 4444 4445 // Information about the policy types. 4446 PolicyTypeDescriptions []*PolicyTypeDescription `type:"list"` 4447} 4448 4449// String returns the string representation 4450func (s DescribeLoadBalancerPolicyTypesOutput) String() string { 4451 return awsutil.Prettify(s) 4452} 4453 4454// GoString returns the string representation 4455func (s DescribeLoadBalancerPolicyTypesOutput) GoString() string { 4456 return s.String() 4457} 4458 4459// SetPolicyTypeDescriptions sets the PolicyTypeDescriptions field's value. 4460func (s *DescribeLoadBalancerPolicyTypesOutput) SetPolicyTypeDescriptions(v []*PolicyTypeDescription) *DescribeLoadBalancerPolicyTypesOutput { 4461 s.PolicyTypeDescriptions = v 4462 return s 4463} 4464 4465// Contains the parameters for DescribeLoadBalancers. 4466type DescribeLoadBalancersInput struct { 4467 _ struct{} `type:"structure"` 4468 4469 // The names of the load balancers. 4470 LoadBalancerNames []*string `type:"list"` 4471 4472 // The marker for the next set of results. (You received this marker from a 4473 // previous call.) 4474 Marker *string `type:"string"` 4475 4476 // The maximum number of results to return with this call (a number from 1 to 4477 // 400). The default is 400. 4478 PageSize *int64 `min:"1" type:"integer"` 4479} 4480 4481// String returns the string representation 4482func (s DescribeLoadBalancersInput) String() string { 4483 return awsutil.Prettify(s) 4484} 4485 4486// GoString returns the string representation 4487func (s DescribeLoadBalancersInput) GoString() string { 4488 return s.String() 4489} 4490 4491// Validate inspects the fields of the type to determine if they are valid. 4492func (s *DescribeLoadBalancersInput) Validate() error { 4493 invalidParams := request.ErrInvalidParams{Context: "DescribeLoadBalancersInput"} 4494 if s.PageSize != nil && *s.PageSize < 1 { 4495 invalidParams.Add(request.NewErrParamMinValue("PageSize", 1)) 4496 } 4497 4498 if invalidParams.Len() > 0 { 4499 return invalidParams 4500 } 4501 return nil 4502} 4503 4504// SetLoadBalancerNames sets the LoadBalancerNames field's value. 4505func (s *DescribeLoadBalancersInput) SetLoadBalancerNames(v []*string) *DescribeLoadBalancersInput { 4506 s.LoadBalancerNames = v 4507 return s 4508} 4509 4510// SetMarker sets the Marker field's value. 4511func (s *DescribeLoadBalancersInput) SetMarker(v string) *DescribeLoadBalancersInput { 4512 s.Marker = &v 4513 return s 4514} 4515 4516// SetPageSize sets the PageSize field's value. 4517func (s *DescribeLoadBalancersInput) SetPageSize(v int64) *DescribeLoadBalancersInput { 4518 s.PageSize = &v 4519 return s 4520} 4521 4522// Contains the parameters for DescribeLoadBalancers. 4523type DescribeLoadBalancersOutput struct { 4524 _ struct{} `type:"structure"` 4525 4526 // Information about the load balancers. 4527 LoadBalancerDescriptions []*LoadBalancerDescription `type:"list"` 4528 4529 // The marker to use when requesting the next set of results. If there are no 4530 // additional results, the string is empty. 4531 NextMarker *string `type:"string"` 4532} 4533 4534// String returns the string representation 4535func (s DescribeLoadBalancersOutput) String() string { 4536 return awsutil.Prettify(s) 4537} 4538 4539// GoString returns the string representation 4540func (s DescribeLoadBalancersOutput) GoString() string { 4541 return s.String() 4542} 4543 4544// SetLoadBalancerDescriptions sets the LoadBalancerDescriptions field's value. 4545func (s *DescribeLoadBalancersOutput) SetLoadBalancerDescriptions(v []*LoadBalancerDescription) *DescribeLoadBalancersOutput { 4546 s.LoadBalancerDescriptions = v 4547 return s 4548} 4549 4550// SetNextMarker sets the NextMarker field's value. 4551func (s *DescribeLoadBalancersOutput) SetNextMarker(v string) *DescribeLoadBalancersOutput { 4552 s.NextMarker = &v 4553 return s 4554} 4555 4556// Contains the parameters for DescribeTags. 4557type DescribeTagsInput struct { 4558 _ struct{} `type:"structure"` 4559 4560 // The names of the load balancers. 4561 // 4562 // LoadBalancerNames is a required field 4563 LoadBalancerNames []*string `min:"1" type:"list" required:"true"` 4564} 4565 4566// String returns the string representation 4567func (s DescribeTagsInput) String() string { 4568 return awsutil.Prettify(s) 4569} 4570 4571// GoString returns the string representation 4572func (s DescribeTagsInput) GoString() string { 4573 return s.String() 4574} 4575 4576// Validate inspects the fields of the type to determine if they are valid. 4577func (s *DescribeTagsInput) Validate() error { 4578 invalidParams := request.ErrInvalidParams{Context: "DescribeTagsInput"} 4579 if s.LoadBalancerNames == nil { 4580 invalidParams.Add(request.NewErrParamRequired("LoadBalancerNames")) 4581 } 4582 if s.LoadBalancerNames != nil && len(s.LoadBalancerNames) < 1 { 4583 invalidParams.Add(request.NewErrParamMinLen("LoadBalancerNames", 1)) 4584 } 4585 4586 if invalidParams.Len() > 0 { 4587 return invalidParams 4588 } 4589 return nil 4590} 4591 4592// SetLoadBalancerNames sets the LoadBalancerNames field's value. 4593func (s *DescribeTagsInput) SetLoadBalancerNames(v []*string) *DescribeTagsInput { 4594 s.LoadBalancerNames = v 4595 return s 4596} 4597 4598// Contains the output for DescribeTags. 4599type DescribeTagsOutput struct { 4600 _ struct{} `type:"structure"` 4601 4602 // Information about the tags. 4603 TagDescriptions []*TagDescription `type:"list"` 4604} 4605 4606// String returns the string representation 4607func (s DescribeTagsOutput) String() string { 4608 return awsutil.Prettify(s) 4609} 4610 4611// GoString returns the string representation 4612func (s DescribeTagsOutput) GoString() string { 4613 return s.String() 4614} 4615 4616// SetTagDescriptions sets the TagDescriptions field's value. 4617func (s *DescribeTagsOutput) SetTagDescriptions(v []*TagDescription) *DescribeTagsOutput { 4618 s.TagDescriptions = v 4619 return s 4620} 4621 4622// Contains the parameters for DetachLoadBalancerFromSubnets. 4623type DetachLoadBalancerFromSubnetsInput struct { 4624 _ struct{} `type:"structure"` 4625 4626 // The name of the load balancer. 4627 // 4628 // LoadBalancerName is a required field 4629 LoadBalancerName *string `type:"string" required:"true"` 4630 4631 // The IDs of the subnets. 4632 // 4633 // Subnets is a required field 4634 Subnets []*string `type:"list" required:"true"` 4635} 4636 4637// String returns the string representation 4638func (s DetachLoadBalancerFromSubnetsInput) String() string { 4639 return awsutil.Prettify(s) 4640} 4641 4642// GoString returns the string representation 4643func (s DetachLoadBalancerFromSubnetsInput) GoString() string { 4644 return s.String() 4645} 4646 4647// Validate inspects the fields of the type to determine if they are valid. 4648func (s *DetachLoadBalancerFromSubnetsInput) Validate() error { 4649 invalidParams := request.ErrInvalidParams{Context: "DetachLoadBalancerFromSubnetsInput"} 4650 if s.LoadBalancerName == nil { 4651 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 4652 } 4653 if s.Subnets == nil { 4654 invalidParams.Add(request.NewErrParamRequired("Subnets")) 4655 } 4656 4657 if invalidParams.Len() > 0 { 4658 return invalidParams 4659 } 4660 return nil 4661} 4662 4663// SetLoadBalancerName sets the LoadBalancerName field's value. 4664func (s *DetachLoadBalancerFromSubnetsInput) SetLoadBalancerName(v string) *DetachLoadBalancerFromSubnetsInput { 4665 s.LoadBalancerName = &v 4666 return s 4667} 4668 4669// SetSubnets sets the Subnets field's value. 4670func (s *DetachLoadBalancerFromSubnetsInput) SetSubnets(v []*string) *DetachLoadBalancerFromSubnetsInput { 4671 s.Subnets = v 4672 return s 4673} 4674 4675// Contains the output of DetachLoadBalancerFromSubnets. 4676type DetachLoadBalancerFromSubnetsOutput struct { 4677 _ struct{} `type:"structure"` 4678 4679 // The IDs of the remaining subnets for the load balancer. 4680 Subnets []*string `type:"list"` 4681} 4682 4683// String returns the string representation 4684func (s DetachLoadBalancerFromSubnetsOutput) String() string { 4685 return awsutil.Prettify(s) 4686} 4687 4688// GoString returns the string representation 4689func (s DetachLoadBalancerFromSubnetsOutput) GoString() string { 4690 return s.String() 4691} 4692 4693// SetSubnets sets the Subnets field's value. 4694func (s *DetachLoadBalancerFromSubnetsOutput) SetSubnets(v []*string) *DetachLoadBalancerFromSubnetsOutput { 4695 s.Subnets = v 4696 return s 4697} 4698 4699// Contains the parameters for DisableAvailabilityZonesForLoadBalancer. 4700type DisableAvailabilityZonesForLoadBalancerInput struct { 4701 _ struct{} `type:"structure"` 4702 4703 // The Availability Zones. 4704 // 4705 // AvailabilityZones is a required field 4706 AvailabilityZones []*string `type:"list" required:"true"` 4707 4708 // The name of the load balancer. 4709 // 4710 // LoadBalancerName is a required field 4711 LoadBalancerName *string `type:"string" required:"true"` 4712} 4713 4714// String returns the string representation 4715func (s DisableAvailabilityZonesForLoadBalancerInput) String() string { 4716 return awsutil.Prettify(s) 4717} 4718 4719// GoString returns the string representation 4720func (s DisableAvailabilityZonesForLoadBalancerInput) GoString() string { 4721 return s.String() 4722} 4723 4724// Validate inspects the fields of the type to determine if they are valid. 4725func (s *DisableAvailabilityZonesForLoadBalancerInput) Validate() error { 4726 invalidParams := request.ErrInvalidParams{Context: "DisableAvailabilityZonesForLoadBalancerInput"} 4727 if s.AvailabilityZones == nil { 4728 invalidParams.Add(request.NewErrParamRequired("AvailabilityZones")) 4729 } 4730 if s.LoadBalancerName == nil { 4731 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 4732 } 4733 4734 if invalidParams.Len() > 0 { 4735 return invalidParams 4736 } 4737 return nil 4738} 4739 4740// SetAvailabilityZones sets the AvailabilityZones field's value. 4741func (s *DisableAvailabilityZonesForLoadBalancerInput) SetAvailabilityZones(v []*string) *DisableAvailabilityZonesForLoadBalancerInput { 4742 s.AvailabilityZones = v 4743 return s 4744} 4745 4746// SetLoadBalancerName sets the LoadBalancerName field's value. 4747func (s *DisableAvailabilityZonesForLoadBalancerInput) SetLoadBalancerName(v string) *DisableAvailabilityZonesForLoadBalancerInput { 4748 s.LoadBalancerName = &v 4749 return s 4750} 4751 4752// Contains the output for DisableAvailabilityZonesForLoadBalancer. 4753type DisableAvailabilityZonesForLoadBalancerOutput struct { 4754 _ struct{} `type:"structure"` 4755 4756 // The remaining Availability Zones for the load balancer. 4757 AvailabilityZones []*string `type:"list"` 4758} 4759 4760// String returns the string representation 4761func (s DisableAvailabilityZonesForLoadBalancerOutput) String() string { 4762 return awsutil.Prettify(s) 4763} 4764 4765// GoString returns the string representation 4766func (s DisableAvailabilityZonesForLoadBalancerOutput) GoString() string { 4767 return s.String() 4768} 4769 4770// SetAvailabilityZones sets the AvailabilityZones field's value. 4771func (s *DisableAvailabilityZonesForLoadBalancerOutput) SetAvailabilityZones(v []*string) *DisableAvailabilityZonesForLoadBalancerOutput { 4772 s.AvailabilityZones = v 4773 return s 4774} 4775 4776// Contains the parameters for EnableAvailabilityZonesForLoadBalancer. 4777type EnableAvailabilityZonesForLoadBalancerInput struct { 4778 _ struct{} `type:"structure"` 4779 4780 // The Availability Zones. These must be in the same region as the load balancer. 4781 // 4782 // AvailabilityZones is a required field 4783 AvailabilityZones []*string `type:"list" required:"true"` 4784 4785 // The name of the load balancer. 4786 // 4787 // LoadBalancerName is a required field 4788 LoadBalancerName *string `type:"string" required:"true"` 4789} 4790 4791// String returns the string representation 4792func (s EnableAvailabilityZonesForLoadBalancerInput) String() string { 4793 return awsutil.Prettify(s) 4794} 4795 4796// GoString returns the string representation 4797func (s EnableAvailabilityZonesForLoadBalancerInput) GoString() string { 4798 return s.String() 4799} 4800 4801// Validate inspects the fields of the type to determine if they are valid. 4802func (s *EnableAvailabilityZonesForLoadBalancerInput) Validate() error { 4803 invalidParams := request.ErrInvalidParams{Context: "EnableAvailabilityZonesForLoadBalancerInput"} 4804 if s.AvailabilityZones == nil { 4805 invalidParams.Add(request.NewErrParamRequired("AvailabilityZones")) 4806 } 4807 if s.LoadBalancerName == nil { 4808 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 4809 } 4810 4811 if invalidParams.Len() > 0 { 4812 return invalidParams 4813 } 4814 return nil 4815} 4816 4817// SetAvailabilityZones sets the AvailabilityZones field's value. 4818func (s *EnableAvailabilityZonesForLoadBalancerInput) SetAvailabilityZones(v []*string) *EnableAvailabilityZonesForLoadBalancerInput { 4819 s.AvailabilityZones = v 4820 return s 4821} 4822 4823// SetLoadBalancerName sets the LoadBalancerName field's value. 4824func (s *EnableAvailabilityZonesForLoadBalancerInput) SetLoadBalancerName(v string) *EnableAvailabilityZonesForLoadBalancerInput { 4825 s.LoadBalancerName = &v 4826 return s 4827} 4828 4829// Contains the output of EnableAvailabilityZonesForLoadBalancer. 4830type EnableAvailabilityZonesForLoadBalancerOutput struct { 4831 _ struct{} `type:"structure"` 4832 4833 // The updated list of Availability Zones for the load balancer. 4834 AvailabilityZones []*string `type:"list"` 4835} 4836 4837// String returns the string representation 4838func (s EnableAvailabilityZonesForLoadBalancerOutput) String() string { 4839 return awsutil.Prettify(s) 4840} 4841 4842// GoString returns the string representation 4843func (s EnableAvailabilityZonesForLoadBalancerOutput) GoString() string { 4844 return s.String() 4845} 4846 4847// SetAvailabilityZones sets the AvailabilityZones field's value. 4848func (s *EnableAvailabilityZonesForLoadBalancerOutput) SetAvailabilityZones(v []*string) *EnableAvailabilityZonesForLoadBalancerOutput { 4849 s.AvailabilityZones = v 4850 return s 4851} 4852 4853// Information about a health check. 4854type HealthCheck struct { 4855 _ struct{} `type:"structure"` 4856 4857 // The number of consecutive health checks successes required before moving 4858 // the instance to the Healthy state. 4859 // 4860 // HealthyThreshold is a required field 4861 HealthyThreshold *int64 `min:"2" type:"integer" required:"true"` 4862 4863 // The approximate interval, in seconds, between health checks of an individual 4864 // instance. 4865 // 4866 // Interval is a required field 4867 Interval *int64 `min:"5" type:"integer" required:"true"` 4868 4869 // The instance being checked. The protocol is either TCP, HTTP, HTTPS, or SSL. 4870 // The range of valid ports is one (1) through 65535. 4871 // 4872 // TCP is the default, specified as a TCP: port pair, for example "TCP:5000". 4873 // In this case, a health check simply attempts to open a TCP connection to 4874 // the instance on the specified port. Failure to connect within the configured 4875 // timeout is considered unhealthy. 4876 // 4877 // SSL is also specified as SSL: port pair, for example, SSL:5000. 4878 // 4879 // For HTTP/HTTPS, you must include a ping path in the string. HTTP is specified 4880 // as a HTTP:port;/;PathToPing; grouping, for example "HTTP:80/weather/us/wa/seattle". 4881 // In this case, a HTTP GET request is issued to the instance on the given port 4882 // and path. Any answer other than "200 OK" within the timeout period is considered 4883 // unhealthy. 4884 // 4885 // The total length of the HTTP ping target must be 1024 16-bit Unicode characters 4886 // or less. 4887 // 4888 // Target is a required field 4889 Target *string `type:"string" required:"true"` 4890 4891 // The amount of time, in seconds, during which no response means a failed health 4892 // check. 4893 // 4894 // This value must be less than the Interval value. 4895 // 4896 // Timeout is a required field 4897 Timeout *int64 `min:"2" type:"integer" required:"true"` 4898 4899 // The number of consecutive health check failures required before moving the 4900 // instance to the Unhealthy state. 4901 // 4902 // UnhealthyThreshold is a required field 4903 UnhealthyThreshold *int64 `min:"2" type:"integer" required:"true"` 4904} 4905 4906// String returns the string representation 4907func (s HealthCheck) String() string { 4908 return awsutil.Prettify(s) 4909} 4910 4911// GoString returns the string representation 4912func (s HealthCheck) GoString() string { 4913 return s.String() 4914} 4915 4916// Validate inspects the fields of the type to determine if they are valid. 4917func (s *HealthCheck) Validate() error { 4918 invalidParams := request.ErrInvalidParams{Context: "HealthCheck"} 4919 if s.HealthyThreshold == nil { 4920 invalidParams.Add(request.NewErrParamRequired("HealthyThreshold")) 4921 } 4922 if s.HealthyThreshold != nil && *s.HealthyThreshold < 2 { 4923 invalidParams.Add(request.NewErrParamMinValue("HealthyThreshold", 2)) 4924 } 4925 if s.Interval == nil { 4926 invalidParams.Add(request.NewErrParamRequired("Interval")) 4927 } 4928 if s.Interval != nil && *s.Interval < 5 { 4929 invalidParams.Add(request.NewErrParamMinValue("Interval", 5)) 4930 } 4931 if s.Target == nil { 4932 invalidParams.Add(request.NewErrParamRequired("Target")) 4933 } 4934 if s.Timeout == nil { 4935 invalidParams.Add(request.NewErrParamRequired("Timeout")) 4936 } 4937 if s.Timeout != nil && *s.Timeout < 2 { 4938 invalidParams.Add(request.NewErrParamMinValue("Timeout", 2)) 4939 } 4940 if s.UnhealthyThreshold == nil { 4941 invalidParams.Add(request.NewErrParamRequired("UnhealthyThreshold")) 4942 } 4943 if s.UnhealthyThreshold != nil && *s.UnhealthyThreshold < 2 { 4944 invalidParams.Add(request.NewErrParamMinValue("UnhealthyThreshold", 2)) 4945 } 4946 4947 if invalidParams.Len() > 0 { 4948 return invalidParams 4949 } 4950 return nil 4951} 4952 4953// SetHealthyThreshold sets the HealthyThreshold field's value. 4954func (s *HealthCheck) SetHealthyThreshold(v int64) *HealthCheck { 4955 s.HealthyThreshold = &v 4956 return s 4957} 4958 4959// SetInterval sets the Interval field's value. 4960func (s *HealthCheck) SetInterval(v int64) *HealthCheck { 4961 s.Interval = &v 4962 return s 4963} 4964 4965// SetTarget sets the Target field's value. 4966func (s *HealthCheck) SetTarget(v string) *HealthCheck { 4967 s.Target = &v 4968 return s 4969} 4970 4971// SetTimeout sets the Timeout field's value. 4972func (s *HealthCheck) SetTimeout(v int64) *HealthCheck { 4973 s.Timeout = &v 4974 return s 4975} 4976 4977// SetUnhealthyThreshold sets the UnhealthyThreshold field's value. 4978func (s *HealthCheck) SetUnhealthyThreshold(v int64) *HealthCheck { 4979 s.UnhealthyThreshold = &v 4980 return s 4981} 4982 4983// The ID of an EC2 instance. 4984type Instance struct { 4985 _ struct{} `type:"structure"` 4986 4987 // The instance ID. 4988 InstanceId *string `type:"string"` 4989} 4990 4991// String returns the string representation 4992func (s Instance) String() string { 4993 return awsutil.Prettify(s) 4994} 4995 4996// GoString returns the string representation 4997func (s Instance) GoString() string { 4998 return s.String() 4999} 5000 5001// SetInstanceId sets the InstanceId field's value. 5002func (s *Instance) SetInstanceId(v string) *Instance { 5003 s.InstanceId = &v 5004 return s 5005} 5006 5007// Information about the state of an EC2 instance. 5008type InstanceState struct { 5009 _ struct{} `type:"structure"` 5010 5011 // A description of the instance state. This string can contain one or more 5012 // of the following messages. 5013 // 5014 // * N/A 5015 // 5016 // * A transient error occurred. Please try again later. 5017 // 5018 // * Instance has failed at least the UnhealthyThreshold number of health 5019 // checks consecutively. 5020 // 5021 // * Instance has not passed the configured HealthyThreshold number of health 5022 // checks consecutively. 5023 // 5024 // * Instance registration is still in progress. 5025 // 5026 // * Instance is in the EC2 Availability Zone for which LoadBalancer is not 5027 // configured to route traffic to. 5028 // 5029 // * Instance is not currently registered with the LoadBalancer. 5030 // 5031 // * Instance deregistration currently in progress. 5032 // 5033 // * Disable Availability Zone is currently in progress. 5034 // 5035 // * Instance is in pending state. 5036 // 5037 // * Instance is in stopped state. 5038 // 5039 // * Instance is in terminated state. 5040 Description *string `type:"string"` 5041 5042 // The ID of the instance. 5043 InstanceId *string `type:"string"` 5044 5045 // Information about the cause of OutOfService instances. Specifically, whether 5046 // the cause is Elastic Load Balancing or the instance. 5047 // 5048 // Valid values: ELB | Instance | N/A 5049 ReasonCode *string `type:"string"` 5050 5051 // The current state of the instance. 5052 // 5053 // Valid values: InService | OutOfService | Unknown 5054 State *string `type:"string"` 5055} 5056 5057// String returns the string representation 5058func (s InstanceState) String() string { 5059 return awsutil.Prettify(s) 5060} 5061 5062// GoString returns the string representation 5063func (s InstanceState) GoString() string { 5064 return s.String() 5065} 5066 5067// SetDescription sets the Description field's value. 5068func (s *InstanceState) SetDescription(v string) *InstanceState { 5069 s.Description = &v 5070 return s 5071} 5072 5073// SetInstanceId sets the InstanceId field's value. 5074func (s *InstanceState) SetInstanceId(v string) *InstanceState { 5075 s.InstanceId = &v 5076 return s 5077} 5078 5079// SetReasonCode sets the ReasonCode field's value. 5080func (s *InstanceState) SetReasonCode(v string) *InstanceState { 5081 s.ReasonCode = &v 5082 return s 5083} 5084 5085// SetState sets the State field's value. 5086func (s *InstanceState) SetState(v string) *InstanceState { 5087 s.State = &v 5088 return s 5089} 5090 5091// Information about a policy for duration-based session stickiness. 5092type LBCookieStickinessPolicy struct { 5093 _ struct{} `type:"structure"` 5094 5095 // The time period, in seconds, after which the cookie should be considered 5096 // stale. If this parameter is not specified, the stickiness session lasts for 5097 // the duration of the browser session. 5098 CookieExpirationPeriod *int64 `type:"long"` 5099 5100 // The name of the policy. This name must be unique within the set of policies 5101 // for this load balancer. 5102 PolicyName *string `type:"string"` 5103} 5104 5105// String returns the string representation 5106func (s LBCookieStickinessPolicy) String() string { 5107 return awsutil.Prettify(s) 5108} 5109 5110// GoString returns the string representation 5111func (s LBCookieStickinessPolicy) GoString() string { 5112 return s.String() 5113} 5114 5115// SetCookieExpirationPeriod sets the CookieExpirationPeriod field's value. 5116func (s *LBCookieStickinessPolicy) SetCookieExpirationPeriod(v int64) *LBCookieStickinessPolicy { 5117 s.CookieExpirationPeriod = &v 5118 return s 5119} 5120 5121// SetPolicyName sets the PolicyName field's value. 5122func (s *LBCookieStickinessPolicy) SetPolicyName(v string) *LBCookieStickinessPolicy { 5123 s.PolicyName = &v 5124 return s 5125} 5126 5127// Information about an Elastic Load Balancing resource limit for your AWS account. 5128type Limit struct { 5129 _ struct{} `type:"structure"` 5130 5131 // The maximum value of the limit. 5132 Max *string `type:"string"` 5133 5134 // The name of the limit. The possible values are: 5135 // 5136 // * classic-listeners 5137 // 5138 // * classic-load-balancers 5139 // 5140 // * classic-registered-instances 5141 Name *string `type:"string"` 5142} 5143 5144// String returns the string representation 5145func (s Limit) String() string { 5146 return awsutil.Prettify(s) 5147} 5148 5149// GoString returns the string representation 5150func (s Limit) GoString() string { 5151 return s.String() 5152} 5153 5154// SetMax sets the Max field's value. 5155func (s *Limit) SetMax(v string) *Limit { 5156 s.Max = &v 5157 return s 5158} 5159 5160// SetName sets the Name field's value. 5161func (s *Limit) SetName(v string) *Limit { 5162 s.Name = &v 5163 return s 5164} 5165 5166// Information about a listener. 5167// 5168// For information about the protocols and the ports supported by Elastic Load 5169// Balancing, see Listeners for Your Classic Load Balancer (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-listener-config.html) 5170// in the Classic Load Balancers Guide. 5171type Listener struct { 5172 _ struct{} `type:"structure"` 5173 5174 // The port on which the instance is listening. 5175 // 5176 // InstancePort is a required field 5177 InstancePort *int64 `min:"1" type:"integer" required:"true"` 5178 5179 // The protocol to use for routing traffic to instances: HTTP, HTTPS, TCP, or 5180 // SSL. 5181 // 5182 // If the front-end protocol is HTTP, HTTPS, TCP, or SSL, InstanceProtocol must 5183 // be at the same protocol. 5184 // 5185 // If there is another listener with the same InstancePort whose InstanceProtocol 5186 // is secure, (HTTPS or SSL), the listener's InstanceProtocol must also be secure. 5187 // 5188 // If there is another listener with the same InstancePort whose InstanceProtocol 5189 // is HTTP or TCP, the listener's InstanceProtocol must be HTTP or TCP. 5190 InstanceProtocol *string `type:"string"` 5191 5192 // The port on which the load balancer is listening. On EC2-VPC, you can specify 5193 // any port from the range 1-65535. On EC2-Classic, you can specify any port 5194 // from the following list: 25, 80, 443, 465, 587, 1024-65535. 5195 // 5196 // LoadBalancerPort is a required field 5197 LoadBalancerPort *int64 `type:"integer" required:"true"` 5198 5199 // The load balancer transport protocol to use for routing: HTTP, HTTPS, TCP, 5200 // or SSL. 5201 // 5202 // Protocol is a required field 5203 Protocol *string `type:"string" required:"true"` 5204 5205 // The Amazon Resource Name (ARN) of the server certificate. 5206 SSLCertificateId *string `type:"string"` 5207} 5208 5209// String returns the string representation 5210func (s Listener) String() string { 5211 return awsutil.Prettify(s) 5212} 5213 5214// GoString returns the string representation 5215func (s Listener) GoString() string { 5216 return s.String() 5217} 5218 5219// Validate inspects the fields of the type to determine if they are valid. 5220func (s *Listener) Validate() error { 5221 invalidParams := request.ErrInvalidParams{Context: "Listener"} 5222 if s.InstancePort == nil { 5223 invalidParams.Add(request.NewErrParamRequired("InstancePort")) 5224 } 5225 if s.InstancePort != nil && *s.InstancePort < 1 { 5226 invalidParams.Add(request.NewErrParamMinValue("InstancePort", 1)) 5227 } 5228 if s.LoadBalancerPort == nil { 5229 invalidParams.Add(request.NewErrParamRequired("LoadBalancerPort")) 5230 } 5231 if s.Protocol == nil { 5232 invalidParams.Add(request.NewErrParamRequired("Protocol")) 5233 } 5234 5235 if invalidParams.Len() > 0 { 5236 return invalidParams 5237 } 5238 return nil 5239} 5240 5241// SetInstancePort sets the InstancePort field's value. 5242func (s *Listener) SetInstancePort(v int64) *Listener { 5243 s.InstancePort = &v 5244 return s 5245} 5246 5247// SetInstanceProtocol sets the InstanceProtocol field's value. 5248func (s *Listener) SetInstanceProtocol(v string) *Listener { 5249 s.InstanceProtocol = &v 5250 return s 5251} 5252 5253// SetLoadBalancerPort sets the LoadBalancerPort field's value. 5254func (s *Listener) SetLoadBalancerPort(v int64) *Listener { 5255 s.LoadBalancerPort = &v 5256 return s 5257} 5258 5259// SetProtocol sets the Protocol field's value. 5260func (s *Listener) SetProtocol(v string) *Listener { 5261 s.Protocol = &v 5262 return s 5263} 5264 5265// SetSSLCertificateId sets the SSLCertificateId field's value. 5266func (s *Listener) SetSSLCertificateId(v string) *Listener { 5267 s.SSLCertificateId = &v 5268 return s 5269} 5270 5271// The policies enabled for a listener. 5272type ListenerDescription struct { 5273 _ struct{} `type:"structure"` 5274 5275 // The listener. 5276 Listener *Listener `type:"structure"` 5277 5278 // The policies. If there are no policies enabled, the list is empty. 5279 PolicyNames []*string `type:"list"` 5280} 5281 5282// String returns the string representation 5283func (s ListenerDescription) String() string { 5284 return awsutil.Prettify(s) 5285} 5286 5287// GoString returns the string representation 5288func (s ListenerDescription) GoString() string { 5289 return s.String() 5290} 5291 5292// SetListener sets the Listener field's value. 5293func (s *ListenerDescription) SetListener(v *Listener) *ListenerDescription { 5294 s.Listener = v 5295 return s 5296} 5297 5298// SetPolicyNames sets the PolicyNames field's value. 5299func (s *ListenerDescription) SetPolicyNames(v []*string) *ListenerDescription { 5300 s.PolicyNames = v 5301 return s 5302} 5303 5304// The attributes for a load balancer. 5305type LoadBalancerAttributes struct { 5306 _ struct{} `type:"structure"` 5307 5308 // If enabled, the load balancer captures detailed information of all requests 5309 // and delivers the information to the Amazon S3 bucket that you specify. 5310 // 5311 // For more information, see Enable Access Logs (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-access-logs.html) 5312 // in the Classic Load Balancers Guide. 5313 AccessLog *AccessLog `type:"structure"` 5314 5315 // This parameter is reserved. 5316 AdditionalAttributes []*AdditionalAttribute `type:"list"` 5317 5318 // If enabled, the load balancer allows existing requests to complete before 5319 // the load balancer shifts traffic away from a deregistered or unhealthy instance. 5320 // 5321 // For more information, see Configure Connection Draining (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/config-conn-drain.html) 5322 // in the Classic Load Balancers Guide. 5323 ConnectionDraining *ConnectionDraining `type:"structure"` 5324 5325 // If enabled, the load balancer allows the connections to remain idle (no data 5326 // is sent over the connection) for the specified duration. 5327 // 5328 // By default, Elastic Load Balancing maintains a 60-second idle connection 5329 // timeout for both front-end and back-end connections of your load balancer. 5330 // For more information, see Configure Idle Connection Timeout (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/config-idle-timeout.html) 5331 // in the Classic Load Balancers Guide. 5332 ConnectionSettings *ConnectionSettings `type:"structure"` 5333 5334 // If enabled, the load balancer routes the request traffic evenly across all 5335 // instances regardless of the Availability Zones. 5336 // 5337 // For more information, see Configure Cross-Zone Load Balancing (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-disable-crosszone-lb.html) 5338 // in the Classic Load Balancers Guide. 5339 CrossZoneLoadBalancing *CrossZoneLoadBalancing `type:"structure"` 5340} 5341 5342// String returns the string representation 5343func (s LoadBalancerAttributes) String() string { 5344 return awsutil.Prettify(s) 5345} 5346 5347// GoString returns the string representation 5348func (s LoadBalancerAttributes) GoString() string { 5349 return s.String() 5350} 5351 5352// Validate inspects the fields of the type to determine if they are valid. 5353func (s *LoadBalancerAttributes) Validate() error { 5354 invalidParams := request.ErrInvalidParams{Context: "LoadBalancerAttributes"} 5355 if s.AccessLog != nil { 5356 if err := s.AccessLog.Validate(); err != nil { 5357 invalidParams.AddNested("AccessLog", err.(request.ErrInvalidParams)) 5358 } 5359 } 5360 if s.ConnectionDraining != nil { 5361 if err := s.ConnectionDraining.Validate(); err != nil { 5362 invalidParams.AddNested("ConnectionDraining", err.(request.ErrInvalidParams)) 5363 } 5364 } 5365 if s.ConnectionSettings != nil { 5366 if err := s.ConnectionSettings.Validate(); err != nil { 5367 invalidParams.AddNested("ConnectionSettings", err.(request.ErrInvalidParams)) 5368 } 5369 } 5370 if s.CrossZoneLoadBalancing != nil { 5371 if err := s.CrossZoneLoadBalancing.Validate(); err != nil { 5372 invalidParams.AddNested("CrossZoneLoadBalancing", err.(request.ErrInvalidParams)) 5373 } 5374 } 5375 5376 if invalidParams.Len() > 0 { 5377 return invalidParams 5378 } 5379 return nil 5380} 5381 5382// SetAccessLog sets the AccessLog field's value. 5383func (s *LoadBalancerAttributes) SetAccessLog(v *AccessLog) *LoadBalancerAttributes { 5384 s.AccessLog = v 5385 return s 5386} 5387 5388// SetAdditionalAttributes sets the AdditionalAttributes field's value. 5389func (s *LoadBalancerAttributes) SetAdditionalAttributes(v []*AdditionalAttribute) *LoadBalancerAttributes { 5390 s.AdditionalAttributes = v 5391 return s 5392} 5393 5394// SetConnectionDraining sets the ConnectionDraining field's value. 5395func (s *LoadBalancerAttributes) SetConnectionDraining(v *ConnectionDraining) *LoadBalancerAttributes { 5396 s.ConnectionDraining = v 5397 return s 5398} 5399 5400// SetConnectionSettings sets the ConnectionSettings field's value. 5401func (s *LoadBalancerAttributes) SetConnectionSettings(v *ConnectionSettings) *LoadBalancerAttributes { 5402 s.ConnectionSettings = v 5403 return s 5404} 5405 5406// SetCrossZoneLoadBalancing sets the CrossZoneLoadBalancing field's value. 5407func (s *LoadBalancerAttributes) SetCrossZoneLoadBalancing(v *CrossZoneLoadBalancing) *LoadBalancerAttributes { 5408 s.CrossZoneLoadBalancing = v 5409 return s 5410} 5411 5412// Information about a load balancer. 5413type LoadBalancerDescription struct { 5414 _ struct{} `type:"structure"` 5415 5416 // The Availability Zones for the load balancer. 5417 AvailabilityZones []*string `type:"list"` 5418 5419 // Information about your EC2 instances. 5420 BackendServerDescriptions []*BackendServerDescription `type:"list"` 5421 5422 // The DNS name of the load balancer. 5423 // 5424 // For more information, see Configure a Custom Domain Name (http://docs.aws.amazon.com/elasticloadbalancing/latest/classic/using-domain-names-with-elb.html) 5425 // in the Classic Load Balancers Guide. 5426 CanonicalHostedZoneName *string `type:"string"` 5427 5428 // The ID of the Amazon Route 53 hosted zone for the load balancer. 5429 CanonicalHostedZoneNameID *string `type:"string"` 5430 5431 // The date and time the load balancer was created. 5432 CreatedTime *time.Time `type:"timestamp"` 5433 5434 // The DNS name of the load balancer. 5435 DNSName *string `type:"string"` 5436 5437 // Information about the health checks conducted on the load balancer. 5438 HealthCheck *HealthCheck `type:"structure"` 5439 5440 // The IDs of the instances for the load balancer. 5441 Instances []*Instance `type:"list"` 5442 5443 // The listeners for the load balancer. 5444 ListenerDescriptions []*ListenerDescription `type:"list"` 5445 5446 // The name of the load balancer. 5447 LoadBalancerName *string `type:"string"` 5448 5449 // The policies defined for the load balancer. 5450 Policies *Policies `type:"structure"` 5451 5452 // The type of load balancer. Valid only for load balancers in a VPC. 5453 // 5454 // If Scheme is internet-facing, the load balancer has a public DNS name that 5455 // resolves to a public IP address. 5456 // 5457 // If Scheme is internal, the load balancer has a public DNS name that resolves 5458 // to a private IP address. 5459 Scheme *string `type:"string"` 5460 5461 // The security groups for the load balancer. Valid only for load balancers 5462 // in a VPC. 5463 SecurityGroups []*string `type:"list"` 5464 5465 // The security group for the load balancer, which you can use as part of your 5466 // inbound rules for your registered instances. To only allow traffic from load 5467 // balancers, add a security group rule that specifies this source security 5468 // group as the inbound source. 5469 SourceSecurityGroup *SourceSecurityGroup `type:"structure"` 5470 5471 // The IDs of the subnets for the load balancer. 5472 Subnets []*string `type:"list"` 5473 5474 // The ID of the VPC for the load balancer. 5475 VPCId *string `type:"string"` 5476} 5477 5478// String returns the string representation 5479func (s LoadBalancerDescription) String() string { 5480 return awsutil.Prettify(s) 5481} 5482 5483// GoString returns the string representation 5484func (s LoadBalancerDescription) GoString() string { 5485 return s.String() 5486} 5487 5488// SetAvailabilityZones sets the AvailabilityZones field's value. 5489func (s *LoadBalancerDescription) SetAvailabilityZones(v []*string) *LoadBalancerDescription { 5490 s.AvailabilityZones = v 5491 return s 5492} 5493 5494// SetBackendServerDescriptions sets the BackendServerDescriptions field's value. 5495func (s *LoadBalancerDescription) SetBackendServerDescriptions(v []*BackendServerDescription) *LoadBalancerDescription { 5496 s.BackendServerDescriptions = v 5497 return s 5498} 5499 5500// SetCanonicalHostedZoneName sets the CanonicalHostedZoneName field's value. 5501func (s *LoadBalancerDescription) SetCanonicalHostedZoneName(v string) *LoadBalancerDescription { 5502 s.CanonicalHostedZoneName = &v 5503 return s 5504} 5505 5506// SetCanonicalHostedZoneNameID sets the CanonicalHostedZoneNameID field's value. 5507func (s *LoadBalancerDescription) SetCanonicalHostedZoneNameID(v string) *LoadBalancerDescription { 5508 s.CanonicalHostedZoneNameID = &v 5509 return s 5510} 5511 5512// SetCreatedTime sets the CreatedTime field's value. 5513func (s *LoadBalancerDescription) SetCreatedTime(v time.Time) *LoadBalancerDescription { 5514 s.CreatedTime = &v 5515 return s 5516} 5517 5518// SetDNSName sets the DNSName field's value. 5519func (s *LoadBalancerDescription) SetDNSName(v string) *LoadBalancerDescription { 5520 s.DNSName = &v 5521 return s 5522} 5523 5524// SetHealthCheck sets the HealthCheck field's value. 5525func (s *LoadBalancerDescription) SetHealthCheck(v *HealthCheck) *LoadBalancerDescription { 5526 s.HealthCheck = v 5527 return s 5528} 5529 5530// SetInstances sets the Instances field's value. 5531func (s *LoadBalancerDescription) SetInstances(v []*Instance) *LoadBalancerDescription { 5532 s.Instances = v 5533 return s 5534} 5535 5536// SetListenerDescriptions sets the ListenerDescriptions field's value. 5537func (s *LoadBalancerDescription) SetListenerDescriptions(v []*ListenerDescription) *LoadBalancerDescription { 5538 s.ListenerDescriptions = v 5539 return s 5540} 5541 5542// SetLoadBalancerName sets the LoadBalancerName field's value. 5543func (s *LoadBalancerDescription) SetLoadBalancerName(v string) *LoadBalancerDescription { 5544 s.LoadBalancerName = &v 5545 return s 5546} 5547 5548// SetPolicies sets the Policies field's value. 5549func (s *LoadBalancerDescription) SetPolicies(v *Policies) *LoadBalancerDescription { 5550 s.Policies = v 5551 return s 5552} 5553 5554// SetScheme sets the Scheme field's value. 5555func (s *LoadBalancerDescription) SetScheme(v string) *LoadBalancerDescription { 5556 s.Scheme = &v 5557 return s 5558} 5559 5560// SetSecurityGroups sets the SecurityGroups field's value. 5561func (s *LoadBalancerDescription) SetSecurityGroups(v []*string) *LoadBalancerDescription { 5562 s.SecurityGroups = v 5563 return s 5564} 5565 5566// SetSourceSecurityGroup sets the SourceSecurityGroup field's value. 5567func (s *LoadBalancerDescription) SetSourceSecurityGroup(v *SourceSecurityGroup) *LoadBalancerDescription { 5568 s.SourceSecurityGroup = v 5569 return s 5570} 5571 5572// SetSubnets sets the Subnets field's value. 5573func (s *LoadBalancerDescription) SetSubnets(v []*string) *LoadBalancerDescription { 5574 s.Subnets = v 5575 return s 5576} 5577 5578// SetVPCId sets the VPCId field's value. 5579func (s *LoadBalancerDescription) SetVPCId(v string) *LoadBalancerDescription { 5580 s.VPCId = &v 5581 return s 5582} 5583 5584// Contains the parameters for ModifyLoadBalancerAttributes. 5585type ModifyLoadBalancerAttributesInput struct { 5586 _ struct{} `type:"structure"` 5587 5588 // The attributes for the load balancer. 5589 // 5590 // LoadBalancerAttributes is a required field 5591 LoadBalancerAttributes *LoadBalancerAttributes `type:"structure" required:"true"` 5592 5593 // The name of the load balancer. 5594 // 5595 // LoadBalancerName is a required field 5596 LoadBalancerName *string `type:"string" required:"true"` 5597} 5598 5599// String returns the string representation 5600func (s ModifyLoadBalancerAttributesInput) String() string { 5601 return awsutil.Prettify(s) 5602} 5603 5604// GoString returns the string representation 5605func (s ModifyLoadBalancerAttributesInput) GoString() string { 5606 return s.String() 5607} 5608 5609// Validate inspects the fields of the type to determine if they are valid. 5610func (s *ModifyLoadBalancerAttributesInput) Validate() error { 5611 invalidParams := request.ErrInvalidParams{Context: "ModifyLoadBalancerAttributesInput"} 5612 if s.LoadBalancerAttributes == nil { 5613 invalidParams.Add(request.NewErrParamRequired("LoadBalancerAttributes")) 5614 } 5615 if s.LoadBalancerName == nil { 5616 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 5617 } 5618 if s.LoadBalancerAttributes != nil { 5619 if err := s.LoadBalancerAttributes.Validate(); err != nil { 5620 invalidParams.AddNested("LoadBalancerAttributes", err.(request.ErrInvalidParams)) 5621 } 5622 } 5623 5624 if invalidParams.Len() > 0 { 5625 return invalidParams 5626 } 5627 return nil 5628} 5629 5630// SetLoadBalancerAttributes sets the LoadBalancerAttributes field's value. 5631func (s *ModifyLoadBalancerAttributesInput) SetLoadBalancerAttributes(v *LoadBalancerAttributes) *ModifyLoadBalancerAttributesInput { 5632 s.LoadBalancerAttributes = v 5633 return s 5634} 5635 5636// SetLoadBalancerName sets the LoadBalancerName field's value. 5637func (s *ModifyLoadBalancerAttributesInput) SetLoadBalancerName(v string) *ModifyLoadBalancerAttributesInput { 5638 s.LoadBalancerName = &v 5639 return s 5640} 5641 5642// Contains the output of ModifyLoadBalancerAttributes. 5643type ModifyLoadBalancerAttributesOutput struct { 5644 _ struct{} `type:"structure"` 5645 5646 // Information about the load balancer attributes. 5647 LoadBalancerAttributes *LoadBalancerAttributes `type:"structure"` 5648 5649 // The name of the load balancer. 5650 LoadBalancerName *string `type:"string"` 5651} 5652 5653// String returns the string representation 5654func (s ModifyLoadBalancerAttributesOutput) String() string { 5655 return awsutil.Prettify(s) 5656} 5657 5658// GoString returns the string representation 5659func (s ModifyLoadBalancerAttributesOutput) GoString() string { 5660 return s.String() 5661} 5662 5663// SetLoadBalancerAttributes sets the LoadBalancerAttributes field's value. 5664func (s *ModifyLoadBalancerAttributesOutput) SetLoadBalancerAttributes(v *LoadBalancerAttributes) *ModifyLoadBalancerAttributesOutput { 5665 s.LoadBalancerAttributes = v 5666 return s 5667} 5668 5669// SetLoadBalancerName sets the LoadBalancerName field's value. 5670func (s *ModifyLoadBalancerAttributesOutput) SetLoadBalancerName(v string) *ModifyLoadBalancerAttributesOutput { 5671 s.LoadBalancerName = &v 5672 return s 5673} 5674 5675// The policies for a load balancer. 5676type Policies struct { 5677 _ struct{} `type:"structure"` 5678 5679 // The stickiness policies created using CreateAppCookieStickinessPolicy. 5680 AppCookieStickinessPolicies []*AppCookieStickinessPolicy `type:"list"` 5681 5682 // The stickiness policies created using CreateLBCookieStickinessPolicy. 5683 LBCookieStickinessPolicies []*LBCookieStickinessPolicy `type:"list"` 5684 5685 // The policies other than the stickiness policies. 5686 OtherPolicies []*string `type:"list"` 5687} 5688 5689// String returns the string representation 5690func (s Policies) String() string { 5691 return awsutil.Prettify(s) 5692} 5693 5694// GoString returns the string representation 5695func (s Policies) GoString() string { 5696 return s.String() 5697} 5698 5699// SetAppCookieStickinessPolicies sets the AppCookieStickinessPolicies field's value. 5700func (s *Policies) SetAppCookieStickinessPolicies(v []*AppCookieStickinessPolicy) *Policies { 5701 s.AppCookieStickinessPolicies = v 5702 return s 5703} 5704 5705// SetLBCookieStickinessPolicies sets the LBCookieStickinessPolicies field's value. 5706func (s *Policies) SetLBCookieStickinessPolicies(v []*LBCookieStickinessPolicy) *Policies { 5707 s.LBCookieStickinessPolicies = v 5708 return s 5709} 5710 5711// SetOtherPolicies sets the OtherPolicies field's value. 5712func (s *Policies) SetOtherPolicies(v []*string) *Policies { 5713 s.OtherPolicies = v 5714 return s 5715} 5716 5717// Information about a policy attribute. 5718type PolicyAttribute struct { 5719 _ struct{} `type:"structure"` 5720 5721 // The name of the attribute. 5722 AttributeName *string `type:"string"` 5723 5724 // The value of the attribute. 5725 AttributeValue *string `type:"string"` 5726} 5727 5728// String returns the string representation 5729func (s PolicyAttribute) String() string { 5730 return awsutil.Prettify(s) 5731} 5732 5733// GoString returns the string representation 5734func (s PolicyAttribute) GoString() string { 5735 return s.String() 5736} 5737 5738// SetAttributeName sets the AttributeName field's value. 5739func (s *PolicyAttribute) SetAttributeName(v string) *PolicyAttribute { 5740 s.AttributeName = &v 5741 return s 5742} 5743 5744// SetAttributeValue sets the AttributeValue field's value. 5745func (s *PolicyAttribute) SetAttributeValue(v string) *PolicyAttribute { 5746 s.AttributeValue = &v 5747 return s 5748} 5749 5750// Information about a policy attribute. 5751type PolicyAttributeDescription struct { 5752 _ struct{} `type:"structure"` 5753 5754 // The name of the attribute. 5755 AttributeName *string `type:"string"` 5756 5757 // The value of the attribute. 5758 AttributeValue *string `type:"string"` 5759} 5760 5761// String returns the string representation 5762func (s PolicyAttributeDescription) String() string { 5763 return awsutil.Prettify(s) 5764} 5765 5766// GoString returns the string representation 5767func (s PolicyAttributeDescription) GoString() string { 5768 return s.String() 5769} 5770 5771// SetAttributeName sets the AttributeName field's value. 5772func (s *PolicyAttributeDescription) SetAttributeName(v string) *PolicyAttributeDescription { 5773 s.AttributeName = &v 5774 return s 5775} 5776 5777// SetAttributeValue sets the AttributeValue field's value. 5778func (s *PolicyAttributeDescription) SetAttributeValue(v string) *PolicyAttributeDescription { 5779 s.AttributeValue = &v 5780 return s 5781} 5782 5783// Information about a policy attribute type. 5784type PolicyAttributeTypeDescription struct { 5785 _ struct{} `type:"structure"` 5786 5787 // The name of the attribute. 5788 AttributeName *string `type:"string"` 5789 5790 // The type of the attribute. For example, Boolean or Integer. 5791 AttributeType *string `type:"string"` 5792 5793 // The cardinality of the attribute. 5794 // 5795 // Valid values: 5796 // 5797 // * ONE(1) : Single value required 5798 // 5799 // * ZERO_OR_ONE(0..1) : Up to one value is allowed 5800 // 5801 // * ZERO_OR_MORE(0..*) : Optional. Multiple values are allowed 5802 // 5803 // * ONE_OR_MORE(1..*0) : Required. Multiple values are allowed 5804 Cardinality *string `type:"string"` 5805 5806 // The default value of the attribute, if applicable. 5807 DefaultValue *string `type:"string"` 5808 5809 // A description of the attribute. 5810 Description *string `type:"string"` 5811} 5812 5813// String returns the string representation 5814func (s PolicyAttributeTypeDescription) String() string { 5815 return awsutil.Prettify(s) 5816} 5817 5818// GoString returns the string representation 5819func (s PolicyAttributeTypeDescription) GoString() string { 5820 return s.String() 5821} 5822 5823// SetAttributeName sets the AttributeName field's value. 5824func (s *PolicyAttributeTypeDescription) SetAttributeName(v string) *PolicyAttributeTypeDescription { 5825 s.AttributeName = &v 5826 return s 5827} 5828 5829// SetAttributeType sets the AttributeType field's value. 5830func (s *PolicyAttributeTypeDescription) SetAttributeType(v string) *PolicyAttributeTypeDescription { 5831 s.AttributeType = &v 5832 return s 5833} 5834 5835// SetCardinality sets the Cardinality field's value. 5836func (s *PolicyAttributeTypeDescription) SetCardinality(v string) *PolicyAttributeTypeDescription { 5837 s.Cardinality = &v 5838 return s 5839} 5840 5841// SetDefaultValue sets the DefaultValue field's value. 5842func (s *PolicyAttributeTypeDescription) SetDefaultValue(v string) *PolicyAttributeTypeDescription { 5843 s.DefaultValue = &v 5844 return s 5845} 5846 5847// SetDescription sets the Description field's value. 5848func (s *PolicyAttributeTypeDescription) SetDescription(v string) *PolicyAttributeTypeDescription { 5849 s.Description = &v 5850 return s 5851} 5852 5853// Information about a policy. 5854type PolicyDescription struct { 5855 _ struct{} `type:"structure"` 5856 5857 // The policy attributes. 5858 PolicyAttributeDescriptions []*PolicyAttributeDescription `type:"list"` 5859 5860 // The name of the policy. 5861 PolicyName *string `type:"string"` 5862 5863 // The name of the policy type. 5864 PolicyTypeName *string `type:"string"` 5865} 5866 5867// String returns the string representation 5868func (s PolicyDescription) String() string { 5869 return awsutil.Prettify(s) 5870} 5871 5872// GoString returns the string representation 5873func (s PolicyDescription) GoString() string { 5874 return s.String() 5875} 5876 5877// SetPolicyAttributeDescriptions sets the PolicyAttributeDescriptions field's value. 5878func (s *PolicyDescription) SetPolicyAttributeDescriptions(v []*PolicyAttributeDescription) *PolicyDescription { 5879 s.PolicyAttributeDescriptions = v 5880 return s 5881} 5882 5883// SetPolicyName sets the PolicyName field's value. 5884func (s *PolicyDescription) SetPolicyName(v string) *PolicyDescription { 5885 s.PolicyName = &v 5886 return s 5887} 5888 5889// SetPolicyTypeName sets the PolicyTypeName field's value. 5890func (s *PolicyDescription) SetPolicyTypeName(v string) *PolicyDescription { 5891 s.PolicyTypeName = &v 5892 return s 5893} 5894 5895// Information about a policy type. 5896type PolicyTypeDescription struct { 5897 _ struct{} `type:"structure"` 5898 5899 // A description of the policy type. 5900 Description *string `type:"string"` 5901 5902 // The description of the policy attributes associated with the policies defined 5903 // by Elastic Load Balancing. 5904 PolicyAttributeTypeDescriptions []*PolicyAttributeTypeDescription `type:"list"` 5905 5906 // The name of the policy type. 5907 PolicyTypeName *string `type:"string"` 5908} 5909 5910// String returns the string representation 5911func (s PolicyTypeDescription) String() string { 5912 return awsutil.Prettify(s) 5913} 5914 5915// GoString returns the string representation 5916func (s PolicyTypeDescription) GoString() string { 5917 return s.String() 5918} 5919 5920// SetDescription sets the Description field's value. 5921func (s *PolicyTypeDescription) SetDescription(v string) *PolicyTypeDescription { 5922 s.Description = &v 5923 return s 5924} 5925 5926// SetPolicyAttributeTypeDescriptions sets the PolicyAttributeTypeDescriptions field's value. 5927func (s *PolicyTypeDescription) SetPolicyAttributeTypeDescriptions(v []*PolicyAttributeTypeDescription) *PolicyTypeDescription { 5928 s.PolicyAttributeTypeDescriptions = v 5929 return s 5930} 5931 5932// SetPolicyTypeName sets the PolicyTypeName field's value. 5933func (s *PolicyTypeDescription) SetPolicyTypeName(v string) *PolicyTypeDescription { 5934 s.PolicyTypeName = &v 5935 return s 5936} 5937 5938// Contains the parameters for RegisterInstancesWithLoadBalancer. 5939type RegisterInstancesWithLoadBalancerInput struct { 5940 _ struct{} `type:"structure"` 5941 5942 // The IDs of the instances. 5943 // 5944 // Instances is a required field 5945 Instances []*Instance `type:"list" required:"true"` 5946 5947 // The name of the load balancer. 5948 // 5949 // LoadBalancerName is a required field 5950 LoadBalancerName *string `type:"string" required:"true"` 5951} 5952 5953// String returns the string representation 5954func (s RegisterInstancesWithLoadBalancerInput) String() string { 5955 return awsutil.Prettify(s) 5956} 5957 5958// GoString returns the string representation 5959func (s RegisterInstancesWithLoadBalancerInput) GoString() string { 5960 return s.String() 5961} 5962 5963// Validate inspects the fields of the type to determine if they are valid. 5964func (s *RegisterInstancesWithLoadBalancerInput) Validate() error { 5965 invalidParams := request.ErrInvalidParams{Context: "RegisterInstancesWithLoadBalancerInput"} 5966 if s.Instances == nil { 5967 invalidParams.Add(request.NewErrParamRequired("Instances")) 5968 } 5969 if s.LoadBalancerName == nil { 5970 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 5971 } 5972 5973 if invalidParams.Len() > 0 { 5974 return invalidParams 5975 } 5976 return nil 5977} 5978 5979// SetInstances sets the Instances field's value. 5980func (s *RegisterInstancesWithLoadBalancerInput) SetInstances(v []*Instance) *RegisterInstancesWithLoadBalancerInput { 5981 s.Instances = v 5982 return s 5983} 5984 5985// SetLoadBalancerName sets the LoadBalancerName field's value. 5986func (s *RegisterInstancesWithLoadBalancerInput) SetLoadBalancerName(v string) *RegisterInstancesWithLoadBalancerInput { 5987 s.LoadBalancerName = &v 5988 return s 5989} 5990 5991// Contains the output of RegisterInstancesWithLoadBalancer. 5992type RegisterInstancesWithLoadBalancerOutput struct { 5993 _ struct{} `type:"structure"` 5994 5995 // The updated list of instances for the load balancer. 5996 Instances []*Instance `type:"list"` 5997} 5998 5999// String returns the string representation 6000func (s RegisterInstancesWithLoadBalancerOutput) String() string { 6001 return awsutil.Prettify(s) 6002} 6003 6004// GoString returns the string representation 6005func (s RegisterInstancesWithLoadBalancerOutput) GoString() string { 6006 return s.String() 6007} 6008 6009// SetInstances sets the Instances field's value. 6010func (s *RegisterInstancesWithLoadBalancerOutput) SetInstances(v []*Instance) *RegisterInstancesWithLoadBalancerOutput { 6011 s.Instances = v 6012 return s 6013} 6014 6015// Contains the parameters for RemoveTags. 6016type RemoveTagsInput struct { 6017 _ struct{} `type:"structure"` 6018 6019 // The name of the load balancer. You can specify a maximum of one load balancer 6020 // name. 6021 // 6022 // LoadBalancerNames is a required field 6023 LoadBalancerNames []*string `type:"list" required:"true"` 6024 6025 // The list of tag keys to remove. 6026 // 6027 // Tags is a required field 6028 Tags []*TagKeyOnly `min:"1" type:"list" required:"true"` 6029} 6030 6031// String returns the string representation 6032func (s RemoveTagsInput) String() string { 6033 return awsutil.Prettify(s) 6034} 6035 6036// GoString returns the string representation 6037func (s RemoveTagsInput) GoString() string { 6038 return s.String() 6039} 6040 6041// Validate inspects the fields of the type to determine if they are valid. 6042func (s *RemoveTagsInput) Validate() error { 6043 invalidParams := request.ErrInvalidParams{Context: "RemoveTagsInput"} 6044 if s.LoadBalancerNames == nil { 6045 invalidParams.Add(request.NewErrParamRequired("LoadBalancerNames")) 6046 } 6047 if s.Tags == nil { 6048 invalidParams.Add(request.NewErrParamRequired("Tags")) 6049 } 6050 if s.Tags != nil && len(s.Tags) < 1 { 6051 invalidParams.Add(request.NewErrParamMinLen("Tags", 1)) 6052 } 6053 if s.Tags != nil { 6054 for i, v := range s.Tags { 6055 if v == nil { 6056 continue 6057 } 6058 if err := v.Validate(); err != nil { 6059 invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams)) 6060 } 6061 } 6062 } 6063 6064 if invalidParams.Len() > 0 { 6065 return invalidParams 6066 } 6067 return nil 6068} 6069 6070// SetLoadBalancerNames sets the LoadBalancerNames field's value. 6071func (s *RemoveTagsInput) SetLoadBalancerNames(v []*string) *RemoveTagsInput { 6072 s.LoadBalancerNames = v 6073 return s 6074} 6075 6076// SetTags sets the Tags field's value. 6077func (s *RemoveTagsInput) SetTags(v []*TagKeyOnly) *RemoveTagsInput { 6078 s.Tags = v 6079 return s 6080} 6081 6082// Contains the output of RemoveTags. 6083type RemoveTagsOutput struct { 6084 _ struct{} `type:"structure"` 6085} 6086 6087// String returns the string representation 6088func (s RemoveTagsOutput) String() string { 6089 return awsutil.Prettify(s) 6090} 6091 6092// GoString returns the string representation 6093func (s RemoveTagsOutput) GoString() string { 6094 return s.String() 6095} 6096 6097// Contains the parameters for SetLoadBalancerListenerSSLCertificate. 6098type SetLoadBalancerListenerSSLCertificateInput struct { 6099 _ struct{} `type:"structure"` 6100 6101 // The name of the load balancer. 6102 // 6103 // LoadBalancerName is a required field 6104 LoadBalancerName *string `type:"string" required:"true"` 6105 6106 // The port that uses the specified SSL certificate. 6107 // 6108 // LoadBalancerPort is a required field 6109 LoadBalancerPort *int64 `type:"integer" required:"true"` 6110 6111 // The Amazon Resource Name (ARN) of the SSL certificate. 6112 // 6113 // SSLCertificateId is a required field 6114 SSLCertificateId *string `type:"string" required:"true"` 6115} 6116 6117// String returns the string representation 6118func (s SetLoadBalancerListenerSSLCertificateInput) String() string { 6119 return awsutil.Prettify(s) 6120} 6121 6122// GoString returns the string representation 6123func (s SetLoadBalancerListenerSSLCertificateInput) GoString() string { 6124 return s.String() 6125} 6126 6127// Validate inspects the fields of the type to determine if they are valid. 6128func (s *SetLoadBalancerListenerSSLCertificateInput) Validate() error { 6129 invalidParams := request.ErrInvalidParams{Context: "SetLoadBalancerListenerSSLCertificateInput"} 6130 if s.LoadBalancerName == nil { 6131 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 6132 } 6133 if s.LoadBalancerPort == nil { 6134 invalidParams.Add(request.NewErrParamRequired("LoadBalancerPort")) 6135 } 6136 if s.SSLCertificateId == nil { 6137 invalidParams.Add(request.NewErrParamRequired("SSLCertificateId")) 6138 } 6139 6140 if invalidParams.Len() > 0 { 6141 return invalidParams 6142 } 6143 return nil 6144} 6145 6146// SetLoadBalancerName sets the LoadBalancerName field's value. 6147func (s *SetLoadBalancerListenerSSLCertificateInput) SetLoadBalancerName(v string) *SetLoadBalancerListenerSSLCertificateInput { 6148 s.LoadBalancerName = &v 6149 return s 6150} 6151 6152// SetLoadBalancerPort sets the LoadBalancerPort field's value. 6153func (s *SetLoadBalancerListenerSSLCertificateInput) SetLoadBalancerPort(v int64) *SetLoadBalancerListenerSSLCertificateInput { 6154 s.LoadBalancerPort = &v 6155 return s 6156} 6157 6158// SetSSLCertificateId sets the SSLCertificateId field's value. 6159func (s *SetLoadBalancerListenerSSLCertificateInput) SetSSLCertificateId(v string) *SetLoadBalancerListenerSSLCertificateInput { 6160 s.SSLCertificateId = &v 6161 return s 6162} 6163 6164// Contains the output of SetLoadBalancerListenerSSLCertificate. 6165type SetLoadBalancerListenerSSLCertificateOutput struct { 6166 _ struct{} `type:"structure"` 6167} 6168 6169// String returns the string representation 6170func (s SetLoadBalancerListenerSSLCertificateOutput) String() string { 6171 return awsutil.Prettify(s) 6172} 6173 6174// GoString returns the string representation 6175func (s SetLoadBalancerListenerSSLCertificateOutput) GoString() string { 6176 return s.String() 6177} 6178 6179// Contains the parameters for SetLoadBalancerPoliciesForBackendServer. 6180type SetLoadBalancerPoliciesForBackendServerInput struct { 6181 _ struct{} `type:"structure"` 6182 6183 // The port number associated with the EC2 instance. 6184 // 6185 // InstancePort is a required field 6186 InstancePort *int64 `type:"integer" required:"true"` 6187 6188 // The name of the load balancer. 6189 // 6190 // LoadBalancerName is a required field 6191 LoadBalancerName *string `type:"string" required:"true"` 6192 6193 // The names of the policies. If the list is empty, then all current polices 6194 // are removed from the EC2 instance. 6195 // 6196 // PolicyNames is a required field 6197 PolicyNames []*string `type:"list" required:"true"` 6198} 6199 6200// String returns the string representation 6201func (s SetLoadBalancerPoliciesForBackendServerInput) String() string { 6202 return awsutil.Prettify(s) 6203} 6204 6205// GoString returns the string representation 6206func (s SetLoadBalancerPoliciesForBackendServerInput) GoString() string { 6207 return s.String() 6208} 6209 6210// Validate inspects the fields of the type to determine if they are valid. 6211func (s *SetLoadBalancerPoliciesForBackendServerInput) Validate() error { 6212 invalidParams := request.ErrInvalidParams{Context: "SetLoadBalancerPoliciesForBackendServerInput"} 6213 if s.InstancePort == nil { 6214 invalidParams.Add(request.NewErrParamRequired("InstancePort")) 6215 } 6216 if s.LoadBalancerName == nil { 6217 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 6218 } 6219 if s.PolicyNames == nil { 6220 invalidParams.Add(request.NewErrParamRequired("PolicyNames")) 6221 } 6222 6223 if invalidParams.Len() > 0 { 6224 return invalidParams 6225 } 6226 return nil 6227} 6228 6229// SetInstancePort sets the InstancePort field's value. 6230func (s *SetLoadBalancerPoliciesForBackendServerInput) SetInstancePort(v int64) *SetLoadBalancerPoliciesForBackendServerInput { 6231 s.InstancePort = &v 6232 return s 6233} 6234 6235// SetLoadBalancerName sets the LoadBalancerName field's value. 6236func (s *SetLoadBalancerPoliciesForBackendServerInput) SetLoadBalancerName(v string) *SetLoadBalancerPoliciesForBackendServerInput { 6237 s.LoadBalancerName = &v 6238 return s 6239} 6240 6241// SetPolicyNames sets the PolicyNames field's value. 6242func (s *SetLoadBalancerPoliciesForBackendServerInput) SetPolicyNames(v []*string) *SetLoadBalancerPoliciesForBackendServerInput { 6243 s.PolicyNames = v 6244 return s 6245} 6246 6247// Contains the output of SetLoadBalancerPoliciesForBackendServer. 6248type SetLoadBalancerPoliciesForBackendServerOutput struct { 6249 _ struct{} `type:"structure"` 6250} 6251 6252// String returns the string representation 6253func (s SetLoadBalancerPoliciesForBackendServerOutput) String() string { 6254 return awsutil.Prettify(s) 6255} 6256 6257// GoString returns the string representation 6258func (s SetLoadBalancerPoliciesForBackendServerOutput) GoString() string { 6259 return s.String() 6260} 6261 6262// Contains the parameters for SetLoadBalancePoliciesOfListener. 6263type SetLoadBalancerPoliciesOfListenerInput struct { 6264 _ struct{} `type:"structure"` 6265 6266 // The name of the load balancer. 6267 // 6268 // LoadBalancerName is a required field 6269 LoadBalancerName *string `type:"string" required:"true"` 6270 6271 // The external port of the load balancer. 6272 // 6273 // LoadBalancerPort is a required field 6274 LoadBalancerPort *int64 `type:"integer" required:"true"` 6275 6276 // The names of the policies. This list must include all policies to be enabled. 6277 // If you omit a policy that is currently enabled, it is disabled. If the list 6278 // is empty, all current policies are disabled. 6279 // 6280 // PolicyNames is a required field 6281 PolicyNames []*string `type:"list" required:"true"` 6282} 6283 6284// String returns the string representation 6285func (s SetLoadBalancerPoliciesOfListenerInput) String() string { 6286 return awsutil.Prettify(s) 6287} 6288 6289// GoString returns the string representation 6290func (s SetLoadBalancerPoliciesOfListenerInput) GoString() string { 6291 return s.String() 6292} 6293 6294// Validate inspects the fields of the type to determine if they are valid. 6295func (s *SetLoadBalancerPoliciesOfListenerInput) Validate() error { 6296 invalidParams := request.ErrInvalidParams{Context: "SetLoadBalancerPoliciesOfListenerInput"} 6297 if s.LoadBalancerName == nil { 6298 invalidParams.Add(request.NewErrParamRequired("LoadBalancerName")) 6299 } 6300 if s.LoadBalancerPort == nil { 6301 invalidParams.Add(request.NewErrParamRequired("LoadBalancerPort")) 6302 } 6303 if s.PolicyNames == nil { 6304 invalidParams.Add(request.NewErrParamRequired("PolicyNames")) 6305 } 6306 6307 if invalidParams.Len() > 0 { 6308 return invalidParams 6309 } 6310 return nil 6311} 6312 6313// SetLoadBalancerName sets the LoadBalancerName field's value. 6314func (s *SetLoadBalancerPoliciesOfListenerInput) SetLoadBalancerName(v string) *SetLoadBalancerPoliciesOfListenerInput { 6315 s.LoadBalancerName = &v 6316 return s 6317} 6318 6319// SetLoadBalancerPort sets the LoadBalancerPort field's value. 6320func (s *SetLoadBalancerPoliciesOfListenerInput) SetLoadBalancerPort(v int64) *SetLoadBalancerPoliciesOfListenerInput { 6321 s.LoadBalancerPort = &v 6322 return s 6323} 6324 6325// SetPolicyNames sets the PolicyNames field's value. 6326func (s *SetLoadBalancerPoliciesOfListenerInput) SetPolicyNames(v []*string) *SetLoadBalancerPoliciesOfListenerInput { 6327 s.PolicyNames = v 6328 return s 6329} 6330 6331// Contains the output of SetLoadBalancePoliciesOfListener. 6332type SetLoadBalancerPoliciesOfListenerOutput struct { 6333 _ struct{} `type:"structure"` 6334} 6335 6336// String returns the string representation 6337func (s SetLoadBalancerPoliciesOfListenerOutput) String() string { 6338 return awsutil.Prettify(s) 6339} 6340 6341// GoString returns the string representation 6342func (s SetLoadBalancerPoliciesOfListenerOutput) GoString() string { 6343 return s.String() 6344} 6345 6346// Information about a source security group. 6347type SourceSecurityGroup struct { 6348 _ struct{} `type:"structure"` 6349 6350 // The name of the security group. 6351 GroupName *string `type:"string"` 6352 6353 // The owner of the security group. 6354 OwnerAlias *string `type:"string"` 6355} 6356 6357// String returns the string representation 6358func (s SourceSecurityGroup) String() string { 6359 return awsutil.Prettify(s) 6360} 6361 6362// GoString returns the string representation 6363func (s SourceSecurityGroup) GoString() string { 6364 return s.String() 6365} 6366 6367// SetGroupName sets the GroupName field's value. 6368func (s *SourceSecurityGroup) SetGroupName(v string) *SourceSecurityGroup { 6369 s.GroupName = &v 6370 return s 6371} 6372 6373// SetOwnerAlias sets the OwnerAlias field's value. 6374func (s *SourceSecurityGroup) SetOwnerAlias(v string) *SourceSecurityGroup { 6375 s.OwnerAlias = &v 6376 return s 6377} 6378 6379// Information about a tag. 6380type Tag struct { 6381 _ struct{} `type:"structure"` 6382 6383 // The key of the tag. 6384 // 6385 // Key is a required field 6386 Key *string `min:"1" type:"string" required:"true"` 6387 6388 // The value of the tag. 6389 Value *string `type:"string"` 6390} 6391 6392// String returns the string representation 6393func (s Tag) String() string { 6394 return awsutil.Prettify(s) 6395} 6396 6397// GoString returns the string representation 6398func (s Tag) GoString() string { 6399 return s.String() 6400} 6401 6402// Validate inspects the fields of the type to determine if they are valid. 6403func (s *Tag) Validate() error { 6404 invalidParams := request.ErrInvalidParams{Context: "Tag"} 6405 if s.Key == nil { 6406 invalidParams.Add(request.NewErrParamRequired("Key")) 6407 } 6408 if s.Key != nil && len(*s.Key) < 1 { 6409 invalidParams.Add(request.NewErrParamMinLen("Key", 1)) 6410 } 6411 6412 if invalidParams.Len() > 0 { 6413 return invalidParams 6414 } 6415 return nil 6416} 6417 6418// SetKey sets the Key field's value. 6419func (s *Tag) SetKey(v string) *Tag { 6420 s.Key = &v 6421 return s 6422} 6423 6424// SetValue sets the Value field's value. 6425func (s *Tag) SetValue(v string) *Tag { 6426 s.Value = &v 6427 return s 6428} 6429 6430// The tags associated with a load balancer. 6431type TagDescription struct { 6432 _ struct{} `type:"structure"` 6433 6434 // The name of the load balancer. 6435 LoadBalancerName *string `type:"string"` 6436 6437 // The tags. 6438 Tags []*Tag `min:"1" type:"list"` 6439} 6440 6441// String returns the string representation 6442func (s TagDescription) String() string { 6443 return awsutil.Prettify(s) 6444} 6445 6446// GoString returns the string representation 6447func (s TagDescription) GoString() string { 6448 return s.String() 6449} 6450 6451// SetLoadBalancerName sets the LoadBalancerName field's value. 6452func (s *TagDescription) SetLoadBalancerName(v string) *TagDescription { 6453 s.LoadBalancerName = &v 6454 return s 6455} 6456 6457// SetTags sets the Tags field's value. 6458func (s *TagDescription) SetTags(v []*Tag) *TagDescription { 6459 s.Tags = v 6460 return s 6461} 6462 6463// The key of a tag. 6464type TagKeyOnly struct { 6465 _ struct{} `type:"structure"` 6466 6467 // The name of the key. 6468 Key *string `min:"1" type:"string"` 6469} 6470 6471// String returns the string representation 6472func (s TagKeyOnly) String() string { 6473 return awsutil.Prettify(s) 6474} 6475 6476// GoString returns the string representation 6477func (s TagKeyOnly) GoString() string { 6478 return s.String() 6479} 6480 6481// Validate inspects the fields of the type to determine if they are valid. 6482func (s *TagKeyOnly) Validate() error { 6483 invalidParams := request.ErrInvalidParams{Context: "TagKeyOnly"} 6484 if s.Key != nil && len(*s.Key) < 1 { 6485 invalidParams.Add(request.NewErrParamMinLen("Key", 1)) 6486 } 6487 6488 if invalidParams.Len() > 0 { 6489 return invalidParams 6490 } 6491 return nil 6492} 6493 6494// SetKey sets the Key field's value. 6495func (s *TagKeyOnly) SetKey(v string) *TagKeyOnly { 6496 s.Key = &v 6497 return s 6498} 6499