Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * Copyright 2010-2015 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;
  
  
  
Asynchronous client for accessing AmazonElastiCache. All asynchronous calls made using this client are non-blocking. Callers could either process the result and handle the exceptions in the worker thread by providing a callback handler when making the call, or use the returned Future object to check the result of the call in the calling thread. 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.

  
          implements AmazonElastiCacheAsync {

    
Executor service for executing asynchronous requests.
  
      private ExecutorService executorService;
  
      private static final int DEFAULT_THREAD_POOL_SIZE = 50;

    
Constructs a new asynchronous client to invoke service methods on AmazonElastiCache. 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.

  
      public AmazonElastiCacheAsyncClient() {
          this(new DefaultAWSCredentialsProviderChain());
      }

    
Constructs a new asynchronous client to invoke service methods on AmazonElastiCache. 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.

Parameters:
clientConfiguration The client configuration options controlling how this client connects to AmazonElastiCache (ex: proxy settings, retry counts, etc.).
See also:
com.amazonaws.auth.DefaultAWSCredentialsProviderChain
 
     public AmazonElastiCacheAsyncClient(ClientConfiguration clientConfiguration) {
         this(new DefaultAWSCredentialsProviderChain(), clientConfiguration, Executors.newFixedThreadPool(clientConfiguration.getMaxConnections()));
     }

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

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

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

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

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

Parameters:
awsCredentials The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
executorService The executor service by which all asynchronous requests will be executed.
 
     public AmazonElastiCacheAsyncClient(AWSCredentials awsCredentialsExecutorService executorService) {
         super(awsCredentials);
         this. = executorService;
     }

    
Constructs a new asynchronous client to invoke service methods on AmazonElastiCache using the specified AWS account credentials, executor service, and client configuration options.

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

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

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

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

Parameters:
awsCredentialsProvider The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
 
     public AmazonElastiCacheAsyncClient(AWSCredentialsProvider awsCredentialsProvider) {
         this(awsCredentialsProvider, Executors.newFixedThreadPool());
     }

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

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

Parameters:
awsCredentialsProvider The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
executorService The executor service by which all asynchronous requests will be executed.
 
     public AmazonElastiCacheAsyncClient(AWSCredentialsProvider awsCredentialsProviderExecutorService executorService) {
         this(awsCredentialsProvidernew ClientConfiguration(), executorService);
     }

    
Constructs a new asynchronous client to invoke service methods on AmazonElastiCache using the specified AWS account credentials provider and client configuration options.

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

Parameters:
awsCredentialsProvider The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
clientConfiguration Client configuration options (ex: max retry limit, proxy settings, etc).
 
     public AmazonElastiCacheAsyncClient(AWSCredentialsProvider awsCredentialsProvider,
                 ClientConfiguration clientConfiguration) {
         this(awsCredentialsProviderclientConfiguration, Executors.newFixedThreadPool(clientConfiguration.getMaxConnections()));
     }

    
Constructs a new asynchronous client to invoke service methods on AmazonElastiCache using the specified AWS account credentials provider, executor service, and client configuration options.

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

Parameters:
awsCredentialsProvider The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
clientConfiguration Client configuration options (ex: max retry limit, proxy settings, etc).
executorService The executor service by which all asynchronous requests will be executed.
 
     public AmazonElastiCacheAsyncClient(AWSCredentialsProvider awsCredentialsProvider,
                 ClientConfiguration clientConfigurationExecutorService executorService) {
         super(awsCredentialsProviderclientConfiguration);
         this. = executorService;
     }

    
Returns the executor service used by this async client to execute requests.

Returns:
The executor service used by this async client to execute requests.
 
     public ExecutorService getExecutorService() {
         return ;
     }

    
Shuts down the client, releasing all managed resources. This includes forcibly terminating all pending asynchronous service calls. Clients who wish to give pending asynchronous service calls time to complete should call getExecutorService().shutdown() followed by getExecutorService().awaitTermination() prior to calling this method.
 
     @Override
     public void shutdown() {
         super.shutdown();
         .shutdownNow();
     }
            
    

The DescribeEngineDefaultParameters action returns the default engine and system parameter information for the specified cache engine.

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

    

The DescribeEngineDefaultParameters action returns the default engine and system parameter information for the specified cache engine.

Parameters:
describeEngineDefaultParametersRequest Container for the necessary parameters to execute the DescribeEngineDefaultParameters operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DescribeEngineDefaultParameters service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
 
             final DescribeEngineDefaultParametersRequest describeEngineDefaultParametersRequest,
             final AsyncHandler<DescribeEngineDefaultParametersRequestEngineDefaultsasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<EngineDefaults>() {
             public EngineDefaults call() throws Exception {
               EngineDefaults result;
                 try {
                 result = describeEngineDefaultParameters(describeEngineDefaultParametersRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(describeEngineDefaultParametersRequestresult);
                  return result;
         }
     });
     }
    
    

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.

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

    

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.

Parameters:
deleteCacheClusterRequest Container for the necessary parameters to execute the DeleteCacheCluster operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DeleteCacheCluster service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
 
             final DeleteCacheClusterRequest deleteCacheClusterRequest,
             final AsyncHandler<DeleteCacheClusterRequestCacheClusterasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<CacheCluster>() {
             public CacheCluster call() throws Exception {
               CacheCluster result;
                 try {
                 result = deleteCacheCluster(deleteCacheClusterRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(deleteCacheClusterRequestresult);
                  return result;
         }
     });
     }
    
    

The DescribeReservedCacheNodes action returns information about reserved cache nodes for this account, or about a specified reserved cache node.

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

    

The DescribeReservedCacheNodes action returns information about reserved cache nodes for this account, or about a specified reserved cache node.

Parameters:
describeReservedCacheNodesRequest Container for the necessary parameters to execute the DescribeReservedCacheNodes operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DescribeReservedCacheNodes service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
 
             final DescribeReservedCacheNodesRequest describeReservedCacheNodesRequest,
                     throws AmazonServiceExceptionAmazonClientException {
             public DescribeReservedCacheNodesResult call() throws Exception {
               DescribeReservedCacheNodesResult result;
                 try {
                 result = describeReservedCacheNodes(describeReservedCacheNodesRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(describeReservedCacheNodesRequestresult);
                  return result;
         }
     });
     }
    
    

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.

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

    

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.

Parameters:
deleteReplicationGroupRequest Container for the necessary parameters to execute the DeleteReplicationGroup operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DeleteReplicationGroup service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
 
             final DeleteReplicationGroupRequest deleteReplicationGroupRequest,
             final AsyncHandler<DeleteReplicationGroupRequestReplicationGroupasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<ReplicationGroup>() {
             public ReplicationGroup call() throws Exception {
               ReplicationGroup result;
                 try {
                 result = deleteReplicationGroup(deleteReplicationGroupRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(deleteReplicationGroupRequestresult);
                  return result;
         }
     });
     }
    
    

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.

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

    

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.

Parameters:
deleteSnapshotRequest Container for the necessary parameters to execute the DeleteSnapshot operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DeleteSnapshot service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
 
             final DeleteSnapshotRequest deleteSnapshotRequest,
             final AsyncHandler<DeleteSnapshotRequestSnapshotasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<Snapshot>() {
             public Snapshot call() throws Exception {
               Snapshot result;
                 try {
                 result = deleteSnapshot(deleteSnapshotRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(deleteSnapshotRequestresult);
                  return result;
         }
     });
     }
    
    

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).

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

    

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).

Parameters:
createCacheSubnetGroupRequest Container for the necessary parameters to execute the CreateCacheSubnetGroup operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the CreateCacheSubnetGroup service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
 
             final CreateCacheSubnetGroupRequest createCacheSubnetGroupRequest,
             final AsyncHandler<CreateCacheSubnetGroupRequestCacheSubnetGroupasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<CacheSubnetGroup>() {
             public CacheSubnetGroup call() throws Exception {
               CacheSubnetGroup result;
                 try {
                 result = createCacheSubnetGroup(createCacheSubnetGroupRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(createCacheSubnetGroupRequestresult);
                  return result;
         }
     });
     }
    
    

The DeleteCacheSubnetGroup action deletes a cache subnet group.

NOTE:You cannot delete a cache subnet group if it is associated with any cache clusters.

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

    

The DeleteCacheSubnetGroup action deletes a cache subnet group.

NOTE:You cannot delete a cache subnet group if it is associated with any cache clusters.

Parameters:
deleteCacheSubnetGroupRequest Container for the necessary parameters to execute the DeleteCacheSubnetGroup operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DeleteCacheSubnetGroup service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
 
             final DeleteCacheSubnetGroupRequest deleteCacheSubnetGroupRequest,
             final AsyncHandler<DeleteCacheSubnetGroupRequestVoidasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
         return .submit(new Callable<Void>() {
             public Void call() throws Exception {
               try {
                 deleteCacheSubnetGroup(deleteCacheSubnetGroupRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(deleteCacheSubnetGroupRequestnull);
                  return null;
         }
     });
     }
    
    

The DescribeCacheParameters action returns the detailed parameter list for a particular cache parameter group.

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

    

The DescribeCacheParameters action returns the detailed parameter list for a particular cache parameter group.

Parameters:
describeCacheParametersRequest Container for the necessary parameters to execute the DescribeCacheParameters operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DescribeCacheParameters service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
 
             final DescribeCacheParametersRequest describeCacheParametersRequest,
             final AsyncHandler<DescribeCacheParametersRequestDescribeCacheParametersResultasyncHandler)
                     throws AmazonServiceExceptionAmazonClientException {
             public DescribeCacheParametersResult call() throws Exception {
               DescribeCacheParametersResult result;
                 try {
                 result = describeCacheParameters(describeCacheParametersRequest);
               } catch (Exception ex) {
                   asyncHandler.onError(ex);
             throw ex;
               }
               asyncHandler.onSuccess(describeCacheParametersRequestresult);
                  return result;
         }
     });
     }
    
    

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 .

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

    

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 .

Parameters:
listTagsForResourceRequest Container for the necessary parameters to execute the ListTagsForResource operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the ListTagsForResource service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
            final ListTagsForResourceRequest listTagsForResourceRequest,
            final AsyncHandler<ListTagsForResourceRequestListTagsForResourceResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
            public ListTagsForResourceResult call() throws Exception {
              ListTagsForResourceResult result;
                try {
                result = listTagsForResource(listTagsForResourceRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(listTagsForResourceRequestresult);
                 return result;
        }
    });
    }
    
    

The DeleteCacheSecurityGroup action deletes a cache security group.

NOTE:You cannot delete a cache security group if it is associated with any cache clusters.

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

    

The DeleteCacheSecurityGroup action deletes a cache security group.

NOTE:You cannot delete a cache security group if it is associated with any cache clusters.

Parameters:
deleteCacheSecurityGroupRequest Container for the necessary parameters to execute the DeleteCacheSecurityGroup operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DeleteCacheSecurityGroup service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
            final DeleteCacheSecurityGroupRequest deleteCacheSecurityGroupRequest,
            final AsyncHandler<DeleteCacheSecurityGroupRequestVoidasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<Void>() {
            public Void call() throws Exception {
              try {
                deleteCacheSecurityGroup(deleteCacheSecurityGroupRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(deleteCacheSecurityGroupRequestnull);
                 return null;
        }
    });
    }
    
    

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 .

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

    

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 .

Parameters:
addTagsToResourceRequest Container for the necessary parameters to execute the AddTagsToResource operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the AddTagsToResource service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
            final AddTagsToResourceRequest addTagsToResourceRequest,
            final AsyncHandler<AddTagsToResourceRequestAddTagsToResourceResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<AddTagsToResourceResult>() {
            public AddTagsToResourceResult call() throws Exception {
              AddTagsToResourceResult result;
                try {
                result = addTagsToResource(addTagsToResourceRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(addTagsToResourceRequestresult);
                 return result;
        }
    });
    }
    
    

The CopySnapshot action makes a copy of an existing snapshot.

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

    

The CopySnapshot action makes a copy of an existing snapshot.

Parameters:
copySnapshotRequest Container for the necessary parameters to execute the CopySnapshot operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the CopySnapshot service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
            final CopySnapshotRequest copySnapshotRequest,
            final AsyncHandler<CopySnapshotRequestSnapshotasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<Snapshot>() {
            public Snapshot call() throws Exception {
              Snapshot result;
                try {
                result = copySnapshot(copySnapshotRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(copySnapshotRequestresult);
                 return result;
        }
    });
    }
    
    

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.

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

    

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.

Parameters:
describeSnapshotsRequest Container for the necessary parameters to execute the DescribeSnapshots operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DescribeSnapshots service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
            final DescribeSnapshotsRequest describeSnapshotsRequest,
            final AsyncHandler<DescribeSnapshotsRequestDescribeSnapshotsResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<DescribeSnapshotsResult>() {
            public DescribeSnapshotsResult call() throws Exception {
              DescribeSnapshotsResult result;
                try {
                result = describeSnapshots(describeSnapshotsRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(describeSnapshotsRequestresult);
                 return result;
        }
    });
    }
    
    

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.

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

    

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.

Parameters:
describeCacheSecurityGroupsRequest Container for the necessary parameters to execute the DescribeCacheSecurityGroups operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DescribeCacheSecurityGroups service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
            final DescribeCacheSecurityGroupsRequest describeCacheSecurityGroupsRequest,
                    throws AmazonServiceExceptionAmazonClientException {
            public DescribeCacheSecurityGroupsResult call() throws Exception {
              DescribeCacheSecurityGroupsResult result;
                try {
                result = describeCacheSecurityGroups(describeCacheSecurityGroupsRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(describeCacheSecurityGroupsRequestresult);
                 return result;
        }
    });
    }
    
    

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.

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

    

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.

Parameters:
revokeCacheSecurityGroupIngressRequest Container for the necessary parameters to execute the RevokeCacheSecurityGroupIngress operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the RevokeCacheSecurityGroupIngress service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
            final RevokeCacheSecurityGroupIngressRequest revokeCacheSecurityGroupIngressRequest,
            final AsyncHandler<RevokeCacheSecurityGroupIngressRequestCacheSecurityGroupasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<CacheSecurityGroup>() {
            public CacheSecurityGroup call() throws Exception {
              CacheSecurityGroup result;
                try {
                result = revokeCacheSecurityGroupIngress(revokeCacheSecurityGroupIngressRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(revokeCacheSecurityGroupIngressRequestresult);
                 return result;
        }
    });
    }
    
    

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.

Note: This action is valid only for Redis.

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

    

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.

Note: This action is valid only for Redis.

Parameters:
createReplicationGroupRequest Container for the necessary parameters to execute the CreateReplicationGroup operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the CreateReplicationGroup service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
            final CreateReplicationGroupRequest createReplicationGroupRequest,
            final AsyncHandler<CreateReplicationGroupRequestReplicationGroupasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<ReplicationGroup>() {
            public ReplicationGroup call() throws Exception {
              ReplicationGroup result;
                try {
                result = createReplicationGroup(createReplicationGroupRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(createReplicationGroupRequestresult);
                 return result;
        }
    });
    }
    
    

The RemoveTagsFromResource action removes the tags identified by the TagKeys list from the named resource.

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

    

The RemoveTagsFromResource action removes the tags identified by the TagKeys list from the named resource.

Parameters:
removeTagsFromResourceRequest Container for the necessary parameters to execute the RemoveTagsFromResource operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the RemoveTagsFromResource service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
            final RemoveTagsFromResourceRequest removeTagsFromResourceRequest,
            final AsyncHandler<RemoveTagsFromResourceRequestRemoveTagsFromResourceResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
            public RemoveTagsFromResourceResult call() throws Exception {
              RemoveTagsFromResourceResult result;
                try {
                result = removeTagsFromResource(removeTagsFromResourceRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(removeTagsFromResourceRequestresult);
                 return result;
        }
    });
    }
    
    

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.

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

    

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.

Parameters:
createCacheClusterRequest Container for the necessary parameters to execute the CreateCacheCluster operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the CreateCacheCluster service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
            final CreateCacheClusterRequest createCacheClusterRequest,
            final AsyncHandler<CreateCacheClusterRequestCacheClusterasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<CacheCluster>() {
            public CacheCluster call() throws Exception {
              CacheCluster result;
                try {
                result = createCacheCluster(createCacheClusterRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(createCacheClusterRequestresult);
                 return result;
        }
    });
    }
    
    

The DescribeCacheEngineVersions action returns a list of the available cache engines and their versions.

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

    

The DescribeCacheEngineVersions action returns a list of the available cache engines and their versions.

Parameters:
describeCacheEngineVersionsRequest Container for the necessary parameters to execute the DescribeCacheEngineVersions operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DescribeCacheEngineVersions service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
            final DescribeCacheEngineVersionsRequest describeCacheEngineVersionsRequest,
                    throws AmazonServiceExceptionAmazonClientException {
            public DescribeCacheEngineVersionsResult call() throws Exception {
              DescribeCacheEngineVersionsResult result;
                try {
                result = describeCacheEngineVersions(describeCacheEngineVersionsRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(describeCacheEngineVersionsRequestresult);
                 return result;
        }
    });
    }
    
    

The ModifyCacheSubnetGroup action modifies an existing cache subnet group.

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

    

The ModifyCacheSubnetGroup action modifies an existing cache subnet group.

Parameters:
modifyCacheSubnetGroupRequest Container for the necessary parameters to execute the ModifyCacheSubnetGroup operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the ModifyCacheSubnetGroup service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
            final ModifyCacheSubnetGroupRequest modifyCacheSubnetGroupRequest,
            final AsyncHandler<ModifyCacheSubnetGroupRequestCacheSubnetGroupasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<CacheSubnetGroup>() {
            public CacheSubnetGroup call() throws Exception {
              CacheSubnetGroup result;
                try {
                result = modifyCacheSubnetGroup(modifyCacheSubnetGroupRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(modifyCacheSubnetGroupRequestresult);
                 return result;
        }
    });
    }
    
    

The DeleteCacheParameterGroup action deletes the specified cache parameter group. You cannot delete a cache parameter group if it is associated with any cache clusters.

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

    

The DeleteCacheParameterGroup action deletes the specified cache parameter group. You cannot delete a cache parameter group if it is associated with any cache clusters.

Parameters:
deleteCacheParameterGroupRequest Container for the necessary parameters to execute the DeleteCacheParameterGroup operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DeleteCacheParameterGroup service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
            final DeleteCacheParameterGroupRequest deleteCacheParameterGroupRequest,
            final AsyncHandler<DeleteCacheParameterGroupRequestVoidasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<Void>() {
            public Void call() throws Exception {
              try {
                deleteCacheParameterGroup(deleteCacheParameterGroupRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(deleteCacheParameterGroupRequestnull);
                 return null;
        }
    });
    }
    
    

The CreateSnapshot action creates a copy of an entire cache cluster at a specific moment in time.

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

    

The CreateSnapshot action creates a copy of an entire cache cluster at a specific moment in time.

Parameters:
createSnapshotRequest Container for the necessary parameters to execute the CreateSnapshot operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the CreateSnapshot service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
            final CreateSnapshotRequest createSnapshotRequest,
            final AsyncHandler<CreateSnapshotRequestSnapshotasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<Snapshot>() {
            public Snapshot call() throws Exception {
              Snapshot result;
                try {
                result = createSnapshot(createSnapshotRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(createSnapshotRequestresult);
                 return result;
        }
    });
    }
    
    

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.

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

    

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.

Parameters:
describeEventsRequest Container for the necessary parameters to execute the DescribeEvents operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the DescribeEvents service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
            final DescribeEventsRequest describeEventsRequest,
            final AsyncHandler<DescribeEventsRequestDescribeEventsResultasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<DescribeEventsResult>() {
            public DescribeEventsResult call() throws Exception {
              DescribeEventsResult result;
                try {
                result = describeEvents(describeEventsRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(describeEventsRequestresult);
                 return result;
        }
    });
    }
    
    

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.

NOTE:You cannot authorize ingress from an Amazon EC2 security group in one region to an ElastiCache cluster in another region.

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

    

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.

NOTE:You cannot authorize ingress from an Amazon EC2 security group in one region to an ElastiCache cluster in another region.

Parameters:
authorizeCacheSecurityGroupIngressRequest Container for the necessary parameters to execute the AuthorizeCacheSecurityGroupIngress operation on AmazonElastiCache.
asyncHandler Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
Returns:
A Java Future object containing the response from the AuthorizeCacheSecurityGroupIngress service method, as returned by AmazonElastiCache.
Throws:
com.amazonaws.AmazonClientException If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
com.amazonaws.AmazonServiceException If an error response is returned by AmazonElastiCache indicating either a problem with the data in the request, or a server side issue.
            final AuthorizeCacheSecurityGroupIngressRequest authorizeCacheSecurityGroupIngressRequest,
            final AsyncHandler<AuthorizeCacheSecurityGroupIngressRequestCacheSecurityGroupasyncHandler)
                    throws AmazonServiceExceptionAmazonClientException {
        return .submit(new Callable<CacheSecurityGroup>() {
            public CacheSecurityGroup call() throws Exception {
              CacheSecurityGroup result;
                try {
                result = authorizeCacheSecurityGroupIngress(authorizeCacheSecurityGroupIngressRequest);
              } catch (Exception ex) {
                  asyncHandler.onError(ex);
            throw ex;
              }
              asyncHandler.onSuccess(authorizeCacheSecurityGroupIngressRequestresult);
                 return result;
        }
    });
    }
    
    

The PurchaseReservedCacheNodesOffering action allows you to purchase a reserved cache node offering.

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