Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2010 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.
  */
 package com.amazonaws.services.elasticloadbalancing;
             
 
 
Client for accessing AmazonElasticLoadBalancing. All calls made using this client are non-blocking and will immediately return a Java Future. Callers must use the Future object to determine when the service call has actually completed.

Elastic Load Balancing is a cost-effective and easy to use web service to help you improve availability and scalability of your application. It makes it easy for you to distribute application loads between two or more EC2 instances. Elastic Load Balancing enables availability through redundancy and supports traffic growth of your application.

        
         implements AmazonElasticLoadBalancingAsync { 

    
Executor service for executing asynchronous requests.
 
     private ExecutorService executorService;

    
    
Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing using the specified AWS account credentials. Default client settings will be used, and a default cached thread pool will be created for executing the asynchronous tasks.

All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.

Parameters:
awsCredentials The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
                                       
     public AmazonElasticLoadBalancingAsyncClient(AWSCredentials awsCredentials) {
         this(awsCredentials, Executors.newCachedThreadPool());
     }

    
Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing using the specified AWS account credentials and executor service. Default client settings will be used.

All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.

Parameters:
awsCredentials The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
executorService The executor service by which all asynchronous requests will be executed.
 
     public AmazonElasticLoadBalancingAsyncClient(AWSCredentials awsCredentialsExecutorService executorService) {
         super(awsCredentials);
         this. = executorService;
     }
     
    
Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing using the specified AWS account credentials, executor service, and client configuration options.

All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.

Parameters:
awsCredentials The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
clientConfiguration Client configuration options (ex: max retry limit, proxy settings, etc).
executorService The executor service by which all asynchronous requests will be executed.
                ClientConfiguration clientConfigurationExecutorService executorService) {
        super(awsCredentialsclientConfiguration);
        this. = executorService;
    }
     
    
Returns the executor service used by this async client to execute requests.

Returns:
The executor service used by this async client to execute requests.
        return ;
    }
            
    

Creates one or more listeners on a LoadBalancer for the specified port. If a listener with the given port does not already exist, it will be created; otherwise, the properties of the new listener must match the properties of the existing listener.

Parameters:
createLoadBalancerListenersRequest Container for the necessary parameters to execute the CreateLoadBalancerListeners operation on AmazonElasticLoadBalancing.
Returns:
A Java Future object containing the response from the CreateLoadBalancerListeners service method, as returned by AmazonElasticLoadBalancing.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
    public Future<VoidcreateLoadBalancerListenersAsync(final CreateLoadBalancerListenersRequest createLoadBalancerListenersRequest
            throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<Void>() {
            public Void call() throws Exception {
                createLoadBalancerListeners(createLoadBalancerListenersRequest);
                return null;
		    }
		});
    }
    
    

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 only be associated only with HTTP listeners.

When a load balancer implements this policy, the load balancer uses a special cookie to track the backend server 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.

Parameters:
createLBCookieStickinessPolicyRequest Container for the necessary parameters to execute the CreateLBCookieStickinessPolicy operation on AmazonElasticLoadBalancing.
Returns:
A Java Future object containing the response from the CreateLBCookieStickinessPolicy service method, as returned by AmazonElasticLoadBalancing.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
            throws AmazonServiceExceptionAmazonClientException {
            public CreateLBCookieStickinessPolicyResult call() throws Exception {
                return createLBCookieStickinessPolicy(createLBCookieStickinessPolicyRequest);
		    }
		});
    }
    
    

Enables the client to define an application healthcheck for the instances.

Parameters:
configureHealthCheckRequest Container for the necessary parameters to execute the ConfigureHealthCheck operation on AmazonElasticLoadBalancing.
Returns:
A Java Future object containing the response from the ConfigureHealthCheck service method, as returned by AmazonElasticLoadBalancing.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
    public Future<ConfigureHealthCheckResultconfigureHealthCheckAsync(final ConfigureHealthCheckRequest configureHealthCheckRequest
            throws AmazonServiceExceptionAmazonClientException {
            public ConfigureHealthCheckResult call() throws Exception {
                return configureHealthCheck(configureHealthCheckRequest);
		    }
		});
    }
    
    

Returns detailed configuration information for the specified LoadBalancers. If no LoadBalancers are specified, the operation returns configuration information for all LoadBalancers created by the caller.

NOTE: The client must have created the specified input LoadBalancers in order to retrieve this information; the client must provide the same account credentials as those that were used to create the LoadBalancer.

Parameters:
describeLoadBalancersRequest Container for the necessary parameters to execute the DescribeLoadBalancers operation on AmazonElasticLoadBalancing.
Returns:
A Java Future object containing the response from the DescribeLoadBalancers service method, as returned by AmazonElasticLoadBalancing.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
    public Future<DescribeLoadBalancersResultdescribeLoadBalancersAsync(final DescribeLoadBalancersRequest describeLoadBalancersRequest
            throws AmazonServiceExceptionAmazonClientException {
            public DescribeLoadBalancersResult call() throws Exception {
                return describeLoadBalancers(describeLoadBalancersRequest);
		    }
		});
    }
    
    

Sets the certificate that terminates the specified listener's SSL connections. The specified certificate replaces any prior certificate that was used on the same LoadBalancer and port.

Parameters:
setLoadBalancerListenerSSLCertificateRequest Container for the necessary parameters to execute the SetLoadBalancerListenerSSLCertificate operation on AmazonElasticLoadBalancing.
Returns:
A Java Future object containing the response from the SetLoadBalancerListenerSSLCertificate service method, as returned by AmazonElasticLoadBalancing.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
    public Future<VoidsetLoadBalancerListenerSSLCertificateAsync(final SetLoadBalancerListenerSSLCertificateRequest setLoadBalancerListenerSSLCertificateRequest
            throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<Void>() {
            public Void call() throws Exception {
                setLoadBalancerListenerSSLCertificate(setLoadBalancerListenerSSLCertificateRequest);
                return null;
		    }
		});
    }
    
    

Creates a new LoadBalancer.

Once the call has completed successfully, a new LoadBalancer is created; however, it will not be usable until at least one instance has been registered. When the LoadBalancer creation is completed, the client can check whether or not it is usable by using the DescribeInstanceHealth API. The LoadBalancer is usable as soon as any registered instance is InService .

NOTE: Currently, the client's quota of LoadBalancers is limited to five per Region.

NOTE: Load balancer DNS names vary depending on the Region they're created in. For load balancers created in the United States, the DNS name ends with: us-east-1.elb.amazonaws.com (for the US Standard Region) us-west-1.elb.amazonaws.com (for the Northern California Region) For load balancers created in the EU (Ireland) Region, the DNS name ends with: eu-west-1.elb.amazonaws.com

Parameters:
createLoadBalancerRequest Container for the necessary parameters to execute the CreateLoadBalancer operation on AmazonElasticLoadBalancing.
Returns:
A Java Future object containing the response from the CreateLoadBalancer service method, as returned by AmazonElasticLoadBalancing.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
    public Future<CreateLoadBalancerResultcreateLoadBalancerAsync(final CreateLoadBalancerRequest createLoadBalancerRequest
            throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<CreateLoadBalancerResult>() {
            public CreateLoadBalancerResult call() throws Exception {
                return createLoadBalancer(createLoadBalancerRequest);
		    }
		});
    }
    
    

Adds one or more EC2 Availability Zones to the LoadBalancer.

The LoadBalancer evenly distributes requests across all its registered Availability Zones that contain instances. As a result, the client must ensure that its LoadBalancer is appropriately scaled for each registered Availability Zone.

NOTE: The new EC2 Availability Zones to be added must be in the same EC2 Region as the Availability Zones for which the LoadBalancer was created.

Parameters:
enableAvailabilityZonesForLoadBalancerRequest Container for the necessary parameters to execute the EnableAvailabilityZonesForLoadBalancer operation on AmazonElasticLoadBalancing.
Returns:
A Java Future object containing the response from the EnableAvailabilityZonesForLoadBalancer service method, as returned by AmazonElasticLoadBalancing.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
            throws AmazonServiceExceptionAmazonClientException {
            public EnableAvailabilityZonesForLoadBalancerResult call() throws Exception {
                return enableAvailabilityZonesForLoadBalancer(enableAvailabilityZonesForLoadBalancerRequest);
		    }
		});
    }
    
    

Returns the current state of the instances of the specified LoadBalancer. If no instances are specified, the state of all the instances for the LoadBalancer is returned.

NOTE: The client must have created the specified input LoadBalancer in order to retrieve this information; the client must provide the same account credentials as those that were used to create the LoadBalancer.

Parameters:
describeInstanceHealthRequest Container for the necessary parameters to execute the DescribeInstanceHealth operation on AmazonElasticLoadBalancing.
Returns:
A Java Future object containing the response from the DescribeInstanceHealth service method, as returned by AmazonElasticLoadBalancing.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
    public Future<DescribeInstanceHealthResultdescribeInstanceHealthAsync(final DescribeInstanceHealthRequest describeInstanceHealthRequest
            throws AmazonServiceExceptionAmazonClientException {
            public DescribeInstanceHealthResult call() throws Exception {
                return describeInstanceHealth(describeInstanceHealthRequest);
		    }
		});
    }
    
    

Deletes a policy from the LoadBalancer. The specified policy must not be enabled for any listeners.

Parameters:
deleteLoadBalancerPolicyRequest Container for the necessary parameters to execute the DeleteLoadBalancerPolicy operation on AmazonElasticLoadBalancing.
Returns:
A Java Future object containing the response from the DeleteLoadBalancerPolicy service method, as returned by AmazonElasticLoadBalancing.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
            throws AmazonServiceExceptionAmazonClientException {
            public DeleteLoadBalancerPolicyResult call() throws Exception {
                return deleteLoadBalancerPolicy(deleteLoadBalancerPolicyRequest);
		    }
		});
    }
    
    

Removes the specified EC2 Availability Zones from the set of configured Availability Zones for the LoadBalancer.

There must be at least one Availability Zone registered with a LoadBalancer at all times. A client cannot remove all the Availability Zones from a LoadBalancer. Once an Availability Zone is removed, all the instances registered with the LoadBalancer that are in the removed Availability Zone go into the OutOfService state. Upon Availability Zone removal, the LoadBalancer attempts to equally balance the traffic among its remaining usable Availability Zones. Trying to remove an Availability Zone that was not associated with the LoadBalancer does nothing.

NOTE: In order for this call to be successful, the client must have created the LoadBalancer. The client must provide the same account credentials as those that were used to create the LoadBalancer.

Parameters:
disableAvailabilityZonesForLoadBalancerRequest Container for the necessary parameters to execute the DisableAvailabilityZonesForLoadBalancer operation on AmazonElasticLoadBalancing.
Returns:
A Java Future object containing the response from the DisableAvailabilityZonesForLoadBalancer service method, as returned by AmazonElasticLoadBalancing.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
            throws AmazonServiceExceptionAmazonClientException {
            public DisableAvailabilityZonesForLoadBalancerResult call() throws Exception {
                return disableAvailabilityZonesForLoadBalancer(disableAvailabilityZonesForLoadBalancerRequest);
		    }
		});
    }
    
    

Deregisters instances from the LoadBalancer. Once the instance is deregistered, it will stop receiving traffic from the LoadBalancer.

In order to successfully call this API, the same account credentials as those used to create the LoadBalancer must be provided.

Parameters:
deregisterInstancesFromLoadBalancerRequest Container for the necessary parameters to execute the DeregisterInstancesFromLoadBalancer operation on AmazonElasticLoadBalancing.
Returns:
A Java Future object containing the response from the DeregisterInstancesFromLoadBalancer service method, as returned by AmazonElasticLoadBalancing.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
            throws AmazonServiceExceptionAmazonClientException {
            public DeregisterInstancesFromLoadBalancerResult call() throws Exception {
                return deregisterInstancesFromLoadBalancer(deregisterInstancesFromLoadBalancerRequest);
		    }
		});
    }
    
    

Deletes listeners from the LoadBalancer for the specified port.

Parameters:
deleteLoadBalancerListenersRequest Container for the necessary parameters to execute the DeleteLoadBalancerListeners operation on AmazonElasticLoadBalancing.
Returns:
A Java Future object containing the response from the DeleteLoadBalancerListeners service method, as returned by AmazonElasticLoadBalancing.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
    public Future<VoiddeleteLoadBalancerListenersAsync(final DeleteLoadBalancerListenersRequest deleteLoadBalancerListenersRequest
            throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<Void>() {
            public Void call() throws Exception {
                deleteLoadBalancerListeners(deleteLoadBalancerListenersRequest);
                return null;
		    }
		});
    }
    
    

Deletes the specified LoadBalancer.

If attempting to recreate the LoadBalancer, the client must reconfigure all the settings. The DNS name associated with a deleted LoadBalancer will no longer be usable. Once deleted, the name and associated DNS record of the LoadBalancer no longer exist and traffic sent to any of its IP addresses will no longer be delivered to client instances. The client will not receive the same DNS name even if a new LoadBalancer with same LoadBalancerName is created.

To successfully call this API, the client must provide the same account credentials as were used to create the LoadBalancer.

NOTE: By design, if the LoadBalancer does not exist or has already been deleted, DeleteLoadBalancer still succeeds.

Parameters:
deleteLoadBalancerRequest Container for the necessary parameters to execute the DeleteLoadBalancer operation on AmazonElasticLoadBalancing.
Returns:
A Java Future object containing the response from the DeleteLoadBalancer service method, as returned by AmazonElasticLoadBalancing.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
    public Future<VoiddeleteLoadBalancerAsync(final DeleteLoadBalancerRequest deleteLoadBalancerRequest
            throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<Void>() {
            public Void call() throws Exception {
                deleteLoadBalancer(deleteLoadBalancerRequest);
                return null;
		    }
		});
    }
    
    

Generates a stickiness policy with sticky session lifetimes that follow that of an application-generated cookie. This policy can only be associated with HTTP listeners.

This policy is similar to the policy created by CreateLBCookieStickinessPolicy, except that the lifetime of the special Elastic Load Balancing cookie 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.

Parameters:
createAppCookieStickinessPolicyRequest Container for the necessary parameters to execute the CreateAppCookieStickinessPolicy operation on AmazonElasticLoadBalancing.
Returns:
A Java Future object containing the response from the CreateAppCookieStickinessPolicy service method, as returned by AmazonElasticLoadBalancing.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
            throws AmazonServiceExceptionAmazonClientException {
            public CreateAppCookieStickinessPolicyResult call() throws Exception {
                return createAppCookieStickinessPolicy(createAppCookieStickinessPolicyRequest);
		    }
		});
    }
    
    

Adds new instances to the LoadBalancer.

Once the instance is registered, it starts receiving traffic and requests from the LoadBalancer. Any instance that is not in any of the Availability Zones registered for the LoadBalancer will be moved to the OutOfService state. It will move to the InService state when the Availability Zone is added to the LoadBalancer.

NOTE: In order for this call to be successful, the client must have created the LoadBalancer. The client must provide the same account credentials as those that were used to create the LoadBalancer.

NOTE: Completion of this API does not guarantee that operation has completed. Rather, it means that the request has been registered and the changes will happen shortly.

Parameters:
registerInstancesWithLoadBalancerRequest Container for the necessary parameters to execute the RegisterInstancesWithLoadBalancer operation on AmazonElasticLoadBalancing.
Returns:
A Java Future object containing the response from the RegisterInstancesWithLoadBalancer service method, as returned by AmazonElasticLoadBalancing.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
            throws AmazonServiceExceptionAmazonClientException {
            public RegisterInstancesWithLoadBalancerResult call() throws Exception {
                return registerInstancesWithLoadBalancer(registerInstancesWithLoadBalancerRequest);
		    }
		});
    }
    
    

Associates, updates, or disables a policy with a listener on the load balancer. Currently only zero (0) or one (1) policy can be associated with a listener.

Parameters:
setLoadBalancerPoliciesOfListenerRequest Container for the necessary parameters to execute the SetLoadBalancerPoliciesOfListener operation on AmazonElasticLoadBalancing.
Returns:
A Java Future object containing the response from the SetLoadBalancerPoliciesOfListener service method, as returned by AmazonElasticLoadBalancing.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
            throws AmazonServiceExceptionAmazonClientException {
            public SetLoadBalancerPoliciesOfListenerResult call() throws Exception {
                return setLoadBalancerPoliciesOfListener(setLoadBalancerPoliciesOfListenerRequest);
		    }
		});
    }
    
}
        
New to GrepCode? Check out our FAQ X