Fix Dns.Resolve issue by using ContinueWith and AggregateException.Flatten

src/core/Akka.Tests/IO/TcpIntegrationSpec.cs

@@ -22,6 +22,8 @@
 using Xunit.Abstractions;
 using FluentAssertions;
 using System.Runtime.InteropServices;
+using System.Threading;
+using Akka.Event;
 
 namespace Akka.Tests.IO
 {
@@ -470,6 +472,19 @@ public void The_TCP_transport_implementation_dont_report_Connected_when_endpoint
             replies.Count.ShouldBe(0);
         }
 
+        [Fact]
+        public void Should_report_Error_only_once_when_connecting_to_unreachable_DnsEndpoint()
+        {
+            var probe = CreateTestProbe();
+            // a "random" endpoint hopefully unavailable since it's in the test-net IP range
+            var endpoint = new DnsEndPoint("fake", 1000);
+            Sys.Tcp().Tell(new Tcp.Connect(endpoint), probe.Ref);
+
+            // expecting CommandFailed or no reply (within timeout)
+            var replies = probe.ReceiveWhile(TimeSpan.FromSeconds(5), x => x as Tcp.CommandFailed);
+            replies.Count.ShouldBe(1);
+        }
+
         [Fact]
         public void The_TCP_transport_implementation_handle_tcp_connection_actor_death_properly()
         {

src/core/Akka/IO/InetAddressDnsResolver.cs

@@ -8,6 +8,8 @@
 using System.Linq;
 using System.Net;
 using System.Net.Sockets;
+using System.Runtime.ExceptionServices;
+using System.Threading.Tasks;
 using Akka.Actor;
 using Akka.Configuration;
 
@@ -43,28 +45,39 @@ public InetAddressDnsResolver(SimpleDnsCache cache, Config config)
         /// <returns>TBD</returns>
         protected override bool Receive(object message)
         {
-            var resolve = message as Dns.Resolve;
-            if (resolve != null)
+            if (message is Dns.Resolve resolve)
             {
                 var answer = _cache.Cached(resolve.Name);
-                if (answer == null)
+                if (answer != null)
                 {
-                    try
-                    {
-                        //TODO: IP6
-                        answer = Dns.Resolved.Create(resolve.Name, System.Net.Dns.GetHostEntryAsync(resolve.Name).Result.AddressList.Where(x => 
-                                x.AddressFamily == AddressFamily.InterNetwork 
-                                || _useIpv6 && x.AddressFamily == AddressFamily.InterNetworkV6));
-                        _cache.Put(answer, _positiveTtl);
-                    }
-                    catch (SocketException ex)
+                    Sender.Tell(answer);
+                    return true;
+                }
+
+                System.Net.Dns.GetHostEntryAsync(resolve.Name).ContinueWith(t =>
+                {
+                    Dns.Resolved newAnswer;
+                    if (t.IsFaulted)
                     {
-                        if (ex.SocketErrorCode != SocketError.HostNotFound) throw;
-                         answer = new Dns.Resolved(resolve.Name, Enumerable.Empty<IPAddress>(), Enumerable.Empty<IPAddress>());
-                        _cache.Put(answer, _negativeTtl);
+                        foreach (var exception in t.Exception.Flatten().InnerExceptions)
+                        {
+                            if (exception is SocketException se && se.SocketErrorCode == SocketError.HostNotFound)
+                            {
+                                newAnswer = new Dns.Resolved(resolve.Name, Enumerable.Empty<IPAddress>(), Enumerable.Empty<IPAddress>());
+                                _cache.Put(newAnswer, _negativeTtl);
+                                return newAnswer;
+                            }
+                        }
+                        ExceptionDispatchInfo.Capture(t.Exception).Throw();
                     }
-                }
-                Sender.Tell(answer);
+
+                    newAnswer = Dns.Resolved.Create(resolve.Name, t.Result.AddressList.Where(x => 
+                        x.AddressFamily == AddressFamily.InterNetwork 
+                        || _useIpv6 && x.AddressFamily == AddressFamily.InterNetworkV6));
+                    _cache.Put(newAnswer, _positiveTtl);
+                    return newAnswer;
+
+                }, TaskContinuationOptions.ExecuteSynchronously).PipeTo(Sender);
                 return true;
             }
             return false;