public async Task UseTransactionalMD5PutTestAsync()
{
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 (HttpRequestParsers.GetContentLength(args.Request) >= buffer.Length)
{
lastCheckMD5 = HttpRequestParsers.GetContentMD5(args.Request);
checkCount++;
}
};
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1");
List <string> blockIds = GetBlockIdList(3);
checkCount = 0;
using (Stream blockData = new MemoryStream(buffer))
{
lastCheckMD5 = "invalid_md5";
await blockBlob.PutBlockAsync(blockIds[0], blockData, null, null, optionsWithNoMD5, opContextWithMD5Check);
Assert.IsNull(lastCheckMD5);
lastCheckMD5 = "invalid_md5";
blockData.Seek(0, SeekOrigin.Begin);
await blockBlob.PutBlockAsync(blockIds[1], blockData, null, null, optionsWithMD5, opContextWithMD5Check);
Assert.AreEqual(md5, lastCheckMD5);
lastCheckMD5 = "invalid_md5";
blockData.Seek(0, SeekOrigin.Begin);
await blockBlob.PutBlockAsync(blockIds[2], blockData, md5, null, optionsWithNoMD5, opContextWithMD5Check);
Assert.AreEqual(md5, lastCheckMD5);
}
Assert.AreEqual(3, checkCount);
checkCount = 0;
CloudAppendBlob appendBlob = container.GetAppendBlobReference("blob2");
await appendBlob.CreateOrReplaceAsync();
checkCount = 0;
using (Stream blockData = new MemoryStream(buffer))
{
lastCheckMD5 = "invalid_md5";
await appendBlob.AppendBlockAsync(blockData, null, null, optionsWithNoMD5, opContextWithMD5Check);
Assert.IsNull(lastCheckMD5);
lastCheckMD5 = "invalid_md5";
blockData.Seek(0, SeekOrigin.Begin);
await appendBlob.AppendBlockAsync(blockData, null, null, optionsWithMD5, opContextWithMD5Check);
Assert.AreEqual(md5, lastCheckMD5);
lastCheckMD5 = "invalid_md5";
blockData.Seek(0, SeekOrigin.Begin);
await appendBlob.AppendBlockAsync(blockData, md5, null, optionsWithNoMD5, opContextWithMD5Check);
Assert.AreEqual(md5, lastCheckMD5);
}
Assert.AreEqual(3, checkCount);
CloudPageBlob pageBlob = container.GetPageBlobReference("blob3");
await pageBlob.CreateAsync(buffer.Length);
checkCount = 0;
using (Stream pageData = new MemoryStream(buffer))
{
lastCheckMD5 = "invalid_md5";
await pageBlob.WritePagesAsync(pageData, 0, null, null, optionsWithNoMD5, opContextWithMD5Check);
Assert.IsNull(lastCheckMD5);
lastCheckMD5 = "invalid_md5";
pageData.Seek(0, SeekOrigin.Begin);
await pageBlob.WritePagesAsync(pageData, 0, null, null, optionsWithMD5, opContextWithMD5Check);
Assert.AreEqual(md5, lastCheckMD5);
lastCheckMD5 = "invalid_md5";
pageData.Seek(0, SeekOrigin.Begin);
await pageBlob.WritePagesAsync(pageData, 0, md5, null, optionsWithNoMD5, opContextWithMD5Check);
Assert.AreEqual(md5, lastCheckMD5);
}
Assert.AreEqual(3, checkCount);
lastCheckMD5 = null;
blockBlob = container.GetBlockBlobReference("blob4");
checkCount = 0;
using (Stream blobStream = await blockBlob.OpenWriteAsync(null, optionsWithMD5, opContextWithMD5Check))
{
blobStream.Write(buffer, 0, buffer.Length);
blobStream.Write(buffer, 0, buffer.Length);
}
Assert.IsNotNull(lastCheckMD5);
Assert.AreEqual(1, checkCount);
lastCheckMD5 = "invalid_md5";
blockBlob = container.GetBlockBlobReference("blob5");
checkCount = 0;
using (Stream blobStream = await blockBlob.OpenWriteAsync(null, optionsWithNoMD5, opContextWithMD5Check))
{
blobStream.Write(buffer, 0, buffer.Length);
blobStream.Write(buffer, 0, buffer.Length);
}
Assert.IsNull(lastCheckMD5);
Assert.AreEqual(1, checkCount);
lastCheckMD5 = null;
pageBlob = container.GetPageBlobReference("blob6");
checkCount = 0;
using (Stream blobStream = await pageBlob.OpenWriteAsync(buffer.Length * 3, null, optionsWithMD5, opContextWithMD5Check))
{
blobStream.Write(buffer, 0, buffer.Length);
blobStream.Write(buffer, 0, buffer.Length);
}
Assert.IsNotNull(lastCheckMD5);
Assert.AreEqual(1, checkCount);
lastCheckMD5 = "invalid_md5";
pageBlob = container.GetPageBlobReference("blob7");
checkCount = 0;
using (Stream blobStream = await pageBlob.OpenWriteAsync(buffer.Length * 3, null, optionsWithNoMD5, opContextWithMD5Check))
{
blobStream.Write(buffer, 0, buffer.Length);
blobStream.Write(buffer, 0, buffer.Length);
}
Assert.IsNull(lastCheckMD5);
Assert.AreEqual(1, checkCount);
}
finally
{
await container.DeleteIfExistsAsync();
}
}
public async Task UseTransactionalMD5GetTestAsync()
{
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 (long.Parse(HttpResponseParsers.GetContentLength(args.Response)) >= buffer.Length)
{
lastCheckMD5 = HttpResponseParsers.GetContentMD5(args.Response);
checkCount++;
}
};
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1");
using (Stream blobStream = await blockBlob.OpenWriteAsync())
{
blobStream.Write(buffer, 0, buffer.Length);
blobStream.Write(buffer, 0, buffer.Length);
}
checkCount = 0;
using (Stream stream = new MemoryStream())
{
lastCheckMD5 = null;
await blockBlob.DownloadToStreamAsync(stream, null, optionsWithNoMD5, opContextWithMD5Check);
Assert.IsNotNull(lastCheckMD5);
lastCheckMD5 = null;
await blockBlob.DownloadToStreamAsync(stream, null, optionsWithMD5, opContextWithMD5Check);
Assert.IsNotNull(lastCheckMD5);
lastCheckMD5 = "invalid_md5";
await blockBlob.DownloadRangeToStreamAsync(stream, buffer.Length, buffer.Length, null, optionsWithNoMD5, opContextWithMD5Check);
Assert.IsNull(lastCheckMD5);
lastCheckMD5 = "invalid_md5";
await blockBlob.DownloadRangeToStreamAsync(stream, buffer.Length, buffer.Length, null, optionsWithMD5, opContextWithMD5Check);
Assert.AreEqual(md5, lastCheckMD5);
lastCheckMD5 = "invalid_md5";
await blockBlob.DownloadRangeToStreamAsync(stream, 1024, 4 * 1024 * 1024 + 1, null, optionsWithNoMD5, opContextWithMD5Check);
Assert.IsNull(lastCheckMD5);
StorageException storageEx = await TestHelper.ExpectedExceptionAsync <StorageException>(
() => blockBlob.DownloadRangeToStreamAsync(stream, 1024, 4 * 1024 * 1024 + 1, null, optionsWithMD5, opContextWithMD5Check),
"Downloading more than 4MB with transactional MD5 should not be supported");
Assert.IsInstanceOfType(storageEx.InnerException, typeof(ArgumentOutOfRangeException));
lastCheckMD5 = null;
using (Stream blobStream = await blockBlob.OpenReadAsync(null, optionsWithMD5, opContextWithMD5Check))
{
blobStream.CopyTo(stream);
Assert.IsNotNull(lastCheckMD5);
}
lastCheckMD5 = "invalid_md5";
using (Stream blobStream = await blockBlob.OpenReadAsync(null, optionsWithNoMD5, opContextWithMD5Check))
{
blobStream.CopyTo(stream);
Assert.IsNull(lastCheckMD5);
}
}
Assert.AreEqual(9, checkCount);
CloudPageBlob pageBlob = container.GetPageBlobReference("blob3");
using (Stream blobStream = await pageBlob.OpenWriteAsync(buffer.Length * 2))
{
blobStream.Write(buffer, 0, buffer.Length);
blobStream.Write(buffer, 0, buffer.Length);
}
checkCount = 0;
using (Stream stream = new MemoryStream())
{
lastCheckMD5 = "invalid_md5";
await pageBlob.DownloadToStreamAsync(stream, null, optionsWithNoMD5, opContextWithMD5Check);
Assert.IsNull(lastCheckMD5);
StorageException storageEx = await TestHelper.ExpectedExceptionAsync <StorageException>(
() => pageBlob.DownloadToStreamAsync(stream, null, optionsWithMD5, opContextWithMD5Check),
"Page blob will not have MD5 set by default; with UseTransactional, download should fail");
lastCheckMD5 = "invalid_md5";
await pageBlob.DownloadRangeToStreamAsync(stream, buffer.Length, buffer.Length, null, optionsWithNoMD5, opContextWithMD5Check);
Assert.IsNull(lastCheckMD5);
lastCheckMD5 = "invalid_md5";
await pageBlob.DownloadRangeToStreamAsync(stream, buffer.Length, buffer.Length, null, optionsWithMD5, opContextWithMD5Check);
Assert.AreEqual(md5, lastCheckMD5);
lastCheckMD5 = "invalid_md5";
await pageBlob.DownloadRangeToStreamAsync(stream, 1024, 4 * 1024 * 1024 + 1, null, optionsWithNoMD5, opContextWithMD5Check);
Assert.IsNull(lastCheckMD5);
storageEx = await TestHelper.ExpectedExceptionAsync <StorageException>(
() => pageBlob.DownloadRangeToStreamAsync(stream, 1024, 4 * 1024 * 1024 + 1, null, optionsWithMD5, opContextWithMD5Check),
"Downloading more than 4MB with transactional MD5 should not be supported");
Assert.IsInstanceOfType(storageEx.InnerException, typeof(ArgumentOutOfRangeException));
lastCheckMD5 = null;
using (Stream blobStream = await pageBlob.OpenReadAsync(null, optionsWithMD5, opContextWithMD5Check))
{
blobStream.CopyTo(stream);
Assert.IsNotNull(lastCheckMD5);
}
lastCheckMD5 = "invalid_md5";
using (Stream blobStream = await pageBlob.OpenReadAsync(null, optionsWithNoMD5, opContextWithMD5Check))
{
blobStream.CopyTo(stream);
Assert.IsNull(lastCheckMD5);
}
}
Assert.AreEqual(9, checkCount);
}
finally
{
await container.DeleteIfExistsAsync();
}
}
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 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 (CloudBlobStream 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 (CloudBlobStream 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 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 CloudBlobClientListBlobsSegmentedWithPrefixAsync()
{
string name = "bb" + GetRandomContainerName();
DelegatingHandlerImpl delegatingHandlerImpl = new DelegatingHandlerImpl(new DelegatingHandlerImpl());
CloudBlobClient blobClient = GenerateCloudBlobClient(delegatingHandlerImpl);
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);
Assert.AreNotEqual(0, delegatingHandlerImpl.CallCount);
}
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);
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 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 (Stream 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 (Stream 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 (Stream 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 (Stream 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 (Stream 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 (Stream 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 (Stream 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 (Stream 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 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.StartCopyAsync(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().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();
}
}
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.StartCopyAsync(TestHelper.Defiddler(source));
Assert.AreEqual(BlobType.PageBlob, copy.BlobType);
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().Wait();
}
}
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();
string 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 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 async Task UseTransactionalCRC64PutTestAsync()
{
BlobRequestOptions optionsWithNoCRC64 = new BlobRequestOptions()
{
ChecksumOptions = new ChecksumOptions {
UseTransactionalCRC64 = false
}
};
BlobRequestOptions optionsWithCRC64 = new BlobRequestOptions()
{
ChecksumOptions = new ChecksumOptions {
UseTransactionalCRC64 = true
}
};
byte[] buffer = GetRandomBuffer(1024);
Crc64Wrapper hasher = new Crc64Wrapper();
hasher.UpdateHash(buffer, 0, buffer.Length);
string crc64 = hasher.ComputeHash();
string lastCheckCRC64 = null;
int checkCount = 0;
OperationContext opContextWithCRC64Check = new OperationContext();
opContextWithCRC64Check.SendingRequest += (_, args) =>
{
if (HttpRequestParsers.GetContentLength(args.Request) >= buffer.Length)
{
lastCheckCRC64 = HttpRequestParsers.GetContentCRC64(args.Request);
checkCount++;
}
};
OperationContext opContextWithCRC64CheckAndInjectedFailure = new OperationContext();
opContextWithCRC64CheckAndInjectedFailure.SendingRequest += (_, args) =>
{
args.Response.Headers.Remove(Constants.HeaderConstants.ContentCrc64Header);
args.Request.Headers.TryAddWithoutValidation(Constants.HeaderConstants.ContentCrc64Header, "dummy");
if (HttpRequestParsers.GetContentLength(args.Request) >= buffer.Length)
{
lastCheckCRC64 = HttpRequestParsers.GetContentCRC64(args.Request);
checkCount++;
}
};
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1");
List <string> blockIds = GetBlockIdList(3);
checkCount = 0;
using (Stream blockData = new MemoryStream(buffer))
{
lastCheckCRC64 = "invalid_CRC64";
await blockBlob.PutBlockAsync(blockIds[0], blockData, null, null, optionsWithNoCRC64, opContextWithCRC64Check);
Assert.IsNull(lastCheckCRC64);
lastCheckCRC64 = "invalid_CRC64";
blockData.Seek(0, SeekOrigin.Begin);
await blockBlob.PutBlockAsync(blockIds[1], blockData, null, null, optionsWithCRC64, opContextWithCRC64Check);
Assert.AreEqual(crc64, lastCheckCRC64);
blockData.Seek(0, SeekOrigin.Begin);
await TestHelper.ExpectedExceptionAsync <StorageException>(
() => blockBlob.PutBlockAsync(blockIds[1], blockData, null, null, optionsWithCRC64, opContextWithCRC64CheckAndInjectedFailure),
"Calculated CRC64 does not match existing property"
);
lastCheckCRC64 = "invalid_CRC64";
blockData.Seek(0, SeekOrigin.Begin);
await blockBlob.PutBlockAsync(blockIds[2], blockData, new Checksum(crc64 : crc64), null, optionsWithNoCRC64, opContextWithCRC64Check);
Assert.AreEqual(crc64, lastCheckCRC64);
}
Assert.AreEqual(3, checkCount);
checkCount = 0;
CloudAppendBlob appendBlob = container.GetAppendBlobReference("blob2");
await appendBlob.CreateOrReplaceAsync();
checkCount = 0;
using (Stream blockData = new MemoryStream(buffer))
{
lastCheckCRC64 = "invalid_CRC64";
await appendBlob.AppendBlockAsync(blockData, null, null, optionsWithNoCRC64, opContextWithCRC64Check);
Assert.IsNull(lastCheckCRC64);
lastCheckCRC64 = "invalid_CRC64";
blockData.Seek(0, SeekOrigin.Begin);
await appendBlob.AppendBlockAsync(blockData, null, null, optionsWithCRC64, opContextWithCRC64Check);
Assert.AreEqual(crc64, lastCheckCRC64);
blockData.Seek(0, SeekOrigin.Begin);
await TestHelper.ExpectedExceptionAsync <StorageException>(
() => appendBlob.AppendBlockAsync(blockData, null, null, optionsWithCRC64, opContextWithCRC64CheckAndInjectedFailure),
"Calculated CRC64 does not match existing property"
);
lastCheckCRC64 = "invalid_CRC64";
blockData.Seek(0, SeekOrigin.Begin);
await appendBlob.AppendBlockAsync(blockData, new Checksum(crc64 : crc64), null, optionsWithNoCRC64, opContextWithCRC64Check);
Assert.AreEqual(crc64, lastCheckCRC64);
}
Assert.AreEqual(3, checkCount);
CloudPageBlob pageBlob = container.GetPageBlobReference("blob3");
await pageBlob.CreateAsync(buffer.Length);
checkCount = 0;
using (Stream pageData = new MemoryStream(buffer))
{
lastCheckCRC64 = "invalid_CRC64";
await pageBlob.WritePagesAsync(pageData, 0, null, null, optionsWithNoCRC64, opContextWithCRC64Check);
Assert.IsNull(lastCheckCRC64);
lastCheckCRC64 = "invalid_CRC64";
pageData.Seek(0, SeekOrigin.Begin);
await pageBlob.WritePagesAsync(pageData, 0, null, null, optionsWithCRC64, opContextWithCRC64Check);
Assert.AreEqual(crc64, lastCheckCRC64);
pageData.Seek(0, SeekOrigin.Begin);
await TestHelper.ExpectedExceptionAsync <StorageException>(
() => pageBlob.WritePagesAsync(pageData, 0, null, null, optionsWithCRC64, opContextWithCRC64CheckAndInjectedFailure),
"Calculated CRC64 does not match existing property"
);
lastCheckCRC64 = "invalid_CRC64";
pageData.Seek(0, SeekOrigin.Begin);
await pageBlob.WritePagesAsync(pageData, 0, new Checksum(crc64 : crc64), null, optionsWithNoCRC64, opContextWithCRC64Check);
Assert.AreEqual(crc64, lastCheckCRC64);
}
Assert.AreEqual(3, checkCount);
lastCheckCRC64 = null;
blockBlob = container.GetBlockBlobReference("blob4");
checkCount = 0;
using (Stream blobStream = await blockBlob.OpenWriteAsync(null, optionsWithCRC64, opContextWithCRC64Check))
{
blobStream.Write(buffer, 0, buffer.Length);
blobStream.Write(buffer, 0, buffer.Length);
}
Assert.IsNotNull(lastCheckCRC64);
Assert.AreEqual(1, checkCount);
lastCheckCRC64 = "invalid_CRC64";
blockBlob = container.GetBlockBlobReference("blob5");
checkCount = 0;
using (Stream blobStream = await blockBlob.OpenWriteAsync(null, optionsWithNoCRC64, opContextWithCRC64Check))
{
blobStream.Write(buffer, 0, buffer.Length);
blobStream.Write(buffer, 0, buffer.Length);
}
Assert.IsNull(lastCheckCRC64);
Assert.AreEqual(1, checkCount);
lastCheckCRC64 = null;
pageBlob = container.GetPageBlobReference("blob6");
checkCount = 0;
using (Stream blobStream = await pageBlob.OpenWriteAsync(buffer.Length * 3, null, optionsWithCRC64, opContextWithCRC64Check))
{
blobStream.Write(buffer, 0, buffer.Length);
blobStream.Write(buffer, 0, buffer.Length);
}
Assert.IsNotNull(lastCheckCRC64);
Assert.AreEqual(1, checkCount);
lastCheckCRC64 = "invalid_CRC64";
pageBlob = container.GetPageBlobReference("blob7");
checkCount = 0;
using (Stream blobStream = await pageBlob.OpenWriteAsync(buffer.Length * 3, null, optionsWithNoCRC64, opContextWithCRC64Check))
{
blobStream.Write(buffer, 0, buffer.Length);
blobStream.Write(buffer, 0, buffer.Length);
}
Assert.IsNull(lastCheckCRC64);
Assert.AreEqual(1, checkCount);
}
finally
{
await container.DeleteIfExistsAsync();
}
}
public async Task CloudBlobSnapshotTask()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
var blobName = GetRandomBlobName();
MemoryStream originalData = new MemoryStream(GetRandomBuffer(1024));
CloudAppendBlob appendBlob = container.GetAppendBlobReference(blobName);
await appendBlob.CreateOrReplaceAsync();
await appendBlob.AppendBlockAsync(originalData, null);
CloudBlob blob = container.GetBlobReference(blobName);
await blob.FetchAttributesAsync();
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);
CloudBlob snapshotCopy = container.GetBlobReference("blob2");
await snapshotCopy.StartCopyAsync(snapshot1.Uri, null, null, null, null);
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);
}
//overwriting will create another snapshot
await appendBlob.CreateOrReplaceAsync();
await blob.FetchAttributesAsync();
using (Stream snapshotStream = await snapshot1.OpenReadAsync())
{
snapshotStream.Seek(0, SeekOrigin.End);
TestHelper.AssertStreamsAreEqual(originalData, snapshotStream);
}
await Task.Delay(500);
List <IListBlobItem> blobs =
(await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.All, null, null, null, null))
.Results
.ToList();
Assert.AreEqual(4, blobs.Count);
AssertAreEqual(snapshotCopy, (CloudBlob)blobs[0]);
AssertAreEqual(snapshot1, (CloudBlob)blobs[1]);
AssertAreEqual(snapshot2, (CloudBlob)blobs[2]);
AssertAreEqual(blob, (CloudBlob)blobs[3]);
}
finally
{
await container.DeleteIfExistsAsync();
}
}
public async Task UseTransactionalCRC64GetTestAsync()
{
BlobRequestOptions optionsWithNoCRC64 = new BlobRequestOptions()
{
ChecksumOptions = new ChecksumOptions {
UseTransactionalCRC64 = false
}
};
BlobRequestOptions optionsWithCRC64 = new BlobRequestOptions()
{
ChecksumOptions = new ChecksumOptions {
UseTransactionalCRC64 = true
}
};
byte[] buffer = GetRandomBuffer(3 * 1024 * 1024);
Crc64Wrapper hasher = new Crc64Wrapper();
hasher.UpdateHash(buffer, 0, buffer.Length);
string crc64 = hasher.ComputeHash();
string lastCheckCRC64 = null;
OperationContext opContextWithCRC64Check = new OperationContext();
opContextWithCRC64Check.ResponseReceived += (_, args) =>
{
if (long.Parse(HttpResponseParsers.GetContentLength(args.Response)) >= buffer.Length)
{
lastCheckCRC64 = HttpResponseParsers.GetContentCRC64(args.Response);
}
};
OperationContext opContextWithCRC64CheckAndInjectedFailure = new OperationContext();
opContextWithCRC64CheckAndInjectedFailure.ResponseReceived += (_, args) =>
{
args.Response.Headers.Remove(Constants.HeaderConstants.ContentCrc64Header);
args.Response.Headers.TryAddWithoutValidation(Constants.HeaderConstants.ContentCrc64Header, "dummy");
if (long.Parse(HttpResponseParsers.GetContentLength(args.Response)) >= buffer.Length)
{
lastCheckCRC64 = HttpResponseParsers.GetContentCRC64(args.Response);
}
};
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1");
using (Stream blobStream = await blockBlob.OpenWriteAsync())
{
blobStream.Write(buffer, 0, buffer.Length);
blobStream.Write(buffer, 0, buffer.Length);
}
using (Stream stream = new MemoryStream())
{
//lastCheckCRC64 = null;
//blockBlob.DownloadToStream(stream, null, optionsWithNoCRC64, opContextWithCRC64Check);
//Assert.IsNotNull(lastCheckCRC64);
//lastCheckCRC64 = null;
//blockBlob.DownloadToStream(stream, null, optionsWithCRC64, opContextWithCRC64Check);
//Assert.IsNotNull(lastCheckCRC64);
lastCheckCRC64 = "invalid_CRC64";
await blockBlob.DownloadRangeToStreamAsync(stream, buffer.Length, buffer.Length, null, optionsWithNoCRC64, opContextWithCRC64Check);
Assert.IsNull(lastCheckCRC64);
lastCheckCRC64 = "invalid_CRC64";
await blockBlob.DownloadRangeToStreamAsync(stream, buffer.Length, buffer.Length, null, optionsWithCRC64, opContextWithCRC64Check);
Assert.AreEqual(crc64, lastCheckCRC64);
await TestHelper.ExpectedExceptionAsync <StorageException>(
() => blockBlob.DownloadRangeToStreamAsync(stream, buffer.Length, buffer.Length, null, optionsWithCRC64, opContextWithCRC64CheckAndInjectedFailure),
"Calculated CRC64 does not match existing property"
);
lastCheckCRC64 = "invalid_CRC64";
await blockBlob.DownloadRangeToStreamAsync(stream, 1024, 4 * 1024 * 1024 + 1, null, optionsWithNoCRC64, opContextWithCRC64Check);
Assert.IsNull(lastCheckCRC64);
StorageException storageEx = await TestHelper.ExpectedExceptionAsync <StorageException>(
() => blockBlob.DownloadRangeToStreamAsync(stream, 1024, 4 * 1024 * 1024 + 1, null, optionsWithCRC64, opContextWithCRC64Check),
"Downloading more than 4MB with transactional CRC64 should not be supported");
Assert.IsInstanceOfType(storageEx.InnerException, typeof(ArgumentOutOfRangeException));
lastCheckCRC64 = null;
using (Stream blobStream = await blockBlob.OpenReadAsync(null, optionsWithCRC64, opContextWithCRC64Check))
{
blobStream.CopyTo(stream);
Assert.IsNotNull(lastCheckCRC64);
}
lastCheckCRC64 = "invalid_CRC64";
using (Stream blobStream = await blockBlob.OpenReadAsync(null, optionsWithNoCRC64, opContextWithCRC64Check))
{
blobStream.CopyTo(stream);
Assert.IsNull(lastCheckCRC64);
}
}
CloudPageBlob pageBlob = container.GetPageBlobReference("blob3");
using (Stream blobStream = await pageBlob.OpenWriteAsync(buffer.Length * 2))
{
blobStream.Write(buffer, 0, buffer.Length);
blobStream.Write(buffer, 0, buffer.Length);
}
using (Stream stream = new MemoryStream())
{
lastCheckCRC64 = "invalid_CRC64";
await pageBlob.DownloadToStreamAsync(stream, null, optionsWithNoCRC64, opContextWithCRC64Check);
Assert.IsNull(lastCheckCRC64);
StorageException storageEx = await TestHelper.ExpectedExceptionAsync <StorageException>(
() => pageBlob.DownloadToStreamAsync(stream, null, optionsWithCRC64, opContextWithCRC64Check),
"Page blob will not have CRC64 set by default; with UseTransactional, download should fail");
lastCheckCRC64 = "invalid_CRC64";
await pageBlob.DownloadRangeToStreamAsync(stream, buffer.Length, buffer.Length, null, optionsWithNoCRC64, opContextWithCRC64Check);
Assert.IsNull(lastCheckCRC64);
lastCheckCRC64 = "invalid_CRC64";
await pageBlob.DownloadRangeToStreamAsync(stream, buffer.Length, buffer.Length, null, optionsWithCRC64, opContextWithCRC64Check);
Assert.AreEqual(crc64, lastCheckCRC64);
await TestHelper.ExpectedExceptionAsync <StorageException>(
() => pageBlob.DownloadRangeToStreamAsync(stream, buffer.Length, buffer.Length, null, optionsWithCRC64, opContextWithCRC64CheckAndInjectedFailure),
"Calculated CRC64 does not match existing property"
);
lastCheckCRC64 = "invalid_CRC64";
await pageBlob.DownloadRangeToStreamAsync(stream, 1024, 4 * 1024 * 1024 + 1, null, optionsWithNoCRC64, opContextWithCRC64Check);
Assert.IsNull(lastCheckCRC64);
storageEx = await TestHelper.ExpectedExceptionAsync <StorageException>(
() => pageBlob.DownloadRangeToStreamAsync(stream, 1024, 4 * 1024 * 1024 + 1, null, optionsWithCRC64, opContextWithCRC64Check),
"Downloading more than 4MB with transactional CRC64 should not be supported");
Assert.IsInstanceOfType(storageEx.InnerException, typeof(ArgumentOutOfRangeException));
lastCheckCRC64 = null;
using (Stream blobStream = await pageBlob.OpenReadAsync(null, optionsWithCRC64, opContextWithCRC64Check))
{
blobStream.CopyTo(stream);
Assert.IsNotNull(lastCheckCRC64);
}
lastCheckCRC64 = "invalid_CRC64";
using (Stream blobStream = await pageBlob.OpenReadAsync(null, optionsWithNoCRC64, opContextWithCRC64Check))
{
blobStream.CopyTo(stream);
Assert.IsNull(lastCheckCRC64);
}
}
}
finally
{
await container.DeleteIfExistsAsync();
}
}
public async Task AppendBlobReadLockToETagTestAsync()
{
byte[] outBuffer = new byte[1 * 1024 * 1024];
byte[] buffer = GetRandomBuffer(2 * outBuffer.Length);
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudAppendBlob blob = container.GetAppendBlobReference("blob1");
await blob.CreateOrReplaceAsync();
blob.StreamMinimumReadSizeInBytes = outBuffer.Length;
using (MemoryStream wholeBlob = new MemoryStream(buffer))
{
#if !FACADE_NETCORE
await blob.AppendBlockAsync(wholeBlob);
#else
await blob.AppendBlockAsync(wholeBlob, string.Empty, null, null, null, CancellationToken.None);
#endif
}
OperationContext opContext = new OperationContext();
using (Stream blobStream = await blob.OpenReadAsync(null, null, opContext))
{
Stream blobStreamForRead = blobStream;
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 (Stream blobStream = await blob.OpenReadAsync(null, null, opContext))
{
Stream blobStreamForRead = blobStream;
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().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();
}
}
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();
}
}