com.amazonaws.services.elasticache.AmazonElastiCacheClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-elasticache Show documentation
/*
* Copyright 2019-2024 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 javax.annotation.Generated;
import org.apache.commons.logging.*;
import com.amazonaws.*;
import com.amazonaws.annotation.SdkInternalApi;
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.client.builder.AdvancedConfig;
import com.amazonaws.services.elasticache.AmazonElastiCacheClientBuilder;
import com.amazonaws.services.elasticache.waiters.AmazonElastiCacheWaiters;
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 get all of the benefits of a high-performance, in-memory cache with less of the
* administrative burden involved in 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
@Generated("com.amazonaws:aws-java-sdk-code-generator")
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";
private volatile AmazonElastiCacheWaiters waiters;
/** Client configuration factory providing ClientConfigurations tailored to this client */
protected static final ClientConfigurationFactory configFactory = new ClientConfigurationFactory();
private final AdvancedConfig advancedConfig;
/**
* Map of exception unmarshallers for all modeled exceptions
*/
private final Map> exceptionUnmarshallersMap = new HashMap>();
/**
* List of exception unmarshallers for all modeled exceptions Even though this exceptionUnmarshallers is not used in
* Clients, this is not removed since this was directly used by Client extended classes. Using this list can cause
* performance impact.
*/
protected final List> exceptionUnmarshallers = new ArrayList>();
protected Unmarshaller defaultUnmarshaller;
/**
* 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
* @deprecated use {@link AmazonElastiCacheClientBuilder#defaultClient()}
*/
@Deprecated
public AmazonElastiCacheClient() {
this(DefaultAWSCredentialsProviderChain.getInstance(), 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
* @deprecated use {@link AmazonElastiCacheClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonElastiCacheClient(ClientConfiguration clientConfiguration) {
this(DefaultAWSCredentialsProviderChain.getInstance(), 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.
* @deprecated use {@link AmazonElastiCacheClientBuilder#withCredentials(AWSCredentialsProvider)} for example:
* {@code AmazonElastiCacheClientBuilder.standard().withCredentials(new AWSStaticCredentialsProvider(awsCredentials)).build();}
*/
@Deprecated
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.).
* @deprecated use {@link AmazonElastiCacheClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonElastiCacheClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonElastiCacheClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration) {
super(clientConfiguration);
this.awsCredentialsProvider = new StaticCredentialsProvider(awsCredentials);
this.advancedConfig = AdvancedConfig.EMPTY;
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.
* @deprecated use {@link AmazonElastiCacheClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
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.).
* @deprecated use {@link AmazonElastiCacheClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonElastiCacheClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
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
* @deprecated use {@link AmazonElastiCacheClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonElastiCacheClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AmazonElastiCacheClientBuilder#withMetricsCollector(RequestMetricCollector)}
*/
@Deprecated
public AmazonElastiCacheClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration,
RequestMetricCollector requestMetricCollector) {
super(clientConfiguration, requestMetricCollector);
this.awsCredentialsProvider = awsCredentialsProvider;
this.advancedConfig = AdvancedConfig.EMPTY;
init();
}
public static AmazonElastiCacheClientBuilder builder() {
return AmazonElastiCacheClientBuilder.standard();
}
/**
* 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) {
this(clientParams, false);
}
/**
* 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, boolean endpointDiscoveryEnabled) {
super(clientParams);
this.awsCredentialsProvider = clientParams.getCredentialsProvider();
this.advancedConfig = clientParams.getAdvancedConfig();
init();
}
private void init() {
if (exceptionUnmarshallersMap.get("CacheSubnetGroupNotFoundFault") == null) {
exceptionUnmarshallersMap.put("CacheSubnetGroupNotFoundFault", new CacheSubnetGroupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CacheSubnetGroupNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SubnetInUse") == null) {
exceptionUnmarshallersMap.put("SubnetInUse", new SubnetInUseExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SubnetInUseExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CacheClusterAlreadyExists") == null) {
exceptionUnmarshallersMap.put("CacheClusterAlreadyExists", new CacheClusterAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CacheClusterAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CacheSecurityGroupAlreadyExists") == null) {
exceptionUnmarshallersMap.put("CacheSecurityGroupAlreadyExists", new CacheSecurityGroupAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CacheSecurityGroupAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidGlobalReplicationGroupState") == null) {
exceptionUnmarshallersMap.put("InvalidGlobalReplicationGroupState", new InvalidGlobalReplicationGroupStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidGlobalReplicationGroupStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ServerlessCacheSnapshotAlreadyExistsFault") == null) {
exceptionUnmarshallersMap.put("ServerlessCacheSnapshotAlreadyExistsFault", new ServerlessCacheSnapshotAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ServerlessCacheSnapshotAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ServerlessCacheSnapshotQuotaExceededFault") == null) {
exceptionUnmarshallersMap.put("ServerlessCacheSnapshotQuotaExceededFault", new ServerlessCacheSnapshotQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ServerlessCacheSnapshotQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidCacheSecurityGroupState") == null) {
exceptionUnmarshallersMap.put("InvalidCacheSecurityGroupState", new InvalidCacheSecurityGroupStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidCacheSecurityGroupStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("QuotaExceeded.CacheSecurityGroup") == null) {
exceptionUnmarshallersMap.put("QuotaExceeded.CacheSecurityGroup", new CacheSecurityGroupQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CacheSecurityGroupQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CacheParameterGroupQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("CacheParameterGroupQuotaExceeded", new CacheParameterGroupQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CacheParameterGroupQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ReservedCacheNodesOfferingNotFound") == null) {
exceptionUnmarshallersMap.put("ReservedCacheNodesOfferingNotFound", new ReservedCacheNodesOfferingNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ReservedCacheNodesOfferingNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ReplicationGroupNotUnderMigrationFault") == null) {
exceptionUnmarshallersMap.put("ReplicationGroupNotUnderMigrationFault", new ReplicationGroupNotUnderMigrationExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ReplicationGroupNotUnderMigrationExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CacheParameterGroupAlreadyExists") == null) {
exceptionUnmarshallersMap.put("CacheParameterGroupAlreadyExists", new CacheParameterGroupAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CacheParameterGroupAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("TestFailoverNotAvailableFault") == null) {
exceptionUnmarshallersMap.put("TestFailoverNotAvailableFault", new TestFailoverNotAvailableExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new TestFailoverNotAvailableExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DuplicateUserName") == null) {
exceptionUnmarshallersMap.put("DuplicateUserName", new DuplicateUserNameExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DuplicateUserNameExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CacheParameterGroupNotFound") == null) {
exceptionUnmarshallersMap.put("CacheParameterGroupNotFound", new CacheParameterGroupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CacheParameterGroupNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SubnetNotAllowedFault") == null) {
exceptionUnmarshallersMap.put("SubnetNotAllowedFault", new SubnetNotAllowedExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SubnetNotAllowedExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ServiceLinkedRoleNotFoundFault") == null) {
exceptionUnmarshallersMap.put("ServiceLinkedRoleNotFoundFault", new ServiceLinkedRoleNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ServiceLinkedRoleNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("UserNotFound") == null) {
exceptionUnmarshallersMap.put("UserNotFound", new UserNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new UserNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("NodeGroupNotFoundFault") == null) {
exceptionUnmarshallersMap.put("NodeGroupNotFoundFault", new NodeGroupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new NodeGroupNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("APICallRateForCustomerExceeded") == null) {
exceptionUnmarshallersMap.put("APICallRateForCustomerExceeded", new APICallRateForCustomerExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new APICallRateForCustomerExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidKMSKeyFault") == null) {
exceptionUnmarshallersMap.put("InvalidKMSKeyFault", new InvalidKMSKeyExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidKMSKeyExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("GlobalReplicationGroupNotFoundFault") == null) {
exceptionUnmarshallersMap.put("GlobalReplicationGroupNotFoundFault", new GlobalReplicationGroupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new GlobalReplicationGroupNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidCredentialsException") == null) {
exceptionUnmarshallersMap.put("InvalidCredentialsException", new InvalidCredentialsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidCredentialsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InsufficientCacheClusterCapacity") == null) {
exceptionUnmarshallersMap.put("InsufficientCacheClusterCapacity", new InsufficientCacheClusterCapacityExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InsufficientCacheClusterCapacityExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ReservedCacheNodeNotFound") == null) {
exceptionUnmarshallersMap.put("ReservedCacheNodeNotFound", new ReservedCacheNodeNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ReservedCacheNodeNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CacheSubnetGroupInUse") == null) {
exceptionUnmarshallersMap.put("CacheSubnetGroupInUse", new CacheSubnetGroupInUseExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CacheSubnetGroupInUseExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidServerlessCacheStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidServerlessCacheStateFault", new InvalidServerlessCacheStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidServerlessCacheStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ReplicationGroupNotFoundFault") == null) {
exceptionUnmarshallersMap.put("ReplicationGroupNotFoundFault", new ReplicationGroupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ReplicationGroupNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidSubnet") == null) {
exceptionUnmarshallersMap.put("InvalidSubnet", new InvalidSubnetExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidSubnetExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ServerlessCacheAlreadyExistsFault") == null) {
exceptionUnmarshallersMap.put("ServerlessCacheAlreadyExistsFault", new ServerlessCacheAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ServerlessCacheAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("NoOperationFault") == null) {
exceptionUnmarshallersMap.put("NoOperationFault", new NoOperationExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new NoOperationExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("NodeGroupsPerReplicationGroupQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("NodeGroupsPerReplicationGroupQuotaExceeded", new NodeGroupsPerReplicationGroupQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new NodeGroupsPerReplicationGroupQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ReservedCacheNodeQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("ReservedCacheNodeQuotaExceeded", new ReservedCacheNodeQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ReservedCacheNodeQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ReservedCacheNodeAlreadyExists") == null) {
exceptionUnmarshallersMap.put("ReservedCacheNodeAlreadyExists", new ReservedCacheNodeAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ReservedCacheNodeAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CacheClusterNotFound") == null) {
exceptionUnmarshallersMap.put("CacheClusterNotFound", new CacheClusterNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CacheClusterNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("GlobalReplicationGroupAlreadyExistsFault") == null) {
exceptionUnmarshallersMap.put("GlobalReplicationGroupAlreadyExistsFault", new GlobalReplicationGroupAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new GlobalReplicationGroupAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidParameterValue") == null) {
exceptionUnmarshallersMap.put("InvalidParameterValue", new InvalidParameterValueExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidParameterValueExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SnapshotAlreadyExistsFault") == null) {
exceptionUnmarshallersMap.put("SnapshotAlreadyExistsFault", new SnapshotAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SnapshotAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("UserGroupQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("UserGroupQuotaExceeded", new UserGroupQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new UserGroupQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidReplicationGroupState") == null) {
exceptionUnmarshallersMap.put("InvalidReplicationGroupState", new InvalidReplicationGroupStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidReplicationGroupStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SnapshotQuotaExceededFault") == null) {
exceptionUnmarshallersMap.put("SnapshotQuotaExceededFault", new SnapshotQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SnapshotQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("UserGroupAlreadyExists") == null) {
exceptionUnmarshallersMap.put("UserGroupAlreadyExists", new UserGroupAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new UserGroupAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ServerlessCacheSnapshotNotFoundFault") == null) {
exceptionUnmarshallersMap.put("ServerlessCacheSnapshotNotFoundFault", new ServerlessCacheSnapshotNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ServerlessCacheSnapshotNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DefaultUserRequired") == null) {
exceptionUnmarshallersMap.put("DefaultUserRequired", new DefaultUserRequiredExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DefaultUserRequiredExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("NodeQuotaForCustomerExceeded") == null) {
exceptionUnmarshallersMap.put("NodeQuotaForCustomerExceeded", new NodeQuotaForCustomerExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new NodeQuotaForCustomerExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("UserAlreadyExists") == null) {
exceptionUnmarshallersMap.put("UserAlreadyExists", new UserAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new UserAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ServerlessCacheNotFoundFault") == null) {
exceptionUnmarshallersMap.put("ServerlessCacheNotFoundFault", new ServerlessCacheNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ServerlessCacheNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidUserGroupState") == null) {
exceptionUnmarshallersMap.put("InvalidUserGroupState", new InvalidUserGroupStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidUserGroupStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("TagNotFound") == null) {
exceptionUnmarshallersMap.put("TagNotFound", new TagNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new TagNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ClusterQuotaForCustomerExceeded") == null) {
exceptionUnmarshallersMap.put("ClusterQuotaForCustomerExceeded", new ClusterQuotaForCustomerExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ClusterQuotaForCustomerExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ServerlessCacheQuotaForCustomerExceededFault") == null) {
exceptionUnmarshallersMap.put("ServerlessCacheQuotaForCustomerExceededFault", new ServerlessCacheQuotaForCustomerExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ServerlessCacheQuotaForCustomerExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("NodeQuotaForClusterExceeded") == null) {
exceptionUnmarshallersMap.put("NodeQuotaForClusterExceeded", new NodeQuotaForClusterExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new NodeQuotaForClusterExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ServiceUpdateNotFoundFault") == null) {
exceptionUnmarshallersMap.put("ServiceUpdateNotFoundFault", new ServiceUpdateNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ServiceUpdateNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidCacheClusterState") == null) {
exceptionUnmarshallersMap.put("InvalidCacheClusterState", new InvalidCacheClusterStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidCacheClusterStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidVPCNetworkStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidVPCNetworkStateFault", new InvalidVPCNetworkStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidVPCNetworkStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CacheSubnetQuotaExceededFault") == null) {
exceptionUnmarshallersMap.put("CacheSubnetQuotaExceededFault", new CacheSubnetQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CacheSubnetQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SnapshotFeatureNotSupportedFault") == null) {
exceptionUnmarshallersMap.put("SnapshotFeatureNotSupportedFault", new SnapshotFeatureNotSupportedExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SnapshotFeatureNotSupportedExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidSnapshotState") == null) {
exceptionUnmarshallersMap.put("InvalidSnapshotState", new InvalidSnapshotStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidSnapshotStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ReplicationGroupAlreadyUnderMigrationFault") == null) {
exceptionUnmarshallersMap.put("ReplicationGroupAlreadyUnderMigrationFault", new ReplicationGroupAlreadyUnderMigrationExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ReplicationGroupAlreadyUnderMigrationExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CacheSubnetGroupAlreadyExists") == null) {
exceptionUnmarshallersMap.put("CacheSubnetGroupAlreadyExists", new CacheSubnetGroupAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CacheSubnetGroupAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CacheSubnetGroupQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("CacheSubnetGroupQuotaExceeded", new CacheSubnetGroupQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CacheSubnetGroupQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ReplicationGroupAlreadyExists") == null) {
exceptionUnmarshallersMap.put("ReplicationGroupAlreadyExists", new ReplicationGroupAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ReplicationGroupAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("DefaultUserAssociatedToUserGroup") == null) {
exceptionUnmarshallersMap.put("DefaultUserAssociatedToUserGroup", new DefaultUserAssociatedToUserGroupExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new DefaultUserAssociatedToUserGroupExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidParameterCombination") == null) {
exceptionUnmarshallersMap.put("InvalidParameterCombination", new InvalidParameterCombinationExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidParameterCombinationExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidServerlessCacheSnapshotStateFault") == null) {
exceptionUnmarshallersMap.put("InvalidServerlessCacheSnapshotStateFault", new InvalidServerlessCacheSnapshotStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidServerlessCacheSnapshotStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidUserState") == null) {
exceptionUnmarshallersMap.put("InvalidUserState", new InvalidUserStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidUserStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("UserGroupNotFound") == null) {
exceptionUnmarshallersMap.put("UserGroupNotFound", new UserGroupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new UserGroupNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("SnapshotNotFoundFault") == null) {
exceptionUnmarshallersMap.put("SnapshotNotFoundFault", new SnapshotNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new SnapshotNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("UserQuotaExceeded") == null) {
exceptionUnmarshallersMap.put("UserQuotaExceeded", new UserQuotaExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new UserQuotaExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("CacheSecurityGroupNotFound") == null) {
exceptionUnmarshallersMap.put("CacheSecurityGroupNotFound", new CacheSecurityGroupNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new CacheSecurityGroupNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidCacheParameterGroupState") == null) {
exceptionUnmarshallersMap.put("InvalidCacheParameterGroupState", new InvalidCacheParameterGroupStateExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidCacheParameterGroupStateExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidARN") == null) {
exceptionUnmarshallersMap.put("InvalidARN", new InvalidARNExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidARNExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("TagQuotaPerResourceExceeded") == null) {
exceptionUnmarshallersMap.put("TagQuotaPerResourceExceeded", new TagQuotaPerResourceExceededExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new TagQuotaPerResourceExceededExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("AuthorizationAlreadyExists") == null) {
exceptionUnmarshallersMap.put("AuthorizationAlreadyExists", new AuthorizationAlreadyExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new AuthorizationAlreadyExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("AuthorizationNotFound") == null) {
exceptionUnmarshallersMap.put("AuthorizationNotFound", new AuthorizationNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new AuthorizationNotFoundExceptionUnmarshaller());
defaultUnmarshaller = new StandardErrorUnmarshaller(com.amazonaws.services.elasticache.model.AmazonElastiCacheException.class);
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"));
requestHandler2s.addAll(chainFactory.getGlobalHandlers());
}
/**
*
* A tag is a key-value pair where the key and value are case-sensitive. You can use tags to categorize and track
* all your ElastiCache resources, with the exception of global replication group. When you add or remove tags on
* replication groups, those actions will be replicated to all nodes in the replication group. For more information,
* see Resource
* -level permissions.
*
*
* For example, you can use cost-allocation tags to your ElastiCache resources, Amazon 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 operation.
* @return Result of the AddTagsToResource operation returned by the service.
* @throws CacheClusterNotFoundException
* The requested cluster ID does not refer to an existing cluster.
* @throws CacheParameterGroupNotFoundException
* The requested cache parameter group name does not refer to an existing cache parameter group.
* @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 InvalidReplicationGroupStateException
* The requested replication group is not in the available state.
* @throws ReplicationGroupNotFoundException
* The specified replication group does not exist.
* @throws ReservedCacheNodeNotFoundException
* The requested reserved cache node was not found.
* @throws SnapshotNotFoundException
* The requested snapshot name does not refer to an existing snapshot.
* @throws UserNotFoundException
* The user does not exist or could not be found.
* @throws UserGroupNotFoundException
* The user group was not found or does not exist
* @throws ServerlessCacheNotFoundException
* The serverless cache was not found or does not exist.
* @throws InvalidServerlessCacheStateException
* The account for these credentials is not currently active.
* @throws ServerlessCacheSnapshotNotFoundException
* This serverless cache snapshot could not be found or does not exist. Available for Redis OSS and
* Serverless Memcached only.
* @throws InvalidServerlessCacheSnapshotStateException
* The state of the serverless cache snapshot was not received. Available for Redis OSS and Serverless
* Memcached only.
* @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 50.
* @throws InvalidARNException
* The requested Amazon Resource Name (ARN) does not refer to an existing resource.
* @sample AmazonElastiCache.AddTagsToResource
* @see AWS
* API Documentation
*/
@Override
public AddTagsToResourceResult addTagsToResource(AddTagsToResourceRequest request) {
request = beforeClientExecution(request);
return executeAddTagsToResource(request);
}
@SdkInternalApi
final AddTagsToResourceResult executeAddTagsToResource(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AddTagsToResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new AddTagsToResourceResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 operation.
* @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
* @see AWS API Documentation
*/
@Override
public CacheSecurityGroup authorizeCacheSecurityGroupIngress(AuthorizeCacheSecurityGroupIngressRequest request) {
request = beforeClientExecution(request);
return executeAuthorizeCacheSecurityGroupIngress(request);
}
@SdkInternalApi
final CacheSecurityGroup executeAuthorizeCacheSecurityGroupIngress(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AuthorizeCacheSecurityGroupIngress");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new CacheSecurityGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Apply the service update. For more information on service updates and applying them, see Applying Service
* Updates.
*
*
* @param batchApplyUpdateActionRequest
* @return Result of the BatchApplyUpdateAction operation returned by the service.
* @throws ServiceUpdateNotFoundException
* The service update doesn't exist
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @sample AmazonElastiCache.BatchApplyUpdateAction
* @see AWS API Documentation
*/
@Override
public BatchApplyUpdateActionResult batchApplyUpdateAction(BatchApplyUpdateActionRequest request) {
request = beforeClientExecution(request);
return executeBatchApplyUpdateAction(request);
}
@SdkInternalApi
final BatchApplyUpdateActionResult executeBatchApplyUpdateAction(BatchApplyUpdateActionRequest batchApplyUpdateActionRequest) {
ExecutionContext executionContext = createExecutionContext(batchApplyUpdateActionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new BatchApplyUpdateActionRequestMarshaller().marshall(super.beforeMarshalling(batchApplyUpdateActionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "BatchApplyUpdateAction");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new BatchApplyUpdateActionResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Stop the service update. For more information on service updates and stopping them, see Stopping
* Service Updates.
*
*
* @param batchStopUpdateActionRequest
* @return Result of the BatchStopUpdateAction operation returned by the service.
* @throws ServiceUpdateNotFoundException
* The service update doesn't exist
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @sample AmazonElastiCache.BatchStopUpdateAction
* @see AWS API Documentation
*/
@Override
public BatchStopUpdateActionResult batchStopUpdateAction(BatchStopUpdateActionRequest request) {
request = beforeClientExecution(request);
return executeBatchStopUpdateAction(request);
}
@SdkInternalApi
final BatchStopUpdateActionResult executeBatchStopUpdateAction(BatchStopUpdateActionRequest batchStopUpdateActionRequest) {
ExecutionContext executionContext = createExecutionContext(batchStopUpdateActionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new BatchStopUpdateActionRequestMarshaller().marshall(super.beforeMarshalling(batchStopUpdateActionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "BatchStopUpdateAction");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new BatchStopUpdateActionResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Complete the migration of data.
*
*
* @param completeMigrationRequest
* @return Result of the CompleteMigration 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 ReplicationGroupNotUnderMigrationException
* The designated replication group is not available for data migration.
* @sample AmazonElastiCache.CompleteMigration
* @see AWS
* API Documentation
*/
@Override
public ReplicationGroup completeMigration(CompleteMigrationRequest request) {
request = beforeClientExecution(request);
return executeCompleteMigration(request);
}
@SdkInternalApi
final ReplicationGroup executeCompleteMigration(CompleteMigrationRequest completeMigrationRequest) {
ExecutionContext executionContext = createExecutionContext(completeMigrationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CompleteMigrationRequestMarshaller().marshall(super.beforeMarshalling(completeMigrationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CompleteMigration");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new ReplicationGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a copy of an existing serverless cache’s snapshot. Available for Redis OSS and Serverless Memcached only.
*
*
* @param copyServerlessCacheSnapshotRequest
* @return Result of the CopyServerlessCacheSnapshot operation returned by the service.
* @throws ServerlessCacheSnapshotAlreadyExistsException
* A serverless cache snapshot with this name already exists. Available for Redis OSS and Serverless
* Memcached only.
* @throws ServerlessCacheSnapshotNotFoundException
* This serverless cache snapshot could not be found or does not exist. Available for Redis OSS and
* Serverless Memcached only.
* @throws ServerlessCacheSnapshotQuotaExceededException
* The number of serverless cache snapshots exceeds the customer snapshot quota. Available for Redis OSS and
* Serverless Memcached only.
* @throws InvalidServerlessCacheSnapshotStateException
* The state of the serverless cache snapshot was not received. Available for Redis OSS and Serverless
* Memcached only.
* @throws ServiceLinkedRoleNotFoundException
* The specified service linked role (SLR) was not found.
* @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 50.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.CopyServerlessCacheSnapshot
* @see AWS API Documentation
*/
@Override
public CopyServerlessCacheSnapshotResult copyServerlessCacheSnapshot(CopyServerlessCacheSnapshotRequest request) {
request = beforeClientExecution(request);
return executeCopyServerlessCacheSnapshot(request);
}
@SdkInternalApi
final CopyServerlessCacheSnapshotResult executeCopyServerlessCacheSnapshot(CopyServerlessCacheSnapshotRequest copyServerlessCacheSnapshotRequest) {
ExecutionContext executionContext = createExecutionContext(copyServerlessCacheSnapshotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CopyServerlessCacheSnapshotRequestMarshaller().marshall(super.beforeMarshalling(copyServerlessCacheSnapshotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CopyServerlessCacheSnapshot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CopyServerlessCacheSnapshotResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Makes a copy of an existing snapshot.
*
*
*
* This operation is valid for Redis OSS only.
*
*
*
* Users or groups that have permissions to use the CopySnapshot operation 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 operation. For more information about using IAM to control the
* use of ElastiCache operations, see Exporting Snapshots
* and Authentication & Access
* Control.
*
*
*
* You could receive the following error messages.
*
*
* Error Messages
*
*
* -
*
* Error Message: The S3 bucket %s is outside of the region.
*
*
* Solution: Create an Amazon S3 bucket in the same region as your snapshot. For more information, see Step 1: Create an Amazon S3 Bucket in the ElastiCache User Guide.
*
*
* -
*
* Error Message: The S3 bucket %s does not exist.
*
*
* Solution: Create an Amazon S3 bucket in the same region as your snapshot. For more information, see Step 1: Create an Amazon S3 Bucket in the ElastiCache User Guide.
*
*
* -
*
* Error Message: The S3 bucket %s is not owned by the authenticated user.
*
*
* Solution: Create an Amazon S3 bucket in the same region as your snapshot. For more information, see Step 1: Create an Amazon S3 Bucket in the ElastiCache User Guide.
*
*
* -
*
* 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.
*
*
* -
*
* Error Message: The S3 bucket %s already contains an object with key %s.
*
*
* Solution: Give the TargetSnapshotName a new and unique value. If exporting a snapshot, you
* could alternatively create a new Amazon S3 bucket and use this same value for TargetSnapshotName.
*
*
* -
*
* Error Message: ElastiCache has not been granted READ permissions %s on the S3 Bucket.
*
*
* Solution: Add List and Read permissions on the bucket. For more information, see Step 2: Grant ElastiCache Access to Your Amazon S3 Bucket in the ElastiCache User Guide.
*
*
* -
*
* Error Message: ElastiCache has not been granted WRITE permissions %s on the S3 Bucket.
*
*
* Solution: Add Upload/Delete permissions on the bucket. For more information, see Step 2: Grant ElastiCache Access to Your Amazon S3 Bucket in the ElastiCache User Guide.
*
*
* -
*
* Error Message: ElastiCache has not been granted READ_ACP permissions %s on the S3 Bucket.
*
*
* Solution: Add View Permissions on the bucket. For more information, see Step 2: Grant ElastiCache Access to Your Amazon S3 Bucket in the ElastiCache User Guide.
*
*
*
*
* @param copySnapshotRequest
* Represents the input of a CopySnapshotMessage operation.
* @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 operation to occur.
* @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 50.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.CopySnapshot
* @see AWS API
* Documentation
*/
@Override
public Snapshot copySnapshot(CopySnapshotRequest request) {
request = beforeClientExecution(request);
return executeCopySnapshot(request);
}
@SdkInternalApi
final Snapshot executeCopySnapshot(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CopySnapshot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new SnapshotStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a cluster. All nodes in the cluster run the same protocol-compliant cache engine software, either
* Memcached or Redis OSS.
*
*
* This operation is not supported for Redis OSS (cluster mode enabled) clusters.
*
*
* @param createCacheClusterRequest
* Represents the input of a CreateCacheCluster operation.
* @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 cluster with the given identifier.
* @throws InsufficientCacheClusterCapacityException
* The requested cache node type is not available in the specified Availability Zone. For more information,
* see InsufficientCacheClusterCapacity in the ElastiCache User Guide.
* @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 clusters per customer.
* @throws NodeQuotaForClusterExceededException
* The request cannot be processed because it would exceed the allowed number of cache nodes in a single
* 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 50.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.CreateCacheCluster
* @see AWS
* API Documentation
*/
@Override
public CacheCluster createCacheCluster(CreateCacheClusterRequest request) {
request = beforeClientExecution(request);
return executeCreateCacheCluster(request);
}
@SdkInternalApi
final CacheCluster executeCreateCacheCluster(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateCacheCluster");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new CacheClusterStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new Amazon ElastiCache cache parameter group. An ElastiCache cache parameter group is a collection of
* parameters and their values that are applied to all of the nodes in any cluster or replication group using the
* CacheParameterGroup.
*
*
* A newly created CacheParameterGroup is an exact duplicate of the default parameter group for the
* CacheParameterGroupFamily. To customize the newly created CacheParameterGroup you can change the values of
* specific parameters. For more information, see:
*
*
* -
*
*
* ModifyCacheParameterGroup in the ElastiCache API Reference.
*
*
* -
*
* Parameters and
* Parameter Groups in the ElastiCache User Guide.
*
*
*
*
* @param createCacheParameterGroupRequest
* Represents the input of a CreateCacheParameterGroup operation.
* @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 operation to occur.
* @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 50.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.CreateCacheParameterGroup
* @see AWS API Documentation
*/
@Override
public CacheParameterGroup createCacheParameterGroup(CreateCacheParameterGroupRequest request) {
request = beforeClientExecution(request);
return executeCreateCacheParameterGroup(request);
}
@SdkInternalApi
final CacheParameterGroup executeCreateCacheParameterGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateCacheParameterGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new CacheParameterGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new cache security group. Use a cache security group to control access to one or more clusters.
*
*
* Cache security groups are only used when you are creating a cluster outside of an Amazon Virtual Private Cloud
* (Amazon VPC). If you are creating a cluster inside of a VPC, use a cache subnet group instead. For more
* information, see CreateCacheSubnetGroup.
*
*
* @param createCacheSecurityGroupRequest
* Represents the input of a CreateCacheSecurityGroup operation.
* @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 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 50.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.CreateCacheSecurityGroup
* @see AWS API Documentation
*/
@Override
public CacheSecurityGroup createCacheSecurityGroup(CreateCacheSecurityGroupRequest request) {
request = beforeClientExecution(request);
return executeCreateCacheSecurityGroup(request);
}
@SdkInternalApi
final CacheSecurityGroup executeCreateCacheSecurityGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateCacheSecurityGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new CacheSecurityGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new cache subnet group.
*
*
* Use this parameter only when you are creating a cluster in an Amazon Virtual Private Cloud (Amazon VPC).
*
*
* @param createCacheSubnetGroupRequest
* Represents the input of a CreateCacheSubnetGroup operation.
* @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 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 50.
* @throws InvalidSubnetException
* An invalid subnet identifier was specified.
* @throws SubnetNotAllowedException
* At least one subnet ID does not match the other subnet IDs. This mismatch typically occurs when a user
* sets one subnet ID to a regional Availability Zone and a different one to an outpost. Or when a user sets
* the subnet ID to an Outpost when not subscribed on this service.
* @sample AmazonElastiCache.CreateCacheSubnetGroup
* @see AWS API Documentation
*/
@Override
public CacheSubnetGroup createCacheSubnetGroup(CreateCacheSubnetGroupRequest request) {
request = beforeClientExecution(request);
return executeCreateCacheSubnetGroup(request);
}
@SdkInternalApi
final CacheSubnetGroup executeCreateCacheSubnetGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateCacheSubnetGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new CacheSubnetGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Global Datastore for Redis OSS offers fully managed, fast, reliable and secure cross-region replication. Using
* Global Datastore for Redis OSS, you can create cross-region read replica clusters for ElastiCache (Redis OSS) to
* enable low-latency reads and disaster recovery across regions. For more information, see Replication Across
* Regions Using Global Datastore.
*
*
* -
*
* The GlobalReplicationGroupIdSuffix is the name of the Global datastore.
*
*
* -
*
* The PrimaryReplicationGroupId represents the name of the primary cluster that accepts writes and will
* replicate updates to the secondary cluster.
*
*
*
*
* @param createGlobalReplicationGroupRequest
* @return Result of the CreateGlobalReplicationGroup 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 GlobalReplicationGroupAlreadyExistsException
* The Global datastore name already exists.
* @throws ServiceLinkedRoleNotFoundException
* The specified service linked role (SLR) was not found.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @sample AmazonElastiCache.CreateGlobalReplicationGroup
* @see AWS API Documentation
*/
@Override
public GlobalReplicationGroup createGlobalReplicationGroup(CreateGlobalReplicationGroupRequest request) {
request = beforeClientExecution(request);
return executeCreateGlobalReplicationGroup(request);
}
@SdkInternalApi
final GlobalReplicationGroup executeCreateGlobalReplicationGroup(CreateGlobalReplicationGroupRequest createGlobalReplicationGroupRequest) {
ExecutionContext executionContext = createExecutionContext(createGlobalReplicationGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateGlobalReplicationGroupRequestMarshaller().marshall(super.beforeMarshalling(createGlobalReplicationGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateGlobalReplicationGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new GlobalReplicationGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a Redis OSS (cluster mode disabled) or a Redis OSS (cluster mode enabled) replication group.
*
*
* This API can be used to create a standalone regional replication group or a secondary replication group
* associated with a Global datastore.
*
*
* A Redis OSS (cluster mode disabled) replication group is a collection of nodes, where one of the nodes is a
* read/write primary and the others are read-only replicas. Writes to the primary are asynchronously propagated to
* the replicas.
*
*
* A Redis OSS cluster-mode enabled cluster is comprised of from 1 to 90 shards (API/CLI: node groups). Each shard
* has a primary node and up to 5 read-only replica nodes. The configuration can range from 90 shards and 0 replicas
* to 15 shards and 5 replicas, which is the maximum number or replicas allowed.
*
*
* The node or shard limit can be increased to a maximum of 500 per cluster if the Redis OSS engine version is 5.0.6
* or higher. For example, you can choose to configure a 500 node cluster that ranges between 83 shards (one primary
* and 5 replicas per shard) and 500 shards (single primary and no replicas). Make sure there are enough available
* IP addresses to accommodate the increase. Common pitfalls include the subnets in the subnet group have too small
* a CIDR range or the subnets are shared and heavily used by other clusters. For more information, see Creating a Subnet
* Group. For versions below 5.0.6, the limit is 250 per cluster.
*
*
* To request a limit increase, see Amazon Service Limits and choose
* the limit type Nodes per cluster per instance type.
*
*
* When a Redis OSS (cluster mode disabled) replication group has been successfully created, you can add one or more
* read replicas to it, up to a total of 5 read replicas. If you need to increase or decrease the number of node
* groups (console: shards), you can use ElastiCache (Redis OSS) scaling. For more information, see Scaling ElastiCache (Redis OSS)
* Clusters in the ElastiCache User Guide.
*
*
*
* This operation is valid for Redis OSS only.
*
*
*
* @param createReplicationGroupRequest
* Represents the input of a CreateReplicationGroup operation.
* @return Result of the CreateReplicationGroup operation returned by the service.
* @throws CacheClusterNotFoundException
* The requested cluster ID does not refer to an existing cluster.
* @throws InvalidCacheClusterStateException
* The requested cluster is not in the available state.
* @throws ReplicationGroupAlreadyExistsException
* The specified replication group already exists.
* @throws InvalidUserGroupStateException
* The user group is not in an active state.
* @throws UserGroupNotFoundException
* The user group was not found or does not exist
* @throws InsufficientCacheClusterCapacityException
* The requested cache node type is not available in the specified Availability Zone. For more information,
* see InsufficientCacheClusterCapacity in the ElastiCache User Guide.
* @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 clusters per customer.
* @throws NodeQuotaForClusterExceededException
* The request cannot be processed because it would exceed the allowed number of cache nodes in a single
* 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 50.
* @throws NodeGroupsPerReplicationGroupQuotaExceededException
* The request cannot be processed because it would exceed the maximum allowed number of node groups
* (shards) in a single replication group. The default maximum is 90
* @throws GlobalReplicationGroupNotFoundException
* The Global datastore does not exist
* @throws InvalidGlobalReplicationGroupStateException
* The Global datastore is not available or in primary-only state.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.CreateReplicationGroup
* @see AWS API Documentation
*/
@Override
public ReplicationGroup createReplicationGroup(CreateReplicationGroupRequest request) {
request = beforeClientExecution(request);
return executeCreateReplicationGroup(request);
}
@SdkInternalApi
final ReplicationGroup executeCreateReplicationGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateReplicationGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new ReplicationGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a serverless cache.
*
*
* @param createServerlessCacheRequest
* @return Result of the CreateServerlessCache operation returned by the service.
* @throws ServerlessCacheNotFoundException
* The serverless cache was not found or does not exist.
* @throws InvalidServerlessCacheStateException
* The account for these credentials is not currently active.
* @throws ServerlessCacheAlreadyExistsException
* A serverless cache with this name already exists.
* @throws ServerlessCacheQuotaForCustomerExceededException
* The number of serverless caches exceeds the customer quota.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @throws InvalidCredentialsException
* You must enter valid credentials.
* @throws InvalidUserGroupStateException
* The user group is not in an active state.
* @throws UserGroupNotFoundException
* The user group was not found or does not exist
* @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 50.
* @throws ServiceLinkedRoleNotFoundException
* The specified service linked role (SLR) was not found.
* @sample AmazonElastiCache.CreateServerlessCache
* @see AWS API Documentation
*/
@Override
public CreateServerlessCacheResult createServerlessCache(CreateServerlessCacheRequest request) {
request = beforeClientExecution(request);
return executeCreateServerlessCache(request);
}
@SdkInternalApi
final CreateServerlessCacheResult executeCreateServerlessCache(CreateServerlessCacheRequest createServerlessCacheRequest) {
ExecutionContext executionContext = createExecutionContext(createServerlessCacheRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateServerlessCacheRequestMarshaller().marshall(super.beforeMarshalling(createServerlessCacheRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateServerlessCache");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CreateServerlessCacheResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* This API creates a copy of an entire ServerlessCache at a specific moment in time. Available for Redis OSS and
* Serverless Memcached only.
*
*
* @param createServerlessCacheSnapshotRequest
* @return Result of the CreateServerlessCacheSnapshot operation returned by the service.
* @throws ServerlessCacheSnapshotAlreadyExistsException
* A serverless cache snapshot with this name already exists. Available for Redis OSS and Serverless
* Memcached only.
* @throws ServerlessCacheNotFoundException
* The serverless cache was not found or does not exist.
* @throws InvalidServerlessCacheStateException
* The account for these credentials is not currently active.
* @throws ServerlessCacheSnapshotQuotaExceededException
* The number of serverless cache snapshots exceeds the customer snapshot quota. Available for Redis OSS and
* Serverless Memcached only.
* @throws ServiceLinkedRoleNotFoundException
* The specified service linked role (SLR) was not found.
* @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 50.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.CreateServerlessCacheSnapshot
* @see AWS API Documentation
*/
@Override
public CreateServerlessCacheSnapshotResult createServerlessCacheSnapshot(CreateServerlessCacheSnapshotRequest request) {
request = beforeClientExecution(request);
return executeCreateServerlessCacheSnapshot(request);
}
@SdkInternalApi
final CreateServerlessCacheSnapshotResult executeCreateServerlessCacheSnapshot(CreateServerlessCacheSnapshotRequest createServerlessCacheSnapshotRequest) {
ExecutionContext executionContext = createExecutionContext(createServerlessCacheSnapshotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateServerlessCacheSnapshotRequestMarshaller().marshall(super.beforeMarshalling(createServerlessCacheSnapshotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateServerlessCacheSnapshot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CreateServerlessCacheSnapshotResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a copy of an entire cluster or replication group at a specific moment in time.
*
*
*
* This operation is valid for Redis OSS only.
*
*
*
* @param createSnapshotRequest
* Represents the input of a CreateSnapshot operation.
* @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 cluster ID does not refer to an existing cluster.
* @throws ReplicationGroupNotFoundException
* The specified replication group does not exist.
* @throws InvalidCacheClusterStateException
* The requested cluster is not in the available state.
* @throws InvalidReplicationGroupStateException
* The requested replication group 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 operations:
*
* -
*
* Creating a snapshot of a Redis OSS cluster running on a cache.t1.micro cache node.
*
*
* -
*
* Creating a snapshot of a cluster that is running Memcached rather than Redis OSS.
*
*
*
*
* Neither of these are supported by ElastiCache.
* @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 50.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @sample AmazonElastiCache.CreateSnapshot
* @see AWS API
* Documentation
*/
@Override
public Snapshot createSnapshot(CreateSnapshotRequest request) {
request = beforeClientExecution(request);
return executeCreateSnapshot(request);
}
@SdkInternalApi
final Snapshot executeCreateSnapshot(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateSnapshot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new SnapshotStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* For Redis OSS engine version 6.0 onwards: Creates a Redis OSS user. For more information, see Using Role Based Access
* Control (RBAC).
*
*
* @param createUserRequest
* @return Result of the CreateUser operation returned by the service.
* @throws UserAlreadyExistsException
* A user with this ID already exists.
* @throws UserQuotaExceededException
* The quota of users has been exceeded.
* @throws DuplicateUserNameException
* A user with this username already exists.
* @throws ServiceLinkedRoleNotFoundException
* The specified service linked role (SLR) was not found.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @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 50.
* @sample AmazonElastiCache.CreateUser
* @see AWS API
* Documentation
*/
@Override
public CreateUserResult createUser(CreateUserRequest request) {
request = beforeClientExecution(request);
return executeCreateUser(request);
}
@SdkInternalApi
final CreateUserResult executeCreateUser(CreateUserRequest createUserRequest) {
ExecutionContext executionContext = createExecutionContext(createUserRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateUserRequestMarshaller().marshall(super.beforeMarshalling(createUserRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateUser");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new CreateUserResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* For Redis OSS engine version 6.0 onwards: Creates a Redis OSS user group. For more information, see Using Role Based Access
* Control (RBAC)
*
*
* @param createUserGroupRequest
* @return Result of the CreateUserGroup operation returned by the service.
* @throws UserNotFoundException
* The user does not exist or could not be found.
* @throws DuplicateUserNameException
* A user with this username already exists.
* @throws UserGroupAlreadyExistsException
* The user group with this ID already exists.
* @throws ServiceLinkedRoleNotFoundException
* The specified service linked role (SLR) was not found.
* @throws DefaultUserRequiredException
* You must add default user to a user group.
* @throws UserGroupQuotaExceededException
* The number of users exceeds the user group limit.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @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 50.
* @sample AmazonElastiCache.CreateUserGroup
* @see AWS
* API Documentation
*/
@Override
public CreateUserGroupResult createUserGroup(CreateUserGroupRequest request) {
request = beforeClientExecution(request);
return executeCreateUserGroup(request);
}
@SdkInternalApi
final CreateUserGroupResult executeCreateUserGroup(CreateUserGroupRequest createUserGroupRequest) {
ExecutionContext executionContext = createExecutionContext(createUserGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateUserGroupRequestMarshaller().marshall(super.beforeMarshalling(createUserGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateUserGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CreateUserGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Decreases the number of node groups in a Global datastore
*
*
* @param decreaseNodeGroupsInGlobalReplicationGroupRequest
* @return Result of the DecreaseNodeGroupsInGlobalReplicationGroup operation returned by the service.
* @throws GlobalReplicationGroupNotFoundException
* The Global datastore does not exist
* @throws InvalidGlobalReplicationGroupStateException
* The Global datastore is not available or in primary-only state.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DecreaseNodeGroupsInGlobalReplicationGroup
* @see AWS API Documentation
*/
@Override
public GlobalReplicationGroup decreaseNodeGroupsInGlobalReplicationGroup(DecreaseNodeGroupsInGlobalReplicationGroupRequest request) {
request = beforeClientExecution(request);
return executeDecreaseNodeGroupsInGlobalReplicationGroup(request);
}
@SdkInternalApi
final GlobalReplicationGroup executeDecreaseNodeGroupsInGlobalReplicationGroup(
DecreaseNodeGroupsInGlobalReplicationGroupRequest decreaseNodeGroupsInGlobalReplicationGroupRequest) {
ExecutionContext executionContext = createExecutionContext(decreaseNodeGroupsInGlobalReplicationGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DecreaseNodeGroupsInGlobalReplicationGroupRequestMarshaller().marshall(super
.beforeMarshalling(decreaseNodeGroupsInGlobalReplicationGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DecreaseNodeGroupsInGlobalReplicationGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new GlobalReplicationGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Dynamically decreases the number of replicas in a Redis OSS (cluster mode disabled) replication group or the
* number of replica nodes in one or more node groups (shards) of a Redis OSS (cluster mode enabled) replication
* group. This operation is performed with no cluster down time.
*
*
* @param decreaseReplicaCountRequest
* @return Result of the DecreaseReplicaCount 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 cluster is not in the available state.
* @throws InvalidVPCNetworkStateException
* The VPC network is in an invalid state.
* @throws InsufficientCacheClusterCapacityException
* The requested cache node type is not available in the specified Availability Zone. For more information,
* see InsufficientCacheClusterCapacity in the ElastiCache User Guide.
* @throws ClusterQuotaForCustomerExceededException
* The request cannot be processed because it would exceed the allowed number of clusters per customer.
* @throws NodeGroupsPerReplicationGroupQuotaExceededException
* The request cannot be processed because it would exceed the maximum allowed number of node groups
* (shards) in a single replication group. The default maximum is 90
* @throws NodeQuotaForCustomerExceededException
* The request cannot be processed because it would exceed the allowed number of cache nodes per customer.
* @throws ServiceLinkedRoleNotFoundException
* The specified service linked role (SLR) was not found.
* @throws NoOperationException
* The operation was not performed because no changes were required.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DecreaseReplicaCount
* @see AWS API Documentation
*/
@Override
public ReplicationGroup decreaseReplicaCount(DecreaseReplicaCountRequest request) {
request = beforeClientExecution(request);
return executeDecreaseReplicaCount(request);
}
@SdkInternalApi
final ReplicationGroup executeDecreaseReplicaCount(DecreaseReplicaCountRequest decreaseReplicaCountRequest) {
ExecutionContext executionContext = createExecutionContext(decreaseReplicaCountRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DecreaseReplicaCountRequestMarshaller().marshall(super.beforeMarshalling(decreaseReplicaCountRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DecreaseReplicaCount");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new ReplicationGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a previously provisioned cluster. DeleteCacheCluster deletes all associated cache nodes,
* node endpoints and the cluster itself. When you receive a successful response from this operation, Amazon
* ElastiCache immediately begins deleting the cluster; you cannot cancel or revert this operation.
*
*
* This operation is not valid for:
*
*
* -
*
* Redis OSS (cluster mode enabled) clusters
*
*
* -
*
* Redis OSS (cluster mode disabled) clusters
*
*
* -
*
* A cluster that is the last read replica of a replication group
*
*
* -
*
* A cluster that is the primary node of a replication group
*
*
* -
*
* A node group (shard) that has Multi-AZ mode enabled
*
*
* -
*
* A cluster from a Redis OSS (cluster mode enabled) replication group
*
*
* -
*
* A cluster that is not in the available state
*
*
*
*
* @param deleteCacheClusterRequest
* Represents the input of a DeleteCacheCluster operation.
* @return Result of the DeleteCacheCluster operation returned by the service.
* @throws CacheClusterNotFoundException
* The requested cluster ID does not refer to an existing cluster.
* @throws InvalidCacheClusterStateException
* The requested 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 operations:
*
* -
*
* Creating a snapshot of a Redis OSS cluster running on a cache.t1.micro cache node.
*
*
* -
*
* Creating a snapshot of a cluster that is running Memcached rather than Redis OSS.
*
*
*
*
* 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
* @see AWS
* API Documentation
*/
@Override
public CacheCluster deleteCacheCluster(DeleteCacheClusterRequest request) {
request = beforeClientExecution(request);
return executeDeleteCacheCluster(request);
}
@SdkInternalApi
final CacheCluster executeDeleteCacheCluster(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteCacheCluster");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new CacheClusterStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the specified cache parameter group. You cannot delete a cache parameter group if it is associated with
* any cache clusters. You cannot delete the default cache parameter groups in your account.
*
*
* @param deleteCacheParameterGroupRequest
* Represents the input of a DeleteCacheParameterGroup operation.
* @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 operation 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
* @see AWS API Documentation
*/
@Override
public DeleteCacheParameterGroupResult deleteCacheParameterGroup(DeleteCacheParameterGroupRequest request) {
request = beforeClientExecution(request);
return executeDeleteCacheParameterGroup(request);
}
@SdkInternalApi
final DeleteCacheParameterGroupResult executeDeleteCacheParameterGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteCacheParameterGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteCacheParameterGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a cache security group.
*
*
*
* You cannot delete a cache security group if it is associated with any clusters.
*
*
*
* @param deleteCacheSecurityGroupRequest
* Represents the input of a DeleteCacheSecurityGroup operation.
* @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
* @see AWS API Documentation
*/
@Override
public DeleteCacheSecurityGroupResult deleteCacheSecurityGroup(DeleteCacheSecurityGroupRequest request) {
request = beforeClientExecution(request);
return executeDeleteCacheSecurityGroup(request);
}
@SdkInternalApi
final DeleteCacheSecurityGroupResult executeDeleteCacheSecurityGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteCacheSecurityGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteCacheSecurityGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a cache subnet group.
*
*
*
* You cannot delete a default cache subnet group or one that is associated with any clusters.
*
*
*
* @param deleteCacheSubnetGroupRequest
* Represents the input of a DeleteCacheSubnetGroup operation.
* @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
* @see AWS API Documentation
*/
@Override
public DeleteCacheSubnetGroupResult deleteCacheSubnetGroup(DeleteCacheSubnetGroupRequest request) {
request = beforeClientExecution(request);
return executeDeleteCacheSubnetGroup(request);
}
@SdkInternalApi
final DeleteCacheSubnetGroupResult executeDeleteCacheSubnetGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteCacheSubnetGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteCacheSubnetGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deleting a Global datastore is a two-step process:
*
*
* -
*
* First, you must DisassociateGlobalReplicationGroup to remove the secondary clusters in the Global
* datastore.
*
*
* -
*
* Once the Global datastore contains only the primary cluster, you can use the
* DeleteGlobalReplicationGroup API to delete the Global datastore while retainining the primary
* cluster using RetainPrimaryReplicationGroup=true.
*
*
*
*
* Since the Global Datastore has only a primary cluster, you can delete the Global Datastore while retaining the
* primary by setting RetainPrimaryReplicationGroup=true. The primary cluster is never deleted when
* deleting a Global Datastore. It can only be deleted when it no longer is associated with any Global Datastore.
*
*
* When you receive a successful response from this operation, Amazon ElastiCache immediately begins deleting the
* selected resources; you cannot cancel or revert this operation.
*
*
* @param deleteGlobalReplicationGroupRequest
* @return Result of the DeleteGlobalReplicationGroup operation returned by the service.
* @throws GlobalReplicationGroupNotFoundException
* The Global datastore does not exist
* @throws InvalidGlobalReplicationGroupStateException
* The Global datastore is not available or in primary-only state.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @sample AmazonElastiCache.DeleteGlobalReplicationGroup
* @see AWS API Documentation
*/
@Override
public GlobalReplicationGroup deleteGlobalReplicationGroup(DeleteGlobalReplicationGroupRequest request) {
request = beforeClientExecution(request);
return executeDeleteGlobalReplicationGroup(request);
}
@SdkInternalApi
final GlobalReplicationGroup executeDeleteGlobalReplicationGroup(DeleteGlobalReplicationGroupRequest deleteGlobalReplicationGroupRequest) {
ExecutionContext executionContext = createExecutionContext(deleteGlobalReplicationGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteGlobalReplicationGroupRequestMarshaller().marshall(super.beforeMarshalling(deleteGlobalReplicationGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteGlobalReplicationGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new GlobalReplicationGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an existing replication group. By default, this operation deletes the entire replication group, including
* the primary/primaries and all of the read replicas. If the replication group has only one primary, you can
* optionally delete only the read replicas, while retaining the primary by setting
* RetainPrimaryCluster=true.
*
*
* When you receive a successful response from this operation, Amazon ElastiCache immediately begins deleting the
* selected resources; you cannot cancel or revert this operation.
*
*
*
* -
*
* CreateSnapshot permission is required to create a final snapshot. Without this permission, the API
* call will fail with an Access Denied exception.
*
*
* -
*
* This operation is valid for Redis OSS only.
*
*
*
*
*
* @param deleteReplicationGroupRequest
* Represents the input of a DeleteReplicationGroup operation.
* @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 operations:
*
* -
*
* Creating a snapshot of a Redis OSS cluster running on a cache.t1.micro cache node.
*
*
* -
*
* Creating a snapshot of a cluster that is running Memcached rather than Redis OSS.
*
*
*
*
* 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
* @see AWS API Documentation
*/
@Override
public ReplicationGroup deleteReplicationGroup(DeleteReplicationGroupRequest request) {
request = beforeClientExecution(request);
return executeDeleteReplicationGroup(request);
}
@SdkInternalApi
final ReplicationGroup executeDeleteReplicationGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteReplicationGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new ReplicationGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a specified existing serverless cache.
*
*
*
* CreateServerlessCacheSnapshot permission is required to create a final snapshot. Without this
* permission, the API call will fail with an Access Denied exception.
*
*
*
* @param deleteServerlessCacheRequest
* @return Result of the DeleteServerlessCache operation returned by the service.
* @throws ServerlessCacheNotFoundException
* The serverless cache was not found or does not exist.
* @throws InvalidServerlessCacheStateException
* The account for these credentials is not currently active.
* @throws ServerlessCacheSnapshotAlreadyExistsException
* A serverless cache snapshot with this name already exists. Available for Redis OSS and Serverless
* Memcached only.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @throws InvalidCredentialsException
* You must enter valid credentials.
* @throws ServiceLinkedRoleNotFoundException
* The specified service linked role (SLR) was not found.
* @sample AmazonElastiCache.DeleteServerlessCache
* @see AWS API Documentation
*/
@Override
public DeleteServerlessCacheResult deleteServerlessCache(DeleteServerlessCacheRequest request) {
request = beforeClientExecution(request);
return executeDeleteServerlessCache(request);
}
@SdkInternalApi
final DeleteServerlessCacheResult executeDeleteServerlessCache(DeleteServerlessCacheRequest deleteServerlessCacheRequest) {
ExecutionContext executionContext = createExecutionContext(deleteServerlessCacheRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteServerlessCacheRequestMarshaller().marshall(super.beforeMarshalling(deleteServerlessCacheRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteServerlessCache");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteServerlessCacheResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an existing serverless cache snapshot. Available for Redis OSS and Serverless Memcached only.
*
*
* @param deleteServerlessCacheSnapshotRequest
* @return Result of the DeleteServerlessCacheSnapshot operation returned by the service.
* @throws ServiceLinkedRoleNotFoundException
* The specified service linked role (SLR) was not found.
* @throws ServerlessCacheSnapshotNotFoundException
* This serverless cache snapshot could not be found or does not exist. Available for Redis OSS and
* Serverless Memcached only.
* @throws InvalidServerlessCacheSnapshotStateException
* The state of the serverless cache snapshot was not received. Available for Redis OSS and Serverless
* Memcached only.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @sample AmazonElastiCache.DeleteServerlessCacheSnapshot
* @see AWS API Documentation
*/
@Override
public DeleteServerlessCacheSnapshotResult deleteServerlessCacheSnapshot(DeleteServerlessCacheSnapshotRequest request) {
request = beforeClientExecution(request);
return executeDeleteServerlessCacheSnapshot(request);
}
@SdkInternalApi
final DeleteServerlessCacheSnapshotResult executeDeleteServerlessCacheSnapshot(DeleteServerlessCacheSnapshotRequest deleteServerlessCacheSnapshotRequest) {
ExecutionContext executionContext = createExecutionContext(deleteServerlessCacheSnapshotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteServerlessCacheSnapshotRequestMarshaller().marshall(super.beforeMarshalling(deleteServerlessCacheSnapshotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteServerlessCacheSnapshot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteServerlessCacheSnapshotResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an existing snapshot. When you receive a successful response from this operation, ElastiCache immediately
* begins deleting the snapshot; you cannot cancel or revert this operation.
*
*
*
* This operation is valid for Redis OSS only.
*
*
*
* @param deleteSnapshotRequest
* Represents the input of a DeleteSnapshot operation.
* @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 operation to occur.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DeleteSnapshot
* @see AWS API
* Documentation
*/
@Override
public Snapshot deleteSnapshot(DeleteSnapshotRequest request) {
request = beforeClientExecution(request);
return executeDeleteSnapshot(request);
}
@SdkInternalApi
final Snapshot executeDeleteSnapshot(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteSnapshot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new SnapshotStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* For Redis OSS engine version 6.0 onwards: Deletes a user. The user will be removed from all user groups and in
* turn removed from all replication groups. For more information, see Using Role Based Access
* Control (RBAC).
*
*
* @param deleteUserRequest
* @return Result of the DeleteUser operation returned by the service.
* @throws InvalidUserStateException
* The user is not in active state.
* @throws UserNotFoundException
* The user does not exist or could not be found.
* @throws ServiceLinkedRoleNotFoundException
* The specified service linked role (SLR) was not found.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws DefaultUserAssociatedToUserGroupException
* The default user assigned to the user group.
* @sample AmazonElastiCache.DeleteUser
* @see AWS API
* Documentation
*/
@Override
public DeleteUserResult deleteUser(DeleteUserRequest request) {
request = beforeClientExecution(request);
return executeDeleteUser(request);
}
@SdkInternalApi
final DeleteUserResult executeDeleteUser(DeleteUserRequest deleteUserRequest) {
ExecutionContext executionContext = createExecutionContext(deleteUserRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteUserRequestMarshaller().marshall(super.beforeMarshalling(deleteUserRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteUser");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new DeleteUserResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* For Redis OSS engine version 6.0 onwards: Deletes a user group. The user group must first be disassociated from
* the replication group before it can be deleted. For more information, see Using Role Based Access
* Control (RBAC).
*
*
* @param deleteUserGroupRequest
* @return Result of the DeleteUserGroup operation returned by the service.
* @throws UserGroupNotFoundException
* The user group was not found or does not exist
* @throws InvalidUserGroupStateException
* The user group is not in an active state.
* @throws ServiceLinkedRoleNotFoundException
* The specified service linked role (SLR) was not found.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @sample AmazonElastiCache.DeleteUserGroup
* @see AWS
* API Documentation
*/
@Override
public DeleteUserGroupResult deleteUserGroup(DeleteUserGroupRequest request) {
request = beforeClientExecution(request);
return executeDeleteUserGroup(request);
}
@SdkInternalApi
final DeleteUserGroupResult executeDeleteUserGroup(DeleteUserGroupRequest deleteUserGroupRequest) {
ExecutionContext executionContext = createExecutionContext(deleteUserGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteUserGroupRequestMarshaller().marshall(super.beforeMarshalling(deleteUserGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteUserGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteUserGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns information about all provisioned clusters if no cluster identifier is specified, or about a specific
* cache cluster if a cluster identifier is supplied.
*
*
* By default, abbreviated information about the clusters is returned. You can use the optional
* ShowCacheNodeInfo flag to retrieve detailed information about the cache nodes associated with the
* 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 is displayed until all of the
* nodes are successfully provisioned.
*
*
* If the cluster is in the deleting state, only cluster-level information is displayed.
*
*
* If cache nodes are currently being added to the cluster, node endpoint information and creation time for the
* additional nodes are not displayed until they are completely provisioned. When the cluster state is
* available, the cluster is ready for use.
*
*
* If cache nodes are currently being removed from the cluster, no endpoint information for the removed nodes is
* displayed.
*
*
* @param describeCacheClustersRequest
* Represents the input of a DescribeCacheClusters operation.
* @return Result of the DescribeCacheClusters operation returned by the service.
* @throws CacheClusterNotFoundException
* The requested cluster ID does not refer to an existing cluster.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DescribeCacheClusters
* @see AWS API Documentation
*/
@Override
public DescribeCacheClustersResult describeCacheClusters(DescribeCacheClustersRequest request) {
request = beforeClientExecution(request);
return executeDescribeCacheClusters(request);
}
@SdkInternalApi
final DescribeCacheClustersResult executeDescribeCacheClusters(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeCacheClusters");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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());
}
/**
*
* Returns a list of the available cache engines and their versions.
*
*
* @param describeCacheEngineVersionsRequest
* Represents the input of a DescribeCacheEngineVersions operation.
* @return Result of the DescribeCacheEngineVersions operation returned by the service.
* @sample AmazonElastiCache.DescribeCacheEngineVersions
* @see AWS API Documentation
*/
@Override
public DescribeCacheEngineVersionsResult describeCacheEngineVersions(DescribeCacheEngineVersionsRequest request) {
request = beforeClientExecution(request);
return executeDescribeCacheEngineVersions(request);
}
@SdkInternalApi
final DescribeCacheEngineVersionsResult executeDescribeCacheEngineVersions(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeCacheEngineVersions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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());
}
/**
*
* Returns a list of cache parameter group descriptions. If a cache parameter group name is specified, the list
* contains only the descriptions for that group.
*
*
* @param describeCacheParameterGroupsRequest
* Represents the input of a DescribeCacheParameterGroups operation.
* @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
* @see AWS API Documentation
*/
@Override
public DescribeCacheParameterGroupsResult describeCacheParameterGroups(DescribeCacheParameterGroupsRequest request) {
request = beforeClientExecution(request);
return executeDescribeCacheParameterGroups(request);
}
@SdkInternalApi
final DescribeCacheParameterGroupsResult executeDescribeCacheParameterGroups(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeCacheParameterGroups");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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());
}
/**
*
* Returns the detailed parameter list for a particular cache parameter group.
*
*
* @param describeCacheParametersRequest
* Represents the input of a DescribeCacheParameters operation.
* @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
* @see AWS API Documentation
*/
@Override
public DescribeCacheParametersResult describeCacheParameters(DescribeCacheParametersRequest request) {
request = beforeClientExecution(request);
return executeDescribeCacheParameters(request);
}
@SdkInternalApi
final DescribeCacheParametersResult executeDescribeCacheParameters(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeCacheParameters");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeCacheParametersResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of cache security group descriptions. If a cache security group name is specified, the list
* contains only the description of that group. This applicable only when you have ElastiCache in Classic setup
*
*
* @param describeCacheSecurityGroupsRequest
* Represents the input of a DescribeCacheSecurityGroups operation.
* @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
* @see AWS API Documentation
*/
@Override
public DescribeCacheSecurityGroupsResult describeCacheSecurityGroups(DescribeCacheSecurityGroupsRequest request) {
request = beforeClientExecution(request);
return executeDescribeCacheSecurityGroups(request);
}
@SdkInternalApi
final DescribeCacheSecurityGroupsResult executeDescribeCacheSecurityGroups(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeCacheSecurityGroups");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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());
}
/**
*
* Returns a list of cache subnet group descriptions. If a subnet group name is specified, the list contains only
* the description of that group. This is applicable only when you have ElastiCache in VPC setup. All ElastiCache
* clusters now launch in VPC by default.
*
*
* @param describeCacheSubnetGroupsRequest
* Represents the input of a DescribeCacheSubnetGroups operation.
* @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
* @see AWS API Documentation
*/
@Override
public DescribeCacheSubnetGroupsResult describeCacheSubnetGroups(DescribeCacheSubnetGroupsRequest request) {
request = beforeClientExecution(request);
return executeDescribeCacheSubnetGroups(request);
}
@SdkInternalApi
final DescribeCacheSubnetGroupsResult executeDescribeCacheSubnetGroups(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeCacheSubnetGroups");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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());
}
/**
*
* Returns the default engine and system parameter information for the specified cache engine.
*
*
* @param describeEngineDefaultParametersRequest
* Represents the input of a DescribeEngineDefaultParameters operation.
* @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
* @see AWS API Documentation
*/
@Override
public EngineDefaults describeEngineDefaultParameters(DescribeEngineDefaultParametersRequest request) {
request = beforeClientExecution(request);
return executeDescribeEngineDefaultParameters(request);
}
@SdkInternalApi
final EngineDefaults executeDescribeEngineDefaultParameters(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeEngineDefaultParameters");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new EngineDefaultsStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns events related to clusters, cache security groups, and cache parameter groups. You can obtain events
* specific to a particular 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 operation.
* @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
* @see AWS API
* Documentation
*/
@Override
public DescribeEventsResult describeEvents(DescribeEventsRequest request) {
request = beforeClientExecution(request);
return executeDescribeEvents(request);
}
@SdkInternalApi
final DescribeEventsResult executeDescribeEvents(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeEvents");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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());
}
/**
*
* Returns information about a particular global replication group. If no identifier is specified, returns
* information about all Global datastores.
*
*
* @param describeGlobalReplicationGroupsRequest
* @return Result of the DescribeGlobalReplicationGroups operation returned by the service.
* @throws GlobalReplicationGroupNotFoundException
* The Global datastore does not exist
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DescribeGlobalReplicationGroups
* @see AWS API Documentation
*/
@Override
public DescribeGlobalReplicationGroupsResult describeGlobalReplicationGroups(DescribeGlobalReplicationGroupsRequest request) {
request = beforeClientExecution(request);
return executeDescribeGlobalReplicationGroups(request);
}
@SdkInternalApi
final DescribeGlobalReplicationGroupsResult executeDescribeGlobalReplicationGroups(
DescribeGlobalReplicationGroupsRequest describeGlobalReplicationGroupsRequest) {
ExecutionContext executionContext = createExecutionContext(describeGlobalReplicationGroupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeGlobalReplicationGroupsRequestMarshaller().marshall(super.beforeMarshalling(describeGlobalReplicationGroupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeGlobalReplicationGroups");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeGlobalReplicationGroupsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns information about a particular replication group. If no identifier is specified,
* DescribeReplicationGroups returns information about all replication groups.
*
*
*
* This operation is valid for Redis OSS only.
*
*
*
* @param describeReplicationGroupsRequest
* Represents the input of a DescribeReplicationGroups operation.
* @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
* @see AWS API Documentation
*/
@Override
public DescribeReplicationGroupsResult describeReplicationGroups(DescribeReplicationGroupsRequest request) {
request = beforeClientExecution(request);
return executeDescribeReplicationGroups(request);
}
@SdkInternalApi
final DescribeReplicationGroupsResult executeDescribeReplicationGroups(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeReplicationGroups");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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());
}
/**
*
* Returns information about reserved cache nodes for this account, or about a specified reserved cache node.
*
*
* @param describeReservedCacheNodesRequest
* Represents the input of a DescribeReservedCacheNodes operation.
* @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
* @see AWS API Documentation
*/
@Override
public DescribeReservedCacheNodesResult describeReservedCacheNodes(DescribeReservedCacheNodesRequest request) {
request = beforeClientExecution(request);
return executeDescribeReservedCacheNodes(request);
}
@SdkInternalApi
final DescribeReservedCacheNodesResult executeDescribeReservedCacheNodes(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeReservedCacheNodes");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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());
}
/**
*
* Lists available reserved cache node offerings.
*
*
* @param describeReservedCacheNodesOfferingsRequest
* Represents the input of a DescribeReservedCacheNodesOfferings operation.
* @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
* @see AWS API Documentation
*/
@Override
public DescribeReservedCacheNodesOfferingsResult describeReservedCacheNodesOfferings(DescribeReservedCacheNodesOfferingsRequest request) {
request = beforeClientExecution(request);
return executeDescribeReservedCacheNodesOfferings(request);
}
@SdkInternalApi
final DescribeReservedCacheNodesOfferingsResult executeDescribeReservedCacheNodesOfferings(
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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeReservedCacheNodesOfferings");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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());
}
/**
*
* Returns information about serverless cache snapshots. By default, this API lists all of the customer’s serverless
* cache snapshots. It can also describe a single serverless cache snapshot, or the snapshots associated with a
* particular serverless cache. Available for Redis OSS and Serverless Memcached only.
*
*
* @param describeServerlessCacheSnapshotsRequest
* @return Result of the DescribeServerlessCacheSnapshots operation returned by the service.
* @throws ServerlessCacheNotFoundException
* The serverless cache was not found or does not exist.
* @throws ServerlessCacheSnapshotNotFoundException
* This serverless cache snapshot could not be found or does not exist. Available for Redis OSS and
* Serverless Memcached only.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DescribeServerlessCacheSnapshots
* @see AWS API Documentation
*/
@Override
public DescribeServerlessCacheSnapshotsResult describeServerlessCacheSnapshots(DescribeServerlessCacheSnapshotsRequest request) {
request = beforeClientExecution(request);
return executeDescribeServerlessCacheSnapshots(request);
}
@SdkInternalApi
final DescribeServerlessCacheSnapshotsResult executeDescribeServerlessCacheSnapshots(
DescribeServerlessCacheSnapshotsRequest describeServerlessCacheSnapshotsRequest) {
ExecutionContext executionContext = createExecutionContext(describeServerlessCacheSnapshotsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeServerlessCacheSnapshotsRequestMarshaller().marshall(super.beforeMarshalling(describeServerlessCacheSnapshotsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeServerlessCacheSnapshots");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeServerlessCacheSnapshotsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns information about a specific serverless cache. If no identifier is specified, then the API returns
* information on all the serverless caches belonging to this Amazon Web Services account.
*
*
* @param describeServerlessCachesRequest
* @return Result of the DescribeServerlessCaches operation returned by the service.
* @throws ServerlessCacheNotFoundException
* The serverless cache was not found or does not exist.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DescribeServerlessCaches
* @see AWS API Documentation
*/
@Override
public DescribeServerlessCachesResult describeServerlessCaches(DescribeServerlessCachesRequest request) {
request = beforeClientExecution(request);
return executeDescribeServerlessCaches(request);
}
@SdkInternalApi
final DescribeServerlessCachesResult executeDescribeServerlessCaches(DescribeServerlessCachesRequest describeServerlessCachesRequest) {
ExecutionContext executionContext = createExecutionContext(describeServerlessCachesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeServerlessCachesRequestMarshaller().marshall(super.beforeMarshalling(describeServerlessCachesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeServerlessCaches");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeServerlessCachesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns details of the service updates
*
*
* @param describeServiceUpdatesRequest
* @return Result of the DescribeServiceUpdates operation returned by the service.
* @throws ServiceUpdateNotFoundException
* The service update doesn't exist
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DescribeServiceUpdates
* @see AWS API Documentation
*/
@Override
public DescribeServiceUpdatesResult describeServiceUpdates(DescribeServiceUpdatesRequest request) {
request = beforeClientExecution(request);
return executeDescribeServiceUpdates(request);
}
@SdkInternalApi
final DescribeServiceUpdatesResult executeDescribeServiceUpdates(DescribeServiceUpdatesRequest describeServiceUpdatesRequest) {
ExecutionContext executionContext = createExecutionContext(describeServiceUpdatesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeServiceUpdatesRequestMarshaller().marshall(super.beforeMarshalling(describeServiceUpdatesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeServiceUpdates");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeServiceUpdatesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns information about cluster or replication group 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.
*
*
*
* This operation is valid for Redis OSS only.
*
*
*
* @param describeSnapshotsRequest
* Represents the input of a DescribeSnapshotsMessage operation.
* @return Result of the DescribeSnapshots operation returned by the service.
* @throws CacheClusterNotFoundException
* The requested cluster ID does not refer to an existing 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
* @see AWS
* API Documentation
*/
@Override
public DescribeSnapshotsResult describeSnapshots(DescribeSnapshotsRequest request) {
request = beforeClientExecution(request);
return executeDescribeSnapshots(request);
}
@SdkInternalApi
final DescribeSnapshotsResult executeDescribeSnapshots(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeSnapshots");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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());
}
/**
*
* Returns details of the update actions
*
*
* @param describeUpdateActionsRequest
* @return Result of the DescribeUpdateActions 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.DescribeUpdateActions
* @see AWS API Documentation
*/
@Override
public DescribeUpdateActionsResult describeUpdateActions(DescribeUpdateActionsRequest request) {
request = beforeClientExecution(request);
return executeDescribeUpdateActions(request);
}
@SdkInternalApi
final DescribeUpdateActionsResult executeDescribeUpdateActions(DescribeUpdateActionsRequest describeUpdateActionsRequest) {
ExecutionContext executionContext = createExecutionContext(describeUpdateActionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeUpdateActionsRequestMarshaller().marshall(super.beforeMarshalling(describeUpdateActionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeUpdateActions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeUpdateActionsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of user groups.
*
*
* @param describeUserGroupsRequest
* @return Result of the DescribeUserGroups operation returned by the service.
* @throws UserGroupNotFoundException
* The user group was not found or does not exist
* @throws ServiceLinkedRoleNotFoundException
* The specified service linked role (SLR) was not found.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DescribeUserGroups
* @see AWS
* API Documentation
*/
@Override
public DescribeUserGroupsResult describeUserGroups(DescribeUserGroupsRequest request) {
request = beforeClientExecution(request);
return executeDescribeUserGroups(request);
}
@SdkInternalApi
final DescribeUserGroupsResult executeDescribeUserGroups(DescribeUserGroupsRequest describeUserGroupsRequest) {
ExecutionContext executionContext = createExecutionContext(describeUserGroupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeUserGroupsRequestMarshaller().marshall(super.beforeMarshalling(describeUserGroupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeUserGroups");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DescribeUserGroupsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of users.
*
*
* @param describeUsersRequest
* @return Result of the DescribeUsers operation returned by the service.
* @throws UserNotFoundException
* The user does not exist or could not be found.
* @throws ServiceLinkedRoleNotFoundException
* The specified service linked role (SLR) was not found.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DescribeUsers
* @see AWS API
* Documentation
*/
@Override
public DescribeUsersResult describeUsers(DescribeUsersRequest request) {
request = beforeClientExecution(request);
return executeDescribeUsers(request);
}
@SdkInternalApi
final DescribeUsersResult executeDescribeUsers(DescribeUsersRequest describeUsersRequest) {
ExecutionContext executionContext = createExecutionContext(describeUsersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeUsersRequestMarshaller().marshall(super.beforeMarshalling(describeUsersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeUsers");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new DescribeUsersResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Remove a secondary cluster from the Global datastore using the Global datastore name. The secondary cluster will
* no longer receive updates from the primary cluster, but will remain as a standalone cluster in that Amazon
* region.
*
*
* @param disassociateGlobalReplicationGroupRequest
* @return Result of the DisassociateGlobalReplicationGroup operation returned by the service.
* @throws GlobalReplicationGroupNotFoundException
* The Global datastore does not exist
* @throws InvalidGlobalReplicationGroupStateException
* The Global datastore is not available or in primary-only state.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.DisassociateGlobalReplicationGroup
* @see AWS API Documentation
*/
@Override
public GlobalReplicationGroup disassociateGlobalReplicationGroup(DisassociateGlobalReplicationGroupRequest request) {
request = beforeClientExecution(request);
return executeDisassociateGlobalReplicationGroup(request);
}
@SdkInternalApi
final GlobalReplicationGroup executeDisassociateGlobalReplicationGroup(DisassociateGlobalReplicationGroupRequest disassociateGlobalReplicationGroupRequest) {
ExecutionContext executionContext = createExecutionContext(disassociateGlobalReplicationGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DisassociateGlobalReplicationGroupRequestMarshaller()
.marshall(super.beforeMarshalling(disassociateGlobalReplicationGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DisassociateGlobalReplicationGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new GlobalReplicationGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Provides the functionality to export the serverless cache snapshot data to Amazon S3. Available for Redis OSS
* only.
*
*
* @param exportServerlessCacheSnapshotRequest
* @return Result of the ExportServerlessCacheSnapshot operation returned by the service.
* @throws ServerlessCacheSnapshotNotFoundException
* This serverless cache snapshot could not be found or does not exist. Available for Redis OSS and
* Serverless Memcached only.
* @throws InvalidServerlessCacheSnapshotStateException
* The state of the serverless cache snapshot was not received. Available for Redis OSS and Serverless
* Memcached only.
* @throws ServiceLinkedRoleNotFoundException
* The specified service linked role (SLR) was not found.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @sample AmazonElastiCache.ExportServerlessCacheSnapshot
* @see AWS API Documentation
*/
@Override
public ExportServerlessCacheSnapshotResult exportServerlessCacheSnapshot(ExportServerlessCacheSnapshotRequest request) {
request = beforeClientExecution(request);
return executeExportServerlessCacheSnapshot(request);
}
@SdkInternalApi
final ExportServerlessCacheSnapshotResult executeExportServerlessCacheSnapshot(ExportServerlessCacheSnapshotRequest exportServerlessCacheSnapshotRequest) {
ExecutionContext executionContext = createExecutionContext(exportServerlessCacheSnapshotRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ExportServerlessCacheSnapshotRequestMarshaller().marshall(super.beforeMarshalling(exportServerlessCacheSnapshotRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ExportServerlessCacheSnapshot");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ExportServerlessCacheSnapshotResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Used to failover the primary region to a secondary region. The secondary region will become primary, and all
* other clusters will become secondary.
*
*
* @param failoverGlobalReplicationGroupRequest
* @return Result of the FailoverGlobalReplicationGroup operation returned by the service.
* @throws GlobalReplicationGroupNotFoundException
* The Global datastore does not exist
* @throws InvalidGlobalReplicationGroupStateException
* The Global datastore is not available or in primary-only state.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.FailoverGlobalReplicationGroup
* @see AWS API Documentation
*/
@Override
public GlobalReplicationGroup failoverGlobalReplicationGroup(FailoverGlobalReplicationGroupRequest request) {
request = beforeClientExecution(request);
return executeFailoverGlobalReplicationGroup(request);
}
@SdkInternalApi
final GlobalReplicationGroup executeFailoverGlobalReplicationGroup(FailoverGlobalReplicationGroupRequest failoverGlobalReplicationGroupRequest) {
ExecutionContext executionContext = createExecutionContext(failoverGlobalReplicationGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new FailoverGlobalReplicationGroupRequestMarshaller().marshall(super.beforeMarshalling(failoverGlobalReplicationGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "FailoverGlobalReplicationGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new GlobalReplicationGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Increase the number of node groups in the Global datastore
*
*
* @param increaseNodeGroupsInGlobalReplicationGroupRequest
* @return Result of the IncreaseNodeGroupsInGlobalReplicationGroup operation returned by the service.
* @throws GlobalReplicationGroupNotFoundException
* The Global datastore does not exist
* @throws InvalidGlobalReplicationGroupStateException
* The Global datastore is not available or in primary-only state.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @sample AmazonElastiCache.IncreaseNodeGroupsInGlobalReplicationGroup
* @see AWS API Documentation
*/
@Override
public GlobalReplicationGroup increaseNodeGroupsInGlobalReplicationGroup(IncreaseNodeGroupsInGlobalReplicationGroupRequest request) {
request = beforeClientExecution(request);
return executeIncreaseNodeGroupsInGlobalReplicationGroup(request);
}
@SdkInternalApi
final GlobalReplicationGroup executeIncreaseNodeGroupsInGlobalReplicationGroup(
IncreaseNodeGroupsInGlobalReplicationGroupRequest increaseNodeGroupsInGlobalReplicationGroupRequest) {
ExecutionContext executionContext = createExecutionContext(increaseNodeGroupsInGlobalReplicationGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new IncreaseNodeGroupsInGlobalReplicationGroupRequestMarshaller().marshall(super
.beforeMarshalling(increaseNodeGroupsInGlobalReplicationGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "IncreaseNodeGroupsInGlobalReplicationGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new GlobalReplicationGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Dynamically increases the number of replicas in a Redis OSS (cluster mode disabled) replication group or the
* number of replica nodes in one or more node groups (shards) of a Redis OSS (cluster mode enabled) replication
* group. This operation is performed with no cluster down time.
*
*
* @param increaseReplicaCountRequest
* @return Result of the IncreaseReplicaCount 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 cluster is not in the available state.
* @throws InvalidVPCNetworkStateException
* The VPC network is in an invalid state.
* @throws InsufficientCacheClusterCapacityException
* The requested cache node type is not available in the specified Availability Zone. For more information,
* see InsufficientCacheClusterCapacity in the ElastiCache User Guide.
* @throws ClusterQuotaForCustomerExceededException
* The request cannot be processed because it would exceed the allowed number of clusters per customer.
* @throws NodeGroupsPerReplicationGroupQuotaExceededException
* The request cannot be processed because it would exceed the maximum allowed number of node groups
* (shards) in a single replication group. The default maximum is 90
* @throws NodeQuotaForCustomerExceededException
* The request cannot be processed because it would exceed the allowed number of cache nodes per customer.
* @throws NoOperationException
* The operation was not performed because no changes were required.
* @throws InvalidKMSKeyException
* The KMS key supplied is not valid.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.IncreaseReplicaCount
* @see AWS API Documentation
*/
@Override
public ReplicationGroup increaseReplicaCount(IncreaseReplicaCountRequest request) {
request = beforeClientExecution(request);
return executeIncreaseReplicaCount(request);
}
@SdkInternalApi
final ReplicationGroup executeIncreaseReplicaCount(IncreaseReplicaCountRequest increaseReplicaCountRequest) {
ExecutionContext executionContext = createExecutionContext(increaseReplicaCountRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new IncreaseReplicaCountRequestMarshaller().marshall(super.beforeMarshalling(increaseReplicaCountRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "IncreaseReplicaCount");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new ReplicationGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists all available node types that you can scale your Redis OSS cluster's or replication group's current node
* type.
*
*
* When you use the ModifyCacheCluster or ModifyReplicationGroup operations to scale your
* cluster or replication group, the value of the CacheNodeType parameter must be one of the node types
* returned by this operation.
*
*
* @param listAllowedNodeTypeModificationsRequest
* The input parameters for the ListAllowedNodeTypeModifications operation.
* @return Result of the ListAllowedNodeTypeModifications operation returned by the service.
* @throws CacheClusterNotFoundException
* The requested cluster ID does not refer to an existing 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
* @see AWS API Documentation
*/
@Override
public ListAllowedNodeTypeModificationsResult listAllowedNodeTypeModifications(ListAllowedNodeTypeModificationsRequest request) {
request = beforeClientExecution(request);
return executeListAllowedNodeTypeModifications(request);
}
@SdkInternalApi
final ListAllowedNodeTypeModificationsResult executeListAllowedNodeTypeModifications(
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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListAllowedNodeTypeModifications");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} 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());
}
/**
*
* Lists all tags currently on a named resource.
*
*
* A tag is a key-value pair where the key and value are case-sensitive. You can use tags to categorize and track
* all your ElastiCache resources, with the exception of global replication group. When you add or remove tags on
* replication groups, those actions will be replicated to all nodes in the replication group. For more information,
* see Resource
* -level permissions.
*
*
* If the cluster is not in the available state, ListTagsForResource returns an error.
*
*
* @param listTagsForResourceRequest
* The input parameters for the ListTagsForResource operation.
* @return Result of the ListTagsForResource operation returned by the service.
* @throws CacheClusterNotFoundException
* The requested cluster ID does not refer to an existing cluster.
* @throws CacheParameterGroupNotFoundException
* The requested cache parameter group name does not refer to an existing cache parameter group.
* @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 InvalidReplicationGroupStateException
* The requested replication group is not in the available state.
* @throws ReplicationGroupNotFoundException
* The specified replication group does not exist.
* @throws ReservedCacheNodeNotFoundException
* The requested reserved cache node was not found.
* @throws SnapshotNotFoundException
* The requested snapshot name does not refer to an existing snapshot.
* @throws UserNotFoundException
* The user does not exist or could not be found.
* @throws UserGroupNotFoundException
* The user group was not found or does not exist
* @throws ServerlessCacheNotFoundException
* The serverless cache was not found or does not exist.
* @throws InvalidServerlessCacheStateException
* The account for these credentials is not currently active.
* @throws ServerlessCacheSnapshotNotFoundException
* This serverless cache snapshot could not be found or does not exist. Available for Redis OSS and
* Serverless Memcached only.
* @throws InvalidServerlessCacheSnapshotStateException
* The state of the serverless cache snapshot was not received. Available for Redis OSS and Serverless
* Memcached only.
* @throws InvalidARNException
* The requested Amazon Resource Name (ARN) does not refer to an existing resource.
* @sample AmazonElastiCache.ListTagsForResource
* @see AWS API Documentation
*/
@Override
public ListTagsForResourceResult listTagsForResource(ListTagsForResourceRequest request) {
request = beforeClientExecution(request);
return executeListTagsForResource(request);
}
@SdkInternalApi
final ListTagsForResourceResult executeListTagsForResource(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListTagsForResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ListTagsForResourceResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modifies the settings for a cluster. You can use this operation to change one or more cluster configuration
* parameters by specifying the parameters and the new values.
*
*
* @param modifyCacheClusterRequest
* Represents the input of a ModifyCacheCluster operation.
* @return Result of the ModifyCacheCluster operation returned by the service.
* @throws InvalidCacheClusterStateException
* The requested 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. For more information,
* see InsufficientCacheClusterCapacity in the ElastiCache User Guide.
* @throws CacheClusterNotFoundException
* The requested cluster ID does not refer to an existing cluster.
* @throws NodeQuotaForClusterExceededException
* The request cannot be processed because it would exceed the allowed number of cache nodes in a single
* 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
* @see AWS
* API Documentation
*/
@Override
public CacheCluster modifyCacheCluster(ModifyCacheClusterRequest request) {
request = beforeClientExecution(request);
return executeModifyCacheCluster(request);
}
@SdkInternalApi
final CacheCluster executeModifyCacheCluster(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyCacheCluster");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new CacheClusterStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 operation.
* @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 operation to occur.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @throws InvalidGlobalReplicationGroupStateException
* The Global datastore is not available or in primary-only state.
* @sample AmazonElastiCache.ModifyCacheParameterGroup
* @see AWS API Documentation
*/
@Override
public ModifyCacheParameterGroupResult modifyCacheParameterGroup(ModifyCacheParameterGroupRequest request) {
request = beforeClientExecution(request);
return executeModifyCacheParameterGroup(request);
}
@SdkInternalApi
final ModifyCacheParameterGroupResult executeModifyCacheParameterGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyCacheParameterGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ModifyCacheParameterGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modifies an existing cache subnet group.
*
*
* @param modifyCacheSubnetGroupRequest
* Represents the input of a ModifyCacheSubnetGroup operation.
* @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.
* @throws SubnetNotAllowedException
* At least one subnet ID does not match the other subnet IDs. This mismatch typically occurs when a user
* sets one subnet ID to a regional Availability Zone and a different one to an outpost. Or when a user sets
* the subnet ID to an Outpost when not subscribed on this service.
* @sample AmazonElastiCache.ModifyCacheSubnetGroup
* @see AWS API Documentation
*/
@Override
public CacheSubnetGroup modifyCacheSubnetGroup(ModifyCacheSubnetGroupRequest request) {
request = beforeClientExecution(request);
return executeModifyCacheSubnetGroup(request);
}
@SdkInternalApi
final CacheSubnetGroup executeModifyCacheSubnetGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyCacheSubnetGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new CacheSubnetGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modifies the settings for a Global datastore.
*
*
* @param modifyGlobalReplicationGroupRequest
* @return Result of the ModifyGlobalReplicationGroup operation returned by the service.
* @throws GlobalReplicationGroupNotFoundException
* The Global datastore does not exist
* @throws InvalidGlobalReplicationGroupStateException
* The Global datastore is not available or in primary-only state.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @sample AmazonElastiCache.ModifyGlobalReplicationGroup
* @see AWS API Documentation
*/
@Override
public GlobalReplicationGroup modifyGlobalReplicationGroup(ModifyGlobalReplicationGroupRequest request) {
request = beforeClientExecution(request);
return executeModifyGlobalReplicationGroup(request);
}
@SdkInternalApi
final GlobalReplicationGroup executeModifyGlobalReplicationGroup(ModifyGlobalReplicationGroupRequest modifyGlobalReplicationGroupRequest) {
ExecutionContext executionContext = createExecutionContext(modifyGlobalReplicationGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyGlobalReplicationGroupRequestMarshaller().marshall(super.beforeMarshalling(modifyGlobalReplicationGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyGlobalReplicationGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new GlobalReplicationGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modifies the settings for a replication group. This is limited to Redis OSS 7 and newer.
*
*
* -
*
*
* Scaling for Amazon ElastiCache (Redis OSS) (cluster mode enabled) in the ElastiCache User Guide
*
*
* -
*
* ModifyReplicationGroupShardConfiguration in the ElastiCache API Reference
*
*
*
*
*
* This operation is valid for Redis OSS only.
*
*
*
* @param modifyReplicationGroupRequest
* Represents the input of a ModifyReplicationGroups operation.
* @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 InvalidUserGroupStateException
* The user group is not in an active state.
* @throws UserGroupNotFoundException
* The user group was not found or does not exist
* @throws InvalidCacheClusterStateException
* The requested 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. For more information,
* see InsufficientCacheClusterCapacity in the ElastiCache User Guide.
* @throws CacheClusterNotFoundException
* The requested cluster ID does not refer to an existing cluster.
* @throws NodeQuotaForClusterExceededException
* The request cannot be processed because it would exceed the allowed number of cache nodes in a single
* 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 InvalidKMSKeyException
* The KMS key supplied is not valid.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.ModifyReplicationGroup
* @see AWS API Documentation
*/
@Override
public ReplicationGroup modifyReplicationGroup(ModifyReplicationGroupRequest request) {
request = beforeClientExecution(request);
return executeModifyReplicationGroup(request);
}
@SdkInternalApi
final ReplicationGroup executeModifyReplicationGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyReplicationGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new ReplicationGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Modifies a replication group's shards (node groups) by allowing you to add shards, remove shards, or rebalance
* the keyspaces among existing shards.
*
*
* @param modifyReplicationGroupShardConfigurationRequest
* Represents the input for a ModifyReplicationGroupShardConfiguration operation.
* @return Result of the ModifyReplicationGroupShardConfiguration 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 cluster is not in the available state.
* @throws InvalidVPCNetworkStateException
* The VPC network is in an invalid state.
* @throws InsufficientCacheClusterCapacityException
* The requested cache node type is not available in the specified Availability Zone. For more information,
* see InsufficientCacheClusterCapacity in the ElastiCache User Guide.
* @throws NodeGroupsPerReplicationGroupQuotaExceededException
* The request cannot be processed because it would exceed the maximum allowed number of node groups
* (shards) in a single replication group. The default maximum is 90
* @throws NodeQuotaForCustomerExceededException
* The request cannot be processed because it would exceed the allowed number of cache nodes per customer.
* @throws InvalidKMSKeyException
* The KMS key supplied is not valid.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.ModifyReplicationGroupShardConfiguration
* @see AWS API Documentation
*/
@Override
public ReplicationGroup modifyReplicationGroupShardConfiguration(ModifyReplicationGroupShardConfigurationRequest request) {
request = beforeClientExecution(request);
return executeModifyReplicationGroupShardConfiguration(request);
}
@SdkInternalApi
final ReplicationGroup executeModifyReplicationGroupShardConfiguration(
ModifyReplicationGroupShardConfigurationRequest modifyReplicationGroupShardConfigurationRequest) {
ExecutionContext executionContext = createExecutionContext(modifyReplicationGroupShardConfigurationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyReplicationGroupShardConfigurationRequestMarshaller().marshall(super
.beforeMarshalling(modifyReplicationGroupShardConfigurationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyReplicationGroupShardConfiguration");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new ReplicationGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* This API modifies the attributes of a serverless cache.
*
*
* @param modifyServerlessCacheRequest
* @return Result of the ModifyServerlessCache operation returned by the service.
* @throws ServerlessCacheNotFoundException
* The serverless cache was not found or does not exist.
* @throws InvalidServerlessCacheStateException
* The account for these credentials is not currently active.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @throws InvalidCredentialsException
* You must enter valid credentials.
* @throws InvalidUserGroupStateException
* The user group is not in an active state.
* @throws UserGroupNotFoundException
* The user group was not found or does not exist
* @throws ServiceLinkedRoleNotFoundException
* The specified service linked role (SLR) was not found.
* @sample AmazonElastiCache.ModifyServerlessCache
* @see AWS API Documentation
*/
@Override
public ModifyServerlessCacheResult modifyServerlessCache(ModifyServerlessCacheRequest request) {
request = beforeClientExecution(request);
return executeModifyServerlessCache(request);
}
@SdkInternalApi
final ModifyServerlessCacheResult executeModifyServerlessCache(ModifyServerlessCacheRequest modifyServerlessCacheRequest) {
ExecutionContext executionContext = createExecutionContext(modifyServerlessCacheRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyServerlessCacheRequestMarshaller().marshall(super.beforeMarshalling(modifyServerlessCacheRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyServerlessCache");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ModifyServerlessCacheResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Changes user password(s) and/or access string.
*
*
* @param modifyUserRequest
* @return Result of the ModifyUser operation returned by the service.
* @throws UserNotFoundException
* The user does not exist or could not be found.
* @throws InvalidUserStateException
* The user is not in active state.
* @throws ServiceLinkedRoleNotFoundException
* The specified service linked role (SLR) was not found.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.ModifyUser
* @see AWS API
* Documentation
*/
@Override
public ModifyUserResult modifyUser(ModifyUserRequest request) {
request = beforeClientExecution(request);
return executeModifyUser(request);
}
@SdkInternalApi
final ModifyUserResult executeModifyUser(ModifyUserRequest modifyUserRequest) {
ExecutionContext executionContext = createExecutionContext(modifyUserRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyUserRequestMarshaller().marshall(super.beforeMarshalling(modifyUserRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyUser");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new ModifyUserResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Changes the list of users that belong to the user group.
*
*
* @param modifyUserGroupRequest
* @return Result of the ModifyUserGroup operation returned by the service.
* @throws UserGroupNotFoundException
* The user group was not found or does not exist
* @throws UserNotFoundException
* The user does not exist or could not be found.
* @throws DuplicateUserNameException
* A user with this username already exists.
* @throws ServiceLinkedRoleNotFoundException
* The specified service linked role (SLR) was not found.
* @throws DefaultUserRequiredException
* You must add default user to a user group.
* @throws InvalidUserGroupStateException
* The user group is not in an active state.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.ModifyUserGroup
* @see AWS
* API Documentation
*/
@Override
public ModifyUserGroupResult modifyUserGroup(ModifyUserGroupRequest request) {
request = beforeClientExecution(request);
return executeModifyUserGroup(request);
}
@SdkInternalApi
final ModifyUserGroupResult executeModifyUserGroup(ModifyUserGroupRequest modifyUserGroupRequest) {
ExecutionContext executionContext = createExecutionContext(modifyUserGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ModifyUserGroupRequestMarshaller().marshall(super.beforeMarshalling(modifyUserGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ModifyUserGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ModifyUserGroupResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Allows you to purchase a reserved cache node offering. Reserved nodes are not eligible for cancellation and are
* non-refundable. For more information, see Managing Costs with
* Reserved Nodes for Redis OSS or Managing Costs with
* Reserved Nodes for Memcached.
*
*
* @param purchaseReservedCacheNodesOfferingRequest
* Represents the input of a PurchaseReservedCacheNodesOffering operation.
* @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 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 50.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @throws InvalidParameterCombinationException
* Two or more incompatible parameters were specified.
* @sample AmazonElastiCache.PurchaseReservedCacheNodesOffering
* @see AWS API Documentation
*/
@Override
public ReservedCacheNode purchaseReservedCacheNodesOffering(PurchaseReservedCacheNodesOfferingRequest request) {
request = beforeClientExecution(request);
return executePurchaseReservedCacheNodesOffering(request);
}
@SdkInternalApi
final ReservedCacheNode executePurchaseReservedCacheNodesOffering(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "PurchaseReservedCacheNodesOffering");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new ReservedCacheNodeStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Redistribute slots to ensure uniform distribution across existing shards in the cluster.
*
*
* @param rebalanceSlotsInGlobalReplicationGroupRequest
* @return Result of the RebalanceSlotsInGlobalReplicationGroup operation returned by the service.
* @throws GlobalReplicationGroupNotFoundException
* The Global datastore does not exist
* @throws InvalidGlobalReplicationGroupStateException
* The Global datastore is not available or in primary-only state.
* @throws InvalidParameterValueException
* The value for a parameter is invalid.
* @sample AmazonElastiCache.RebalanceSlotsInGlobalReplicationGroup
* @see AWS API Documentation
*/
@Override
public GlobalReplicationGroup rebalanceSlotsInGlobalReplicationGroup(RebalanceSlotsInGlobalReplicationGroupRequest request) {
request = beforeClientExecution(request);
return executeRebalanceSlotsInGlobalReplicationGroup(request);
}
@SdkInternalApi
final GlobalReplicationGroup executeRebalanceSlotsInGlobalReplicationGroup(
RebalanceSlotsInGlobalReplicationGroupRequest rebalanceSlotsInGlobalReplicationGroupRequest) {
ExecutionContext executionContext = createExecutionContext(rebalanceSlotsInGlobalReplicationGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RebalanceSlotsInGlobalReplicationGroupRequestMarshaller().marshall(super
.beforeMarshalling(rebalanceSlotsInGlobalReplicationGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RebalanceSlotsInGlobalReplicationGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new GlobalReplicationGroupStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Reboots some, or all, of the cache nodes within a provisioned cluster. This operation applies any modified cache
* parameter groups to the cluster. The reboot operation takes place as soon as possible, and results in a momentary
* outage to the cluster. During the reboot, the 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 cluster event is created.
*
*
* Rebooting a cluster is currently supported on Memcached and Redis OSS (cluster mode disabled) clusters. Rebooting
* is not supported on Redis OSS (cluster mode enabled) clusters.
*
*
* If you make changes to parameters that require a Redis OSS (cluster mode enabled) cluster reboot for the changes
* to be applied, see Rebooting a Cluster
* for an alternate process.
*
*
* @param rebootCacheClusterRequest
* Represents the input of a RebootCacheCluster operation.
* @return Result of the RebootCacheCluster operation returned by the service.
* @throws InvalidCacheClusterStateException
* The requested cluster is not in the available state.
* @throws CacheClusterNotFoundException
* The requested cluster ID does not refer to an existing cluster.
* @sample AmazonElastiCache.RebootCacheCluster
* @see AWS
* API Documentation
*/
@Override
public CacheCluster rebootCacheCluster(RebootCacheClusterRequest request) {
request = beforeClientExecution(request);
return executeRebootCacheCluster(request);
}
@SdkInternalApi
final CacheCluster executeRebootCacheCluster(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RebootCacheCluster");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new CacheClusterStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Removes the tags identified by the TagKeys list from the named resource. A tag is a key-value pair
* where the key and value are case-sensitive. You can use tags to categorize and track all your ElastiCache
* resources, with the exception of global replication group. When you add or remove tags on replication groups,
* those actions will be replicated to all nodes in the replication group. For more information, see Resource-level permissions.
*
*
* @param removeTagsFromResourceRequest
* Represents the input of a RemoveTagsFromResource operation.
* @return Result of the RemoveTagsFromResource operation returned by the service.
* @throws CacheClusterNotFoundException
* The requested cluster ID does not refer to an existing cluster.
* @throws CacheParameterGroupNotFoundException
* The requested cache parameter group name does not refer to an existing cache parameter group.
* @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 InvalidReplicationGroupStateException
* The requested replication group is not in the available state.
* @throws ReplicationGroupNotFoundException
* The specified replication group does not exist.
* @throws ReservedCacheNodeNotFoundException
* The requested reserved cache node was not found.
* @throws SnapshotNotFoundException
* The requested snapshot name does not refer to an existing snapshot.
* @throws UserNotFoundException
* The user does not exist or could not be found.
* @throws UserGroupNotFoundException
* The user group was not found or does not exist
* @throws ServerlessCacheNotFoundException
* The serverless cache was not found or does not exist.
* @throws InvalidServerlessCacheStateException
* The account for these credentials is not currently active.
* @throws ServerlessCacheSnapshotNotFoundException
* This serverless cache snapshot could not be found or does not exist. Available for Redis OSS and
* Serverless Memcached only.
* @throws InvalidServerlessCacheSnapshotStateException
* The state of the serverless cache snapshot was not received. Available for Redis OSS and Serverless
* Memcached only.
* @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
* @see AWS API Documentation
*/
@Override
public RemoveTagsFromResourceResult removeTagsFromResource(RemoveTagsFromResourceRequest request) {
request = beforeClientExecution(request);
return executeRemoveTagsFromResource(request);
}
@SdkInternalApi
final RemoveTagsFromResourceResult executeRemoveTagsFromResource(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RemoveTagsFromResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new RemoveTagsFromResourceResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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 operation.
* @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 operation 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.
* @throws InvalidGlobalReplicationGroupStateException
* The Global datastore is not available or in primary-only state.
* @sample AmazonElastiCache.ResetCacheParameterGroup
* @see AWS API Documentation
*/
@Override
public ResetCacheParameterGroupResult resetCacheParameterGroup(ResetCacheParameterGroupRequest request) {
request = beforeClientExecution(request);
return executeResetCacheParameterGroup(request);
}
@SdkInternalApi
final ResetCacheParameterGroupResult executeResetCacheParameterGroup(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);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "ElastiCache");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ResetCacheParameterGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler