protected void SetContainerPermission(CloudBlobContainer container, BlobContainerPublicAccessType perimssion)
{
container.SetPermissionsAsync(new BlobContainerPermissions
{
PublicAccess = perimssion
});
}
public async Task CloudBlobClientListContainersWithPublicAccessAsync()
{
string name = GetRandomContainerName();
CloudBlobClient blobClient = GenerateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference(name);
try
{
await container.CreateAsync();
BlobContainerPublicAccessType[] accessValues = { BlobContainerPublicAccessType.Container, BlobContainerPublicAccessType.Off, BlobContainerPublicAccessType.Blob };
BlobContainerPermissions permissions = new BlobContainerPermissions();
foreach (BlobContainerPublicAccessType access in accessValues)
{
permissions.PublicAccess = access;
await container.SetPermissionsAsync(permissions);
Assert.AreEqual(access, container.Properties.PublicAccess);
CloudBlobContainer container2 = blobClient.GetContainerReference(name);
Assert.IsFalse(container2.Properties.PublicAccess.HasValue);
await container2.FetchAttributesAsync();
Assert.AreEqual(access, container2.Properties.PublicAccess);
CloudBlobContainer container3 = blobClient.GetContainerReference(name);
BlobContainerPermissions containerAccess = await container3.GetPermissionsAsync();
Assert.AreEqual(access, containerAccess.PublicAccess);
Assert.AreEqual(access, container3.Properties.PublicAccess);
List <CloudBlobContainer> listedContainers = new List <CloudBlobContainer>();
BlobContinuationToken token = null;
do
{
ContainerResultSegment resultSegment = await blobClient.ListContainersSegmentedAsync(name, token);
foreach (CloudBlobContainer returnedContainer in resultSegment.Results)
{
listedContainers.Add(returnedContainer);
}
token = resultSegment.ContinuationToken;
}while (token != null);
Assert.AreEqual(1, listedContainers.Count());
Assert.AreEqual(access, listedContainers.First().Properties.PublicAccess);
}
}
finally
{
container.DeleteAsync().GetAwaiter().GetResult();
}
}
/// <summary>
/// Creates a private container with the given name
/// </summary>
/// <param name="containerName"></param>
/// <returns></returns>
public async Task<bool> CreateContainerAsync(string containerName, bool isPublic)
{
// Create the container if it doesn't exist.
blobContainer = blobClient.GetContainerReference(containerName);
if (isPublic)
{
var returnData = await blobContainer.CreateIfNotExistsAsync();
if (returnData)
await blobContainer.SetPermissionsAsync(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob });
return returnData;
}
return await blobContainer.CreateIfNotExistsAsync();
}
public void Sync(CloudBlobContainer container, string localPath)
{
Console.WriteLine("Syncing localPath: '{0}', to container: '{1}'.", localPath, container.Uri);
container.CreateIfNotExists();
container.SetPermissionsAsync(new BlobContainerPermissions {
PublicAccess = BlobContainerPublicAccessType.Blob
});
SyncLocalDirToBlob(localPath, container);
Console.WriteLine(
@"Total new: {0}, updated: {1}, deleted {2}."
, _new.Count
, _changed.Count
, _deleted.Count
);
}
public async Task CloudBlobContainerSetPermissionsAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
BlobContainerPermissions permissions = await container.GetPermissionsAsync();
Assert.AreEqual(BlobContainerPublicAccessType.Off, permissions.PublicAccess);
Assert.AreEqual(0, permissions.SharedAccessPolicies.Count);
// We do not have precision at milliseconds level. Hence, we need
// to recreate the start DateTime to be able to compare it later.
DateTime start = DateTime.UtcNow;
start = new DateTime(start.Year, start.Month, start.Day, start.Hour, start.Minute, start.Second, DateTimeKind.Utc);
DateTime expiry = start.AddMinutes(30);
permissions.PublicAccess = BlobContainerPublicAccessType.Container;
permissions.SharedAccessPolicies.Add("key1", new SharedAccessBlobPolicy()
{
SharedAccessStartTime = start,
SharedAccessExpiryTime = expiry,
Permissions = SharedAccessBlobPermissions.List,
});
await container.SetPermissionsAsync(permissions);
await Task.Delay(30 * 1000);
CloudBlobContainer container2 = container.ServiceClient.GetContainerReference(container.Name);
permissions = await container2.GetPermissionsAsync();
Assert.AreEqual(BlobContainerPublicAccessType.Container, permissions.PublicAccess);
Assert.AreEqual(1, permissions.SharedAccessPolicies.Count);
Assert.IsTrue(permissions.SharedAccessPolicies["key1"].SharedAccessStartTime.HasValue);
Assert.AreEqual(start, permissions.SharedAccessPolicies["key1"].SharedAccessStartTime.Value.UtcDateTime);
Assert.IsTrue(permissions.SharedAccessPolicies["key1"].SharedAccessExpiryTime.HasValue);
Assert.AreEqual(expiry, permissions.SharedAccessPolicies["key1"].SharedAccessExpiryTime.Value.UtcDateTime);
Assert.AreEqual(SharedAccessBlobPermissions.List, permissions.SharedAccessPolicies["key1"].Permissions);
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
/// <summary>
/// Return a task that asynchronously set the container permission
/// </summary>
/// <param name="container">CloudBlobContainer object</param>
/// <param name="permissions">Container permission</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="requestOptions">Blob request option</param>
/// <param name="operationContext">Operation context</param>
/// <param name="cmdletCancellationToken">cancellation token</param>
/// <returns>Return a task that asynchronously set the container permission</returns>
public Task SetContainerPermissionsAsync(CloudBlobContainer container, BlobContainerPermissions permissions, AccessCondition accessCondition, BlobRequestOptions requestOptions, OperationContext operationContext, CancellationToken cancellationToken)
{
return container.SetPermissionsAsync(permissions, accessCondition, requestOptions, operationContext, cancellationToken);
}
private async Task <(bool, string)> UploadToBlob(string filename, byte[] imageBuffer = null, Stream stream = null)
{
Microsoft.WindowsAzure.Storage.CloudStorageAccount storageAccount = null;
Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer cloudBlobContainer = null;
string storageConnectionString = _configuration["storageconnectionstring"];
// Check whether the connection string can be parsed.
if (Microsoft.WindowsAzure.Storage.CloudStorageAccount.TryParse(storageConnectionString, out storageAccount))
{
try
{
// Create the CloudBlobClient that represents the Blob storage endpoint for the storage account.
Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient cloudBlobClient = storageAccount.CreateCloudBlobClient();
// Create a container called 'uploadblob' and append a GUID value to it to make the name unique.
cloudBlobContainer = cloudBlobClient.GetContainerReference("womeninworkforce");// ("uploadblob" + Guid.NewGuid().ToString());
await cloudBlobContainer.CreateIfNotExistsAsync();
// Set the permissions so the blobs are public.
BlobContainerPermissions permissions = new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
};
await cloudBlobContainer.SetPermissionsAsync(permissions);
// Get a reference to the blob address, then upload the file to the blob.
CloudBlockBlob cloudBlockBlob = cloudBlobContainer.GetBlockBlobReference(filename);
List <Task> tasks = new List <Task>();
int count = 0;
if (imageBuffer != null)
{
// OPTION A: use imageBuffer (converted from memory stream)
await cloudBlockBlob.UploadFromByteArrayAsync(imageBuffer, 0, imageBuffer.Length);
//tasks.Add(cloudBlockBlob.UploadFromByteArrayAsync(imageBuffer, 0, options, null).ContinueWith((t) =>
//{
// sem.Release();
// Interlocked.Increment(ref completed_count);
//}));
//count++;
}
else if (stream != null)
{
// OPTION B: pass in memory stream directly
await cloudBlockBlob.UploadFromStreamAsync(stream);
}
else
{
return(false, null);
}
return(true, cloudBlockBlob.SnapshotQualifiedStorageUri.PrimaryUri.ToString());
}
catch (Microsoft.WindowsAzure.Storage.StorageException ex)
{
return(false, null);
}
finally
{
// OPTIONAL: Clean up resources, e.g. blob container
//if (cloudBlobContainer != null)
//{
// await cloudBlobContainer.DeleteIfExistsAsync();
//}
}
}
else
{
return(false, null);
}
}
/// <summary>
/// Creates a shared access policy on the container.
/// </summary>
/// <param name="container">A CloudBlobContainer object.</param>
/// <param name="policyName">The name of the stored access policy.</param>
/// <returns>A Task object.</returns>
private static async Task CreateSharedAccessPolicyAsync(CloudBlobContainer container, string policyName)
{
// Create a new shared access policy and define its constraints.
// The access policy provides create, write, read, list, and delete permissions.
SharedAccessBlobPolicy sharedPolicy = new SharedAccessBlobPolicy()
{
// When the start time for the SAS is omitted, the start time is assumed to be the time when the storage service receives the request.
// Omitting the start time for a SAS that is effective immediately helps to avoid clock skew.
SharedAccessExpiryTime = DateTime.UtcNow.AddHours(24),
Permissions = SharedAccessBlobPermissions.Read | SharedAccessBlobPermissions.List |
SharedAccessBlobPermissions.Write | SharedAccessBlobPermissions.Create | SharedAccessBlobPermissions.Delete
};
// Get the container's existing permissions.
BlobContainerPermissions permissions = await container.GetPermissionsAsync();
// Add the new policy to the container's permissions, and set the container's permissions.
permissions.SharedAccessPolicies.Add(policyName, sharedPolicy);
await container.SetPermissionsAsync(permissions);
}
/// <summary>
/// Sets the anonymous access level.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="accessType">Type of the access.</param>
/// <returns>A Task object.</returns>
private static async Task SetAnonymousAccessLevelAsync(CloudBlobContainer container, BlobContainerPublicAccessType accessType)
{
try
{
// Read the existing permissions first so that we have all container permissions.
// This ensures that we do not inadvertently remove any shared access policies while setting the public access level.
BlobContainerPermissions permissions = await container.GetPermissionsAsync();
// Set the container's public access level.
permissions.PublicAccess = BlobContainerPublicAccessType.Container;
await container.SetPermissionsAsync(permissions);
Console.WriteLine("Container public access set to {0}", accessType.ToString());
Console.WriteLine();
}
catch (StorageException e)
{
Console.WriteLine(e.Message);
Console.ReadLine();
throw;
}
}
/// <summary>
/// Test container reads and writes, expecting success.
/// </summary>
/// <param name="testContainer">The container.</param>
/// <param name="testAccessCondition">The access condition to use.</param>
private async Task ContainerReadWriteExpectLeaseSuccessAsync(CloudBlobContainer testContainer, AccessCondition testAccessCondition)
{
await testContainer.FetchAttributesAsync(testAccessCondition, null /* options */, null);
await testContainer.GetPermissionsAsync(testAccessCondition, null /* options */, null);
await testContainer.SetMetadataAsync(testAccessCondition, null /* options */, null);
await testContainer.SetPermissionsAsync(new BlobContainerPermissions(), testAccessCondition, null /* options */, null);
}
/// <summary>
/// Test container reads and writes, expecting lease failure.
/// </summary>
/// <param name="testContainer">The container.</param>
/// <param name="testAccessCondition">The failing access condition to use.</param>
/// <param name="expectedErrorCode">The expected error code.</param>
/// <param name="description">The reason why these calls should fail.</param>
private async Task ContainerReadWriteExpectLeaseFailureAsync(CloudBlobContainer testContainer, AccessCondition testAccessCondition, HttpStatusCode expectedStatusCode, string expectedErrorCode, string description)
{
OperationContext operationContext = new OperationContext();
// FetchAttributes is a HEAD request with no extended error info, so it returns with the generic ConditionFailed error code.
await TestHelper.ExpectedExceptionAsync(
async () => await testContainer.FetchAttributesAsync(testAccessCondition, null /* options */, operationContext),
operationContext,
description + "(Fetch Attributes)",
HttpStatusCode.PreconditionFailed);
await TestHelper.ExpectedExceptionAsync(
async () => await testContainer.GetPermissionsAsync(testAccessCondition, null /* options */, operationContext),
operationContext,
description + " (Get Permissions)",
expectedStatusCode,
expectedErrorCode);
await TestHelper.ExpectedExceptionAsync(
async () => await testContainer.SetMetadataAsync(testAccessCondition, null /* options */, operationContext),
operationContext,
description + " (Set Metadata)",
expectedStatusCode,
expectedErrorCode);
await TestHelper.ExpectedExceptionAsync(
async () => await testContainer.SetPermissionsAsync(new BlobContainerPermissions(), testAccessCondition, null /* options */, operationContext),
operationContext,
description + " (Set Permissions)",
expectedStatusCode,
expectedErrorCode);
}
/// <summary>
/// Test container reads and writes, expecting success.
/// </summary>
/// <param name="testContainer">The container.</param>
/// <param name="testAccessCondition">The access condition to use.</param>
private void ContainerReadWriteExpectLeaseSuccessTask(CloudBlobContainer testContainer, AccessCondition testAccessCondition)
{
testContainer.FetchAttributesAsync(testAccessCondition, null /* options */, null /* operationContext */).Wait();
testContainer.GetPermissionsAsync(testAccessCondition, null /* options */, null /* operationContext */).Wait();
testContainer.SetMetadataAsync(testAccessCondition, null /* options */, null /* operationContext */).Wait();
testContainer.SetPermissionsAsync(new BlobContainerPermissions(), testAccessCondition, null /* options */, null /* operationContext */).Wait();
}
static async Task CopyContainer(CloudBlobContainer sourceContainer, CloudBlobContainer destContainer)
{
await sourceContainer.FetchAttributesAsync();
var access = await sourceContainer.GetPermissionsAsync();
await destContainer.CreateIfNotExistsAsync(access.PublicAccess, null, null);
await destContainer.SetPermissionsAsync(access);
destContainer.Metadata.Clear();
foreach (var metadatum in sourceContainer.Metadata)
{
destContainer.Metadata.Add(metadatum);
}
await destContainer.SetMetadataAsync();
}