< Summary

Class:Azure.Core.ArmOperationHelpers`1
Assembly:Azure.ResourceManager.AppConfiguration
File(s):C:\Git\azure-sdk-for-net\sdk\core\Azure.Core\src\Shared\AutoRest\ArmOperationHelpers.cs
Covered lines:115
Uncovered lines:40
Coverable lines:155
Total lines:359
Line coverage:74.1% (115 of 155)
Covered branches:59
Total branches:98
Branch coverage:60.2% (59 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()-83.87%50%
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(...)-91.67%75%
InitializeScenarioInfo()-69.23%66.67%
UpdatePollUri()-50%50%
GetFinalUri()-75%62.5%

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
 1027        private static readonly string[] s_failureStates = {"failed", "canceled"};
 1028        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
 3248        public ArmOperationHelpers(
 3249            IOperationSource<T> source,
 3250            ClientDiagnostics clientDiagnostics,
 3251            HttpPipeline pipeline,
 3252            Request originalRequest,
 3253            Response originalResponse,
 3254            OperationFinalStateVia finalStateVia,
 3255            string scopeName)
 56        {
 3257            _source = source;
 3258            _rawResponse = originalResponse;
 3259            _requestMethod = originalRequest.Method;
 3260            _originalUri = originalRequest.Uri.ToString();
 3261            _finalStateVia = finalStateVia;
 3262            InitializeScenarioInfo();
 63
 3264            _pipeline = pipeline;
 3265            _clientDiagnostics = clientDiagnostics;
 3266            _scopeName = scopeName;
 67            // When the original response has no headers, we do not start polling immediately.
 3268            _shouldPoll = _headerFrom != HeaderFrom.None;
 3269        }
 70
 39271        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        {
 13280            while (true)
 81            {
 16482                await UpdateStatusAsync(cancellationToken).ConfigureAwait(false);
 16483                if (HasCompleted)
 84                {
 3285                    return Response.FromValue(Value, GetRawResponse());
 86                }
 87
 13288                await Task.Delay(pollingInterval, cancellationToken).ConfigureAwait(false);
 89            }
 3290        }
 91
 92        private async ValueTask<Response> UpdateStatusAsync(bool async, CancellationToken cancellationToken)
 93        {
 16494            if (_hasCompleted)
 95            {
 096                return GetRawResponse();
 97            }
 98
 16499            if (_shouldPoll)
 100            {
 156101                UpdatePollUri();
 156102                _rawResponse = async
 156103                    ? await GetResponseAsync(_pollUri, cancellationToken).ConfigureAwait(false)
 156104                    : GetResponse(_pollUri, cancellationToken);
 105            }
 106
 164107            _shouldPoll = true;
 164108            _hasCompleted = IsTerminalState(out string state);
 164109            if (_hasCompleted)
 110            {
 32111                Response finalResponse = GetRawResponse();
 32112                if (s_failureStates.Contains(state))
 113                {
 0114                    throw _clientDiagnostics.CreateRequestFailedException(finalResponse);
 115                }
 116
 32117                string? finalUri = GetFinalUri();
 32118                if (finalUri != null)
 119                {
 20120                    finalResponse = async
 20121                        ? await GetResponseAsync(finalUri, cancellationToken).ConfigureAwait(false)
 20122                        : GetResponse(finalUri, cancellationToken);
 123                }
 124
 32125                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                    {
 32131                        _value = async
 32132                            ? await _source.CreateResultAsync(finalResponse, cancellationToken).ConfigureAwait(false)
 32133                            : _source.CreateResult(finalResponse, cancellationToken);
 32134                        _rawResponse = finalResponse;
 32135                        _hasValue = true;
 32136                        break;
 137                    }
 138                    default:
 0139                        throw _clientDiagnostics.CreateRequestFailedException(finalResponse);
 140                }
 32141            }
 142
 164143            return GetRawResponse();
 164144        }
 145
 164146        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            {
 32159                if (!HasValue)
 160                {
 0161                    throw new InvalidOperationException("The operation has not completed yet.");
 162                }
 163
 32164                return _value;
 165            }
 166        }
 167
 164168        public bool HasCompleted => _hasCompleted;
 32169        public bool HasValue => _hasValue;
 170
 171        private HttpMessage CreateRequest(string link)
 172        {
 176173            HttpMessage message = _pipeline.CreateMessage();
 176174            Request request = message.Request;
 176175            request.Method = RequestMethod.Get;
 176176            request.Uri.Reset(new Uri(link));
 176177            return message;
 178        }
 179
 180        private async ValueTask<Response> GetResponseAsync(string link, CancellationToken cancellationToken = default)
 181        {
 176182            if (link == null)
 183            {
 0184                throw new ArgumentNullException(nameof(link));
 185            }
 186
 176187            using DiagnosticScope scope = _clientDiagnostics.CreateScope(_scopeName);
 176188            scope.Start();
 189            try
 190            {
 176191                using HttpMessage message = CreateRequest(link);
 176192                await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 176193                return message.Response;
 194            }
 0195            catch (Exception e)
 196            {
 0197                scope.Failed(e);
 0198                throw;
 199            }
 176200        }
 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        {
 164226            Response response = GetRawResponse();
 164227            state = string.Empty;
 164228            if (_headerFrom == HeaderFrom.Location)
 229            {
 0230                return response.Status != 202;
 231            }
 232
 164233            if (response.Status >= 200 && response.Status <= 204)
 234            {
 164235                if (response.ContentStream?.Length > 0)
 236                {
 237                    try
 238                    {
 160239                        using JsonDocument document = JsonDocument.Parse(response.ContentStream);
 776240                        foreach (JsonProperty property in document.RootElement.EnumerateObject())
 241                        {
 308242                            if ((_headerFrom == HeaderFrom.OperationLocation ||
 308243                                 _headerFrom == HeaderFrom.AzureAsyncOperation) &&
 308244                                property.NameEquals("status"))
 245                            {
 156246                                state = property.Value.GetString().ToLowerInvariant();
 156247                                return s_terminalStates.Contains(state);
 248                            }
 249
 152250                            if (_headerFrom == HeaderFrom.None && property.NameEquals("properties"))
 251                            {
 12252                                foreach (JsonProperty innerProperty in property.Value.EnumerateObject())
 253                                {
 4254                                    if (innerProperty.NameEquals("provisioningState"))
 255                                    {
 4256                                        state = innerProperty.Value.GetString().ToLowerInvariant();
 4257                                        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
 160266                        response.ContentStream.Position = 0;
 160267                    }
 268                }
 269
 270                // If provisioningState was not found, it defaults to Succeeded.
 4271                if (_headerFrom == HeaderFrom.None)
 272                {
 4273                    return true;
 274                }
 275            }
 276
 0277            throw _clientDiagnostics.CreateRequestFailedException(response);
 160278        }
 279
 280        private enum HeaderFrom
 281        {
 282            None,
 283            OperationLocation,
 284            AzureAsyncOperation,
 285            Location
 286        }
 287
 288        private void InitializeScenarioInfo()
 289        {
 32290            _originalHasLocation = _rawResponse.Headers.Contains("Location");
 291
 32292            if (_rawResponse.Headers.Contains("Operation-Location"))
 293            {
 0294                _headerFrom = HeaderFrom.OperationLocation;
 0295                return;
 296            }
 297
 32298            if (_rawResponse.Headers.Contains("Azure-AsyncOperation"))
 299            {
 24300                _headerFrom = HeaderFrom.AzureAsyncOperation;
 24301                return;
 302            }
 303
 8304            if (_originalHasLocation)
 305            {
 0306                _headerFrom = HeaderFrom.Location;
 0307                return;
 308            }
 309
 8310            _pollUri = _originalUri;
 8311            _headerFrom = HeaderFrom.None;
 8312        }
 313
 314        private void UpdatePollUri()
 315        {
 156316            var hasLocation = _rawResponse.Headers.TryGetValue("Location", out string? location);
 156317            if (hasLocation)
 318            {
 0319                _lastKnownLocation = location;
 320            }
 321
 156322            switch (_headerFrom)
 323            {
 0324                case HeaderFrom.OperationLocation when _rawResponse.Headers.TryGetValue("Operation-Location", out string
 0325                    _pollUri = operationLocation;
 0326                    return;
 156327                case HeaderFrom.AzureAsyncOperation when _rawResponse.Headers.TryGetValue("Azure-AsyncOperation", out st
 80328                    _pollUri = azureAsyncOperation;
 80329                    return;
 0330                case HeaderFrom.Location when hasLocation:
 0331                    _pollUri = location!;
 0332                    return;
 333            }
 76334        }
 335
 336        private string? GetFinalUri()
 337        {
 32338            if (_headerFrom == HeaderFrom.OperationLocation || _headerFrom == HeaderFrom.AzureAsyncOperation)
 339            {
 24340                if (_requestMethod == RequestMethod.Delete)
 341                {
 4342                    return null;
 343                }
 344
 20345                if (_requestMethod == RequestMethod.Put || (_originalHasLocation && _finalStateVia == OperationFinalStat
 346                {
 20347                    return _originalUri;
 348                }
 349
 0350                if (_originalHasLocation && _finalStateVia == OperationFinalStateVia.Location)
 351                {
 0352                    return _lastKnownLocation;
 353                }
 354            }
 355
 8356            return null;
 357        }
 358    }
 359}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:46:43 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()