Merge pull request #55 from tpeczek/46-controlling-format-of-keep-alive

Adding options to configure the format of keepalive. Resolves #46

Author: tpeczek

DocFx.AspNetCore.ServerSentEvents/index.md

@@ -12,7 +12,7 @@ You can install [Lib.AspNetCore.ServerSentEvents](https://www.nuget.org/packages
 PM>  Install-Package Lib.AspNetCore.ServerSentEvents
 ```
 
-The configuration and basic usage patterns are described [here](articles/getting-started.md).
+The configuration and basic usage patterns are described [here](articles/getting-started.html).
 
 ## Demos
 

Lib.AspNetCore.ServerSentEvents/Lib.AspNetCore.ServerSentEvents.csproj

@@ -12,6 +12,7 @@
     <PackageTags>aspnetcore;sse;server-sent;events;eventsource</PackageTags>
     <PackageProjectUrl>https://github.com/tpeczek/Lib.AspNetCore.ServerSentEvents</PackageProjectUrl>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
     <RepositoryType>git</RepositoryType>
     <RepositoryUrl>git://github.com/tpeczek/Lib.AspNetCore.ServerSentEvents</RepositoryUrl>
     <GenerateAssemblyTitleAttribute>true</GenerateAssemblyTitleAttribute>

Lib.AspNetCore.ServerSentEvents/ServerSentEventsEndpointRouteBuilderExtensions.cs

@@ -1,4 +1,4 @@
-#if !NETCOREAPP2_1 && !NET461
+#if !NET461
 using System;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Builder;

Lib.AspNetCore.ServerSentEvents/ServerSentEventsKeepaliveKind.cs

@@ -0,0 +1,17 @@
+namespace Lib.AspNetCore.ServerSentEvents
+{
+    /// <summary>
+    /// The kind of content for keepalive.
+    /// </summary>
+    public enum ServerSentEventsKeepaliveKind
+    {
+        /// <summary>
+        /// The keepalive will be send as a comment.
+        /// </summary>
+        Comment,
+        /// <summary>
+        /// The keepalive will be send as an event.
+        /// </summary>
+        Event
+    }
+}

Lib.AspNetCore.ServerSentEvents/ServerSentEventsKeepaliveService.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Collections.Generic;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Options;
 using Lib.AspNetCore.ServerSentEvents.Internals;
@@ -12,7 +13,7 @@ internal class ServerSentEventsKeepaliveService<TServerSentEventsService> : IHos
     {
         #region Fields
         private readonly bool _isBehindAncm = IsBehindAncm();
-        private readonly static ServerSentEventBytes _keepaliveServerSentEventBytes = ServerSentEventsHelper.GetCommentBytes("KEEPALIVE");
+        private readonly ServerSentEventBytes _keepaliveServerSentEventBytes;
 
         private readonly CancellationTokenSource _stoppingCts = new CancellationTokenSource();
 
@@ -26,7 +27,11 @@ internal class ServerSentEventsKeepaliveService<TServerSentEventsService> : IHos
         public ServerSentEventsKeepaliveService(TServerSentEventsService serverSentEventsService, IOptions<ServerSentEventsServiceOptions<TServerSentEventsService>> options)
         {
             _options = options?.Value ?? throw new ArgumentNullException(nameof(options));
+
             _serverSentEventsService = serverSentEventsService;
+            _keepaliveServerSentEventBytes = (_options.KeepaliveKind == ServerSentEventsKeepaliveKind.Comment)
+                ? ServerSentEventsHelper.GetCommentBytes(_options.KeepaliveContent)
+                : ServerSentEventsHelper.GetEventBytes(new ServerSentEvent { Type = _options.KeepaliveContent, Data = new List<string> { String.Empty } });
         }
         #endregion
 

Lib.AspNetCore.ServerSentEvents/ServerSentEventsMiddleware.cs

@@ -217,7 +217,7 @@ private async Task ForbidAsync(HttpContext context)
 
         private void DisableResponseBuffering(HttpContext context)
         {
-#if !NETCOREAPP2_1 && !NET461
+#if !NET461
             IHttpResponseBodyFeature responseBodyFeature = context.Features.Get<IHttpResponseBodyFeature>();
             if (responseBodyFeature != null)
             {

Lib.AspNetCore.ServerSentEvents/ServerSentEventsServiceOptions.cs

@@ -8,9 +8,11 @@ namespace Lib.AspNetCore.ServerSentEvents
     /// </summary>
     public class ServerSentEventsServiceOptions<TServerSentEventsService> where TServerSentEventsService : ServerSentEventsService
     {
-        internal const int DEFAULT_KEEPALIVE_INTERVAL = 30;
+        private const int DEFAULT_KEEPALIVE_INTERVAL = 30;
+        private const string DEFAULT_KEEPALIVE_CONTENT = "KEEPALIVE";
 
         private int _keepaliveInterval = DEFAULT_KEEPALIVE_INTERVAL;
+        private string _keepaliveContent = DEFAULT_KEEPALIVE_CONTENT;
 
         /// <summary>
         /// Gets or sets the keepalive sending mode.
@@ -35,6 +37,29 @@ public int KeepaliveInterval
             }
         }
 
+        /// <summary>
+        /// Gets or sets the kind of content for keepalive.
+        /// </summary>
+        public ServerSentEventsKeepaliveKind KeepaliveKind { get; set; } = ServerSentEventsKeepaliveKind.Comment;
+
+        /// <summary>
+        /// Gets or sets the content for keepalive. If the <see cref="KeepaliveKind"/> is <see cref="ServerSentEventsKeepaliveKind.Comment"/> it will be the content of the comment. If the <see cref="KeepaliveKind"/> is <see cref="ServerSentEventsKeepaliveKind.Event"/> it will be the type of the event.
+        /// </summary>
+        public string KeepaliveContent
+        {
+            get { return _keepaliveContent; }
+
+            set
+            {
+                if (String.IsNullOrWhiteSpace(value))
+                {
+                    throw new ArgumentNullException(nameof(value));
+                }
+
+                _keepaliveContent = value;
+            }
+        }
+
         /// <summary>
         /// Gets or sets the interval after which clients will attempt to reestablish failed connections.
         /// </summary>

Test.AspNetCore.ServerSentEvents/Functional/Infrastructure/FakeServerSentEventsServerStartup.cs

@@ -0,0 +1,43 @@
+using System;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Lib.AspNetCore.ServerSentEvents;
+
+namespace Test.AspNetCore.ServerSentEvents.Functional.Infrastructure
+{
+    internal abstract class FakeServerSentEventsServerStartup
+    {
+        public const string SERVER_SENT_EVENTS_ENDPOINT = "/sse";
+
+        protected abstract Action<ServerSentEventsServiceOptions<ServerSentEventsService>> ConfigureServerSentEventsOption { get; }
+
+        public IConfiguration Configuration { get; }
+
+        public FakeServerSentEventsServerStartup(IConfiguration configuration)
+        {
+            Configuration = configuration;
+        }
+
+        public void ConfigureServices(IServiceCollection services)
+        {
+            services.AddServerSentEvents(ConfigureServerSentEventsOption);
+        }
+
+#if !NET461
+        public void Configure(IApplicationBuilder app)
+        {
+            app.UseRouting()
+                .UseEndpoints(endpoints =>
+                {
+                    endpoints.MapServerSentEvents(SERVER_SENT_EVENTS_ENDPOINT);
+                });
+        }
+#else
+        public void Configure(IApplicationBuilder app)
+        {
+            app.MapServerSentEvents(SERVER_SENT_EVENTS_ENDPOINT);
+        }
+#endif
+    }
+}

Test.AspNetCore.ServerSentEvents/Functional/Infrastructure/FakeServerSentEventsServerrApplicationFactory.cs

@@ -0,0 +1,29 @@
+using System.IO;
+using Microsoft.AspNetCore;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Mvc.Testing;
+
+namespace Test.AspNetCore.ServerSentEvents.Functional.Infrastructure
+{
+    internal class FakeServerSentEventsServerrApplicationFactory<TFakeServerSentEventsServerStartup> : WebApplicationFactory<TFakeServerSentEventsServerStartup> where TFakeServerSentEventsServerStartup : FakeServerSentEventsServerStartup
+    {
+#if !NET461
+        protected override IWebHostBuilder CreateWebHostBuilder()
+        {
+            return WebHost.CreateDefaultBuilder()
+                .UseStartup<TFakeServerSentEventsServerStartup>();
+        }
+#else
+        protected override IWebHostBuilder CreateWebHostBuilder()
+        {
+            return new WebHostBuilder()
+                .UseStartup<TFakeServerSentEventsServerStartup>();
+        }
+#endif
+
+        protected override void ConfigureWebHost(IWebHostBuilder builder)
+        {
+            builder.UseContentRoot(Path.GetTempPath());
+        }
+    }
+}

Test.AspNetCore.ServerSentEvents/Functional/KeepaliveTests.cs

@@ -0,0 +1,190 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Buffers;
+using System.Net.Http;
+using System.Threading;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration;
+using Xunit;
+using Lib.AspNetCore.ServerSentEvents;
+using Test.AspNetCore.ServerSentEvents.Functional.Infrastructure;
+
+namespace Test.AspNetCore.ServerSentEvents.Functional
+{
+    public class KeepAliveTests
+    {
+        #region Fields
+        private const int KEEPALIVE_INTERVAL = 1;
+        private readonly static TimeSpan KEEPALIVE_TIMESPAN = TimeSpan.FromSeconds(KEEPALIVE_INTERVAL + 1);
+
+        private const string DEFAULT_KEEPALIVE = ": KEEPALIVE\r\n\r\n";
+        private const string CUSTOM_KEEPALIVE_CONTENT = "PING";
+        private const string CUSTOM_KEEPALIVE_COMMENT = ": PING\r\n\r\n";
+        private const string CUSTOM_KEEPALIVE_EVENT = "event: PING\r\ndata: \r\n\r\n";
+        #endregion
+
+        #region SUT
+        private class KeepaliveNeverServerSentEventsServerStartup : FakeServerSentEventsServerStartup
+        {
+            public KeepaliveNeverServerSentEventsServerStartup(IConfiguration configuration) : base(configuration)
+            { }
+
+            protected override Action<ServerSentEventsServiceOptions<ServerSentEventsService>> ConfigureServerSentEventsOption
+            {
+                get
+                {
+                    return options =>
+                    {
+                        options.KeepaliveMode = ServerSentEventsKeepaliveMode.Never;
+                        options.KeepaliveInterval = KEEPALIVE_INTERVAL;
+                    };
+                }
+            }
+        }
+
+        private class KeepaliveDefultAlwaysServerSentEventsServerStartup : FakeServerSentEventsServerStartup
+        {
+            public KeepaliveDefultAlwaysServerSentEventsServerStartup(IConfiguration configuration) : base(configuration)
+            { }
+
+            protected override Action<ServerSentEventsServiceOptions<ServerSentEventsService>> ConfigureServerSentEventsOption
+            {
+                get
+                {
+                    return options =>
+                    {
+                        options.KeepaliveMode = ServerSentEventsKeepaliveMode.Always;
+                        options.KeepaliveInterval = KEEPALIVE_INTERVAL;
+                    };
+                }
+            }
+        }
+
+        private class KeepaliveCustomCommentAlwaysServerSentEventsServerStartup : FakeServerSentEventsServerStartup
+        {
+            public KeepaliveCustomCommentAlwaysServerSentEventsServerStartup(IConfiguration configuration) : base(configuration)
+            { }
+
+            protected override Action<ServerSentEventsServiceOptions<ServerSentEventsService>> ConfigureServerSentEventsOption
+            {
+                get
+                {
+                    return options =>
+                    {
+                        options.KeepaliveMode = ServerSentEventsKeepaliveMode.Always;
+                        options.KeepaliveInterval = KEEPALIVE_INTERVAL;
+                        options.KeepaliveKind = ServerSentEventsKeepaliveKind.Comment;
+                        options.KeepaliveContent = CUSTOM_KEEPALIVE_CONTENT;
+                    };
+                }
+            }
+        }
+
+        private class KeepaliveCustomEventAlwaysServerSentEventsServerStartup : FakeServerSentEventsServerStartup
+        {
+            public KeepaliveCustomEventAlwaysServerSentEventsServerStartup(IConfiguration configuration) : base(configuration)
+            { }
+
+            protected override Action<ServerSentEventsServiceOptions<ServerSentEventsService>> ConfigureServerSentEventsOption
+            {
+                get
+                {
+                    return options =>
+                    {
+                        options.KeepaliveMode = ServerSentEventsKeepaliveMode.Always;
+                        options.KeepaliveInterval = KEEPALIVE_INTERVAL;
+                        options.KeepaliveKind = ServerSentEventsKeepaliveKind.Event;
+                        options.KeepaliveContent = CUSTOM_KEEPALIVE_CONTENT;
+                    };
+                }
+            }
+        }
+        #endregion
+
+        #region Tests
+        [Fact]
+        public async Task ServerSentEventsServer_KeepaliveModeNever_DoesNotSendKeepalive()
+        {
+            using FakeServerSentEventsServerrApplicationFactory<KeepaliveNeverServerSentEventsServerStartup> serverSentEventsServerApplicationFactory = new();
+            HttpClient serverSentEventsClient = serverSentEventsServerApplicationFactory.CreateClient();
+
+            string serverSentEvents = await GetServerSentEvents(serverSentEventsClient).ConfigureAwait(false);
+
+            Assert.Equal(String.Empty, serverSentEvents);
+        }
+
+        [Fact]
+        public async Task ServerSentEventsServer_KeepaliveModeAlways_SendsDefaultKeepalive()
+        {
+            using FakeServerSentEventsServerrApplicationFactory<KeepaliveDefultAlwaysServerSentEventsServerStartup> serverSentEventsServerApplicationFactory = new ();
+            HttpClient serverSentEventsClient = serverSentEventsServerApplicationFactory.CreateClient();
+
+            string serverSentEvents = await GetServerSentEvents(serverSentEventsClient).ConfigureAwait(false);
+
+            Assert.Matches($"^({DEFAULT_KEEPALIVE})+$", serverSentEvents);
+        }
+
+        [Fact]
+        public async Task ServerSentEventsServer_KeepaliveModeAlwaysKeepaliveKindCommentKeepaliveContentCustom_SendsCustomCommentKeepalive()
+        {
+            using FakeServerSentEventsServerrApplicationFactory<KeepaliveCustomCommentAlwaysServerSentEventsServerStartup> serverSentEventsServerApplicationFactory = new();
+            HttpClient serverSentEventsClient = serverSentEventsServerApplicationFactory.CreateClient();
+
+            string serverSentEvents = await GetServerSentEvents(serverSentEventsClient).ConfigureAwait(false);
+
+            Assert.Matches($"^({CUSTOM_KEEPALIVE_COMMENT})+$", serverSentEvents);
+        }
+
+        [Fact]
+        public async Task ServerSentEventsServer_KeepaliveModeAlwaysKeepaliveKindEventKeepaliveContentCustom_SendsCustomEventKeepalive()
+        {
+            using FakeServerSentEventsServerrApplicationFactory<KeepaliveCustomEventAlwaysServerSentEventsServerStartup> serverSentEventsServerApplicationFactory = new();
+            HttpClient serverSentEventsClient = serverSentEventsServerApplicationFactory.CreateClient();
+
+            string serverSentEvents = await GetServerSentEvents(serverSentEventsClient).ConfigureAwait(false);
+
+            Assert.Matches($"^({CUSTOM_KEEPALIVE_EVENT})+$", serverSentEvents);
+        }
+
+        private static async Task<string> GetServerSentEvents(HttpClient serverSentEventsClient)
+        {
+            Stopwatch keepaliveStopwatch = new Stopwatch();
+            string serverSentEventsResponseContent = String.Empty;
+
+            serverSentEventsClient.DefaultRequestHeaders.Add("Accept", "text/event-stream");
+            using (HttpResponseMessage serverSentEventsResponse = await serverSentEventsClient.GetAsync(FakeServerSentEventsServerStartup.SERVER_SENT_EVENTS_ENDPOINT, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false))
+            {
+                serverSentEventsResponse.EnsureSuccessStatusCode();
+
+                keepaliveStopwatch.Start();
+
+                using (Stream responseStream = await serverSentEventsResponse.Content.ReadAsStreamAsync().ConfigureAwait(false))
+                {
+                    do
+                    {
+                        byte[] buffer = ArrayPool<byte>.Shared.Rent(128);
+
+                        try
+                        {
+                            using CancellationTokenSource keepaliveCancellationTokenSource = new CancellationTokenSource(KEEPALIVE_TIMESPAN);
+                            
+                            int bytesRead = await responseStream.ReadAsync(buffer, 0, buffer.Length, keepaliveCancellationTokenSource.Token).ConfigureAwait(false);
+                            serverSentEventsResponseContent += Encoding.UTF8.GetString(buffer, 0, bytesRead);
+                        }
+                        catch (Exception ex) when (ex is OperationCanceledException || ex.InnerException is OperationCanceledException)
+                        { }
+
+                        ArrayPool<byte>.Shared.Return(buffer);
+                    } while (keepaliveStopwatch.Elapsed < KEEPALIVE_TIMESPAN);
+                }
+            }
+
+            keepaliveStopwatch.Stop();
+
+            return serverSentEventsResponseContent;
+        }
+        #endregion
+    }
+}