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