Retry requests on 401 Unauthorized result

When a token expires, the API returns 401 Unauthorized. At that point
the SDK should request a new token and retry the request.

The new OpenStack.HttpTest class enables unit testing this behavior.
If the Flurl HttpTest class is used, then our special message handler is
not used and this authentication behavior is not exercised in unit tests.
Which should not be an issue, unless the user was explicitly attempting
to test out the retry logic.

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;
+            }
+        }
+    }
+}