Merge pull request #481 from akka/wip-2136-balancing-routees-√

Wip 2136 balancing routees √

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

@@ -42,27 +42,27 @@ class ActorConfigurationVerificationSpec extends AkkaSpec(ActorConfigurationVeri
   "An Actor configured with a BalancingDispatcher" must {
     "fail verification with a ConfigurationException if also configured with a RoundRobinRouter" in {
       intercept[ConfigurationException] {
-        system.actorOf(Props[TestActor].withDispatcher("balancing-dispatcher").withRouter(RoundRobinRouter(2)))
+        system.actorOf(Props[TestActor].withRouter(RoundRobinRouter(2).withDispatcher("balancing-dispatcher")))
       }
     }
     "fail verification with a ConfigurationException if also configured with a BroadcastRouter" in {
       intercept[ConfigurationException] {
-        system.actorOf(Props[TestActor].withDispatcher("balancing-dispatcher").withRouter(BroadcastRouter(2)))
+        system.actorOf(Props[TestActor].withRouter(BroadcastRouter(2).withDispatcher("balancing-dispatcher")))
       }
     }
     "fail verification with a ConfigurationException if also configured with a RandomRouter" in {
       intercept[ConfigurationException] {
-        system.actorOf(Props[TestActor].withDispatcher("balancing-dispatcher").withRouter(RandomRouter(2)))
+        system.actorOf(Props[TestActor].withRouter(RandomRouter(2).withDispatcher("balancing-dispatcher")))
       }
     }
     "fail verification with a ConfigurationException if also configured with a SmallestMailboxRouter" in {
       intercept[ConfigurationException] {
-        system.actorOf(Props[TestActor].withDispatcher("balancing-dispatcher").withRouter(SmallestMailboxRouter(2)))
+        system.actorOf(Props[TestActor].withRouter(SmallestMailboxRouter(2).withDispatcher("balancing-dispatcher")))
       }
     }
     "fail verification with a ConfigurationException if also configured with a ScatterGatherFirstCompletedRouter" in {
       intercept[ConfigurationException] {
-        system.actorOf(Props[TestActor].withDispatcher("balancing-dispatcher").withRouter(ScatterGatherFirstCompletedRouter(nrOfInstances = 2, within = 2 seconds)))
+        system.actorOf(Props[TestActor].withRouter(ScatterGatherFirstCompletedRouter(nrOfInstances = 2, within = 2 seconds).withDispatcher("balancing-dispatcher")))
       }
     }
     "not fail verification with a ConfigurationException also not configured with a Router" in {

akka-actor-tests/src/test/scala/akka/routing/ResizerSpec.scala

@@ -128,6 +128,35 @@ class ResizerSpec extends AkkaSpec(ResizerSpec.config) with DefaultTimeout with
       current.routees.size must be(2)
     }
 
+    "resize when busy" ignore {
+
+      val busy = new TestLatch(1)
+
+      val resizer = DefaultResizer(
+        lowerBound = 1,
+        upperBound = 3,
+        pressureThreshold = 0,
+        messagesPerResize = 1)
+
+      val router = system.actorOf(Props[BusyActor].withRouter(RoundRobinRouter(resizer = Some(resizer))).withDispatcher("bal-disp"))
+
+      val latch1 = new TestLatch(1)
+      router ! (latch1, busy)
+      Await.ready(latch1, 2 seconds)
+
+      val latch2 = new TestLatch(1)
+      router ! (latch2, busy)
+      Await.ready(latch2, 2 seconds)
+
+      val latch3 = new TestLatch(1)
+      router ! (latch3, busy)
+      Await.ready(latch3, 2 seconds)
+
+      Await.result(router ? CurrentRoutees, 5 seconds).asInstanceOf[RouterRoutees].routees.size must be(3)
+
+      busy.countDown()
+    }
+
     "grow as needed under pressure" in {
       // make sure the pool starts at the expected lower limit and grows to the upper as needed
       // as influenced by the backlog of blocking pooled actors

akka-actor/src/main/scala/akka/routing/Routing.scala

@@ -30,7 +30,7 @@ private[akka] class RoutedActorRef(_system: ActorSystemImpl, _props: Props, _sup
     _path) {
 
   // verify that a BalancingDispatcher is not used with a Router
-  if (_system.dispatchers.isBalancingDispatcher(_props.dispatcher) && _props.routerConfig != NoRouter)
+  if (_props.routerConfig != NoRouter && _system.dispatchers.isBalancingDispatcher(_props.routerConfig.routerDispatcher))
     throw new ConfigurationException(
       "Configuration for actor [" + _path.toString +
         "] is invalid - you can not use a 'BalancingDispatcher' together with any type of 'Router'")

akka-docs/java/dispatchers.rst

@@ -85,7 +85,7 @@ There are 4 different types of message dispatchers:
                "thread-pool-executor" or the FQCN of
                an ``akka.dispatcher.ExecutorServiceConfigurator``
 
-  - Note that you can **not** use a ``BalancingDispatcher`` together with any kind of ``Router``, trying to do so will make your actor fail verification.
+  - Note that you can **not** use a ``BalancingDispatcher`` as a **Router Dispatcher**. (You can however use it for the **Routees**)
 
 * CallingThreadDispatcher
 

akka-docs/java/routing.rst

@@ -380,8 +380,8 @@ The dispatcher for created children of the router will be taken from
 makes sense to configure the :class:`BalancingDispatcher` if the precise
 routing is not so important (i.e. no consistent hashing or round-robin is
 required); this enables newly created routees to pick up work immediately by
-stealing it from their siblings. Note that you can **not** use a ``BalancingDispatcher``
-together with any kind of ``Router``, trying to do so will make your actor fail verification.
+stealing it from their siblings. Note that you can **not** use a ``BalancingDispatcher`` as a **Router Dispatcher**.
+(You can however use it for the **Routees**)
 
 The “head” router, of course, cannot run on the same balancing dispatcher,
 because it does not process the same messages, hence this special actor does

akka-docs/scala/dispatchers.rst

@@ -86,7 +86,7 @@ There are 4 different types of message dispatchers:
                "thread-pool-executor" or the FQCN of
                an ``akka.dispatcher.ExecutorServiceConfigurator``
 
-  - Note that you can **not** use a ``BalancingDispatcher`` together with any kind of ``Router``, trying to do so will make your actor fail verification.
+  - Note that you can **not** use a ``BalancingDispatcher`` as a **Router Dispatcher**. (You can however use it for the **Routees**)
 
 * CallingThreadDispatcher
 
@@ -114,7 +114,7 @@ And then using it:
 
 .. includecode:: ../scala/code/docs/dispatcher/DispatcherDocSpec.scala#defining-pinned-dispatcher
 
-Note that ``thread-pool-executor`` configuration as per the above ``my-thread-pool-dispatcher`` exmaple is
+Note that ``thread-pool-executor`` configuration as per the above ``my-thread-pool-dispatcher`` example is
 NOT applicable. This is because every actor will have its own thread pool when using ``PinnedDispatcher``,
 and that pool will have only one thread.
 

akka-docs/scala/routing.rst

@@ -380,8 +380,8 @@ The dispatcher for created children of the router will be taken from
 makes sense to configure the :class:`BalancingDispatcher` if the precise
 routing is not so important (i.e. no consistent hashing or round-robin is
 required); this enables newly created routees to pick up work immediately by
-stealing it from their siblings. Note that you can **not** use a ``BalancingDispatcher``
-together with any kind of ``Router``, trying to do so will make your actor fail verification.
+stealing it from their siblings. Note that you can **not** use a ``BalancingDispatcher`` as a **Router Dispatcher**.
+(You can however use it for the **Routees**)
 
 
 .. note::