public void CloudQueueAddUpdateEncryptedBinaryMessage()
{
// Create the Key to be used for wrapping.
SymmetricKey aesKey = new SymmetricKey("symencryptionkey");
CloudQueueClient client = GenerateCloudQueueClient();
string name = GenerateNewQueueName();
CloudQueue queue = client.GetQueueReference(name);
try
{
queue.CreateIfNotExists();
byte[] messageBytes = new byte[100];
Random rand = new Random();
rand.NextBytes(messageBytes);
CloudQueueMessage message = new CloudQueueMessage(messageBytes);
QueueEncryptionPolicy policy = new QueueEncryptionPolicy(aesKey, null);
QueueRequestOptions options = new QueueRequestOptions()
{
EncryptionPolicy = policy
};
// Add message
queue.AddMessage(message, null, null, options, null);
// Retrieve message
CloudQueueMessage retrMessage = queue.GetMessage(null, options, null);
TestHelper.AssertBuffersAreEqual(messageBytes, retrMessage.AsBytes);
}
finally
{
queue.DeleteIfExists();
}
}
public void CloudQueueAddEncrypted64KMessage()
{
// Create the Key to be used for wrapping.
SymmetricKey aesKey = new SymmetricKey("symencryptionkey");
CloudQueueClient client = GenerateCloudQueueClient();
string name = GenerateNewQueueName();
CloudQueue queue = client.GetQueueReference(name);
try
{
queue.CreateIfNotExists();
string inputMessage = new string('a', 64 * 1024);
CloudQueueMessage message = new CloudQueueMessage(inputMessage);
queue.EncodeMessage = false;
QueueEncryptionPolicy policy = new QueueEncryptionPolicy(aesKey, null);
QueueRequestOptions options = new QueueRequestOptions()
{
EncryptionPolicy = policy
};
// Add message
queue.AddMessage(message, null, null, null, null);
// Add encrypted Message
TestHelper.ExpectedException <ArgumentException>(
() => queue.AddMessage(message, null, null, options, null),
"Adding an encrypted message that exceeds message limits should throw");
}
finally
{
queue.DeleteIfExists();
}
}
public virtual Task<ServiceStats> GetServiceStatsAsync(QueueRequestOptions options, OperationContext operationContext)
{
return this.GetServiceStatsAsync(options, operationContext, CancellationToken.None);
}
private RESTCommand<NullType> SetServicePropertiesImpl(ServiceProperties properties, QueueRequestOptions requestOptions)
{
MultiBufferMemoryStream memoryStream = new MultiBufferMemoryStream(null /* bufferManager */, (int)(1 * Constants.KB));
try
{
properties.WriteServiceProperties(memoryStream);
}
catch (InvalidOperationException invalidOpException)
{
throw new ArgumentException(invalidOpException.Message, "properties");
}
RESTCommand<NullType> retCmd = new RESTCommand<NullType>(this.Credentials, this.StorageUri, this.HttpClient);
requestOptions.ApplyToStorageCommand(retCmd);
retCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) => QueueHttpRequestMessageFactory.SetServiceProperties(uri, serverTimeout, cnt, ctx, this.GetCanonicalizer(), this.Credentials);
retCmd.BuildContent = (cmd, ctx) => HttpContentFactory.BuildContentFromStream(memoryStream, 0, memoryStream.Length, null /* md5 */, cmd, ctx);
retCmd.StreamToDispose = memoryStream;
retCmd.PreProcessResponse =
(cmd, resp, ex, ctx) =>
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Accepted, resp, null /* retVal */, cmd, ex);
requestOptions.ApplyToStorageCommand(retCmd);
return retCmd;
}
public virtual Task SetServicePropertiesAsync(ServiceProperties properties, QueueRequestOptions requestOptions, OperationContext operationContext)
{
return this.SetServicePropertiesAsync(properties, requestOptions, operationContext, CancellationToken.None);
}
/// <summary>
/// Core implementation for the ListQueues method.
/// </summary>
/// <param name="prefix">The queue prefix.</param>
/// <param name="detailsIncluded">The details included.</param>
/// <param name="currentToken">The continuation token.</param>
/// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the
/// per-operation limit of 5000. If this value is <c>null</c>, the maximum possible number of results will be returned, up to 5000.</param>
/// <returns>A <see cref="TaskSequence"/> that lists the queues.</returns>
private RESTCommand<ResultSegment<CloudQueue>> ListQueuesImpl(string prefix, int? maxResults, QueueListingDetails detailsIncluded, QueueRequestOptions options, QueueContinuationToken currentToken)
{
ListingContext listingContext = new ListingContext(prefix, maxResults)
{
Marker = currentToken != null ? currentToken.NextMarker : null
};
RESTCommand<ResultSegment<CloudQueue>> getCmd = new RESTCommand<ResultSegment<CloudQueue>>(this.Credentials, this.StorageUri, this.HttpClient);
options.ApplyToStorageCommand(getCmd);
getCmd.CommandLocationMode = CommonUtility.GetListingLocationMode(currentToken);
getCmd.RetrieveResponseStream = true;
getCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) => QueueHttpRequestMessageFactory.List(uri, serverTimeout, listingContext, detailsIncluded, cnt, ctx, this.GetCanonicalizer(), this.Credentials);
getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex);
getCmd.PostProcessResponseAsync = async (cmd, resp, ctx, ct) =>
{
ListQueuesResponse listQueuesResponse = await ListQueuesResponse.ParseAsync(cmd.ResponseStream, ct).ConfigureAwait(false);
List<CloudQueue> queuesList = listQueuesResponse.Queues.Select(item => new CloudQueue(item.Metadata, item.Name, this)).ToList();
QueueContinuationToken continuationToken = null;
if (listQueuesResponse.NextMarker != null)
{
continuationToken = new QueueContinuationToken()
{
NextMarker = listQueuesResponse.NextMarker,
TargetLocation = cmd.CurrentResult.TargetLocation,
};
}
return new ResultSegment<CloudQueue>(queuesList)
{
ContinuationToken = continuationToken,
};
};
return getCmd;
}
public virtual async Task<QueueResultSegment> ListQueuesSegmentedAsync(string prefix, QueueListingDetails detailsIncluded, int? maxResults, QueueContinuationToken currentToken, QueueRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
QueueRequestOptions modifiedOptions = QueueRequestOptions.ApplyDefaults(options, this);
operationContext = operationContext ?? new OperationContext();
ResultSegment<CloudQueue> resultSegment = await Executor.ExecuteAsync(
this.ListQueuesImpl(prefix, maxResults, detailsIncluded, modifiedOptions, currentToken),
modifiedOptions.RetryPolicy,
operationContext,
cancellationToken).ConfigureAwait(false);
return new QueueResultSegment(resultSegment.Results, (QueueContinuationToken)resultSegment.ContinuationToken);
}
/// <summary>
/// Selects the peek message response.
/// </summary>
/// <param name="protocolMessage">The protocol message.</param>
/// <param name="options">A <see cref="QueueRequestOptions"/> object that specifies additional options for the request.</param>
/// <returns>The parsed message.</returns>
private CloudQueueMessage SelectPeekMessageResponse(QueueMessage protocolMessage, QueueRequestOptions options)
{
CloudQueueMessage message = null;
byte[] dest = null;
#if !(WINDOWS_RT || NETCORE)
if (options != null && options.EncryptionPolicy != null)
{
// If EncryptionPolicy is set, decrypt the message and set it.
dest = options.EncryptionPolicy.DecryptMessage(protocolMessage.Text, options.RequireEncryption);
}
#endif
if (this.EncodeMessage)
{
if (dest != null)
{
protocolMessage.Text = Convert.ToBase64String(dest, 0, dest.Length);
}
// if EncodeMessage is true, we assume the string returned from server is Base64 encoding of original message;
// if this is not true, exception will likely be thrown.
// it is user's responsibility to make sure EncodeMessage setting matches the queue that is being read.
message = new CloudQueueMessage(protocolMessage.Text, true);
}
else
{
#if !(WINDOWS_RT || NETCORE)
if (dest != null)
{
message = new CloudQueueMessage(dest);
}
else
#endif
{
message = new CloudQueueMessage(protocolMessage.Text);
}
}
message.Id = protocolMessage.Id;
message.InsertionTime = protocolMessage.InsertionTime;
message.ExpirationTime = protocolMessage.ExpirationTime;
message.DequeueCount = protocolMessage.DequeueCount;
// PopReceipt and TimeNextVisible are not returned during peek
return(message);
}
public virtual void SetServiceProperties(ServiceProperties properties, QueueRequestOptions requestOptions = null, OperationContext operationContext = null)
{
requestOptions = QueueRequestOptions.ApplyDefaults(requestOptions, this);
operationContext = operationContext ?? new OperationContext();
Executor.ExecuteSync(this.SetServicePropertiesImpl(properties, requestOptions), requestOptions.RetryPolicy, operationContext);
}
public virtual ICancellableAsyncResult BeginSetServiceProperties(ServiceProperties properties, QueueRequestOptions requestOptions, OperationContext operationContext, AsyncCallback callback, object state)
{
requestOptions = QueueRequestOptions.ApplyDefaults(requestOptions, this);
operationContext = operationContext ?? new OperationContext();
return(CancellableAsyncResultTaskWrapper.Create(token => this.SetServicePropertiesAsync(properties, requestOptions, operationContext), callback, state));
}
public virtual Task <ServiceProperties> GetServicePropertiesAsync(QueueRequestOptions requestOptions, OperationContext operationContext)
{
return(this.GetServicePropertiesAsync(requestOptions, operationContext, CancellationToken.None));
}
/// <summary>
/// Begins an asynchronous operation to return a result segment containing a collection of queues.
/// </summary>
/// <param name="prefix">A string containing the queue name prefix.</param>
/// <param name="queueListingDetails">A <see cref="QueueListingDetails"/> enumeration describing which items to include in the listing.</param>
/// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the
/// per-operation limit of 5000. If this value is <c>null</c>, the maximum possible number of results will be returned, up to 5000.</param>
/// <param name="currentToken">A <see cref="QueueContinuationToken"/> returned by a previous listing operation.</param>
/// <param name="options">A <see cref="QueueRequestOptions"/> object that specifies additional options for the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
/// <param name="callback">An <see cref="AsyncCallback"/> 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 virtual ICancellableAsyncResult BeginListQueuesSegmented(string prefix, QueueListingDetails queueListingDetails, int?maxResults, QueueContinuationToken currentToken, QueueRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state)
{
return(CancellableAsyncResultTaskWrapper.Create(token => this.ListQueuesSegmentedAsync(prefix, queueListingDetails, maxResults, currentToken, options, operationContext, token), callback, state));
}
/// <summary>
/// Returns a result segment containing a collection of queues.
/// </summary>
/// <param name="prefix">A string containing the queue name prefix.</param>
/// <param name="queueListingDetails">A <see cref="QueueListingDetails"/> enumeration describing which items to include in the listing.</param>
/// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the
/// per-operation limit of 5000. If this value is <c>null</c>, the maximum possible number of results will be returned, up to 5000.</param>
/// <param name="currentToken">A <see cref="QueueContinuationToken"/> returned by a previous listing operation.</param>
/// <param name="options">A <see cref="QueueRequestOptions"/> object that specifies additional options for the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
/// <returns>A <see cref="ResultSegment{T}"/> of type <see cref="CloudQueue"/>.</returns>
private ResultSegment <CloudQueue> ListQueuesSegmentedCore(string prefix, QueueListingDetails queueListingDetails, int?maxResults, QueueContinuationToken currentToken, QueueRequestOptions options, OperationContext operationContext)
{
return(Executor.ExecuteSync(
this.ListQueuesImpl(prefix, maxResults, queueListingDetails, options, currentToken),
options.RetryPolicy,
operationContext));
}
/// <summary>
/// Returns a result segment containing a collection of queues.
/// </summary>
/// <param name="prefix">A string containing the queue name prefix.</param>
/// <param name="queueListingDetails">A <see cref="QueueListingDetails"/> enumeration describing which items to include in the listing.</param>
/// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the
/// per-operation limit of 5000. If this value is <c>null</c>, the maximum possible number of results will be returned, up to 5000.</param>
/// <param name="currentToken">A <see cref="QueueContinuationToken"/> returned by a previous listing operation.</param>
/// <param name="options">A <see cref="QueueRequestOptions"/> object that specifies additional options for the request. If <c>null</c>, default options are applied to the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
/// <returns>A <see cref="QueueResultSegment"/> object.</returns>
public virtual QueueResultSegment ListQueuesSegmented(string prefix, QueueListingDetails queueListingDetails, int?maxResults, QueueContinuationToken currentToken, QueueRequestOptions options = null, OperationContext operationContext = null)
{
QueueRequestOptions modifiedOptions = QueueRequestOptions.ApplyDefaults(options, this);
operationContext = operationContext ?? new OperationContext();
ResultSegment <CloudQueue> resultSegment = this.ListQueuesSegmentedCore(prefix, queueListingDetails, maxResults, currentToken, modifiedOptions, operationContext);
return(new QueueResultSegment(resultSegment.Results, (QueueContinuationToken)resultSegment.ContinuationToken));
}
public void CloudQueueMessageEncryptionWithStrictMode()
{
// Create the Key to be used for wrapping.
SymmetricKey aesKey = new SymmetricKey("symencryptionkey");
// Create the resolver to be used for unwrapping.
DictionaryKeyResolver resolver = new DictionaryKeyResolver();
resolver.Add(aesKey);
CloudQueueClient client = GenerateCloudQueueClient();
string name = GenerateNewQueueName();
CloudQueue queue = client.GetQueueReference(name);
try
{
queue.CreateIfNotExists();
string messageStr = Guid.NewGuid().ToString();
CloudQueueMessage message = new CloudQueueMessage(messageStr);
QueueEncryptionPolicy policy = new QueueEncryptionPolicy(aesKey, null);
// Add message with policy.
QueueRequestOptions createOptions = new QueueRequestOptions()
{
EncryptionPolicy = policy
};
createOptions.RequireEncryption = true;
queue.AddMessage(message, null, null, createOptions, null);
// Set policy to null and add message while RequireEncryption flag is still set to true. This should throw.
createOptions.EncryptionPolicy = null;
TestHelper.ExpectedException <InvalidOperationException>(
() => queue.AddMessage(message, null, null, createOptions, null),
"Not specifying a policy when RequireEnryption is set to true should throw.");
// Retrieve message
QueueEncryptionPolicy retrPolicy = new QueueEncryptionPolicy(null, resolver);
QueueRequestOptions retrieveOptions = new QueueRequestOptions()
{
EncryptionPolicy = retrPolicy
};
retrieveOptions.RequireEncryption = true;
CloudQueueMessage retrMessage = queue.GetMessage(null, retrieveOptions, null);
// Update message with plain text.
string updatedMessage = Guid.NewGuid().ToString("N");
retrMessage.SetMessageContent(updatedMessage);
queue.UpdateMessage(retrMessage, TimeSpan.FromSeconds(0), MessageUpdateFields.Content | MessageUpdateFields.Visibility);
// Retrieve updated message with RequireEncryption flag but no metadata on the service. This should throw.
TestHelper.ExpectedException <StorageException>(
() => queue.GetMessage(null, retrieveOptions, null),
"Retrieving with RequireEncryption set to true and no metadata on the service should fail.");
// Set RequireEncryption to false and retrieve.
retrieveOptions.RequireEncryption = false;
queue.GetMessage(null, retrieveOptions, null);
}
finally
{
queue.DeleteIfExists();
}
}
public virtual Task<QueueResultSegment> ListQueuesSegmentedAsync(string prefix, QueueListingDetails detailsIncluded, int? maxResults, QueueContinuationToken currentToken, QueueRequestOptions options, OperationContext operationContext)
{
return this.ListQueuesSegmentedAsync(prefix, detailsIncluded, maxResults, currentToken, options, operationContext, CancellationToken.None);
}
/// <summary>
/// Selects the get message response.
/// </summary>
/// <param name="protocolMessage">The protocol message.</param>
/// <param name="options">A <see cref="QueueRequestOptions"/> object that specifies additional options for the request.</param>
/// <returns>The parsed message.</returns>
private CloudQueueMessage SelectGetMessageResponse(QueueMessage protocolMessage, QueueRequestOptions options = null)
{
CloudQueueMessage message = this.SelectPeekMessageResponse(protocolMessage, options);
message.PopReceipt = protocolMessage.PopReceipt;
if (protocolMessage.NextVisibleTime.HasValue)
{
message.NextVisibleTime = protocolMessage.NextVisibleTime.Value;
}
return(message);
}
public virtual ICancellableAsyncResult BeginGetServiceStats(QueueRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state)
{
return(CancellableAsyncResultTaskWrapper.Create(token => this.GetServiceStatsAsync(options, operationContext, token), callback, state));
}
/// <summary>
/// Gets the content of the message for transfer (internal use only).
/// </summary>
/// <param name="shouldEncodeMessage">Indicates if the message should be encoded.</param>
/// <param name="options">A <see cref="QueueRequestOptions"/> object that specifies additional options for the request.</param>
/// <returns>The message content as a string.</returns>
internal string GetMessageContentForTransfer(bool shouldEncodeMessage, QueueRequestOptions options = null)
{
if (!shouldEncodeMessage && this.MessageType != QueueMessageType.RawString)
{
throw new ArgumentException(SR.BinaryMessageShouldUseBase64Encoding);
}
string outgoingMessageString = null;
#if !(WINDOWS_RT || NETCORE)
if (options != null)
{
options.AssertPolicyIfRequired();
if (options.EncryptionPolicy != null)
{
// Create an encrypted message that will hold the message contents along with encryption related metadata and return it.
// The encrypted message is already Base 64 encoded. So no need to process further in this method.
string encryptedMessageString = options.EncryptionPolicy.EncryptMessage(this.AsBytes);
// the size of Base64 encoded string is the number of bytes this message will take up on server.
if (encryptedMessageString.Length > CloudQueueMessage.MaxMessageSize)
{
throw new ArgumentException(string.Format(
CultureInfo.InvariantCulture,
SR.EncryptedMessageTooLarge,
CloudQueueMessage.MaxMessageSize));
}
return(encryptedMessageString);
}
}
#endif
if (this.MessageType != QueueMessageType.Base64Encoded)
{
if (shouldEncodeMessage)
{
outgoingMessageString = Convert.ToBase64String(this.AsBytes);
// the size of Base64 encoded string is the number of bytes this message will take up on server.
if (outgoingMessageString.Length > CloudQueueMessage.MaxMessageSize)
{
throw new ArgumentException(string.Format(
CultureInfo.InvariantCulture,
SR.MessageTooLarge,
CloudQueueMessage.MaxMessageSize));
}
}
else
{
outgoingMessageString = this.RawString;
// we need to calculate the size of its UTF8 byte array, as that will be the storage usage on server.
if (Encoding.UTF8.GetBytes(outgoingMessageString).Length > CloudQueueMessage.MaxMessageSize)
{
throw new ArgumentException(string.Format(
CultureInfo.InvariantCulture,
SR.MessageTooLarge,
CloudQueueMessage.MaxMessageSize));
}
}
}
else
{
// at this point, this.EncodeMessage must be true
outgoingMessageString = this.RawString;
// the size of Base64 encoded string is the number of bytes this message will take up on server.
if (outgoingMessageString.Length > CloudQueueMessage.MaxMessageSize)
{
throw new ArgumentException(string.Format(
CultureInfo.InvariantCulture,
SR.MessageTooLarge,
CloudQueueMessage.MaxMessageSize));
}
}
return(outgoingMessageString);
}
/// <summary>
/// Returns an enumerable collection of the queues in the storage account whose names begin with the specified prefix and that are retrieved lazily.
/// </summary>
/// <param name="prefix">A string containing the queue name prefix.</param>
/// <param name="queueListingDetails">A <see cref="QueueListingDetails"/> enumeration value that indicates which details to include in the listing.</param>
/// <param name="options">A <see cref="QueueRequestOptions"/> object that specifies additional options for the request. If <c>null</c>, default options are applied to the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
/// <returns>An enumerable collection of objects of type <see cref="CloudQueue"/> that are retrieved lazily.</returns>
public virtual IEnumerable <CloudQueue> ListQueues(string prefix = null, QueueListingDetails queueListingDetails = QueueListingDetails.None, QueueRequestOptions options = null, OperationContext operationContext = null)
{
QueueRequestOptions modifiedOptions = QueueRequestOptions.ApplyDefaults(options, this);
operationContext = operationContext ?? new OperationContext();
return(CommonUtility.LazyEnumerable(
(token) => this.ListQueuesSegmentedCore(prefix, queueListingDetails, null, token as QueueContinuationToken, modifiedOptions, operationContext),
long.MaxValue));
}
