< Summary

Class:Azure.Storage.Files.DataLake.DataLakeLeaseClient
Assembly:Azure.Storage.Files.DataLake
File(s):C:\Git\azure-sdk-for-net\sdk\storage\Azure.Storage.Files.DataLake\src\DataLakeLeaseClient.cs
Covered lines:159
Uncovered lines:2
Coverable lines:161
Total lines:752
Line coverage:98.7% (159 of 161)
Covered branches:0
Total branches:0

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
.cctor()-100%100%
get_Uri()-0%100%
get_LeaseId()-0%100%
get_ClientDiagnostics()-100%100%
.ctor()-100%100%
.ctor(...)-100%100%
.ctor(...)-100%100%
Acquire(...)-100%100%
AcquireAsync()-100%100%
Renew(...)-100%100%
RenewAsync()-100%100%
Release(...)-100%100%
ReleaseAsync()-100%100%
Change(...)-100%100%
ChangeAsync()-100%100%
Break(...)-100%100%
BreakAsync()-100%100%

File(s)

C:\Git\azure-sdk-for-net\sdk\storage\Azure.Storage.Files.DataLake\src\DataLakeLeaseClient.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4using System;
 5using System.Threading;
 6using System.Threading.Tasks;
 7using Azure.Core.Pipeline;
 8using Azure.Storage.Blobs;
 9using Azure.Storage.Blobs.Specialized;
 10using Azure.Storage.Files.DataLake.Models;
 11
 12namespace Azure.Storage.Files.DataLake
 13{
 14    /// <summary>
 15    /// The <see cref="DataLakeLeaseClient"/> allows you to manipulate Azure
 16    /// Storage leases on paths.
 17    /// </summary>
 18    public class DataLakeLeaseClient
 19    {
 20        /// <summary>
 21        /// Blob lease client for managing leases.
 22        /// </summary>
 23        private readonly BlobLeaseClient _blobLeaseClient;
 24
 25        /// <summary>
 26        /// The <see cref="TimeSpan"/> representing an infinite lease duration.
 27        /// </summary>
 228        public static readonly TimeSpan InfiniteLeaseDuration = TimeSpan.FromSeconds(Constants.Blob.Lease.InfiniteLeaseD
 29
 30        /// <summary>
 31        /// Gets the URI of the object being leased.
 32        /// </summary>
 033        public Uri Uri => _blobLeaseClient.Uri;
 34
 35        /// <summary>
 36        /// Gets the Lease ID for this lease.
 37        /// </summary>
 038        public virtual string LeaseId => _blobLeaseClient.LeaseId;
 39
 40        /// <summary>
 41        /// The <see cref="ClientDiagnostics"/> instance used to create diagnostic scopes
 42        /// every request.
 43        /// </summary>
 44        private readonly ClientDiagnostics _clientDiagnostics;
 45
 46        /// <summary>
 47        /// The <see cref="ClientDiagnostics"/> instance used to create diagnostic scopes
 48        /// every request.
 49        /// </summary>
 112050        internal virtual ClientDiagnostics ClientDiagnostics => _clientDiagnostics;
 51
 52        #region ctors
 53        /// <summary>
 54        /// Initializes a new instance of the <see cref="DataLakeLeaseClient"/> class
 55        /// for mocking.
 56        /// </summary>
 76057        protected DataLakeLeaseClient()
 58        {
 76059            _blobLeaseClient = null;
 76060            _clientDiagnostics = null;
 76061        }
 62
 63        /// <summary>
 64        /// Initializes a new instance of the <see cref="DataLakeLeaseClient"/>  class.
 65        /// </summary>
 66        /// <param name="client">
 67        /// A <see cref="BlobClient"/> representing the blob being leased.
 68        /// </param>
 69        /// <param name="leaseId">
 70        /// An optional lease ID.  If no lease ID is provided, a random lease
 71        /// ID will be created.
 72        /// </param>
 54873        public DataLakeLeaseClient(DataLakePathClient client, string leaseId = null)
 74        {
 54875            _blobLeaseClient = new BlobLeaseClient(client.BlobClient, leaseId);
 54876            _clientDiagnostics = client.ClientDiagnostics;
 54877        }
 78
 79        /// <summary>
 80        /// Initializes a new instance of the <see cref="DataLakeLeaseClient"/>  class.
 81        /// </summary>
 82        /// <param name="client">
 83        /// A <see cref="DataLakeFileSystemClient"/> representing the file system
 84        /// being leased.
 85        /// </param>
 86        /// <param name="leaseId">
 87        /// An optional lease ID.  If no lease ID is provided, a random lease
 88        /// ID will be created.
 89        /// </param>
 21290        public DataLakeLeaseClient(DataLakeFileSystemClient client, string leaseId = null)
 91        {
 21292            _blobLeaseClient = new BlobLeaseClient(client.ContainerClient, leaseId);
 21293            _clientDiagnostics = client.ClientDiagnostics;
 21294        }
 95        #endregion ctors
 96
 97        #region Acquire
 98        /// <summary>
 99        /// The <see cref="Acquire"/> operation acquires a lease on
 100        /// the path or file system.  The lease <paramref name="duration"/> must
 101        /// be between 15 to 60 seconds, or infinite (-1).
 102        ///
 103        /// If the file system does not have an active lease, the Data Lake service
 104        /// creates a lease on the path or file system and returns it.  If the
 105        /// file system has an active lease, you can only request a new lease
 106        /// using the active lease ID as <see cref="LeaseId"/>, but you can
 107        /// specify a new <paramref name="duration"/>.
 108        ///
 109        /// For more information, see
 110        /// <see href="https://docs.microsoft.com/rest/api/storageservices/lease-container">
 111        /// Lease Container</see>.
 112        /// </summary>
 113        /// <param name="duration">
 114        /// Specifies the duration of the lease, in seconds, or specify
 115        /// <see cref="InfiniteLeaseDuration"/> for a lease that never expires.
 116        /// A non-infinite lease can be between 15 and 60 seconds.
 117        /// A lease duration cannot be changed using <see cref="RenewAsync"/> or <see cref="ChangeAsync"/>.
 118        /// </param>
 119        /// <param name="conditions">
 120        /// Optional <see cref="RequestConditions"/> to add
 121        /// conditions on acquiring a lease.
 122        /// </param>
 123        /// <param name="cancellationToken">
 124        /// Optional <see cref="CancellationToken"/> to propagate
 125        /// notifications that the operation should be cancelled.
 126        /// </param>
 127        /// <returns>
 128        /// A <see cref="Response{Lease}"/> describing the lease.
 129        /// </returns>
 130        /// <remarks>
 131        /// A <see cref="RequestFailedException"/> will be thrown if
 132        /// a failure occurs.
 133        /// </remarks>
 134        public virtual Response<DataLakeLease> Acquire(
 135            TimeSpan duration,
 136            RequestConditions conditions = default,
 137            CancellationToken cancellationToken = default)
 138        {
 326139            DiagnosticScope scope = ClientDiagnostics.CreateScope($"{nameof(DataLakeLeaseClient)}.{nameof(Acquire)}");
 140
 141            try
 142            {
 326143                scope.Start();
 144
 326145                Response<Blobs.Models.BlobLease> response = _blobLeaseClient.Acquire(
 326146                    duration,
 326147                    conditions,
 326148                    cancellationToken);
 149
 300150                return Response.FromValue(
 300151                    response.Value.ToDataLakeLease(),
 300152                    response.GetRawResponse());
 153            }
 26154            catch (Exception ex)
 155            {
 26156                scope.Failed(ex);
 26157                throw;
 158            }
 159            finally
 160            {
 326161                scope.Dispose();
 326162            }
 300163        }
 164
 165        /// <summary>
 166        /// The <see cref="AcquireAsync"/> operation acquires a lease on
 167        /// the path or file system.  The lease <paramref name="duration"/> must
 168        /// be between 15 to 60 seconds, or infinite (-1).
 169        ///
 170        /// If the file system does not have an active lease, the Data Lake service
 171        /// creates a lease on the file system or path and returns it.  If the
 172        /// file system has an active lease, you can only request a new lease
 173        /// using the active lease ID as <see cref="LeaseId"/>, but you can
 174        /// specify a new <paramref name="duration"/>.
 175        ///
 176        /// For more information, see
 177        /// <see href="https://docs.microsoft.com/rest/api/storageservices/lease-container">
 178        /// Lease Container</see>.
 179        /// </summary>
 180        /// <param name="duration">
 181        /// Specifies the duration of the lease, in seconds, or specify
 182        /// <see cref="InfiniteLeaseDuration"/> for a lease that never expires.
 183        /// A non-infinite lease can be between 15 and 60 seconds.
 184        /// A lease duration cannot be changed using <see cref="RenewAsync"/> or <see cref="ChangeAsync"/>.
 185        /// </param>
 186        /// <param name="conditions">
 187        /// Optional <see cref="RequestConditions"/> to add
 188        /// conditions on acquiring a lease.
 189        /// </param>
 190        /// <param name="cancellationToken">
 191        /// Optional <see cref="CancellationToken"/> to propagate
 192        /// notifications that the operation should be cancelled.
 193        /// </param>
 194        /// <returns>
 195        /// A <see cref="Response{Lease}"/> describing the lease.
 196        /// </returns>
 197        /// <remarks>
 198        /// A <see cref="RequestFailedException"/> will be thrown if
 199        /// a failure occurs.
 200        /// </remarks>
 201        public virtual async Task<Response<DataLakeLease>> AcquireAsync(
 202            TimeSpan duration,
 203            RequestConditions conditions = default,
 204            CancellationToken cancellationToken = default)
 205        {
 326206            DiagnosticScope scope = ClientDiagnostics.CreateScope($"{nameof(DataLakeLeaseClient)}.{nameof(Acquire)}");
 207
 208            try
 209            {
 326210                scope.Start();
 211
 326212                Response<Blobs.Models.BlobLease> response = await _blobLeaseClient.AcquireAsync(
 326213                    duration,
 326214                    conditions,
 326215                    cancellationToken)
 326216                    .ConfigureAwait(false);
 217
 300218                return Response.FromValue(
 300219                    response.Value.ToDataLakeLease(),
 300220                    response.GetRawResponse());
 221            }
 26222            catch (Exception ex)
 223            {
 26224                scope.Failed(ex);
 26225                throw;
 226            }
 227            finally
 228            {
 326229                scope.Dispose();
 230            }
 300231        }
 232        #endregion Acquire
 233
 234        #region Renew
 235        /// <summary>
 236        /// The <see cref="Renew"/> operation renews the path or
 237        /// file system's previously-acquired lease.
 238        ///
 239        /// The lease can be renewed if the leaseId
 240        /// matches that associated with the path or file system.  Note that the]
 241        /// lease may be renewed even if it has expired as long as the path or
 242        /// file system has not been leased again since the expiration of that
 243        /// lease.  When you renew a lease, the lease duration clock resets.
 244        ///
 245        /// For more information, see
 246        /// <see href="https://docs.microsoft.com/rest/api/storageservices/lease-container">
 247        /// Lease Container</see>.
 248        /// </summary>
 249        /// <param name="conditions">
 250        /// Optional <see cref="RequestConditions"/> to add
 251        /// conditions on acquiring a lease.
 252        /// </param>
 253        /// <param name="cancellationToken">
 254        /// Optional <see cref="CancellationToken"/> to propagate
 255        /// notifications that the operation should be cancelled.
 256        /// </param>
 257        /// <returns>
 258        /// A <see cref="Response{Lease}"/> describing the lease.
 259        /// </returns>
 260        /// <remarks>
 261        /// A <see cref="RequestFailedException"/> will be thrown if
 262        /// a failure occurs.
 263        /// </remarks>
 264        public virtual Response<DataLakeLease> Renew(
 265            RequestConditions conditions = default,
 266            CancellationToken cancellationToken = default)
 267        {
 56268            DiagnosticScope scope = ClientDiagnostics.CreateScope($"{nameof(DataLakeLeaseClient)}.{nameof(Renew)}");
 269
 270            try
 271            {
 56272                scope.Start();
 273
 56274                Response<Blobs.Models.BlobLease> response = _blobLeaseClient.Renew(
 56275                    conditions,
 56276                    cancellationToken);
 277
 32278                return Response.FromValue(
 32279                    response.Value.ToDataLakeLease(),
 32280                    response.GetRawResponse());
 281            }
 24282            catch (Exception ex)
 283            {
 24284                scope.Failed(ex);
 24285                throw;
 286            }
 287            finally
 288            {
 56289                scope.Dispose();
 56290            }
 32291        }
 292
 293        /// <summary>
 294        /// The <see cref="RenewAsync"/> operation renews the path or
 295        /// file system's previously-acquired lease.
 296        ///
 297        /// The lease can be renewed if the leaseId
 298        /// matches that associated with the path or file system.  Note that the
 299        /// lease may be renewed even if it has expired as long as the path or
 300        /// file system has not been leased again since the expiration of that
 301        /// lease.  When you renew a lease, the lease duration clock resets.
 302        ///
 303        /// For more information, see
 304        /// <see href="https://docs.microsoft.com/rest/api/storageservices/lease-container">
 305        /// Lease Container</see>.
 306        /// </summary>
 307        /// <param name="conditions">
 308        /// Optional <see cref="RequestConditions"/> to add
 309        /// conditions on acquiring a lease.
 310        /// </param>
 311        /// <param name="cancellationToken">
 312        /// Optional <see cref="CancellationToken"/> to propagate
 313        /// notifications that the operation should be cancelled.
 314        /// </param>
 315        /// <returns>
 316        /// A <see cref="Response{Lease}"/> describing the lease.
 317        /// </returns>
 318        /// <remarks>
 319        /// A <see cref="RequestFailedException"/> will be thrown if
 320        /// a failure occurs.
 321        /// </remarks>
 322        public virtual async Task<Response<DataLakeLease>> RenewAsync(
 323            RequestConditions conditions = default,
 324            CancellationToken cancellationToken = default)
 325        {
 56326            DiagnosticScope scope = ClientDiagnostics.CreateScope($"{nameof(DataLakeLeaseClient)}.{nameof(Renew)}");
 327
 328            try
 329            {
 56330                scope.Start();
 56331                Response<Blobs.Models.BlobLease> response = await _blobLeaseClient.RenewAsync(
 56332                    conditions,
 56333                    cancellationToken)
 56334                    .ConfigureAwait(false);
 335
 32336                return Response.FromValue(
 32337                    response.Value.ToDataLakeLease(),
 32338                    response.GetRawResponse());
 339            }
 24340            catch (Exception ex)
 341            {
 24342                scope.Failed(ex);
 24343                throw;
 344            }
 345            finally
 346            {
 56347                scope.Dispose();
 348            }
 32349        }
 350        #endregion Renew
 351
 352        #region Release
 353        /// <summary>
 354        /// The <see cref="Release"/> operation releases the
 355        /// file system or path's previously-acquired lease.
 356        ///
 357        /// The lease may be released if the <see cref="LeaseId"/>
 358        /// matches that associated with the file system or path.  Releasing the
 359        /// lease allows another client to immediately acquire the lease for the
 360        /// file system or path as soon as the release is complete.
 361        ///
 362        /// For more information, see
 363        /// <see href="https://docs.microsoft.com/rest/api/storageservices/lease-container">
 364        /// Lease Container</see>.
 365        /// </summary>
 366        /// <param name="conditions">
 367        /// Optional <see cref="RequestConditions"/> to add
 368        /// conditions on acquiring a lease.
 369        /// </param>
 370        /// <param name="cancellationToken">
 371        /// Optional <see cref="CancellationToken"/> to propagate
 372        /// notifications that the operation should be cancelled.
 373        /// </param>
 374        /// <returns>
 375        /// A <see cref="Response{ReleaseObjectLeaseInfo}"/> describing the
 376        /// updated path or file system.
 377        /// </returns>
 378        /// <remarks>
 379        /// A <see cref="RequestFailedException"/> will be thrown if
 380        /// a failure occurs.
 381        /// </remarks>
 382        public virtual Response<ReleasedObjectInfo> Release(
 383            RequestConditions conditions = default,
 384            CancellationToken cancellationToken = default)
 385        {
 62386            DiagnosticScope scope = ClientDiagnostics.CreateScope($"{nameof(DataLakeLeaseClient)}.{nameof(Release)}");
 387
 388            try
 389            {
 62390                scope.Start();
 391
 62392                Response<Blobs.Models.ReleasedObjectInfo> response = _blobLeaseClient.Release(
 62393                    conditions,
 62394                    cancellationToken);
 395
 34396                return Response.FromValue(
 34397                    new ReleasedObjectInfo(response.Value.ETag, response.Value.LastModified),
 34398                    response.GetRawResponse());
 399            }
 28400            catch (Exception ex)
 401            {
 28402                scope.Failed(ex);
 28403                throw;
 404            }
 405            finally
 406            {
 62407                scope.Dispose();
 62408            }
 34409        }
 410
 411        /// <summary>
 412        /// The <see cref="ReleaseAsync"/> operation releases the
 413        /// file system or path's previously-acquired lease.
 414        ///
 415        /// The lease may be released if the <see cref="LeaseId"/>
 416        /// matches that associated with the file system or path.  Releasing the
 417        /// lease allows another client to immediately acquire the lease for the
 418        /// file system or path as soon as the release is complete.
 419        ///
 420        /// For more information, see
 421        /// <see href="https://docs.microsoft.com/rest/api/storageservices/lease-container">
 422        /// Lease Container</see>.
 423        /// </summary>
 424        /// <param name="conditions">
 425        /// Optional <see cref="RequestConditions"/> to add
 426        /// conditions on acquiring a lease.
 427        /// </param>
 428        /// <param name="cancellationToken">
 429        /// Optional <see cref="CancellationToken"/> to propagate
 430        /// notifications that the operation should be cancelled.
 431        /// </param>
 432        /// <returns>
 433        /// A <see cref="Response{ReleasedObjectInfo}"/> describing the
 434        /// updated path or file system.
 435        /// </returns>
 436        /// <remarks>
 437        /// A <see cref="RequestFailedException"/> will be thrown if
 438        /// a failure occurs.
 439        /// </remarks>
 440        public virtual async Task<Response<ReleasedObjectInfo>> ReleaseAsync(
 441            RequestConditions conditions = default,
 442            CancellationToken cancellationToken = default)
 443        {
 62444            DiagnosticScope scope = ClientDiagnostics.CreateScope($"{nameof(DataLakeLeaseClient)}.{nameof(Release)}");
 445
 446            try
 447            {
 62448                scope.Start();
 449
 62450                Response<Blobs.Models.ReleasedObjectInfo> response = await _blobLeaseClient.ReleaseAsync(
 62451                    conditions,
 62452                    cancellationToken)
 62453                    .ConfigureAwait(false);
 454
 34455                return Response.FromValue(
 34456                    new ReleasedObjectInfo(response.Value.ETag, response.Value.LastModified),
 34457                    response.GetRawResponse());
 458            }
 28459            catch (Exception ex)
 460            {
 28461                scope.Failed(ex);
 28462                throw;
 463            }
 464            finally
 465            {
 62466                scope.Dispose();
 467            }
 34468        }
 469        #endregion Release
 470
 471        #region Change
 472        /// <summary>
 473        /// The <see cref="Change"/> operation changes the lease
 474        /// of an active lease.  A change must include the current
 475        /// <see cref="LeaseId"/> and a new <paramref name="proposedId"/>.
 476        ///
 477        /// For more information, see
 478        /// <see href="https://docs.microsoft.com/rest/api/storageservices/lease-container">
 479        /// Lease Container</see>.
 480        /// </summary>
 481        /// <param name="proposedId">
 482        /// An optional proposed lease ID, in a GUID string format. A
 483        /// <see cref="RequestFailedException"/> will be thrown if the
 484        /// proposed lease ID is not in the correct format.
 485        /// </param>
 486        /// <param name="conditions">
 487        /// Optional <see cref="RequestConditions"/> to add
 488        /// conditions on acquiring a lease.
 489        /// </param>
 490        /// <param name="cancellationToken">
 491        /// Optional <see cref="CancellationToken"/> to propagate
 492        /// notifications that the operation should be cancelled.
 493        /// </param>
 494        /// <returns>
 495        /// A <see cref="Response{Lease}"/> describing the lease.
 496        /// </returns>
 497        /// <remarks>
 498        /// A <see cref="RequestFailedException"/> will be thrown if
 499        /// a failure occurs.
 500        /// </remarks>
 501        public virtual Response<DataLakeLease> Change(
 502            string proposedId,
 503            RequestConditions conditions = default,
 504            CancellationToken cancellationToken = default)
 505        {
 58506            DiagnosticScope scope = ClientDiagnostics.CreateScope($"{nameof(DataLakeLeaseClient)}.{nameof(Change)}");
 507
 508            try
 509            {
 58510                scope.Start();
 511
 58512                Response<Blobs.Models.BlobLease> response = _blobLeaseClient.Change(
 58513                    proposedId,
 58514                    conditions,
 58515                    cancellationToken);
 516
 32517                return Response.FromValue(
 32518                    response.Value.ToDataLakeLease(),
 32519                    response.GetRawResponse());
 520            }
 26521            catch (Exception ex)
 522            {
 26523                scope.Failed(ex);
 26524                throw;
 525            }
 526            finally
 527            {
 58528                scope.Dispose();
 58529            }
 32530        }
 531
 532        /// <summary>
 533        /// The <see cref="ChangeAsync"/> operation changes the lease
 534        /// of an active lease.  A change must include the current
 535        /// <see cref="LeaseId"/> and a new <paramref name="proposedId"/>.
 536        ///
 537        /// For more information, see
 538        /// <see href="https://docs.microsoft.com/rest/api/storageservices/lease-container">
 539        /// Lease Container</see>.
 540        /// </summary>
 541        /// <param name="proposedId">
 542        /// An optional proposed lease ID, in a GUID string format. A
 543        /// <see cref="RequestFailedException"/> will be thrown if the
 544        /// proposed lease ID is not in the correct format.
 545        /// </param>
 546        /// <param name="conditions">
 547        /// Optional <see cref="RequestConditions"/> to add
 548        /// conditions on acquiring a lease.
 549        /// </param>
 550        /// <param name="cancellationToken">
 551        /// Optional <see cref="CancellationToken"/> to propagate
 552        /// notifications that the operation should be cancelled.
 553        /// </param>
 554        /// <returns>
 555        /// A <see cref="Response{Lease}"/> describing the lease.
 556        /// </returns>
 557        /// <remarks>
 558        /// A <see cref="RequestFailedException"/> will be thrown if
 559        /// a failure occurs.
 560        /// </remarks>
 561        public virtual async Task<Response<DataLakeLease>> ChangeAsync(
 562            string proposedId,
 563            RequestConditions conditions = default,
 564            CancellationToken cancellationToken = default)
 565        {
 58566            DiagnosticScope scope = ClientDiagnostics.CreateScope($"{nameof(DataLakeLeaseClient)}.{nameof(Change)}");
 567
 568            try
 569            {
 58570                scope.Start();
 571
 58572                Response<Blobs.Models.BlobLease> response = await _blobLeaseClient.ChangeAsync(
 58573                    proposedId,
 58574                    conditions,
 58575                    cancellationToken)
 58576                    .ConfigureAwait(false);
 577
 32578                return Response.FromValue(
 32579                    response.Value.ToDataLakeLease(),
 32580                    response.GetRawResponse());
 581            }
 26582            catch (Exception ex)
 583            {
 26584                scope.Failed(ex);
 26585                throw;
 586            }
 587            finally
 588            {
 58589                scope.Dispose();
 590            }
 32591        }
 592        #endregion Change
 593
 594        #region Break
 595        /// <summary>
 596        /// The <see cref="Break"/> operation breaks the path or
 597        /// file system's previously-acquired lease (if it exists).
 598        ///
 599        /// Once a lease is broken, it cannot be renewed.  Any authorized
 600        /// request can break the lease; the request is not required to
 601        /// specify a matching lease ID.  When a lease is broken, the lease
 602        /// break <paramref name="breakPeriod"/> is allowed to elapse,
 603        /// during which time no lease operation except
 604        /// <see cref="Break"/> and <see cref="Release"/> can be
 605        /// performed on the path or file system.  When a lease is successfully
 606        /// broken, the response indicates the interval in seconds until a new
 607        /// lease can be acquired.
 608        ///
 609        /// A lease that has been broken can also be released.  A client can
 610        /// immediately acquire a path or file system lease that has been
 611        /// released.
 612        ///
 613        /// For more information, see
 614        /// <see href="https://docs.microsoft.com/rest/api/storageservices/lease-container">
 615        /// Lease Container</see>.
 616        /// </summary>
 617        /// <param name="breakPeriod">
 618        /// Specifies the proposed duration the lease should continue before
 619        /// it is broken, in seconds, between 0 and 60.  This break period is
 620        /// only used if it is shorter than the time remaining on the lease.
 621        /// If longer, the time remaining on the lease is used.  A new lease
 622        /// will not be available before the break period has expired, but the
 623        /// lease may be held for longer than the break period.  If this value
 624        /// is not provided, a fixed-duration lease breaks after the remaining
 625        /// lease period elapses, and an infinite lease breaks immediately.
 626        /// </param>
 627        /// <param name="conditions">
 628        /// Optional <see cref="RequestConditions"/> to add
 629        /// conditions on acquiring a lease.
 630        /// </param>
 631        /// <param name="cancellationToken">
 632        /// Optional <see cref="CancellationToken"/> to propagate
 633        /// notifications that the operation should be cancelled.
 634        /// </param>
 635        /// <returns>
 636        /// A <see cref="Response{Lease}"/> describing the broken lease.
 637        /// </returns>
 638        /// <remarks>
 639        /// A <see cref="RequestFailedException"/> will be thrown if
 640        /// a failure occurs.
 641        /// </remarks>
 642        public virtual Response<DataLakeLease> Break(
 643            TimeSpan? breakPeriod = default,
 644            RequestConditions conditions = default,
 645            CancellationToken cancellationToken = default)
 646        {
 58647            DiagnosticScope scope = ClientDiagnostics.CreateScope($"{nameof(DataLakeLeaseClient)}.{nameof(Break)}");
 648
 649            try
 650            {
 58651                scope.Start();
 652
 58653                Response<Blobs.Models.BlobLease> response = _blobLeaseClient.Break(
 58654                    breakPeriod,
 58655                    conditions,
 58656                    cancellationToken);
 657
 32658                return Response.FromValue(
 32659                    response.Value.ToDataLakeLease(),
 32660                    response.GetRawResponse());
 661            }
 26662            catch (Exception ex)
 663            {
 26664                scope.Failed(ex);
 26665                throw;
 666            }
 667            finally
 668            {
 58669                scope.Dispose();
 58670            }
 32671        }
 672
 673        /// <summary>
 674        /// The <see cref="BreakAsync"/> operation breaks the path or
 675        /// file system's previously-acquired lease (if it exists).
 676        ///
 677        /// Once a lease is broken, it cannot be renewed.  Any authorized
 678        /// request can break the lease; the request is not required to
 679        /// specify a matching lease ID.  When a lease is broken, the lease
 680        /// break <paramref name="breakPeriod"/> is allowed to elapse,
 681        /// during which time no lease operation except
 682        /// <see cref="BreakAsync"/> and <see cref="ReleaseAsync"/> can be
 683        /// performed on the path or file system.  When a lease is successfully
 684        /// broken, the response indicates the interval in seconds until a new
 685        /// lease can be acquired.
 686        ///
 687        /// A lease that has been broken can also be released.  A client can
 688        /// immediately acquire a path or file system lease that has been
 689        /// released.
 690        ///
 691        /// For more information, see
 692        /// <see href="https://docs.microsoft.com/rest/api/storageservices/lease-container">
 693        /// Lease Container</see>.
 694        /// </summary>
 695        /// <param name="breakPeriod">
 696        /// Specifies the proposed duration the lease should continue before
 697        /// it is broken, in seconds, between 0 and 60.  This break period is
 698        /// only used if it is shorter than the time remaining on the lease.
 699        /// If longer, the time remaining on the lease is used.  A new lease
 700        /// will not be available before the break period has expired, but the
 701        /// lease may be held for longer than the break period.  If this value
 702        /// is not provided, a fixed-duration lease breaks after the remaining
 703        /// lease period elapses, and an infinite lease breaks immediately.
 704        /// </param>
 705        /// <param name="conditions">
 706        /// Optional <see cref="RequestConditions"/> to add
 707        /// conditions on acquiring a lease.
 708        /// </param>
 709        /// <param name="cancellationToken">
 710        /// Optional <see cref="CancellationToken"/> to propagate
 711        /// notifications that the operation should be cancelled.
 712        /// </param>
 713        /// <returns>
 714        /// A <see cref="Response{Lease}"/> describing the broken lease.
 715        /// </returns>
 716        /// <remarks>
 717        /// A <see cref="RequestFailedException"/> will be thrown if
 718        /// a failure occurs.
 719        /// </remarks>
 720        public virtual async Task<Response<DataLakeLease>> BreakAsync(
 721            TimeSpan? breakPeriod = default,
 722           RequestConditions conditions = default,
 723            CancellationToken cancellationToken = default)
 724        {
 58725            DiagnosticScope scope = ClientDiagnostics.CreateScope($"{nameof(DataLakeLeaseClient)}.{nameof(Break)}");
 726
 727            try
 728            {
 58729                scope.Start();
 730
 58731                Response<Blobs.Models.BlobLease> response = await _blobLeaseClient.BreakAsync(
 58732                    breakPeriod,
 58733                    conditions,
 58734                    cancellationToken).ConfigureAwait(false);
 735
 32736                return Response.FromValue(
 32737                    response.Value.ToDataLakeLease(),
 32738                    response.GetRawResponse());
 739            }
 26740            catch (Exception ex)
 741            {
 26742                scope.Failed(ex);
 26743                throw;
 744            }
 745            finally
 746            {
 58747                scope.Dispose();
 748            }
 32749        }
 750        #endregion Break
 751    }
 752}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:47:05 PM
GitHub | www.palmmedia.de

Methods/Properties

.cctor()
get_Uri()
get_LeaseId()
get_ClientDiagnostics()
.ctor()
.ctor(...)
.ctor(...)
Acquire(...)
AcquireAsync()
Renew(...)
RenewAsync()
Release(...)
ReleaseAsync()
Change(...)
ChangeAsync()
Break(...)
BreakAsync()