Revert "Add IAsyncReplicationServer/IAsyncReplicationResponse, update ReplicationService, Middleware, and TestServer to support async replication with conditional sync/async DI."

This reverts commit 349621f.

Author: NehanPathan

src/Lucene.Net.Replicator/Http/ReplicationService.cs

@@ -49,7 +49,7 @@ namespace Lucene.Net.Replicator.Http
     /// <para/>
     /// @lucene.experimental
     /// </remarks>
-    public class ReplicationService : IReplicationService, IAsyncReplicationService // LUCENENET specific: added interface so we can mock easier.
+    public class ReplicationService : IReplicationService // LUCENENET specific: added interface so we can mock easier.
     {
         /// <summary>
         /// Actions supported by the <see cref="ReplicationService"/>.
@@ -121,14 +121,13 @@ private static string ExtractRequestParam(IReplicationRequest request, string pa
             return param;
         }
 
-        // Shared internal logic (generic on response)
-        private async Task ExecuteReplicationInternal<TResponse>(
+        // method to avoid code duplication in sync and async Perform methods
+        private async Task ExecuteReplicationAsync(
             IReplicationRequest request,
-            TResponse response,
+            IReplicationResponse response,
             Func<Stream, Task> copyStreamFunc,
             Func<SessionToken, Task> writeTokenFunc,
             Func<Task> flushFunc)
-            where TResponse : IBaseReplicationResponse
         {
             string[] pathElements = GetPathElements(request);
             if (pathElements.Length != 2)
@@ -184,28 +183,6 @@ private async Task ExecuteReplicationInternal<TResponse>(
             }
         }
 
-        // For sync
-        private async Task ExecuteReplicationAsync(
-            IReplicationRequest request,
-            IReplicationResponse response,
-            Func<Stream, Task> copyStreamFunc,
-            Func<SessionToken, Task> writeTokenFunc,
-            Func<Task> flushFunc)
-        {
-            await ExecuteReplicationInternal(request, response, copyStreamFunc, writeTokenFunc, flushFunc);
-        }
-
-        // For async
-        private async Task ExecuteReplicationAsync(
-            IReplicationRequest request,
-            IAsyncReplicationResponse response,
-            Func<Stream, Task> copyStreamFunc,
-            Func<SessionToken, Task> writeTokenFunc,
-            Func<Task> flushFunc)
-        {
-            await ExecuteReplicationInternal(request, response, copyStreamFunc, writeTokenFunc, flushFunc);
-        }
-
         // LUCENENET specific - copy method not used
 
         /// <summary>
@@ -245,7 +222,7 @@ public virtual void Perform(IReplicationRequest request, IReplicationResponse re
         /// <exception cref="InvalidOperationException">Thrown when required parameters are missing or invalid.</exception>
         public virtual Task PerformAsync(
             IReplicationRequest request,
-            IAsyncReplicationResponse response,
+            IReplicationResponse response,
             CancellationToken cancellationToken = default)
         {
             return ExecuteReplicationAsync(

src/Lucene.Net.Replicator/Support/Http/Abstractions/IAsyncReplicationResponse.cs

@@ -28,11 +28,28 @@ namespace Lucene.Net.Replicator.Http.Abstractions
     /// .NET Specific Abstraction
     /// </remarks>
     //Note: LUCENENET specific
-    public interface IReplicationResponse: IBaseReplicationResponse
+    public interface IReplicationResponse
     {
+        /// <summary>
+        /// Gets or sets the http status code of the response.
+        /// </summary>
+        int StatusCode { get; set; }
+
+        /// <summary>
+        /// The response content.
+        /// </summary>
+        Stream Body { get; }
+
         /// <summary>
         /// Flushes the reponse to the underlying response stream.
         /// </summary>
         void Flush();
+
+        /// <summary>
+        /// Flushes the response to the underlying response stream asynchronously.
+        /// </summary>
+        /// <param name="cancellationToken">Optional cancellation token.</param>
+        /// <returns>A task representing the asynchronous operation.</returns>
+        Task FlushAsync(CancellationToken cancellationToken = default);
     }
 }

src/Lucene.Net.Replicator/Support/Http/Abstractions/IAsyncReplicationService.cs

@@ -32,5 +32,15 @@ public interface IReplicationService
         /// </summary>
         /// <exception cref="InvalidOperationException">required parameters are missing</exception>
         void Perform(IReplicationRequest request, IReplicationResponse response);
+
+        /// <summary>
+        /// Executes the replication task asynchronously.
+        /// </summary>
+        /// <param name="request">The replication request.</param>
+        /// <param name="response">The replication response.</param>
+        /// <param name="cancellationToken">Optional cancellation token.</param>
+        /// <returns>A task representing the asynchronous operation.</returns>
+        Task PerformAsync(IReplicationRequest request, IReplicationResponse response, CancellationToken cancellationToken = default);
+
     }
 }

src/Lucene.Net.Replicator/Support/Http/Abstractions/IBaseReplicationResponse.cs

@@ -32,7 +32,7 @@ namespace Lucene.Net.Replicator.Http
 
     public class ReplicationServlet
     {
-        public void Configure(IApplicationBuilder app, IAsyncReplicationService service, ReplicatorTestCase.MockErrorConfig mockErrorConfig)
+        public void Configure(IApplicationBuilder app, IReplicationService service, ReplicatorTestCase.MockErrorConfig mockErrorConfig)
         {
             // Middleware to throw an exception conditionally from our test server.
             app.Use(async (context, next) =>
@@ -63,9 +63,9 @@ public void Configure(IApplicationBuilder app, IAsyncReplicationService service,
     public class ReplicationServiceMiddleware
     {
         private readonly RequestDelegate next;
-        private readonly IAsyncReplicationService  service;
+        private readonly IReplicationService service;
 
-        public ReplicationServiceMiddleware(RequestDelegate next, IAsyncReplicationService  service)
+        public ReplicationServiceMiddleware(RequestDelegate next, IReplicationService service)
         {
             this.next = next ?? throw new ArgumentNullException(nameof(next));
             this.service = service ?? throw new ArgumentNullException(nameof(service));

src/Lucene.Net.Replicator/Support/Http/Abstractions/IReplicationResponse.cs

@@ -81,17 +81,15 @@ public class MockErrorConfig
 #if FEATURE_ASPNETCORE_TESTHOST
     public partial class ReplicatorTestCase
     {
-        public static TestServer NewHttpServer(ReplicationService  service, MockErrorConfig mockErrorConfig, bool useSynchronousIO, bool useStartupClass)
+        public static TestServer NewHttpServer(IReplicationService service, MockErrorConfig mockErrorConfig, bool useSynchronousIO, bool useStartupClass)
         {
             if (useStartupClass)
             {
                 var builder = new WebHostBuilder()
                     .ConfigureServices(container =>
                     {
-                        // Register concrete services
-                    container.AddSingleton<IAsyncReplicationService>(service);
-                    container.AddSingleton<IReplicationService>(service);
-                    container.AddSingleton(mockErrorConfig);
+                        container.AddSingleton(service);
+                        container.AddSingleton(mockErrorConfig);
                     });
 
                 if (useSynchronousIO)
@@ -113,8 +111,7 @@ public static TestServer NewHttpServer(ReplicationService  service, MockErrorCon
                     .ConfigureServices(container =>
                     {
                         container.AddRouting();
-                        container.AddSingleton<IAsyncReplicationService>(service);
-                        container.AddSingleton<IReplicationService>(service);
+                        container.AddSingleton(service);
                         container.AddSingleton(mockErrorConfig);
                         if (useSynchronousIO)
                         {
@@ -219,7 +216,7 @@ public async Task InvokeAsync(HttpContext context)
     public partial class ReplicatorTestCase
     {
         // LUCENENET: This uses HttpListener from System.Net to test the service where ASP.NET Core is not supported.
-        public static TestServer NewHttpServer(ReplicationService service, MockErrorConfig mockErrorConfig, bool useSynchronousIO, bool useStartupClass)
+        public static TestServer NewHttpServer(IReplicationService service, MockErrorConfig mockErrorConfig, bool useSynchronousIO, bool useStartupClass)
         {
             return new TestServer(service, mockErrorConfig, useSynchronousIO);
         }

src/Lucene.Net.Replicator/Support/Http/Abstractions/IReplicationService.cs

@@ -27,7 +27,7 @@ namespace Lucene.Net.Replicator.Net
     /// A concrete implementation of <see cref="IReplicationResponse"/> for supporting
     /// <see cref="HttpListener"/>.
     /// </summary>
-    public class HttpListenerReplicationResponse : IReplicationResponse, IAsyncReplicationResponse
+    public class HttpListenerReplicationResponse : IReplicationResponse
     {
         private readonly HttpListenerResponse _response;
 

src/Lucene.Net.Tests.Replicator/Http/ReplicationServlet.cs

@@ -6,7 +6,6 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using Lucene.Net.Replicator.Http;
 
 namespace Lucene.Net.Replicator.Net
 {
@@ -35,9 +34,7 @@ namespace Lucene.Net.Replicator.Net
     public class TestServer : IDisposable
     {
         private readonly HttpListener _listener;
-        private readonly IAsyncReplicationService _asyncService;
-        private readonly IReplicationService _syncService;
-
+        private readonly IReplicationService _service;
         private readonly ReplicatorTestCase.MockErrorConfig _mockErrorConfig;
         private readonly bool _useSynchronousIO;
         private readonly CancellationTokenSource _cancellationTokenSource = new();
@@ -46,15 +43,12 @@ public class TestServer : IDisposable
         public Uri BaseAddress { get; }
 
         public TestServer(
-            ReplicationService service, // concrete type implements both sync + async
+            IReplicationService service,
             ReplicatorTestCase.MockErrorConfig mockErrorConfig,
             bool useSynchronousIO,
             string prefix = "http://localhost:0/")
         {
-            if (service == null) throw new ArgumentNullException(nameof(service));
-            _asyncService = service;
-            _syncService = service;
-
+            _service = service ?? throw new ArgumentNullException(nameof(service));
             _mockErrorConfig = mockErrorConfig ?? throw new ArgumentNullException(nameof(mockErrorConfig));
             _useSynchronousIO = useSynchronousIO;
 
@@ -98,11 +92,11 @@ private async Task ListenLoopAsync(CancellationToken token)
 
                             if (_useSynchronousIO)
                             {
-                                _syncService.Perform(request, response);
+                                _service.Perform(request, response);
                             }
                             else
                             {
-                                await _asyncService.PerformAsync(request, response, token);
+                                await _service.PerformAsync(request, response, token);
                             }
                         }
                         catch