/// <summary>
/// Implementation for the AddMessageImpl method.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="timeToLive">The maximum time to allow the message to be in the queue, or null.</param>
/// <param name="initialVisibilityDelay">The length of time from now during which the message will be invisible.
/// If <c>null</c> then the message will be visible immediately.</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> AddMessageImpl(CloudQueueMessage message, TimeSpan? timeToLive, TimeSpan? initialVisibilityDelay, QueueRequestOptions options)
{
MemoryStream memoryStream = new MemoryStream();
QueueRequest.WriteMessageContent(message.GetMessageContentForTransfer(this.EncodeMessage), memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, this.GetMessageRequestAddress());
options.ApplyToStorageCommand(putCmd);
putCmd.Handler = this.ServiceClient.AuthenticationHandler;
putCmd.BuildClient = HttpClientFactory.BuildHttpClient;
putCmd.BuildRequest = (cmd, cnt, ctx) => QueueHttpRequestMessageFactory.AddMessage(cmd.Uri, cmd.ServerTimeoutInSeconds, timeToLive, initialVisibilityDelay, cnt, ctx);
putCmd.BuildContent = (cmd, ctx) => HttpContentFactory.BuildContentFromStream(memoryStream, 0, memoryStream.Length, null, cmd, ctx);
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Created, resp, NullType.Value, cmd, ex, ctx);
GetMessageCountAndMetadataFromResponse(resp);
return NullType.Value;
};
return putCmd;
}
/// <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;
}
/// <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;
}
/// <summary>
/// Implementation for the AddMessageImpl method.
/// </summary>
/// <param name="message">A queue message.</param>
/// <param name="timeToLive">A value indicating the message time-to-live.</param>
/// <param name="initialVisibilityDelay">The visibility delay for the message.</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> AddMessageImpl(CloudQueueMessage message, TimeSpan? timeToLive, TimeSpan? initialVisibilityDelay, QueueRequestOptions options)
{
int? timeToLiveInSeconds = null;
int? initialVisibilityDelayInSeconds = null;
if (timeToLive != null)
{
CommonUtils.AssertInBounds<TimeSpan>("timeToLive", timeToLive.Value, TimeSpan.Zero, CloudQueueMessage.MaxTimeToLive);
timeToLiveInSeconds = (int)timeToLive.Value.TotalSeconds;
}
if (initialVisibilityDelay != null)
{
CommonUtils.AssertInBounds<TimeSpan>("initialVisibilityDelay", initialVisibilityDelay.Value, TimeSpan.Zero, timeToLive ?? CloudQueueMessage.MaxTimeToLive);
initialVisibilityDelayInSeconds = (int)initialVisibilityDelay.Value.TotalSeconds;
}
CommonUtils.AssertNotNull("message", message);
CommonUtils.AssertNotNull("MessageContent", message.AsBytes);
MemoryStream memoryStream = new MemoryStream();
QueueRequest.WriteMessageContent(message.GetMessageContentForTransfer(this.EncodeMessage), memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, this.GetMessageRequestAddress());
options.ApplyToStorageCommand(putCmd);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => QueueHttpWebRequestFactory.AddMessage(putCmd.Uri, serverTimeout, timeToLiveInSeconds, initialVisibilityDelayInSeconds, ctx);
putCmd.SendStream = memoryStream;
putCmd.RecoveryAction = RecoveryActions.RewindStream;
putCmd.SetHeaders = (r, ctx) =>
{
if (timeToLive != null)
{
r.Headers.Set(Constants.QueryConstants.MessageTimeToLive, timeToLive.Value.TotalSeconds.ToString());
}
if (initialVisibilityDelay != null)
{
r.Headers.Set(Constants.QueryConstants.VisibilityTimeout, initialVisibilityDelay.Value.TotalSeconds.ToString());
}
};
putCmd.SignRequest = this.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Created, resp, NullType.Value, cmd, ex, ctx);
return NullType.Value;
};
return putCmd;
}
/// <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;
}
/// <summary>
/// Implementation for the AddMessage method.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="timeToLive">The maximum time to allow the message to be in the queue, or null.</param>
/// <param name="initialVisibilityDelay">The length of time from now during which the message will be invisible.
/// If <c>null</c> then the message will be visible immediately.</param>
/// <param name="options">A <see cref="QueueRequestOptions"/> object that specifies additional options for the request.</param>
/// <returns>A <see cref="RESTCommand"/> that sets the permissions.</returns>
private RESTCommand<NullType> AddMessageImpl(CloudQueueMessage message, TimeSpan? timeToLive, TimeSpan? initialVisibilityDelay, QueueRequestOptions options)
{
int? timeToLiveInSeconds = null;
int? initialVisibilityDelayInSeconds = null;
if (timeToLive.HasValue)
{
CommonUtility.AssertInBounds("timeToLive", timeToLive.Value, TimeSpan.Zero, CloudQueueMessage.MaxTimeToLive);
timeToLiveInSeconds = (int)timeToLive.Value.TotalSeconds;
}
if (initialVisibilityDelay.HasValue)
{
CommonUtility.AssertInBounds("initialVisibilityDelay", initialVisibilityDelay.Value, TimeSpan.Zero, timeToLive ?? CloudQueueMessage.MaxTimeToLive);
initialVisibilityDelayInSeconds = (int)initialVisibilityDelay.Value.TotalSeconds;
}
MultiBufferMemoryStream memoryStream = new MultiBufferMemoryStream(null /* bufferManager */, (int)(1 * Constants.KB));
QueueRequest.WriteMessageContent(message.GetMessageContentForTransfer(this.EncodeMessage), memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, this.GetMessageRequestAddress());
options.ApplyToStorageCommand(putCmd);
putCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) => QueueHttpRequestMessageFactory.AddMessage(uri, serverTimeout, timeToLiveInSeconds, initialVisibilityDelayInSeconds, cnt, ctx, this.ServiceClient.GetCanonicalizer(), this.ServiceClient.Credentials);
putCmd.BuildContent = (cmd, ctx) => HttpContentFactory.BuildContentFromStream(memoryStream, 0, memoryStream.Length, null, cmd, ctx);
putCmd.StreamToDispose = memoryStream;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Created, resp, NullType.Value, cmd, ex);
GetMessageCountAndMetadataFromResponse(resp);
return NullType.Value;
};
return putCmd;
}
/// <summary>
/// Implementation for the AddMessageImpl method.
/// </summary>
/// <param name="message">A queue message.</param>
/// <param name="timeToLive">A value indicating the message time-to-live.</param>
/// <param name="initialVisibilityDelay">The visibility delay for the message.</param>
/// <param name="options">A <see cref="QueueRequestOptions"/> object that specifies additional options for the request.</param>
/// <returns>A <see cref="RESTCommand{T}"/> that sets the permissions.</returns>
private RESTCommand<NullType> AddMessageImpl(CloudQueueMessage message, TimeSpan? timeToLive, TimeSpan? initialVisibilityDelay, QueueRequestOptions options)
{
int? timeToLiveInSeconds = null;
int? initialVisibilityDelayInSeconds = null;
if (timeToLive.HasValue)
{
CommonUtility.AssertInBounds("timeToLive", timeToLive.Value, TimeSpan.Zero, CloudQueueMessage.MaxTimeToLive);
timeToLiveInSeconds = (int)timeToLive.Value.TotalSeconds;
}
if (initialVisibilityDelay.HasValue)
{
CommonUtility.AssertInBounds("initialVisibilityDelay", initialVisibilityDelay.Value, TimeSpan.Zero, timeToLive ?? CloudQueueMessage.MaxTimeToLive);
initialVisibilityDelayInSeconds = (int)initialVisibilityDelay.Value.TotalSeconds;
}
CommonUtility.AssertNotNull("message", message);
MultiBufferMemoryStream memoryStream = new MultiBufferMemoryStream(null /* bufferManager */, (int)(1 * Constants.KB));
QueueRequest.WriteMessageContent(message.GetMessageContentForTransfer(this.EncodeMessage, options), memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, this.GetMessageRequestAddress());
options.ApplyToStorageCommand(putCmd);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, useVersionHeader, ctx) => QueueHttpWebRequestFactory.AddMessage(uri, serverTimeout, timeToLiveInSeconds, initialVisibilityDelayInSeconds, useVersionHeader, ctx);
putCmd.SendStream = memoryStream;
putCmd.StreamToDispose = memoryStream;
putCmd.RecoveryAction = RecoveryActions.RewindStream;
putCmd.SetHeaders = (r, ctx) =>
{
if (timeToLive != null)
{
#if WINDOWS_PHONE
r.Headers[Constants.QueryConstants.MessageTimeToLive] = timeToLive.Value.TotalSeconds.ToString(CultureInfo.InvariantCulture);
#else
r.Headers.Set(Constants.QueryConstants.MessageTimeToLive, timeToLive.Value.TotalSeconds.ToString(CultureInfo.InvariantCulture));
#endif
}
if (initialVisibilityDelay != null)
{
#if WINDOWS_PHONE
r.Headers[Constants.QueryConstants.VisibilityTimeout] = initialVisibilityDelay.Value.TotalSeconds.ToString(CultureInfo.InvariantCulture);
#else
r.Headers.Set(Constants.QueryConstants.VisibilityTimeout, initialVisibilityDelay.Value.TotalSeconds.ToString(CultureInfo.InvariantCulture));
#endif
}
};
putCmd.SignRequest = this.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Created, resp, NullType.Value, cmd, ex);
return NullType.Value;
};
return putCmd;
}