private static void TestAccess(string sasToken, SharedAccessBlobPermissions permissions, SharedAccessBlobHeaders headers, CloudBlobContainer container, CloudBlob blob)
{
CloudBlob SASblob;
StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ?
new StorageCredentials() :
new StorageCredentials(sasToken);
if (container != null)
{
container = new CloudBlobContainer(credentials.TransformUri(container.Uri));
if (blob.BlobType == BlobType.BlockBlob)
{
SASblob = container.GetBlockBlobReference(blob.Name);
}
else if (blob.BlobType == BlobType.PageBlob)
{
SASblob = container.GetPageBlobReference(blob.Name);
}
else
{
SASblob = container.GetAppendBlobReference(blob.Name);
}
}
else
{
if (blob.BlobType == BlobType.BlockBlob)
{
SASblob = new CloudBlockBlob(credentials.TransformUri(blob.Uri));
}
else if (blob.BlobType == BlobType.PageBlob)
{
SASblob = new CloudPageBlob(credentials.TransformUri(blob.Uri));
}
else
{
SASblob = new CloudAppendBlob(credentials.TransformUri(blob.Uri));
}
}
HttpStatusCode failureCode = sasToken == null ? HttpStatusCode.NotFound : HttpStatusCode.Forbidden;
// We want to ensure that 'create', 'add', and 'write' permissions all allow for correct writing of blobs, as is reasonable.
if (((permissions & SharedAccessBlobPermissions.Create) == SharedAccessBlobPermissions.Create) || ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write))
{
if (blob.BlobType == BlobType.PageBlob)
{
CloudPageBlob SASpageBlob = (CloudPageBlob)SASblob;
SASpageBlob.Create(512);
CloudPageBlob pageBlob = (CloudPageBlob)blob;
byte[] buffer = new byte[512];
buffer[0] = 2; // random data
if (((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write))
{
SASpageBlob.UploadFromByteArray(buffer, 0, 512);
}
else
{
TestHelper.ExpectedException(
() => SASpageBlob.UploadFromByteArray(buffer, 0, 512),
"pageBlob SAS token without Write perms should not allow for writing/adding",
failureCode);
pageBlob.UploadFromByteArray(buffer, 0, 512);
}
}
else if (blob.BlobType == BlobType.BlockBlob)
{
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
UploadText(SASblob, "blob", Encoding.UTF8);
}
else
{
TestHelper.ExpectedException(
() => UploadText(SASblob, "blob", Encoding.UTF8),
"Block blob SAS token without Write or perms should not allow for writing",
failureCode);
UploadText(blob, "blob", Encoding.UTF8);
}
}
else // append blob
{
// If the sas token contains Feb 2012, append won't be accepted
if (sasToken.Contains(Constants.VersionConstants.February2012))
{
UploadText(blob, "blob", Encoding.UTF8);
}
else
{
CloudAppendBlob SASAppendBlob = SASblob as CloudAppendBlob;
SASAppendBlob.CreateOrReplace();
byte[] textAsBytes = Encoding.UTF8.GetBytes("blob");
using (MemoryStream stream = new MemoryStream())
{
stream.Write(textAsBytes, 0, textAsBytes.Length);
stream.Seek(0, SeekOrigin.Begin);
if (((permissions & SharedAccessBlobPermissions.Add) == SharedAccessBlobPermissions.Add) || ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write))
{
SASAppendBlob.AppendBlock(stream, null);
}
else
{
TestHelper.ExpectedException(
() => SASAppendBlob.AppendBlock(stream, null),
"Append blob SAS token without Write or Add perms should not allow for writing/adding",
failureCode);
stream.Seek(0, SeekOrigin.Begin);
((CloudAppendBlob)blob).AppendBlock(stream, null);
}
}
}
}
}
else
{
TestHelper.ExpectedException(
() => UploadText(SASblob, "blob", Encoding.UTF8),
"UploadText SAS does not allow for writing/adding",
((blob.BlobType == BlobType.AppendBlob) && (sasToken != null) && (sasToken.Contains(Constants.VersionConstants.February2012))) ? HttpStatusCode.BadRequest : failureCode);
UploadText(blob, "blob", Encoding.UTF8);
}
if (container != null)
{
if ((permissions & SharedAccessBlobPermissions.List) == SharedAccessBlobPermissions.List)
{
container.ListBlobs().ToArray();
}
else
{
TestHelper.ExpectedException(
() => container.ListBlobs().ToArray(),
"List blobs while SAS does not allow for listing",
failureCode);
}
}
// need to have written to the blob to read from it.
if (((permissions & SharedAccessBlobPermissions.Read) == SharedAccessBlobPermissions.Read))
{
SASblob.FetchAttributes();
// Test headers
if (headers != null)
{
if (headers.CacheControl != null)
{
Assert.AreEqual(headers.CacheControl, SASblob.Properties.CacheControl);
}
if (headers.ContentDisposition != null)
{
Assert.AreEqual(headers.ContentDisposition, SASblob.Properties.ContentDisposition);
}
if (headers.ContentEncoding != null)
{
Assert.AreEqual(headers.ContentEncoding, SASblob.Properties.ContentEncoding);
}
if (headers.ContentLanguage != null)
{
Assert.AreEqual(headers.ContentLanguage, SASblob.Properties.ContentLanguage);
}
if (headers.ContentType != null)
{
Assert.AreEqual(headers.ContentType, SASblob.Properties.ContentType);
}
}
}
else
{
TestHelper.ExpectedException(
() => SASblob.FetchAttributes(),
"Fetch blob attributes while SAS does not allow for reading",
failureCode);
}
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
SASblob.SetMetadata();
}
else
{
TestHelper.ExpectedException(
() => SASblob.SetMetadata(),
"Set blob metadata while SAS does not allow for writing",
failureCode);
}
if ((permissions & SharedAccessBlobPermissions.Delete) == SharedAccessBlobPermissions.Delete)
{
SASblob.Delete();
}
else
{
TestHelper.ExpectedException(
() => SASblob.Delete(),
"Delete blob while SAS does not allow for deleting",
failureCode);
}
}
public async Task BlobWriteStreamOpenAndCloseAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
// Block blob tests
CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1");
using (Stream writeStream = await blockBlob.OpenWriteAsync())
{
}
CloudBlockBlob blockBlob2 = container.GetBlockBlobReference(blockBlob.Name);
await blockBlob2.FetchAttributesAsync();
Assert.AreEqual(0, blockBlob2.Properties.Length);
Assert.AreEqual(BlobType.BlockBlob, blockBlob2.Properties.BlobType);
// Page blob tests
CloudPageBlob pageBlob = container.GetPageBlobReference("blob2");
OperationContext opContext = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await pageBlob.OpenWriteAsync(null, null, null, opContext),
opContext,
"Opening a page blob stream with no size should fail on a blob that does not exist",
HttpStatusCode.NotFound);
using (Stream writeStream = await pageBlob.OpenWriteAsync(1024))
{
}
using (Stream writeStream = await pageBlob.OpenWriteAsync(null))
{
}
CloudPageBlob pageBlob2 = container.GetPageBlobReference(pageBlob.Name);
await pageBlob2.FetchAttributesAsync();
Assert.AreEqual(1024, pageBlob2.Properties.Length);
Assert.AreEqual(BlobType.PageBlob, pageBlob2.Properties.BlobType);
// Append blob test
CloudAppendBlob appendBlob = container.GetAppendBlobReference("blob3");
using (Stream writeStream = await appendBlob.OpenWriteAsync(true))
{
}
CloudAppendBlob appendBlob2 = container.GetAppendBlobReference(appendBlob.Name);
await appendBlob2.FetchAttributesAsync();
Assert.AreEqual(0, appendBlob2.Properties.Length);
Assert.AreEqual(BlobType.AppendBlob, appendBlob2.Properties.BlobType);
}
finally
{
container.DeleteAsync().Wait();
}
}
public async Task AppendBlobReadStreamBasicTestAsync()
{
byte[] buffer = GetRandomBuffer(4 * 1024 * 1024);
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudAppendBlob blob = container.GetAppendBlobReference("blob1");
await blob.CreateOrReplaceAsync();
using (MemoryStream wholeBlob = new MemoryStream(buffer))
{
await blob.AppendBlockAsync(wholeBlob);
}
using (MemoryStream wholeBlob = new MemoryStream(buffer))
{
using (Stream blobStream = (await blob.OpenReadAsync()))
{
TestHelper.AssertStreamsAreEqual(wholeBlob, blobStream);
}
}
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
public static List <string> CreateBlobsTask(CloudBlobContainer container, int count, BlobType type)
{
string name;
List <string> blobs = new List <string>();
for (int i = 0; i < count; i++)
{
switch (type)
{
case BlobType.BlockBlob:
name = "bb" + Guid.NewGuid().ToString();
CloudBlockBlob blockBlob = container.GetBlockBlobReference(name);
blockBlob.PutBlockListAsync(new string[] { }).Wait();
blobs.Add(name);
break;
case BlobType.PageBlob:
name = "pb" + Guid.NewGuid().ToString();
CloudPageBlob pageBlob = container.GetPageBlobReference(name);
pageBlob.CreateAsync(0).Wait();
blobs.Add(name);
break;
case BlobType.AppendBlob:
name = "ab" + Guid.NewGuid().ToString();
CloudAppendBlob appendBlob = container.GetAppendBlobReference(name);
appendBlob.CreateOrReplaceAsync().Wait();
blobs.Add(name);
break;
}
}
return(blobs);
}
public static async Task<List<string>> CreateBlobsAsync(CloudBlobContainer container, int count, BlobType type)
{
string name;
List<string> blobs = new List<string>();
for (int i = 0; i < count; i++)
{
switch (type)
{
case BlobType.BlockBlob:
name = "bb" + Guid.NewGuid().ToString();
CloudBlockBlob blockBlob = container.GetBlockBlobReference(name);
await blockBlob.PutBlockListAsync(new string[] { });
blobs.Add(name);
break;
case BlobType.PageBlob:
name = "pb" + Guid.NewGuid().ToString();
CloudPageBlob pageBlob = container.GetPageBlobReference(name);
await pageBlob.CreateAsync(0);
blobs.Add(name);
break;
case BlobType.AppendBlob:
name = "ab" + Guid.NewGuid().ToString();
CloudAppendBlob appendBlob = container.GetAppendBlobReference(name);
await appendBlob.CreateOrReplaceAsync();
blobs.Add(name);
break;
}
}
return blobs;
}
public async Task AppendBlobWriteStreamFlushTestAsync()
{
byte[] buffer = GetRandomBuffer(512 * 1024);
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudAppendBlob blob = container.GetAppendBlobReference("blob1");
blob.StreamWriteSizeInBytes = 1 * 1024 * 1024;
using (MemoryStream wholeBlob = new MemoryStream())
{
OperationContext opContext = new OperationContext();
using (CloudBlobStream blobStream = await blob.OpenWriteAsync(true, null, null, opContext))
{
for (int i = 0; i < 3; i++)
{
await blobStream.WriteAsync(buffer, 0, buffer.Length);
await wholeBlob.WriteAsync(buffer, 0, buffer.Length);
}
Assert.AreEqual(2, opContext.RequestResults.Count);
await blobStream.FlushAsync();
Assert.AreEqual(3, opContext.RequestResults.Count);
await blobStream.FlushAsync();
Assert.AreEqual(3, opContext.RequestResults.Count);
await blobStream.WriteAsync(buffer, 0, buffer.Length);
await wholeBlob.WriteAsync(buffer, 0, buffer.Length);
Assert.AreEqual(3, opContext.RequestResults.Count);
await Task.Factory.FromAsync(blobStream.BeginCommit, blobStream.EndCommit, null);
Assert.AreEqual(4, opContext.RequestResults.Count);
}
Assert.AreEqual(4, opContext.RequestResults.Count);
using (MemoryStream downloadedBlob = new MemoryStream())
{
await blob.DownloadToStreamAsync(downloadedBlob);
TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob);
}
}
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
public void CloudBlobClientObjects()
{
CloudBlobClient blobClient = GenerateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference("container");
Assert.AreEqual(blobClient, container.ServiceClient);
CloudBlockBlob blockBlob = container.GetBlockBlobReference("blockblob");
Assert.AreEqual(blobClient, blockBlob.ServiceClient);
CloudPageBlob pageBlob = container.GetPageBlobReference("pageblob");
Assert.AreEqual(blobClient, pageBlob.ServiceClient);
CloudAppendBlob appendBlob = container.GetAppendBlobReference("appendblob");
Assert.AreEqual(blobClient, appendBlob.ServiceClient);
CloudBlobContainer container2 = GetRandomContainerReference();
Assert.AreNotEqual(blobClient, container2.ServiceClient);
CloudBlockBlob blockBlob2 = container2.GetBlockBlobReference("blockblob");
Assert.AreEqual(container2.ServiceClient, blockBlob2.ServiceClient);
CloudPageBlob pageBlob2 = container2.GetPageBlobReference("pageblob");
Assert.AreEqual(container2.ServiceClient, pageBlob2.ServiceClient);
CloudAppendBlob appendBlob2 = container2.GetAppendBlobReference("appendblob");
Assert.AreEqual(container2.ServiceClient, appendBlob2.ServiceClient);
}
public async Task AppendBlobReadStreamSeekTestAsync()
{
byte[] buffer = GetRandomBuffer(3 * 1024 * 1024);
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudAppendBlob blob = container.GetAppendBlobReference("blob1");
await blob.CreateOrReplaceAsync();
blob.StreamMinimumReadSizeInBytes = 2 * 1024 * 1024;
using (MemoryStream wholeBlob = new MemoryStream(buffer))
{
await blob.AppendBlockAsync(wholeBlob);
}
OperationContext opContext = new OperationContext();
using (var blobStream = await blob.OpenReadAsync(null, null, opContext))
{
#if WINDOWS_RT
int attempts = await BlobReadStreamSeekTestAsync(blobStream.AsRandomAccessStream(), blob.StreamMinimumReadSizeInBytes, buffer);
#else
int attempts = await BlobReadStreamSeekTestAsync(blobStream, blob.StreamMinimumReadSizeInBytes, buffer);
#endif
TestHelper.AssertNAttempts(opContext, attempts);
}
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
public void CloudBlobSnapshotMetadataAPM()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
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
// None of the original metadata should be present
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("Ma", snapshot.Metadata["Yoyo"]);
Assert.IsFalse(snapshot.Metadata.ContainsKey("Marco"));
}
}
finally
{
container.DeleteIfExists();
}
}
public async Task AppendBlobWriteStreamBasicTestAsync()
{
byte[] buffer = GetRandomBuffer(3 * 1024 * 1024);
CloudBlobClient blobClient = GenerateCloudBlobClient();
string name = GetRandomContainerName();
CloudBlobContainer container = blobClient.GetContainerReference(name);
try
{
await container.CreateAsync();
CloudAppendBlob blob = container.GetAppendBlobReference("blob1");
using (MemoryStream wholeBlob = new MemoryStream())
{
using (Stream writeStream = await blob.OpenWriteAsync(true))
{
Stream blobStream = writeStream;
for (int i = 0; i < 3; i++)
{
await blobStream.WriteAsync(buffer, 0, buffer.Length);
await wholeBlob.WriteAsync(buffer, 0, buffer.Length);
Assert.AreEqual(wholeBlob.Position, blobStream.Position);
}
await blobStream.FlushAsync();
}
using (MemoryStream downloadedBlob = new MemoryStream())
{
await blob.DownloadToStreamAsync(downloadedBlob);
TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob);
}
}
}
finally
{
container.DeleteAsync().Wait();
}
}
public void CloudBlobContainerReference()
{
CloudBlobClient client = GenerateCloudBlobClient();
CloudBlobContainer container = client.GetContainerReference("container");
CloudBlockBlob blockBlob = container.GetBlockBlobReference("directory1/blob1");
CloudPageBlob pageBlob = container.GetPageBlobReference("directory2/blob2");
CloudAppendBlob appendBlob = container.GetAppendBlobReference("directory3/blob3");
CloudBlobDirectory directory = container.GetDirectoryReference("directory4");
CloudBlobDirectory directory2 = directory.GetDirectoryReference("directory5");
Assert.AreEqual(container, blockBlob.Container);
Assert.AreEqual(container, pageBlob.Container);
Assert.AreEqual(container, appendBlob.Container);
Assert.AreEqual(container, directory.Container);
Assert.AreEqual(container, directory2.Container);
Assert.AreEqual(container, directory2.Parent.Container);
Assert.AreEqual(container, blockBlob.Parent.Container);
Assert.AreEqual(container, blockBlob.Parent.Container);
}
public async Task CloudBlobSnapshotMetadataAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudAppendBlob appendBlob = container.GetAppendBlobReference(BlobName);
await appendBlob.CreateOrReplaceAsync();
CloudBlob blob = container.GetBlobReference(BlobName);
blob.Metadata["Hello"] = "World";
blob.Metadata["Marco"] = "Polo";
await blob.SetMetadataAsync();
IDictionary <string, string> snapshotMetadata = new Dictionary <string, string>();
snapshotMetadata["Hello"] = "Dolly";
snapshotMetadata["Yoyo"] = "Ma";
CloudBlob snapshot = await blob.SnapshotAsync(snapshotMetadata, null, null, null);
// Test the client view against the expected metadata
// None of the original metadata should be present
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
await snapshot.FetchAttributesAsync();
Assert.AreEqual("Dolly", snapshot.Metadata["Hello"]);
Assert.AreEqual("Ma", snapshot.Metadata["Yoyo"]);
Assert.IsFalse(snapshot.Metadata.ContainsKey("Marco"));
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
public async Task AppendBlobWriteStreamSeekTestAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudAppendBlob blob = container.GetAppendBlobReference("blob1");
using (Stream writeStream = await blob.OpenWriteAsync(true))
{
Stream blobStream = writeStream;
TestHelper.ExpectedException <NotSupportedException>(
() => blobStream.Seek(1, SeekOrigin.Begin),
"Append blob write stream should not be seekable");
}
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
public static async Task <List <string> > CreateBlobs(CloudBlobContainer container, int count, BlobType type)
{
string name;
List <string> blobs = new List <string>();
List <Task> tasks = new List <Task>();
for (int i = 0; i < count; i++)
{
switch (type)
{
case BlobType.BlockBlob:
name = "bb" + Guid.NewGuid().ToString();
CloudBlockBlob blockBlob = container.GetBlockBlobReference(name);
tasks.Add(Task.Run(() => blockBlob.PutBlockList(new string[] { })));
blobs.Add(name);
break;
case BlobType.PageBlob:
name = "pb" + Guid.NewGuid().ToString();
CloudPageBlob pageBlob = container.GetPageBlobReference(name);
tasks.Add(Task.Run(() => pageBlob.Create(0)));
blobs.Add(name);
break;
case BlobType.AppendBlob:
name = "ab" + Guid.NewGuid().ToString();
CloudAppendBlob appendBlob = container.GetAppendBlobReference(name);
tasks.Add(Task.Run(() => appendBlob.CreateOrReplace()));
blobs.Add(name);
break;
}
}
await Task.WhenAll(tasks);
return(blobs);
}
private static void TestAccess(string sasToken, SharedAccessBlobPermissions permissions, SharedAccessBlobHeaders headers, CloudBlobContainer container, CloudBlob blob)
{
StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ?
new StorageCredentials() :
new StorageCredentials(sasToken);
if (container != null)
{
container = new CloudBlobContainer(credentials.TransformUri(container.Uri));
if (blob.BlobType == BlobType.BlockBlob)
{
blob = container.GetBlockBlobReference(blob.Name);
}
else if (blob.BlobType == BlobType.PageBlob)
{
blob = container.GetPageBlobReference(blob.Name);
}
else
{
blob = container.GetAppendBlobReference(blob.Name);
}
}
else
{
if (blob.BlobType == BlobType.BlockBlob)
{
blob = new CloudBlockBlob(credentials.TransformUri(blob.Uri));
}
else if (blob.BlobType == BlobType.PageBlob)
{
blob = new CloudPageBlob(credentials.TransformUri(blob.Uri));
}
else
{
blob = new CloudAppendBlob(credentials.TransformUri(blob.Uri));
}
}
if (container != null)
{
if ((permissions & SharedAccessBlobPermissions.List) == SharedAccessBlobPermissions.List)
{
container.ListBlobs().ToArray();
}
else
{
TestHelper.ExpectedException(
() => container.ListBlobs().ToArray(),
"List blobs while SAS does not allow for listing",
HttpStatusCode.NotFound);
}
}
if ((permissions & SharedAccessBlobPermissions.Read) == SharedAccessBlobPermissions.Read)
{
blob.FetchAttributes();
// Test headers
if (headers != null)
{
if (headers.CacheControl != null)
{
Assert.AreEqual(headers.CacheControl, blob.Properties.CacheControl);
}
if (headers.ContentDisposition != null)
{
Assert.AreEqual(headers.ContentDisposition, blob.Properties.ContentDisposition);
}
if (headers.ContentEncoding != null)
{
Assert.AreEqual(headers.ContentEncoding, blob.Properties.ContentEncoding);
}
if (headers.ContentLanguage != null)
{
Assert.AreEqual(headers.ContentLanguage, blob.Properties.ContentLanguage);
}
if (headers.ContentType != null)
{
Assert.AreEqual(headers.ContentType, blob.Properties.ContentType);
}
}
}
else
{
TestHelper.ExpectedException(
() => blob.FetchAttributes(),
"Fetch blob attributes while SAS does not allow for reading",
HttpStatusCode.NotFound);
}
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
blob.SetMetadata();
}
else
{
TestHelper.ExpectedException(
() => blob.SetMetadata(),
"Set blob metadata while SAS does not allow for writing",
HttpStatusCode.NotFound);
}
if ((permissions & SharedAccessBlobPermissions.Delete) == SharedAccessBlobPermissions.Delete)
{
blob.Delete();
}
else
{
TestHelper.ExpectedException(
() => blob.Delete(),
"Delete blob while SAS does not allow for deleting",
HttpStatusCode.NotFound);
}
}
public static CloudBlob GetBlobReference(CloudBlobContainer container, string blobName, BlobType blobType)
{
switch(blobType)
{
case BlobType.BlockBlob:
return container.GetBlockBlobReference(blobName);
case BlobType.PageBlob:
return container.GetPageBlobReference(blobName);
case BlobType.AppendBlob:
return container.GetAppendBlobReference(blobName);
default:
throw new ArgumentException(String.Format(
CultureInfo.CurrentCulture,
Resources.InvalidBlobType,
blobType,
blobName));
}
}
public void CloudBlobSnapshot()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
// Upload some data to the blob.
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);
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);
}
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(snapshot1, (CloudBlob)blobs[0]);
AssertAreEqual(snapshot2, (CloudBlob)blobs[1]);
AssertAreEqual(blob, (CloudBlob)blobs[2]);
AssertAreEqual(snapshotCopy, (CloudBlob)blobs[3]);
}
finally
{
container.DeleteIfExists();
}
}
private void CloudAppendBlock(CloudBlobContainer container, int size, AccessCondition accessCondition, int startOffset, bool isAsync)
{
byte[] buffer = GetRandomBuffer(size);
CloudAppendBlob blob = container.GetAppendBlobReference("blob1");
blob.CreateOrReplace();
using (MemoryStream originalBlob = new MemoryStream())
{
originalBlob.Write(buffer, startOffset, buffer.Length - startOffset);
using (MemoryStream sourceStream = new MemoryStream(buffer))
{
sourceStream.Seek(startOffset, SeekOrigin.Begin);
BlobRequestOptions options = new BlobRequestOptions()
{
UseTransactionalMD5 = true,
};
if (isAsync)
{
using (ManualResetEvent waitHandle = new ManualResetEvent(false))
{
ICancellableAsyncResult result = blob.BeginAppendBlock(
sourceStream, null, accessCondition, options, null, ar => waitHandle.Set(), null);
waitHandle.WaitOne();
blob.EndAppendBlock(result);
}
}
else
{
blob.AppendBlock(sourceStream, null, accessCondition, options);
}
}
blob.FetchAttributes();
using (MemoryStream downloadedBlob = new MemoryStream())
{
if (isAsync)
{
using (ManualResetEvent waitHandle = new ManualResetEvent(false))
{
ICancellableAsyncResult result = blob.BeginDownloadToStream(downloadedBlob,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
blob.EndDownloadToStream(result);
}
}
else
{
blob.DownloadToStream(downloadedBlob);
}
TestHelper.AssertStreamsAreEqualAtIndex(
originalBlob,
downloadedBlob,
0,
0,
(int)originalBlob.Length);
}
}
}
private static void TestAccess(string sasToken, SharedAccessBlobPermissions permissions, SharedAccessBlobHeaders headers, CloudBlobContainer container, CloudBlob blob)
{
StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ?
new StorageCredentials() :
new StorageCredentials(sasToken);
if (container != null)
{
container = new CloudBlobContainer(credentials.TransformUri(container.Uri));
if (blob.BlobType == BlobType.BlockBlob)
{
blob = container.GetBlockBlobReference(blob.Name);
}
else if (blob.BlobType == BlobType.PageBlob)
{
blob = container.GetPageBlobReference(blob.Name);
}
else
{
blob = container.GetAppendBlobReference(blob.Name);
}
}
else
{
if (blob.BlobType == BlobType.BlockBlob)
{
blob = new CloudBlockBlob(credentials.TransformUri(blob.Uri));
}
else if (blob.BlobType == BlobType.PageBlob)
{
blob = new CloudPageBlob(credentials.TransformUri(blob.Uri));
}
else
{
blob = new CloudAppendBlob(credentials.TransformUri(blob.Uri));
}
}
if (container != null)
{
if ((permissions & SharedAccessBlobPermissions.List) == SharedAccessBlobPermissions.List)
{
container.ListBlobs().ToArray();
}
else
{
TestHelper.ExpectedException(
() => container.ListBlobs().ToArray(),
"List blobs while SAS does not allow for listing",
HttpStatusCode.NotFound);
}
}
if ((permissions & SharedAccessBlobPermissions.Read) == SharedAccessBlobPermissions.Read)
{
blob.FetchAttributes();
// Test headers
if (headers != null)
{
if (headers.CacheControl != null)
{
Assert.AreEqual(headers.CacheControl, blob.Properties.CacheControl);
}
if (headers.ContentDisposition != null)
{
Assert.AreEqual(headers.ContentDisposition, blob.Properties.ContentDisposition);
}
if (headers.ContentEncoding != null)
{
Assert.AreEqual(headers.ContentEncoding, blob.Properties.ContentEncoding);
}
if (headers.ContentLanguage != null)
{
Assert.AreEqual(headers.ContentLanguage, blob.Properties.ContentLanguage);
}
if (headers.ContentType != null)
{
Assert.AreEqual(headers.ContentType, blob.Properties.ContentType);
}
}
}
else
{
TestHelper.ExpectedException(
() => blob.FetchAttributes(),
"Fetch blob attributes while SAS does not allow for reading",
HttpStatusCode.NotFound);
}
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
blob.SetMetadata();
}
else
{
TestHelper.ExpectedException(
() => blob.SetMetadata(),
"Set blob metadata while SAS does not allow for writing",
HttpStatusCode.NotFound);
}
if ((permissions & SharedAccessBlobPermissions.Delete) == SharedAccessBlobPermissions.Delete)
{
blob.Delete();
}
else
{
TestHelper.ExpectedException(
() => blob.Delete(),
"Delete blob while SAS does not allow for deleting",
HttpStatusCode.NotFound);
}
}
private static void TestAccess(string sasToken, SharedAccessBlobPermissions permissions, SharedAccessBlobHeaders headers, CloudBlobContainer container, CloudBlob blob)
{
CloudBlob SASblob;
StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ?
new StorageCredentials() :
new StorageCredentials(sasToken);
if (container != null)
{
container = new CloudBlobContainer(credentials.TransformUri(container.Uri));
if (blob.BlobType == BlobType.BlockBlob)
{
SASblob = container.GetBlockBlobReference(blob.Name);
}
else if (blob.BlobType == BlobType.PageBlob)
{
SASblob = container.GetPageBlobReference(blob.Name);
}
else
{
SASblob = container.GetAppendBlobReference(blob.Name);
}
}
else
{
if (blob.BlobType == BlobType.BlockBlob)
{
SASblob = new CloudBlockBlob(credentials.TransformUri(blob.Uri));
}
else if (blob.BlobType == BlobType.PageBlob)
{
SASblob = new CloudPageBlob(credentials.TransformUri(blob.Uri));
}
else
{
SASblob = new CloudAppendBlob(credentials.TransformUri(blob.Uri));
}
}
HttpStatusCode failureCode = sasToken == null ? HttpStatusCode.NotFound : HttpStatusCode.Forbidden;
// We want to ensure that 'create', 'add', and 'write' permissions all allow for correct writing of blobs, as is reasonable.
if (((permissions & SharedAccessBlobPermissions.Create) == SharedAccessBlobPermissions.Create) || ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write))
{
if (blob.BlobType == BlobType.PageBlob)
{
CloudPageBlob SASpageBlob = (CloudPageBlob)SASblob;
SASpageBlob.Create(512);
CloudPageBlob pageBlob = (CloudPageBlob)blob;
byte[] buffer = new byte[512];
buffer[0] = 2; // random data
if (((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write))
{
SASpageBlob.UploadFromByteArray(buffer, 0, 512);
}
else
{
TestHelper.ExpectedException(
() => SASpageBlob.UploadFromByteArray(buffer, 0, 512),
"pageBlob SAS token without Write perms should not allow for writing/adding",
failureCode);
pageBlob.UploadFromByteArray(buffer, 0, 512);
}
}
else if (blob.BlobType == BlobType.BlockBlob)
{
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
UploadText(SASblob, "blob", Encoding.UTF8);
}
else
{
TestHelper.ExpectedException(
() => UploadText(SASblob, "blob", Encoding.UTF8),
"Block blob SAS token without Write or perms should not allow for writing",
failureCode);
UploadText(blob, "blob", Encoding.UTF8);
}
}
else // append blob
{
// If the sas token contains Feb 2012, append won't be accepted
if (sasToken.Contains(Constants.VersionConstants.February2012))
{
UploadText(blob, "blob", Encoding.UTF8);
}
else
{
CloudAppendBlob SASAppendBlob = SASblob as CloudAppendBlob;
SASAppendBlob.CreateOrReplace();
byte[] textAsBytes = Encoding.UTF8.GetBytes("blob");
using (MemoryStream stream = new MemoryStream())
{
stream.Write(textAsBytes, 0, textAsBytes.Length);
stream.Seek(0, SeekOrigin.Begin);
if (((permissions & SharedAccessBlobPermissions.Add) == SharedAccessBlobPermissions.Add) || ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write))
{
SASAppendBlob.AppendBlock(stream, null);
}
else
{
TestHelper.ExpectedException(
() => SASAppendBlob.AppendBlock(stream, null),
"Append blob SAS token without Write or Add perms should not allow for writing/adding",
failureCode);
stream.Seek(0, SeekOrigin.Begin);
((CloudAppendBlob)blob).AppendBlock(stream, null);
}
}
}
}
}
else
{
TestHelper.ExpectedException(
() => UploadText(SASblob, "blob", Encoding.UTF8),
"UploadText SAS does not allow for writing/adding",
((blob.BlobType == BlobType.AppendBlob) && (sasToken != null) && (sasToken.Contains(Constants.VersionConstants.February2012))) ? HttpStatusCode.BadRequest : failureCode);
UploadText(blob, "blob", Encoding.UTF8);
}
if (container != null)
{
if ((permissions & SharedAccessBlobPermissions.List) == SharedAccessBlobPermissions.List)
{
container.ListBlobs().ToArray();
}
else
{
TestHelper.ExpectedException(
() => container.ListBlobs().ToArray(),
"List blobs while SAS does not allow for listing",
failureCode);
}
}
// need to have written to the blob to read from it.
if (((permissions & SharedAccessBlobPermissions.Read) == SharedAccessBlobPermissions.Read))
{
SASblob.FetchAttributes();
// Test headers
if (headers != null)
{
if (headers.CacheControl != null)
{
Assert.AreEqual(headers.CacheControl, SASblob.Properties.CacheControl);
}
if (headers.ContentDisposition != null)
{
Assert.AreEqual(headers.ContentDisposition, SASblob.Properties.ContentDisposition);
}
if (headers.ContentEncoding != null)
{
Assert.AreEqual(headers.ContentEncoding, SASblob.Properties.ContentEncoding);
}
if (headers.ContentLanguage != null)
{
Assert.AreEqual(headers.ContentLanguage, SASblob.Properties.ContentLanguage);
}
if (headers.ContentType != null)
{
Assert.AreEqual(headers.ContentType, SASblob.Properties.ContentType);
}
}
}
else
{
TestHelper.ExpectedException(
() => SASblob.FetchAttributes(),
"Fetch blob attributes while SAS does not allow for reading",
failureCode);
}
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
SASblob.SetMetadata();
}
else
{
TestHelper.ExpectedException(
() => SASblob.SetMetadata(),
"Set blob metadata while SAS does not allow for writing",
failureCode);
}
if ((permissions & SharedAccessBlobPermissions.Delete) == SharedAccessBlobPermissions.Delete)
{
SASblob.Delete();
}
else
{
TestHelper.ExpectedException(
() => SASblob.Delete(),
"Delete blob while SAS does not allow for deleting",
failureCode);
}
}
public 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.Create();
// Upload some data to the blob.
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;
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.Delete(DeleteSnapshotsOption.IncludeSnapshots);
Assert.IsFalse(blob.Exists());
Assert.IsFalse(snapshot.Exists());
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.Undelete();
blob.FetchAttributes();
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.DeleteIfExists();
}
}
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.FetchAttributes();
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.DeleteIfExists();
}
}
private void CloudAppendBlobUploadFromStream(CloudBlobContainer container, int size, long? copyLength, AccessCondition accessCondition, bool seekableSourceStream, bool allowSinglePut, int startOffset, bool isAsync, bool testMd5)
{
byte[] buffer = GetRandomBuffer(size);
MD5 hasher = MD5.Create();
string md5 = string.Empty;
if (testMd5)
{
md5 = Convert.ToBase64String(hasher.ComputeHash(buffer, startOffset, copyLength.HasValue ? (int)copyLength : buffer.Length - startOffset));
}
CloudAppendBlob blob = container.GetAppendBlobReference("blob1");
blob.StreamWriteSizeInBytes = 1 * 1024 * 1024;
using (MemoryStream originalBlobStream = new MemoryStream())
{
originalBlobStream.Write(buffer, startOffset, buffer.Length - startOffset);
Stream sourceStream;
if (seekableSourceStream)
{
MemoryStream stream = new MemoryStream(buffer);
stream.Seek(startOffset, SeekOrigin.Begin);
sourceStream = stream;
}
else
{
NonSeekableMemoryStream stream = new NonSeekableMemoryStream(buffer);
stream.ForceSeek(startOffset, SeekOrigin.Begin);
sourceStream = stream;
}
using (sourceStream)
{
BlobRequestOptions options = new BlobRequestOptions()
{
StoreBlobContentMD5 = true,
};
if (isAsync)
{
using (ManualResetEvent waitHandle = new ManualResetEvent(false))
{
if (copyLength.HasValue)
{
ICancellableAsyncResult result = blob.BeginUploadFromStream(
sourceStream, copyLength.Value, accessCondition, options, null, ar => waitHandle.Set(), null);
waitHandle.WaitOne();
blob.EndUploadFromStream(result);
}
else
{
ICancellableAsyncResult result = blob.BeginUploadFromStream(
sourceStream, accessCondition, options, null, ar => waitHandle.Set(), null);
waitHandle.WaitOne();
blob.EndUploadFromStream(result);
}
}
}
else
{
if (copyLength.HasValue)
{
blob.UploadFromStream(sourceStream, copyLength.Value, accessCondition, options);
}
else
{
blob.UploadFromStream(sourceStream, accessCondition, options);
}
}
}
blob.FetchAttributes();
if (testMd5)
{
Assert.AreEqual(md5, blob.Properties.ContentMD5);
}
using (MemoryStream downloadedBlobStream = new MemoryStream())
{
if (isAsync)
{
using (ManualResetEvent waitHandle = new ManualResetEvent(false))
{
ICancellableAsyncResult result = blob.BeginDownloadToStream(
downloadedBlobStream, ar => waitHandle.Set(), null);
waitHandle.WaitOne();
blob.EndDownloadToStream(result);
}
}
else
{
blob.DownloadToStream(downloadedBlobStream);
}
Assert.AreEqual(copyLength ?? originalBlobStream.Length, downloadedBlobStream.Length);
TestHelper.AssertStreamsAreEqualAtIndex(
originalBlobStream,
downloadedBlobStream,
0,
0,
copyLength.HasValue ? (int)copyLength : (int)originalBlobStream.Length);
}
}
blob.Delete();
}
public async Task CloudBlobContainerGetBlobReferenceFromServerAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy()
{
Permissions = SharedAccessBlobPermissions.Read,
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
};
CloudBlockBlob blockBlob = container.GetBlockBlobReference("bb");
await blockBlob.PutBlockListAsync(new List <string>());
CloudPageBlob pageBlob = container.GetPageBlobReference("pb");
await pageBlob.CreateAsync(0);
CloudAppendBlob appendBlob = container.GetAppendBlobReference("ab");
await appendBlob.CreateOrReplaceAsync();
CloudBlobClient client;
ICloudBlob blob;
blob = await container.GetBlobReferenceFromServerAsync("bb");
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.Equals(blockBlob.StorageUri));
CloudBlockBlob blockBlobSnapshot = await((CloudBlockBlob)blob).CreateSnapshotAsync();
await blob.SetPropertiesAsync();
Uri blockBlobSnapshotUri = new Uri(blockBlobSnapshot.Uri.AbsoluteUri + "?snapshot=" + blockBlobSnapshot.SnapshotTime.Value.UtcDateTime.ToString("o"));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(blockBlobSnapshotUri);
AssertAreEqual(blockBlobSnapshot.Properties, blob.Properties);
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(blockBlobSnapshot.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.GetBlobReferenceFromServerAsync("pb");
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.Equals(pageBlob.StorageUri));
CloudPageBlob pageBlobSnapshot = await((CloudPageBlob)blob).CreateSnapshotAsync();
await blob.SetPropertiesAsync();
Uri pageBlobSnapshotUri = new Uri(pageBlobSnapshot.Uri.AbsoluteUri + "?snapshot=" + pageBlobSnapshot.SnapshotTime.Value.UtcDateTime.ToString("o"));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(pageBlobSnapshotUri);
AssertAreEqual(pageBlobSnapshot.Properties, blob.Properties);
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(pageBlobSnapshot.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.GetBlobReferenceFromServerAsync("ab");
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.Equals(appendBlob.StorageUri));
CloudAppendBlob appendBlobSnapshot = await((CloudAppendBlob)blob).CreateSnapshotAsync();
await blob.SetPropertiesAsync();
Uri appendBlobSnapshotUri = new Uri(appendBlobSnapshot.Uri.AbsoluteUri + "?snapshot=" + appendBlobSnapshot.SnapshotTime.Value.UtcDateTime.ToString("o"));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(appendBlobSnapshotUri);
AssertAreEqual(appendBlobSnapshot.Properties, blob.Properties);
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(appendBlobSnapshot.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(blockBlob.Uri);
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(blockBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(pageBlob.Uri);
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(pageBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(appendBlob.Uri);
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(appendBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(blockBlob.StorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.Equals(blockBlob.StorageUri));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(pageBlob.StorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.Equals(pageBlob.StorageUri));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(appendBlob.StorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.Equals(appendBlob.StorageUri));
string blockBlobToken = blockBlob.GetSharedAccessSignature(policy);
StorageCredentials blockBlobSAS = new StorageCredentials(blockBlobToken);
Uri blockBlobSASUri = blockBlobSAS.TransformUri(blockBlob.Uri);
StorageUri blockBlobSASStorageUri = blockBlobSAS.TransformUri(blockBlob.StorageUri);
string appendBlobToken = appendBlob.GetSharedAccessSignature(policy);
StorageCredentials appendBlobSAS = new StorageCredentials(appendBlobToken);
Uri appendBlobSASUri = appendBlobSAS.TransformUri(appendBlob.Uri);
StorageUri appendBlobSASStorageUri = appendBlobSAS.TransformUri(appendBlob.StorageUri);
string pageBlobToken = pageBlob.GetSharedAccessSignature(policy);
StorageCredentials pageBlobSAS = new StorageCredentials(pageBlobToken);
Uri pageBlobSASUri = pageBlobSAS.TransformUri(pageBlob.Uri);
StorageUri pageBlobSASStorageUri = pageBlobSAS.TransformUri(pageBlob.StorageUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(blockBlobSASUri);
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(blockBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(pageBlobSASUri);
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(pageBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(appendBlobSASUri);
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(appendBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(blockBlobSASStorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.Equals(blockBlob.StorageUri));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(pageBlobSASStorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.Equals(pageBlob.StorageUri));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(appendBlobSASStorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.Equals(appendBlob.StorageUri));
client = new CloudBlobClient(container.ServiceClient.BaseUri, blockBlobSAS);
blob = await client.GetBlobReferenceFromServerAsync(blockBlobSASUri);
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(blockBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
client = new CloudBlobClient(container.ServiceClient.BaseUri, pageBlobSAS);
blob = await client.GetBlobReferenceFromServerAsync(pageBlobSASUri);
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(pageBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
client = new CloudBlobClient(container.ServiceClient.BaseUri, appendBlobSAS);
blob = await client.GetBlobReferenceFromServerAsync(appendBlobSASUri);
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(appendBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
client = new CloudBlobClient(container.ServiceClient.StorageUri, blockBlobSAS);
blob = await client.GetBlobReferenceFromServerAsync(blockBlobSASStorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.Equals(blockBlob.StorageUri));
client = new CloudBlobClient(container.ServiceClient.StorageUri, pageBlobSAS);
blob = await client.GetBlobReferenceFromServerAsync(pageBlobSASStorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.Equals(pageBlob.StorageUri));
client = new CloudBlobClient(container.ServiceClient.StorageUri, appendBlobSAS);
blob = await client.GetBlobReferenceFromServerAsync(appendBlobSASStorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.Equals(appendBlob.StorageUri));
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
private async Task CloudAppendBlobUploadFromStreamAsync(CloudBlobContainer container, int size, long? copyLength, AccessCondition accessCondition, bool seekableSourceStream, int startOffset)
{
byte[] buffer = GetRandomBuffer(size);
CloudAppendBlob blob = container.GetAppendBlobReference("blob1");
blob.StreamWriteSizeInBytes = 1 * 1024 * 1024;
using (MemoryStream originalBlobStream = new MemoryStream())
{
originalBlobStream.Write(buffer, startOffset, buffer.Length - startOffset);
Stream sourceStream;
if (seekableSourceStream)
{
MemoryStream stream = new MemoryStream(buffer);
stream.Seek(startOffset, SeekOrigin.Begin);
sourceStream = stream;
}
else
{
NonSeekableMemoryStream stream = new NonSeekableMemoryStream(buffer);
stream.ForceSeek(startOffset, SeekOrigin.Begin);
sourceStream = stream;
}
using (sourceStream)
{
if (copyLength.HasValue)
{
await blob.UploadFromStreamAsync(sourceStream, copyLength.Value, accessCondition, null, null);
}
else
{
await blob.UploadFromStreamAsync(sourceStream, accessCondition, null, null);
}
}
using (MemoryStream downloadedBlobStream = new MemoryStream())
{
await blob.DownloadToStreamAsync(downloadedBlobStream);
Assert.AreEqual(copyLength ?? originalBlobStream.Length, downloadedBlobStream.Length);
TestHelper.AssertStreamsAreEqualAtIndex(
originalBlobStream,
downloadedBlobStream,
0,
0,
copyLength.HasValue ? (int)copyLength : (int)originalBlobStream.Length);
}
}
}
public async Task CloudBlobSnapshotAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
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();
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, false);
CloudAppendBlob snapshotCopy = container.GetAppendBlobReference("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 appendBlob.CreateOrReplaceAsync();
await appendBlob.FetchAttributesAsync(); // This is needed as cache settings are not updated with create call above.
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(appendBlob, (CloudBlob)blobs[2]);
AssertAreEqual(snapshotCopy, (CloudBlob)blobs[3]);
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
private static ICloudBlob GetCloudBlobReference(BlobType type, CloudBlobContainer container)
{
ICloudBlob blob;
if (type == BlobType.BlockBlob)
{
blob = container.GetBlockBlobReference("blockblob");
}
else if (type == BlobType.PageBlob)
{
blob = container.GetPageBlobReference("pageblob");
}
else
{
blob = container.GetAppendBlobReference("appendblob");
}
return blob;
}
public void CloudBlobSASApiVersionQueryParam()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudBlob blob;
SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy()
{
Permissions = SharedAccessBlobPermissions.Read,
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
};
CloudBlockBlob blockBlob = container.GetBlockBlobReference("bb");
blockBlob.PutBlockList(new string[] { });
CloudPageBlob pageBlob = container.GetPageBlobReference("pb");
pageBlob.Create(0);
CloudAppendBlob appendBlob = container.GetAppendBlobReference("ab");
appendBlob.CreateOrReplace();
string blockBlobToken = blockBlob.GetSharedAccessSignature(policy);
StorageCredentials blockBlobSAS = new StorageCredentials(blockBlobToken);
Uri blockBlobSASUri = blockBlobSAS.TransformUri(blockBlob.Uri);
StorageUri blockBlobSASStorageUri = blockBlobSAS.TransformUri(blockBlob.StorageUri);
string pageBlobToken = pageBlob.GetSharedAccessSignature(policy);
StorageCredentials pageBlobSAS = new StorageCredentials(pageBlobToken);
Uri pageBlobSASUri = pageBlobSAS.TransformUri(pageBlob.Uri);
StorageUri pageBlobSASStorageUri = pageBlobSAS.TransformUri(pageBlob.StorageUri);
string appendBlobToken = appendBlob.GetSharedAccessSignature(policy);
StorageCredentials appendBlobSAS = new StorageCredentials(appendBlobToken);
Uri appendBlobSASUri = appendBlobSAS.TransformUri(appendBlob.Uri);
StorageUri appendBlobSASStorageUri = appendBlobSAS.TransformUri(appendBlob.StorageUri);
OperationContext apiVersionCheckContext = new OperationContext();
apiVersionCheckContext.SendingRequest += (sender, e) =>
{
Assert.IsTrue(e.Request.RequestUri.Query.Contains("api-version"));
};
blob = new CloudBlob(blockBlobSASUri);
blob.FetchAttributes(operationContext: apiVersionCheckContext);
Assert.AreEqual(blob.BlobType, BlobType.BlockBlob);
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(blockBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = new CloudBlob(pageBlobSASUri);
blob.FetchAttributes(operationContext: apiVersionCheckContext);
Assert.AreEqual(blob.BlobType, BlobType.PageBlob);
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(pageBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = new CloudBlob(blockBlobSASStorageUri, null, null);
blob.FetchAttributes(operationContext: apiVersionCheckContext);
Assert.AreEqual(blob.BlobType, BlobType.BlockBlob);
Assert.IsTrue(blob.StorageUri.Equals(blockBlob.StorageUri));
blob = new CloudBlob(pageBlobSASStorageUri, null, null);
blob.FetchAttributes(operationContext: apiVersionCheckContext);
Assert.AreEqual(blob.BlobType, BlobType.PageBlob);
Assert.IsTrue(blob.StorageUri.Equals(pageBlob.StorageUri));
}
finally
{
container.DeleteIfExists();
}
}
private void CloudAppendBlockTask(CloudBlobContainer container, int size, AccessCondition accessCondition, int startOffset)
{
try
{
byte[] buffer = GetRandomBuffer(size);
CloudAppendBlob blob = container.GetAppendBlobReference("blob1");
blob.CreateOrReplaceAsync().Wait();
using (MemoryStream originalBlob = new MemoryStream())
{
originalBlob.Write(buffer, startOffset, buffer.Length - startOffset);
using (MemoryStream sourceStream = new MemoryStream(buffer))
{
sourceStream.Seek(startOffset, SeekOrigin.Begin);
BlobRequestOptions options = new BlobRequestOptions()
{
UseTransactionalMD5 = true,
};
blob.AppendBlockAsync(sourceStream, null, accessCondition, options, null).Wait();
}
blob.FetchAttributesAsync().Wait();
using (MemoryStream downloadedBlob = new MemoryStream())
{
blob.DownloadToStreamAsync(downloadedBlob).Wait();
TestHelper.AssertStreamsAreEqualAtIndex(
originalBlob,
downloadedBlob,
0,
0,
(int)originalBlob.Length);
}
}
}
catch (AggregateException ex)
{
throw ex.InnerException;
}
}
private static CloudAppendBlob GetAppendBlob(CloudBlobContainer container, string extension, string partitionId)
{
var now = DateTime.UtcNow;
var blobPath = string.Format("{0:0000}/{1:00}/{2:00}/{3}p{4}.{5}", now.Year, now.Month, now.Day, now.ToString("yyyyMMddHH"), partitionId, extension);
var blob = container.GetAppendBlobReference(blobPath);
if (!blob.Exists())
blob.CreateOrReplace();
return blob;
}
public void CloudBlobSnapshotAPM()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
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(snapshot1, (CloudBlob)blobs[0]);
AssertAreEqual(snapshot2, (CloudBlob)blobs[1]);
AssertAreEqual(blob, (CloudBlob)blobs[2]);
AssertAreEqual(snapshotCopy, (CloudBlob)blobs[3]);
}
}
finally
{
container.DeleteIfExists();
}
}
private async Task CloudAppendBlobUploadFromStreamAsync(CloudBlobContainer container, int size, AccessCondition accessCondition, OperationContext operationContext, int startOffset)
{
byte[] buffer = GetRandomBuffer(size);
CloudAppendBlob blob = container.GetAppendBlobReference("blob1");
await blob.CreateOrReplaceAsync();
using (MemoryStream originalBlobStream = new MemoryStream())
{
originalBlobStream.Write(buffer, startOffset, buffer.Length - startOffset);
using (MemoryStream sourceStream = new MemoryStream(buffer))
{
sourceStream.Seek(startOffset, SeekOrigin.Begin);
await blob.AppendBlockAsync(sourceStream, null, accessCondition, null, operationContext);
}
using (MemoryStream downloadedBlobStream = new MemoryStream())
{
await blob.DownloadToStreamAsync(downloadedBlobStream);
TestHelper.AssertStreamsAreEqualAtIndex(
originalBlobStream,
downloadedBlobStream,
0,
0,
(int)originalBlobStream.Length);
}
}
}
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))
{
await blob.AppendBlockAsync(wholeBlob);
}
OperationContext opContext = new OperationContext();
using (var 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 (var 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 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.
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(blobCount, 1);
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 async Task AppendBlobWriteStreamOpenWithAccessConditionAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
await container.CreateAsync();
try
{
OperationContext context = new OperationContext();
CloudAppendBlob existingBlob = container.GetAppendBlobReference("blob");
await existingBlob.CreateOrReplaceAsync();
CloudAppendBlob blob = container.GetAppendBlobReference("blob2");
AccessCondition accessCondition = AccessCondition.GenerateIfMatchCondition(existingBlob.Properties.ETag);
await TestHelper.ExpectedExceptionAsync(
async() => await blob.OpenWriteAsync(true, accessCondition, null, context),
context,
"OpenWriteAsync with a non-met condition should fail",
HttpStatusCode.PreconditionFailed);
blob = container.GetAppendBlobReference("blob3");
accessCondition = AccessCondition.GenerateIfNoneMatchCondition(existingBlob.Properties.ETag);
var blobStream = await blob.OpenWriteAsync(true, accessCondition, null, context);
blobStream.Dispose();
blob = container.GetAppendBlobReference("blob4");
accessCondition = AccessCondition.GenerateIfNoneMatchCondition("*");
blobStream = await blob.OpenWriteAsync(true, accessCondition, null, context);
blobStream.Dispose();
blob = container.GetAppendBlobReference("blob5");
accessCondition = AccessCondition.GenerateIfModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(1));
blobStream = await blob.OpenWriteAsync(true, accessCondition, null, context);
blobStream.Dispose();
blob = container.GetAppendBlobReference("blob6");
accessCondition = AccessCondition.GenerateIfNotModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(-1));
blobStream = await blob.OpenWriteAsync(true, accessCondition, null, context);
blobStream.Dispose();
accessCondition = AccessCondition.GenerateIfMatchCondition(existingBlob.Properties.ETag);
blobStream = await existingBlob.OpenWriteAsync(true, accessCondition, null, context);
blobStream.Dispose();
accessCondition = AccessCondition.GenerateIfMatchCondition(blob.Properties.ETag);
await TestHelper.ExpectedExceptionAsync(
async() => await existingBlob.OpenWriteAsync(true, accessCondition, null, context),
context,
"OpenWriteAsync with a non-met condition should fail",
HttpStatusCode.PreconditionFailed);
accessCondition = AccessCondition.GenerateIfNoneMatchCondition(blob.Properties.ETag);
blobStream = await existingBlob.OpenWriteAsync(true, accessCondition, null, context);
blobStream.Dispose();
accessCondition = AccessCondition.GenerateIfNoneMatchCondition(existingBlob.Properties.ETag);
await TestHelper.ExpectedExceptionAsync(
async() => await existingBlob.OpenWriteAsync(true, accessCondition, null, context),
context,
"OpenWriteAsync with a non-met condition should fail",
HttpStatusCode.PreconditionFailed);
accessCondition = AccessCondition.GenerateIfNoneMatchCondition("*");
await TestHelper.ExpectedExceptionAsync(
async() => await existingBlob.OpenWriteAsync(true, accessCondition, null, context),
context,
"BlobWriteStream.Dispose with a non-met condition should fail",
HttpStatusCode.Conflict);
accessCondition = AccessCondition.GenerateIfModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(-1));
blobStream = await existingBlob.OpenWriteAsync(true, accessCondition, null, context);
blobStream.Dispose();
accessCondition = AccessCondition.GenerateIfModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(1));
await TestHelper.ExpectedExceptionAsync(
async() => await existingBlob.OpenWriteAsync(true, accessCondition, null, context),
context,
"OpenWriteAsync with a non-met condition should fail",
HttpStatusCode.PreconditionFailed);
accessCondition = AccessCondition.GenerateIfNotModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(1));
blobStream = await existingBlob.OpenWriteAsync(true, accessCondition, null, context);
blobStream.Dispose();
accessCondition = AccessCondition.GenerateIfNotModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(-1));
await TestHelper.ExpectedExceptionAsync(
async() => await existingBlob.OpenWriteAsync(true, accessCondition, null, context),
context,
"OpenWriteAsync with a non-met condition should fail",
HttpStatusCode.PreconditionFailed);
}
finally
{
container.DeleteAsync().Wait();
}
}