/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include #include namespace Aws { namespace ElastiCache { /** * 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.

*/ class AWS_ELASTICACHE_API ElastiCacheClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef ElastiCacheClientConfiguration ClientConfigurationType; typedef ElastiCacheEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ElastiCacheClient(const Aws::ElastiCache::ElastiCacheClientConfiguration& clientConfiguration = Aws::ElastiCache::ElastiCacheClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ElastiCacheClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::ElastiCache::ElastiCacheClientConfiguration& clientConfiguration = Aws::ElastiCache::ElastiCacheClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ ElastiCacheClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::ElastiCache::ElastiCacheClientConfiguration& clientConfiguration = Aws::ElastiCache::ElastiCacheClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ElastiCacheClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ElastiCacheClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ ElastiCacheClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~ElastiCacheClient(); /** * Converts any request object to a presigned URL with the GET method, using region for the signer and a timeout of 15 minutes. */ Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const; /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::AddTagsToResourceOutcome AddTagsToResource(const Model::AddTagsToResourceRequest& request) const; /** * A Callable wrapper for AddTagsToResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddTagsToResourceOutcomeCallable AddTagsToResourceCallable(const AddTagsToResourceRequestT& request) const { return SubmitCallable(&ElastiCacheClient::AddTagsToResource, request); } /** * An Async wrapper for AddTagsToResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddTagsToResourceAsync(const AddTagsToResourceRequestT& request, const AddTagsToResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::AddTagsToResource, request, handler, context); } /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::AuthorizeCacheSecurityGroupIngressOutcome AuthorizeCacheSecurityGroupIngress(const Model::AuthorizeCacheSecurityGroupIngressRequest& request) const; /** * A Callable wrapper for AuthorizeCacheSecurityGroupIngress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AuthorizeCacheSecurityGroupIngressOutcomeCallable AuthorizeCacheSecurityGroupIngressCallable(const AuthorizeCacheSecurityGroupIngressRequestT& request) const { return SubmitCallable(&ElastiCacheClient::AuthorizeCacheSecurityGroupIngress, request); } /** * An Async wrapper for AuthorizeCacheSecurityGroupIngress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AuthorizeCacheSecurityGroupIngressAsync(const AuthorizeCacheSecurityGroupIngressRequestT& request, const AuthorizeCacheSecurityGroupIngressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::AuthorizeCacheSecurityGroupIngress, request, handler, context); } /** *

Apply the service update. For more information on service updates and * applying them, see Applying * Service Updates.

See Also:

AWS * API Reference

*/ virtual Model::BatchApplyUpdateActionOutcome BatchApplyUpdateAction(const Model::BatchApplyUpdateActionRequest& request) const; /** * A Callable wrapper for BatchApplyUpdateAction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchApplyUpdateActionOutcomeCallable BatchApplyUpdateActionCallable(const BatchApplyUpdateActionRequestT& request) const { return SubmitCallable(&ElastiCacheClient::BatchApplyUpdateAction, request); } /** * An Async wrapper for BatchApplyUpdateAction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchApplyUpdateActionAsync(const BatchApplyUpdateActionRequestT& request, const BatchApplyUpdateActionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::BatchApplyUpdateAction, request, handler, context); } /** *

Stop the service update. For more information on service updates and stopping * them, see Stopping * Service Updates.

See Also:

AWS * API Reference

*/ virtual Model::BatchStopUpdateActionOutcome BatchStopUpdateAction(const Model::BatchStopUpdateActionRequest& request) const; /** * A Callable wrapper for BatchStopUpdateAction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchStopUpdateActionOutcomeCallable BatchStopUpdateActionCallable(const BatchStopUpdateActionRequestT& request) const { return SubmitCallable(&ElastiCacheClient::BatchStopUpdateAction, request); } /** * An Async wrapper for BatchStopUpdateAction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchStopUpdateActionAsync(const BatchStopUpdateActionRequestT& request, const BatchStopUpdateActionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::BatchStopUpdateAction, request, handler, context); } /** *

Complete the migration of data.

See Also:

AWS * API Reference

*/ virtual Model::CompleteMigrationOutcome CompleteMigration(const Model::CompleteMigrationRequest& request) const; /** * A Callable wrapper for CompleteMigration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CompleteMigrationOutcomeCallable CompleteMigrationCallable(const CompleteMigrationRequestT& request) const { return SubmitCallable(&ElastiCacheClient::CompleteMigration, request); } /** * An Async wrapper for CompleteMigration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CompleteMigrationAsync(const CompleteMigrationRequestT& request, const CompleteMigrationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::CompleteMigration, request, handler, context); } /** *

Makes a copy of an existing snapshot.

This operation is valid * for Redis 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.

See Also:

AWS * API Reference

*/ virtual Model::CopySnapshotOutcome CopySnapshot(const Model::CopySnapshotRequest& request) const; /** * A Callable wrapper for CopySnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CopySnapshotOutcomeCallable CopySnapshotCallable(const CopySnapshotRequestT& request) const { return SubmitCallable(&ElastiCacheClient::CopySnapshot, request); } /** * An Async wrapper for CopySnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CopySnapshotAsync(const CopySnapshotRequestT& request, const CopySnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::CopySnapshot, request, handler, context); } /** *

Creates a cluster. All nodes in the cluster run the same protocol-compliant * cache engine software, either Memcached or Redis.

This operation is not * supported for Redis (cluster mode enabled) clusters.

See Also:

* AWS * API Reference

*/ virtual Model::CreateCacheClusterOutcome CreateCacheCluster(const Model::CreateCacheClusterRequest& request) const; /** * A Callable wrapper for CreateCacheCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCacheClusterOutcomeCallable CreateCacheClusterCallable(const CreateCacheClusterRequestT& request) const { return SubmitCallable(&ElastiCacheClient::CreateCacheCluster, request); } /** * An Async wrapper for CreateCacheCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCacheClusterAsync(const CreateCacheClusterRequestT& request, const CreateCacheClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::CreateCacheCluster, request, handler, context); } /** *

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:

See Also:

AWS * API Reference

*/ virtual Model::CreateCacheParameterGroupOutcome CreateCacheParameterGroup(const Model::CreateCacheParameterGroupRequest& request) const; /** * A Callable wrapper for CreateCacheParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCacheParameterGroupOutcomeCallable CreateCacheParameterGroupCallable(const CreateCacheParameterGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::CreateCacheParameterGroup, request); } /** * An Async wrapper for CreateCacheParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCacheParameterGroupAsync(const CreateCacheParameterGroupRequestT& request, const CreateCacheParameterGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::CreateCacheParameterGroup, request, handler, context); } /** *

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.

See * Also:

AWS * API Reference

*/ virtual Model::CreateCacheSecurityGroupOutcome CreateCacheSecurityGroup(const Model::CreateCacheSecurityGroupRequest& request) const; /** * A Callable wrapper for CreateCacheSecurityGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCacheSecurityGroupOutcomeCallable CreateCacheSecurityGroupCallable(const CreateCacheSecurityGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::CreateCacheSecurityGroup, request); } /** * An Async wrapper for CreateCacheSecurityGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCacheSecurityGroupAsync(const CreateCacheSecurityGroupRequestT& request, const CreateCacheSecurityGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::CreateCacheSecurityGroup, request, handler, context); } /** *

Creates a new cache subnet group.

Use this parameter only when you are * creating a cluster in an Amazon Virtual Private Cloud (Amazon * VPC).

See Also:

AWS * API Reference

*/ virtual Model::CreateCacheSubnetGroupOutcome CreateCacheSubnetGroup(const Model::CreateCacheSubnetGroupRequest& request) const; /** * A Callable wrapper for CreateCacheSubnetGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCacheSubnetGroupOutcomeCallable CreateCacheSubnetGroupCallable(const CreateCacheSubnetGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::CreateCacheSubnetGroup, request); } /** * An Async wrapper for CreateCacheSubnetGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCacheSubnetGroupAsync(const CreateCacheSubnetGroupRequestT& request, const CreateCacheSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::CreateCacheSubnetGroup, request, handler, context); } /** *

Global Datastore for Redis offers fully managed, fast, reliable and secure * cross-region replication. Using Global Datastore for Redis, you can create * cross-region read replica clusters for ElastiCache for Redis 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.

See Also:

AWS * API Reference

*/ virtual Model::CreateGlobalReplicationGroupOutcome CreateGlobalReplicationGroup(const Model::CreateGlobalReplicationGroupRequest& request) const; /** * A Callable wrapper for CreateGlobalReplicationGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateGlobalReplicationGroupOutcomeCallable CreateGlobalReplicationGroupCallable(const CreateGlobalReplicationGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::CreateGlobalReplicationGroup, request); } /** * An Async wrapper for CreateGlobalReplicationGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateGlobalReplicationGroupAsync(const CreateGlobalReplicationGroupRequestT& request, const CreateGlobalReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::CreateGlobalReplicationGroup, request, handler, context); } /** *

Creates a Redis (cluster mode disabled) or a Redis (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 (cluster mode disabled) replication group is a * collection of clusters, where one of the clusters is a read/write primary and * the others are read-only replicas. Writes to the primary are asynchronously * propagated to the replicas.

A Redis 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 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 (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 avail yourself of ElastiCache for Redis' * scaling. For more information, see Scaling * ElastiCache for Redis Clusters in the ElastiCache User Guide.

*

This operation is valid for Redis only.

See * Also:

AWS * API Reference

*/ virtual Model::CreateReplicationGroupOutcome CreateReplicationGroup(const Model::CreateReplicationGroupRequest& request) const; /** * A Callable wrapper for CreateReplicationGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateReplicationGroupOutcomeCallable CreateReplicationGroupCallable(const CreateReplicationGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::CreateReplicationGroup, request); } /** * An Async wrapper for CreateReplicationGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateReplicationGroupAsync(const CreateReplicationGroupRequestT& request, const CreateReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::CreateReplicationGroup, request, handler, context); } /** *

Creates a copy of an entire cluster or replication group at a specific moment * in time.

This operation is valid for Redis only.

*

See Also:

AWS * API Reference

*/ virtual Model::CreateSnapshotOutcome CreateSnapshot(const Model::CreateSnapshotRequest& request) const; /** * A Callable wrapper for CreateSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSnapshotOutcomeCallable CreateSnapshotCallable(const CreateSnapshotRequestT& request) const { return SubmitCallable(&ElastiCacheClient::CreateSnapshot, request); } /** * An Async wrapper for CreateSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSnapshotAsync(const CreateSnapshotRequestT& request, const CreateSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::CreateSnapshot, request, handler, context); } /** *

For Redis engine version 6.0 onwards: Creates a Redis user. For more * information, see Using * Role Based Access Control (RBAC).

See Also:

AWS * API Reference

*/ virtual Model::CreateUserOutcome CreateUser(const Model::CreateUserRequest& request) const; /** * A Callable wrapper for CreateUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateUserOutcomeCallable CreateUserCallable(const CreateUserRequestT& request) const { return SubmitCallable(&ElastiCacheClient::CreateUser, request); } /** * An Async wrapper for CreateUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateUserAsync(const CreateUserRequestT& request, const CreateUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::CreateUser, request, handler, context); } /** *

For Redis engine version 6.0 onwards: Creates a Redis user group. For more * information, see Using * Role Based Access Control (RBAC)

See Also:

AWS * API Reference

*/ virtual Model::CreateUserGroupOutcome CreateUserGroup(const Model::CreateUserGroupRequest& request) const; /** * A Callable wrapper for CreateUserGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateUserGroupOutcomeCallable CreateUserGroupCallable(const CreateUserGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::CreateUserGroup, request); } /** * An Async wrapper for CreateUserGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateUserGroupAsync(const CreateUserGroupRequestT& request, const CreateUserGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::CreateUserGroup, request, handler, context); } /** *

Decreases the number of node groups in a Global datastore

See * Also:

AWS * API Reference

*/ virtual Model::DecreaseNodeGroupsInGlobalReplicationGroupOutcome DecreaseNodeGroupsInGlobalReplicationGroup(const Model::DecreaseNodeGroupsInGlobalReplicationGroupRequest& request) const; /** * A Callable wrapper for DecreaseNodeGroupsInGlobalReplicationGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DecreaseNodeGroupsInGlobalReplicationGroupOutcomeCallable DecreaseNodeGroupsInGlobalReplicationGroupCallable(const DecreaseNodeGroupsInGlobalReplicationGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DecreaseNodeGroupsInGlobalReplicationGroup, request); } /** * An Async wrapper for DecreaseNodeGroupsInGlobalReplicationGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DecreaseNodeGroupsInGlobalReplicationGroupAsync(const DecreaseNodeGroupsInGlobalReplicationGroupRequestT& request, const DecreaseNodeGroupsInGlobalReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DecreaseNodeGroupsInGlobalReplicationGroup, request, handler, context); } /** *

Dynamically decreases the number of replicas in a Redis (cluster mode * disabled) replication group or the number of replica nodes in one or more node * groups (shards) of a Redis (cluster mode enabled) replication group. This * operation is performed with no cluster down time.

See Also:

AWS * API Reference

*/ virtual Model::DecreaseReplicaCountOutcome DecreaseReplicaCount(const Model::DecreaseReplicaCountRequest& request) const; /** * A Callable wrapper for DecreaseReplicaCount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DecreaseReplicaCountOutcomeCallable DecreaseReplicaCountCallable(const DecreaseReplicaCountRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DecreaseReplicaCount, request); } /** * An Async wrapper for DecreaseReplicaCount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DecreaseReplicaCountAsync(const DecreaseReplicaCountRequestT& request, const DecreaseReplicaCountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DecreaseReplicaCount, request, handler, context); } /** *

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 * (cluster mode enabled) clusters

  • Redis (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 (cluster mode enabled) * replication group

  • A cluster that is not in the * available state

See Also:

AWS * API Reference

*/ virtual Model::DeleteCacheClusterOutcome DeleteCacheCluster(const Model::DeleteCacheClusterRequest& request) const; /** * A Callable wrapper for DeleteCacheCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCacheClusterOutcomeCallable DeleteCacheClusterCallable(const DeleteCacheClusterRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DeleteCacheCluster, request); } /** * An Async wrapper for DeleteCacheCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCacheClusterAsync(const DeleteCacheClusterRequestT& request, const DeleteCacheClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DeleteCacheCluster, request, handler, context); } /** *

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.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteCacheParameterGroupOutcome DeleteCacheParameterGroup(const Model::DeleteCacheParameterGroupRequest& request) const; /** * A Callable wrapper for DeleteCacheParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCacheParameterGroupOutcomeCallable DeleteCacheParameterGroupCallable(const DeleteCacheParameterGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DeleteCacheParameterGroup, request); } /** * An Async wrapper for DeleteCacheParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCacheParameterGroupAsync(const DeleteCacheParameterGroupRequestT& request, const DeleteCacheParameterGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DeleteCacheParameterGroup, request, handler, context); } /** *

Deletes a cache security group.

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

See * Also:

AWS * API Reference

*/ virtual Model::DeleteCacheSecurityGroupOutcome DeleteCacheSecurityGroup(const Model::DeleteCacheSecurityGroupRequest& request) const; /** * A Callable wrapper for DeleteCacheSecurityGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCacheSecurityGroupOutcomeCallable DeleteCacheSecurityGroupCallable(const DeleteCacheSecurityGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DeleteCacheSecurityGroup, request); } /** * An Async wrapper for DeleteCacheSecurityGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCacheSecurityGroupAsync(const DeleteCacheSecurityGroupRequestT& request, const DeleteCacheSecurityGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DeleteCacheSecurityGroup, request, handler, context); } /** *

Deletes a cache subnet group.

You cannot delete a default cache * subnet group or one that is associated with any clusters.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteCacheSubnetGroupOutcome DeleteCacheSubnetGroup(const Model::DeleteCacheSubnetGroupRequest& request) const; /** * A Callable wrapper for DeleteCacheSubnetGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCacheSubnetGroupOutcomeCallable DeleteCacheSubnetGroupCallable(const DeleteCacheSubnetGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DeleteCacheSubnetGroup, request); } /** * An Async wrapper for DeleteCacheSubnetGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCacheSubnetGroupAsync(const DeleteCacheSubnetGroupRequestT& request, const DeleteCacheSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DeleteCacheSubnetGroup, request, handler, context); } /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::DeleteGlobalReplicationGroupOutcome DeleteGlobalReplicationGroup(const Model::DeleteGlobalReplicationGroupRequest& request) const; /** * A Callable wrapper for DeleteGlobalReplicationGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteGlobalReplicationGroupOutcomeCallable DeleteGlobalReplicationGroupCallable(const DeleteGlobalReplicationGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DeleteGlobalReplicationGroup, request); } /** * An Async wrapper for DeleteGlobalReplicationGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteGlobalReplicationGroupAsync(const DeleteGlobalReplicationGroupRequestT& request, const DeleteGlobalReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DeleteGlobalReplicationGroup, request, handler, context); } /** *

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.

*

This operation is valid for Redis only.

See Also:

AWS * API Reference

*/ virtual Model::DeleteReplicationGroupOutcome DeleteReplicationGroup(const Model::DeleteReplicationGroupRequest& request) const; /** * A Callable wrapper for DeleteReplicationGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteReplicationGroupOutcomeCallable DeleteReplicationGroupCallable(const DeleteReplicationGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DeleteReplicationGroup, request); } /** * An Async wrapper for DeleteReplicationGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteReplicationGroupAsync(const DeleteReplicationGroupRequestT& request, const DeleteReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DeleteReplicationGroup, request, handler, context); } /** *

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 * only.

See Also:

AWS * API Reference

*/ virtual Model::DeleteSnapshotOutcome DeleteSnapshot(const Model::DeleteSnapshotRequest& request) const; /** * A Callable wrapper for DeleteSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteSnapshotOutcomeCallable DeleteSnapshotCallable(const DeleteSnapshotRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DeleteSnapshot, request); } /** * An Async wrapper for DeleteSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteSnapshotAsync(const DeleteSnapshotRequestT& request, const DeleteSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DeleteSnapshot, request, handler, context); } /** *

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

See Also:

AWS * API Reference

*/ virtual Model::DeleteUserOutcome DeleteUser(const Model::DeleteUserRequest& request) const; /** * A Callable wrapper for DeleteUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteUserOutcomeCallable DeleteUserCallable(const DeleteUserRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DeleteUser, request); } /** * An Async wrapper for DeleteUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteUserAsync(const DeleteUserRequestT& request, const DeleteUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DeleteUser, request, handler, context); } /** *

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

See Also:

AWS * API Reference

*/ virtual Model::DeleteUserGroupOutcome DeleteUserGroup(const Model::DeleteUserGroupRequest& request) const; /** * A Callable wrapper for DeleteUserGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteUserGroupOutcomeCallable DeleteUserGroupCallable(const DeleteUserGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DeleteUserGroup, request); } /** * An Async wrapper for DeleteUserGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteUserGroupAsync(const DeleteUserGroupRequestT& request, const DeleteUserGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DeleteUserGroup, request, handler, context); } /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::DescribeCacheClustersOutcome DescribeCacheClusters(const Model::DescribeCacheClustersRequest& request) const; /** * A Callable wrapper for DescribeCacheClusters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCacheClustersOutcomeCallable DescribeCacheClustersCallable(const DescribeCacheClustersRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DescribeCacheClusters, request); } /** * An Async wrapper for DescribeCacheClusters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCacheClustersAsync(const DescribeCacheClustersRequestT& request, const DescribeCacheClustersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DescribeCacheClusters, request, handler, context); } /** *

Returns a list of the available cache engines and their * versions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeCacheEngineVersionsOutcome DescribeCacheEngineVersions(const Model::DescribeCacheEngineVersionsRequest& request) const; /** * A Callable wrapper for DescribeCacheEngineVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCacheEngineVersionsOutcomeCallable DescribeCacheEngineVersionsCallable(const DescribeCacheEngineVersionsRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DescribeCacheEngineVersions, request); } /** * An Async wrapper for DescribeCacheEngineVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCacheEngineVersionsAsync(const DescribeCacheEngineVersionsRequestT& request, const DescribeCacheEngineVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DescribeCacheEngineVersions, request, handler, context); } /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::DescribeCacheParameterGroupsOutcome DescribeCacheParameterGroups(const Model::DescribeCacheParameterGroupsRequest& request) const; /** * A Callable wrapper for DescribeCacheParameterGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCacheParameterGroupsOutcomeCallable DescribeCacheParameterGroupsCallable(const DescribeCacheParameterGroupsRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DescribeCacheParameterGroups, request); } /** * An Async wrapper for DescribeCacheParameterGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCacheParameterGroupsAsync(const DescribeCacheParameterGroupsRequestT& request, const DescribeCacheParameterGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DescribeCacheParameterGroups, request, handler, context); } /** *

Returns the detailed parameter list for a particular cache parameter * group.

See Also:

AWS * API Reference

*/ virtual Model::DescribeCacheParametersOutcome DescribeCacheParameters(const Model::DescribeCacheParametersRequest& request) const; /** * A Callable wrapper for DescribeCacheParameters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCacheParametersOutcomeCallable DescribeCacheParametersCallable(const DescribeCacheParametersRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DescribeCacheParameters, request); } /** * An Async wrapper for DescribeCacheParameters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCacheParametersAsync(const DescribeCacheParametersRequestT& request, const DescribeCacheParametersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DescribeCacheParameters, request, handler, context); } /** *

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

See * Also:

AWS * API Reference

*/ virtual Model::DescribeCacheSecurityGroupsOutcome DescribeCacheSecurityGroups(const Model::DescribeCacheSecurityGroupsRequest& request) const; /** * A Callable wrapper for DescribeCacheSecurityGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCacheSecurityGroupsOutcomeCallable DescribeCacheSecurityGroupsCallable(const DescribeCacheSecurityGroupsRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DescribeCacheSecurityGroups, request); } /** * An Async wrapper for DescribeCacheSecurityGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCacheSecurityGroupsAsync(const DescribeCacheSecurityGroupsRequestT& request, const DescribeCacheSecurityGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DescribeCacheSecurityGroups, request, handler, context); } /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::DescribeCacheSubnetGroupsOutcome DescribeCacheSubnetGroups(const Model::DescribeCacheSubnetGroupsRequest& request) const; /** * A Callable wrapper for DescribeCacheSubnetGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCacheSubnetGroupsOutcomeCallable DescribeCacheSubnetGroupsCallable(const DescribeCacheSubnetGroupsRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DescribeCacheSubnetGroups, request); } /** * An Async wrapper for DescribeCacheSubnetGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCacheSubnetGroupsAsync(const DescribeCacheSubnetGroupsRequestT& request, const DescribeCacheSubnetGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DescribeCacheSubnetGroups, request, handler, context); } /** *

Returns the default engine and system parameter information for the specified * cache engine.

See Also:

AWS * API Reference

*/ virtual Model::DescribeEngineDefaultParametersOutcome DescribeEngineDefaultParameters(const Model::DescribeEngineDefaultParametersRequest& request) const; /** * A Callable wrapper for DescribeEngineDefaultParameters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEngineDefaultParametersOutcomeCallable DescribeEngineDefaultParametersCallable(const DescribeEngineDefaultParametersRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DescribeEngineDefaultParameters, request); } /** * An Async wrapper for DescribeEngineDefaultParameters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEngineDefaultParametersAsync(const DescribeEngineDefaultParametersRequestT& request, const DescribeEngineDefaultParametersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DescribeEngineDefaultParameters, request, handler, context); } /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::DescribeEventsOutcome DescribeEvents(const Model::DescribeEventsRequest& request) const; /** * A Callable wrapper for DescribeEvents that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEventsOutcomeCallable DescribeEventsCallable(const DescribeEventsRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DescribeEvents, request); } /** * An Async wrapper for DescribeEvents that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEventsAsync(const DescribeEventsRequestT& request, const DescribeEventsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DescribeEvents, request, handler, context); } /** *

Returns information about a particular global replication group. If no * identifier is specified, returns information about all Global datastores. *

See Also:

AWS * API Reference

*/ virtual Model::DescribeGlobalReplicationGroupsOutcome DescribeGlobalReplicationGroups(const Model::DescribeGlobalReplicationGroupsRequest& request) const; /** * A Callable wrapper for DescribeGlobalReplicationGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeGlobalReplicationGroupsOutcomeCallable DescribeGlobalReplicationGroupsCallable(const DescribeGlobalReplicationGroupsRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DescribeGlobalReplicationGroups, request); } /** * An Async wrapper for DescribeGlobalReplicationGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeGlobalReplicationGroupsAsync(const DescribeGlobalReplicationGroupsRequestT& request, const DescribeGlobalReplicationGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DescribeGlobalReplicationGroups, request, handler, context); } /** *

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

*

See Also:

AWS * API Reference

*/ virtual Model::DescribeReplicationGroupsOutcome DescribeReplicationGroups(const Model::DescribeReplicationGroupsRequest& request) const; /** * A Callable wrapper for DescribeReplicationGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeReplicationGroupsOutcomeCallable DescribeReplicationGroupsCallable(const DescribeReplicationGroupsRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DescribeReplicationGroups, request); } /** * An Async wrapper for DescribeReplicationGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeReplicationGroupsAsync(const DescribeReplicationGroupsRequestT& request, const DescribeReplicationGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DescribeReplicationGroups, request, handler, context); } /** *

Returns information about reserved cache nodes for this account, or about a * specified reserved cache node.

See Also:

AWS * API Reference

*/ virtual Model::DescribeReservedCacheNodesOutcome DescribeReservedCacheNodes(const Model::DescribeReservedCacheNodesRequest& request) const; /** * A Callable wrapper for DescribeReservedCacheNodes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeReservedCacheNodesOutcomeCallable DescribeReservedCacheNodesCallable(const DescribeReservedCacheNodesRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DescribeReservedCacheNodes, request); } /** * An Async wrapper for DescribeReservedCacheNodes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeReservedCacheNodesAsync(const DescribeReservedCacheNodesRequestT& request, const DescribeReservedCacheNodesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DescribeReservedCacheNodes, request, handler, context); } /** *

Lists available reserved cache node offerings.

See Also:

AWS * API Reference

*/ virtual Model::DescribeReservedCacheNodesOfferingsOutcome DescribeReservedCacheNodesOfferings(const Model::DescribeReservedCacheNodesOfferingsRequest& request) const; /** * A Callable wrapper for DescribeReservedCacheNodesOfferings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeReservedCacheNodesOfferingsOutcomeCallable DescribeReservedCacheNodesOfferingsCallable(const DescribeReservedCacheNodesOfferingsRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DescribeReservedCacheNodesOfferings, request); } /** * An Async wrapper for DescribeReservedCacheNodesOfferings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeReservedCacheNodesOfferingsAsync(const DescribeReservedCacheNodesOfferingsRequestT& request, const DescribeReservedCacheNodesOfferingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DescribeReservedCacheNodesOfferings, request, handler, context); } /** *

Returns details of the service updates

See Also:

AWS * API Reference

*/ virtual Model::DescribeServiceUpdatesOutcome DescribeServiceUpdates(const Model::DescribeServiceUpdatesRequest& request) const; /** * A Callable wrapper for DescribeServiceUpdates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeServiceUpdatesOutcomeCallable DescribeServiceUpdatesCallable(const DescribeServiceUpdatesRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DescribeServiceUpdates, request); } /** * An Async wrapper for DescribeServiceUpdates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeServiceUpdatesAsync(const DescribeServiceUpdatesRequestT& request, const DescribeServiceUpdatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DescribeServiceUpdates, request, handler, context); } /** *

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

*

See Also:

AWS * API Reference

*/ virtual Model::DescribeSnapshotsOutcome DescribeSnapshots(const Model::DescribeSnapshotsRequest& request) const; /** * A Callable wrapper for DescribeSnapshots that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSnapshotsOutcomeCallable DescribeSnapshotsCallable(const DescribeSnapshotsRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DescribeSnapshots, request); } /** * An Async wrapper for DescribeSnapshots that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSnapshotsAsync(const DescribeSnapshotsRequestT& request, const DescribeSnapshotsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DescribeSnapshots, request, handler, context); } /** *

Returns details of the update actions

See Also:

AWS * API Reference

*/ virtual Model::DescribeUpdateActionsOutcome DescribeUpdateActions(const Model::DescribeUpdateActionsRequest& request) const; /** * A Callable wrapper for DescribeUpdateActions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeUpdateActionsOutcomeCallable DescribeUpdateActionsCallable(const DescribeUpdateActionsRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DescribeUpdateActions, request); } /** * An Async wrapper for DescribeUpdateActions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeUpdateActionsAsync(const DescribeUpdateActionsRequestT& request, const DescribeUpdateActionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DescribeUpdateActions, request, handler, context); } /** *

Returns a list of user groups.

See Also:

AWS * API Reference

*/ virtual Model::DescribeUserGroupsOutcome DescribeUserGroups(const Model::DescribeUserGroupsRequest& request) const; /** * A Callable wrapper for DescribeUserGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeUserGroupsOutcomeCallable DescribeUserGroupsCallable(const DescribeUserGroupsRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DescribeUserGroups, request); } /** * An Async wrapper for DescribeUserGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeUserGroupsAsync(const DescribeUserGroupsRequestT& request, const DescribeUserGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DescribeUserGroups, request, handler, context); } /** *

Returns a list of users.

See Also:

AWS * API Reference

*/ virtual Model::DescribeUsersOutcome DescribeUsers(const Model::DescribeUsersRequest& request) const; /** * A Callable wrapper for DescribeUsers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeUsersOutcomeCallable DescribeUsersCallable(const DescribeUsersRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DescribeUsers, request); } /** * An Async wrapper for DescribeUsers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeUsersAsync(const DescribeUsersRequestT& request, const DescribeUsersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DescribeUsers, request, handler, context); } /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateGlobalReplicationGroupOutcome DisassociateGlobalReplicationGroup(const Model::DisassociateGlobalReplicationGroupRequest& request) const; /** * A Callable wrapper for DisassociateGlobalReplicationGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateGlobalReplicationGroupOutcomeCallable DisassociateGlobalReplicationGroupCallable(const DisassociateGlobalReplicationGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::DisassociateGlobalReplicationGroup, request); } /** * An Async wrapper for DisassociateGlobalReplicationGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateGlobalReplicationGroupAsync(const DisassociateGlobalReplicationGroupRequestT& request, const DisassociateGlobalReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::DisassociateGlobalReplicationGroup, request, handler, context); } /** *

Used to failover the primary region to a secondary region. The secondary * region will become primary, and all other clusters will become * secondary.

See Also:

AWS * API Reference

*/ virtual Model::FailoverGlobalReplicationGroupOutcome FailoverGlobalReplicationGroup(const Model::FailoverGlobalReplicationGroupRequest& request) const; /** * A Callable wrapper for FailoverGlobalReplicationGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::FailoverGlobalReplicationGroupOutcomeCallable FailoverGlobalReplicationGroupCallable(const FailoverGlobalReplicationGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::FailoverGlobalReplicationGroup, request); } /** * An Async wrapper for FailoverGlobalReplicationGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void FailoverGlobalReplicationGroupAsync(const FailoverGlobalReplicationGroupRequestT& request, const FailoverGlobalReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::FailoverGlobalReplicationGroup, request, handler, context); } /** *

Increase the number of node groups in the Global datastore

See * Also:

AWS * API Reference

*/ virtual Model::IncreaseNodeGroupsInGlobalReplicationGroupOutcome IncreaseNodeGroupsInGlobalReplicationGroup(const Model::IncreaseNodeGroupsInGlobalReplicationGroupRequest& request) const; /** * A Callable wrapper for IncreaseNodeGroupsInGlobalReplicationGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::IncreaseNodeGroupsInGlobalReplicationGroupOutcomeCallable IncreaseNodeGroupsInGlobalReplicationGroupCallable(const IncreaseNodeGroupsInGlobalReplicationGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::IncreaseNodeGroupsInGlobalReplicationGroup, request); } /** * An Async wrapper for IncreaseNodeGroupsInGlobalReplicationGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void IncreaseNodeGroupsInGlobalReplicationGroupAsync(const IncreaseNodeGroupsInGlobalReplicationGroupRequestT& request, const IncreaseNodeGroupsInGlobalReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::IncreaseNodeGroupsInGlobalReplicationGroup, request, handler, context); } /** *

Dynamically increases the number of replicas in a Redis (cluster mode * disabled) replication group or the number of replica nodes in one or more node * groups (shards) of a Redis (cluster mode enabled) replication group. This * operation is performed with no cluster down time.

See Also:

AWS * API Reference

*/ virtual Model::IncreaseReplicaCountOutcome IncreaseReplicaCount(const Model::IncreaseReplicaCountRequest& request) const; /** * A Callable wrapper for IncreaseReplicaCount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::IncreaseReplicaCountOutcomeCallable IncreaseReplicaCountCallable(const IncreaseReplicaCountRequestT& request) const { return SubmitCallable(&ElastiCacheClient::IncreaseReplicaCount, request); } /** * An Async wrapper for IncreaseReplicaCount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void IncreaseReplicaCountAsync(const IncreaseReplicaCountRequestT& request, const IncreaseReplicaCountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::IncreaseReplicaCount, request, handler, context); } /** *

Lists all available node types that you can scale your Redis 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.

See Also:

AWS * API Reference

*/ virtual Model::ListAllowedNodeTypeModificationsOutcome ListAllowedNodeTypeModifications(const Model::ListAllowedNodeTypeModificationsRequest& request) const; /** * A Callable wrapper for ListAllowedNodeTypeModifications that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAllowedNodeTypeModificationsOutcomeCallable ListAllowedNodeTypeModificationsCallable(const ListAllowedNodeTypeModificationsRequestT& request) const { return SubmitCallable(&ElastiCacheClient::ListAllowedNodeTypeModifications, request); } /** * An Async wrapper for ListAllowedNodeTypeModifications that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAllowedNodeTypeModificationsAsync(const ListAllowedNodeTypeModificationsRequestT& request, const ListAllowedNodeTypeModificationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::ListAllowedNodeTypeModifications, request, handler, context); } /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&ElastiCacheClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::ListTagsForResource, request, handler, context); } /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::ModifyCacheClusterOutcome ModifyCacheCluster(const Model::ModifyCacheClusterRequest& request) const; /** * A Callable wrapper for ModifyCacheCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyCacheClusterOutcomeCallable ModifyCacheClusterCallable(const ModifyCacheClusterRequestT& request) const { return SubmitCallable(&ElastiCacheClient::ModifyCacheCluster, request); } /** * An Async wrapper for ModifyCacheCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyCacheClusterAsync(const ModifyCacheClusterRequestT& request, const ModifyCacheClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::ModifyCacheCluster, request, handler, context); } /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::ModifyCacheParameterGroupOutcome ModifyCacheParameterGroup(const Model::ModifyCacheParameterGroupRequest& request) const; /** * A Callable wrapper for ModifyCacheParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyCacheParameterGroupOutcomeCallable ModifyCacheParameterGroupCallable(const ModifyCacheParameterGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::ModifyCacheParameterGroup, request); } /** * An Async wrapper for ModifyCacheParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyCacheParameterGroupAsync(const ModifyCacheParameterGroupRequestT& request, const ModifyCacheParameterGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::ModifyCacheParameterGroup, request, handler, context); } /** *

Modifies an existing cache subnet group.

See Also:

AWS * API Reference

*/ virtual Model::ModifyCacheSubnetGroupOutcome ModifyCacheSubnetGroup(const Model::ModifyCacheSubnetGroupRequest& request) const; /** * A Callable wrapper for ModifyCacheSubnetGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyCacheSubnetGroupOutcomeCallable ModifyCacheSubnetGroupCallable(const ModifyCacheSubnetGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::ModifyCacheSubnetGroup, request); } /** * An Async wrapper for ModifyCacheSubnetGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyCacheSubnetGroupAsync(const ModifyCacheSubnetGroupRequestT& request, const ModifyCacheSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::ModifyCacheSubnetGroup, request, handler, context); } /** *

Modifies the settings for a Global datastore.

See Also:

AWS * API Reference

*/ virtual Model::ModifyGlobalReplicationGroupOutcome ModifyGlobalReplicationGroup(const Model::ModifyGlobalReplicationGroupRequest& request) const; /** * A Callable wrapper for ModifyGlobalReplicationGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyGlobalReplicationGroupOutcomeCallable ModifyGlobalReplicationGroupCallable(const ModifyGlobalReplicationGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::ModifyGlobalReplicationGroup, request); } /** * An Async wrapper for ModifyGlobalReplicationGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyGlobalReplicationGroupAsync(const ModifyGlobalReplicationGroupRequestT& request, const ModifyGlobalReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::ModifyGlobalReplicationGroup, request, handler, context); } /** *

Modifies the settings for a replication group.

This operation is * valid for Redis only.

See Also:

AWS * API Reference

*/ virtual Model::ModifyReplicationGroupOutcome ModifyReplicationGroup(const Model::ModifyReplicationGroupRequest& request) const; /** * A Callable wrapper for ModifyReplicationGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyReplicationGroupOutcomeCallable ModifyReplicationGroupCallable(const ModifyReplicationGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::ModifyReplicationGroup, request); } /** * An Async wrapper for ModifyReplicationGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyReplicationGroupAsync(const ModifyReplicationGroupRequestT& request, const ModifyReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::ModifyReplicationGroup, request, handler, context); } /** *

Modifies a replication group's shards (node groups) by allowing you to add * shards, remove shards, or rebalance the keyspaces among existing * shards.

See Also:

AWS * API Reference

*/ virtual Model::ModifyReplicationGroupShardConfigurationOutcome ModifyReplicationGroupShardConfiguration(const Model::ModifyReplicationGroupShardConfigurationRequest& request) const; /** * A Callable wrapper for ModifyReplicationGroupShardConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyReplicationGroupShardConfigurationOutcomeCallable ModifyReplicationGroupShardConfigurationCallable(const ModifyReplicationGroupShardConfigurationRequestT& request) const { return SubmitCallable(&ElastiCacheClient::ModifyReplicationGroupShardConfiguration, request); } /** * An Async wrapper for ModifyReplicationGroupShardConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyReplicationGroupShardConfigurationAsync(const ModifyReplicationGroupShardConfigurationRequestT& request, const ModifyReplicationGroupShardConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::ModifyReplicationGroupShardConfiguration, request, handler, context); } /** *

Changes user password(s) and/or access string.

See Also:

AWS * API Reference

*/ virtual Model::ModifyUserOutcome ModifyUser(const Model::ModifyUserRequest& request) const; /** * A Callable wrapper for ModifyUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyUserOutcomeCallable ModifyUserCallable(const ModifyUserRequestT& request) const { return SubmitCallable(&ElastiCacheClient::ModifyUser, request); } /** * An Async wrapper for ModifyUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyUserAsync(const ModifyUserRequestT& request, const ModifyUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::ModifyUser, request, handler, context); } /** *

Changes the list of users that belong to the user group.

See * Also:

AWS * API Reference

*/ virtual Model::ModifyUserGroupOutcome ModifyUserGroup(const Model::ModifyUserGroupRequest& request) const; /** * A Callable wrapper for ModifyUserGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyUserGroupOutcomeCallable ModifyUserGroupCallable(const ModifyUserGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::ModifyUserGroup, request); } /** * An Async wrapper for ModifyUserGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyUserGroupAsync(const ModifyUserGroupRequestT& request, const ModifyUserGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::ModifyUserGroup, request, handler, context); } /** *

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 or Managing * Costs with Reserved Nodes for Memcached.

See Also:

AWS * API Reference

*/ virtual Model::PurchaseReservedCacheNodesOfferingOutcome PurchaseReservedCacheNodesOffering(const Model::PurchaseReservedCacheNodesOfferingRequest& request) const; /** * A Callable wrapper for PurchaseReservedCacheNodesOffering that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PurchaseReservedCacheNodesOfferingOutcomeCallable PurchaseReservedCacheNodesOfferingCallable(const PurchaseReservedCacheNodesOfferingRequestT& request) const { return SubmitCallable(&ElastiCacheClient::PurchaseReservedCacheNodesOffering, request); } /** * An Async wrapper for PurchaseReservedCacheNodesOffering that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PurchaseReservedCacheNodesOfferingAsync(const PurchaseReservedCacheNodesOfferingRequestT& request, const PurchaseReservedCacheNodesOfferingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::PurchaseReservedCacheNodesOffering, request, handler, context); } /** *

Redistribute slots to ensure uniform distribution across existing shards in * the cluster.

See Also:

AWS * API Reference

*/ virtual Model::RebalanceSlotsInGlobalReplicationGroupOutcome RebalanceSlotsInGlobalReplicationGroup(const Model::RebalanceSlotsInGlobalReplicationGroupRequest& request) const; /** * A Callable wrapper for RebalanceSlotsInGlobalReplicationGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RebalanceSlotsInGlobalReplicationGroupOutcomeCallable RebalanceSlotsInGlobalReplicationGroupCallable(const RebalanceSlotsInGlobalReplicationGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::RebalanceSlotsInGlobalReplicationGroup, request); } /** * An Async wrapper for RebalanceSlotsInGlobalReplicationGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RebalanceSlotsInGlobalReplicationGroupAsync(const RebalanceSlotsInGlobalReplicationGroupRequestT& request, const RebalanceSlotsInGlobalReplicationGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::RebalanceSlotsInGlobalReplicationGroup, request, handler, context); } /** *

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 (cluster mode disabled) clusters. Rebooting is not supported on Redis * (cluster mode enabled) clusters.

If you make changes to parameters that * require a Redis (cluster mode enabled) cluster reboot for the changes to be * applied, see Rebooting * a Cluster for an alternate process.

See Also:

AWS * API Reference

*/ virtual Model::RebootCacheClusterOutcome RebootCacheCluster(const Model::RebootCacheClusterRequest& request) const; /** * A Callable wrapper for RebootCacheCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RebootCacheClusterOutcomeCallable RebootCacheClusterCallable(const RebootCacheClusterRequestT& request) const { return SubmitCallable(&ElastiCacheClient::RebootCacheCluster, request); } /** * An Async wrapper for RebootCacheCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RebootCacheClusterAsync(const RebootCacheClusterRequestT& request, const RebootCacheClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::RebootCacheCluster, request, handler, context); } /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::RemoveTagsFromResourceOutcome RemoveTagsFromResource(const Model::RemoveTagsFromResourceRequest& request) const; /** * A Callable wrapper for RemoveTagsFromResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RemoveTagsFromResourceOutcomeCallable RemoveTagsFromResourceCallable(const RemoveTagsFromResourceRequestT& request) const { return SubmitCallable(&ElastiCacheClient::RemoveTagsFromResource, request); } /** * An Async wrapper for RemoveTagsFromResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RemoveTagsFromResourceAsync(const RemoveTagsFromResourceRequestT& request, const RemoveTagsFromResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::RemoveTagsFromResource, request, handler, context); } /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::ResetCacheParameterGroupOutcome ResetCacheParameterGroup(const Model::ResetCacheParameterGroupRequest& request) const; /** * A Callable wrapper for ResetCacheParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ResetCacheParameterGroupOutcomeCallable ResetCacheParameterGroupCallable(const ResetCacheParameterGroupRequestT& request) const { return SubmitCallable(&ElastiCacheClient::ResetCacheParameterGroup, request); } /** * An Async wrapper for ResetCacheParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ResetCacheParameterGroupAsync(const ResetCacheParameterGroupRequestT& request, const ResetCacheParameterGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::ResetCacheParameterGroup, request, handler, context); } /** *

Revokes ingress from a cache security group. Use this operation to disallow * access from an Amazon EC2 security group that had been previously * authorized.

See Also:

AWS * API Reference

*/ virtual Model::RevokeCacheSecurityGroupIngressOutcome RevokeCacheSecurityGroupIngress(const Model::RevokeCacheSecurityGroupIngressRequest& request) const; /** * A Callable wrapper for RevokeCacheSecurityGroupIngress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RevokeCacheSecurityGroupIngressOutcomeCallable RevokeCacheSecurityGroupIngressCallable(const RevokeCacheSecurityGroupIngressRequestT& request) const { return SubmitCallable(&ElastiCacheClient::RevokeCacheSecurityGroupIngress, request); } /** * An Async wrapper for RevokeCacheSecurityGroupIngress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RevokeCacheSecurityGroupIngressAsync(const RevokeCacheSecurityGroupIngressRequestT& request, const RevokeCacheSecurityGroupIngressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::RevokeCacheSecurityGroupIngress, request, handler, context); } /** *

Start the migration of data.

See Also:

AWS * API Reference

*/ virtual Model::StartMigrationOutcome StartMigration(const Model::StartMigrationRequest& request) const; /** * A Callable wrapper for StartMigration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartMigrationOutcomeCallable StartMigrationCallable(const StartMigrationRequestT& request) const { return SubmitCallable(&ElastiCacheClient::StartMigration, request); } /** * An Async wrapper for StartMigration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartMigrationAsync(const StartMigrationRequestT& request, const StartMigrationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::StartMigration, request, handler, context); } /** *

Represents the input of a TestFailover operation which test * automatic failover on a specified node group (called shard in the console) in a * replication group (called cluster in the console).

This API is designed * for testing the behavior of your application in case of ElastiCache failover. It * is not designed to be an operational tool for initiating a failover to overcome * a problem you may have with the cluster. Moreover, in certain conditions such as * large-scale operational events, Amazon may block this API.

Note the following

  • A customer can use * this operation to test automatic failover on up to 5 shards (called node groups * in the ElastiCache API and Amazon CLI) in any rolling 24-hour period.

    • *

  • If calling this operation on shards in different clusters (called * replication groups in the API and CLI), the calls can be made concurrently.

    *

  • If calling this operation multiple times on different * shards in the same Redis (cluster mode enabled) replication group, the first * node replacement must complete before a subsequent call can be made.

    • *

  • To determine whether the node replacement is complete you can check * Events using the Amazon ElastiCache console, the Amazon CLI, or the ElastiCache * API. Look for the following automatic failover related events, listed here in * order of occurrance:

    1. Replication group message: Test * Failover API called for node group <node-group-id>

    2. *

      Cache cluster message: Failover from primary node * <primary-node-id> to replica node <node-id> completed

      *

    3. Replication group message: Failover from primary node * <primary-node-id> to replica node <node-id> completed

      *

    4. Cache cluster message: Recovering cache nodes * <node-id>

    5. Cache cluster message: Finished * recovery for cache nodes <node-id>

    For more * information see:

Also see, Testing * Multi-AZ in the ElastiCache User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::TestFailoverOutcome TestFailover(const Model::TestFailoverRequest& request) const; /** * A Callable wrapper for TestFailover that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TestFailoverOutcomeCallable TestFailoverCallable(const TestFailoverRequestT& request) const { return SubmitCallable(&ElastiCacheClient::TestFailover, request); } /** * An Async wrapper for TestFailover that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TestFailoverAsync(const TestFailoverRequestT& request, const TestFailoverResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ElastiCacheClient::TestFailover, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const ElastiCacheClientConfiguration& clientConfiguration); ElastiCacheClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace ElastiCache } // namespace Aws