public async Task SendMany <T>(List <Message <T> > messages)
{
var request = new AwsModel.SendMessageBatchRequest
{
Entries = messages.Select(m => { return(new AwsModel.SendMessageBatchRequestEntry(m.Id.ToString(), JsonConvert.SerializeObject(m.Body))); }).ToList(),
QueueUrl = Url
};
var response = await Client.AwsClient.SendMessageBatchAsync(request);
foreach (var success in response.Successful)
{
SuccessEvent?.Invoke(true, $"Message Sent Success => Message id : {success.MessageId} - Message MD5 Body: {success.MD5OfMessageBody}");
}
foreach (var failed in response.Failed)
{
ErrorEvent?.Invoke(false, $"Message Sent Error => Message id : {failed.Id} - Message Body: {failed.Message}");
}
}
public object Execute(ExecutorContext context)
{
var cmdletContext = context as CmdletContext;
// create request
var request = new Amazon.SQS.Model.SendMessageBatchRequest();
if (cmdletContext.Entry != null)
{
request.Entries = cmdletContext.Entry;
}
if (cmdletContext.QueueUrl != null)
{
request.QueueUrl = cmdletContext.QueueUrl;
}
CmdletOutput output;
// issue call
var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);
try
{
var response = CallAWSServiceOperation(client, request);
object pipelineOutput = null;
pipelineOutput = cmdletContext.Select(response, this);
output = new CmdletOutput
{
PipelineOutput = pipelineOutput,
ServiceResponse = response
};
}
catch (Exception e)
{
output = new CmdletOutput {
ErrorResponse = e
};
}
return(output);
}
public int SendMessages(string queueUrl = null, int count = 1)
{
if (queueUrl == null)
{
queueUrl = defaultQueueUrl;
}
if (count <= 1)
{
var scalarResponse = client.SendMessage(queueUrl, FakeSqsModel.CreateJson());
return string.IsNullOrEmpty(scalarResponse.MessageId)
? 0
: 1;
}
var request = new SendMessageBatchRequest
{
QueueUrl = queueUrl,
Entries = new List<SendMessageBatchRequestEntry>(count)
};
for (var x = 0; x < count; x++)
{
var model = new FakeSqsModel();
request.Entries.Add(new SendMessageBatchRequestEntry
{
Id = model.Id,
MessageBody = model.ToJson(),
});
}
var response = client.SendMessageBatch(request);
return response.Successful.Count;
}
public async Task <SendMessageBatchResponse> SendMessagesAsync(string queueUrl,
IEnumerable <SendMessageBatchRequestEntry> messages,
CancellationToken cancellationToken = default)
{
this.Logger.LogDebug($"[{nameof(this.SendMessagesAsync)}]");
this.Logger.LogTrace(JsonConvert.SerializeObject(new { queueUrl, messages }));
if (string.IsNullOrWhiteSpace(queueUrl))
{
throw new ArgumentNullException(nameof(queueUrl));
}
if (messages == null)
{
throw new ArgumentNullException(nameof(messages));
}
if (messages.Count() == 0)
{
throw new ArgumentException(nameof(messages));
}
var request = new Amazon.SQS.Model.SendMessageBatchRequest
{
Entries = messages.ToList(),
QueueUrl = queueUrl,
};
this.Logger.LogTrace(JsonConvert.SerializeObject(value: request));
var response = await this.Repository.SendMessageBatchAsync(request : request,
cancellationToken : cancellationToken == default?this.CancellationToken.Token : cancellationToken);
this.Logger.LogTrace(JsonConvert.SerializeObject(value: response));
return(response);
}
/// <summary>
/// Initiates the asynchronous execution of the SendMessageBatch operation.
/// <seealso cref="Amazon.SQS.IAmazonSQS.SendMessageBatch"/>
/// </summary>
///
/// <param name="sendMessageBatchRequest">Container for the necessary parameters to execute the SendMessageBatch operation on AmazonSQS.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">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>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSendMessageBatch
/// operation.</returns>
public IAsyncResult BeginSendMessageBatch(SendMessageBatchRequest sendMessageBatchRequest, AsyncCallback callback, object state)
{
return invokeSendMessageBatch(sendMessageBatchRequest, callback, state, false);
}
/// <summary>
/// <para>This is a batch version of SendMessage. It takes multiple messages and adds each of them to the queue. The result of each add
/// operation is reported individually in the response.</para>
/// </summary>
///
/// <param name="sendMessageBatchRequest">Container for the necessary parameters to execute the SendMessageBatch service method on
/// AmazonSQS.</param>
///
/// <returns>The response from the SendMessageBatch service method, as returned by AmazonSQS.</returns>
///
/// <exception cref="BatchEntryIdsNotDistinctException"/>
/// <exception cref="TooManyEntriesInBatchRequestException"/>
/// <exception cref="BatchRequestTooLongException"/>
/// <exception cref="InvalidBatchEntryIdException"/>
/// <exception cref="EmptyBatchRequestException"/>
public SendMessageBatchResponse SendMessageBatch(SendMessageBatchRequest sendMessageBatchRequest)
{
IAsyncResult asyncResult = invokeSendMessageBatch(sendMessageBatchRequest, null, null, true);
return EndSendMessageBatch(asyncResult);
}
private static void QueueMessages(int count)
{
using (AmazonSQSClient client = new AmazonSQSClient(
ConfigurationManager.AppSettings["AWSAccessKey"],
ConfigurationManager.AppSettings["AWSSecretAccessKey"]))
{
Parallel.ForEach(Partitioner.Create(0, count), (range) =>
{
SendMessageBatchRequest request = new SendMessageBatchRequest();
request.QueueUrl = ConfigurationManager.AppSettings["QueueUrl"];
int numberOfMessages = range.Item2 - range.Item1;
for (int i = 0; i < numberOfMessages; i++)
{
request.Entries.Add(new SendMessageBatchRequestEntry() { Id = i.ToString(), MessageBody = i.ToString() });
if ((request.Entries.Count == 10) |
(i == numberOfMessages - 1))
{
client.SendMessageBatch(request);
request.Entries.Clear();
}
}
});
}
}
public static void ValidateSendMessageBatch(SendMessageBatchRequest request, SendMessageBatchResponse response)
{
if (response != null && response.SendMessageBatchResult != null &&
response.SendMessageBatchResult.SendMessageBatchResultEntry != null && response.SendMessageBatchResult.SendMessageBatchResultEntry.Count > 0)
{
Dictionary<string, string> requestMessages = request.Entries.ToDictionary(entry => entry.Id, entry => entry.MessageBody, StringComparer.Ordinal);
List<SendMessageBatchResultEntry> resultEntries = response.SendMessageBatchResult.SendMessageBatchResultEntry;
foreach (SendMessageBatchResultEntry entry in resultEntries)
{
string body = requestMessages[entry.Id];
string md5 = entry.MD5OfMessageBody;
string id = entry.MessageId;
AmazonSQSUtil.ValidateMD5(body, id, md5);
}
}
}
public static void SQSSendMessageBatch()
{
#region SQSSendMessageBatch
var client = new AmazonSQSClient();
var entry1 = new SendMessageBatchRequestEntry
{
DelaySeconds = 0,
Id = "Entry1",
MessageAttributes = new Dictionary<string, MessageAttributeValue>
{
{
"MyNameAttribute", new MessageAttributeValue
{ DataType = "String", StringValue = "John Doe" }
},
{
"MyAddressAttribute", new MessageAttributeValue
{ DataType = "String", StringValue = "123 Main St." }
},
{
"MyRegionAttribute", new MessageAttributeValue
{ DataType = "String", StringValue = "Any Town, United States" }
}
},
MessageBody = "John Doe customer information."
};
var entry2 = new SendMessageBatchRequestEntry
{
DelaySeconds = 0,
Id = "Entry2",
MessageAttributes = new Dictionary<string, MessageAttributeValue>
{
{
"MyNameAttribute", new MessageAttributeValue
{ DataType = "String", StringValue = "Jane Doe" }
},
{
"MyAddressAttribute", new MessageAttributeValue
{ DataType = "String", StringValue = "456 Center Road" }
},
{
"MyRegionAttribute", new MessageAttributeValue
{ DataType = "String", StringValue = "Any City, United States" }
}
},
MessageBody = "Jane Doe customer information."
};
var entry3 = new SendMessageBatchRequestEntry
{
DelaySeconds = 0,
Id = "Entry3",
MessageAttributes = new Dictionary<string, MessageAttributeValue>
{
{
"MyNameAttribute", new MessageAttributeValue
{ DataType = "String", StringValue = "Richard Doe" }
},
{
"MyAddressAttribute", new MessageAttributeValue
{ DataType = "String", StringValue = "789 East Blvd." }
},
{
"MyRegionAttribute", new MessageAttributeValue
{ DataType = "String", StringValue = "Anywhere, United States" }
}
},
MessageBody = "Richard Doe customer information."
};
var request = new SendMessageBatchRequest
{
Entries = new List<SendMessageBatchRequestEntry>() { entry1, entry2, entry3 },
QueueUrl = "https://sqs.us-east-1.amazonaws.com/80398EXAMPLE/MyTestQueue"
};
var response = client.SendMessageBatch(request);
if (response.Successful.Count > 0)
{
Console.WriteLine("Successfully sent:");
foreach (var success in response.Successful)
{
Console.WriteLine(" For ID: '" + success.Id + "':");
Console.WriteLine(" Message ID = " + success.MessageId);
Console.WriteLine(" MD5 of message attributes = " +
success.MD5OfMessageAttributes);
Console.WriteLine(" MD5 of message body = " +
success.MD5OfMessageBody);
}
}
if (response.Failed.Count > 0)
{
Console.WriteLine("Failed to be sent:");
foreach (var fail in response.Failed)
{
Console.WriteLine(" For ID '" + fail.Id + "':");
Console.WriteLine(" Code = " + fail.Code);
Console.WriteLine(" Message = " + fail.Message);
Console.WriteLine(" Sender's fault? = " +
fail.SenderFault);
}
}
#endregion
Console.ReadLine();
}
internal SendMessageBatchResponse SendMessageBatch(SendMessageBatchRequest request)
{
var task = SendMessageBatchAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
throw e.InnerException;
}
}
/// <summary>
/// Initiates the asynchronous execution of the SendMessageBatch operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the SendMessageBatch operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<SendMessageBatchResponse> SendMessageBatchAsync(SendMessageBatchRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new SendMessageBatchRequestMarshaller();
var unmarshaller = SendMessageBatchResponseUnmarshaller.Instance;
return InvokeAsync<SendMessageBatchRequest,SendMessageBatchResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
/// <summary>
/// Delivers up to ten messages to the specified queue. This is a batch version of
/// <a>SendMessage</a>. The result of the send action on each message is reported
/// individually in the response. The maximum allowed individual message size is
/// 256 KB (262,144 bytes).
///
///
/// <para>
/// The maximum total payload size (i.e., the sum of all a batch's individual message
/// lengths) is also 256 KB (262,144 bytes).
/// </para>
///
/// <para>
/// If the <code>DelaySeconds</code> parameter is not specified for an entry, the
/// default for the queue is used.
/// </para>
/// <important>The following list shows the characters (in Unicode) that are allowed
/// in your message, according to the W3C XML specification. For more information,
/// go to <a href="http://www.faqs.org/rfcs/rfc1321.html">http://www.faqs.org/rfcs/rfc1321.html</a>.
/// If you send any characters that are not included in the list, your request will
/// be rejected.
/// <para>
/// #x9 | #xA | #xD | [#x20 to #xD7FF] | [#xE000 to #xFFFD] | [#x10000 to #x10FFFF]
/// </para>
/// </important> <important> Because the batch request can result in a combination
/// of successful and unsuccessful actions, you should check for batch errors even
/// when the call returns an HTTP status code of 200. </important> <note>Some API
/// actions take lists of parameters. These lists are specified using the <code>param.n</code>
/// notation. Values of <code>n</code> are integers starting from 1. For example,
/// a parameter list with two elements looks like this: </note>
/// <para>
/// <code>&Attribute.1=this</code>
/// </para>
///
/// <para>
/// <code>&Attribute.2=that</code>
/// </para>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the SendMessageBatch service method.</param>
///
/// <returns>The response from the SendMessageBatch service method, as returned by SQS.</returns>
/// <exception cref="BatchEntryIdsNotDistinctException">
/// Two or more batch entries have the same <code>Id</code> in the request.
/// </exception>
/// <exception cref="BatchRequestTooLongException">
/// The length of all the messages put together is more than the limit.
/// </exception>
/// <exception cref="EmptyBatchRequestException">
/// Batch request does not contain an entry.
/// </exception>
/// <exception cref="InvalidBatchEntryIdException">
/// The <code>Id</code> of a batch entry in a batch request does not abide by the
/// specification.
/// </exception>
/// <exception cref="TooManyEntriesInBatchRequestException">
/// Batch request contains more number of entries than permissible.
/// </exception>
/// <exception cref="UnsupportedOperationException">
/// Error code 400. Unsupported operation.
/// </exception>
public SendMessageBatchResponse SendMessageBatch(SendMessageBatchRequest request)
{
var marshaller = new SendMessageBatchRequestMarshaller();
var unmarshaller = SendMessageBatchResponseUnmarshaller.Instance;
return Invoke<SendMessageBatchRequest,SendMessageBatchResponse>(request, marshaller, unmarshaller);
}
public Task<SendMessageBatchResponse> SendMessageBatchAsync(SendMessageBatchRequest request, CancellationToken cancellationToken = new CancellationToken())
{
throw new NotImplementedException();
}
/// <exception cref="Exception" />
internal void SendMessageBatch(List<Message> messages)
{
if (messages == null || messages.Count == 0)
return;
string url = messages[0].Queue.Url;
CheckMessageBatchRestrictions(messages, url);
int batchId = 0;
var entries = new List<SendMessageBatchRequestEntry>();
foreach (var message in messages)
{
if (string.IsNullOrWhiteSpace(message.BatchId))
message.BatchId = Convert.ToString(batchId++);
entries.Add(new SendMessageBatchRequestEntry
{
DelaySeconds = message.DelaySeconds,
Id = message.BatchId,
MessageBody = message.Body
});
}
var request = new SendMessageBatchRequest { Entries = entries, QueueUrl = url };
var response = _sqsClient.SendMessageBatch(request);
if (response.IsSetSendMessageBatchResult())
{
if (response.SendMessageBatchResult.IsSetSendMessageBatchResultEntry())
{
foreach (var resultEntry in response.SendMessageBatchResult.SendMessageBatchResultEntry)
{
if (resultEntry.IsSetId() && resultEntry.IsSetMessageId())
{
messages.Single(m => m.BatchId.Equals(resultEntry.Id)).AwsAssignedId = resultEntry.MessageId;
}
}
}
else if (response.SendMessageBatchResult.IsSetBatchResultErrorEntry())
{
foreach (var errorEntry in response.SendMessageBatchResult.BatchResultErrorEntry)
{
if (errorEntry.IsSetId())
{
messages.Single(m => m.BatchId.Equals(errorEntry.Id)).Error = new Error
{
BatchId = errorEntry.Id,
Code = errorEntry.Code,
MessageText = errorEntry.Message,
SenderFault = errorEntry.SenderFault,
Service = "SQS Send Message Batch"
};
}
}
}
}
}
public SendMessageBatchResponse SendMessageBatch(SendMessageBatchRequest request)
{
if (request.Entries == null || request.Entries.Count <= 0)
{
throw new EmptyBatchRequestException("No entires in request");
}
if (request.Entries.Count > SqsQueueDefinition.MaxBatchSendItems)
{
throw new TooManyEntriesInBatchRequestException("Count of [{0}] exceeds limit of [{1}]".Fmt(request.Entries.Count, SqsQueueDefinition.MaxBatchSendItems));
}
var q = GetQueue(request.QueueUrl);
var response = new SendMessageBatchResponse
{
Failed = new List<BatchResultErrorEntry>(),
Successful = new List<SendMessageBatchResultEntry>()
};
var entryIds = new HashSet<string>();
foreach (var entry in request.Entries)
{
string id = null;
BatchResultErrorEntry batchError = null;
try
{
if (entryIds.Contains(entry.Id))
throw new BatchEntryIdsNotDistinctException("Duplicate Id of [{0}]".Fmt(entry.Id));
entryIds.Add(entry.Id);
id = q.Send(new SendMessageRequest
{
MessageBody = entry.MessageBody,
QueueUrl = q.QueueDefinition.QueueUrl
});
}
catch (ReceiptHandleIsInvalidException rhex)
{
batchError = new BatchResultErrorEntry
{
Id = entry.Id,
Message = rhex.Message,
Code = rhex.ErrorCode
};
}
if (id == null)
{
var entryToQueue = batchError ?? new BatchResultErrorEntry
{
Id = entry.Id,
Message = "FakeSendError",
Code = "789"
};
response.Failed.Add(entryToQueue);
}
else
{
response.Successful.Add(new SendMessageBatchResultEntry
{
Id = entry.Id,
MessageId = id
});
}
}
return response;
}
/// <summary>
/// Initiates the asynchronous execution of the SendMessageBatch operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the SendMessageBatch operation on AmazonSQSClient.</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 SendMessageBatchAsync(SendMessageBatchRequest request, AmazonServiceCallback<SendMessageBatchRequest, SendMessageBatchResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new SendMessageBatchRequestMarshaller();
var unmarshaller = SendMessageBatchResponseUnmarshaller.Instance;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult<SendMessageBatchRequest,SendMessageBatchResponse> responseObject
= new AmazonServiceResult<SendMessageBatchRequest,SendMessageBatchResponse>((SendMessageBatchRequest)req, (SendMessageBatchResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke<SendMessageBatchRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Delivers up to ten messages to the specified queue. This is a batch version of <a>SendMessage</a>.
/// The result of the send action on each message is reported individually in the response.
/// The maximum allowed individual message size is 256 KB (262,144 bytes).
///
///
/// <para>
/// The maximum total payload size (i.e., the sum of all a batch's individual message
/// lengths) is also 256 KB (262,144 bytes).
/// </para>
///
/// <para>
/// If the <code>DelaySeconds</code> parameter is not specified for an entry, the default
/// for the queue is used.
/// </para>
/// <important>The following list shows the characters (in Unicode) that are allowed
/// in your message, according to the W3C XML specification. For more information, go
/// to <a href="http://www.faqs.org/rfcs/rfc1321.html">http://www.faqs.org/rfcs/rfc1321.html</a>.
/// If you send any characters that are not included in the list, your request will be
/// rejected.
/// <para>
/// #x9 | #xA | #xD | [#x20 to #xD7FF] | [#xE000 to #xFFFD] | [#x10000 to #x10FFFF]
/// </para>
/// </important> <important> Because the batch request can result in a combination of
/// successful and unsuccessful actions, you should check for batch errors even when the
/// call returns an HTTP status code of 200. </important> <note>Some API actions take
/// lists of parameters. These lists are specified using the <code>param.n</code> notation.
/// Values of <code>n</code> are integers starting from 1. For example, a parameter list
/// with two elements looks like this: </note>
/// <para>
/// <code>&Attribute.1=this</code>
/// </para>
///
/// <para>
/// <code>&Attribute.2=that</code>
/// </para>
/// </summary>
/// <param name="queueUrl">The URL of the Amazon SQS queue to take action on.</param>
/// <param name="entries">A list of <a>SendMessageBatchRequestEntry</a> items.</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 SendMessageBatch service method, as returned by SQS.</returns>
/// <exception cref="Amazon.SQS.Model.BatchEntryIdsNotDistinctException">
/// Two or more batch entries have the same <code>Id</code> in the request.
/// </exception>
/// <exception cref="Amazon.SQS.Model.BatchRequestTooLongException">
/// The length of all the messages put together is more than the limit.
/// </exception>
/// <exception cref="Amazon.SQS.Model.EmptyBatchRequestException">
/// Batch request does not contain an entry.
/// </exception>
/// <exception cref="Amazon.SQS.Model.InvalidBatchEntryIdException">
/// The <code>Id</code> of a batch entry in a batch request does not abide by the specification.
/// </exception>
/// <exception cref="Amazon.SQS.Model.TooManyEntriesInBatchRequestException">
/// Batch request contains more number of entries than permissible.
/// </exception>
/// <exception cref="Amazon.SQS.Model.UnsupportedOperationException">
/// Error code 400. Unsupported operation.
/// </exception>
public void SendMessageBatchAsync(string queueUrl, List<SendMessageBatchRequestEntry> entries, AmazonServiceCallback<SendMessageBatchRequest, SendMessageBatchResponse> callback, AsyncOptions options = null)
{
var request = new SendMessageBatchRequest();
request.QueueUrl = queueUrl;
request.Entries = entries;
SendMessageBatchAsync(request, callback, options);
}
IAsyncResult invokeSendMessageBatch(SendMessageBatchRequest sendMessageBatchRequest, AsyncCallback callback, object state, bool synchronized)
{
IRequest irequest = new SendMessageBatchRequestMarshaller().Marshall(sendMessageBatchRequest);
var unmarshaller = SendMessageBatchResponseUnmarshaller.GetInstance();
AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
Invoke(result);
return result;
}
/// <summary>
/// Initiates the asynchronous execution of the SendMessageBatch operation.
/// <seealso cref="Amazon.SQS.IAmazonSQS.SendMessageBatch"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the SendMessageBatch operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public async Task<SendMessageBatchResponse> SendMessageBatchAsync(SendMessageBatchRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new SendMessageBatchRequestMarshaller();
var unmarshaller = SendMessageBatchResponseUnmarshaller.GetInstance();
var response = await Invoke<IRequest, SendMessageBatchRequest, SendMessageBatchResponse>(request, marshaller, unmarshaller, signer, cancellationToken)
.ConfigureAwait(continueOnCapturedContext: false);
return response;
}
/// <summary>
/// Delivers up to ten messages to the specified queue. This is a batch version of <code>
/// <a>SendMessage</a> </code>. For a FIFO queue, multiple messages within a single batch
/// are enqueued in the order they are sent.
///
///
/// <para>
/// The result of sending each message is reported individually in the response. Because
/// the batch request can result in a combination of successful and unsuccessful actions,
/// you should check for batch errors even when the call returns an HTTP status code of
/// <code>200</code>.
/// </para>
///
/// <para>
/// The maximum allowed individual message size and the maximum total payload size (the
/// sum of the individual lengths of all of the batched messages) are both 256 KB (262,144
/// bytes).
/// </para>
/// <important>
/// <para>
/// The following list shows the characters (in Unicode) that are allowed in your message,
/// according to the W3C XML specification:
/// </para>
/// <ul> <li>
/// <para>
/// <code>#x9</code>
/// </para>
/// </li> <li>
/// <para>
/// <code>#xA</code>
/// </para>
/// </li> <li>
/// <para>
/// <code>#xD</code>
/// </para>
/// </li> <li>
/// <para>
/// <code>#x20</code> to <code>#xD7FF</code>
/// </para>
/// </li> <li>
/// <para>
/// <code>#xE000</code> to <code>#xFFFD</code>
/// </para>
/// </li> <li>
/// <para>
/// <code>#x10000</code> to <code>#x10FFFF</code>
/// </para>
/// </li> </ul>
/// <para>
/// For more information, see <a href="https://www.ietf.org/rfc/rfc1321.txt">RFC1321</a>.
/// If you send any characters that aren't included in this list, your request is rejected.
/// </para>
/// </important>
/// <para>
/// If you don't specify the <code>DelaySeconds</code> parameter for an entry, Amazon
/// SQS uses the default value for the queue.
/// </para>
/// <note>
/// <para>
/// Some actions take lists of parameters. These lists are specified using the <code>param.n</code>
/// notation. Values of <code>n</code> are integers starting from 1. For example, a parameter
/// list with two elements looks like this:
/// </para>
///
/// <para>
/// <code>&Attribute.1=this</code>
/// </para>
///
/// <para>
/// <code>&Attribute.2=that</code>
/// </para>
/// </note>
/// </summary>
/// <param name="queueUrl">The URL of the Amazon SQS queue to which batched messages are sent. Queue URLs are case-sensitive.</param>
/// <param name="entries">A list of <code> <a>SendMessageBatchRequestEntry</a> </code> items.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
///
/// <returns>The response from the SendMessageBatch service method, as returned by SQS.</returns>
/// <exception cref="Amazon.SQS.Model.BatchEntryIdsNotDistinctException">
/// Two or more batch entries in the request have the same <code>Id</code>.
/// </exception>
/// <exception cref="Amazon.SQS.Model.BatchRequestTooLongException">
/// The length of all the messages put together is more than the limit.
/// </exception>
/// <exception cref="Amazon.SQS.Model.EmptyBatchRequestException">
/// The batch request doesn't contain any entries.
/// </exception>
/// <exception cref="Amazon.SQS.Model.InvalidBatchEntryIdException">
/// The <code>Id</code> of a batch entry in a batch request doesn't abide by the specification.
/// </exception>
/// <exception cref="Amazon.SQS.Model.TooManyEntriesInBatchRequestException">
/// The batch request contains more entries than permissible.
/// </exception>
/// <exception cref="Amazon.SQS.Model.UnsupportedOperationException">
/// Error code 400. Unsupported operation.
/// </exception>
public Task<SendMessageBatchResponse> SendMessageBatchAsync(string queueUrl, List<SendMessageBatchRequestEntry> entries, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var request = new SendMessageBatchRequest();
request.QueueUrl = queueUrl;
request.Entries = entries;
return SendMessageBatchAsync(request, cancellationToken);
}
IAsyncResult invokeSendMessageBatch(SendMessageBatchRequest request, AsyncCallback callback, object state, bool synchronized)
{
var marshaller = new SendMessageBatchRequestMarshaller();
var unmarshaller = SendMessageBatchResponseUnmarshaller.Instance;
return Invoke(request, callback, state, synchronized, marshaller, unmarshaller, signer);
}
/// <summary>
/// Delivers up to ten messages to the specified queue. This is a batch version of
/// <a>SendMessage</a>. The result of the send action on each message is reported
/// individually in the response. The maximum allowed individual message size is
/// 256 KB (262,144 bytes).
///
///
/// <para>
/// The maximum total payload size (i.e., the sum of all a batch's individual message
/// lengths) is also 256 KB (262,144 bytes).
/// </para>
///
/// <para>
/// If the <code>DelaySeconds</code> parameter is not specified for an entry, the
/// default for the queue is used.
/// </para>
/// <important>The following list shows the characters (in Unicode) that are allowed
/// in your message, according to the W3C XML specification. For more information,
/// go to <a href="http://www.faqs.org/rfcs/rfc1321.html">http://www.faqs.org/rfcs/rfc1321.html</a>.
/// If you send any characters that are not included in the list, your request will
/// be rejected.
/// <para>
/// #x9 | #xA | #xD | [#x20 to #xD7FF] | [#xE000 to #xFFFD] | [#x10000 to #x10FFFF]
/// </para>
/// </important> <important> Because the batch request can result in a combination
/// of successful and unsuccessful actions, you should check for batch errors even
/// when the call returns an HTTP status code of 200. </important> <note>Some API
/// actions take lists of parameters. These lists are specified using the <code>param.n</code>
/// notation. Values of <code>n</code> are integers starting from 1. For example,
/// a parameter list with two elements looks like this: </note>
/// <para>
/// <code>&Attribute.1=this</code>
/// </para>
///
/// <para>
/// <code>&Attribute.2=that</code>
/// </para>
/// </summary>
/// <param name="queueUrl">The URL of the Amazon SQS queue to take action on.</param>
/// <param name="entries">A list of <a>SendMessageBatchRequestEntry</a> items.</param>
///
/// <returns>The response from the SendMessageBatch service method, as returned by SQS.</returns>
/// <exception cref="BatchEntryIdsNotDistinctException">
/// Two or more batch entries have the same <code>Id</code> in the request.
/// </exception>
/// <exception cref="BatchRequestTooLongException">
/// The length of all the messages put together is more than the limit.
/// </exception>
/// <exception cref="EmptyBatchRequestException">
/// Batch request does not contain an entry.
/// </exception>
/// <exception cref="InvalidBatchEntryIdException">
/// The <code>Id</code> of a batch entry in a batch request does not abide by the
/// specification.
/// </exception>
/// <exception cref="TooManyEntriesInBatchRequestException">
/// Batch request contains more number of entries than permissible.
/// </exception>
/// <exception cref="UnsupportedOperationException">
/// Error code 400. Unsupported operation.
/// </exception>
public SendMessageBatchResponse SendMessageBatch(string queueUrl, List<SendMessageBatchRequestEntry> entries)
{
var request = new SendMessageBatchRequest();
request.QueueUrl = queueUrl;
request.Entries = entries;
return SendMessageBatch(request);
}
private Amazon.SQS.Model.SendMessageBatchResponse CallAWSServiceOperation(IAmazonSQS client, Amazon.SQS.Model.SendMessageBatchRequest request)
{
Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Simple Queue Service (SQS)", "SendMessageBatch");
try
{
#if DESKTOP
return(client.SendMessageBatch(request));
#elif CORECLR
return(client.SendMessageBatchAsync(request).GetAwaiter().GetResult());
#else
#error "Unknown build edition"
#endif
}
catch (AmazonServiceException exc)
{
var webException = exc.InnerException as System.Net.WebException;
if (webException != null)
{
throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException);
}
throw;
}
}
/// <summary>
/// Initiates the asynchronous execution of the SendMessageBatch operation.
/// <seealso cref="Amazon.SQS.IAmazonSQS"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the SendMessageBatch operation on AmazonSQSClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">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>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSendMessageBatch
/// operation.</returns>
public IAsyncResult BeginSendMessageBatch(SendMessageBatchRequest request, AsyncCallback callback, object state)
{
var marshaller = new SendMessageBatchRequestMarshaller();
var unmarshaller = SendMessageBatchResponseUnmarshaller.Instance;
return BeginInvoke<SendMessageBatchRequest>(request, marshaller, unmarshaller,
callback, state);
}
private static void ValidateSendMessageBatch(SendMessageBatchRequest request, SendMessageBatchResponse response)
{
if (response != null && response.Successful != null && response.Successful.Count > 0)
{
Dictionary<string, SendMessageBatchRequestEntry> requestMessages = request.Entries.ToDictionary(entry => entry.Id, StringComparer.Ordinal);
List<SendMessageBatchResultEntry> resultEntries = response.Successful;
foreach (SendMessageBatchResultEntry entry in resultEntries)
{
var message = requestMessages[entry.Id];
string id = entry.MessageId;
var body = message.MessageBody;
var bodyMd5 = entry.MD5OfMessageBody;
ValidateMD5(body, id, bodyMd5);
var attributes = message.MessageAttributes;
var attributesMd5 = entry.MD5OfMessageAttributes;
if (attributes != null && attributes.Count > 0 && !string.IsNullOrEmpty(attributesMd5))
ValidateMD5(attributes, id, attributesMd5);
}
}
}
/// <summary>
/// <para>Delivers up to ten messages to the specified queue. This is a batch version of SendMessage. The result of the send action on each
/// message is reported individually in the response. The maximum allowed individual message size is 256 KB (262,144 bytes).</para> <para>The
/// maximum total payload size (i.e., the sum of all a batch's individual message lengths) is also 256 KB (262,144 bytes).</para> <para>If the
/// <c>DelaySeconds</c> parameter is not specified for an entry, the default for the queue is used.</para> <para><b>IMPORTANT:</b>The following
/// list shows the characters (in Unicode) that are allowed in your message, according to the W3C XML specification. For more information, go to
/// http://www.faqs.org/rfcs/rfc1321.html. If you send any characters that are not included in the list, your request will be rejected. #x9 |
/// #xA | #xD | [#x20 to #xD7FF] | [#xE000 to #xFFFD] | [#x10000 to #x10FFFF] </para> <para><b>IMPORTANT:</b> Because the batch request can
/// result in a combination of successful and unsuccessful actions, you should check for batch errors even when the call returns an HTTP status
/// code of 200. </para> <para><b>NOTE:</b>Some API actions take lists of parameters. These lists are specified using the param.n notation.
/// Values of n are integers starting from 1. For example, a parameter list with two elements looks like this: </para> <para>
/// <c>&amp;Attribute.1=this</c> </para> <para> <c>&amp;Attribute.2=that</c> </para>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the SendMessageBatch service method on
/// AmazonSQS.</param>
///
/// <returns>The response from the SendMessageBatch service method, as returned by AmazonSQS.</returns>
///
/// <exception cref="T:Amazon.SQS.Model.BatchEntryIdsNotDistinctException" />
/// <exception cref="T:Amazon.SQS.Model.TooManyEntriesInBatchRequestException" />
/// <exception cref="T:Amazon.SQS.Model.BatchRequestTooLongException" />
/// <exception cref="T:Amazon.SQS.Model.InvalidBatchEntryIdException" />
/// <exception cref="T:Amazon.SQS.Model.EmptyBatchRequestException" />
public SendMessageBatchResponse SendMessageBatch(SendMessageBatchRequest request)
{
var task = SendMessageBatchAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return null;
}
}
async Task SendOutgoingMessages(ConcurrentQueue<OutgoingMessage> outgoingMessages, ITransactionContext context)
{
if (!outgoingMessages.Any()) return;
var client = GetClientFromTransactionContext(context);
var messagesByDestination = outgoingMessages
.GroupBy(m => m.DestinationAddress)
.ToList();
await Task.WhenAll(
messagesByDestination
.Select(async batch =>
{
var entries = batch
.Select(message =>
{
var transportMessage = message.TransportMessage;
var headers = transportMessage.Headers;
return new SendMessageBatchRequestEntry
{
Id = headers[Headers.MessageId],
MessageBody = GetBody(transportMessage.Body),
MessageAttributes = CreateAttributesFromHeaders(headers),
DelaySeconds = GetDelaySeconds(headers)
};
})
.ToList();
var destinationUrl = GetDestinationQueueUrlByName(batch.Key, context);
var request = new SendMessageBatchRequest(destinationUrl, entries);
var response = await client.SendMessageBatchAsync(request);
if (response.Failed.Any())
{
var failed = response.Failed.Select(f => new AmazonSQSException($"Failed {f.Message} with Id={f.Id}, Code={f.Code}, SenderFault={f.SenderFault}"));
throw new AggregateException(failed);
}
})
);
}
/// <summary>
/// <para>This is a batch version of SendMessage. It takes multiple messages and adds each of them to the queue. The result of each add
/// operation is reported individually in the response.</para>
/// </summary>
///
/// <param name="sendMessageBatchRequest">Container for the necessary parameters to execute the SendMessageBatch service method on
/// AmazonSQS.</param>
///
/// <returns>The response from the SendMessageBatch service method, as returned by AmazonSQS.</returns>
///
/// <exception cref="T:Amazon.SQS.Model.BatchEntryIdsNotDistinctException" />
/// <exception cref="T:Amazon.SQS.Model.TooManyEntriesInBatchRequestException" />
/// <exception cref="T:Amazon.SQS.Model.BatchRequestTooLongException" />
/// <exception cref="T:Amazon.SQS.Model.InvalidBatchEntryIdException" />
/// <exception cref="T:Amazon.SQS.Model.EmptyBatchRequestException" />
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
public Task<SendMessageBatchResponse> SendMessageBatchAsync(SendMessageBatchRequest sendMessageBatchRequest, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new SendMessageBatchRequestMarshaller();
var unmarshaller = SendMessageBatchResponseUnmarshaller.GetInstance();
return Invoke<IRequest, SendMessageBatchRequest, SendMessageBatchResponse>(sendMessageBatchRequest, marshaller, unmarshaller, signer, cancellationToken);
}
/// <summary>
/// Enqueues multiple messages into the opened queue at the same time
/// </summary>
public bool EnqueueMessages(IList<string> messages)
{
ClearErrorInfo ();
bool result = false;
try
{
var request = new SendMessageBatchRequest
{
QueueUrl = queueurl.QueueUrl
};
List<SendMessageBatchRequestEntry> entries = new List<SendMessageBatchRequestEntry> ();
// Messages counter
int ix = 0;
// Iterating until theres no message left
while (ix < messages.Count)
{
entries.Clear ();
// Storing upper limit of iteration
var len = Math.Min (ix + 10, messages.Count);
// Iterating over 10
for (var i = ix; i < len; i++)
{
entries.Add (new SendMessageBatchRequestEntry (i.ToString (), messages[i]));
ix++;
}
// Renewing entries from the object
request.Entries = entries;
// Batch Sending
var response = queue.SendMessageBatch (request);
// If any message failed to enqueue, use individual enqueue method
if (response.Failed != null && response.Failed.Count > 0)
{
// Hiccup
Thread.Sleep (100);
foreach (var failedMessage in response.Failed)
{
// Individual Enqueues
EnqueueMessage (failedMessage.Message);
}
}
}
result = true;
}
catch (Exception ex)
{
ErrorCode = e_Exception;
ErrorMessage = ex.Message;
}
return result;
}