public void CloudBlobSoftDeleteSnapshotTask()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
//Enables a delete retention policy on the blob with 1 day of default retention days
container.ServiceClient.EnableSoftDelete();
container.CreateAsync().Wait();
// Upload some data to the blob.
MemoryStream originalData = new MemoryStream(GetRandomBuffer(1024));
CloudAppendBlob appendBlob = container.GetAppendBlobReference(BlobName);
appendBlob.UploadFromStreamAsync(originalData).Wait();
CloudBlob blob = container.GetBlobReference(BlobName);
//create snapshot via api
CloudBlob snapshot = blob.SnapshotAsync().Result;
//create snapshot via write protection
appendBlob.UploadFromStreamAsync(originalData).Wait();
//we should have 2 snapshots 1 regular and 1 deleted: there is no way to get only the deleted snapshots but the below listing will get both snapshot types
int blobCount = 0;
int deletedSnapshotCount = 0;
int snapShotCount = 0;
BlobContinuationToken ct = null;
do
{
foreach (IListBlobItem item in container.ListBlobsSegmentedAsync
(null, true, BlobListingDetails.Snapshots | BlobListingDetails.Deleted, null, ct, null, null)
.Result
.Results
.ToList())
{
CloudAppendBlob blobItem = (CloudAppendBlob)item;
Assert.AreEqual(blobItem.Name, BlobName);
if (blobItem.IsSnapshot)
{
snapShotCount++;
}
if (blobItem.IsDeleted)
{
Assert.IsNotNull(blobItem.Properties.DeletedTime);
Assert.AreEqual(blobItem.Properties.RemainingDaysBeforePermanentDelete, 0);
deletedSnapshotCount++;
}
blobCount++;
}
} while (ct != null);
Assert.AreEqual(blobCount, 3);
Assert.AreEqual(deletedSnapshotCount, 1);
Assert.AreEqual(snapShotCount, 2);
blobCount = 0;
ct = null;
do
{
foreach (IListBlobItem item in container.ListBlobsSegmentedAsync
(null, true, BlobListingDetails.Snapshots, null, ct, null, null)
.Result
.Results
.ToList())
{
CloudAppendBlob blobItem = (CloudAppendBlob)item;
Assert.AreEqual(blobItem.Name, BlobName);
Assert.IsFalse(blobItem.IsDeleted);
Assert.IsNull(blobItem.Properties.DeletedTime);
Assert.IsNull(blobItem.Properties.RemainingDaysBeforePermanentDelete);
blobCount++;
}
} while (ct != null);
Assert.AreEqual(blobCount, 2);
//Delete Blob and snapshots
blob.DeleteAsync(DeleteSnapshotsOption.IncludeSnapshots, null, null, null).Wait();
Assert.IsFalse(blob.ExistsAsync().Result);
Assert.IsFalse(snapshot.ExistsAsync().Result);
blobCount = 0;
ct = null;
do
{
foreach (IListBlobItem item in container.ListBlobsSegmentedAsync
(null, true, BlobListingDetails.All, null, ct, null, null)
.Result
.Results
.ToList())
{
CloudAppendBlob blobItem = (CloudAppendBlob)item;
Assert.AreEqual(blobItem.Name, BlobName);
Assert.IsTrue(blobItem.IsDeleted);
Assert.IsNotNull(blobItem.Properties.DeletedTime);
Assert.AreEqual(blobItem.Properties.RemainingDaysBeforePermanentDelete, 0);
blobCount++;
}
} while (ct != null);
Assert.AreEqual(blobCount, 3);
blob.UndeleteAsync().Wait();
blob.FetchAttributesAsync().Wait();
Assert.IsFalse(blob.IsDeleted);
Assert.IsNull(blob.Properties.DeletedTime);
Assert.IsNull(blob.Properties.RemainingDaysBeforePermanentDelete);
blobCount = 0;
ct = null;
do
{
foreach (IListBlobItem item in container.ListBlobsSegmentedAsync
(null, true, BlobListingDetails.All, null, ct, null, null)
.Result
.Results
.ToList())
{
CloudAppendBlob blobItem = (CloudAppendBlob)item;
Assert.AreEqual(blobItem.Name, BlobName);
Assert.IsFalse(blobItem.IsDeleted);
Assert.IsNull(blobItem.Properties.DeletedTime);
Assert.IsNull(blobItem.Properties.RemainingDaysBeforePermanentDelete);
blobCount++;
}
} while (ct != null);
Assert.AreEqual(blobCount, 3);
}
finally
{
container.ServiceClient.DisableSoftDelete();
container.DeleteIfExistsAsync().Wait();
}
}
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 (var 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);
}
#if ASPNET_K
// todo: Make some other better logic for this test to be reliable.
System.Threading.Thread.Sleep(500);
#endif
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 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.AsBuffer());
}
// 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.AsBuffer());
await bos.CommitAsync();
}
using (Stream bis = (await blockBlob.OpenReadAsync()).AsStreamForRead())
{
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.AsBuffer());
}
// 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.AsBuffer());
await bos.CommitAsync();
}
using (Stream bis = (await pageBlob.OpenReadAsync()).AsStreamForRead())
{
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().AsTask().Wait();
}
}
/// <summary>
/// Basic operations to work with block blobs
/// </summary>
/// <returns>Task<returns>
private static async Task BasicStorageBlockBlobOperationsWithAccountSASAsync()
{
const string imageToUpload = "HelloWorld.png";
string blockBlobContainerName = "demoblockblobcontainer-" + Guid.NewGuid();
// Call GetAccountSASToken to get a sasToken based on the Storage Account Key
string sasToken = GetAccountSASToken();
// Create an AccountSAS from the SASToken
StorageCredentials accountSAS = new StorageCredentials(sasToken);
//Informational: Print the Account SAS Signature and Token
Console.WriteLine();
Console.WriteLine("Account SAS Signature: " + accountSAS.SASSignature);
Console.WriteLine("Account SAS Token: " + accountSAS.SASToken);
Console.WriteLine();
// Create a container for organizing blobs within the storage account.
Console.WriteLine("1. Creating Container using Account SAS");
// Get the Container Uri by passing the Storage Account and the container Name
Uri ContainerUri = GetContainerSASUri(blockBlobContainerName);
// Create a CloudBlobContainer by using the Uri and the sasToken
CloudBlobContainer container = new CloudBlobContainer(ContainerUri, new StorageCredentials(sasToken));
try
{
await container.CreateIfNotExistsAsync();
}
catch (StorageException)
{
Console.WriteLine("If you are running with the default configuration please make sure you have started the storage emulator. Press the Windows key and type Azure Storage to select and run it from the list of applications - then restart the sample.");
Console.ReadLine();
throw;
}
// To view the uploaded blob in a browser, you have two options. The first option is to use a Shared Access Signature (SAS) token to delegate
// access to the resource. See the documentation links at the top for more information on SAS. The second approach is to set permissions
// to allow public access to blobs in this container. Uncomment the line below to use this approach. Then you can view the image
// using: https://[InsertYourStorageAccountNameHere].blob.core.windows.net/democontainer/HelloWorld.png
// await container.SetPermissionsAsync(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob });
// Upload a BlockBlob to the newly created container
Console.WriteLine("2. Uploading BlockBlob");
CloudBlockBlob blockBlob = container.GetBlockBlobReference(imageToUpload);
await blockBlob.UploadFromFileAsync(imageToUpload, FileMode.Open);
// List all the blobs in the container
Console.WriteLine("3. List Blobs in Container");
foreach (IListBlobItem blob in container.ListBlobs())
{
// Blob type will be CloudBlockBlob, CloudPageBlob or CloudBlobDirectory
// Use blob.GetType() and cast to appropriate type to gain access to properties specific to each type
Console.WriteLine("- {0} (type: {1})", blob.Uri, blob.GetType());
}
// Download a blob to your file system
Console.WriteLine("4. Download Blob from {0}", blockBlob.Uri.AbsoluteUri);
await blockBlob.DownloadToFileAsync(string.Format("./CopyOf{0}", imageToUpload), FileMode.Create);
// Create a read-only snapshot of the blob
Console.WriteLine("5. Create a read-only snapshot of the blob");
CloudBlockBlob blockBlobSnapshot = await blockBlob.CreateSnapshotAsync(null, null, null, null);
// Clean up after the demo
Console.WriteLine("6. Delete block Blob and all of its snapshots");
await blockBlob.DeleteIfExistsAsync(DeleteSnapshotsOption.IncludeSnapshots, null, null, null);
Console.WriteLine("7. Delete Container");
await container.DeleteIfExistsAsync();
}
public async Task CloudBlobDirectoryFlatListingAsync()
{
foreach (String delimiter in Delimiters)
{
CloudBlobClient client = GenerateCloudBlobClient();
client.DefaultDelimiter = delimiter;
string name = GetRandomContainerName();
CloudBlobContainer container = client.GetContainerReference(name);
try
{
await container.CreateAsync();
if (await CloudBlobDirectorySetupWithDelimiterAsync(container, delimiter))
{
BlobResultSegment segment = await container.ListBlobsSegmentedAsync("TopDir1" + delimiter, false, BlobListingDetails.None, null, null, null, null);
List <IListBlobItem> simpleList1 = new List <IListBlobItem>();
simpleList1.AddRange(segment.Results);
while (segment.ContinuationToken != null)
{
segment = await container.ListBlobsSegmentedAsync("TopDir1" + delimiter, false, BlobListingDetails.None, null, segment.ContinuationToken, null, null);
simpleList1.AddRange(segment.Results);
}
Assert.IsTrue(simpleList1.Count == 3);
IListBlobItem item11 = simpleList1.ElementAt(0);
Assert.IsTrue(item11.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "Blob1"));
IListBlobItem item12 = simpleList1.ElementAt(1);
Assert.IsTrue(item12.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir1" + delimiter));
IListBlobItem item13 = simpleList1.ElementAt(2);
Assert.IsTrue(item13.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir2" + delimiter));
CloudBlobDirectory midDir2 = (CloudBlobDirectory)item13;
BlobResultSegment segment2 = await container.ListBlobsSegmentedAsync("TopDir1" + delimiter + "MidDir1", true, BlobListingDetails.None, null, null, null, null);
List <IListBlobItem> simpleList2 = new List <IListBlobItem>();
simpleList2.AddRange(segment2.Results);
while (segment2.ContinuationToken != null)
{
segment2 = await container.ListBlobsSegmentedAsync("TopDir1" + delimiter + "MidDir1", true, BlobListingDetails.None, null, segment2.ContinuationToken, null, null);
simpleList2.AddRange(segment2.Results);
}
Assert.IsTrue(simpleList2.Count == 2);
IListBlobItem item21 = simpleList2.ElementAt(0);
Assert.IsTrue(item21.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir1" + delimiter + "EndDir1" + delimiter + "EndBlob1"));
IListBlobItem item22 = simpleList2.ElementAt(1);
Assert.IsTrue(item22.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir1" + delimiter + "EndDir2" + delimiter + "EndBlob2"));
BlobResultSegment segment3 = await container.ListBlobsSegmentedAsync("TopDir1" + delimiter + "MidDir1" + delimiter, false, BlobListingDetails.None, null, null, null, null);
List <IListBlobItem> simpleList3 = new List <IListBlobItem>();
simpleList3.AddRange(segment3.Results);
while (segment3.ContinuationToken != null)
{
segment3 = await container.ListBlobsSegmentedAsync("TopDir1" + delimiter + "MidDir1" + delimiter, false, BlobListingDetails.None, null, segment3.ContinuationToken, null, null);
simpleList3.AddRange(segment3.Results);
}
Assert.IsTrue(simpleList3.Count == 2);
IListBlobItem item31 = simpleList3.ElementAt(0);
Assert.IsTrue(item31.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir1" + delimiter + "EndDir1" + delimiter));
IListBlobItem item32 = simpleList3.ElementAt(1);
Assert.IsTrue(item32.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir1" + delimiter + "EndDir2" + delimiter));
BlobResultSegment segment4 = await midDir2.ListBlobsSegmentedAsync(true, BlobListingDetails.None, null, null, null, null);
List <IListBlobItem> simpleList4 = new List <IListBlobItem>();
simpleList4.AddRange(segment4.Results);
while (segment4.ContinuationToken != null)
{
segment4 = await midDir2.ListBlobsSegmentedAsync(true, BlobListingDetails.None, null, segment4.ContinuationToken, null, null);
simpleList4.AddRange(segment4.Results);
}
Assert.IsTrue(simpleList4.Count == 2);
IListBlobItem item41 = simpleList4.ElementAt(0);
Assert.IsTrue(item41.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir2" + delimiter + "EndDir1" + delimiter + "EndBlob1"));
IListBlobItem item42 = simpleList4.ElementAt(1);
Assert.IsTrue(item42.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir2" + delimiter + "EndDir2" + delimiter + "EndBlob2"));
}
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
}
public async Task CloudBlockBlobConditionalAccessAsync()
{
OperationContext operationContext = new OperationContext();
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudBlockBlob blob = container.GetBlockBlobReference("blob1");
await CreateForTestAsync(blob, 2, 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 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 async Task StoreBlobContentMD5TestAsync()
{
BlobRequestOptions optionsWithNoMD5 = new BlobRequestOptions()
{
StoreBlobContentMD5 = false,
};
BlobRequestOptions optionsWithMD5 = new BlobRequestOptions()
{
StoreBlobContentMD5 = true,
};
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
ICloudBlob blob = container.GetBlockBlobReference("blob1");
using (Stream stream = new NonSeekableMemoryStream())
{
await blob.UploadFromStreamAsync(stream.AsInputStream(), null, optionsWithMD5, null);
}
await blob.FetchAttributesAsync();
Assert.IsNotNull(blob.Properties.ContentMD5);
blob = container.GetBlockBlobReference("blob2");
using (Stream stream = new NonSeekableMemoryStream())
{
await blob.UploadFromStreamAsync(stream.AsInputStream(), null, optionsWithNoMD5, null);
}
await blob.FetchAttributesAsync();
Assert.IsNull(blob.Properties.ContentMD5);
blob = container.GetBlockBlobReference("blob3");
using (Stream stream = new NonSeekableMemoryStream())
{
await blob.UploadFromStreamAsync(stream.AsInputStream());
}
await blob.FetchAttributesAsync();
Assert.IsNotNull(blob.Properties.ContentMD5);
blob = container.GetPageBlobReference("blob4");
using (Stream stream = new MemoryStream())
{
await blob.UploadFromStreamAsync(stream.AsInputStream(), null, optionsWithMD5, null);
}
await blob.FetchAttributesAsync();
Assert.IsNotNull(blob.Properties.ContentMD5);
blob = container.GetPageBlobReference("blob5");
using (Stream stream = new MemoryStream())
{
await blob.UploadFromStreamAsync(stream.AsInputStream(), null, optionsWithNoMD5, null);
}
await blob.FetchAttributesAsync();
Assert.IsNull(blob.Properties.ContentMD5);
blob = container.GetPageBlobReference("blob6");
using (Stream stream = new MemoryStream())
{
await blob.UploadFromStreamAsync(stream.AsInputStream());
}
await blob.FetchAttributesAsync();
Assert.IsNull(blob.Properties.ContentMD5);
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
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();
}
}
/// <summary>
/// Basic operations to work with block blobs
/// </summary>
/// <returns>A Task object.</returns>
private static async Task BasicStorageBlockBlobOperationsWithAccountSASAsync()
{
const string ImageToUpload = "HelloWorld.png";
string containerName = ContainerPrefix + Guid.NewGuid();
// Get an account SAS token.
string sasToken = GetAccountSASToken();
// Use the account SAS token to create authentication credentials.
StorageCredentials accountSAS = new StorageCredentials(sasToken);
// Informational: Print the Account SAS Signature and Token.
Console.WriteLine();
Console.WriteLine("Account SAS Signature: " + accountSAS.SASSignature);
Console.WriteLine("Account SAS Token: " + accountSAS.SASToken);
Console.WriteLine();
// Get the URI for the container.
Uri containerUri = GetContainerUri(containerName);
// Get a reference to a container using the URI and the SAS token.
CloudBlobContainer container = new CloudBlobContainer(containerUri, accountSAS);
try
{
// Create a container for organizing blobs within the storage account.
Console.WriteLine("1. Creating Container using Account SAS");
await container.CreateIfNotExistsAsync();
}
catch (StorageException e)
{
Console.WriteLine(e.ToString());
Console.WriteLine("If you are running with the default configuration, please make sure you have started the storage emulator. Press the Windows key and type Azure Storage to select and run it from the list of applications - then restart the sample.");
Console.ReadLine();
throw;
}
try
{
// To view the uploaded blob in a browser, you have two options. The first option is to use a Shared Access Signature (SAS) token to delegate
// access to the resource. See the documentation links at the top for more information on SAS. The second approach is to set permissions
// to allow public access to blobs in this container. Uncomment the line below to use this approach. Then you can view the image
// using: https://[InsertYourStorageAccountNameHere].blob.core.windows.net/democontainer/HelloWorld.png
// await container.SetPermissionsAsync(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob });
// Upload a BlockBlob to the newly created container
Console.WriteLine("2. Uploading BlockBlob");
CloudBlockBlob blockBlob = container.GetBlockBlobReference(ImageToUpload);
await blockBlob.UploadFromFileAsync(ImageToUpload);
// List all the blobs in the container
Console.WriteLine("3. List Blobs in Container");
BlobContinuationToken token = null;
do
{
BlobResultSegment resultSegment = await container.ListBlobsSegmentedAsync(token);
token = resultSegment.ContinuationToken;
foreach (IListBlobItem blob in resultSegment.Results)
{
// Blob type will be CloudBlockBlob, CloudPageBlob or CloudBlobDirectory
Console.WriteLine("{0} (type: {1}", blob.Uri, blob.GetType());
}
}
while (token != null);
// Download a blob to your file system
Console.WriteLine("4. Download Blob from {0}", blockBlob.Uri.AbsoluteUri);
await blockBlob.DownloadToFileAsync(string.Format("./CopyOf{0}", ImageToUpload), FileMode.Create);
// Create a read-only snapshot of the blob
Console.WriteLine("5. Create a read-only snapshot of the blob");
CloudBlockBlob blockBlobSnapshot = await blockBlob.CreateSnapshotAsync(null, null, null, null);
// Delete the blob and its snapshots.
Console.WriteLine("6. Delete block Blob and all of its snapshots");
await blockBlob.DeleteIfExistsAsync(DeleteSnapshotsOption.IncludeSnapshots, null, null, null);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.ReadLine();
throw;
}
finally
{
// Clean up after the demo.
// Note that it is not necessary to delete all of the blobs in the container first; they will be deleted
// with the container.
Console.WriteLine("7. Delete Container");
await container.DeleteIfExistsAsync();
}
}
private static async Task CloudBlockBlobCopyFromCloudFileImpl(Func <CloudFile, CloudBlockBlob, string> copyFunc)
{
CloudFileClient fileClient = GenerateCloudFileClient();
string name = GetRandomContainerName();
CloudFileShare share = fileClient.GetShareReference(name);
CloudBlobContainer container = GetRandomContainerReference();
try
{
try
{
await container.CreateAsync();
await share.CreateAsync();
CloudFile source = share.GetRootDirectoryReference().GetFileReference("source");
byte[] data = GetRandomBuffer(1024);
await source.UploadFromByteArrayAsync(data, 0, data.Length);
source.Metadata["Test"] = "value";
source.SetMetadataAsync().Wait();
var sasToken = source.GetSharedAccessSignature(new SharedAccessFilePolicy
{
Permissions = SharedAccessFilePermissions.Read,
SharedAccessExpiryTime = DateTime.UtcNow.AddHours(24)
});
Uri fileSasUri = new Uri(source.StorageUri.PrimaryUri.ToString() + sasToken);
source = new CloudFile(fileSasUri);
CloudBlockBlob copy = container.GetBlockBlobReference("copy");
string copyId = copyFunc(source, copy);
Assert.AreEqual(BlobType.BlockBlob, copy.BlobType);
try
{
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.IsFalse(copy.Properties.IsIncrementalCopy);
Assert.IsTrue(copy.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
}
catch (NullReferenceException)
{
// potential null ref in the WaitForCopyTask and CopyState check implementation
}
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");
source.FetchAttributesAsync().Wait();
Assert.IsNotNull(copy.Properties.ETag);
Assert.AreNotEqual(source.Properties.ETag, copy.Properties.ETag);
Assert.IsTrue(copy.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
byte[] copyData = new byte[source.Properties.Length];
await copy.DownloadToByteArrayAsync(copyData, 0);
Assert.IsTrue(data.SequenceEqual(copyData), "Data inside copy of blob not similar");
copy.FetchAttributesAsync().Wait();
BlobProperties prop1 = copy.Properties;
FileProperties 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.DeleteIfExistsAsync().Wait();
}
finally
{
share.DeleteIfExistsAsync().Wait();
}
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
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);
ICloudBlob blob1 = await container.GetBlobReferenceFromServerAsync("bb");
Assert.IsInstanceOfType(blob1, typeof(CloudBlockBlob));
CloudBlockBlob blob1Snapshot = await((CloudBlockBlob)blob1).CreateSnapshotAsync();
await blob1.SetPropertiesAsync();
Uri blob1SnapshotUri = new Uri(blob1Snapshot.Uri.AbsoluteUri + "?snapshot=" + blob1Snapshot.SnapshotTime.Value.UtcDateTime.ToString("o"));
ICloudBlob blob1SnapshotReference = await container.ServiceClient.GetBlobReferenceFromServerAsync(blob1SnapshotUri);
AssertAreEqual(blob1Snapshot.Properties, blob1SnapshotReference.Properties);
ICloudBlob blob2 = await container.GetBlobReferenceFromServerAsync("pb");
Assert.IsInstanceOfType(blob2, typeof(CloudPageBlob));
CloudPageBlob blob2Snapshot = await((CloudPageBlob)blob2).CreateSnapshotAsync();
await blob2.SetPropertiesAsync();
Uri blob2SnapshotUri = new Uri(blob2Snapshot.Uri.AbsoluteUri + "?snapshot=" + blob2Snapshot.SnapshotTime.Value.UtcDateTime.ToString("o"));
ICloudBlob blob2SnapshotReference = await container.ServiceClient.GetBlobReferenceFromServerAsync(blob2SnapshotUri);
AssertAreEqual(blob2Snapshot.Properties, blob2SnapshotReference.Properties);
ICloudBlob blob3 = await container.ServiceClient.GetBlobReferenceFromServerAsync(blockBlob.Uri);
Assert.IsInstanceOfType(blob3, typeof(CloudBlockBlob));
ICloudBlob blob4 = await container.ServiceClient.GetBlobReferenceFromServerAsync(pageBlob.Uri);
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);
ICloudBlob blob5 = await container.ServiceClient.GetBlobReferenceFromServerAsync(blockBlobSASUri);
Assert.IsInstanceOfType(blob5, typeof(CloudBlockBlob));
ICloudBlob blob6 = await container.ServiceClient.GetBlobReferenceFromServerAsync(pageBlobSASUri);
Assert.IsInstanceOfType(blob6, typeof(CloudPageBlob));
CloudBlobClient client7 = new CloudBlobClient(container.ServiceClient.BaseUri, blockBlobSAS);
ICloudBlob blob7 = await client7.GetBlobReferenceFromServerAsync(blockBlobSASUri);
Assert.IsInstanceOfType(blob7, typeof(CloudBlockBlob));
CloudBlobClient client8 = new CloudBlobClient(container.ServiceClient.BaseUri, pageBlobSAS);
ICloudBlob blob8 = await client8.GetBlobReferenceFromServerAsync(pageBlobSASUri);
Assert.IsInstanceOfType(blob8, typeof(CloudPageBlob));
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
public async Task CloudBlobSnapshotAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
MemoryStream originalData = new MemoryStream(GetRandomBuffer(1024));
CloudBlockBlob blockBlob = container.GetBlockBlobReference(BlobName);
await blockBlob.UploadFromStreamAsync(originalData);
CloudBlob blob = container.GetBlobReference(BlobName);
await blob.FetchAttributesAsync();
Assert.IsFalse(blob.IsSnapshot);
Assert.IsNull(blob.SnapshotTime, "Root blob has SnapshotTime set");
Assert.IsFalse(blob.SnapshotQualifiedUri.Query.Contains("snapshot"));
Assert.AreEqual(blob.Uri, blob.SnapshotQualifiedUri);
CloudBlob snapshot1 = await blob.SnapshotAsync();
Assert.AreEqual(blob.Properties.ETag, snapshot1.Properties.ETag);
Assert.AreEqual(blob.Properties.LastModified, snapshot1.Properties.LastModified);
Assert.IsTrue(snapshot1.IsSnapshot);
Assert.IsNotNull(snapshot1.SnapshotTime, "Snapshot does not have SnapshotTime set");
Assert.AreEqual(blob.Uri, snapshot1.Uri);
Assert.AreNotEqual(blob.SnapshotQualifiedUri, snapshot1.SnapshotQualifiedUri);
Assert.AreNotEqual(snapshot1.Uri, snapshot1.SnapshotQualifiedUri);
Assert.IsTrue(snapshot1.SnapshotQualifiedUri.Query.Contains("snapshot"));
CloudBlob snapshot2 = await blob.SnapshotAsync();
Assert.IsTrue(snapshot2.SnapshotTime.Value > snapshot1.SnapshotTime.Value);
await snapshot1.FetchAttributesAsync();
await snapshot2.FetchAttributesAsync();
await blob.FetchAttributesAsync();
AssertAreEqual(snapshot1.Properties, blob.Properties);
CloudBlob snapshot1Clone = new CloudBlob(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);
// The query parser should not be case sensitive in detecting a snapshot in the query string
CloudBlob snapshotParseVerifier = new CloudBlob(new Uri(blob.Uri + "?sNapshOt=" + snapshot1.SnapshotTime.Value.ToString("O")), blob.ServiceClient.Credentials);
Assert.IsNotNull(snapshotParseVerifier.SnapshotTime, "Snapshot parse verifier did not successfully detect the snapshot time");
Assert.AreEqual(snapshot1.SnapshotTime.Value, snapshotParseVerifier.SnapshotTime.Value);
CloudBlob snapshotCopy = container.GetBlobReference("blob2");
await snapshotCopy.StartCopyAsync(TestHelper.Defiddler(snapshot1.Uri));
await WaitForCopyAsync(snapshotCopy);
Assert.AreEqual(CopyStatus.Success, snapshotCopy.CopyState.Status);
using (Stream snapshotStream = (await snapshot1.OpenReadAsync()))
{
snapshotStream.Seek(0, SeekOrigin.End);
TestHelper.AssertStreamsAreEqual(originalData, snapshotStream);
}
await blockBlob.PutBlockListAsync(new List <string>());
await blob.FetchAttributesAsync();
using (Stream snapshotStream = (await snapshot1.OpenReadAsync()))
{
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, (CloudBlob)blobs[0]);
AssertAreEqual(snapshot2, (CloudBlob)blobs[1]);
AssertAreEqual(blob, (CloudBlob)blobs[2]);
AssertAreEqual(snapshotCopy, (CloudBlob)blobs[3]);
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
public void CloudBlobSnapshotTask()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.CreateAsync().Wait();
MemoryStream originalData = new MemoryStream(GetRandomBuffer(1024));
CloudAppendBlob appendBlob = container.GetAppendBlobReference(BlobName);
appendBlob.CreateOrReplaceAsync().Wait();
appendBlob.AppendBlockAsync(originalData, null).Wait();
CloudBlob blob = container.GetBlobReference(BlobName);
blob.FetchAttributesAsync().Wait();
CloudBlob snapshot1 = blob.SnapshotAsync().Result;
Assert.AreEqual(blob.Properties.ETag, snapshot1.Properties.ETag);
Assert.AreEqual(blob.Properties.LastModified, snapshot1.Properties.LastModified);
Assert.IsTrue(snapshot1.IsSnapshot);
Assert.IsNotNull(snapshot1.SnapshotTime, "Snapshot does not have SnapshotTime set");
Assert.AreEqual(blob.Uri, snapshot1.Uri);
Assert.AreNotEqual(blob.SnapshotQualifiedUri, snapshot1.SnapshotQualifiedUri);
Assert.AreNotEqual(snapshot1.Uri, snapshot1.SnapshotQualifiedUri);
Assert.IsTrue(snapshot1.SnapshotQualifiedUri.Query.Contains("snapshot"));
CloudBlob snapshot2 = blob.SnapshotAsync().Result;
Assert.IsTrue(snapshot2.SnapshotTime.Value > snapshot1.SnapshotTime.Value);
snapshot1.FetchAttributesAsync().Wait();
snapshot2.FetchAttributesAsync().Wait();
blob.FetchAttributesAsync().Wait();
AssertAreEqual(snapshot1.Properties, blob.Properties);
CloudBlob snapshot1Clone = new CloudBlob(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);
snapshot1Clone.FetchAttributesAsync().Wait();
AssertAreEqual(snapshot1.Properties, snapshot1Clone.Properties);
CloudBlob snapshotCopy = container.GetBlobReference("blob2");
snapshotCopy.StartCopyAsync(snapshot1.Uri, null, null, null, null).Wait();
WaitForCopy(snapshotCopy);
Assert.AreEqual(CopyStatus.Success, snapshotCopy.CopyState.Status);
using (Stream snapshotStream = snapshot1.OpenReadAsync().Result)
{
snapshotStream.Seek(0, SeekOrigin.End);
TestHelper.AssertStreamsAreEqual(originalData, snapshotStream);
}
appendBlob.CreateOrReplaceAsync().Wait();
blob.FetchAttributesAsync().Wait();
using (Stream snapshotStream = snapshot1.OpenReadAsync().Result)
{
snapshotStream.Seek(0, SeekOrigin.End);
TestHelper.AssertStreamsAreEqual(originalData, snapshotStream);
}
List <IListBlobItem> blobs =
container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.All, null, null, null, null)
.Result
.Results
.ToList();
Assert.AreEqual(4, blobs.Count);
AssertAreEqual(snapshot1, (CloudBlob)blobs[0]);
AssertAreEqual(snapshot2, (CloudBlob)blobs[1]);
AssertAreEqual(blob, (CloudBlob)blobs[2]);
AssertAreEqual(snapshotCopy, (CloudBlob)blobs[3]);
}
finally
{
container.DeleteIfExistsAsync().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 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.AsInputStream(), null, optionsWithMD5, null);
}
using (Stream stream = new MemoryStream())
{
await blockBlob.DownloadToStreamAsync(stream.AsOutputStream(), null, optionsWithMD5, null);
await blockBlob.DownloadToStreamAsync(stream.AsOutputStream(), null, optionsWithNoMD5, null);
using (var blobStream = await blockBlob.OpenReadAsync(null, optionsWithMD5, null))
{
Stream blobStreamForRead = blobStream.AsStreamForRead();
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.AsStreamForRead();
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.AsOutputStream(), null, optionsWithMD5, opContext),
opContext,
"Downloading a blob with invalid MD5 should fail",
HttpStatusCode.OK);
await blockBlob.DownloadToStreamAsync(stream.AsOutputStream(), null, optionsWithNoMD5, null);
using (var blobStream = await blockBlob.OpenReadAsync(null, optionsWithMD5, null))
{
Stream blobStreamForRead = blobStream.AsStreamForRead();
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.AsStreamForRead();
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.AsInputStream(), null, optionsWithMD5, null);
}
using (Stream stream = new MemoryStream())
{
await pageBlob.DownloadToStreamAsync(stream.AsOutputStream(), null, optionsWithMD5, null);
await pageBlob.DownloadToStreamAsync(stream.AsOutputStream(), null, optionsWithNoMD5, null);
using (var blobStream = await pageBlob.OpenReadAsync(null, optionsWithMD5, null))
{
Stream blobStreamForRead = blobStream.AsStreamForRead();
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.AsStreamForRead();
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.AsOutputStream(), null, optionsWithMD5, opContext),
opContext,
"Downloading a blob with invalid MD5 should fail",
HttpStatusCode.OK);
await pageBlob.DownloadToStreamAsync(stream.AsOutputStream(), null, optionsWithNoMD5, null);
using (var blobStream = await pageBlob.OpenReadAsync(null, optionsWithMD5, null))
{
Stream blobStreamForRead = blobStream.AsStreamForRead();
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.AsStreamForRead();
int read;
do
{
read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length);
}while (read > 0);
}
}
}
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 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().Wait();
}
}
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 (var blobStream = await blob.OpenReadAsync(null, null, opContext))
{
Stream blobStreamForRead = blobStream.AsStreamForRead();
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 (var blobStream = await blob.OpenReadAsync(null, null, opContext))
{
Stream blobStreamForRead = blobStream.AsStreamForRead();
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.Subtract(TimeSpan.FromHours(1)));
await blob.SetMetadataAsync();
await TestHelper.ExpectedExceptionAsync(
async() => await blob.OpenReadAsync(accessCondition, null, opContext),
opContext,
"Blob read stream should fail if blob is modified during read",
HttpStatusCode.PreconditionFailed);
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
private async Task CloudBlockBlobUploadFromStreamAsync(bool seekableSourceStream, int startOffset)
{
byte[] buffer = GetRandomBuffer(1 * 1024 * 1024);
CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash();
hasher.Append(buffer.AsBuffer(startOffset, buffer.Length - startOffset));
string md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset());
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudBlockBlob blob = container.GetBlockBlobReference("blob1");
using (MemoryStream originalBlob = new MemoryStream())
{
originalBlob.Write(buffer, startOffset, buffer.Length - startOffset);
Stream sourceStream;
if (seekableSourceStream)
{
MemoryStream stream = new MemoryStream(buffer);
stream.Seek(startOffset, SeekOrigin.Begin);
sourceStream = stream;
}
else
{
NonSeekableMemoryStream stream = new NonSeekableMemoryStream(buffer);
stream.ForceSeek(startOffset, SeekOrigin.Begin);
sourceStream = stream;
}
using (sourceStream)
{
BlobRequestOptions options = new BlobRequestOptions()
{
StoreBlobContentMD5 = true,
};
await blob.UploadFromStreamAsync(sourceStream.AsInputStream(), null, options, null);
}
await blob.FetchAttributesAsync();
Assert.AreEqual(md5, blob.Properties.ContentMD5);
using (MemoryStream downloadedBlob = new MemoryStream())
{
await blob.DownloadToStreamAsync(downloadedBlob.AsOutputStream());
TestHelper.AssertStreamsAreEqual(originalBlob, downloadedBlob);
}
}
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
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();
}
}
public async Task CloudBlockBlobBlockReorderingAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudBlockBlob blob = container.GetBlockBlobReference("blob1");
List <string> originalBlockIds = GetBlockIdList(10);
List <string> blockIds = new List <string>(originalBlockIds);
List <byte[]> blocks = new List <byte[]>();
for (int i = 0; i < blockIds.Count; i++)
{
byte[] buffer = Encoding.UTF8.GetBytes(i.ToString());
using (MemoryStream stream = new MemoryStream(buffer))
{
await blob.PutBlockAsync(blockIds[i], stream.AsInputStream(), null);
}
blocks.Add(buffer);
}
await blob.PutBlockListAsync(blockIds);
Assert.AreEqual("0123456789", await DownloadTextAsync(blob, Encoding.UTF8));
blockIds.RemoveAt(0);
await blob.PutBlockListAsync(blockIds);
Assert.AreEqual("123456789", await DownloadTextAsync(blob, Encoding.UTF8));
blockIds.RemoveAt(8);
await blob.PutBlockListAsync(blockIds);
Assert.AreEqual("12345678", await DownloadTextAsync(blob, Encoding.UTF8));
blockIds.RemoveAt(3);
await blob.PutBlockListAsync(blockIds);
Assert.AreEqual("1235678", await DownloadTextAsync(blob, Encoding.UTF8));
using (MemoryStream stream = new MemoryStream(blocks[9]))
{
await blob.PutBlockAsync(originalBlockIds[9], stream.AsInputStream(), null);
}
blockIds.Insert(0, originalBlockIds[9]);
await blob.PutBlockListAsync(blockIds);
Assert.AreEqual("91235678", await DownloadTextAsync(blob, Encoding.UTF8));
using (MemoryStream stream = new MemoryStream(blocks[0]))
{
await blob.PutBlockAsync(originalBlockIds[0], stream.AsInputStream(), null);
}
blockIds.Add(originalBlockIds[0]);
await blob.PutBlockListAsync(blockIds);
Assert.AreEqual("912356780", await DownloadTextAsync(blob, Encoding.UTF8));
using (MemoryStream stream = new MemoryStream(blocks[4]))
{
await blob.PutBlockAsync(originalBlockIds[4], stream.AsInputStream(), null);
}
blockIds.Insert(2, originalBlockIds[4]);
await blob.PutBlockListAsync(blockIds);
Assert.AreEqual("9142356780", await DownloadTextAsync(blob, Encoding.UTF8));
blockIds.Insert(0, originalBlockIds[0]);
await blob.PutBlockListAsync(blockIds);
Assert.AreEqual("09142356780", await DownloadTextAsync(blob, Encoding.UTF8));
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
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.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().Wait();
}
}
public async Task CloudBlobClientListBlobsSegmentedWithPrefixAsync()
{
string name = "bb" + GetRandomContainerName();
CloudBlobClient blobClient = GenerateCloudBlobClient();
CloudBlobContainer rootContainer = blobClient.GetRootContainerReference();
CloudBlobContainer container = blobClient.GetContainerReference(name);
try
{
await rootContainer.CreateIfNotExistsAsync();
await container.CreateAsync();
List <string> blobNames = await CreateBlobsAsync(container, 3, BlobType.BlockBlob);
List <string> rootBlobNames = await CreateBlobsAsync(rootContainer, 2, BlobType.BlockBlob);
BlobResultSegment results;
BlobContinuationToken token = null;
do
{
results = await blobClient.ListBlobsSegmentedAsync("bb", token);
token = results.ContinuationToken;
foreach (CloudBlockBlob blob in results.Results)
{
await blob.DeleteAsync();
rootBlobNames.Remove(blob.Name);
}
}while (token != null);
Assert.AreEqual(0, rootBlobNames.Count);
results = await blobClient.ListBlobsSegmentedAsync("bb", token);
Assert.AreEqual(0, results.Results.Count());
Assert.IsNull(results.ContinuationToken);
results = await blobClient.ListBlobsSegmentedAsync(name, token);
Assert.AreEqual(0, results.Results.Count());
Assert.IsNull(results.ContinuationToken);
token = null;
do
{
results = await blobClient.ListBlobsSegmentedAsync(name + "/", token);
token = results.ContinuationToken;
foreach (CloudBlockBlob blob in results.Results)
{
Assert.IsTrue(blobNames.Remove(blob.Name));
}
}while (token != null);
Assert.AreEqual(0, blobNames.Count);
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
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.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().Wait();
}
}
public async Task<bool> DeleteContainerAsync(string containerName)
{
// Delete the container if it doesn't exist.
blobContainer = blobClient.GetContainerReference(containerName);
return await blobContainer.DeleteIfExistsAsync();
}
public void CloudBlobSoftDeleteNoSnapshotTask()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
//Enables a delete retention policy on the blob with 1 day of default retention days
container.ServiceClient.EnableSoftDelete();
container.CreateAsync().Wait();
// Upload some data to the blob.
MemoryStream originalData = new MemoryStream(GetRandomBuffer(1024));
CloudAppendBlob appendBlob = container.GetAppendBlobReference(BlobName);
appendBlob.CreateOrReplaceAsync().Wait();
appendBlob.AppendBlockAsync(originalData, null).Wait();
CloudBlob blob = container.GetBlobReference(BlobName);
Assert.IsTrue(blob.ExistsAsync().Result);
Assert.IsFalse(blob.IsDeleted);
blob.DeleteAsync().Wait();
Assert.IsFalse(blob.ExistsAsync().Result);
int blobCount = 0;
BlobContinuationToken ct = null;
do
{
foreach (IListBlobItem item in container.ListBlobsSegmentedAsync
(null, true, BlobListingDetails.All, null, ct, null, null)
.Result
.Results
.ToList())
{
CloudAppendBlob blobItem = (CloudAppendBlob)item;
Assert.AreEqual(blobItem.Name, BlobName);
Assert.IsTrue(blobItem.IsDeleted);
Assert.IsNotNull(blobItem.Properties.DeletedTime);
Assert.AreEqual(blobItem.Properties.RemainingDaysBeforePermanentDelete, 0);
blobCount++;
}
} while (ct != null);
Assert.AreEqual(blobCount, 1);
blob.UndeleteAsync().Wait();
blob.FetchAttributesAsync().Wait();
Assert.IsFalse(blob.IsDeleted);
Assert.IsNull(blob.Properties.DeletedTime);
Assert.IsNull(blob.Properties.RemainingDaysBeforePermanentDelete);
blobCount = 0;
ct = null;
do
{
foreach (IListBlobItem item in container.ListBlobsSegmentedAsync
(null, true, BlobListingDetails.All, null, ct, null, null)
.Result
.Results
.ToList())
{
CloudAppendBlob blobItem = (CloudAppendBlob)item;
Assert.AreEqual(blobItem.Name, BlobName);
Assert.IsFalse(blobItem.IsDeleted);
Assert.IsNull(blobItem.Properties.DeletedTime);
Assert.IsNull(blobItem.Properties.RemainingDaysBeforePermanentDelete);
blobCount++;
}
} while (ct != null);
Assert.AreEqual(blobCount, 1);
}
finally
{
container.ServiceClient.DisableSoftDelete();
container.DeleteIfExistsAsync().Wait();
}
}
