public void DeleteBucketPolicyAsync(string bucketName, AmazonServiceCallback <DeleteBucketPolicyRequest, DeleteBucketPolicyResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Creates a Table object with the specified name, using the
/// passed-in client to load the table definition.
///
/// This method return an exception if the table does not exist within the callback.
/// </summary>
/// <param name="ddbClient">Client to use to access DynamoDB.</param>
/// <param name="tableName">Name of the table.</param>
/// <param name="conversion">Conversion to use for converting .NET values to DynamoDB values.</param>
/// <param name="callback">The callback that will be invoked when the asynchronous operation completes.</para>
/// <param name="asyncOptions">An instance of AsyncOptions that specifies how the async method should be executed.</para>
public static void LoadTableAsync(IAmazonDynamoDB ddbClient, string tableName, DynamoDBEntryConversion conversion, AmazonDynamoDBCallback <Table> callback, AsyncOptions asyncOptions = null)
{
LoadTableAsync(ddbClient, tableName, DynamoDBConsumer.DocumentModel, conversion, callback, asyncOptions);
}
/// <summary>
/// Initiates the asynchronous execution of the PutItem operation.
/// <seealso cref="Amazon.DynamoDBv2.DocumentModel.Table.PutItem"/>
/// </summary>
/// <param name="doc">Document to save.</param>
/// <param name="callback">The callback that will be invoked when the asynchronous operation completes.</param>
/// <param name="asyncOptions">An instance of AsyncOptions that specifies how the async method should be executed.</param>
public void PutItemAsync(Document doc, AmazonDynamoDBCallback <Document> callback, AsyncOptions asyncOptions = null)
{
asyncOptions = asyncOptions ?? new AsyncOptions();
DynamoDBAsyncExecutor.ExecuteAsync <Document>(
() => { return(PutItemHelper(doc, null, true)); },
asyncOptions,
callback);
}
/// <summary>
/// Creates a Table object with the specified name, using the
/// passed-in client to load the table definition.
///
/// This method return an exception if the table does not exist within the callback.
/// </summary>
/// <param name="ddbClient">Client to use to access DynamoDB.</param>
/// <param name="tableName">Name of the table.</param>
/// <param name="conversion">Conversion to use for converting .NET values to DynamoDB values.</param>
/// <param name="callback">The callback that will be invoked when the asynchronous operation completes.</param>
/// <param name="asyncOptions">An instance of AsyncOptions that specifies how the async method should be executed.</param>
public static void LoadTableAsync(IAmazonDynamoDB ddbClient, string tableName, DynamoDBEntryConversion conversion, AmazonDynamoDBCallback <Table> callback, AsyncOptions asyncOptions = null)
{
var config = new TableConfig(tableName, conversion, DynamoDBConsumer.DocumentModel, storeAsEpoch: null);
LoadTableAsync(ddbClient, config, callback, asyncOptions);
}
/// <summary>
/// Initiates the asynchronous execution of the GetItem operation.
/// <seealso cref="Amazon.DynamoDBv2.DocumentModel.Table.GetItem"/>
/// </summary>
/// <param name="hashKey">Hash key element of the document.</param>
/// <param name="callback">The callback that will be invoked when the asynchronous operation completes.</param>
/// <param name="asyncOptions">An instance of AsyncOptions that specifies how the async method should be executed.</param>
public void GetItemAsync(Primitive hashKey, AmazonDynamoDBCallback <Document> callback, AsyncOptions asyncOptions = null)
{
asyncOptions = asyncOptions ?? new AsyncOptions();
DynamoDBAsyncExecutor.ExecuteAsync <Document>(
() => { return(GetItemHelper(MakeKey(hashKey, null), null, true)); },
asyncOptions,
callback);
}
/// <summary>
/// Lists your Amazon Kinesis streams.
///
///
/// <para>
/// The number of streams may be too large to return from a single call to <code>ListStreams</code>.
/// You can limit the number of returned streams using the <code>Limit</code> parameter.
/// If you do not specify a value for the <code>Limit</code> parameter, Amazon Kinesis
/// uses the default limit, which is currently 10.
/// </para>
///
/// <para>
/// You can detect if there are more streams available to list by using the <code>HasMoreStreams</code>
/// flag from the returned output. If there are more streams available, you can request
/// more streams by using the name of the last stream returned by the <code>ListStreams</code>
/// request in the <code>ExclusiveStartStreamName</code> parameter in a subsequent request
/// to <code>ListStreams</code>. The group of stream names returned by the subsequent
/// request is then added to the list. You can continue this process until all the stream
/// names have been collected in the list.
/// </para>
///
/// <para>
/// <a>ListStreams</a> has a limit of 5 transactions per second per account.
/// </para>
/// </summary>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// </param>
///
/// <returns>The response from the ListStreams service method, as returned by Kinesis.</returns>
/// <exception cref="Amazon.Kinesis.Model.LimitExceededException">
/// The requested resource exceeds the maximum number allowed, or the number of concurrent
/// stream requests exceeds the maximum number allowed (5).
/// </exception>
public void ListStreamsAsync(AmazonServiceCallback <ListStreamsRequest, ListStreamsResponse> callback, AsyncOptions options = null)
{
ListStreamsAsync(new ListStreamsRequest(), callback, options);
}
/// <summary>
/// Initiates the asynchronous execution of the UpdateShardCount operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the UpdateShardCount operation on AmazonKinesisClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
public void UpdateShardCountAsync(UpdateShardCountRequest request, AmazonServiceCallback <UpdateShardCountRequest, UpdateShardCountResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new UpdateShardCountRequestMarshaller();
var unmarshaller = UpdateShardCountResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if (callback != null)
{
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult <UpdateShardCountRequest, UpdateShardCountResponse> responseObject
= new AmazonServiceResult <UpdateShardCountRequest, UpdateShardCountResponse>((UpdateShardCountRequest)req, (UpdateShardCountResponse)res, ex, ao.State);
callback(responseObject);
}
}
;
BeginInvoke <UpdateShardCountRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
#endregion
}
/// <summary>
/// Initiates the asynchronous execution of the AssumeRoleWithWebIdentity operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the AssumeRoleWithWebIdentity operation on AmazonSecurityTokenServiceClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRoleWithWebIdentity">REST API Reference for AssumeRoleWithWebIdentity Operation</seealso>
public void AssumeRoleWithWebIdentityAsync(AssumeRoleWithWebIdentityRequest request, AmazonServiceCallback <AssumeRoleWithWebIdentityRequest, AssumeRoleWithWebIdentityResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new AssumeRoleWithWebIdentityRequestMarshaller();
var unmarshaller = AssumeRoleWithWebIdentityResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if (callback != null)
{
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult <AssumeRoleWithWebIdentityRequest, AssumeRoleWithWebIdentityResponse> responseObject
= new AmazonServiceResult <AssumeRoleWithWebIdentityRequest, AssumeRoleWithWebIdentityResponse>((AssumeRoleWithWebIdentityRequest)req, (AssumeRoleWithWebIdentityResponse)res, ex, ao.State);
callback(responseObject);
}
}
;
BeginInvoke <AssumeRoleWithWebIdentityRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Initiates the asynchronous execution of the DecodeAuthorizationMessage operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DecodeAuthorizationMessage operation on AmazonSecurityTokenServiceClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/DecodeAuthorizationMessage">REST API Reference for DecodeAuthorizationMessage Operation</seealso>
public void DecodeAuthorizationMessageAsync(DecodeAuthorizationMessageRequest request, AmazonServiceCallback <DecodeAuthorizationMessageRequest, DecodeAuthorizationMessageResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new DecodeAuthorizationMessageRequestMarshaller();
var unmarshaller = DecodeAuthorizationMessageResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if (callback != null)
{
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult <DecodeAuthorizationMessageRequest, DecodeAuthorizationMessageResponse> responseObject
= new AmazonServiceResult <DecodeAuthorizationMessageRequest, DecodeAuthorizationMessageResponse>((DecodeAuthorizationMessageRequest)req, (DecodeAuthorizationMessageResponse)res, ex, ao.State);
callback(responseObject);
}
}
;
BeginInvoke <DecodeAuthorizationMessageRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Refreshes dataset metadata. Dataset metadata is pulled from remote
/// storage and stored in local storage. Their record data isn't pulled down
/// until you sync each dataset.
/// </summary>
/// <param name="callback">Callback once the refresh is complete</param>
/// <param name="options">Options for asynchronous execution</param>
/// <exception cref="Amazon.CognitoSync.SyncManager.DataStorageException">Thrown when fail to fresh dataset metadata</exception>
public void RefreshDatasetMetadataAsync(AmazonCognitoSyncCallback <List <DatasetMetadata> > callback, AsyncOptions options = null)
{
options = options ?? new AsyncOptions();
remote.GetDatasetMetadataAsync((cognitoResult) =>
{
Exception ex = cognitoResult.Exception;
List <DatasetMetadata> res = cognitoResult.Response;
if (ex != null)
{
InternalSDKUtils.AsyncExecutor(() => callback(cognitoResult), options);
}
else
{
Local.UpdateDatasetMetadata(GetIdentityId(), res);
InternalSDKUtils.AsyncExecutor(() => callback(cognitoResult), options);
}
}, options);
}
/// <summary>
/// Initiates the asynchronous execution of the ListTagsForDeliveryStream operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListTagsForDeliveryStream operation on AmazonKinesisFirehoseClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/firehose-2015-08-04/ListTagsForDeliveryStream">REST API Reference for ListTagsForDeliveryStream Operation</seealso>
public virtual void ListTagsForDeliveryStreamAsync(ListTagsForDeliveryStreamRequest request, AmazonServiceCallback <ListTagsForDeliveryStreamRequest, ListTagsForDeliveryStreamResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = ListTagsForDeliveryStreamRequestMarshaller.Instance;
var unmarshaller = ListTagsForDeliveryStreamResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if (callback != null)
{
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult <ListTagsForDeliveryStreamRequest, ListTagsForDeliveryStreamResponse> responseObject
= new AmazonServiceResult <ListTagsForDeliveryStreamRequest, ListTagsForDeliveryStreamResponse>((ListTagsForDeliveryStreamRequest)req, (ListTagsForDeliveryStreamResponse)res, ex, ao.State);
callback(responseObject);
}
}
;
BeginInvoke <ListTagsForDeliveryStreamRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Upload data to Amazon S3 using HTTP POST.
/// </summary>
/// <remarks>
/// For more information, <see href="http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingHTTPPOST.html"/>
/// </remarks>
/// <param name="request">Request object which describes the data to POST</param>
public void PostObjectAsync(PostObjectRequest request, AmazonServiceCallback <PostObjectRequest, PostObjectResponse> callback, AsyncOptions options = null)
{
options = options == null ? new AsyncOptions() : options;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper
= (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) =>
{
AmazonServiceResult <PostObjectRequest, PostObjectResponse> responseObject
= new AmazonServiceResult <PostObjectRequest, PostObjectResponse>((PostObjectRequest)req, (PostObjectResponse)res, ex, ao.State);
if (callback != null)
{
callback(responseObject);
}
};
ThreadPool.QueueUserWorkItem(new WaitCallback(delegate
{
// Provide a default policy if user doesn't set it.
if (request.SignedPolicy == null)
{
CreateSignedPolicy(request);
}
PostObject(request, options, callbackHelper);
}));
}
private void PostObject(PostObjectRequest request, AsyncOptions options, Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper)
{
string url;
string subdomain = request.Region.Equals(RegionEndpoint.USEast1) ? "s3" : "s3-" + request.Region.SystemName;
IDictionary <string, string> headers = new Dictionary <string, string>();
if (request.Bucket.IndexOf('.') > -1)
{
url = string.Format(CultureInfo.InvariantCulture, "https://{0}.amazonaws.com/{1}/", subdomain, request.Bucket);
}
else
{
url = string.Format(CultureInfo.InvariantCulture, "https://{0}.{1}.amazonaws.com", request.Bucket, subdomain);
}
Uri uri = new Uri(url);
UnityWebRequest webRequest = new UnityWebRequest(uri);
request.webRequest = webRequest;
var boundary = Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Replace('=', 'z');
headers[HeaderKeys.ContentTypeHeader] = string.Format(CultureInfo.InvariantCulture, "multipart/form-data; boundary={0}", boundary);
headers[HeaderKeys.UserAgentHeader] = AWSSDKUtils.UserAgentHeader;
webRequest.Method = "POST";
using (var reqStream = new MemoryStream())
{
request.WriteFormData(boundary, reqStream);
byte[] boundaryBytes = Encoding.UTF8.GetBytes(string.Format(CultureInfo.InvariantCulture, "--{0}\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n", boundary));
reqStream.Write(boundaryBytes, 0, boundaryBytes.Length);
using (var inputStream = null == request.Path ? request.InputStream : File.OpenRead(request.Path))
{
byte[] buf = new byte[1024];
int bytesRead;
while ((bytesRead = inputStream.Read(buf, 0, 1024)) > 0)
{
reqStream.Write(buf, 0, bytesRead);
}
}
byte[] endBoundaryBytes = Encoding.UTF8.GetBytes(string.Format(CultureInfo.InvariantCulture, "\r\n--{0}--", boundary));
reqStream.Write(endBoundaryBytes, 0, endBoundaryBytes.Length);
webRequest.WriteToRequestBody(null, reqStream.ToArray(), headers);
}
var executionContext = new AsyncExecutionContext(
new AsyncRequestContext(this.Config.LogMetrics)
{
ClientConfig = this.Config,
OriginalRequest = request,
Action = callbackHelper,
AsyncOptions = options,
IsAsync = true
},
new AsyncResponseContext()
);
webRequest.SetRequestHeaders(headers);
executionContext.RuntimeState = webRequest;
executionContext.ResponseContext.AsyncResult =
new RuntimeAsyncResult(executionContext.RequestContext.Callback,
executionContext.RequestContext.State);
executionContext.ResponseContext.AsyncResult.AsyncOptions = executionContext.RequestContext.AsyncOptions;
executionContext.ResponseContext.AsyncResult.Action = executionContext.RequestContext.Action;
executionContext.ResponseContext.AsyncResult.Request = executionContext.RequestContext.OriginalRequest;
webRequest.BeginGetResponse(new AsyncCallback(ProcessPostResponse), executionContext);
}
public void DeleteBucketReplicationAsync(DeleteBucketReplicationRequest request, AmazonServiceCallback <DeleteBucketReplicationRequest, DeleteBucketReplicationResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Increases the Amazon Kinesis stream's retention period, which is the length of time
/// data records are accessible after they are added to the stream. The maximum value
/// of a stream's retention period is 168 hours (7 days).
///
///
/// <para>
/// Upon choosing a longer stream retention period, this operation will increase the time
/// period records are accessible that have not yet expired. However, it will not make
/// previous data that has expired (older than the stream's previous retention period)
/// accessible after the operation has been called. For example, if a stream's retention
/// period is set to 24 hours and is increased to 168 hours, any data that is older than
/// 24 hours will remain inaccessible to consumer applications.
/// </para>
/// </summary>
/// <param name="streamName">The name of the stream to modify.</param>
/// <param name="retentionPeriodHours">The new retention period of the stream, in hours. Must be more than the current retention period.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// </param>
///
/// <returns>The response from the IncreaseStreamRetentionPeriod service method, as returned by Kinesis.</returns>
/// <exception cref="Amazon.Kinesis.Model.InvalidArgumentException">
/// A specified parameter exceeds its restrictions, is not supported, or can't be used.
/// For more information, see the returned message.
/// </exception>
/// <exception cref="Amazon.Kinesis.Model.ResourceInUseException">
/// The resource is not available for this operation. For successful operation, the resource
/// needs to be in the <code>ACTIVE</code> state.
/// </exception>
/// <exception cref="Amazon.Kinesis.Model.ResourceNotFoundException">
/// The requested resource could not be found. The stream might not be specified correctly.
/// </exception>
public void IncreaseStreamRetentionPeriodAsync(string streamName, int retentionPeriodHours, AmazonServiceCallback <IncreaseStreamRetentionPeriodRequest, IncreaseStreamRetentionPeriodResponse> callback, AsyncOptions options = null)
{
var request = new IncreaseStreamRetentionPeriodRequest();
request.StreamName = streamName;
request.RetentionPeriodHours = retentionPeriodHours;
IncreaseStreamRetentionPeriodAsync(request, callback, options);
}
/// <summary>
/// Returns a set of temporary credentials for an AWS account or IAM user. The credentials
/// consist of an access key ID, a secret access key, and a security token. Typically,
/// you use <code>GetSessionToken</code> if you want to use MFA to protect programmatic
/// calls to specific AWS APIs like Amazon EC2 <code>StopInstances</code>. MFA-enabled
/// IAM users would need to call <code>GetSessionToken</code> and submit an MFA code that
/// is associated with their MFA device. Using the temporary security credentials that
/// are returned from the call, IAM users can then make programmatic calls to APIs that
/// require MFA authentication. If you do not supply a correct MFA code, then the API
/// returns an access denied error. For a comparison of <code>GetSessionToken</code> with
/// the other APIs that produce temporary credentials, see <a href="http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html">Requesting
/// Temporary Security Credentials</a> and <a href="http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#stsapi_comparison">Comparing
/// the AWS STS APIs</a> in the <i>IAM User Guide</i>.
///
///
/// <para>
/// The <code>GetSessionToken</code> action must be called by using the long-term AWS
/// security credentials of the AWS account or an IAM user. Credentials that are created
/// by IAM users are valid for the duration that you specify, from 900 seconds (15 minutes)
/// up to a maximum of 129600 seconds (36 hours), with a default of 43200 seconds (12
/// hours); credentials that are created by using account credentials can range from 900
/// seconds (15 minutes) up to a maximum of 3600 seconds (1 hour), with a default of 1
/// hour.
/// </para>
///
/// <para>
/// The temporary security credentials created by <code>GetSessionToken</code> can be
/// used to make API calls to any AWS service with the following exceptions:
/// </para>
/// <ul> <li>
/// <para>
/// You cannot call any IAM APIs unless MFA authentication information is included in
/// the request.
/// </para>
/// </li> <li>
/// <para>
/// You cannot call any STS API <i>except</i> <code>AssumeRole</code> or <code>GetCallerIdentity</code>.
/// </para>
/// </li> </ul> <note>
/// <para>
/// We recommend that you do not call <code>GetSessionToken</code> with root account credentials.
/// Instead, follow our <a href="http://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#create-iam-users">best
/// practices</a> by creating one or more IAM users, giving them the necessary permissions,
/// and using IAM users for everyday interaction with AWS.
/// </para>
/// </note>
/// <para>
/// The permissions associated with the temporary security credentials returned by <code>GetSessionToken</code>
/// are based on the permissions associated with account or IAM user whose credentials
/// are used to call the action. If <code>GetSessionToken</code> is called using root
/// account credentials, the temporary credentials have root account permissions. Similarly,
/// if <code>GetSessionToken</code> is called using the credentials of an IAM user, the
/// temporary credentials have the same permissions as the IAM user.
/// </para>
///
/// <para>
/// For more information about using <code>GetSessionToken</code> to create temporary
/// credentials, go to <a href="http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_getsessiontoken">Temporary
/// Credentials for Users in Untrusted Environments</a> in the <i>IAM User Guide</i>.
///
/// </para>
/// </summary>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// </param>
///
/// <returns>The response from the GetSessionToken service method, as returned by SecurityTokenService.</returns>
/// <exception cref="Amazon.SecurityToken.Model.RegionDisabledException">
/// STS is not activated in the requested region for the account that is being asked to
/// generate credentials. The account administrator must use the IAM console to activate
/// STS in that region. For more information, see <a href="http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html">Activating
/// and Deactivating AWS STS in an AWS Region</a> in the <i>IAM User Guide</i>.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetSessionToken">REST API Reference for GetSessionToken Operation</seealso>
public void GetSessionTokenAsync(AmazonServiceCallback <GetSessionTokenRequest, GetSessionTokenResponse> callback, AsyncOptions options = null)
{
GetSessionTokenAsync(new GetSessionTokenRequest(), callback, options);
}
/// <summary>
/// Initiates the asynchronous execution of the IncreaseStreamRetentionPeriod operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the IncreaseStreamRetentionPeriod operation on AmazonKinesisClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
public void IncreaseStreamRetentionPeriodAsync(IncreaseStreamRetentionPeriodRequest request, AmazonServiceCallback <IncreaseStreamRetentionPeriodRequest, IncreaseStreamRetentionPeriodResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new IncreaseStreamRetentionPeriodRequestMarshaller();
var unmarshaller = IncreaseStreamRetentionPeriodResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if (callback != null)
{
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult <IncreaseStreamRetentionPeriodRequest, IncreaseStreamRetentionPeriodResponse> responseObject
= new AmazonServiceResult <IncreaseStreamRetentionPeriodRequest, IncreaseStreamRetentionPeriodResponse>((IncreaseStreamRetentionPeriodRequest)req, (IncreaseStreamRetentionPeriodResponse)res, ex, ao.State);
callback(responseObject);
}
}
;
BeginInvoke <IncreaseStreamRetentionPeriodRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Deletes a delivery stream and its data.
///
///
/// <para>
/// You can delete a delivery stream only if it is in <code>ACTIVE</code> or <code>DELETING</code>
/// state, and not in the <code>CREATING</code> state. While the deletion request is in
/// process, the delivery stream is in the <code>DELETING</code> state.
/// </para>
///
/// <para>
/// To check the state of a delivery stream, use <a>DescribeDeliveryStream</a>.
/// </para>
///
/// <para>
/// While the delivery stream is <code>DELETING</code> state, the service may continue
/// to accept the records, but the service doesn't make any guarantees with respect to
/// delivering the data. Therefore, as a best practice, you should first stop any applications
/// that are sending records before deleting a delivery stream.
/// </para>
/// </summary>
/// <param name="deliveryStreamName">The name of the delivery stream.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// </param>
///
/// <returns>The response from the DeleteDeliveryStream service method, as returned by KinesisFirehose.</returns>
/// <exception cref="Amazon.KinesisFirehose.Model.ResourceInUseException">
/// The resource is already in use and not available for this operation.
/// </exception>
/// <exception cref="Amazon.KinesisFirehose.Model.ResourceNotFoundException">
/// The specified resource could not be found.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/firehose-2015-08-04/DeleteDeliveryStream">REST API Reference for DeleteDeliveryStream Operation</seealso>
public virtual void DeleteDeliveryStreamAsync(string deliveryStreamName, AmazonServiceCallback <DeleteDeliveryStreamRequest, DeleteDeliveryStreamResponse> callback, AsyncOptions options = null)
{
var request = new DeleteDeliveryStreamRequest();
request.DeliveryStreamName = deliveryStreamName;
DeleteDeliveryStreamAsync(request, callback, options);
}
/// <summary>
/// Initiates the asynchronous execution of the RemoveTagsFromStream operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the RemoveTagsFromStream operation on AmazonKinesisClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
public void RemoveTagsFromStreamAsync(RemoveTagsFromStreamRequest request, AmazonServiceCallback <RemoveTagsFromStreamRequest, RemoveTagsFromStreamResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new RemoveTagsFromStreamRequestMarshaller();
var unmarshaller = RemoveTagsFromStreamResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if (callback != null)
{
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult <RemoveTagsFromStreamRequest, RemoveTagsFromStreamResponse> responseObject
= new AmazonServiceResult <RemoveTagsFromStreamRequest, RemoveTagsFromStreamResponse>((RemoveTagsFromStreamRequest)req, (RemoveTagsFromStreamResponse)res, ex, ao.State);
callback(responseObject);
}
}
;
BeginInvoke <RemoveTagsFromStreamRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Writes a single data record into an Amazon Kinesis Firehose delivery stream. To write
/// multiple data records into a delivery stream, use <a>PutRecordBatch</a>. Applications
/// using these operations are referred to as producers.
///
///
/// <para>
/// By default, each delivery stream can take in up to 2,000 transactions per second,
/// 5,000 records per second, or 5 MB per second. Note that if you use <a>PutRecord</a>
/// and <a>PutRecordBatch</a>, the limits are an aggregate across these two operations
/// for each delivery stream. For more information about limits and how to request an
/// increase, see <a href="http://docs.aws.amazon.com/firehose/latest/dev/limits.html">Amazon
/// Kinesis Firehose Limits</a>.
/// </para>
///
/// <para>
/// You must specify the name of the delivery stream and the data record when using <a>PutRecord</a>.
/// The data record consists of a data blob that can be up to 1,000 KB in size, and any
/// kind of data, for example, a segment from a log file, geographic location data, website
/// clickstream data, and so on.
/// </para>
///
/// <para>
/// Kinesis Firehose buffers records before delivering them to the destination. To disambiguate
/// the data blobs at the destination, a common solution is to use delimiters in the data,
/// such as a newline (<code>\n</code>) or some other character unique within the data.
/// This allows the consumer application to parse individual data items when reading the
/// data from the destination.
/// </para>
///
/// <para>
/// The <a>PutRecord</a> operation returns a <b>RecordId</b>, which is a unique string
/// assigned to each record. Producer applications can use this ID for purposes such as
/// auditability and investigation.
/// </para>
///
/// <para>
/// If the <a>PutRecord</a> operation throws a <b>ServiceUnavailableException</b>, back
/// off and retry. If the exception persists, it is possible that the throughput limits
/// have been exceeded for the delivery stream.
/// </para>
///
/// <para>
/// Data records sent to Kinesis Firehose are stored for 24 hours from the time they are
/// added to a delivery stream as it attempts to send the records to the destination.
/// If the destination is unreachable for more than 24 hours, the data is no longer available.
/// </para>
/// </summary>
/// <param name="deliveryStreamName">The name of the delivery stream.</param>
/// <param name="record">The record.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// </param>
///
/// <returns>The response from the PutRecord service method, as returned by KinesisFirehose.</returns>
/// <exception cref="Amazon.KinesisFirehose.Model.InvalidArgumentException">
/// The specified input parameter has a value that is not valid.
/// </exception>
/// <exception cref="Amazon.KinesisFirehose.Model.ResourceNotFoundException">
/// The specified resource could not be found.
/// </exception>
/// <exception cref="Amazon.KinesisFirehose.Model.ServiceUnavailableException">
/// The service is unavailable, back off and retry the operation. If you continue to see
/// the exception, throughput limits for the delivery stream may have been exceeded. For
/// more information about limits and how to request an increase, see <a href="http://docs.aws.amazon.com/firehose/latest/dev/limits.html">Amazon
/// Kinesis Firehose Limits</a>.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/firehose-2015-08-04/PutRecord">REST API Reference for PutRecord Operation</seealso>
public virtual void PutRecordAsync(string deliveryStreamName, Record record, AmazonServiceCallback <PutRecordRequest, PutRecordResponse> callback, AsyncOptions options = null)
{
var request = new PutRecordRequest();
request.DeliveryStreamName = deliveryStreamName;
request.Record = record;
PutRecordAsync(request, callback, options);
}
/// <summary>
/// Initiates the asynchronous execution of the GetRemaining operation.
/// <seealso cref="Amazon.DynamoDBv2.DocumentModel.Search.GetRemaining"/>
/// </summary>
/// <param name="callback">The callback that will be invoked when the asynchronous operation completes.</param>
/// <param name="asyncOptions">An instance of AsyncOptions that specifies how the async method should be executed.</param>
public void GetRemainingAsync(AmazonDynamoDBCallback <List <Document> > callback, AsyncOptions asyncOptions = null)
{
asyncOptions = asyncOptions ?? new AsyncOptions();
DynamoDBAsyncExecutor.ExecuteAsync <List <Document> >(
() => { return(GetRemainingHelper(true)); },
asyncOptions,
callback);
}
/// <summary>
/// Writes multiple data records into a delivery stream in a single call, which can achieve
/// higher throughput per producer than when writing single records. To write single data
/// records into a delivery stream, use <a>PutRecord</a>. Applications using these operations
/// are referred to as producers.
///
///
/// <para>
/// By default, each delivery stream can take in up to 2,000 transactions per second,
/// 5,000 records per second, or 5 MB per second. If you use <a>PutRecord</a> and <a>PutRecordBatch</a>,
/// the limits are an aggregate across these two operations for each delivery stream.
/// For more information about limits, see <a href="http://docs.aws.amazon.com/firehose/latest/dev/limits.html">Amazon
/// Kinesis Firehose Limits</a>.
/// </para>
///
/// <para>
/// Each <a>PutRecordBatch</a> request supports up to 500 records. Each record in the
/// request can be as large as 1,000 KB (before 64-bit encoding), up to a limit of 4 MB
/// for the entire request. These limits cannot be changed.
/// </para>
///
/// <para>
/// You must specify the name of the delivery stream and the data record when using <a>PutRecord</a>.
/// The data record consists of a data blob that can be up to 1,000 KB in size, and any
/// kind of data. For example, it could be a segment from a log file, geographic location
/// data, web site clickstream data, and so on.
/// </para>
///
/// <para>
/// Kinesis Firehose buffers records before delivering them to the destination. To disambiguate
/// the data blobs at the destination, a common solution is to use delimiters in the data,
/// such as a newline (<code>\n</code>) or some other character unique within the data.
/// This allows the consumer application to parse individual data items when reading the
/// data from the destination.
/// </para>
///
/// <para>
/// The <a>PutRecordBatch</a> response includes a count of failed records, <b>FailedPutCount</b>,
/// and an array of responses, <b>RequestResponses</b>. Each entry in the <b>RequestResponses</b>
/// array provides additional information about the processed record. It directly correlates
/// with a record in the request array using the same ordering, from the top to the bottom.
/// The response array always includes the same number of records as the request array.
/// <b>RequestResponses</b> includes both successfully and unsuccessfully processed records.
/// Kinesis Firehose attempts to process all records in each <a>PutRecordBatch</a> request.
/// A single record failure does not stop the processing of subsequent records.
/// </para>
///
/// <para>
/// A successfully processed record includes a <b>RecordId</b> value, which is unique
/// for the record. An unsuccessfully processed record includes <b>ErrorCode</b> and <b>ErrorMessage</b>
/// values. <b>ErrorCode</b> reflects the type of error, and is one of the following values:
/// <code>ServiceUnavailable</code> or <code>InternalFailure</code>. <b>ErrorMessage</b>
/// provides more detailed information about the error.
/// </para>
///
/// <para>
/// If there is an internal server error or a timeout, the write might have completed
/// or it might have failed. If <b>FailedPutCount</b> is greater than 0, retry the request,
/// resending only those records that might have failed processing. This minimizes the
/// possible duplicate records and also reduces the total bytes sent (and corresponding
/// charges). We recommend that you handle any duplicates at the destination.
/// </para>
///
/// <para>
/// If <a>PutRecordBatch</a> throws <b>ServiceUnavailableException</b>, back off and retry.
/// If the exception persists, it is possible that the throughput limits have been exceeded
/// for the delivery stream.
/// </para>
///
/// <para>
/// Data records sent to Kinesis Firehose are stored for 24 hours from the time they are
/// added to a delivery stream as it attempts to send the records to the destination.
/// If the destination is unreachable for more than 24 hours, the data is no longer available.
/// </para>
/// </summary>
/// <param name="deliveryStreamName">The name of the delivery stream.</param>
/// <param name="records">One or more records.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// </param>
///
/// <returns>The response from the PutRecordBatch service method, as returned by KinesisFirehose.</returns>
/// <exception cref="Amazon.KinesisFirehose.Model.InvalidArgumentException">
/// The specified input parameter has a value that is not valid.
/// </exception>
/// <exception cref="Amazon.KinesisFirehose.Model.ResourceNotFoundException">
/// The specified resource could not be found.
/// </exception>
/// <exception cref="Amazon.KinesisFirehose.Model.ServiceUnavailableException">
/// The service is unavailable, back off and retry the operation. If you continue to see
/// the exception, throughput limits for the delivery stream may have been exceeded. For
/// more information about limits and how to request an increase, see <a href="http://docs.aws.amazon.com/firehose/latest/dev/limits.html">Amazon
/// Kinesis Firehose Limits</a>.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/firehose-2015-08-04/PutRecordBatch">REST API Reference for PutRecordBatch Operation</seealso>
public virtual void PutRecordBatchAsync(string deliveryStreamName, List <Record> records, AmazonServiceCallback <PutRecordBatchRequest, PutRecordBatchResponse> callback, AsyncOptions options = null)
{
var request = new PutRecordBatchRequest();
request.DeliveryStreamName = deliveryStreamName;
request.Records = records;
PutRecordBatchAsync(request, callback, options);
}
/// <summary>
/// Creates a Table object with the specified configuration, using the
/// passed-in client to load the table definition.
///
/// This method will throw an exception if the table does not exist.
/// </summary>
/// <param name="ddbClient">Client to use to access DynamoDB.</param>
/// <param name="config">Configuration to use for the table.</param>
/// <param name="callback">The callback that will be invoked when the asynchronous operation completes.</param>
/// <param name="asyncOptions">An instance of AsyncOptions that specifies how the async method should be executed.</param>
public static void LoadTableAsync(IAmazonDynamoDB ddbClient, TableConfig config, AmazonDynamoDBCallback <Table> callback, AsyncOptions asyncOptions = null)
{
asyncOptions = asyncOptions ?? new AsyncOptions();
DynamoDBAsyncExecutor.ExecuteAsync <Table>(
() => {
return(LoadTable(ddbClient, config));
}, asyncOptions, callback);
}
/// <summary>
/// Initiates the asynchronous execution of the PutRecordBatch operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutRecordBatch operation on AmazonKinesisFirehoseClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/firehose-2015-08-04/PutRecordBatch">REST API Reference for PutRecordBatch Operation</seealso>
public virtual void PutRecordBatchAsync(PutRecordBatchRequest request, AmazonServiceCallback <PutRecordBatchRequest, PutRecordBatchResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = PutRecordBatchRequestMarshaller.Instance;
var unmarshaller = PutRecordBatchResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if (callback != null)
{
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult <PutRecordBatchRequest, PutRecordBatchResponse> responseObject
= new AmazonServiceResult <PutRecordBatchRequest, PutRecordBatchResponse>((PutRecordBatchRequest)req, (PutRecordBatchResponse)res, ex, ao.State);
callback(responseObject);
}
}
;
BeginInvoke <PutRecordBatchRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Creates a Table object with the specified name, using the
/// passed-in client to load the table definition.
/// The returned table will use the conversion specified by
/// AWSConfigs.DynamoDBConfig.ConversionSchema
///
/// This method return an exception if the table does not exist within the callback.
/// </summary>
/// <param name="ddbClient">Client to use to access DynamoDB.</param>
/// <param name="tableName">Name of the table.</param>
/// <param name="callback">The callback that will be invoked when the asynchronous operation completes.</para>
/// <param name="asyncOptions">An instance of AsyncOptions that specifies how the async method should be executed.</para>
public static void LoadTableAsync(IAmazonDynamoDB ddbClient, string tableName, AmazonDynamoDBCallback <Table> callback, AsyncOptions asyncOptions = null)
{
LoadTableAsync(ddbClient, tableName, DynamoDBEntryConversion.CurrentConversion, callback, asyncOptions);
}
/// <summary>
/// Initiates the asynchronous execution of the EnableEnhancedMonitoring operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the EnableEnhancedMonitoring operation on AmazonKinesisClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
public void EnableEnhancedMonitoringAsync(EnableEnhancedMonitoringRequest request, AmazonServiceCallback <EnableEnhancedMonitoringRequest, EnableEnhancedMonitoringResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new EnableEnhancedMonitoringRequestMarshaller();
var unmarshaller = EnableEnhancedMonitoringResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if (callback != null)
{
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult <EnableEnhancedMonitoringRequest, EnableEnhancedMonitoringResponse> responseObject
= new AmazonServiceResult <EnableEnhancedMonitoringRequest, EnableEnhancedMonitoringResponse>((EnableEnhancedMonitoringRequest)req, (EnableEnhancedMonitoringResponse)res, ex, ao.State);
callback(responseObject);
}
}
;
BeginInvoke <EnableEnhancedMonitoringRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
internal static void LoadTableAsync(IAmazonDynamoDB ddbClient, string tableName, Table.DynamoDBConsumer consumer, DynamoDBEntryConversion conversion, AmazonDynamoDBCallback <Table> callback, AsyncOptions asyncOptions = null)
{
asyncOptions = asyncOptions ?? new AsyncOptions();
DynamoDBAsyncExecutor.ExecuteAsync <Table>(
() => {
return(LoadTable(ddbClient, tableName, consumer, conversion));
}, asyncOptions, callback);
}
/// <summary>
/// Initiates the asynchronous execution of the GetShardIterator operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetShardIterator operation on AmazonKinesisClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
public void GetShardIteratorAsync(GetShardIteratorRequest request, AmazonServiceCallback <GetShardIteratorRequest, GetShardIteratorResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new GetShardIteratorRequestMarshaller();
var unmarshaller = GetShardIteratorResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if (callback != null)
{
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult <GetShardIteratorRequest, GetShardIteratorResponse> responseObject
= new AmazonServiceResult <GetShardIteratorRequest, GetShardIteratorResponse>((GetShardIteratorRequest)req, (GetShardIteratorResponse)res, ex, ao.State);
callback(responseObject);
}
}
;
BeginInvoke <GetShardIteratorRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
public void ListUpdatesAsync(string datasetName, long lastSyncCount, AmazonCognitoSyncCallback <DatasetUpdates> callback, AsyncOptions options = null)
{
options = options ?? new AsyncOptions();
PopulateListUpdatesAsync(datasetName, lastSyncCount, new List <Record>(), null, callback, options);
}
public void UploadPartAsync(UploadPartRequest request, AmazonServiceCallback <UploadPartRequest, UploadPartResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
