/*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
/*
* Do not modify this file. This file is generated from the memorydb-2021-01-01.normal.json service model.
*/
using System;
using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Net;
using Amazon.MemoryDB.Model;
using Amazon.MemoryDB.Model.Internal.MarshallTransformations;
using Amazon.MemoryDB.Internal;
using Amazon.Runtime;
using Amazon.Runtime.Internal;
using Amazon.Runtime.Internal.Auth;
using Amazon.Runtime.Internal.Transform;
namespace Amazon.MemoryDB
{
///
/// Implementation for accessing MemoryDB
///
/// MemoryDB for Redis is a fully managed, Redis-compatible, in-memory database that delivers
/// ultra-fast performance and Multi-AZ durability for modern applications built using
/// microservices architectures. MemoryDB stores the entire database in-memory, enabling
/// low latency and high throughput data access. It is compatible with Redis, a popular
/// open source data store, enabling you to leverage Redis’ flexible and friendly data
/// structures, APIs, and commands.
///
public partial class AmazonMemoryDBClient : AmazonServiceClient, IAmazonMemoryDB
{
private static IServiceMetadata serviceMetadata = new AmazonMemoryDBMetadata();
#region Constructors
///
/// Constructs AmazonMemoryDBClient with the credentials loaded from the application's
/// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance.
///
/// Example App.config with credentials set.
///
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="AWSProfileName" value="AWS Default"/>
/// </appSettings>
/// </configuration>
///
///
///
public AmazonMemoryDBClient()
: base(FallbackCredentialsFactory.GetCredentials(), new AmazonMemoryDBConfig()) { }
///
/// Constructs AmazonMemoryDBClient with the credentials loaded from the application's
/// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance.
///
/// Example App.config with credentials set.
///
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="AWSProfileName" value="AWS Default"/>
/// </appSettings>
/// </configuration>
///
///
///
/// The region to connect.
public AmazonMemoryDBClient(RegionEndpoint region)
: base(FallbackCredentialsFactory.GetCredentials(), new AmazonMemoryDBConfig{RegionEndpoint = region}) { }
///
/// Constructs AmazonMemoryDBClient with the credentials loaded from the application's
/// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance.
///
/// Example App.config with credentials set.
///
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="AWSProfileName" value="AWS Default"/>
/// </appSettings>
/// </configuration>
///
///
///
/// The AmazonMemoryDBClient Configuration Object
public AmazonMemoryDBClient(AmazonMemoryDBConfig config)
: base(FallbackCredentialsFactory.GetCredentials(config), config){}
///
/// Constructs AmazonMemoryDBClient with AWS Credentials
///
/// AWS Credentials
public AmazonMemoryDBClient(AWSCredentials credentials)
: this(credentials, new AmazonMemoryDBConfig())
{
}
///
/// Constructs AmazonMemoryDBClient with AWS Credentials
///
/// AWS Credentials
/// The region to connect.
public AmazonMemoryDBClient(AWSCredentials credentials, RegionEndpoint region)
: this(credentials, new AmazonMemoryDBConfig{RegionEndpoint = region})
{
}
///
/// Constructs AmazonMemoryDBClient with AWS Credentials and an
/// AmazonMemoryDBClient Configuration object.
///
/// AWS Credentials
/// The AmazonMemoryDBClient Configuration Object
public AmazonMemoryDBClient(AWSCredentials credentials, AmazonMemoryDBConfig clientConfig)
: base(credentials, clientConfig)
{
}
///
/// Constructs AmazonMemoryDBClient with AWS Access Key ID and AWS Secret Key
///
/// AWS Access Key ID
/// AWS Secret Access Key
public AmazonMemoryDBClient(string awsAccessKeyId, string awsSecretAccessKey)
: this(awsAccessKeyId, awsSecretAccessKey, new AmazonMemoryDBConfig())
{
}
///
/// Constructs AmazonMemoryDBClient with AWS Access Key ID and AWS Secret Key
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// The region to connect.
public AmazonMemoryDBClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region)
: this(awsAccessKeyId, awsSecretAccessKey, new AmazonMemoryDBConfig() {RegionEndpoint=region})
{
}
///
/// Constructs AmazonMemoryDBClient with AWS Access Key ID, AWS Secret Key and an
/// AmazonMemoryDBClient Configuration object.
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// The AmazonMemoryDBClient Configuration Object
public AmazonMemoryDBClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonMemoryDBConfig clientConfig)
: base(awsAccessKeyId, awsSecretAccessKey, clientConfig)
{
}
///
/// Constructs AmazonMemoryDBClient with AWS Access Key ID and AWS Secret Key
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// AWS Session Token
public AmazonMemoryDBClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken)
: this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonMemoryDBConfig())
{
}
///
/// Constructs AmazonMemoryDBClient with AWS Access Key ID and AWS Secret Key
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// AWS Session Token
/// The region to connect.
public AmazonMemoryDBClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region)
: this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonMemoryDBConfig{RegionEndpoint = region})
{
}
///
/// Constructs AmazonMemoryDBClient with AWS Access Key ID, AWS Secret Key and an
/// AmazonMemoryDBClient Configuration object.
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// AWS Session Token
/// The AmazonMemoryDBClient Configuration Object
public AmazonMemoryDBClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonMemoryDBConfig clientConfig)
: base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig)
{
}
#endregion
#if AWS_ASYNC_ENUMERABLES_API
private IMemoryDBPaginatorFactory _paginators;
///
/// Paginators for the service
///
public IMemoryDBPaginatorFactory Paginators
{
get
{
if (this._paginators == null)
{
this._paginators = new MemoryDBPaginatorFactory(this);
}
return this._paginators;
}
}
#endif
#region Overrides
///
/// Creates the signer for the service.
///
protected override AbstractAWSSigner CreateSigner()
{
return new AWS4Signer();
}
///
/// Customizes the runtime pipeline.
///
/// Runtime pipeline for the current client.
protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline)
{
pipeline.RemoveHandler();
pipeline.AddHandlerAfter(new AmazonMemoryDBEndpointResolver());
}
///
/// Capture metadata for the service.
///
protected override IServiceMetadata ServiceMetadata
{
get
{
return serviceMetadata;
}
}
#endregion
#region Dispose
///
/// Disposes the service client.
///
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
}
#endregion
#region BatchUpdateCluster
internal virtual BatchUpdateClusterResponse BatchUpdateCluster(BatchUpdateClusterRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = BatchUpdateClusterRequestMarshaller.Instance;
options.ResponseUnmarshaller = BatchUpdateClusterResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Apply the service update to a list of clusters supplied. For more information on service
/// updates and applying them, see Applying
/// the service updates.
///
/// Container for the necessary parameters to execute the BatchUpdateCluster service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the BatchUpdateCluster service method, as returned by MemoryDB.
///
///
///
///
///
///
/// REST API Reference for BatchUpdateCluster Operation
public virtual Task BatchUpdateClusterAsync(BatchUpdateClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = BatchUpdateClusterRequestMarshaller.Instance;
options.ResponseUnmarshaller = BatchUpdateClusterResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region CopySnapshot
internal virtual CopySnapshotResponse CopySnapshot(CopySnapshotRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CopySnapshotRequestMarshaller.Instance;
options.ResponseUnmarshaller = CopySnapshotResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Makes a copy of an existing snapshot.
///
/// Container for the necessary parameters to execute the CopySnapshot service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the CopySnapshot service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for CopySnapshot Operation
public virtual Task CopySnapshotAsync(CopySnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CopySnapshotRequestMarshaller.Instance;
options.ResponseUnmarshaller = CopySnapshotResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region CreateACL
internal virtual CreateACLResponse CreateACL(CreateACLRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateACLRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateACLResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Creates an Access Control List. For more information, see Authenticating
/// users with Access Contol Lists (ACLs).
///
/// Container for the necessary parameters to execute the CreateACL service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the CreateACL service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for CreateACL Operation
public virtual Task CreateACLAsync(CreateACLRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateACLRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateACLResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region CreateCluster
internal virtual CreateClusterResponse CreateCluster(CreateClusterRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateClusterRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateClusterResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Creates a cluster. All nodes in the cluster run the same protocol-compliant engine
/// software.
///
/// Container for the necessary parameters to execute the CreateCluster service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the CreateCluster service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for CreateCluster Operation
public virtual Task CreateClusterAsync(CreateClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateClusterRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateClusterResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region CreateParameterGroup
internal virtual CreateParameterGroupResponse CreateParameterGroup(CreateParameterGroupRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateParameterGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateParameterGroupResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Creates a new MemoryDB parameter group. A parameter group is a collection of parameters
/// and their values that are applied to all of the nodes in any cluster. For more information,
/// see Configuring
/// engine parameters using parameter groups.
///
/// Container for the necessary parameters to execute the CreateParameterGroup service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the CreateParameterGroup service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for CreateParameterGroup Operation
public virtual Task CreateParameterGroupAsync(CreateParameterGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateParameterGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateParameterGroupResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region CreateSnapshot
internal virtual CreateSnapshotResponse CreateSnapshot(CreateSnapshotRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateSnapshotRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateSnapshotResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Creates a copy of an entire cluster at a specific moment in time.
///
/// Container for the necessary parameters to execute the CreateSnapshot service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the CreateSnapshot service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for CreateSnapshot Operation
public virtual Task CreateSnapshotAsync(CreateSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateSnapshotRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateSnapshotResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region CreateSubnetGroup
internal virtual CreateSubnetGroupResponse CreateSubnetGroup(CreateSubnetGroupRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateSubnetGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateSubnetGroupResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Creates a subnet group. A subnet group is a collection of subnets (typically private)
/// that you can designate for your clusters running in an Amazon Virtual Private Cloud
/// (VPC) environment. When you create a cluster in an Amazon VPC, you must specify a
/// subnet group. MemoryDB uses that subnet group to choose a subnet and IP addresses
/// within that subnet to associate with your nodes. For more information, see Subnets
/// and subnet groups.
///
/// Container for the necessary parameters to execute the CreateSubnetGroup service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the CreateSubnetGroup service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for CreateSubnetGroup Operation
public virtual Task CreateSubnetGroupAsync(CreateSubnetGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateSubnetGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateSubnetGroupResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region CreateUser
internal virtual CreateUserResponse CreateUser(CreateUserRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateUserRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateUserResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Creates a MemoryDB user. For more information, see Authenticating
/// users with Access Contol Lists (ACLs).
///
/// Container for the necessary parameters to execute the CreateUser service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the CreateUser service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for CreateUser Operation
public virtual Task CreateUserAsync(CreateUserRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateUserRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateUserResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteACL
internal virtual DeleteACLResponse DeleteACL(DeleteACLRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteACLRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteACLResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Deletes an Access Control List. The ACL must first be disassociated from the cluster
/// before it can be deleted. For more information, see Authenticating
/// users with Access Contol Lists (ACLs).
///
/// Container for the necessary parameters to execute the DeleteACL service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteACL service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
/// REST API Reference for DeleteACL Operation
public virtual Task DeleteACLAsync(DeleteACLRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteACLRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteACLResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteCluster
internal virtual DeleteClusterResponse DeleteCluster(DeleteClusterRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteClusterRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteClusterResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Deletes a cluster. It also deletes all associated nodes and node endpoints
///
/// Container for the necessary parameters to execute the DeleteCluster service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteCluster service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for DeleteCluster Operation
public virtual Task DeleteClusterAsync(DeleteClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteClusterRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteClusterResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteParameterGroup
internal virtual DeleteParameterGroupResponse DeleteParameterGroup(DeleteParameterGroupRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteParameterGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteParameterGroupResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Deletes the specified parameter group. You cannot delete a parameter group if it is
/// associated with any clusters. You cannot delete the default parameter groups in your
/// account.
///
/// Container for the necessary parameters to execute the DeleteParameterGroup service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteParameterGroup service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for DeleteParameterGroup Operation
public virtual Task DeleteParameterGroupAsync(DeleteParameterGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteParameterGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteParameterGroupResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteSnapshot
internal virtual DeleteSnapshotResponse DeleteSnapshot(DeleteSnapshotRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteSnapshotRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteSnapshotResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Deletes an existing snapshot. When you receive a successful response from this operation,
/// MemoryDB immediately begins deleting the snapshot; you cannot cancel or revert this
/// operation.
///
/// Container for the necessary parameters to execute the DeleteSnapshot service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteSnapshot service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for DeleteSnapshot Operation
public virtual Task DeleteSnapshotAsync(DeleteSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteSnapshotRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteSnapshotResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteSubnetGroup
internal virtual DeleteSubnetGroupResponse DeleteSubnetGroup(DeleteSubnetGroupRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteSubnetGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteSubnetGroupResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Deletes a subnet group. You cannot delete a default subnet group or one that is associated
/// with any clusters.
///
/// Container for the necessary parameters to execute the DeleteSubnetGroup service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteSubnetGroup service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
/// REST API Reference for DeleteSubnetGroup Operation
public virtual Task DeleteSubnetGroupAsync(DeleteSubnetGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteSubnetGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteSubnetGroupResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DeleteUser
internal virtual DeleteUserResponse DeleteUser(DeleteUserRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteUserRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteUserResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Deletes a user. The user will be removed from all ACLs and in turn removed from all
/// clusters.
///
/// Container for the necessary parameters to execute the DeleteUser service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DeleteUser service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
/// REST API Reference for DeleteUser Operation
public virtual Task DeleteUserAsync(DeleteUserRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteUserRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteUserResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DescribeACLs
internal virtual DescribeACLsResponse DescribeACLs(DescribeACLsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeACLsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeACLsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns a list of ACLs
///
/// Container for the necessary parameters to execute the DescribeACLs service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeACLs service method, as returned by MemoryDB.
///
///
///
///
///
///
/// REST API Reference for DescribeACLs Operation
public virtual Task DescribeACLsAsync(DescribeACLsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeACLsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeACLsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DescribeClusters
internal virtual DescribeClustersResponse DescribeClusters(DescribeClustersRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeClustersRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeClustersResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns information about all provisioned clusters if no cluster identifier is specified,
/// or about a specific cluster if a cluster name is supplied.
///
/// Container for the necessary parameters to execute the DescribeClusters service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeClusters service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for DescribeClusters Operation
public virtual Task DescribeClustersAsync(DescribeClustersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeClustersRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeClustersResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DescribeEngineVersions
internal virtual DescribeEngineVersionsResponse DescribeEngineVersions(DescribeEngineVersionsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeEngineVersionsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeEngineVersionsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns a list of the available Redis engine versions.
///
/// Container for the necessary parameters to execute the DescribeEngineVersions service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeEngineVersions service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
/// REST API Reference for DescribeEngineVersions Operation
public virtual Task DescribeEngineVersionsAsync(DescribeEngineVersionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeEngineVersionsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeEngineVersionsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DescribeEvents
internal virtual DescribeEventsResponse DescribeEvents(DescribeEventsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeEventsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeEventsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns events related to clusters, security groups, and parameter groups. You can
/// obtain events specific to a particular cluster, security group, or 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.
///
/// Container for the necessary parameters to execute the DescribeEvents service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeEvents service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
/// REST API Reference for DescribeEvents Operation
public virtual Task DescribeEventsAsync(DescribeEventsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeEventsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeEventsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DescribeParameterGroups
internal virtual DescribeParameterGroupsResponse DescribeParameterGroups(DescribeParameterGroupsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeParameterGroupsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeParameterGroupsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns a list of parameter group descriptions. If a parameter group name is specified,
/// the list contains only the descriptions for that group.
///
/// Container for the necessary parameters to execute the DescribeParameterGroups service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeParameterGroups service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for DescribeParameterGroups Operation
public virtual Task DescribeParameterGroupsAsync(DescribeParameterGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeParameterGroupsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeParameterGroupsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DescribeParameters
internal virtual DescribeParametersResponse DescribeParameters(DescribeParametersRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeParametersRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeParametersResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns the detailed parameter list for a particular parameter group.
///
/// Container for the necessary parameters to execute the DescribeParameters service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeParameters service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for DescribeParameters Operation
public virtual Task DescribeParametersAsync(DescribeParametersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeParametersRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeParametersResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DescribeReservedNodes
internal virtual DescribeReservedNodesResponse DescribeReservedNodes(DescribeReservedNodesRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeReservedNodesRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeReservedNodesResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns information about reserved nodes for this account, or about a specified reserved
/// node.
///
/// Container for the necessary parameters to execute the DescribeReservedNodes service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeReservedNodes service method, as returned by MemoryDB.
///
///
///
///
///
///
///
/// The requested node does not exist.
///
///
///
///
/// REST API Reference for DescribeReservedNodes Operation
public virtual Task DescribeReservedNodesAsync(DescribeReservedNodesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeReservedNodesRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeReservedNodesResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DescribeReservedNodesOfferings
internal virtual DescribeReservedNodesOfferingsResponse DescribeReservedNodesOfferings(DescribeReservedNodesOfferingsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeReservedNodesOfferingsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeReservedNodesOfferingsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Lists available reserved node offerings.
///
/// Container for the necessary parameters to execute the DescribeReservedNodesOfferings service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeReservedNodesOfferings service method, as returned by MemoryDB.
///
///
///
///
///
///
///
/// The requested node offering does not exist.
///
///
///
///
/// REST API Reference for DescribeReservedNodesOfferings Operation
public virtual Task DescribeReservedNodesOfferingsAsync(DescribeReservedNodesOfferingsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeReservedNodesOfferingsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeReservedNodesOfferingsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DescribeServiceUpdates
internal virtual DescribeServiceUpdatesResponse DescribeServiceUpdates(DescribeServiceUpdatesRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeServiceUpdatesRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeServiceUpdatesResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns details of the service updates
///
/// Container for the necessary parameters to execute the DescribeServiceUpdates service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeServiceUpdates service method, as returned by MemoryDB.
///
///
///
///
///
///
/// REST API Reference for DescribeServiceUpdates Operation
public virtual Task DescribeServiceUpdatesAsync(DescribeServiceUpdatesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeServiceUpdatesRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeServiceUpdatesResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DescribeSnapshots
internal virtual DescribeSnapshotsResponse DescribeSnapshots(DescribeSnapshotsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeSnapshotsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeSnapshotsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns information about cluster snapshots. By default, DescribeSnapshots lists all
/// of your snapshots; it can optionally describe a single snapshot, or just the snapshots
/// associated with a particular cluster.
///
/// Container for the necessary parameters to execute the DescribeSnapshots service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeSnapshots service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for DescribeSnapshots Operation
public virtual Task DescribeSnapshotsAsync(DescribeSnapshotsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeSnapshotsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeSnapshotsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DescribeSubnetGroups
internal virtual DescribeSubnetGroupsResponse DescribeSubnetGroups(DescribeSubnetGroupsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeSubnetGroupsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeSubnetGroupsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns a list of subnet group descriptions. If a subnet group name is specified,
/// the list contains only the description of that group.
///
/// Container for the necessary parameters to execute the DescribeSubnetGroups service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeSubnetGroups service method, as returned by MemoryDB.
///
///
///
///
///
///
/// REST API Reference for DescribeSubnetGroups Operation
public virtual Task DescribeSubnetGroupsAsync(DescribeSubnetGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeSubnetGroupsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeSubnetGroupsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region DescribeUsers
internal virtual DescribeUsersResponse DescribeUsers(DescribeUsersRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeUsersRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeUsersResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Returns a list of users.
///
/// Container for the necessary parameters to execute the DescribeUsers service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the DescribeUsers service method, as returned by MemoryDB.
///
///
///
///
///
///
/// REST API Reference for DescribeUsers Operation
public virtual Task DescribeUsersAsync(DescribeUsersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeUsersRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeUsersResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region FailoverShard
internal virtual FailoverShardResponse FailoverShard(FailoverShardRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = FailoverShardRequestMarshaller.Instance;
options.ResponseUnmarshaller = FailoverShardResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Used to failover a shard. This API is designed for testing the behavior of your application
/// in case of MemoryDB failover. It is not designed to be used as a production-level
/// 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.
///
/// Container for the necessary parameters to execute the FailoverShard service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the FailoverShard service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for FailoverShard Operation
public virtual Task FailoverShardAsync(FailoverShardRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = FailoverShardRequestMarshaller.Instance;
options.ResponseUnmarshaller = FailoverShardResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region ListAllowedNodeTypeUpdates
internal virtual ListAllowedNodeTypeUpdatesResponse ListAllowedNodeTypeUpdates(ListAllowedNodeTypeUpdatesRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListAllowedNodeTypeUpdatesRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListAllowedNodeTypeUpdatesResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Lists all available node types that you can scale to from your cluster's current node
/// type. When you use the UpdateCluster operation to scale your cluster, the value of
/// the NodeType parameter must be one of the node types returned by this operation.
///
/// Container for the necessary parameters to execute the ListAllowedNodeTypeUpdates service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the ListAllowedNodeTypeUpdates service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for ListAllowedNodeTypeUpdates Operation
public virtual Task ListAllowedNodeTypeUpdatesAsync(ListAllowedNodeTypeUpdatesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = ListAllowedNodeTypeUpdatesRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListAllowedNodeTypeUpdatesResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region ListTags
internal virtual ListTagsResponse ListTags(ListTagsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListTagsRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListTagsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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 your MemoryDB
/// resources. For more information, see Tagging
/// your MemoryDB resources
///
/// Container for the necessary parameters to execute the ListTags service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the ListTags service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for ListTags Operation
public virtual Task ListTagsAsync(ListTagsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = ListTagsRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListTagsResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region PurchaseReservedNodesOffering
internal virtual PurchaseReservedNodesOfferingResponse PurchaseReservedNodesOffering(PurchaseReservedNodesOfferingRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = PurchaseReservedNodesOfferingRequestMarshaller.Instance;
options.ResponseUnmarshaller = PurchaseReservedNodesOfferingResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Allows you to purchase a reserved node offering. Reserved nodes are not eligible for
/// cancellation and are non-refundable.
///
/// Container for the necessary parameters to execute the PurchaseReservedNodesOffering service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the PurchaseReservedNodesOffering service method, as returned by MemoryDB.
///
///
///
///
///
///
///
/// You already have a reservation with the given identifier.
///
///
/// The request cannot be processed because it would exceed the user's node quota.
///
///
/// The requested node offering does not exist.
///
///
///
///
///
///
///
/// REST API Reference for PurchaseReservedNodesOffering Operation
public virtual Task PurchaseReservedNodesOfferingAsync(PurchaseReservedNodesOfferingRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = PurchaseReservedNodesOfferingRequestMarshaller.Instance;
options.ResponseUnmarshaller = PurchaseReservedNodesOfferingResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region ResetParameterGroup
internal virtual ResetParameterGroupResponse ResetParameterGroup(ResetParameterGroupRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ResetParameterGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = ResetParameterGroupResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Modifies the parameters of a 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 parameter group, specify the AllParameters and ParameterGroupName parameters.
///
/// Container for the necessary parameters to execute the ResetParameterGroup service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the ResetParameterGroup service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for ResetParameterGroup Operation
public virtual Task ResetParameterGroupAsync(ResetParameterGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = ResetParameterGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = ResetParameterGroupResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region TagResource
internal virtual TagResourceResponse TagResource(TagResourceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = TagResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// 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 MemoryDB resources. When you add or remove tags
/// on clusters, those actions will be replicated to all nodes in the cluster. For more
/// information, see Resource-level
/// permissions.
///
///
///
/// For example, you can use cost-allocation tags to your MemoryDB 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.
///
///
/// Container for the necessary parameters to execute the TagResource service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the TagResource service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for TagResource Operation
public virtual Task TagResourceAsync(TagResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = TagResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region UntagResource
internal virtual UntagResourceResponse UntagResource(UntagResourceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UntagResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Use this operation to remove tags on a resource
///
/// Container for the necessary parameters to execute the UntagResource service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the UntagResource service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for UntagResource Operation
public virtual Task UntagResourceAsync(UntagResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = UntagResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region UpdateACL
internal virtual UpdateACLResponse UpdateACL(UpdateACLRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateACLRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateACLResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Changes the list of users that belong to the Access Control List.
///
/// Container for the necessary parameters to execute the UpdateACL service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the UpdateACL service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for UpdateACL Operation
public virtual Task UpdateACLAsync(UpdateACLRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateACLRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateACLResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region UpdateCluster
internal virtual UpdateClusterResponse UpdateCluster(UpdateClusterRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateClusterRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateClusterResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Modifies the settings for a cluster. You can use this operation to change one or more
/// cluster configuration settings by specifying the settings and the new values.
///
/// Container for the necessary parameters to execute the UpdateCluster service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the UpdateCluster service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for UpdateCluster Operation
public virtual Task UpdateClusterAsync(UpdateClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateClusterRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateClusterResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region UpdateParameterGroup
internal virtual UpdateParameterGroupResponse UpdateParameterGroup(UpdateParameterGroupRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateParameterGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateParameterGroupResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Updates 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.
///
/// Container for the necessary parameters to execute the UpdateParameterGroup service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the UpdateParameterGroup service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for UpdateParameterGroup Operation
public virtual Task UpdateParameterGroupAsync(UpdateParameterGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateParameterGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateParameterGroupResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region UpdateSubnetGroup
internal virtual UpdateSubnetGroupResponse UpdateSubnetGroup(UpdateSubnetGroupRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateSubnetGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateSubnetGroupResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Updates a subnet group. For more information, see Updating
/// a subnet group
///
/// Container for the necessary parameters to execute the UpdateSubnetGroup service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the UpdateSubnetGroup service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for UpdateSubnetGroup Operation
public virtual Task UpdateSubnetGroupAsync(UpdateSubnetGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateSubnetGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateSubnetGroupResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
#region UpdateUser
internal virtual UpdateUserResponse UpdateUser(UpdateUserRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateUserRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateUserResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Changes user password(s) and/or access string.
///
/// Container for the necessary parameters to execute the UpdateUser service method.
///
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
///
///
/// The response from the UpdateUser service method, as returned by MemoryDB.
///
///
///
///
///
///
///
///
///
///
///
///
/// REST API Reference for UpdateUser Operation
public virtual Task UpdateUserAsync(UpdateUserRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateUserRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateUserResponseUnmarshaller.Instance;
return InvokeAsync(request, options, cancellationToken);
}
#endregion
}
}