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 static List<string> CreateBlobs(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.PutBlockList(new string[] { }); blobs.Add(name); break; case BlobType.PageBlob: name = "pb" + Guid.NewGuid().ToString(); CloudPageBlob pageBlob = container.GetPageBlobReference(name); pageBlob.Create(0); blobs.Add(name); break; } } return blobs; }
// copy a directory of the same container to another container public static List<ICancellableAsyncResult> CopyBlobDirectory(CloudBlobDirectory srcDirectory, CloudBlobContainer destContainer, string sourceblobToken) { List<ICancellableAsyncResult> mylistresults = new List<ICancellableAsyncResult>(); var srcBlobList = srcDirectory.ListBlobs( useFlatBlobListing: true, blobListingDetails: BlobListingDetails.None).ToList(); foreach (var src in srcBlobList) { var srcBlob = src as ICloudBlob; // Create appropriate destination blob type to match the source blob ICloudBlob destBlob; if (srcBlob.Properties.BlobType == BlobType.BlockBlob) destBlob = destContainer.GetBlockBlobReference(srcBlob.Name); else destBlob = destContainer.GetPageBlobReference(srcBlob.Name); // copy using src blob as SAS mylistresults.Add(destBlob.BeginStartCopyFromBlob(new Uri(srcBlob.Uri.AbsoluteUri + sourceblobToken), null, null)); } return mylistresults; }
private async Task<bool> CloudBlobDirectorySetupWithDelimiterAsync(CloudBlobContainer container, string delimiter = "/") { try { for (int i = 1; i < 3; i++) { for (int j = 1; j < 3; j++) { for (int k = 1; k < 3; k++) { String directory = "TopDir" + i + delimiter + "MidDir" + j + delimiter + "EndDir" + k + delimiter + "EndBlob" + k; CloudPageBlob blob1 = container.GetPageBlobReference(directory); await blob1.CreateAsync(0); } } CloudPageBlob blob2 = container.GetPageBlobReference("TopDir" + i + delimiter + "Blob" + i); await blob2.CreateAsync(0); } return true; } catch (Exception e) { throw e; } }
public static MessageReader GetReader(string sas) { var uri = new Uri(sas); var container = new CloudBlobContainer(uri); var posBlob = container.GetPageBlobReference(Constants.PositionFileName); var dataBlob = container.GetPageBlobReference(Constants.StreamFileName); var position = new CloudCheckpointReader(posBlob); var messages = new CloudPageReader(dataBlob); return new MessageReader(position, messages); }
public static MessageWriter CreateAndInitWriter(CloudBlobContainer container) { container.CreateIfNotExists(); var dataBlob = container.GetPageBlobReference(Constants.StreamFileName); var posBlob = container.GetPageBlobReference(Constants.PositionFileName); var pageWriter = new CloudPageWriter(dataBlob); var posWriter = new CloudCheckpointWriter(posBlob); var writer = new MessageWriter(pageWriter, posWriter); writer.Init(); return writer; }
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 static StorageBlob.ICloudBlob GetBlob(StorageBlob.CloudBlobContainer container, string blobName, StorageType blobType) { StorageBlob.ICloudBlob blob = null; if (blobType == StorageType.BlockBlob) { blob = container.GetBlockBlobReference(blobName); } else { blob = container.GetPageBlobReference(blobName); } return(blob); }
/// <summary> /// create a new page blob with random properties and metadata /// </summary> /// <param name="container">CloudBlobContainer object</param> /// <param name="blobName">blob name</param> /// <returns>ICloudBlob object</returns> public StorageBlob.ICloudBlob CreatePageBlob(StorageBlob.CloudBlobContainer container, string blobName) { StorageBlob.CloudPageBlob pageBlob = container.GetPageBlobReference(blobName); int size = random.Next(1, 10) * PageBlobUnitSize; pageBlob.Create(size); byte[] buffer = new byte[size]; string md5sum = Convert.ToBase64String(Helper.GetMD5(buffer)); pageBlob.Properties.ContentMD5 = md5sum; GenerateBlobPropertiesAndMetaData(pageBlob); Test.Info(string.Format("create page blob '{0}' in container '{1}'", blobName, container.Name)); return(pageBlob); }
public async Task PageBlobWriteStreamFlushTestAsync() { byte[] buffer = GetRandomBuffer(512); CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); blob.StreamWriteSizeInBytes = 1024; using (MemoryStream wholeBlob = new MemoryStream()) { BlobRequestOptions options = new BlobRequestOptions() { StoreBlobContentMD5 = true }; OperationContext opContext = new OperationContext(); using (ICloudBlobStream blobStream = await blob.OpenWriteAsync(4 * 512, null, options, opContext)) { for (int i = 0; i < 3; i++) { await blobStream.WriteAsync(buffer.AsBuffer()); 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.AsBuffer()); await wholeBlob.WriteAsync(buffer, 0, buffer.Length); Assert.AreEqual(3, opContext.RequestResults.Count); await blobStream.CommitAsync(); Assert.AreEqual(5, opContext.RequestResults.Count); } Assert.AreEqual(5, opContext.RequestResults.Count); using (MemoryOutputStream downloadedBlob = new MemoryOutputStream()) { await blob.DownloadToStreamAsync(downloadedBlob); TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob.UnderlyingStream); } } } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task PageBlobWriteStreamOpenWithAccessConditionAsync() { CloudBlobContainer container = GetRandomContainerReference(); await container.CreateAsync(); try { OperationContext context = new OperationContext(); CloudPageBlob existingBlob = container.GetPageBlobReference("blob"); await existingBlob.CreateAsync(1024); CloudPageBlob blob = container.GetPageBlobReference("blob2"); AccessCondition accessCondition = AccessCondition.GenerateIfMatchCondition(existingBlob.Properties.ETag); await TestHelper.ExpectedExceptionAsync( async() => await blob.OpenWriteAsync(1024, accessCondition, null, context), context, "OpenWriteAsync with a non-met condition should fail", HttpStatusCode.PreconditionFailed); blob = container.GetPageBlobReference("blob3"); accessCondition = AccessCondition.GenerateIfNoneMatchCondition(existingBlob.Properties.ETag); IOutputStream blobStream = await blob.OpenWriteAsync(1024, accessCondition, null, context); blobStream.Dispose(); blob = container.GetPageBlobReference("blob4"); accessCondition = AccessCondition.GenerateIfNoneMatchCondition("*"); blobStream = await blob.OpenWriteAsync(1024, accessCondition, null, context); blobStream.Dispose(); blob = container.GetPageBlobReference("blob5"); accessCondition = AccessCondition.GenerateIfModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(1)); blobStream = await blob.OpenWriteAsync(1024, accessCondition, null, context); blobStream.Dispose(); blob = container.GetPageBlobReference("blob6"); accessCondition = AccessCondition.GenerateIfNotModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(-1)); blobStream = await blob.OpenWriteAsync(1024, accessCondition, null, context); blobStream.Dispose(); accessCondition = AccessCondition.GenerateIfMatchCondition(existingBlob.Properties.ETag); blobStream = await existingBlob.OpenWriteAsync(1024, accessCondition, null, context); blobStream.Dispose(); accessCondition = AccessCondition.GenerateIfMatchCondition(blob.Properties.ETag); await TestHelper.ExpectedExceptionAsync( async() => await existingBlob.OpenWriteAsync(1024, accessCondition, null, context), context, "OpenWriteAsync with a non-met condition should fail", HttpStatusCode.PreconditionFailed); accessCondition = AccessCondition.GenerateIfNoneMatchCondition(blob.Properties.ETag); blobStream = await existingBlob.OpenWriteAsync(1024, accessCondition, null, context); blobStream.Dispose(); accessCondition = AccessCondition.GenerateIfNoneMatchCondition(existingBlob.Properties.ETag); await TestHelper.ExpectedExceptionAsync( async() => await existingBlob.OpenWriteAsync(1024, accessCondition, null, context), context, "OpenWriteAsync with a non-met condition should fail", HttpStatusCode.PreconditionFailed); accessCondition = AccessCondition.GenerateIfNoneMatchCondition("*"); await TestHelper.ExpectedExceptionAsync( async() => await existingBlob.OpenWriteAsync(1024, 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(1024, accessCondition, null, context); blobStream.Dispose(); accessCondition = AccessCondition.GenerateIfModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(1)); await TestHelper.ExpectedExceptionAsync( async() => await existingBlob.OpenWriteAsync(1024, 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(1024, accessCondition, null, context); blobStream.Dispose(); accessCondition = AccessCondition.GenerateIfNotModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(-1)); await TestHelper.ExpectedExceptionAsync( async() => await existingBlob.OpenWriteAsync(1024, accessCondition, null, context), context, "OpenWriteAsync with a non-met condition should fail", HttpStatusCode.PreconditionFailed); } finally { container.DeleteAsync().AsTask().Wait(); } }
public static ICloudBlob GetBlob(CloudBlobContainer container, string blobName, StorageType blobType) { ICloudBlob blob = null; if (blobType == StorageType.BlockBlob) { blob = container.GetBlockBlobReference(blobName); } else { blob = container.GetPageBlobReference(blobName); } return blob; }
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); } }
/// <summary> /// Get a list of valid page ranges for a page blob /// </summary> /// <param name="container"></param> /// <returns>A Task object.</returns> private static async Task PageRangesSample(CloudBlobContainer container) { BlobRequestOptions requestOptions = new BlobRequestOptions { RetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 3) }; await container.CreateIfNotExistsAsync(requestOptions, null); Console.WriteLine("Create Page Blob"); CloudPageBlob pageBlob = container.GetPageBlobReference("blob1"); pageBlob.Create(4 * 1024); Console.WriteLine("Write Pages to Blob"); byte[] buffer = GetRandomBuffer(1024); using (MemoryStream memoryStream = new MemoryStream(buffer)) { pageBlob.WritePages(memoryStream, 512); } using (MemoryStream memoryStream = new MemoryStream(buffer)) { pageBlob.WritePages(memoryStream, 3 * 1024); } Console.WriteLine("Get Page Ranges"); IEnumerable<PageRange> pageRanges = pageBlob.GetPageRanges(); foreach (PageRange pageRange in pageRanges) { Console.WriteLine(pageRange.ToString()); } // Clean up after the demo. This line is not strictly necessary as the container is deleted in the next call. // It is included for the purposes of the example. Console.WriteLine("Delete page blob"); await pageBlob.DeleteIfExistsAsync(); Console.WriteLine(); }
public async Task CloudPageBlobCopyTestAsync() { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob source = container.GetPageBlobReference("source"); string data = new string('a', 512); await UploadTextAsync(source, data, Encoding.UTF8); source.Metadata["Test"] = "value"; await source.SetMetadataAsync(); CloudPageBlob copy = container.GetPageBlobReference("copy"); string copyId = await copy.StartCopyFromBlobAsync(TestHelper.Defiddler(source)); 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(); } }
private async Task CloudPageBlobUploadFromStreamAsync(CloudBlobContainer container, int size, long? copyLength, AccessCondition accessCondition, OperationContext operationContext, int startOffset, bool testMd5) { byte[] buffer = GetRandomBuffer(size); string md5 = string.Empty; if (testMd5) { #if ASPNET_K MD5 hasher = MD5.Create(); md5 = Convert.ToBase64String(hasher.ComputeHash(buffer, startOffset, copyLength.HasValue ? (int)copyLength : buffer.Length - startOffset)); #else CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash(); hasher.Append(buffer.AsBuffer(startOffset, copyLength.HasValue ? (int)copyLength : buffer.Length - startOffset)); md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset()); #endif } CloudPageBlob blob = container.GetPageBlobReference("blob1"); blob.StreamWriteSizeInBytes = 512; using (MemoryStream originalBlobStream = new MemoryStream()) { originalBlobStream.Write(buffer, startOffset, buffer.Length - startOffset); using (MemoryStream sourceStream = new MemoryStream(buffer)) { sourceStream.Seek(startOffset, SeekOrigin.Begin); BlobRequestOptions options = new BlobRequestOptions() { StoreBlobContentMD5 = true, }; if (copyLength.HasValue) { await blob.UploadFromStreamAsync(sourceStream, copyLength.Value, accessCondition, options, operationContext); } else { await blob.UploadFromStreamAsync(sourceStream, accessCondition, options, operationContext); } } if (testMd5) { await blob.FetchAttributesAsync(); Assert.AreEqual(md5, blob.Properties.ContentMD5); } using (MemoryOutputStream downloadedBlobStream = new MemoryOutputStream()) { await blob.DownloadToStreamAsync(downloadedBlobStream); Assert.AreEqual(copyLength ?? originalBlobStream.Length, downloadedBlobStream.UnderlyingStream.Length); TestHelper.AssertStreamsAreEqualAtIndex( originalBlobStream, downloadedBlobStream.UnderlyingStream, 0, 0, copyLength.HasValue ? (int)copyLength : (int)originalBlobStream.Length); } } }
public static void CopyBlobs( CloudBlobContainer srcContainer, string policyId, CloudBlobContainer destContainer) { // get the SAS token to use for all blobs string blobToken = srcContainer.GetSharedAccessSignature( new SharedAccessBlobPolicy(), policyId); var srcBlobList = srcContainer.ListBlobs(null, false); foreach (var src in srcBlobList) { var srcBlob = src as CloudBlob; try { // Create appropriate destination blob type to match the source blob CloudBlob destBlob; if (srcBlob.Properties.BlobType == BlobType.BlockBlob) { destBlob = destContainer.GetBlockBlobReference(srcBlob.Name); } else { destBlob = destContainer.GetPageBlobReference(srcBlob.Name); } // copy using src blob as SAS // destBlob.StartCopyFromBlob(new Uri(srcBlob.Uri.AbsoluteUri + blobToken)); destBlob.StartCopy(new Uri(srcBlob.Uri.AbsoluteUri)); Console.WriteLine("Copied: " + srcBlob.Uri.AbsoluteUri); } catch (Exception e) { Console.WriteLine("Error: " + e.Message); } } }
private async Task CloudPageBlobUploadFromStreamAsync(CloudBlobContainer container, int size, long? copyLength, AccessCondition accessCondition, OperationContext operationContext, int startOffset) { byte[] buffer = GetRandomBuffer(size); CloudPageBlob blob = container.GetPageBlobReference("blob1"); blob.StreamWriteSizeInBytes = 512; using (MemoryStream originalBlobStream = new MemoryStream()) { originalBlobStream.Write(buffer, startOffset, buffer.Length - startOffset); using (MemoryStream sourceStream = new MemoryStream(buffer)) { sourceStream.Seek(startOffset, SeekOrigin.Begin); if (copyLength.HasValue) { await blob.UploadFromStreamAsync(sourceStream, copyLength.Value, accessCondition, null, operationContext); } else { await blob.UploadFromStreamAsync(sourceStream, accessCondition, null, operationContext); } } 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 CloudPageBlobConditionalAccessAsync() { OperationContext operationContext = new OperationContext(); CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); await blob.CreateAsync(1024); await blob.FetchAttributesAsync(); string currentETag = blob.Properties.ETag; DateTimeOffset currentModifiedTime = blob.Properties.LastModified.Value; // ETag conditional tests blob.Metadata["ETagConditionalName"] = "ETagConditionalValue"; await blob.SetMetadataAsync(AccessCondition.GenerateIfMatchCondition(currentETag), null, null); await blob.FetchAttributesAsync(); string newETag = blob.Properties.ETag; Assert.AreNotEqual(newETag, currentETag, "ETage should be modified on write metadata"); blob.Metadata["ETagConditionalName"] = "ETagConditionalValue2"; await TestHelper.ExpectedExceptionAsync( async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfNoneMatchCondition(newETag), null, operationContext), operationContext, "If none match on conditional test should throw", HttpStatusCode.PreconditionFailed, "ConditionNotMet"); string invalidETag = "\"0x10101010\""; await TestHelper.ExpectedExceptionAsync( async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfMatchCondition(invalidETag), null, operationContext), operationContext, "Invalid ETag on conditional test should throw", HttpStatusCode.PreconditionFailed, "ConditionNotMet"); currentETag = blob.Properties.ETag; await blob.SetMetadataAsync(AccessCondition.GenerateIfNoneMatchCondition(invalidETag), null, null); await blob.FetchAttributesAsync(); newETag = blob.Properties.ETag; // LastModifiedTime tests currentModifiedTime = blob.Properties.LastModified.Value; blob.Metadata["DateConditionalName"] = "DateConditionalValue"; await TestHelper.ExpectedExceptionAsync( async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfModifiedSinceCondition(currentModifiedTime), null, operationContext), operationContext, "IfModifiedSince conditional on current modified time should throw", HttpStatusCode.PreconditionFailed, "ConditionNotMet"); DateTimeOffset pastTime = currentModifiedTime.Subtract(TimeSpan.FromMinutes(5)); await blob.SetMetadataAsync(AccessCondition.GenerateIfModifiedSinceCondition(pastTime), null, null); pastTime = currentModifiedTime.Subtract(TimeSpan.FromHours(5)); await blob.SetMetadataAsync(AccessCondition.GenerateIfModifiedSinceCondition(pastTime), null, null); pastTime = currentModifiedTime.Subtract(TimeSpan.FromDays(5)); await blob.SetMetadataAsync(AccessCondition.GenerateIfModifiedSinceCondition(pastTime), null, null); currentModifiedTime = blob.Properties.LastModified.Value; pastTime = currentModifiedTime.Subtract(TimeSpan.FromMinutes(5)); await TestHelper.ExpectedExceptionAsync( async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfNotModifiedSinceCondition(pastTime), null, operationContext), operationContext, "IfNotModifiedSince conditional on past time should throw", HttpStatusCode.PreconditionFailed, "ConditionNotMet"); pastTime = currentModifiedTime.Subtract(TimeSpan.FromHours(5)); await TestHelper.ExpectedExceptionAsync( async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfNotModifiedSinceCondition(pastTime), null, operationContext), operationContext, "IfNotModifiedSince conditional on past time should throw", HttpStatusCode.PreconditionFailed, "ConditionNotMet"); pastTime = currentModifiedTime.Subtract(TimeSpan.FromDays(5)); await TestHelper.ExpectedExceptionAsync( async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfNotModifiedSinceCondition(pastTime), null, operationContext), operationContext, "IfNotModifiedSince conditional on past time should throw", HttpStatusCode.PreconditionFailed, "ConditionNotMet"); blob.Metadata["DateConditionalName"] = "DateConditionalValue2"; currentETag = blob.Properties.ETag; await blob.SetMetadataAsync(AccessCondition.GenerateIfNotModifiedSinceCondition(currentModifiedTime), null, null); await blob.FetchAttributesAsync(); newETag = blob.Properties.ETag; Assert.AreNotEqual(newETag, currentETag, "ETage should be modified on write metadata"); } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task CloudPageBlobSnapshotAsync() { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); MemoryStream originalData = new MemoryStream(GetRandomBuffer(1024)); CloudPageBlob blob = container.GetPageBlobReference("blob1"); await blob.UploadFromStreamAsync(originalData.AsInputStream()); CloudPageBlob snapshot1 = await blob.CreateSnapshotAsync(); Assert.AreEqual(blob.Properties.ETag, snapshot1.Properties.ETag); Assert.AreEqual(blob.Properties.LastModified, snapshot1.Properties.LastModified); Assert.IsNotNull(snapshot1.SnapshotTime, "Snapshot does not have SnapshotTime set"); CloudPageBlob 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); CloudPageBlob snapshot1Clone = new CloudPageBlob(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); CloudPageBlob snapshotCopy = container.GetPageBlobReference("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(1024), "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.CreateAsync(1024); 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(); } }
public async Task CloudPageBlobWritePagesAsync() { byte[] buffer = GetRandomBuffer(4 * 1024 * 1024); CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash(); hasher.Append(buffer.AsBuffer()); string contentMD5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset()); CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); await blob.CreateAsync(4 * 1024 * 1024); using (MemoryStream memoryStream = new MemoryStream()) { await TestHelper.ExpectedExceptionAsync <ArgumentOutOfRangeException>( async() => await blob.WritePagesAsync(memoryStream.AsInputStream(), 0, null), "Zero-length WritePages should fail"); memoryStream.SetLength(4 * 1024 * 1024 + 1); await TestHelper.ExpectedExceptionAsync <ArgumentOutOfRangeException>( async() => await blob.WritePagesAsync(memoryStream.AsInputStream(), 0, null), ">4MB WritePages should fail"); } using (MemoryStream resultingData = new MemoryStream()) { using (MemoryStream memoryStream = new MemoryStream(buffer)) { OperationContext opContext = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async() => await blob.WritePagesAsync(memoryStream.AsInputStream(), 512, null, null, null, opContext), opContext, "Writing out-of-range pages should fail", HttpStatusCode.RequestedRangeNotSatisfiable, "InvalidPageRange"); memoryStream.Seek(0, SeekOrigin.Begin); await blob.WritePagesAsync(memoryStream.AsInputStream(), 0, contentMD5); resultingData.Write(buffer, 0, buffer.Length); int offset = buffer.Length - 1024; memoryStream.Seek(offset, SeekOrigin.Begin); await TestHelper.ExpectedExceptionAsync( async() => await blob.WritePagesAsync(memoryStream.AsInputStream(), 0, contentMD5, null, null, opContext), opContext, "Invalid MD5 should fail with mismatch", HttpStatusCode.BadRequest, "Md5Mismatch"); memoryStream.Seek(offset, SeekOrigin.Begin); await blob.WritePagesAsync(memoryStream.AsInputStream(), 0, null); resultingData.Seek(0, SeekOrigin.Begin); resultingData.Write(buffer, offset, buffer.Length - offset); offset = buffer.Length - 2048; memoryStream.Seek(offset, SeekOrigin.Begin); await blob.WritePagesAsync(memoryStream.AsInputStream(), 1024, null); resultingData.Seek(1024, SeekOrigin.Begin); resultingData.Write(buffer, offset, buffer.Length - offset); } using (MemoryStream blobData = new MemoryStream()) { await blob.DownloadToStreamAsync(blobData.AsOutputStream()); Assert.AreEqual(resultingData.Length, blobData.Length); Assert.IsTrue(blobData.ToArray().SequenceEqual(resultingData.ToArray())); } } } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task CloudPageBlobGetPageRangesAsync() { byte[] buffer = GetRandomBuffer(1024); CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); await blob.CreateAsync(4 * 1024); using (MemoryStream memoryStream = new MemoryStream(buffer)) { await blob.WritePagesAsync(memoryStream.AsInputStream(), 512, null); } using (MemoryStream memoryStream = new MemoryStream(buffer)) { await blob.WritePagesAsync(memoryStream.AsInputStream(), 3 * 1024, null); } await blob.ClearPagesAsync(1024, 1024); await blob.ClearPagesAsync(0, 512); IEnumerable <PageRange> pageRanges = await blob.GetPageRangesAsync(); List <string> expectedPageRanges = new List <string>() { new PageRange(512, 1023).ToString(), new PageRange(3 * 1024, 4 * 1024 - 1).ToString(), }; foreach (PageRange pageRange in pageRanges) { Assert.IsTrue(expectedPageRanges.Remove(pageRange.ToString())); } Assert.AreEqual(0, expectedPageRanges.Count); pageRanges = await blob.GetPageRangesAsync(1024, 1024, null, null, null); Assert.AreEqual(0, pageRanges.Count()); pageRanges = await blob.GetPageRangesAsync(512, 3 * 1024, null, null, null); expectedPageRanges = new List <string>() { new PageRange(512, 1023).ToString(), new PageRange(3 * 1024, 7 * 512 - 1).ToString(), }; foreach (PageRange pageRange in pageRanges) { Assert.IsTrue(expectedPageRanges.Remove(pageRange.ToString())); } Assert.AreEqual(0, expectedPageRanges.Count); OperationContext opContext = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async() => await blob.GetPageRangesAsync(1024, null, null, null, opContext), opContext, "Get Page Ranges with an offset but no count should fail", HttpStatusCode.Unused); Assert.IsInstanceOfType(opContext.LastResult.Exception.InnerException, typeof(ArgumentNullException)); } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public void CloudBlobSASApiVersionQueryParam() { CloudBlobContainer container = GetRandomContainerReference(); try { container.Create(); ICloudBlob 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); 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); OperationContext apiVersionCheckContext = new OperationContext(); apiVersionCheckContext.SendingRequest += (sender, e) => { Assert.IsNull(e.Request.Headers.Get("x-ms-version")); Assert.IsTrue(e.Request.RequestUri.Query.Contains("api-version")); }; blob = container.ServiceClient.GetBlobReferenceFromServer(blockBlobSASUri, operationContext: apiVersionCheckContext); Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob)); Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(blockBlob.Uri)); Assert.IsNull(blob.StorageUri.SecondaryUri); blob = container.ServiceClient.GetBlobReferenceFromServer(pageBlobSASUri, operationContext: apiVersionCheckContext); Assert.IsInstanceOfType(blob, typeof(CloudPageBlob)); Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(pageBlob.Uri)); Assert.IsNull(blob.StorageUri.SecondaryUri); blob = container.ServiceClient.GetBlobReferenceFromServer(blockBlobSASStorageUri, operationContext: apiVersionCheckContext); Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob)); Assert.IsTrue(blob.StorageUri.Equals(blockBlob.StorageUri)); blob = container.ServiceClient.GetBlobReferenceFromServer(pageBlobSASStorageUri, operationContext: apiVersionCheckContext); Assert.IsInstanceOfType(blob, typeof(CloudPageBlob)); Assert.IsTrue(blob.StorageUri.Equals(pageBlob.StorageUri)); } finally { container.DeleteIfExists(); } }
public void PageBlobReadLockToETagTestAPM() { byte[] outBuffer = new byte[1 * 1024 * 1024]; byte[] buffer = GetRandomBuffer(2 * outBuffer.Length); CloudBlobContainer container = GetRandomContainerReference(); try { container.Create(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); blob.StreamMinimumReadSizeInBytes = outBuffer.Length; using (MemoryStream wholeBlob = new MemoryStream(buffer)) { blob.UploadFromStream(wholeBlob); } using (AutoResetEvent waitHandle = new AutoResetEvent(false)) { IAsyncResult result = blob.BeginOpenRead( ar => waitHandle.Set(), null); waitHandle.WaitOne(); using (Stream blobStream = blob.EndOpenRead(result)) { blobStream.Read(outBuffer, 0, outBuffer.Length); blob.SetMetadata(); TestHelper.ExpectedException( () => blobStream.Read(outBuffer, 0, outBuffer.Length), "Blob read stream should fail if blob is modified during read", HttpStatusCode.PreconditionFailed); } result = blob.BeginOpenRead( ar => waitHandle.Set(), null); waitHandle.WaitOne(); using (Stream blobStream = blob.EndOpenRead(result)) { long length = blobStream.Length; blob.SetMetadata(); TestHelper.ExpectedException( () => blobStream.Read(outBuffer, 0, outBuffer.Length), "Blob read stream should fail if blob is modified during read", HttpStatusCode.PreconditionFailed); } AccessCondition accessCondition = AccessCondition.GenerateIfNotModifiedSinceCondition(DateTimeOffset.Now.Subtract(TimeSpan.FromHours(1))); blob.SetMetadata(); result = blob.BeginOpenRead( accessCondition, null, null, ar => waitHandle.Set(), null); waitHandle.WaitOne(); TestHelper.ExpectedException( () => blob.EndOpenRead(result), "Blob read stream should fail if blob is modified during read", HttpStatusCode.PreconditionFailed); } } finally { container.DeleteIfExists(); } }
private static void TestAccess(string sasToken, SharedAccessBlobPermissions permissions, SharedAccessBlobHeaders headers, CloudBlobContainer container, ICloudBlob 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 { blob = container.GetPageBlobReference(blob.Name); } } else { if (blob.BlobType == BlobType.BlockBlob) { blob = new CloudBlockBlob(credentials.TransformUri(blob.Uri)); } else { blob = new CloudPageBlob(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); } }
/// <summary> /// set azure blob content /// </summary> /// <param name="fileName">local file path</param> /// <param name="container">destination container</param> /// <param name="blobName">blob name</param> /// <returns>null if user cancel the overwrite operation, otherwise return destination blob object</returns> internal AzureStorageBlob SetAzureBlobContent(string fileName, CloudBlobContainer container, string blobName) { string filePath = GetFullSendFilePath(fileName); if (string.IsNullOrEmpty(filePath)) { return null; } ValidatePipelineCloudBlobContainer(container); if (string.IsNullOrEmpty(blobName)) { blobName = GetBlobNameFromRelativeFilePath(filePath); } ICloudBlob blob = null; switch (CultureInfo.CurrentCulture.TextInfo.ToTitleCase(blobType)) { case PageBlobType: blob = container.GetPageBlobReference(blobName); break; case BlockBlobType: default: blob = container.GetBlockBlobReference(blobName); break; } return SetAzureBlobContent(fileName, blob); }
public async Task CloudBlobClientMaximumExecutionTimeoutShouldNotBeHonoredForStreamsAsync() { CloudBlobClient blobClient = GenerateCloudBlobClient(); CloudBlobContainer container = blobClient.GetContainerReference(Guid.NewGuid().ToString("N")); byte[] buffer = BlobTestBase.GetRandomBuffer(1024 * 1024); try { await container.CreateAsync(); blobClient.DefaultRequestOptions.MaximumExecutionTime = TimeSpan.FromSeconds(30); CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1"); CloudPageBlob pageBlob = container.GetPageBlobReference("blob2"); blockBlob.StreamWriteSizeInBytes = 1024 * 1024; blockBlob.StreamMinimumReadSizeInBytes = 1024 * 1024; pageBlob.StreamWriteSizeInBytes = 1024 * 1024; pageBlob.StreamMinimumReadSizeInBytes = 1024 * 1024; using (var bos = await blockBlob.OpenWriteAsync()) { DateTime start = DateTime.Now; for (int i = 0; i < 7; i++) { await bos.WriteAsync(buffer, 0, buffer.Length); } // Sleep to ensure we are over the Max execution time when we do the last write int msRemaining = (int)(blobClient.DefaultRequestOptions.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds; if (msRemaining > 0) { await Task.Delay(msRemaining); } await bos.WriteAsync(buffer, 0, buffer.Length); await bos.CommitAsync(); } using (Stream bis = (await blockBlob.OpenReadAsync())) { DateTime start = DateTime.Now; int total = 0; while (total < 7 * 1024 * 1024) { total += await bis.ReadAsync(buffer, 0, buffer.Length); } // Sleep to ensure we are over the Max execution time when we do the last read int msRemaining = (int)(blobClient.DefaultRequestOptions.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds; if (msRemaining > 0) { await Task.Delay(msRemaining); } while (true) { int count = await bis.ReadAsync(buffer, 0, buffer.Length); total += count; if (count == 0) { break; } } } using (var bos = await pageBlob.OpenWriteAsync(8 * 1024 * 1024)) { DateTime start = DateTime.Now; for (int i = 0; i < 7; i++) { await bos.WriteAsync(buffer, 0, buffer.Length); } // Sleep to ensure we are over the Max execution time when we do the last write int msRemaining = (int)(blobClient.DefaultRequestOptions.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds; if (msRemaining > 0) { await Task.Delay(msRemaining); } await bos.WriteAsync(buffer, 0, buffer.Length); await bos.CommitAsync(); } using (Stream bis = (await pageBlob.OpenReadAsync())) { DateTime start = DateTime.Now; int total = 0; while (total < 7 * 1024 * 1024) { total += await bis.ReadAsync(buffer, 0, buffer.Length); } // Sleep to ensure we are over the Max execution time when we do the last read int msRemaining = (int)(blobClient.DefaultRequestOptions.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds; if (msRemaining > 0) { await Task.Delay(msRemaining); } while (true) { int count = await bis.ReadAsync(buffer, 0, buffer.Length); total += count; if (count == 0) { break; } } } } finally { blobClient.DefaultRequestOptions.MaximumExecutionTime = null; container.DeleteIfExistsAsync().Wait(); } }
public 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)); } }
/// <summary> /// Write page blob. Although concurrency params exist, does NOT do concurrent uploading yet. /// </summary> /// <param name="stream"></param> /// <param name="blob"></param> /// <param name="container"></param> /// <param name="parallelFactor"></param> /// <param name="chunkSizeInMB"></param> private void WritePageBlob(Stream stream, string blobName, Blob blob, CloudBlobContainer container, int parallelFactor = 1, int chunkSizeInMB = 2) { var blobRef = container.GetPageBlobReference(blobName); blobRef.UploadFromStream(stream); }
public void UseTransactionalMD5GetTestAPM() { BlobRequestOptions optionsWithNoMD5 = new BlobRequestOptions() { UseTransactionalMD5 = false, }; BlobRequestOptions optionsWithMD5 = new BlobRequestOptions() { UseTransactionalMD5 = true, }; byte[] buffer = GetRandomBuffer(3 * 1024 * 1024); MD5 hasher = MD5.Create(); string md5 = Convert.ToBase64String(hasher.ComputeHash(buffer)); string lastCheckMD5 = null; int checkCount = 0; OperationContext opContextWithMD5Check = new OperationContext(); opContextWithMD5Check.ResponseReceived += (_, args) => { if (args.Response.ContentLength >= buffer.Length) { lastCheckMD5 = args.Response.Headers[HttpResponseHeader.ContentMd5]; checkCount++; } }; CloudBlobContainer container = GetRandomContainerReference(); try { container.Create(); using (AutoResetEvent waitHandle = new AutoResetEvent(false)) { IAsyncResult result; CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1"); using (Stream blobStream = blockBlob.OpenWrite()) { blobStream.Write(buffer, 0, buffer.Length); blobStream.Write(buffer, 0, buffer.Length); } checkCount = 0; using (Stream stream = new MemoryStream()) { result = blockBlob.BeginDownloadToStream(stream, null, optionsWithNoMD5, opContextWithMD5Check, ar => waitHandle.Set(), null); waitHandle.WaitOne(); blockBlob.EndDownloadRangeToStream(result); Assert.IsNotNull(lastCheckMD5); result = blockBlob.BeginDownloadToStream(stream, null, optionsWithMD5, opContextWithMD5Check, ar => waitHandle.Set(), null); waitHandle.WaitOne(); blockBlob.EndDownloadRangeToStream(result); Assert.IsNotNull(lastCheckMD5); result = blockBlob.BeginDownloadRangeToStream(stream, buffer.Length, buffer.Length, null, optionsWithNoMD5, opContextWithMD5Check, ar => waitHandle.Set(), null); waitHandle.WaitOne(); blockBlob.EndDownloadRangeToStream(result); Assert.IsNull(lastCheckMD5); result = blockBlob.BeginDownloadRangeToStream(stream, buffer.Length, buffer.Length, null, optionsWithMD5, opContextWithMD5Check, ar => waitHandle.Set(), null); waitHandle.WaitOne(); blockBlob.EndDownloadRangeToStream(result); Assert.AreEqual(md5, lastCheckMD5); result = blockBlob.BeginDownloadRangeToStream(stream, 1024, 4 * 1024 * 1024 + 1, null, optionsWithNoMD5, opContextWithMD5Check, ar => waitHandle.Set(), null); waitHandle.WaitOne(); blockBlob.EndDownloadRangeToStream(result); Assert.IsNull(lastCheckMD5); result = blockBlob.BeginDownloadRangeToStream(stream, 1024, 4 * 1024 * 1024 + 1, null, optionsWithMD5, opContextWithMD5Check, ar => waitHandle.Set(), null); waitHandle.WaitOne(); StorageException storageEx = TestHelper.ExpectedException <StorageException>( () => blockBlob.EndDownloadRangeToStream(result), "Downloading more than 4MB with transactional MD5 should not be supported"); Assert.IsInstanceOfType(storageEx.InnerException, typeof(ArgumentOutOfRangeException)); } Assert.AreEqual(5, checkCount); CloudPageBlob pageBlob = container.GetPageBlobReference("blob2"); using (Stream blobStream = pageBlob.OpenWrite(buffer.Length * 2)) { blobStream.Write(buffer, 0, buffer.Length); blobStream.Write(buffer, 0, buffer.Length); } checkCount = 0; using (Stream stream = new MemoryStream()) { result = pageBlob.BeginDownloadToStream(stream, null, optionsWithNoMD5, opContextWithMD5Check, ar => waitHandle.Set(), null); waitHandle.WaitOne(); pageBlob.EndDownloadRangeToStream(result); Assert.IsNull(lastCheckMD5); result = pageBlob.BeginDownloadToStream(stream, null, optionsWithMD5, opContextWithMD5Check, ar => waitHandle.Set(), null); waitHandle.WaitOne(); StorageException storageEx = TestHelper.ExpectedException <StorageException>( () => pageBlob.EndDownloadRangeToStream(result), "Page blob will not have MD5 set by default; with UseTransactional, download should fail"); result = pageBlob.BeginDownloadRangeToStream(stream, buffer.Length, buffer.Length, null, optionsWithNoMD5, opContextWithMD5Check, ar => waitHandle.Set(), null); waitHandle.WaitOne(); pageBlob.EndDownloadRangeToStream(result); Assert.IsNull(lastCheckMD5); result = pageBlob.BeginDownloadRangeToStream(stream, buffer.Length, buffer.Length, null, optionsWithMD5, opContextWithMD5Check, ar => waitHandle.Set(), null); waitHandle.WaitOne(); pageBlob.EndDownloadRangeToStream(result); Assert.AreEqual(md5, lastCheckMD5); result = pageBlob.BeginDownloadRangeToStream(stream, 1024, 4 * 1024 * 1024 + 1, null, optionsWithNoMD5, opContextWithMD5Check, ar => waitHandle.Set(), null); waitHandle.WaitOne(); pageBlob.EndDownloadRangeToStream(result); Assert.IsNull(lastCheckMD5); result = pageBlob.BeginDownloadRangeToStream(stream, 1024, 4 * 1024 * 1024 + 1, null, optionsWithMD5, opContextWithMD5Check, ar => waitHandle.Set(), null); waitHandle.WaitOne(); storageEx = TestHelper.ExpectedException <StorageException>( () => pageBlob.EndDownloadRangeToStream(result), "Downloading more than 4MB with transactional MD5 should not be supported"); Assert.IsInstanceOfType(storageEx.InnerException, typeof(ArgumentOutOfRangeException)); } Assert.AreEqual(5, checkCount); } } finally { container.DeleteIfExists(); } }
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(); } }
public void PageBlobWriteStreamBasicTestAPM() { byte[] buffer = GetRandomBuffer(1024 * 1024); MD5 hasher = MD5.Create(); CloudBlobClient blobClient = GenerateCloudBlobClient(); blobClient.ParallelOperationThreadCount = 4; string name = GetRandomContainerName(); CloudBlobContainer container = blobClient.GetContainerReference(name); try { container.Create(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); blob.StreamWriteSizeInBytes = buffer.Length; using (MemoryStream wholeBlob = new MemoryStream()) { BlobRequestOptions options = new BlobRequestOptions() { StoreBlobContentMD5 = true, }; using (AutoResetEvent waitHandle = new AutoResetEvent(false)) { IAsyncResult result = blob.BeginOpenWrite(blobClient.ParallelOperationThreadCount * 2 * buffer.Length, null, options, null, ar => waitHandle.Set(), null); waitHandle.WaitOne(); using (Stream blobStream = blob.EndOpenWrite(result)) { IAsyncResult[] results = new IAsyncResult[blobClient.ParallelOperationThreadCount * 2]; for (int i = 0; i < results.Length; i++) { results[i] = blobStream.BeginWrite(buffer, 0, buffer.Length, null, null); wholeBlob.Write(buffer, 0, buffer.Length); Assert.AreEqual(wholeBlob.Position, blobStream.Position); } for (int i = 0; i < blobClient.ParallelOperationThreadCount; i++) { Assert.IsTrue(results[i].IsCompleted); } for (int i = blobClient.ParallelOperationThreadCount; i < results.Length; i++) { Assert.IsFalse(results[i].IsCompleted); } for (int i = 0; i < results.Length; i++) { blobStream.EndWrite(results[i]); } } } wholeBlob.Seek(0, SeekOrigin.Begin); string md5 = Convert.ToBase64String(hasher.ComputeHash(wholeBlob)); blob.FetchAttributes(); Assert.AreEqual(md5, blob.Properties.ContentMD5); using (MemoryStream downloadedBlob = new MemoryStream()) { blob.DownloadToStream(downloadedBlob); TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob); } } } finally { container.DeleteIfExists(); } }
public void CloudPageBlobCopyTestAPM() { CloudBlobContainer container = GetRandomContainerReference(); try { container.Create(); CloudPageBlob source = container.GetPageBlobReference("source"); string data = new string('a', 512); UploadText(source, data, Encoding.UTF8); source.Metadata["Test"] = "value"; source.SetMetadata(); CloudPageBlob copy = container.GetPageBlobReference("copy"); using (AutoResetEvent waitHandle = new AutoResetEvent(false)) { IAsyncResult result = copy.BeginStartCopyFromBlob(TestHelper.Defiddler(source), ar => waitHandle.Set(), null); waitHandle.WaitOne(); string copyId = copy.EndStartCopyFromBlob(result); WaitForCopy(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))); result = copy.BeginAbortCopy(copyId, ar => waitHandle.Set(), null); waitHandle.WaitOne(); TestHelper.ExpectedException( () => copy.EndAbortCopy(result), "Aborting a copy operation after completion should fail", HttpStatusCode.Conflict, "NoPendingCopyOperation"); } source.FetchAttributes(); 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 = DownloadText(copy, Encoding.UTF8); Assert.AreEqual(data, copyData, "Data inside copy of blob not similar"); copy.FetchAttributes(); BlobProperties prop1 = copy.Properties; BlobProperties 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.Delete(); } finally { container.DeleteIfExists(); } }
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; }
/// <summary> /// create a new page blob with random properties and metadata /// </summary> /// <param name="container">CloudBlobContainer object</param> /// <param name="blobName">blob name</param> /// <returns>ICloudBlob object</returns> public ICloudBlob CreatePageBlob(CloudBlobContainer container, string blobName) { CloudPageBlob pageBlob = container.GetPageBlobReference(blobName); int size = random.Next(1, 10) * PageBlobUnitSize; pageBlob.Create(size); byte[] buffer = new byte[size]; string md5sum = Convert.ToBase64String(Helper.GetMD5(buffer)); pageBlob.Properties.ContentMD5 = md5sum; GenerateBlobPropertiesAndMetaData(pageBlob); Test.Info(string.Format("create page blob '{0}' in container '{1}'", blobName, container.Name)); return pageBlob; }
private void TestAccess(string sasToken, SharedAccessBlobPermissions permissions, CloudBlobContainer container, ICloudBlob blob) { StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ? new StorageCredentials() : new StorageCredentials(sasToken); if (container != null) { container = new CloudBlobContainer(container.Uri, credentials); if (blob.BlobType == BlobType.BlockBlob) { blob = container.GetBlockBlobReference(blob.Name); } else { blob = container.GetPageBlobReference(blob.Name); } } else { if (blob.BlobType == BlobType.BlockBlob) { blob = new CloudBlockBlob(blob.Uri, credentials); } else { blob = new CloudPageBlob(blob.Uri, credentials); } } 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(); } 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 async Task PageBlobWriteStreamBasicTestAsync() { byte[] buffer = GetRandomBuffer(6 * 512); CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash(); CloudBlobContainer container = GetRandomContainerReference(); container.ServiceClient.DefaultRequestOptions.ParallelOperationThreadCount = 2; try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); blob.StreamWriteSizeInBytes = 8 * 512; using (MemoryStream wholeBlob = new MemoryStream()) { BlobRequestOptions options = new BlobRequestOptions() { StoreBlobContentMD5 = true, }; using (IOutputStream writeStream = await blob.OpenWriteAsync(buffer.Length * 3, null, options, null)) { Stream blobStream = writeStream.AsStreamForWrite(); 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); hasher.Append(buffer.AsBuffer()); } await blobStream.FlushAsync(); } string md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset()); await blob.FetchAttributesAsync(); Assert.AreEqual(md5, blob.Properties.ContentMD5); using (MemoryOutputStream downloadedBlob = new MemoryOutputStream()) { await blob.DownloadToStreamAsync(downloadedBlob); TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob.UnderlyingStream); } await TestHelper.ExpectedExceptionAsync <ArgumentException>( async() => await blob.OpenWriteAsync(null, null, options, null), "OpenWrite with StoreBlobContentMD5 on an existing page blob should fail"); using (IOutputStream writeStream = await blob.OpenWriteAsync(null)) { Stream blobStream = writeStream.AsStreamForWrite(); blobStream.Seek(buffer.Length / 2, SeekOrigin.Begin); wholeBlob.Seek(buffer.Length / 2, SeekOrigin.Begin); for (int i = 0; i < 2; i++) { blobStream.Write(buffer, 0, buffer.Length); wholeBlob.Write(buffer, 0, buffer.Length); Assert.AreEqual(wholeBlob.Position, blobStream.Position); } await blobStream.FlushAsync(); } await blob.FetchAttributesAsync(); Assert.AreEqual(md5, blob.Properties.ContentMD5); using (MemoryOutputStream downloadedBlob = new MemoryOutputStream()) { options.DisableContentMD5Validation = true; await blob.DownloadToStreamAsync(downloadedBlob, null, options, null); TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob.UnderlyingStream); } } } finally { container.DeleteAsync().AsTask().Wait(); } }
private static void TestAccess(string sasToken, SharedAccessBlobPermissions permissions, SharedAccessBlobHeaders headers, CloudBlobContainer container, ICloudBlob 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 { blob = container.GetPageBlobReference(blob.Name); } } else { if (blob.BlobType == BlobType.BlockBlob) { blob = new CloudBlockBlob(credentials.TransformUri(blob.Uri)); } else { blob = new CloudPageBlob(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 async Task IncrementalCopyAsyncImpl(int overload) { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob source = container.GetPageBlobReference("source"); await source.CreateAsync(1024); string data = new string('a', 512); await UploadTextAsync(source, data, Encoding.UTF8); CloudPageBlob sourceSnapshot = await source.CreateSnapshotAsync(null, null, null, null); SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy() { SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5), SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30), Permissions = SharedAccessBlobPermissions.Read | SharedAccessBlobPermissions.Write, }; string sasToken = sourceSnapshot.GetSharedAccessSignature(policy); StorageCredentials blobSAS = new StorageCredentials(sasToken); Uri sourceSnapshotUri = blobSAS.TransformUri(TestHelper.Defiddler(sourceSnapshot).SnapshotQualifiedUri); StorageCredentials accountSAS = new StorageCredentials(sasToken); CloudStorageAccount accountWithSAS = new CloudStorageAccount(accountSAS, source.ServiceClient.StorageUri, null, null, null); CloudPageBlob snapshotWithSas = await accountWithSAS.CreateCloudBlobClient().GetBlobReferenceFromServerAsync(sourceSnapshot.SnapshotQualifiedUri) as CloudPageBlob; CloudPageBlob copy = container.GetPageBlobReference("copy"); string copyId = null; if (overload == 0) { #if !FACADE_NETCORE copyId = await copy.StartIncrementalCopyAsync(accountSAS.TransformUri(TestHelper.Defiddler(snapshotWithSas).SnapshotQualifiedUri)); #else Uri snapShotQualifiedUri = accountSAS.TransformUri(TestHelper.Defiddler(snapshotWithSas).SnapshotQualifiedUri); copyId = await copy.StartIncrementalCopyAsync(new CloudPageBlob(new StorageUri(snapShotQualifiedUri), null, null)); #endif } else if (overload == 1) { #if !FACADE_NETCORE CloudPageBlob blob = new CloudPageBlob(accountSAS.TransformUri(TestHelper.Defiddler(snapshotWithSas).SnapshotQualifiedUri)); #else Uri snapShotQualifiedUri = accountSAS.TransformUri(TestHelper.Defiddler(snapshotWithSas).SnapshotQualifiedUri); CloudPageBlob blob = new CloudPageBlob(new StorageUri(snapShotQualifiedUri), null, null); #endif copyId = await copy.StartIncrementalCopyAsync(blob); } else if (overload == 2) { #if !FACADE_NETCORE CloudPageBlob blob = new CloudPageBlob(accountSAS.TransformUri(TestHelper.Defiddler(snapshotWithSas).SnapshotQualifiedUri)); #else Uri snapShotQualifiedUri = accountSAS.TransformUri(TestHelper.Defiddler(snapshotWithSas).SnapshotQualifiedUri); CloudPageBlob blob = new CloudPageBlob(new StorageUri(snapShotQualifiedUri), null, null); #endif copyId = await copy.StartIncrementalCopyAsync(blob, null, null, null, CancellationToken.None); } else { #if !FACADE_NETCORE copyId = await copy.StartIncrementalCopyAsync(accountSAS.TransformUri(TestHelper.Defiddler(snapshotWithSas).SnapshotQualifiedUri), null, null, null, CancellationToken.None); #else Uri snapShotQualifiedUri = accountSAS.TransformUri(TestHelper.Defiddler(snapshotWithSas).SnapshotQualifiedUri); CloudPageBlob blob = new CloudPageBlob(new StorageUri(snapShotQualifiedUri), null, null); copyId = await copy.StartIncrementalCopyAsync(blob, null, null, null, CancellationToken.None); #endif } await WaitForCopyAsync(copy); Assert.AreEqual(BlobType.PageBlob, copy.BlobType); Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status); Assert.AreEqual(source.Uri.AbsolutePath, copy.CopyState.Source.AbsolutePath); Assert.AreEqual(data.Length, copy.CopyState.TotalBytes); Assert.AreEqual(data.Length, copy.CopyState.BytesCopied); Assert.AreEqual(copyId, copy.CopyState.CopyId); Assert.IsTrue(copy.Properties.IsIncrementalCopy); Assert.IsTrue(copy.CopyState.DestinationSnapshotTime.HasValue); Assert.IsTrue(copy.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1))); } finally { container.DeleteIfExistsAsync().Wait(); } }
private static async Task TestAccessAsync(string sasToken, SharedAccessBlobPermissions permissions, SharedAccessBlobHeaders headers, CloudBlobContainer container, CloudBlob blob) { OperationContext operationContext = new OperationContext(); StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ? new StorageCredentials() : new StorageCredentials(sasToken); if (container != null) { container = new CloudBlobContainer(container.Uri, credentials); if (blob.BlobType == BlobType.BlockBlob) { blob = container.GetBlockBlobReference(blob.Name); } else { blob = container.GetPageBlobReference(blob.Name); } } else { if (blob.BlobType == BlobType.BlockBlob) { blob = new CloudBlockBlob(blob.Uri, credentials); } else { blob = new CloudPageBlob(blob.Uri, credentials); } } if (container != null) { if ((permissions & SharedAccessBlobPermissions.List) == SharedAccessBlobPermissions.List) { await container.ListBlobsSegmentedAsync(null); } else { await TestHelper.ExpectedExceptionAsync( async() => await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.None, null, null, null, operationContext), operationContext, "List blobs while SAS does not allow for listing", HttpStatusCode.NotFound); } } if ((permissions & SharedAccessBlobPermissions.Read) == SharedAccessBlobPermissions.Read) { await blob.FetchAttributesAsync(); // 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 { await TestHelper.ExpectedExceptionAsync( async() => await blob.FetchAttributesAsync(null, null, operationContext), operationContext, "Fetch blob attributes while SAS does not allow for reading", HttpStatusCode.NotFound); } if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write) { await blob.SetMetadataAsync(); } else { await TestHelper.ExpectedExceptionAsync( async() => await blob.SetMetadataAsync(null, null, operationContext), operationContext, "Set blob metadata while SAS does not allow for writing", HttpStatusCode.NotFound); } if ((permissions & SharedAccessBlobPermissions.Delete) == SharedAccessBlobPermissions.Delete) { await blob.DeleteAsync(); } else { await TestHelper.ExpectedExceptionAsync( async() => await blob.DeleteAsync(DeleteSnapshotsOption.None, null, null, operationContext), operationContext, "Delete blob while SAS does not allow for deleting", HttpStatusCode.NotFound); } }
public void UseTransactionalMD5PutTestAPM() { BlobRequestOptions optionsWithNoMD5 = new BlobRequestOptions() { UseTransactionalMD5 = false, }; BlobRequestOptions optionsWithMD5 = new BlobRequestOptions() { UseTransactionalMD5 = true, }; byte[] buffer = GetRandomBuffer(1024); MD5 hasher = MD5.Create(); string md5 = Convert.ToBase64String(hasher.ComputeHash(buffer)); string lastCheckMD5 = null; int checkCount = 0; OperationContext opContextWithMD5Check = new OperationContext(); opContextWithMD5Check.SendingRequest += (_, args) => { if (args.Request.ContentLength >= buffer.Length) { lastCheckMD5 = args.Request.Headers[HttpRequestHeader.ContentMd5]; checkCount++; } }; CloudBlobContainer container = GetRandomContainerReference(); try { container.Create(); using (AutoResetEvent waitHandle = new AutoResetEvent(false)) { IAsyncResult result; CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1"); List <string> blockIds = GetBlockIdList(3); checkCount = 0; using (Stream blockData = new MemoryStream(buffer)) { result = blockBlob.BeginPutBlock(blockIds[0], blockData, null, null, optionsWithNoMD5, opContextWithMD5Check, ar => waitHandle.Set(), null); waitHandle.WaitOne(); blockBlob.EndPutBlock(result); Assert.IsNull(lastCheckMD5); blockData.Seek(0, SeekOrigin.Begin); result = blockBlob.BeginPutBlock(blockIds[1], blockData, null, null, optionsWithMD5, opContextWithMD5Check, ar => waitHandle.Set(), null); waitHandle.WaitOne(); blockBlob.EndPutBlock(result); Assert.AreEqual(md5, lastCheckMD5); blockData.Seek(0, SeekOrigin.Begin); result = blockBlob.BeginPutBlock(blockIds[2], blockData, md5, null, optionsWithNoMD5, opContextWithMD5Check, ar => waitHandle.Set(), null); waitHandle.WaitOne(); blockBlob.EndPutBlock(result); Assert.AreEqual(md5, lastCheckMD5); } Assert.AreEqual(3, checkCount); CloudPageBlob pageBlob = container.GetPageBlobReference("blob2"); pageBlob.Create(buffer.Length); checkCount = 0; using (Stream pageData = new MemoryStream(buffer)) { result = pageBlob.BeginWritePages(pageData, 0, null, null, optionsWithNoMD5, opContextWithMD5Check, ar => waitHandle.Set(), null); waitHandle.WaitOne(); pageBlob.EndWritePages(result); Assert.IsNull(lastCheckMD5); pageData.Seek(0, SeekOrigin.Begin); result = pageBlob.BeginWritePages(pageData, 0, null, null, optionsWithMD5, opContextWithMD5Check, ar => waitHandle.Set(), null); waitHandle.WaitOne(); pageBlob.EndWritePages(result); Assert.AreEqual(md5, lastCheckMD5); pageData.Seek(0, SeekOrigin.Begin); result = pageBlob.BeginWritePages(pageData, 0, md5, null, optionsWithNoMD5, opContextWithMD5Check, ar => waitHandle.Set(), null); waitHandle.WaitOne(); pageBlob.EndWritePages(result); Assert.AreEqual(md5, lastCheckMD5); } Assert.AreEqual(3, checkCount); } } finally { container.DeleteIfExists(); } }
private async Task CloudPageBlobUploadFromStreamAsync(CloudBlobContainer container, int size, AccessCondition accessCondition, OperationContext operationContext, int startOffset) { byte[] buffer = GetRandomBuffer(size); CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash(); hasher.Append(buffer.AsBuffer(startOffset, buffer.Length - startOffset)); string md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset()); CloudPageBlob blob = container.GetPageBlobReference("blob1"); blob.StreamWriteSizeInBytes = 512; 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() { StoreBlobContentMD5 = true, }; await blob.UploadFromStreamAsync(sourceStream.AsInputStream(), accessCondition, options, operationContext); } await blob.FetchAttributesAsync(); Assert.AreEqual(md5, blob.Properties.ContentMD5); using (MemoryStream downloadedBlob = new MemoryStream()) { await blob.DownloadToStreamAsync(downloadedBlob.AsOutputStream()); TestHelper.AssertStreamsAreEqual(originalBlob, downloadedBlob); } } }
public async Task PageBlobReadLockToETagTestAsync() { byte[] outBuffer = new byte[1 * 1024 * 1024]; byte[] buffer = GetRandomBuffer(2 * outBuffer.Length); CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); blob.StreamMinimumReadSizeInBytes = outBuffer.Length; using (MemoryStream wholeBlob = new MemoryStream(buffer)) { await blob.UploadFromStreamAsync(wholeBlob.AsInputStream()); } OperationContext opContext = new OperationContext(); using (IRandomAccessStreamWithContentType blobStream = await blob.OpenReadAsync(null, null, opContext)) { Stream blobStreamForRead = blobStream.AsStreamForRead(); await blob.SetMetadataAsync(); 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 (IRandomAccessStreamWithContentType blobStream = await blob.OpenReadAsync(null, null, opContext)) { Stream blobStreamForRead = blobStream.AsStreamForRead(); await blob.SetMetadataAsync(); 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); using (IRandomAccessStreamWithContentType blobStream = await blob.OpenReadAsync(accessCondition, null, opContext)) { Stream blobStreamForRead = blobStream.AsStreamForRead(); await blob.SetMetadataAsync(); 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); } } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task DisableContentMD5ValidationTestAsync() { byte[] buffer = new byte[1024]; Random random = new Random(); random.NextBytes(buffer); BlobRequestOptions optionsWithNoMD5 = new BlobRequestOptions() { DisableContentMD5Validation = true, StoreBlobContentMD5 = true, }; BlobRequestOptions optionsWithMD5 = new BlobRequestOptions() { DisableContentMD5Validation = false, StoreBlobContentMD5 = true, }; CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1"); using (Stream stream = new NonSeekableMemoryStream(buffer)) { await blockBlob.UploadFromStreamAsync(stream, null, optionsWithMD5, null); } using (Stream stream = new MemoryStream()) { await blockBlob.DownloadToStreamAsync(stream, null, optionsWithMD5, null); await blockBlob.DownloadToStreamAsync(stream, null, optionsWithNoMD5, null); using (var blobStream = await blockBlob.OpenReadAsync(null, optionsWithMD5, null)) { Stream blobStreamForRead = blobStream; int read; do { read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length); }while (read > 0); } using (var blobStream = await blockBlob.OpenReadAsync(null, optionsWithNoMD5, null)) { Stream blobStreamForRead = blobStream; int read; do { read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length); }while (read > 0); } blockBlob.Properties.ContentMD5 = "MDAwMDAwMDA="; await blockBlob.SetPropertiesAsync(); OperationContext opContext = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async() => await blockBlob.DownloadToStreamAsync(stream, null, optionsWithMD5, opContext), opContext, "Downloading a blob with invalid MD5 should fail", HttpStatusCode.OK); await blockBlob.DownloadToStreamAsync(stream, null, optionsWithNoMD5, null); using (var blobStream = await blockBlob.OpenReadAsync(null, optionsWithMD5, null)) { Stream blobStreamForRead = blobStream; TestHelper.ExpectedException <IOException>( () => { int read; do { read = blobStreamForRead.Read(buffer, 0, buffer.Length); }while (read > 0); }, "Downloading a blob with invalid MD5 should fail"); } using (var blobStream = await blockBlob.OpenReadAsync(null, optionsWithNoMD5, null)) { Stream blobStreamForRead = blobStream; int read; do { read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length); }while (read > 0); } } CloudPageBlob pageBlob = container.GetPageBlobReference("blob2"); using (Stream stream = new MemoryStream(buffer)) { await pageBlob.UploadFromStreamAsync(stream, null, optionsWithMD5, null); } using (Stream stream = new MemoryStream()) { await pageBlob.DownloadToStreamAsync(stream, null, optionsWithMD5, null); await pageBlob.DownloadToStreamAsync(stream, null, optionsWithNoMD5, null); using (var blobStream = await pageBlob.OpenReadAsync(null, optionsWithMD5, null)) { Stream blobStreamForRead = blobStream; int read; do { read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length); }while (read > 0); } using (var blobStream = await pageBlob.OpenReadAsync(null, optionsWithNoMD5, null)) { Stream blobStreamForRead = blobStream; int read; do { read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length); }while (read > 0); } pageBlob.Properties.ContentMD5 = "MDAwMDAwMDA="; await pageBlob.SetPropertiesAsync(); OperationContext opContext = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async() => await pageBlob.DownloadToStreamAsync(stream, null, optionsWithMD5, opContext), opContext, "Downloading a blob with invalid MD5 should fail", HttpStatusCode.OK); await pageBlob.DownloadToStreamAsync(stream, null, optionsWithNoMD5, null); using (var blobStream = await pageBlob.OpenReadAsync(null, optionsWithMD5, null)) { Stream blobStreamForRead = blobStream; TestHelper.ExpectedException <IOException>( () => { int read; do { read = blobStreamForRead.Read(buffer, 0, buffer.Length); }while (read > 0); }, "Downloading a blob with invalid MD5 should fail"); } using (var blobStream = await pageBlob.OpenReadAsync(null, optionsWithNoMD5, null)) { Stream blobStreamForRead = blobStream; int read; do { read = await blobStreamForRead.ReadAsync(buffer, 0, buffer.Length); }while (read > 0); } } } finally { container.DeleteIfExistsAsync().Wait(); } }
public async Task 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 async Task TestAccessAsync(string sasToken, SharedAccessBlobPermissions permissions, CloudBlobContainer container, ICloudBlob blob) { OperationContext operationContext = new OperationContext(); StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ? new StorageCredentials() : new StorageCredentials(sasToken); if (container != null) { container = new CloudBlobContainer(container.Uri, credentials); if (blob.BlobType == BlobType.BlockBlob) { blob = container.GetBlockBlobReference(blob.Name); } else { blob = container.GetPageBlobReference(blob.Name); } } else { if (blob.BlobType == BlobType.BlockBlob) { blob = new CloudBlockBlob(blob.Uri, credentials); } else { blob = new CloudPageBlob(blob.Uri, credentials); } } if (container != null) { if ((permissions & SharedAccessBlobPermissions.List) == SharedAccessBlobPermissions.List) { await container.ListBlobsSegmentedAsync(null); } else { await TestHelper.ExpectedExceptionAsync( async () => await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.None, null, null, null, operationContext), operationContext, "List blobs while SAS does not allow for listing", HttpStatusCode.NotFound); } } if ((permissions & SharedAccessBlobPermissions.Read) == SharedAccessBlobPermissions.Read) { await blob.FetchAttributesAsync(); } else { await TestHelper.ExpectedExceptionAsync( async () => await blob.FetchAttributesAsync(null, null, operationContext), operationContext, "Fetch blob attributes while SAS does not allow for reading", HttpStatusCode.NotFound); } if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write) { await blob.SetMetadataAsync(); } else { await TestHelper.ExpectedExceptionAsync( async () => await blob.SetMetadataAsync(null, null, operationContext), operationContext, "Set blob metadata while SAS does not allow for writing", HttpStatusCode.NotFound); } if ((permissions & SharedAccessBlobPermissions.Delete) == SharedAccessBlobPermissions.Delete) { await blob.DeleteAsync(); } else { await TestHelper.ExpectedExceptionAsync( async () => await blob.DeleteAsync(DeleteSnapshotsOption.None, null, null, operationContext), operationContext, "Delete blob while SAS does not allow for deleting", HttpStatusCode.NotFound); } }
public async Task CloudBlobClientMaximumExecutionTimeoutAsync() { CloudBlobClient blobClient = GenerateCloudBlobClient(); CloudBlobContainer container = blobClient.GetContainerReference(Guid.NewGuid().ToString("N")); byte[] buffer = BlobTestBase.GetRandomBuffer(80 * 1024 * 1024); try { await container.CreateAsync(); blobClient.DefaultRequestOptions.MaximumExecutionTime = TimeSpan.FromSeconds(5); blobClient.DefaultRequestOptions.SingleBlobUploadThresholdInBytes = 2 * 1024 * 1024; CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1"); blockBlob.StreamWriteSizeInBytes = 1 * 1024 * 1024; using (MemoryStream ms = new MemoryStream(buffer)) { try { await blockBlob.UploadFromStreamAsync(ms); Assert.Fail(); } catch (AggregateException ex) { #if !FACADE_NETCORE Assert.AreEqual("The client could not finish the operation within specified timeout.", RequestResult.TranslateFromExceptionMessage(ex.InnerException.Message).ExceptionInfo.Message); #else Assert.AreEqual("The client could not finish the operation within specified timeout.", RequestResult.TranslateFromExceptionMessage(ex.InnerException.Message).Exception.Message); #endif } catch (TaskCanceledException) { } } CloudPageBlob pageBlob = container.GetPageBlobReference("blob2"); pageBlob.StreamWriteSizeInBytes = 1 * 1024 * 1024; using (MemoryStream ms = new MemoryStream(buffer)) { try { await pageBlob.UploadFromStreamAsync(ms); Assert.Fail(); } catch (AggregateException ex) { #if !FACADE_NETCORE Assert.AreEqual("The client could not finish the operation within specified timeout.", RequestResult.TranslateFromExceptionMessage(ex.InnerException.Message).ExceptionInfo.Message); #else Assert.AreEqual("The client could not finish the operation within specified timeout.", RequestResult.TranslateFromExceptionMessage(ex.InnerException.Message).Exception.Message); #endif } catch (TaskCanceledException) { } } } finally { blobClient.DefaultRequestOptions.MaximumExecutionTime = null; container.DeleteIfExistsAsync().Wait(); } }
private static async Task TestAccessAsync(string sasToken, SharedAccessBlobPermissions permissions, SharedAccessBlobHeaders headers, CloudBlobContainer container, CloudBlob blob) { OperationContext operationContext = new OperationContext(); StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ? new StorageCredentials() : new StorageCredentials(sasToken); if (container != null) { container = new CloudBlobContainer(container.Uri, credentials); if (blob.BlobType == BlobType.BlockBlob) { blob = container.GetBlockBlobReference(blob.Name); } else { blob = container.GetPageBlobReference(blob.Name); } } else { if (blob.BlobType == BlobType.BlockBlob) { blob = new CloudBlockBlob(blob.Uri, credentials); } else { blob = new CloudPageBlob(blob.Uri, credentials); } } if (container != null) { if ((permissions & SharedAccessBlobPermissions.List) == SharedAccessBlobPermissions.List) { await container.ListBlobsSegmentedAsync(null); } else { await TestHelper.ExpectedExceptionAsync( async () => await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.None, null, null, null, operationContext), operationContext, "List blobs while SAS does not allow for listing", HttpStatusCode.Forbidden); } } if ((permissions & SharedAccessBlobPermissions.Read) == SharedAccessBlobPermissions.Read) { await blob.FetchAttributesAsync(); // 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 { await TestHelper.ExpectedExceptionAsync( async () => await blob.FetchAttributesAsync(null, null, operationContext), operationContext, "Fetch blob attributes while SAS does not allow for reading", HttpStatusCode.Forbidden); } if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write) { await blob.SetMetadataAsync(); } else { await TestHelper.ExpectedExceptionAsync( async () => await blob.SetMetadataAsync(null, null, operationContext), operationContext, "Set blob metadata while SAS does not allow for writing", HttpStatusCode.Forbidden); } if ((permissions & SharedAccessBlobPermissions.Delete) == SharedAccessBlobPermissions.Delete) { await blob.DeleteAsync(); } else { await TestHelper.ExpectedExceptionAsync( async () => await blob.DeleteAsync(DeleteSnapshotsOption.None, null, null, operationContext), operationContext, "Delete blob while SAS does not allow for deleting", HttpStatusCode.Forbidden); } }
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 void CloudPageBlobUploadFromStream(CloudBlobContainer container, int size, long? copyLength, AccessCondition accessCondition, 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)); } CloudPageBlob blob = container.GetPageBlobReference("blob1"); blob.StreamWriteSizeInBytes = 512; 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() { 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 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, copyLength.HasValue ? (int)copyLength : (int)originalBlob.Length); } } }
public async Task CloudPageBlobCopyFromSnapshotTestAsync() { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob source = container.GetPageBlobReference("source"); string data = new string('a', 512); await UploadTextAsync(source, data, Encoding.UTF8); source.Metadata["Test"] = "value"; await source.SetMetadataAsync(); CloudPageBlob snapshot = await source.CreateSnapshotAsync(); //Modify source string newData = new string('b', 512); source.Metadata["Test"] = "newvalue"; await source.SetMetadataAsync(); source.Properties.ContentMD5 = null; await UploadTextAsync(source, newData, Encoding.UTF8); Assert.AreEqual(newData, await DownloadTextAsync(source, Encoding.UTF8), "Source is modified correctly"); Assert.AreEqual(data, await DownloadTextAsync(snapshot, Encoding.UTF8), "Modifying source blob should not modify snapshot"); await source.FetchAttributesAsync(); await snapshot.FetchAttributesAsync(); Assert.AreNotEqual(source.Metadata["Test"], snapshot.Metadata["Test"], "Source and snapshot metadata should be independent"); CloudPageBlob copy = container.GetPageBlobReference("copy"); await copy.StartCopyFromBlobAsync(TestHelper.Defiddler(snapshot)); await WaitForCopyAsync(copy); Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status); Assert.AreEqual(data, await DownloadTextAsync(copy, Encoding.UTF8), "Data inside copy of blob not similar"); await copy.FetchAttributesAsync(); BlobProperties prop1 = copy.Properties; BlobProperties prop2 = snapshot.Properties; Assert.AreEqual(prop1.CacheControl, prop2.CacheControl); Assert.AreEqual(prop1.ContentDisposition, prop2.ContentDisposition); Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding); Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage); Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5); Assert.AreEqual(prop1.ContentType, prop2.ContentType); Assert.AreEqual("value", copy.Metadata["Test"], false, "Copied metadata not same"); await copy.DeleteAsync(); } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
private void CloudPageBlobUploadFromStreamTask(CloudBlobContainer container, int size, long? copyLength, AccessCondition accessCondition, int startOffset, bool testMd5) { try { 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)); } CloudPageBlob blob = container.GetPageBlobReference("blob1"); blob.StreamWriteSizeInBytes = 512; 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() { StoreBlobContentMD5 = true, }; if (copyLength.HasValue) { blob.UploadFromStreamAsync(sourceStream, copyLength.Value, accessCondition, options, null).Wait(); } else { blob.UploadFromStreamAsync(sourceStream, accessCondition, options, null).Wait(); } } blob.FetchAttributesAsync().Wait(); if (testMd5) { Assert.AreEqual(md5, blob.Properties.ContentMD5); } using (MemoryStream downloadedBlob = new MemoryStream()) { blob.DownloadToStreamAsync(downloadedBlob).Wait(); TestHelper.AssertStreamsAreEqualAtIndex( originalBlob, downloadedBlob, 0, 0, copyLength.HasValue ? (int)copyLength : (int)originalBlob.Length); } } } catch (AggregateException ex) { throw ex.InnerException; } }
public void CloudBlobContainerGetBlobReferenceFromServerAPM() { CloudBlobContainer container = GetRandomContainerReference(); try { container.Create(); 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); using (AutoResetEvent waitHandle = new AutoResetEvent(false)) { IAsyncResult result = container.BeginGetBlobReferenceFromServer("bb", ar => waitHandle.Set(), null); waitHandle.WaitOne(); ICloudBlob blob1 = container.EndGetBlobReferenceFromServer(result); Assert.IsInstanceOfType(blob1, typeof(CloudBlockBlob)); result = ((CloudBlockBlob)blob1).BeginCreateSnapshot( ar => waitHandle.Set(), null); waitHandle.WaitOne(); CloudBlockBlob blob1Snapshot = ((CloudBlockBlob)blob1).EndCreateSnapshot(result); result = blob1.BeginSetProperties( ar => waitHandle.Set(), null); waitHandle.WaitOne(); blob1.EndSetProperties(result); Uri blob1SnapshotUri = new Uri(blob1Snapshot.Uri.AbsoluteUri + "?snapshot=" + blob1Snapshot.SnapshotTime.Value.UtcDateTime.ToString("o")); result = container.ServiceClient.BeginGetBlobReferenceFromServer(blob1SnapshotUri, ar => waitHandle.Set(), null); waitHandle.WaitOne(); ICloudBlob blob1SnapshotReference = container.ServiceClient.EndGetBlobReferenceFromServer(result); AssertAreEqual(blob1Snapshot.Properties, blob1SnapshotReference.Properties); result = container.BeginGetBlobReferenceFromServer("pb", ar => waitHandle.Set(), null); waitHandle.WaitOne(); ICloudBlob blob2 = container.EndGetBlobReferenceFromServer(result); Assert.IsInstanceOfType(blob2, typeof(CloudPageBlob)); result = ((CloudPageBlob)blob2).BeginCreateSnapshot( ar => waitHandle.Set(), null); waitHandle.WaitOne(); CloudPageBlob blob2Snapshot = ((CloudPageBlob)blob2).EndCreateSnapshot(result); result = blob2.BeginSetProperties( ar => waitHandle.Set(), null); waitHandle.WaitOne(); blob2.EndSetProperties(result); Uri blob2SnapshotUri = new Uri(blob2Snapshot.Uri.AbsoluteUri + "?snapshot=" + blob2Snapshot.SnapshotTime.Value.UtcDateTime.ToString("o")); result = container.ServiceClient.BeginGetBlobReferenceFromServer(blob2SnapshotUri, ar => waitHandle.Set(), null); waitHandle.WaitOne(); ICloudBlob blob2SnapshotReference = container.ServiceClient.EndGetBlobReferenceFromServer(result); AssertAreEqual(blob2Snapshot.Properties, blob2SnapshotReference.Properties); result = container.ServiceClient.BeginGetBlobReferenceFromServer(blockBlob.Uri, ar => waitHandle.Set(), null); waitHandle.WaitOne(); ICloudBlob blob3 = container.ServiceClient.EndGetBlobReferenceFromServer(result); Assert.IsInstanceOfType(blob3, typeof(CloudBlockBlob)); result = container.ServiceClient.BeginGetBlobReferenceFromServer(pageBlob.Uri, ar => waitHandle.Set(), null); waitHandle.WaitOne(); ICloudBlob blob4 = container.ServiceClient.EndGetBlobReferenceFromServer(result); Assert.IsInstanceOfType(blob4, typeof(CloudPageBlob)); string blockBlobToken = blockBlob.GetSharedAccessSignature(policy); StorageCredentials blockBlobSAS = new StorageCredentials(blockBlobToken); Uri blockBlobSASUri = blockBlobSAS.TransformUri(blockBlob.Uri); string pageBlobToken = pageBlob.GetSharedAccessSignature(policy); StorageCredentials pageBlobSAS = new StorageCredentials(pageBlobToken); Uri pageBlobSASUri = pageBlobSAS.TransformUri(pageBlob.Uri); result = container.ServiceClient.BeginGetBlobReferenceFromServer(blockBlobSASUri, ar => waitHandle.Set(), null); waitHandle.WaitOne(); ICloudBlob blob5 = container.ServiceClient.EndGetBlobReferenceFromServer(result); Assert.IsInstanceOfType(blob5, typeof(CloudBlockBlob)); result = container.ServiceClient.BeginGetBlobReferenceFromServer(pageBlobSASUri, ar => waitHandle.Set(), null); waitHandle.WaitOne(); ICloudBlob blob6 = container.ServiceClient.EndGetBlobReferenceFromServer(result); Assert.IsInstanceOfType(blob6, typeof(CloudPageBlob)); CloudBlobClient client7 = new CloudBlobClient(container.ServiceClient.BaseUri, blockBlobSAS); result = client7.BeginGetBlobReferenceFromServer(blockBlobSASUri, ar => waitHandle.Set(), null); waitHandle.WaitOne(); ICloudBlob blob7 = client7.EndGetBlobReferenceFromServer(result); Assert.IsInstanceOfType(blob7, typeof(CloudBlockBlob)); CloudBlobClient client8 = new CloudBlobClient(container.ServiceClient.BaseUri, pageBlobSAS); result = client8.BeginGetBlobReferenceFromServer(pageBlobSASUri, ar => waitHandle.Set(), null); waitHandle.WaitOne(); ICloudBlob blob8 = client8.EndGetBlobReferenceFromServer(result); Assert.IsInstanceOfType(blob8, typeof(CloudPageBlob)); } } finally { container.DeleteIfExists(); } }
public async Task PageBlobWriteStreamBasicTestAsync() { byte[] buffer = GetRandomBuffer(6 * 512); CloudBlobContainer container = GetRandomContainerReference(); container.ServiceClient.ParallelOperationThreadCount = 2; try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); blob.StreamWriteSizeInBytes = 8 * 512; using (MemoryStream wholeBlob = new MemoryStream()) { using (Stream writeStream = await blob.OpenWriteAsync(buffer.Length * 3)) { 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); } using (Stream writeStream = await blob.OpenWriteAsync(null)) { Stream blobStream = writeStream; blobStream.Seek(buffer.Length / 2, SeekOrigin.Begin); wholeBlob.Seek(buffer.Length / 2, SeekOrigin.Begin); for (int i = 0; i < 2; i++) { blobStream.Write(buffer, 0, buffer.Length); wholeBlob.Write(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(); } }