public void QueueSetACLCancellation()
{
CloudQueue queue = DefaultQueueClient.GetQueueReference(GenerateNewQueueName());
QueuePermissions permissions = new QueuePermissions();
permissions.SharedAccessPolicies.Add(Guid.NewGuid().ToString(), new SharedAccessQueuePolicy()
{
SharedAccessStartTime = DateTimeOffset.Now - TimeSpan.FromHours(1),
SharedAccessExpiryTime = DateTimeOffset.Now + TimeSpan.FromHours(1),
Permissions = SharedAccessQueuePermissions.Add | SharedAccessQueuePermissions.ProcessMessages | SharedAccessQueuePermissions.Read | SharedAccessQueuePermissions.Update
});
TestHelper.ExecuteAPMMethodWithCancellation(4000,
new[] { DelayBehaviors.DelayAllRequestsIf(4000 * 3, XStoreSelectors.QueueTraffic().IfHostNameContains(DefaultQueueClient.Credentials.AccountName)) },
(options, opContext, callback, state) => queue.BeginSetPermissions(permissions, (QueueRequestOptions)options, opContext, callback, state),
queue.EndSetPermissions);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
var storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString"));
var cloudTableClient = storageAccount.CreateCloudTableClient();
var table = cloudTableClient.GetTableReference("Photos");
table.CreateIfNotExists();
var cloudBlobClient = storageAccount.CreateCloudBlobClient();
var container = cloudBlobClient.GetContainerReference(CloudConfigurationManager.GetSetting("ContainerName"));
if (container.CreateIfNotExists())
{
container.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob });
}
var cloudQueueClient = storageAccount.CreateCloudQueueClient();
var queue = cloudQueueClient.GetQueueReference("messagequeue");
queue.CreateIfNotExists();
TablePermissions tp = new TablePermissions();
tp.SharedAccessPolicies.Add("readonly", new SharedAccessTablePolicy { Permissions = SharedAccessTablePermissions.Query, SharedAccessExpiryTime = System.DateTime.UtcNow.AddMinutes(15) });
tp.SharedAccessPolicies.Add("edit", new SharedAccessTablePolicy { Permissions = SharedAccessTablePermissions.Query | SharedAccessTablePermissions.Add | SharedAccessTablePermissions.Update, SharedAccessExpiryTime = System.DateTime.UtcNow.AddMinutes(15) });
tp.SharedAccessPolicies.Add("admin", new SharedAccessTablePolicy { Permissions = SharedAccessTablePermissions.Query | SharedAccessTablePermissions.Add | SharedAccessTablePermissions.Update | SharedAccessTablePermissions.Delete, SharedAccessExpiryTime = System.DateTime.UtcNow.AddMinutes(15) });
tp.SharedAccessPolicies.Add("none", new SharedAccessTablePolicy { Permissions = SharedAccessTablePermissions.None, SharedAccessExpiryTime = System.DateTime.UtcNow.AddMinutes(15) });
table.SetPermissions(tp);
BlobContainerPermissions bp = new BlobContainerPermissions();
bp.SharedAccessPolicies.Add("read", new SharedAccessBlobPolicy { Permissions = SharedAccessBlobPermissions.Read, SharedAccessExpiryTime = System.DateTime.UtcNow.AddMinutes(60) });
container.SetPermissions(bp);
QueuePermissions qp = new QueuePermissions();
qp.SharedAccessPolicies.Add("add", new SharedAccessQueuePolicy { Permissions = SharedAccessQueuePermissions.Add | SharedAccessQueuePermissions.Read, SharedAccessExpiryTime = System.DateTime.UtcNow.AddMinutes(15) });
qp.SharedAccessPolicies.Add("process", new SharedAccessQueuePolicy { Permissions = SharedAccessQueuePermissions.ProcessMessages | SharedAccessQueuePermissions.Read, SharedAccessExpiryTime = System.DateTime.UtcNow.AddMinutes(15) });
queue.SetPermissions(qp);
queue.Metadata.Add("Resize", "true");
queue.SetMetadata();
}
public Task SetPermissionsAsync(QueuePermissions permissions)
/// <summary>
/// Sets permissions for the queue.
/// </summary>
/// <param name="permissions">The permissions to apply to the queue.</param>
/// <returns>An <see cref="IAsyncAction"/> that represents an asynchronous action.</returns>
public IAsyncAction SetPermissionsAsync(QueuePermissions permissions)
{
return this.SetPermissionsAsync(permissions, null, null);
}
/// <summary>
/// Implementation for the SetPermissions method.
/// </summary>
/// <param name="acl">The permissions to set.</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> SetPermissionsImpl(QueuePermissions acl, QueueRequestOptions options)
{
MemoryStream memoryStream = new MemoryStream();
QueueRequest.WriteSharedAccessIdentifiers(acl.SharedAccessPolicies, memoryStream);
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, this.Uri);
options.ApplyToStorageCommand(putCmd);
putCmd.Handler = this.ServiceClient.AuthenticationHandler;
putCmd.BuildClient = HttpClientFactory.BuildHttpClient;
putCmd.BuildRequest = (cmd, cnt, ctx) => QueueHttpRequestMessageFactory.SetAcl(cmd.Uri, cmd.ServerTimeoutInSeconds, cnt, ctx);
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);
GetMessageCountAndMetadataFromResponse(resp);
return NullType.Value;
};
return putCmd;
}
/// <summary>
/// Begins an asynchronous request to set permissions for the queue.
/// </summary>
/// <param name="permissions">The permissions to apply to the queue.</param>
/// <param name="options">An <see cref="QueueRequestOptions"/> object that specifies any additional options for the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation. This object is used to track requests to the storage service, and to provide additional runtime information about the 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 BeginSetPermissions(QueuePermissions permissions, QueueRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state)
{
QueueRequestOptions modifiedOptions = QueueRequestOptions.ApplyDefaults(options, this.ServiceClient);
operationContext = operationContext ?? new OperationContext();
return Executor.BeginExecuteAsync(
this.SetPermissionsImpl(permissions, modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext,
callback,
state);
}
public async Task QueueSASTestAsync()
{
CloudQueueClient client = GenerateCloudQueueClient();
CloudQueue queue = client.GetQueueReference(GenerateNewQueueName());
await queue.CreateAsync();
string messageContent = Guid.NewGuid().ToString();
CloudQueueMessage message = new CloudQueueMessage(messageContent);
await queue.AddMessageAsync(message);
// Prepare SAS authentication with full permissions
string id = Guid.NewGuid().ToString();
DateTime start = DateTime.UtcNow;
DateTime expiry = start.AddMinutes(30);
QueuePermissions permissions = new QueuePermissions();
SharedAccessQueuePermissions queuePerm = SharedAccessQueuePermissions.Add | SharedAccessQueuePermissions.ProcessMessages | SharedAccessQueuePermissions.Read | SharedAccessQueuePermissions.Update;
permissions.SharedAccessPolicies.Add(id, new SharedAccessQueuePolicy()
{
SharedAccessStartTime = start,
SharedAccessExpiryTime = expiry,
Permissions = queuePerm
});
await queue.SetPermissionsAsync(permissions);
await Task.Delay(30 * 1000);
string sasTokenFromId = queue.GetSharedAccessSignature(null, id);
StorageCredentials sasCredsFromId = new StorageCredentials(sasTokenFromId);
CloudStorageAccount sasAcc = new CloudStorageAccount(sasCredsFromId, null /* blobEndpoint */, new Uri(TestBase.TargetTenantConfig.QueueServiceEndpoint), null /* tableEndpoint */, null /* fileEndpoint */);
CloudQueueClient sasClient = sasAcc.CreateCloudQueueClient();
CloudQueue sasQueueFromSasUri = new CloudQueue(sasClient.Credentials.TransformUri(queue.Uri));
CloudQueueMessage receivedMessage = await sasQueueFromSasUri.PeekMessageAsync();
Assert.AreEqual(messageContent, receivedMessage.AsString);
CloudQueue sasQueueFromSasUri1 = new CloudQueue(new Uri(queue.Uri.ToString() + sasTokenFromId));
CloudQueueMessage receivedMessage1 = await sasQueueFromSasUri1.PeekMessageAsync();
Assert.AreEqual(messageContent, receivedMessage1.AsString);
CloudQueue sasQueueFromId = new CloudQueue(queue.Uri, sasCredsFromId);
CloudQueueMessage receivedMessage2 = await sasQueueFromId.PeekMessageAsync();
Assert.AreEqual(messageContent, receivedMessage2.AsString);
string sasTokenFromPolicy = queue.GetSharedAccessSignature(permissions.SharedAccessPolicies[id], null);
StorageCredentials sasCredsFromPolicy = new StorageCredentials(sasTokenFromPolicy);
CloudQueue sasQueueFromPolicy = new CloudQueue(queue.Uri, sasCredsFromPolicy);
CloudQueueMessage receivedMessage3 = await sasQueueFromPolicy.PeekMessageAsync();
Assert.AreEqual(messageContent, receivedMessage3.AsString);
await queue.DeleteAsync();
}
/// <summary>
/// Implementation for the SetPermissions method.
/// </summary>
/// <param name="acl">The permissions to set.</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> SetPermissionsImpl(QueuePermissions acl, QueueRequestOptions options)
{
MemoryStream memoryStream = new MemoryStream();
QueueRequest.WriteSharedAccessIdentifiers(acl.SharedAccessPolicies, memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, this.Uri);
options.ApplyToStorageCommand(putCmd);
putCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => QueueHttpWebRequestFactory.SetAcl(uri, serverTimeout, ctx);
putCmd.SendStream = memoryStream;
putCmd.RecoveryAction = RecoveryActions.RewindStream;
putCmd.SignRequest = this.ServiceClient.AuthenticationHandler.SignRequest;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.NoContent, resp, NullType.Value, cmd, ex, ctx);
return NullType.Value;
};
return putCmd;
}
/// <summary>
/// Sets permissions for the queue.
/// </summary>
/// <param name="permissions">The permissions to apply to the queue.</param>
/// <param name="options">An <see cref="QueueRequestOptions"/> object that specifies any additional options for the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation. This object is used to track requests to the storage service, and to provide additional runtime information about the operation.</param>
public void SetPermissions(QueuePermissions permissions, QueueRequestOptions options = null, OperationContext operationContext = null)
{
QueueRequestOptions modifiedOptions = QueueRequestOptions.ApplyDefaults(options, this.ServiceClient);
operationContext = operationContext ?? new OperationContext();
Executor.ExecuteSync(
this.SetPermissionsImpl(permissions, modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext);
}
/// <summary>
/// Manage stored access policies specified on the queue
/// </summary>
/// <param name="cloudQueueClient"></param>
/// <returns></returns>
private static async Task QueueAclSample(CloudQueueClient cloudQueueClient)
{
// Create the queue name -- use a guid in the name so it's unique.
string queueName = "demotest-" + Guid.NewGuid();
// Create the queue with this name.
Console.WriteLine("Creating queue with name {0}", queueName);
CloudQueue queue = cloudQueueClient.GetQueueReference(queueName);
try
{
await queue.CreateIfNotExistsAsync();
Console.WriteLine(" Queue created successfully.");
}
catch (StorageException exStorage)
{
Common.WriteException(exStorage);
Console.WriteLine(
"Please make sure your storage account is specified correctly in the app.config - then restart the sample.");
Console.WriteLine("Press any key to exit");
Console.ReadLine();
throw;
}
catch (Exception ex)
{
Console.WriteLine(" Exception thrown creating queue.");
Common.WriteException(ex);
throw;
}
// Set queue permissions
SharedAccessQueuePolicy accessQueuePolicy = new SharedAccessQueuePolicy();
accessQueuePolicy.SharedAccessStartTime = new DateTimeOffset(DateTime.Now);
accessQueuePolicy.SharedAccessExpiryTime = new DateTimeOffset(DateTime.Now.AddMinutes(10));
accessQueuePolicy.Permissions = SharedAccessQueuePermissions.Update;
QueuePermissions permissions = new QueuePermissions();
permissions.SharedAccessPolicies.Add("key1", accessQueuePolicy);
Console.WriteLine("Set queue permissions");
await queue.SetPermissionsAsync(permissions);
// Get queue permissions
Console.WriteLine("Get queue permissions:");
permissions = await queue.GetPermissionsAsync();
foreach (var keyValue in permissions.SharedAccessPolicies)
{
Console.WriteLine(" {0}:", keyValue.Key);
Console.WriteLine(" permissions: {0}:", keyValue.Value.Permissions);
Console.WriteLine(" start time: {0}:", keyValue.Value.SharedAccessStartTime);
Console.WriteLine(" expiry time: {0}:", keyValue.Value.SharedAccessExpiryTime);
}
// Delete queue
Console.WriteLine("Deleting queue with name {0}", queueName);
queue.DeleteIfExists();
}
public void CloudQueueGetSetPermissions()
{
CloudQueue queue = DefaultQueueClient.GetQueueReference(GenerateNewQueueName());
try
{
queue.Create();
QueuePermissions emptyPermission = queue.GetPermissions();
Assert.AreEqual(emptyPermission.SharedAccessPolicies.Count, 0);
string id = Guid.NewGuid().ToString();
DateTime start = DateTime.UtcNow;
DateTime expiry = start.AddMinutes(30);
QueuePermissions permissions = new QueuePermissions();
SharedAccessQueuePermissions queuePerm = SharedAccessQueuePermissions.Add|SharedAccessQueuePermissions.ProcessMessages|SharedAccessQueuePermissions.Read|SharedAccessQueuePermissions.Update;
permissions.SharedAccessPolicies.Add(id, new SharedAccessQueuePolicy()
{
SharedAccessStartTime = start,
SharedAccessExpiryTime = expiry,
Permissions = queuePerm
});
queue.SetPermissions(permissions);
Thread.Sleep(30 * 1000);
CloudQueue queueToRetrieve = DefaultQueueClient.GetQueueReference(queue.Name);
QueuePermissions permissionsToRetrieve = queueToRetrieve.GetPermissions();
Assert.AreEqual(permissions.SharedAccessPolicies.Count, permissionsToRetrieve.SharedAccessPolicies.Count);
//Assert.AreEqual(start, permissionsToRetrieve.SharedAccessPolicies[id].SharedAccessStartTime.Value.UtcDateTime);
//Assert.AreEqual(expiry, permissionsToRetrieve.SharedAccessPolicies[id].SharedAccessExpiryTime.Value.UtcDateTime);
Assert.AreEqual(permissions.SharedAccessPolicies[id].Permissions, permissionsToRetrieve.SharedAccessPolicies[id].Permissions);
}
finally
{
queue.DeleteIfExists();
}
}
/// <summary>
/// Reads the share access policies from a stream in XML.
/// </summary>
/// <param name="inputStream">The stream of XML policies.</param>
/// <param name="permissions">The permissions object to which the policies are to be written.</param>
public static void ReadSharedAccessIdentifiers(Stream inputStream, QueuePermissions permissions)
{
CommonUtility.AssertNotNull("permissions", permissions);
Response.ReadSharedAccessIdentifiers(permissions.SharedAccessPolicies, new QueueAccessPolicyResponse(inputStream));
}
/// <summary>
/// Reads the share access policies from a stream in XML.
/// </summary>
/// <param name="inputStream">The stream of XML policies.</param>
/// <param name="permissions">The permissions object to which the policies are to be written.</param>
public static void ReadSharedAccessIdentifiers(Stream inputStream, QueuePermissions permissions)
{
CommonUtility.AssertNotNull("permissions", permissions);
Response.ReadSharedAccessIdentifiers(permissions.SharedAccessPolicies, new QueueAccessPolicyResponse(inputStream));
}
public virtual Task SetPermissionsAsync(QueuePermissions permissions, QueueRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return AsyncExtensions.TaskFromVoidApm(this.BeginSetPermissions, this.EndSetPermissions, permissions, options, operationContext, cancellationToken);
}
public virtual Task SetPermissionsAsync(QueuePermissions permissions, CancellationToken cancellationToken)
{
return AsyncExtensions.TaskFromVoidApm(this.BeginSetPermissions, this.EndSetPermissions, permissions, cancellationToken);
}
public virtual Task SetPermissionsAsync(QueuePermissions permissions)
{
return this.SetPermissionsAsync(permissions, CancellationToken.None);
}
public static void ReadSharedAccessIdentifiers(Stream inputStream, QueuePermissions permissions)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Reads the share access policies from a stream in XML.
/// </summary>
/// <param name="inputStream">The stream of XML policies.</param>
/// <param name="permissions">The permissions object to which the policies are to be written.</param>
public static Task ReadSharedAccessIdentifiersAsync(Stream inputStream, QueuePermissions permissions, CancellationToken token)
{
CommonUtility.AssertNotNull("permissions", permissions);
return(Response.ReadSharedAccessIdentifiersAsync(permissions.SharedAccessPolicies, new QueueAccessPolicyResponse(inputStream), token));
}
public IAsyncAction SetPermissionsAsync(QueuePermissions permissions)
{
return this.SetPermissionsAsync(permissions, null /* options */, null /* operationContext */);
}
internal static void AssertPermissionsEqual(QueuePermissions permissions1, QueuePermissions permissions2)
{
Assert.AreEqual(permissions1.SharedAccessPolicies.Count, permissions2.SharedAccessPolicies.Count);
foreach (KeyValuePair<string, SharedAccessQueuePolicy> pair in permissions1.SharedAccessPolicies)
{
SharedAccessQueuePolicy policy1 = pair.Value;
SharedAccessQueuePolicy policy2 = permissions2.SharedAccessPolicies[pair.Key];
Assert.IsNotNull(policy1);
Assert.IsNotNull(policy2);
Assert.AreEqual(policy1.Permissions, policy2.Permissions);
if (policy1.SharedAccessStartTime != null)
{
Assert.IsTrue(Math.Floor((policy1.SharedAccessStartTime.Value - policy2.SharedAccessStartTime.Value).TotalSeconds) == 0);
}
if (policy1.SharedAccessExpiryTime != null)
{
Assert.IsTrue(Math.Floor((policy1.SharedAccessExpiryTime.Value - policy2.SharedAccessExpiryTime.Value).TotalSeconds) == 0);
}
}
}
public void QueueSASTest()
{
CloudQueue queue = DefaultQueueClient.GetQueueReference(GenerateNewQueueName());
try
{
queue.Create();
string messageContent = Guid.NewGuid().ToString();
CloudQueueMessage message = new CloudQueueMessage(messageContent);
queue.AddMessage(message);
// Prepare SAS authentication with full permissions
string id = Guid.NewGuid().ToString();
DateTime start = DateTime.UtcNow;
DateTime expiry = start.AddMinutes(30);
QueuePermissions permissions = new QueuePermissions();
SharedAccessQueuePermissions queuePerm = SharedAccessQueuePermissions.Add | SharedAccessQueuePermissions.ProcessMessages | SharedAccessQueuePermissions.Read | SharedAccessQueuePermissions.Update;
permissions.SharedAccessPolicies.Add(id, new SharedAccessQueuePolicy()
{
SharedAccessStartTime = start,
SharedAccessExpiryTime = expiry,
Permissions = queuePerm
});
queue.SetPermissions(permissions);
Thread.Sleep(30 * 1000);
string sasTokenFromId = queue.GetSharedAccessSignature(null, id);
StorageCredentials sasCredsFromId = new StorageCredentials(sasTokenFromId);
CloudQueue sasQueueFromId = new CloudQueue(queue.Uri, sasCredsFromId);
CloudQueueMessage receivedMessage1 = sasQueueFromId.PeekMessage();
Assert.AreEqual(messageContent, receivedMessage1.AsString);
string sasTokenFromPolicy = queue.GetSharedAccessSignature(permissions.SharedAccessPolicies[id], null);
StorageCredentials sasCredsFromPolicy = new StorageCredentials(sasTokenFromPolicy);
CloudQueue sasQueueFromPolicy = new CloudQueue(queue.Uri, sasCredsFromPolicy);
CloudQueueMessage receivedMessage2 = sasQueueFromPolicy.PeekMessage();
Assert.AreEqual(messageContent, receivedMessage2.AsString);
}
finally
{
queue.DeleteIfExists();
}
}
public void CloudQueueGetSetPermissionsAPM()
{
CloudQueueClient client = GenerateCloudQueueClient();
CloudQueue queue = client.GetQueueReference(GenerateNewQueueName());
try
{
queue.Create();
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result = queue.BeginGetPermissions(ar => waitHandle.Set(), null);
waitHandle.WaitOne();
QueuePermissions emptyPermission = queue.EndGetPermissions(result);
Assert.AreEqual(emptyPermission.SharedAccessPolicies.Count, 0);
string id = Guid.NewGuid().ToString();
DateTime start = DateTime.UtcNow;
DateTime expiry = start.AddMinutes(30);
QueuePermissions permissions = new QueuePermissions();
SharedAccessQueuePermissions queuePerm = SharedAccessQueuePermissions.Add | SharedAccessQueuePermissions.ProcessMessages | SharedAccessQueuePermissions.Read | SharedAccessQueuePermissions.Update;
permissions.SharedAccessPolicies.Add(id, new SharedAccessQueuePolicy()
{
SharedAccessStartTime = start,
SharedAccessExpiryTime = expiry,
Permissions = queuePerm
});
result = queue.BeginSetPermissions(permissions, ar => waitHandle.Set(), null);
waitHandle.WaitOne();
queue.EndSetPermissions(result);
Thread.Sleep(30 * 1000);
CloudQueue queueToRetrieve = client.GetQueueReference(queue.Name);
result = queueToRetrieve.BeginGetPermissions(ar => waitHandle.Set(), null);
waitHandle.WaitOne();
QueuePermissions permissionsToRetrieve = queueToRetrieve.EndGetPermissions(result);
AssertPermissionsEqual(permissions, permissionsToRetrieve);
}
}
finally
{
queue.DeleteIfExists();
}
}
/// <summary>
/// Implementation for the GetPermissions method.
/// </summary>
/// <param name="options">An <see cref="QueueRequestOptions"/> object that specifies any additional options for the request.</param>
/// <returns>A <see cref="RESTCommand{T}"/> that gets the permissions.</returns>
private RESTCommand<QueuePermissions> GetPermissionsImpl(QueueRequestOptions options)
{
RESTCommand<QueuePermissions> getCmd = new RESTCommand<QueuePermissions>(this.ServiceClient.Credentials, this.Uri);
options.ApplyToStorageCommand(getCmd);
getCmd.RetrieveResponseStream = true;
getCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => QueueHttpWebRequestFactory.GetAcl(uri, serverTimeout, ctx);
getCmd.SignRequest = this.ServiceClient.AuthenticationHandler.SignRequest;
getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex, ctx);
getCmd.PostProcessResponse = (cmd, resp, ex, ctx) =>
{
QueuePermissions queueAcl = new QueuePermissions();
QueueHttpResponseParsers.ReadSharedAccessIdentifiers(cmd.ResponseStream, queueAcl);
return queueAcl;
};
return getCmd;
}
/// <summary>
/// Implementation for the SetPermissions method.
/// </summary>
/// <param name="acl">The permissions to set.</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> SetPermissionsImpl(QueuePermissions acl, QueueRequestOptions options)
{
MultiBufferMemoryStream memoryStream = new MultiBufferMemoryStream(null /* bufferManager */, (int)(1 * Constants.KB));
QueueRequest.WriteSharedAccessIdentifiers(acl.SharedAccessPolicies, memoryStream);
RESTCommand<NullType> putCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, this.StorageUri);
options.ApplyToStorageCommand(putCmd);
putCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) => QueueHttpRequestMessageFactory.SetAcl(uri, serverTimeout, cnt, ctx, this.ServiceClient.GetCanonicalizer(), this.ServiceClient.Credentials);
putCmd.BuildContent = (cmd, ctx) => HttpContentFactory.BuildContentFromStream(memoryStream, 0, memoryStream.Length, null /* md5 */, cmd, ctx);
putCmd.StreamToDispose = memoryStream;
putCmd.PreProcessResponse = (cmd, resp, ex, ctx) =>
{
HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.NoContent, resp, NullType.Value, cmd, ex);
GetMessageCountAndMetadataFromResponse(resp);
return NullType.Value;
};
return putCmd;
}
/// <summary>
/// Begins an asynchronous request to set permissions for the queue.
/// </summary>
/// <param name="permissions">The permissions to apply to the queue.</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 BeginSetPermissions(QueuePermissions permissions, AsyncCallback callback, object state)
{
return this.BeginSetPermissions(permissions, null, null, callback, state);
}
/// <summary>
/// Implementation for the GetPermissions method.
/// </summary>
/// <param name="options">A <see cref="QueueRequestOptions"/> object that specifies additional options for the request.</param>
/// <returns>A <see cref="RESTCommand"/> that gets the permissions.</returns>
private RESTCommand<QueuePermissions> GetPermissionsImpl(QueueRequestOptions options)
{
RESTCommand<QueuePermissions> getCmd = new RESTCommand<QueuePermissions>(this.ServiceClient.Credentials, this.StorageUri);
options.ApplyToStorageCommand(getCmd);
getCmd.CommandLocationMode = CommandLocationMode.PrimaryOrSecondary;
getCmd.RetrieveResponseStream = true;
getCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) => QueueHttpRequestMessageFactory.GetAcl(uri, serverTimeout, cnt, ctx, this.ServiceClient.GetCanonicalizer(), this.ServiceClient.Credentials);
getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex);
getCmd.PostProcessResponse = (cmd, resp, ctx) =>
{
this.GetMessageCountAndMetadataFromResponse(resp);
return Task<QueuePermissions>.Factory.StartNew(() =>
{
QueuePermissions queueAcl = new QueuePermissions();
QueueHttpResponseParsers.ReadSharedAccessIdentifiers(cmd.ResponseStream, queueAcl);
return queueAcl;
});
};
return getCmd;
}
public async Task CloudQueueGetSetPermissionsAsync()
{
CloudQueueClient client = GenerateCloudQueueClient();
CloudQueue queue = client.GetQueueReference(GenerateNewQueueName());
await queue.CreateAsync();
QueuePermissions emptyPermission = await queue.GetPermissionsAsync();
Assert.AreEqual(emptyPermission.SharedAccessPolicies.Count, 0);
string id = Guid.NewGuid().ToString();
DateTime start = DateTime.UtcNow;
DateTime expiry = start.AddMinutes(30);
QueuePermissions permissions = new QueuePermissions();
SharedAccessQueuePermissions queuePerm = SharedAccessQueuePermissions.Add | SharedAccessQueuePermissions.ProcessMessages | SharedAccessQueuePermissions.Read | SharedAccessQueuePermissions.Update;
permissions.SharedAccessPolicies.Add(id, new SharedAccessQueuePolicy()
{
SharedAccessStartTime = start,
SharedAccessExpiryTime = expiry,
Permissions = queuePerm
});
await queue.SetPermissionsAsync(permissions);
await Task.Delay(30 * 1000);
await queue.FetchAttributesAsync();
CloudQueue queueToRetrieve = client.GetQueueReference(queue.Name);
QueuePermissions permissionsToRetrieve = await queueToRetrieve.GetPermissionsAsync();
Assert.AreEqual(permissions.SharedAccessPolicies.Count, permissionsToRetrieve.SharedAccessPolicies.Count);
//Assert.AreEqual(start, permissionsToRetrieve.SharedAccessPolicies[id].SharedAccessStartTime.Value.UtcDateTime);
//Assert.AreEqual(expiry, permissionsToRetrieve.SharedAccessPolicies[id].SharedAccessExpiryTime.Value.UtcDateTime);
Assert.AreEqual(permissions.SharedAccessPolicies[id].Permissions, permissionsToRetrieve.SharedAccessPolicies[id].Permissions);
await queue.DeleteAsync();
}
public virtual Task SetPermissionsAsync(QueuePermissions permissions)
{
return this.SetPermissionsAsync(permissions, null /* options */, null /* operationContext */);
}
public async Task QueueRegionalSASTestAsync()
{
#if ASPNET_K
//CultureInfo currentCulture = CultureInfo.CurrentCulture;
//CultureInfo.CurrentCulture = new CultureInfo("it");
#else
string currentPrimaryLanguage = ApplicationLanguages.PrimaryLanguageOverride;
ApplicationLanguages.PrimaryLanguageOverride = "it";
#endif
CloudQueueClient client = GenerateCloudQueueClient();
CloudQueue queue = client.GetQueueReference(GenerateNewQueueName());
try
{
await queue.CreateAsync();
string messageContent = Guid.NewGuid().ToString();
CloudQueueMessage message = new CloudQueueMessage(messageContent);
await queue.AddMessageAsync(message);
// Prepare SAS authentication with full permissions
string id = Guid.NewGuid().ToString();
DateTime start = DateTime.UtcNow;
DateTime expiry = start.AddMinutes(30);
QueuePermissions permissions = new QueuePermissions();
SharedAccessQueuePermissions queuePerm = SharedAccessQueuePermissions.Add | SharedAccessQueuePermissions.ProcessMessages | SharedAccessQueuePermissions.Read | SharedAccessQueuePermissions.Update;
permissions.SharedAccessPolicies.Add(id, new SharedAccessQueuePolicy()
{
SharedAccessStartTime = start,
SharedAccessExpiryTime = expiry,
Permissions = queuePerm
});
await queue.SetPermissionsAsync(permissions);
await Task.Delay(30 * 1000);
string sasTokenFromId = queue.GetSharedAccessSignature(null, id);
StorageCredentials sasCredsFromId = new StorageCredentials(sasTokenFromId);
CloudQueue sasQueueFromId = new CloudQueue(queue.Uri, sasCredsFromId);
CloudQueueMessage receivedMessage1 = await sasQueueFromId.PeekMessageAsync();
Assert.AreEqual(messageContent, receivedMessage1.AsString);
string sasTokenFromPolicy = queue.GetSharedAccessSignature(permissions.SharedAccessPolicies[id], null);
StorageCredentials sasCredsFromPolicy = new StorageCredentials(sasTokenFromPolicy);
CloudQueue sasQueueFromPolicy = new CloudQueue(queue.Uri, sasCredsFromPolicy);
CloudQueueMessage receivedMessage2 = await sasQueueFromPolicy.PeekMessageAsync();
Assert.AreEqual(messageContent, receivedMessage2.AsString);
}
finally
{
#if ASPNET_K
//CultureInfo.CurrentCulture = currentCulture;
#else
ApplicationLanguages.PrimaryLanguageOverride = currentPrimaryLanguage;
#endif
queue.DeleteAsync().AsTask().Wait();
}
}
public virtual Task SetPermissionsAsync(QueuePermissions permissions, QueueRequestOptions options, OperationContext operationContext)
{
return this.SetPermissionsAsync(permissions, options, operationContext, CancellationToken.None);
}
/// <summary>
/// Sets permissions for the queue.
/// </summary>
/// <param name="permissions">The permissions to apply to the queue.</param>
/// <param name="options">A <see cref="QueueRequestOptions"/> object that specifies any additional options for the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
/// <returns>An <see cref="IAsyncAction"/> that represents an asynchronous action.</returns>
public IAsyncAction SetPermissionsAsync(QueuePermissions permissions, QueueRequestOptions options, OperationContext operationContext)
{
QueueRequestOptions modifiedOptions = QueueRequestOptions.ApplyDefaults(options, this.ServiceClient);
operationContext = operationContext ?? new OperationContext();
return AsyncInfo.Run(async (token) => await Executor.ExecuteAsyncNullReturn(
this.SetPermissionsImpl(permissions, modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext,
token));
}
public virtual Task SetPermissionsAsync(QueuePermissions permissions, 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.SetPermissionsImpl(permissions, modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext,
cancellationToken), cancellationToken);
}
/// <summary>
/// Implementation for the GetPermissions method.
/// </summary>
/// <param name="options">A <see cref="QueueRequestOptions"/> object that specifies any additional options for the request.</param>
/// <returns>A <see cref="RESTCommand"/> that gets the permissions.</returns>
private RESTCommand<QueuePermissions> GetPermissionsImpl(QueueRequestOptions options)
{
RESTCommand<QueuePermissions> getCmd = new RESTCommand<QueuePermissions>(this.ServiceClient.Credentials, this.Uri);
options.ApplyToStorageCommand(getCmd);
getCmd.Handler = this.ServiceClient.AuthenticationHandler;
getCmd.BuildClient = HttpClientFactory.BuildHttpClient;
getCmd.RetrieveResponseStream = true;
getCmd.BuildRequest = (cmd, cnt, ctx) => QueueHttpRequestMessageFactory.GetAcl(cmd.Uri, cmd.ServerTimeoutInSeconds, cnt, ctx);
getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex, ctx);
getCmd.PostProcessResponse = (cmd, resp, ex, ctx) =>
{
this.GetMessageCountAndMetadataFromResponse(resp);
return Task<QueuePermissions>.Factory.StartNew(() =>
{
QueuePermissions queueAcl = new QueuePermissions();
QueueHttpResponseParsers.ReadSharedAccessIdentifiers(cmd.ResponseStream, queueAcl);
return queueAcl;
});
};
return getCmd;
}
/// <summary>
/// Reads the share access policies from a stream in XML.
/// </summary>
/// <param name="inputStream">The stream of XML policies.</param>
/// <param name="permissions">The permissions object to which the policies are to be written.</param>
public static void ReadSharedAccessIdentifiers(Stream inputStream, QueuePermissions permissions)
{
Response.ReadSharedAccessIdentifiers(permissions.SharedAccessPolicies, new QueueAccessPolicyResponse(inputStream));
}
