< Summary

Class:Azure.Core.ArmOperationHelpers`1
Assembly:Azure.ResourceManager.Resources
File(s):C:\Git\azure-sdk-for-net\sdk\core\Azure.Core\src\Shared\AutoRest\ArmOperationHelpers.cs
Covered lines:123
Uncovered lines:32
Coverable lines:155
Total lines:359
Line coverage:79.3% (123 of 155)
Covered branches:69
Total branches:98
Branch coverage:70.4% (69 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()-87.1%53.57%
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(...)-100%96.43%
InitializeScenarioInfo()-84.62%83.33%
UpdatePollUri()-78.57%75%
GetFinalUri()-62.5%56.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
 1227        private static readonly string[] s_failureStates = {"failed", "canceled"};
 1228        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
 28048        public ArmOperationHelpers(
 28049            IOperationSource<T> source,
 28050            ClientDiagnostics clientDiagnostics,
 28051            HttpPipeline pipeline,
 28052            Request originalRequest,
 28053            Response originalResponse,
 28054            OperationFinalStateVia finalStateVia,
 28055            string scopeName)
 56        {
 28057            _source = source;
 28058            _rawResponse = originalResponse;
 28059            _requestMethod = originalRequest.Method;
 28060            _originalUri = originalRequest.Uri.ToString();
 28061            _finalStateVia = finalStateVia;
 28062            InitializeScenarioInfo();
 63
 28064            _pipeline = pipeline;
 28065            _clientDiagnostics = clientDiagnostics;
 28066            _scopeName = scopeName;
 67            // When the original response has no headers, we do not start polling immediately.
 28068            _shouldPoll = _headerFrom != HeaderFrom.None;
 28069        }
 70
 502071        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        {
 215880            while (true)
 81            {
 234682                await UpdateStatusAsync(cancellationToken).ConfigureAwait(false);
 233083                if (HasCompleted)
 84                {
 17285                    return Response.FromValue(Value, GetRawResponse());
 86                }
 87
 215888                await Task.Delay(pollingInterval, cancellationToken).ConfigureAwait(false);
 89            }
 17290        }
 91
 92        private async ValueTask<Response> UpdateStatusAsync(bool async, CancellationToken cancellationToken)
 93        {
 234694            if (_hasCompleted)
 95            {
 096                return GetRawResponse();
 97            }
 98
 234699            if (_shouldPoll)
 100            {
 2254101                UpdatePollUri();
 2254102                _rawResponse = async
 2254103                    ? await GetResponseAsync(_pollUri, cancellationToken).ConfigureAwait(false)
 2254104                    : GetResponse(_pollUri, cancellationToken);
 105            }
 106
 2346107            _shouldPoll = true;
 2346108            _hasCompleted = IsTerminalState(out string state);
 2330109            if (_hasCompleted)
 110            {
 172111                Response finalResponse = GetRawResponse();
 172112                if (s_failureStates.Contains(state))
 113                {
 0114                    throw _clientDiagnostics.CreateRequestFailedException(finalResponse);
 115                }
 116
 172117                string? finalUri = GetFinalUri();
 172118                if (finalUri != null)
 119                {
 48120                    finalResponse = async
 48121                        ? await GetResponseAsync(finalUri, cancellationToken).ConfigureAwait(false)
 48122                        : GetResponse(finalUri, cancellationToken);
 123                }
 124
 172125                switch (finalResponse.Status)
 126                {
 127                    case 200:
 16128                    case 201 when _requestMethod == RequestMethod.Put:
 0129                    case 204 when !(_requestMethod == RequestMethod.Put || _requestMethod == RequestMethod.Patch):
 130                    {
 172131                        _value = async
 172132                            ? await _source.CreateResultAsync(finalResponse, cancellationToken).ConfigureAwait(false)
 172133                            : _source.CreateResult(finalResponse, cancellationToken);
 172134                        _rawResponse = finalResponse;
 172135                        _hasValue = true;
 172136                        break;
 137                    }
 138                    default:
 0139                        throw _clientDiagnostics.CreateRequestFailedException(finalResponse);
 140                }
 172141            }
 142
 2330143            return GetRawResponse();
 2330144        }
 145
 2346146        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            {
 172159                if (!HasValue)
 160                {
 0161                    throw new InvalidOperationException("The operation has not completed yet.");
 162                }
 163
 172164                return _value;
 165            }
 166        }
 167
 2330168        public bool HasCompleted => _hasCompleted;
 172169        public bool HasValue => _hasValue;
 170
 171        private HttpMessage CreateRequest(string link)
 172        {
 2302173            HttpMessage message = _pipeline.CreateMessage();
 2302174            Request request = message.Request;
 2302175            request.Method = RequestMethod.Get;
 2302176            request.Uri.Reset(new Uri(link));
 2302177            return message;
 178        }
 179
 180        private async ValueTask<Response> GetResponseAsync(string link, CancellationToken cancellationToken = default)
 181        {
 2302182            if (link == null)
 183            {
 0184                throw new ArgumentNullException(nameof(link));
 185            }
 186
 2302187            using DiagnosticScope scope = _clientDiagnostics.CreateScope(_scopeName);
 2302188            scope.Start();
 189            try
 190            {
 2302191                using HttpMessage message = CreateRequest(link);
 2302192                await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 2302193                return message.Response;
 194            }
 0195            catch (Exception e)
 196            {
 0197                scope.Failed(e);
 0198                throw;
 199            }
 2302200        }
 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        {
 2346226            Response response = GetRawResponse();
 2346227            state = string.Empty;
 2346228            if (_headerFrom == HeaderFrom.Location)
 229            {
 646230                return response.Status != 202;
 231            }
 232
 1700233            if (response.Status >= 200 && response.Status <= 204)
 234            {
 1684235                if (response.ContentStream?.Length > 0)
 236                {
 237                    try
 238                    {
 1684239                        using JsonDocument document = JsonDocument.Parse(response.ContentStream);
 7408240                        foreach (JsonProperty property in document.RootElement.EnumerateObject())
 241                        {
 2852242                            if ((_headerFrom == HeaderFrom.OperationLocation ||
 2852243                                 _headerFrom == HeaderFrom.AzureAsyncOperation) &&
 2852244                                property.NameEquals("status"))
 245                            {
 1608246                                state = property.Value.GetString().ToLowerInvariant();
 1608247                                return s_terminalStates.Contains(state);
 248                            }
 249
 1244250                            if (_headerFrom == HeaderFrom.None && property.NameEquals("properties"))
 251                            {
 1480252                                foreach (JsonProperty innerProperty in property.Value.EnumerateObject())
 253                                {
 696254                                    if (innerProperty.NameEquals("provisioningState"))
 255                                    {
 56256                                        state = innerProperty.Value.GetString().ToLowerInvariant();
 56257                                        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
 1684266                        response.ContentStream.Position = 0;
 1684267                    }
 268                }
 269
 270                // If provisioningState was not found, it defaults to Succeeded.
 20271                if (_headerFrom == HeaderFrom.None)
 272                {
 20273                    return true;
 274                }
 275            }
 276
 16277            throw _clientDiagnostics.CreateRequestFailedException(response);
 1664278        }
 279
 280        private enum HeaderFrom
 281        {
 282            None,
 283            OperationLocation,
 284            AzureAsyncOperation,
 285            Location
 286        }
 287
 288        private void InitializeScenarioInfo()
 289        {
 280290            _originalHasLocation = _rawResponse.Headers.Contains("Location");
 291
 280292            if (_rawResponse.Headers.Contains("Operation-Location"))
 293            {
 0294                _headerFrom = HeaderFrom.OperationLocation;
 0295                return;
 296            }
 297
 280298            if (_rawResponse.Headers.Contains("Azure-AsyncOperation"))
 299            {
 56300                _headerFrom = HeaderFrom.AzureAsyncOperation;
 56301                return;
 302            }
 303
 224304            if (_originalHasLocation)
 305            {
 52306                _headerFrom = HeaderFrom.Location;
 52307                return;
 308            }
 309
 172310            _pollUri = _originalUri;
 172311            _headerFrom = HeaderFrom.None;
 172312        }
 313
 314        private void UpdatePollUri()
 315        {
 2254316            var hasLocation = _rawResponse.Headers.TryGetValue("Location", out string? location);
 2254317            if (hasLocation)
 318            {
 646319                _lastKnownLocation = location;
 320            }
 321
 2254322            switch (_headerFrom)
 323            {
 0324                case HeaderFrom.OperationLocation when _rawResponse.Headers.TryGetValue("Operation-Location", out string
 0325                    _pollUri = operationLocation;
 0326                    return;
 1608327                case HeaderFrom.AzureAsyncOperation when _rawResponse.Headers.TryGetValue("Azure-AsyncOperation", out st
 48328                    _pollUri = azureAsyncOperation;
 48329                    return;
 646330                case HeaderFrom.Location when hasLocation:
 646331                    _pollUri = location!;
 646332                    return;
 333            }
 1560334        }
 335
 336        private string? GetFinalUri()
 337        {
 172338            if (_headerFrom == HeaderFrom.OperationLocation || _headerFrom == HeaderFrom.AzureAsyncOperation)
 339            {
 48340                if (_requestMethod == RequestMethod.Delete)
 341                {
 0342                    return null;
 343                }
 344
 48345                if (_requestMethod == RequestMethod.Put || (_originalHasLocation && _finalStateVia == OperationFinalStat
 346                {
 48347                    return _originalUri;
 348                }
 349
 0350                if (_originalHasLocation && _finalStateVia == OperationFinalStateVia.Location)
 351                {
 0352                    return _lastKnownLocation;
 353                }
 354            }
 355
 124356            return null;
 357        }
 358    }
 359}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:46:49 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()