Merge pull request #17 from thefringeninja/etags

Add ETag Support

Author: thefringeninja

src/SqlStreamStore.HAL.DevServer/SqlStreamStore.HAL.DevServer.csproj

@@ -2,9 +2,9 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp2.1</TargetFramework>
-    <LangVersion>latest</LangVersion>
     <RuntimeIdentifiers>alpine.3.7-x64</RuntimeIdentifiers>
     <TargetLatestRuntimePatch>true</TargetLatestRuntimePatch>
+    <LangVersion>7.3</LangVersion>
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.AspNetCore.Hosting" Version="2.1.1" />

src/SqlStreamStore.HAL.Tests/ConditionalRequestTests.cs

@@ -0,0 +1,68 @@
+namespace SqlStreamStore.HAL.Tests
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Net;
+    using System.Net.Http;
+    using System.Threading.Tasks;
+    using Shouldly;
+    using SqlStreamStore.Streams;
+    using Xunit;
+
+    public class ConditionalRequestTests : IDisposable
+    {
+        private readonly SqlStreamStoreHalMiddlewareFixture _fixture;
+
+        public ConditionalRequestTests()
+        {
+            _fixture = new SqlStreamStoreHalMiddlewareFixture(true);
+        }
+
+        public static IEnumerable<object[]> IfNoneMatchCases()
+        {
+            var message = new NewStreamMessage(Guid.NewGuid(), "type", "{}", "{}");
+            const string streamId = "stream-1";
+            yield return new object[]
+            {
+                "/stream",
+                new Func<IStreamStore, Task>(
+                    streamStore => streamStore.AppendToStream(streamId, ExpectedVersion.NoStream, message)),
+            };
+            yield return new object[]
+            {
+                $"/streams/{streamId}",
+                new Func<IStreamStore, Task>(
+                    streamStore => streamStore.AppendToStream(streamId, ExpectedVersion.NoStream, message))
+            };
+            yield return new object[]
+            {
+                $"/streams/{streamId}/metadata",
+                new Func<IStreamStore, Task>(
+                    streamStore => streamStore.SetStreamMetadata(streamId, ExpectedVersion.NoStream, 1))
+            };
+        }
+
+        [Theory, MemberData(nameof(IfNoneMatchCases))]
+        public async Task when_match(string path, Func<IStreamStore, Task> operation)
+        {
+            await operation(_fixture.StreamStore);
+
+            using(var unconditionalResponse = await _fixture.HttpClient.SendAsync(
+                new HttpRequestMessage(HttpMethod.Get, path)))
+            {
+                unconditionalResponse.Headers.ETag.ShouldNotBeNull();
+
+                using(var conditionalResponse = await _fixture.HttpClient.SendAsync(
+                    new HttpRequestMessage(HttpMethod.Get, path)
+                    {
+                        Headers = { IfNoneMatch = { unconditionalResponse.Headers.ETag } }
+                    }))
+                {
+                    conditionalResponse.StatusCode.ShouldBe(HttpStatusCode.NotModified);
+                }
+            }
+        }
+
+        public void Dispose() => _fixture.Dispose();
+    }
+}

src/SqlStreamStore.HAL.Tests/RedirectingHandler.cs

@@ -0,0 +1,217 @@
+namespace SqlStreamStore.HAL.Tests
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Net;
+    using System.Net.Http;
+    using System.Threading;
+    using System.Threading.Tasks;
+
+    /// <summary>
+    /// A delegating handler that handles HTTP redirects (301, 302, 303, 307, and 308).
+    /// https://gist.github.com/joelverhagen/3be85bc0d5733756befa#file-redirectinghandler-cs
+    /// </summary>
+    internal class RedirectingHandler : DelegatingHandler
+    {
+        /// <summary>
+        /// The property key used to access the list of responses.
+        /// </summary>
+        public const string HistoryPropertyKey = "Knapcode.Http.Handlers.RedirectingHandler.ResponseHistory";
+
+        private static readonly ISet<HttpStatusCode> s_redirectStatusCodes = new HashSet<HttpStatusCode>(new[]
+        {
+            HttpStatusCode.MovedPermanently,
+            HttpStatusCode.Found,
+            HttpStatusCode.SeeOther,
+            HttpStatusCode.PermanentRedirect,
+        });
+
+        private static readonly ISet<HttpStatusCode> s_keepRequestBodyRedirectStatusCodes = new HashSet<HttpStatusCode>(
+            new[]
+            {
+                HttpStatusCode.TemporaryRedirect,
+                HttpStatusCode.PermanentRedirect,
+            });
+
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RedirectingHandler"/> class.
+        /// </summary>
+        public RedirectingHandler()
+        {
+            AllowAutoRedirect = true;
+            MaxAutomaticRedirections = 50;
+            DisableInnerAutoRedirect = true;
+            DownloadContentOnRedirect = true;
+            KeepResponseHistory = true;
+        }
+
+        /// <summary>
+        /// Gets or sets a value that indicates whether the handler should follow redirection responses.
+        /// </summary>
+        public bool AllowAutoRedirect { get; set; }
+
+        /// <summary>
+        /// Gets or sets the maximum number of redirects that the handler follows.
+        /// </summary>
+        public int MaxAutomaticRedirections { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the response body should be downloaded before each redirection.
+        /// </summary>
+        public bool DownloadContentOnRedirect { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating inner redirections on <see cref="HttpClientHandler"/> and <see cref="RedirectingHandler"/> should be disabled.
+        /// </summary>
+        public bool DisableInnerAutoRedirect { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the response history should be saved to the <see cref="HttpResponseMessage.RequestMessage"/> properties with the key of <see cref="HistoryPropertyKey"/>.
+        /// </summary>
+        public bool KeepResponseHistory { get; set; }
+
+        protected override async Task<HttpResponseMessage> SendAsync(
+            HttpRequestMessage request,
+            CancellationToken cancellationToken)
+        {
+            if(DisableInnerAutoRedirect)
+            {
+                // find the inner-most handler
+                HttpMessageHandler innerHandler = InnerHandler;
+                while(innerHandler is DelegatingHandler)
+                {
+                    if(innerHandler is RedirectingHandler redirectingHandler)
+                    {
+                        redirectingHandler.AllowAutoRedirect = false;
+                    }
+
+                    innerHandler = ((DelegatingHandler) innerHandler).InnerHandler;
+                }
+
+                if(innerHandler is HttpClientHandler httpClientHandler)
+                {
+                    httpClientHandler.AllowAutoRedirect = false;
+                }
+            }
+
+            // buffer the request body, to allow re-use in redirects
+            HttpContent requestBody = null;
+            if(AllowAutoRedirect && request.Content != null)
+            {
+                var buffer = await request.Content.ReadAsByteArrayAsync();
+                requestBody = new ByteArrayContent(buffer);
+                foreach(var header in request.Content.Headers)
+                {
+                    requestBody.Headers.Add(header.Key, header.Value);
+                }
+            }
+
+            // make a copy of the request headers
+            var requestHeaders = request
+                .Headers
+                .Select(p => new KeyValuePair<string, string[]>(p.Key, p.Value.ToArray()))
+                .ToArray();
+
+            // send the initial request
+            var response = await base.SendAsync(request, cancellationToken);
+            var responses = new List<HttpResponseMessage>();
+
+            var redirectCount = 0;
+            while(AllowAutoRedirect && redirectCount < MaxAutomaticRedirections
+                                    && TryGetRedirectLocation(response, out var locationString))
+            {
+                if(DownloadContentOnRedirect && response.Content != null)
+                {
+                    await response.Content.ReadAsByteArrayAsync();
+                }
+
+                Uri previousRequestUri = response.RequestMessage.RequestUri;
+
+                // Credit where credit is due: https://github.com/kennethreitz/requests/blob/master/requests/sessions.py
+                // allow redirection without a scheme
+                if(locationString.StartsWith("//"))
+                {
+                    locationString = previousRequestUri.Scheme + ":" + locationString;
+                }
+
+                var nextRequestUri = new Uri(locationString, UriKind.RelativeOrAbsolute);
+
+                // allow relative redirects
+                if(!nextRequestUri.IsAbsoluteUri)
+                {
+                    nextRequestUri = new Uri(previousRequestUri, nextRequestUri);
+                }
+
+                // override previous method
+                HttpMethod nextMethod = response.RequestMessage.Method;
+                if(response.StatusCode == HttpStatusCode.Moved && nextMethod == HttpMethod.Post
+                   || response.StatusCode == HttpStatusCode.Found && nextMethod != HttpMethod.Head
+                   || response.StatusCode == HttpStatusCode.SeeOther && nextMethod != HttpMethod.Head)
+                {
+                    nextMethod = HttpMethod.Get;
+                    requestBody = null;
+                }
+
+                if(!s_keepRequestBodyRedirectStatusCodes.Contains(response.StatusCode))
+                {
+                    requestBody = null;
+                }
+
+                // build the next request
+                var nextRequest = new HttpRequestMessage(nextMethod, nextRequestUri)
+                {
+                    Content = requestBody,
+                    Version = request.Version
+                };
+
+                foreach(var header in requestHeaders)
+                {
+                    nextRequest.Headers.Add(header.Key, header.Value);
+                }
+
+                foreach(var pair in request.Properties)
+                {
+                    nextRequest.Properties.Add(pair.Key, pair.Value);
+                }
+
+                // keep a history all responses
+                if(KeepResponseHistory)
+                {
+                    responses.Add(response);
+                }
+
+                // send the next request
+                response = await base.SendAsync(nextRequest, cancellationToken);
+
+                request = response.RequestMessage;
+                redirectCount++;
+            }
+
+            // save the history to the request message properties
+            if(KeepResponseHistory && response.RequestMessage != null)
+            {
+                responses.Add(response);
+                response.RequestMessage.Properties.Add(HistoryPropertyKey, responses);
+            }
+
+            return response;
+        }
+
+        private static bool TryGetRedirectLocation(HttpResponseMessage response, out string location)
+        {
+            if(s_redirectStatusCodes.Contains(response.StatusCode)
+               && response.Headers.TryGetValues("Location", out var locations)
+               && (locations = locations.ToArray()).Count() == 1
+               && !string.IsNullOrWhiteSpace(locations.First()))
+            {
+                location = locations.First().Trim();
+                return true;
+            }
+
+            location = null;
+            return false;
+        }
+    }
+}

src/SqlStreamStore.HAL.Tests/SqlStreamStore.HAL.Tests.csproj

@@ -14,6 +14,7 @@
     <DebugSymbols>true</DebugSymbols>
     <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
     <NoWarn>1591</NoWarn>
+    <LangVersion>7.3</LangVersion>
   </PropertyGroup>
   <ItemGroup>
     <ProjectReference Include="..\SqlStreamStore.HAL\SqlStreamStore.HAL.csproj" />

src/SqlStreamStore.HAL.Tests/SqlStreamStoreHalMiddlewareFixture.cs

@@ -17,7 +17,7 @@ internal class SqlStreamStoreHalMiddlewareFixture : IDisposable
 
         private readonly TestServer _server;
 
-        public SqlStreamStoreHalMiddlewareFixture()
+        public SqlStreamStoreHalMiddlewareFixture(bool followRedirects = false)
         {
             StreamStore = new InMemoryStreamStore();
 
@@ -26,7 +26,16 @@ public SqlStreamStoreHalMiddlewareFixture()
                     .ConfigureServices(services => services.AddSingleton<IStartup>(new TestStartup(StreamStore)))
                     .UseSetting(WebHostDefaults.ApplicationKey, "WHY"));
 
-            HttpClient = _server.CreateClient();
+            var handler = _server.CreateHandler();
+            if(followRedirects)
+            {
+                handler = new RedirectingHandler
+                {
+                    InnerHandler = handler
+                };
+            }
+
+            HttpClient = new HttpClient(handler) { BaseAddress = new UriBuilder().Uri };
             HttpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/hal+json"));
         }
 

src/SqlStreamStore.HAL.Tests/StreamMessageTests.cs

@@ -2,6 +2,7 @@
 {
     using System;
     using System.Net;
+    using System.Net.Http.Headers;
     using System.Threading.Tasks;
     using Shouldly;
     using Xunit;
@@ -20,12 +21,12 @@ public StreamMessageTests()
         [Fact]
         public async Task read_single_message_stream()
         {
-            // position of event in all stream would be helpful here
             var writeResult = await _fixture.WriteNMessages("a-stream", 1);
 
             using(var response = await _fixture.HttpClient.GetAsync("/streams/a-stream/0"))
             {
                 response.StatusCode.ShouldBe(HttpStatusCode.OK);
+                response.Headers.ETag.ShouldBe(new EntityTagHeaderValue($@"""{writeResult.CurrentVersion}"""));
 
                 var resource = await response.AsHal();
 
@@ -56,6 +57,7 @@ public async Task read_single_message_does_not_exist_stream()
             using(var response = await _fixture.HttpClient.GetAsync("/streams/a-stream/0"))
             {
                 response.StatusCode.ShouldBe(HttpStatusCode.NotFound);
+                response.Headers.ETag.ShouldBeNull();
 
                 var resource = await response.AsHal();
 
@@ -91,6 +93,7 @@ public async Task delete_single_message_by_version()
             using(var response = await _fixture.HttpClient.GetAsync("/streams/a-stream/0"))
             {
                 response.StatusCode.ShouldBe(HttpStatusCode.NotFound);
+                response.Headers.ETag.ShouldBeNull();
             }
         }
     }

src/SqlStreamStore.HAL.Tests/StreamMetadataTests.cs

@@ -30,6 +30,7 @@ await _fixture.HttpClient.SendAsync(
                     new HttpRequestMessage(HttpMethod.Get, $"/streams/{StreamId}/metadata")))
             {
                 response.StatusCode.ShouldBe(HttpStatusCode.NotFound);
+                response.Headers.ETag.ShouldBe(new EntityTagHeaderValue(@"""-1"""));
 
                 var resource = await response.AsHal();
 
@@ -72,6 +73,7 @@ await _fixture.HttpClient.SendAsync(
                     new HttpRequestMessage(HttpMethod.Get, $"/streams/{StreamId}/metadata")))
             {
                 response.StatusCode.ShouldBe(HttpStatusCode.OK);
+                response.Headers.ETag.ShouldBe(new EntityTagHeaderValue(@"""0"""));
 
                 var resource = await response.AsHal();