< Summary

Class:Azure.Core.ArmOperationHelpers`1
Assembly:Azure.ResourceManager.KeyVault
File(s):C:\Git\azure-sdk-for-net\sdk\core\Azure.Core\src\Shared\AutoRest\ArmOperationHelpers.cs
Covered lines:106
Uncovered lines:49
Coverable lines:155
Total lines:359
Line coverage:68.3% (106 of 155)
Covered branches:47
Total branches:98
Branch coverage:47.9% (47 of 98)

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
get_DefaultPollingInterval()-0%100%
.cctor()-100%100%
.ctor(...)-100%100%
GetRawResponse()-100%100%
WaitForCompletionAsync(...)-0%100%
WaitForCompletionAsync()-100%100%
UpdateStatusAsync()-77.42%46.43%
UpdateStatusAsync()-100%100%
UpdateStatus(...)-0%100%
get_Id()-0%100%
get_Value()-66.67%50%
get_HasCompleted()-100%100%
get_HasValue()-100%100%
CreateRequest(...)-100%100%
GetResponseAsync()-63.64%50%
GetResponse(...)-0%0%
IsTerminalState(...)-79.17%60.71%
InitializeScenarioInfo()-69.23%66.67%
UpdatePollUri()-50%41.67%
GetFinalUri()-25%25%

File(s)

C:\Git\azure-sdk-for-net\sdk\core\Azure.Core\src\Shared\AutoRest\ArmOperationHelpers.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4#nullable enable
 5
 6using System;
 7using System.Linq;
 8using System.Text.Json;
 9using System.Threading;
 10using System.Threading.Tasks;
 11using Azure.Core.Pipeline;
 12
 13namespace Azure.Core
 14{
 15    /// <summary>
 16    /// This implements the ARM scenarios for LROs. It is highly recommended to read the ARM spec prior to modifying thi
 17    /// https://github.com/Azure/azure-resource-manager-rpc/blob/master/v1.0/Addendum.md#asynchronous-operations
 18    /// Other reference documents include:
 19    /// https://github.com/Azure/autorest/blob/master/docs/extensions/readme.md#x-ms-long-running-operation
 20    /// https://github.com/Azure/adx-documentation-pr/blob/master/sdks/LRO/LRO_AzureSDK.md
 21    /// </summary>
 22    /// <typeparam name="T">The final result of the LRO.</typeparam>
 23    internal class ArmOperationHelpers<T>
 24    {
 025        public static TimeSpan DefaultPollingInterval { get; } = TimeSpan.FromSeconds(1);
 26
 427        private static readonly string[] s_failureStates = {"failed", "canceled"};
 428        private static readonly string[] s_terminalStates = {"succeeded", "failed", "canceled"};
 29
 30        private readonly HttpPipeline _pipeline;
 31        private readonly ClientDiagnostics _clientDiagnostics;
 32        private readonly string _scopeName;
 33        private readonly RequestMethod _requestMethod;
 34        private readonly string _originalUri;
 35        private readonly OperationFinalStateVia _finalStateVia;
 36        private HeaderFrom _headerFrom;
 37        private string _pollUri = default!;
 38        private bool _originalHasLocation;
 39        private string? _lastKnownLocation;
 40
 41        private readonly IOperationSource<T> _source;
 42        private Response _rawResponse;
 43        private T _value = default!;
 44        private bool _hasValue;
 45        private bool _hasCompleted;
 46        private bool _shouldPoll;
 47
 6448        public ArmOperationHelpers(
 6449            IOperationSource<T> source,
 6450            ClientDiagnostics clientDiagnostics,
 6451            HttpPipeline pipeline,
 6452            Request originalRequest,
 6453            Response originalResponse,
 6454            OperationFinalStateVia finalStateVia,
 6455            string scopeName)
 56        {
 6457            _source = source;
 6458            _rawResponse = originalResponse;
 6459            _requestMethod = originalRequest.Method;
 6460            _originalUri = originalRequest.Uri.ToString();
 6461            _finalStateVia = finalStateVia;
 6462            InitializeScenarioInfo();
 63
 6464            _pipeline = pipeline;
 6465            _clientDiagnostics = clientDiagnostics;
 6466            _scopeName = scopeName;
 67            // When the original response has no headers, we do not start polling immediately.
 6468            _shouldPoll = _headerFrom != HeaderFrom.None;
 6469        }
 70
 137271        public Response GetRawResponse() => _rawResponse;
 72
 73        public ValueTask<Response<T>> WaitForCompletionAsync(CancellationToken cancellationToken = default)
 74        {
 075            return WaitForCompletionAsync(DefaultPollingInterval, cancellationToken);
 76        }
 77
 78        public async ValueTask<Response<T>> WaitForCompletionAsync(TimeSpan pollingInterval, CancellationToken cancellat
 79        {
 56280            while (true)
 81            {
 62682                await UpdateStatusAsync(cancellationToken).ConfigureAwait(false);
 62683                if (HasCompleted)
 84                {
 6485                    return Response.FromValue(Value, GetRawResponse());
 86                }
 87
 56288                await Task.Delay(pollingInterval, cancellationToken).ConfigureAwait(false);
 89            }
 6490        }
 91
 92        private async ValueTask<Response> UpdateStatusAsync(bool async, CancellationToken cancellationToken)
 93        {
 62694            if (_hasCompleted)
 95            {
 496                return GetRawResponse();
 97            }
 98
 62299            if (_shouldPoll)
 100            {
 574101                UpdatePollUri();
 574102                _rawResponse = async
 574103                    ? await GetResponseAsync(_pollUri, cancellationToken).ConfigureAwait(false)
 574104                    : GetResponse(_pollUri, cancellationToken);
 105            }
 106
 622107            _shouldPoll = true;
 622108            _hasCompleted = IsTerminalState(out string state);
 622109            if (_hasCompleted)
 110            {
 60111                Response finalResponse = GetRawResponse();
 60112                if (s_failureStates.Contains(state))
 113                {
 0114                    throw _clientDiagnostics.CreateRequestFailedException(finalResponse);
 115                }
 116
 60117                string? finalUri = GetFinalUri();
 60118                if (finalUri != null)
 119                {
 0120                    finalResponse = async
 0121                        ? await GetResponseAsync(finalUri, cancellationToken).ConfigureAwait(false)
 0122                        : GetResponse(finalUri, cancellationToken);
 123                }
 124
 60125                switch (finalResponse.Status)
 126                {
 127                    case 200:
 0128                    case 201 when _requestMethod == RequestMethod.Put:
 0129                    case 204 when !(_requestMethod == RequestMethod.Put || _requestMethod == RequestMethod.Patch):
 130                    {
 60131                        _value = async
 60132                            ? await _source.CreateResultAsync(finalResponse, cancellationToken).ConfigureAwait(false)
 60133                            : _source.CreateResult(finalResponse, cancellationToken);
 60134                        _rawResponse = finalResponse;
 60135                        _hasValue = true;
 60136                        break;
 137                    }
 138                    default:
 0139                        throw _clientDiagnostics.CreateRequestFailedException(finalResponse);
 140                }
 60141            }
 142
 622143            return GetRawResponse();
 626144        }
 145
 626146        public async ValueTask<Response> UpdateStatusAsync(CancellationToken cancellationToken = default) => await Updat
 147
 0148        public Response UpdateStatus(CancellationToken cancellationToken = default) => UpdateStatusAsync(async: false, c
 149
 150#pragma warning disable CA1822
 151        //TODO: This is currently unused.
 0152        public string Id => throw new NotImplementedException();
 153#pragma warning restore CA1822
 154
 155        public T Value
 156        {
 157            get
 158            {
 64159                if (!HasValue)
 160                {
 0161                    throw new InvalidOperationException("The operation has not completed yet.");
 162                }
 163
 64164                return _value;
 165            }
 166        }
 167
 626168        public bool HasCompleted => _hasCompleted;
 64169        public bool HasValue => _hasValue;
 170
 171        private HttpMessage CreateRequest(string link)
 172        {
 574173            HttpMessage message = _pipeline.CreateMessage();
 574174            Request request = message.Request;
 574175            request.Method = RequestMethod.Get;
 574176            request.Uri.Reset(new Uri(link));
 574177            return message;
 178        }
 179
 180        private async ValueTask<Response> GetResponseAsync(string link, CancellationToken cancellationToken = default)
 181        {
 574182            if (link == null)
 183            {
 0184                throw new ArgumentNullException(nameof(link));
 185            }
 186
 574187            using DiagnosticScope scope = _clientDiagnostics.CreateScope(_scopeName);
 574188            scope.Start();
 189            try
 190            {
 574191                using HttpMessage message = CreateRequest(link);
 574192                await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 574193                return message.Response;
 194            }
 0195            catch (Exception e)
 196            {
 0197                scope.Failed(e);
 0198                throw;
 199            }
 574200        }
 201
 202        private Response GetResponse(string link, CancellationToken cancellationToken = default)
 203        {
 0204            if (link == null)
 205            {
 0206                throw new ArgumentNullException(nameof(link));
 207            }
 208
 0209            using DiagnosticScope scope = _clientDiagnostics.CreateScope(_scopeName);
 0210            scope.Start();
 211            try
 212            {
 0213                using HttpMessage message = CreateRequest(link);
 0214                _pipeline.Send(message, cancellationToken);
 0215                return message.Response;
 216            }
 0217            catch (Exception e)
 218            {
 0219                scope.Failed(e);
 0220                throw;
 221            }
 0222        }
 223
 224        private bool IsTerminalState(out string state)
 225        {
 622226            Response response = GetRawResponse();
 622227            state = string.Empty;
 622228            if (_headerFrom == HeaderFrom.Location)
 229            {
 150230                return response.Status != 202;
 231            }
 232
 472233            if (response.Status >= 200 && response.Status <= 204)
 234            {
 472235                if (response.ContentStream?.Length > 0)
 236                {
 237                    try
 238                    {
 472239                        using JsonDocument document = JsonDocument.Parse(response.ContentStream);
 6136240                        foreach (JsonProperty property in document.RootElement.EnumerateObject())
 241                        {
 2832242                            if ((_headerFrom == HeaderFrom.OperationLocation ||
 2832243                                 _headerFrom == HeaderFrom.AzureAsyncOperation) &&
 2832244                                property.NameEquals("status"))
 245                            {
 0246                                state = property.Value.GetString().ToLowerInvariant();
 0247                                return s_terminalStates.Contains(state);
 248                            }
 249
 2832250                            if (_headerFrom == HeaderFrom.None && property.NameEquals("properties"))
 251                            {
 9912252                                foreach (JsonProperty innerProperty in property.Value.EnumerateObject())
 253                                {
 4720254                                    if (innerProperty.NameEquals("provisioningState"))
 255                                    {
 472256                                        state = innerProperty.Value.GetString().ToLowerInvariant();
 472257                                        return s_terminalStates.Contains(state);
 258                                    }
 259                                }
 260                            }
 261                        }
 262                    }
 263                    finally
 264                    {
 265                        // It is required to reset the position of the content after reading as this response may be use
 472266                        response.ContentStream.Position = 0;
 472267                    }
 268                }
 269
 270                // If provisioningState was not found, it defaults to Succeeded.
 0271                if (_headerFrom == HeaderFrom.None)
 272                {
 0273                    return true;
 274                }
 275            }
 276
 0277            throw _clientDiagnostics.CreateRequestFailedException(response);
 472278        }
 279
 280        private enum HeaderFrom
 281        {
 282            None,
 283            OperationLocation,
 284            AzureAsyncOperation,
 285            Location
 286        }
 287
 288        private void InitializeScenarioInfo()
 289        {
 64290            _originalHasLocation = _rawResponse.Headers.Contains("Location");
 291
 64292            if (_rawResponse.Headers.Contains("Operation-Location"))
 293            {
 0294                _headerFrom = HeaderFrom.OperationLocation;
 0295                return;
 296            }
 297
 64298            if (_rawResponse.Headers.Contains("Azure-AsyncOperation"))
 299            {
 0300                _headerFrom = HeaderFrom.AzureAsyncOperation;
 0301                return;
 302            }
 303
 64304            if (_originalHasLocation)
 305            {
 12306                _headerFrom = HeaderFrom.Location;
 12307                return;
 308            }
 309
 52310            _pollUri = _originalUri;
 52311            _headerFrom = HeaderFrom.None;
 52312        }
 313
 314        private void UpdatePollUri()
 315        {
 574316            var hasLocation = _rawResponse.Headers.TryGetValue("Location", out string? location);
 574317            if (hasLocation)
 318            {
 150319                _lastKnownLocation = location;
 320            }
 321
 574322            switch (_headerFrom)
 323            {
 0324                case HeaderFrom.OperationLocation when _rawResponse.Headers.TryGetValue("Operation-Location", out string
 0325                    _pollUri = operationLocation;
 0326                    return;
 0327                case HeaderFrom.AzureAsyncOperation when _rawResponse.Headers.TryGetValue("Azure-AsyncOperation", out st
 0328                    _pollUri = azureAsyncOperation;
 0329                    return;
 150330                case HeaderFrom.Location when hasLocation:
 150331                    _pollUri = location!;
 150332                    return;
 333            }
 0334        }
 335
 336        private string? GetFinalUri()
 337        {
 60338            if (_headerFrom == HeaderFrom.OperationLocation || _headerFrom == HeaderFrom.AzureAsyncOperation)
 339            {
 0340                if (_requestMethod == RequestMethod.Delete)
 341                {
 0342                    return null;
 343                }
 344
 0345                if (_requestMethod == RequestMethod.Put || (_originalHasLocation && _finalStateVia == OperationFinalStat
 346                {
 0347                    return _originalUri;
 348                }
 349
 0350                if (_originalHasLocation && _finalStateVia == OperationFinalStateVia.Location)
 351                {
 0352                    return _lastKnownLocation;
 353                }
 354            }
 355
 60356            return null;
 357        }
 358    }
 359}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:46:46 PM
GitHub | www.palmmedia.de

Methods/Properties

get_DefaultPollingInterval()
.cctor()
.ctor(...)
GetRawResponse()
WaitForCompletionAsync(...)
WaitForCompletionAsync()
UpdateStatusAsync()
UpdateStatusAsync()
UpdateStatus(...)
get_Id()
get_Value()
get_HasCompleted()
get_HasValue()
CreateRequest(...)
GetResponseAsync()
GetResponse(...)
IsTerminalState(...)
InitializeScenarioInfo()
UpdatePollUri()
GetFinalUri()