/*
* Copyright 2010-2011 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;
import org.w3c.dom.Node;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map.Entry;
import com.amazonaws.*;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWS3Signer;
import com.amazonaws.auth.QueryStringSigner;
import com.amazonaws.handlers.HandlerChainFactory;
import com.amazonaws.handlers.RequestHandler;
import com.amazonaws.http.StaxResponseHandler;
import com.amazonaws.http.DefaultErrorResponseHandler;
import com.amazonaws.http.HttpClient;
import com.amazonaws.http.ExecutionContext;
import com.amazonaws.transform.Unmarshaller;
import com.amazonaws.transform.StaxUnmarshallerContext;
import com.amazonaws.transform.StandardErrorUnmarshaller;
import com.amazonaws.services.elasticloadbalancing.model.*;
import com.amazonaws.services.elasticloadbalancing.model.transform.*;
/**
* Client for accessing AmazonElasticLoadBalancing. All service calls made
* using this client are blocking, and will not return until the service call
* completes.
* <p>
* Elastic Load Balancing <p>
* 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.
* </p>
*/
public class AmazonElasticLoadBalancingClient extends AmazonWebServiceClient implements AmazonElasticLoadBalancing {
/**
* The AWS credentials (access key ID and secret key) to use when
* authenticating with AWS services.
*/
private AWSCredentials awsCredentials;
/**
* List of exception unmarshallers for all AmazonElasticLoadBalancing exceptions.
*/
protected final List<Unmarshaller<AmazonServiceException, Node>> exceptionUnmarshallers;
/** Low level client for sending requests to AWS services. */
protected final HttpClient client;
/** Optional request handlers for additional request processing. */
private final List<RequestHandler> requestHandlers;
/** AWS signer for authenticating requests. */
private QueryStringSigner signer;
/**
* Constructs a new client to invoke service methods on
* AmazonElasticLoadBalancing using the specified AWS account credentials.
*
* <p>
* All service calls made using this new client object are blocking, and will not
* return until the service call completes.
*
* @param awsCredentials The AWS credentials (access key ID and secret key) to use
* when authenticating with AWS services.
*/
public AmazonElasticLoadBalancingClient(AWSCredentials awsCredentials) {
this(awsCredentials, new ClientConfiguration());
}
/**
* Constructs a new client to invoke service methods on
* AmazonElasticLoadBalancing using the specified AWS account credentials
* and client configuration options.
*
* <p>
* All service calls made using this new client object are blocking, and will not
* return until the service call completes.
*
* @param awsCredentials The AWS credentials (access key ID and secret key) to use
* when authenticating with AWS services.
* @param clientConfiguration The client configuration options controlling how this
* client connects to AmazonElasticLoadBalancing
* (ex: proxy settings, retry counts, etc.).
*/
public AmazonElasticLoadBalancingClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration) {
super(clientConfiguration);
this.awsCredentials = awsCredentials;
exceptionUnmarshallers = new ArrayList<Unmarshaller<AmazonServiceException, Node>>();
exceptionUnmarshallers.add(new InvalidConfigurationRequestExceptionUnmarshaller());
exceptionUnmarshallers.add(new ListenerNotFoundExceptionUnmarshaller());
exceptionUnmarshallers.add(new CertificateNotFoundExceptionUnmarshaller());
exceptionUnmarshallers.add(new DuplicateListenerExceptionUnmarshaller());
exceptionUnmarshallers.add(new PolicyNotFoundExceptionUnmarshaller());
exceptionUnmarshallers.add(new TooManyLoadBalancersExceptionUnmarshaller());
exceptionUnmarshallers.add(new DuplicatePolicyNameExceptionUnmarshaller());
exceptionUnmarshallers.add(new InvalidInstanceExceptionUnmarshaller());
exceptionUnmarshallers.add(new TooManyPoliciesExceptionUnmarshaller());
exceptionUnmarshallers.add(new LoadBalancerNotFoundExceptionUnmarshaller());
exceptionUnmarshallers.add(new DuplicateLoadBalancerNameExceptionUnmarshaller());
exceptionUnmarshallers.add(new StandardErrorUnmarshaller());
setEndpoint("elasticloadbalancing.amazonaws.com");
signer = new QueryStringSigner();
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandlers = Collections.synchronizedList(chainFactory.newRequestHandlerChain(
"/com/amazonaws/services/elasticloadbalancing/request.handlers"));
client = new HttpClient(clientConfiguration);
}
/**
* Appends a request handler to the list of registered handlers that are run
* as part of a request's lifecycle.
*
* @param requestHandler
* The new handler to add to the current list of request
* handlers.
*/
public void addRequestHandler(RequestHandler requestHandler) {
requestHandlers.add(requestHandler);
}
/**
* <p>
* 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.
* </p>
*
* @param createLoadBalancerListenersRequest Container for the necessary
* parameters to execute the CreateLoadBalancerListeners service method
* on AmazonElasticLoadBalancing.
*
* @throws LoadBalancerNotFoundException
* @throws InvalidConfigurationRequestException
* @throws DuplicateListenerException
* @throws CertificateNotFoundException
*
* @throws 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.
* @throws 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 void createLoadBalancerListeners(CreateLoadBalancerListenersRequest createLoadBalancerListenersRequest)
throws AmazonServiceException, AmazonClientException {
Request<CreateLoadBalancerListenersRequest> request = new CreateLoadBalancerListenersRequestMarshaller().marshall(createLoadBalancerListenersRequest);
invoke(request, null);
}
/**
* <p>
* Deletes listeners from the LoadBalancer for the specified port.
* </p>
*
* @param deleteLoadBalancerListenersRequest Container for the necessary
* parameters to execute the DeleteLoadBalancerListeners service method
* on AmazonElasticLoadBalancing.
*
* @throws LoadBalancerNotFoundException
*
* @throws 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.
* @throws 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 void deleteLoadBalancerListeners(DeleteLoadBalancerListenersRequest deleteLoadBalancerListenersRequest)
throws AmazonServiceException, AmazonClientException {
Request<DeleteLoadBalancerListenersRequest> request = new DeleteLoadBalancerListenersRequestMarshaller().marshall(deleteLoadBalancerListenersRequest);
invoke(request, null);
}
/**
* <p>
* Enables the client to define an application healthcheck for the
* instances.
* </p>
*
* @param configureHealthCheckRequest Container for the necessary
* parameters to execute the ConfigureHealthCheck service method on
* AmazonElasticLoadBalancing.
*
* @return The response from the ConfigureHealthCheck service method, as
* returned by AmazonElasticLoadBalancing.
*
* @throws LoadBalancerNotFoundException
*
* @throws 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.
* @throws 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 ConfigureHealthCheckResult configureHealthCheck(ConfigureHealthCheckRequest configureHealthCheckRequest)
throws AmazonServiceException, AmazonClientException {
Request<ConfigureHealthCheckRequest> request = new ConfigureHealthCheckRequestMarshaller().marshall(configureHealthCheckRequest);
return invoke(request, new ConfigureHealthCheckResultStaxUnmarshaller());
}
/**
* <p>
* 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.
* </p>
* <p>
* <b>NOTE:</b> 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.
* </p>
*
* @param describeLoadBalancersRequest Container for the necessary
* parameters to execute the DescribeLoadBalancers service method on
* AmazonElasticLoadBalancing.
*
* @return The response from the DescribeLoadBalancers service method, as
* returned by AmazonElasticLoadBalancing.
*
* @throws LoadBalancerNotFoundException
*
* @throws 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.
* @throws 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 DescribeLoadBalancersResult describeLoadBalancers(DescribeLoadBalancersRequest describeLoadBalancersRequest)
throws AmazonServiceException, AmazonClientException {
Request<DescribeLoadBalancersRequest> request = new DescribeLoadBalancersRequestMarshaller().marshall(describeLoadBalancersRequest);
return invoke(request, new DescribeLoadBalancersResultStaxUnmarshaller());
}
/**
* <p>
* 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.
* </p>
* <p>
* 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.
* </p>
* <p>
* 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.
* </p>
*
* @param createLBCookieStickinessPolicyRequest Container for the
* necessary parameters to execute the CreateLBCookieStickinessPolicy
* service method on AmazonElasticLoadBalancing.
*
* @return The response from the CreateLBCookieStickinessPolicy service
* method, as returned by AmazonElasticLoadBalancing.
*
* @throws DuplicatePolicyNameException
* @throws TooManyPoliciesException
* @throws LoadBalancerNotFoundException
* @throws InvalidConfigurationRequestException
*
* @throws 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.
* @throws 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 CreateLBCookieStickinessPolicyResult createLBCookieStickinessPolicy(CreateLBCookieStickinessPolicyRequest createLBCookieStickinessPolicyRequest)
throws AmazonServiceException, AmazonClientException {
Request<CreateLBCookieStickinessPolicyRequest> request = new CreateLBCookieStickinessPolicyRequestMarshaller().marshall(createLBCookieStickinessPolicyRequest);
return invoke(request, new CreateLBCookieStickinessPolicyResultStaxUnmarshaller());
}
/**
* <p>
* Adds one or more EC2 Availability Zones to the LoadBalancer.
* </p>
* <p>
* 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.
* </p>
* <p>
* <b>NOTE:</b> 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.
* </p>
*
* @param enableAvailabilityZonesForLoadBalancerRequest Container for the
* necessary parameters to execute the
* EnableAvailabilityZonesForLoadBalancer service method on
* AmazonElasticLoadBalancing.
*
* @return The response from the EnableAvailabilityZonesForLoadBalancer
* service method, as returned by AmazonElasticLoadBalancing.
*
* @throws LoadBalancerNotFoundException
*
* @throws 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.
* @throws 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 EnableAvailabilityZonesForLoadBalancerResult enableAvailabilityZonesForLoadBalancer(EnableAvailabilityZonesForLoadBalancerRequest enableAvailabilityZonesForLoadBalancerRequest)
throws AmazonServiceException, AmazonClientException {
Request<EnableAvailabilityZonesForLoadBalancerRequest> request = new EnableAvailabilityZonesForLoadBalancerRequestMarshaller().marshall(enableAvailabilityZonesForLoadBalancerRequest);
return invoke(request, new EnableAvailabilityZonesForLoadBalancerResultStaxUnmarshaller());
}
/**
* <p>
* 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.
* </p>
* <p>
* <b>NOTE:</b> 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.
* </p>
*
* @param describeInstanceHealthRequest Container for the necessary
* parameters to execute the DescribeInstanceHealth service method on
* AmazonElasticLoadBalancing.
*
* @return The response from the DescribeInstanceHealth service method,
* as returned by AmazonElasticLoadBalancing.
*
* @throws LoadBalancerNotFoundException
* @throws InvalidInstanceException
*
* @throws 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.
* @throws 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 DescribeInstanceHealthResult describeInstanceHealth(DescribeInstanceHealthRequest describeInstanceHealthRequest)
throws AmazonServiceException, AmazonClientException {
Request<DescribeInstanceHealthRequest> request = new DescribeInstanceHealthRequestMarshaller().marshall(describeInstanceHealthRequest);
return invoke(request, new DescribeInstanceHealthResultStaxUnmarshaller());
}
/**
* <p>
* 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.
* </p>
*
* @param setLoadBalancerListenerSSLCertificateRequest Container for the
* necessary parameters to execute the
* SetLoadBalancerListenerSSLCertificate service method on
* AmazonElasticLoadBalancing.
*
* @throws LoadBalancerNotFoundException
* @throws InvalidConfigurationRequestException
* @throws ListenerNotFoundException
* @throws CertificateNotFoundException
*
* @throws 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.
* @throws 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 void setLoadBalancerListenerSSLCertificate(SetLoadBalancerListenerSSLCertificateRequest setLoadBalancerListenerSSLCertificateRequest)
throws AmazonServiceException, AmazonClientException {
Request<SetLoadBalancerListenerSSLCertificateRequest> request = new SetLoadBalancerListenerSSLCertificateRequestMarshaller().marshall(setLoadBalancerListenerSSLCertificateRequest);
invoke(request, null);
}
/**
* <p>
* 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.
* </p>
*
* @param setLoadBalancerPoliciesOfListenerRequest Container for the
* necessary parameters to execute the SetLoadBalancerPoliciesOfListener
* service method on AmazonElasticLoadBalancing.
*
* @return The response from the SetLoadBalancerPoliciesOfListener
* service method, as returned by AmazonElasticLoadBalancing.
*
* @throws PolicyNotFoundException
* @throws LoadBalancerNotFoundException
* @throws InvalidConfigurationRequestException
* @throws ListenerNotFoundException
*
* @throws 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.
* @throws 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 SetLoadBalancerPoliciesOfListenerResult setLoadBalancerPoliciesOfListener(SetLoadBalancerPoliciesOfListenerRequest setLoadBalancerPoliciesOfListenerRequest)
throws AmazonServiceException, AmazonClientException {
Request<SetLoadBalancerPoliciesOfListenerRequest> request = new SetLoadBalancerPoliciesOfListenerRequestMarshaller().marshall(setLoadBalancerPoliciesOfListenerRequest);
return invoke(request, new SetLoadBalancerPoliciesOfListenerResultStaxUnmarshaller());
}
/**
* <p>
* Creates a new LoadBalancer.
* </p>
* <p>
* 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 <i>InService</i> .
*
* </p>
* <p>
* <b>NOTE:</b> Currently, the client's quota of LoadBalancers is limited
* to five per Region.
* </p>
* <p>
* <b>NOTE:</b> 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
* </p>
*
* @param createLoadBalancerRequest Container for the necessary
* parameters to execute the CreateLoadBalancer service method on
* AmazonElasticLoadBalancing.
*
* @return The response from the CreateLoadBalancer service method, as
* returned by AmazonElasticLoadBalancing.
*
* @throws DuplicateLoadBalancerNameException
* @throws TooManyLoadBalancersException
* @throws InvalidConfigurationRequestException
* @throws CertificateNotFoundException
*
* @throws 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.
* @throws 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 CreateLoadBalancerResult createLoadBalancer(CreateLoadBalancerRequest createLoadBalancerRequest)
throws AmazonServiceException, AmazonClientException {
Request<CreateLoadBalancerRequest> request = new CreateLoadBalancerRequestMarshaller().marshall(createLoadBalancerRequest);
return invoke(request, new CreateLoadBalancerResultStaxUnmarshaller());
}
/**
* <p>
* Adds new instances to the LoadBalancer.
* </p>
* <p>
* 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 <i>OutOfService</i> state. It will move to the <i>InService</i>
* state when the Availability Zone is added to the LoadBalancer.
* </p>
* <p>
* <b>NOTE:</b> 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.
* </p>
* <p>
* <b>NOTE:</b> 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.
* </p>
*
* @param registerInstancesWithLoadBalancerRequest Container for the
* necessary parameters to execute the RegisterInstancesWithLoadBalancer
* service method on AmazonElasticLoadBalancing.
*
* @return The response from the RegisterInstancesWithLoadBalancer
* service method, as returned by AmazonElasticLoadBalancing.
*
* @throws LoadBalancerNotFoundException
* @throws InvalidInstanceException
*
* @throws 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.
* @throws 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 RegisterInstancesWithLoadBalancerResult registerInstancesWithLoadBalancer(RegisterInstancesWithLoadBalancerRequest registerInstancesWithLoadBalancerRequest)
throws AmazonServiceException, AmazonClientException {
Request<RegisterInstancesWithLoadBalancerRequest> request = new RegisterInstancesWithLoadBalancerRequestMarshaller().marshall(registerInstancesWithLoadBalancerRequest);
return invoke(request, new RegisterInstancesWithLoadBalancerResultStaxUnmarshaller());
}
/**
* <p>
* 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.
* </p>
* <p>
* 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.
* </p>
* <p>
* If the application cookie is explicitly removed or expires, the
* session stops being sticky until a new application cookie is issued.
* </p>
*
* @param createAppCookieStickinessPolicyRequest Container for the
* necessary parameters to execute the CreateAppCookieStickinessPolicy
* service method on AmazonElasticLoadBalancing.
*
* @return The response from the CreateAppCookieStickinessPolicy service
* method, as returned by AmazonElasticLoadBalancing.
*
* @throws DuplicatePolicyNameException
* @throws TooManyPoliciesException
* @throws LoadBalancerNotFoundException
* @throws InvalidConfigurationRequestException
*
* @throws 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.
* @throws 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 CreateAppCookieStickinessPolicyResult createAppCookieStickinessPolicy(CreateAppCookieStickinessPolicyRequest createAppCookieStickinessPolicyRequest)
throws AmazonServiceException, AmazonClientException {
Request<CreateAppCookieStickinessPolicyRequest> request = new CreateAppCookieStickinessPolicyRequestMarshaller().marshall(createAppCookieStickinessPolicyRequest);
return invoke(request, new CreateAppCookieStickinessPolicyResultStaxUnmarshaller());
}
/**
* <p>
* Deletes the specified LoadBalancer.
* </p>
* <p>
* 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.
* </p>
* <p>
* To successfully call this API, the client must provide the same
* account credentials as were used to create the LoadBalancer.
* </p>
* <p>
* <b>NOTE:</b> By design, if the LoadBalancer does not exist or has
* already been deleted, DeleteLoadBalancer still succeeds.
* </p>
*
* @param deleteLoadBalancerRequest Container for the necessary
* parameters to execute the DeleteLoadBalancer service method on
* AmazonElasticLoadBalancing.
*
*
* @throws 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.
* @throws 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 void deleteLoadBalancer(DeleteLoadBalancerRequest deleteLoadBalancerRequest)
throws AmazonServiceException, AmazonClientException {
Request<DeleteLoadBalancerRequest> request = new DeleteLoadBalancerRequestMarshaller().marshall(deleteLoadBalancerRequest);
invoke(request, null);
}
/**
* <p>
* Removes the specified EC2 Availability Zones from the set of
* configured Availability Zones for the LoadBalancer.
* </p>
* <p>
* 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.
* </p>
* <p>
* <b>NOTE:</b> 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.
* </p>
*
* @param disableAvailabilityZonesForLoadBalancerRequest Container for
* the necessary parameters to execute the
* DisableAvailabilityZonesForLoadBalancer service method on
* AmazonElasticLoadBalancing.
*
* @return The response from the DisableAvailabilityZonesForLoadBalancer
* service method, as returned by AmazonElasticLoadBalancing.
*
* @throws LoadBalancerNotFoundException
* @throws InvalidConfigurationRequestException
*
* @throws 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.
* @throws 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 DisableAvailabilityZonesForLoadBalancerResult disableAvailabilityZonesForLoadBalancer(DisableAvailabilityZonesForLoadBalancerRequest disableAvailabilityZonesForLoadBalancerRequest)
throws AmazonServiceException, AmazonClientException {
Request<DisableAvailabilityZonesForLoadBalancerRequest> request = new DisableAvailabilityZonesForLoadBalancerRequestMarshaller().marshall(disableAvailabilityZonesForLoadBalancerRequest);
return invoke(request, new DisableAvailabilityZonesForLoadBalancerResultStaxUnmarshaller());
}
/**
* <p>
* Deletes a policy from the LoadBalancer. The specified policy must not
* be enabled for any listeners.
* </p>
*
* @param deleteLoadBalancerPolicyRequest Container for the necessary
* parameters to execute the DeleteLoadBalancerPolicy service method on
* AmazonElasticLoadBalancing.
*
* @return The response from the DeleteLoadBalancerPolicy service method,
* as returned by AmazonElasticLoadBalancing.
*
* @throws LoadBalancerNotFoundException
* @throws InvalidConfigurationRequestException
*
* @throws 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.
* @throws 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 DeleteLoadBalancerPolicyResult deleteLoadBalancerPolicy(DeleteLoadBalancerPolicyRequest deleteLoadBalancerPolicyRequest)
throws AmazonServiceException, AmazonClientException {
Request<DeleteLoadBalancerPolicyRequest> request = new DeleteLoadBalancerPolicyRequestMarshaller().marshall(deleteLoadBalancerPolicyRequest);
return invoke(request, new DeleteLoadBalancerPolicyResultStaxUnmarshaller());
}
/**
* <p>
* Deregisters instances from the LoadBalancer. Once the instance is
* deregistered, it will stop receiving traffic from the LoadBalancer.
* </p>
* <p>
* In order to successfully call this API, the same account credentials
* as those used to create the LoadBalancer must be provided.
* </p>
*
* @param deregisterInstancesFromLoadBalancerRequest Container for the
* necessary parameters to execute the
* DeregisterInstancesFromLoadBalancer service method on
* AmazonElasticLoadBalancing.
*
* @return The response from the DeregisterInstancesFromLoadBalancer
* service method, as returned by AmazonElasticLoadBalancing.
*
* @throws LoadBalancerNotFoundException
* @throws InvalidInstanceException
*
* @throws 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.
* @throws 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 DeregisterInstancesFromLoadBalancerResult deregisterInstancesFromLoadBalancer(DeregisterInstancesFromLoadBalancerRequest deregisterInstancesFromLoadBalancerRequest)
throws AmazonServiceException, AmazonClientException {
Request<DeregisterInstancesFromLoadBalancerRequest> request = new DeregisterInstancesFromLoadBalancerRequestMarshaller().marshall(deregisterInstancesFromLoadBalancerRequest);
return invoke(request, new DeregisterInstancesFromLoadBalancerResultStaxUnmarshaller());
}
/**
* <p>
* 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.
* </p>
* <p>
* <b>NOTE:</b> 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.
* </p>
*
* @return The response from the DescribeLoadBalancers service method, as
* returned by AmazonElasticLoadBalancing.
*
* @throws LoadBalancerNotFoundException
*
* @throws 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.
* @throws 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 DescribeLoadBalancersResult describeLoadBalancers() throws AmazonServiceException, AmazonClientException {
return describeLoadBalancers(new DescribeLoadBalancersRequest());
}
/**
* Returns additional metadata for a previously executed successful, request, typically used for
* debugging issues where a service isn't acting as expected. This data isn't considered part
* of the result data returned by an operation, so it's available through this separate,
* diagnostic interface.
* <p>
* Response metadata is only cached for a limited period of time, so if you need to access
* this extra diagnostic information for an executed request, you should use this method
* to retrieve it as soon as possible after executing the request.
*
* @param request
* The originally executed request
*
* @return The response metadata for the specified request, or null if none
* is available.
*/
public ResponseMetadata getCachedResponseMetadata(AmazonWebServiceRequest request) {
return client.getResponseMetadataForRequest(request);
}
private <X, Y extends AmazonWebServiceRequest> X invoke(Request<Y> request, Unmarshaller<X, StaxUnmarshallerContext> unmarshaller) {
request.setEndpoint(endpoint);
for (Entry<String, String> entry : request.getOriginalRequest().copyPrivateRequestParameters().entrySet()) {
request.addParameter(entry.getKey(), entry.getValue());
}
// Apply any additional service specific request handlers that need to be run
if (requestHandlers != null) {
for (RequestHandler requestHandler : requestHandlers) {
requestHandler.beforeRequest(request);
}
}
if (request.getOriginalRequest().getRequestCredentials() != null) {
signer.sign(request, request.getOriginalRequest().getRequestCredentials());
} else {
signer.sign(request, awsCredentials);
}
StaxResponseHandler<X> responseHandler = new StaxResponseHandler<X>(unmarshaller);
DefaultErrorResponseHandler errorResponseHandler = new DefaultErrorResponseHandler(exceptionUnmarshallers);
ExecutionContext executionContext = new ExecutionContext(requestHandlers);
return (X)client.execute(request, responseHandler, errorResponseHandler, executionContext);
}
}