[Storage] OpenWrite - support for metadata, tags and headers

sdk/storage/Azure.Storage.Blobs/api/Azure.Storage.Blobs.netstandard2.0.cs

@@ -910,8 +910,11 @@ public partial class BlockBlobOpenWriteOptions
     {
         public BlockBlobOpenWriteOptions() { }
         public long? BufferSize { get { throw null; } set { } }
+        public Azure.Storage.Blobs.Models.BlobHttpHeaders HttpHeaders { get { throw null; } set { } }
+        public System.Collections.Generic.IDictionary<string, string> Metadata { get { throw null; } set { } }
         public Azure.Storage.Blobs.Models.BlobRequestConditions OpenConditions { get { throw null; } set { } }
         public System.IProgress<long> ProgressHandler { get { throw null; } set { } }
+        public System.Collections.Generic.IDictionary<string, string> Tags { get { throw null; } set { } }
     }
     public partial class BlockInfo
     {

sdk/storage/Azure.Storage.Blobs/src/BlockBlobClient.cs

@@ -2121,9 +2121,9 @@ private async Task<Stream> OpenWriteInternal(
                 // Create Block Blob
                 Response<BlobContentInfo> response = await UploadInternal(
                     content: new MemoryStream(Array.Empty<byte>()),
-                    blobHttpHeaders: default,
-                    metadata: default,
-                    tags: default,
+                    blobHttpHeaders: options?.HttpHeaders,
+                    metadata: options?.Metadata,
+                    tags: options?.Tags,
                     conditions: options?.OpenConditions,
                     accessTier: default,
                     progressHandler: default,
@@ -2143,7 +2143,10 @@ private async Task<Stream> OpenWriteInternal(
                     bufferSize: options?.BufferSize ?? Constants.DefaultBufferSize,
                     position: position,
                     conditions: conditions,
-                    progressHandler: options?.ProgressHandler);
+                    progressHandler: options?.ProgressHandler,
+                    blobHttpHeaders: options?.HttpHeaders,
+                    metadata: options?.Metadata,
+                    tags: options?.Tags);
             }
             catch (Exception ex)
             {

sdk/storage/Azure.Storage.Blobs/src/BlockBlobWriteStream.cs

@@ -17,13 +17,19 @@ internal class BlockBlobWriteStream : StorageWriteStream
         private readonly BlockBlobClient _blockBlobClient;
         private readonly BlobRequestConditions _conditions;
         private readonly List<string> _blockIds;
+        private readonly BlobHttpHeaders _blobHttpHeaders;
+        private readonly IDictionary<string, string> _metadata;
+        private readonly IDictionary<string, string> _tags;
 
         public BlockBlobWriteStream(
             BlockBlobClient blockBlobClient,
             long bufferSize,
             long position,
             BlobRequestConditions conditions,
-            IProgress<long> progressHandler) : base(
+            IProgress<long> progressHandler,
+            BlobHttpHeaders blobHttpHeaders,
+            IDictionary<string, string> metadata,
+            IDictionary<string, string> tags) : base(
                 position,
                 bufferSize,
                 progressHandler)
@@ -32,6 +38,9 @@ public BlockBlobWriteStream(
             _blockBlobClient = blockBlobClient;
             _conditions = conditions ?? new BlobRequestConditions();
             _blockIds = new List<string>();
+            _blobHttpHeaders = blobHttpHeaders;
+            _metadata = metadata;
+            _tags = tags;
         }
 
         protected override async Task AppendInternal(bool async, CancellationToken cancellationToken)
@@ -63,9 +72,9 @@ protected override async Task FlushInternal(bool async, CancellationToken cancel
 
             Response<BlobContentInfo> response = await _blockBlobClient.CommitBlockListInternal(
                 base64BlockIds: _blockIds,
-                blobHttpHeaders: default,
-                metadata: default,
-                tags: default,
+                blobHttpHeaders: _blobHttpHeaders,
+                metadata: _metadata,
+                tags: _tags,
                 conditions: _conditions,
                 accessTier: default,
                 async: async,

sdk/storage/Azure.Storage.Blobs/src/Models/BlockBlobOpenWriteOptions.cs

@@ -3,6 +3,8 @@
 
 using System;
 using Azure.Storage.Blobs.Specialized;
+using Metadata = System.Collections.Generic.IDictionary<string, string>;
+using Tags = System.Collections.Generic.IDictionary<string, string>;
 
 namespace Azure.Storage.Blobs.Models
 {
@@ -27,5 +29,20 @@ public class BlockBlobOpenWriteOptions
         /// progress updates about data transfers.
         /// </summary>
         public IProgress<long> ProgressHandler { get; set; }
+
+        /// <summary>
+        /// Optional standard HTTP header properties that can be set for this block blob.
+        /// </summary>
+        public BlobHttpHeaders HttpHeaders { get; set; }
+
+        /// <summary>
+        /// Optional custom metadata to set for this block blob.
+        /// </summary>
+        public Metadata Metadata { get; set; }
+
+        /// <summary>
+        /// Options tags to set for this block blob.
+        /// </summary>
+        public Tags Tags { get; set; }
     }
 }

sdk/storage/Azure.Storage.Blobs/src/Models/CommitBlockListOptions.cs

@@ -16,12 +16,12 @@ public class CommitBlockListOptions
     {
         /// <summary>
         /// Optional standard HTTP header properties that can be set for the
-        /// new append blob.
+        /// new block blob.
         /// </summary>
         public BlobHttpHeaders HttpHeaders { get; set; }
 
         /// <summary>
-        /// Optional custom metadata to set for this append blob.
+        /// Optional custom metadata to set for this block blob.
         /// </summary>
         public Metadata Metadata { get; set; }
 

sdk/storage/Azure.Storage.Blobs/tests/BlockBlobClientTests.cs

@@ -26,7 +26,7 @@ public class BlockBlobClientTests : BlobTestBase
             ex => ex.Status == 500 && ex.ErrorCode == BlobErrorCode.CannotVerifyCopySource.ToString();
 
         public BlockBlobClientTests(bool async, BlobClientOptions.ServiceVersion serviceVersion)
-            : base(async, serviceVersion, null /* RecordedTestMode.Record /* to re-record */)
+            : base(async, serviceVersion, RecordedTestMode.Record /* RecordedTestMode.Record /* to re-record */)
         {
         }
 
@@ -2299,6 +2299,180 @@ public async Task OpenWriteAsync_NewBlob()
             TestHelper.AssertSequenceEqual(data, dataResult.ToArray());
         }
 
+        [Test]
+        [ServiceVersion(Min = BlobClientOptions.ServiceVersion.V2019_12_12)]
+        public async Task OpenWriteAsync_NewBlob_WithTags()
+        {
+            // Arrange
+            await using DisposingContainer test = await GetTestContainerAsync();
+            BlockBlobClient blob = InstrumentClient(test.Container.GetBlockBlobClient(GetNewBlobName()));
+            await blob.UploadAsync(new MemoryStream(Array.Empty<byte>()));
+
+            Dictionary<string, string> tags = new Dictionary<string, string>() { { "testkey", "testvalue" } };
+
+            BlockBlobOpenWriteOptions options = new BlockBlobOpenWriteOptions
+            {
+                BufferSize = Constants.KB,
+                Tags = tags,
+            };
+
+            Stream stream = await blob.OpenWriteAsync(
+                overwrite: true,
+                options);
+
+            // Act
+            await stream.FlushAsync();
+
+            // Assert
+            GetBlobTagResult tagsResult = await blob.GetTagsAsync();
+            CollectionAssert.AreEqual(tags, tagsResult.Tags);
+        }
+
+        [Test]
+        [ServiceVersion(Min = BlobClientOptions.ServiceVersion.V2019_12_12)]
+        public async Task OpenWriteAsync_CreateEmptyBlob_WithTags()
+        {
+            // Arrange
+            await using DisposingContainer test = await GetTestContainerAsync();
+            BlockBlobClient blob = InstrumentClient(test.Container.GetBlockBlobClient(GetNewBlobName()));
+            await blob.UploadAsync(new MemoryStream(Array.Empty<byte>()));
+
+            Dictionary<string, string> tags = new Dictionary<string, string>() { { "testkey", "testvalue" } };
+
+            BlockBlobOpenWriteOptions options = new BlockBlobOpenWriteOptions
+            {
+                BufferSize = Constants.KB,
+                Tags = tags,
+            };
+
+            // Act
+            Stream stream = await blob.OpenWriteAsync(
+                overwrite: true,
+                options);
+
+            // Assert
+            GetBlobTagResult tagsResult = await blob.GetTagsAsync();
+            CollectionAssert.AreEqual(tags, tagsResult.Tags);
+        }
+
+        [Test]
+        public async Task OpenWriteAsync_NewBlob_WithMetadata()
+        {
+            // Arrange
+            await using DisposingContainer test = await GetTestContainerAsync();
+            BlockBlobClient blob = InstrumentClient(test.Container.GetBlockBlobClient(GetNewBlobName()));
+            await blob.UploadAsync(new MemoryStream(Array.Empty<byte>()));
+
+            Dictionary<string, string> metadata = new Dictionary<string, string>() { { "testkey", "testvalue" } };
+
+            BlockBlobOpenWriteOptions options = new BlockBlobOpenWriteOptions
+            {
+                BufferSize = Constants.KB,
+                Metadata = metadata,
+            };
+
+            Stream stream = await blob.OpenWriteAsync(
+                overwrite: true,
+                options);
+
+            // Act
+            await stream.FlushAsync();
+
+            // Assert
+            BlobProperties properties = await blob.GetPropertiesAsync();
+            CollectionAssert.AreEqual(metadata, properties.Metadata);
+        }
+
+        [Test]
+        public async Task OpenWriteAsync_CreateEmptyBlob_WithMetadata()
+        {
+            // Arrange
+            await using DisposingContainer test = await GetTestContainerAsync();
+            BlockBlobClient blob = InstrumentClient(test.Container.GetBlockBlobClient(GetNewBlobName()));
+            await blob.UploadAsync(new MemoryStream(Array.Empty<byte>()));
+
+            Dictionary<string, string> metadata = new Dictionary<string, string>() { { "testkey", "testvalue" } };
+
+            BlockBlobOpenWriteOptions options = new BlockBlobOpenWriteOptions
+            {
+                BufferSize = Constants.KB,
+                Metadata = metadata,
+            };
+
+            // Act
+            Stream stream = await blob.OpenWriteAsync(
+                overwrite: true,
+                options);
+
+            // Assert
+            BlobProperties properties = await blob.GetPropertiesAsync();
+            CollectionAssert.AreEqual(metadata, properties.Metadata);
+        }
+
+        [Test]
+        public async Task OpenWriteAsync_NewBlob_WithHeaders()
+        {
+            // Arrange
+            await using DisposingContainer test = await GetTestContainerAsync();
+            BlockBlobClient blob = InstrumentClient(test.Container.GetBlockBlobClient(GetNewBlobName()));
+            await blob.UploadAsync(new MemoryStream(Array.Empty<byte>()));
+
+            BlobHttpHeaders headers = new BlobHttpHeaders()
+            {
+                ContentType = "application/json",
+                ContentLanguage = "en",
+            };
+
+            BlockBlobOpenWriteOptions options = new BlockBlobOpenWriteOptions
+            {
+                BufferSize = Constants.KB,
+                HttpHeaders = headers,
+            };
+
+            Stream stream = await blob.OpenWriteAsync(
+                overwrite: true,
+                options);
+
+            // Act
+            await stream.FlushAsync();
+
+            // Assert
+            BlobProperties properties = await blob.GetPropertiesAsync();
+            Assert.AreEqual(headers.ContentType, properties.ContentType);
+            Assert.AreEqual(headers.ContentLanguage, properties.ContentLanguage);
+        }
+
+        [Test]
+        public async Task OpenWriteAsync_CreateEmptyBlob_WithHeaders()
+        {
+            // Arrange
+            await using DisposingContainer test = await GetTestContainerAsync();
+            BlockBlobClient blob = InstrumentClient(test.Container.GetBlockBlobClient(GetNewBlobName()));
+            await blob.UploadAsync(new MemoryStream(Array.Empty<byte>()));
+
+            BlobHttpHeaders headers = new BlobHttpHeaders()
+            {
+                ContentType = "application/json",
+                ContentLanguage = "en",
+            };
+
+            BlockBlobOpenWriteOptions options = new BlockBlobOpenWriteOptions
+            {
+                BufferSize = Constants.KB,
+                HttpHeaders = headers,
+            };
+
+            // Act
+            Stream stream = await blob.OpenWriteAsync(
+                overwrite: true,
+                options);
+
+            // Assert
+            BlobProperties properties = await blob.GetPropertiesAsync();
+            Assert.AreEqual(headers.ContentType, properties.ContentType);
+            Assert.AreEqual(headers.ContentLanguage, properties.ContentLanguage);
+        }
+
         [Test]
         public async Task OpenWriteAsync_NewBlob_WithUsing()
         {