/// <summary>
/// Copies the file.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="blob">The BLOB.</param>
/// <param name="newFileName">New name of the file.</param>
/// <returns></returns>
public async Task <bool> CopyFile(CloudBlobContainer container, Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob blob, string newFileName)
{
await blob.FetchAttributesAsync();
Uri uri = new Uri(blob.Name);
string filename = System.IO.Path.GetFileName(uri.LocalPath);
var newFile = uri.OriginalString.Replace(filename, newFileName);
var newBlob = blob.Container.GetBlockBlobReference(newFile);
var exists = BlobExistsOnCloud(container, newFile);
if (exists)
{
//Inform the user that the blob exists
return(false);
}
await newBlob.StartCopyFromBlobAsync(blob);
return(true);
}
private async Task CheckForUpdateAsync()
{
var storageAccount = CloudStorageAccount.Parse(_configuration.ReferenceDataStorageAccount);
var blobClient = storageAccount.CreateCloudBlobClient();
var container = blobClient.GetContainerReference(_configuration.ReferenceDataStorageContainer);
_blockBlob = container.GetBlockBlobReference(_configuration.ReferenceDataFilePath);
if(!await _blockBlob.ExistsAsync())
{
throw new ApplicationException(string.Format(CultureInfo.InvariantCulture,
"Could not find blob named {0}.",
_configuration.ReferenceDataFilePath));
}
await _blockBlob.FetchAttributesAsync();
if (_blockBlob.Properties.ETag == _blobETag)
{
return;
}
await LoadDictionaryAsync();
_blobETag = _blockBlob.Properties.ETag;
}
/// <summary>
/// Test blob reads, expecting success.
/// </summary>
/// <param name="testBlob">The blob to test.</param>
/// <param name="targetBlob">The blob to use for the target of copy operations.</param>
/// <param name="testAccessCondition">The access condition to use.</param>
private async Task BlobReadExpectLeaseSuccessAsync(CloudBlockBlob testBlob, AccessCondition testAccessCondition)
{
await testBlob.FetchAttributesAsync(testAccessCondition, null /* options */, null);
await (await testBlob.SnapshotAsync(null /* metadata */, testAccessCondition, null /* options */, null)).DeleteAsync();
await DownloadTextAsync(testBlob, Encoding.UTF8, testAccessCondition, null /* options */, null);
var readStream = await testBlob.OpenReadAsync(testAccessCondition, null /* options */, null);
Stream stream = readStream.AsStreamForRead();
stream.ReadByte();
}
/// <summary>
/// Test blob reads, expecting lease failure.
/// </summary>
/// <param name="testBlob">The blob to test.</param>
/// <param name="targetBlob">The blob to use for the target of copy operations.</param>
/// <param name="testAccessCondition">The failing access condition to use.</param>
/// <param name="expectedErrorCode">The expected error code.</param>
/// <param name="description">The reason why these calls should fail.</param>
private async Task BlobReadExpectLeaseFailureAsync(CloudBlockBlob testBlob, CloudBlockBlob targetBlob, AccessCondition testAccessCondition, HttpStatusCode expectedStatusCode, string expectedErrorCode, string description)
{
OperationContext operationContext = new OperationContext();
// FetchAttributes is a HEAD request with no extended error info, so it returns with the generic ConditionFailed error code.
await TestHelper.ExpectedExceptionAsync(
async () => await testBlob.FetchAttributesAsync(testAccessCondition, null /* options */, operationContext),
operationContext,
description + "(Fetch Attributes)",
HttpStatusCode.PreconditionFailed);
await TestHelper.ExpectedExceptionAsync(
async () => await testBlob.SnapshotAsync(null /* metadata */, testAccessCondition, null /* options */, operationContext),
operationContext,
description + " (Create Snapshot)",
expectedStatusCode,
expectedErrorCode);
await TestHelper.ExpectedExceptionAsync(
async () => await DownloadTextAsync(testBlob, Encoding.UTF8, testAccessCondition, null /* options */, operationContext),
operationContext,
description + " (Download Text)",
expectedStatusCode,
expectedErrorCode);
await TestHelper.ExpectedExceptionAsync(
async () => await testBlob.OpenReadAsync(testAccessCondition, null /* options */, operationContext),
operationContext,
description + " (Read Stream)",
expectedStatusCode/*,
expectedErrorCode*/);
}
/// <summary>
/// Test blob writing, expecting success.
/// </summary>
/// <param name="testBlob">The blob to test.</param>
/// <param name="sourceBlob">A blob to use as the source of a copy.</param>
/// <param name="testAccessCondition">The access condition to use.</param>
private async Task BlobWriteExpectLeaseSuccessAsync(CloudBlockBlob testBlob, CloudBlob sourceBlob, AccessCondition testAccessCondition)
{
await testBlob.SetMetadataAsync(testAccessCondition, null /* options */, null);
await testBlob.SetPropertiesAsync(testAccessCondition, null /* options */, null);
await UploadTextAsync(testBlob, "No Problem", Encoding.UTF8, testAccessCondition, null /* options */, null);
await testBlob.StartCopyAsync(TestHelper.Defiddler(sourceBlob.Uri), null /* source access condition */, testAccessCondition, null /* options */, null);
while (testBlob.CopyState.Status == CopyStatus.Pending)
{
await Task.Delay(1000);
await testBlob.FetchAttributesAsync();
}
var writeStream = await testBlob.OpenWriteAsync(testAccessCondition, null /* options */, null);
Stream stream = writeStream.AsStreamForWrite();
stream.WriteByte(0);
await stream.FlushAsync();
await testBlob.DeleteAsync(DeleteSnapshotsOption.None, testAccessCondition, null /* options */, null);
}
public static async Task TouchBlobAsync(CloudBlockBlob blob)
{
await blob.FetchAttributesAsync();
blob.Metadata.Add("touch", Guid.NewGuid().ToString("N"));
await blob.SetMetadataAsync();
}
/// <summary>
/// Test blob reads, expecting success.
/// </summary>
/// <param name="testBlob">The blob to test.</param>
/// <param name="testAccessCondition">The access condition to use.</param>
private void BlobReadExpectLeaseSuccessTask(CloudBlockBlob testBlob, AccessCondition testAccessCondition)
{
testBlob.FetchAttributesAsync(testAccessCondition, null /* options */, new OperationContext());
testBlob.SnapshotAsync(null /* metadata */, testAccessCondition, null /* options */, new OperationContext()).Result.Delete();
DownloadTextTask(testBlob, Encoding.UTF8, testAccessCondition, null /* options */);
Stream stream = testBlob.OpenReadAsync(testAccessCondition, null /* options */, new OperationContext()).Result;
stream.ReadByte();
}
/// <summary>
/// Test blob writing, expecting success.
/// </summary>
/// <param name="testBlob">The blob to test.</param>
/// <param name="sourceBlob">A blob to use as the source of a copy.</param>
/// <param name="testAccessCondition">The access condition to use.</param>
private void BlobWriteExpectLeaseSuccessTask(CloudBlockBlob testBlob, CloudBlob sourceBlob, AccessCondition testAccessCondition)
{
testBlob.SetMetadataAsync(testAccessCondition, null /* options */, new OperationContext()).Wait();
testBlob.SetPropertiesAsync(testAccessCondition, null /* options */, new OperationContext()).Wait();
UploadTextTask(testBlob, "No Problem", Encoding.UTF8, testAccessCondition, null /* options */, new OperationContext());
testBlob.StartCopyAsync(
TestHelper.Defiddler(sourceBlob.Uri),
null /* source access condition */,
testAccessCondition,
null /* options */,
new OperationContext()).Wait();
while (testBlob.CopyState.Status == CopyStatus.Pending)
{
Thread.Sleep(1000);
testBlob.FetchAttributesAsync().Wait();
}
Stream stream = testBlob.OpenWriteAsync(testAccessCondition, null /* options */, new OperationContext()).Result;
stream.WriteByte(0);
stream.Flush();
testBlob.DeleteAsync(DeleteSnapshotsOption.None, testAccessCondition, null /* options */, new OperationContext());
}
public async Task StoreBlobContentMD5TestAsync()
{
BlobRequestOptions optionsWithNoMD5 = new BlobRequestOptions()
{
StoreBlobContentMD5 = false,
};
BlobRequestOptions optionsWithMD5 = new BlobRequestOptions()
{
StoreBlobContentMD5 = true,
};
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudBlockBlob blob1 = container.GetBlockBlobReference("blob1");
using (Stream stream = new NonSeekableMemoryStream())
{
await blob1.UploadFromStreamAsync(stream, null, optionsWithMD5, null);
}
await blob1.FetchAttributesAsync();
Assert.IsNotNull(blob1.Properties.ContentMD5);
blob1 = container.GetBlockBlobReference("blob2");
using (Stream stream = new NonSeekableMemoryStream())
{
await blob1.UploadFromStreamAsync(stream, null, optionsWithNoMD5, null);
}
await blob1.FetchAttributesAsync();
Assert.IsNull(blob1.Properties.ContentMD5);
blob1 = container.GetBlockBlobReference("blob3");
using (Stream stream = new NonSeekableMemoryStream())
{
await blob1.UploadFromStreamAsync(stream);
}
await blob1.FetchAttributesAsync();
Assert.IsNotNull(blob1.Properties.ContentMD5);
CloudPageBlob blob2 = container.GetPageBlobReference("blob4");
blob2 = container.GetPageBlobReference("blob4");
using (Stream stream = new MemoryStream())
{
await blob2.UploadFromStreamAsync(stream, null, optionsWithMD5, null);
}
await blob2.FetchAttributesAsync();
Assert.IsNotNull(blob2.Properties.ContentMD5);
blob2 = container.GetPageBlobReference("blob5");
using (Stream stream = new MemoryStream())
{
await blob2.UploadFromStreamAsync(stream, null, optionsWithNoMD5, null);
}
await blob2.FetchAttributesAsync();
Assert.IsNull(blob2.Properties.ContentMD5);
blob2 = container.GetPageBlobReference("blob6");
using (Stream stream = new MemoryStream())
{
await blob2.UploadFromStreamAsync(stream);
}
await blob2.FetchAttributesAsync();
Assert.IsNull(blob2.Properties.ContentMD5);
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
private static async Task<DateTimeOffset> GetLastModifiedAsync(CloudBlockBlob blob)
{
await blob.FetchAttributesAsync().ConfigureAwait(false);
return blob.Properties.LastModified.Value;
}
private async Task StartCopyFromFile(long taskId, IStorageBlobManagement destChannel, CloudFile srcFile, CloudBlockBlob destBlob)
{
bool destExist = true;
try
{
await destBlob.FetchAttributesAsync(null, this.RequestOptions, this.OperationContext, this.CmdletCancellationToken);
}
catch (StorageException ex)
{
if (ex.IsNotFoundException())
{
destExist = false;
}
else
{
throw;
}
}
if (!destExist || this.ConfirmOverwrite(srcFile.Uri.ToString(), destBlob.Uri.ToString()))
{
string copyId = await destBlob.StartCopyAsync(srcFile.GenerateCopySourceFile(), null, null, this.RequestOptions, this.OperationContext, this.CmdletCancellationToken);
this.OutputStream.WriteVerbose(taskId, String.Format(Resources.CopyDestinationBlobPending, destBlob.Name, destBlob.Container.Name, copyId));
this.WriteCloudBlobObject(taskId, destChannel, destBlob);
}
}
public async Task CloudBlockBlobCopyTestAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudBlockBlob source = container.GetBlockBlobReference("source");
string data = "String data";
await UploadTextAsync(source, data, Encoding.UTF8);
source.Metadata["Test"] = "value";
await source.SetMetadataAsync();
CloudBlockBlob copy = container.GetBlockBlobReference("copy");
string copyId = await copy.StartCopyAsync(TestHelper.Defiddler(source));
Assert.AreEqual(BlobType.BlockBlob, copy.BlobType);
await WaitForCopyAsync(copy);
Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status);
Assert.AreEqual(source.Uri.AbsolutePath, copy.CopyState.Source.AbsolutePath);
Assert.AreEqual(data.Length, copy.CopyState.TotalBytes);
Assert.AreEqual(data.Length, copy.CopyState.BytesCopied);
Assert.AreEqual(copyId, copy.CopyState.CopyId);
Assert.IsTrue(copy.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
OperationContext opContext = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await copy.AbortCopyAsync(copyId, null, null, opContext),
opContext,
"Aborting a copy operation after completion should fail",
HttpStatusCode.Conflict,
"NoPendingCopyOperation");
await source.FetchAttributesAsync();
Assert.IsNotNull(copy.Properties.ETag);
Assert.AreNotEqual(source.Properties.ETag, copy.Properties.ETag);
Assert.IsTrue(copy.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
string copyData = await DownloadTextAsync(copy, Encoding.UTF8);
Assert.AreEqual(data, copyData, "Data inside copy of blob not similar");
await copy.FetchAttributesAsync();
BlobProperties prop1 = copy.Properties;
BlobProperties prop2 = source.Properties;
Assert.AreEqual(prop1.CacheControl, prop2.CacheControl);
Assert.AreEqual(prop1.ContentDisposition, prop2.ContentDisposition);
Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding);
Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage);
Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5);
Assert.AreEqual(prop1.ContentType, prop2.ContentType);
Assert.AreEqual("value", copy.Metadata["Test"], false, "Copied metadata not same");
await copy.DeleteAsync();
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
public async Task CloudBlockBlobCopyFromSnapshotTestAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudBlockBlob source = container.GetBlockBlobReference("source");
string data = "String data";
await UploadTextAsync(source, data, Encoding.UTF8);
source.Metadata["Test"] = "value";
await source.SetMetadataAsync();
CloudBlockBlob snapshot = await source.CreateSnapshotAsync();
//Modify source
string newData = "Hello";
source.Metadata["Test"] = "newvalue";
await source.SetMetadataAsync();
source.Properties.ContentMD5 = null;
await UploadTextAsync(source, newData, Encoding.UTF8);
Assert.AreEqual(newData, await DownloadTextAsync(source, Encoding.UTF8), "Source is modified correctly");
Assert.AreEqual(data, await DownloadTextAsync(snapshot, Encoding.UTF8), "Modifying source blob should not modify snapshot");
await source.FetchAttributesAsync();
await snapshot.FetchAttributesAsync();
Assert.AreNotEqual(source.Metadata["Test"], snapshot.Metadata["Test"], "Source and snapshot metadata should be independent");
CloudBlockBlob copy = container.GetBlockBlobReference("copy");
await copy.StartCopyAsync(TestHelper.Defiddler(snapshot));
await WaitForCopyAsync(copy);
Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status);
Assert.AreEqual(data, await DownloadTextAsync(copy, Encoding.UTF8), "Data inside copy of blob not similar");
await copy.FetchAttributesAsync();
BlobProperties prop1 = copy.Properties;
BlobProperties prop2 = snapshot.Properties;
Assert.AreEqual(prop1.CacheControl, prop2.CacheControl);
Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding);
Assert.AreEqual(prop1.ContentDisposition, prop2.ContentDisposition);
Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage);
Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5);
Assert.AreEqual(prop1.ContentType, prop2.ContentType);
Assert.AreEqual("value", copy.Metadata["Test"], false, "Copied metadata not same");
await copy.DeleteAsync();
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
private static async Task CloudBlockBlobCopyFromCloudFileImpl(Func <CloudFile, CloudBlockBlob, string> copyFunc)
{
CloudFileClient fileClient = GenerateCloudFileClient();
string name = GetRandomContainerName();
CloudFileShare share = fileClient.GetShareReference(name);
CloudBlobContainer container = GetRandomContainerReference();
try
{
try
{
await container.CreateAsync();
await share.CreateAsync();
CloudFile source = share.GetRootDirectoryReference().GetFileReference("source");
byte[] data = GetRandomBuffer(1024);
await source.UploadFromByteArrayAsync(data, 0, data.Length);
source.Metadata["Test"] = "value";
source.SetMetadataAsync().Wait();
var sasToken = source.GetSharedAccessSignature(new SharedAccessFilePolicy
{
Permissions = SharedAccessFilePermissions.Read,
SharedAccessExpiryTime = DateTime.UtcNow.AddHours(24)
});
Uri fileSasUri = new Uri(source.StorageUri.PrimaryUri.ToString() + sasToken);
source = new CloudFile(fileSasUri);
CloudBlockBlob copy = container.GetBlockBlobReference("copy");
string copyId = copyFunc(source, copy);
Assert.AreEqual(BlobType.BlockBlob, copy.BlobType);
try
{
await WaitForCopyAsync(copy);
Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status);
Assert.AreEqual(source.Uri.AbsolutePath, copy.CopyState.Source.AbsolutePath);
Assert.AreEqual(data.Length, copy.CopyState.TotalBytes);
Assert.AreEqual(data.Length, copy.CopyState.BytesCopied);
Assert.AreEqual(copyId, copy.CopyState.CopyId);
Assert.IsFalse(copy.Properties.IsIncrementalCopy);
Assert.IsTrue(copy.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
}
catch (NullReferenceException)
{
// potential null ref in the WaitForCopyTask and CopyState check implementation
}
OperationContext opContext = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await copy.AbortCopyAsync(copyId, null, null, opContext),
opContext,
"Aborting a copy operation after completion should fail",
HttpStatusCode.Conflict,
"NoPendingCopyOperation");
source.FetchAttributesAsync().Wait();
Assert.IsNotNull(copy.Properties.ETag);
Assert.AreNotEqual(source.Properties.ETag, copy.Properties.ETag);
Assert.IsTrue(copy.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
byte[] copyData = new byte[source.Properties.Length];
await copy.DownloadToByteArrayAsync(copyData, 0);
Assert.IsTrue(data.SequenceEqual(copyData), "Data inside copy of blob not similar");
copy.FetchAttributesAsync().Wait();
BlobProperties prop1 = copy.Properties;
FileProperties prop2 = source.Properties;
Assert.AreEqual(prop1.CacheControl, prop2.CacheControl);
Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding);
Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage);
Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5);
Assert.AreEqual(prop1.ContentType, prop2.ContentType);
Assert.AreEqual("value", copy.Metadata["Test"], false, "Copied metadata not same");
copy.DeleteIfExistsAsync().Wait();
}
finally
{
share.DeleteIfExistsAsync().Wait();
}
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
/// <summary>
/// Tests a blob SAS to determine which operations it allows.
/// </summary>
/// <param name="sasUri">A string containing a URI with a SAS appended.</param>
/// <param name="blobContent">A string content content to write to the blob.</param>
/// <returns>A Task object.</returns>
private static async Task TestBlobSASAsync(string sasUri, string blobContent)
{
// Try performing blob operations using the SAS provided.
// Return a reference to the blob using the SAS URI.
CloudBlockBlob blob = new CloudBlockBlob(new Uri(sasUri));
// Create operation: Upload a blob with the specified name to the container.
// If the blob does not exist, it will be created. If it does exist, it will be overwritten.
try
{
MemoryStream msWrite = new MemoryStream(Encoding.UTF8.GetBytes(blobContent));
msWrite.Position = 0;
using (msWrite)
{
await blob.UploadFromStreamAsync(msWrite);
}
Console.WriteLine("Create operation succeeded for SAS {0}", sasUri);
Console.WriteLine();
}
catch (StorageException e)
{
if (e.RequestInformation.HttpStatusCode == 403)
{
Console.WriteLine("Create operation failed for SAS {0}", sasUri);
Console.WriteLine("Additional error information: " + e.Message);
Console.WriteLine();
}
else
{
Console.WriteLine(e.Message);
Console.ReadLine();
throw;
}
}
// Write operation: Add metadata to the blob
try
{
await blob.FetchAttributesAsync();
string rnd = new Random().Next().ToString();
string metadataName = "name";
string metadataValue = "value";
blob.Metadata.Add(metadataName, metadataValue);
await blob.SetMetadataAsync();
Console.WriteLine("Write operation succeeded for SAS {0}", sasUri);
Console.WriteLine();
}
catch (StorageException e)
{
if (e.RequestInformation.HttpStatusCode == 403)
{
Console.WriteLine("Write operation failed for SAS {0}", sasUri);
Console.WriteLine("Additional error information: " + e.Message);
Console.WriteLine();
}
else
{
Console.WriteLine(e.Message);
Console.ReadLine();
throw;
}
}
// Read operation: Read the contents of the blob.
try
{
MemoryStream msRead = new MemoryStream();
using (msRead)
{
await blob.DownloadToStreamAsync(msRead);
msRead.Position = 0;
using (StreamReader reader = new StreamReader(msRead, true))
{
string line;
while ((line = reader.ReadLine()) != null)
{
Console.WriteLine(line);
}
}
Console.WriteLine();
}
Console.WriteLine("Read operation succeeded for SAS {0}", sasUri);
Console.WriteLine();
}
catch (StorageException e)
{
if (e.RequestInformation.HttpStatusCode == 403)
{
Console.WriteLine("Read operation failed for SAS {0}", sasUri);
Console.WriteLine("Additional error information: " + e.Message);
Console.WriteLine();
}
else
{
Console.WriteLine(e.Message);
Console.ReadLine();
throw;
}
}
// Delete operation: Delete the blob.
try
{
await blob.DeleteAsync();
Console.WriteLine("Delete operation succeeded for SAS {0}", sasUri);
Console.WriteLine();
}
catch (StorageException e)
{
if (e.RequestInformation.HttpStatusCode == 403)
{
Console.WriteLine("Delete operation failed for SAS {0}", sasUri);
Console.WriteLine("Additional error information: " + e.Message);
Console.WriteLine();
}
else
{
Console.WriteLine(e.Message);
Console.ReadLine();
throw;
}
}
}
public async Task CloudBlockBlobSnapshotAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
MemoryStream originalData = new MemoryStream(GetRandomBuffer(1024));
CloudBlockBlob blob = container.GetBlockBlobReference("blob1");
await blob.UploadFromStreamAsync(originalData.AsInputStream());
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);
CloudBlockBlob snapshot1 = await blob.CreateSnapshotAsync();
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"));
CloudBlockBlob snapshot2 = await blob.CreateSnapshotAsync();
Assert.IsTrue(snapshot2.SnapshotTime.Value > snapshot1.SnapshotTime.Value);
await snapshot1.FetchAttributesAsync();
await snapshot2.FetchAttributesAsync();
await blob.FetchAttributesAsync();
AssertAreEqual(snapshot1.Properties, blob.Properties);
CloudBlockBlob snapshot1Clone = new CloudBlockBlob(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);
CloudBlockBlob snapshotCopy = container.GetBlockBlobReference("blob2");
await snapshotCopy.StartCopyFromBlobAsync(TestHelper.Defiddler(snapshot1.Uri));
await WaitForCopyAsync(snapshotCopy);
Assert.AreEqual(CopyStatus.Success, snapshotCopy.CopyState.Status);
await TestHelper.ExpectedExceptionAsync<InvalidOperationException>(
async () => await snapshot1.OpenWriteAsync(),
"Trying to write to a blob snapshot should fail");
using (Stream snapshotStream = (await snapshot1.OpenReadAsync()).AsStreamForRead())
{
snapshotStream.Seek(0, SeekOrigin.End);
TestHelper.AssertStreamsAreEqual(originalData, snapshotStream);
}
await blob.PutBlockListAsync(new List<string>());
await blob.FetchAttributesAsync();
using (Stream snapshotStream = (await snapshot1.OpenReadAsync()).AsStreamForRead())
{
snapshotStream.Seek(0, SeekOrigin.End);
TestHelper.AssertStreamsAreEqual(originalData, snapshotStream);
}
BlobResultSegment resultSegment = await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.All, null, null, null, null);
List<IListBlobItem> blobs = resultSegment.Results.ToList();
Assert.AreEqual(4, blobs.Count);
AssertAreEqual(snapshot1, (ICloudBlob)blobs[0]);
AssertAreEqual(snapshot2, (ICloudBlob)blobs[1]);
AssertAreEqual(blob, (ICloudBlob)blobs[2]);
AssertAreEqual(snapshotCopy, (ICloudBlob)blobs[3]);
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
/// <summary>
/// Copies the log directory to the
/// </summary>
public async Task<CopyableBlob[]> CopyDirectoryTo(string accountName, string accountKey,
string sourceContainerName, string directoryName, string destinationContanerName, string copyDirectoryPrefix = "")
{
var copyIds = new List<CopyableBlob>();
// get a list of the source account blobs
var sourceAccountStorageCredentials = new StorageCredentials(AccountName, AccountKey);
var account = new CloudStorageAccount(sourceAccountStorageCredentials, true);
var client = account.CreateCloudBlobClient();
var sourceContainer = client.GetContainerReference(sourceContainerName);
var blobs = sourceContainer.ListBlobs(directoryName, true);
// get a list of the destination account blobs
var destinationAccountCredentials = new StorageCredentials(accountName, accountKey);
var destinationAccount = new CloudStorageAccount(destinationAccountCredentials, true);
var destinationClient = destinationAccount.CreateCloudBlobClient();
var destinationContainer = destinationClient.GetContainerReference(destinationContanerName);
destinationContainer.CreateIfNotExists();
foreach (var blob in blobs)
{
var blockBlob = blob as CloudBlockBlob;
var destinationBlockBlob =
destinationContainer.GetBlockBlobReference(String.Format("{0}/{1}", copyDirectoryPrefix,
String.Join("", blob.Uri.Segments.Skip(3).Take(5).ToArray())));
var sas = blockBlob.GetSharedAccessSignature(new SharedAccessBlobPolicy()
{
Permissions = SharedAccessBlobPermissions.Read,
SharedAccessStartTime = DateTime.Now.AddMinutes(-15),
SharedAccessExpiryTime = DateTime.Now.AddHours(1)
});
blockBlob = new CloudBlockBlob(new Uri(blockBlob.Uri.AbsoluteUri + sas));
copyIds.Add(new CopyableBlob()
{
// the use of a SAS fubars this
CopyId = await destinationBlockBlob.StartCopyFromBlobAsync(blockBlob),
BlobUri = destinationBlockBlob.Uri,
ContainerName = destinationContanerName,
Size = (double) blockBlob.Properties.Length/1024,
PercentageCopied = 0
});
}
CopyingBlobs = copyIds.ToArray();
int completed = 0;
while (true)
{
foreach (var blob in copyIds)
{
var blockBlob = new CloudBlockBlob(blob.BlobUri, destinationAccountCredentials);
await blockBlob.FetchAttributesAsync();
await Task.Delay(500);
if (blockBlob.CopyState.BytesCopied.HasValue)
{
blob.PercentageCopied =
Convert.ToInt32(
Math.Round(
(double) blockBlob.CopyState.BytesCopied.Value/blockBlob.CopyState.TotalBytes.Value,
2)*100);
}
if (blockBlob.CopyState.Status == CopyStatus.Success ||
blockBlob.CopyState.Status == CopyStatus.Failed)
{
completed++;
}
if (completed == copyIds.Count)
return CopyingBlobs;
}
}
}
