/// <summary>
/// Receives the next message (if any) from the transport's input queue <see cref="ITransport.Address"/>
/// </summary>
public async Task <TransportMessage> Receive(ITransactionContext context, CancellationToken cancellationToken)
{
if (_inputQueueName == null)
{
throw new InvalidOperationException("This Azure Storage Queues transport does not have an input queue, hence it is not possible to receive anything");
}
var inputQueue = GetQueue(_inputQueueName);
var cloudQueueMessage = await inputQueue.GetMessageAsync(_initialVisibilityDelay, new QueueRequestOptions(), new OperationContext(), cancellationToken);
if (cloudQueueMessage == null)
{
return(null);
}
context.OnCompleted(async() =>
{
// if we get this far, don't pass on the cancellation token
// ReSharper disable once MethodSupportsCancellation
await inputQueue.DeleteMessageAsync(cloudQueueMessage);
});
context.OnAborted(() =>
{
const MessageUpdateFields fields = MessageUpdateFields.Visibility;
var visibilityTimeout = TimeSpan.FromSeconds(0);
AsyncHelpers.RunSync(() => inputQueue.UpdateMessageAsync(cloudQueueMessage, visibilityTimeout, fields));
});
return(Deserialize(cloudQueueMessage));
}
/// <inheritdoc />
public Task UpdateMessageAsync(IStorageQueueMessage message, TimeSpan visibilityTimeout,
MessageUpdateFields updateFields, CancellationToken cancellationToken)
{
CloudQueueMessage sdkMessage = ((StorageQueueMessage)message).SdkObject;
return(_sdk.UpdateMessageAsync(sdkMessage, visibilityTimeout, updateFields, options: null, operationContext: null, cancellationToken: cancellationToken));
}
public void UpdateMessage(MutableStorageQueueMessage message, TimeSpan visibilityTimeout,
MessageUpdateFields updateFields)
{
if ((updateFields & MessageUpdateFields.Content) == MessageUpdateFields.Content)
{
// No-op; queue messages already provide in-memory content updating.
}
if ((updateFields & MessageUpdateFields.Visibility) == MessageUpdateFields.Visibility)
{
message.NextVisibleTime = DateTimeOffset.Now.Add(visibilityTimeout);
}
}
static void SetUpCompletion(ITransactionContext context, CloudQueueMessage cloudQueueMessage, CloudQueue inputQueue)
{
var messageId = cloudQueueMessage.Id;
var popReceipt = cloudQueueMessage.PopReceipt;
context.OnCompleted(async() =>
{
try
{
// if we get this far, don't pass on the cancellation token
// ReSharper disable once MethodSupportsCancellation
await inputQueue.DeleteMessageAsync(
messageId,
popReceipt,
ExponentialRetryRequestOptions,
new OperationContext()
);
}
catch (Exception exception)
{
throw new RebusApplicationException(exception, $"Could not delete message with ID {messageId} and pop receipt {popReceipt} from the input queue");
}
});
context.OnAborted(() =>
{
const MessageUpdateFields fields = MessageUpdateFields.Visibility;
var visibilityTimeout = TimeSpan.FromSeconds(0);
AsyncHelpers.RunSync(async() =>
{
// ignore if this fails
try
{
await inputQueue.UpdateMessageAsync(cloudQueueMessage, visibilityTimeout, fields);
}
catch { }
});
});
}
public async Task UpdateMessageAsync(
CloudQueueMessage message,
TimeSpan visibilityTimeout,
MessageUpdateFields updateFields,
CancellationToken cancellationToken)
{
try
{
await _queue.UpdateMessageAsync(
message,
visibilityTimeout,
updateFields,
_options,
null,
cancellationToken);
}
catch (StorageException se)
{
HandleException(se);
throw;
}
}
/// <summary>Generates a task sequence for updating a message in the queue.</summary>
/// <param name="message">The message. </param>
/// <param name="visibilityTimeout">The visibility timeout. </param>
/// <param name="updateFlags">The flags controlling which parts of the message to update. Must include Visibility. </param>
/// <returns>A <see cref="TaskSequence"/> that updates the message. </returns>
private TaskSequence UpdateMessageImpl(
CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFlags)
{
CommonUtils.AssertNotNull("message", message);
CommonUtils.AssertNotNullOrEmpty("messageId", message.Id);
CommonUtils.AssertNotNullOrEmpty("popReceipt", message.PopReceipt);
CommonUtils.AssertInBounds(
"visibilityTimeout", visibilityTimeout, TimeSpan.Zero, CloudQueueMessage.MaxTimeToLive);
if ((updateFlags & MessageUpdateFields.Visibility) == 0)
{
throw new ArgumentException(SR.Calls_to_UpdateMessage_must_include_the_Visibility_flag, "updateFlags");
}
var messageUri = this.GetIndividualMessageAddress(message.Id);
var webRequest = QueueRequest.UpdateMessage(
messageUri,
this.ServiceClient.Timeout.RoundUpToSeconds(),
message.PopReceipt,
(int)visibilityTimeout.TotalSeconds);
if ((updateFlags & MessageUpdateFields.Content) != 0)
{
var requestBody =
QueueRequest.GenerateMessageRequestBody(this.GenerateMessageContentsForRequest(message));
CommonUtils.ApplyRequestOptimizations(webRequest, requestBody.Length);
this.ServiceClient.Credentials.SignRequest(webRequest);
var requestTask = webRequest.GetRequestStreamAsync();
yield return requestTask;
using (var requestStream = requestTask.Result)
{
var writeTask = requestStream.WriteAsync(requestBody, 0, requestBody.Length);
yield return writeTask;
var scratch = writeTask.Result;
}
}
else
{
CommonUtils.ApplyRequestOptimizations(webRequest, 0);
this.ServiceClient.Credentials.SignRequest(webRequest);
}
var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, this.ServiceClient.Timeout);
yield return task;
using (var webResponse = task.Result as HttpWebResponse)
{
// Update the message pop receipt and next visible time
message.PopReceipt = QueueResponse.GetPopReceipt(webResponse);
message.NextVisibleTime = QueueResponse.GetNextVisibleTime(webResponse);
}
}
/// <summary>
/// Begins an asynchronous operation to update the visibility timeout and optionally the content of a message.
/// </summary>
/// <param name="message">The message to update.</param>
/// <param name="visibilityTimeout">The visibility timeout interval.</param>
/// <param name="updateFields">An EnumSet of <see cref="MessageUpdateFields"/> values that specifies which parts of the message are to be updated.</param>
/// <param name="options">An <see cref="QueueRequestOptions"/> object that specifies any additional options for the request.</param>
/// <param name="operationContext">An object that represents the context for the current operation.</param>
/// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
/// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
/// <returns>An <see cref="ICancellableAsyncResult"/> that references the asynchronous operation.</returns>
public ICancellableAsyncResult BeginUpdateMessage(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields, QueueRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state)
{
CommonUtils.AssertNotNull("message", message);
QueueRequestOptions modifiedOptions = QueueRequestOptions.ApplyDefaults(options, this.ServiceClient);
operationContext = operationContext ?? new OperationContext();
return Executor.BeginExecuteAsync(
this.UpdateMessageImpl(message, visibilityTimeout, updateFields, modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext,
callback,
state);
}
public Task UpdateMessageAsync(IStorageQueueMessage message, TimeSpan visibilityTimeout,
MessageUpdateFields updateFields, CancellationToken cancellationToken)
{
_store.UpdateMessage(_queueName, (MutableStorageQueueMessage)message, visibilityTimeout, updateFields);
return(Task.FromResult(0));
}
/// <summary>
/// Implementation for the UpdateMessage method.
/// </summary>
/// <param name="message">The message to update.</param>
/// <param name="visibilityTimeout">The visibility timeout interval.</param>
/// <param name="updateFields">The message update fields.</param>
/// <param name="options">A <see cref="QueueRequestOptions"/> object that specifies any additional options for the request.</param>
/// <returns>A <see cref="RESTCommand"/> that sets the permissions.</returns>
private RESTCommand<NullType> UpdateMessageImpl(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields, QueueRequestOptions options)
{
CommonUtility.AssertNotNull("message", message);
CommonUtility.AssertNotNullOrEmpty("messageId", message.Id);
CommonUtility.AssertNotNullOrEmpty("popReceipt", message.PopReceipt);
CommonUtility.AssertInBounds<TimeSpan>("visibilityTimeout", visibilityTimeout, TimeSpan.Zero, CloudQueueMessage.MaxTimeToLive);
if ((updateFields & MessageUpdateFields.Visibility) == 0)
{
throw new ArgumentException(SR.UpdateMessageVisibilityRequired, "updateFlags");
}
Uri messageUri = this.GetIndividualMessageAddress(message.Id);
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, messageUri);
putCmd.ApplyRequestOptions(options);
putCmd.Handler = this.ServiceClient.AuthenticationHandler;
putCmd.BuildClient = HttpClientFactory.BuildHttpClient;
putCmd.BuildRequest = (cmd, cnt, ctx) => QueueHttpRequestMessageFactory.UpdateMessage(cmd.Uri, cmd.ServerTimeoutInSeconds, message.PopReceipt, visibilityTimeout, cnt, ctx);
if ((updateFields & MessageUpdateFields.Content) != 0)
{
MultiBufferMemoryStream memoryStream = new MultiBufferMemoryStream(null /* bufferManager */, (int)(1 * Constants.KB));
QueueRequest.WriteMessageContent(message.GetMessageContentForTransfer(this.EncodeMessage), memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
putCmd.BuildContent = (cmd, ctx) => HttpContentFactory.BuildContentFromStream(memoryStream, 0, memoryStream.Length, null, cmd, ctx);
}
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.NoContent, resp, NullType.Value, cmd, ex);
GetPopReceiptAndNextVisibleTimeFromResponse(message, resp);
return NullType.Value;
};
return putCmd;
}
public void UpdateMessage(MutableStorageQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields)
{
MutableStorageQueueMessage storedMessage = LookupMessage(message.PopReceipt);
if ((updateFields & MessageUpdateFields.Content) == MessageUpdateFields.Content)
{
// No-op; queue messages already provide in-memory content updating.
}
if ((updateFields & MessageUpdateFields.Visibility) == MessageUpdateFields.Visibility)
{
DateTimeOffset nextVisibleTime = DateTimeOffset.Now.Add(visibilityTimeout);
storedMessage.NextVisibleTime = message.NextVisibleTime = nextVisibleTime;
}
}
/// <summary>
/// Implementation for the UpdateMessage method.
/// </summary>
/// <param name="message">The message to update.</param>
/// <param name="visibilityTimeout">The visibility timeout interval.</param>
/// <param name="updateFields">The message update fields.</param>
/// <param name="options">A <see cref="QueueRequestOptions"/> object that specifies any additional options for the request.</param>
/// <returns>A <see cref="RESTCommand"/> that sets the permissions.</returns>
private RESTCommand<NullType> UpdateMessageImpl(CloudQueueMessage message, TimeSpan? visibilityTimeout, MessageUpdateFields updateFields, QueueRequestOptions options)
{
TimeSpan? effectiveVisibilityTimeout = visibilityTimeout;
if ((updateFields & MessageUpdateFields.Visibility) != 0)
{
CommonUtils.AssertNotNull("visibilityTimeout", visibilityTimeout);
}
else
{
effectiveVisibilityTimeout = TimeSpan.FromSeconds(0);
}
Uri messageUri = this.GetIndividualMessageAddress(message.Id);
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, messageUri);
options.ApplyToStorageCommand(putCmd);
putCmd.Handler = this.ServiceClient.AuthenticationHandler;
putCmd.BuildClient = HttpClientFactory.BuildHttpClient;
putCmd.BuildRequest = (cmd, cnt, ctx) => QueueHttpRequestMessageFactory.UpdateMessage(cmd.Uri, cmd.ServerTimeoutInSeconds, message.PopReceipt, effectiveVisibilityTimeout, cnt, ctx);
if ((updateFields & MessageUpdateFields.Content) != 0)
{
MemoryStream memoryStream = new MemoryStream();
QueueRequest.WriteMessageContent(message.GetMessageContentForTransfer(this.EncodeMessage), memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
putCmd.BuildContent = (cmd, ctx) => HttpContentFactory.BuildContentFromStream(memoryStream, 0, memoryStream.Length, null, cmd, ctx);
}
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.NoContent, resp, NullType.Value, cmd, ex, ctx);
GetPopReceiptAndNextVisibleTimeFromResponse(message, resp);
return NullType.Value;
};
return putCmd;
}
public Task UpdateMessageAsync(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields, CancellationToken cancellationToken)
{
return AsyncExtensions.TaskFromVoidApm(this.BeginUpdateMessage, this.EndUpdateMessage, message, visibilityTimeout, updateFields, cancellationToken);
}
public Task UpdateMessageAsync(IStorageQueueMessage message, TimeSpan visibilityTimeout,
MessageUpdateFields updateFields, CancellationToken cancellationToken)
{
_store.UpdateMessage(_queueName, (MutableStorageQueueMessage)message, visibilityTimeout, updateFields);
return Task.FromResult(0);
}
public static Task UpdateMessageAsync(this CloudQueue queue, CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields, CancellationToken cancellationToken)
{
return(queue.UpdateMessageAsync(message, visibilityTimeout, updateFields, null, null, cancellationToken));
}
/// <summary>
/// Updates the visibility timeout and optionally the content of a message.
/// </summary>
/// <param name="messages">The messages.</param>
/// <param name="visibilityTimeout">A System.TimeSpan specifying the visibility timeout interval.</param>
/// <param name="updateFields">Flags of Microsoft.WindowsAzure.Storage.Queue.MessageUpdateFields values that specifies which parts of the message are to be updated.</param>
/// <param name="cancellationToken">A <see cref="T:System.Threading.CancellationToken" /> to observe while waiting for a task to complete.</param>
/// <returns>The current QueueStorage instance.</returns>
public Task <QueueStorage> UpdateManyAsync(IEnumerable <CloudQueueMessage> messages, TimeSpan?visibilityTimeout = null, MessageUpdateFields updateFields = MessageUpdateFields.Content | MessageUpdateFields.Visibility, CancellationToken?cancellationToken = null)
{
messages.ValidateNull();
return(Task.Run(async() =>
{
foreach (var message in messages)
{
await this._cloudQueue.UpdateMessageAsync(message, visibilityTimeout.HasValue ? visibilityTimeout.Value : TimeSpan.Zero, MessageUpdateFields.Content | MessageUpdateFields.Visibility, cancellationToken ?? CancellationToken.None);
}
return this;
},
cancellationToken ?? CancellationToken.None));
}
private RESTCommand <NullType> UpdateMessageImpl(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields, QueueRequestOptions options)
{
throw new System.NotImplementedException();
}
public virtual Task UpdateMessageAsync(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields, QueueRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
public virtual Task UpdateMessageAsync(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Updates the visibility timeout and optionally the content of a message.
/// </summary>
/// <param name="message">The message to update.</param>
/// <param name="visibilityTimeout">The length of time from now during which the message will be invisible.</param>
/// <param name="updateFields">Flags indicating which parts of the message are to be updated. This must include the Visibility flag.</param>
public void UpdateMessage(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields)
{
TaskImplHelper.ExecuteImplWithRetry(
() => this.UpdateMessageImpl(message, visibilityTimeout, updateFields),
this.ServiceClient.RetryPolicy);
}
public Task UpdateMessageAsync(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields, CancellationToken cancellationToken)
{
return(_queue.UpdateMessageAsync(message, visibilityTimeout, updateFields, cancellationToken));
}
/// <summary>
/// Updates a message.
/// </summary>
/// <param name="message">The message to update.</param>
/// <param name="visibilityTimeout">The visibility timeout interval.</param>
/// <param name="updateFields">The message update fields.</param>
/// <returns>An <see cref="IAsyncAction"/> that represents an asynchronous action.</returns>
public IAsyncAction UpdateMessageAsync(CloudQueueMessage message, TimeSpan? visibilityTimeout, MessageUpdateFields updateFields)
{
return this.UpdateMessageAsync(message, visibilityTimeout, updateFields, null, null);
}
public virtual ICancellableAsyncResult BeginUpdateMessage(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields, AsyncCallback callback, object state)
{
return this.BeginUpdateMessage(message, visibilityTimeout, updateFields, null /* options */, null /* operationContext */, callback, state);
}
/// <summary>
/// Updates the visibility timeout and optionally the content of a message.
/// </summary>
/// <param name="messages">The messages.</param>
/// <param name="visibilityTimeout">A System.TimeSpan specifying the visibility timeout interval.</param>
/// <param name="updateFields">Flags of Microsoft.WindowsAzure.Storage.Queue.MessageUpdateFields values that specifies which parts of the message are to be updated.</param>
/// <returns>The current QueueStorage instance.</returns>
public QueueStorage UpdateMany(IEnumerable <CloudQueueMessage> messages, TimeSpan?visibilityTimeout = null, MessageUpdateFields updateFields = MessageUpdateFields.Content | MessageUpdateFields.Visibility)
{
messages.ValidateNull();
foreach (var message in messages)
{
this._cloudQueue.UpdateMessage(message, visibilityTimeout.HasValue ? visibilityTimeout.Value : TimeSpan.Zero, updateFields);
}
return(this);
}
/// <summary>
/// Update the visibility timeout and optionally the content of a message.
/// </summary>
/// <param name="cloudQueueMessage">A Microsoft.WindowsAzure.Storage.Queue.CloudQueueMessage object.</param>
/// <param name="visibilityTimeout">A System.TimeSpan specifying the visibility timeout interval.</param>
/// <param name="messageUpdateFields">A set of Microsoft.WindowsAzure.Storage.Queue.MessageUpdateFields values that specify which parts of the message are to be updated.</param>
/// <returns>The async task.</returns>
public async Task UpdateMessageAsync(CloudQueueMessage cloudQueueMessage, TimeSpan visibilityTimeout, MessageUpdateFields messageUpdateFields)
{
await _cloudQueue.UpdateMessageAsync(cloudQueueMessage, visibilityTimeout, messageUpdateFields);
}
public void UpdateMessage(string queueName, MutableStorageQueueMessage message, TimeSpan visibilityTimeout,
MessageUpdateFields updateFields)
{
_items[queueName].UpdateMessage(message, visibilityTimeout, updateFields);
}
/// <inheritdoc />
public Task UpdateMessageAsync(IStorageQueueMessage message, TimeSpan visibilityTimeout,
MessageUpdateFields updateFields, CancellationToken cancellationToken)
{
CloudQueueMessage sdkMessage = ((StorageQueueMessage)message).SdkObject;
return _sdk.UpdateMessageAsync(sdkMessage, visibilityTimeout, updateFields, cancellationToken);
}
public IAsyncAction UpdateMessageAsync(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields)
{
return this.UpdateMessageAsync(message, visibilityTimeout, updateFields, null /* options */, null /* operationContext */);
}
/// <summary>
/// Updates the visibility timeout and optionally the content of a message.
/// </summary>
/// <param name="message">The message to update.</param>
/// <param name="visibilityTimeout">The visibility timeout interval.</param>
/// <param name="updateFields">Flags of <see cref="MessageUpdateFields"/> values that specifies which parts of the message are to be updated.</param>
/// <param name="options">An <see cref="QueueRequestOptions"/> object that specifies any additional options for the request.</param>
/// <param name="operationContext">An object that represents the context for the current operation.</param>
public void UpdateMessage(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields, QueueRequestOptions options = null, OperationContext operationContext = null)
{
QueueRequestOptions modifiedOptions = QueueRequestOptions.ApplyDefaults(options, this.ServiceClient);
operationContext = operationContext ?? new OperationContext();
Executor.ExecuteSync(
this.UpdateMessageImpl(message, visibilityTimeout, updateFields, modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext);
}
public virtual Task UpdateMessageAsync(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields)
{
return this.UpdateMessageAsync(message, visibilityTimeout, updateFields, CancellationToken.None);
}
/// <summary>
/// Update the visibility timeout and optionally the content of a message.
/// </summary>
/// <param name="cloudQueueMessage">A Microsoft.WindowsAzure.Storage.Queue.CloudQueueMessage object.</param>
/// <param name="visibilityTimeout">A System.TimeSpan specifying the visibility timeout interval.</param>
/// <param name="messageUpdateFields">A set of Microsoft.WindowsAzure.Storage.Queue.MessageUpdateFields values that specify which parts of the message are to be updated.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The async task.</returns>
public async Task UpdateMessageAsync(CloudQueueMessage cloudQueueMessage, TimeSpan visibilityTimeout, MessageUpdateFields messageUpdateFields, CancellationToken cancellationToken)
{
await _cloudQueue.UpdateMessageAsync(cloudQueueMessage, visibilityTimeout, messageUpdateFields, cancellationToken);
}
public Task UpdateMessageAsync(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields, QueueRequestOptions options = null, OperationContext operationContext = null, CancellationToken cancellationToken = default(CancellationToken))
{
return(CloudQueue.UpdateMessageAsync(message, visibilityTimeout, updateFields, options, operationContext, cancellationToken));
}
public virtual Task UpdateMessageAsync(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields, QueueRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return AsyncExtensions.TaskFromVoidApm(this.BeginUpdateMessage, this.EndUpdateMessage, message, visibilityTimeout, updateFields, options, operationContext, cancellationToken);
}
/// <summary>
/// Implementation for the UpdateMessage method.
/// </summary>
/// <param name="message">A queue message.</param>
/// <param name="visibilityTimeout">The visibility timeout for the message.</param>
/// <param name="updateFlags">Indicates whether to update the visibility delay, message contents, or both.</param>
/// <param name="options">An <see cref="QueueRequestOptions"/> object that specifies any additional options for the request.</param>
/// <returns>A <see cref="RESTCommand{T}"/> that sets the permissions.</returns>
private RESTCommand<NullType> UpdateMessageImpl(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFlags, QueueRequestOptions options)
{
CommonUtils.AssertNotNull("message", message);
CommonUtils.AssertNotNullOrEmpty("messageId", message.Id);
CommonUtils.AssertNotNullOrEmpty("popReceipt", message.PopReceipt);
CommonUtils.AssertInBounds<TimeSpan>("visibilityTimeout", visibilityTimeout, TimeSpan.Zero, CloudQueueMessage.MaxTimeToLive);
if ((updateFlags & MessageUpdateFields.Visibility) == 0)
{
throw new ArgumentException("Calls to UpdateMessage must include the Visibility flag.", "updateFlags");
}
Uri messageUri = this.GetIndividualMessageAddress(message.Id);
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, messageUri);
options.ApplyToStorageCommand(putCmd);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => QueueHttpWebRequestFactory.UpdateMessage(putCmd.Uri, serverTimeout, message.PopReceipt, visibilityTimeout.RoundUpToSeconds(), ctx);
if ((updateFlags & MessageUpdateFields.Content) != 0)
{
MemoryStream memoryStream = new MemoryStream();
QueueRequest.WriteMessageContent(message.GetMessageContentForTransfer(this.EncodeMessage), memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
putCmd.SendStream = memoryStream;
putCmd.RecoveryAction = RecoveryActions.RewindStream;
}
else
{
putCmd.SetHeaders = (r, ctx) =>
{
r.ContentLength = 0;
};
}
putCmd.SignRequest = this.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.NoContent, resp, NullType.Value, cmd, ex, ctx);
GetPopReceiptAndNextVisibleTimeFromResponse(message, resp);
return NullType.Value;
};
return putCmd;
}
public override Task UpdateMessageAsync(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields)
{
//throw new NotImplementedException();
return(base.UpdateMessageAsync(message, visibilityTimeout, updateFields));
}
/// <summary>
/// Begins an asynchronous operation to update the visibility timeout and optionally the content of a message.
/// </summary>
/// <param name="message">The message to update.</param>
/// <param name="visibilityTimeout">The visibility timeout interval.</param>
/// <param name="updateFields">An EnumSet of <see cref="MessageUpdateFields"/> values that specifies which parts of the message are to be updated.</param>
/// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
/// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
/// <returns>An <see cref="ICancellableAsyncResult"/> that references the asynchronous operation.</returns>
public ICancellableAsyncResult BeginUpdateMessage(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields, AsyncCallback callback, object state)
{
return this.BeginUpdateMessage(message, visibilityTimeout, updateFields, null, null, callback, state);
}
public override Task UpdateMessageAsync(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields, QueueRequestOptions options, OperationContext operationContext)
{
//throw new NotImplementedException();
return(base.UpdateMessageAsync(message, visibilityTimeout, updateFields, options, operationContext));
}
public void UpdateMessage(string queueName, MutableStorageQueueMessage message, TimeSpan visibilityTimeout,
MessageUpdateFields updateFields)
{
_items[queueName].UpdateMessage(message, visibilityTimeout, updateFields);
}
public override Task UpdateMessageAsync(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields, QueueRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
//throw new NotImplementedException();
//return base.UpdateMessageAsync(message, visibilityTimeout, updateFields, options, operationContext, cancellationToken);
_store.UpdateMessage(this.Name, message, visibilityTimeout, updateFields);
return(Task.FromResult(0));
}
/// <summary>
/// Generates a task sequence for updating a message in the queue.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="visibilityTimeout">The visibility timeout.</param>
/// <param name="updateFlags">The flags controlling which parts of the message to update. Must include Visibility.</param>
/// <returns>A <see cref="TaskSequence"/> that updates the message.</returns>
private TaskSequence UpdateMessageImpl(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFlags)
{
CommonUtils.AssertNotNull("message", message);
CommonUtils.AssertNotNullOrEmpty("messageId", message.Id);
CommonUtils.AssertNotNullOrEmpty("popReceipt", message.PopReceipt);
CommonUtils.AssertInBounds<TimeSpan>("visibilityTimeout", visibilityTimeout, TimeSpan.Zero, CloudQueueMessage.MaxTimeToLive);
if ((updateFlags & MessageUpdateFields.Visibility) == 0)
{
throw new ArgumentException("Calls to UpdateMessage must include the Visibility flag.", "updateFlags");
}
Uri messageUri = this.GetIndividualMessageAddress(message.Id);
HttpWebRequest webRequest = QueueRequest.UpdateMessage(messageUri, this.ServiceClient.Timeout.RoundUpToSeconds(), message.PopReceipt, (int)visibilityTimeout.TotalSeconds);
if ((updateFlags & MessageUpdateFields.Content) != 0)
{
byte[] requestBody = QueueRequest.GenerateMessageRequestBody(this.GenerateMessageContentsForRequest(message));
CommonUtils.ApplyRequestOptimizations(webRequest, requestBody.Length);
this.ServiceClient.Credentials.SignRequest(webRequest);
StorageTask<Stream> requestTask = webRequest.GetRequestStreamAsyncEx();
yield return requestTask;
using (Stream requestStream = requestTask.Result)
{
StorageTask<NullTaskReturn> writeTask = requestStream.WriteAsyncEx(requestBody, 0, requestBody.Length);
yield return writeTask;
NullTaskReturn scratch = writeTask.Result;
Console.WriteLine(scratch);
}
}
else
{
CommonUtils.ApplyRequestOptimizations(webRequest, 0);
this.ServiceClient.Credentials.SignRequest(webRequest);
}
StorageTask<WebResponse> task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, this.ServiceClient.Timeout);
yield return task;
using (HttpWebResponse webResponse = task.Result as HttpWebResponse)
{
// Update the message pop receipt and next visible time
message.PopReceipt = QueueResponse.GetPopReceipt(webResponse);
message.NextVisibleTime = QueueResponse.GetNextVisibleTime(webResponse);
}
}
public Task UpdateMessageAsync(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields)
/// <summary>
/// Begins an asynchronous operation to update the visibility timeout and optionally the content of a message.
/// </summary>
/// <param name="message">The message to update.</param>
/// <param name="visibilityTimeout">The length of time from now during which the message will be invisible.</param>
/// <param name="updateFields">Flags indicating which parts of the message are to be updated. This must include the Visibility flag.</param>
/// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
/// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
/// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
public IAsyncResult BeginUpdateMessage(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields, AsyncCallback callback, object state)
{
return TaskImplHelper.BeginImplWithRetry(
() => this.UpdateMessageImpl(message, visibilityTimeout, updateFields),
this.ServiceClient.RetryPolicy,
callback,
state);
}
public virtual Task UpdateMessageAsync(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields, QueueRequestOptions options, OperationContext operationContext)
{
return this.UpdateMessageAsync(message, visibilityTimeout, updateFields, options, operationContext, CancellationToken.None);
}
/// <summary>
/// Updates a message.
/// </summary>
/// <param name="message">The message to update.</param>
/// <param name="visibilityTimeout">The visibility timeout interval.</param>
/// <param name="updateFields">The message update fields.</param>
/// <param name="options">A <see cref="QueueRequestOptions"/> object that specifies any additional options for the request.</param>
/// <param name="operationContext">An object that represents the context for the current operation.</param>
/// <returns>An <see cref="IAsyncAction"/> that represents an asynchronous action.</returns>
public IAsyncAction UpdateMessageAsync(CloudQueueMessage message, TimeSpan? visibilityTimeout, MessageUpdateFields updateFields, QueueRequestOptions options, OperationContext operationContext)
{
QueueRequestOptions modifiedOptions = QueueRequestOptions.ApplyDefaults(options, this.ServiceClient);
operationContext = operationContext ?? new OperationContext();
return AsyncInfo.Run(async (token) => await Executor.ExecuteAsyncNullReturn(
this.UpdateMessageImpl(message, visibilityTimeout, updateFields, modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext,
token));
}
public virtual Task UpdateMessageAsync(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields, QueueRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
QueueRequestOptions modifiedOptions = QueueRequestOptions.ApplyDefaults(options, this.ServiceClient);
operationContext = operationContext ?? new OperationContext();
return Task.Run(async () => await Executor.ExecuteAsyncNullReturn(
this.UpdateMessageImpl(message, visibilityTimeout, updateFields, modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext,
cancellationToken), cancellationToken);
}
public void UpdateMessage(MutableStorageQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields)
{
MutableStorageQueueMessage storedMessage = LookupMessage(message.PopReceipt);
if ((updateFields & MessageUpdateFields.Content) == MessageUpdateFields.Content)
{
// No-op; queue messages already provide in-memory content updating.
}
if ((updateFields & MessageUpdateFields.Visibility) == MessageUpdateFields.Visibility)
{
DateTimeOffset nextVisibleTime = DateTimeOffset.Now.Add(visibilityTimeout);
storedMessage.NextVisibleTime = message.NextVisibleTime = nextVisibleTime;
}
}
/// <summary>
/// Updates the visibility timeout and optionally the content of a message.
/// </summary>
/// <param name="message">A Microsoft.WindowsAzure.Storage.Queue.CloudQueueMessage object to update.</param>
/// <param name="visibilityTimeout">A System.TimeSpan specifying the visibility timeout interval.</param>
/// <param name="updateFields">Flags of Microsoft.WindowsAzure.Storage.Queue.MessageUpdateFields values that specifies which parts of the message are to be updated.</param>
/// <returns>The current QueueStorage instance.</returns>
public QueueStorage Update(CloudQueueMessage message, TimeSpan?visibilityTimeout = null, MessageUpdateFields updateFields = MessageUpdateFields.Content | MessageUpdateFields.Visibility)
{
message.ValidateNull();
this._cloudQueue.UpdateMessage(message, visibilityTimeout.HasValue ? visibilityTimeout.Value : TimeSpan.Zero, updateFields);
return(this);
}
