Merge pull request #526 from carolynvs/retry-on-token-expiration

Retry requests on 401 Unauthorized result

Author: carolynvs

src/corelib/Authentication/AuthenticatedHttpClientFactory.cs

@@ -0,0 +1,26 @@
+using System.Net.Http;
+using Flurl;
+using Flurl.Http;
+using Flurl.Http.Configuration;
+
+namespace OpenStack.Authentication
+{
+    /// <summary>
+    /// Instructs Flurl to use our <see cref="AuthenticatedMessageHandler"/> for all requests.
+    /// </summary>
+    internal class AuthenticatedHttpClientFactory : DefaultHttpClientFactory
+    {
+        public override HttpClient CreateClient(Url url, HttpMessageHandler handler)
+        {
+            return new HttpClient(handler)
+            {
+                Timeout = FlurlHttp.Configuration.DefaultTimeout
+            };
+        }
+
+        public override HttpMessageHandler CreateMessageHandler()
+        {
+            return new AuthenticatedMessageHandler(base.CreateMessageHandler());
+        }
+    }
+}

src/corelib/Authentication/AuthenticatedMessageHandler.cs

@@ -0,0 +1,43 @@
+using System.Net;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Flurl.Http;
+using Flurl.Http.Configuration;
+
+namespace OpenStack.Authentication
+{
+    /// <summary>
+    /// Used by Flurl for all requests. Understands how to authenticate and retry when a token expires.
+    /// </summary>
+    internal class AuthenticatedMessageHandler : FlurlMessageHandler
+    {
+        public AuthenticatedMessageHandler(HttpMessageHandler innerHandler) 
+            : base(innerHandler)
+        { }
+
+        public IAuthenticationProvider AuthenticationProvider;
+
+        protected async override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            string token = await AuthenticationProvider.GetToken(cancellationToken).ConfigureAwait(false);
+            request.Headers.SetAuthToken(token);
+
+            try
+            {
+                return await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
+            }
+            catch (FlurlHttpException ex)
+            {
+                if (ex.Call.HttpStatus != HttpStatusCode.Unauthorized)
+                    throw;
+            }
+                
+            // Retry with a new token
+            var retryRequest = request.Copy();
+            var retryToken = await AuthenticationProvider.GetToken(cancellationToken).ConfigureAwait(false);
+            retryRequest.Headers.SetAuthToken(retryToken);
+            return await base.SendAsync(retryRequest, cancellationToken).ConfigureAwait(false);
+        }
+    }
+}

src/corelib/Authentication/ServiceUrlBuilder.cs

@@ -1,7 +1,6 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Flurl;
-using Flurl.Http;
 
 namespace OpenStack.Authentication
 {
@@ -25,16 +24,5 @@ public async Task<Url> GetEndpoint(CancellationToken cancellationToken)
             string endpoint = await _authenticationProvider.GetEndpoint(_serviceType, _region, _useInternalUrl, cancellationToken).ConfigureAwait(false);
             return new Url(endpoint);
         }
-
-        public async Task<string> GetToken(CancellationToken cancellationToken)
-        {
-            return await _authenticationProvider.GetToken(cancellationToken).ConfigureAwait(false);
-        }
-
-        public async Task<FlurlClient> Authenticate(FlurlClient client, CancellationToken cancellationToken)
-        {
-            string token = await GetToken(cancellationToken).ConfigureAwait(false);
-            return client.Authenticate(token);
-        }
     }
 }

src/corelib/Configuration.cs

@@ -0,0 +1,67 @@
+using System;
+using Flurl.Http;
+using Flurl.Http.Configuration;
+using Newtonsoft.Json;
+using OpenStack.Authentication;
+using OpenStack.Serialization;
+
+namespace OpenStack
+{
+    /// <summary>
+    /// A static container for global configuration settings affecting OpenStack.NET behavior.
+    /// </summary>
+    /// <threadsafety static="true" instance="false"/>
+    public static class OpenStackNet
+    {
+        private static readonly object ConfigureLock = new object();
+        private static bool _isConfigured = false;
+
+        /// <summary>
+        /// Provides thread-safe accesss to OpenStack.NET's global configuration options.
+        /// <para>
+        /// Can only be called once at application start-up, before instantiating any OpenStack.NET objects.
+        /// </para>
+        /// </summary>
+        /// <param name="configureFlurl">Addtional configuration of Flurl's global settings <seealso cref="Flurl.Http.FlurlHttp.Configure"/>.</param>
+        /// <param name="configureJson">Additional configuration of Json.NET's glboal settings <seealso cref="Newtonsoft.Json.JsonConvert.DefaultSettings"/>.</param>
+        public static void Configure(Action<FlurlHttpConfigurationOptions> configureFlurl = null, Action<JsonSerializerSettings> configureJson = null)
+        {
+            if (_isConfigured)
+                return;
+
+            lock (ConfigureLock)
+            {
+                if (_isConfigured)
+                    return;
+
+                JsonConvert.DefaultSettings = () =>
+                {
+                    // Apply our default settings
+                    var settings = new JsonSerializerSettings
+                    {
+                        DefaultValueHandling = DefaultValueHandling.Ignore,
+                        NullValueHandling = NullValueHandling.Ignore,
+                        ContractResolver = new EmptyEnumerableResolver()
+                    };
+
+                    // Apply application's default settings
+                    if (configureJson != null)
+                        configureJson(settings);
+                    return settings;
+                };
+
+                FlurlHttp.Configure(c =>
+                {
+                    // Apply our default settings
+                    c.HttpClientFactory = new AuthenticatedHttpClientFactory();
+
+                    // Apply application's default settings
+                    if (configureFlurl != null)
+                        configureFlurl(c);
+                });
+
+                _isConfigured = true;
+            }
+        }
+    }
+}