Lease client updates itself (Azure#20513)

jaschrep-msft · web-flow · commit de1abf5f50a3 · 2021-04-20T15:22:34.000-07:00
* Lease client updates itself

Lease client now retains the latest leaseID response as it's internal
property for the lease ID.

* Datalake tests for lease client changes

* Volatile lease id

* Volatile fix

Co-authored-by: jschrepp-MSFT &lt;41338290+jschrepp-MSFT@users.noreply.github.com&gt;
diff --git a/sdk/storage/Azure.Storage.Blobs/src/BlobLeaseClient.cs b/sdk/storage/Azure.Storage.Blobs/src/BlobLeaseClient.cs
@@ -44,10 +44,15 @@ public class BlobLeaseClient
         /// </summary>
         public Uri Uri => BlobClient?.Uri ?? BlobContainerClient?.Uri;
 
+        private string _leaseId;
         /// <summary>
         /// Gets the Lease ID for this lease.
         /// </summary>
-        public virtual string LeaseId { get; private set; }
+        public virtual string LeaseId
+        {
+            get => Volatile.Read(ref _leaseId);
+            private set => Volatile.Write(ref _leaseId, value);
+        }
 
         /// <summary>
         /// The <see cref="HttpPipeline"/> transport pipeline used to send
@@ -299,13 +304,14 @@ private async Task<Response<BlobLease>> AcquireInternal(
                         tagCondition = leaseConditions?.TagConditions;
                     }
 
+                    Response<BlobLease> response;
                     if (BlobClient != null)
                     {
-                        ResponseWithHeaders<BlobAcquireLeaseHeaders> response;
+                        ResponseWithHeaders<BlobAcquireLeaseHeaders> blobClientResponse;
 
                         if (async)
                         {
-                            response = await BlobClient.BlobRestClient.AcquireLeaseAsync(
+                            blobClientResponse = await BlobClient.BlobRestClient.AcquireLeaseAsync(
                                 duration: serviceDuration,
                                 proposedLeaseId: LeaseId,
                                 ifModifiedSince: conditions?.IfModifiedSince,
@@ -318,7 +324,7 @@ private async Task<Response<BlobLease>> AcquireInternal(
                         }
                         else
                         {
-                            response = BlobClient.BlobRestClient.AcquireLease(
+                            blobClientResponse = BlobClient.BlobRestClient.AcquireLease(
                                 duration: serviceDuration,
                                 proposedLeaseId: LeaseId,
                                 ifModifiedSince: conditions?.IfModifiedSince,
@@ -329,9 +335,9 @@ private async Task<Response<BlobLease>> AcquireInternal(
                                 cancellationToken: cancellationToken);
                         }
 
-                        return Response.FromValue(
-                            response.ToBlobLease(),
-                            response.GetRawResponse());
+                        response = Response.FromValue(
+                            blobClientResponse.ToBlobLease(),
+                            blobClientResponse.GetRawResponse());
                     }
                     else
                     {
@@ -342,11 +348,11 @@ private async Task<Response<BlobLease>> AcquireInternal(
                                 nameof(conditions.IfNoneMatch));
                         }
 
-                        ResponseWithHeaders<ContainerAcquireLeaseHeaders> response;
+                        ResponseWithHeaders<ContainerAcquireLeaseHeaders> containerClientResponse;
 
                         if (async)
                         {
-                            response = await BlobContainerClient.ContainerRestClient.AcquireLeaseAsync(
+                            containerClientResponse = await BlobContainerClient.ContainerRestClient.AcquireLeaseAsync(
                                 duration: serviceDuration,
                                 proposedLeaseId: LeaseId,
                                 ifModifiedSince: conditions?.IfModifiedSince,
@@ -356,18 +362,20 @@ private async Task<Response<BlobLease>> AcquireInternal(
                         }
                         else
                         {
-                            response = BlobContainerClient.ContainerRestClient.AcquireLease(
+                            containerClientResponse = BlobContainerClient.ContainerRestClient.AcquireLease(
                                 duration: serviceDuration,
                                 proposedLeaseId: LeaseId,
                                 ifModifiedSince: conditions?.IfModifiedSince,
                                 ifUnmodifiedSince: conditions?.IfUnmodifiedSince,
                                 cancellationToken: cancellationToken);
                         }
 
-                        return Response.FromValue(
-                            response.ToBlobLease(),
-                            response.GetRawResponse());
+                        response = Response.FromValue(
+                            containerClientResponse.ToBlobLease(),
+                            containerClientResponse.GetRawResponse());
                     }
+                    LeaseId = response.Value.LeaseId;
+                    return response;
                 }
                 catch (Exception ex)
                 {
@@ -518,13 +526,14 @@ private async Task<Response<BlobLease>> RenewInternal(
                         tagConditions = ((BlobLeaseRequestConditions)conditions).TagConditions;
                     }
 
+                    Response<BlobLease> response;
                     if (BlobClient != null)
                     {
-                        ResponseWithHeaders<BlobRenewLeaseHeaders> response;
+                        ResponseWithHeaders<BlobRenewLeaseHeaders> blobClientResponse;
 
                         if (async)
                         {
-                            response = await BlobClient.BlobRestClient.RenewLeaseAsync(
+                            blobClientResponse = await BlobClient.BlobRestClient.RenewLeaseAsync(
                                 leaseId: LeaseId,
                                 ifModifiedSince: conditions?.IfModifiedSince,
                                 ifUnmodifiedSince: conditions?.IfUnmodifiedSince,
@@ -536,7 +545,7 @@ private async Task<Response<BlobLease>> RenewInternal(
                         }
                         else
                         {
-                            response = BlobClient.BlobRestClient.RenewLease(
+                            blobClientResponse = BlobClient.BlobRestClient.RenewLease(
                                 leaseId: LeaseId,
                                 ifModifiedSince: conditions?.IfModifiedSince,
                                 ifUnmodifiedSince: conditions?.IfUnmodifiedSince,
@@ -546,9 +555,9 @@ private async Task<Response<BlobLease>> RenewInternal(
                                 cancellationToken: cancellationToken);
                         }
 
-                        return Response.FromValue(
-                            response.ToBlobLease(),
-                            response.GetRawResponse());
+                        response = Response.FromValue(
+                            blobClientResponse.ToBlobLease(),
+                            blobClientResponse.GetRawResponse());
                     }
                     else
                     {
@@ -559,11 +568,11 @@ private async Task<Response<BlobLease>> RenewInternal(
                                 nameof(conditions.IfNoneMatch));
                         }
 
-                        ResponseWithHeaders<ContainerRenewLeaseHeaders> response;
+                        ResponseWithHeaders<ContainerRenewLeaseHeaders> containerClientResponse;
 
                         if (async)
                         {
-                            response = await BlobContainerClient.ContainerRestClient.RenewLeaseAsync(
+                            containerClientResponse = await BlobContainerClient.ContainerRestClient.RenewLeaseAsync(
                                 leaseId: LeaseId,
                                 ifModifiedSince: conditions?.IfModifiedSince,
                                 ifUnmodifiedSince: conditions?.IfUnmodifiedSince,
@@ -572,17 +581,20 @@ private async Task<Response<BlobLease>> RenewInternal(
                         }
                         else
                         {
-                            response = BlobContainerClient.ContainerRestClient.RenewLease(
+                            containerClientResponse = BlobContainerClient.ContainerRestClient.RenewLease(
                                 leaseId: LeaseId,
                                 ifModifiedSince: conditions?.IfModifiedSince,
                                 ifUnmodifiedSince: conditions?.IfUnmodifiedSince,
                                 cancellationToken: cancellationToken);
                         }
 
-                        return Response.FromValue(
-                            response.ToBlobLease(),
-                            response.GetRawResponse());
+                        response = Response.FromValue(
+                            containerClientResponse.ToBlobLease(),
+                            containerClientResponse.GetRawResponse());
                     }
+
+                    LeaseId = response.Value.LeaseId;
+                    return response;
                 }
                 catch (Exception ex)
                 {
@@ -960,13 +972,14 @@ private async Task<Response<BlobLease>> ChangeInternal(
                         tagCondition = ((BlobLeaseRequestConditions)conditions).TagConditions;
                     }
 
+                    Response<BlobLease> response;
                     if (BlobClient != null)
                     {
-                        ResponseWithHeaders<BlobChangeLeaseHeaders> response;
+                        ResponseWithHeaders<BlobChangeLeaseHeaders> blobClientResponse;
 
                         if (async)
                         {
-                            response = await BlobClient.BlobRestClient.ChangeLeaseAsync(
+                            blobClientResponse = await BlobClient.BlobRestClient.ChangeLeaseAsync(
                                 leaseId: LeaseId,
                                 proposedLeaseId: proposedId,
                                 ifModifiedSince: conditions?.IfModifiedSince,
@@ -979,7 +992,7 @@ private async Task<Response<BlobLease>> ChangeInternal(
                         }
                         else
                         {
-                            response = BlobClient.BlobRestClient.ChangeLease(
+                            blobClientResponse = BlobClient.BlobRestClient.ChangeLease(
                                 leaseId: LeaseId,
                                 proposedLeaseId: proposedId,
                                 ifModifiedSince: conditions?.IfModifiedSince,
@@ -990,9 +1003,9 @@ private async Task<Response<BlobLease>> ChangeInternal(
                                 cancellationToken: cancellationToken);
                         }
 
-                        return Response.FromValue(
-                            response.ToBlobLease(),
-                            response.GetRawResponse());
+                        response = Response.FromValue(
+                            blobClientResponse.ToBlobLease(),
+                            blobClientResponse.GetRawResponse());
                     }
                     else
                     {
@@ -1003,11 +1016,11 @@ private async Task<Response<BlobLease>> ChangeInternal(
                                 nameof(conditions.IfNoneMatch));
                         }
 
-                        ResponseWithHeaders<ContainerChangeLeaseHeaders> response;
+                        ResponseWithHeaders<ContainerChangeLeaseHeaders> containerClientResponse;
 
                         if (async)
                         {
-                            response = await BlobContainerClient.ContainerRestClient.ChangeLeaseAsync(
+                            containerClientResponse = await BlobContainerClient.ContainerRestClient.ChangeLeaseAsync(
                                 leaseId: LeaseId,
                                 proposedLeaseId: proposedId,
                                 ifModifiedSince: conditions?.IfModifiedSince,
@@ -1017,18 +1030,21 @@ private async Task<Response<BlobLease>> ChangeInternal(
                         }
                         else
                         {
-                            response = BlobContainerClient.ContainerRestClient.ChangeLease(
+                            containerClientResponse = BlobContainerClient.ContainerRestClient.ChangeLease(
                                 leaseId: LeaseId,
                                 proposedLeaseId: proposedId,
                                 ifModifiedSince: conditions?.IfModifiedSince,
                                 ifUnmodifiedSince: conditions?.IfUnmodifiedSince,
                                 cancellationToken: cancellationToken);
                         }
 
-                        return Response.FromValue(
-                            response.ToBlobLease(),
-                            response.GetRawResponse());
+                        response = Response.FromValue(
+                            containerClientResponse.ToBlobLease(),
+                            containerClientResponse.GetRawResponse());
                     }
+
+                    LeaseId = response.Value.LeaseId;
+                    return response;
                 }
                 catch (Exception ex)
                 {
diff --git a/sdk/storage/Azure.Storage.Blobs/tests/BlobBaseClientTests.cs b/sdk/storage/Azure.Storage.Blobs/tests/BlobBaseClientTests.cs
@@ -4982,12 +4982,14 @@ public async Task AcquireLeaseAsync()
 
             var leaseId = Recording.Random.NewGuid().ToString();
             var duration = TimeSpan.FromSeconds(15);
+            var leaseClient = InstrumentClient(blob.GetBlobLeaseClient(leaseId));
 
             // Act
-            Response<BlobLease> response = await InstrumentClient(blob.GetBlobLeaseClient(leaseId)).AcquireAsync(duration);
+            Response<BlobLease> response = await leaseClient.AcquireAsync(duration);
 
             // Assert
             Assert.IsNotNull(response.GetRawResponse().Headers.RequestId);
+            Assert.AreEqual(response.Value.LeaseId, leaseClient.LeaseId);
         }
 
         [RecordedTest]
@@ -5147,6 +5149,7 @@ public async Task RenewLeaseAsync()
 
             // Assert
             Assert.IsNotNull(response.GetRawResponse().Headers.RequestId);
+            Assert.AreEqual(response.Value.LeaseId, lease.LeaseId);
         }
 
         [RecordedTest]
@@ -5591,6 +5594,8 @@ public async Task ChangeLeaseAsync()
 
             // Assert
             Assert.IsNotNull(response.GetRawResponse().Headers.RequestId);
+            Assert.AreEqual(newLeaseId, response.Value.LeaseId);
+            Assert.AreEqual(response.Value.LeaseId, lease.LeaseId);
         }
 
         [RecordedTest]
diff --git a/sdk/storage/Azure.Storage.Blobs/tests/ContainerClientTests.cs b/sdk/storage/Azure.Storage.Blobs/tests/ContainerClientTests.cs
@@ -1288,12 +1288,14 @@ public async Task AcquireLeaseAsync()
             await container.CreateIfNotExistsAsync();
             var id = Recording.Random.NewGuid().ToString();
             var duration = TimeSpan.FromSeconds(15);
+            var leaseClient = InstrumentClient(container.GetBlobLeaseClient(id));
 
             // Act
-            Response<BlobLease> response = await InstrumentClient(container.GetBlobLeaseClient(id)).AcquireAsync(duration: duration);
+            Response<BlobLease> response = await leaseClient.AcquireAsync(duration: duration);
 
             // Assert
             Assert.AreEqual(id, response.Value.LeaseId);
+            Assert.AreEqual(response.Value.LeaseId, leaseClient.LeaseId);
 
             // Cleanup
             await container.DeleteIfExistsAsync(conditions: new BlobRequestConditions { LeaseId = response.Value.LeaseId });
@@ -1394,15 +1396,16 @@ public async Task RenewLeaseAsync()
 
             var id = Recording.Random.NewGuid().ToString();
             var duration = TimeSpan.FromSeconds(15);
+            var leaseClient = InstrumentClient(container.GetBlobLeaseClient(id));
 
-            Response<BlobLease> leaseResponse = await InstrumentClient(container.GetBlobLeaseClient(id)).AcquireAsync(
-                duration: duration);
+            Response<BlobLease> leaseResponse = await leaseClient.AcquireAsync(duration: duration);
 
             // Act
             Response<BlobLease> renewResponse = await InstrumentClient(container.GetBlobLeaseClient(leaseResponse.Value.LeaseId)).RenewAsync();
 
             // Assert
             Assert.IsNotNull(renewResponse.GetRawResponse().Headers.RequestId);
+            Assert.AreEqual(renewResponse.Value.LeaseId, leaseClient.LeaseId);
 
             // Cleanup
             await container.DeleteIfExistsAsync(conditions: new BlobRequestConditions { LeaseId = renewResponse.Value.LeaseId });
@@ -1679,12 +1682,14 @@ public async Task ChangeLeaseAsync()
             var duration = TimeSpan.FromSeconds(15);
             Response<BlobLease> leaseResponse = await InstrumentClient(test.Container.GetBlobLeaseClient(id)).AcquireAsync(duration);
             var newId = Recording.Random.NewGuid().ToString();
+            var leaseClient = InstrumentClient(test.Container.GetBlobLeaseClient(id));
 
             // Act
-            Response<BlobLease> changeResponse = await InstrumentClient(test.Container.GetBlobLeaseClient(id)).ChangeAsync(newId);
+            Response<BlobLease> changeResponse = await leaseClient.ChangeAsync(newId);
 
             // Assert
             Assert.AreEqual(newId, changeResponse.Value.LeaseId);
+            Assert.AreEqual(changeResponse.Value.LeaseId, leaseClient.LeaseId);
 
             // Cleanup
             await InstrumentClient(test.Container.GetBlobLeaseClient(changeResponse.Value.LeaseId)).ReleaseAsync();
diff --git a/sdk/storage/Azure.Storage.Files.DataLake/tests/FileClientTests.cs b/sdk/storage/Azure.Storage.Files.DataLake/tests/FileClientTests.cs
@@ -2262,12 +2262,14 @@ public async Task AcquireLeaseAsync()
 
             var leaseId = Recording.Random.NewGuid().ToString();
             var duration = TimeSpan.FromSeconds(15);
+            var leaseClient = InstrumentClient(file.GetDataLakeLeaseClient(leaseId));
 
             // Act
-            Response<DataLakeLease> response = await InstrumentClient(file.GetDataLakeLeaseClient(leaseId)).AcquireAsync(duration);
+            Response<DataLakeLease> response = await leaseClient.AcquireAsync(duration);
 
             // Assert
             Assert.IsNotNull(response.GetRawResponse().Headers.RequestId);
+            Assert.AreEqual(response.Value.LeaseId, leaseClient.LeaseId);
         }
 
         [RecordedTest]
@@ -2357,6 +2359,7 @@ public async Task RenewLeaseAsync()
 
             // Assert
             Assert.IsNotNull(response.GetRawResponse().Headers.RequestId);
+            Assert.AreEqual(response.Value.LeaseId, lease.LeaseId);
         }
 
         [RecordedTest]
@@ -2538,6 +2541,7 @@ public async Task ChangeLeaseAsync()
 
             // Assert
             Assert.IsNotNull(response.GetRawResponse().Headers.RequestId);
+            Assert.AreEqual(response.Value.LeaseId, lease.LeaseId);
         }
 
         [RecordedTest]

Original file line number	Diff line number	Diff line change
`@@ -44,10 +44,15 @@ public class BlobLeaseClient`
`44`	`44`	`/// </summary>`
`45`	`45`	`public Uri Uri => BlobClient?.Uri ?? BlobContainerClient?.Uri;`
`46`	`46`
	`47`	`+ private string _leaseId;`
`47`	`48`	`/// <summary>`
`48`	`49`	`/// Gets the Lease ID for this lease.`
`49`	`50`	`/// </summary>`
`50`		`- public virtual string LeaseId { get; private set; }`
	`51`	`+ public virtual string LeaseId`
	`52`	`+ {`
	`53`	`+ get => Volatile.Read(ref _leaseId);`
	`54`	`+ private set => Volatile.Write(ref _leaseId, value);`
	`55`	`+ }`
`51`	`56`
`52`	`57`	`/// <summary>`
`53`	`58`	`/// The <see cref="HttpPipeline"/> transport pipeline used to send`
`@@ -299,13 +304,14 @@ private async Task<Response<BlobLease>> AcquireInternal(`
`299`	`304`	`tagCondition = leaseConditions?.TagConditions;`
`300`	`305`	`}`
`301`	`306`
	`307`	`+ Response<BlobLease> response;`
`302`	`308`	`if (BlobClient != null)`
`303`	`309`	`{`
`304`		`- ResponseWithHeaders<BlobAcquireLeaseHeaders> response;`
	`310`	`+ ResponseWithHeaders<BlobAcquireLeaseHeaders> blobClientResponse;`
`305`	`311`
`306`	`312`	`if (async)`
`307`	`313`	`{`
`308`		`- response = await BlobClient.BlobRestClient.AcquireLeaseAsync(`
	`314`	`+ blobClientResponse = await BlobClient.BlobRestClient.AcquireLeaseAsync(`
`309`	`315`	`duration: serviceDuration,`
`310`	`316`	`proposedLeaseId: LeaseId,`
`311`	`317`	`ifModifiedSince: conditions?.IfModifiedSince,`
`@@ -318,7 +324,7 @@ private async Task<Response<BlobLease>> AcquireInternal(`
`318`	`324`	`}`
`319`	`325`	`else`
`320`	`326`	`{`
`321`		`- response = BlobClient.BlobRestClient.AcquireLease(`
	`327`	`+ blobClientResponse = BlobClient.BlobRestClient.AcquireLease(`
`322`	`328`	`duration: serviceDuration,`
`323`	`329`	`proposedLeaseId: LeaseId,`
`324`	`330`	`ifModifiedSince: conditions?.IfModifiedSince,`
`@@ -329,9 +335,9 @@ private async Task<Response<BlobLease>> AcquireInternal(`
`329`	`335`	`cancellationToken: cancellationToken);`
`330`	`336`	`}`
`331`	`337`
`332`		`- return Response.FromValue(`
`333`		`- response.ToBlobLease(),`
`334`		`- response.GetRawResponse());`
	`338`	`+ response = Response.FromValue(`
	`339`	`+ blobClientResponse.ToBlobLease(),`
	`340`	`+ blobClientResponse.GetRawResponse());`
`335`	`341`	`}`
`336`	`342`	`else`
`337`	`343`	`{`
`@@ -342,11 +348,11 @@ private async Task<Response<BlobLease>> AcquireInternal(`
`342`	`348`	`nameof(conditions.IfNoneMatch));`
`343`	`349`	`}`
`344`	`350`
`345`		`- ResponseWithHeaders<ContainerAcquireLeaseHeaders> response;`
	`351`	`+ ResponseWithHeaders<ContainerAcquireLeaseHeaders> containerClientResponse;`
`346`	`352`
`347`	`353`	`if (async)`
`348`	`354`	`{`
`349`		`- response = await BlobContainerClient.ContainerRestClient.AcquireLeaseAsync(`
	`355`	`+ containerClientResponse = await BlobContainerClient.ContainerRestClient.AcquireLeaseAsync(`
`350`	`356`	`duration: serviceDuration,`
`351`	`357`	`proposedLeaseId: LeaseId,`
`352`	`358`	`ifModifiedSince: conditions?.IfModifiedSince,`
`@@ -356,18 +362,20 @@ private async Task<Response<BlobLease>> AcquireInternal(`
`356`	`362`	`}`
`357`	`363`	`else`
`358`	`364`	`{`
`359`		`- response = BlobContainerClient.ContainerRestClient.AcquireLease(`
	`365`	`+ containerClientResponse = BlobContainerClient.ContainerRestClient.AcquireLease(`
`360`	`366`	`duration: serviceDuration,`
`361`	`367`	`proposedLeaseId: LeaseId,`
`362`	`368`	`ifModifiedSince: conditions?.IfModifiedSince,`
`363`	`369`	`ifUnmodifiedSince: conditions?.IfUnmodifiedSince,`
`364`	`370`	`cancellationToken: cancellationToken);`
`365`	`371`	`}`
`366`	`372`
`367`		`- return Response.FromValue(`
`368`		`- response.ToBlobLease(),`
`369`		`- response.GetRawResponse());`
	`373`	`+ response = Response.FromValue(`
	`374`	`+ containerClientResponse.ToBlobLease(),`
	`375`	`+ containerClientResponse.GetRawResponse());`
`370`	`376`	`}`
	`377`	`+ LeaseId = response.Value.LeaseId;`
	`378`	`+ return response;`
`371`	`379`	`}`
`372`	`380`	`catch (Exception ex)`
`373`	`381`	`{`
`@@ -518,13 +526,14 @@ private async Task<Response<BlobLease>> RenewInternal(`
`518`	`526`	`tagConditions = ((BlobLeaseRequestConditions)conditions).TagConditions;`
`519`	`527`	`}`
`520`	`528`
	`529`	`+ Response<BlobLease> response;`
`521`	`530`	`if (BlobClient != null)`
`522`	`531`	`{`
`523`		`- ResponseWithHeaders<BlobRenewLeaseHeaders> response;`
	`532`	`+ ResponseWithHeaders<BlobRenewLeaseHeaders> blobClientResponse;`
`524`	`533`
`525`	`534`	`if (async)`
`526`	`535`	`{`
`527`		`- response = await BlobClient.BlobRestClient.RenewLeaseAsync(`
	`536`	`+ blobClientResponse = await BlobClient.BlobRestClient.RenewLeaseAsync(`
`528`	`537`	`leaseId: LeaseId,`
`529`	`538`	`ifModifiedSince: conditions?.IfModifiedSince,`
`530`	`539`	`ifUnmodifiedSince: conditions?.IfUnmodifiedSince,`
`@@ -536,7 +545,7 @@ private async Task<Response<BlobLease>> RenewInternal(`
`536`	`545`	`}`
`537`	`546`	`else`
`538`	`547`	`{`
`539`		`- response = BlobClient.BlobRestClient.RenewLease(`
	`548`	`+ blobClientResponse = BlobClient.BlobRestClient.RenewLease(`
`540`	`549`	`leaseId: LeaseId,`
`541`	`550`	`ifModifiedSince: conditions?.IfModifiedSince,`
`542`	`551`	`ifUnmodifiedSince: conditions?.IfUnmodifiedSince,`
`@@ -546,9 +555,9 @@ private async Task<Response<BlobLease>> RenewInternal(`
`546`	`555`	`cancellationToken: cancellationToken);`
`547`	`556`	`}`
`548`	`557`
`549`		`- return Response.FromValue(`
`550`		`- response.ToBlobLease(),`
`551`		`- response.GetRawResponse());`
	`558`	`+ response = Response.FromValue(`
	`559`	`+ blobClientResponse.ToBlobLease(),`
	`560`	`+ blobClientResponse.GetRawResponse());`
`552`	`561`	`}`
`553`	`562`	`else`
`554`	`563`	`{`
`@@ -559,11 +568,11 @@ private async Task<Response<BlobLease>> RenewInternal(`
`559`	`568`	`nameof(conditions.IfNoneMatch));`
`560`	`569`	`}`
`561`	`570`
`562`		`- ResponseWithHeaders<ContainerRenewLeaseHeaders> response;`
	`571`	`+ ResponseWithHeaders<ContainerRenewLeaseHeaders> containerClientResponse;`
`563`	`572`
`564`	`573`	`if (async)`
`565`	`574`	`{`
`566`		`- response = await BlobContainerClient.ContainerRestClient.RenewLeaseAsync(`
	`575`	`+ containerClientResponse = await BlobContainerClient.ContainerRestClient.RenewLeaseAsync(`
`567`	`576`	`leaseId: LeaseId,`
`568`	`577`	`ifModifiedSince: conditions?.IfModifiedSince,`
`569`	`578`	`ifUnmodifiedSince: conditions?.IfUnmodifiedSince,`
`@@ -572,17 +581,20 @@ private async Task<Response<BlobLease>> RenewInternal(`
`572`	`581`	`}`
`573`	`582`	`else`
`574`	`583`	`{`
`575`		`- response = BlobContainerClient.ContainerRestClient.RenewLease(`
	`584`	`+ containerClientResponse = BlobContainerClient.ContainerRestClient.RenewLease(`
`576`	`585`	`leaseId: LeaseId,`
`577`	`586`	`ifModifiedSince: conditions?.IfModifiedSince,`
`578`	`587`	`ifUnmodifiedSince: conditions?.IfUnmodifiedSince,`
`579`	`588`	`cancellationToken: cancellationToken);`
`580`	`589`	`}`
`581`	`590`
`582`		`- return Response.FromValue(`
`583`		`- response.ToBlobLease(),`
`584`		`- response.GetRawResponse());`
	`591`	`+ response = Response.FromValue(`
	`592`	`+ containerClientResponse.ToBlobLease(),`
	`593`	`+ containerClientResponse.GetRawResponse());`
`585`	`594`	`}`
	`595`	`+`
	`596`	`+ LeaseId = response.Value.LeaseId;`
	`597`	`+ return response;`
`586`	`598`	`}`
`587`	`599`	`catch (Exception ex)`
`588`	`600`	`{`
`@@ -960,13 +972,14 @@ private async Task<Response<BlobLease>> ChangeInternal(`
`960`	`972`	`tagCondition = ((BlobLeaseRequestConditions)conditions).TagConditions;`
`961`	`973`	`}`
`962`	`974`
	`975`	`+ Response<BlobLease> response;`
`963`	`976`	`if (BlobClient != null)`
`964`	`977`	`{`
`965`		`- ResponseWithHeaders<BlobChangeLeaseHeaders> response;`
	`978`	`+ ResponseWithHeaders<BlobChangeLeaseHeaders> blobClientResponse;`
`966`	`979`
`967`	`980`	`if (async)`
`968`	`981`	`{`
`969`		`- response = await BlobClient.BlobRestClient.ChangeLeaseAsync(`
	`982`	`+ blobClientResponse = await BlobClient.BlobRestClient.ChangeLeaseAsync(`
`970`	`983`	`leaseId: LeaseId,`
`971`	`984`	`proposedLeaseId: proposedId,`
`972`	`985`	`ifModifiedSince: conditions?.IfModifiedSince,`
`@@ -979,7 +992,7 @@ private async Task<Response<BlobLease>> ChangeInternal(`
`979`	`992`	`}`
`980`	`993`	`else`
`981`	`994`	`{`
`982`		`- response = BlobClient.BlobRestClient.ChangeLease(`
	`995`	`+ blobClientResponse = BlobClient.BlobRestClient.ChangeLease(`
`983`	`996`	`leaseId: LeaseId,`
`984`	`997`	`proposedLeaseId: proposedId,`
`985`	`998`	`ifModifiedSince: conditions?.IfModifiedSince,`
`@@ -990,9 +1003,9 @@ private async Task<Response<BlobLease>> ChangeInternal(`
`990`	`1003`	`cancellationToken: cancellationToken);`
`991`	`1004`	`}`
`992`	`1005`
`993`		`- return Response.FromValue(`
`994`		`- response.ToBlobLease(),`
`995`		`- response.GetRawResponse());`
	`1006`	`+ response = Response.FromValue(`
	`1007`	`+ blobClientResponse.ToBlobLease(),`
	`1008`	`+ blobClientResponse.GetRawResponse());`
`996`	`1009`	`}`
`997`	`1010`	`else`
`998`	`1011`	`{`
`@@ -1003,11 +1016,11 @@ private async Task<Response<BlobLease>> ChangeInternal(`
`1003`	`1016`	`nameof(conditions.IfNoneMatch));`
`1004`	`1017`	`}`
`1005`	`1018`
`1006`		`- ResponseWithHeaders<ContainerChangeLeaseHeaders> response;`
	`1019`	`+ ResponseWithHeaders<ContainerChangeLeaseHeaders> containerClientResponse;`
`1007`	`1020`
`1008`	`1021`	`if (async)`
`1009`	`1022`	`{`
`1010`		`- response = await BlobContainerClient.ContainerRestClient.ChangeLeaseAsync(`
	`1023`	`+ containerClientResponse = await BlobContainerClient.ContainerRestClient.ChangeLeaseAsync(`
`1011`	`1024`	`leaseId: LeaseId,`
`1012`	`1025`	`proposedLeaseId: proposedId,`
`1013`	`1026`	`ifModifiedSince: conditions?.IfModifiedSince,`
`@@ -1017,18 +1030,21 @@ private async Task<Response<BlobLease>> ChangeInternal(`
`1017`	`1030`	`}`
`1018`	`1031`	`else`
`1019`	`1032`	`{`
`1020`		`- response = BlobContainerClient.ContainerRestClient.ChangeLease(`
	`1033`	`+ containerClientResponse = BlobContainerClient.ContainerRestClient.ChangeLease(`
`1021`	`1034`	`leaseId: LeaseId,`
`1022`	`1035`	`proposedLeaseId: proposedId,`
`1023`	`1036`	`ifModifiedSince: conditions?.IfModifiedSince,`
`1024`	`1037`	`ifUnmodifiedSince: conditions?.IfUnmodifiedSince,`
`1025`	`1038`	`cancellationToken: cancellationToken);`
`1026`	`1039`	`}`
`1027`	`1040`
`1028`		`- return Response.FromValue(`
`1029`		`- response.ToBlobLease(),`
`1030`		`- response.GetRawResponse());`
	`1041`	`+ response = Response.FromValue(`
	`1042`	`+ containerClientResponse.ToBlobLease(),`
	`1043`	`+ containerClientResponse.GetRawResponse());`
`1031`	`1044`	`}`
	`1045`	`+`
	`1046`	`+ LeaseId = response.Value.LeaseId;`
	`1047`	`+ return response;`
`1032`	`1048`	`}`
`1033`	`1049`	`catch (Exception ex)`
`1034`	`1050`	`{`