private static void TestAccess(string sasToken, SharedAccessBlobPermissions permissions, SharedAccessBlobHeaders headers, CloudBlobContainer container, CloudBlob blob)
{
CloudBlob SASblob;
StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ?
new StorageCredentials() :
new StorageCredentials(sasToken);
if (container != null)
{
container = new CloudBlobContainer(credentials.TransformUri(container.Uri));
if (blob.BlobType == BlobType.BlockBlob)
{
SASblob = container.GetBlockBlobReference(blob.Name);
}
else if (blob.BlobType == BlobType.PageBlob)
{
SASblob = container.GetPageBlobReference(blob.Name);
}
else
{
SASblob = container.GetAppendBlobReference(blob.Name);
}
}
else
{
if (blob.BlobType == BlobType.BlockBlob)
{
SASblob = new CloudBlockBlob(credentials.TransformUri(blob.Uri));
}
else if (blob.BlobType == BlobType.PageBlob)
{
SASblob = new CloudPageBlob(credentials.TransformUri(blob.Uri));
}
else
{
SASblob = new CloudAppendBlob(credentials.TransformUri(blob.Uri));
}
}
HttpStatusCode failureCode = sasToken == null ? HttpStatusCode.NotFound : HttpStatusCode.Forbidden;
// We want to ensure that 'create', 'add', and 'write' permissions all allow for correct writing of blobs, as is reasonable.
if (((permissions & SharedAccessBlobPermissions.Create) == SharedAccessBlobPermissions.Create) || ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write))
{
if (blob.BlobType == BlobType.PageBlob)
{
CloudPageBlob SASpageBlob = (CloudPageBlob)SASblob;
SASpageBlob.Create(512);
CloudPageBlob pageBlob = (CloudPageBlob)blob;
byte[] buffer = new byte[512];
buffer[0] = 2; // random data
if (((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write))
{
SASpageBlob.UploadFromByteArray(buffer, 0, 512);
}
else
{
TestHelper.ExpectedException(
() => SASpageBlob.UploadFromByteArray(buffer, 0, 512),
"pageBlob SAS token without Write perms should not allow for writing/adding",
failureCode);
pageBlob.UploadFromByteArray(buffer, 0, 512);
}
}
else if (blob.BlobType == BlobType.BlockBlob)
{
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
UploadText(SASblob, "blob", Encoding.UTF8);
}
else
{
TestHelper.ExpectedException(
() => UploadText(SASblob, "blob", Encoding.UTF8),
"Block blob SAS token without Write or perms should not allow for writing",
failureCode);
UploadText(blob, "blob", Encoding.UTF8);
}
}
else // append blob
{
// If the sas token contains Feb 2012, append won't be accepted
if (sasToken.Contains(Constants.VersionConstants.February2012))
{
UploadText(blob, "blob", Encoding.UTF8);
}
else
{
CloudAppendBlob SASAppendBlob = SASblob as CloudAppendBlob;
SASAppendBlob.CreateOrReplace();
byte[] textAsBytes = Encoding.UTF8.GetBytes("blob");
using (MemoryStream stream = new MemoryStream())
{
stream.Write(textAsBytes, 0, textAsBytes.Length);
stream.Seek(0, SeekOrigin.Begin);
if (((permissions & SharedAccessBlobPermissions.Add) == SharedAccessBlobPermissions.Add) || ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write))
{
SASAppendBlob.AppendBlock(stream, null);
}
else
{
TestHelper.ExpectedException(
() => SASAppendBlob.AppendBlock(stream, null),
"Append blob SAS token without Write or Add perms should not allow for writing/adding",
failureCode);
stream.Seek(0, SeekOrigin.Begin);
((CloudAppendBlob)blob).AppendBlock(stream, null);
}
}
}
}
}
else
{
TestHelper.ExpectedException(
() => UploadText(SASblob, "blob", Encoding.UTF8),
"UploadText SAS does not allow for writing/adding",
((blob.BlobType == BlobType.AppendBlob) && (sasToken != null) && (sasToken.Contains(Constants.VersionConstants.February2012))) ? HttpStatusCode.BadRequest : failureCode);
UploadText(blob, "blob", Encoding.UTF8);
}
if (container != null)
{
if ((permissions & SharedAccessBlobPermissions.List) == SharedAccessBlobPermissions.List)
{
container.ListBlobs().ToArray();
}
else
{
TestHelper.ExpectedException(
() => container.ListBlobs().ToArray(),
"List blobs while SAS does not allow for listing",
failureCode);
}
}
// need to have written to the blob to read from it.
if (((permissions & SharedAccessBlobPermissions.Read) == SharedAccessBlobPermissions.Read))
{
SASblob.FetchAttributes();
// Test headers
if (headers != null)
{
if (headers.CacheControl != null)
{
Assert.AreEqual(headers.CacheControl, SASblob.Properties.CacheControl);
}
if (headers.ContentDisposition != null)
{
Assert.AreEqual(headers.ContentDisposition, SASblob.Properties.ContentDisposition);
}
if (headers.ContentEncoding != null)
{
Assert.AreEqual(headers.ContentEncoding, SASblob.Properties.ContentEncoding);
}
if (headers.ContentLanguage != null)
{
Assert.AreEqual(headers.ContentLanguage, SASblob.Properties.ContentLanguage);
}
if (headers.ContentType != null)
{
Assert.AreEqual(headers.ContentType, SASblob.Properties.ContentType);
}
}
}
else
{
TestHelper.ExpectedException(
() => SASblob.FetchAttributes(),
"Fetch blob attributes while SAS does not allow for reading",
failureCode);
}
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
SASblob.SetMetadata();
}
else
{
TestHelper.ExpectedException(
() => SASblob.SetMetadata(),
"Set blob metadata while SAS does not allow for writing",
failureCode);
}
if ((permissions & SharedAccessBlobPermissions.Delete) == SharedAccessBlobPermissions.Delete)
{
SASblob.Delete();
}
else
{
TestHelper.ExpectedException(
() => SASblob.Delete(),
"Delete blob while SAS does not allow for deleting",
failureCode);
}
}
public static List<string> CreateBlobs(CloudBlobContainer container, int count, BlobType type)
{
string name;
List<string> blobs = new List<string>();
for (int i = 0; i < count; i++)
{
switch (type)
{
case BlobType.BlockBlob:
name = "bb" + Guid.NewGuid().ToString();
CloudBlockBlob blockBlob = container.GetBlockBlobReference(name);
blockBlob.PutBlockList(new string[] { });
blobs.Add(name);
break;
case BlobType.PageBlob:
name = "pb" + Guid.NewGuid().ToString();
CloudPageBlob pageBlob = container.GetPageBlobReference(name);
pageBlob.Create(0);
blobs.Add(name);
break;
}
}
return blobs;
}
// copy a directory of the same container to another container
public static List<ICancellableAsyncResult> CopyBlobDirectory(CloudBlobDirectory srcDirectory, CloudBlobContainer destContainer, string sourceblobToken)
{
List<ICancellableAsyncResult> mylistresults = new List<ICancellableAsyncResult>();
var srcBlobList = srcDirectory.ListBlobs(
useFlatBlobListing: true,
blobListingDetails: BlobListingDetails.None).ToList();
foreach (var src in srcBlobList)
{
var srcBlob = src as ICloudBlob;
// Create appropriate destination blob type to match the source blob
ICloudBlob destBlob;
if (srcBlob.Properties.BlobType == BlobType.BlockBlob)
destBlob = destContainer.GetBlockBlobReference(srcBlob.Name);
else
destBlob = destContainer.GetPageBlobReference(srcBlob.Name);
// copy using src blob as SAS
mylistresults.Add(destBlob.BeginStartCopyFromBlob(new Uri(srcBlob.Uri.AbsoluteUri + sourceblobToken), null, null));
}
return mylistresults;
}
private async Task<bool> CloudBlobDirectorySetupWithDelimiterAsync(CloudBlobContainer container, string delimiter = "/")
{
try
{
for (int i = 1; i < 3; i++)
{
for (int j = 1; j < 3; j++)
{
for (int k = 1; k < 3; k++)
{
String directory = "TopDir" + i + delimiter + "MidDir" + j + delimiter + "EndDir" + k + delimiter + "EndBlob" + k;
CloudPageBlob blob1 = container.GetPageBlobReference(directory);
await blob1.CreateAsync(0);
}
}
CloudPageBlob blob2 = container.GetPageBlobReference("TopDir" + i + delimiter + "Blob" + i);
await blob2.CreateAsync(0);
}
return true;
}
catch (Exception e)
{
throw e;
}
}
public static MessageReader GetReader(string sas)
{
var uri = new Uri(sas);
var container = new CloudBlobContainer(uri);
var posBlob = container.GetPageBlobReference(Constants.PositionFileName);
var dataBlob = container.GetPageBlobReference(Constants.StreamFileName);
var position = new CloudCheckpointReader(posBlob);
var messages = new CloudPageReader(dataBlob);
return new MessageReader(position, messages);
}
public static MessageWriter CreateAndInitWriter(CloudBlobContainer container)
{
container.CreateIfNotExists();
var dataBlob = container.GetPageBlobReference(Constants.StreamFileName);
var posBlob = container.GetPageBlobReference(Constants.PositionFileName);
var pageWriter = new CloudPageWriter(dataBlob);
var posWriter = new CloudCheckpointWriter(posBlob);
var writer = new MessageWriter(pageWriter, posWriter);
writer.Init();
return writer;
}
public static async Task<List<string>> CreateBlobsAsync(CloudBlobContainer container, int count, BlobType type)
{
string name;
List<string> blobs = new List<string>();
for (int i = 0; i < count; i++)
{
switch (type)
{
case BlobType.BlockBlob:
name = "bb" + Guid.NewGuid().ToString();
CloudBlockBlob blockBlob = container.GetBlockBlobReference(name);
await blockBlob.PutBlockListAsync(new string[] { });
blobs.Add(name);
break;
case BlobType.PageBlob:
name = "pb" + Guid.NewGuid().ToString();
CloudPageBlob pageBlob = container.GetPageBlobReference(name);
await pageBlob.CreateAsync(0);
blobs.Add(name);
break;
case BlobType.AppendBlob:
name = "ab" + Guid.NewGuid().ToString();
CloudAppendBlob appendBlob = container.GetAppendBlobReference(name);
await appendBlob.CreateOrReplaceAsync();
blobs.Add(name);
break;
}
}
return blobs;
}
public static StorageBlob.ICloudBlob GetBlob(StorageBlob.CloudBlobContainer container, string blobName, StorageType blobType)
{
StorageBlob.ICloudBlob blob = null;
if (blobType == StorageType.BlockBlob)
{
blob = container.GetBlockBlobReference(blobName);
}
else
{
blob = container.GetPageBlobReference(blobName);
}
return(blob);
}
/// <summary>
/// create a new page blob with random properties and metadata
/// </summary>
/// <param name="container">CloudBlobContainer object</param>
/// <param name="blobName">blob name</param>
/// <returns>ICloudBlob object</returns>
public StorageBlob.ICloudBlob CreatePageBlob(StorageBlob.CloudBlobContainer container, string blobName)
{
StorageBlob.CloudPageBlob pageBlob = container.GetPageBlobReference(blobName);
int size = random.Next(1, 10) * PageBlobUnitSize;
pageBlob.Create(size);
byte[] buffer = new byte[size];
string md5sum = Convert.ToBase64String(Helper.GetMD5(buffer));
pageBlob.Properties.ContentMD5 = md5sum;
GenerateBlobPropertiesAndMetaData(pageBlob);
Test.Info(string.Format("create page blob '{0}' in container '{1}'", blobName, container.Name));
return(pageBlob);
}
public async Task PageBlobWriteStreamFlushTestAsync()
{
byte[] buffer = GetRandomBuffer(512);
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
blob.StreamWriteSizeInBytes = 1024;
using (MemoryStream wholeBlob = new MemoryStream())
{
BlobRequestOptions options = new BlobRequestOptions()
{
StoreBlobContentMD5 = true
};
OperationContext opContext = new OperationContext();
using (ICloudBlobStream blobStream = await blob.OpenWriteAsync(4 * 512, null, options, opContext))
{
for (int i = 0; i < 3; i++)
{
await blobStream.WriteAsync(buffer.AsBuffer());
await wholeBlob.WriteAsync(buffer, 0, buffer.Length);
}
Assert.AreEqual(2, opContext.RequestResults.Count);
await blobStream.FlushAsync();
Assert.AreEqual(3, opContext.RequestResults.Count);
await blobStream.FlushAsync();
Assert.AreEqual(3, opContext.RequestResults.Count);
await blobStream.WriteAsync(buffer.AsBuffer());
await wholeBlob.WriteAsync(buffer, 0, buffer.Length);
Assert.AreEqual(3, opContext.RequestResults.Count);
await blobStream.CommitAsync();
Assert.AreEqual(5, opContext.RequestResults.Count);
}
Assert.AreEqual(5, opContext.RequestResults.Count);
using (MemoryOutputStream downloadedBlob = new MemoryOutputStream())
{
await blob.DownloadToStreamAsync(downloadedBlob);
TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob.UnderlyingStream);
}
}
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
public async Task PageBlobWriteStreamOpenWithAccessConditionAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
await container.CreateAsync();
try
{
OperationContext context = new OperationContext();
CloudPageBlob existingBlob = container.GetPageBlobReference("blob");
await existingBlob.CreateAsync(1024);
CloudPageBlob blob = container.GetPageBlobReference("blob2");
AccessCondition accessCondition = AccessCondition.GenerateIfMatchCondition(existingBlob.Properties.ETag);
await TestHelper.ExpectedExceptionAsync(
async() => await blob.OpenWriteAsync(1024, accessCondition, null, context),
context,
"OpenWriteAsync with a non-met condition should fail",
HttpStatusCode.PreconditionFailed);
blob = container.GetPageBlobReference("blob3");
accessCondition = AccessCondition.GenerateIfNoneMatchCondition(existingBlob.Properties.ETag);
IOutputStream blobStream = await blob.OpenWriteAsync(1024, accessCondition, null, context);
blobStream.Dispose();
blob = container.GetPageBlobReference("blob4");
accessCondition = AccessCondition.GenerateIfNoneMatchCondition("*");
blobStream = await blob.OpenWriteAsync(1024, accessCondition, null, context);
blobStream.Dispose();
blob = container.GetPageBlobReference("blob5");
accessCondition = AccessCondition.GenerateIfModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(1));
blobStream = await blob.OpenWriteAsync(1024, accessCondition, null, context);
blobStream.Dispose();
blob = container.GetPageBlobReference("blob6");
accessCondition = AccessCondition.GenerateIfNotModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(-1));
blobStream = await blob.OpenWriteAsync(1024, accessCondition, null, context);
blobStream.Dispose();
accessCondition = AccessCondition.GenerateIfMatchCondition(existingBlob.Properties.ETag);
blobStream = await existingBlob.OpenWriteAsync(1024, accessCondition, null, context);
blobStream.Dispose();
accessCondition = AccessCondition.GenerateIfMatchCondition(blob.Properties.ETag);
await TestHelper.ExpectedExceptionAsync(
async() => await existingBlob.OpenWriteAsync(1024, accessCondition, null, context),
context,
"OpenWriteAsync with a non-met condition should fail",
HttpStatusCode.PreconditionFailed);
accessCondition = AccessCondition.GenerateIfNoneMatchCondition(blob.Properties.ETag);
blobStream = await existingBlob.OpenWriteAsync(1024, accessCondition, null, context);
blobStream.Dispose();
accessCondition = AccessCondition.GenerateIfNoneMatchCondition(existingBlob.Properties.ETag);
await TestHelper.ExpectedExceptionAsync(
async() => await existingBlob.OpenWriteAsync(1024, accessCondition, null, context),
context,
"OpenWriteAsync with a non-met condition should fail",
HttpStatusCode.PreconditionFailed);
accessCondition = AccessCondition.GenerateIfNoneMatchCondition("*");
await TestHelper.ExpectedExceptionAsync(
async() => await existingBlob.OpenWriteAsync(1024, accessCondition, null, context),
context,
"BlobWriteStream.Dispose with a non-met condition should fail",
HttpStatusCode.Conflict);
accessCondition = AccessCondition.GenerateIfModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(-1));
blobStream = await existingBlob.OpenWriteAsync(1024, accessCondition, null, context);
blobStream.Dispose();
accessCondition = AccessCondition.GenerateIfModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(1));
await TestHelper.ExpectedExceptionAsync(
async() => await existingBlob.OpenWriteAsync(1024, accessCondition, null, context),
context,
"OpenWriteAsync with a non-met condition should fail",
HttpStatusCode.PreconditionFailed);
accessCondition = AccessCondition.GenerateIfNotModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(1));
blobStream = await existingBlob.OpenWriteAsync(1024, accessCondition, null, context);
blobStream.Dispose();
accessCondition = AccessCondition.GenerateIfNotModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(-1));
await TestHelper.ExpectedExceptionAsync(
async() => await existingBlob.OpenWriteAsync(1024, accessCondition, null, context),
context,
"OpenWriteAsync with a non-met condition should fail",
HttpStatusCode.PreconditionFailed);
}
finally
{
container.DeleteAsync().AsTask().Wait();
}
}
public static ICloudBlob GetBlob(CloudBlobContainer container, string blobName, StorageType blobType)
{
ICloudBlob blob = null;
if (blobType == StorageType.BlockBlob)
{
blob = container.GetBlockBlobReference(blobName);
}
else
{
blob = container.GetPageBlobReference(blobName);
}
return blob;
}
private static void TestAccess(string sasToken, SharedAccessBlobPermissions permissions, SharedAccessBlobHeaders headers, CloudBlobContainer container, CloudBlob blob)
{
CloudBlob SASblob;
StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ?
new StorageCredentials() :
new StorageCredentials(sasToken);
if (container != null)
{
container = new CloudBlobContainer(credentials.TransformUri(container.Uri));
if (blob.BlobType == BlobType.BlockBlob)
{
SASblob = container.GetBlockBlobReference(blob.Name);
}
else if (blob.BlobType == BlobType.PageBlob)
{
SASblob = container.GetPageBlobReference(blob.Name);
}
else
{
SASblob = container.GetAppendBlobReference(blob.Name);
}
}
else
{
if (blob.BlobType == BlobType.BlockBlob)
{
SASblob = new CloudBlockBlob(credentials.TransformUri(blob.Uri));
}
else if (blob.BlobType == BlobType.PageBlob)
{
SASblob = new CloudPageBlob(credentials.TransformUri(blob.Uri));
}
else
{
SASblob = new CloudAppendBlob(credentials.TransformUri(blob.Uri));
}
}
HttpStatusCode failureCode = sasToken == null ? HttpStatusCode.NotFound : HttpStatusCode.Forbidden;
// We want to ensure that 'create', 'add', and 'write' permissions all allow for correct writing of blobs, as is reasonable.
if (((permissions & SharedAccessBlobPermissions.Create) == SharedAccessBlobPermissions.Create) || ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write))
{
if (blob.BlobType == BlobType.PageBlob)
{
CloudPageBlob SASpageBlob = (CloudPageBlob)SASblob;
SASpageBlob.Create(512);
CloudPageBlob pageBlob = (CloudPageBlob)blob;
byte[] buffer = new byte[512];
buffer[0] = 2; // random data
if (((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write))
{
SASpageBlob.UploadFromByteArray(buffer, 0, 512);
}
else
{
TestHelper.ExpectedException(
() => SASpageBlob.UploadFromByteArray(buffer, 0, 512),
"pageBlob SAS token without Write perms should not allow for writing/adding",
failureCode);
pageBlob.UploadFromByteArray(buffer, 0, 512);
}
}
else if (blob.BlobType == BlobType.BlockBlob)
{
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
UploadText(SASblob, "blob", Encoding.UTF8);
}
else
{
TestHelper.ExpectedException(
() => UploadText(SASblob, "blob", Encoding.UTF8),
"Block blob SAS token without Write or perms should not allow for writing",
failureCode);
UploadText(blob, "blob", Encoding.UTF8);
}
}
else // append blob
{
// If the sas token contains Feb 2012, append won't be accepted
if (sasToken.Contains(Constants.VersionConstants.February2012))
{
UploadText(blob, "blob", Encoding.UTF8);
}
else
{
CloudAppendBlob SASAppendBlob = SASblob as CloudAppendBlob;
SASAppendBlob.CreateOrReplace();
byte[] textAsBytes = Encoding.UTF8.GetBytes("blob");
using (MemoryStream stream = new MemoryStream())
{
stream.Write(textAsBytes, 0, textAsBytes.Length);
stream.Seek(0, SeekOrigin.Begin);
if (((permissions & SharedAccessBlobPermissions.Add) == SharedAccessBlobPermissions.Add) || ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write))
{
SASAppendBlob.AppendBlock(stream, null);
}
else
{
TestHelper.ExpectedException(
() => SASAppendBlob.AppendBlock(stream, null),
"Append blob SAS token without Write or Add perms should not allow for writing/adding",
failureCode);
stream.Seek(0, SeekOrigin.Begin);
((CloudAppendBlob)blob).AppendBlock(stream, null);
}
}
}
}
}
else
{
TestHelper.ExpectedException(
() => UploadText(SASblob, "blob", Encoding.UTF8),
"UploadText SAS does not allow for writing/adding",
((blob.BlobType == BlobType.AppendBlob) && (sasToken != null) && (sasToken.Contains(Constants.VersionConstants.February2012))) ? HttpStatusCode.BadRequest : failureCode);
UploadText(blob, "blob", Encoding.UTF8);
}
if (container != null)
{
if ((permissions & SharedAccessBlobPermissions.List) == SharedAccessBlobPermissions.List)
{
container.ListBlobs().ToArray();
}
else
{
TestHelper.ExpectedException(
() => container.ListBlobs().ToArray(),
"List blobs while SAS does not allow for listing",
failureCode);
}
}
// need to have written to the blob to read from it.
if (((permissions & SharedAccessBlobPermissions.Read) == SharedAccessBlobPermissions.Read))
{
SASblob.FetchAttributes();
// Test headers
if (headers != null)
{
if (headers.CacheControl != null)
{
Assert.AreEqual(headers.CacheControl, SASblob.Properties.CacheControl);
}
if (headers.ContentDisposition != null)
{
Assert.AreEqual(headers.ContentDisposition, SASblob.Properties.ContentDisposition);
}
if (headers.ContentEncoding != null)
{
Assert.AreEqual(headers.ContentEncoding, SASblob.Properties.ContentEncoding);
}
if (headers.ContentLanguage != null)
{
Assert.AreEqual(headers.ContentLanguage, SASblob.Properties.ContentLanguage);
}
if (headers.ContentType != null)
{
Assert.AreEqual(headers.ContentType, SASblob.Properties.ContentType);
}
}
}
else
{
TestHelper.ExpectedException(
() => SASblob.FetchAttributes(),
"Fetch blob attributes while SAS does not allow for reading",
failureCode);
}
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
SASblob.SetMetadata();
}
else
{
TestHelper.ExpectedException(
() => SASblob.SetMetadata(),
"Set blob metadata while SAS does not allow for writing",
failureCode);
}
if ((permissions & SharedAccessBlobPermissions.Delete) == SharedAccessBlobPermissions.Delete)
{
SASblob.Delete();
}
else
{
TestHelper.ExpectedException(
() => SASblob.Delete(),
"Delete blob while SAS does not allow for deleting",
failureCode);
}
}
/// <summary>
/// Get a list of valid page ranges for a page blob
/// </summary>
/// <param name="container"></param>
/// <returns>A Task object.</returns>
private static async Task PageRangesSample(CloudBlobContainer container)
{
BlobRequestOptions requestOptions = new BlobRequestOptions { RetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 3) };
await container.CreateIfNotExistsAsync(requestOptions, null);
Console.WriteLine("Create Page Blob");
CloudPageBlob pageBlob = container.GetPageBlobReference("blob1");
pageBlob.Create(4 * 1024);
Console.WriteLine("Write Pages to Blob");
byte[] buffer = GetRandomBuffer(1024);
using (MemoryStream memoryStream = new MemoryStream(buffer))
{
pageBlob.WritePages(memoryStream, 512);
}
using (MemoryStream memoryStream = new MemoryStream(buffer))
{
pageBlob.WritePages(memoryStream, 3 * 1024);
}
Console.WriteLine("Get Page Ranges");
IEnumerable<PageRange> pageRanges = pageBlob.GetPageRanges();
foreach (PageRange pageRange in pageRanges)
{
Console.WriteLine(pageRange.ToString());
}
// Clean up after the demo. This line is not strictly necessary as the container is deleted in the next call.
// It is included for the purposes of the example.
Console.WriteLine("Delete page blob");
await pageBlob.DeleteIfExistsAsync();
Console.WriteLine();
}
public async Task CloudPageBlobCopyTestAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudPageBlob source = container.GetPageBlobReference("source");
string data = new string('a', 512);
await UploadTextAsync(source, data, Encoding.UTF8);
source.Metadata["Test"] = "value";
await source.SetMetadataAsync();
CloudPageBlob copy = container.GetPageBlobReference("copy");
string copyId = await copy.StartCopyFromBlobAsync(TestHelper.Defiddler(source));
await WaitForCopyAsync(copy);
Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status);
Assert.AreEqual(source.Uri.AbsolutePath, copy.CopyState.Source.AbsolutePath);
Assert.AreEqual(data.Length, copy.CopyState.TotalBytes);
Assert.AreEqual(data.Length, copy.CopyState.BytesCopied);
Assert.AreEqual(copyId, copy.CopyState.CopyId);
Assert.IsTrue(copy.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
OperationContext opContext = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await copy.AbortCopyAsync(copyId, null, null, opContext),
opContext,
"Aborting a copy operation after completion should fail",
HttpStatusCode.Conflict,
"NoPendingCopyOperation");
await source.FetchAttributesAsync();
Assert.IsNotNull(copy.Properties.ETag);
Assert.AreNotEqual(source.Properties.ETag, copy.Properties.ETag);
Assert.IsTrue(copy.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
string copyData = await DownloadTextAsync(copy, Encoding.UTF8);
Assert.AreEqual(data, copyData, "Data inside copy of blob not similar");
await copy.FetchAttributesAsync();
BlobProperties prop1 = copy.Properties;
BlobProperties prop2 = source.Properties;
Assert.AreEqual(prop1.CacheControl, prop2.CacheControl);
Assert.AreEqual(prop1.ContentDisposition, prop2.ContentDisposition);
Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding);
Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage);
Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5);
Assert.AreEqual(prop1.ContentType, prop2.ContentType);
Assert.AreEqual("value", copy.Metadata["Test"], false, "Copied metadata not same");
await copy.DeleteAsync();
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
private async Task CloudPageBlobUploadFromStreamAsync(CloudBlobContainer container, int size, long? copyLength, AccessCondition accessCondition, OperationContext operationContext, int startOffset, bool testMd5)
{
byte[] buffer = GetRandomBuffer(size);
string md5 = string.Empty;
if (testMd5)
{
#if ASPNET_K
MD5 hasher = MD5.Create();
md5 = Convert.ToBase64String(hasher.ComputeHash(buffer, startOffset, copyLength.HasValue ? (int)copyLength : buffer.Length - startOffset));
#else
CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash();
hasher.Append(buffer.AsBuffer(startOffset, copyLength.HasValue ? (int)copyLength : buffer.Length - startOffset));
md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset());
#endif
}
CloudPageBlob blob = container.GetPageBlobReference("blob1");
blob.StreamWriteSizeInBytes = 512;
using (MemoryStream originalBlobStream = new MemoryStream())
{
originalBlobStream.Write(buffer, startOffset, buffer.Length - startOffset);
using (MemoryStream sourceStream = new MemoryStream(buffer))
{
sourceStream.Seek(startOffset, SeekOrigin.Begin);
BlobRequestOptions options = new BlobRequestOptions()
{
StoreBlobContentMD5 = true,
};
if (copyLength.HasValue)
{
await blob.UploadFromStreamAsync(sourceStream, copyLength.Value, accessCondition, options, operationContext);
}
else
{
await blob.UploadFromStreamAsync(sourceStream, accessCondition, options, operationContext);
}
}
if (testMd5)
{
await blob.FetchAttributesAsync();
Assert.AreEqual(md5, blob.Properties.ContentMD5);
}
using (MemoryOutputStream downloadedBlobStream = new MemoryOutputStream())
{
await blob.DownloadToStreamAsync(downloadedBlobStream);
Assert.AreEqual(copyLength ?? originalBlobStream.Length, downloadedBlobStream.UnderlyingStream.Length);
TestHelper.AssertStreamsAreEqualAtIndex(
originalBlobStream,
downloadedBlobStream.UnderlyingStream,
0,
0,
copyLength.HasValue ? (int)copyLength : (int)originalBlobStream.Length);
}
}
}
public static void CopyBlobs(
CloudBlobContainer srcContainer,
string policyId,
CloudBlobContainer destContainer)
{
// get the SAS token to use for all blobs
string blobToken = srcContainer.GetSharedAccessSignature(
new SharedAccessBlobPolicy(), policyId);
var srcBlobList = srcContainer.ListBlobs(null, false);
foreach (var src in srcBlobList)
{
var srcBlob = src as CloudBlob;
try {
// Create appropriate destination blob type to match the source blob
CloudBlob destBlob;
if (srcBlob.Properties.BlobType == BlobType.BlockBlob)
{
destBlob = destContainer.GetBlockBlobReference(srcBlob.Name);
}
else
{
destBlob = destContainer.GetPageBlobReference(srcBlob.Name);
}
// copy using src blob as SAS
// destBlob.StartCopyFromBlob(new Uri(srcBlob.Uri.AbsoluteUri + blobToken));
destBlob.StartCopy(new Uri(srcBlob.Uri.AbsoluteUri));
Console.WriteLine("Copied: " + srcBlob.Uri.AbsoluteUri);
}
catch (Exception e)
{
Console.WriteLine("Error: " + e.Message);
}
}
}
private async Task CloudPageBlobUploadFromStreamAsync(CloudBlobContainer container, int size, long? copyLength, AccessCondition accessCondition, OperationContext operationContext, int startOffset)
{
byte[] buffer = GetRandomBuffer(size);
CloudPageBlob blob = container.GetPageBlobReference("blob1");
blob.StreamWriteSizeInBytes = 512;
using (MemoryStream originalBlobStream = new MemoryStream())
{
originalBlobStream.Write(buffer, startOffset, buffer.Length - startOffset);
using (MemoryStream sourceStream = new MemoryStream(buffer))
{
sourceStream.Seek(startOffset, SeekOrigin.Begin);
if (copyLength.HasValue)
{
await blob.UploadFromStreamAsync(sourceStream, copyLength.Value, accessCondition, null, operationContext);
}
else
{
await blob.UploadFromStreamAsync(sourceStream, accessCondition, null, operationContext);
}
}
using (MemoryStream downloadedBlobStream = new MemoryStream())
{
await blob.DownloadToStreamAsync(downloadedBlobStream);
Assert.AreEqual(copyLength ?? originalBlobStream.Length, downloadedBlobStream.Length);
TestHelper.AssertStreamsAreEqualAtIndex(
originalBlobStream,
downloadedBlobStream,
0,
0,
copyLength.HasValue ? (int)copyLength : (int)originalBlobStream.Length);
}
}
}
public async Task CloudPageBlobConditionalAccessAsync()
{
OperationContext operationContext = new OperationContext();
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
await blob.CreateAsync(1024);
await blob.FetchAttributesAsync();
string currentETag = blob.Properties.ETag;
DateTimeOffset currentModifiedTime = blob.Properties.LastModified.Value;
// ETag conditional tests
blob.Metadata["ETagConditionalName"] = "ETagConditionalValue";
await blob.SetMetadataAsync(AccessCondition.GenerateIfMatchCondition(currentETag), null, null);
await blob.FetchAttributesAsync();
string newETag = blob.Properties.ETag;
Assert.AreNotEqual(newETag, currentETag, "ETage should be modified on write metadata");
blob.Metadata["ETagConditionalName"] = "ETagConditionalValue2";
await TestHelper.ExpectedExceptionAsync(
async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfNoneMatchCondition(newETag), null, operationContext),
operationContext,
"If none match on conditional test should throw",
HttpStatusCode.PreconditionFailed,
"ConditionNotMet");
string invalidETag = "\"0x10101010\"";
await TestHelper.ExpectedExceptionAsync(
async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfMatchCondition(invalidETag), null, operationContext),
operationContext,
"Invalid ETag on conditional test should throw",
HttpStatusCode.PreconditionFailed,
"ConditionNotMet");
currentETag = blob.Properties.ETag;
await blob.SetMetadataAsync(AccessCondition.GenerateIfNoneMatchCondition(invalidETag), null, null);
await blob.FetchAttributesAsync();
newETag = blob.Properties.ETag;
// LastModifiedTime tests
currentModifiedTime = blob.Properties.LastModified.Value;
blob.Metadata["DateConditionalName"] = "DateConditionalValue";
await TestHelper.ExpectedExceptionAsync(
async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfModifiedSinceCondition(currentModifiedTime), null, operationContext),
operationContext,
"IfModifiedSince conditional on current modified time should throw",
HttpStatusCode.PreconditionFailed,
"ConditionNotMet");
DateTimeOffset pastTime = currentModifiedTime.Subtract(TimeSpan.FromMinutes(5));
await blob.SetMetadataAsync(AccessCondition.GenerateIfModifiedSinceCondition(pastTime), null, null);
pastTime = currentModifiedTime.Subtract(TimeSpan.FromHours(5));
await blob.SetMetadataAsync(AccessCondition.GenerateIfModifiedSinceCondition(pastTime), null, null);
pastTime = currentModifiedTime.Subtract(TimeSpan.FromDays(5));
await blob.SetMetadataAsync(AccessCondition.GenerateIfModifiedSinceCondition(pastTime), null, null);
currentModifiedTime = blob.Properties.LastModified.Value;
pastTime = currentModifiedTime.Subtract(TimeSpan.FromMinutes(5));
await TestHelper.ExpectedExceptionAsync(
async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfNotModifiedSinceCondition(pastTime), null, operationContext),
operationContext,
"IfNotModifiedSince conditional on past time should throw",
HttpStatusCode.PreconditionFailed,
"ConditionNotMet");
pastTime = currentModifiedTime.Subtract(TimeSpan.FromHours(5));
await TestHelper.ExpectedExceptionAsync(
async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfNotModifiedSinceCondition(pastTime), null, operationContext),
operationContext,
"IfNotModifiedSince conditional on past time should throw",
HttpStatusCode.PreconditionFailed,
"ConditionNotMet");
pastTime = currentModifiedTime.Subtract(TimeSpan.FromDays(5));
await TestHelper.ExpectedExceptionAsync(
async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfNotModifiedSinceCondition(pastTime), null, operationContext),
operationContext,
"IfNotModifiedSince conditional on past time should throw",
HttpStatusCode.PreconditionFailed,
"ConditionNotMet");
blob.Metadata["DateConditionalName"] = "DateConditionalValue2";
currentETag = blob.Properties.ETag;
await blob.SetMetadataAsync(AccessCondition.GenerateIfNotModifiedSinceCondition(currentModifiedTime), null, null);
await blob.FetchAttributesAsync();
newETag = blob.Properties.ETag;
Assert.AreNotEqual(newETag, currentETag, "ETage should be modified on write metadata");
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
public async Task CloudPageBlobSnapshotAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
MemoryStream originalData = new MemoryStream(GetRandomBuffer(1024));
CloudPageBlob blob = container.GetPageBlobReference("blob1");
await blob.UploadFromStreamAsync(originalData.AsInputStream());
CloudPageBlob snapshot1 = await blob.CreateSnapshotAsync();
Assert.AreEqual(blob.Properties.ETag, snapshot1.Properties.ETag);
Assert.AreEqual(blob.Properties.LastModified, snapshot1.Properties.LastModified);
Assert.IsNotNull(snapshot1.SnapshotTime, "Snapshot does not have SnapshotTime set");
CloudPageBlob snapshot2 = await blob.CreateSnapshotAsync();
Assert.IsTrue(snapshot2.SnapshotTime.Value > snapshot1.SnapshotTime.Value);
await snapshot1.FetchAttributesAsync();
await snapshot2.FetchAttributesAsync();
await blob.FetchAttributesAsync();
AssertAreEqual(snapshot1.Properties, blob.Properties);
CloudPageBlob snapshot1Clone = new CloudPageBlob(new Uri(blob.Uri + "?snapshot=" + snapshot1.SnapshotTime.Value.ToString("O")), blob.ServiceClient.Credentials);
Assert.IsNotNull(snapshot1Clone.SnapshotTime, "Snapshot clone does not have SnapshotTime set");
Assert.AreEqual(snapshot1.SnapshotTime.Value, snapshot1Clone.SnapshotTime.Value);
await snapshot1Clone.FetchAttributesAsync();
AssertAreEqual(snapshot1.Properties, snapshot1Clone.Properties);
CloudPageBlob snapshotCopy = container.GetPageBlobReference("blob2");
await snapshotCopy.StartCopyFromBlobAsync(TestHelper.Defiddler(snapshot1.Uri));
await WaitForCopyAsync(snapshotCopy);
Assert.AreEqual(CopyStatus.Success, snapshotCopy.CopyState.Status);
await TestHelper.ExpectedExceptionAsync <InvalidOperationException>(
async() => await snapshot1.OpenWriteAsync(1024),
"Trying to write to a blob snapshot should fail");
using (Stream snapshotStream = (await snapshot1.OpenReadAsync()).AsStreamForRead())
{
snapshotStream.Seek(0, SeekOrigin.End);
TestHelper.AssertStreamsAreEqual(originalData, snapshotStream);
}
await blob.CreateAsync(1024);
using (Stream snapshotStream = (await snapshot1.OpenReadAsync()).AsStreamForRead())
{
snapshotStream.Seek(0, SeekOrigin.End);
TestHelper.AssertStreamsAreEqual(originalData, snapshotStream);
}
BlobResultSegment resultSegment = await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.All, null, null, null, null);
List <IListBlobItem> blobs = resultSegment.Results.ToList();
Assert.AreEqual(4, blobs.Count);
AssertAreEqual(snapshot1, (ICloudBlob)blobs[0]);
AssertAreEqual(snapshot2, (ICloudBlob)blobs[1]);
AssertAreEqual(blob, (ICloudBlob)blobs[2]);
AssertAreEqual(snapshotCopy, (ICloudBlob)blobs[3]);
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
public async Task CloudPageBlobWritePagesAsync()
{
byte[] buffer = GetRandomBuffer(4 * 1024 * 1024);
CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash();
hasher.Append(buffer.AsBuffer());
string contentMD5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset());
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
await blob.CreateAsync(4 * 1024 * 1024);
using (MemoryStream memoryStream = new MemoryStream())
{
await TestHelper.ExpectedExceptionAsync <ArgumentOutOfRangeException>(
async() => await blob.WritePagesAsync(memoryStream.AsInputStream(), 0, null),
"Zero-length WritePages should fail");
memoryStream.SetLength(4 * 1024 * 1024 + 1);
await TestHelper.ExpectedExceptionAsync <ArgumentOutOfRangeException>(
async() => await blob.WritePagesAsync(memoryStream.AsInputStream(), 0, null),
">4MB WritePages should fail");
}
using (MemoryStream resultingData = new MemoryStream())
{
using (MemoryStream memoryStream = new MemoryStream(buffer))
{
OperationContext opContext = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await blob.WritePagesAsync(memoryStream.AsInputStream(), 512, null, null, null, opContext),
opContext,
"Writing out-of-range pages should fail",
HttpStatusCode.RequestedRangeNotSatisfiable,
"InvalidPageRange");
memoryStream.Seek(0, SeekOrigin.Begin);
await blob.WritePagesAsync(memoryStream.AsInputStream(), 0, contentMD5);
resultingData.Write(buffer, 0, buffer.Length);
int offset = buffer.Length - 1024;
memoryStream.Seek(offset, SeekOrigin.Begin);
await TestHelper.ExpectedExceptionAsync(
async() => await blob.WritePagesAsync(memoryStream.AsInputStream(), 0, contentMD5, null, null, opContext),
opContext,
"Invalid MD5 should fail with mismatch",
HttpStatusCode.BadRequest,
"Md5Mismatch");
memoryStream.Seek(offset, SeekOrigin.Begin);
await blob.WritePagesAsync(memoryStream.AsInputStream(), 0, null);
resultingData.Seek(0, SeekOrigin.Begin);
resultingData.Write(buffer, offset, buffer.Length - offset);
offset = buffer.Length - 2048;
memoryStream.Seek(offset, SeekOrigin.Begin);
await blob.WritePagesAsync(memoryStream.AsInputStream(), 1024, null);
resultingData.Seek(1024, SeekOrigin.Begin);
resultingData.Write(buffer, offset, buffer.Length - offset);
}
using (MemoryStream blobData = new MemoryStream())
{
await blob.DownloadToStreamAsync(blobData.AsOutputStream());
Assert.AreEqual(resultingData.Length, blobData.Length);
Assert.IsTrue(blobData.ToArray().SequenceEqual(resultingData.ToArray()));
}
}
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
public async Task CloudPageBlobGetPageRangesAsync()
{
byte[] buffer = GetRandomBuffer(1024);
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
await blob.CreateAsync(4 * 1024);
using (MemoryStream memoryStream = new MemoryStream(buffer))
{
await blob.WritePagesAsync(memoryStream.AsInputStream(), 512, null);
}
using (MemoryStream memoryStream = new MemoryStream(buffer))
{
await blob.WritePagesAsync(memoryStream.AsInputStream(), 3 * 1024, null);
}
await blob.ClearPagesAsync(1024, 1024);
await blob.ClearPagesAsync(0, 512);
IEnumerable <PageRange> pageRanges = await blob.GetPageRangesAsync();
List <string> expectedPageRanges = new List <string>()
{
new PageRange(512, 1023).ToString(),
new PageRange(3 * 1024, 4 * 1024 - 1).ToString(),
};
foreach (PageRange pageRange in pageRanges)
{
Assert.IsTrue(expectedPageRanges.Remove(pageRange.ToString()));
}
Assert.AreEqual(0, expectedPageRanges.Count);
pageRanges = await blob.GetPageRangesAsync(1024, 1024, null, null, null);
Assert.AreEqual(0, pageRanges.Count());
pageRanges = await blob.GetPageRangesAsync(512, 3 * 1024, null, null, null);
expectedPageRanges = new List <string>()
{
new PageRange(512, 1023).ToString(),
new PageRange(3 * 1024, 7 * 512 - 1).ToString(),
};
foreach (PageRange pageRange in pageRanges)
{
Assert.IsTrue(expectedPageRanges.Remove(pageRange.ToString()));
}
Assert.AreEqual(0, expectedPageRanges.Count);
OperationContext opContext = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await blob.GetPageRangesAsync(1024, null, null, null, opContext),
opContext,
"Get Page Ranges with an offset but no count should fail",
HttpStatusCode.Unused);
Assert.IsInstanceOfType(opContext.LastResult.Exception.InnerException, typeof(ArgumentNullException));
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
public void CloudBlobSASApiVersionQueryParam()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
ICloudBlob blob;
SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy()
{
Permissions = SharedAccessBlobPermissions.Read,
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
};
CloudBlockBlob blockBlob = container.GetBlockBlobReference("bb");
blockBlob.PutBlockList(new string[] { });
CloudPageBlob pageBlob = container.GetPageBlobReference("pb");
pageBlob.Create(0);
string blockBlobToken = blockBlob.GetSharedAccessSignature(policy);
StorageCredentials blockBlobSAS = new StorageCredentials(blockBlobToken);
Uri blockBlobSASUri = blockBlobSAS.TransformUri(blockBlob.Uri);
StorageUri blockBlobSASStorageUri = blockBlobSAS.TransformUri(blockBlob.StorageUri);
string pageBlobToken = pageBlob.GetSharedAccessSignature(policy);
StorageCredentials pageBlobSAS = new StorageCredentials(pageBlobToken);
Uri pageBlobSASUri = pageBlobSAS.TransformUri(pageBlob.Uri);
StorageUri pageBlobSASStorageUri = pageBlobSAS.TransformUri(pageBlob.StorageUri);
OperationContext apiVersionCheckContext = new OperationContext();
apiVersionCheckContext.SendingRequest += (sender, e) =>
{
Assert.IsNull(e.Request.Headers.Get("x-ms-version"));
Assert.IsTrue(e.Request.RequestUri.Query.Contains("api-version"));
};
blob = container.ServiceClient.GetBlobReferenceFromServer(blockBlobSASUri, operationContext: apiVersionCheckContext);
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(blockBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = container.ServiceClient.GetBlobReferenceFromServer(pageBlobSASUri, operationContext: apiVersionCheckContext);
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(pageBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = container.ServiceClient.GetBlobReferenceFromServer(blockBlobSASStorageUri, operationContext: apiVersionCheckContext);
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.Equals(blockBlob.StorageUri));
blob = container.ServiceClient.GetBlobReferenceFromServer(pageBlobSASStorageUri, operationContext: apiVersionCheckContext);
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.Equals(pageBlob.StorageUri));
}
finally
{
container.DeleteIfExists();
}
}
public void PageBlobReadLockToETagTestAPM()
{
byte[] outBuffer = new byte[1 * 1024 * 1024];
byte[] buffer = GetRandomBuffer(2 * outBuffer.Length);
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
blob.StreamMinimumReadSizeInBytes = outBuffer.Length;
using (MemoryStream wholeBlob = new MemoryStream(buffer))
{
blob.UploadFromStream(wholeBlob);
}
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result = blob.BeginOpenRead(
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
using (Stream blobStream = blob.EndOpenRead(result))
{
blobStream.Read(outBuffer, 0, outBuffer.Length);
blob.SetMetadata();
TestHelper.ExpectedException(
() => blobStream.Read(outBuffer, 0, outBuffer.Length),
"Blob read stream should fail if blob is modified during read",
HttpStatusCode.PreconditionFailed);
}
result = blob.BeginOpenRead(
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
using (Stream blobStream = blob.EndOpenRead(result))
{
long length = blobStream.Length;
blob.SetMetadata();
TestHelper.ExpectedException(
() => blobStream.Read(outBuffer, 0, outBuffer.Length),
"Blob read stream should fail if blob is modified during read",
HttpStatusCode.PreconditionFailed);
}
AccessCondition accessCondition = AccessCondition.GenerateIfNotModifiedSinceCondition(DateTimeOffset.Now.Subtract(TimeSpan.FromHours(1)));
blob.SetMetadata();
result = blob.BeginOpenRead(
accessCondition,
null,
null,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
TestHelper.ExpectedException(
() => blob.EndOpenRead(result),
"Blob read stream should fail if blob is modified during read",
HttpStatusCode.PreconditionFailed);
}
}
finally
{
container.DeleteIfExists();
}
}
private static void TestAccess(string sasToken, SharedAccessBlobPermissions permissions, SharedAccessBlobHeaders headers, CloudBlobContainer container, ICloudBlob blob)
{
StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ?
new StorageCredentials() :
new StorageCredentials(sasToken);
if (container != null)
{
container = new CloudBlobContainer(credentials.TransformUri(container.Uri));
if (blob.BlobType == BlobType.BlockBlob)
{
blob = container.GetBlockBlobReference(blob.Name);
}
else
{
blob = container.GetPageBlobReference(blob.Name);
}
}
else
{
if (blob.BlobType == BlobType.BlockBlob)
{
blob = new CloudBlockBlob(credentials.TransformUri(blob.Uri));
}
else
{
blob = new CloudPageBlob(credentials.TransformUri(blob.Uri));
}
}
if (container != null)
{
if ((permissions & SharedAccessBlobPermissions.List) == SharedAccessBlobPermissions.List)
{
container.ListBlobs().ToArray();
}
else
{
TestHelper.ExpectedException(
() => container.ListBlobs().ToArray(),
"List blobs while SAS does not allow for listing",
HttpStatusCode.NotFound);
}
}
if ((permissions & SharedAccessBlobPermissions.Read) == SharedAccessBlobPermissions.Read)
{
blob.FetchAttributes();
// Test headers
if (headers != null)
{
if (headers.CacheControl != null)
{
Assert.AreEqual(headers.CacheControl, blob.Properties.CacheControl);
}
if (headers.ContentDisposition != null)
{
Assert.AreEqual(headers.ContentDisposition, blob.Properties.ContentDisposition);
}
if (headers.ContentEncoding != null)
{
Assert.AreEqual(headers.ContentEncoding, blob.Properties.ContentEncoding);
}
if (headers.ContentLanguage != null)
{
Assert.AreEqual(headers.ContentLanguage, blob.Properties.ContentLanguage);
}
if (headers.ContentType != null)
{
Assert.AreEqual(headers.ContentType, blob.Properties.ContentType);
}
}
}
else
{
TestHelper.ExpectedException(
() => blob.FetchAttributes(),
"Fetch blob attributes while SAS does not allow for reading",
HttpStatusCode.NotFound);
}
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
blob.SetMetadata();
}
else
{
TestHelper.ExpectedException(
() => blob.SetMetadata(),
"Set blob metadata while SAS does not allow for writing",
HttpStatusCode.NotFound);
}
if ((permissions & SharedAccessBlobPermissions.Delete) == SharedAccessBlobPermissions.Delete)
{
blob.Delete();
}
else
{
TestHelper.ExpectedException(
() => blob.Delete(),
"Delete blob while SAS does not allow for deleting",
HttpStatusCode.NotFound);
}
}
/// <summary>
/// set azure blob content
/// </summary>
/// <param name="fileName">local file path</param>
/// <param name="container">destination container</param>
/// <param name="blobName">blob name</param>
/// <returns>null if user cancel the overwrite operation, otherwise return destination blob object</returns>
internal AzureStorageBlob SetAzureBlobContent(string fileName, CloudBlobContainer container, string blobName)
{
string filePath = GetFullSendFilePath(fileName);
if (string.IsNullOrEmpty(filePath))
{
return null;
}
ValidatePipelineCloudBlobContainer(container);
if (string.IsNullOrEmpty(blobName))
{
blobName = GetBlobNameFromRelativeFilePath(filePath);
}
ICloudBlob blob = null;
switch (CultureInfo.CurrentCulture.TextInfo.ToTitleCase(blobType))
{
case PageBlobType:
blob = container.GetPageBlobReference(blobName);
break;
case BlockBlobType:
default:
blob = container.GetBlockBlobReference(blobName);
break;
}
return SetAzureBlobContent(fileName, blob);
}
public async Task CloudBlobClientMaximumExecutionTimeoutShouldNotBeHonoredForStreamsAsync()
{
CloudBlobClient blobClient = GenerateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference(Guid.NewGuid().ToString("N"));
byte[] buffer = BlobTestBase.GetRandomBuffer(1024 * 1024);
try
{
await container.CreateAsync();
blobClient.DefaultRequestOptions.MaximumExecutionTime = TimeSpan.FromSeconds(30);
CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1");
CloudPageBlob pageBlob = container.GetPageBlobReference("blob2");
blockBlob.StreamWriteSizeInBytes = 1024 * 1024;
blockBlob.StreamMinimumReadSizeInBytes = 1024 * 1024;
pageBlob.StreamWriteSizeInBytes = 1024 * 1024;
pageBlob.StreamMinimumReadSizeInBytes = 1024 * 1024;
using (var bos = await blockBlob.OpenWriteAsync())
{
DateTime start = DateTime.Now;
for (int i = 0; i < 7; i++)
{
await bos.WriteAsync(buffer, 0, buffer.Length);
}
// Sleep to ensure we are over the Max execution time when we do the last write
int msRemaining = (int)(blobClient.DefaultRequestOptions.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds;
if (msRemaining > 0)
{
await Task.Delay(msRemaining);
}
await bos.WriteAsync(buffer, 0, buffer.Length);
await bos.CommitAsync();
}
using (Stream bis = (await blockBlob.OpenReadAsync()))
{
DateTime start = DateTime.Now;
int total = 0;
while (total < 7 * 1024 * 1024)
{
total += await bis.ReadAsync(buffer, 0, buffer.Length);
}
// Sleep to ensure we are over the Max execution time when we do the last read
int msRemaining = (int)(blobClient.DefaultRequestOptions.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds;
if (msRemaining > 0)
{
await Task.Delay(msRemaining);
}
while (true)
{
int count = await bis.ReadAsync(buffer, 0, buffer.Length);
total += count;
if (count == 0)
{
break;
}
}
}
using (var bos = await pageBlob.OpenWriteAsync(8 * 1024 * 1024))
{
DateTime start = DateTime.Now;
for (int i = 0; i < 7; i++)
{
await bos.WriteAsync(buffer, 0, buffer.Length);
}
// Sleep to ensure we are over the Max execution time when we do the last write
int msRemaining = (int)(blobClient.DefaultRequestOptions.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds;
if (msRemaining > 0)
{
await Task.Delay(msRemaining);
}
await bos.WriteAsync(buffer, 0, buffer.Length);
await bos.CommitAsync();
}
using (Stream bis = (await pageBlob.OpenReadAsync()))
{
DateTime start = DateTime.Now;
int total = 0;
while (total < 7 * 1024 * 1024)
{
total += await bis.ReadAsync(buffer, 0, buffer.Length);
}
// Sleep to ensure we are over the Max execution time when we do the last read
int msRemaining = (int)(blobClient.DefaultRequestOptions.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds;
if (msRemaining > 0)
{
await Task.Delay(msRemaining);
}
while (true)
{
int count = await bis.ReadAsync(buffer, 0, buffer.Length);
total += count;
if (count == 0)
{
break;
}
}
}
}
finally
{
blobClient.DefaultRequestOptions.MaximumExecutionTime = null;
container.DeleteIfExistsAsync().Wait();
}
}
public static CloudBlob GetBlobReference(CloudBlobContainer container, string blobName, BlobType blobType)
{
switch(blobType)
{
case BlobType.BlockBlob:
return container.GetBlockBlobReference(blobName);
case BlobType.PageBlob:
return container.GetPageBlobReference(blobName);
case BlobType.AppendBlob:
return container.GetAppendBlobReference(blobName);
default:
throw new ArgumentException(String.Format(
CultureInfo.CurrentCulture,
Resources.InvalidBlobType,
blobType,
blobName));
}
}
/// <summary>
/// Write page blob. Although concurrency params exist, does NOT do concurrent uploading yet.
/// </summary>
/// <param name="stream"></param>
/// <param name="blob"></param>
/// <param name="container"></param>
/// <param name="parallelFactor"></param>
/// <param name="chunkSizeInMB"></param>
private void WritePageBlob(Stream stream, string blobName, Blob blob, CloudBlobContainer container, int parallelFactor = 1, int chunkSizeInMB = 2)
{
var blobRef = container.GetPageBlobReference(blobName);
blobRef.UploadFromStream(stream);
}
public void UseTransactionalMD5GetTestAPM()
{
BlobRequestOptions optionsWithNoMD5 = new BlobRequestOptions()
{
UseTransactionalMD5 = false,
};
BlobRequestOptions optionsWithMD5 = new BlobRequestOptions()
{
UseTransactionalMD5 = true,
};
byte[] buffer = GetRandomBuffer(3 * 1024 * 1024);
MD5 hasher = MD5.Create();
string md5 = Convert.ToBase64String(hasher.ComputeHash(buffer));
string lastCheckMD5 = null;
int checkCount = 0;
OperationContext opContextWithMD5Check = new OperationContext();
opContextWithMD5Check.ResponseReceived += (_, args) =>
{
if (args.Response.ContentLength >= buffer.Length)
{
lastCheckMD5 = args.Response.Headers[HttpResponseHeader.ContentMd5];
checkCount++;
}
};
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result;
CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1");
using (Stream blobStream = blockBlob.OpenWrite())
{
blobStream.Write(buffer, 0, buffer.Length);
blobStream.Write(buffer, 0, buffer.Length);
}
checkCount = 0;
using (Stream stream = new MemoryStream())
{
result = blockBlob.BeginDownloadToStream(stream, null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
blockBlob.EndDownloadRangeToStream(result);
Assert.IsNotNull(lastCheckMD5);
result = blockBlob.BeginDownloadToStream(stream, null, optionsWithMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
blockBlob.EndDownloadRangeToStream(result);
Assert.IsNotNull(lastCheckMD5);
result = blockBlob.BeginDownloadRangeToStream(stream, buffer.Length, buffer.Length, null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
blockBlob.EndDownloadRangeToStream(result);
Assert.IsNull(lastCheckMD5);
result = blockBlob.BeginDownloadRangeToStream(stream, buffer.Length, buffer.Length, null, optionsWithMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
blockBlob.EndDownloadRangeToStream(result);
Assert.AreEqual(md5, lastCheckMD5);
result = blockBlob.BeginDownloadRangeToStream(stream, 1024, 4 * 1024 * 1024 + 1, null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
blockBlob.EndDownloadRangeToStream(result);
Assert.IsNull(lastCheckMD5);
result = blockBlob.BeginDownloadRangeToStream(stream, 1024, 4 * 1024 * 1024 + 1, null, optionsWithMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
StorageException storageEx = TestHelper.ExpectedException <StorageException>(
() => blockBlob.EndDownloadRangeToStream(result),
"Downloading more than 4MB with transactional MD5 should not be supported");
Assert.IsInstanceOfType(storageEx.InnerException, typeof(ArgumentOutOfRangeException));
}
Assert.AreEqual(5, checkCount);
CloudPageBlob pageBlob = container.GetPageBlobReference("blob2");
using (Stream blobStream = pageBlob.OpenWrite(buffer.Length * 2))
{
blobStream.Write(buffer, 0, buffer.Length);
blobStream.Write(buffer, 0, buffer.Length);
}
checkCount = 0;
using (Stream stream = new MemoryStream())
{
result = pageBlob.BeginDownloadToStream(stream, null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
pageBlob.EndDownloadRangeToStream(result);
Assert.IsNull(lastCheckMD5);
result = pageBlob.BeginDownloadToStream(stream, null, optionsWithMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
StorageException storageEx = TestHelper.ExpectedException <StorageException>(
() => pageBlob.EndDownloadRangeToStream(result),
"Page blob will not have MD5 set by default; with UseTransactional, download should fail");
result = pageBlob.BeginDownloadRangeToStream(stream, buffer.Length, buffer.Length, null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
pageBlob.EndDownloadRangeToStream(result);
Assert.IsNull(lastCheckMD5);
result = pageBlob.BeginDownloadRangeToStream(stream, buffer.Length, buffer.Length, null, optionsWithMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
pageBlob.EndDownloadRangeToStream(result);
Assert.AreEqual(md5, lastCheckMD5);
result = pageBlob.BeginDownloadRangeToStream(stream, 1024, 4 * 1024 * 1024 + 1, null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
pageBlob.EndDownloadRangeToStream(result);
Assert.IsNull(lastCheckMD5);
result = pageBlob.BeginDownloadRangeToStream(stream, 1024, 4 * 1024 * 1024 + 1, null, optionsWithMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
storageEx = TestHelper.ExpectedException <StorageException>(
() => pageBlob.EndDownloadRangeToStream(result),
"Downloading more than 4MB with transactional MD5 should not be supported");
Assert.IsInstanceOfType(storageEx.InnerException, typeof(ArgumentOutOfRangeException));
}
Assert.AreEqual(5, checkCount);
}
}
finally
{
container.DeleteIfExists();
}
}
public void CloudBlobSASApiVersionQueryParam()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudBlob blob;
SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy()
{
Permissions = SharedAccessBlobPermissions.Read,
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
};
CloudBlockBlob blockBlob = container.GetBlockBlobReference("bb");
blockBlob.PutBlockList(new string[] { });
CloudPageBlob pageBlob = container.GetPageBlobReference("pb");
pageBlob.Create(0);
CloudAppendBlob appendBlob = container.GetAppendBlobReference("ab");
appendBlob.CreateOrReplace();
string blockBlobToken = blockBlob.GetSharedAccessSignature(policy);
StorageCredentials blockBlobSAS = new StorageCredentials(blockBlobToken);
Uri blockBlobSASUri = blockBlobSAS.TransformUri(blockBlob.Uri);
StorageUri blockBlobSASStorageUri = blockBlobSAS.TransformUri(blockBlob.StorageUri);
string pageBlobToken = pageBlob.GetSharedAccessSignature(policy);
StorageCredentials pageBlobSAS = new StorageCredentials(pageBlobToken);
Uri pageBlobSASUri = pageBlobSAS.TransformUri(pageBlob.Uri);
StorageUri pageBlobSASStorageUri = pageBlobSAS.TransformUri(pageBlob.StorageUri);
string appendBlobToken = appendBlob.GetSharedAccessSignature(policy);
StorageCredentials appendBlobSAS = new StorageCredentials(appendBlobToken);
Uri appendBlobSASUri = appendBlobSAS.TransformUri(appendBlob.Uri);
StorageUri appendBlobSASStorageUri = appendBlobSAS.TransformUri(appendBlob.StorageUri);
OperationContext apiVersionCheckContext = new OperationContext();
apiVersionCheckContext.SendingRequest += (sender, e) =>
{
Assert.IsTrue(e.Request.RequestUri.Query.Contains("api-version"));
};
blob = new CloudBlob(blockBlobSASUri);
blob.FetchAttributes(operationContext: apiVersionCheckContext);
Assert.AreEqual(blob.BlobType, BlobType.BlockBlob);
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(blockBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = new CloudBlob(pageBlobSASUri);
blob.FetchAttributes(operationContext: apiVersionCheckContext);
Assert.AreEqual(blob.BlobType, BlobType.PageBlob);
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(pageBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = new CloudBlob(blockBlobSASStorageUri, null, null);
blob.FetchAttributes(operationContext: apiVersionCheckContext);
Assert.AreEqual(blob.BlobType, BlobType.BlockBlob);
Assert.IsTrue(blob.StorageUri.Equals(blockBlob.StorageUri));
blob = new CloudBlob(pageBlobSASStorageUri, null, null);
blob.FetchAttributes(operationContext: apiVersionCheckContext);
Assert.AreEqual(blob.BlobType, BlobType.PageBlob);
Assert.IsTrue(blob.StorageUri.Equals(pageBlob.StorageUri));
}
finally
{
container.DeleteIfExists();
}
}
public void PageBlobWriteStreamBasicTestAPM()
{
byte[] buffer = GetRandomBuffer(1024 * 1024);
MD5 hasher = MD5.Create();
CloudBlobClient blobClient = GenerateCloudBlobClient();
blobClient.ParallelOperationThreadCount = 4;
string name = GetRandomContainerName();
CloudBlobContainer container = blobClient.GetContainerReference(name);
try
{
container.Create();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
blob.StreamWriteSizeInBytes = buffer.Length;
using (MemoryStream wholeBlob = new MemoryStream())
{
BlobRequestOptions options = new BlobRequestOptions()
{
StoreBlobContentMD5 = true,
};
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result = blob.BeginOpenWrite(blobClient.ParallelOperationThreadCount * 2 * buffer.Length, null, options, null,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
using (Stream blobStream = blob.EndOpenWrite(result))
{
IAsyncResult[] results = new IAsyncResult[blobClient.ParallelOperationThreadCount * 2];
for (int i = 0; i < results.Length; i++)
{
results[i] = blobStream.BeginWrite(buffer, 0, buffer.Length, null, null);
wholeBlob.Write(buffer, 0, buffer.Length);
Assert.AreEqual(wholeBlob.Position, blobStream.Position);
}
for (int i = 0; i < blobClient.ParallelOperationThreadCount; i++)
{
Assert.IsTrue(results[i].IsCompleted);
}
for (int i = blobClient.ParallelOperationThreadCount; i < results.Length; i++)
{
Assert.IsFalse(results[i].IsCompleted);
}
for (int i = 0; i < results.Length; i++)
{
blobStream.EndWrite(results[i]);
}
}
}
wholeBlob.Seek(0, SeekOrigin.Begin);
string md5 = Convert.ToBase64String(hasher.ComputeHash(wholeBlob));
blob.FetchAttributes();
Assert.AreEqual(md5, blob.Properties.ContentMD5);
using (MemoryStream downloadedBlob = new MemoryStream())
{
blob.DownloadToStream(downloadedBlob);
TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob);
}
}
}
finally
{
container.DeleteIfExists();
}
}
public void CloudPageBlobCopyTestAPM()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudPageBlob source = container.GetPageBlobReference("source");
string data = new string('a', 512);
UploadText(source, data, Encoding.UTF8);
source.Metadata["Test"] = "value";
source.SetMetadata();
CloudPageBlob copy = container.GetPageBlobReference("copy");
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result = copy.BeginStartCopyFromBlob(TestHelper.Defiddler(source),
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
string copyId = copy.EndStartCopyFromBlob(result);
WaitForCopy(copy);
Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status);
Assert.AreEqual(source.Uri.AbsolutePath, copy.CopyState.Source.AbsolutePath);
Assert.AreEqual(data.Length, copy.CopyState.TotalBytes);
Assert.AreEqual(data.Length, copy.CopyState.BytesCopied);
Assert.AreEqual(copyId, copy.CopyState.CopyId);
Assert.IsTrue(copy.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
result = copy.BeginAbortCopy(copyId,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
TestHelper.ExpectedException(
() => copy.EndAbortCopy(result),
"Aborting a copy operation after completion should fail",
HttpStatusCode.Conflict,
"NoPendingCopyOperation");
}
source.FetchAttributes();
Assert.IsNotNull(copy.Properties.ETag);
Assert.AreNotEqual(source.Properties.ETag, copy.Properties.ETag);
Assert.IsTrue(copy.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
string copyData = DownloadText(copy, Encoding.UTF8);
Assert.AreEqual(data, copyData, "Data inside copy of blob not similar");
copy.FetchAttributes();
BlobProperties prop1 = copy.Properties;
BlobProperties prop2 = source.Properties;
Assert.AreEqual(prop1.CacheControl, prop2.CacheControl);
Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding);
Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage);
Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5);
Assert.AreEqual(prop1.ContentType, prop2.ContentType);
Assert.AreEqual("value", copy.Metadata["Test"], false, "Copied metadata not same");
copy.Delete();
}
finally
{
container.DeleteIfExists();
}
}
private static ICloudBlob GetCloudBlobReference(BlobType type, CloudBlobContainer container)
{
ICloudBlob blob;
if (type == BlobType.BlockBlob)
{
blob = container.GetBlockBlobReference("blockblob");
}
else if (type == BlobType.PageBlob)
{
blob = container.GetPageBlobReference("pageblob");
}
else
{
blob = container.GetAppendBlobReference("appendblob");
}
return blob;
}
/// <summary>
/// create a new page blob with random properties and metadata
/// </summary>
/// <param name="container">CloudBlobContainer object</param>
/// <param name="blobName">blob name</param>
/// <returns>ICloudBlob object</returns>
public ICloudBlob CreatePageBlob(CloudBlobContainer container, string blobName)
{
CloudPageBlob pageBlob = container.GetPageBlobReference(blobName);
int size = random.Next(1, 10) * PageBlobUnitSize;
pageBlob.Create(size);
byte[] buffer = new byte[size];
string md5sum = Convert.ToBase64String(Helper.GetMD5(buffer));
pageBlob.Properties.ContentMD5 = md5sum;
GenerateBlobPropertiesAndMetaData(pageBlob);
Test.Info(string.Format("create page blob '{0}' in container '{1}'", blobName, container.Name));
return pageBlob;
}
private void TestAccess(string sasToken, SharedAccessBlobPermissions permissions, CloudBlobContainer container, ICloudBlob blob)
{
StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ?
new StorageCredentials() :
new StorageCredentials(sasToken);
if (container != null)
{
container = new CloudBlobContainer(container.Uri, credentials);
if (blob.BlobType == BlobType.BlockBlob)
{
blob = container.GetBlockBlobReference(blob.Name);
}
else
{
blob = container.GetPageBlobReference(blob.Name);
}
}
else
{
if (blob.BlobType == BlobType.BlockBlob)
{
blob = new CloudBlockBlob(blob.Uri, credentials);
}
else
{
blob = new CloudPageBlob(blob.Uri, credentials);
}
}
if (container != null)
{
if ((permissions & SharedAccessBlobPermissions.List) == SharedAccessBlobPermissions.List)
{
container.ListBlobs().ToArray();
}
else
{
TestHelper.ExpectedException(
() => container.ListBlobs().ToArray(),
"List blobs while SAS does not allow for listing",
HttpStatusCode.NotFound);
}
}
if ((permissions & SharedAccessBlobPermissions.Read) == SharedAccessBlobPermissions.Read)
{
blob.FetchAttributes();
}
else
{
TestHelper.ExpectedException(
() => blob.FetchAttributes(),
"Fetch blob attributes while SAS does not allow for reading",
HttpStatusCode.NotFound);
}
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
blob.SetMetadata();
}
else
{
TestHelper.ExpectedException(
() => blob.SetMetadata(),
"Set blob metadata while SAS does not allow for writing",
HttpStatusCode.NotFound);
}
if ((permissions & SharedAccessBlobPermissions.Delete) == SharedAccessBlobPermissions.Delete)
{
blob.Delete();
}
else
{
TestHelper.ExpectedException(
() => blob.Delete(),
"Delete blob while SAS does not allow for deleting",
HttpStatusCode.NotFound);
}
}
public async Task PageBlobWriteStreamBasicTestAsync()
{
byte[] buffer = GetRandomBuffer(6 * 512);
CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash();
CloudBlobContainer container = GetRandomContainerReference();
container.ServiceClient.DefaultRequestOptions.ParallelOperationThreadCount = 2;
try
{
await container.CreateAsync();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
blob.StreamWriteSizeInBytes = 8 * 512;
using (MemoryStream wholeBlob = new MemoryStream())
{
BlobRequestOptions options = new BlobRequestOptions()
{
StoreBlobContentMD5 = true,
};
using (IOutputStream writeStream = await blob.OpenWriteAsync(buffer.Length * 3, null, options, null))
{
Stream blobStream = writeStream.AsStreamForWrite();
for (int i = 0; i < 3; i++)
{
await blobStream.WriteAsync(buffer, 0, buffer.Length);
await wholeBlob.WriteAsync(buffer, 0, buffer.Length);
Assert.AreEqual(wholeBlob.Position, blobStream.Position);
hasher.Append(buffer.AsBuffer());
}
await blobStream.FlushAsync();
}
string md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset());
await blob.FetchAttributesAsync();
Assert.AreEqual(md5, blob.Properties.ContentMD5);
using (MemoryOutputStream downloadedBlob = new MemoryOutputStream())
{
await blob.DownloadToStreamAsync(downloadedBlob);
TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob.UnderlyingStream);
}
await TestHelper.ExpectedExceptionAsync <ArgumentException>(
async() => await blob.OpenWriteAsync(null, null, options, null),
"OpenWrite with StoreBlobContentMD5 on an existing page blob should fail");
using (IOutputStream writeStream = await blob.OpenWriteAsync(null))
{
Stream blobStream = writeStream.AsStreamForWrite();
blobStream.Seek(buffer.Length / 2, SeekOrigin.Begin);
wholeBlob.Seek(buffer.Length / 2, SeekOrigin.Begin);
for (int i = 0; i < 2; i++)
{
blobStream.Write(buffer, 0, buffer.Length);
wholeBlob.Write(buffer, 0, buffer.Length);
Assert.AreEqual(wholeBlob.Position, blobStream.Position);
}
await blobStream.FlushAsync();
}
await blob.FetchAttributesAsync();
Assert.AreEqual(md5, blob.Properties.ContentMD5);
using (MemoryOutputStream downloadedBlob = new MemoryOutputStream())
{
options.DisableContentMD5Validation = true;
await blob.DownloadToStreamAsync(downloadedBlob, null, options, null);
TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob.UnderlyingStream);
}
}
}
finally
{
container.DeleteAsync().AsTask().Wait();
}
}
private static void TestAccess(string sasToken, SharedAccessBlobPermissions permissions, SharedAccessBlobHeaders headers, CloudBlobContainer container, ICloudBlob blob)
{
StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ?
new StorageCredentials() :
new StorageCredentials(sasToken);
if (container != null)
{
container = new CloudBlobContainer(credentials.TransformUri(container.Uri));
if (blob.BlobType == BlobType.BlockBlob)
{
blob = container.GetBlockBlobReference(blob.Name);
}
else
{
blob = container.GetPageBlobReference(blob.Name);
}
}
else
{
if (blob.BlobType == BlobType.BlockBlob)
{
blob = new CloudBlockBlob(credentials.TransformUri(blob.Uri));
}
else
{
blob = new CloudPageBlob(credentials.TransformUri(blob.Uri));
}
}
if (container != null)
{
if ((permissions & SharedAccessBlobPermissions.List) == SharedAccessBlobPermissions.List)
{
container.ListBlobs().ToArray();
}
else
{
TestHelper.ExpectedException(
() => container.ListBlobs().ToArray(),
"List blobs while SAS does not allow for listing",
HttpStatusCode.NotFound);
}
}
if ((permissions & SharedAccessBlobPermissions.Read) == SharedAccessBlobPermissions.Read)
{
blob.FetchAttributes();
// Test headers
if (headers != null)
{
if (headers.CacheControl != null)
{
Assert.AreEqual(headers.CacheControl, blob.Properties.CacheControl);
}
if (headers.ContentDisposition != null)
{
Assert.AreEqual(headers.ContentDisposition, blob.Properties.ContentDisposition);
}
if (headers.ContentEncoding != null)
{
Assert.AreEqual(headers.ContentEncoding, blob.Properties.ContentEncoding);
}
if (headers.ContentLanguage != null)
{
Assert.AreEqual(headers.ContentLanguage, blob.Properties.ContentLanguage);
}
if (headers.ContentType != null)
{
Assert.AreEqual(headers.ContentType, blob.Properties.ContentType);
}
}
}
else
{
TestHelper.ExpectedException(
() => blob.FetchAttributes(),
"Fetch blob attributes while SAS does not allow for reading",
HttpStatusCode.NotFound);
}
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
blob.SetMetadata();
}
else
{
TestHelper.ExpectedException(
() => blob.SetMetadata(),
"Set blob metadata while SAS does not allow for writing",
HttpStatusCode.NotFound);
}
if ((permissions & SharedAccessBlobPermissions.Delete) == SharedAccessBlobPermissions.Delete)
{
blob.Delete();
}
else
{
TestHelper.ExpectedException(
() => blob.Delete(),
"Delete blob while SAS does not allow for deleting",
HttpStatusCode.NotFound);
}
}
private async Task IncrementalCopyAsyncImpl(int overload)
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudPageBlob source = container.GetPageBlobReference("source");
await source.CreateAsync(1024);
string data = new string('a', 512);
await UploadTextAsync(source, data, Encoding.UTF8);
CloudPageBlob sourceSnapshot = await source.CreateSnapshotAsync(null, null, null, null);
SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy()
{
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
Permissions = SharedAccessBlobPermissions.Read | SharedAccessBlobPermissions.Write,
};
string sasToken = sourceSnapshot.GetSharedAccessSignature(policy);
StorageCredentials blobSAS = new StorageCredentials(sasToken);
Uri sourceSnapshotUri = blobSAS.TransformUri(TestHelper.Defiddler(sourceSnapshot).SnapshotQualifiedUri);
StorageCredentials accountSAS = new StorageCredentials(sasToken);
CloudStorageAccount accountWithSAS = new CloudStorageAccount(accountSAS, source.ServiceClient.StorageUri, null, null, null);
CloudPageBlob snapshotWithSas = await accountWithSAS.CreateCloudBlobClient().GetBlobReferenceFromServerAsync(sourceSnapshot.SnapshotQualifiedUri) as CloudPageBlob;
CloudPageBlob copy = container.GetPageBlobReference("copy");
string copyId = null;
if (overload == 0)
{
#if !FACADE_NETCORE
copyId = await copy.StartIncrementalCopyAsync(accountSAS.TransformUri(TestHelper.Defiddler(snapshotWithSas).SnapshotQualifiedUri));
#else
Uri snapShotQualifiedUri = accountSAS.TransformUri(TestHelper.Defiddler(snapshotWithSas).SnapshotQualifiedUri);
copyId = await copy.StartIncrementalCopyAsync(new CloudPageBlob(new StorageUri(snapShotQualifiedUri), null, null));
#endif
}
else if (overload == 1)
{
#if !FACADE_NETCORE
CloudPageBlob blob = new CloudPageBlob(accountSAS.TransformUri(TestHelper.Defiddler(snapshotWithSas).SnapshotQualifiedUri));
#else
Uri snapShotQualifiedUri = accountSAS.TransformUri(TestHelper.Defiddler(snapshotWithSas).SnapshotQualifiedUri);
CloudPageBlob blob = new CloudPageBlob(new StorageUri(snapShotQualifiedUri), null, null);
#endif
copyId = await copy.StartIncrementalCopyAsync(blob);
}
else if (overload == 2)
{
#if !FACADE_NETCORE
CloudPageBlob blob = new CloudPageBlob(accountSAS.TransformUri(TestHelper.Defiddler(snapshotWithSas).SnapshotQualifiedUri));
#else
Uri snapShotQualifiedUri = accountSAS.TransformUri(TestHelper.Defiddler(snapshotWithSas).SnapshotQualifiedUri);
CloudPageBlob blob = new CloudPageBlob(new StorageUri(snapShotQualifiedUri), null, null);
#endif
copyId = await copy.StartIncrementalCopyAsync(blob, null, null, null, CancellationToken.None);
}
else
{
#if !FACADE_NETCORE
copyId = await copy.StartIncrementalCopyAsync(accountSAS.TransformUri(TestHelper.Defiddler(snapshotWithSas).SnapshotQualifiedUri), null, null, null, CancellationToken.None);
#else
Uri snapShotQualifiedUri = accountSAS.TransformUri(TestHelper.Defiddler(snapshotWithSas).SnapshotQualifiedUri);
CloudPageBlob blob = new CloudPageBlob(new StorageUri(snapShotQualifiedUri), null, null);
copyId = await copy.StartIncrementalCopyAsync(blob, null, null, null, CancellationToken.None);
#endif
}
await WaitForCopyAsync(copy);
Assert.AreEqual(BlobType.PageBlob, copy.BlobType);
Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status);
Assert.AreEqual(source.Uri.AbsolutePath, copy.CopyState.Source.AbsolutePath);
Assert.AreEqual(data.Length, copy.CopyState.TotalBytes);
Assert.AreEqual(data.Length, copy.CopyState.BytesCopied);
Assert.AreEqual(copyId, copy.CopyState.CopyId);
Assert.IsTrue(copy.Properties.IsIncrementalCopy);
Assert.IsTrue(copy.CopyState.DestinationSnapshotTime.HasValue);
Assert.IsTrue(copy.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
private static async Task TestAccessAsync(string sasToken, SharedAccessBlobPermissions permissions, SharedAccessBlobHeaders headers, CloudBlobContainer container, CloudBlob blob)
{
OperationContext operationContext = new OperationContext();
StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ?
new StorageCredentials() :
new StorageCredentials(sasToken);
if (container != null)
{
container = new CloudBlobContainer(container.Uri, credentials);
if (blob.BlobType == BlobType.BlockBlob)
{
blob = container.GetBlockBlobReference(blob.Name);
}
else
{
blob = container.GetPageBlobReference(blob.Name);
}
}
else
{
if (blob.BlobType == BlobType.BlockBlob)
{
blob = new CloudBlockBlob(blob.Uri, credentials);
}
else
{
blob = new CloudPageBlob(blob.Uri, credentials);
}
}
if (container != null)
{
if ((permissions & SharedAccessBlobPermissions.List) == SharedAccessBlobPermissions.List)
{
await container.ListBlobsSegmentedAsync(null);
}
else
{
await TestHelper.ExpectedExceptionAsync(
async() => await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.None, null, null, null, operationContext),
operationContext,
"List blobs while SAS does not allow for listing",
HttpStatusCode.NotFound);
}
}
if ((permissions & SharedAccessBlobPermissions.Read) == SharedAccessBlobPermissions.Read)
{
await blob.FetchAttributesAsync();
// Test headers
if (headers != null)
{
if (headers.CacheControl != null)
{
Assert.AreEqual(headers.CacheControl, blob.Properties.CacheControl);
}
if (headers.ContentDisposition != null)
{
Assert.AreEqual(headers.ContentDisposition, blob.Properties.ContentDisposition);
}
if (headers.ContentEncoding != null)
{
Assert.AreEqual(headers.ContentEncoding, blob.Properties.ContentEncoding);
}
if (headers.ContentLanguage != null)
{
Assert.AreEqual(headers.ContentLanguage, blob.Properties.ContentLanguage);
}
if (headers.ContentType != null)
{
Assert.AreEqual(headers.ContentType, blob.Properties.ContentType);
}
}
}
else
{
await TestHelper.ExpectedExceptionAsync(
async() => await blob.FetchAttributesAsync(null, null, operationContext),
operationContext,
"Fetch blob attributes while SAS does not allow for reading",
HttpStatusCode.NotFound);
}
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
await blob.SetMetadataAsync();
}
else
{
await TestHelper.ExpectedExceptionAsync(
async() => await blob.SetMetadataAsync(null, null, operationContext),
operationContext,
"Set blob metadata while SAS does not allow for writing",
HttpStatusCode.NotFound);
}
if ((permissions & SharedAccessBlobPermissions.Delete) == SharedAccessBlobPermissions.Delete)
{
await blob.DeleteAsync();
}
else
{
await TestHelper.ExpectedExceptionAsync(
async() => await blob.DeleteAsync(DeleteSnapshotsOption.None, null, null, operationContext),
operationContext,
"Delete blob while SAS does not allow for deleting",
HttpStatusCode.NotFound);
}
}
public void UseTransactionalMD5PutTestAPM()
{
BlobRequestOptions optionsWithNoMD5 = new BlobRequestOptions()
{
UseTransactionalMD5 = false,
};
BlobRequestOptions optionsWithMD5 = new BlobRequestOptions()
{
UseTransactionalMD5 = true,
};
byte[] buffer = GetRandomBuffer(1024);
MD5 hasher = MD5.Create();
string md5 = Convert.ToBase64String(hasher.ComputeHash(buffer));
string lastCheckMD5 = null;
int checkCount = 0;
OperationContext opContextWithMD5Check = new OperationContext();
opContextWithMD5Check.SendingRequest += (_, args) =>
{
if (args.Request.ContentLength >= buffer.Length)
{
lastCheckMD5 = args.Request.Headers[HttpRequestHeader.ContentMd5];
checkCount++;
}
};
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result;
CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1");
List <string> blockIds = GetBlockIdList(3);
checkCount = 0;
using (Stream blockData = new MemoryStream(buffer))
{
result = blockBlob.BeginPutBlock(blockIds[0], blockData, null, null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
blockBlob.EndPutBlock(result);
Assert.IsNull(lastCheckMD5);
blockData.Seek(0, SeekOrigin.Begin);
result = blockBlob.BeginPutBlock(blockIds[1], blockData, null, null, optionsWithMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
blockBlob.EndPutBlock(result);
Assert.AreEqual(md5, lastCheckMD5);
blockData.Seek(0, SeekOrigin.Begin);
result = blockBlob.BeginPutBlock(blockIds[2], blockData, md5, null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
blockBlob.EndPutBlock(result);
Assert.AreEqual(md5, lastCheckMD5);
}
Assert.AreEqual(3, checkCount);
CloudPageBlob pageBlob = container.GetPageBlobReference("blob2");
pageBlob.Create(buffer.Length);
checkCount = 0;
using (Stream pageData = new MemoryStream(buffer))
{
result = pageBlob.BeginWritePages(pageData, 0, null, null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
pageBlob.EndWritePages(result);
Assert.IsNull(lastCheckMD5);
pageData.Seek(0, SeekOrigin.Begin);
result = pageBlob.BeginWritePages(pageData, 0, null, null, optionsWithMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
pageBlob.EndWritePages(result);
Assert.AreEqual(md5, lastCheckMD5);
pageData.Seek(0, SeekOrigin.Begin);
result = pageBlob.BeginWritePages(pageData, 0, md5, null, optionsWithNoMD5, opContextWithMD5Check,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
pageBlob.EndWritePages(result);
Assert.AreEqual(md5, lastCheckMD5);
}
Assert.AreEqual(3, checkCount);
}
}
finally
{
container.DeleteIfExists();
}
}
private async Task CloudPageBlobUploadFromStreamAsync(CloudBlobContainer container, int size, AccessCondition accessCondition, OperationContext operationContext, int startOffset)
{
byte[] buffer = GetRandomBuffer(size);
CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash();
hasher.Append(buffer.AsBuffer(startOffset, buffer.Length - startOffset));
string md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset());
CloudPageBlob blob = container.GetPageBlobReference("blob1");
blob.StreamWriteSizeInBytes = 512;
using (MemoryStream originalBlob = new MemoryStream())
{
originalBlob.Write(buffer, startOffset, buffer.Length - startOffset);
using (MemoryStream sourceStream = new MemoryStream(buffer))
{
sourceStream.Seek(startOffset, SeekOrigin.Begin);
BlobRequestOptions options = new BlobRequestOptions()
{
StoreBlobContentMD5 = true,
};
await blob.UploadFromStreamAsync(sourceStream.AsInputStream(), accessCondition, options, operationContext);
}
await blob.FetchAttributesAsync();
Assert.AreEqual(md5, blob.Properties.ContentMD5);
using (MemoryStream downloadedBlob = new MemoryStream())
{
await blob.DownloadToStreamAsync(downloadedBlob.AsOutputStream());
TestHelper.AssertStreamsAreEqual(originalBlob, downloadedBlob);
}
}
}
public async Task PageBlobReadLockToETagTestAsync()
{
byte[] outBuffer = new byte[1 * 1024 * 1024];
byte[] buffer = GetRandomBuffer(2 * outBuffer.Length);
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
blob.StreamMinimumReadSizeInBytes = outBuffer.Length;
using (MemoryStream wholeBlob = new MemoryStream(buffer))
{
await blob.UploadFromStreamAsync(wholeBlob.AsInputStream());
}
OperationContext opContext = new OperationContext();
using (IRandomAccessStreamWithContentType blobStream = await blob.OpenReadAsync(null, null, opContext))
{
Stream blobStreamForRead = blobStream.AsStreamForRead();
await blob.SetMetadataAsync();
await blobStreamForRead.ReadAsync(outBuffer, 0, outBuffer.Length);
await blob.SetMetadataAsync();
await TestHelper.ExpectedExceptionAsync(
async() => await blobStreamForRead.ReadAsync(outBuffer, 0, outBuffer.Length),
opContext,
"Blob read stream should fail if blob is modified during read",
HttpStatusCode.PreconditionFailed);
}
opContext = new OperationContext();
using (IRandomAccessStreamWithContentType blobStream = await blob.OpenReadAsync(null, null, opContext))
{
Stream blobStreamForRead = blobStream.AsStreamForRead();
await blob.SetMetadataAsync();
long length = blobStreamForRead.Length;
await blob.SetMetadataAsync();
await TestHelper.ExpectedExceptionAsync(
async() => await blobStreamForRead.ReadAsync(outBuffer, 0, outBuffer.Length),
opContext,
"Blob read stream should fail if blob is modified during read",
HttpStatusCode.PreconditionFailed);
}
opContext = new OperationContext();
AccessCondition accessCondition = AccessCondition.GenerateIfNotModifiedSinceCondition(DateTimeOffset.Now);
using (IRandomAccessStreamWithContentType blobStream = await blob.OpenReadAsync(accessCondition, null, opContext))
{
Stream blobStreamForRead = blobStream.AsStreamForRead();
await blob.SetMetadataAsync();
await blobStreamForRead.ReadAsync(outBuffer, 0, outBuffer.Length);
await blob.SetMetadataAsync();
await TestHelper.ExpectedExceptionAsync(
async() => await blobStreamForRead.ReadAsync(outBuffer, 0, outBuffer.Length),
opContext,
"Blob read stream should fail if blob is modified during read",
HttpStatusCode.PreconditionFailed);
}
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
public async Task DisableContentMD5ValidationTestAsync()
{
byte[] buffer = new byte[1024];
Random random = new Random();
random.NextBytes(buffer);
BlobRequestOptions optionsWithNoMD5 = new BlobRequestOptions()
{
DisableContentMD5Validation = true,
StoreBlobContentMD5 = true,
};
BlobRequestOptions optionsWithMD5 = new BlobRequestOptions()
{
DisableContentMD5Validation = false,
StoreBlobContentMD5 = true,
};
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1");
using (Stream stream = new NonSeekableMemoryStream(buffer))
{
await blockBlob.UploadFromStreamAsync(stream, null, optionsWithMD5, null);
}
using (Stream stream = new MemoryStream())
{
await blockBlob.DownloadToStreamAsync(stream, null, optionsWithMD5, null);
await blockBlob.DownloadToStreamAsync(stream, null, optionsWithNoMD5, null);
using (var blobStream = await blockBlob.OpenReadAsync(null, optionsWithMD5, null))
{
Stream blobStreamForRead = blobStream;
int read;
do
{
read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length);
}while (read > 0);
}
using (var blobStream = await blockBlob.OpenReadAsync(null, optionsWithNoMD5, null))
{
Stream blobStreamForRead = blobStream;
int read;
do
{
read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length);
}while (read > 0);
}
blockBlob.Properties.ContentMD5 = "MDAwMDAwMDA=";
await blockBlob.SetPropertiesAsync();
OperationContext opContext = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await blockBlob.DownloadToStreamAsync(stream, null, optionsWithMD5, opContext),
opContext,
"Downloading a blob with invalid MD5 should fail",
HttpStatusCode.OK);
await blockBlob.DownloadToStreamAsync(stream, null, optionsWithNoMD5, null);
using (var blobStream = await blockBlob.OpenReadAsync(null, optionsWithMD5, null))
{
Stream blobStreamForRead = blobStream;
TestHelper.ExpectedException <IOException>(
() =>
{
int read;
do
{
read = blobStreamForRead.Read(buffer, 0, buffer.Length);
}while (read > 0);
},
"Downloading a blob with invalid MD5 should fail");
}
using (var blobStream = await blockBlob.OpenReadAsync(null, optionsWithNoMD5, null))
{
Stream blobStreamForRead = blobStream;
int read;
do
{
read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length);
}while (read > 0);
}
}
CloudPageBlob pageBlob = container.GetPageBlobReference("blob2");
using (Stream stream = new MemoryStream(buffer))
{
await pageBlob.UploadFromStreamAsync(stream, null, optionsWithMD5, null);
}
using (Stream stream = new MemoryStream())
{
await pageBlob.DownloadToStreamAsync(stream, null, optionsWithMD5, null);
await pageBlob.DownloadToStreamAsync(stream, null, optionsWithNoMD5, null);
using (var blobStream = await pageBlob.OpenReadAsync(null, optionsWithMD5, null))
{
Stream blobStreamForRead = blobStream;
int read;
do
{
read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length);
}while (read > 0);
}
using (var blobStream = await pageBlob.OpenReadAsync(null, optionsWithNoMD5, null))
{
Stream blobStreamForRead = blobStream;
int read;
do
{
read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length);
}while (read > 0);
}
pageBlob.Properties.ContentMD5 = "MDAwMDAwMDA=";
await pageBlob.SetPropertiesAsync();
OperationContext opContext = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await pageBlob.DownloadToStreamAsync(stream, null, optionsWithMD5, opContext),
opContext,
"Downloading a blob with invalid MD5 should fail",
HttpStatusCode.OK);
await pageBlob.DownloadToStreamAsync(stream, null, optionsWithNoMD5, null);
using (var blobStream = await pageBlob.OpenReadAsync(null, optionsWithMD5, null))
{
Stream blobStreamForRead = blobStream;
TestHelper.ExpectedException <IOException>(
() =>
{
int read;
do
{
read = blobStreamForRead.Read(buffer, 0, buffer.Length);
}while (read > 0);
},
"Downloading a blob with invalid MD5 should fail");
}
using (var blobStream = await pageBlob.OpenReadAsync(null, optionsWithNoMD5, null))
{
Stream blobStreamForRead = blobStream;
int read;
do
{
read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length);
}while (read > 0);
}
}
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
public async Task StoreBlobContentMD5TestAsync()
{
BlobRequestOptions optionsWithNoMD5 = new BlobRequestOptions()
{
StoreBlobContentMD5 = false,
};
BlobRequestOptions optionsWithMD5 = new BlobRequestOptions()
{
StoreBlobContentMD5 = true,
};
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudBlockBlob blob1 = container.GetBlockBlobReference("blob1");
using (Stream stream = new NonSeekableMemoryStream())
{
await blob1.UploadFromStreamAsync(stream, null, optionsWithMD5, null);
}
await blob1.FetchAttributesAsync();
Assert.IsNotNull(blob1.Properties.ContentMD5);
blob1 = container.GetBlockBlobReference("blob2");
using (Stream stream = new NonSeekableMemoryStream())
{
await blob1.UploadFromStreamAsync(stream, null, optionsWithNoMD5, null);
}
await blob1.FetchAttributesAsync();
Assert.IsNull(blob1.Properties.ContentMD5);
blob1 = container.GetBlockBlobReference("blob3");
using (Stream stream = new NonSeekableMemoryStream())
{
await blob1.UploadFromStreamAsync(stream);
}
await blob1.FetchAttributesAsync();
Assert.IsNotNull(blob1.Properties.ContentMD5);
CloudPageBlob blob2 = container.GetPageBlobReference("blob4");
blob2 = container.GetPageBlobReference("blob4");
using (Stream stream = new MemoryStream())
{
await blob2.UploadFromStreamAsync(stream, null, optionsWithMD5, null);
}
await blob2.FetchAttributesAsync();
Assert.IsNotNull(blob2.Properties.ContentMD5);
blob2 = container.GetPageBlobReference("blob5");
using (Stream stream = new MemoryStream())
{
await blob2.UploadFromStreamAsync(stream, null, optionsWithNoMD5, null);
}
await blob2.FetchAttributesAsync();
Assert.IsNull(blob2.Properties.ContentMD5);
blob2 = container.GetPageBlobReference("blob6");
using (Stream stream = new MemoryStream())
{
await blob2.UploadFromStreamAsync(stream);
}
await blob2.FetchAttributesAsync();
Assert.IsNull(blob2.Properties.ContentMD5);
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
private async Task TestAccessAsync(string sasToken, SharedAccessBlobPermissions permissions, CloudBlobContainer container, ICloudBlob blob)
{
OperationContext operationContext = new OperationContext();
StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ?
new StorageCredentials() :
new StorageCredentials(sasToken);
if (container != null)
{
container = new CloudBlobContainer(container.Uri, credentials);
if (blob.BlobType == BlobType.BlockBlob)
{
blob = container.GetBlockBlobReference(blob.Name);
}
else
{
blob = container.GetPageBlobReference(blob.Name);
}
}
else
{
if (blob.BlobType == BlobType.BlockBlob)
{
blob = new CloudBlockBlob(blob.Uri, credentials);
}
else
{
blob = new CloudPageBlob(blob.Uri, credentials);
}
}
if (container != null)
{
if ((permissions & SharedAccessBlobPermissions.List) == SharedAccessBlobPermissions.List)
{
await container.ListBlobsSegmentedAsync(null);
}
else
{
await TestHelper.ExpectedExceptionAsync(
async () => await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.None, null, null, null, operationContext),
operationContext,
"List blobs while SAS does not allow for listing",
HttpStatusCode.NotFound);
}
}
if ((permissions & SharedAccessBlobPermissions.Read) == SharedAccessBlobPermissions.Read)
{
await blob.FetchAttributesAsync();
}
else
{
await TestHelper.ExpectedExceptionAsync(
async () => await blob.FetchAttributesAsync(null, null, operationContext),
operationContext,
"Fetch blob attributes while SAS does not allow for reading",
HttpStatusCode.NotFound);
}
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
await blob.SetMetadataAsync();
}
else
{
await TestHelper.ExpectedExceptionAsync(
async () => await blob.SetMetadataAsync(null, null, operationContext),
operationContext,
"Set blob metadata while SAS does not allow for writing",
HttpStatusCode.NotFound);
}
if ((permissions & SharedAccessBlobPermissions.Delete) == SharedAccessBlobPermissions.Delete)
{
await blob.DeleteAsync();
}
else
{
await TestHelper.ExpectedExceptionAsync(
async () => await blob.DeleteAsync(DeleteSnapshotsOption.None, null, null, operationContext),
operationContext,
"Delete blob while SAS does not allow for deleting",
HttpStatusCode.NotFound);
}
}
public async Task CloudBlobClientMaximumExecutionTimeoutAsync()
{
CloudBlobClient blobClient = GenerateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference(Guid.NewGuid().ToString("N"));
byte[] buffer = BlobTestBase.GetRandomBuffer(80 * 1024 * 1024);
try
{
await container.CreateAsync();
blobClient.DefaultRequestOptions.MaximumExecutionTime = TimeSpan.FromSeconds(5);
blobClient.DefaultRequestOptions.SingleBlobUploadThresholdInBytes = 2 * 1024 * 1024;
CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1");
blockBlob.StreamWriteSizeInBytes = 1 * 1024 * 1024;
using (MemoryStream ms = new MemoryStream(buffer))
{
try
{
await blockBlob.UploadFromStreamAsync(ms);
Assert.Fail();
}
catch (AggregateException ex)
{
#if !FACADE_NETCORE
Assert.AreEqual("The client could not finish the operation within specified timeout.", RequestResult.TranslateFromExceptionMessage(ex.InnerException.Message).ExceptionInfo.Message);
#else
Assert.AreEqual("The client could not finish the operation within specified timeout.", RequestResult.TranslateFromExceptionMessage(ex.InnerException.Message).Exception.Message);
#endif
}
catch (TaskCanceledException)
{
}
}
CloudPageBlob pageBlob = container.GetPageBlobReference("blob2");
pageBlob.StreamWriteSizeInBytes = 1 * 1024 * 1024;
using (MemoryStream ms = new MemoryStream(buffer))
{
try
{
await pageBlob.UploadFromStreamAsync(ms);
Assert.Fail();
}
catch (AggregateException ex)
{
#if !FACADE_NETCORE
Assert.AreEqual("The client could not finish the operation within specified timeout.", RequestResult.TranslateFromExceptionMessage(ex.InnerException.Message).ExceptionInfo.Message);
#else
Assert.AreEqual("The client could not finish the operation within specified timeout.", RequestResult.TranslateFromExceptionMessage(ex.InnerException.Message).Exception.Message);
#endif
}
catch (TaskCanceledException)
{
}
}
}
finally
{
blobClient.DefaultRequestOptions.MaximumExecutionTime = null;
container.DeleteIfExistsAsync().Wait();
}
}
private static async Task TestAccessAsync(string sasToken, SharedAccessBlobPermissions permissions, SharedAccessBlobHeaders headers, CloudBlobContainer container, CloudBlob blob)
{
OperationContext operationContext = new OperationContext();
StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ?
new StorageCredentials() :
new StorageCredentials(sasToken);
if (container != null)
{
container = new CloudBlobContainer(container.Uri, credentials);
if (blob.BlobType == BlobType.BlockBlob)
{
blob = container.GetBlockBlobReference(blob.Name);
}
else
{
blob = container.GetPageBlobReference(blob.Name);
}
}
else
{
if (blob.BlobType == BlobType.BlockBlob)
{
blob = new CloudBlockBlob(blob.Uri, credentials);
}
else
{
blob = new CloudPageBlob(blob.Uri, credentials);
}
}
if (container != null)
{
if ((permissions & SharedAccessBlobPermissions.List) == SharedAccessBlobPermissions.List)
{
await container.ListBlobsSegmentedAsync(null);
}
else
{
await TestHelper.ExpectedExceptionAsync(
async () => await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.None, null, null, null, operationContext),
operationContext,
"List blobs while SAS does not allow for listing",
HttpStatusCode.Forbidden);
}
}
if ((permissions & SharedAccessBlobPermissions.Read) == SharedAccessBlobPermissions.Read)
{
await blob.FetchAttributesAsync();
// Test headers
if (headers != null)
{
if (headers.CacheControl != null)
{
Assert.AreEqual(headers.CacheControl, blob.Properties.CacheControl);
}
if (headers.ContentDisposition != null)
{
Assert.AreEqual(headers.ContentDisposition, blob.Properties.ContentDisposition);
}
if (headers.ContentEncoding != null)
{
Assert.AreEqual(headers.ContentEncoding, blob.Properties.ContentEncoding);
}
if (headers.ContentLanguage != null)
{
Assert.AreEqual(headers.ContentLanguage, blob.Properties.ContentLanguage);
}
if (headers.ContentType != null)
{
Assert.AreEqual(headers.ContentType, blob.Properties.ContentType);
}
}
}
else
{
await TestHelper.ExpectedExceptionAsync(
async () => await blob.FetchAttributesAsync(null, null, operationContext),
operationContext,
"Fetch blob attributes while SAS does not allow for reading",
HttpStatusCode.Forbidden);
}
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
await blob.SetMetadataAsync();
}
else
{
await TestHelper.ExpectedExceptionAsync(
async () => await blob.SetMetadataAsync(null, null, operationContext),
operationContext,
"Set blob metadata while SAS does not allow for writing",
HttpStatusCode.Forbidden);
}
if ((permissions & SharedAccessBlobPermissions.Delete) == SharedAccessBlobPermissions.Delete)
{
await blob.DeleteAsync();
}
else
{
await TestHelper.ExpectedExceptionAsync(
async () => await blob.DeleteAsync(DeleteSnapshotsOption.None, null, null, operationContext),
operationContext,
"Delete blob while SAS does not allow for deleting",
HttpStatusCode.Forbidden);
}
}
public async Task CloudBlobContainerGetBlobReferenceFromServerAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy()
{
Permissions = SharedAccessBlobPermissions.Read,
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
};
CloudBlockBlob blockBlob = container.GetBlockBlobReference("bb");
await blockBlob.PutBlockListAsync(new List <string>());
CloudPageBlob pageBlob = container.GetPageBlobReference("pb");
await pageBlob.CreateAsync(0);
CloudAppendBlob appendBlob = container.GetAppendBlobReference("ab");
await appendBlob.CreateOrReplaceAsync();
CloudBlobClient client;
ICloudBlob blob;
blob = await container.GetBlobReferenceFromServerAsync("bb");
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.Equals(blockBlob.StorageUri));
CloudBlockBlob blockBlobSnapshot = await((CloudBlockBlob)blob).CreateSnapshotAsync();
await blob.SetPropertiesAsync();
Uri blockBlobSnapshotUri = new Uri(blockBlobSnapshot.Uri.AbsoluteUri + "?snapshot=" + blockBlobSnapshot.SnapshotTime.Value.UtcDateTime.ToString("o"));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(blockBlobSnapshotUri);
AssertAreEqual(blockBlobSnapshot.Properties, blob.Properties);
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(blockBlobSnapshot.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.GetBlobReferenceFromServerAsync("pb");
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.Equals(pageBlob.StorageUri));
CloudPageBlob pageBlobSnapshot = await((CloudPageBlob)blob).CreateSnapshotAsync();
await blob.SetPropertiesAsync();
Uri pageBlobSnapshotUri = new Uri(pageBlobSnapshot.Uri.AbsoluteUri + "?snapshot=" + pageBlobSnapshot.SnapshotTime.Value.UtcDateTime.ToString("o"));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(pageBlobSnapshotUri);
AssertAreEqual(pageBlobSnapshot.Properties, blob.Properties);
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(pageBlobSnapshot.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.GetBlobReferenceFromServerAsync("ab");
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.Equals(appendBlob.StorageUri));
CloudAppendBlob appendBlobSnapshot = await((CloudAppendBlob)blob).CreateSnapshotAsync();
await blob.SetPropertiesAsync();
Uri appendBlobSnapshotUri = new Uri(appendBlobSnapshot.Uri.AbsoluteUri + "?snapshot=" + appendBlobSnapshot.SnapshotTime.Value.UtcDateTime.ToString("o"));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(appendBlobSnapshotUri);
AssertAreEqual(appendBlobSnapshot.Properties, blob.Properties);
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(appendBlobSnapshot.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(blockBlob.Uri);
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(blockBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(pageBlob.Uri);
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(pageBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(appendBlob.Uri);
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(appendBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(blockBlob.StorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.Equals(blockBlob.StorageUri));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(pageBlob.StorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.Equals(pageBlob.StorageUri));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(appendBlob.StorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.Equals(appendBlob.StorageUri));
string blockBlobToken = blockBlob.GetSharedAccessSignature(policy);
StorageCredentials blockBlobSAS = new StorageCredentials(blockBlobToken);
Uri blockBlobSASUri = blockBlobSAS.TransformUri(blockBlob.Uri);
StorageUri blockBlobSASStorageUri = blockBlobSAS.TransformUri(blockBlob.StorageUri);
string appendBlobToken = appendBlob.GetSharedAccessSignature(policy);
StorageCredentials appendBlobSAS = new StorageCredentials(appendBlobToken);
Uri appendBlobSASUri = appendBlobSAS.TransformUri(appendBlob.Uri);
StorageUri appendBlobSASStorageUri = appendBlobSAS.TransformUri(appendBlob.StorageUri);
string pageBlobToken = pageBlob.GetSharedAccessSignature(policy);
StorageCredentials pageBlobSAS = new StorageCredentials(pageBlobToken);
Uri pageBlobSASUri = pageBlobSAS.TransformUri(pageBlob.Uri);
StorageUri pageBlobSASStorageUri = pageBlobSAS.TransformUri(pageBlob.StorageUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(blockBlobSASUri);
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(blockBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(pageBlobSASUri);
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(pageBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(appendBlobSASUri);
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(appendBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(blockBlobSASStorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.Equals(blockBlob.StorageUri));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(pageBlobSASStorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.Equals(pageBlob.StorageUri));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(appendBlobSASStorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.Equals(appendBlob.StorageUri));
client = new CloudBlobClient(container.ServiceClient.BaseUri, blockBlobSAS);
blob = await client.GetBlobReferenceFromServerAsync(blockBlobSASUri);
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(blockBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
client = new CloudBlobClient(container.ServiceClient.BaseUri, pageBlobSAS);
blob = await client.GetBlobReferenceFromServerAsync(pageBlobSASUri);
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(pageBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
client = new CloudBlobClient(container.ServiceClient.BaseUri, appendBlobSAS);
blob = await client.GetBlobReferenceFromServerAsync(appendBlobSASUri);
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(appendBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
client = new CloudBlobClient(container.ServiceClient.StorageUri, blockBlobSAS);
blob = await client.GetBlobReferenceFromServerAsync(blockBlobSASStorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.Equals(blockBlob.StorageUri));
client = new CloudBlobClient(container.ServiceClient.StorageUri, pageBlobSAS);
blob = await client.GetBlobReferenceFromServerAsync(pageBlobSASStorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.Equals(pageBlob.StorageUri));
client = new CloudBlobClient(container.ServiceClient.StorageUri, appendBlobSAS);
blob = await client.GetBlobReferenceFromServerAsync(appendBlobSASStorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.Equals(appendBlob.StorageUri));
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
private void CloudPageBlobUploadFromStream(CloudBlobContainer container, int size, long? copyLength, AccessCondition accessCondition, int startOffset, bool isAsync, bool testMd5)
{
byte[] buffer = GetRandomBuffer(size);
MD5 hasher = MD5.Create();
string md5 = string.Empty;
if (testMd5)
{
md5 = Convert.ToBase64String(hasher.ComputeHash(buffer, startOffset, copyLength.HasValue ? (int)copyLength : buffer.Length - startOffset));
}
CloudPageBlob blob = container.GetPageBlobReference("blob1");
blob.StreamWriteSizeInBytes = 512;
using (MemoryStream originalBlob = new MemoryStream())
{
originalBlob.Write(buffer, startOffset, buffer.Length - startOffset);
using (MemoryStream sourceStream = new MemoryStream(buffer))
{
sourceStream.Seek(startOffset, SeekOrigin.Begin);
BlobRequestOptions options = new BlobRequestOptions()
{
StoreBlobContentMD5 = true,
};
if (isAsync)
{
using (ManualResetEvent waitHandle = new ManualResetEvent(false))
{
if (copyLength.HasValue)
{
ICancellableAsyncResult result = blob.BeginUploadFromStream(
sourceStream, copyLength.Value, accessCondition, options, null, ar => waitHandle.Set(), null);
waitHandle.WaitOne();
blob.EndUploadFromStream(result);
}
else
{
ICancellableAsyncResult result = blob.BeginUploadFromStream(
sourceStream, accessCondition, options, null, ar => waitHandle.Set(), null);
waitHandle.WaitOne();
blob.EndUploadFromStream(result);
}
}
}
else
{
if (copyLength.HasValue)
{
blob.UploadFromStream(sourceStream, copyLength.Value, accessCondition, options);
}
else
{
blob.UploadFromStream(sourceStream, accessCondition, options);
}
}
}
blob.FetchAttributes();
if (testMd5)
{
Assert.AreEqual(md5, blob.Properties.ContentMD5);
}
using (MemoryStream downloadedBlob = new MemoryStream())
{
if (isAsync)
{
using (ManualResetEvent waitHandle = new ManualResetEvent(false))
{
ICancellableAsyncResult result = blob.BeginDownloadToStream(downloadedBlob,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
blob.EndDownloadToStream(result);
}
}
else
{
blob.DownloadToStream(downloadedBlob);
}
TestHelper.AssertStreamsAreEqualAtIndex(
originalBlob,
downloadedBlob,
0,
0,
copyLength.HasValue ? (int)copyLength : (int)originalBlob.Length);
}
}
}
public async Task CloudPageBlobCopyFromSnapshotTestAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudPageBlob source = container.GetPageBlobReference("source");
string data = new string('a', 512);
await UploadTextAsync(source, data, Encoding.UTF8);
source.Metadata["Test"] = "value";
await source.SetMetadataAsync();
CloudPageBlob snapshot = await source.CreateSnapshotAsync();
//Modify source
string newData = new string('b', 512);
source.Metadata["Test"] = "newvalue";
await source.SetMetadataAsync();
source.Properties.ContentMD5 = null;
await UploadTextAsync(source, newData, Encoding.UTF8);
Assert.AreEqual(newData, await DownloadTextAsync(source, Encoding.UTF8), "Source is modified correctly");
Assert.AreEqual(data, await DownloadTextAsync(snapshot, Encoding.UTF8), "Modifying source blob should not modify snapshot");
await source.FetchAttributesAsync();
await snapshot.FetchAttributesAsync();
Assert.AreNotEqual(source.Metadata["Test"], snapshot.Metadata["Test"], "Source and snapshot metadata should be independent");
CloudPageBlob copy = container.GetPageBlobReference("copy");
await copy.StartCopyFromBlobAsync(TestHelper.Defiddler(snapshot));
await WaitForCopyAsync(copy);
Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status);
Assert.AreEqual(data, await DownloadTextAsync(copy, Encoding.UTF8), "Data inside copy of blob not similar");
await copy.FetchAttributesAsync();
BlobProperties prop1 = copy.Properties;
BlobProperties prop2 = snapshot.Properties;
Assert.AreEqual(prop1.CacheControl, prop2.CacheControl);
Assert.AreEqual(prop1.ContentDisposition, prop2.ContentDisposition);
Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding);
Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage);
Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5);
Assert.AreEqual(prop1.ContentType, prop2.ContentType);
Assert.AreEqual("value", copy.Metadata["Test"], false, "Copied metadata not same");
await copy.DeleteAsync();
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
private void CloudPageBlobUploadFromStreamTask(CloudBlobContainer container, int size, long? copyLength, AccessCondition accessCondition, int startOffset, bool testMd5)
{
try
{
byte[] buffer = GetRandomBuffer(size);
MD5 hasher = MD5.Create();
string md5 = string.Empty;
if (testMd5)
{
md5 = Convert.ToBase64String(hasher.ComputeHash(buffer, startOffset, copyLength.HasValue ? (int)copyLength : buffer.Length - startOffset));
}
CloudPageBlob blob = container.GetPageBlobReference("blob1");
blob.StreamWriteSizeInBytes = 512;
using (MemoryStream originalBlob = new MemoryStream())
{
originalBlob.Write(buffer, startOffset, buffer.Length - startOffset);
using (MemoryStream sourceStream = new MemoryStream(buffer))
{
sourceStream.Seek(startOffset, SeekOrigin.Begin);
BlobRequestOptions options = new BlobRequestOptions()
{
StoreBlobContentMD5 = true,
};
if (copyLength.HasValue)
{
blob.UploadFromStreamAsync(sourceStream, copyLength.Value, accessCondition, options, null).Wait();
}
else
{
blob.UploadFromStreamAsync(sourceStream, accessCondition, options, null).Wait();
}
}
blob.FetchAttributesAsync().Wait();
if (testMd5)
{
Assert.AreEqual(md5, blob.Properties.ContentMD5);
}
using (MemoryStream downloadedBlob = new MemoryStream())
{
blob.DownloadToStreamAsync(downloadedBlob).Wait();
TestHelper.AssertStreamsAreEqualAtIndex(
originalBlob,
downloadedBlob,
0,
0,
copyLength.HasValue ? (int)copyLength : (int)originalBlob.Length);
}
}
}
catch (AggregateException ex)
{
throw ex.InnerException;
}
}
public void CloudBlobContainerGetBlobReferenceFromServerAPM()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy()
{
Permissions = SharedAccessBlobPermissions.Read,
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
};
CloudBlockBlob blockBlob = container.GetBlockBlobReference("bb");
blockBlob.PutBlockList(new string[] { });
CloudPageBlob pageBlob = container.GetPageBlobReference("pb");
pageBlob.Create(0);
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result = container.BeginGetBlobReferenceFromServer("bb",
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
ICloudBlob blob1 = container.EndGetBlobReferenceFromServer(result);
Assert.IsInstanceOfType(blob1, typeof(CloudBlockBlob));
result = ((CloudBlockBlob)blob1).BeginCreateSnapshot(
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
CloudBlockBlob blob1Snapshot = ((CloudBlockBlob)blob1).EndCreateSnapshot(result);
result = blob1.BeginSetProperties(
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
blob1.EndSetProperties(result);
Uri blob1SnapshotUri = new Uri(blob1Snapshot.Uri.AbsoluteUri + "?snapshot=" + blob1Snapshot.SnapshotTime.Value.UtcDateTime.ToString("o"));
result = container.ServiceClient.BeginGetBlobReferenceFromServer(blob1SnapshotUri,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
ICloudBlob blob1SnapshotReference = container.ServiceClient.EndGetBlobReferenceFromServer(result);
AssertAreEqual(blob1Snapshot.Properties, blob1SnapshotReference.Properties);
result = container.BeginGetBlobReferenceFromServer("pb",
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
ICloudBlob blob2 = container.EndGetBlobReferenceFromServer(result);
Assert.IsInstanceOfType(blob2, typeof(CloudPageBlob));
result = ((CloudPageBlob)blob2).BeginCreateSnapshot(
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
CloudPageBlob blob2Snapshot = ((CloudPageBlob)blob2).EndCreateSnapshot(result);
result = blob2.BeginSetProperties(
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
blob2.EndSetProperties(result);
Uri blob2SnapshotUri = new Uri(blob2Snapshot.Uri.AbsoluteUri + "?snapshot=" + blob2Snapshot.SnapshotTime.Value.UtcDateTime.ToString("o"));
result = container.ServiceClient.BeginGetBlobReferenceFromServer(blob2SnapshotUri,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
ICloudBlob blob2SnapshotReference = container.ServiceClient.EndGetBlobReferenceFromServer(result);
AssertAreEqual(blob2Snapshot.Properties, blob2SnapshotReference.Properties);
result = container.ServiceClient.BeginGetBlobReferenceFromServer(blockBlob.Uri,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
ICloudBlob blob3 = container.ServiceClient.EndGetBlobReferenceFromServer(result);
Assert.IsInstanceOfType(blob3, typeof(CloudBlockBlob));
result = container.ServiceClient.BeginGetBlobReferenceFromServer(pageBlob.Uri,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
ICloudBlob blob4 = container.ServiceClient.EndGetBlobReferenceFromServer(result);
Assert.IsInstanceOfType(blob4, typeof(CloudPageBlob));
string blockBlobToken = blockBlob.GetSharedAccessSignature(policy);
StorageCredentials blockBlobSAS = new StorageCredentials(blockBlobToken);
Uri blockBlobSASUri = blockBlobSAS.TransformUri(blockBlob.Uri);
string pageBlobToken = pageBlob.GetSharedAccessSignature(policy);
StorageCredentials pageBlobSAS = new StorageCredentials(pageBlobToken);
Uri pageBlobSASUri = pageBlobSAS.TransformUri(pageBlob.Uri);
result = container.ServiceClient.BeginGetBlobReferenceFromServer(blockBlobSASUri,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
ICloudBlob blob5 = container.ServiceClient.EndGetBlobReferenceFromServer(result);
Assert.IsInstanceOfType(blob5, typeof(CloudBlockBlob));
result = container.ServiceClient.BeginGetBlobReferenceFromServer(pageBlobSASUri,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
ICloudBlob blob6 = container.ServiceClient.EndGetBlobReferenceFromServer(result);
Assert.IsInstanceOfType(blob6, typeof(CloudPageBlob));
CloudBlobClient client7 = new CloudBlobClient(container.ServiceClient.BaseUri, blockBlobSAS);
result = client7.BeginGetBlobReferenceFromServer(blockBlobSASUri,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
ICloudBlob blob7 = client7.EndGetBlobReferenceFromServer(result);
Assert.IsInstanceOfType(blob7, typeof(CloudBlockBlob));
CloudBlobClient client8 = new CloudBlobClient(container.ServiceClient.BaseUri, pageBlobSAS);
result = client8.BeginGetBlobReferenceFromServer(pageBlobSASUri,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
ICloudBlob blob8 = client8.EndGetBlobReferenceFromServer(result);
Assert.IsInstanceOfType(blob8, typeof(CloudPageBlob));
}
}
finally
{
container.DeleteIfExists();
}
}
public async Task PageBlobWriteStreamBasicTestAsync()
{
byte[] buffer = GetRandomBuffer(6 * 512);
CloudBlobContainer container = GetRandomContainerReference();
container.ServiceClient.ParallelOperationThreadCount = 2;
try
{
await container.CreateAsync();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
blob.StreamWriteSizeInBytes = 8 * 512;
using (MemoryStream wholeBlob = new MemoryStream())
{
using (Stream writeStream = await blob.OpenWriteAsync(buffer.Length * 3))
{
Stream blobStream = writeStream;
for (int i = 0; i < 3; i++)
{
await blobStream.WriteAsync(buffer, 0, buffer.Length);
await wholeBlob.WriteAsync(buffer, 0, buffer.Length);
Assert.AreEqual(wholeBlob.Position, blobStream.Position);
}
await blobStream.FlushAsync();
}
using (MemoryStream downloadedBlob = new MemoryStream())
{
await blob.DownloadToStreamAsync(downloadedBlob);
TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob);
}
using (Stream writeStream = await blob.OpenWriteAsync(null))
{
Stream blobStream = writeStream;
blobStream.Seek(buffer.Length / 2, SeekOrigin.Begin);
wholeBlob.Seek(buffer.Length / 2, SeekOrigin.Begin);
for (int i = 0; i < 2; i++)
{
blobStream.Write(buffer, 0, buffer.Length);
wholeBlob.Write(buffer, 0, buffer.Length);
Assert.AreEqual(wholeBlob.Position, blobStream.Position);
}
await blobStream.FlushAsync();
}
using (MemoryStream downloadedBlob = new MemoryStream())
{
await blob.DownloadToStreamAsync(downloadedBlob);
TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob);
}
}
}
finally
{
container.DeleteAsync().Wait();
}
}