< Summary

Class:Azure.Core.ArmOperationHelpers`1
Assembly:Azure.Iot.Hub.Service
File(s):C:\Git\azure-sdk-for-net\sdk\core\Azure.Core\src\Shared\AutoRest\ArmOperationHelpers.cs
Covered lines:0
Uncovered lines:155
Coverable lines:155
Total lines:359
Line coverage:0% (0 of 155)
Covered branches:0
Total branches:98
Branch coverage:0% (0 of 98)

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
get_DefaultPollingInterval()-0%100%
.cctor()-0%100%
.ctor(...)-0%100%
GetRawResponse()-0%100%
WaitForCompletionAsync(...)-0%100%
WaitForCompletionAsync()-0%0%
UpdateStatusAsync()-0%0%
UpdateStatusAsync()-0%100%
UpdateStatus(...)-0%100%
get_Id()-0%100%
get_Value()-0%0%
get_HasCompleted()-0%100%
get_HasValue()-0%100%
CreateRequest(...)-0%100%
GetResponseAsync()-0%0%
GetResponse(...)-0%0%
IsTerminalState(...)-0%0%
InitializeScenarioInfo()-0%0%
UpdatePollUri()-0%0%
GetFinalUri()-0%0%

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
 027        private static readonly string[] s_failureStates = {"failed", "canceled"};
 028        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
 048        public ArmOperationHelpers(
 049            IOperationSource<T> source,
 050            ClientDiagnostics clientDiagnostics,
 051            HttpPipeline pipeline,
 052            Request originalRequest,
 053            Response originalResponse,
 054            OperationFinalStateVia finalStateVia,
 055            string scopeName)
 56        {
 057            _source = source;
 058            _rawResponse = originalResponse;
 059            _requestMethod = originalRequest.Method;
 060            _originalUri = originalRequest.Uri.ToString();
 061            _finalStateVia = finalStateVia;
 062            InitializeScenarioInfo();
 63
 064            _pipeline = pipeline;
 065            _clientDiagnostics = clientDiagnostics;
 066            _scopeName = scopeName;
 67            // When the original response has no headers, we do not start polling immediately.
 068            _shouldPoll = _headerFrom != HeaderFrom.None;
 069        }
 70
 071        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        {
 080            while (true)
 81            {
 082                await UpdateStatusAsync(cancellationToken).ConfigureAwait(false);
 083                if (HasCompleted)
 84                {
 085                    return Response.FromValue(Value, GetRawResponse());
 86                }
 87
 088                await Task.Delay(pollingInterval, cancellationToken).ConfigureAwait(false);
 89            }
 090        }
 91
 92        private async ValueTask<Response> UpdateStatusAsync(bool async, CancellationToken cancellationToken)
 93        {
 094            if (_hasCompleted)
 95            {
 096                return GetRawResponse();
 97            }
 98
 099            if (_shouldPoll)
 100            {
 0101                UpdatePollUri();
 0102                _rawResponse = async
 0103                    ? await GetResponseAsync(_pollUri, cancellationToken).ConfigureAwait(false)
 0104                    : GetResponse(_pollUri, cancellationToken);
 105            }
 106
 0107            _shouldPoll = true;
 0108            _hasCompleted = IsTerminalState(out string state);
 0109            if (_hasCompleted)
 110            {
 0111                Response finalResponse = GetRawResponse();
 0112                if (s_failureStates.Contains(state))
 113                {
 0114                    throw _clientDiagnostics.CreateRequestFailedException(finalResponse);
 115                }
 116
 0117                string? finalUri = GetFinalUri();
 0118                if (finalUri != null)
 119                {
 0120                    finalResponse = async
 0121                        ? await GetResponseAsync(finalUri, cancellationToken).ConfigureAwait(false)
 0122                        : GetResponse(finalUri, cancellationToken);
 123                }
 124
 0125                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                    {
 0131                        _value = async
 0132                            ? await _source.CreateResultAsync(finalResponse, cancellationToken).ConfigureAwait(false)
 0133                            : _source.CreateResult(finalResponse, cancellationToken);
 0134                        _rawResponse = finalResponse;
 0135                        _hasValue = true;
 0136                        break;
 137                    }
 138                    default:
 0139                        throw _clientDiagnostics.CreateRequestFailedException(finalResponse);
 140                }
 0141            }
 142
 0143            return GetRawResponse();
 0144        }
 145
 0146        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            {
 0159                if (!HasValue)
 160                {
 0161                    throw new InvalidOperationException("The operation has not completed yet.");
 162                }
 163
 0164                return _value;
 165            }
 166        }
 167
 0168        public bool HasCompleted => _hasCompleted;
 0169        public bool HasValue => _hasValue;
 170
 171        private HttpMessage CreateRequest(string link)
 172        {
 0173            HttpMessage message = _pipeline.CreateMessage();
 0174            Request request = message.Request;
 0175            request.Method = RequestMethod.Get;
 0176            request.Uri.Reset(new Uri(link));
 0177            return message;
 178        }
 179
 180        private async ValueTask<Response> GetResponseAsync(string link, CancellationToken cancellationToken = default)
 181        {
 0182            if (link == null)
 183            {
 0184                throw new ArgumentNullException(nameof(link));
 185            }
 186
 0187            using DiagnosticScope scope = _clientDiagnostics.CreateScope(_scopeName);
 0188            scope.Start();
 189            try
 190            {
 0191                using HttpMessage message = CreateRequest(link);
 0192                await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 0193                return message.Response;
 194            }
 0195            catch (Exception e)
 196            {
 0197                scope.Failed(e);
 0198                throw;
 199            }
 0200        }
 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        {
 0226            Response response = GetRawResponse();
 0227            state = string.Empty;
 0228            if (_headerFrom == HeaderFrom.Location)
 229            {
 0230                return response.Status != 202;
 231            }
 232
 0233            if (response.Status >= 200 && response.Status <= 204)
 234            {
 0235                if (response.ContentStream?.Length > 0)
 236                {
 237                    try
 238                    {
 0239                        using JsonDocument document = JsonDocument.Parse(response.ContentStream);
 0240                        foreach (JsonProperty property in document.RootElement.EnumerateObject())
 241                        {
 0242                            if ((_headerFrom == HeaderFrom.OperationLocation ||
 0243                                 _headerFrom == HeaderFrom.AzureAsyncOperation) &&
 0244                                property.NameEquals("status"))
 245                            {
 0246                                state = property.Value.GetString().ToLowerInvariant();
 0247                                return s_terminalStates.Contains(state);
 248                            }
 249
 0250                            if (_headerFrom == HeaderFrom.None && property.NameEquals("properties"))
 251                            {
 0252                                foreach (JsonProperty innerProperty in property.Value.EnumerateObject())
 253                                {
 0254                                    if (innerProperty.NameEquals("provisioningState"))
 255                                    {
 0256                                        state = innerProperty.Value.GetString().ToLowerInvariant();
 0257                                        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
 0266                        response.ContentStream.Position = 0;
 0267                    }
 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);
 0278        }
 279
 280        private enum HeaderFrom
 281        {
 282            None,
 283            OperationLocation,
 284            AzureAsyncOperation,
 285            Location
 286        }
 287
 288        private void InitializeScenarioInfo()
 289        {
 0290            _originalHasLocation = _rawResponse.Headers.Contains("Location");
 291
 0292            if (_rawResponse.Headers.Contains("Operation-Location"))
 293            {
 0294                _headerFrom = HeaderFrom.OperationLocation;
 0295                return;
 296            }
 297
 0298            if (_rawResponse.Headers.Contains("Azure-AsyncOperation"))
 299            {
 0300                _headerFrom = HeaderFrom.AzureAsyncOperation;
 0301                return;
 302            }
 303
 0304            if (_originalHasLocation)
 305            {
 0306                _headerFrom = HeaderFrom.Location;
 0307                return;
 308            }
 309
 0310            _pollUri = _originalUri;
 0311            _headerFrom = HeaderFrom.None;
 0312        }
 313
 314        private void UpdatePollUri()
 315        {
 0316            var hasLocation = _rawResponse.Headers.TryGetValue("Location", out string? location);
 0317            if (hasLocation)
 318            {
 0319                _lastKnownLocation = location;
 320            }
 321
 0322            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;
 0330                case HeaderFrom.Location when hasLocation:
 0331                    _pollUri = location!;
 0332                    return;
 333            }
 0334        }
 335
 336        private string? GetFinalUri()
 337        {
 0338            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
 0356            return null;
 357        }
 358    }
 359}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:46:42 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()