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