Fix serialization verification problem with Akka.IO messages (#4974)

Arkatufus · web-flow · commit 442f8eb790b4 · 2021-04-23T02:05:13.000Z
* Fix serialization verification problem with Akka.IO messages

* Wrap naked SocketAsyncEventArgs in a struct that inherits INoSerializationVerificationNeeded

* Make the wrapper struct readonly

* Expand exception message with their actor types

* Update API Approver list
diff --git a/src/core/Akka.API.Tests/CoreAPISpec.ApproveCore.approved.txt b/src/core/Akka.API.Tests/CoreAPISpec.ApproveCore.approved.txt
@@ -3256,7 +3256,7 @@ namespace Akka.IO
         public static Akka.IO.Dns.Resolved Cached(string name, Akka.Actor.ActorSystem system) { }
         public override Akka.IO.DnsExt CreateExtension(Akka.Actor.ExtendedActorSystem system) { }
         public static Akka.IO.Dns.Resolved ResolveName(string name, Akka.Actor.ActorSystem system, Akka.Actor.IActorRef sender) { }
-        public abstract class Command
+        public abstract class Command : Akka.Actor.INoSerializationVerificationNeeded
         {
             protected Command() { }
         }
@@ -3685,7 +3685,7 @@ namespace Akka.IO
         {
             protected Event() { }
         }
-        public abstract class Message
+        public abstract class Message : Akka.Actor.INoSerializationVerificationNeeded
         {
             protected Message() { }
         }
@@ -3792,7 +3792,7 @@ namespace Akka.IO
         {
             protected Event() { }
         }
-        public abstract class Message
+        public abstract class Message : Akka.Actor.INoSerializationVerificationNeeded
         {
             protected Message() { }
         }
@@ -3827,7 +3827,7 @@ namespace Akka.IO
             public static readonly Akka.IO.UdpConnected.SuspendReading Instance;
         }
     }
-    public class UdpConnectedExt : Akka.IO.IOExtension
+    public class UdpConnectedExt : Akka.IO.IOExtension, Akka.Actor.INoSerializationVerificationNeeded
     {
         public UdpConnectedExt(Akka.Actor.ExtendedActorSystem system) { }
         public UdpConnectedExt(Akka.Actor.ExtendedActorSystem system, Akka.IO.UdpSettings settings) { }
diff --git a/src/core/Akka.Tests/IO/TcpIntegrationSpec.cs b/src/core/Akka.Tests/IO/TcpIntegrationSpec.cs
@@ -45,6 +45,8 @@ class AckWithValue : Tcp.Event
         
         public TcpIntegrationSpec(ITestOutputHelper output)
             : base($@"akka.loglevel = DEBUG
+                     akka.actor.serialize-creators = on
+                     akka.actor.serialize-messages = on
                      akka.io.tcp.trace-logging = true
                      akka.io.tcp.write-commands-queue-max-size = {InternalConnectionActorMaxQueueSize}", output: output)
         { }
@@ -190,7 +192,7 @@ public void The_TCP_transport_implementation_should_properly_support_connecting_
             var targetAddress = new DnsEndPoint("localhost", boundMsg.LocalAddress.AsInstanceOf<IPEndPoint>().Port);
             var clientHandler = CreateTestProbe();
             Sys.Tcp().Tell(new Tcp.Connect(targetAddress), clientHandler);
-            clientHandler.ExpectMsg<Tcp.Connected>(TimeSpan.FromMinutes(10));
+            clientHandler.ExpectMsg<Tcp.Connected>(TimeSpan.FromSeconds(3));
             var clientEp = clientHandler.Sender;
             clientEp.Tell(new Tcp.Register(clientHandler));
             serverHandler.ExpectMsg<Tcp.Connected>();
diff --git a/src/core/Akka.Tests/IO/TcpListenerSpec.cs b/src/core/Akka.Tests/IO/TcpListenerSpec.cs
@@ -19,12 +19,14 @@ namespace Akka.Tests.IO
     public class TcpListenerSpec : AkkaSpec
     {
         public TcpListenerSpec()
-            : base(@"akka.io.tcp.register-timeout = 500ms
+            : base(@"
+                     akka.actor.serialize-creators = on
+                     akka.actor.serialize-messages = on
+                     akka.io.tcp.register-timeout = 500ms
                      akka.io.tcp.max-received-message-size = 1024
                      akka.io.tcp.direct-buffer-size = 512
                      akka.actor.serialize-creators = on
-                     akka.io.tcp.batch-accept-limit = 2
-                    ")
+                     akka.io.tcp.batch-accept-limit = 2")
         { }
 
         [Fact]
diff --git a/src/core/Akka.Tests/IO/UdpConnectedIntegrationSpec.cs b/src/core/Akka.Tests/IO/UdpConnectedIntegrationSpec.cs
@@ -24,6 +24,8 @@ public class UdpConnectedIntegrationSpec : AkkaSpec
 
         public UdpConnectedIntegrationSpec(ITestOutputHelper output)
             : base(@"
+                    akka.actor.serialize-creators = on
+                    akka.actor.serialize-messages = on
                     akka.io.udp-connected.nr-of-selectors = 1
                     akka.io.udp-connected.direct-buffer-pool-limit = 100
                     akka.io.udp-connected.direct-buffer-size = 1024
diff --git a/src/core/Akka.Tests/IO/UdpIntegrationSpec.cs b/src/core/Akka.Tests/IO/UdpIntegrationSpec.cs
@@ -27,6 +27,8 @@ public class UdpIntegrationSpec : AkkaSpec
 
         public UdpIntegrationSpec(ITestOutputHelper output)
             : base(@"
+                    akka.actor.serialize-creators = on
+                    akka.actor.serialize-messages = on
                     akka.io.udp.max-channels = unlimited
                     akka.io.udp.nr-of-selectors = 1
                     akka.io.udp.direct-buffer-pool-limit = 100
diff --git a/src/core/Akka.Tests/IO/UdpListenerSpec.cs b/src/core/Akka.Tests/IO/UdpListenerSpec.cs
@@ -13,17 +13,21 @@
 using Akka.IO;
 using Akka.TestKit;
 using Xunit;
+using Xunit.Abstractions;
 using UdpListener = Akka.IO.UdpListener;
 
 namespace Akka.Tests.IO
 {
     public class UdpListenerSpec : AkkaSpec
     {
-        public UdpListenerSpec()
-            : base(@"akka.io.udp.max-channels = unlimited
+        public UdpListenerSpec(ITestOutputHelper output)
+            : base(@"
+                    akka.actor.serialize-creators = on
+                    akka.actor.serialize-messages = on
+                    akka.io.udp.max-channels = unlimited
                     akka.io.udp.nr-of-selectors = 1
                     akka.io.udp.direct-buffer-pool-limit = 100
-                    akka.io.udp.direct-buffer-size = 1024")
+                    akka.io.udp.direct-buffer-size = 1024", output)
         { }
 
         [Fact]
diff --git a/src/core/Akka/Actor/ActorCell.Children.cs b/src/core/Akka/Actor/ActorCell.Children.cs
@@ -10,8 +10,10 @@
 using System.Collections.Immutable;
 using System.Text;
 using System.Runtime.CompilerServices;
+using System.Runtime.Serialization;
 using System.Threading;
 using Akka.Actor.Internal;
+using Akka.Dispatch.SysMsg;
 using Akka.Serialization;
 using Akka.Util;
 using Akka.Util.Internal;
@@ -452,6 +454,7 @@ private IInternalActorRef MakeChild(Props props, string name, bool async, bool s
             if (_systemImpl.Settings.SerializeAllCreators && !systemService && !(props.Deploy.Scope is LocalScope))
             {
                 var oldInfo = Serialization.Serialization.CurrentTransportInformation;
+                object propArgument = null;
                 try
                 {
                     if (oldInfo == null)
@@ -465,17 +468,24 @@ private IInternalActorRef MakeChild(Props props, string name, bool async, bool s
                         {
                             if (argument != null && !(argument is INoSerializationVerificationNeeded))
                             {
+                                propArgument = argument;
                                 var serializer = ser.FindSerializerFor(argument);
                                 var bytes = serializer.ToBinary(argument);
                                 var ms = Serialization.Serialization.ManifestFor(serializer, argument);
-                                if(ser.Deserialize(bytes, serializer.Identifier, ms) == null)
+                                if (ser.Deserialize(bytes, serializer.Identifier, ms) == null)
                                     throw new ArgumentException(
-                                            $"Pre-creation serialization check failed at [${_self.Path}/{name}]",
-                                            nameof(name));
+                                        $"Pre-creation serialization check failed at [${_self.Path}/{name}]",
+                                        nameof(name));
                             }
                         }
                     }
                 }
+                catch (Exception e)
+                {
+                    throw new SerializationException(
+                        $"Failed to serialize and deserialize actor props argument of type {propArgument?.GetType()} for actor type [{props.Type}].",
+                        e);
+                }
                 finally
                 {
                     Serialization.Serialization.CurrentTransportInformation = oldInfo;
diff --git a/src/core/Akka/Actor/ActorCell.cs b/src/core/Akka/Actor/ActorCell.cs
@@ -13,6 +13,7 @@
 using Akka.Dispatch.SysMsg;
 using Akka.Event;
 using System.Reflection;
+using System.Runtime.Serialization;
 using Akka.Serialization;
 using Akka.Util;
 using Assert = System.Diagnostics.Debug;
@@ -518,7 +519,16 @@ private Envelope SerializeAndDeserialize(Envelope envelope)
             if (unwrapped is INoSerializationVerificationNeeded)
                 return envelope;
 
-            var deserializedMsg = SerializeAndDeserializePayload(unwrapped);
+            object deserializedMsg;
+            try
+            {
+                deserializedMsg = SerializeAndDeserializePayload(unwrapped);
+            }
+            catch (Exception e)
+            {
+                throw new SerializationException($"Failed to serialize and deserialize payload object [{unwrapped.GetType()}]. Envelope: [{envelope}], Actor type: [{Actor.GetType()}]", e);
+            }
+
             if (deadLetter != null)
                 return new Envelope(new DeadLetter(deserializedMsg, deadLetter.Sender, deadLetter.Recipient), envelope.Sender);
             return new Envelope(deserializedMsg, envelope.Sender);
diff --git a/src/core/Akka/IO/Dns.cs b/src/core/Akka/IO/Dns.cs
@@ -59,7 +59,7 @@ public class Dns : ExtensionIdProvider<DnsExt>
         /// <summary>
         /// TBD
         /// </summary>
-        public abstract class Command
+        public abstract class Command : INoSerializationVerificationNeeded
         { }
 
         /// <summary>
diff --git a/src/core/Akka/IO/Tcp.cs b/src/core/Akka/IO/Tcp.cs
@@ -53,7 +53,7 @@ public override TcpExt CreateExtension(ExtendedActorSystem system)
 
         #region internal connection messages
         
-        internal abstract class SocketCompleted { }
+        internal abstract class SocketCompleted : INoSerializationVerificationNeeded { }
 
         internal sealed class SocketSent : SocketCompleted
         {
diff --git a/src/core/Akka/IO/TcpListener.cs b/src/core/Akka/IO/TcpListener.cs
@@ -71,9 +71,9 @@ private IEnumerable<SocketAsyncEventArgs> Accept(int limit)
             {
                 var self = Self;
                 var saea = new SocketAsyncEventArgs();
-                saea.Completed += (s, e) => self.Tell(e);
+                saea.Completed += (s, e) => self.Tell(new SocketEvent(e));
                 if (!_socket.AcceptAsync(saea))
-                    Self.Tell(saea);
+                    Self.Tell(new SocketEvent(saea));
                 yield return saea;
             }
         }
@@ -85,34 +85,34 @@ protected override SupervisorStrategy SupervisorStrategy()
 
         protected override bool Receive(object message)
         {
-            if (message is SocketAsyncEventArgs)
+            switch (message)
             {
-                var saea = message as SocketAsyncEventArgs;
-                if (saea.SocketError == SocketError.Success)
-                    Context.ActorOf(Props.Create<TcpIncomingConnection>(_tcp, saea.AcceptSocket, _bind.Handler, _bind.Options, _bind.PullMode).WithDeploy(Deploy.Local));
-                saea.AcceptSocket = null;
+                case SocketEvent evt:
+                    var saea = evt.Args;
+                    if (saea.SocketError == SocketError.Success)
+                        Context.ActorOf(Props.Create<TcpIncomingConnection>(_tcp, saea.AcceptSocket, _bind.Handler, _bind.Options, _bind.PullMode).WithDeploy(Deploy.Local));
+                    saea.AcceptSocket = null;
 
-                if (!_socket.AcceptAsync(saea))
-                    Self.Tell(saea);
-                return true;
-            }
-            var resumeAccepting = message as Tcp.ResumeAccepting;
-            if (resumeAccepting != null)
-            {
-                _acceptLimit = resumeAccepting.BatchSize;
-                _saeas = Accept(_acceptLimit).ToArray();
-                return true;
-            }
-            if (message is Tcp.Unbind)
-            {
-                _log.Debug("Unbinding endpoint {0}", _bind.LocalAddress);
-                 _socket.Dispose();
-                Sender.Tell(Tcp.Unbound.Instance);
-                _log.Debug("Unbound endpoint {0}, stopping listener", _bind.LocalAddress);
-                Context.Stop(Self);
-                return true;
+                    if (!_socket.AcceptAsync(saea))
+                        Self.Tell(new SocketEvent(saea));
+                    return true;
+
+                case Tcp.ResumeAccepting resumeAccepting:
+                    _acceptLimit = resumeAccepting.BatchSize;
+                    _saeas = Accept(_acceptLimit).ToArray();
+                    return true;
+
+                case Tcp.Unbind _:
+                    _log.Debug("Unbinding endpoint {0}", _bind.LocalAddress);
+                    _socket.Dispose();
+                    Sender.Tell(Tcp.Unbound.Instance);
+                    _log.Debug("Unbound endpoint {0}, stopping listener", _bind.LocalAddress);
+                    Context.Stop(Self);
+                    return true;
+
+                default:
+                    return false;
             }
-            return false;
         }
 
         /// <summary>
@@ -130,5 +130,15 @@ protected override void PostStop()
                 _log.Debug("Error closing ServerSocketChannel: {0}", e);
             }
         }
+
+        private readonly struct SocketEvent : INoSerializationVerificationNeeded
+        {
+            public readonly SocketAsyncEventArgs Args;
+
+            public SocketEvent(SocketAsyncEventArgs args)
+            {
+                Args = args;
+            }
+        }
     }
 }
diff --git a/src/core/Akka/IO/Udp.cs b/src/core/Akka/IO/Udp.cs
@@ -34,7 +34,7 @@ public class Udp : ExtensionIdProvider<UdpExt>
     {
         #region internal connection messages
 
-        internal abstract class SocketCompleted { }
+        internal abstract class SocketCompleted : INoSerializationVerificationNeeded { }
 
         internal sealed class SocketSent : SocketCompleted
         {
@@ -104,7 +104,7 @@ public override UdpExt CreateExtension(ExtendedActorSystem system)
         }
 
         /// <summary>The common interface for <see cref="Command"/> and <see cref="Event"/>.</summary>
-        public abstract class Message { }
+        public abstract class Message : INoSerializationVerificationNeeded { }
 
         /// <summary>The common type of all commands supported by the UDP implementation.</summary>
         public abstract class Command : Message
diff --git a/src/core/Akka/IO/UdpConnected.cs b/src/core/Akka/IO/UdpConnected.cs
@@ -34,7 +34,7 @@ public class UdpConnected : ExtensionIdProvider<UdpConnectedExt>
     {
         #region internal connection messages
 
-        internal abstract class SocketCompleted
+        internal abstract class SocketCompleted : INoSerializationVerificationNeeded
         {
             public readonly SocketAsyncEventArgs EventArgs;
 
@@ -92,7 +92,7 @@ public override UdpConnectedExt CreateExtension(ExtendedActorSystem system)
         /// <summary>
         /// The common interface for <see cref="Command"/> and <see cref="Event"/>.
         /// </summary>
-        public abstract class Message { }
+        public abstract class Message : INoSerializationVerificationNeeded { }
 
         /// <summary>
         /// The common type of all commands supported by the UDP implementation.
@@ -372,7 +372,7 @@ private Disconnected()
     /// <summary>
     /// TBD
     /// </summary>
-    public class UdpConnectedExt : IOExtension
+    public class UdpConnectedExt : IOExtension, INoSerializationVerificationNeeded
     {
         public UdpConnectedExt(ExtendedActorSystem system)
             : this(system, UdpSettings.Create(system.Settings.Config.GetConfig("akka.io.udp-connected")))

Original file line number	Diff line number	Diff line change
`@@ -3256,7 +3256,7 @@ namespace Akka.IO`
`3256`	`3256`	`public static Akka.IO.Dns.Resolved Cached(string name, Akka.Actor.ActorSystem system) { }`
`3257`	`3257`	`public override Akka.IO.DnsExt CreateExtension(Akka.Actor.ExtendedActorSystem system) { }`
`3258`	`3258`	`public static Akka.IO.Dns.Resolved ResolveName(string name, Akka.Actor.ActorSystem system, Akka.Actor.IActorRef sender) { }`
`3259`		`- public abstract class Command`
	`3259`	`+ public abstract class Command : Akka.Actor.INoSerializationVerificationNeeded`
`3260`	`3260`	`{`
`3261`	`3261`	`protected Command() { }`
`3262`	`3262`	`}`
`@@ -3685,7 +3685,7 @@ namespace Akka.IO`
`3685`	`3685`	`{`
`3686`	`3686`	`protected Event() { }`
`3687`	`3687`	`}`
`3688`		`- public abstract class Message`
	`3688`	`+ public abstract class Message : Akka.Actor.INoSerializationVerificationNeeded`
`3689`	`3689`	`{`
`3690`	`3690`	`protected Message() { }`
`3691`	`3691`	`}`
`@@ -3792,7 +3792,7 @@ namespace Akka.IO`
`3792`	`3792`	`{`
`3793`	`3793`	`protected Event() { }`
`3794`	`3794`	`}`
`3795`		`- public abstract class Message`
	`3795`	`+ public abstract class Message : Akka.Actor.INoSerializationVerificationNeeded`
`3796`	`3796`	`{`
`3797`	`3797`	`protected Message() { }`
`3798`	`3798`	`}`
`@@ -3827,7 +3827,7 @@ namespace Akka.IO`
`3827`	`3827`	`public static readonly Akka.IO.UdpConnected.SuspendReading Instance;`
`3828`	`3828`	`}`
`3829`	`3829`	`}`
`3830`		`- public class UdpConnectedExt : Akka.IO.IOExtension`
	`3830`	`+ public class UdpConnectedExt : Akka.IO.IOExtension, Akka.Actor.INoSerializationVerificationNeeded`
`3831`	`3831`	`{`
`3832`	`3832`	`public UdpConnectedExt(Akka.Actor.ExtendedActorSystem system) { }`
`3833`	`3833`	`public UdpConnectedExt(Akka.Actor.ExtendedActorSystem system, Akka.IO.UdpSettings settings) { }`
Original file line number	Diff line number	Diff line change
`@@ -10,8 +10,10 @@`
`10`	`10`	`using System.Collections.Immutable;`
`11`	`11`	`using System.Text;`
`12`	`12`	`using System.Runtime.CompilerServices;`
	`13`	`+using System.Runtime.Serialization;`
`13`	`14`	`using System.Threading;`
`14`	`15`	`using Akka.Actor.Internal;`
	`16`	`+using Akka.Dispatch.SysMsg;`
`15`	`17`	`using Akka.Serialization;`
`16`	`18`	`using Akka.Util;`
`17`	`19`	`using Akka.Util.Internal;`
`@@ -452,6 +454,7 @@ private IInternalActorRef MakeChild(Props props, string name, bool async, bool s`
`452`	`454`	`if (_systemImpl.Settings.SerializeAllCreators && !systemService && !(props.Deploy.Scope is LocalScope))`
`453`	`455`	`{`
`454`	`456`	`var oldInfo = Serialization.Serialization.CurrentTransportInformation;`
	`457`	`+ object propArgument = null;`
`455`	`458`	`try`
`456`	`459`	`{`
`457`	`460`	`if (oldInfo == null)`
`@@ -465,17 +468,24 @@ private IInternalActorRef MakeChild(Props props, string name, bool async, bool s`
`465`	`468`	`{`
`466`	`469`	`if (argument != null && !(argument is INoSerializationVerificationNeeded))`
`467`	`470`	`{`
	`471`	`+ propArgument = argument;`
`468`	`472`	`var serializer = ser.FindSerializerFor(argument);`
`469`	`473`	`var bytes = serializer.ToBinary(argument);`
`470`	`474`	`var ms = Serialization.Serialization.ManifestFor(serializer, argument);`
`471`		`- if(ser.Deserialize(bytes, serializer.Identifier, ms) == null)`
	`475`	`+ if (ser.Deserialize(bytes, serializer.Identifier, ms) == null)`
`472`	`476`	`throw new ArgumentException(`
`473`		`- $"Pre-creation serialization check failed at [${_self.Path}/{name}]",`
`474`		`- nameof(name));`
	`477`	`+ $"Pre-creation serialization check failed at [${_self.Path}/{name}]",`
	`478`	`+ nameof(name));`
`475`	`479`	`}`
`476`	`480`	`}`
`477`	`481`	`}`
`478`	`482`	`}`
	`483`	`+ catch (Exception e)`
	`484`	`+ {`
	`485`	`+ throw new SerializationException(`
	`486`	`+ $"Failed to serialize and deserialize actor props argument of type {propArgument?.GetType()} for actor type [{props.Type}].",`
	`487`	`+ e);`
	`488`	`+ }`
`479`	`489`	`finally`
`480`	`490`	`{`
`481`	`491`	`Serialization.Serialization.CurrentTransportInformation = oldInfo;`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ public override TcpExt CreateExtension(ExtendedActorSystem system)`
`53`	`53`
`54`	`54`	`#region internal connection messages`
`55`	`55`
`56`		`- internal abstract class SocketCompleted { }`
	`56`	`+ internal abstract class SocketCompleted : INoSerializationVerificationNeeded { }`
`57`	`57`
`58`	`58`	`internal sealed class SocketSent : SocketCompleted`
`59`	`59`	`{`