Merge pull request #15 from thefringeninja/head

Code Improvments

Author: thefringeninja

src/SqlStreamStore.HAL/ExceptionHandlingMiddleware.cs

@@ -3,6 +3,7 @@
     using System;
     using System.Collections.Generic;
     using Halcyon.HAL;
+    using Microsoft.AspNetCore.Builder;
     using Newtonsoft.Json;
     using SqlStreamStore.Streams;
     using MidFunc = System.Func<
@@ -45,7 +46,10 @@ private static readonly IDictionary<Type, Func<Exception, Response>> s_exception
                 [typeof(Exception)] = s_defaultExceptionHandler
             };
 
-        public static MidFunc HandleExceptions => async (context, next) =>
+        public static IApplicationBuilder UseExceptionHandling(this IApplicationBuilder builder)
+            => builder.Use(HandleExceptions);
+
+        private static MidFunc HandleExceptions => async (context, next) =>
         {
             try
             {

src/SqlStreamStore.HAL/IndexMiddleware.cs

@@ -17,18 +17,15 @@ public static IApplicationBuilder UseIndex(this IApplicationBuilder builder)
         private static bool IsIndex(HttpContext context)
             => (context.Request.Path.Value ?? "/") == "/";
 
-        private static MidFunc Index => async (context, next) =>
+        private static MidFunc Index => (context, next) =>
         {
             var response = new Response(new HALResponse(null)
                 .AddLinks(new Link(Constants.Relations.Feed, "stream"))
                 .AddLinks(new Link(Constants.Relations.Self, string.Empty))
                 .AddLinks(Links.Index(string.Empty))
                 .AddLinks(Links.Find("streams/{streamId}")));
 
-            using(new OptionalHeadRequestWrapper(context))
-            {
-                await context.WriteHalResponse(response);
-            }
+            return context.WriteHalResponse(response);
         };
     }
 }

src/SqlStreamStore.HAL/OptionalHeadRequestWrapper.cs

@@ -34,22 +34,16 @@ private static MidFunc GetStream(AllStreamResource allStream) => async (context,
 
             var response = await allStream.Get(options, context.RequestAborted);
 
-            using(new OptionalHeadRequestWrapper(context))
-            {
-                await context.WriteHalResponse(response);
-            }
+            await context.WriteHalResponse(response);
         };
 
-        private static MidFunc GetStreamMessage(AllStreamMessageResource allStreamMessages) => async (context, next) => 
+        private static MidFunc GetStreamMessage(AllStreamMessageResource allStreamMessages) => async (context, next) =>
         {
             var response = await allStreamMessages.Get(
                 new ReadAllStreamMessageOperation(context.Request),
                 context.RequestAborted);
 
-            using(new OptionalHeadRequestWrapper(context))
-            {
-                await context.WriteHalResponse(response);
-            }
+            await context.WriteHalResponse(response);
         };
     }
 }

src/SqlStreamStore.HAL/ReadAllStreamMiddleware.cs

@@ -33,10 +33,7 @@ private static MidFunc GetStream(StreamResource streams) => async (context, next
 
             var response = await streams.Get(options, context.RequestAborted);
 
-            using(new OptionalHeadRequestWrapper(context))
-            {
-                await context.WriteHalResponse(response);
-            }
+            await context.WriteHalResponse(response);
         };
 
         private static MidFunc GetStreamMessage(StreamMessageResource streamMessages) => async (context, next) =>
@@ -45,10 +42,7 @@ private static MidFunc GetStreamMessage(StreamMessageResource streamMessages) =>
 
             var response = await streamMessages.Get(options, context.RequestAborted);
 
-            using(new OptionalHeadRequestWrapper(context))
-            {
-                await context.WriteHalResponse(response);
-            }
+            await context.WriteHalResponse(response);
         };
     }
 }

src/SqlStreamStore.HAL/ReadStreamMiddleware.cs

@@ -1,7 +1,9 @@
 namespace SqlStreamStore.HAL
 {
     using System;
+    using System.IO;
     using System.Linq;
+    using System.Threading;
     using System.Threading.Tasks;
     using Halcyon.HAL;
     using Microsoft.AspNetCore.Builder;
@@ -57,6 +59,13 @@ private static MidFunc MethodsNotAllowed(params string[] methods) => (context, n
                     406));
         };
 
+        private static MidFunc HeadRequests => async (context, next) =>
+        {
+            using(new OptionalHeadRequestWrapper(context))
+            {
+                await next();
+            }
+        };
         public static IApplicationBuilder UseSqlStreamStoreHal(
             this IApplicationBuilder builder,
             IStreamStore streamStore)
@@ -67,9 +76,10 @@ public static IApplicationBuilder UseSqlStreamStoreHal(
                 throw new ArgumentNullException(nameof(streamStore));
 
             return builder
-                .Use(ExceptionHandlingMiddleware.HandleExceptions)
+                .UseExceptionHandling()
                 .Use(CaseSensitiveQueryStrings)
                 .Use(AcceptHalJson)
+                .Use(HeadRequests)
                 .UseIndex()
                 .Map("/stream", UseAllStream(streamStore))
                 .Map("/streams", UseStream(streamStore));
@@ -91,5 +101,56 @@ private static Action<IApplicationBuilder> UseAllStream(IStreamStore streamStore
                 .Use(MethodsNotAllowed("POST", "PUT", "DELETE", "TRACE", "PATCH"));
 
         private static bool IsOptions(HttpContext context) => context.IsOptions();
+
+        private class OptionalHeadRequestWrapper : IDisposable
+        {
+            private readonly HttpContext _context;
+            private readonly Stream _originalBody;
+
+            public OptionalHeadRequestWrapper(HttpContext context)
+            {
+                _context = context;
+                _originalBody = _context.Response.Body;
+                if(context.Request.Method == "HEAD")
+                {
+                    context.Response.Body = new HeadRequestStream();
+                }
+            }
+
+            public void Dispose()
+            {
+                _context.Response.Body = _originalBody;
+            }
+
+            private class HeadRequestStream : Stream
+            {
+                private long _length;
+
+                public override void Flush() => FlushAsync(CancellationToken.None).Wait();
+                public override int Read(byte[] buffer, int offset, int count) => throw new NotImplementedException();
+                public override long Seek(long offset, SeekOrigin origin) => throw new NotImplementedException();
+                public override void SetLength(long value) => throw new NotImplementedException();
+                public override void Write(byte[] buffer, int offset, int count) => throw new NotImplementedException();
+
+                public override Task WriteAsync(
+                    byte[] buffer,
+                    int offset,
+                    int count,
+                    CancellationToken cancellationToken)
+                {
+                    _length += count;
+                    Position += count;
+                    return Task.CompletedTask;
+                }
+
+                public override Task FlushAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+
+                public override bool CanRead { get; } = false;
+                public override bool CanSeek { get; } = false;
+                public override bool CanWrite { get; } = true;
+                public override long Length => _length;
+                public override long Position { get; set; }
+            }
+        }
     }
 }

src/SqlStreamStore.HAL/SqlStreamStoreHalMiddleware.cs

@@ -43,10 +43,7 @@ private static MidFunc GetStreamMetadata(StreamMetadataResource streamsMetadata)
 
                 var response = await streamsMetadata.Get(options, context.RequestAborted);
 
-                using(new OptionalHeadRequestWrapper(context))
-                {
-                    await context.WriteHalResponse(response);
-                }
+                await context.WriteHalResponse(response);
             };
     }
 }