feat: Add async read/write support in ReplicationServlet and corresponding J2N-based async tests in TestStreamExtensions

Author: NehanPathan

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

@@ -52,14 +52,16 @@ public void Configure(IApplicationBuilder app, IReplicationService service, Repl
             {
                 // LUCENENET: This is to allow synchronous IO to happen for these requests.
                 // LUCENENET TODO: Allow async operations from Replicator.
-                var syncIoFeature = context.Features.Get<IHttpBodyControlFeature>();
-                if (syncIoFeature != null)
-                {
-                    syncIoFeature.AllowSynchronousIO = true;
-                }
+                // var syncIoFeature = context.Features.Get<IHttpBodyControlFeature>();
+                // if (syncIoFeature != null)
+                // {
+                //     syncIoFeature.AllowSynchronousIO = false;
+                // }
+
+                // await Task.Yield();
+                // service.Perform(context.Request, context.Response);
+                await service.PerformAsync(context.Request, context.Response, context.RequestAborted);
 
-                await Task.Yield();
-                service.Perform(context.Request, context.Response);
             });
         }
     }
@@ -84,14 +86,15 @@ public async Task InvokeAsync(HttpContext context)
         {
             // LUCENENET: This is to allow synchronous IO to happen for these requests.
             // LUCENENET TODO: Allow async operations from Replicator.
-            var syncIoFeature = context.Features.Get<IHttpBodyControlFeature>();
-            if (syncIoFeature != null)
-            {
-                syncIoFeature.AllowSynchronousIO = true;
-            }
+            // var syncIoFeature = context.Features.Get<IHttpBodyControlFeature>();
+            // if (syncIoFeature != null)
+            // {
+            //     syncIoFeature.AllowSynchronousIO = false;
+            // }
 
-            await Task.Yield();
-            service.Perform(context.Request, context.Response);
+            // await Task.Yield();
+            // service.Perform(context.Request, context.Response);
+             await service.PerformAsync(context.Request, context.Response, context.RequestAborted);
 
             // This is a terminating endpoint. Do not call the next delegate/middleware in the pipeline.
         }

src/Lucene.Net.Tests/Support/IO/TestStreamExtensions.cs

@@ -8,6 +8,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Text;
+using System.Threading.Tasks;
 
 namespace Lucene.Net.Support.IO
 {
@@ -33,6 +34,8 @@ public class TestStreamExtensions : LuceneTestCase
     {
         private Stream stream;
 
+        private static readonly string unihw = "\u0048\u0065\u006C\u006C\u006F\u0020\u0057\u006F\u0072\u006C\u0064";
+
         private const string fileString = "Test_All_Tests\nTest_java_io_BufferedInputStream\nTest_java_io_BufferedOutputStream\nTest_java_io_ByteArrayInputStream\nTest_java_io_ByteArrayOutputStream\nTest_DataInputStream\n";
 
         [Test]
@@ -115,6 +118,98 @@ public void TestReadInt64()
             Assert.AreEqual(9875645283333L, stream.ReadInt64(), "Incorrect long read");
         }
 
+        // Additional async tests
+
+        [Test]
+        // LUCENENET note: adapted from test_writeInt()
+        public async Task TestWriteInt32BigEndianAsync()
+        {
+            await stream.WriteInt32BigEndianAsync(9087589);
+            // Reset the stream so we can read back
+            ResetStreamForReading();
+            int c = await stream.ReadInt32BigEndianAsync();
+            Assert.AreEqual(9087589, c, "Incorrect int written (async)");
+        }
+
+        [Test]
+        // LUCENENET note: adapted from test_writeLong()
+        public async Task TestWriteInt64BigEndianAsync()
+        {
+            await stream.WriteInt64BigEndianAsync(908755555456L);
+            // Reset the stream so we can read back
+            ResetStreamForReading();
+            long c = await stream.ReadInt64BigEndianAsync();
+            Assert.AreEqual(908755555456L, c, "Incorrect long written (async)");
+        }
+
+        [Test]
+        // LUCENENET note: adapted from test_writeUTF()
+        public async Task TestWriteUTFAsync()
+        {
+            await stream.WriteUTFAsync(unihw);
+            // Reset the stream so we can read back
+            ResetStreamForReading();
+            string result = await stream.ReadUTFAsync();
+            Assert.AreEqual(unihw, result, "Incorrect string written (async)");
+        }
+
+        [Test]
+        // LUCENENET note: adapted from test_readInt()
+        public async Task TestReadInt32BigEndianAsync()
+        {
+            await stream.WriteInt32BigEndianAsync(768347202);
+            // Reset the stream so we can read back
+            ResetStreamForReading();
+            int result = await stream.ReadInt32BigEndianAsync();
+            Assert.AreEqual(768347202, result, "Incorrect int read (async)");
+        }
+
+        [Test]
+        // LUCENENET note: adapted from test_readLong()
+        public async Task TestReadInt64BigEndianAsync()
+        {
+            await stream.WriteInt64BigEndianAsync(9875645283333L);
+            // Reset the stream so we can read back
+            ResetStreamForReading();
+            long result = await stream.ReadInt64BigEndianAsync();
+            Assert.AreEqual(9875645283333L, result, "Incorrect long read (async)");
+        }
+
+        [Test]
+        // LUCENENET note: adapted from test_readUTF()
+        public async Task TestReadUTFAsync()
+        {
+            await stream.WriteUTFAsync(unihw);
+
+            // Check that the length was written correctly (UTF length + 2 bytes for length header)
+            long expectedStreamLength = CalculateExpectedUTFStreamLength(unihw);
+            Assert.AreEqual(expectedStreamLength, stream.Length, "Failed to write string in UTF format");
+
+            // Reset and read the string
+            ResetStreamForReading();
+            string result = await stream.ReadUTFAsync();
+            Assert.AreEqual(unihw, result, "Incorrect string read (async)");
+        }
+
+        /// <summary>
+        /// Helper method to calculate expected UTF stream length for validation
+        /// Matches DataOutput.writeUTF() spec (Java)
+        /// </summary>
+        private long CalculateExpectedUTFStreamLength(string value)
+        {
+            long utfCount = 0;
+            foreach (char ch in value)
+            {
+                if (ch > 0 && ch <= 127)
+                    utfCount++;
+                else if (ch <= 2047)
+                    utfCount += 2;
+                else
+                    utfCount += 3;
+            }
+            return utfCount + 2; // +2 for the 2-byte length header
+        }
+
         private void ResetStreamForReading() // LUCENENET - was "OpenDataInputStream" in Harmony tests
         {
             // LUCENENET specific - in the Harmony tests, there were separate streams

src/dotnet/Lucene.Net.Replicator.AspNetCore/AspNetCoreReplicationServiceExtentions.cs

@@ -1,6 +1,8 @@
 using Lucene.Net.Replicator.Http;
 using Lucene.Net.Replicator.Http.Abstractions;
 using Microsoft.AspNetCore.Http;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace Lucene.Net.Replicator.AspNetCore
 {
@@ -27,9 +29,25 @@ public static class AspNetCoreReplicationServiceExtentions
         /// <summary>
         /// Extension method that mirrors the signature of <see cref="IReplicationService.Perform"/> using AspNetCore as implementation.
         /// </summary>
+        // public static void Perform(this IReplicationService self, HttpRequest request, HttpResponse response)
+        // {
+        //     self.Perform(new AspNetCoreReplicationRequest(request), new AspNetCoreReplicationResponse(response));
+        // }
         public static void Perform(this IReplicationService self, HttpRequest request, HttpResponse response)
         {
             self.Perform(new AspNetCoreReplicationRequest(request), new AspNetCoreReplicationResponse(response));
         }
+
+        public static async Task PerformAsync(
+       this IReplicationService self,
+       HttpRequest request,
+       HttpResponse response,
+       CancellationToken cancellationToken = default)
+        {
+            await self.PerformAsync(
+                new AspNetCoreReplicationRequest(request),
+                new AspNetCoreReplicationResponse(response),
+                cancellationToken);
+        }
     }
 }