little improvments

Author: st0o0

src/Servus.Akka.Tests/IO/ClientByteMoverSpec.cs

@@ -107,9 +107,9 @@ public async Task ClientByteMover_should_write_large_buffers_directly()
         var state = new ClientState(stream, inbound, outbound);
 
         // Write a large buffer (> 16KB) followed by a small buffer
-        var largeBuf = NetworkBuffer.Rent(17 * 1024);
+        var largeBuf = NetworkBuffer.Rent(33 * 1024);
         largeBuf.Memory.Span.Fill(0xAA);
-        largeBuf.Length = 17 * 1024;
+        largeBuf.Length = 33 * 1024;
 
         var smallBuf = NetworkBuffer.Rent(100);
         smallBuf.Memory.Span.Fill(0xBB);
@@ -259,17 +259,17 @@ public async Task ClientByteMover_should_handle_alternating_large_small_buffers(
         var stream = new CapturingStream(capturedWrites);
         var state = new ClientState(stream, inbound, outbound);
 
-        var largeBuf = NetworkBuffer.Rent(17 * 1024);
+        var largeBuf = NetworkBuffer.Rent(33 * 1024);
         largeBuf.Memory.Span.Fill(0xAA);
-        largeBuf.Length = 17 * 1024;
+        largeBuf.Length = 33 * 1024;
 
         var smallBuf = NetworkBuffer.Rent(100);
         smallBuf.Memory.Span.Fill(0xBB);
         smallBuf.Length = 100;
 
-        var largeBuf2 = NetworkBuffer.Rent(17 * 1024);
+        var largeBuf2 = NetworkBuffer.Rent(33 * 1024);
         largeBuf2.Memory.Span.Fill(0xCC);
-        largeBuf2.Length = 17 * 1024;
+        largeBuf2.Length = 33 * 1024;
 
         var smallBuf2 = NetworkBuffer.Rent(100);
         smallBuf2.Memory.Span.Fill(0xDD);
@@ -327,9 +327,9 @@ public async Task ClientByteMover_should_flush_coalesce_before_large_buffer()
         smallBuf.Memory.Span.Fill(0x11);
         smallBuf.Length = 100;
 
-        var largeBuf = NetworkBuffer.Rent(17 * 1024);
+        var largeBuf = NetworkBuffer.Rent(33 * 1024);
         largeBuf.Memory.Span.Fill(0xAA);
-        largeBuf.Length = 17 * 1024;
+        largeBuf.Length = 33 * 1024;
 
         outbound.Writer.TryWrite(smallBuf);
         outbound.Writer.TryWrite(largeBuf);
@@ -341,7 +341,7 @@ public async Task ClientByteMover_should_flush_coalesce_before_large_buffer()
 
         Assert.True(capturedWrites.Count >= 2);
         Assert.Equal(100, capturedWrites[0].Length);
-        Assert.Equal(17 * 1024, capturedWrites[1].Length);
+        Assert.Equal(33 * 1024, capturedWrites[1].Length);
     }
 
     [Fact(Timeout = 5000)]

src/Servus.Akka.Tests/IO/MessagesSpec.cs

@@ -1,7 +1,6 @@
 using System.Net;
 using Servus.Akka.IO;
 using Servus.Akka.IO.Tcp;
-using Servus.Akka.Tests.Utils;
 
 namespace Servus.Akka.Tests.IO;
 
@@ -26,17 +25,6 @@ public void NetworkBuffer_Rent_should_return_buffer_with_capacity()
         buf.Dispose();
     }
 
-    [Fact(Timeout = 5000)]
-    public void NetworkBuffer_Rent_should_have_key()
-    {
-        var buf = NetworkBuffer.Rent(64);
-
-        Assert.Equal(string.Empty, buf.Key.Host);
-        Assert.Equal(string.Empty, buf.Key.Scheme);
-
-        buf.Dispose();
-    }
-
     [Fact(Timeout = 5000)]
     public void NetworkBuffer_should_expose_memory_up_to_length()
     {

src/Servus.Akka.Tests/IO/Tcp/DnsCacheSpec.cs

@@ -0,0 +1,75 @@
+using System.Net;
+using Servus.Akka.IO.Tcp;
+
+namespace Servus.Akka.Tests.IO.Tcp;
+
+public sealed class DnsCacheSpec : IDisposable
+{
+    public DnsCacheSpec()
+    {
+        DnsCache.Clear();
+    }
+
+    public void Dispose()
+    {
+        DnsCache.Clear();
+        DnsCache.Ttl = TimeSpan.FromSeconds(120);
+    }
+
+    [Fact(Timeout = 5000)]
+    public async Task ResolveAsync_should_return_literal_ip_without_dns_lookup()
+    {
+        var addresses = await DnsCache.ResolveAsync("127.0.0.1", CancellationToken.None);
+
+        Assert.Single(addresses);
+        Assert.Equal(IPAddress.Loopback, addresses[0]);
+    }
+
+    [Fact(Timeout = 5000)]
+    public async Task ResolveAsync_should_return_ipv6_literal()
+    {
+        var addresses = await DnsCache.ResolveAsync("::1", CancellationToken.None);
+
+        Assert.Single(addresses);
+        Assert.Equal(IPAddress.IPv6Loopback, addresses[0]);
+    }
+
+    [Fact(Timeout = 10000)]
+    public async Task ResolveAsync_should_resolve_localhost()
+    {
+        var addresses = await DnsCache.ResolveAsync("localhost", CancellationToken.None);
+
+        Assert.NotEmpty(addresses);
+    }
+
+    [Fact(Timeout = 10000)]
+    public async Task ResolveAsync_should_cache_results()
+    {
+        var first = await DnsCache.ResolveAsync("localhost", CancellationToken.None);
+        var second = await DnsCache.ResolveAsync("localhost", CancellationToken.None);
+
+        Assert.Same(first, second);
+    }
+
+    [Fact(Timeout = 10000)]
+    public async Task ResolveAsync_should_expire_after_ttl()
+    {
+        DnsCache.Ttl = TimeSpan.FromMilliseconds(1);
+
+        var first = await DnsCache.ResolveAsync("localhost", CancellationToken.None);
+        await Task.Delay(10);
+        var second = await DnsCache.ResolveAsync("localhost", CancellationToken.None);
+
+        Assert.NotSame(first, second);
+    }
+
+    [Fact(Timeout = 5000)]
+    public async Task Clear_should_remove_all_entries()
+    {
+        await DnsCache.ResolveAsync("127.0.0.1", CancellationToken.None);
+        DnsCache.Clear();
+
+        var addresses = await DnsCache.ResolveAsync("127.0.0.1", CancellationToken.None);
+        Assert.NotNull(addresses);
+    }
+}

src/Servus.Akka.Tests/IO/Tcp/TcpClientProviderSpec.cs

@@ -74,7 +74,7 @@ await Assert.ThrowsAsync<NotSupportedException>(() =>
             provider.AcceptInboundStreamAsync(CancellationToken.None));
     }
 
-    [Fact(Timeout = 5000)]
+    [Fact(Timeout = 10_000)]
     public async Task TcpClientProvider_should_resolve_proxy_when_configured()
     {
         var proxyUri = new Uri("http://proxy.local:8080");
@@ -90,15 +90,15 @@ public async Task TcpClientProvider_should_resolve_proxy_when_configured()
 
         var provider = new TcpClientProvider(options);
 
-        // Verify GetStreamAsync uses proxy for connection (DNS lookup will fail, which is ok for this test)
-        // This test verifies the proxy resolution path works without requiring actual network
+        // proxy.local is a .local mDNS domain — resolution may be slow on Linux.
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(2));
         try
         {
-            await provider.GetStreamAsync(CancellationToken.None);
+            await provider.GetStreamAsync(cts.Token);
         }
-        catch (SocketException)
+        catch (Exception ex) when (ex is SocketException or OperationCanceledException)
         {
-            // Expected: DNS resolution fails for "proxy.local"
+            // Expected: DNS resolution fails or times out for "proxy.local"
         }
 
         await provider.DisposeAsync();
@@ -196,7 +196,7 @@ public async Task TcpClientProvider_should_apply_default_proxy_credentials()
         await provider.DisposeAsync();
     }
 
-    [Fact(Timeout = 5000)]
+    [Fact(Timeout = 10_000)]
     public async Task TcpClientProvider_should_not_override_existing_proxy_credentials()
     {
         var existingCredentials = new NetworkCredential("existing", "existing");
@@ -214,13 +214,15 @@ public async Task TcpClientProvider_should_not_override_existing_proxy_credentia
 
         var provider = new TcpClientProvider(options);
 
+        // proxy.local is a .local mDNS domain — resolution may be slow on Linux.
+        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(2));
         try
         {
-            await provider.GetStreamAsync(CancellationToken.None);
+            await provider.GetStreamAsync(cts.Token);
         }
-        catch (SocketException)
+        catch (Exception ex) when (ex is SocketException or OperationCanceledException)
         {
-            // Expected
+            // Expected: DNS resolution fails or times out for "proxy.local"
         }
 
         // Verify existing credentials were not replaced

src/Servus.Akka.Tests/IO/Tcp/TcpPumpManagerSpec.cs

@@ -94,8 +94,7 @@ public async Task PumpAsync_should_flush_and_grow_batch_when_full()
         var pump = new TcpPumpManager(probe.Ref);
         var (inbound, handle) = CreateTestHandle();
 
-        // Detect the actual ArrayPool bucket size for Rent(8) at runtime (may be 8, 16, etc.)
-        var sampleBatch = ArrayPool<IInputItem>.Shared.Rent(8);
+        var sampleBatch = ArrayPool<IInputItem>.Shared.Rent(32);
         var initialBatchSize = sampleBatch.Length;
         ArrayPool<IInputItem>.Shared.Return(sampleBatch);
 

src/Servus.Akka/IO/ClientByteMover.cs

@@ -6,7 +6,7 @@ public static class ClientByteMover
 {
     // Threshold below which consecutive small buffers are coalesced into a single write.
     // Reduces syscall overhead for HTTP/2 frame headers (9 bytes) and small DATA frames.
-    private const int CoalesceThreshold = 16 * 1024;
+    private const int CoalesceThreshold = 32 * 1024;
 
     // Cached delegates — created once at class init, reused for every connection.
     // Avoids a delegate heap allocation on each MoveStreamToChannel call.

src/Servus.Akka/IO/Messages.cs

@@ -67,7 +67,7 @@ public class NetworkBuffer : IInputItem, IOutputItem
 {
     private static readonly ConcurrentStack<NetworkBuffer> WrapperPool = new();
 
-    protected static int MaxPoolSize { get; private set; } = Environment.ProcessorCount * 2;
+    protected static int MaxPoolSize { get; private set; } = Environment.ProcessorCount * 4;
 
     protected IMemoryOwner<byte>? Owner;
 

src/Servus.Akka/IO/Tcp/DnsCache.cs

@@ -0,0 +1,47 @@
+using System.Collections.Concurrent;
+using System.Net;
+
+namespace Servus.Akka.IO.Tcp;
+
+internal static class DnsCache
+{
+    private static readonly ConcurrentDictionary<string, DnsEntry> Cache = new(StringComparer.OrdinalIgnoreCase);
+
+    private static TimeSpan _ttl = TimeSpan.FromSeconds(120);
+
+    public static TimeSpan Ttl
+    {
+        get => _ttl;
+        set => _ttl = value;
+    }
+
+    public static async Task<IPAddress[]> ResolveAsync(string host, CancellationToken ct)
+    {
+        if (IPAddress.TryParse(host, out var literal))
+        {
+            return [literal];
+        }
+
+        if (Cache.TryGetValue(host, out var entry) && !entry.IsExpired(_ttl))
+        {
+            return entry.Addresses;
+        }
+
+        var addresses = await Dns.GetHostAddressesAsync(host, ct).ConfigureAwait(false);
+
+        if (addresses.Length > 0)
+        {
+            Cache[host] = new DnsEntry(addresses, Environment.TickCount64);
+        }
+
+        return addresses;
+    }
+
+    internal static void Clear() => Cache.Clear();
+
+    private readonly record struct DnsEntry(IPAddress[] Addresses, long TimestampMs)
+    {
+        public bool IsExpired(TimeSpan ttl)
+            => Environment.TickCount64 - TimestampMs > (long)ttl.TotalMilliseconds;
+    }
+}

src/Servus.Akka/IO/Tcp/TcpClientProvider.cs

@@ -29,7 +29,7 @@ public async Task<Stream> GetStreamAsync(CancellationToken ct = default)
         try
         {
             var dnsStart = Stopwatch.GetTimestamp();
-            addresses = await Dns.GetHostAddressesAsync(connectHost, ct).ConfigureAwait(false);
+            addresses = await DnsCache.ResolveAsync(connectHost, ct).ConfigureAwait(false);
             var dnsDuration = Stopwatch.GetElapsedTime(dnsStart).TotalSeconds;
 
             if (addresses.Length == 0)

src/Servus.Akka/IO/Tcp/TcpPumpManager.cs

@@ -69,7 +69,7 @@ private static async Task PumpAsync(
                     }
 
                     chunk.Key = key;
-                    batch ??= ArrayPool<IInputItem>.Shared.Rent(8);
+                    batch ??= ArrayPool<IInputItem>.Shared.Rent(32);
 
                     if (count == batch.Length)
                     {