/**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0.
*/
#pragma once
#include <aws/dax/DAX_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/dax/DAXServiceClientModel.h>
namespace Aws
{
namespace DAX
{
/**
* <p>DAX is a managed caching service engineered for Amazon DynamoDB. DAX
* dramatically speeds up database reads by caching frequently-accessed data from
* DynamoDB, so applications can access that data with sub-millisecond latency. You
* can create a DAX cluster easily, using the AWS Management Console. With a few
* simple modifications to your code, your application can begin taking advantage
* of the DAX cluster and realize significant improvements in read performance.</p>
*/
class AWS_DAX_API DAXClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<DAXClient>
{
public:
typedef Aws::Client::AWSJsonClient BASECLASS;
static const char* SERVICE_NAME;
static const char* ALLOCATION_TAG;
typedef DAXClientConfiguration ClientConfigurationType;
typedef DAXEndpointProvider 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.
*/
DAXClient(const Aws::DAX::DAXClientConfiguration& clientConfiguration = Aws::DAX::DAXClientConfiguration(),
std::shared_ptr<DAXEndpointProviderBase> endpointProvider = Aws::MakeShared<DAXEndpointProvider>(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.
*/
DAXClient(const Aws::Auth::AWSCredentials& credentials,
std::shared_ptr<DAXEndpointProviderBase> endpointProvider = Aws::MakeShared<DAXEndpointProvider>(ALLOCATION_TAG),
const Aws::DAX::DAXClientConfiguration& clientConfiguration = Aws::DAX::DAXClientConfiguration());
/**
* 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
*/
DAXClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
std::shared_ptr<DAXEndpointProviderBase> endpointProvider = Aws::MakeShared<DAXEndpointProvider>(ALLOCATION_TAG),
const Aws::DAX::DAXClientConfiguration& clientConfiguration = Aws::DAX::DAXClientConfiguration());
/* 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.
*/
DAXClient(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.
*/
DAXClient(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
*/
DAXClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
const Aws::Client::ClientConfiguration& clientConfiguration);
/* End of legacy constructors due deprecation */
virtual ~DAXClient();
/**
* <p>Creates a DAX cluster. All nodes in the cluster run the same DAX caching
* software.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/CreateCluster">AWS
* API Reference</a></p>
*/
virtual Model::CreateClusterOutcome CreateCluster(const Model::CreateClusterRequest& request) const;
/**
* A Callable wrapper for CreateCluster that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template<typename CreateClusterRequestT = Model::CreateClusterRequest>
Model::CreateClusterOutcomeCallable CreateClusterCallable(const CreateClusterRequestT& request) const
{
return SubmitCallable(&DAXClient::CreateCluster, request);
}
/**
* An Async wrapper for CreateCluster that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename CreateClusterRequestT = Model::CreateClusterRequest>
void CreateClusterAsync(const CreateClusterRequestT& request, const CreateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::CreateCluster, request, handler, context);
}
/**
* <p>Creates a new parameter group. A parameter group is a collection of
* parameters that you apply to all of the nodes in a DAX cluster.</p><p><h3>See
* Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/CreateParameterGroup">AWS
* API Reference</a></p>
*/
virtual Model::CreateParameterGroupOutcome CreateParameterGroup(const Model::CreateParameterGroupRequest& request) const;
/**
* A Callable wrapper for CreateParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template<typename CreateParameterGroupRequestT = Model::CreateParameterGroupRequest>
Model::CreateParameterGroupOutcomeCallable CreateParameterGroupCallable(const CreateParameterGroupRequestT& request) const
{
return SubmitCallable(&DAXClient::CreateParameterGroup, request);
}
/**
* An Async wrapper for CreateParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename CreateParameterGroupRequestT = Model::CreateParameterGroupRequest>
void CreateParameterGroupAsync(const CreateParameterGroupRequestT& request, const CreateParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::CreateParameterGroup, request, handler, context);
}
/**
* <p>Creates a new subnet group.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/CreateSubnetGroup">AWS
* API Reference</a></p>
*/
virtual Model::CreateSubnetGroupOutcome CreateSubnetGroup(const Model::CreateSubnetGroupRequest& request) const;
/**
* A Callable wrapper for CreateSubnetGroup that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template<typename CreateSubnetGroupRequestT = Model::CreateSubnetGroupRequest>
Model::CreateSubnetGroupOutcomeCallable CreateSubnetGroupCallable(const CreateSubnetGroupRequestT& request) const
{
return SubmitCallable(&DAXClient::CreateSubnetGroup, request);
}
/**
* An Async wrapper for CreateSubnetGroup that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename CreateSubnetGroupRequestT = Model::CreateSubnetGroupRequest>
void CreateSubnetGroupAsync(const CreateSubnetGroupRequestT& request, const CreateSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::CreateSubnetGroup, request, handler, context);
}
/**
* <p>Removes one or more nodes from a DAX cluster.</p> <p>You cannot use
* <code>DecreaseReplicationFactor</code> to remove the last node in a DAX cluster.
* If you need to do this, use <code>DeleteCluster</code> instead.</p>
* <p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DecreaseReplicationFactor">AWS
* API Reference</a></p>
*/
virtual Model::DecreaseReplicationFactorOutcome DecreaseReplicationFactor(const Model::DecreaseReplicationFactorRequest& request) const;
/**
* A Callable wrapper for DecreaseReplicationFactor that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template<typename DecreaseReplicationFactorRequestT = Model::DecreaseReplicationFactorRequest>
Model::DecreaseReplicationFactorOutcomeCallable DecreaseReplicationFactorCallable(const DecreaseReplicationFactorRequestT& request) const
{
return SubmitCallable(&DAXClient::DecreaseReplicationFactor, request);
}
/**
* An Async wrapper for DecreaseReplicationFactor that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename DecreaseReplicationFactorRequestT = Model::DecreaseReplicationFactorRequest>
void DecreaseReplicationFactorAsync(const DecreaseReplicationFactorRequestT& request, const DecreaseReplicationFactorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::DecreaseReplicationFactor, request, handler, context);
}
/**
* <p>Deletes a previously provisioned DAX cluster. <i>DeleteCluster</i> deletes
* all associated nodes, node endpoints and the DAX cluster itself. When you
* receive a successful response from this action, DAX immediately begins deleting
* the cluster; you cannot cancel or revert this action.</p><p><h3>See Also:</h3>
* <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DeleteCluster">AWS
* API Reference</a></p>
*/
virtual Model::DeleteClusterOutcome DeleteCluster(const Model::DeleteClusterRequest& request) const;
/**
* A Callable wrapper for DeleteCluster that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template<typename DeleteClusterRequestT = Model::DeleteClusterRequest>
Model::DeleteClusterOutcomeCallable DeleteClusterCallable(const DeleteClusterRequestT& request) const
{
return SubmitCallable(&DAXClient::DeleteCluster, request);
}
/**
* An Async wrapper for DeleteCluster that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename DeleteClusterRequestT = Model::DeleteClusterRequest>
void DeleteClusterAsync(const DeleteClusterRequestT& request, const DeleteClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::DeleteCluster, request, handler, context);
}
/**
* <p>Deletes the specified parameter group. You cannot delete a parameter group if
* it is associated with any DAX clusters.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DeleteParameterGroup">AWS
* API Reference</a></p>
*/
virtual Model::DeleteParameterGroupOutcome DeleteParameterGroup(const Model::DeleteParameterGroupRequest& request) const;
/**
* A Callable wrapper for DeleteParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template<typename DeleteParameterGroupRequestT = Model::DeleteParameterGroupRequest>
Model::DeleteParameterGroupOutcomeCallable DeleteParameterGroupCallable(const DeleteParameterGroupRequestT& request) const
{
return SubmitCallable(&DAXClient::DeleteParameterGroup, request);
}
/**
* An Async wrapper for DeleteParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename DeleteParameterGroupRequestT = Model::DeleteParameterGroupRequest>
void DeleteParameterGroupAsync(const DeleteParameterGroupRequestT& request, const DeleteParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::DeleteParameterGroup, request, handler, context);
}
/**
* <p>Deletes a subnet group.</p> <p>You cannot delete a subnet group if it
* is associated with any DAX clusters.</p> <p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DeleteSubnetGroup">AWS
* API Reference</a></p>
*/
virtual Model::DeleteSubnetGroupOutcome DeleteSubnetGroup(const Model::DeleteSubnetGroupRequest& request) const;
/**
* A Callable wrapper for DeleteSubnetGroup that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template<typename DeleteSubnetGroupRequestT = Model::DeleteSubnetGroupRequest>
Model::DeleteSubnetGroupOutcomeCallable DeleteSubnetGroupCallable(const DeleteSubnetGroupRequestT& request) const
{
return SubmitCallable(&DAXClient::DeleteSubnetGroup, request);
}
/**
* An Async wrapper for DeleteSubnetGroup that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename DeleteSubnetGroupRequestT = Model::DeleteSubnetGroupRequest>
void DeleteSubnetGroupAsync(const DeleteSubnetGroupRequestT& request, const DeleteSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::DeleteSubnetGroup, request, handler, context);
}
/**
* <p>Returns information about all provisioned DAX clusters if no cluster
* identifier is specified, or about a specific DAX cluster if a cluster identifier
* is supplied.</p> <p>If the cluster is in the CREATING state, only cluster level
* information will be displayed until all of the nodes are successfully
* provisioned.</p> <p>If the cluster is in the DELETING state, only cluster level
* information will be displayed.</p> <p>If nodes are currently being added to the
* DAX cluster, node endpoint information and creation time for the additional
* nodes will not be displayed until they are completely provisioned. When the DAX
* cluster state is <i>available</i>, the cluster is ready for use.</p> <p>If nodes
* are currently being removed from the DAX cluster, no endpoint information for
* the removed nodes is displayed.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeClusters">AWS
* API Reference</a></p>
*/
virtual Model::DescribeClustersOutcome DescribeClusters(const Model::DescribeClustersRequest& request) const;
/**
* A Callable wrapper for DescribeClusters that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template<typename DescribeClustersRequestT = Model::DescribeClustersRequest>
Model::DescribeClustersOutcomeCallable DescribeClustersCallable(const DescribeClustersRequestT& request) const
{
return SubmitCallable(&DAXClient::DescribeClusters, request);
}
/**
* An Async wrapper for DescribeClusters that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename DescribeClustersRequestT = Model::DescribeClustersRequest>
void DescribeClustersAsync(const DescribeClustersRequestT& request, const DescribeClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::DescribeClusters, request, handler, context);
}
/**
* <p>Returns the default system parameter information for the DAX caching
* software.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeDefaultParameters">AWS
* API Reference</a></p>
*/
virtual Model::DescribeDefaultParametersOutcome DescribeDefaultParameters(const Model::DescribeDefaultParametersRequest& request) const;
/**
* A Callable wrapper for DescribeDefaultParameters that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template<typename DescribeDefaultParametersRequestT = Model::DescribeDefaultParametersRequest>
Model::DescribeDefaultParametersOutcomeCallable DescribeDefaultParametersCallable(const DescribeDefaultParametersRequestT& request) const
{
return SubmitCallable(&DAXClient::DescribeDefaultParameters, request);
}
/**
* An Async wrapper for DescribeDefaultParameters that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename DescribeDefaultParametersRequestT = Model::DescribeDefaultParametersRequest>
void DescribeDefaultParametersAsync(const DescribeDefaultParametersRequestT& request, const DescribeDefaultParametersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::DescribeDefaultParameters, request, handler, context);
}
/**
* <p>Returns events related to DAX clusters and parameter groups. You can obtain
* events specific to a particular DAX cluster or parameter group by providing the
* name as a parameter.</p> <p>By default, only the events occurring within the
* last 24 hours are returned; however, you can retrieve up to 14 days' worth of
* events if necessary.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeEvents">AWS
* API Reference</a></p>
*/
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<typename DescribeEventsRequestT = Model::DescribeEventsRequest>
Model::DescribeEventsOutcomeCallable DescribeEventsCallable(const DescribeEventsRequestT& request) const
{
return SubmitCallable(&DAXClient::DescribeEvents, request);
}
/**
* An Async wrapper for DescribeEvents that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename DescribeEventsRequestT = Model::DescribeEventsRequest>
void DescribeEventsAsync(const DescribeEventsRequestT& request, const DescribeEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::DescribeEvents, request, handler, context);
}
/**
* <p>Returns a list of parameter group descriptions. If a parameter group name is
* specified, the list will contain only the descriptions for that
* group.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeParameterGroups">AWS
* API Reference</a></p>
*/
virtual Model::DescribeParameterGroupsOutcome DescribeParameterGroups(const Model::DescribeParameterGroupsRequest& request) const;
/**
* A Callable wrapper for DescribeParameterGroups that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template<typename DescribeParameterGroupsRequestT = Model::DescribeParameterGroupsRequest>
Model::DescribeParameterGroupsOutcomeCallable DescribeParameterGroupsCallable(const DescribeParameterGroupsRequestT& request) const
{
return SubmitCallable(&DAXClient::DescribeParameterGroups, request);
}
/**
* An Async wrapper for DescribeParameterGroups that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename DescribeParameterGroupsRequestT = Model::DescribeParameterGroupsRequest>
void DescribeParameterGroupsAsync(const DescribeParameterGroupsRequestT& request, const DescribeParameterGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::DescribeParameterGroups, request, handler, context);
}
/**
* <p>Returns the detailed parameter list for a particular parameter
* group.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeParameters">AWS
* API Reference</a></p>
*/
virtual Model::DescribeParametersOutcome DescribeParameters(const Model::DescribeParametersRequest& request) const;
/**
* A Callable wrapper for DescribeParameters that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template<typename DescribeParametersRequestT = Model::DescribeParametersRequest>
Model::DescribeParametersOutcomeCallable DescribeParametersCallable(const DescribeParametersRequestT& request) const
{
return SubmitCallable(&DAXClient::DescribeParameters, request);
}
/**
* An Async wrapper for DescribeParameters that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename DescribeParametersRequestT = Model::DescribeParametersRequest>
void DescribeParametersAsync(const DescribeParametersRequestT& request, const DescribeParametersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::DescribeParameters, request, handler, context);
}
/**
* <p>Returns a list of subnet group descriptions. If a subnet group name is
* specified, the list will contain only the description of that
* group.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/DescribeSubnetGroups">AWS
* API Reference</a></p>
*/
virtual Model::DescribeSubnetGroupsOutcome DescribeSubnetGroups(const Model::DescribeSubnetGroupsRequest& request) const;
/**
* A Callable wrapper for DescribeSubnetGroups that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template<typename DescribeSubnetGroupsRequestT = Model::DescribeSubnetGroupsRequest>
Model::DescribeSubnetGroupsOutcomeCallable DescribeSubnetGroupsCallable(const DescribeSubnetGroupsRequestT& request) const
{
return SubmitCallable(&DAXClient::DescribeSubnetGroups, request);
}
/**
* An Async wrapper for DescribeSubnetGroups that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename DescribeSubnetGroupsRequestT = Model::DescribeSubnetGroupsRequest>
void DescribeSubnetGroupsAsync(const DescribeSubnetGroupsRequestT& request, const DescribeSubnetGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::DescribeSubnetGroups, request, handler, context);
}
/**
* <p>Adds one or more nodes to a DAX cluster.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/IncreaseReplicationFactor">AWS
* API Reference</a></p>
*/
virtual Model::IncreaseReplicationFactorOutcome IncreaseReplicationFactor(const Model::IncreaseReplicationFactorRequest& request) const;
/**
* A Callable wrapper for IncreaseReplicationFactor that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template<typename IncreaseReplicationFactorRequestT = Model::IncreaseReplicationFactorRequest>
Model::IncreaseReplicationFactorOutcomeCallable IncreaseReplicationFactorCallable(const IncreaseReplicationFactorRequestT& request) const
{
return SubmitCallable(&DAXClient::IncreaseReplicationFactor, request);
}
/**
* An Async wrapper for IncreaseReplicationFactor that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename IncreaseReplicationFactorRequestT = Model::IncreaseReplicationFactorRequest>
void IncreaseReplicationFactorAsync(const IncreaseReplicationFactorRequestT& request, const IncreaseReplicationFactorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::IncreaseReplicationFactor, request, handler, context);
}
/**
* <p>List all of the tags for a DAX cluster. You can call <code>ListTags</code> up
* to 10 times per second, per account.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/ListTags">AWS API
* Reference</a></p>
*/
virtual Model::ListTagsOutcome ListTags(const Model::ListTagsRequest& request) const;
/**
* A Callable wrapper for ListTags that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template<typename ListTagsRequestT = Model::ListTagsRequest>
Model::ListTagsOutcomeCallable ListTagsCallable(const ListTagsRequestT& request) const
{
return SubmitCallable(&DAXClient::ListTags, request);
}
/**
* An Async wrapper for ListTags that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename ListTagsRequestT = Model::ListTagsRequest>
void ListTagsAsync(const ListTagsRequestT& request, const ListTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::ListTags, request, handler, context);
}
/**
* <p>Reboots a single node of a DAX cluster. The reboot action takes place as soon
* as possible. During the reboot, the node status is set to REBOOTING.</p>
* <p> <code>RebootNode</code> restarts the DAX engine process and does not remove
* the contents of the cache. </p> <p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/RebootNode">AWS API
* Reference</a></p>
*/
virtual Model::RebootNodeOutcome RebootNode(const Model::RebootNodeRequest& request) const;
/**
* A Callable wrapper for RebootNode that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template<typename RebootNodeRequestT = Model::RebootNodeRequest>
Model::RebootNodeOutcomeCallable RebootNodeCallable(const RebootNodeRequestT& request) const
{
return SubmitCallable(&DAXClient::RebootNode, request);
}
/**
* An Async wrapper for RebootNode that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename RebootNodeRequestT = Model::RebootNodeRequest>
void RebootNodeAsync(const RebootNodeRequestT& request, const RebootNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::RebootNode, request, handler, context);
}
/**
* <p>Associates a set of tags with a DAX resource. You can call
* <code>TagResource</code> up to 5 times per second, per account. </p><p><h3>See
* Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/TagResource">AWS API
* Reference</a></p>
*/
virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
/**
* A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template<typename TagResourceRequestT = Model::TagResourceRequest>
Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const
{
return SubmitCallable(&DAXClient::TagResource, request);
}
/**
* An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename TagResourceRequestT = Model::TagResourceRequest>
void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::TagResource, request, handler, context);
}
/**
* <p>Removes the association of tags from a DAX resource. You can call
* <code>UntagResource</code> up to 5 times per second, per account. </p><p><h3>See
* Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/UntagResource">AWS
* API Reference</a></p>
*/
virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
/**
* A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template<typename UntagResourceRequestT = Model::UntagResourceRequest>
Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const
{
return SubmitCallable(&DAXClient::UntagResource, request);
}
/**
* An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename UntagResourceRequestT = Model::UntagResourceRequest>
void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::UntagResource, request, handler, context);
}
/**
* <p>Modifies the settings for a DAX cluster. You can use this action to change
* one or more cluster configuration parameters by specifying the parameters and
* the new values.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/UpdateCluster">AWS
* API Reference</a></p>
*/
virtual Model::UpdateClusterOutcome UpdateCluster(const Model::UpdateClusterRequest& request) const;
/**
* A Callable wrapper for UpdateCluster that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template<typename UpdateClusterRequestT = Model::UpdateClusterRequest>
Model::UpdateClusterOutcomeCallable UpdateClusterCallable(const UpdateClusterRequestT& request) const
{
return SubmitCallable(&DAXClient::UpdateCluster, request);
}
/**
* An Async wrapper for UpdateCluster that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename UpdateClusterRequestT = Model::UpdateClusterRequest>
void UpdateClusterAsync(const UpdateClusterRequestT& request, const UpdateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::UpdateCluster, request, handler, context);
}
/**
* <p>Modifies the parameters of a parameter group. You can modify up to 20
* parameters in a single request by submitting a list parameter name and value
* pairs.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/UpdateParameterGroup">AWS
* API Reference</a></p>
*/
virtual Model::UpdateParameterGroupOutcome UpdateParameterGroup(const Model::UpdateParameterGroupRequest& request) const;
/**
* A Callable wrapper for UpdateParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template<typename UpdateParameterGroupRequestT = Model::UpdateParameterGroupRequest>
Model::UpdateParameterGroupOutcomeCallable UpdateParameterGroupCallable(const UpdateParameterGroupRequestT& request) const
{
return SubmitCallable(&DAXClient::UpdateParameterGroup, request);
}
/**
* An Async wrapper for UpdateParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename UpdateParameterGroupRequestT = Model::UpdateParameterGroupRequest>
void UpdateParameterGroupAsync(const UpdateParameterGroupRequestT& request, const UpdateParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::UpdateParameterGroup, request, handler, context);
}
/**
* <p>Modifies an existing subnet group.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/UpdateSubnetGroup">AWS
* API Reference</a></p>
*/
virtual Model::UpdateSubnetGroupOutcome UpdateSubnetGroup(const Model::UpdateSubnetGroupRequest& request) const;
/**
* A Callable wrapper for UpdateSubnetGroup that returns a future to the operation so that it can be executed in parallel to other requests.
*/
template<typename UpdateSubnetGroupRequestT = Model::UpdateSubnetGroupRequest>
Model::UpdateSubnetGroupOutcomeCallable UpdateSubnetGroupCallable(const UpdateSubnetGroupRequestT& request) const
{
return SubmitCallable(&DAXClient::UpdateSubnetGroup, request);
}
/**
* An Async wrapper for UpdateSubnetGroup that queues the request into a thread executor and triggers associated callback when operation has finished.
*/
template<typename UpdateSubnetGroupRequestT = Model::UpdateSubnetGroupRequest>
void UpdateSubnetGroupAsync(const UpdateSubnetGroupRequestT& request, const UpdateSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
{
return SubmitAsync(&DAXClient::UpdateSubnetGroup, request, handler, context);
}
void OverrideEndpoint(const Aws::String& endpoint);
std::shared_ptr<DAXEndpointProviderBase>& accessEndpointProvider();
private:
friend class Aws::Client::ClientWithAsyncTemplateMethods<DAXClient>;
void init(const DAXClientConfiguration& clientConfiguration);
DAXClientConfiguration m_clientConfiguration;
std::shared_ptr<Aws::Utils::Threading::Executor> m_executor;
std::shared_ptr<DAXEndpointProviderBase> m_endpointProvider;
};
} // namespace DAX
} // namespace Aws