/* * 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 elasticloadbalancingv2-2015-12-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.ElasticLoadBalancingV2.Model; using Amazon.ElasticLoadBalancingV2.Model.Internal.MarshallTransformations; using Amazon.ElasticLoadBalancingV2.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.ElasticLoadBalancingV2 { /// /// Implementation for accessing ElasticLoadBalancingV2 /// /// Elastic Load Balancing /// /// A load balancer distributes incoming traffic across targets, such as your EC2 instances. /// This enables you to increase the availability of your application. The load balancer /// also monitors the health of its registered targets and ensures that it routes traffic /// only to healthy targets. 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. You configure a target group /// with a protocol and port number for connections from the load balancer to the targets, /// and with health check settings to be used when checking the health status of the targets. /// /// /// /// Elastic Load Balancing supports the following types of load balancers: Application /// Load Balancers, Network Load Balancers, Gateway Load Balancers, and Classic Load Balancers. /// This reference covers the following load balancer types: /// /// /// /// For more information, see the Elastic /// Load Balancing User Guide. /// /// /// /// All Elastic Load Balancing operations are idempotent, which means that they complete /// at most one time. If you repeat an operation, it succeeds. /// /// public partial class AmazonElasticLoadBalancingV2Client : AmazonServiceClient, IAmazonElasticLoadBalancingV2 { private static IServiceMetadata serviceMetadata = new AmazonElasticLoadBalancingV2Metadata(); #region Constructors /// /// Constructs AmazonElasticLoadBalancingV2Client 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 AmazonElasticLoadBalancingV2Client() : base(FallbackCredentialsFactory.GetCredentials(), new AmazonElasticLoadBalancingV2Config()) { } /// /// Constructs AmazonElasticLoadBalancingV2Client 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 AmazonElasticLoadBalancingV2Client(RegionEndpoint region) : base(FallbackCredentialsFactory.GetCredentials(), new AmazonElasticLoadBalancingV2Config{RegionEndpoint = region}) { } /// /// Constructs AmazonElasticLoadBalancingV2Client 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 AmazonElasticLoadBalancingV2Client Configuration Object public AmazonElasticLoadBalancingV2Client(AmazonElasticLoadBalancingV2Config config) : base(FallbackCredentialsFactory.GetCredentials(config), config){} /// /// Constructs AmazonElasticLoadBalancingV2Client with AWS Credentials /// /// AWS Credentials public AmazonElasticLoadBalancingV2Client(AWSCredentials credentials) : this(credentials, new AmazonElasticLoadBalancingV2Config()) { } /// /// Constructs AmazonElasticLoadBalancingV2Client with AWS Credentials /// /// AWS Credentials /// The region to connect. public AmazonElasticLoadBalancingV2Client(AWSCredentials credentials, RegionEndpoint region) : this(credentials, new AmazonElasticLoadBalancingV2Config{RegionEndpoint = region}) { } /// /// Constructs AmazonElasticLoadBalancingV2Client with AWS Credentials and an /// AmazonElasticLoadBalancingV2Client Configuration object. /// /// AWS Credentials /// The AmazonElasticLoadBalancingV2Client Configuration Object public AmazonElasticLoadBalancingV2Client(AWSCredentials credentials, AmazonElasticLoadBalancingV2Config clientConfig) : base(credentials, clientConfig) { } /// /// Constructs AmazonElasticLoadBalancingV2Client with AWS Access Key ID and AWS Secret Key /// /// AWS Access Key ID /// AWS Secret Access Key public AmazonElasticLoadBalancingV2Client(string awsAccessKeyId, string awsSecretAccessKey) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonElasticLoadBalancingV2Config()) { } /// /// Constructs AmazonElasticLoadBalancingV2Client with AWS Access Key ID and AWS Secret Key /// /// AWS Access Key ID /// AWS Secret Access Key /// The region to connect. public AmazonElasticLoadBalancingV2Client(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonElasticLoadBalancingV2Config() {RegionEndpoint=region}) { } /// /// Constructs AmazonElasticLoadBalancingV2Client with AWS Access Key ID, AWS Secret Key and an /// AmazonElasticLoadBalancingV2Client Configuration object. /// /// AWS Access Key ID /// AWS Secret Access Key /// The AmazonElasticLoadBalancingV2Client Configuration Object public AmazonElasticLoadBalancingV2Client(string awsAccessKeyId, string awsSecretAccessKey, AmazonElasticLoadBalancingV2Config clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, clientConfig) { } /// /// Constructs AmazonElasticLoadBalancingV2Client with AWS Access Key ID and AWS Secret Key /// /// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token public AmazonElasticLoadBalancingV2Client(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonElasticLoadBalancingV2Config()) { } /// /// Constructs AmazonElasticLoadBalancingV2Client 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 AmazonElasticLoadBalancingV2Client(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonElasticLoadBalancingV2Config{RegionEndpoint = region}) { } /// /// Constructs AmazonElasticLoadBalancingV2Client with AWS Access Key ID, AWS Secret Key and an /// AmazonElasticLoadBalancingV2Client Configuration object. /// /// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The AmazonElasticLoadBalancingV2Client Configuration Object public AmazonElasticLoadBalancingV2Client(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonElasticLoadBalancingV2Config clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig) { } #endregion #if AWS_ASYNC_ENUMERABLES_API private IElasticLoadBalancingV2PaginatorFactory _paginators; /// /// Paginators for the service /// public IElasticLoadBalancingV2PaginatorFactory Paginators { get { if (this._paginators == null) { this._paginators = new ElasticLoadBalancingV2PaginatorFactory(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.RemoveHandler(); pipeline.AddHandlerAfter(new AmazonElasticLoadBalancingV2EndpointResolver()); } /// /// 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 AddListenerCertificates internal virtual AddListenerCertificatesResponse AddListenerCertificates(AddListenerCertificatesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AddListenerCertificatesRequestMarshaller.Instance; options.ResponseUnmarshaller = AddListenerCertificatesResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Adds the specified SSL server certificate to the certificate list for the specified /// HTTPS or TLS listener. /// /// /// /// If the certificate in already in the certificate list, the call is successful but /// the certificate is not added again. /// /// /// /// For more information, see HTTPS /// listeners in the Application Load Balancers Guide or TLS /// listeners in the Network Load Balancers Guide. /// /// /// Container for the necessary parameters to execute the AddListenerCertificates service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AddListenerCertificates service method, as returned by ElasticLoadBalancingV2. /// /// The specified certificate does not exist. /// /// /// The specified listener does not exist. /// /// /// You've reached the limit on the number of certificates per load balancer. /// /// REST API Reference for AddListenerCertificates Operation public virtual Task AddListenerCertificatesAsync(AddListenerCertificatesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AddListenerCertificatesRequestMarshaller.Instance; options.ResponseUnmarshaller = AddListenerCertificatesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #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 Elastic Load Balancing resource. You can /// tag your Application Load Balancers, Network Load Balancers, Gateway Load Balancers, /// target groups, listeners, and rules. /// /// /// /// Each tag consists of a key and an optional value. If a resource already has a tag /// with the same key, AddTags updates its value. /// /// /// 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 ElasticLoadBalancingV2. /// /// A tag key was specified more than once. /// /// /// The specified listener does not exist. /// /// /// The specified load balancer does not exist. /// /// /// The specified rule does not exist. /// /// /// The specified target group does not exist. /// /// /// You've reached the limit on the number of tags per load balancer. /// /// 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 CreateListener internal virtual CreateListenerResponse CreateListener(CreateListenerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateListenerRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateListenerResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Creates a listener for the specified Application Load Balancer, Network Load Balancer, /// or Gateway Load Balancer. /// /// /// /// For more information, see the following: /// /// /// /// This operation is idempotent, which means that it completes at most one time. If you /// attempt to create multiple listeners with the same settings, each call succeeds. /// /// /// Container for the necessary parameters to execute the CreateListener service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateListener service method, as returned by ElasticLoadBalancingV2. /// /// The specified ALPN policy is not supported. /// /// /// The specified certificate does not exist. /// /// /// A listener with the specified port already exists. /// /// /// The specified configuration is not valid with this protocol. /// /// /// The requested configuration is not valid. /// /// /// The requested action is not valid. /// /// /// The specified load balancer does not exist. /// /// /// The specified SSL policy does not exist. /// /// /// You've reached the limit on the number of load balancers per target group. /// /// /// The specified target group does not exist. /// /// /// You've reached the limit on the number of actions per rule. /// /// /// You've reached the limit on the number of certificates per load balancer. /// /// /// You've reached the limit on the number of listeners per load balancer. /// /// /// You've reached the limit on the number of times a target can be registered with a /// load balancer. /// /// /// You've reached the limit on the number of tags per load balancer. /// /// /// You've reached the limit on the number of targets. /// /// /// You've reached the limit on the number of unique target groups per load balancer across /// all listeners. If a target group is used by multiple actions for a load balancer, /// it is counted as only one use. /// /// /// The specified protocol is not supported. /// /// REST API Reference for CreateListener Operation public virtual Task CreateListenerAsync(CreateListenerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateListenerRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateListenerResponseUnmarshaller.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 an Application Load Balancer, Network Load Balancer, or Gateway Load Balancer. /// /// /// /// For more information, see the following: /// /// /// /// This operation is idempotent, which means that it completes at most one time. If you /// attempt to create multiple load balancers with the same settings, each call succeeds. /// /// /// 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 ElasticLoadBalancingV2. /// /// The specified allocation ID does not exist. /// /// /// The specified Availability Zone is not supported. /// /// /// A load balancer with the specified name already exists. /// /// /// A tag key was specified more than once. /// /// /// The requested configuration is not valid. /// /// /// The requested scheme is not valid. /// /// /// The specified security group does not exist. /// /// /// The specified subnet is out of available addresses. /// /// /// This operation is not allowed. /// /// /// A specified resource is in use. /// /// /// The specified subnet does not exist. /// /// /// You've reached the limit on the number of load balancers for your Amazon Web Services /// account. /// /// /// You've reached the limit on the number of tags per load balancer. /// /// 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 CreateRule internal virtual CreateRuleResponse CreateRule(CreateRuleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateRuleResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Creates a rule for the specified listener. The listener must be associated with an /// Application Load Balancer. /// /// /// /// Each rule consists of a priority, one or more actions, and one or more conditions. /// Rules are evaluated in priority order, from the lowest value to the highest value. /// When the conditions for a rule are met, its actions are performed. If the conditions /// for no rules are met, the actions for the default rule are performed. For more information, /// see Listener /// rules in the Application Load Balancers Guide. /// /// /// Container for the necessary parameters to execute the CreateRule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateRule service method, as returned by ElasticLoadBalancingV2. /// /// The specified configuration is not valid with this protocol. /// /// /// The requested configuration is not valid. /// /// /// The requested action is not valid. /// /// /// The specified listener does not exist. /// /// /// The specified priority is in use. /// /// /// You've reached the limit on the number of load balancers per target group. /// /// /// The specified target group does not exist. /// /// /// You've reached the limit on the number of actions per rule. /// /// /// You've reached the limit on the number of times a target can be registered with a /// load balancer. /// /// /// You've reached the limit on the number of rules per load balancer. /// /// /// You've reached the limit on the number of tags per load balancer. /// /// /// You've reached the limit on the number of target groups for your Amazon Web Services /// account. /// /// /// You've reached the limit on the number of targets. /// /// /// You've reached the limit on the number of unique target groups per load balancer across /// all listeners. If a target group is used by multiple actions for a load balancer, /// it is counted as only one use. /// /// /// The specified protocol is not supported. /// /// REST API Reference for CreateRule Operation public virtual Task CreateRuleAsync(CreateRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateRuleResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateTargetGroup internal virtual CreateTargetGroupResponse CreateTargetGroup(CreateTargetGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTargetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTargetGroupResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Creates a target group. /// /// /// /// For more information, see the following: /// /// /// /// This operation is idempotent, which means that it completes at most one time. If you /// attempt to create multiple target groups with the same settings, each call succeeds. /// /// /// Container for the necessary parameters to execute the CreateTargetGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTargetGroup service method, as returned by ElasticLoadBalancingV2. /// /// A target group with the specified name already exists. /// /// /// The requested configuration is not valid. /// /// /// You've reached the limit on the number of tags per load balancer. /// /// /// You've reached the limit on the number of target groups for your Amazon Web Services /// account. /// /// REST API Reference for CreateTargetGroup Operation public virtual Task CreateTargetGroupAsync(CreateTargetGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTargetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTargetGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteListener internal virtual DeleteListenerResponse DeleteListener(DeleteListenerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteListenerRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteListenerResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Deletes the specified listener. /// /// /// /// Alternatively, your listener is deleted when you delete the load balancer to which /// it is attached. /// /// /// Container for the necessary parameters to execute the DeleteListener service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteListener service method, as returned by ElasticLoadBalancingV2. /// /// The specified listener does not exist. /// /// /// A specified resource is in use. /// /// REST API Reference for DeleteListener Operation public virtual Task DeleteListenerAsync(DeleteListenerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteListenerRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteListenerResponseUnmarshaller.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 Application Load Balancer, Network Load Balancer, or Gateway /// Load Balancer. Deleting a load balancer also deletes its listeners. /// /// /// /// You can't delete a load balancer if deletion protection is enabled. If the load balancer /// does not exist or has already been deleted, the call succeeds. /// /// /// /// Deleting a load balancer does not affect its registered targets. For example, your /// EC2 instances continue to run and are still registered to their target groups. If /// you no longer need these EC2 instances, you can stop or terminate them. /// /// /// 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 ElasticLoadBalancingV2. /// /// The specified load balancer does not exist. /// /// /// This operation is not allowed. /// /// /// A specified resource is in use. /// /// 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 DeleteRule internal virtual DeleteRuleResponse DeleteRule(DeleteRuleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteRuleResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Deletes the specified rule. /// /// /// /// You can't delete the default rule. /// /// /// Container for the necessary parameters to execute the DeleteRule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteRule service method, as returned by ElasticLoadBalancingV2. /// /// This operation is not allowed. /// /// /// The specified rule does not exist. /// /// REST API Reference for DeleteRule Operation public virtual Task DeleteRuleAsync(DeleteRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteRuleResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteTargetGroup internal virtual DeleteTargetGroupResponse DeleteTargetGroup(DeleteTargetGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteTargetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteTargetGroupResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Deletes the specified target group. /// /// /// /// You can delete a target group if it is not referenced by any actions. Deleting a target /// group also deletes any associated health checks. Deleting a target group does not /// affect its registered targets. For example, any EC2 instances continue to run until /// you stop or terminate them. /// /// /// Container for the necessary parameters to execute the DeleteTargetGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTargetGroup service method, as returned by ElasticLoadBalancingV2. /// /// A specified resource is in use. /// /// REST API Reference for DeleteTargetGroup Operation public virtual Task DeleteTargetGroupAsync(DeleteTargetGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteTargetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteTargetGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeregisterTargets internal virtual DeregisterTargetsResponse DeregisterTargets(DeregisterTargetsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterTargetsResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Deregisters the specified targets from the specified target group. After the targets /// are deregistered, they no longer receive traffic from the load balancer. /// /// Container for the necessary parameters to execute the DeregisterTargets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeregisterTargets service method, as returned by ElasticLoadBalancingV2. /// /// The specified target does not exist, is not in the same VPC as the target group, or /// has an unsupported instance type. /// /// /// The specified target group does not exist. /// /// REST API Reference for DeregisterTargets Operation public virtual Task DeregisterTargetsAsync(DeregisterTargetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterTargetsResponseUnmarshaller.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 Amazon Web Services /// account. /// /// /// /// For more information, see the following: /// /// /// /// 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 ElasticLoadBalancingV2. /// 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 DescribeListenerCertificates internal virtual DescribeListenerCertificatesResponse DescribeListenerCertificates(DescribeListenerCertificatesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeListenerCertificatesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeListenerCertificatesResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Describes the default certificate and the certificate list for the specified HTTPS /// or TLS listener. /// /// /// /// If the default certificate is also in the certificate list, it appears twice in the /// results (once with IsDefault set to true and once with IsDefault /// set to false). /// /// /// /// For more information, see SSL /// certificates in the Application Load Balancers Guide or Server /// certificates in the Network Load Balancers Guide. /// /// /// Container for the necessary parameters to execute the DescribeListenerCertificates service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeListenerCertificates service method, as returned by ElasticLoadBalancingV2. /// /// The specified listener does not exist. /// /// REST API Reference for DescribeListenerCertificates Operation public virtual Task DescribeListenerCertificatesAsync(DescribeListenerCertificatesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeListenerCertificatesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeListenerCertificatesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeListeners internal virtual DescribeListenersResponse DescribeListeners(DescribeListenersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeListenersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeListenersResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Describes the specified listeners or the listeners for the specified Application Load /// Balancer, Network Load Balancer, or Gateway Load Balancer. You must specify either /// a load balancer or one or more listeners. /// /// Container for the necessary parameters to execute the DescribeListeners service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeListeners service method, as returned by ElasticLoadBalancingV2. /// /// The specified listener does not exist. /// /// /// The specified load balancer does not exist. /// /// /// The specified protocol is not supported. /// /// REST API Reference for DescribeListeners Operation public virtual Task DescribeListenersAsync(DescribeListenersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeListenersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeListenersResponseUnmarshaller.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 Application Load Balancer, Network Load /// Balancer, or Gateway Load Balancer. /// /// /// /// For more information, see the following: /// /// /// /// 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 ElasticLoadBalancingV2. /// /// The specified load balancer 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 DescribeLoadBalancers 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 load balancers or 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 ElasticLoadBalancingV2. /// /// The specified load balancer does not exist. /// /// 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 DescribeRules internal virtual DescribeRulesResponse DescribeRules(DescribeRulesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeRulesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeRulesResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Describes the specified rules or the rules for the specified listener. You must specify /// either a listener or one or more rules. /// /// Container for the necessary parameters to execute the DescribeRules service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeRules service method, as returned by ElasticLoadBalancingV2. /// /// The specified listener does not exist. /// /// /// The specified rule does not exist. /// /// /// The specified protocol is not supported. /// /// REST API Reference for DescribeRules Operation public virtual Task DescribeRulesAsync(DescribeRulesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeRulesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeRulesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeSSLPolicies internal virtual DescribeSSLPoliciesResponse DescribeSSLPolicies(DescribeSSLPoliciesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSSLPoliciesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSSLPoliciesResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Describes the specified policies or all policies used for SSL negotiation. /// /// /// /// For more information, see Security /// policies in the Application Load Balancers Guide or Security /// policies in the Network Load Balancers Guide. /// /// /// Container for the necessary parameters to execute the DescribeSSLPolicies service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSSLPolicies service method, as returned by ElasticLoadBalancingV2. /// /// The specified SSL policy does not exist. /// /// REST API Reference for DescribeSSLPolicies Operation public virtual Task DescribeSSLPoliciesAsync(DescribeSSLPoliciesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSSLPoliciesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSSLPoliciesResponseUnmarshaller.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 for the specified Elastic Load Balancing resources. You can describe /// the tags for one or more Application Load Balancers, Network Load Balancers, Gateway /// Load Balancers, target groups, listeners, or rules. /// /// 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 ElasticLoadBalancingV2. /// /// The specified listener does not exist. /// /// /// The specified load balancer does not exist. /// /// /// The specified rule does not exist. /// /// /// The specified target group 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 DescribeTargetGroupAttributes internal virtual DescribeTargetGroupAttributesResponse DescribeTargetGroupAttributes(DescribeTargetGroupAttributesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeTargetGroupAttributesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeTargetGroupAttributesResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Describes the attributes for the specified target group. /// /// /// /// For more information, see the following: /// /// /// /// Container for the necessary parameters to execute the DescribeTargetGroupAttributes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTargetGroupAttributes service method, as returned by ElasticLoadBalancingV2. /// /// The specified target group does not exist. /// /// REST API Reference for DescribeTargetGroupAttributes Operation public virtual Task DescribeTargetGroupAttributesAsync(DescribeTargetGroupAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeTargetGroupAttributesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeTargetGroupAttributesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeTargetGroups internal virtual DescribeTargetGroupsResponse DescribeTargetGroups(DescribeTargetGroupsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeTargetGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeTargetGroupsResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Describes the specified target groups or all of your target groups. By default, all /// target groups are described. Alternatively, you can specify one of the following to /// filter the results: the ARN of the load balancer, the names of one or more target /// groups, or the ARNs of one or more target groups. /// /// Container for the necessary parameters to execute the DescribeTargetGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTargetGroups service method, as returned by ElasticLoadBalancingV2. /// /// The specified load balancer does not exist. /// /// /// The specified target group does not exist. /// /// REST API Reference for DescribeTargetGroups Operation public virtual Task DescribeTargetGroupsAsync(DescribeTargetGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeTargetGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeTargetGroupsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeTargetHealth internal virtual DescribeTargetHealthResponse DescribeTargetHealth(DescribeTargetHealthRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeTargetHealthRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeTargetHealthResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Describes the health of the specified targets or all of your targets. /// /// Container for the necessary parameters to execute the DescribeTargetHealth service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTargetHealth service method, as returned by ElasticLoadBalancingV2. /// /// The health of the specified targets could not be retrieved due to an internal error. /// /// /// The specified target does not exist, is not in the same VPC as the target group, or /// has an unsupported instance type. /// /// /// The specified target group does not exist. /// /// REST API Reference for DescribeTargetHealth Operation public virtual Task DescribeTargetHealthAsync(DescribeTargetHealthRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeTargetHealthRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeTargetHealthResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyListener internal virtual ModifyListenerResponse ModifyListener(ModifyListenerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyListenerRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyListenerResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Replaces the specified properties of the specified listener. Any properties that you /// do not specify remain unchanged. /// /// /// /// Changing the protocol from HTTPS to HTTP, or from TLS to TCP, removes the security /// policy and default certificate properties. If you change the protocol from HTTP to /// HTTPS, or from TCP to TLS, you must add the security policy and default certificate /// properties. /// /// /// /// To add an item to a list, remove an item from a list, or update an item in a list, /// you must provide the entire list. For example, to add an action, specify a list with /// the current actions plus the new action. /// /// /// Container for the necessary parameters to execute the ModifyListener service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyListener service method, as returned by ElasticLoadBalancingV2. /// /// The specified ALPN policy is not supported. /// /// /// The specified certificate does not exist. /// /// /// A listener with the specified port already exists. /// /// /// The specified configuration is not valid with this protocol. /// /// /// The requested configuration is not valid. /// /// /// The requested action is not valid. /// /// /// The specified listener does not exist. /// /// /// The specified SSL policy does not exist. /// /// /// You've reached the limit on the number of load balancers per target group. /// /// /// The specified target group does not exist. /// /// /// You've reached the limit on the number of actions per rule. /// /// /// You've reached the limit on the number of certificates per load balancer. /// /// /// You've reached the limit on the number of listeners per load balancer. /// /// /// You've reached the limit on the number of times a target can be registered with a /// load balancer. /// /// /// You've reached the limit on the number of targets. /// /// /// You've reached the limit on the number of unique target groups per load balancer across /// all listeners. If a target group is used by multiple actions for a load balancer, /// it is counted as only one use. /// /// /// The specified protocol is not supported. /// /// REST API Reference for ModifyListener Operation public virtual Task ModifyListenerAsync(ModifyListenerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyListenerRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyListenerResponseUnmarshaller.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 specified attributes of the specified Application Load Balancer, Network /// Load Balancer, or Gateway Load Balancer. /// /// /// /// If any of the specified attributes can't be modified as requested, the call fails. /// Any existing attributes that you do not modify retain their current values. /// /// /// 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 ElasticLoadBalancingV2. /// /// The requested configuration is not valid. /// /// /// The specified load balancer 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 ModifyRule internal virtual ModifyRuleResponse ModifyRule(ModifyRuleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyRuleResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Replaces the specified properties of the specified rule. Any properties that you do /// not specify are unchanged. /// /// /// /// To add an item to a list, remove an item from a list, or update an item in a list, /// you must provide the entire list. For example, to add an action, specify a list with /// the current actions plus the new action. /// /// /// Container for the necessary parameters to execute the ModifyRule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyRule service method, as returned by ElasticLoadBalancingV2. /// /// The specified configuration is not valid with this protocol. /// /// /// The requested action is not valid. /// /// /// This operation is not allowed. /// /// /// The specified rule does not exist. /// /// /// You've reached the limit on the number of load balancers per target group. /// /// /// The specified target group does not exist. /// /// /// You've reached the limit on the number of actions per rule. /// /// /// You've reached the limit on the number of times a target can be registered with a /// load balancer. /// /// /// You've reached the limit on the number of targets. /// /// /// You've reached the limit on the number of unique target groups per load balancer across /// all listeners. If a target group is used by multiple actions for a load balancer, /// it is counted as only one use. /// /// /// The specified protocol is not supported. /// /// REST API Reference for ModifyRule Operation public virtual Task ModifyRuleAsync(ModifyRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyRuleResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyTargetGroup internal virtual ModifyTargetGroupResponse ModifyTargetGroup(ModifyTargetGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyTargetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyTargetGroupResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Modifies the health checks used when evaluating the health state of the targets in /// the specified target group. /// /// Container for the necessary parameters to execute the ModifyTargetGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyTargetGroup service method, as returned by ElasticLoadBalancingV2. /// /// The requested configuration is not valid. /// /// /// The specified target group does not exist. /// /// REST API Reference for ModifyTargetGroup Operation public virtual Task ModifyTargetGroupAsync(ModifyTargetGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyTargetGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyTargetGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyTargetGroupAttributes internal virtual ModifyTargetGroupAttributesResponse ModifyTargetGroupAttributes(ModifyTargetGroupAttributesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyTargetGroupAttributesRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyTargetGroupAttributesResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Modifies the specified attributes of the specified target group. /// /// Container for the necessary parameters to execute the ModifyTargetGroupAttributes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyTargetGroupAttributes service method, as returned by ElasticLoadBalancingV2. /// /// The requested configuration is not valid. /// /// /// The specified target group does not exist. /// /// REST API Reference for ModifyTargetGroupAttributes Operation public virtual Task ModifyTargetGroupAttributesAsync(ModifyTargetGroupAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyTargetGroupAttributesRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyTargetGroupAttributesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RegisterTargets internal virtual RegisterTargetsResponse RegisterTargets(RegisterTargetsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterTargetsResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Registers the specified targets with the specified target group. /// /// /// /// If the target is an EC2 instance, it must be in the running state when /// you register it. /// /// /// /// By default, the load balancer routes requests to registered targets using the protocol /// and port for the target group. Alternatively, you can override the port for a target /// when you register it. You can register each EC2 instance or IP address with the same /// target group multiple times using different ports. /// /// /// /// With a Network Load Balancer, you cannot register instances by instance ID if they /// have the following instance types: C1, CC1, CC2, CG1, CG2, CR1, CS1, G1, G2, HI1, /// HS1, M1, M2, M3, and T1. You can register instances of these types by IP address. /// /// /// Container for the necessary parameters to execute the RegisterTargets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RegisterTargets service method, as returned by ElasticLoadBalancingV2. /// /// The specified target does not exist, is not in the same VPC as the target group, or /// has an unsupported instance type. /// /// /// The specified target group does not exist. /// /// /// You've reached the limit on the number of times a target can be registered with a /// load balancer. /// /// /// You've reached the limit on the number of targets. /// /// REST API Reference for RegisterTargets Operation public virtual Task RegisterTargetsAsync(RegisterTargetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterTargetsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RemoveListenerCertificates internal virtual RemoveListenerCertificatesResponse RemoveListenerCertificates(RemoveListenerCertificatesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveListenerCertificatesRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveListenerCertificatesResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Removes the specified certificate from the certificate list for the specified HTTPS /// or TLS listener. /// /// Container for the necessary parameters to execute the RemoveListenerCertificates service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RemoveListenerCertificates service method, as returned by ElasticLoadBalancingV2. /// /// The specified listener does not exist. /// /// /// This operation is not allowed. /// /// REST API Reference for RemoveListenerCertificates Operation public virtual Task RemoveListenerCertificatesAsync(RemoveListenerCertificatesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveListenerCertificatesRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveListenerCertificatesResponseUnmarshaller.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 the specified tags from the specified Elastic Load Balancing resources. You /// can remove the tags for one or more Application Load Balancers, Network Load Balancers, /// Gateway Load Balancers, target groups, listeners, or rules. /// /// 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 ElasticLoadBalancingV2. /// /// The specified listener does not exist. /// /// /// The specified load balancer does not exist. /// /// /// The specified rule does not exist. /// /// /// The specified target group does not exist. /// /// /// You've reached the limit on the number of tags per load balancer. /// /// 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 SetIpAddressType internal virtual SetIpAddressTypeResponse SetIpAddressType(SetIpAddressTypeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = SetIpAddressTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = SetIpAddressTypeResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Sets the type of IP addresses used by the subnets of the specified load balancer. /// /// Container for the necessary parameters to execute the SetIpAddressType service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the SetIpAddressType service method, as returned by ElasticLoadBalancingV2. /// /// The requested configuration is not valid. /// /// /// The specified subnet is out of available addresses. /// /// /// The specified load balancer does not exist. /// /// REST API Reference for SetIpAddressType Operation public virtual Task SetIpAddressTypeAsync(SetIpAddressTypeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = SetIpAddressTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = SetIpAddressTypeResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region SetRulePriorities internal virtual SetRulePrioritiesResponse SetRulePriorities(SetRulePrioritiesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = SetRulePrioritiesRequestMarshaller.Instance; options.ResponseUnmarshaller = SetRulePrioritiesResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Sets the priorities of the specified rules. /// /// /// /// You can reorder the rules as long as there are no priority conflicts in the new order. /// Any existing rules that you do not specify retain their current priority. /// /// /// Container for the necessary parameters to execute the SetRulePriorities service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the SetRulePriorities service method, as returned by ElasticLoadBalancingV2. /// /// This operation is not allowed. /// /// /// The specified priority is in use. /// /// /// The specified rule does not exist. /// /// REST API Reference for SetRulePriorities Operation public virtual Task SetRulePrioritiesAsync(SetRulePrioritiesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = SetRulePrioritiesRequestMarshaller.Instance; options.ResponseUnmarshaller = SetRulePrioritiesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region SetSecurityGroups internal virtual SetSecurityGroupsResponse SetSecurityGroups(SetSecurityGroupsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = SetSecurityGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = SetSecurityGroupsResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Associates the specified security groups with the specified Application Load Balancer. /// The specified security groups override the previously associated security groups. /// /// /// /// You can't specify a security group for a Network Load Balancer or Gateway Load Balancer. /// /// /// Container for the necessary parameters to execute the SetSecurityGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the SetSecurityGroups service method, as returned by ElasticLoadBalancingV2. /// /// The requested configuration is not valid. /// /// /// The specified security group does not exist. /// /// /// The specified load balancer does not exist. /// /// REST API Reference for SetSecurityGroups Operation public virtual Task SetSecurityGroupsAsync(SetSecurityGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = SetSecurityGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = SetSecurityGroupsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region SetSubnets internal virtual SetSubnetsResponse SetSubnets(SetSubnetsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = SetSubnetsRequestMarshaller.Instance; options.ResponseUnmarshaller = SetSubnetsResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Enables the Availability Zones for the specified public subnets for the specified /// Application Load Balancer or Network Load Balancer. The specified subnets replace /// the previously enabled subnets. /// /// /// /// When you specify subnets for a Network Load Balancer, you must include all subnets /// that were enabled previously, with their existing configurations, plus any additional /// subnets. /// /// /// Container for the necessary parameters to execute the SetSubnets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the SetSubnets service method, as returned by ElasticLoadBalancingV2. /// /// The specified allocation ID does not exist. /// /// /// The specified Availability Zone is not supported. /// /// /// The requested configuration is not valid. /// /// /// The specified subnet is out of available addresses. /// /// /// The specified load balancer does not exist. /// /// /// The specified subnet does not exist. /// /// REST API Reference for SetSubnets Operation public virtual Task SetSubnetsAsync(SetSubnetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = SetSubnetsRequestMarshaller.Instance; options.ResponseUnmarshaller = SetSubnetsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion } }