public void BlobWriteWhenOpenRead()
{
byte[] buffer = GetRandomBuffer(2 * 1024);
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
using (MemoryStream srcStream = new MemoryStream(buffer))
{
blob.UploadFromStream(srcStream);
Stream blobStream = blob.OpenRead();
byte[] testBuffer = new byte[2048];
TestHelper.ExpectedException <NotSupportedException>(() => blobStream.Write(testBuffer, 0, 2048),
"Try writing to a stream opened for read");
}
}
finally
{
container.DeleteIfExists();
}
}
public void CloudBlobDirectoryFlatListingWithPrefix()
{
foreach (String delimiter in Delimiters)
{
CloudBlobClient client = GenerateCloudBlobClient();
client.DefaultDelimiter = delimiter;
string name = GetRandomContainerName();
CloudBlobContainer container = client.GetContainerReference(name);
try
{
container.Create();
if (CloudBlobDirectorySetupWithDelimiter(container, delimiter))
{
BlobContinuationToken token = null;
CloudBlobDirectory directory = container.GetDirectoryReference("TopDir1");
List <IListBlobItem> list1 = new List <IListBlobItem>();
do
{
BlobResultSegment result1 = directory.ListBlobsSegmented(token);
token = result1.ContinuationToken;
list1.AddRange(result1.Results);
}while (token != null);
Assert.IsTrue(list1.Count == 3);
IListBlobItem item11 = list1.ElementAt(0);
Assert.IsTrue(item11.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "Blob1"));
IListBlobItem item12 = list1.ElementAt(1);
Assert.IsTrue(item12.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir1" + delimiter));
IListBlobItem item13 = list1.ElementAt(2);
Assert.IsTrue(item13.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir2" + delimiter));
CloudBlobDirectory midDir2 = (CloudBlobDirectory)item13;
List <IListBlobItem> list2 = new List <IListBlobItem>();
do
{
BlobResultSegment result2 = midDir2.ListBlobsSegmented(true, BlobListingDetails.None, null, token, null, null);
token = result2.ContinuationToken;
list2.AddRange(result2.Results);
}while (token != null);
Assert.IsTrue(list2.Count == 2);
IListBlobItem item41 = list2.ElementAt(0);
Assert.IsTrue(item41.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir2" + delimiter + "EndDir1" + delimiter + "EndBlob1"));
IListBlobItem item42 = list2.ElementAt(1);
Assert.IsTrue(item42.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir2" + delimiter + "EndDir2" + delimiter + "EndBlob2"));
}
}
finally
{
container.DeleteIfExists();
}
}
}
public void BlobOpenWriteTest()
{
byte[] buffer = GetRandomBuffer(2 * 1024);
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
using (CloudBlobStream blobStream = blob.OpenWrite(2048))
{
blobStream.Write(buffer, 0, 2048);
blobStream.Flush();
byte[] testBuffer = new byte[2048];
MemoryStream dstStream = new MemoryStream(testBuffer);
blob.DownloadRangeToStream(dstStream, null, null);
MemoryStream memStream = new MemoryStream(buffer);
TestHelper.AssertStreamsAreEqual(memStream, dstStream);
}
}
finally
{
container.DeleteIfExists();
}
}
public void BlobOpenWriteSeekReadTest()
{
byte[] buffer = GetRandomBuffer(2 * 1024);
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
MemoryStream memoryStream = new MemoryStream(buffer);
Stream blobStream = blob.OpenWrite(2048);
blobStream.Write(buffer, 0, 2048);
Assert.AreEqual(blobStream.Position, 2048);
blobStream.Seek(1024, 0);
memoryStream.Seek(1024, 0);
Assert.AreEqual(blobStream.Position, 1024);
byte[] testBuffer = GetRandomBuffer(1024);
memoryStream.Write(testBuffer, 0, 1024);
blobStream.Write(testBuffer, 0, 1024);
Assert.AreEqual(blobStream.Position, memoryStream.Position);
blobStream.Close();
Stream dstStream = blob.OpenRead();
TestHelper.AssertStreamsAreEqual(memoryStream, dstStream);
}
finally
{
container.DeleteIfExists();
}
}
public void CloudBlobLocaleParsing()
{
CloudBlobContainer container = GetRandomContainerReference();
CultureInfo currCulture = Thread.CurrentThread.CurrentCulture;
try
{
const string blobname = "tempfile";
container.Create();
CloudBlockBlob blockBlob = container.GetBlockBlobReference(blobname);
OperationContext context = new OperationContext();
blockBlob.UploadText("placeholder", null, null, null, context);
foreach (CultureInfo culture in CultureInfo.GetCultures(CultureTypes.AllCultures))
{
Thread.CurrentThread.CurrentCulture = culture;
Assert.IsTrue(blockBlob.Exists()); // parses the header to ensure can be parsed across cultures
} // failed assertion means we never tested the parser
}
finally
{
Thread.CurrentThread.CurrentCulture = currCulture;
container.DeleteIfExists();
}
}
public void CloudBlobSnapshotMetadataAPM()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
var blobName = GetRandomBlobName();
CloudAppendBlob appendBlob = container.GetAppendBlobReference(blobName);
appendBlob.CreateOrReplace();
CloudBlob blob = container.GetBlobReference(blobName);
blob.Metadata["Hello"] = "World";
blob.Metadata["Marco"] = "Polo";
blob.SetMetadata();
IDictionary <string, string> snapshotMetadata = new Dictionary <string, string>();
snapshotMetadata["Hello"] = "Dolly";
snapshotMetadata["Yoyo"] = "Ma";
IAsyncResult result;
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
result = blob.BeginSnapshot(snapshotMetadata, null, null, null, ar => waitHandle.Set(), null);
waitHandle.WaitOne();
CloudBlob snapshot = blob.EndSnapshot(result);
// Test the client view against the expected metadata
// Metadata keys should be case-insensitive
// None of the original metadata should be present
Assert.AreEqual("Dolly", snapshot.Metadata["Hello"]);
Assert.AreEqual("Dolly", snapshot.Metadata["HELLO"]);
Assert.AreEqual("Ma", snapshot.Metadata["Yoyo"]);
Assert.IsFalse(snapshot.Metadata.ContainsKey("Marco"));
// Test the server view against the expected metadata
snapshot.FetchAttributes();
Assert.AreEqual("Dolly", snapshot.Metadata["Hello"]);
Assert.AreEqual("Dolly", snapshot.Metadata["HELLO"]);
Assert.AreEqual("Ma", snapshot.Metadata["Yoyo"]);
Assert.IsFalse(snapshot.Metadata.ContainsKey("Marco"));
}
}
finally
{
container.DeleteIfExists();
}
}
public void CloudBlockBlobDownloadToStreamAPMCancel()
{
byte[] buffer = GetRandomBuffer(1 * 1024 * 1024);
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudBlockBlob blob = container.GetBlockBlobReference("blob1");
using (MemoryStream originalBlob = new MemoryStream(buffer))
{
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
ICancellableAsyncResult result = blob.BeginUploadFromStream(originalBlob,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
blob.EndUploadFromStream(result);
using (MemoryStream downloadedBlob = new MemoryStream())
{
OperationContext operationContext = new OperationContext();
result = blob.BeginDownloadToStream(downloadedBlob, null, null, operationContext,
ar => waitHandle.Set(),
null);
Thread.Sleep(100);
result.Cancel();
waitHandle.WaitOne();
try
{
blob.EndDownloadToStream(result);
}
catch (StorageException ex)
{
Assert.AreEqual("A task was canceled.", ex.Message);
Assert.AreEqual(ex.RequestInformation.HttpStatusCode, 306);
Assert.AreEqual(ex.RequestInformation.HttpStatusMessage, null);
}
TestHelper.AssertNAttempts(operationContext, 1);
}
}
}
}
finally
{
container.DeleteIfExists();
}
}
public void CloudBlobDirectoryGetParent()
{
foreach (String delimiter in Delimiters)
{
CloudBlobClient client = GenerateCloudBlobClient();
client.DefaultDelimiter = delimiter;
string name = GetRandomContainerName();
CloudBlobContainer container = client.GetContainerReference(name);
try
{
container.Create();
CloudPageBlob blob = container.GetPageBlobReference("Dir1" + delimiter + "Blob1");
blob.Create(0);
Assert.AreEqual("Dir1" + delimiter + "Blob1", blob.Name);
// get the blob's parent
CloudBlobDirectory parent = blob.Parent;
Assert.AreEqual(parent.Prefix, "Dir1" + delimiter);
// get container as parent
CloudBlobDirectory root = parent.Parent;
Assert.AreEqual(root.Prefix, "");
// make sure the parent of the container dir is null
CloudBlobDirectory empty = root.Parent;
Assert.IsNull(empty);
// from container, get directory reference to container
root = container.GetDirectoryReference("");
Assert.AreEqual("", root.Prefix);
Assert.AreEqual(container.Uri.AbsoluteUri, root.Uri.AbsoluteUri);
List <IListBlobItem> list = root.ListBlobs().ToList();
Assert.AreEqual(1, list.Count);
// make sure the parent of the container dir is null
empty = root.Parent;
Assert.IsNull(empty);
blob.DeleteIfExists();
}
finally
{
container.DeleteIfExists();
}
}
}
public async Task BlobOpenReadWithCancelTest()
{
CancellationTokenSource cts = new CancellationTokenSource();
byte[] buffer = new byte[4 * 1024 * 1024];
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
using (MemoryStream srcStream = new MemoryStream(buffer))
{
blob.UploadFromStream(srcStream);
}
Stream dstStream = await blob.OpenReadAsync(null, null, null, cts.Token);
cts.Cancel();
try
{
Assert.IsTrue(cts.Token.IsCancellationRequested);
int bytesRead = 0;
do
{
bytesRead = await dstStream.ReadAsync(buffer, 0, buffer.Length, cts.Token);
}while (bytesRead > 0);
Assert.Fail("Expected exception not raised");
}
catch (StorageException e)
{
Assert.AreEqual("A task was canceled.", e.Message);
}
}
finally
{
container.DeleteIfExists();
}
}
public void CloudBlobDirectoryMultipleDelimiters()
{
foreach (String delimiter in Delimiters)
{
CloudBlobClient client = GenerateCloudBlobClient();
////Set the default delimiter to \
client.DefaultDelimiter = delimiter;
string name = GetRandomContainerName();
CloudBlobContainer container = client.GetContainerReference(name);
try
{
container.Create();
if (CloudBlobDirectorySetupWithDelimiter(container, delimiter))
{
IEnumerable <IListBlobItem> list1 = container.ListBlobs("TopDir1" + delimiter, false, BlobListingDetails.None, null, null);
List <IListBlobItem> simpleList1 = list1.ToList();
////Check if for 3 because if there were more than 3, the previous assert would have failed.
////So the only thing we need to make sure is that it is not less than 3.
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 directory = container.GetDirectoryReference("TopDir1" + delimiter);
CloudBlobDirectory subDirectory = directory.GetDirectoryReference("MidDir1" + delimiter);
CloudBlobDirectory parent = subDirectory.Parent;
Assert.AreEqual(parent.Prefix, directory.Prefix);
Assert.AreEqual(parent.Uri, directory.Uri);
}
}
finally
{
container.DeleteIfExists();
}
}
}
public void CloudBlobContainerSetMetadataAPMCancel()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
container.Metadata.Add("key1", "value1");
TestHelper.ExecuteAPMMethodWithCancellation(4000,
new[] { DelayBehaviors.DelayAllRequestsIf(4000 * 3, AzureStorageSelectors.BlobTraffic().IfHostNameContains(container.ServiceClient.Credentials.AccountName)) },
(options, opContext, callback, state) => container.BeginSetMetadata(null, (BlobRequestOptions)options, opContext, callback, state),
container.EndSetMetadata);
}
finally
{
container.DeleteIfExists();
}
}
private void PrefixEscapingTest(string prefix, string blobName)
{
CloudBlobClient service = GenerateCloudBlobClient();
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
string text = Guid.NewGuid().ToString();
// Create from CloudBlobContainer.
CloudBlockBlob originalBlob = container.GetBlockBlobReference(prefix + "/" + blobName);
originalBlob.PutBlockList(new string[] { });
// List blobs from container.
IListBlobItem blobFromContainerListingBlobs = container.ListBlobs(null, true).First();
Assert.AreEqual(originalBlob.Uri, blobFromContainerListingBlobs.Uri);
CloudBlockBlob uriBlob = new CloudBlockBlob(originalBlob.Uri, service.Credentials);
// Check Name
Assert.AreEqual <string>(prefix + "/" + blobName, originalBlob.Name);
Assert.AreEqual <string>(prefix + "/" + blobName, uriBlob.Name);
// Absolute URI access from CloudBlockBlob
CloudBlockBlob blobInfo = new CloudBlockBlob(originalBlob.Uri, service.Credentials);
blobInfo.FetchAttributes();
// Access from CloudBlobDirectory
CloudBlobDirectory cloudBlobDirectory = container.GetDirectoryReference(prefix);
CloudBlockBlob blobFromCloudBlobDirectory = cloudBlobDirectory.GetBlockBlobReference(blobName);
Assert.AreEqual(blobInfo.Uri, blobFromCloudBlobDirectory.Uri);
// Copy blob verification.
CloudBlockBlob copyBlob = container.GetBlockBlobReference(prefix + "/" + blobName + "copy");
copyBlob.StartCopy(blobInfo.Uri);
copyBlob.FetchAttributes();
}
finally
{
container.Delete();
}
}
public void CloudBlobSnapshotMetadata()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
var blobName = GetRandomBlobName();
CloudAppendBlob appendBlob = container.GetAppendBlobReference(blobName);
appendBlob.CreateOrReplace();
CloudBlob blob = container.GetBlobReference(blobName);
blob.Metadata["Hello"] = "World";
blob.Metadata["Marco"] = "Polo";
blob.SetMetadata();
IDictionary <string, string> snapshotMetadata = new Dictionary <string, string>();
snapshotMetadata["Hello"] = "Dolly";
snapshotMetadata["Yoyo"] = "Ma";
CloudBlob snapshot = blob.Snapshot(snapshotMetadata);
// Test the client view against the expected metadata
// Metadata keys should be case-insensitive
// None of the original metadata should be present
Assert.AreEqual("Dolly", snapshot.Metadata["Hello"]);
Assert.AreEqual("Dolly", snapshot.Metadata["HELLO"]);
Assert.AreEqual("Ma", snapshot.Metadata["Yoyo"]);
Assert.IsFalse(snapshot.Metadata.ContainsKey("Marco"));
// Test the server view against the expected metadata
snapshot.FetchAttributes();
Assert.AreEqual("Dolly", snapshot.Metadata["Hello"]);
Assert.AreEqual("Dolly", snapshot.Metadata["HELLO"]);
Assert.AreEqual("Ma", snapshot.Metadata["Yoyo"]);
Assert.IsFalse(snapshot.Metadata.ContainsKey("Marco"));
}
finally
{
container.DeleteIfExists();
}
}
public void BlobReadWhenOpenWrite()
{
byte[] buffer = GetRandomBuffer(2 * 1024);
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
MemoryStream memoryStream = new MemoryStream(buffer);
Stream blobStream = blob.OpenWrite(2048);
blobStream.Write(buffer, 0, 2048);
byte[] testBuffer = new byte[2048];
TestHelper.ExpectedException <NotSupportedException>(() => blobStream.Read(testBuffer, 0, 2048),
"Try reading from a stream opened for Write");
}
finally
{
container.DeleteIfExists();
}
}
public void BlobOpenReadTest()
{
byte[] buffer = GetRandomBuffer(2 * 1024);
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
using (MemoryStream srcStream = new MemoryStream(buffer))
{
blob.UploadFromStream(srcStream);
Stream dstStream = blob.OpenRead();
TestHelper.AssertStreamsAreEqual(srcStream, dstStream);
}
}
finally
{
container.DeleteIfExists();
}
}
public void BlobSeekTest()
{
byte[] buffer = GetRandomBuffer(2 * 1024);
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
using (MemoryStream srcStream = new MemoryStream(buffer))
{
blob.UploadFromStream(srcStream);
Stream blobStream = blob.OpenRead();
blobStream.Seek(2048, 0);
byte[] buff = new byte[100];
int numRead = blobStream.Read(buff, 0, 100);
Assert.AreEqual(numRead, 0);
}
}
finally
{
container.DeleteIfExists();
}
}
public void CloudBlobSnapshotAPM()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
var blobName = GetRandomBlobName();
MemoryStream originalData = new MemoryStream(GetRandomBuffer(1024));
CloudAppendBlob appendBlob = container.GetAppendBlobReference(blobName);
appendBlob.CreateOrReplace();
appendBlob.AppendBlock(originalData, null);
CloudBlob blob = container.GetBlobReference(blobName);
blob.FetchAttributes();
IAsyncResult result;
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
result = blob.BeginSnapshot(ar => waitHandle.Set(), null);
waitHandle.WaitOne();
CloudBlob snapshot1 = blob.EndSnapshot(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"));
result = blob.BeginSnapshot(ar => waitHandle.Set(), null);
waitHandle.WaitOne();
CloudBlob snapshot2 = blob.EndSnapshot(result);
Assert.IsTrue(snapshot2.SnapshotTime.Value > snapshot1.SnapshotTime.Value);
snapshot1.FetchAttributes();
snapshot2.FetchAttributes();
blob.FetchAttributes();
AssertAreEqual(snapshot1.Properties, blob.Properties);
CloudBlob snapshotCopy = container.GetBlobReference("blob2");
result = snapshotCopy.BeginStartCopy(snapshot1.Uri, null, null, null, null, ar => waitHandle.Set(), null);
waitHandle.WaitOne();
snapshotCopy.EndStartCopy(result);
WaitForCopy(snapshotCopy);
Assert.AreEqual(CopyStatus.Success, snapshotCopy.CopyState.Status);
result = snapshot1.BeginOpenRead(ar => waitHandle.Set(), null);
waitHandle.WaitOne();
using (Stream snapshotStream = snapshot1.EndOpenRead(result))
{
snapshotStream.Seek(0, SeekOrigin.End);
TestHelper.AssertStreamsAreEqual(originalData, snapshotStream);
}
result = appendBlob.BeginCreateOrReplace(ar => waitHandle.Set(), null);
waitHandle.WaitOne();
appendBlob.EndCreateOrReplace(result);
result = blob.BeginFetchAttributes(ar => waitHandle.Set(), null);
waitHandle.WaitOne();
blob.EndFetchAttributes(result);
result = snapshot1.BeginOpenRead(ar => waitHandle.Set(), null);
waitHandle.WaitOne();
using (Stream snapshotStream = snapshot1.EndOpenRead(result))
{
snapshotStream.Seek(0, SeekOrigin.End);
TestHelper.AssertStreamsAreEqual(originalData, snapshotStream);
}
List <IListBlobItem> blobs = container.ListBlobs(null, true, BlobListingDetails.All, null, null).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
{
container.DeleteIfExists();
}
}
public void CloudBlockBlobDownloadRangeToStreamAPMRetry()
{
byte[] buffer = GetRandomBuffer(1 * 1024 * 1024);
int offset = 1024;
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudBlockBlob blob = container.GetBlockBlobReference("blob1");
using (MemoryStream originalBlob = new MemoryStream(buffer))
{
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
ICancellableAsyncResult result = blob.BeginUploadFromStream(originalBlob,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
blob.EndUploadFromStream(result);
}
}
using (MemoryStream originalBlob = new MemoryStream())
{
originalBlob.Write(buffer, offset, buffer.Length - offset);
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
Exception manglerEx = null;
using (HttpMangler proxy = new HttpMangler(false,
new[]
{
TamperBehaviors.TamperNRequestsIf(
session => ThreadPool.QueueUserWorkItem(state =>
{
Thread.Sleep(1000);
try
{
session.Abort();
}
catch (Exception e)
{
manglerEx = e;
}
}),
2,
AzureStorageSelectors.BlobTraffic().IfHostNameContains(container.ServiceClient.Credentials.AccountName))
}))
{
foreach (var options in new[]
{
new BlobRequestOptions()
{
ChecksumOptions =
new ChecksumOptions
{
UseTransactionalMD5 = true,
UseTransactionalCRC64 = false
}
},
new BlobRequestOptions()
{
ChecksumOptions =
new ChecksumOptions
{
UseTransactionalMD5 = false,
UseTransactionalCRC64 = true
}
}
})
{
using (MemoryStream downloadedBlob = new MemoryStream())
{
OperationContext operationContext = new OperationContext();
ICancellableAsyncResult result = blob.BeginDownloadRangeToStream(downloadedBlob, offset, buffer.Length - offset, null, options, operationContext,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
blob.EndDownloadToStream(result);
TestHelper.AssertStreamsAreEqual(originalBlob, downloadedBlob);
if (manglerEx != null)
{
throw manglerEx;
}
}
}
}
}
}
}
finally
{
container.DeleteIfExists();
}
}
public void CloudBlobDirectoryFlatListing()
{
foreach (String delimiter in Delimiters)
{
CloudBlobClient client = GenerateCloudBlobClient();
client.DefaultDelimiter = delimiter;
string name = GetRandomContainerName();
CloudBlobContainer container = client.GetContainerReference(name);
try
{
container.Create();
if (CloudBlobDirectorySetupWithDelimiter(container, delimiter))
{
IEnumerable <IListBlobItem> list1 = container.ListBlobs("TopDir1" + delimiter, false, BlobListingDetails.None, null, null);
List <IListBlobItem> simpleList1 = list1.ToList();
////Check if for 3 because if there were more than 3, the previous assert would have failed.
////So the only thing we need to make sure is that it is not less than 3.
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;
IEnumerable <IListBlobItem> list2 = container.ListBlobs("TopDir1" + delimiter + "MidDir1", true, BlobListingDetails.None, null, null);
List <IListBlobItem> simpleList2 = list2.ToList();
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"));
IEnumerable <IListBlobItem> list3 = container.ListBlobs("TopDir1" + delimiter + "MidDir1" + delimiter, false, BlobListingDetails.None, null, null);
List <IListBlobItem> simpleList3 = list3.ToList();
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));
IEnumerable <IListBlobItem> list4 = midDir2.ListBlobs(true);
List <IListBlobItem> simpleList4 = list4.ToList();
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.DeleteIfExists();
}
}
}
public void CloudBlobSoftDeleteNoSnapshotAPM()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
//Enables a delete retention policy on the blob with 1 day of default retention days
container.ServiceClient.EnableSoftDelete();
container.Create();
// Upload some data to the blob.
var blobName = GetRandomBlobName();
MemoryStream originalData = new MemoryStream(GetRandomBuffer(1024));
CloudAppendBlob appendBlob = container.GetAppendBlobReference(blobName);
appendBlob.CreateOrReplace();
appendBlob.AppendBlock(originalData, null);
CloudBlob blob = container.GetBlobReference(blobName);
Assert.IsFalse(blob.IsDeleted);
IAsyncResult result;
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
result = blob.BeginDelete(DeleteSnapshotsOption.None, null, null, null, ar => waitHandle.Set(), null);
waitHandle.WaitOne();
blob.EndDelete(result);
}
Assert.IsFalse(blob.Exists());
int blobCount = 0;
foreach (IListBlobItem item in container.ListBlobs(null, true, BlobListingDetails.All))
{
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++;
}
Assert.AreEqual(1, blobCount);
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
result = blob.BeginUndelete(ar => waitHandle.Set(), null);
waitHandle.WaitOne();
blob.EndUndelete(result);
}
blob.FetchAttributes();
Assert.IsFalse(blob.IsDeleted);
Assert.IsNull(blob.Properties.DeletedTime);
Assert.IsNull(blob.Properties.RemainingDaysBeforePermanentDelete);
blobCount = 0;
foreach (IListBlobItem item in container.ListBlobs(null, true, BlobListingDetails.All))
{
CloudAppendBlob blobItem = (CloudAppendBlob)item;
Assert.AreEqual(blobItem.Name, blobName);
Assert.IsFalse(blobItem.IsDeleted);
Assert.IsNull(blobItem.Properties.DeletedTime);
Assert.IsNull(blobItem.Properties.RemainingDaysBeforePermanentDelete);
blobCount++;
}
Assert.AreEqual(blobCount, 1);
}
finally
{
container.ServiceClient.DisableSoftDelete();
container.DeleteIfExists();
}
}
public void CloudBlobSoftDeleteSnapshot()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
//Enables a delete retention policy on the blob with 1 day of default retention days
container.ServiceClient.EnableSoftDelete();
container.Create();
// Upload some data to the blob.
var blobName = GetRandomBlobName();
MemoryStream originalData = new MemoryStream(GetRandomBuffer(1024));
CloudAppendBlob appendBlob = container.GetAppendBlobReference(blobName);
appendBlob.UploadFromStream(originalData);
CloudBlob blob = container.GetBlobReference(blobName);
//create snapshot via api
CloudBlob snapshot = blob.Snapshot();
//create snapshot via write protection
appendBlob.UploadFromStream(originalData);
//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;
foreach (IListBlobItem item in container.ListBlobs(null, true, BlobListingDetails.Snapshots | BlobListingDetails.Deleted))
{
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++;
}
Assert.AreEqual(blobCount, 3);
Assert.AreEqual(deletedSnapshotCount, 1);
Assert.AreEqual(snapShotCount, 2);
blobCount = 0;
foreach (IListBlobItem item in container.ListBlobs(null, true, BlobListingDetails.Snapshots))
{
CloudAppendBlob blobItem = (CloudAppendBlob)item;
Assert.AreEqual(blobItem.Name, blobName);
Assert.IsFalse(blobItem.IsDeleted);
Assert.IsNull(blobItem.Properties.DeletedTime);
Assert.IsNull(blobItem.Properties.RemainingDaysBeforePermanentDelete);
blobCount++;
}
Assert.AreEqual(blobCount, 2);
//Delete Blob and snapshots
blob.Delete(DeleteSnapshotsOption.IncludeSnapshots);
Assert.IsFalse(blob.Exists());
Assert.IsFalse(snapshot.Exists());
blobCount = 0;
foreach (IListBlobItem item in container.ListBlobs(null, true, BlobListingDetails.All))
{
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++;
}
Assert.AreEqual(blobCount, 3);
blob.Undelete();
blob.FetchAttributes();
Assert.IsFalse(blob.IsDeleted);
Assert.IsNull(blob.Properties.DeletedTime);
Assert.IsNull(blob.Properties.RemainingDaysBeforePermanentDelete);
blobCount = 0;
foreach (IListBlobItem item in container.ListBlobs(null, true, BlobListingDetails.All))
{
CloudAppendBlob blobItem = (CloudAppendBlob)item;
Assert.AreEqual(blobItem.Name, blobName);
Assert.IsFalse(blobItem.IsDeleted);
Assert.IsNull(blobItem.Properties.DeletedTime);
Assert.IsNull(blobItem.Properties.RemainingDaysBeforePermanentDelete);
blobCount++;
}
Assert.AreEqual(blobCount, 3);
}
finally
{
container.ServiceClient.DisableSoftDelete();
container.DeleteIfExists();
}
}
public void CloudBlobSnapshot()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
// Upload some data to the blob.
var blobName = GetRandomBlobName();
MemoryStream originalData = new MemoryStream(GetRandomBuffer(1024));
CloudAppendBlob appendBlob = container.GetAppendBlobReference(blobName);
appendBlob.CreateOrReplace();
appendBlob.AppendBlock(originalData, null);
CloudBlob blob = container.GetBlobReference(blobName);
blob.FetchAttributes();
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 = blob.Snapshot();
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.Snapshot();
Assert.IsTrue(snapshot2.SnapshotTime.Value > snapshot1.SnapshotTime.Value);
snapshot1.FetchAttributes();
snapshot2.FetchAttributes();
blob.FetchAttributes();
AssertAreEqual(snapshot1.Properties, blob.Properties, false);
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.FetchAttributes();
AssertAreEqual(snapshot1.Properties, snapshot1Clone.Properties, false);
// 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");
snapshotCopy.StartCopy(TestHelper.Defiddler(snapshot1.Uri));
WaitForCopy(snapshotCopy);
Assert.AreEqual(CopyStatus.Success, snapshotCopy.CopyState.Status);
using (Stream snapshotStream = snapshot1.OpenRead())
{
snapshotStream.Seek(0, SeekOrigin.End);
TestHelper.AssertStreamsAreEqual(originalData, snapshotStream);
}
//overwriting the blob and creating the 5th snapshot
appendBlob.CreateOrReplace();
blob.FetchAttributes();
using (Stream snapshotStream = snapshot1.OpenRead())
{
snapshotStream.Seek(0, SeekOrigin.End);
TestHelper.AssertStreamsAreEqual(originalData, snapshotStream);
}
List <IListBlobItem> blobs = container.ListBlobs(null, true, BlobListingDetails.All, null, null).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
{
container.DeleteIfExists();
}
}
public void CloudBlobSoftDeleteNoSnapshot()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
//Enables a delete retention policy on the blob with 1 day of default retention days
container.ServiceClient.EnableSoftDelete();
Shared.Protocol.ServiceProperties props = container.ServiceClient.GetServiceProperties();
container.Create();
// Upload some data to the blob.
var blobName = GetRandomBlobName();
MemoryStream originalData = new MemoryStream(GetRandomBuffer(1024));
CloudAppendBlob appendBlob = container.GetAppendBlobReference(blobName);
appendBlob.CreateOrReplace();
appendBlob.AppendBlock(originalData, null);
CloudBlob blob = container.GetBlobReference(blobName);
Assert.IsTrue(blob.Exists());
Assert.IsFalse(blob.IsDeleted);
blob.Delete();
Assert.IsFalse(blob.Exists());
int blobCount = 0;
foreach (IListBlobItem item in container.ListBlobs(null, true, BlobListingDetails.Snapshots | BlobListingDetails.Deleted))
{
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++;
}
Assert.AreEqual(blobCount, 1);
blob.Undelete();
blob.FetchAttributes();
Assert.IsFalse(blob.IsDeleted);
Assert.IsNull(blob.Properties.DeletedTime);
Assert.IsNull(blob.Properties.RemainingDaysBeforePermanentDelete);
blobCount = 0;
foreach (IListBlobItem item in container.ListBlobs(null, true, BlobListingDetails.All))
{
CloudAppendBlob blobItem = (CloudAppendBlob)item;
Assert.AreEqual(blobItem.Name, blobName);
Assert.IsFalse(blobItem.IsDeleted);
Assert.IsNull(blobItem.Properties.DeletedTime);
Assert.IsNull(blobItem.Properties.RemainingDaysBeforePermanentDelete);
blobCount++;
}
Assert.AreEqual(blobCount, 1);
}
finally
{
container.ServiceClient.DisableSoftDelete();
container.DeleteIfExists();
}
}