/// <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 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); }
/// <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); }