make LocalScope mean “purely local” and avoid Props serialization check, see #3210

Author: rkuhn

akka-actor-tests/src/test/scala/akka/actor/DeathWatchSpec.scala

@@ -87,7 +87,7 @@ trait DeathWatchSpec { this: AkkaSpec with ImplicitSender with DefaultTimeout 
           case "ping"        ⇒ sender ! "pong"
           case t: Terminated ⇒ testActor ! WrappedTerminated(t)
         }
-      }))
+      }).withDeploy(Deploy.local))
 
       monitor2 ! "ping"
 
@@ -133,7 +133,7 @@ trait DeathWatchSpec { this: AkkaSpec with ImplicitSender with DefaultTimeout 
             super.handleFailure(context, child, cause, stats, children)
           }
         }
-        val supervisor = system.actorOf(Props(new Supervisor(strategy)))
+        val supervisor = system.actorOf(Props(new Supervisor(strategy)).withDeploy(Deploy.local))
 
         val failed = Await.result((supervisor ? Props.empty).mapTo[ActorRef], timeout.duration)
         val brother = Await.result((supervisor ? Props(new Actor {
@@ -166,7 +166,7 @@ trait DeathWatchSpec { this: AkkaSpec with ImplicitSender with DefaultTimeout 
                 context unbecome
             }
         }
-      }))
+      }).withDeploy(Deploy.local))
 
       parent ! "NKOTB"
       expectMsg("GREEN")
@@ -198,7 +198,7 @@ trait DeathWatchSpec { this: AkkaSpec with ImplicitSender with DefaultTimeout 
       }
 
       val t1, t2 = TestLatch()
-      val w = system.actorOf(Props(new Watcher), "myDearWatcher")
+      val w = system.actorOf(Props(new Watcher).withDeploy(Deploy.local), "myDearWatcher")
       val p = TestProbe()
       w ! W(p.ref)
       w ! ((t1, t2))

akka-actor-tests/src/test/scala/akka/io/BackpressureSpec.scala

@@ -6,16 +6,15 @@ package akka.io
 
 import java.net.InetSocketAddress
 import java.security.MessageDigest
-
 import scala.concurrent.Await
 import scala.concurrent.duration.{ Duration, DurationInt }
 import scala.concurrent.forkjoin.ThreadLocalRandom
-
 import akka.actor.{ Actor, ActorContext, ActorLogging, ActorRef, Props, ReceiveTimeout, Stash, Terminated }
 import akka.io.TcpPipelineHandler.{ Init, Management, WithinActorContext }
 import akka.pattern.ask
 import akka.testkit.{ AkkaSpec, ImplicitSender }
 import akka.util.{ ByteString, Timeout }
+import akka.actor.Deploy
 
 object BackpressureSpec {
 
@@ -38,7 +37,7 @@ object BackpressureSpec {
         val init = TcpPipelineHandler.withLogger(log,
           new TcpReadWriteAdapter >>
             new BackpressureBuffer(10000, 1000000, Long.MaxValue))
-        val handler = context.actorOf(TcpPipelineHandler(init, sender, self), "pipeline")
+        val handler = context.actorOf(TcpPipelineHandler(init, sender, self).withDeploy(Deploy.local), "pipeline")
         sender ! Tcp.Register(handler)
         unstashAll()
         context.become(connected(init, handler))
@@ -78,6 +77,8 @@ object BackpressureSpec {
     val failed: Receive = {
       case _ ⇒ sender ! Failed
     }
+
+    override def postRestart(thr: Throwable): Unit = context.stop(self)
   }
 
   case object GetPort
@@ -113,7 +114,7 @@ object BackpressureSpec {
         val init = TcpPipelineHandler.withLogger(log,
           new TcpReadWriteAdapter >>
             new BackpressureBuffer(10000, 1000000, Long.MaxValue))
-        val handler = context.actorOf(TcpPipelineHandler(init, sender, self), "pipeline")
+        val handler = context.actorOf(TcpPipelineHandler(init, sender, self).withDeploy(Deploy.local), "pipeline")
         sender ! Tcp.Register(handler)
         unstashAll()
         context.become(connected(init, handler))
@@ -147,10 +148,12 @@ object BackpressureSpec {
     val failed: Receive = {
       case _ ⇒ sender ! Failed
     }
+
+    override def postRestart(thr: Throwable): Unit = context.stop(self)
   }
 }
 
-class BackpressureSpec extends AkkaSpec with ImplicitSender {
+class BackpressureSpec extends AkkaSpec("akka.actor.serialize-creators=on") with ImplicitSender {
 
   import BackpressureSpec._
 

akka-actor-tests/src/test/scala/akka/io/CapacityLimitSpec.scala

@@ -9,7 +9,11 @@ import Tcp._
 import akka.TestUtils
 import TestUtils._
 
-class CapacityLimitSpec extends AkkaSpec("akka.loglevel = ERROR\nakka.io.tcp.max-channels = 4")
+class CapacityLimitSpec extends AkkaSpec("""
+    akka.loglevel = ERROR
+    akka.io.tcp.max-channels = 4
+    akka.actor.serialize-creators = on
+    """)
   with TcpIntegrationSpecSupport {
 
   "The TCP transport implementation" should {

akka-actor-tests/src/test/scala/akka/io/DelimiterFramingSpec.scala

@@ -12,8 +12,9 @@ import java.util.concurrent.atomic.AtomicInteger
 import scala.concurrent.duration._
 import akka.io.TcpPipelineHandler.Management
 import akka.actor.ActorRef
+import akka.actor.Deploy
 
-class DelimiterFramingSpec extends AkkaSpec {
+class DelimiterFramingSpec extends AkkaSpec("akka.actor.serialize-creators = on") {
 
   val addresses = TestUtils.temporaryServerAddresses(4)
 
@@ -40,7 +41,7 @@ class DelimiterFramingSpec extends AkkaSpec {
   val counter = new AtomicInteger
 
   def testSetup(serverAddress: InetSocketAddress, delimiter: String, includeDelimiter: Boolean): Unit = {
-    val bindHandler = system.actorOf(Props(classOf[AkkaLineEchoServer], this, delimiter, includeDelimiter))
+    val bindHandler = system.actorOf(Props(classOf[AkkaLineEchoServer], this, delimiter, includeDelimiter).withDeploy(Deploy.local))
     val probe = TestProbe()
     probe.send(IO(Tcp), Tcp.Bind(bindHandler, serverAddress))
     probe.expectMsgType[Tcp.Bound]
@@ -68,7 +69,7 @@ class DelimiterFramingSpec extends AkkaSpec {
 
     import init._
 
-    val handler = system.actorOf(TcpPipelineHandler(init, connection, probe.ref),
+    val handler = system.actorOf(TcpPipelineHandler(init, connection, probe.ref).withDeploy(Deploy.local),
       "client" + counter.incrementAndGet())
     probe.send(connection, Tcp.Register(handler))
 
@@ -128,7 +129,7 @@ class DelimiterFramingSpec extends AkkaSpec {
         import init._
 
         val connection = sender
-        val handler = context.actorOf(TcpPipelineHandler(init, sender, self), "pipeline")
+        val handler = context.actorOf(TcpPipelineHandler(init, sender, self).withDeploy(Deploy.local), "pipeline")
 
         connection ! Tcp.Register(handler)
 

akka-actor-tests/src/test/scala/akka/io/PipelineSpec.scala

@@ -12,7 +12,7 @@ import scala.concurrent.forkjoin.ThreadLocalRandom
 import scala.util.Try
 import scala.util.Success
 
-class PipelineSpec extends AkkaSpec {
+class PipelineSpec extends AkkaSpec("akka.actor.serialize-creators = on") {
 
   trait Level1
   trait Level2

akka-actor-tests/src/test/scala/akka/io/TcpConnectionSpec.scala

@@ -23,7 +23,10 @@ import akka.testkit.{ AkkaSpec, EventFilter, TestActorRef, TestProbe }
 import akka.util.{ Helpers, ByteString }
 import akka.TestUtils._
 
-class TcpConnectionSpec extends AkkaSpec("akka.io.tcp.register-timeout = 500ms") {
+class TcpConnectionSpec extends AkkaSpec("""
+    akka.io.tcp.register-timeout = 500ms
+    akka.actor.serialize-creators = on
+    """) {
   // Helper to avoid Windows localization specific differences
   def ignoreIfWindows(): Unit =
     if (Helpers.isWindows) {

akka-actor-tests/src/test/scala/akka/io/TcpIntegrationSpec.scala

@@ -12,7 +12,10 @@ import TestUtils._
 import akka.testkit.EventFilter
 import java.io.IOException
 
-class TcpIntegrationSpec extends AkkaSpec("akka.loglevel = INFO") with TcpIntegrationSpecSupport {
+class TcpIntegrationSpec extends AkkaSpec("""
+    akka.loglevel = INFO
+    akka.actor.serialize-creators = on
+    """) with TcpIntegrationSpecSupport {
 
   "The TCP transport implementation" should {
 

akka-actor-tests/src/test/scala/akka/io/TcpListenerSpec.scala

@@ -15,7 +15,10 @@ import akka.io.SelectionHandler._
 import akka.TestUtils
 import Tcp._
 
-class TcpListenerSpec extends AkkaSpec("akka.io.tcp.batch-accept-limit = 2") {
+class TcpListenerSpec extends AkkaSpec("""
+    akka.io.tcp.batch-accept-limit = 2
+    akka.actor.serialize-creators = on
+    """) {
 
   "A TcpListener" must {
 
@@ -130,7 +133,7 @@ class TcpListenerSpec extends AkkaSpec("akka.io.tcp.batch-accept-limit = 2") {
     private class ListenerParent extends Actor with ChannelRegistry {
       val listener = context.actorOf(
         props = Props(classOf[TcpListener], selectorRouter.ref, Tcp(system), this, bindCommander.ref,
-          Bind(handler.ref, endpoint, 100, Nil)),
+          Bind(handler.ref, endpoint, 100, Nil)).withDeploy(Deploy.local),
         name = "test-listener-" + counter.next())
       parent.watch(listener)
       def receive: Receive = {

akka-actor-tests/src/test/scala/akka/io/UdpConnectedIntegrationSpec.scala

@@ -10,7 +10,10 @@ import akka.util.ByteString
 import java.net.InetSocketAddress
 import akka.actor.ActorRef
 
-class UdpConnectedIntegrationSpec extends AkkaSpec("akka.loglevel = INFO") with ImplicitSender {
+class UdpConnectedIntegrationSpec extends AkkaSpec("""
+    akka.loglevel = INFO
+    akka.actor.serialize-creators = on
+    """) with ImplicitSender {
 
   val addresses = temporaryServerAddresses(3, udp = true)
 

akka-actor-tests/src/test/scala/akka/io/UdpIntegrationSpec.scala

@@ -10,7 +10,9 @@ import akka.util.ByteString
 import java.net.InetSocketAddress
 import akka.actor.ActorRef
 
-class UdpIntegrationSpec extends AkkaSpec("akka.loglevel = INFO") with ImplicitSender {
+class UdpIntegrationSpec extends AkkaSpec("""
+    akka.loglevel = INFO
+    akka.actor.serialize-creators = on""") with ImplicitSender {
 
   val addresses = temporaryServerAddresses(3, udp = true)