com.amazonaws.services.elasticache.AmazonElastiCacheClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-osgi Show documentation
/*
* Copyright 2011-2016 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.elasticache;
import org.w3c.dom.*;
import java.net.*;
import java.util.*;
import java.util.Map.Entry;
import org.apache.commons.logging.*;
import com.amazonaws.*;
import com.amazonaws.auth.*;
import com.amazonaws.handlers.*;
import com.amazonaws.http.*;
import com.amazonaws.internal.*;
import com.amazonaws.internal.auth.*;
import com.amazonaws.metrics.*;
import com.amazonaws.regions.*;
import com.amazonaws.transform.*;
import com.amazonaws.util.*;
import com.amazonaws.protocol.json.*;
import com.amazonaws.util.AWSRequestMetrics.Field;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.client.AwsSyncClientParams;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.elasticache.model.*;
import com.amazonaws.services.elasticache.model.transform.*;
/**
* Client for accessing Amazon ElastiCache. All service calls made using this
* client are blocking, and will not return until the service call completes.
*
* Amazon ElastiCache
*
* Amazon ElastiCache is a web service that makes it easier to set up, operate,
* and scale a distributed cache in the cloud.
*
*
* With ElastiCache, customers gain all of the benefits of a high-performance,
* in-memory cache with far less of the administrative burden of launching and
* managing a distributed cache. The service makes setup, scaling, and cluster
* failure handling much simpler than in a self-managed cache deployment.
*
*
* In addition, through integration with Amazon CloudWatch, customers get
* enhanced visibility into the key performance statistics associated with their
* cache and can receive alarms if a part of their cache runs hot.
*
*/
@ThreadSafe
public class AmazonElastiCacheClient extends AmazonWebServiceClient implements
AmazonElastiCache {
/** Provider for AWS credentials. */
private final AWSCredentialsProvider awsCredentialsProvider;
private static final Log log = LogFactory.getLog(AmazonElastiCache.class);
/** Default signing name for the service. */
private static final String DEFAULT_SIGNING_NAME = "elasticache";
/**
* Client configuration factory providing ClientConfigurations tailored to
* this client
*/
protected static final ClientConfigurationFactory configFactory = new ClientConfigurationFactory();
/**
* List of exception unmarshallers for all modeled exceptions
*/
protected final List> exceptionUnmarshallers = new ArrayList>();
/**
* Constructs a new client to invoke service methods on Amazon ElastiCache.
* A credentials provider chain will be used that searches for credentials
* in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Instance profile credentials delivered through the Amazon EC2
* metadata service
*
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @see DefaultAWSCredentialsProviderChain
*/
public AmazonElastiCacheClient() {
this(new DefaultAWSCredentialsProviderChain(), configFactory
.getConfig());
}
/**
* Constructs a new client to invoke service methods on Amazon ElastiCache.
* A credentials provider chain will be used that searches for credentials
* in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Instance profile credentials delivered through the Amazon EC2
* metadata service
*
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param clientConfiguration
* The client configuration options controlling how this client
* connects to Amazon ElastiCache (ex: proxy settings, retry counts,
* etc.).
*
* @see DefaultAWSCredentialsProviderChain
*/
public AmazonElastiCacheClient(ClientConfiguration clientConfiguration) {
this(new DefaultAWSCredentialsProviderChain(), clientConfiguration);
}
/**
* Constructs a new client to invoke service methods on Amazon ElastiCache
* using the specified AWS account credentials.
*
*
* 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 AmazonElastiCacheClient(AWSCredentials awsCredentials) {
this(awsCredentials, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on Amazon ElastiCache
* using the specified AWS account credentials and client configuration
* options.
*
*
* 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 Amazon ElastiCache (ex: proxy settings, retry counts,
* etc.).
*/
public AmazonElastiCacheClient(AWSCredentials awsCredentials,
ClientConfiguration clientConfiguration) {
super(clientConfiguration);
this.awsCredentialsProvider = new StaticCredentialsProvider(
awsCredentials);
init();
}
/**
* Constructs a new client to invoke service methods on Amazon ElastiCache
* using the specified AWS account credentials provider.
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to
* authenticate requests with AWS services.
*/
public AmazonElastiCacheClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on Amazon ElastiCache
* using the specified AWS account credentials provider and client
* configuration options.
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to
* authenticate requests with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client
* connects to Amazon ElastiCache (ex: proxy settings, retry counts,
* etc.).
*/
public AmazonElastiCacheClient(
AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, null);
}
/**
* Constructs a new client to invoke service methods on Amazon ElastiCache
* using the specified AWS account credentials provider, client
* configuration options, and request metric collector.
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to
* authenticate requests with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client
* connects to Amazon ElastiCache (ex: proxy settings, retry counts,
* etc.).
* @param requestMetricCollector
* optional request metric collector
*/
public AmazonElastiCacheClient(
AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration,
RequestMetricCollector requestMetricCollector) {
super(clientConfiguration, requestMetricCollector);
this.awsCredentialsProvider = awsCredentialsProvider;
init();
}
/**
* Constructs a new client to invoke service methods on Amazon ElastiCache
* using the specified parameters.
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonElastiCacheClient(AwsSyncClientParams clientParams) {
super(clientParams);
this.awsCredentialsProvider = clientParams.getCredentialsProvider();
init();
}
private void init() {
exceptionUnmarshallers
.add(new ReservedCacheNodeAlreadyExistsExceptionUnmarshaller());
exceptionUnmarshallers
.add(new CacheSubnetGroupNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new CacheClusterNotFoundExceptionUnmarshaller());
exceptionUnmarshallers.add(new SubnetInUseExceptionUnmarshaller());
exceptionUnmarshallers
.add(new CacheClusterAlreadyExistsExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InvalidParameterValueExceptionUnmarshaller());
exceptionUnmarshallers
.add(new CacheSecurityGroupAlreadyExistsExceptionUnmarshaller());
exceptionUnmarshallers
.add(new SnapshotAlreadyExistsExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InvalidReplicationGroupStateExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InvalidCacheSecurityGroupStateExceptionUnmarshaller());
exceptionUnmarshallers
.add(new CacheSecurityGroupQuotaExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new SnapshotQuotaExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new CacheParameterGroupQuotaExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new ReservedCacheNodesOfferingNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new CacheParameterGroupAlreadyExistsExceptionUnmarshaller());
exceptionUnmarshallers
.add(new NodeQuotaForCustomerExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new CacheParameterGroupNotFoundExceptionUnmarshaller());
exceptionUnmarshallers.add(new TagNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new ClusterQuotaForCustomerExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new NodeQuotaForClusterExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InvalidCacheClusterStateExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InvalidVPCNetworkStateExceptionUnmarshaller());
exceptionUnmarshallers
.add(new CacheSubnetQuotaExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new SnapshotFeatureNotSupportedExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InvalidSnapshotStateExceptionUnmarshaller());
exceptionUnmarshallers
.add(new CacheSubnetGroupAlreadyExistsExceptionUnmarshaller());
exceptionUnmarshallers
.add(new CacheSubnetGroupQuotaExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new ReplicationGroupAlreadyExistsExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InsufficientCacheClusterCapacityExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InvalidParameterCombinationExceptionUnmarshaller());
exceptionUnmarshallers
.add(new ReservedCacheNodeNotFoundExceptionUnmarshaller());
exceptionUnmarshallers.add(new SnapshotNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new CacheSubnetGroupInUseExceptionUnmarshaller());
exceptionUnmarshallers
.add(new CacheSecurityGroupNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new InvalidCacheParameterGroupStateExceptionUnmarshaller());
exceptionUnmarshallers.add(new InvalidARNExceptionUnmarshaller());
exceptionUnmarshallers
.add(new TagQuotaPerResourceExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new ReplicationGroupNotFoundExceptionUnmarshaller());
exceptionUnmarshallers.add(new InvalidSubnetExceptionUnmarshaller());
exceptionUnmarshallers
.add(new AuthorizationAlreadyExistsExceptionUnmarshaller());
exceptionUnmarshallers
.add(new ReservedCacheNodeQuotaExceededExceptionUnmarshaller());
exceptionUnmarshallers
.add(new AuthorizationNotFoundExceptionUnmarshaller());
exceptionUnmarshallers
.add(new StandardErrorUnmarshaller(
com.amazonaws.services.elasticache.model.AmazonElastiCacheException.class));
setServiceNameIntern(DEFAULT_SIGNING_NAME);
setEndpointPrefix(ENDPOINT_PREFIX);
// calling this.setEndPoint(...) will also modify the signer accordingly
this.setEndpoint("elasticache.us-east-1.amazonaws.com");
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s
.addAll(chainFactory
.newRequestHandlerChain("/com/amazonaws/services/elasticache/request.handlers"));
requestHandler2s
.addAll(chainFactory
.newRequestHandler2Chain("/com/amazonaws/services/elasticache/request.handler2s"));
}
/**
*
* The AddTagsToResource action adds up to 10 cost allocation tags to
* the named resource. A cost allocation tag is a key-value pair
* where the key and value are case-sensitive. Cost allocation tags can be
* used to categorize and track your AWS costs.
*
*
* When you apply tags to your ElastiCache resources, AWS generates a cost
* allocation report as a comma-separated value (CSV) file with your usage
* and costs aggregated by your tags. You can apply tags that represent
* business categories (such as cost centers, application names, or owners)
* to organize your costs across multiple services. For more information,
* see Using Cost Allocation Tags in Amazon ElastiCache in the
* ElastiCache User Guide.
*
*
* @param addTagsToResourceRequest
* Represents the input of an AddTagsToResource action.
* @return Result of the AddTagsToResource operation returned by the
* service.
* @throws CacheClusterNotFoundException
* The requested cache cluster ID does not refer to an existing
* cache cluster.
* @throws SnapshotNotFoundException
* The requested snapshot name does not refer to an existing
* snapshot.
* @throws TagQuotaPerResourceExceededException
* The request cannot be processed because it would cause the
* resource to have more than the allowed number of tags. The
* maximum number of tags permitted on a resource is 10.
* @throws InvalidARNException
* The requested Amazon Resource Name (ARN) does not refer to an
* existing resource.
* @sample AmazonElastiCache.AddTagsToResource
*/
@Override
public AddTagsToResourceResult addTagsToResource(
AddTagsToResourceRequest addTagsToResourceRequest) {
ExecutionContext executionContext = createExecutionContext(addTagsToResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AddTagsToResourceRequestMarshaller()
.marshall(super
.beforeMarshalling(addTagsToResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new AddTagsToResourceResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The AuthorizeCacheSecurityGroupIngress action allows network
* ingress to a cache security group. Applications using ElastiCache must be
* running on Amazon EC2, and Amazon EC2 security groups are used as the
* authorization mechanism.
*
*
*
* You cannot authorize ingress from an Amazon EC2 security group in one
* region to an ElastiCache cluster in another region.
*
*
*
* @param authorizeCacheSecurityGroupIngressRequest
* Represents the input of an
* AuthorizeCacheSecurityGroupIngress action.
* @return Result of the AuthorizeCacheSecurityGroupIngress operation
* returned by the service.
* @throws CacheSecurityGroupNotFoundException
* The requested cache security group name does not refer to an
* existing cache security group.
* @throws InvalidCacheSecurityGroupStateException
* The current state of the cache security group does not allow
* deletion.
* @throws AuthorizationAlreadyExistsException
* The specified Amazon EC2 security group is already authorized for
* the specified cache security group.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.AuthorizeCacheSecurityGroupIngress
*/
@Override
public CacheSecurityGroup authorizeCacheSecurityGroupIngress(
AuthorizeCacheSecurityGroupIngressRequest authorizeCacheSecurityGroupIngressRequest) {
ExecutionContext executionContext = createExecutionContext(authorizeCacheSecurityGroupIngressRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AuthorizeCacheSecurityGroupIngressRequestMarshaller()
.marshall(super
.beforeMarshalling(authorizeCacheSecurityGroupIngressRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CacheSecurityGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The CopySnapshot action makes a copy of an existing snapshot.
*
*
*
* Users or groups that have permissions to use the CopySnapshot API
* can create their own Amazon S3 buckets and copy snapshots to it. To
* control access to your snapshots, use an IAM policy to control who has
* the ability to use the CopySnapshot API. For more information
* about using IAM to control the use of ElastiCache APIs, see Exporting Snapshots and Authentication & Access Control.
*
*
*
* Erorr Message:
*
*
* -
*
* Error Message: The authenticated user does not have sufficient
* permissions to perform the desired activity.
*
*
* Solution: Contact your system administrator to get the needed
* permissions.
*
*
*
*
* @param copySnapshotRequest
* Represents the input of a CopySnapshotMessage action.
* @return Result of the CopySnapshot operation returned by the service.
* @throws SnapshotAlreadyExistsException
* You already have a snapshot with the given name.
* @throws SnapshotNotFoundException
* The requested snapshot name does not refer to an existing
* snapshot.
* @throws SnapshotQuotaExceededException
* The request cannot be processed because it would exceed the
* maximum number of snapshots.
* @throws InvalidSnapshotStateException
* The current state of the snapshot does not allow the requested
* action to occur.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.CopySnapshot
*/
@Override
public Snapshot copySnapshot(CopySnapshotRequest copySnapshotRequest) {
ExecutionContext executionContext = createExecutionContext(copySnapshotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CopySnapshotRequestMarshaller().marshall(super
.beforeMarshalling(copySnapshotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new SnapshotStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The CreateCacheCluster action creates a cache cluster. All nodes
* in the cache cluster run the same protocol-compliant cache engine
* software, either Memcached or Redis.
*
*
* @param createCacheClusterRequest
* Represents the input of a CreateCacheCluster action.
* @return Result of the CreateCacheCluster operation returned by the
* service.
* @throws ReplicationGroupNotFoundException
* The specified replication group does not exist.
* @throws InvalidReplicationGroupStateException
* The requested replication group is not in the available
* state.
* @throws CacheClusterAlreadyExistsException
* You already have a cache cluster with the given identifier.
* @throws InsufficientCacheClusterCapacityException
* The requested cache node type is not available in the specified
* Availability Zone.
* @throws CacheSecurityGroupNotFoundException
* The requested cache security group name does not refer to an
* existing cache security group.
* @throws CacheSubnetGroupNotFoundException
* The requested cache subnet group name does not refer to an
* existing cache subnet group.
* @throws ClusterQuotaForCustomerExceededException
* The request cannot be processed because it would exceed the
* allowed number of cache clusters per customer.
* @throws NodeQuotaForClusterExceededException
* The request cannot be processed because it would exceed the
* allowed number of cache nodes in a single cache cluster.
* @throws NodeQuotaForCustomerExceededException
* The request cannot be processed because it would exceed the
* allowed number of cache nodes per customer.
* @throws CacheParameterGroupNotFoundException
* The requested cache parameter group name does not refer to an
* existing cache parameter group.
* @throws InvalidVPCNetworkStateException
* The VPC network is in an invalid state.
* @throws TagQuotaPerResourceExceededException
* The request cannot be processed because it would cause the
* resource to have more than the allowed number of tags. The
* maximum number of tags permitted on a resource is 10.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.CreateCacheCluster
*/
@Override
public CacheCluster createCacheCluster(
CreateCacheClusterRequest createCacheClusterRequest) {
ExecutionContext executionContext = createExecutionContext(createCacheClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateCacheClusterRequestMarshaller()
.marshall(super
.beforeMarshalling(createCacheClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CacheClusterStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The CreateCacheParameterGroup action creates a new cache parameter
* group. A cache parameter group is a collection of parameters that you
* apply to all of the nodes in a cache cluster.
*
*
* @param createCacheParameterGroupRequest
* Represents the input of a CreateCacheParameterGroup action.
* @return Result of the CreateCacheParameterGroup operation returned by the
* service.
* @throws CacheParameterGroupQuotaExceededException
* The request cannot be processed because it would exceed the
* maximum number of cache security groups.
* @throws CacheParameterGroupAlreadyExistsException
* A cache parameter group with the requested name already exists.
* @throws InvalidCacheParameterGroupStateException
* The current state of the cache parameter group does not allow the
* requested action to occur.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.CreateCacheParameterGroup
*/
@Override
public CacheParameterGroup createCacheParameterGroup(
CreateCacheParameterGroupRequest createCacheParameterGroupRequest) {
ExecutionContext executionContext = createExecutionContext(createCacheParameterGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateCacheParameterGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(createCacheParameterGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CacheParameterGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The CreateCacheSecurityGroup action creates a new cache security
* group. Use a cache security group to control access to one or more cache
* clusters.
*
*
* Cache security groups are only used when you are creating a cache cluster
* outside of an Amazon Virtual Private Cloud (VPC). If you are creating a
* cache cluster inside of a VPC, use a cache subnet group instead. For more
* information, see CreateCacheSubnetGroup.
*
*
* @param createCacheSecurityGroupRequest
* Represents the input of a CreateCacheSecurityGroup action.
* @return Result of the CreateCacheSecurityGroup operation returned by the
* service.
* @throws CacheSecurityGroupAlreadyExistsException
* A cache security group with the specified name already exists.
* @throws CacheSecurityGroupQuotaExceededException
* The request cannot be processed because it would exceed the
* allowed number of cache security groups.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.CreateCacheSecurityGroup
*/
@Override
public CacheSecurityGroup createCacheSecurityGroup(
CreateCacheSecurityGroupRequest createCacheSecurityGroupRequest) {
ExecutionContext executionContext = createExecutionContext(createCacheSecurityGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateCacheSecurityGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(createCacheSecurityGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CacheSecurityGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The CreateCacheSubnetGroup action creates a new cache subnet
* group.
*
*
* Use this parameter only when you are creating a cluster in an Amazon
* Virtual Private Cloud (VPC).
*
*
* @param createCacheSubnetGroupRequest
* Represents the input of a CreateCacheSubnetGroup action.
* @return Result of the CreateCacheSubnetGroup operation returned by the
* service.
* @throws CacheSubnetGroupAlreadyExistsException
* The requested cache subnet group name is already in use by an
* existing cache subnet group.
* @throws CacheSubnetGroupQuotaExceededException
* The request cannot be processed because it would exceed the
* allowed number of cache subnet groups.
* @throws CacheSubnetQuotaExceededException
* The request cannot be processed because it would exceed the
* allowed number of subnets in a cache subnet group.
* @throws InvalidSubnetException
* An invalid subnet identifier was specified.
* @sample AmazonElastiCache.CreateCacheSubnetGroup
*/
@Override
public CacheSubnetGroup createCacheSubnetGroup(
CreateCacheSubnetGroupRequest createCacheSubnetGroupRequest) {
ExecutionContext executionContext = createExecutionContext(createCacheSubnetGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateCacheSubnetGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(createCacheSubnetGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CacheSubnetGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The CreateReplicationGroup action creates a replication group. A
* replication group is a collection of cache clusters, where one of the
* cache clusters is a read/write primary and the others are read-only
* replicas. Writes to the primary are automatically propagated to the
* replicas.
*
*
* When you create a replication group, you must specify an existing cache
* cluster that is in the primary role. When the replication group has been
* successfully created, you can add one or more read replica replicas to
* it, up to a total of five read replicas.
*
*
*
* This action is valid only for Redis.
*
*
*
* @param createReplicationGroupRequest
* Represents the input of a CreateReplicationGroup action.
* @return Result of the CreateReplicationGroup operation returned by the
* service.
* @throws CacheClusterNotFoundException
* The requested cache cluster ID does not refer to an existing
* cache cluster.
* @throws InvalidCacheClusterStateException
* The requested cache cluster is not in the available state.
* @throws ReplicationGroupAlreadyExistsException
* The specified replication group already exists.
* @throws InsufficientCacheClusterCapacityException
* The requested cache node type is not available in the specified
* Availability Zone.
* @throws CacheSecurityGroupNotFoundException
* The requested cache security group name does not refer to an
* existing cache security group.
* @throws CacheSubnetGroupNotFoundException
* The requested cache subnet group name does not refer to an
* existing cache subnet group.
* @throws ClusterQuotaForCustomerExceededException
* The request cannot be processed because it would exceed the
* allowed number of cache clusters per customer.
* @throws NodeQuotaForClusterExceededException
* The request cannot be processed because it would exceed the
* allowed number of cache nodes in a single cache cluster.
* @throws NodeQuotaForCustomerExceededException
* The request cannot be processed because it would exceed the
* allowed number of cache nodes per customer.
* @throws CacheParameterGroupNotFoundException
* The requested cache parameter group name does not refer to an
* existing cache parameter group.
* @throws InvalidVPCNetworkStateException
* The VPC network is in an invalid state.
* @throws TagQuotaPerResourceExceededException
* The request cannot be processed because it would cause the
* resource to have more than the allowed number of tags. The
* maximum number of tags permitted on a resource is 10.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.CreateReplicationGroup
*/
@Override
public ReplicationGroup createReplicationGroup(
CreateReplicationGroupRequest createReplicationGroupRequest) {
ExecutionContext executionContext = createExecutionContext(createReplicationGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateReplicationGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(createReplicationGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ReplicationGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The CreateSnapshot action creates a copy of an entire cache
* cluster at a specific moment in time.
*
*
* @param createSnapshotRequest
* Represents the input of a CreateSnapshot action.
* @return Result of the CreateSnapshot operation returned by the service.
* @throws SnapshotAlreadyExistsException
* You already have a snapshot with the given name.
* @throws CacheClusterNotFoundException
* The requested cache cluster ID does not refer to an existing
* cache cluster.
* @throws InvalidCacheClusterStateException
* The requested cache cluster is not in the available state.
* @throws SnapshotQuotaExceededException
* The request cannot be processed because it would exceed the
* maximum number of snapshots.
* @throws SnapshotFeatureNotSupportedException
* You attempted one of the following actions:
*
* -
*
* Creating a snapshot of a Redis cache cluster running on a
* t1.micro cache node.
*
*
* -
*
* Creating a snapshot of a cache cluster that is running Memcached
* rather than Redis.
*
*
*
*
* Neither of these are supported by ElastiCache.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @sample AmazonElastiCache.CreateSnapshot
*/
@Override
public Snapshot createSnapshot(CreateSnapshotRequest createSnapshotRequest) {
ExecutionContext executionContext = createExecutionContext(createSnapshotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateSnapshotRequestMarshaller().marshall(super
.beforeMarshalling(createSnapshotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new SnapshotStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The DeleteCacheCluster action deletes a previously provisioned
* cache cluster. DeleteCacheCluster deletes all associated cache
* nodes, node endpoints and the cache cluster itself. When you receive a
* successful response from this action, Amazon ElastiCache immediately
* begins deleting the cache cluster; you cannot cancel or revert this
* action.
*
*
* This API cannot be used to delete a cache cluster that is the last read
* replica of a replication group that has Multi-AZ mode enabled.
*
*
* @param deleteCacheClusterRequest
* Represents the input of a DeleteCacheCluster action.
* @return Result of the DeleteCacheCluster operation returned by the
* service.
* @throws CacheClusterNotFoundException
* The requested cache cluster ID does not refer to an existing
* cache cluster.
* @throws InvalidCacheClusterStateException
* The requested cache cluster is not in the available state.
* @throws SnapshotAlreadyExistsException
* You already have a snapshot with the given name.
* @throws SnapshotFeatureNotSupportedException
* You attempted one of the following actions:
*
* -
*
* Creating a snapshot of a Redis cache cluster running on a
* t1.micro cache node.
*
*
* -
*
* Creating a snapshot of a cache cluster that is running Memcached
* rather than Redis.
*
*
*
*
* Neither of these are supported by ElastiCache.
* @throws SnapshotQuotaExceededException
* The request cannot be processed because it would exceed the
* maximum number of snapshots.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DeleteCacheCluster
*/
@Override
public CacheCluster deleteCacheCluster(
DeleteCacheClusterRequest deleteCacheClusterRequest) {
ExecutionContext executionContext = createExecutionContext(deleteCacheClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteCacheClusterRequestMarshaller()
.marshall(super
.beforeMarshalling(deleteCacheClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CacheClusterStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The DeleteCacheParameterGroup action deletes the specified cache
* parameter group. You cannot delete a cache parameter group if it is
* associated with any cache clusters.
*
*
* @param deleteCacheParameterGroupRequest
* Represents the input of a DeleteCacheParameterGroup action.
* @return Result of the DeleteCacheParameterGroup operation returned by the
* service.
* @throws InvalidCacheParameterGroupStateException
* The current state of the cache parameter group does not allow the
* requested action to occur.
* @throws CacheParameterGroupNotFoundException
* The requested cache parameter group name does not refer to an
* existing cache parameter group.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DeleteCacheParameterGroup
*/
@Override
public DeleteCacheParameterGroupResult deleteCacheParameterGroup(
DeleteCacheParameterGroupRequest deleteCacheParameterGroupRequest) {
ExecutionContext executionContext = createExecutionContext(deleteCacheParameterGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteCacheParameterGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(deleteCacheParameterGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteCacheParameterGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The DeleteCacheSecurityGroup action deletes a cache security
* group.
*
*
*
* You cannot delete a cache security group if it is associated with any
* cache clusters.
*
*
*
* @param deleteCacheSecurityGroupRequest
* Represents the input of a DeleteCacheSecurityGroup action.
* @return Result of the DeleteCacheSecurityGroup operation returned by the
* service.
* @throws InvalidCacheSecurityGroupStateException
* The current state of the cache security group does not allow
* deletion.
* @throws CacheSecurityGroupNotFoundException
* The requested cache security group name does not refer to an
* existing cache security group.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DeleteCacheSecurityGroup
*/
@Override
public DeleteCacheSecurityGroupResult deleteCacheSecurityGroup(
DeleteCacheSecurityGroupRequest deleteCacheSecurityGroupRequest) {
ExecutionContext executionContext = createExecutionContext(deleteCacheSecurityGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteCacheSecurityGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(deleteCacheSecurityGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteCacheSecurityGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The DeleteCacheSubnetGroup action deletes a cache subnet group.
*
*
*
* You cannot delete a cache subnet group if it is associated with any cache
* clusters.
*
*
*
* @param deleteCacheSubnetGroupRequest
* Represents the input of a DeleteCacheSubnetGroup action.
* @return Result of the DeleteCacheSubnetGroup operation returned by the
* service.
* @throws CacheSubnetGroupInUseException
* The requested cache subnet group is currently in use.
* @throws CacheSubnetGroupNotFoundException
* The requested cache subnet group name does not refer to an
* existing cache subnet group.
* @sample AmazonElastiCache.DeleteCacheSubnetGroup
*/
@Override
public DeleteCacheSubnetGroupResult deleteCacheSubnetGroup(
DeleteCacheSubnetGroupRequest deleteCacheSubnetGroupRequest) {
ExecutionContext executionContext = createExecutionContext(deleteCacheSubnetGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteCacheSubnetGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(deleteCacheSubnetGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteCacheSubnetGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The DeleteReplicationGroup action deletes an existing replication
* group. By default, this action deletes the entire replication group,
* including the primary cluster and all of the read replicas. You can
* optionally delete only the read replicas, while retaining the primary
* cluster.
*
*
* When you receive a successful response from this action, Amazon
* ElastiCache immediately begins deleting the selected resources; you
* cannot cancel or revert this action.
*
*
* @param deleteReplicationGroupRequest
* Represents the input of a DeleteReplicationGroup action.
* @return Result of the DeleteReplicationGroup operation returned by the
* service.
* @throws ReplicationGroupNotFoundException
* The specified replication group does not exist.
* @throws InvalidReplicationGroupStateException
* The requested replication group is not in the available
* state.
* @throws SnapshotAlreadyExistsException
* You already have a snapshot with the given name.
* @throws SnapshotFeatureNotSupportedException
* You attempted one of the following actions:
*
* -
*
* Creating a snapshot of a Redis cache cluster running on a
* t1.micro cache node.
*
*
* -
*
* Creating a snapshot of a cache cluster that is running Memcached
* rather than Redis.
*
*
*
*
* Neither of these are supported by ElastiCache.
* @throws SnapshotQuotaExceededException
* The request cannot be processed because it would exceed the
* maximum number of snapshots.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DeleteReplicationGroup
*/
@Override
public ReplicationGroup deleteReplicationGroup(
DeleteReplicationGroupRequest deleteReplicationGroupRequest) {
ExecutionContext executionContext = createExecutionContext(deleteReplicationGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteReplicationGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(deleteReplicationGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ReplicationGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The DeleteSnapshot action deletes an existing snapshot. When you
* receive a successful response from this action, ElastiCache immediately
* begins deleting the snapshot; you cannot cancel or revert this action.
*
*
* @param deleteSnapshotRequest
* Represents the input of a DeleteSnapshot action.
* @return Result of the DeleteSnapshot operation returned by the service.
* @throws SnapshotNotFoundException
* The requested snapshot name does not refer to an existing
* snapshot.
* @throws InvalidSnapshotStateException
* The current state of the snapshot does not allow the requested
* action to occur.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DeleteSnapshot
*/
@Override
public Snapshot deleteSnapshot(DeleteSnapshotRequest deleteSnapshotRequest) {
ExecutionContext executionContext = createExecutionContext(deleteSnapshotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteSnapshotRequestMarshaller().marshall(super
.beforeMarshalling(deleteSnapshotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new SnapshotStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The DescribeCacheClusters action returns information about all
* provisioned cache clusters if no cache cluster identifier is specified,
* or about a specific cache cluster if a cache cluster identifier is
* supplied.
*
*
* By default, abbreviated information about the cache clusters(s) will be
* returned. You can use the optional ShowDetails flag to retrieve
* detailed information about the cache nodes associated with the cache
* clusters. These details include the DNS address and port for the cache
* node endpoint.
*
*
* If the cluster is in the CREATING state, only cluster level information
* will be displayed until all of the nodes are successfully provisioned.
*
*
* If the cluster is in the DELETING state, only cluster level information
* will be displayed.
*
*
* If cache nodes are currently being added to the cache cluster, node
* endpoint information and creation time for the additional nodes will not
* be displayed until they are completely provisioned. When the cache
* cluster state is available, the cluster is ready for use.
*
*
* If cache nodes are currently being removed from the cache cluster, no
* endpoint information for the removed nodes is displayed.
*
*
* @param describeCacheClustersRequest
* Represents the input of a DescribeCacheClusters action.
* @return Result of the DescribeCacheClusters operation returned by the
* service.
* @throws CacheClusterNotFoundException
* The requested cache cluster ID does not refer to an existing
* cache cluster.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DescribeCacheClusters
*/
@Override
public DescribeCacheClustersResult describeCacheClusters(
DescribeCacheClustersRequest describeCacheClustersRequest) {
ExecutionContext executionContext = createExecutionContext(describeCacheClustersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeCacheClustersRequestMarshaller()
.marshall(super
.beforeMarshalling(describeCacheClustersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeCacheClustersResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeCacheClustersResult describeCacheClusters() {
return describeCacheClusters(new DescribeCacheClustersRequest());
}
/**
*
* The DescribeCacheEngineVersions action returns a list of the
* available cache engines and their versions.
*
*
* @param describeCacheEngineVersionsRequest
* Represents the input of a DescribeCacheEngineVersions
* action.
* @return Result of the DescribeCacheEngineVersions operation returned by
* the service.
* @sample AmazonElastiCache.DescribeCacheEngineVersions
*/
@Override
public DescribeCacheEngineVersionsResult describeCacheEngineVersions(
DescribeCacheEngineVersionsRequest describeCacheEngineVersionsRequest) {
ExecutionContext executionContext = createExecutionContext(describeCacheEngineVersionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeCacheEngineVersionsRequestMarshaller()
.marshall(super
.beforeMarshalling(describeCacheEngineVersionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeCacheEngineVersionsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeCacheEngineVersionsResult describeCacheEngineVersions() {
return describeCacheEngineVersions(new DescribeCacheEngineVersionsRequest());
}
/**
*
* The DescribeCacheParameterGroups action returns a list of cache
* parameter group descriptions. If a cache parameter group name is
* specified, the list will contain only the descriptions for that group.
*
*
* @param describeCacheParameterGroupsRequest
* Represents the input of a DescribeCacheParameterGroups
* action.
* @return Result of the DescribeCacheParameterGroups operation returned by
* the service.
* @throws CacheParameterGroupNotFoundException
* The requested cache parameter group name does not refer to an
* existing cache parameter group.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DescribeCacheParameterGroups
*/
@Override
public DescribeCacheParameterGroupsResult describeCacheParameterGroups(
DescribeCacheParameterGroupsRequest describeCacheParameterGroupsRequest) {
ExecutionContext executionContext = createExecutionContext(describeCacheParameterGroupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeCacheParameterGroupsRequestMarshaller()
.marshall(super
.beforeMarshalling(describeCacheParameterGroupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeCacheParameterGroupsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeCacheParameterGroupsResult describeCacheParameterGroups() {
return describeCacheParameterGroups(new DescribeCacheParameterGroupsRequest());
}
/**
*
* The DescribeCacheParameters action returns the detailed parameter
* list for a particular cache parameter group.
*
*
* @param describeCacheParametersRequest
* Represents the input of a DescribeCacheParameters action.
* @return Result of the DescribeCacheParameters operation returned by the
* service.
* @throws CacheParameterGroupNotFoundException
* The requested cache parameter group name does not refer to an
* existing cache parameter group.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DescribeCacheParameters
*/
@Override
public DescribeCacheParametersResult describeCacheParameters(
DescribeCacheParametersRequest describeCacheParametersRequest) {
ExecutionContext executionContext = createExecutionContext(describeCacheParametersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeCacheParametersRequestMarshaller()
.marshall(super
.beforeMarshalling(describeCacheParametersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeCacheParametersResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The DescribeCacheSecurityGroups action returns a list of cache
* security group descriptions. If a cache security group name is specified,
* the list will contain only the description of that group.
*
*
* @param describeCacheSecurityGroupsRequest
* Represents the input of a DescribeCacheSecurityGroups
* action.
* @return Result of the DescribeCacheSecurityGroups operation returned by
* the service.
* @throws CacheSecurityGroupNotFoundException
* The requested cache security group name does not refer to an
* existing cache security group.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DescribeCacheSecurityGroups
*/
@Override
public DescribeCacheSecurityGroupsResult describeCacheSecurityGroups(
DescribeCacheSecurityGroupsRequest describeCacheSecurityGroupsRequest) {
ExecutionContext executionContext = createExecutionContext(describeCacheSecurityGroupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeCacheSecurityGroupsRequestMarshaller()
.marshall(super
.beforeMarshalling(describeCacheSecurityGroupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeCacheSecurityGroupsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeCacheSecurityGroupsResult describeCacheSecurityGroups() {
return describeCacheSecurityGroups(new DescribeCacheSecurityGroupsRequest());
}
/**
*
* The DescribeCacheSubnetGroups action returns a list of cache
* subnet group descriptions. If a subnet group name is specified, the list
* will contain only the description of that group.
*
*
* @param describeCacheSubnetGroupsRequest
* Represents the input of a DescribeCacheSubnetGroups action.
* @return Result of the DescribeCacheSubnetGroups operation returned by the
* service.
* @throws CacheSubnetGroupNotFoundException
* The requested cache subnet group name does not refer to an
* existing cache subnet group.
* @sample AmazonElastiCache.DescribeCacheSubnetGroups
*/
@Override
public DescribeCacheSubnetGroupsResult describeCacheSubnetGroups(
DescribeCacheSubnetGroupsRequest describeCacheSubnetGroupsRequest) {
ExecutionContext executionContext = createExecutionContext(describeCacheSubnetGroupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeCacheSubnetGroupsRequestMarshaller()
.marshall(super
.beforeMarshalling(describeCacheSubnetGroupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeCacheSubnetGroupsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeCacheSubnetGroupsResult describeCacheSubnetGroups() {
return describeCacheSubnetGroups(new DescribeCacheSubnetGroupsRequest());
}
/**
*
* The DescribeEngineDefaultParameters action returns the default
* engine and system parameter information for the specified cache engine.
*
*
* @param describeEngineDefaultParametersRequest
* Represents the input of a DescribeEngineDefaultParameters
* action.
* @return Result of the DescribeEngineDefaultParameters operation returned
* by the service.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DescribeEngineDefaultParameters
*/
@Override
public EngineDefaults describeEngineDefaultParameters(
DescribeEngineDefaultParametersRequest describeEngineDefaultParametersRequest) {
ExecutionContext executionContext = createExecutionContext(describeEngineDefaultParametersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeEngineDefaultParametersRequestMarshaller()
.marshall(super
.beforeMarshalling(describeEngineDefaultParametersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new EngineDefaultsStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The DescribeEvents action returns events related to cache
* clusters, cache security groups, and cache parameter groups. You can
* obtain events specific to a particular cache cluster, cache security
* group, or cache parameter group by providing the name as a parameter.
*
*
* By default, only the events occurring within the last hour are returned;
* however, you can retrieve up to 14 days' worth of events if necessary.
*
*
* @param describeEventsRequest
* Represents the input of a DescribeEvents action.
* @return Result of the DescribeEvents operation returned by the service.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DescribeEvents
*/
@Override
public DescribeEventsResult describeEvents(
DescribeEventsRequest describeEventsRequest) {
ExecutionContext executionContext = createExecutionContext(describeEventsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeEventsRequestMarshaller().marshall(super
.beforeMarshalling(describeEventsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeEventsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeEventsResult describeEvents() {
return describeEvents(new DescribeEventsRequest());
}
/**
*
* The DescribeReplicationGroups action returns information about a
* particular replication group. If no identifier is specified,
* DescribeReplicationGroups returns information about all
* replication groups.
*
*
* @param describeReplicationGroupsRequest
* Represents the input of a DescribeReplicationGroups action.
* @return Result of the DescribeReplicationGroups operation returned by the
* service.
* @throws ReplicationGroupNotFoundException
* The specified replication group does not exist.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DescribeReplicationGroups
*/
@Override
public DescribeReplicationGroupsResult describeReplicationGroups(
DescribeReplicationGroupsRequest describeReplicationGroupsRequest) {
ExecutionContext executionContext = createExecutionContext(describeReplicationGroupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeReplicationGroupsRequestMarshaller()
.marshall(super
.beforeMarshalling(describeReplicationGroupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeReplicationGroupsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeReplicationGroupsResult describeReplicationGroups() {
return describeReplicationGroups(new DescribeReplicationGroupsRequest());
}
/**
*
* The DescribeReservedCacheNodes action returns information about
* reserved cache nodes for this account, or about a specified reserved
* cache node.
*
*
* @param describeReservedCacheNodesRequest
* Represents the input of a DescribeReservedCacheNodes
* action.
* @return Result of the DescribeReservedCacheNodes operation returned by
* the service.
* @throws ReservedCacheNodeNotFoundException
* The requested reserved cache node was not found.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DescribeReservedCacheNodes
*/
@Override
public DescribeReservedCacheNodesResult describeReservedCacheNodes(
DescribeReservedCacheNodesRequest describeReservedCacheNodesRequest) {
ExecutionContext executionContext = createExecutionContext(describeReservedCacheNodesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeReservedCacheNodesRequestMarshaller()
.marshall(super
.beforeMarshalling(describeReservedCacheNodesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeReservedCacheNodesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeReservedCacheNodesResult describeReservedCacheNodes() {
return describeReservedCacheNodes(new DescribeReservedCacheNodesRequest());
}
/**
*
* The DescribeReservedCacheNodesOfferings action lists available
* reserved cache node offerings.
*
*
* @param describeReservedCacheNodesOfferingsRequest
* Represents the input of a
* DescribeReservedCacheNodesOfferings action.
* @return Result of the DescribeReservedCacheNodesOfferings operation
* returned by the service.
* @throws ReservedCacheNodesOfferingNotFoundException
* The requested cache node offering does not exist.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DescribeReservedCacheNodesOfferings
*/
@Override
public DescribeReservedCacheNodesOfferingsResult describeReservedCacheNodesOfferings(
DescribeReservedCacheNodesOfferingsRequest describeReservedCacheNodesOfferingsRequest) {
ExecutionContext executionContext = createExecutionContext(describeReservedCacheNodesOfferingsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeReservedCacheNodesOfferingsRequestMarshaller()
.marshall(super
.beforeMarshalling(describeReservedCacheNodesOfferingsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeReservedCacheNodesOfferingsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeReservedCacheNodesOfferingsResult describeReservedCacheNodesOfferings() {
return describeReservedCacheNodesOfferings(new DescribeReservedCacheNodesOfferingsRequest());
}
/**
*
* The DescribeSnapshots action returns information about cache
* cluster snapshots. By default, DescribeSnapshots lists all of your
* snapshots; it can optionally describe a single snapshot, or just the
* snapshots associated with a particular cache cluster.
*
*
* @param describeSnapshotsRequest
* Represents the input of a DescribeSnapshotsMessage action.
* @return Result of the DescribeSnapshots operation returned by the
* service.
* @throws CacheClusterNotFoundException
* The requested cache cluster ID does not refer to an existing
* cache cluster.
* @throws SnapshotNotFoundException
* The requested snapshot name does not refer to an existing
* snapshot.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DescribeSnapshots
*/
@Override
public DescribeSnapshotsResult describeSnapshots(
DescribeSnapshotsRequest describeSnapshotsRequest) {
ExecutionContext executionContext = createExecutionContext(describeSnapshotsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeSnapshotsRequestMarshaller()
.marshall(super
.beforeMarshalling(describeSnapshotsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeSnapshotsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeSnapshotsResult describeSnapshots() {
return describeSnapshots(new DescribeSnapshotsRequest());
}
/**
*
* The ListAllowedNodeTypeModifications action lists all
* available node types that you can scale your Redis cluster's or
* replication group's current node type up to.
*
*
* When you use the ModifyCacheCluster or
* ModifyReplicationGroup APIs to scale up your cluster or
* replication group, the value of the CacheNodeType parameter must
* be one of the node types returned by this action.
*
*
* @param listAllowedNodeTypeModificationsRequest
* The input parameters for the
* ListAllowedNodeTypeModifications action.
* @return Result of the ListAllowedNodeTypeModifications operation returned
* by the service.
* @throws CacheClusterNotFoundException
* The requested cache cluster ID does not refer to an existing
* cache cluster.
* @throws ReplicationGroupNotFoundException
* The specified replication group does not exist.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @sample AmazonElastiCache.ListAllowedNodeTypeModifications
*/
@Override
public ListAllowedNodeTypeModificationsResult listAllowedNodeTypeModifications(
ListAllowedNodeTypeModificationsRequest listAllowedNodeTypeModificationsRequest) {
ExecutionContext executionContext = createExecutionContext(listAllowedNodeTypeModificationsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListAllowedNodeTypeModificationsRequestMarshaller()
.marshall(super
.beforeMarshalling(listAllowedNodeTypeModificationsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ListAllowedNodeTypeModificationsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public ListAllowedNodeTypeModificationsResult listAllowedNodeTypeModifications() {
return listAllowedNodeTypeModifications(new ListAllowedNodeTypeModificationsRequest());
}
/**
*
* The ListTagsForResource action lists all cost allocation tags
* currently on the named resource. A cost allocation tag is a
* key-value pair where the key is case-sensitive and the value is optional.
* Cost allocation tags can be used to categorize and track your AWS costs.
*
*
* You can have a maximum of 10 cost allocation tags on an ElastiCache
* resource. For more information, see Using Cost Allocation Tags in Amazon ElastiCache.
*
*
* @param listTagsForResourceRequest
* The input parameters for the ListTagsForResource action.
* @return Result of the ListTagsForResource operation returned by the
* service.
* @throws CacheClusterNotFoundException
* The requested cache cluster ID does not refer to an existing
* cache cluster.
* @throws SnapshotNotFoundException
* The requested snapshot name does not refer to an existing
* snapshot.
* @throws InvalidARNException
* The requested Amazon Resource Name (ARN) does not refer to an
* existing resource.
* @sample AmazonElastiCache.ListTagsForResource
*/
@Override
public ListTagsForResourceResult listTagsForResource(
ListTagsForResourceRequest listTagsForResourceRequest) {
ExecutionContext executionContext = createExecutionContext(listTagsForResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListTagsForResourceRequestMarshaller()
.marshall(super
.beforeMarshalling(listTagsForResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ListTagsForResourceResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The ModifyCacheCluster action modifies the settings for a cache
* cluster. You can use this action to change one or more cluster
* configuration parameters by specifying the parameters and the new values.
*
*
* @param modifyCacheClusterRequest
* Represents the input of a ModifyCacheCluster action.
* @return Result of the ModifyCacheCluster operation returned by the
* service.
* @throws InvalidCacheClusterStateException
* The requested cache cluster is not in the available state.
* @throws InvalidCacheSecurityGroupStateException
* The current state of the cache security group does not allow
* deletion.
* @throws InsufficientCacheClusterCapacityException
* The requested cache node type is not available in the specified
* Availability Zone.
* @throws CacheClusterNotFoundException
* The requested cache cluster ID does not refer to an existing
* cache cluster.
* @throws NodeQuotaForClusterExceededException
* The request cannot be processed because it would exceed the
* allowed number of cache nodes in a single cache cluster.
* @throws NodeQuotaForCustomerExceededException
* The request cannot be processed because it would exceed the
* allowed number of cache nodes per customer.
* @throws CacheSecurityGroupNotFoundException
* The requested cache security group name does not refer to an
* existing cache security group.
* @throws CacheParameterGroupNotFoundException
* The requested cache parameter group name does not refer to an
* existing cache parameter group.
* @throws InvalidVPCNetworkStateException
* The VPC network is in an invalid state.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.ModifyCacheCluster
*/
@Override
public CacheCluster modifyCacheCluster(
ModifyCacheClusterRequest modifyCacheClusterRequest) {
ExecutionContext executionContext = createExecutionContext(modifyCacheClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyCacheClusterRequestMarshaller()
.marshall(super
.beforeMarshalling(modifyCacheClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CacheClusterStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The ModifyCacheParameterGroup action modifies the parameters of a
* cache parameter group. You can modify up to 20 parameters in a single
* request by submitting a list parameter name and value pairs.
*
*
* @param modifyCacheParameterGroupRequest
* Represents the input of a ModifyCacheParameterGroup action.
* @return Result of the ModifyCacheParameterGroup operation returned by the
* service.
* @throws CacheParameterGroupNotFoundException
* The requested cache parameter group name does not refer to an
* existing cache parameter group.
* @throws InvalidCacheParameterGroupStateException
* The current state of the cache parameter group does not allow the
* requested action to occur.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.ModifyCacheParameterGroup
*/
@Override
public ModifyCacheParameterGroupResult modifyCacheParameterGroup(
ModifyCacheParameterGroupRequest modifyCacheParameterGroupRequest) {
ExecutionContext executionContext = createExecutionContext(modifyCacheParameterGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyCacheParameterGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(modifyCacheParameterGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ModifyCacheParameterGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The ModifyCacheSubnetGroup action modifies an existing cache
* subnet group.
*
*
* @param modifyCacheSubnetGroupRequest
* Represents the input of a ModifyCacheSubnetGroup action.
* @return Result of the ModifyCacheSubnetGroup operation returned by the
* service.
* @throws CacheSubnetGroupNotFoundException
* The requested cache subnet group name does not refer to an
* existing cache subnet group.
* @throws CacheSubnetQuotaExceededException
* The request cannot be processed because it would exceed the
* allowed number of subnets in a cache subnet group.
* @throws SubnetInUseException
* The requested subnet is being used by another cache subnet group.
* @throws InvalidSubnetException
* An invalid subnet identifier was specified.
* @sample AmazonElastiCache.ModifyCacheSubnetGroup
*/
@Override
public CacheSubnetGroup modifyCacheSubnetGroup(
ModifyCacheSubnetGroupRequest modifyCacheSubnetGroupRequest) {
ExecutionContext executionContext = createExecutionContext(modifyCacheSubnetGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyCacheSubnetGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(modifyCacheSubnetGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CacheSubnetGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The ModifyReplicationGroup action modifies the settings for a
* replication group.
*
*
* @param modifyReplicationGroupRequest
* Represents the input of a ModifyReplicationGroups action.
* @return Result of the ModifyReplicationGroup operation returned by the
* service.
* @throws ReplicationGroupNotFoundException
* The specified replication group does not exist.
* @throws InvalidReplicationGroupStateException
* The requested replication group is not in the available
* state.
* @throws InvalidCacheClusterStateException
* The requested cache cluster is not in the available state.
* @throws InvalidCacheSecurityGroupStateException
* The current state of the cache security group does not allow
* deletion.
* @throws InsufficientCacheClusterCapacityException
* The requested cache node type is not available in the specified
* Availability Zone.
* @throws CacheClusterNotFoundException
* The requested cache cluster ID does not refer to an existing
* cache cluster.
* @throws NodeQuotaForClusterExceededException
* The request cannot be processed because it would exceed the
* allowed number of cache nodes in a single cache cluster.
* @throws NodeQuotaForCustomerExceededException
* The request cannot be processed because it would exceed the
* allowed number of cache nodes per customer.
* @throws CacheSecurityGroupNotFoundException
* The requested cache security group name does not refer to an
* existing cache security group.
* @throws CacheParameterGroupNotFoundException
* The requested cache parameter group name does not refer to an
* existing cache parameter group.
* @throws InvalidVPCNetworkStateException
* The VPC network is in an invalid state.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.ModifyReplicationGroup
*/
@Override
public ReplicationGroup modifyReplicationGroup(
ModifyReplicationGroupRequest modifyReplicationGroupRequest) {
ExecutionContext executionContext = createExecutionContext(modifyReplicationGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyReplicationGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(modifyReplicationGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ReplicationGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The PurchaseReservedCacheNodesOffering action allows you to
* purchase a reserved cache node offering.
*
*
* @param purchaseReservedCacheNodesOfferingRequest
* Represents the input of a
* PurchaseReservedCacheNodesOffering action.
* @return Result of the PurchaseReservedCacheNodesOffering operation
* returned by the service.
* @throws ReservedCacheNodesOfferingNotFoundException
* The requested cache node offering does not exist.
* @throws ReservedCacheNodeAlreadyExistsException
* You already have a reservation with the given identifier.
* @throws ReservedCacheNodeQuotaExceededException
* The request cannot be processed because it would exceed the
* user's cache node quota.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.PurchaseReservedCacheNodesOffering
*/
@Override
public ReservedCacheNode purchaseReservedCacheNodesOffering(
PurchaseReservedCacheNodesOfferingRequest purchaseReservedCacheNodesOfferingRequest) {
ExecutionContext executionContext = createExecutionContext(purchaseReservedCacheNodesOfferingRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new PurchaseReservedCacheNodesOfferingRequestMarshaller()
.marshall(super
.beforeMarshalling(purchaseReservedCacheNodesOfferingRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ReservedCacheNodeStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The RebootCacheCluster action reboots some, or all, of the cache
* nodes within a provisioned cache cluster. This API will apply any
* modified cache parameter groups to the cache cluster. The reboot action
* takes place as soon as possible, and results in a momentary outage to the
* cache cluster. During the reboot, the cache cluster status is set to
* REBOOTING.
*
*
* The reboot causes the contents of the cache (for each cache node being
* rebooted) to be lost.
*
*
* When the reboot is complete, a cache cluster event is created.
*
*
* @param rebootCacheClusterRequest
* Represents the input of a RebootCacheCluster action.
* @return Result of the RebootCacheCluster operation returned by the
* service.
* @throws InvalidCacheClusterStateException
* The requested cache cluster is not in the available state.
* @throws CacheClusterNotFoundException
* The requested cache cluster ID does not refer to an existing
* cache cluster.
* @sample AmazonElastiCache.RebootCacheCluster
*/
@Override
public CacheCluster rebootCacheCluster(
RebootCacheClusterRequest rebootCacheClusterRequest) {
ExecutionContext executionContext = createExecutionContext(rebootCacheClusterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RebootCacheClusterRequestMarshaller()
.marshall(super
.beforeMarshalling(rebootCacheClusterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CacheClusterStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The RemoveTagsFromResource action removes the tags identified by
* the TagKeys list from the named resource.
*
*
* @param removeTagsFromResourceRequest
* Represents the input of a RemoveTagsFromResource action.
* @return Result of the RemoveTagsFromResource operation returned by the
* service.
* @throws CacheClusterNotFoundException
* The requested cache cluster ID does not refer to an existing
* cache cluster.
* @throws SnapshotNotFoundException
* The requested snapshot name does not refer to an existing
* snapshot.
* @throws InvalidARNException
* The requested Amazon Resource Name (ARN) does not refer to an
* existing resource.
* @throws TagNotFoundException
* The requested tag was not found on this resource.
* @sample AmazonElastiCache.RemoveTagsFromResource
*/
@Override
public RemoveTagsFromResourceResult removeTagsFromResource(
RemoveTagsFromResourceRequest removeTagsFromResourceRequest) {
ExecutionContext executionContext = createExecutionContext(removeTagsFromResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RemoveTagsFromResourceRequestMarshaller()
.marshall(super
.beforeMarshalling(removeTagsFromResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new RemoveTagsFromResourceResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The ResetCacheParameterGroup action modifies the parameters of a
* cache parameter group to the engine or system default value. You can
* reset specific parameters by submitting a list of parameter names. To
* reset the entire cache parameter group, specify the
* ResetAllParameters and CacheParameterGroupName parameters.
*
*
* @param resetCacheParameterGroupRequest
* Represents the input of a ResetCacheParameterGroup action.
* @return Result of the ResetCacheParameterGroup operation returned by the
* service.
* @throws InvalidCacheParameterGroupStateException
* The current state of the cache parameter group does not allow the
* requested action to occur.
* @throws CacheParameterGroupNotFoundException
* The requested cache parameter group name does not refer to an
* existing cache parameter group.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.ResetCacheParameterGroup
*/
@Override
public ResetCacheParameterGroupResult resetCacheParameterGroup(
ResetCacheParameterGroupRequest resetCacheParameterGroupRequest) {
ExecutionContext executionContext = createExecutionContext(resetCacheParameterGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ResetCacheParameterGroupRequestMarshaller()
.marshall(super
.beforeMarshalling(resetCacheParameterGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ResetCacheParameterGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* The RevokeCacheSecurityGroupIngress action revokes ingress from a
* cache security group. Use this action to disallow access from an Amazon
* EC2 security group that had been previously authorized.
*
*
* @param revokeCacheSecurityGroupIngressRequest
* Represents the input of a RevokeCacheSecurityGroupIngress
* action.
* @return Result of the RevokeCacheSecurityGroupIngress operation returned
* by the service.
* @throws CacheSecurityGroupNotFoundException
* The requested cache security group name does not refer to an
* existing cache security group.
* @throws AuthorizationNotFoundException
* The specified Amazon EC2 security group is not authorized for the
* specified cache security group.
* @throws InvalidCacheSecurityGroupStateException
* The current state of the cache security group does not allow
* deletion.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.RevokeCacheSecurityGroupIngress
*/
@Override
public CacheSecurityGroup revokeCacheSecurityGroupIngress(
RevokeCacheSecurityGroupIngressRequest revokeCacheSecurityGroupIngressRequest) {
ExecutionContext executionContext = createExecutionContext(revokeCacheSecurityGroupIngressRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RevokeCacheSecurityGroupIngressRequestMarshaller()
.marshall(super
.beforeMarshalling(revokeCacheSecurityGroupIngressRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CacheSecurityGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* 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.
*
* 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);
}
/**
* Normal invoke with authentication. Credentials are required and may be
* overriden at the request level.
**/
private Response invoke(
Request request,
HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
executionContext.setCredentialsProvider(CredentialUtils
.getCredentialsProvider(request.getOriginalRequest(),
awsCredentialsProvider));
return doInvoke(request, responseHandler, executionContext);
}
/**
* Invoke with no authentication. Credentials are not required and any
* credentials set on the client or request will be ignored for this
* operation.
**/
private Response anonymousInvoke(
Request request,
HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
return doInvoke(request, responseHandler, executionContext);
}
/**
* Invoke the request using the http client. Assumes credentials (or lack
* thereof) have been configured in the ExecutionContext beforehand.
**/
private Response doInvoke(
Request request,
HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
request.setEndpoint(endpoint);
request.setTimeOffset(timeOffset);
DefaultErrorResponseHandler errorResponseHandler = new DefaultErrorResponseHandler(
exceptionUnmarshallers);
return client.execute(request, responseHandler, errorResponseHandler,
executionContext);
}
}