/*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
/*
* Do not modify this file. This file is generated from the elasticloadbalancing-2012-06-01.normal.json service model.
*/
using System;
using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Net;
using Amazon.ElasticLoadBalancing.Model;
using Amazon.ElasticLoadBalancing.Model.Internal.MarshallTransformations;
using Amazon.ElasticLoadBalancing.Internal;
using Amazon.Runtime;
using Amazon.Runtime.Internal;
using Amazon.Runtime.Internal.Auth;
using Amazon.Runtime.Internal.Transform;
namespace Amazon.ElasticLoadBalancing
{
///
/// Implementation for accessing ElasticLoadBalancing
///
/// Elastic Load Balancing
///
/// A load balancer can distribute incoming traffic across your EC2 instances. This enables
/// you to increase the availability of your application. The load balancer also monitors
/// the health of its registered instances and ensures that it routes traffic only to
/// healthy instances. You configure your load balancer to accept incoming traffic by
/// specifying one or more listeners, which are configured with a protocol and port number
/// for connections from clients to the load balancer and a protocol and port number for
/// connections from the load balancer to the instances.
///
///
///
/// Elastic Load Balancing supports three types of load balancers: Application Load Balancers,
/// Network Load Balancers, and Classic Load Balancers. You can select a load balancer
/// based on your application needs. For more information, see the Elastic
/// Load Balancing User Guide.
///
///
///
/// This reference covers the 2012-06-01 API, which supports Classic Load Balancers. The
/// 2015-12-01 API supports Application Load Balancers and Network Load Balancers.
///
///
///
/// To get started, create a load balancer with one or more listeners using CreateLoadBalancer.
/// Register your instances with the load balancer using RegisterInstancesWithLoadBalancer.
///
///
///
/// All Elastic Load Balancing operations are idempotent, which means that they
/// complete at most one time. If you repeat an operation, it succeeds with a 200 OK response
/// code.
///
///
public partial class AmazonElasticLoadBalancingClient : AmazonServiceClient, IAmazonElasticLoadBalancing
{
private static IServiceMetadata serviceMetadata = new AmazonElasticLoadBalancingMetadata();
#region Constructors
///
/// Constructs AmazonElasticLoadBalancingClient with the credentials loaded from the application's
/// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance.
///
/// Example App.config with credentials set.
///
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="AWSProfileName" value="AWS Default"/>
/// </appSettings>
/// </configuration>
///
///
///
public AmazonElasticLoadBalancingClient()
: base(FallbackCredentialsFactory.GetCredentials(), new AmazonElasticLoadBalancingConfig()) { }
///
/// Constructs AmazonElasticLoadBalancingClient with the credentials loaded from the application's
/// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance.
///
/// Example App.config with credentials set.
///
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="AWSProfileName" value="AWS Default"/>
/// </appSettings>
/// </configuration>
///
///
///
/// The region to connect.
public AmazonElasticLoadBalancingClient(RegionEndpoint region)
: base(FallbackCredentialsFactory.GetCredentials(), new AmazonElasticLoadBalancingConfig{RegionEndpoint = region}) { }
///
/// Constructs AmazonElasticLoadBalancingClient with the credentials loaded from the application's
/// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance.
///
/// Example App.config with credentials set.
///
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="AWSProfileName" value="AWS Default"/>
/// </appSettings>
/// </configuration>
///
///
///
/// The AmazonElasticLoadBalancingClient Configuration Object
public AmazonElasticLoadBalancingClient(AmazonElasticLoadBalancingConfig config)
: base(FallbackCredentialsFactory.GetCredentials(config), config){}
///
/// Constructs AmazonElasticLoadBalancingClient with AWS Credentials
///
/// AWS Credentials
public AmazonElasticLoadBalancingClient(AWSCredentials credentials)
: this(credentials, new AmazonElasticLoadBalancingConfig())
{
}
///
/// Constructs AmazonElasticLoadBalancingClient with AWS Credentials
///
/// AWS Credentials
/// The region to connect.
public AmazonElasticLoadBalancingClient(AWSCredentials credentials, RegionEndpoint region)
: this(credentials, new AmazonElasticLoadBalancingConfig{RegionEndpoint = region})
{
}
///
/// Constructs AmazonElasticLoadBalancingClient with AWS Credentials and an
/// AmazonElasticLoadBalancingClient Configuration object.
///
/// AWS Credentials
/// The AmazonElasticLoadBalancingClient Configuration Object
public AmazonElasticLoadBalancingClient(AWSCredentials credentials, AmazonElasticLoadBalancingConfig clientConfig)
: base(credentials, clientConfig)
{
}
///
/// Constructs AmazonElasticLoadBalancingClient with AWS Access Key ID and AWS Secret Key
///
/// AWS Access Key ID
/// AWS Secret Access Key
public AmazonElasticLoadBalancingClient(string awsAccessKeyId, string awsSecretAccessKey)
: this(awsAccessKeyId, awsSecretAccessKey, new AmazonElasticLoadBalancingConfig())
{
}
///
/// Constructs AmazonElasticLoadBalancingClient with AWS Access Key ID and AWS Secret Key
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// The region to connect.
public AmazonElasticLoadBalancingClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region)
: this(awsAccessKeyId, awsSecretAccessKey, new AmazonElasticLoadBalancingConfig() {RegionEndpoint=region})
{
}
///
/// Constructs AmazonElasticLoadBalancingClient with AWS Access Key ID, AWS Secret Key and an
/// AmazonElasticLoadBalancingClient Configuration object.
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// The AmazonElasticLoadBalancingClient Configuration Object
public AmazonElasticLoadBalancingClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonElasticLoadBalancingConfig clientConfig)
: base(awsAccessKeyId, awsSecretAccessKey, clientConfig)
{
}
///
/// Constructs AmazonElasticLoadBalancingClient with AWS Access Key ID and AWS Secret Key
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// AWS Session Token
public AmazonElasticLoadBalancingClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken)
: this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonElasticLoadBalancingConfig())
{
}
///
/// Constructs AmazonElasticLoadBalancingClient with AWS Access Key ID and AWS Secret Key
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// AWS Session Token
/// The region to connect.
public AmazonElasticLoadBalancingClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region)
: this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonElasticLoadBalancingConfig{RegionEndpoint = region})
{
}
///
/// Constructs AmazonElasticLoadBalancingClient with AWS Access Key ID, AWS Secret Key and an
/// AmazonElasticLoadBalancingClient Configuration object.
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// AWS Session Token
/// The AmazonElasticLoadBalancingClient Configuration Object
public AmazonElasticLoadBalancingClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonElasticLoadBalancingConfig clientConfig)
: base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig)
{
}
#endregion
#if AWS_ASYNC_ENUMERABLES_API
private IElasticLoadBalancingPaginatorFactory _paginators;
///
/// Paginators for the service
///
public IElasticLoadBalancingPaginatorFactory Paginators
{
get
{
if (this._paginators == null)
{
this._paginators = new ElasticLoadBalancingPaginatorFactory(this);
}
return this._paginators;
}
}
#endif
#region Overrides
///
/// Creates the signer for the service.
///
protected override AbstractAWSSigner CreateSigner()
{
return new AWS4Signer();
}
///
/// Customizes the runtime pipeline.
///
/// Runtime pipeline for the current client.
protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline)
{
pipeline.AddHandlerAfter(new Amazon.ElasticLoadBalancing.Internal.ProcessRequestHandler());
pipeline.RemoveHandler();
pipeline.AddHandlerAfter(new AmazonElasticLoadBalancingEndpointResolver());
}
///
/// Capture metadata for the service.
///
protected override IServiceMetadata ServiceMetadata
{
get
{
return serviceMetadata;
}
}
#endregion
#region Dispose
///
/// Disposes the service client.
///
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
}
#endregion
#region AddTags
internal virtual AddTagsResponse AddTags(AddTagsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = AddTagsRequestMarshaller.Instance;
options.ResponseUnmarshaller = AddTagsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Adds the specified tags to the specified load balancer. Each load balancer can have
/// a maximum of 10 tags.
///
///
///
/// Each tag consists of a key and an optional value. If a tag with the same key is already
/// associated with the load balancer, AddTags updates its value.
///
///
///
/// For more information, see Tag
/// Your Classic Load Balancer in the Classic Load Balancers Guide.
///
///
/// Container for the necessary parameters to execute the AddTags service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the AddTags service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// A tag key was specified more than once.
///
///
/// The quota for the number of tags that can be assigned to a load balancer has been
/// reached.
///
/// REST API Reference for AddTags Operation
public virtual Task AddTagsAsync(AddTagsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = AddTagsRequestMarshaller.Instance;
options.ResponseUnmarshaller = AddTagsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region ApplySecurityGroupsToLoadBalancer
internal virtual ApplySecurityGroupsToLoadBalancerResponse ApplySecurityGroupsToLoadBalancer(ApplySecurityGroupsToLoadBalancerRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ApplySecurityGroupsToLoadBalancerRequestMarshaller.Instance;
options.ResponseUnmarshaller = ApplySecurityGroupsToLoadBalancerResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Associates one or more security groups with your load balancer in a virtual private
/// cloud (VPC). The specified security groups override the previously associated security
/// groups.
///
///
///
/// For more information, see Security
/// Groups for Load Balancers in a VPC in the Classic Load Balancers Guide.
///
///
/// Container for the necessary parameters to execute the ApplySecurityGroupsToLoadBalancer service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the ApplySecurityGroupsToLoadBalancer service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// The requested configuration change is not valid.
///
///
/// One or more of the specified security groups do not exist.
///
/// REST API Reference for ApplySecurityGroupsToLoadBalancer Operation
public virtual Task ApplySecurityGroupsToLoadBalancerAsync(ApplySecurityGroupsToLoadBalancerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = ApplySecurityGroupsToLoadBalancerRequestMarshaller.Instance;
options.ResponseUnmarshaller = ApplySecurityGroupsToLoadBalancerResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region AttachLoadBalancerToSubnets
internal virtual AttachLoadBalancerToSubnetsResponse AttachLoadBalancerToSubnets(AttachLoadBalancerToSubnetsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = AttachLoadBalancerToSubnetsRequestMarshaller.Instance;
options.ResponseUnmarshaller = AttachLoadBalancerToSubnetsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Adds one or more subnets to the set of configured subnets for the specified load balancer.
///
///
///
/// The load balancer evenly distributes requests across all registered subnets. For more
/// information, see Add
/// or Remove Subnets for Your Load Balancer in a VPC in the Classic Load Balancers
/// Guide.
///
///
/// Container for the necessary parameters to execute the AttachLoadBalancerToSubnets service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the AttachLoadBalancerToSubnets service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// The requested configuration change is not valid.
///
///
/// The specified VPC has no associated Internet gateway.
///
///
/// One or more of the specified subnets do not exist.
///
/// REST API Reference for AttachLoadBalancerToSubnets Operation
public virtual Task AttachLoadBalancerToSubnetsAsync(AttachLoadBalancerToSubnetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = AttachLoadBalancerToSubnetsRequestMarshaller.Instance;
options.ResponseUnmarshaller = AttachLoadBalancerToSubnetsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region ConfigureHealthCheck
internal virtual ConfigureHealthCheckResponse ConfigureHealthCheck(ConfigureHealthCheckRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ConfigureHealthCheckRequestMarshaller.Instance;
options.ResponseUnmarshaller = ConfigureHealthCheckResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Specifies the health check settings to use when evaluating the health state of your
/// EC2 instances.
///
///
///
/// For more information, see Configure
/// Health Checks for Your Load Balancer in the Classic Load Balancers Guide.
///
///
/// Container for the necessary parameters to execute the ConfigureHealthCheck service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the ConfigureHealthCheck service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
/// REST API Reference for ConfigureHealthCheck Operation
public virtual Task ConfigureHealthCheckAsync(ConfigureHealthCheckRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = ConfigureHealthCheckRequestMarshaller.Instance;
options.ResponseUnmarshaller = ConfigureHealthCheckResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region CreateAppCookieStickinessPolicy
internal virtual CreateAppCookieStickinessPolicyResponse CreateAppCookieStickinessPolicy(CreateAppCookieStickinessPolicyRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateAppCookieStickinessPolicyRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateAppCookieStickinessPolicyResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Generates a stickiness policy with sticky session lifetimes that follow that of an
/// application-generated cookie. This policy can be associated only with HTTP/HTTPS listeners.
///
///
///
/// This policy is similar to the policy created by CreateLBCookieStickinessPolicy,
/// except that the lifetime of the special Elastic Load Balancing cookie, AWSELB,
/// follows the lifetime of the application-generated cookie specified in the policy configuration.
/// The load balancer only inserts a new stickiness cookie when the application response
/// includes a new application cookie.
///
///
///
/// If the application cookie is explicitly removed or expires, the session stops being
/// sticky until a new application cookie is issued.
///
///
///
/// For more information, see Application-Controlled
/// Session Stickiness in the Classic Load Balancers Guide.
///
///
/// Container for the necessary parameters to execute the CreateAppCookieStickinessPolicy service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the CreateAppCookieStickinessPolicy service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// A policy with the specified name already exists for this load balancer.
///
///
/// The requested configuration change is not valid.
///
///
/// The quota for the number of policies for this load balancer has been reached.
///
/// REST API Reference for CreateAppCookieStickinessPolicy Operation
public virtual Task CreateAppCookieStickinessPolicyAsync(CreateAppCookieStickinessPolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateAppCookieStickinessPolicyRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateAppCookieStickinessPolicyResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region CreateLBCookieStickinessPolicy
internal virtual CreateLBCookieStickinessPolicyResponse CreateLBCookieStickinessPolicy(CreateLBCookieStickinessPolicyRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateLBCookieStickinessPolicyRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateLBCookieStickinessPolicyResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Generates a stickiness policy with sticky session lifetimes controlled by the lifetime
/// of the browser (user-agent) or a specified expiration period. This policy can be associated
/// only with HTTP/HTTPS listeners.
///
///
///
/// When a load balancer implements this policy, the load balancer uses a special cookie
/// to track the instance for each request. When the load balancer receives a request,
/// it first checks to see if this cookie is present in the request. If so, the load balancer
/// sends the request to the application server specified in the cookie. If not, the load
/// balancer sends the request to a server that is chosen based on the existing load-balancing
/// algorithm.
///
///
///
/// A cookie is inserted into the response for binding subsequent requests from the same
/// user to that server. The validity of the cookie is based on the cookie expiration
/// time, which is specified in the policy configuration.
///
///
///
/// For more information, see Duration-Based
/// Session Stickiness in the Classic Load Balancers Guide.
///
///
/// Container for the necessary parameters to execute the CreateLBCookieStickinessPolicy service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the CreateLBCookieStickinessPolicy service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// A policy with the specified name already exists for this load balancer.
///
///
/// The requested configuration change is not valid.
///
///
/// The quota for the number of policies for this load balancer has been reached.
///
/// REST API Reference for CreateLBCookieStickinessPolicy Operation
public virtual Task CreateLBCookieStickinessPolicyAsync(CreateLBCookieStickinessPolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateLBCookieStickinessPolicyRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateLBCookieStickinessPolicyResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region CreateLoadBalancer
internal virtual CreateLoadBalancerResponse CreateLoadBalancer(CreateLoadBalancerRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateLoadBalancerRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateLoadBalancerResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Creates a Classic Load Balancer.
///
///
///
/// You can add listeners, security groups, subnets, and tags when you create your load
/// balancer, or you can add them later using CreateLoadBalancerListeners, ApplySecurityGroupsToLoadBalancer,
/// AttachLoadBalancerToSubnets, and AddTags.
///
///
///
/// To describe your current load balancers, see DescribeLoadBalancers. When you
/// are finished with a load balancer, you can delete it using DeleteLoadBalancer.
///
///
///
/// You can create up to 20 load balancers per region per account. You can request an
/// increase for the number of load balancers for your account. For more information,
/// see Limits
/// for Your Classic Load Balancer in the Classic Load Balancers Guide.
///
///
/// Container for the necessary parameters to execute the CreateLoadBalancer service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the CreateLoadBalancer service method, as returned by ElasticLoadBalancing.
///
/// The specified ARN does not refer to a valid SSL certificate in AWS Identity and Access
/// Management (IAM) or AWS Certificate Manager (ACM). Note that if you recently uploaded
/// the certificate to IAM, this error might indicate that the certificate is not fully
/// available yet.
///
///
/// The specified load balancer name already exists for this account.
///
///
/// A tag key was specified more than once.
///
///
/// The requested configuration change is not valid.
///
///
/// The specified value for the schema is not valid. You can only specify a scheme for
/// load balancers in a VPC.
///
///
/// One or more of the specified security groups do not exist.
///
///
/// The specified VPC has no associated Internet gateway.
///
///
/// This operation is not allowed.
///
///
/// One or more of the specified subnets do not exist.
///
///
/// The quota for the number of load balancers has been reached.
///
///
/// The quota for the number of tags that can be assigned to a load balancer has been
/// reached.
///
///
/// The specified protocol or signature version is not supported.
///
/// REST API Reference for CreateLoadBalancer Operation
public virtual Task CreateLoadBalancerAsync(CreateLoadBalancerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateLoadBalancerRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateLoadBalancerResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region CreateLoadBalancerListeners
internal virtual CreateLoadBalancerListenersResponse CreateLoadBalancerListeners(CreateLoadBalancerListenersRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateLoadBalancerListenersRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateLoadBalancerListenersResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Creates one or more listeners for the specified load balancer. If a listener with
/// the specified port does not already exist, it is created; otherwise, the properties
/// of the new listener must match the properties of the existing listener.
///
///
///
/// For more information, see Listeners
/// for Your Classic Load Balancer in the Classic Load Balancers Guide.
///
///
/// Container for the necessary parameters to execute the CreateLoadBalancerListeners service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the CreateLoadBalancerListeners service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// The specified ARN does not refer to a valid SSL certificate in AWS Identity and Access
/// Management (IAM) or AWS Certificate Manager (ACM). Note that if you recently uploaded
/// the certificate to IAM, this error might indicate that the certificate is not fully
/// available yet.
///
///
/// A listener already exists for the specified load balancer name and port, but with
/// a different instance port, protocol, or SSL certificate.
///
///
/// The requested configuration change is not valid.
///
///
/// The specified protocol or signature version is not supported.
///
/// REST API Reference for CreateLoadBalancerListeners Operation
public virtual Task CreateLoadBalancerListenersAsync(CreateLoadBalancerListenersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateLoadBalancerListenersRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateLoadBalancerListenersResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region CreateLoadBalancerPolicy
internal virtual CreateLoadBalancerPolicyResponse CreateLoadBalancerPolicy(CreateLoadBalancerPolicyRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateLoadBalancerPolicyRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateLoadBalancerPolicyResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Creates a policy with the specified attributes for the specified load balancer.
///
///
///
/// Policies are settings that are saved for your load balancer and that can be applied
/// to the listener or the application server, depending on the policy type.
///
///
/// Container for the necessary parameters to execute the CreateLoadBalancerPolicy service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the CreateLoadBalancerPolicy service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// A policy with the specified name already exists for this load balancer.
///
///
/// The requested configuration change is not valid.
///
///
/// One or more of the specified policy types do not exist.
///
///
/// The quota for the number of policies for this load balancer has been reached.
///
/// REST API Reference for CreateLoadBalancerPolicy Operation
public virtual Task CreateLoadBalancerPolicyAsync(CreateLoadBalancerPolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateLoadBalancerPolicyRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateLoadBalancerPolicyResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteLoadBalancer
internal virtual DeleteLoadBalancerResponse DeleteLoadBalancer(DeleteLoadBalancerRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteLoadBalancerRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteLoadBalancerResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Deletes the specified load balancer.
///
///
///
/// If you are attempting to recreate a load balancer, you must reconfigure all settings.
/// The DNS name associated with a deleted load balancer are no longer usable. The name
/// and associated DNS record of the deleted load balancer no longer exist and traffic
/// sent to any of its IP addresses is no longer delivered to your instances.
///
///
///
/// If the load balancer does not exist or has already been deleted, the call to DeleteLoadBalancer
/// still succeeds.
///
///
/// Container for the necessary parameters to execute the DeleteLoadBalancer service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteLoadBalancer service method, as returned by ElasticLoadBalancing.
/// REST API Reference for DeleteLoadBalancer Operation
public virtual Task DeleteLoadBalancerAsync(DeleteLoadBalancerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteLoadBalancerRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteLoadBalancerResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteLoadBalancerListeners
internal virtual DeleteLoadBalancerListenersResponse DeleteLoadBalancerListeners(DeleteLoadBalancerListenersRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteLoadBalancerListenersRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteLoadBalancerListenersResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Deletes the specified listeners from the specified load balancer.
///
/// Container for the necessary parameters to execute the DeleteLoadBalancerListeners service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteLoadBalancerListeners service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
/// REST API Reference for DeleteLoadBalancerListeners Operation
public virtual Task DeleteLoadBalancerListenersAsync(DeleteLoadBalancerListenersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteLoadBalancerListenersRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteLoadBalancerListenersResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteLoadBalancerPolicy
internal virtual DeleteLoadBalancerPolicyResponse DeleteLoadBalancerPolicy(DeleteLoadBalancerPolicyRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteLoadBalancerPolicyRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteLoadBalancerPolicyResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Deletes the specified policy from the specified load balancer. This policy must not
/// be enabled for any listeners.
///
/// Container for the necessary parameters to execute the DeleteLoadBalancerPolicy service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteLoadBalancerPolicy service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// The requested configuration change is not valid.
///
/// REST API Reference for DeleteLoadBalancerPolicy Operation
public virtual Task DeleteLoadBalancerPolicyAsync(DeleteLoadBalancerPolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteLoadBalancerPolicyRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteLoadBalancerPolicyResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeregisterInstancesFromLoadBalancer
internal virtual DeregisterInstancesFromLoadBalancerResponse DeregisterInstancesFromLoadBalancer(DeregisterInstancesFromLoadBalancerRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeregisterInstancesFromLoadBalancerRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeregisterInstancesFromLoadBalancerResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Deregisters the specified instances from the specified load balancer. After the instance
/// is deregistered, it no longer receives traffic from the load balancer.
///
///
///
/// You can use DescribeLoadBalancers to verify that the instance is deregistered
/// from the load balancer.
///
///
///
/// For more information, see Register
/// or De-Register EC2 Instances in the Classic Load Balancers Guide.
///
///
/// Container for the necessary parameters to execute the DeregisterInstancesFromLoadBalancer service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeregisterInstancesFromLoadBalancer service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// The specified endpoint is not valid.
///
/// REST API Reference for DeregisterInstancesFromLoadBalancer Operation
public virtual Task DeregisterInstancesFromLoadBalancerAsync(DeregisterInstancesFromLoadBalancerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeregisterInstancesFromLoadBalancerRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeregisterInstancesFromLoadBalancerResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DescribeAccountLimits
internal virtual DescribeAccountLimitsResponse DescribeAccountLimits(DescribeAccountLimitsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeAccountLimitsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeAccountLimitsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Describes the current Elastic Load Balancing resource limits for your AWS account.
///
///
///
/// For more information, see Limits
/// for Your Classic Load Balancer in the Classic Load Balancers Guide.
///
///
/// Container for the necessary parameters to execute the DescribeAccountLimits service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeAccountLimits service method, as returned by ElasticLoadBalancing.
/// REST API Reference for DescribeAccountLimits Operation
public virtual Task DescribeAccountLimitsAsync(DescribeAccountLimitsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeAccountLimitsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeAccountLimitsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DescribeInstanceHealth
internal virtual DescribeInstanceHealthResponse DescribeInstanceHealth(DescribeInstanceHealthRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeInstanceHealthRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeInstanceHealthResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Describes the state of the specified instances with respect to the specified load
/// balancer. If no instances are specified, the call describes the state of all instances
/// that are currently registered with the load balancer. If instances are specified,
/// their state is returned even if they are no longer registered with the load balancer.
/// The state of terminated instances is not returned.
///
/// Container for the necessary parameters to execute the DescribeInstanceHealth service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeInstanceHealth service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// The specified endpoint is not valid.
///
/// REST API Reference for DescribeInstanceHealth Operation
public virtual Task DescribeInstanceHealthAsync(DescribeInstanceHealthRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeInstanceHealthRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeInstanceHealthResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DescribeLoadBalancerAttributes
internal virtual DescribeLoadBalancerAttributesResponse DescribeLoadBalancerAttributes(DescribeLoadBalancerAttributesRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeLoadBalancerAttributesRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeLoadBalancerAttributesResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Describes the attributes for the specified load balancer.
///
/// Container for the necessary parameters to execute the DescribeLoadBalancerAttributes service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeLoadBalancerAttributes service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// The specified load balancer attribute does not exist.
///
/// REST API Reference for DescribeLoadBalancerAttributes Operation
public virtual Task DescribeLoadBalancerAttributesAsync(DescribeLoadBalancerAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeLoadBalancerAttributesRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeLoadBalancerAttributesResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DescribeLoadBalancerPolicies
internal virtual DescribeLoadBalancerPoliciesResponse DescribeLoadBalancerPolicies()
{
return DescribeLoadBalancerPolicies(new DescribeLoadBalancerPoliciesRequest());
}
internal virtual DescribeLoadBalancerPoliciesResponse DescribeLoadBalancerPolicies(DescribeLoadBalancerPoliciesRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeLoadBalancerPoliciesRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeLoadBalancerPoliciesResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Describes the specified policies.
///
///
///
/// If you specify a load balancer name, the action returns the descriptions of all policies
/// created for the load balancer. If you specify a policy name associated with your load
/// balancer, the action returns the description of that policy. If you don't specify
/// a load balancer name, the action returns descriptions of the specified sample policies,
/// or descriptions of all sample policies. The names of the sample policies have the
/// ELBSample- prefix.
///
///
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeLoadBalancerPolicies service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// One or more of the specified policies do not exist.
///
/// REST API Reference for DescribeLoadBalancerPolicies Operation
public virtual Task DescribeLoadBalancerPoliciesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
return DescribeLoadBalancerPoliciesAsync(new DescribeLoadBalancerPoliciesRequest(), cancellationToken);
}
///
/// Describes the specified policies.
///
///
///
/// If you specify a load balancer name, the action returns the descriptions of all policies
/// created for the load balancer. If you specify a policy name associated with your load
/// balancer, the action returns the description of that policy. If you don't specify
/// a load balancer name, the action returns descriptions of the specified sample policies,
/// or descriptions of all sample policies. The names of the sample policies have the
/// ELBSample- prefix.
///
///
/// Container for the necessary parameters to execute the DescribeLoadBalancerPolicies service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeLoadBalancerPolicies service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// One or more of the specified policies do not exist.
///
/// REST API Reference for DescribeLoadBalancerPolicies Operation
public virtual Task DescribeLoadBalancerPoliciesAsync(DescribeLoadBalancerPoliciesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeLoadBalancerPoliciesRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeLoadBalancerPoliciesResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DescribeLoadBalancerPolicyTypes
internal virtual DescribeLoadBalancerPolicyTypesResponse DescribeLoadBalancerPolicyTypes()
{
return DescribeLoadBalancerPolicyTypes(new DescribeLoadBalancerPolicyTypesRequest());
}
internal virtual DescribeLoadBalancerPolicyTypesResponse DescribeLoadBalancerPolicyTypes(DescribeLoadBalancerPolicyTypesRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeLoadBalancerPolicyTypesRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeLoadBalancerPolicyTypesResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Describes the specified load balancer policy types or all load balancer policy types.
///
///
///
/// The description of each type indicates how it can be used. For example, some policies
/// can be used only with layer 7 listeners, some policies can be used only with layer
/// 4 listeners, and some policies can be used only with your EC2 instances.
///
///
///
/// You can use CreateLoadBalancerPolicy to create a policy configuration for any
/// of these policy types. Then, depending on the policy type, use either SetLoadBalancerPoliciesOfListener
/// or SetLoadBalancerPoliciesForBackendServer to set the policy.
///
///
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeLoadBalancerPolicyTypes service method, as returned by ElasticLoadBalancing.
///
/// One or more of the specified policy types do not exist.
///
/// REST API Reference for DescribeLoadBalancerPolicyTypes Operation
public virtual Task DescribeLoadBalancerPolicyTypesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
return DescribeLoadBalancerPolicyTypesAsync(new DescribeLoadBalancerPolicyTypesRequest(), cancellationToken);
}
///
/// Describes the specified load balancer policy types or all load balancer policy types.
///
///
///
/// The description of each type indicates how it can be used. For example, some policies
/// can be used only with layer 7 listeners, some policies can be used only with layer
/// 4 listeners, and some policies can be used only with your EC2 instances.
///
///
///
/// You can use CreateLoadBalancerPolicy to create a policy configuration for any
/// of these policy types. Then, depending on the policy type, use either SetLoadBalancerPoliciesOfListener
/// or SetLoadBalancerPoliciesForBackendServer to set the policy.
///
///
/// Container for the necessary parameters to execute the DescribeLoadBalancerPolicyTypes service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeLoadBalancerPolicyTypes service method, as returned by ElasticLoadBalancing.
///
/// One or more of the specified policy types do not exist.
///
/// REST API Reference for DescribeLoadBalancerPolicyTypes Operation
public virtual Task DescribeLoadBalancerPolicyTypesAsync(DescribeLoadBalancerPolicyTypesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeLoadBalancerPolicyTypesRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeLoadBalancerPolicyTypesResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DescribeLoadBalancers
internal virtual DescribeLoadBalancersResponse DescribeLoadBalancers()
{
return DescribeLoadBalancers(new DescribeLoadBalancersRequest());
}
internal virtual DescribeLoadBalancersResponse DescribeLoadBalancers(DescribeLoadBalancersRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeLoadBalancersRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeLoadBalancersResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Describes the specified the load balancers. If no load balancers are specified, the
/// call describes all of your load balancers.
///
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeLoadBalancers service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// A request made by Elastic Load Balancing to another service exceeds the maximum request
/// rate permitted for your account.
///
/// REST API Reference for DescribeLoadBalancers Operation
public virtual Task DescribeLoadBalancersAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
return DescribeLoadBalancersAsync(new DescribeLoadBalancersRequest(), cancellationToken);
}
///
/// Describes the specified the load balancers. If no load balancers are specified, the
/// call describes all of your load balancers.
///
/// Container for the necessary parameters to execute the DescribeLoadBalancers service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeLoadBalancers service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// A request made by Elastic Load Balancing to another service exceeds the maximum request
/// rate permitted for your account.
///
/// REST API Reference for DescribeLoadBalancers Operation
public virtual Task DescribeLoadBalancersAsync(DescribeLoadBalancersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeLoadBalancersRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeLoadBalancersResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DescribeTags
internal virtual DescribeTagsResponse DescribeTags(DescribeTagsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeTagsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeTagsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Describes the tags associated with the specified load balancers.
///
/// Container for the necessary parameters to execute the DescribeTags service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeTags service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
/// REST API Reference for DescribeTags Operation
public virtual Task DescribeTagsAsync(DescribeTagsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeTagsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeTagsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DetachLoadBalancerFromSubnets
internal virtual DetachLoadBalancerFromSubnetsResponse DetachLoadBalancerFromSubnets(DetachLoadBalancerFromSubnetsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DetachLoadBalancerFromSubnetsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DetachLoadBalancerFromSubnetsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Removes the specified subnets from the set of configured subnets for the load balancer.
///
///
///
/// After a subnet is removed, all EC2 instances registered with the load balancer in
/// the removed subnet go into the OutOfService state. Then, the load balancer
/// balances the traffic among the remaining routable subnets.
///
///
/// Container for the necessary parameters to execute the DetachLoadBalancerFromSubnets service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DetachLoadBalancerFromSubnets service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// The requested configuration change is not valid.
///
/// REST API Reference for DetachLoadBalancerFromSubnets Operation
public virtual Task DetachLoadBalancerFromSubnetsAsync(DetachLoadBalancerFromSubnetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DetachLoadBalancerFromSubnetsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DetachLoadBalancerFromSubnetsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DisableAvailabilityZonesForLoadBalancer
internal virtual DisableAvailabilityZonesForLoadBalancerResponse DisableAvailabilityZonesForLoadBalancer(DisableAvailabilityZonesForLoadBalancerRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DisableAvailabilityZonesForLoadBalancerRequestMarshaller.Instance;
options.ResponseUnmarshaller = DisableAvailabilityZonesForLoadBalancerResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Removes the specified Availability Zones from the set of Availability Zones for the
/// specified load balancer in EC2-Classic or a default VPC.
///
///
///
/// For load balancers in a non-default VPC, use DetachLoadBalancerFromSubnets.
///
///
///
/// There must be at least one Availability Zone registered with a load balancer at all
/// times. After an Availability Zone is removed, all instances registered with the load
/// balancer that are in the removed Availability Zone go into the OutOfService
/// state. Then, the load balancer attempts to equally balance the traffic among its remaining
/// Availability Zones.
///
///
///
/// For more information, see Add
/// or Remove Availability Zones in the Classic Load Balancers Guide.
///
///
/// Container for the necessary parameters to execute the DisableAvailabilityZonesForLoadBalancer service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DisableAvailabilityZonesForLoadBalancer service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// The requested configuration change is not valid.
///
/// REST API Reference for DisableAvailabilityZonesForLoadBalancer Operation
public virtual Task DisableAvailabilityZonesForLoadBalancerAsync(DisableAvailabilityZonesForLoadBalancerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DisableAvailabilityZonesForLoadBalancerRequestMarshaller.Instance;
options.ResponseUnmarshaller = DisableAvailabilityZonesForLoadBalancerResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region EnableAvailabilityZonesForLoadBalancer
internal virtual EnableAvailabilityZonesForLoadBalancerResponse EnableAvailabilityZonesForLoadBalancer(EnableAvailabilityZonesForLoadBalancerRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = EnableAvailabilityZonesForLoadBalancerRequestMarshaller.Instance;
options.ResponseUnmarshaller = EnableAvailabilityZonesForLoadBalancerResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Adds the specified Availability Zones to the set of Availability Zones for the specified
/// load balancer in EC2-Classic or a default VPC.
///
///
///
/// For load balancers in a non-default VPC, use AttachLoadBalancerToSubnets.
///
///
///
/// The load balancer evenly distributes requests across all its registered Availability
/// Zones that contain instances. For more information, see Add
/// or Remove Availability Zones in the Classic Load Balancers Guide.
///
///
/// Container for the necessary parameters to execute the EnableAvailabilityZonesForLoadBalancer service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the EnableAvailabilityZonesForLoadBalancer service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
/// REST API Reference for EnableAvailabilityZonesForLoadBalancer Operation
public virtual Task EnableAvailabilityZonesForLoadBalancerAsync(EnableAvailabilityZonesForLoadBalancerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = EnableAvailabilityZonesForLoadBalancerRequestMarshaller.Instance;
options.ResponseUnmarshaller = EnableAvailabilityZonesForLoadBalancerResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region ModifyLoadBalancerAttributes
internal virtual ModifyLoadBalancerAttributesResponse ModifyLoadBalancerAttributes(ModifyLoadBalancerAttributesRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ModifyLoadBalancerAttributesRequestMarshaller.Instance;
options.ResponseUnmarshaller = ModifyLoadBalancerAttributesResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Modifies the attributes of the specified load balancer.
///
///
///
/// You can modify the load balancer attributes, such as AccessLogs, ConnectionDraining,
/// and CrossZoneLoadBalancing by either enabling or disabling them. Or,
/// you can modify the load balancer attribute ConnectionSettings by specifying
/// an idle connection timeout value for your load balancer.
///
///
///
/// For more information, see the following in the Classic Load Balancers Guide:
///
///
///
/// Container for the necessary parameters to execute the ModifyLoadBalancerAttributes service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the ModifyLoadBalancerAttributes service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// The requested configuration change is not valid.
///
///
/// The specified load balancer attribute does not exist.
///
/// REST API Reference for ModifyLoadBalancerAttributes Operation
public virtual Task ModifyLoadBalancerAttributesAsync(ModifyLoadBalancerAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = ModifyLoadBalancerAttributesRequestMarshaller.Instance;
options.ResponseUnmarshaller = ModifyLoadBalancerAttributesResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region RegisterInstancesWithLoadBalancer
internal virtual RegisterInstancesWithLoadBalancerResponse RegisterInstancesWithLoadBalancer(RegisterInstancesWithLoadBalancerRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = RegisterInstancesWithLoadBalancerRequestMarshaller.Instance;
options.ResponseUnmarshaller = RegisterInstancesWithLoadBalancerResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Adds the specified instances to the specified load balancer.
///
///
///
/// The instance must be a running instance in the same network as the load balancer (EC2-Classic
/// or the same VPC). If you have EC2-Classic instances and a load balancer in a VPC with
/// ClassicLink enabled, you can link the EC2-Classic instances to that VPC and then register
/// the linked EC2-Classic instances with the load balancer in the VPC.
///
///
///
/// Note that RegisterInstanceWithLoadBalancer completes when the request
/// has been registered. Instance registration takes a little time to complete. To check
/// the state of the registered instances, use DescribeLoadBalancers or DescribeInstanceHealth.
///
///
///
/// After the instance is registered, it starts receiving traffic and requests from the
/// load balancer. Any instance that is not in one of the Availability Zones registered
/// for the load balancer is moved to the OutOfService state. If an Availability
/// Zone is added to the load balancer later, any instances registered with the load balancer
/// move to the InService state.
///
///
///
/// To deregister instances from a load balancer, use DeregisterInstancesFromLoadBalancer.
///
///
///
/// For more information, see Register
/// or De-Register EC2 Instances in the Classic Load Balancers Guide.
///
///
/// Container for the necessary parameters to execute the RegisterInstancesWithLoadBalancer service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the RegisterInstancesWithLoadBalancer service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// The specified endpoint is not valid.
///
/// REST API Reference for RegisterInstancesWithLoadBalancer Operation
public virtual Task RegisterInstancesWithLoadBalancerAsync(RegisterInstancesWithLoadBalancerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = RegisterInstancesWithLoadBalancerRequestMarshaller.Instance;
options.ResponseUnmarshaller = RegisterInstancesWithLoadBalancerResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region RemoveTags
internal virtual RemoveTagsResponse RemoveTags(RemoveTagsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = RemoveTagsRequestMarshaller.Instance;
options.ResponseUnmarshaller = RemoveTagsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Removes one or more tags from the specified load balancer.
///
/// Container for the necessary parameters to execute the RemoveTags service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the RemoveTags service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
/// REST API Reference for RemoveTags Operation
public virtual Task RemoveTagsAsync(RemoveTagsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = RemoveTagsRequestMarshaller.Instance;
options.ResponseUnmarshaller = RemoveTagsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region SetLoadBalancerListenerSSLCertificate
internal virtual SetLoadBalancerListenerSSLCertificateResponse SetLoadBalancerListenerSSLCertificate(SetLoadBalancerListenerSSLCertificateRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = SetLoadBalancerListenerSSLCertificateRequestMarshaller.Instance;
options.ResponseUnmarshaller = SetLoadBalancerListenerSSLCertificateResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Sets the certificate that terminates the specified listener's SSL connections. The
/// specified certificate replaces any prior certificate that was used on the same load
/// balancer and port.
///
///
///
/// For more information about updating your SSL certificate, see Replace
/// the SSL Certificate for Your Load Balancer in the Classic Load Balancers Guide.
///
///
/// Container for the necessary parameters to execute the SetLoadBalancerListenerSSLCertificate service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the SetLoadBalancerListenerSSLCertificate service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// The specified ARN does not refer to a valid SSL certificate in AWS Identity and Access
/// Management (IAM) or AWS Certificate Manager (ACM). Note that if you recently uploaded
/// the certificate to IAM, this error might indicate that the certificate is not fully
/// available yet.
///
///
/// The requested configuration change is not valid.
///
///
/// The load balancer does not have a listener configured at the specified port.
///
///
/// The specified protocol or signature version is not supported.
///
/// REST API Reference for SetLoadBalancerListenerSSLCertificate Operation
public virtual Task SetLoadBalancerListenerSSLCertificateAsync(SetLoadBalancerListenerSSLCertificateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = SetLoadBalancerListenerSSLCertificateRequestMarshaller.Instance;
options.ResponseUnmarshaller = SetLoadBalancerListenerSSLCertificateResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region SetLoadBalancerPoliciesForBackendServer
internal virtual SetLoadBalancerPoliciesForBackendServerResponse SetLoadBalancerPoliciesForBackendServer(SetLoadBalancerPoliciesForBackendServerRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = SetLoadBalancerPoliciesForBackendServerRequestMarshaller.Instance;
options.ResponseUnmarshaller = SetLoadBalancerPoliciesForBackendServerResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Replaces the set of policies associated with the specified port on which the EC2 instance
/// is listening with a new set of policies. At this time, only the back-end server authentication
/// policy type can be applied to the instance ports; this policy type is composed of
/// multiple public key policies.
///
///
///
/// Each time you use SetLoadBalancerPoliciesForBackendServer to enable the
/// policies, use the PolicyNames parameter to list the policies that you
/// want to enable.
///
///
///
/// You can use DescribeLoadBalancers or DescribeLoadBalancerPolicies to
/// verify that the policy is associated with the EC2 instance.
///
///
///
/// For more information about enabling back-end instance authentication, see Configure
/// Back-end Instance Authentication in the Classic Load Balancers Guide. For
/// more information about Proxy Protocol, see Configure
/// Proxy Protocol Support in the Classic Load Balancers Guide.
///
///
/// Container for the necessary parameters to execute the SetLoadBalancerPoliciesForBackendServer service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the SetLoadBalancerPoliciesForBackendServer service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// The requested configuration change is not valid.
///
///
/// One or more of the specified policies do not exist.
///
/// REST API Reference for SetLoadBalancerPoliciesForBackendServer Operation
public virtual Task SetLoadBalancerPoliciesForBackendServerAsync(SetLoadBalancerPoliciesForBackendServerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = SetLoadBalancerPoliciesForBackendServerRequestMarshaller.Instance;
options.ResponseUnmarshaller = SetLoadBalancerPoliciesForBackendServerResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region SetLoadBalancerPoliciesOfListener
internal virtual SetLoadBalancerPoliciesOfListenerResponse SetLoadBalancerPoliciesOfListener(SetLoadBalancerPoliciesOfListenerRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = SetLoadBalancerPoliciesOfListenerRequestMarshaller.Instance;
options.ResponseUnmarshaller = SetLoadBalancerPoliciesOfListenerResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Replaces the current set of policies for the specified load balancer port with the
/// specified set of policies.
///
///
///
/// To enable back-end server authentication, use SetLoadBalancerPoliciesForBackendServer.
///
///
///
/// For more information about setting policies, see Update
/// the SSL Negotiation Configuration, Duration-Based
/// Session Stickiness, and Application-Controlled
/// Session Stickiness in the Classic Load Balancers Guide.
///
///
/// Container for the necessary parameters to execute the SetLoadBalancerPoliciesOfListener service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the SetLoadBalancerPoliciesOfListener service method, as returned by ElasticLoadBalancing.
///
/// The specified load balancer does not exist.
///
///
/// The requested configuration change is not valid.
///
///
/// The load balancer does not have a listener configured at the specified port.
///
///
/// One or more of the specified policies do not exist.
///
/// REST API Reference for SetLoadBalancerPoliciesOfListener Operation
public virtual Task SetLoadBalancerPoliciesOfListenerAsync(SetLoadBalancerPoliciesOfListenerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = SetLoadBalancerPoliciesOfListenerRequestMarshaller.Instance;
options.ResponseUnmarshaller = SetLoadBalancerPoliciesOfListenerResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
}
}