rewrite mailbox selection logic, see #3342

- add “mailbox-requirement” key to dispatcher section
- split out mailbox section, add akka.actor.default-mailbox
- rewrite findMarker method and use it for Props.create() and getting
  the required mailbox of an actor
- add ProducesMessageQueue trait for MailboxType so that requirements
  can be checked before trying to create the actor for real
- verify actor as well as dispatcher requirements for message queue
  before creation, even in remote-deployed case
- change MessageDispatcher constructor to take a Configurator, add that
  to migration guide

Author: rkuhn

akka-actor-tests/src/test/java/akka/actor/ActorCreationTest.java

@@ -47,6 +47,14 @@ public T create() {
     }
   }
 
+  static interface I<T> extends Creator<UntypedActor> {}
+  static class F implements I<Object> {
+    @Override
+    public UntypedActor create() {
+      return null;
+    }
+  }
+  
   @Test
   public void testRightCreator() {
     final Props p = Props.create(new C());
@@ -65,4 +73,10 @@ public void testBoundedCreator() {
     assertEquals(UntypedActor.class, p.actorClass());
   }
 
+  @Test
+  public void testSuperinterface() {
+    final Props p = Props.create(new F());
+    assertEquals(UntypedActor.class, p.actorClass());
+  }
+  
 }

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

@@ -22,6 +22,13 @@ object ActorMailboxSpec {
       mailbox-type = "akka.dispatch.BoundedMailbox"
     }
 
+    requiring-bounded-dispatcher {
+      mailbox-capacity = 1000
+      mailbox-push-timeout-time = 10s
+      mailbox-type = "akka.dispatch.BoundedMailbox"
+      mailbox-requirement = "akka.dispatch.BoundedMessageQueueSemantics"
+    }
+
     unbounded-mailbox {
       mailbox-type = "akka.dispatch.UnboundedMailbox"
     }
@@ -80,10 +87,32 @@ object ActorMailboxSpec {
         dispatcher = bounded-dispatcher
         mailbox = unbounded-mailbox
       }
-    }
-
-    akka.actor.mailbox.requirements {
-      "akka.dispatch.BoundedMessageQueueSemantics" = bounded-mailbox
+      /bounded-deque-requirements-configured {
+        dispatcher = requiring-bounded-dispatcher
+        mailbox = akka.actor.mailbox.bounded-deque-based
+      }
+      /bounded-deque-require-unbounded-configured {
+        dispatcher = requiring-bounded-dispatcher
+        mailbox = akka.actor.mailbox.unbounded-deque-based
+      }
+      /bounded-deque-require-unbounded-unconfigured {
+        dispatcher = requiring-bounded-dispatcher
+      }
+      /bounded-deque-requirements-configured-props-disp {
+        mailbox = akka.actor.mailbox.bounded-deque-based
+      }
+      /bounded-deque-require-unbounded-configured-props-disp {
+        mailbox = akka.actor.mailbox.unbounded-deque-based
+      }
+      /bounded-deque-requirements-configured-props-mail {
+        dispatcher = requiring-bounded-dispatcher
+      }
+      /bounded-deque-require-unbounded-configured-props-mail {
+        dispatcher = requiring-bounded-dispatcher
+      }
+      /bounded-deque-require-unbounded-unconfigured-props-mail {
+        dispatcher = requiring-bounded-dispatcher
+      }
     }
   """)
 
@@ -97,10 +126,16 @@ object ActorMailboxSpec {
 
   class StashQueueReportingActor extends QueueReportingActor with Stash
 
-  val UnboundedMailboxTypes = Seq(classOf[QueueBasedMessageQueue], classOf[UnboundedMessageQueueSemantics])
-  val BoundedMailboxTypes = Seq(classOf[QueueBasedMessageQueue], classOf[BoundedMessageQueueSemantics])
-  val UnboundedDeqMailboxTypes = Seq(classOf[QueueBasedMessageQueue], classOf[DequeBasedMessageQueue],
+  val UnboundedMailboxTypes = Seq(classOf[UnboundedMessageQueueSemantics])
+  val BoundedMailboxTypes = Seq(classOf[BoundedMessageQueueSemantics])
+  val UnboundedDeqMailboxTypes = Seq(
+    classOf[DequeBasedMessageQueueSemantics],
+    classOf[UnboundedMessageQueueSemantics],
     classOf[UnboundedDequeBasedMessageQueueSemantics])
+  val BoundedDeqMailboxTypes = Seq(
+    classOf[DequeBasedMessageQueueSemantics],
+    classOf[BoundedMessageQueueSemantics],
+    classOf[BoundedDequeBasedMessageQueueSemantics])
 }
 
 class ActorMailboxSpec extends AkkaSpec(ActorMailboxSpec.mailboxConf) with DefaultTimeout with ImplicitSender {
@@ -122,7 +157,7 @@ class ActorMailboxSpec extends AkkaSpec(ActorMailboxSpec.mailboxConf) with Defau
       checkMailboxQueue(Props[QueueReportingActor], "default-default", UnboundedMailboxTypes)
     }
 
-    "get an unbounded dequeu message queue when it is only configured on the props" in {
+    "get an unbounded deque message queue when it is only configured on the props" in {
       checkMailboxQueue(Props[QueueReportingActor].withMailbox("akka.actor.mailbox.unbounded-deque-based"),
         "default-override-from-props", UnboundedDeqMailboxTypes)
     }
@@ -132,7 +167,7 @@ class ActorMailboxSpec extends AkkaSpec(ActorMailboxSpec.mailboxConf) with Defau
         "default-override-from-trait", BoundedMailboxTypes)
     }
 
-    "get an unbounded dequeu message queue when it's only mixed with Stash" in {
+    "get an unbounded deque message queue when it's only mixed with Stash" in {
       checkMailboxQueue(Props[StashQueueReportingActor],
         "default-override-from-stash", UnboundedDeqMailboxTypes)
     }
@@ -141,24 +176,20 @@ class ActorMailboxSpec extends AkkaSpec(ActorMailboxSpec.mailboxConf) with Defau
       checkMailboxQueue(Props[QueueReportingActor], "default-bounded", BoundedMailboxTypes)
     }
 
-    "get an unbounded dequeu message queue when it's configured as mailbox" in {
+    "get an unbounded deque message queue when it's configured as mailbox" in {
       checkMailboxQueue(Props[QueueReportingActor], "default-unbounded-deque", UnboundedDeqMailboxTypes)
     }
 
     "fail to create actor when an unbounded dequeu message queue is configured as mailbox overriding RequestMailbox" in {
-      filterEvents(EventFilter[ActorInitializationException]()) {
-        verifyActorTermination(system.actorOf(Props[BoundedQueueReportingActor], "default-unbounded-deque-override-trait"))
-      }
+      intercept[IllegalArgumentException](system.actorOf(Props[BoundedQueueReportingActor], "default-unbounded-deque-override-trait"))
     }
 
     "get an unbounded message queue when defined in dispatcher" in {
       checkMailboxQueue(Props[QueueReportingActor], "unbounded-default", UnboundedMailboxTypes)
     }
 
     "fail to create actor when an unbounded message queue is defined in dispatcher overriding RequestMailbox" in {
-      filterEvents(EventFilter[ActorInitializationException]()) {
-        verifyActorTermination(system.actorOf(Props[BoundedQueueReportingActor], "unbounded-default-override-trait"))
-      }
+      intercept[IllegalArgumentException](system.actorOf(Props[BoundedQueueReportingActor], "unbounded-default-override-trait"))
     }
 
     "get a bounded message queue when it's configured as mailbox overriding unbounded in dispatcher" in {
@@ -183,5 +214,84 @@ class ActorMailboxSpec extends AkkaSpec(ActorMailboxSpec.mailboxConf) with Defau
         "bounded-unbounded-override-props", UnboundedMailboxTypes)
     }
 
+    "get a bounded deque-based message queue if configured and required" in {
+      checkMailboxQueue(Props[StashQueueReportingActor], "bounded-deque-requirements-configured", BoundedDeqMailboxTypes)
+    }
+
+    "fail with a unbounded deque-based message queue if configured and required" in {
+      intercept[IllegalArgumentException](system.actorOf(Props[StashQueueReportingActor], "bounded-deque-require-unbounded-configured"))
+    }
+
+    "fail with a bounded deque-based message queue if not configured" in {
+      intercept[IllegalArgumentException](system.actorOf(Props[StashQueueReportingActor], "bounded-deque-require-unbounded-unconfigured"))
+    }
+
+    "get a bounded deque-based message queue if configured and required with Props" in {
+      checkMailboxQueue(
+        Props[StashQueueReportingActor]
+          .withDispatcher("requiring-bounded-dispatcher")
+          .withMailbox("akka.actor.mailbox.bounded-deque-based"),
+        "bounded-deque-requirements-configured-props",
+        BoundedDeqMailboxTypes)
+    }
+
+    "fail with a unbounded deque-based message queue if configured and required with Props" in {
+      intercept[IllegalArgumentException](system.actorOf(
+        Props[StashQueueReportingActor]
+          .withDispatcher("requiring-bounded-dispatcher")
+          .withMailbox("akka.actor.mailbox.unbounded-deque-based"),
+        "bounded-deque-require-unbounded-configured-props"))
+    }
+
+    "fail with a bounded deque-based message queue if not configured with Props" in {
+      intercept[IllegalArgumentException](system.actorOf(
+        Props[StashQueueReportingActor]
+          .withDispatcher("requiring-bounded-dispatcher"),
+        "bounded-deque-require-unbounded-unconfigured-props"))
+    }
+
+    "get a bounded deque-based message queue if configured and required with Props (dispatcher)" in {
+      checkMailboxQueue(
+        Props[StashQueueReportingActor]
+          .withDispatcher("requiring-bounded-dispatcher"),
+        "bounded-deque-requirements-configured-props-disp",
+        BoundedDeqMailboxTypes)
+    }
+
+    "fail with a unbounded deque-based message queue if configured and required with Props (dispatcher)" in {
+      intercept[IllegalArgumentException](system.actorOf(
+        Props[StashQueueReportingActor]
+          .withDispatcher("requiring-bounded-dispatcher"),
+        "bounded-deque-require-unbounded-configured-props-disp"))
+    }
+
+    "fail with a bounded deque-based message queue if not configured with Props (dispatcher)" in {
+      intercept[IllegalArgumentException](system.actorOf(
+        Props[StashQueueReportingActor]
+          .withDispatcher("requiring-bounded-dispatcher"),
+        "bounded-deque-require-unbounded-unconfigured-props-disp"))
+    }
+
+    "get a bounded deque-based message queue if configured and required with Props (mailbox)" in {
+      checkMailboxQueue(
+        Props[StashQueueReportingActor]
+          .withMailbox("akka.actor.mailbox.bounded-deque-based"),
+        "bounded-deque-requirements-configured-props-mail",
+        BoundedDeqMailboxTypes)
+    }
+
+    "fail with a unbounded deque-based message queue if configured and required with Props (mailbox)" in {
+      intercept[IllegalArgumentException](system.actorOf(
+        Props[StashQueueReportingActor]
+          .withMailbox("akka.actor.mailbox.unbounded-deque-based"),
+        "bounded-deque-require-unbounded-configured-props-mail"))
+    }
+
+    "fail with a bounded deque-based message queue if not configured with Props (mailbox)" in {
+      intercept[IllegalArgumentException](system.actorOf(
+        Props[StashQueueReportingActor],
+        "bounded-deque-require-unbounded-unconfigured-props-mail"))
+    }
+
   }
 }

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

@@ -84,12 +84,10 @@ object ActorSystemSpec {
 
   class SlowDispatcher(_config: Config, _prerequisites: DispatcherPrerequisites) extends MessageDispatcherConfigurator(_config, _prerequisites) {
     private val instance = new Dispatcher(
-      prerequisites,
+      this,
       config.getString("id"),
       config.getInt("throughput"),
       Duration(config.getNanoseconds("throughput-deadline-time"), TimeUnit.NANOSECONDS),
-      mailboxType,
-      mailBoxTypeConfigured,
       configureExecutor(),
       Duration(config.getMilliseconds("shutdown-timeout"), TimeUnit.MILLISECONDS)) {
       val doneIt = new Switch

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

@@ -269,7 +269,7 @@ class IOActorSpec extends AkkaSpec with DefaultTimeout {
         case Failure(e) if check(n, e) ⇒
           if (delay.isDefined) {
             executor match {
-              case m: MessageDispatcher ⇒ m.prerequisites.scheduler.scheduleOnce(delay.get)(run(n + 1))
+              case m: MessageDispatcher ⇒ m.configurator.prerequisites.scheduler.scheduleOnce(delay.get)(run(n + 1))
               case _                    ⇒ // Thread.sleep, ignore, or other?
             }
           } else run(n + 1)

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

@@ -78,12 +78,10 @@ object SupervisorHierarchySpec {
     extends DispatcherConfigurator(config, prerequisites) {
 
     private val instance: MessageDispatcher =
-      new Dispatcher(prerequisites,
+      new Dispatcher(this,
         config.getString("id"),
         config.getInt("throughput"),
         Duration(config.getNanoseconds("throughput-deadline-time"), TimeUnit.NANOSECONDS),
-        mailboxType,
-        mailBoxTypeConfigured,
         configureExecutor(),
         Duration(config.getMilliseconds("shutdown-timeout"), TimeUnit.MILLISECONDS)) {
 

akka-actor-tests/src/test/scala/akka/actor/dispatch/ActorModelSpec.scala

@@ -529,12 +529,10 @@ object DispatcherModelSpec {
     extends MessageDispatcherConfigurator(config, prerequisites) {
 
     private val instance: MessageDispatcher =
-      new Dispatcher(prerequisites,
+      new Dispatcher(this,
         config.getString("id"),
         config.getInt("throughput"),
         Duration(config.getNanoseconds("throughput-deadline-time"), TimeUnit.NANOSECONDS),
-        mailboxType,
-        mailBoxTypeConfigured,
         configureExecutor(),
         Duration(config.getMilliseconds("shutdown-timeout"), TimeUnit.MILLISECONDS)) with MessageDispatcherInterceptor
 
@@ -600,20 +598,17 @@ object BalancingDispatcherModelSpec {
   }
 
   class BalancingMessageDispatcherInterceptorConfigurator(config: Config, prerequisites: DispatcherPrerequisites)
-    extends MessageDispatcherConfigurator(config, prerequisites) {
+    extends BalancingDispatcherConfigurator(config, prerequisites) {
 
-    private val instance: MessageDispatcher =
-      new BalancingDispatcher(prerequisites,
+    override protected def create(mailboxType: MailboxType): BalancingDispatcher =
+      new BalancingDispatcher(this,
         config.getString("id"),
         config.getInt("throughput"),
         Duration(config.getNanoseconds("throughput-deadline-time"), TimeUnit.NANOSECONDS),
         mailboxType,
-        mailBoxTypeConfigured,
         configureExecutor(),
         Duration(config.getMilliseconds("shutdown-timeout"), TimeUnit.MILLISECONDS),
         config.getBoolean("attempt-teamwork")) with MessageDispatcherInterceptor
-
-    override def dispatcher(): MessageDispatcher = instance
   }
 }
 

akka-actor-tests/src/test/scala/akka/config/ConfigSpec.scala

@@ -63,9 +63,6 @@ class ConfigSpec extends AkkaSpec(ConfigFactory.defaultReference(ActorSystem.fin
         {
           c.getString("type") must equal("Dispatcher")
           c.getString("executor") must equal("fork-join-executor")
-          c.getInt("mailbox-capacity") must equal(-1)
-          c.getMilliseconds("mailbox-push-timeout-time") must equal(10 * 1000)
-          c.getString("mailbox-type") must be("")
           c.getMilliseconds("shutdown-timeout") must equal(1 * 1000)
           c.getInt("throughput") must equal(5)
           c.getMilliseconds("throughput-deadline-time") must equal(0)
@@ -134,6 +131,18 @@ class ConfigSpec extends AkkaSpec(ConfigFactory.defaultReference(ActorSystem.fin
           io.getInt("default-backlog") must be(ioExtSettings.defaultBacklog)
         }
       }
+
+      {
+        val c = config.getConfig("akka.actor.default-mailbox")
+
+        // general mailbox config
+
+        {
+          c.getInt("mailbox-capacity") must equal(1000)
+          c.getMilliseconds("mailbox-push-timeout-time") must equal(10 * 1000)
+          c.getString("mailbox-type") must be("akka.dispatch.UnboundedMailbox")
+        }
+      }
     }
   }
 }

akka-actor-tests/src/test/scala/akka/dispatch/MailboxConfigSpec.scala

@@ -209,7 +209,7 @@ object CustomMailboxSpec {
     }
   }
 
-  class MyMailbox(owner: ActorRef) extends QueueBasedMessageQueue with UnboundedMessageQueueSemantics {
+  class MyMailbox(owner: ActorRef) extends UnboundedQueueBasedMessageQueue {
     final val queue = new ConcurrentLinkedQueue[Envelope]()
   }
 }

akka-actor-tests/src/test/scala/akka/testkit/CallingThreadDispatcherModelSpec.scala

@@ -32,7 +32,7 @@ object CallingThreadDispatcherModelSpec {
     extends MessageDispatcherConfigurator(config, prerequisites) {
 
     private val instance: MessageDispatcher =
-      new CallingThreadDispatcher(prerequisites, UnboundedMailbox(), false) with MessageDispatcherInterceptor {
+      new CallingThreadDispatcher(this) with MessageDispatcherInterceptor {
         override def id: String = config.getString("id")
       }