Ensure HttpApplicaiton raises SessionStart (#551)

This fixes two issues that combined to not raise this event:

- A typo sent the event SessionEnd instead of SessionStart
- Wrapped ASP.NET Core session didn't implement the IsNewSession - it was always false. Now we check if there are any keys to determine if it is a new session

Author: twsouthwick

src/Microsoft.AspNetCore.SystemWebAdapters.CoreServices/SessionEventsMiddleware.cs

@@ -19,19 +19,51 @@ public SessionEventsMiddleware(RequestDelegate next)
 
     public async Task InvokeAsync(HttpContextCore context)
     {
-        var app = context.Features.GetRequiredFeature<IHttpApplicationFeature>();
-        var session = context.AsSystemWeb().Session;
+        if (await RunEventAsync(context, ApplicationEvent.AcquireRequestState))
+        {
+            return;
+        }
+
+        if (context.AsSystemWeb().Session is { IsNewSession: true })
+        {
+            if (await RunEventAsync(context, ApplicationEvent.SessionStart))
+            {
+                return;
+            }
+        }
 
-        if (session is { IsNewSession: true })
+        if (await RunEventAsync(context, ApplicationEvent.PostAcquireRequestState))
         {
-            await app.RaiseEventAsync(ApplicationEvent.SessionEnd);
+            return;
         }
 
         await _next(context);
 
-        if (session is { State.IsAbandoned: true })
+        if (context.Features.GetRequiredFeature<IHttpResponseEndFeature>().IsEnded)
+        {
+            return;
+        }
+
+        if (await RunEventAsync(context, ApplicationEvent.ReleaseRequestState))
         {
-            await app.RaiseEventAsync(ApplicationEvent.SessionEnd);
+            return;
         }
+
+        if (context.AsSystemWeb().Session is { State.IsAbandoned: true })
+        {
+            if (await RunEventAsync(context, ApplicationEvent.SessionEnd))
+            {
+                return;
+            }
+        }
+
+        await context.Features.GetRequiredFeature<IHttpApplicationFeature>().RaiseEventAsync(ApplicationEvent.PostReleaseRequestState);
+    }
+
+    private static async ValueTask<bool> RunEventAsync(HttpContextCore context, ApplicationEvent @event)
+    {
+        await context.Features.GetRequiredFeature<IHttpApplicationFeature>().RaiseEventAsync(@event);
+
+        return context.Features.GetRequiredFeature<IHttpResponseEndFeature>().IsEnded;
     }
 }

src/Microsoft.AspNetCore.SystemWebAdapters.CoreServices/SessionState/Wrapped/AspNetCoreSessionState.cs

@@ -26,6 +26,7 @@ public AspNetCoreSessionState(ISession session, ISessionKeySerializer serializer
         _throwOnUnknown = throwOnUnknown;
         _logger = factory.CreateLogger<AspNetCoreSessionState>();
 
+        IsNewSession = !session.Keys.Any();
         IsReadOnly = isReadOnly;
     }
 
@@ -99,7 +100,7 @@ public object? this[string key]
 
     public int Timeout { get; set; } = 20;
 
-    public bool IsNewSession => false;
+    public bool IsNewSession { get; }
 
     public int Count => _session.Keys.Count();
 

src/Microsoft.AspNetCore.SystemWebAdapters.CoreServices/SystemWebAdaptersExtensions.cs

@@ -96,13 +96,9 @@ public static void UseSystemWebAdapters(this IApplicationBuilder app)
                 ApplicationEvent.PostResolveRequestCache,
                 ApplicationEvent.MapRequestHandler,
                 ApplicationEvent.PostMapRequestHandler,
-                ApplicationEvent.AcquireRequestState,
-                ApplicationEvent.PostAcquireRequestState,
             },
             postEvents: new[]
             {
-                ApplicationEvent.ReleaseRequestState,
-                ApplicationEvent.PostReleaseRequestState,
                 ApplicationEvent.UpdateRequestCache,
                 ApplicationEvent.PostUpdateRequestCache,
             });

test/Microsoft.AspNetCore.SystemWebAdapters.CoreServices.Tests/SessionState/SessionIntegrationTests.cs

@@ -5,6 +5,7 @@
 using System;
 using System.Net.Http;
 using System.Threading.Tasks;
+using System.Web;
 using System.Web.SessionState;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
@@ -52,6 +53,84 @@ public async Task TestOverrideSessionStateBehavior(string endpoint, string expec
         Assert.Equal(expected, actual);
     }
 
+    [InlineData(true)]
+    [InlineData(false)]
+    [Theory]
+    public async Task SessionStartEvent(bool abandon)
+    {
+        // Arrange
+        using var host = await new HostBuilder()
+           .ConfigureWebHost(webBuilder =>
+           {
+               webBuilder
+                   .UseTestServer(options =>
+                   {
+                       options.AllowSynchronousIO = true;
+                   })
+                   .ConfigureServices(services =>
+                   {
+                       services.AddRouting();
+                       services.AddControllers();
+                       services.AddSystemWebAdapters()
+                         .AddHttpApplication<SessionApplication>()
+                         .AddWrappedAspNetCoreSession();
+
+                       services.AddDistributedMemoryCache();
+                   })
+                   .Configure(app =>
+                   {
+                       app.UseRouting();
+                       app.UseSession();
+                       app.UseSystemWebAdapters();
+
+                       if (abandon)
+                       {
+                           app.Use((ctx, next) =>
+                           {
+                               ctx.AsSystemWeb().Session!.Abandon();
+                               return next(ctx);
+                           });
+                       }
+
+                       app.UseEndpoints(endpoints =>
+                       {
+                           endpoints.MapGet("/", ctx => Task.CompletedTask)
+                            .RequireSystemWebAdapterSession();
+                       });
+                   });
+           })
+           .StartAsync();
+
+        // Act
+        var result = await host.GetTestClient().GetStringAsync(new Uri("/", UriKind.Relative));
+
+        // Assert
+        if (abandon)
+        {
+            Assert.Equal("SessionStart::SessionEnd", result);
+        }
+        else
+        {
+
+            Assert.Equal("SessionStart::", result);
+        }
+
+        await host.StopAsync();
+    }
+
+    private sealed class SessionApplication : HttpApplication
+    {
+        private void Session_Start(Object sender, EventArgs e)
+        {
+            HttpContext.Current?.Response.Write("SessionStart::");
+        }
+
+        private void Session_End(Object sender, EventArgs e)
+        {
+            HttpContext.Current?.Response.Write("SessionEnd");
+        }
+    }
+
     private static async Task<string> GetAsync(string endpoint)
     {
         using var host = await new HostBuilder()