/// <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; } } }