Merge branch 'master' into pluggable-serializer
This commit is contained in:
Jonas Bonér
commit
04bf416ead
80 changed files with 1366 additions and 789 deletions
|
|
@ -23,7 +23,7 @@ object ActorFireForgetRequestReplySpec {
|
|||
case "Send" ⇒
|
||||
self.reply("Reply")
|
||||
case "SendImplicit" ⇒
|
||||
self.sender.get ! "ReplyImplicit"
|
||||
self.channel ! "ReplyImplicit"
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -260,7 +260,7 @@ class ActorRefSpec extends WordSpec with MustMatchers {
|
|||
def receive = { case _ ⇒ self reply nested }
|
||||
}).start()
|
||||
|
||||
val nested = (a !! "any").get.asInstanceOf[ActorRef]
|
||||
val nested = (a ? "any").as[ActorRef].get
|
||||
a must not be null
|
||||
nested must not be null
|
||||
(a ne nested) must be === true
|
||||
|
|
@ -268,13 +268,13 @@ class ActorRefSpec extends WordSpec with MustMatchers {
|
|||
|
||||
"support advanced nested actorOfs" in {
|
||||
val a = Actor.actorOf(new OuterActor(Actor.actorOf(new InnerActor).start)).start
|
||||
val inner = (a !! "innerself").get
|
||||
val inner = (a ? "innerself").as[Any].get
|
||||
|
||||
(a !! a).get must be(a)
|
||||
(a !! "self").get must be(a)
|
||||
(a ? a).as[ActorRef].get must be(a)
|
||||
(a ? "self").as[ActorRef].get must be(a)
|
||||
inner must not be a
|
||||
|
||||
(a !! "msg").get must be === "msg"
|
||||
(a ? "msg").as[String] must be === Some("msg")
|
||||
}
|
||||
|
||||
"support reply via channel" in {
|
||||
|
|
@ -310,11 +310,11 @@ class ActorRefSpec extends WordSpec with MustMatchers {
|
|||
}
|
||||
}).start()
|
||||
|
||||
val ffive: Future[String] = ref !!! 5
|
||||
val fnull: Future[String] = ref !!! null
|
||||
val ffive = (ref ? 5).mapTo[String]
|
||||
val fnull = (ref ? null).mapTo[String]
|
||||
|
||||
intercept[ActorKilledException] {
|
||||
ref !! PoisonPill
|
||||
(ref ? PoisonPill).get
|
||||
fail("shouldn't get here")
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,44 @@
|
|||
/**
|
||||
* Copyright (C) 2009-2011 Scalable Solutions AB <http://scalablesolutions.se>
|
||||
*/
|
||||
package akka.actor
|
||||
|
||||
import org.scalatest.{ WordSpec, BeforeAndAfterAll }
|
||||
import org.scalatest.matchers.MustMatchers
|
||||
import akka.testkit.TestKit
|
||||
import akka.dispatch.FutureTimeoutException
|
||||
import akka.util.duration._
|
||||
|
||||
class ActorTimeoutSpec
|
||||
extends WordSpec
|
||||
with BeforeAndAfterAll
|
||||
with MustMatchers
|
||||
with TestKit {
|
||||
|
||||
val echo = Actor.actorOf(new Actor {
|
||||
def receive = {
|
||||
case x ⇒
|
||||
}
|
||||
}).start()
|
||||
|
||||
val testTimeout = if (Actor.defaultTimeout.duration < 400.millis) 500 millis else 100 millis
|
||||
|
||||
override def afterAll { echo.stop() }
|
||||
|
||||
"An Actor-based Future" must {
|
||||
|
||||
"use the global default timeout if no implicit in scope" in {
|
||||
echo.timeout = 12
|
||||
within((Actor.TIMEOUT - 100).millis, (Actor.TIMEOUT + 300).millis) {
|
||||
val f = echo ? "hallo"
|
||||
intercept[FutureTimeoutException] { f.await }
|
||||
}
|
||||
}
|
||||
|
||||
"use explicitly supplied timeout" in {
|
||||
within(testTimeout - 100.millis, testTimeout + 300.millis) {
|
||||
(echo.?("hallo", testTimeout)).as[String] must be(None)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -102,7 +102,7 @@ object Chameneos {
|
|||
}
|
||||
} else {
|
||||
waitingChameneo.foreach(_ ! Exit)
|
||||
self.sender.get ! Exit
|
||||
self.channel ! Exit
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -50,10 +50,7 @@ object ForwardActorSpec {
|
|||
val latch = TestLatch()
|
||||
val forwardActor = actorOf[ForwardActor]
|
||||
forwardActor.start()
|
||||
(forwardActor !! "SendBangBang") match {
|
||||
case Some(_) ⇒ latch.countDown()
|
||||
case None ⇒ {}
|
||||
}
|
||||
forwardActor ? "SendBangBang" onComplete { _ ⇒ latch.countDown() }
|
||||
def receive = {
|
||||
case _ ⇒ {}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -66,7 +66,7 @@ object SupervisorSpec {
|
|||
}
|
||||
|
||||
override def receive = {
|
||||
case Die ⇒ temp !! (Die, TimeoutMillis)
|
||||
case Die ⇒ (temp.?(Die, TimeoutMillis)).get
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -200,13 +200,13 @@ class SupervisorSpec extends WordSpec with MustMatchers with BeforeAndAfterEach
|
|||
}
|
||||
|
||||
def ping(pingPongActor: ActorRef) = {
|
||||
(pingPongActor !! (Ping, TimeoutMillis)).getOrElse("nil") must be(PongMessage)
|
||||
messageLogPoll must be(PingMessage)
|
||||
(pingPongActor.?(Ping, TimeoutMillis)).as[String].getOrElse("nil") must be === PongMessage
|
||||
messageLogPoll must be === PingMessage
|
||||
}
|
||||
|
||||
def kill(pingPongActor: ActorRef) = {
|
||||
intercept[RuntimeException] { pingPongActor !! (Die, TimeoutMillis) }
|
||||
messageLogPoll must be(ExceptionMessage)
|
||||
messageLogPoll must be === ExceptionMessage
|
||||
}
|
||||
|
||||
"A supervisor" must {
|
||||
|
|
@ -215,7 +215,7 @@ class SupervisorSpec extends WordSpec with MustMatchers with BeforeAndAfterEach
|
|||
val master = actorOf[Master].start()
|
||||
|
||||
intercept[RuntimeException] {
|
||||
master !! (Die, TimeoutMillis)
|
||||
(master.?(Die, TimeoutMillis)).get
|
||||
}
|
||||
|
||||
sleepFor(1 second)
|
||||
|
|
@ -226,7 +226,7 @@ class SupervisorSpec extends WordSpec with MustMatchers with BeforeAndAfterEach
|
|||
val (temporaryActor, supervisor) = temporaryActorAllForOne
|
||||
|
||||
intercept[RuntimeException] {
|
||||
temporaryActor !! (Die, TimeoutMillis)
|
||||
(temporaryActor.?(Die, TimeoutMillis)).get
|
||||
}
|
||||
|
||||
sleepFor(1 second)
|
||||
|
|
@ -374,13 +374,13 @@ class SupervisorSpec extends WordSpec with MustMatchers with BeforeAndAfterEach
|
|||
Supervise(dyingActor, Permanent) :: Nil))
|
||||
|
||||
intercept[Exception] {
|
||||
dyingActor !! (Die, TimeoutMillis)
|
||||
(dyingActor.?(Die, TimeoutMillis)).get
|
||||
}
|
||||
|
||||
// give time for restart
|
||||
sleepFor(3 seconds)
|
||||
|
||||
(dyingActor !! (Ping, TimeoutMillis)).getOrElse("nil") must be(PongMessage)
|
||||
(dyingActor.?(Ping, TimeoutMillis)).as[String].getOrElse("nil") must be === PongMessage
|
||||
|
||||
inits.get must be(3)
|
||||
|
||||
|
|
|
|||
|
|
@ -348,9 +348,9 @@ abstract class ActorModelSpec extends JUnitSuite {
|
|||
implicit val dispatcher = newInterceptedDispatcher
|
||||
val a = newTestActor.start()
|
||||
dispatcher.suspend(a)
|
||||
val f1: Future[String] = a !!! Reply("foo")
|
||||
val stopped = a !!! PoisonPill
|
||||
val shouldBeCompleted = for (i ← 1 to 10) yield a !!! Reply(i)
|
||||
val f1: Future[String] = a ? Reply("foo") mapTo manifest[String]
|
||||
val stopped = a ? PoisonPill
|
||||
val shouldBeCompleted = for (i ← 1 to 10) yield a ? Reply(i)
|
||||
dispatcher.resume(a)
|
||||
assert(f1.get === "foo")
|
||||
stopped.await
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ class DispatcherActorSpec extends JUnitSuite {
|
|||
@Test
|
||||
def shouldSendReplySync = {
|
||||
val actor = actorOf[TestActor].start()
|
||||
val result = (actor !! ("Hello", 10000)).as[String]
|
||||
val result = (actor.?("Hello", 10000)).as[String]
|
||||
assert("World" === result.get)
|
||||
actor.stop()
|
||||
}
|
||||
|
|
@ -53,8 +53,8 @@ class DispatcherActorSpec extends JUnitSuite {
|
|||
@Test
|
||||
def shouldSendReplyAsync = {
|
||||
val actor = actorOf[TestActor].start()
|
||||
val result = actor !! "Hello"
|
||||
assert("World" === result.get.asInstanceOf[String])
|
||||
val result = (actor ? "Hello").as[String]
|
||||
assert("World" === result.get)
|
||||
actor.stop()
|
||||
}
|
||||
|
||||
|
|
@ -62,7 +62,7 @@ class DispatcherActorSpec extends JUnitSuite {
|
|||
def shouldSendReceiveException = {
|
||||
val actor = actorOf[TestActor].start()
|
||||
try {
|
||||
actor !! "Failure"
|
||||
(actor ? "Failure").get
|
||||
fail("Should have thrown an exception")
|
||||
} catch {
|
||||
case e ⇒
|
||||
|
|
@ -40,7 +40,7 @@ class FutureSpec extends JUnitSuite {
|
|||
def shouldActorReplyResultThroughExplicitFuture {
|
||||
val actor = actorOf[TestActor]
|
||||
actor.start()
|
||||
val future = actor !!! "Hello"
|
||||
val future = actor ? "Hello"
|
||||
future.await
|
||||
assert(future.result.isDefined)
|
||||
assert("World" === future.result.get)
|
||||
|
|
@ -51,7 +51,7 @@ class FutureSpec extends JUnitSuite {
|
|||
def shouldActorReplyExceptionThroughExplicitFuture {
|
||||
val actor = actorOf[TestActor]
|
||||
actor.start()
|
||||
val future = actor !!! "Failure"
|
||||
val future = actor ? "Failure"
|
||||
future.await
|
||||
assert(future.exception.isDefined)
|
||||
assert("Expected exception; to test fault-tolerance" === future.exception.get.getMessage)
|
||||
|
|
@ -62,22 +62,8 @@ class FutureSpec extends JUnitSuite {
|
|||
def shouldFutureCompose {
|
||||
val actor1 = actorOf[TestActor].start()
|
||||
val actor2 = actorOf(new Actor { def receive = { case s: String ⇒ self reply s.toUpperCase } }).start()
|
||||
val future1 = actor1 !!! "Hello" flatMap ((s: String) ⇒ actor2 !!! s)
|
||||
val future2 = actor1 !!! "Hello" flatMap (actor2 !!! (_: String))
|
||||
val future3 = actor1 !!! "Hello" flatMap (actor2 !!! (_: Int))
|
||||
assert((future1.get: Any) === "WORLD")
|
||||
assert((future2.get: Any) === "WORLD")
|
||||
intercept[ClassCastException] { future3.get }
|
||||
actor1.stop()
|
||||
actor2.stop()
|
||||
}
|
||||
|
||||
@Test
|
||||
def shouldFutureComposePatternMatch {
|
||||
val actor1 = actorOf[TestActor].start()
|
||||
val actor2 = actorOf(new Actor { def receive = { case s: String ⇒ self reply s.toUpperCase } }).start()
|
||||
val future1 = actor1 !!! "Hello" collect { case (s: String) ⇒ s } flatMap (actor2 !!! _)
|
||||
val future2 = actor1 !!! "Hello" collect { case (n: Int) ⇒ n } flatMap (actor2 !!! _)
|
||||
val future1 = actor1 ? "Hello" flatMap { _ match { case s: String ⇒ actor2 ? s } }
|
||||
val future2 = actor1 ? "Hello" flatMap { _ match { case i: Int ⇒ actor2 ? i } }
|
||||
assert((future1.get: Any) === "WORLD")
|
||||
intercept[MatchError] { future2.get }
|
||||
actor1.stop()
|
||||
|
|
@ -93,18 +79,18 @@ class FutureSpec extends JUnitSuite {
|
|||
}
|
||||
}).start()
|
||||
|
||||
val future0 = actor !!! "Hello"
|
||||
val future0 = actor ? "Hello"
|
||||
|
||||
val future1 = for {
|
||||
a: Int ← future0 // returns 5
|
||||
b: String ← actor !!! a // returns "10"
|
||||
c: String ← actor !!! 7 // returns "14"
|
||||
a: Int ← future0.mapTo[Int] // returns 5
|
||||
b: String ← (actor ? a).mapTo[String] // returns "10"
|
||||
c: String ← (actor ? 7).mapTo[String] // returns "14"
|
||||
} yield b + "-" + c
|
||||
|
||||
val future2 = for {
|
||||
a: Int ← future0
|
||||
b: Int ← actor !!! a
|
||||
c: String ← actor !!! 7
|
||||
a: Int ← future0.mapTo[Int]
|
||||
b: Int ← (actor ? a).mapTo[Int]
|
||||
c: String ← (actor ? 7).mapTo[String]
|
||||
} yield b + "-" + c
|
||||
|
||||
assert(future1.get === "10-14")
|
||||
|
|
@ -124,15 +110,15 @@ class FutureSpec extends JUnitSuite {
|
|||
}).start()
|
||||
|
||||
val future1 = for {
|
||||
Res(a: Int) ← actor.!!![Res[Int]](Req("Hello"))
|
||||
Res(b: String) ← actor.!!![Res[String]](Req(a))
|
||||
Res(c: String) ← actor.!!![Res[String]](Req(7))
|
||||
Res(a: Int) ← actor ? Req("Hello")
|
||||
Res(b: String) ← actor ? Req(a)
|
||||
Res(c: String) ← actor ? Req(7)
|
||||
} yield b + "-" + c
|
||||
|
||||
val future2 = for {
|
||||
Res(a: Int) ← actor.!!![Any](Req("Hello"))
|
||||
Res(b: Int) ← actor.!!![Res[Int]](Req(a))
|
||||
Res(c: Int) ← actor.!!![Res[Int]](Req(7))
|
||||
Res(a: Int) ← actor ? Req("Hello")
|
||||
Res(b: Int) ← actor ? Req(a)
|
||||
Res(c: Int) ← actor ? Req(7)
|
||||
} yield b + "-" + c
|
||||
|
||||
assert(future1.get === "10-14")
|
||||
|
|
@ -162,14 +148,14 @@ class FutureSpec extends JUnitSuite {
|
|||
|
||||
val actor = actorOf[TestActor].start()
|
||||
|
||||
val future8 = actor !!! "Failure"
|
||||
val future9 = actor !!! "Failure" recover {
|
||||
val future8 = actor ? "Failure"
|
||||
val future9 = actor ? "Failure" recover {
|
||||
case e: RuntimeException ⇒ "FAIL!"
|
||||
}
|
||||
val future10 = actor !!! "Hello" recover {
|
||||
val future10 = actor ? "Hello" recover {
|
||||
case e: RuntimeException ⇒ "FAIL!"
|
||||
}
|
||||
val future11 = actor !!! "Failure" recover { case _ ⇒ "Oops!" }
|
||||
val future11 = actor ? "Failure" recover { case _ ⇒ "Oops!" }
|
||||
|
||||
assert(future1.get === 5)
|
||||
intercept[ArithmeticException] { future2.get }
|
||||
|
|
@ -194,7 +180,7 @@ class FutureSpec extends JUnitSuite {
|
|||
}).start()
|
||||
}
|
||||
val timeout = 10000
|
||||
def futures = actors.zipWithIndex map { case (actor: ActorRef, idx: Int) ⇒ actor.!!, timeout) }
|
||||
def futures = actors.zipWithIndex map { case (actor: ActorRef, idx: Int) ⇒ actor.?((idx, idx * 200), timeout).mapTo[Int] }
|
||||
assert(Futures.fold(0, timeout)(futures)(_ + _).await.result.get === 45)
|
||||
}
|
||||
|
||||
|
|
@ -205,7 +191,7 @@ class FutureSpec extends JUnitSuite {
|
|||
def receive = { case (add: Int, wait: Int) ⇒ Thread.sleep(wait); self reply_? add }
|
||||
}).start()
|
||||
}
|
||||
def futures = actors.zipWithIndex map { case (actor: ActorRef, idx: Int) ⇒ actor.!!, 10000) }
|
||||
def futures = actors.zipWithIndex map { case (actor: ActorRef, idx: Int) ⇒ actor.?((idx, idx * 200), 10000).mapTo[Int] }
|
||||
assert(futures.foldLeft(Future(0))((fr, fa) ⇒ for (r ← fr; a ← fa) yield (r + a)).get === 45)
|
||||
}
|
||||
|
||||
|
|
@ -222,7 +208,7 @@ class FutureSpec extends JUnitSuite {
|
|||
}).start()
|
||||
}
|
||||
val timeout = 10000
|
||||
def futures = actors.zipWithIndex map { case (actor: ActorRef, idx: Int) ⇒ actor.!!, timeout) }
|
||||
def futures = actors.zipWithIndex map { case (actor: ActorRef, idx: Int) ⇒ actor.?((idx, idx * 100), timeout).mapTo[Int] }
|
||||
assert(Futures.fold(0, timeout)(futures)(_ + _).await.exception.get.getMessage === "shouldFoldResultsWithException: expected")
|
||||
}
|
||||
|
||||
|
|
@ -239,7 +225,7 @@ class FutureSpec extends JUnitSuite {
|
|||
}).start()
|
||||
}
|
||||
val timeout = 10000
|
||||
def futures = actors.zipWithIndex map { case (actor: ActorRef, idx: Int) ⇒ actor.!!, timeout) }
|
||||
def futures = actors.zipWithIndex map { case (actor: ActorRef, idx: Int) ⇒ actor.?((idx, idx * 200), timeout).mapTo[Int] }
|
||||
assert(Futures.reduce(futures, timeout)(_ + _).get === 45)
|
||||
}
|
||||
|
||||
|
|
@ -256,7 +242,7 @@ class FutureSpec extends JUnitSuite {
|
|||
}).start()
|
||||
}
|
||||
val timeout = 10000
|
||||
def futures = actors.zipWithIndex map { case (actor: ActorRef, idx: Int) ⇒ actor.!!, timeout) }
|
||||
def futures = actors.zipWithIndex map { case (actor: ActorRef, idx: Int) ⇒ actor.?((idx, idx * 100), timeout).mapTo[Int] }
|
||||
assert(Futures.reduce(futures, timeout)(_ + _).await.exception.get.getMessage === "shouldFoldResultsWithException: expected")
|
||||
}
|
||||
|
||||
|
|
@ -269,7 +255,7 @@ class FutureSpec extends JUnitSuite {
|
|||
def receiveShouldExecuteOnComplete {
|
||||
val latch = new StandardLatch
|
||||
val actor = actorOf[TestActor].start()
|
||||
actor !!! "Hello" onResult { case "World" ⇒ latch.open }
|
||||
actor ? "Hello" onResult { case "World" ⇒ latch.open }
|
||||
assert(latch.tryAwait(5, TimeUnit.SECONDS))
|
||||
actor.stop()
|
||||
}
|
||||
|
|
@ -285,7 +271,7 @@ class FutureSpec extends JUnitSuite {
|
|||
}
|
||||
}).start()
|
||||
|
||||
val oddFutures: List[Future[Int]] = List.fill(100)(oddActor !!! 'GetNext)
|
||||
val oddFutures = List.fill(100)(oddActor ? 'GetNext mapTo manifest[Int])
|
||||
assert(Future.sequence(oddFutures).get.sum === 10000)
|
||||
oddActor.stop()
|
||||
|
||||
|
|
@ -342,9 +328,9 @@ class FutureSpec extends JUnitSuite {
|
|||
val actor = actorOf[TestActor].start
|
||||
|
||||
val x = Future("Hello")
|
||||
val y = x flatMap (actor !!! _)
|
||||
val y = x flatMap (actor ? _) mapTo manifest[String]
|
||||
|
||||
val r = flow(x() + " " + y[String]() + "!")
|
||||
val r = flow(x() + " " + y() + "!")
|
||||
|
||||
assert(r.get === "Hello World!")
|
||||
|
||||
|
|
@ -370,9 +356,9 @@ class FutureSpec extends JUnitSuite {
|
|||
val actor = actorOf[TestActor].start
|
||||
|
||||
val x = Future(3)
|
||||
val y = actor !!! "Hello"
|
||||
val y = (actor ? "Hello").mapTo[Int]
|
||||
|
||||
val r = flow(x() + y[Int](), 100)
|
||||
val r = flow(x() + y(), 100)
|
||||
|
||||
intercept[ClassCastException](r.get)
|
||||
}
|
||||
|
|
@ -384,7 +370,7 @@ class FutureSpec extends JUnitSuite {
|
|||
val actor = actorOf[TestActor].start
|
||||
|
||||
val x = Future("Hello")
|
||||
val y = actor !!! "Hello"
|
||||
val y = actor ? "Hello" mapTo manifest[Nothing]
|
||||
|
||||
val r = flow(x() + y())
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ import org.scalatest.matchers.MustMatchers
|
|||
import org.scalatest.{ BeforeAndAfterAll, BeforeAndAfterEach }
|
||||
import org.scalatest.junit.JUnitRunner
|
||||
import org.junit.runner.RunWith
|
||||
import akka.actor.{ Actor, ActorRegistry }
|
||||
import akka.actor.{ Actor, ActorRegistry, NullChannel }
|
||||
import akka.actor.Actor.{ actorOf }
|
||||
import java.util.concurrent.{ TimeUnit, CountDownLatch, BlockingQueue }
|
||||
import java.util.{ Queue }
|
||||
|
|
@ -84,7 +84,7 @@ abstract class MailboxSpec extends WordSpec with MustMatchers with BeforeAndAfte
|
|||
new MessageInvocation(
|
||||
actorOf(new Actor { //Dummy actor
|
||||
def receive = { case _ ⇒ }
|
||||
}), msg, None, None)
|
||||
}), msg, NullChannel)
|
||||
}
|
||||
|
||||
def ensureInitialMailboxState(config: MailboxType, q: MessageQueue) {
|
||||
|
|
@ -158,4 +158,4 @@ class PriorityMailboxSpec extends MailboxSpec {
|
|||
case UnboundedMailbox() ⇒ new UnboundedPriorityMessageQueue(comparator)
|
||||
case BoundedMailbox(capacity, pushTimeOut) ⇒ new BoundedPriorityMessageQueue(capacity, pushTimeOut, comparator)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ import akka.dispatch.Dispatchers
|
|||
import akka.actor.Actor
|
||||
import Actor._
|
||||
|
||||
object ThreadBasedActorSpec {
|
||||
object PinnedActorSpec {
|
||||
class TestActor extends Actor {
|
||||
self.dispatcher = Dispatchers.newPinnedDispatcher(self)
|
||||
|
||||
|
|
@ -21,8 +21,8 @@ object ThreadBasedActorSpec {
|
|||
}
|
||||
}
|
||||
|
||||
class ThreadBasedActorSpec extends JUnitSuite {
|
||||
import ThreadBasedActorSpec._
|
||||
class PinnedActorSpec extends JUnitSuite {
|
||||
import PinnedActorSpec._
|
||||
|
||||
private val unit = TimeUnit.MILLISECONDS
|
||||
|
||||
|
|
@ -43,7 +43,7 @@ class ThreadBasedActorSpec extends JUnitSuite {
|
|||
@Test
|
||||
def shouldSendReplySync = {
|
||||
val actor = actorOf[TestActor].start()
|
||||
val result = (actor !! ("Hello", 10000)).as[String]
|
||||
val result = (actor.?("Hello", 10000)).as[String]
|
||||
assert("World" === result.get)
|
||||
actor.stop()
|
||||
}
|
||||
|
|
@ -51,8 +51,8 @@ class ThreadBasedActorSpec extends JUnitSuite {
|
|||
@Test
|
||||
def shouldSendReplyAsync = {
|
||||
val actor = actorOf[TestActor].start()
|
||||
val result = actor !! "Hello"
|
||||
assert("World" === result.get.asInstanceOf[String])
|
||||
val result = (actor ? "Hello").as[String]
|
||||
assert("World" === result.get)
|
||||
actor.stop()
|
||||
}
|
||||
|
||||
|
|
@ -60,7 +60,7 @@ class ThreadBasedActorSpec extends JUnitSuite {
|
|||
def shouldSendReceiveException = {
|
||||
val actor = actorOf[TestActor].start()
|
||||
try {
|
||||
actor !! "Failure"
|
||||
(actor ? "Failure").get
|
||||
fail("Should have thrown an exception")
|
||||
} catch {
|
||||
case e ⇒
|
||||
|
|
@ -44,7 +44,7 @@ class PriorityDispatcherSpec extends WordSpec with MustMatchers {
|
|||
|
||||
dispatcher.resume(actor) //Signal the actor to start treating it's message backlog
|
||||
|
||||
actor.!!![List[Int]]('Result).await.result.get must be === (msgs.reverse)
|
||||
actor.?('Result).as[List[Int]].get must be === (msgs.reverse)
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -89,7 +89,7 @@ class ActorRegistrySpec extends JUnitSuite {
|
|||
val actor2 = actorOf[TestActor]("test-actor-2").start
|
||||
val results = new ConcurrentLinkedQueue[Future[String]]
|
||||
|
||||
Actor.registry.local.foreach(actor ⇒ results.add(actor.!!![String]("ping")))
|
||||
Actor.registry.local.foreach(actor ⇒ results.add(actor.?("ping").mapTo[String]))
|
||||
|
||||
assert(results.size === 2)
|
||||
val i = results.iterator
|
||||
|
|
|
|||
|
|
@ -7,12 +7,12 @@ import akka.testing._
|
|||
import akka.testing.Testing.{ sleepFor, testMillis }
|
||||
import akka.util.duration._
|
||||
|
||||
import akka.actor._
|
||||
import akka.actor.Actor._
|
||||
import akka.routing._
|
||||
|
||||
import java.util.concurrent.atomic.AtomicInteger
|
||||
import akka.dispatch.{ KeptPromise, Future }
|
||||
import akka.actor.{ TypedActor, Actor }
|
||||
|
||||
object RoutingSpec {
|
||||
trait Foo {
|
||||
|
|
@ -55,10 +55,11 @@ class RoutingSpec extends WordSpec with MustMatchers {
|
|||
case Test3 ⇒ t2
|
||||
}.start()
|
||||
|
||||
implicit val timeout = Actor.Timeout(testMillis(5 seconds))
|
||||
val result = for {
|
||||
a ← (d !! (Test1, testMillis(5 seconds))).as[Int]
|
||||
b ← (d !! (Test2, testMillis(5 seconds))).as[Int]
|
||||
c ← (d !! (Test3, testMillis(5 seconds))).as[Int]
|
||||
a ← (d ? (Test1)).as[Int]
|
||||
b ← (d ? (Test2)).as[Int]
|
||||
c ← (d ? (Test3)).as[Int]
|
||||
} yield a + b + c
|
||||
|
||||
result.isDefined must be(true)
|
||||
|
|
@ -193,11 +194,11 @@ class RoutingSpec extends WordSpec with MustMatchers {
|
|||
}).start()
|
||||
|
||||
val successes = TestLatch(2)
|
||||
val successCounter = Some(actorOf(new Actor {
|
||||
val successCounter = actorOf(new Actor {
|
||||
def receive = {
|
||||
case "success" ⇒ successes.countDown()
|
||||
}
|
||||
}).start())
|
||||
}).start()
|
||||
|
||||
implicit val replyTo = successCounter
|
||||
pool ! "a"
|
||||
|
|
@ -208,7 +209,7 @@ class RoutingSpec extends WordSpec with MustMatchers {
|
|||
|
||||
count.get must be(2)
|
||||
|
||||
(pool !! ActorPool.Stat).asInstanceOf[Option[ActorPool.Stats]].get.size must be(2)
|
||||
(pool ? ActorPool.Stat).as[ActorPool.Stats].get.size must be(2)
|
||||
|
||||
pool.stop()
|
||||
}
|
||||
|
|
@ -237,7 +238,7 @@ class RoutingSpec extends WordSpec with MustMatchers {
|
|||
}).start()
|
||||
|
||||
try {
|
||||
(for (count ← 1 to 500) yield pool.!!![String]("Test", 20000)) foreach {
|
||||
(for (count ← 1 to 500) yield pool.?("Test", 20000)) foreach {
|
||||
_.await.resultOrException.get must be("Response")
|
||||
}
|
||||
} finally {
|
||||
|
|
@ -276,14 +277,14 @@ class RoutingSpec extends WordSpec with MustMatchers {
|
|||
|
||||
pool ! 1
|
||||
|
||||
(pool !! ActorPool.Stat).asInstanceOf[Option[ActorPool.Stats]].get.size must be(2)
|
||||
(pool ? ActorPool.Stat).as[ActorPool.Stats].get.size must be(2)
|
||||
|
||||
var loops = 0
|
||||
def loop(t: Int) = {
|
||||
latch = TestLatch(loops)
|
||||
count.set(0)
|
||||
for (m ← 0 until loops) {
|
||||
pool !!! t
|
||||
pool ? t
|
||||
sleepFor(50 millis)
|
||||
}
|
||||
}
|
||||
|
|
@ -296,7 +297,7 @@ class RoutingSpec extends WordSpec with MustMatchers {
|
|||
latch.await
|
||||
count.get must be(loops)
|
||||
|
||||
(pool !! ActorPool.Stat).asInstanceOf[Option[ActorPool.Stats]].get.size must be(2)
|
||||
(pool ? ActorPool.Stat).as[ActorPool.Stats].get.size must be(2)
|
||||
|
||||
// a whole bunch should max it out
|
||||
|
||||
|
|
@ -305,7 +306,7 @@ class RoutingSpec extends WordSpec with MustMatchers {
|
|||
latch.await
|
||||
count.get must be(loops)
|
||||
|
||||
(pool !! ActorPool.Stat).asInstanceOf[Option[ActorPool.Stats]].get.size must be(4)
|
||||
(pool ? ActorPool.Stat).as[ActorPool.Stats].get.size must be(4)
|
||||
|
||||
pool.stop()
|
||||
}
|
||||
|
|
@ -353,7 +354,7 @@ class RoutingSpec extends WordSpec with MustMatchers {
|
|||
latch.await
|
||||
count.get must be(loops)
|
||||
|
||||
(pool !! ActorPool.Stat).asInstanceOf[Option[ActorPool.Stats]].get.size must be(2)
|
||||
(pool ? ActorPool.Stat).as[ActorPool.Stats].get.size must be(2)
|
||||
|
||||
// send a bunch over the theshold and observe an increment
|
||||
loops = 15
|
||||
|
|
@ -362,7 +363,7 @@ class RoutingSpec extends WordSpec with MustMatchers {
|
|||
latch.await(10 seconds)
|
||||
count.get must be(loops)
|
||||
|
||||
(pool !! ActorPool.Stat).asInstanceOf[Option[ActorPool.Stats]].get.size must be >= (3)
|
||||
(pool ? ActorPool.Stat).as[ActorPool.Stats].get.size must be >= (3)
|
||||
|
||||
pool.stop()
|
||||
}
|
||||
|
|
@ -458,7 +459,7 @@ class RoutingSpec extends WordSpec with MustMatchers {
|
|||
|
||||
sleepFor(5 millis)
|
||||
|
||||
val z = (pool !! ActorPool.Stat).asInstanceOf[Option[ActorPool.Stats]].get.size
|
||||
val z = (pool ? ActorPool.Stat).as[ActorPool.Stats].get.size
|
||||
|
||||
z must be >= (2)
|
||||
|
||||
|
|
@ -469,7 +470,7 @@ class RoutingSpec extends WordSpec with MustMatchers {
|
|||
sleepFor(500 millis)
|
||||
}
|
||||
|
||||
(pool !! ActorPool.Stat).asInstanceOf[Option[ActorPool.Stats]].get.size must be <= (z)
|
||||
(pool ? ActorPool.Stat).as[ActorPool.Stats].get.size must be <= (z)
|
||||
|
||||
pool.stop()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ import org.scalatest.matchers.MustMatchers
|
|||
|
||||
class Ticket703Spec extends WordSpec with MustMatchers {
|
||||
|
||||
"A !!! call to an actor pool" should {
|
||||
"A ? call to an actor pool" should {
|
||||
"reuse the proper timeout" in {
|
||||
val actorPool = actorOf(
|
||||
new Actor with DefaultActorPool with BoundedCapacityStrategy with MailboxPressureCapacitor with SmallestMailboxSelector with BasicNoBackoffFilter {
|
||||
|
|
@ -28,7 +28,7 @@ class Ticket703Spec extends WordSpec with MustMatchers {
|
|||
}
|
||||
})
|
||||
}).start()
|
||||
(actorPool.!!![String]("Ping", 7000)).await.result must be === Some("Response")
|
||||
(actorPool.?("Ping", 7000)).await.result must be === Some("Response")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,7 +10,6 @@ import akka.config._
|
|||
import Config._
|
||||
import akka.util.{ ListenerManagement, ReflectiveAccess, Duration, Helpers }
|
||||
import ReflectiveAccess._
|
||||
import Helpers.{ narrow, narrowSilently }
|
||||
import akka.remoteinterface.RemoteSupport
|
||||
import akka.japi.{ Creator, Procedure }
|
||||
import akka.AkkaException
|
||||
|
|
@ -24,6 +23,7 @@ import scala.reflect.BeanProperty
|
|||
import com.eaio.uuid.UUID
|
||||
|
||||
import java.lang.reflect.InvocationTargetException
|
||||
import java.util.concurrent.TimeUnit
|
||||
|
||||
/**
|
||||
* Life-cycle messages for the Actors
|
||||
|
|
@ -89,8 +89,11 @@ class InvalidMessageException private[akka] (message: String, cause: Throwable =
|
|||
/**
|
||||
* This message is thrown by default when an Actors behavior doesn't match a message
|
||||
*/
|
||||
case class UnhandledMessageException(msg: Any, ref: ActorRef) extends Exception {
|
||||
override def getMessage = "Actor %s does not handle [%s]".format(ref, msg)
|
||||
case class UnhandledMessageException(msg: Any, ref: ActorRef = null) extends Exception {
|
||||
// constructor with 'null' ActorRef needed to work with client instantiation of remote exception
|
||||
override def getMessage =
|
||||
if (ref ne null) "Actor %s does not handle [%s]".format(ref, msg)
|
||||
else "Actor does not handle [%s]".format(msg)
|
||||
override def fillInStackTrace() = this //Don't waste cycles generating stack trace
|
||||
}
|
||||
|
||||
|
|
@ -110,9 +113,6 @@ object Status {
|
|||
*/
|
||||
object Actor extends ListenerManagement {
|
||||
|
||||
private[akka] val TIMEOUT = Duration(config.getInt("akka.actor.timeout", 5), TIME_UNIT).toMillis
|
||||
private[akka] val SERIALIZE_MESSAGES = config.getBool("akka.actor.serialize-messages", false)
|
||||
|
||||
/**
|
||||
* A Receive is a convenience type that defines actor message behavior currently modeled as
|
||||
* a PartialFunction[Any, Unit].
|
||||
|
|
@ -140,6 +140,22 @@ object Actor extends ListenerManagement {
|
|||
override def initialValue = Stack[ActorRef]()
|
||||
}
|
||||
|
||||
case class Timeout(duration: Duration) {
|
||||
def this(timeout: Long) = this(Duration(timeout, TimeUnit.MILLISECONDS))
|
||||
def this(length: Long, unit: TimeUnit) = this(Duration(length, unit))
|
||||
}
|
||||
object Timeout {
|
||||
def apply(timeout: Long) = new Timeout(timeout)
|
||||
def apply(length: Long, unit: TimeUnit) = new Timeout(length, unit)
|
||||
implicit def durationToTimeout(duration: Duration) = new Timeout(duration)
|
||||
implicit def intToTimeout(timeout: Int) = new Timeout(timeout)
|
||||
implicit def longToTimeout(timeout: Long) = new Timeout(timeout)
|
||||
}
|
||||
|
||||
private[akka] val TIMEOUT = Duration(config.getInt("akka.actor.timeout", 5), TIME_UNIT).toMillis
|
||||
val defaultTimeout = Timeout(TIMEOUT)
|
||||
private[akka] val SERIALIZE_MESSAGES = config.getBool("akka.actor.serialize-messages", false)
|
||||
|
||||
/**
|
||||
* Handle to the ActorRegistry.
|
||||
*/
|
||||
|
|
@ -321,25 +337,6 @@ object Actor extends ListenerManagement {
|
|||
}).start() ! Spawn
|
||||
}
|
||||
|
||||
/**
|
||||
* Implicitly converts the given Option[Any] to a AnyOptionAsTypedOption which offers the method <code>as[T]</code>
|
||||
* to convert an Option[Any] to an Option[T].
|
||||
*/
|
||||
implicit def toAnyOptionAsTypedOption(anyOption: Option[Any]) = new AnyOptionAsTypedOption(anyOption)
|
||||
|
||||
/**
|
||||
* Implicitly converts the given Future[_] to a AnyOptionAsTypedOption which offers the method <code>as[T]</code>
|
||||
* to convert an Option[Any] to an Option[T].
|
||||
* This means that the following code is equivalent:
|
||||
* (actor !! "foo").as[Int] (Deprecated)
|
||||
* and
|
||||
* (actor !!! "foo").as[Int] (Recommended)
|
||||
*/
|
||||
implicit def futureToAnyOptionAsTypedOption(anyFuture: Future[_]) = new AnyOptionAsTypedOption({
|
||||
try { anyFuture.await } catch { case t: FutureTimeoutException ⇒ }
|
||||
anyFuture.resultOrException
|
||||
})
|
||||
|
||||
private[akka] def createActor(address: String, actorFactory: () ⇒ ActorRef): ActorRef = {
|
||||
Address.validate(address)
|
||||
registry.actorFor(address) match { // check if the actor for the address is already in the registry
|
||||
|
|
@ -474,7 +471,7 @@ object Actor extends ListenerManagement {
|
|||
*
|
||||
* <p/>
|
||||
* Here you find functions like:
|
||||
* - !, !!, !!! and forward
|
||||
* - !, ? and forward
|
||||
* - link, unlink, startLink etc
|
||||
* - start, stop
|
||||
* - etc.
|
||||
|
|
@ -511,14 +508,14 @@ trait Actor {
|
|||
*/
|
||||
type Receive = Actor.Receive
|
||||
|
||||
/*
|
||||
/**
|
||||
* Some[ActorRef] representation of the 'self' ActorRef reference.
|
||||
* <p/>
|
||||
* Mainly for internal use, functions as the implicit sender references when invoking
|
||||
* the 'forward' function.
|
||||
*/
|
||||
@transient
|
||||
implicit val someSelf: Some[ActorRef] = {
|
||||
val someSelf: Some[ActorRef] = {
|
||||
val refStack = Actor.actorRefInCreation.get
|
||||
if (refStack.isEmpty) throw new ActorInitializationException(
|
||||
"\n\tYou can not create an instance of an " + getClass.getName + " explicitly using 'new MyActor'." +
|
||||
|
|
@ -542,9 +539,9 @@ trait Actor {
|
|||
* Option[ActorRef] representation of the 'self' ActorRef reference.
|
||||
* <p/>
|
||||
* Mainly for internal use, functions as the implicit sender references when invoking
|
||||
* one of the message send functions ('!', '!!' and '!!!').
|
||||
* one of the message send functions ('!' and '?').
|
||||
*/
|
||||
implicit def optionSelf: Option[ActorRef] = someSelf
|
||||
def optionSelf: Option[ActorRef] = someSelf
|
||||
|
||||
/**
|
||||
* The 'self' field holds the ActorRef for this actor.
|
||||
|
|
@ -574,7 +571,7 @@ trait Actor {
|
|||
* </pre>
|
||||
*/
|
||||
@transient
|
||||
val self: ScalaActorRef = someSelf.get
|
||||
implicit val self: ScalaActorRef = someSelf.get
|
||||
|
||||
/**
|
||||
* User overridable callback/setting.
|
||||
|
|
@ -661,8 +658,7 @@ trait Actor {
|
|||
|
||||
private[akka] final def apply(msg: Any) = {
|
||||
if (msg.isInstanceOf[AnyRef] && (msg.asInstanceOf[AnyRef] eq null))
|
||||
throw new InvalidMessageException("Message from [" + self.sender + "] to [" + self.toString + "] is null")
|
||||
|
||||
throw new InvalidMessageException("Message from [" + self.channel + "] to [" + self.toString + "] is null")
|
||||
val behaviorStack = self.hotswap
|
||||
|
||||
msg match {
|
||||
|
|
@ -684,26 +680,11 @@ trait Actor {
|
|||
case Restart(reason) ⇒ throw reason
|
||||
case Kill ⇒ throw new ActorKilledException("Kill")
|
||||
case PoisonPill ⇒
|
||||
val f = self.senderFuture()
|
||||
val ch = self.channel
|
||||
self.stop()
|
||||
if (f.isDefined) f.get.completeWithException(new ActorKilledException("PoisonPill"))
|
||||
ch.sendException(new ActorKilledException("PoisonPill"))
|
||||
}
|
||||
}
|
||||
|
||||
private lazy val processingBehavior = receive //ProcessingBehavior is the original behavior
|
||||
}
|
||||
|
||||
private[actor] class AnyOptionAsTypedOption(anyOption: Option[Any]) {
|
||||
|
||||
/**
|
||||
* Convenience helper to cast the given Option of Any to an Option of the given type. Will throw a ClassCastException
|
||||
* if the actual type is not assignable from the given one.
|
||||
*/
|
||||
def as[T]: Option[T] = narrow[T](anyOption)
|
||||
|
||||
/**
|
||||
* Convenience helper to cast the given Option of Any to an Option of the given type. Will swallow a possible
|
||||
* ClassCastException and return None in that case.
|
||||
*/
|
||||
def asSilently[T: Manifest]: Option[T] = narrowSilently[T](anyOption)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -36,27 +36,6 @@ private[akka] object ActorRefInternals {
|
|||
object SHUTDOWN extends StatusType
|
||||
}
|
||||
|
||||
/**
|
||||
* Abstraction for unification of sender and senderFuture for later reply.
|
||||
* Can be stored away and used at a later point in time.
|
||||
*/
|
||||
abstract class Channel[T] {
|
||||
|
||||
/**
|
||||
* Scala API. <p/>
|
||||
* Sends the specified message to the channel.
|
||||
*/
|
||||
def !(msg: T)
|
||||
|
||||
/**
|
||||
* Java API. <p/>
|
||||
* Sends the specified message to the channel.
|
||||
*/
|
||||
def sendOneWay(msg: T) {
|
||||
this.!(msg)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* ActorRef is an immutable and serializable handle to an Actor.
|
||||
* <p/>
|
||||
|
|
@ -89,7 +68,7 @@ abstract class Channel[T] {
|
|||
*
|
||||
* @author <a href="http://jonasboner.com">Jonas Bonér</a>
|
||||
*/
|
||||
trait ActorRef extends ActorRefShared with java.lang.Comparable[ActorRef] with Serializable { scalaRef: ScalaActorRef ⇒
|
||||
trait ActorRef extends ActorRefShared with ForwardableChannel with java.lang.Comparable[ActorRef] with Serializable { scalaRef: ScalaActorRef ⇒
|
||||
// Only mutable for RemoteServer in order to maintain identity across nodes
|
||||
@volatile
|
||||
protected[akka] var _uuid = newUuid
|
||||
|
|
@ -101,8 +80,8 @@ trait ActorRef extends ActorRefShared with java.lang.Comparable[ActorRef] with S
|
|||
/**
|
||||
* User overridable callback/setting.
|
||||
* <p/>
|
||||
* Defines the default timeout for '!!' and '!!!' invocations,
|
||||
* e.g. the timeout for the future returned by the call to '!!' and '!!!'.
|
||||
* Defines the default timeout for '?'/'ask' invocations,
|
||||
* e.g. the timeout for the future returned by the call to '?'/'ask'.
|
||||
*/
|
||||
@deprecated("Will be replaced by implicit-scoped timeout on all methods that needs it, will default to timeout specified in config", "1.1")
|
||||
@BeanProperty
|
||||
|
|
@ -210,7 +189,7 @@ trait ActorRef extends ActorRefShared with java.lang.Comparable[ActorRef] with S
|
|||
/**
|
||||
* Akka Java API. <p/>
|
||||
* The reference sender future of the last received message.
|
||||
* Is defined if the message was sent with sent with '!!' or '!!!', else None.
|
||||
* Is defined if the message was sent with sent with '?'/'ask', else None.
|
||||
*/
|
||||
def getSenderFuture: Option[Promise[Any]] = senderFuture
|
||||
|
||||
|
|
@ -246,82 +225,17 @@ trait ActorRef extends ActorRefShared with java.lang.Comparable[ActorRef] with S
|
|||
|
||||
/**
|
||||
* Akka Java API. <p/>
|
||||
* Sends a one-way asynchronous message. E.g. fire-and-forget semantics.
|
||||
* <p/>
|
||||
* <pre>
|
||||
* actor.sendOneWay(message);
|
||||
* </pre>
|
||||
* <p/>
|
||||
*/
|
||||
def sendOneWay(message: AnyRef): Unit = {
|
||||
sendOneWay(message, null)
|
||||
}
|
||||
|
||||
/**
|
||||
* Akka Java API. <p/>
|
||||
* Sends a one-way asynchronous message. E.g. fire-and-forget semantics.
|
||||
* <p/>
|
||||
* Allows you to pass along the sender of the message.
|
||||
* <p/>
|
||||
* <pre>
|
||||
* actor.sendOneWay(message, context);
|
||||
* </pre>
|
||||
* <p/>
|
||||
*/
|
||||
def sendOneWay(message: AnyRef, sender: ActorRef) {
|
||||
this.!(message)(Option(sender))
|
||||
}
|
||||
|
||||
/**
|
||||
* Akka Java API. <p/>
|
||||
* @see sendRequestReply(message: AnyRef, timeout: Long, sender: ActorRef)
|
||||
* Uses the default timeout of the Actor (setTimeout()) and omits the sender reference
|
||||
*/
|
||||
def sendRequestReply(message: AnyRef): AnyRef = sendRequestReply(message, timeout, null)
|
||||
|
||||
/**
|
||||
* Akka Java API. <p/>
|
||||
* @see sendRequestReply(message: AnyRef, timeout: Long, sender: ActorRef)
|
||||
* Uses the default timeout of the Actor (setTimeout())
|
||||
*/
|
||||
def sendRequestReply(message: AnyRef, sender: ActorRef): AnyRef = sendRequestReply(message, timeout, sender)
|
||||
|
||||
/**
|
||||
* Akka Java API. <p/>
|
||||
* Sends a message asynchronously and waits on a future for a reply message under the hood.
|
||||
* <p/>
|
||||
* It waits on the reply either until it receives it or until the timeout expires
|
||||
* (which will throw an ActorTimeoutException). E.g. send-and-receive-eventually semantics.
|
||||
* <p/>
|
||||
* <b>NOTE:</b>
|
||||
* Use this method with care. In most cases it is better to use 'sendOneWay' together with 'getContext().getSender()' to
|
||||
* implement request/response message exchanges.
|
||||
* <p/>
|
||||
* If you are sending messages using <code>sendRequestReply</code> then you <b>have to</b> use <code>getContext().reply(..)</code>
|
||||
* to send a reply message to the original sender. If not then the sender will block until the timeout expires.
|
||||
*/
|
||||
def sendRequestReply(message: AnyRef, timeout: Long, sender: ActorRef): AnyRef = {
|
||||
!!(message, timeout)(Option(sender)).getOrElse(throw new ActorTimeoutException(
|
||||
"Message [" + message +
|
||||
"]\n\tfrom [" + (if (sender ne null) sender.address else "nowhere") +
|
||||
"]\n\twith timeout [" + timeout +
|
||||
"]\n\ttimed out."))
|
||||
.asInstanceOf[AnyRef]
|
||||
}
|
||||
|
||||
/**
|
||||
* Akka Java API. <p/>
|
||||
* @see sendRequestReplyFuture(message: AnyRef, sender: ActorRef): Future[_]
|
||||
* @see ask(message: AnyRef, sender: ActorRef): Future[_]
|
||||
* Uses the Actors default timeout (setTimeout()) and omits the sender
|
||||
*/
|
||||
def sendRequestReplyFuture[T <: AnyRef](message: AnyRef): Future[T] = sendRequestReplyFuture(message, timeout, null).asInstanceOf[Future[T]]
|
||||
def ask(message: AnyRef): Future[AnyRef] = ask(message, timeout, null)
|
||||
|
||||
/**
|
||||
* Akka Java API. <p/>
|
||||
* @see sendRequestReplyFuture(message: AnyRef, sender: ActorRef): Future[_]
|
||||
* @see ask(message: AnyRef, sender: ActorRef): Future[_]
|
||||
* Uses the Actors default timeout (setTimeout())
|
||||
*/
|
||||
def sendRequestReplyFuture[T <: AnyRef](message: AnyRef, sender: ActorRef): Future[T] = sendRequestReplyFuture(message, timeout, sender).asInstanceOf[Future[T]]
|
||||
def ask(message: AnyRef, sender: ActorRef): Future[AnyRef] = ask(message, timeout, sender)
|
||||
|
||||
/**
|
||||
* Akka Java API. <p/>
|
||||
|
|
@ -331,10 +245,11 @@ trait ActorRef extends ActorRefShared with java.lang.Comparable[ActorRef] with S
|
|||
* Use this method with care. In most cases it is better to use 'sendOneWay' together with the 'getContext().getSender()' to
|
||||
* implement request/response message exchanges.
|
||||
* <p/>
|
||||
* If you are sending messages using <code>sendRequestReplyFuture</code> then you <b>have to</b> use <code>getContext().reply(..)</code>
|
||||
* If you are sending messages using <code>ask</code> then you <b>have to</b> use <code>getContext().reply(..)</code>
|
||||
* to send a reply message to the original sender. If not then the sender will block until the timeout expires.
|
||||
*/
|
||||
def sendRequestReplyFuture[T <: AnyRef](message: AnyRef, timeout: Long, sender: ActorRef): Future[T] = !!!(message, timeout)(Option(sender)).asInstanceOf[Future[T]]
|
||||
def ask(message: AnyRef, timeout: Long, sender: ActorRef): Future[AnyRef] =
|
||||
?(message, Actor.Timeout(timeout))(sender).asInstanceOf[Future[AnyRef]]
|
||||
|
||||
/**
|
||||
* Akka Java API. <p/>
|
||||
|
|
@ -342,7 +257,7 @@ trait ActorRef extends ActorRefShared with java.lang.Comparable[ActorRef] with S
|
|||
*/
|
||||
def forward(message: AnyRef, sender: ActorRef) {
|
||||
if (sender eq null) throw new IllegalArgumentException("The 'sender' argument to 'forward' can't be null")
|
||||
else forward(message)(Some(sender))
|
||||
else forward(message)(sender)
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -440,36 +355,36 @@ trait ActorRef extends ActorRefShared with java.lang.Comparable[ActorRef] with S
|
|||
/**
|
||||
* Abstraction for unification of sender and senderFuture for later reply
|
||||
*/
|
||||
def channel: Channel[Any] = {
|
||||
if (senderFuture.isDefined) {
|
||||
new Channel[Any] {
|
||||
val future = senderFuture.get
|
||||
def !(msg: Any) = future completeWithResult msg
|
||||
}
|
||||
} else if (sender.isDefined) {
|
||||
val someSelf = Some(this)
|
||||
new Channel[Any] {
|
||||
val client = sender.get
|
||||
def !(msg: Any) = client.!(msg)(someSelf)
|
||||
}
|
||||
} else throw new IllegalActorStateException("No channel available")
|
||||
def channel: UntypedChannel = {
|
||||
val msg = currentMessage
|
||||
if (msg ne null) msg.channel
|
||||
else NullChannel
|
||||
}
|
||||
|
||||
/*
|
||||
* Implementation of ForwardableChannel
|
||||
*/
|
||||
|
||||
def sendException(ex: Throwable) {}
|
||||
def isUsableOnlyOnce = false
|
||||
def isUsable = true
|
||||
def isReplyable = true
|
||||
def canSendException = false
|
||||
|
||||
/**
|
||||
* Java API. <p/>
|
||||
* Abstraction for unification of sender and senderFuture for later reply
|
||||
*/
|
||||
def getChannel: Channel[Any] = channel
|
||||
def getChannel: UntypedChannel = channel
|
||||
|
||||
protected[akka] def invoke(messageHandle: MessageInvocation)
|
||||
|
||||
protected[akka] def postMessageToMailbox(message: Any, senderOption: Option[ActorRef])
|
||||
protected[akka] def postMessageToMailbox(message: Any, channel: UntypedChannel): Unit
|
||||
|
||||
protected[akka] def postMessageToMailboxAndCreateFutureResultWithTimeout[T](
|
||||
protected[akka] def postMessageToMailboxAndCreateFutureResultWithTimeout(
|
||||
message: Any,
|
||||
timeout: Long,
|
||||
senderOption: Option[ActorRef],
|
||||
senderFuture: Option[Promise[T]]): Promise[T]
|
||||
channel: UntypedChannel): Future[Any]
|
||||
|
||||
protected[akka] def actorInstance: AtomicReference[Actor]
|
||||
|
||||
|
|
@ -745,18 +660,19 @@ class LocalActorRef private[akka] (
|
|||
_supervisor = sup
|
||||
}
|
||||
|
||||
protected[akka] def postMessageToMailbox(message: Any, senderOption: Option[ActorRef]) {
|
||||
dispatcher dispatchMessage MessageInvocation(this, message, senderOption, None)
|
||||
}
|
||||
protected[akka] def postMessageToMailbox(message: Any, channel: UntypedChannel): Unit =
|
||||
dispatcher dispatchMessage new MessageInvocation(this, message, channel)
|
||||
|
||||
protected[akka] def postMessageToMailboxAndCreateFutureResultWithTimeout[T](
|
||||
protected[akka] def postMessageToMailboxAndCreateFutureResultWithTimeout(
|
||||
message: Any,
|
||||
timeout: Long,
|
||||
senderOption: Option[ActorRef],
|
||||
senderFuture: Option[Promise[T]]): Promise[T] = {
|
||||
val future = if (senderFuture.isDefined) senderFuture else Some(new DefaultPromise[T](timeout))
|
||||
dispatcher dispatchMessage MessageInvocation(this, message, senderOption, future.asInstanceOf[Some[Promise[Any]]])
|
||||
future.get
|
||||
channel: UntypedChannel): Future[Any] = {
|
||||
val future = channel match {
|
||||
case f: ActorPromise ⇒ f
|
||||
case _ ⇒ new ActorPromise(timeout)
|
||||
}
|
||||
dispatcher dispatchMessage new MessageInvocation(this, message, future)
|
||||
future
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -853,7 +769,8 @@ class LocalActorRef private[akka] (
|
|||
}
|
||||
|
||||
def tooManyRestarts() {
|
||||
notifySupervisorWithMessage(MaximumNumberOfRestartsWithinTimeRangeReached(this, maxNrOfRetries, withinTimeRange, reason))
|
||||
notifySupervisorWithMessage(
|
||||
MaximumNumberOfRestartsWithinTimeRangeReached(this, maxNrOfRetries, withinTimeRange, reason))
|
||||
stop()
|
||||
}
|
||||
|
||||
|
|
@ -946,7 +863,7 @@ class LocalActorRef private[akka] (
|
|||
//Prevent any further messages to be processed until the actor has been restarted
|
||||
dispatcher.suspend(this)
|
||||
|
||||
senderFuture.foreach(_.completeWithException(reason))
|
||||
channel.sendException(reason)
|
||||
|
||||
if (supervisor.isDefined) notifySupervisorWithMessage(Exit(this, reason))
|
||||
else {
|
||||
|
|
@ -1051,19 +968,28 @@ private[akka] case class RemoteActorRef private[akka] (
|
|||
|
||||
start()
|
||||
|
||||
def postMessageToMailbox(message: Any, senderOption: Option[ActorRef]) {
|
||||
Actor.remote.send[Any](message, senderOption, None, remoteAddress, timeout, true, this, loader)
|
||||
def postMessageToMailbox(message: Any, channel: UntypedChannel): Unit = {
|
||||
val chSender = channel match {
|
||||
case ref: ActorRef ⇒ Some(ref)
|
||||
case _ ⇒ None
|
||||
}
|
||||
Actor.remote.send[Any](message, chSender, None, remoteAddress, timeout, true, this, loader)
|
||||
}
|
||||
|
||||
def postMessageToMailboxAndCreateFutureResultWithTimeout[T](
|
||||
def postMessageToMailboxAndCreateFutureResultWithTimeout(
|
||||
message: Any,
|
||||
timeout: Long,
|
||||
senderOption: Option[ActorRef],
|
||||
senderFuture: Option[Promise[T]]): Promise[T] = {
|
||||
val future = Actor.remote.send[T](
|
||||
message, senderOption, senderFuture,
|
||||
remoteAddress, timeout, false, this, loader)
|
||||
if (future.isDefined) future.get
|
||||
channel: UntypedChannel): Future[Any] = {
|
||||
val chSender = channel match {
|
||||
case ref: ActorRef ⇒ Some(ref)
|
||||
case _ ⇒ None
|
||||
}
|
||||
val chFuture = channel match {
|
||||
case f: Promise[Any] ⇒ Some(f)
|
||||
case _ ⇒ None
|
||||
}
|
||||
val future = Actor.remote.send[Any](message, chSender, chFuture, remoteAddress, timeout, false, this, loader)
|
||||
if (future.isDefined) ActorPromise(future.get)
|
||||
else throw new IllegalActorStateException("Expected a future from remote call to actor " + toString)
|
||||
}
|
||||
|
||||
|
|
@ -1149,7 +1075,7 @@ trait ActorRefShared {
|
|||
* There are implicit conversions in ../actor/Implicits.scala
|
||||
* from ActorRef -> ScalaActorRef and back
|
||||
*/
|
||||
trait ScalaActorRef extends ActorRefShared { ref: ActorRef ⇒
|
||||
trait ScalaActorRef extends ActorRefShared with ForwardableChannel { ref: ActorRef ⇒
|
||||
|
||||
/**
|
||||
* Address for actor, must be a unique one.
|
||||
|
|
@ -1187,20 +1113,28 @@ trait ScalaActorRef extends ActorRefShared { ref: ActorRef ⇒
|
|||
* The reference sender Actor of the last received message.
|
||||
* Is defined if the message was sent from another Actor, else None.
|
||||
*/
|
||||
@deprecated("will be removed in 2.0, use channel instead", "1.2")
|
||||
def sender: Option[ActorRef] = {
|
||||
val msg = currentMessage
|
||||
if (msg eq null) None
|
||||
else msg.sender
|
||||
else msg.channel match {
|
||||
case ref: ActorRef ⇒ Some(ref)
|
||||
case _ ⇒ None
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The reference sender future of the last received message.
|
||||
* Is defined if the message was sent with sent with '!!' or '!!!', else None.
|
||||
* Is defined if the message was sent with sent with '?'/'ask', else None.
|
||||
*/
|
||||
@deprecated("will be removed in 2.0, use channel instead", "1.2")
|
||||
def senderFuture(): Option[Promise[Any]] = {
|
||||
val msg = currentMessage
|
||||
if (msg eq null) None
|
||||
else msg.senderFuture
|
||||
else msg.channel match {
|
||||
case f: ActorPromise ⇒ Some(f)
|
||||
case _ ⇒ None
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -1217,8 +1151,8 @@ trait ScalaActorRef extends ActorRefShared { ref: ActorRef ⇒
|
|||
* </pre>
|
||||
* <p/>
|
||||
*/
|
||||
def !(message: Any)(implicit sender: Option[ActorRef] = None) {
|
||||
if (isRunning) postMessageToMailbox(message, sender)
|
||||
def !(message: Any)(implicit channel: UntypedChannel = NullChannel): Unit = {
|
||||
if (isRunning) postMessageToMailbox(message, channel)
|
||||
else throw new ActorInitializationException(
|
||||
"Actor has not been started, you need to invoke 'actor.start()' before using it")
|
||||
}
|
||||
|
|
@ -1235,9 +1169,10 @@ trait ScalaActorRef extends ActorRefShared { ref: ActorRef ⇒
|
|||
* If you are sending messages using <code>!!</code> then you <b>have to</b> use <code>self.reply(..)</code>
|
||||
* to send a reply message to the original sender. If not then the sender will block until the timeout expires.
|
||||
*/
|
||||
def !!(message: Any, timeout: Long = this.timeout)(implicit sender: Option[ActorRef] = None): Option[Any] = {
|
||||
@deprecated("use `(actor ? msg).as[T]` instead", "1.2")
|
||||
def !!(message: Any, timeout: Long = this.timeout)(implicit channel: UntypedChannel = NullChannel): Option[Any] = {
|
||||
if (isRunning) {
|
||||
val future = postMessageToMailboxAndCreateFutureResultWithTimeout[Any](message, timeout, sender, None)
|
||||
val future = postMessageToMailboxAndCreateFutureResultWithTimeout(message, timeout, channel)
|
||||
|
||||
try { future.await.resultOrException } catch { case e: FutureTimeoutException ⇒ None }
|
||||
} else throw new ActorInitializationException(
|
||||
|
|
@ -1245,16 +1180,10 @@ trait ScalaActorRef extends ActorRefShared { ref: ActorRef ⇒
|
|||
}
|
||||
|
||||
/**
|
||||
* Sends a message asynchronously returns a future holding the eventual reply message.
|
||||
* <p/>
|
||||
* <b>NOTE:</b>
|
||||
* Use this method with care. In most cases it is better to use '!' together with the 'sender' member field to
|
||||
* implement request/response message exchanges.
|
||||
* If you are sending messages using <code>!!!</code> then you <b>have to</b> use <code>self.reply(..)</code>
|
||||
* to send a reply message to the original sender. If not then the sender will block until the timeout expires.
|
||||
* Sends a message asynchronously, returning a future which may eventually hold the reply.
|
||||
*/
|
||||
def !!(implicit sender: Option[ActorRef] = None): Future[T] = {
|
||||
if (isRunning) postMessageToMailboxAndCreateFutureResultWithTimeout[T](message, timeout, sender, None)
|
||||
def ?(message: Any, timeout: Actor.Timeout = Actor.defaultTimeout)(implicit channel: UntypedChannel = NullChannel): Future[Any] = {
|
||||
if (isRunning) postMessageToMailboxAndCreateFutureResultWithTimeout(message, timeout.duration.toMillis, channel)
|
||||
else throw new ActorInitializationException(
|
||||
"Actor has not been started, you need to invoke 'actor.start()' before using it")
|
||||
}
|
||||
|
|
@ -1262,15 +1191,13 @@ trait ScalaActorRef extends ActorRefShared { ref: ActorRef ⇒
|
|||
/**
|
||||
* Forwards the message and passes the original sender actor as the sender.
|
||||
* <p/>
|
||||
* Works with '!', '!!' and '!!!'.
|
||||
* Works with '!' and '?'/'ask'.
|
||||
*/
|
||||
def forward(message: Any)(implicit sender: Some[ActorRef]) = {
|
||||
def forward(message: Any)(implicit channel: ForwardableChannel) = {
|
||||
if (isRunning) {
|
||||
if (sender.get.senderFuture.isDefined)
|
||||
postMessageToMailboxAndCreateFutureResultWithTimeout(message, timeout, sender.get.sender, sender.get.senderFuture)
|
||||
else
|
||||
postMessageToMailbox(message, sender.get.sender)
|
||||
} else throw new ActorInitializationException("Actor has not been started, you need to invoke 'actor.start()' before using it")
|
||||
postMessageToMailbox(message, channel.channel)
|
||||
} else throw new ActorInitializationException(
|
||||
"Actor has not been started, you need to invoke 'actor.start()' before using it")
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -1279,14 +1206,7 @@ trait ScalaActorRef extends ActorRefShared { ref: ActorRef ⇒
|
|||
* <p/>
|
||||
* Throws an IllegalStateException if unable to determine what to reply to.
|
||||
*/
|
||||
def reply(message: Any) {
|
||||
if (!reply_?(message)) throw new IllegalActorStateException(
|
||||
"\n\tNo sender in scope, can't reply. " +
|
||||
"\n\tYou have probably: " +
|
||||
"\n\t\t1. Sent a message to an Actor from an instance that is NOT an Actor." +
|
||||
"\n\t\t2. Invoked a method on an TypedActor from an instance NOT an TypedActor." +
|
||||
"\n\tElse you might want to use 'reply_?' which returns Boolean(true) if succes and Boolean(false) if no sender in scope")
|
||||
}
|
||||
def reply(message: Any) = channel.!(message)(this)
|
||||
|
||||
/**
|
||||
* Use <code>reply_?(..)</code> to reply with a message to the original sender of the message currently
|
||||
|
|
@ -1294,16 +1214,7 @@ trait ScalaActorRef extends ActorRefShared { ref: ActorRef ⇒
|
|||
* <p/>
|
||||
* Returns true if reply was sent, and false if unable to determine what to reply to.
|
||||
*/
|
||||
def reply_?(message: Any): Boolean = {
|
||||
if (senderFuture.isDefined) {
|
||||
senderFuture.get completeWithResult message
|
||||
true
|
||||
} else if (sender.isDefined) {
|
||||
//TODO: optimize away this allocation, perhaps by having implicit self: Option[ActorRef] in signature
|
||||
sender.get.!(message)(Some(this))
|
||||
true
|
||||
} else false
|
||||
}
|
||||
def reply_?(message: Any): Boolean = channel.safe_!(message)(this)
|
||||
}
|
||||
|
||||
case class SerializedActorRef(val uuid: Uuid,
|
||||
|
|
|
|||
173
akka-actor/src/main/scala/akka/actor/Channel.scala
Normal file
173
akka-actor/src/main/scala/akka/actor/Channel.scala
Normal file
|
|
@ -0,0 +1,173 @@
|
|||
/**
|
||||
* Copyright (C) 2009-2011 Scalable Solutions AB <http://scalablesolutions.se>
|
||||
*/
|
||||
|
||||
package akka.actor
|
||||
|
||||
/**
|
||||
* Abstraction for unification of sender and senderFuture for later reply.
|
||||
* Can be stored away and used at a later point in time.
|
||||
*
|
||||
* Channel cannot be contravariant because of Future providing its value in
|
||||
* covariant position.
|
||||
*
|
||||
* The possible reply channel which can be passed into ! and safe_! is always
|
||||
* untyped, as there is no way to utilize its real static type without
|
||||
* requiring runtime-costly manifests.
|
||||
*/
|
||||
trait Channel[T] {
|
||||
|
||||
/**
|
||||
* Scala API. <p/>
|
||||
* Sends the specified message to the channel.
|
||||
*/
|
||||
def !(msg: T)(implicit channel: UntypedChannel = NullChannel): Unit
|
||||
|
||||
/**
|
||||
* Try to send an exception. Not all channel types support this, one notable
|
||||
* positive example is Future. Failure to send is silent.
|
||||
*/
|
||||
def sendException(ex: Throwable): Unit
|
||||
|
||||
/**
|
||||
* Scala API.<p/>
|
||||
* Try to send message to the channel, return whether successful.
|
||||
*/
|
||||
def safe_!(msg: T)(implicit channel: UntypedChannel = NullChannel): Boolean
|
||||
|
||||
/**
|
||||
* Indicates whether this channel may be used only once, e.g. a Future.
|
||||
*/
|
||||
def isUsableOnlyOnce: Boolean
|
||||
|
||||
/**
|
||||
* Indicates whether this channel may still be used (only useful if
|
||||
* isUsableOnlyOnce returns true).
|
||||
*/
|
||||
def isUsable: Boolean
|
||||
|
||||
/**
|
||||
* Indicates whether this channel carries reply information, e.g. an
|
||||
* ActorRef.
|
||||
*/
|
||||
def isReplyable: Boolean
|
||||
|
||||
/**
|
||||
* Indicates whether this channel is capable of sending exceptions to its
|
||||
* recipient.
|
||||
*/
|
||||
def canSendException: Boolean
|
||||
|
||||
/**
|
||||
* Java API.<p/>
|
||||
* Sends the specified message to the channel, i.e. fire-and-forget semantics.<p/>
|
||||
* <pre>
|
||||
* actor.sendOneWay(message);
|
||||
* </pre>
|
||||
*/
|
||||
def sendOneWay(msg: T): Unit = this.!(msg)
|
||||
|
||||
/**
|
||||
* Java API. <p/>
|
||||
* Sends the specified message to the channel, i.e. fire-and-forget
|
||||
* semantics, including the sender reference if possible (not supported on
|
||||
* all channels).<p/>
|
||||
* <pre>
|
||||
* actor.sendOneWay(message, context);
|
||||
* </pre>
|
||||
*/
|
||||
def sendOneWay(msg: T, sender: UntypedChannel): Unit = this.!(msg)(sender)
|
||||
|
||||
/**
|
||||
* Java API.<p/>
|
||||
* Try to send the specified message to the channel, i.e. fire-and-forget semantics.<p/>
|
||||
* <pre>
|
||||
* actor.sendOneWay(message);
|
||||
* </pre>
|
||||
*/
|
||||
def sendOneWaySafe(msg: T): Boolean = this.safe_!(msg)
|
||||
|
||||
/**
|
||||
* Java API. <p/>
|
||||
* Try to send the specified message to the channel, i.e. fire-and-forget
|
||||
* semantics, including the sender reference if possible (not supported on
|
||||
* all channels).<p/>
|
||||
* <pre>
|
||||
* actor.sendOneWay(message, context);
|
||||
* </pre>
|
||||
*/
|
||||
def sendOneWaySafe(msg: T, sender: UntypedChannel): Boolean = this.safe_!(msg)(sender)
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* This trait represents a channel that a priori does have sending capability,
|
||||
* i.e. ! is not guaranteed to fail (e.g. NullChannel would be a
|
||||
* counter-example).
|
||||
*/
|
||||
trait AvailableChannel[T] { self: Channel[T] ⇒
|
||||
def safe_!(msg: T)(implicit channel: UntypedChannel = NullChannel): Boolean = {
|
||||
if (isUsable) {
|
||||
try {
|
||||
this ! msg
|
||||
true
|
||||
} catch {
|
||||
case _ ⇒ false
|
||||
}
|
||||
} else false
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* All channels used in conjunction with MessageInvocation are untyped by
|
||||
* design, so make this explicit.
|
||||
*/
|
||||
trait UntypedChannel extends Channel[Any]
|
||||
|
||||
object UntypedChannel {
|
||||
implicit def senderOption2Channel(sender: Option[ActorRef]): UntypedChannel =
|
||||
sender match {
|
||||
case Some(actor) ⇒ actor
|
||||
case None ⇒ NullChannel
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Default channel when none available.
|
||||
*/
|
||||
case object NullChannel extends UntypedChannel {
|
||||
def !(msg: Any)(implicit channel: UntypedChannel = NullChannel) {
|
||||
throw new IllegalActorStateException("""
|
||||
No sender in scope, can't reply.
|
||||
You have probably:
|
||||
1. Sent a message to an Actor from an instance that is NOT an Actor.
|
||||
2. Invoked a method on an TypedActor from an instance NOT an TypedActor.
|
||||
You may want to have a look at safe_! for a variant returning a Boolean""")
|
||||
}
|
||||
def safe_!(msg: Any)(implicit channel: UntypedChannel = NullChannel): Boolean = false
|
||||
def sendException(ex: Throwable) {}
|
||||
def isUsableOnlyOnce = false
|
||||
def isUsable = false
|
||||
def isReplyable = false
|
||||
def canSendException = false
|
||||
}
|
||||
|
||||
/**
|
||||
* A channel which may be forwarded: a message received with such a reply
|
||||
* channel attached can be passed on transparently such that a reply from a
|
||||
* later processing stage is sent directly back to the origin. Keep in mind
|
||||
* that not all channels can be used multiple times.
|
||||
*/
|
||||
trait ForwardableChannel extends UntypedChannel with AvailableChannel[Any] {
|
||||
/**
|
||||
* Get channel by which this channel would reply (ActorRef.forward takes an
|
||||
* implicit ForwardableChannel and uses its .channel as message origin)
|
||||
*/
|
||||
def channel: UntypedChannel
|
||||
}
|
||||
|
||||
object ForwardableChannel {
|
||||
implicit def someS2FC(sender: Some[ActorRef]): ForwardableChannel = sender.get
|
||||
implicit def someIS2FC(implicit sender: Some[ActorRef]): ForwardableChannel = sender.get
|
||||
}
|
||||
|
||||
|
|
@ -494,10 +494,7 @@ trait FSM[S, D] extends ListenerManagement {
|
|||
* @return this state transition descriptor
|
||||
*/
|
||||
def replying(replyValue: Any): State = {
|
||||
self.sender match {
|
||||
case Some(sender) ⇒ sender ! replyValue
|
||||
case None ⇒
|
||||
}
|
||||
self.channel safe_! replyValue
|
||||
this
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -5,8 +5,8 @@ package akka.actor
|
|||
*/
|
||||
|
||||
import akka.japi.{ Creator, Option ⇒ JOption }
|
||||
import akka.actor.Actor.{ actorOf, futureToAnyOptionAsTypedOption }
|
||||
import akka.dispatch.{ MessageDispatcher, Dispatchers, Future }
|
||||
import akka.actor.Actor._
|
||||
import akka.dispatch.{ MessageDispatcher, Dispatchers, Future, FutureTimeoutException }
|
||||
import java.lang.reflect.{ InvocationTargetException, Method, InvocationHandler, Proxy }
|
||||
import akka.util.{ Duration }
|
||||
import java.util.concurrent.atomic.{ AtomicReference ⇒ AtomVar }
|
||||
|
|
@ -41,19 +41,23 @@ object TypedActor {
|
|||
case "equals" ⇒ (args.length == 1 && (proxy eq args(0)) || actor == getActorRefFor(args(0))).asInstanceOf[AnyRef] //Force boxing of the boolean
|
||||
case "hashCode" ⇒ actor.hashCode.asInstanceOf[AnyRef]
|
||||
case _ ⇒
|
||||
val timeout = Actor.Timeout(actor.timeout)
|
||||
MethodCall(method, args) match {
|
||||
case m if m.isOneWay ⇒
|
||||
actor ! m
|
||||
null
|
||||
case m if m.returnsFuture_? ⇒
|
||||
actor !!! m
|
||||
actor ? (m, timeout)
|
||||
case m if m.returnsJOption_? || m.returnsOption_? ⇒
|
||||
(actor !!! m).as[AnyRef] match {
|
||||
case Some(null) | None ⇒ if (m.returnsJOption_?) JOption.none[Any] else None
|
||||
case Some(joption) ⇒ joption
|
||||
val f = actor ? (m, timeout)
|
||||
try { f.await } catch { case _: FutureTimeoutException ⇒ }
|
||||
f.value match {
|
||||
case None | Some(Right(null)) ⇒ if (m.returnsJOption_?) JOption.none[Any] else None
|
||||
case Some(Right(joption: AnyRef)) ⇒ joption
|
||||
case Some(Left(ex)) ⇒ throw ex
|
||||
}
|
||||
case m ⇒
|
||||
(actor !!! m).get
|
||||
(actor ? (m, timeout)).get.asInstanceOf[AnyRef]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -164,4 +168,4 @@ object TypedActor {
|
|||
}
|
||||
|
||||
private[akka] def extractInterfaces(clazz: Class[_]): Array[Class[_]] = if (clazz.isInterface) Array[Class[_]](clazz) else clazz.getInterfaces
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -129,10 +129,7 @@ class BalancingDispatcher(
|
|||
*/
|
||||
protected def donate(organ: MessageInvocation, recipient: ActorRef): Boolean = {
|
||||
if (organ ne null) {
|
||||
if (organ.senderFuture.isDefined) recipient.postMessageToMailboxAndCreateFutureResultWithTimeout[Any](
|
||||
organ.message, recipient.timeout, organ.sender, organ.senderFuture)
|
||||
else if (organ.sender.isDefined) recipient.postMessageToMailbox(organ.message, organ.sender)
|
||||
else recipient.postMessageToMailbox(organ.message, None)
|
||||
recipient.postMessageToMailbox(organ.message, organ.channel)
|
||||
true
|
||||
} else false
|
||||
}
|
||||
|
|
|
|||
|
|
@ -166,10 +166,7 @@ class Dispatcher(
|
|||
var invocation = m.dequeue
|
||||
lazy val exception = new ActorKilledException("Actor has been stopped")
|
||||
while (invocation ne null) {
|
||||
val f = invocation.senderFuture
|
||||
if (f.isDefined)
|
||||
f.get.completeWithException(exception)
|
||||
|
||||
invocation.channel.sendException(exception)
|
||||
invocation = m.dequeue
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,8 +6,8 @@ package akka.dispatch
|
|||
|
||||
import akka.AkkaException
|
||||
import akka.event.EventHandler
|
||||
import akka.actor.{ Actor, Channel }
|
||||
import akka.util.Duration
|
||||
import akka.actor.{ Actor, Channel, ForwardableChannel, NullChannel, UntypedChannel, ActorRef }
|
||||
import akka.util.{ Duration, BoxedType }
|
||||
import akka.japi.{ Procedure, Function ⇒ JFunc }
|
||||
|
||||
import scala.util.continuations._
|
||||
|
|
@ -278,7 +278,7 @@ sealed trait Future[+T] {
|
|||
* continuation until the result is available.
|
||||
*
|
||||
* If this Future is untyped (a Future[Nothing]), a type parameter must be explicitly provided or
|
||||
* execution will fail. The normal result of getting a Future from an ActorRef using !!! will return
|
||||
* execution will fail. The normal result of getting a Future from an ActorRef using ? will return
|
||||
* an untyped Future.
|
||||
*/
|
||||
def apply[A >: T](): A @cps[Future[Any]] = shift(this flatMap (_: A ⇒ Future[Any]))
|
||||
|
|
@ -308,6 +308,23 @@ sealed trait Future[+T] {
|
|||
*/
|
||||
def await(atMost: Duration): Future[T]
|
||||
|
||||
/**
|
||||
* Await completion of this Future (as `await`) and return its value if it
|
||||
* conforms to A's erased type.
|
||||
*
|
||||
* def as[A](implicit m: Manifest[A]): Option[A] =
|
||||
* try {
|
||||
* await
|
||||
* value match {
|
||||
* case None ⇒ None
|
||||
* case Some(_: Left[_, _]) ⇒ None
|
||||
* case Some(Right(v)) ⇒ Some(BoxedType(m.erasure).cast(v).asInstanceOf[A])
|
||||
* }
|
||||
* } catch {
|
||||
* case _: Exception ⇒ None
|
||||
* }
|
||||
*/
|
||||
|
||||
/**
|
||||
* Tests whether this Future has been completed.
|
||||
*/
|
||||
|
|
@ -357,7 +374,7 @@ sealed trait Future[+T] {
|
|||
* Future. If the Future has already been completed, this will apply
|
||||
* immediately.
|
||||
*/
|
||||
def onComplete(func: Future[T] ⇒ Unit): Future[T]
|
||||
def onComplete(func: Future[T] ⇒ Unit): this.type
|
||||
|
||||
/**
|
||||
* When the future is completed with a valid result, apply the provided
|
||||
|
|
@ -369,7 +386,7 @@ sealed trait Future[+T] {
|
|||
* }
|
||||
* </pre>
|
||||
*/
|
||||
final def onResult(pf: PartialFunction[Any, Unit]): Future[T] = onComplete { f ⇒
|
||||
final def onResult(pf: PartialFunction[Any, Unit]): this.type = onComplete { f ⇒
|
||||
val optr = f.result
|
||||
if (optr.isDefined) {
|
||||
val r = optr.get
|
||||
|
|
@ -403,9 +420,9 @@ sealed trait Future[+T] {
|
|||
* Example:
|
||||
* <pre>
|
||||
* val future1 = for {
|
||||
* a <- actor !!! Req("Hello") collect { case Res(x: Int) => x }
|
||||
* b <- actor !!! Req(a) collect { case Res(x: String) => x }
|
||||
* c <- actor !!! Req(7) collect { case Res(x: String) => x }
|
||||
* a <- actor ? Req("Hello") collect { case Res(x: Int) => x }
|
||||
* b <- actor ? Req(a) collect { case Res(x: String) => x }
|
||||
* c <- actor ? Req(7) collect { case Res(x: String) => x }
|
||||
* } yield b + "-" + c
|
||||
* </pre>
|
||||
*/
|
||||
|
|
@ -468,9 +485,9 @@ sealed trait Future[+T] {
|
|||
* Example:
|
||||
* <pre>
|
||||
* val future1 = for {
|
||||
* a: Int <- actor !!! "Hello" // returns 5
|
||||
* b: String <- actor !!! a // returns "10"
|
||||
* c: String <- actor !!! 7 // returns "14"
|
||||
* a: Int <- actor ? "Hello" // returns 5
|
||||
* b: String <- actor ? a // returns "10"
|
||||
* c: String <- actor ? 7 // returns "14"
|
||||
* } yield b + "-" + c
|
||||
* </pre>
|
||||
*/
|
||||
|
|
@ -496,6 +513,26 @@ sealed trait Future[+T] {
|
|||
fa
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new Future[A] which is completed with this Future's result if
|
||||
* that conforms to A's erased type or a ClassCastException otherwise.
|
||||
*/
|
||||
final def mapTo[A](implicit m: Manifest[A]): Future[A] = {
|
||||
val fa = new DefaultPromise[A](timeoutInNanos, NANOS)
|
||||
onComplete { ft ⇒
|
||||
fa complete (ft.value.get match {
|
||||
case l: Left[_, _] ⇒ l.asInstanceOf[Either[Throwable, A]]
|
||||
case Right(t) ⇒
|
||||
try {
|
||||
Right(BoxedType(m.erasure).cast(t).asInstanceOf[A])
|
||||
} catch {
|
||||
case e: ClassCastException ⇒ Left(e)
|
||||
}
|
||||
})
|
||||
}
|
||||
fa
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new Future by applying a function to the successful result of
|
||||
* this Future, and returns the result of the function as the new Future.
|
||||
|
|
@ -504,9 +541,9 @@ sealed trait Future[+T] {
|
|||
* Example:
|
||||
* <pre>
|
||||
* val future1 = for {
|
||||
* a: Int <- actor !!! "Hello" // returns 5
|
||||
* b: String <- actor !!! a // returns "10"
|
||||
* c: String <- actor !!! 7 // returns "14"
|
||||
* a: Int <- actor ? "Hello" // returns 5
|
||||
* b: String <- actor ? a // returns "10"
|
||||
* c: String <- actor ? 7 // returns "14"
|
||||
* } yield b + "-" + c
|
||||
* </pre>
|
||||
*/
|
||||
|
|
@ -539,7 +576,7 @@ sealed trait Future[+T] {
|
|||
}
|
||||
}
|
||||
|
||||
/*final def withFilter(p: T ⇒ Boolean) = new FutureWithFilter[T](this, p)
|
||||
final def withFilter(p: T ⇒ Boolean) = new FutureWithFilter[T](this, p)
|
||||
|
||||
final class FutureWithFilter[+A](self: Future[A], p: A ⇒ Boolean) {
|
||||
def foreach(f: A ⇒ Unit): Unit = self filter p foreach f
|
||||
|
|
@ -548,8 +585,7 @@ sealed trait Future[+T] {
|
|||
def withFilter(q: A ⇒ Boolean): FutureWithFilter[A] = new FutureWithFilter[A](self, x ⇒ p(x) && q(x))
|
||||
}
|
||||
|
||||
final def filter(p: T ⇒ Boolean): Future[T] = { */
|
||||
final def filter(p: Any ⇒ Boolean): Future[T] = {
|
||||
final def filter(p: T ⇒ Boolean): Future[T] = {
|
||||
val f = new DefaultPromise[T](timeoutInNanos, NANOS)
|
||||
onComplete { ft ⇒
|
||||
val optv = ft.value
|
||||
|
|
@ -586,7 +622,7 @@ sealed trait Future[+T] {
|
|||
}
|
||||
|
||||
/* Java API */
|
||||
final def onComplete[A >: T](proc: Procedure[Future[A]]): Future[T] = onComplete(proc(_))
|
||||
final def onComplete[A >: T](proc: Procedure[Future[A]]): this.type = onComplete(proc(_))
|
||||
|
||||
final def map[A >: T, B](f: JFunc[A, B]): Future[B] = map(f(_))
|
||||
|
||||
|
|
@ -607,10 +643,7 @@ object Promise {
|
|||
/**
|
||||
* Construct a completable channel
|
||||
*/
|
||||
def channel(timeout: Long = Actor.TIMEOUT) = new Channel[Any] {
|
||||
val promise = Promise[Any](timeout)
|
||||
def !(msg: Any) = promise completeWithResult msg
|
||||
}
|
||||
def channel(timeout: Long = Actor.TIMEOUT): ActorPromise = new ActorPromise(timeout)
|
||||
|
||||
private[akka] val callbacksPendingExecution = new ThreadLocal[Option[Stack[() ⇒ Unit]]]() {
|
||||
override def initialValue = None
|
||||
|
|
@ -625,26 +658,26 @@ trait Promise[T] extends Future[T] {
|
|||
* Completes this Future with the specified result, if not already completed.
|
||||
* @return this
|
||||
*/
|
||||
def complete(value: Either[Throwable, T]): Future[T]
|
||||
def complete(value: Either[Throwable, T]): this.type
|
||||
|
||||
/**
|
||||
* Completes this Future with the specified result, if not already completed.
|
||||
* @return this
|
||||
*/
|
||||
final def completeWithResult(result: T): Future[T] = complete(Right(result))
|
||||
final def completeWithResult(result: T): this.type = complete(Right(result))
|
||||
|
||||
/**
|
||||
* Completes this Future with the specified exception, if not already completed.
|
||||
* @return this
|
||||
*/
|
||||
final def completeWithException(exception: Throwable): Future[T] = complete(Left(exception))
|
||||
final def completeWithException(exception: Throwable): this.type = complete(Left(exception))
|
||||
|
||||
/**
|
||||
* Completes this Future with the specified other Future, when that Future is completed,
|
||||
* unless this Future has already been completed.
|
||||
* @return this.
|
||||
*/
|
||||
final def completeWith(other: Future[T]): Future[T] = {
|
||||
final def completeWith(other: Future[T]): this.type = {
|
||||
other onComplete { f ⇒ complete(f.value.get) }
|
||||
this
|
||||
}
|
||||
|
|
@ -725,7 +758,7 @@ class DefaultPromise[T](timeout: Long, timeunit: TimeUnit) extends Promise[T] {
|
|||
}
|
||||
}
|
||||
|
||||
def complete(value: Either[Throwable, T]): DefaultPromise[T] = {
|
||||
def complete(value: Either[Throwable, T]): this.type = {
|
||||
_lock.lock
|
||||
val notifyTheseListeners = try {
|
||||
if (_value.isEmpty) { //Only complete if we aren't expired
|
||||
|
|
@ -772,7 +805,7 @@ class DefaultPromise[T](timeout: Long, timeunit: TimeUnit) extends Promise[T] {
|
|||
this
|
||||
}
|
||||
|
||||
def onComplete(func: Future[T] ⇒ Unit): Promise[T] = {
|
||||
def onComplete(func: Future[T] ⇒ Unit): this.type = {
|
||||
_lock.lock
|
||||
val notifyNow = try {
|
||||
if (_value.isEmpty) {
|
||||
|
|
@ -804,6 +837,36 @@ class DefaultPromise[T](timeout: Long, timeunit: TimeUnit) extends Promise[T] {
|
|||
private def timeLeft(): Long = timeoutInNanos - (currentTimeInNanos - _startTimeInNanos)
|
||||
}
|
||||
|
||||
class ActorPromise(timeout: Long, timeunit: TimeUnit)
|
||||
extends DefaultPromise[Any](timeout, timeunit)
|
||||
with ForwardableChannel {
|
||||
def this() = this(0, MILLIS)
|
||||
def this(timeout: Long) = this(timeout, MILLIS)
|
||||
|
||||
def !(message: Any)(implicit channel: UntypedChannel = NullChannel) = completeWithResult(message)
|
||||
|
||||
def sendException(ex: Throwable) = completeWithException(ex)
|
||||
|
||||
def channel: UntypedChannel = this
|
||||
|
||||
def isUsableOnlyOnce = true
|
||||
def isUsable = !isCompleted
|
||||
def isReplyable = false
|
||||
def canSendException = true
|
||||
|
||||
@deprecated("ActorPromise merged with Channel[Any], just use 'this'", "1.2")
|
||||
def future = this
|
||||
}
|
||||
|
||||
object ActorPromise {
|
||||
def apply(f: Promise[Any]): ActorPromise =
|
||||
new ActorPromise(f.timeoutInNanos, NANOS) {
|
||||
completeWith(f)
|
||||
override def !(message: Any)(implicit channel: UntypedChannel) = f completeWithResult message
|
||||
override def sendException(ex: Throwable) = f completeWithException ex
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* An already completed Future is seeded with it's result at creation, is useful for when you are participating in
|
||||
* a Future-composition but you already have a value to contribute.
|
||||
|
|
@ -811,10 +874,10 @@ class DefaultPromise[T](timeout: Long, timeunit: TimeUnit) extends Promise[T] {
|
|||
sealed class KeptPromise[T](suppliedValue: Either[Throwable, T]) extends Promise[T] {
|
||||
val value = Some(suppliedValue)
|
||||
|
||||
def complete(value: Either[Throwable, T]): Promise[T] = this
|
||||
def onComplete(func: Future[T] ⇒ Unit): Future[T] = { func(this); this }
|
||||
def await(atMost: Duration): Future[T] = this
|
||||
def await: Future[T] = this
|
||||
def complete(value: Either[Throwable, T]): this.type = this
|
||||
def onComplete(func: Future[T] ⇒ Unit): this.type = { func(this); this }
|
||||
def await(atMost: Duration): this.type = this
|
||||
def await: this.type = this
|
||||
def isExpired: Boolean = true
|
||||
def timeoutInNanos: Long = 0
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,10 +16,9 @@ import akka.actor._
|
|||
/**
|
||||
* @author <a href="http://jonasboner.com">Jonas Bonér</a>
|
||||
*/
|
||||
final case class MessageInvocation(receiver: ActorRef,
|
||||
message: Any,
|
||||
sender: Option[ActorRef],
|
||||
senderFuture: Option[Promise[Any]]) {
|
||||
final case class MessageInvocation(val receiver: ActorRef,
|
||||
val message: Any,
|
||||
val channel: UntypedChannel) {
|
||||
if (receiver eq null) throw new IllegalArgumentException("Receiver can't be null")
|
||||
|
||||
final def invoke() {
|
||||
|
|
|
|||
39
akka-actor/src/main/scala/akka/package.scala
Normal file
39
akka-actor/src/main/scala/akka/package.scala
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
/**
|
||||
* Copyright (C) 2009-2011 Scalable Solutions AB <http://scalablesolutions.se>
|
||||
*/
|
||||
|
||||
import akka.dispatch.{ FutureTimeoutException, Future }
|
||||
import akka.util.Helpers.{ narrow, narrowSilently }
|
||||
|
||||
package object akka {
|
||||
/**
|
||||
* Implicitly converts the given Option[Any] to a AnyOptionAsTypedOption which offers the method <code>as[T]</code>
|
||||
* to convert an Option[Any] to an Option[T].
|
||||
*/
|
||||
implicit def toAnyOptionAsTypedOption(anyOption: Option[Any]) = new AnyOptionAsTypedOption(anyOption)
|
||||
|
||||
/**
|
||||
* Implicitly converts the given Future[_] to a AnyOptionAsTypedOption which offers the method <code>as[T]</code>
|
||||
* to convert an Option[Any] to an Option[T].
|
||||
* This means that the following code is equivalent:
|
||||
* (actor ? "foo").as[Int] (Recommended)
|
||||
*/
|
||||
implicit def futureToAnyOptionAsTypedOption(anyFuture: Future[_]) = new AnyOptionAsTypedOption({
|
||||
try { anyFuture.await } catch { case t: FutureTimeoutException ⇒ }
|
||||
anyFuture.resultOrException
|
||||
})
|
||||
|
||||
private[akka] class AnyOptionAsTypedOption(anyOption: Option[Any]) {
|
||||
/**
|
||||
* Convenience helper to cast the given Option of Any to an Option of the given type. Will throw a ClassCastException
|
||||
* if the actual type is not assignable from the given one.
|
||||
*/
|
||||
def as[T]: Option[T] = narrow[T](anyOption)
|
||||
|
||||
/**
|
||||
* Convenience helper to cast the given Option of Any to an Option of the given type. Will swallow a possible
|
||||
* ClassCastException and return None in that case.
|
||||
*/
|
||||
def asSilently[T: Manifest]: Option[T] = narrowSilently[T](anyOption)
|
||||
}
|
||||
}
|
||||
|
|
@ -5,6 +5,7 @@
|
|||
package akka.routing
|
||||
|
||||
import akka.actor.{ Actor, ActorRef, PoisonPill }
|
||||
import akka.dispatch.{ Promise }
|
||||
|
||||
/**
|
||||
* Actor pooling
|
||||
|
|
@ -195,7 +196,7 @@ trait MailboxPressureCapacitor {
|
|||
*/
|
||||
trait ActiveFuturesPressureCapacitor {
|
||||
def pressure(delegates: Seq[ActorRef]): Int =
|
||||
delegates count { _.senderFuture.isDefined }
|
||||
delegates count { _.channel.isInstanceOf[Promise[Any]] }
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
25
akka-actor/src/main/scala/akka/util/BoxedType.scala
Normal file
25
akka-actor/src/main/scala/akka/util/BoxedType.scala
Normal file
|
|
@ -0,0 +1,25 @@
|
|||
/**
|
||||
* Copyright (C) 2009-2011 Scalable Solutions AB <http://scalablesolutions.se>
|
||||
*/
|
||||
package akka.util
|
||||
|
||||
import java.{ lang ⇒ jl }
|
||||
|
||||
object BoxedType {
|
||||
|
||||
private val toBoxed = Map[Class[_], Class[_]](
|
||||
classOf[Boolean] -> classOf[jl.Boolean],
|
||||
classOf[Byte] -> classOf[jl.Byte],
|
||||
classOf[Char] -> classOf[jl.Character],
|
||||
classOf[Short] -> classOf[jl.Short],
|
||||
classOf[Int] -> classOf[jl.Integer],
|
||||
classOf[Long] -> classOf[jl.Long],
|
||||
classOf[Float] -> classOf[jl.Float],
|
||||
classOf[Double] -> classOf[jl.Double],
|
||||
classOf[Unit] -> classOf[scala.runtime.BoxedUnit])
|
||||
|
||||
def apply(c: Class[_]): Class[_] = {
|
||||
if (c.isPrimitive) toBoxed(c) else c
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -40,10 +40,10 @@ class TypedConsumerPublishRequestorTest extends JUnitSuite {
|
|||
@Test
|
||||
def shouldReceiveOneConsumerMethodRegisteredEvent = {
|
||||
Actor.registry.addListener(requestor)
|
||||
val latch = (publisher !! SetExpectedTestMessageCount(1)).as[CountDownLatch].get
|
||||
val latch = (publisher ? SetExpectedTestMessageCount(1)).as[CountDownLatch].get
|
||||
val obj = TypedActor.typedActorOf(classOf[SampleTypedSingleConsumer], classOf[SampleTypedSingleConsumerImpl], defaultConfiguration)
|
||||
assert(latch.await(5000, TimeUnit.MILLISECONDS))
|
||||
val event = (publisher !! GetRetainedMessage).as[ConsumerMethodRegistered].get
|
||||
val event = (publisher ? GetRetainedMessage).as[ConsumerMethodRegistered].get
|
||||
assert(event.endpointUri === "direct:foo")
|
||||
assert(event.typedActor === obj)
|
||||
assert(event.methodName === "foo")
|
||||
|
|
@ -52,11 +52,11 @@ class TypedConsumerPublishRequestorTest extends JUnitSuite {
|
|||
@Test
|
||||
def shouldReceiveOneConsumerMethodUnregisteredEvent = {
|
||||
val obj = TypedActor.typedActorOf(classOf[SampleTypedSingleConsumer], classOf[SampleTypedSingleConsumerImpl], defaultConfiguration)
|
||||
val latch = (publisher !! SetExpectedTestMessageCount(1)).as[CountDownLatch].get
|
||||
val latch = (publisher ? SetExpectedTestMessageCount(1)).as[CountDownLatch].get
|
||||
Actor.registry.addListener(requestor)
|
||||
TypedActor.stop(obj)
|
||||
assert(latch.await(5000, TimeUnit.MILLISECONDS))
|
||||
val event = (publisher !! GetRetainedMessage).as[ConsumerMethodUnregistered].get
|
||||
val event = (publisher ? GetRetainedMessage).as[ConsumerMethodUnregistered].get
|
||||
assert(event.endpointUri === "direct:foo")
|
||||
assert(event.typedActor === obj)
|
||||
assert(event.methodName === "foo")
|
||||
|
|
@ -65,23 +65,23 @@ class TypedConsumerPublishRequestorTest extends JUnitSuite {
|
|||
@Test
|
||||
def shouldReceiveThreeConsumerMethodRegisteredEvents = {
|
||||
Actor.registry.addListener(requestor)
|
||||
val latch = (publisher !! SetExpectedTestMessageCount(3)).as[CountDownLatch].get
|
||||
val latch = (publisher ? SetExpectedTestMessageCount(3)).as[CountDownLatch].get
|
||||
val obj = TypedActor.typedActorOf(classOf[SampleTypedConsumer], classOf[SampleTypedConsumerImpl], defaultConfiguration)
|
||||
assert(latch.await(5000, TimeUnit.MILLISECONDS))
|
||||
val request = GetRetainedMessages(_.isInstanceOf[ConsumerMethodRegistered])
|
||||
val events = (publisher !! request).as[List[ConsumerMethodRegistered]].get
|
||||
val events = (publisher ? request).as[List[ConsumerMethodRegistered]].get
|
||||
assert(events.map(_.method.getName).sortWith(_ < _) === List("m2", "m3", "m4"))
|
||||
}
|
||||
|
||||
@Test
|
||||
def shouldReceiveThreeConsumerMethodUnregisteredEvents = {
|
||||
val obj = TypedActor.typedActorOf(classOf[SampleTypedConsumer], classOf[SampleTypedConsumerImpl], defaultConfiguration)
|
||||
val latch = (publisher !! SetExpectedTestMessageCount(3)).as[CountDownLatch].get
|
||||
val latch = (publisher ? SetExpectedTestMessageCount(3)).as[CountDownLatch].get
|
||||
Actor.registry.addListener(requestor)
|
||||
TypedActor.stop(obj)
|
||||
assert(latch.await(5000, TimeUnit.MILLISECONDS))
|
||||
val request = GetRetainedMessages(_.isInstanceOf[ConsumerMethodUnregistered])
|
||||
val events = (publisher !! request).as[List[ConsumerMethodUnregistered]].get
|
||||
val events = (publisher ? request).as[List[ConsumerMethodUnregistered]].get
|
||||
assert(events.map(_.method.getName).sortWith(_ < _) === List("m2", "m3", "m4"))
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@ import org.apache.camel._
|
|||
import org.apache.camel.processor.SendProcessor
|
||||
|
||||
import akka.actor.{ Actor, ActorRef, UntypedActor }
|
||||
import akka.dispatch.ActorPromise
|
||||
|
||||
/**
|
||||
* Support trait for producing messages to Camel endpoints.
|
||||
|
|
@ -96,10 +97,9 @@ trait ProducerSupport { this: Actor ⇒
|
|||
val exchange = createExchange(pattern).fromRequestMessage(cmsg)
|
||||
processor.process(exchange, new AsyncCallback {
|
||||
val producer = self
|
||||
// Need copies of sender and senderFuture references here
|
||||
// since the callback could be done later by another thread.
|
||||
val sender = self.sender
|
||||
val senderFuture = self.senderFuture
|
||||
// Need copies of channel reference here since the callback could be done
|
||||
// later by another thread.
|
||||
val channel = self.channel
|
||||
|
||||
def done(doneSync: Boolean): Unit = {
|
||||
(doneSync, exchange.isFailed) match {
|
||||
|
|
@ -114,10 +114,12 @@ trait ProducerSupport { this: Actor ⇒
|
|||
receiveAfterProduce(result)
|
||||
|
||||
private def dispatchAsync(result: Any) = {
|
||||
if (senderFuture.isDefined)
|
||||
producer.postMessageToMailboxAndCreateFutureResultWithTimeout(result, producer.timeout, sender, senderFuture)
|
||||
else
|
||||
producer.postMessageToMailbox(result, sender)
|
||||
channel match {
|
||||
case _: ActorPromise ⇒
|
||||
producer.postMessageToMailboxAndCreateFutureResultWithTimeout(result, producer.timeout, channel)
|
||||
case _ ⇒
|
||||
producer.postMessageToMailbox(result, channel)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
|
|||
|
|
@ -285,7 +285,7 @@ private[akka] class AsyncCallbackAdapter(exchange: Exchange, callback: AsyncCall
|
|||
* @param message reply message
|
||||
* @param sender ignored
|
||||
*/
|
||||
protected[akka] def postMessageToMailbox(message: Any, senderOption: Option[ActorRef]) = {
|
||||
protected[akka] def postMessageToMailbox(message: Any, channel: UntypedChannel) = {
|
||||
message match {
|
||||
case Ack ⇒ { /* no response message to set */ }
|
||||
case msg: Failure ⇒ exchange.fromFailureMessage(msg)
|
||||
|
|
@ -312,7 +312,7 @@ private[akka] class AsyncCallbackAdapter(exchange: Exchange, callback: AsyncCall
|
|||
def shutdownLinkedActors: Unit = unsupported
|
||||
def supervisor: Option[ActorRef] = unsupported
|
||||
def homeAddress: Option[InetSocketAddress] = None
|
||||
protected[akka] def postMessageToMailboxAndCreateFutureResultWithTimeout[T](message: Any, timeout: Long, senderOption: Option[ActorRef], senderFuture: Option[Promise[T]]) = unsupported
|
||||
protected[akka] def postMessageToMailboxAndCreateFutureResultWithTimeout(message: Any, timeout: Long, channel: UntypedChannel) = unsupported
|
||||
protected[akka] def mailbox: AnyRef = unsupported
|
||||
protected[akka] def mailbox_=(msg: AnyRef): AnyRef = unsupported
|
||||
protected[akka] def restart(reason: Throwable, maxNrOfRetries: Option[Int], withinTimeRange: Option[Int]): Unit = unsupported
|
||||
|
|
|
|||
|
|
@ -402,7 +402,7 @@ public final class ClusterProtocol {
|
|||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
||||
private Builder(BuilderParent parent) {
|
||||
private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
|
||||
super(parent);
|
||||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
|
@ -1092,7 +1092,7 @@ public final class ClusterProtocol {
|
|||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
||||
private Builder(BuilderParent parent) {
|
||||
private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
|
||||
super(parent);
|
||||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
|
@ -1694,7 +1694,7 @@ public final class ClusterProtocol {
|
|||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
||||
private Builder(BuilderParent parent) {
|
||||
private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
|
||||
super(parent);
|
||||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -665,7 +665,7 @@ class DefaultClusterNode private[akka] (
|
|||
.build
|
||||
|
||||
replicaConnectionsForReplicationFactor(replicationFactor) foreach { connection ⇒
|
||||
(connection !! (command, remoteDaemonAckTimeout)) match {
|
||||
(connection ? (command, remoteDaemonAckTimeout)).as[Status] match {
|
||||
|
||||
case Some(Success) ⇒
|
||||
EventHandler.debug(this, "Replica for [%s] successfully created".format(actorRef.address))
|
||||
|
|
@ -676,7 +676,7 @@ class DefaultClusterNode private[akka] (
|
|||
|
||||
case None ⇒
|
||||
val error = new ClusterException(
|
||||
"Operation to instantiate replicas throughout the cluster timed out, cause of error unknow")
|
||||
"Operation to instantiate replicas throughout the cluster timed out")
|
||||
EventHandler.error(error, this, error.toString)
|
||||
throw error
|
||||
}
|
||||
|
|
@ -1056,7 +1056,7 @@ class DefaultClusterNode private[akka] (
|
|||
.setMessageType(FUNCTION_FUN0_ANY)
|
||||
.setPayload(ByteString.copyFrom(Serializers.Java.toBinary(f)))
|
||||
.build
|
||||
val results = replicaConnectionsForReplicationFactor(replicationFactor) map (_ !!! message)
|
||||
val results = replicaConnectionsForReplicationFactor(replicationFactor) map (_ ? message)
|
||||
results.toList.asInstanceOf[List[Future[Any]]]
|
||||
}
|
||||
|
||||
|
|
@ -1082,7 +1082,7 @@ class DefaultClusterNode private[akka] (
|
|||
.setMessageType(FUNCTION_FUN1_ARG_ANY)
|
||||
.setPayload(ByteString.copyFrom(Serializers.Java.toBinary((f, arg))))
|
||||
.build
|
||||
val results = replicaConnectionsForReplicationFactor(replicationFactor) map (_ !!! message)
|
||||
val results = replicaConnectionsForReplicationFactor(replicationFactor) map (_ ? message)
|
||||
results.toList.asInstanceOf[List[Future[Any]]]
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ import akka.util._
|
|||
import ReflectiveAccess._
|
||||
import ClusterModule._
|
||||
import akka.event.EventHandler
|
||||
import akka.dispatch.Future
|
||||
|
||||
import java.net.InetSocketAddress
|
||||
import java.util.concurrent.atomic.AtomicReference
|
||||
|
|
@ -40,15 +41,23 @@ class ClusterActorRef private[akka] (
|
|||
|
||||
def connections: Map[InetSocketAddress, ActorRef] = inetSocketAddressToActorRefMap.get
|
||||
|
||||
override def postMessageToMailbox(message: Any, senderOption: Option[ActorRef]): Unit =
|
||||
route(message)(senderOption)
|
||||
override def postMessageToMailbox(message: Any, channel: UntypedChannel): Unit = {
|
||||
val sender = channel match {
|
||||
case ref: ActorRef ⇒ Some(ref)
|
||||
case _ ⇒ None
|
||||
}
|
||||
route(message)(sender)
|
||||
}
|
||||
|
||||
override def postMessageToMailboxAndCreateFutureResultWithTimeout[T](
|
||||
override def postMessageToMailboxAndCreateFutureResultWithTimeout(
|
||||
message: Any,
|
||||
timeout: Long,
|
||||
senderOption: Option[ActorRef],
|
||||
senderFuture: Option[Promise[T]]): Promise[T] = {
|
||||
route[T](message, timeout)(senderOption).asInstanceOf[Promise[T]]
|
||||
channel: UntypedChannel): Future[Any] = {
|
||||
val sender = channel match {
|
||||
case ref: ActorRef ⇒ Some(ref)
|
||||
case _ ⇒ None
|
||||
}
|
||||
route[Any](message, timeout)(sender)
|
||||
}
|
||||
|
||||
private[akka] def failOver(fromInetSocketAddress: InetSocketAddress, toInetSocketAddress: InetSocketAddress) {
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@ object Router {
|
|||
}
|
||||
|
||||
def route[T](message: Any, timeout: Long)(implicit sender: Option[ActorRef]): Future[T] = next match {
|
||||
case Some(actor) ⇒ actor.!!!(message, timeout)(sender)
|
||||
case Some(actor) ⇒ actor.?(message, timeout)(sender).asInstanceOf[Future[T]]
|
||||
case _ ⇒ throwNoConnectionsError()
|
||||
}
|
||||
|
||||
|
|
|
|||
182
akka-cluster/src/main/scala/akka/cluster/Storage.scala
Normal file → Executable file
182
akka-cluster/src/main/scala/akka/cluster/Storage.scala
Normal file → Executable file
|
|
@ -5,9 +5,8 @@ import akka.AkkaException
|
|||
import org.apache.zookeeper.{ KeeperException, CreateMode }
|
||||
import org.apache.zookeeper.data.Stat
|
||||
import java.util.concurrent.ConcurrentHashMap
|
||||
import org.apache.zookeeper.KeeperException.NoNodeException
|
||||
import java.lang.UnsupportedOperationException
|
||||
import annotation.tailrec
|
||||
import java.lang.{ UnsupportedOperationException, RuntimeException }
|
||||
|
||||
/**
|
||||
* Simple abstraction to store an Array of bytes based on some String key.
|
||||
|
|
@ -15,36 +14,37 @@ import annotation.tailrec
|
|||
* Nothing is being said about ACID, transactions etc. It depends on the implementation
|
||||
* of this Storage interface of what is and isn't done on the lowest level.
|
||||
*
|
||||
* TODO: Perhaps add a version to the store to prevent lost updates using optimistic locking.
|
||||
* (This is supported by ZooKeeper).
|
||||
* The amount of data that is allowed to be insert/updated is implementation specific. The InMemoryStorage
|
||||
* has no limits, but the ZooKeeperStorage has a maximum size of 1 mb.
|
||||
*
|
||||
* TODO: Class is up for better names.
|
||||
* TODO: Instead of a String as key, perhaps also a byte-array.
|
||||
*/
|
||||
trait Storage {
|
||||
|
||||
/**
|
||||
* Loads the given entry.
|
||||
* Loads the VersionedData for the given key.
|
||||
*
|
||||
* @param key: the key of the data to load.
|
||||
* @return the VersionedData for the given key.
|
||||
* @throws NoNodeExistsException if the data with the given key doesn't exist.
|
||||
* @param key: the key of the VersionedData to load.
|
||||
* @return the VersionedData for the given entry.
|
||||
* @throws MissingDataException if the entry with the given key doesn't exist.
|
||||
* @throws StorageException if anything goes wrong while accessing the storage
|
||||
*/
|
||||
def load(key: String): VersionedData
|
||||
|
||||
/**
|
||||
* Loads the data for the given key and version.
|
||||
* Loads the VersionedData for the given key and version.
|
||||
*
|
||||
* @param key: the key of the data to load
|
||||
* @param version the version of the data to load
|
||||
* @throws NoNodeExistsException if the data with the given key doesn't exist.
|
||||
* @throws VersioningMismatchStorageException if the version of the data is not the same as the given data.
|
||||
* @param key: the key of the VersionedData to load
|
||||
* @param version the version of the VersionedData to load
|
||||
* @throws MissingDataException if the data with the given key doesn't exist.
|
||||
* @throws VersioningException if the version of the data is not the same as the given data.
|
||||
* @throws StorageException if anything goes wrong while accessing the storage
|
||||
*/
|
||||
def load(key: String, version: Long): VersionedData
|
||||
|
||||
/**
|
||||
* Checks if a value with the given key exists.
|
||||
* Checks if a VersionedData with the given key exists.
|
||||
*
|
||||
* @param key the key to check the existence for.
|
||||
* @return true if exists, false if not.
|
||||
|
|
@ -57,19 +57,34 @@ trait Storage {
|
|||
*
|
||||
* @param key the key of the Data to insert.
|
||||
* @param bytes the data to insert.
|
||||
* @return the version of the inserted data
|
||||
* @throws NodeExistsException when a Node with the given Key already exists.
|
||||
* @return the VersionedData
|
||||
* @throws DataExistsException when VersionedData with the given Key already exists.
|
||||
* @throws StorageException if anything goes wrong while accessing the storage
|
||||
*/
|
||||
def insert(key: String, bytes: Array[Byte]): VersionedData
|
||||
|
||||
/**
|
||||
* Stores a array of bytes based on some key.
|
||||
* Inserts the data if there is no data for that key, or overwrites it if it is there.
|
||||
*
|
||||
* @throws MissingNodeException when the Node with the given key doesn't exist.
|
||||
* This is the method you want to call if you just want to save something and don't
|
||||
* care about any lost update issues.
|
||||
*
|
||||
* @param key the key of the data
|
||||
* @param bytes the data to insert
|
||||
* @return the VersionedData that was stored.
|
||||
* @throws StorageException if anything goes wrong while accessing the storage
|
||||
*/
|
||||
def update(key: String, bytes: Array[Byte]): VersionedData
|
||||
def insertOrOverwrite(key: String, bytes: Array[Byte]): VersionedData
|
||||
|
||||
/**
|
||||
* Overwrites the current data for the given key.
|
||||
*
|
||||
* @param key the key of the data to overwrite
|
||||
* @param bytes the data to insert.
|
||||
* @throws ` when the entry with the given key doesn't exist.
|
||||
* @throws StorageException if anything goes wrong while accessing the storage
|
||||
*/
|
||||
def overwrite(key: String, bytes: Array[Byte]): VersionedData
|
||||
|
||||
/**
|
||||
* @throws StorageException if anything goes wrong while accessing the storage
|
||||
|
|
@ -98,17 +113,17 @@ class StorageException(msg: String = null, cause: java.lang.Throwable = null) ex
|
|||
* *
|
||||
* A StorageException thrown when an operation is done on a non existing node.
|
||||
*/
|
||||
class MissingNodeException(msg: String = null, cause: java.lang.Throwable = null) extends StorageException(msg, cause)
|
||||
class MissingDataException(msg: String = null, cause: java.lang.Throwable = null) extends StorageException(msg, cause)
|
||||
|
||||
/**
|
||||
* A StorageException thrown when an operation is done on an existing node, but no node was expected.
|
||||
*/
|
||||
class NodeExistsException(msg: String = null, cause: java.lang.Throwable = null) extends StorageException(msg, cause)
|
||||
class DataExistsException(msg: String = null, cause: java.lang.Throwable = null) extends StorageException(msg, cause)
|
||||
|
||||
/**
|
||||
* A StorageException thrown when an operation causes an optimistic locking failure.
|
||||
*/
|
||||
class VersioningMismatchStorageException(msg: String = null, cause: java.lang.Throwable = null) extends StorageException(msg, cause)
|
||||
class VersioningException(msg: String = null, cause: java.lang.Throwable = null) extends StorageException(msg, cause)
|
||||
|
||||
/**
|
||||
* A Storage implementation based on ZooKeeper.
|
||||
|
|
@ -117,59 +132,89 @@ class VersioningMismatchStorageException(msg: String = null, cause: java.lang.Th
|
|||
* - so everything is written or nothing is written
|
||||
* - is isolated, so threadsafe,
|
||||
* but it will not participate in any transactions.
|
||||
* //todo: unclear, is only a single connection used in the JVM??
|
||||
*
|
||||
*/
|
||||
class ZooKeeperStorage(zkClient: AkkaZkClient) extends Storage {
|
||||
|
||||
def load(key: String) = try {
|
||||
val arrayOfBytes: Array[Byte] = zkClient.connection.readData(key, new Stat, false)
|
||||
//Some(arrayOfBytes)
|
||||
throw new UnsupportedOperationException()
|
||||
val stat = new Stat
|
||||
val arrayOfBytes = zkClient.connection.readData(key, stat, false)
|
||||
new VersionedData(arrayOfBytes, stat.getVersion)
|
||||
} catch {
|
||||
//todo: improved error messaged
|
||||
case e: KeeperException.NoNodeException ⇒ throw new MissingNodeException("Failed to load key", e)
|
||||
case e: KeeperException ⇒ throw new StorageException("failed to load key " + key, e)
|
||||
case e: KeeperException.NoNodeException ⇒ throw new MissingDataException(
|
||||
String.format("Failed to load key [%s]: no data was found", key), e)
|
||||
case e: KeeperException ⇒ throw new StorageException(
|
||||
String.format("Failed to load key [%s]", key), e)
|
||||
}
|
||||
|
||||
def load(key: String, version: Long) = {
|
||||
throw new UnsupportedOperationException()
|
||||
def load(key: String, expectedVersion: Long) = try {
|
||||
val stat = new Stat
|
||||
val arrayOfBytes = zkClient.connection.readData(key, stat, false)
|
||||
|
||||
if (stat.getVersion != expectedVersion) throw new VersioningException(
|
||||
"Failed to update key [" + key + "]: version mismatch, expected [" + expectedVersion + "]" +
|
||||
" but found [" + stat.getVersion + "]")
|
||||
|
||||
new VersionedData(arrayOfBytes, stat.getVersion)
|
||||
} catch {
|
||||
case e: KeeperException.NoNodeException ⇒ throw new MissingDataException(
|
||||
String.format("Failed to load key [%s]: no data was found", key), e)
|
||||
case e: KeeperException ⇒ throw new StorageException(
|
||||
String.format("Failed to load key [%s]", key), e)
|
||||
}
|
||||
|
||||
def insertOrOverwrite(key: String, bytes: Array[Byte]) = {
|
||||
try {
|
||||
throw new UnsupportedOperationException()
|
||||
} catch {
|
||||
case e: KeeperException.NodeExistsException ⇒ throw new DataExistsException(
|
||||
String.format("Failed to insert key [%s]: an entry already exists with the same key", key), e)
|
||||
case e: KeeperException ⇒ throw new StorageException(
|
||||
String.format("Failed to insert key [%s]", key), e)
|
||||
}
|
||||
}
|
||||
|
||||
def insert(key: String, bytes: Array[Byte]): VersionedData = {
|
||||
try {
|
||||
zkClient.connection.create(key, bytes, CreateMode.PERSISTENT);
|
||||
throw new UnsupportedOperationException()
|
||||
zkClient.connection.create(key, bytes, CreateMode.PERSISTENT)
|
||||
//todo: how to get hold of the reference.
|
||||
val version: Long = 0
|
||||
new VersionedData(bytes, version)
|
||||
} catch {
|
||||
//todo: improved error messaged
|
||||
case e: KeeperException.NodeExistsException ⇒ throw new NodeExistsException("failed to insert key " + key, e)
|
||||
case e: KeeperException ⇒ throw new StorageException("failed to insert key " + key, e)
|
||||
case e: KeeperException.NodeExistsException ⇒ throw new DataExistsException(
|
||||
String.format("Failed to insert key [%s]: an entry already exists with the same key", key), e)
|
||||
case e: KeeperException ⇒ throw new StorageException(
|
||||
String.format("Failed to insert key [%s]", key), e)
|
||||
}
|
||||
}
|
||||
|
||||
def exists(key: String) = try {
|
||||
zkClient.connection.exists(key, false)
|
||||
} catch {
|
||||
//todo: improved error messaged
|
||||
case e: KeeperException ⇒ throw new StorageException("failed to check for existance on key " + key, e)
|
||||
case e: KeeperException ⇒ throw new StorageException(
|
||||
String.format("Failed to check existance for key [%s]", key), e)
|
||||
}
|
||||
|
||||
def update(key: String, versionedData: VersionedData) = try {
|
||||
zkClient.connection.writeData(key, versionedData.data, versionedData.version.asInstanceOf[Int])
|
||||
} catch {
|
||||
//todo: improved error messaged
|
||||
case e: KeeperException.BadVersionException ⇒ throw new VersioningMismatchStorageException()
|
||||
case e: KeeperException ⇒ throw new StorageException("failed to check for existance on key " + key, e)
|
||||
def update(key: String, versionedData: VersionedData) {
|
||||
try {
|
||||
zkClient.connection.writeData(key, versionedData.data, versionedData.version.asInstanceOf[Int])
|
||||
} catch {
|
||||
case e: KeeperException.BadVersionException ⇒ throw new VersioningException(
|
||||
String.format("Failed to update key [%s]: version mismatch", key), e)
|
||||
case e: KeeperException ⇒ throw new StorageException(
|
||||
String.format("Failed to update key [%s]", key), e)
|
||||
}
|
||||
}
|
||||
|
||||
def update(key: String, bytes: Array[Byte]): VersionedData = {
|
||||
def overwrite(key: String, bytes: Array[Byte]): VersionedData = {
|
||||
try {
|
||||
zkClient.connection.writeData(key, bytes)
|
||||
throw new RuntimeException()
|
||||
} catch {
|
||||
//todo: improved error messaged
|
||||
case e: KeeperException.NoNodeException ⇒ throw new MissingNodeException("failed to update key ", e)
|
||||
case e: KeeperException ⇒ throw new StorageException("failed to update key ", e)
|
||||
case e: KeeperException.NoNodeException ⇒ throw new MissingDataException(
|
||||
String.format("Failed to overwrite key [%s]: a previous entry already exists", key), e)
|
||||
case e: KeeperException ⇒ throw new StorageException(
|
||||
String.format("Failed to overwrite key [%s]", key), e)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -188,8 +233,8 @@ final class InMemoryStorage extends Storage {
|
|||
def load(key: String) = {
|
||||
val result = map.get(key)
|
||||
|
||||
if (result == null) throw new MissingNodeException(
|
||||
String.format("Failed to load data for key [%s]: no data was found", key))
|
||||
if (result == null) throw new MissingDataException(
|
||||
String.format("Failed to load key [%s]: no data was found", key))
|
||||
|
||||
result
|
||||
}
|
||||
|
|
@ -197,8 +242,8 @@ final class InMemoryStorage extends Storage {
|
|||
def load(key: String, expectedVersion: Long) = {
|
||||
val result = load(key)
|
||||
|
||||
if (result.version != expectedVersion) throw new VersioningMismatchStorageException(
|
||||
"Failed to load data for key [" + key + "]: version mismatch, expected [" + result.version + "] " +
|
||||
if (result.version != expectedVersion) throw new VersioningException(
|
||||
"Failed to load key [" + key + "]: version mismatch, expected [" + result.version + "] " +
|
||||
"but found [" + expectedVersion + "]")
|
||||
|
||||
result
|
||||
|
|
@ -211,7 +256,7 @@ final class InMemoryStorage extends Storage {
|
|||
val result = new VersionedData(bytes, version)
|
||||
|
||||
val previous = map.putIfAbsent(key, result)
|
||||
if (previous != null) throw new NodeExistsException(
|
||||
if (previous != null) throw new DataExistsException(
|
||||
String.format("Failed to insert key [%s]: the key already has been inserted previously", key))
|
||||
|
||||
result
|
||||
|
|
@ -221,23 +266,36 @@ final class InMemoryStorage extends Storage {
|
|||
def update(key: String, updatedData: VersionedData) {
|
||||
val currentData = map.get(key)
|
||||
|
||||
if (currentData == null) throw new MissingNodeException(
|
||||
String.format("Failed to update data for key [%s], no previous entry exist", key))
|
||||
if (currentData == null) throw new MissingDataException(
|
||||
String.format("Failed to update key [%s], no previous entry exist", key))
|
||||
|
||||
val expectedVersion = currentData.version + 1
|
||||
if (expectedVersion != updatedData.version) throw new VersioningMismatchStorageException(
|
||||
"Failed to update data for key [" + key + "]: version mismatch, expected [" + expectedVersion + "]" +
|
||||
if (expectedVersion != updatedData.version) throw new VersioningException(
|
||||
"Failed to update key [" + key + "]: version mismatch, expected [" + expectedVersion + "]" +
|
||||
" but found [" + updatedData.version + "]")
|
||||
|
||||
if (!map.replace(key, currentData, updatedData)) update(key, updatedData)
|
||||
}
|
||||
|
||||
def update(key: String, bytes: Array[Byte]): VersionedData = {
|
||||
if (map.get(key) == null) throw new NoNodeException(
|
||||
String.format("Failed to update key [%s]: no previous insert of this key exists", key))
|
||||
@tailrec
|
||||
def overwrite(key: String, bytes: Array[Byte]): VersionedData = {
|
||||
val currentData = map.get(key)
|
||||
|
||||
//smap.put(key, bytes)
|
||||
throw new UnsupportedOperationException()
|
||||
if (currentData == null) throw new MissingDataException(
|
||||
String.format("Failed to overwrite key [%s], no previous entry exist", key))
|
||||
|
||||
val newData = currentData.createUpdate(bytes)
|
||||
if (map.replace(key, currentData, newData)) newData else overwrite(key, bytes)
|
||||
}
|
||||
|
||||
def insertOrOverwrite(key: String, bytes: Array[Byte]): VersionedData = {
|
||||
val version = InMemoryStorage.InitialVersion
|
||||
val result = new VersionedData(bytes, version)
|
||||
|
||||
val previous = map.putIfAbsent(key, result)
|
||||
|
||||
if (previous == null) result
|
||||
else overwrite(key, bytes)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ object PingPong {
|
|||
count += 1
|
||||
self reply Ball
|
||||
} else {
|
||||
self.sender.foreach(_ !! Stop)
|
||||
self.sender.foreach(s ⇒ (s ? Stop).await)
|
||||
gameOverLatch.countDown
|
||||
self.stop
|
||||
}
|
||||
|
|
|
|||
251
akka-cluster/src/test/scala/akka/cluster/InMemoryStorageSpec.scala
Executable file
251
akka-cluster/src/test/scala/akka/cluster/InMemoryStorageSpec.scala
Executable file
|
|
@ -0,0 +1,251 @@
|
|||
package akka.cluster
|
||||
|
||||
import org.scalatest.matchers.MustMatchers
|
||||
import org.scalatest.WordSpec
|
||||
import akka.cluster.StorageTestUtils._
|
||||
|
||||
class InMemoryStorageSpec extends WordSpec with MustMatchers {
|
||||
|
||||
"unversioned load" must {
|
||||
"throw MissingDataException if non existing key" in {
|
||||
val store = new InMemoryStorage()
|
||||
|
||||
try {
|
||||
store.load("foo")
|
||||
fail()
|
||||
} catch {
|
||||
case e: MissingDataException ⇒
|
||||
}
|
||||
}
|
||||
|
||||
"return VersionedData if key existing" in {
|
||||
val storage = new InMemoryStorage()
|
||||
val key = "somekey"
|
||||
val value = "somevalue".getBytes
|
||||
storage.insert(key, value)
|
||||
|
||||
val result = storage.load(key)
|
||||
//todo: strange that the implicit store is not found
|
||||
assertContent(key, value, result.version)(storage)
|
||||
}
|
||||
}
|
||||
|
||||
"exist" must {
|
||||
"return true if value exists" in {
|
||||
val store = new InMemoryStorage()
|
||||
val key = "somekey"
|
||||
store.insert(key, "somevalue".getBytes)
|
||||
store.exists(key) must be(true)
|
||||
}
|
||||
|
||||
"return false if value not exists" in {
|
||||
val store = new InMemoryStorage()
|
||||
store.exists("somekey") must be(false)
|
||||
}
|
||||
}
|
||||
|
||||
"versioned load" must {
|
||||
"throw MissingDataException if non existing key" in {
|
||||
val store = new InMemoryStorage()
|
||||
|
||||
try {
|
||||
store.load("foo", 1)
|
||||
fail()
|
||||
} catch {
|
||||
case e: MissingDataException ⇒
|
||||
}
|
||||
}
|
||||
|
||||
"return VersionedData if key existing and exact version match" in {
|
||||
val storage = new InMemoryStorage()
|
||||
val key = "somekey"
|
||||
val value = "somevalue".getBytes
|
||||
val stored = storage.insert(key, value)
|
||||
|
||||
val result = storage.load(key, stored.version)
|
||||
assert(result.version == stored.version)
|
||||
assert(result.data == stored.data)
|
||||
}
|
||||
|
||||
"throw VersioningException is version too new" in {
|
||||
val storage = new InMemoryStorage()
|
||||
val key = "somekey"
|
||||
val value = "somevalue".getBytes
|
||||
val stored = storage.insert(key, value)
|
||||
|
||||
try {
|
||||
storage.load(key, stored.version + 1)
|
||||
fail()
|
||||
} catch {
|
||||
case e: VersioningException ⇒
|
||||
}
|
||||
}
|
||||
|
||||
"throw VersioningException is version too old" in {
|
||||
val storage = new InMemoryStorage()
|
||||
val key = "somekey"
|
||||
val value = "somevalue".getBytes
|
||||
val stored = storage.insert(key, value)
|
||||
|
||||
try {
|
||||
storage.load(key, stored.version - 1)
|
||||
fail()
|
||||
} catch {
|
||||
case e: VersioningException ⇒
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
"insert" must {
|
||||
|
||||
"place a new value when non previously existed" in {
|
||||
val storage = new InMemoryStorage()
|
||||
val key = "somekey"
|
||||
val oldValue = "oldvalue".getBytes
|
||||
storage.insert(key, oldValue)
|
||||
|
||||
val result = storage.load(key)
|
||||
assertContent(key, oldValue)(storage)
|
||||
assert(InMemoryStorage.InitialVersion == result.version)
|
||||
}
|
||||
|
||||
"throw MissingDataException when there already exists an entry with the same key" in {
|
||||
val storage = new InMemoryStorage()
|
||||
val key = "somekey"
|
||||
val oldValue = "oldvalue".getBytes
|
||||
|
||||
val oldVersionedData = storage.insert(key, oldValue)
|
||||
|
||||
val newValue = "newValue".getBytes
|
||||
|
||||
try {
|
||||
storage.insert(key, newValue)
|
||||
fail()
|
||||
} catch {
|
||||
case e: DataExistsException ⇒
|
||||
}
|
||||
|
||||
//make sure that the old value was not changed
|
||||
assert(oldVersionedData == storage.load(key))
|
||||
}
|
||||
}
|
||||
|
||||
"update" must {
|
||||
|
||||
"throw MissingDataException when no node exists" in {
|
||||
val storage = new InMemoryStorage()
|
||||
|
||||
val key = "somekey"
|
||||
|
||||
try {
|
||||
storage.update(key, new VersionedData("somevalue".getBytes, 1))
|
||||
fail()
|
||||
} catch {
|
||||
case e: MissingDataException ⇒
|
||||
}
|
||||
}
|
||||
|
||||
"replace if previous value exists and no other updates have been done" in {
|
||||
val storage = new InMemoryStorage()
|
||||
|
||||
//do the initial insert
|
||||
val key = "foo"
|
||||
val oldValue = "insert".getBytes
|
||||
val insert = storage.insert(key, oldValue)
|
||||
|
||||
//do the update the will be the cause of the conflict.
|
||||
val updateValue = "update".getBytes
|
||||
val update = insert.createUpdate(updateValue)
|
||||
storage.update(key, update)
|
||||
|
||||
assertContent(key, update.data, update.version)(storage)
|
||||
}
|
||||
|
||||
"throw VersioningException when already overwritten" in {
|
||||
val storage = new InMemoryStorage()
|
||||
|
||||
//do the initial insert
|
||||
val key = "foo"
|
||||
val oldValue = "insert".getBytes
|
||||
val insert = storage.insert(key, oldValue)
|
||||
|
||||
//do the update the will be the cause of the conflict.
|
||||
val otherUpdateValue = "otherupdate".getBytes
|
||||
val otherUpdate = insert.createUpdate(otherUpdateValue)
|
||||
storage.update(key, otherUpdate)
|
||||
|
||||
val update = insert.createUpdate("update".getBytes)
|
||||
|
||||
try {
|
||||
storage.update(key, update)
|
||||
fail()
|
||||
} catch {
|
||||
case e: VersioningException ⇒
|
||||
}
|
||||
|
||||
assertContent(key, otherUpdate.data, otherUpdate.version)(storage)
|
||||
}
|
||||
}
|
||||
|
||||
"overwrite" must {
|
||||
|
||||
"throw MissingDataException when no node exists" in {
|
||||
val storage = new InMemoryStorage()
|
||||
val key = "somekey"
|
||||
|
||||
try {
|
||||
storage.overwrite(key, "somevalue".getBytes)
|
||||
fail()
|
||||
} catch {
|
||||
case e: MissingDataException ⇒
|
||||
}
|
||||
|
||||
storage.exists(key) must be(false)
|
||||
}
|
||||
|
||||
"succeed if previous value exist" in {
|
||||
val storage = new InMemoryStorage()
|
||||
val key = "somekey"
|
||||
val oldValue = "oldvalue".getBytes
|
||||
val newValue: Array[Byte] = "somevalue".getBytes
|
||||
|
||||
val initialInsert: VersionedData = storage.insert(key, oldValue)
|
||||
|
||||
val result: VersionedData = storage.overwrite(key, newValue)
|
||||
|
||||
assert(result.version == initialInsert.version + 1)
|
||||
assert(result.data == newValue)
|
||||
storage.load(key) must be eq (result)
|
||||
}
|
||||
}
|
||||
|
||||
"insertOrOverwrite" must {
|
||||
"insert if nothing was inserted before" in {
|
||||
val storage = new InMemoryStorage()
|
||||
val key = "somekey"
|
||||
val value = "somevalue".getBytes
|
||||
|
||||
val result = storage.insertOrOverwrite(key, value)
|
||||
|
||||
assert(result.version == InMemoryStorage.InitialVersion)
|
||||
assert(result.data == value)
|
||||
storage.load(key) must be eq (result)
|
||||
}
|
||||
|
||||
"overwrite of something existed before" in {
|
||||
val storage = new InMemoryStorage()
|
||||
val key = "somekey"
|
||||
val oldValue = "oldvalue".getBytes
|
||||
val newValue = "somevalue".getBytes
|
||||
|
||||
val initialInsert = storage.insert(key, oldValue)
|
||||
|
||||
val result = storage.insertOrOverwrite(key, newValue)
|
||||
|
||||
assert(result.version == initialInsert.version + 1)
|
||||
assert(result.data == newValue)
|
||||
storage.load(key) must be eq (result)
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,165 +0,0 @@
|
|||
package akka.cluster
|
||||
|
||||
import org.scalatest.matchers.MustMatchers
|
||||
import org.scalatest.WordSpec
|
||||
|
||||
class InMemoryStorageSpec extends WordSpec with MustMatchers {
|
||||
|
||||
"unversioned load" must {
|
||||
"throw MissingNodeException if non existing key" in {
|
||||
val store = new InMemoryStorage()
|
||||
|
||||
try {
|
||||
store.load("foo")
|
||||
fail()
|
||||
} catch {
|
||||
case e: MissingNodeException ⇒
|
||||
}
|
||||
}
|
||||
|
||||
"return VersionedData if key existing" in {
|
||||
val storage = new InMemoryStorage()
|
||||
val key = "somekey"
|
||||
val value = "somevalue".getBytes
|
||||
storage.insert(key, value)
|
||||
|
||||
val result = storage.load(key)
|
||||
//todo: strange that the implicit store is not found
|
||||
assertContent(key, value, result.version)(storage)
|
||||
}
|
||||
}
|
||||
|
||||
"exist" must {
|
||||
"return true if value exists" in {
|
||||
val store = new InMemoryStorage()
|
||||
val key = "somekey"
|
||||
store.insert(key, "somevalue".getBytes)
|
||||
store.exists(key) must be(true)
|
||||
}
|
||||
|
||||
"return false if value not exists" in {
|
||||
val store = new InMemoryStorage()
|
||||
store.exists("somekey") must be(false)
|
||||
}
|
||||
}
|
||||
|
||||
"versioned load" must {
|
||||
"throw MissingNodeException if non existing key" in {
|
||||
val store = new InMemoryStorage()
|
||||
|
||||
try {
|
||||
store.load("foo", 1)
|
||||
fail()
|
||||
} catch {
|
||||
case e: MissingNodeException ⇒
|
||||
}
|
||||
}
|
||||
|
||||
"return VersionedData if key existing and exact version match" in {
|
||||
val storage = new InMemoryStorage()
|
||||
val key = "somekey"
|
||||
val value = "somevalue".getBytes
|
||||
val stored = storage.insert(key, value)
|
||||
|
||||
val result = storage.load(key, stored.version)
|
||||
assert(result.version == stored.version)
|
||||
assert(result.data == stored.data)
|
||||
}
|
||||
|
||||
"throw VersioningMismatchStorageException is version too new" in {
|
||||
val storage = new InMemoryStorage()
|
||||
val key = "somekey"
|
||||
val value = "somevalue".getBytes
|
||||
val stored = storage.insert(key, value)
|
||||
|
||||
try {
|
||||
storage.load(key, stored.version + 1)
|
||||
fail()
|
||||
} catch {
|
||||
case e: VersioningMismatchStorageException ⇒
|
||||
}
|
||||
}
|
||||
|
||||
"throw VersioningMismatchStorageException is version too old" in {
|
||||
val storage = new InMemoryStorage()
|
||||
val key = "somekey"
|
||||
val value = "somevalue".getBytes
|
||||
val stored = storage.insert(key, value)
|
||||
|
||||
try {
|
||||
storage.load(key, stored.version - 1)
|
||||
fail()
|
||||
} catch {
|
||||
case e: VersioningMismatchStorageException ⇒
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
"insert" must {
|
||||
|
||||
"place a new value when non previously existed" in {
|
||||
val storage = new InMemoryStorage()
|
||||
val key = "somekey"
|
||||
val oldValue = "oldvalue".getBytes
|
||||
storage.insert(key, oldValue)
|
||||
|
||||
val result = storage.load(key)
|
||||
assertContent(key, oldValue)(storage)
|
||||
assert(InMemoryStorage.InitialVersion == result.version)
|
||||
}
|
||||
|
||||
"throw MissingNodeException when there already exists an entry with the same key" in {
|
||||
val storage = new InMemoryStorage()
|
||||
val key = "somekey"
|
||||
val oldValue = "oldvalue".getBytes
|
||||
|
||||
val oldVersionedData = storage.insert(key, oldValue)
|
||||
|
||||
val newValue = "newValue".getBytes
|
||||
|
||||
try {
|
||||
storage.insert(key, newValue)
|
||||
fail()
|
||||
} catch {
|
||||
case e: NodeExistsException ⇒
|
||||
}
|
||||
|
||||
//make sure that the old value was not changed
|
||||
assert(oldVersionedData == storage.load(key))
|
||||
}
|
||||
}
|
||||
|
||||
"update with versioning" must {
|
||||
|
||||
"throw NoNodeException when no node exists" in {
|
||||
val storage = new InMemoryStorage()
|
||||
|
||||
val key = "somekey"
|
||||
|
||||
try {
|
||||
storage.update(key, new VersionedData("somevalue".getBytes, 1))
|
||||
fail()
|
||||
} catch {
|
||||
case e: MissingNodeException ⇒
|
||||
}
|
||||
}
|
||||
|
||||
"throw OptimisticLockException when ..." in {
|
||||
|
||||
}
|
||||
|
||||
"replace" in {
|
||||
}
|
||||
}
|
||||
|
||||
def assertContent(key: String, expectedData: Array[Byte], expectedVersion: Long)(implicit storage: InMemoryStorage) {
|
||||
val found = storage.load(key)
|
||||
assert(found.version == expectedVersion)
|
||||
assert(expectedData == found.data) //todo: structural equals
|
||||
}
|
||||
|
||||
def assertContent(key: String, expectedData: Array[Byte])(implicit storage: InMemoryStorage) {
|
||||
val found = storage.load(key)
|
||||
assert(expectedData == found.data) //todo: structural equals
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
package akka.cluster
|
||||
|
||||
object StorageTestUtils {
|
||||
|
||||
def assertContent(key: String, expectedData: Array[Byte], expectedVersion: Long)(implicit storage: InMemoryStorage) {
|
||||
val found = storage.load(key)
|
||||
assert(found.version == expectedVersion)
|
||||
assert(expectedData == found.data) //todo: structural equals
|
||||
}
|
||||
|
||||
def assertContent(key: String, expectedData: Array[Byte])(implicit storage: InMemoryStorage) {
|
||||
val found = storage.load(key)
|
||||
assert(expectedData == found.data) //todo: structural equals
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
package akka.cluster
|
||||
|
||||
import org.scalatest.matchers.MustMatchers
|
||||
import akka.actor.Actor
|
||||
import org.scalatest.{ BeforeAndAfterEach, BeforeAndAfterAll, WordSpec }
|
||||
import org.I0Itec.zkclient.ZkServer
|
||||
import zookeeper.AkkaZkClient
|
||||
|
||||
class ZooKeeperStorageSpec extends WordSpec with MustMatchers with BeforeAndAfterAll with BeforeAndAfterEach {
|
||||
val dataPath = "_akka_cluster/data"
|
||||
val logPath = "_akka_cluster/log"
|
||||
var zkServer: ZkServer = _
|
||||
var zkClient: AkkaZkClient = _
|
||||
/*
|
||||
override def beforeAll() {
|
||||
try {
|
||||
zkServer = Cluster.startLocalCluster(dataPath, logPath)
|
||||
Thread.sleep(5000)
|
||||
Actor.cluster.start()
|
||||
zkClient = Cluster.newZkClient()
|
||||
} catch {
|
||||
case e ⇒ e.printStackTrace()
|
||||
}
|
||||
}
|
||||
|
||||
override def afterAll() {
|
||||
zkClient.close()
|
||||
Actor.cluster.shutdown()
|
||||
ClusterDeployer.shutdown()
|
||||
Cluster.shutdownLocalCluster()
|
||||
Actor.registry.local.shutdownAll()
|
||||
}
|
||||
*/
|
||||
"unversioned load" must {
|
||||
"throw MissingDataException if non existing key" in {
|
||||
// val store = new ZooKeeperStorage(zkClient)
|
||||
|
||||
//try {
|
||||
// store.load("foo")
|
||||
// fail()
|
||||
//} catch {
|
||||
// case e: MissingDataException ⇒
|
||||
//}
|
||||
}
|
||||
|
||||
/*
|
||||
"return VersionedData if key existing" in {
|
||||
val storage = new InMemoryStorage()
|
||||
val key = "somekey"
|
||||
val value = "somevalue".getBytes
|
||||
storage.insert(key, value)
|
||||
|
||||
val result = storage.load(key)
|
||||
//todo: strange that the implicit store is not found
|
||||
assertContent(key, value, result.version)(storage)
|
||||
} */
|
||||
}
|
||||
}
|
||||
|
|
@ -13,7 +13,7 @@ import BKException._
|
|||
|
||||
import akka.cluster._
|
||||
import akka.actor._
|
||||
import Actor._
|
||||
import akka.actor.Actor._
|
||||
import akka.config.Config
|
||||
|
||||
object RoundRobin1ReplicaMultiJvmSpec {
|
||||
|
|
@ -31,7 +31,7 @@ class RoundRobin1ReplicaMultiJvmNode1 extends WordSpec with MustMatchers with Be
|
|||
import RoundRobin1ReplicaMultiJvmSpec._
|
||||
|
||||
private var bookKeeper: BookKeeper = _
|
||||
private var localBookKeeper: LocalBookKeeper = _
|
||||
// private var localBookKeeper: LocalBookKeeper = _
|
||||
|
||||
"A cluster" must {
|
||||
|
||||
|
|
@ -55,13 +55,13 @@ class RoundRobin1ReplicaMultiJvmNode1 extends WordSpec with MustMatchers with Be
|
|||
|
||||
override def beforeAll() = {
|
||||
Cluster.startLocalCluster()
|
||||
LocalBookKeeperEnsemble.start()
|
||||
// LocalBookKeeperEnsemble.start()
|
||||
}
|
||||
|
||||
override def afterAll() = {
|
||||
Cluster.shutdownLocalCluster()
|
||||
TransactionLog.shutdown()
|
||||
LocalBookKeeperEnsemble.shutdown()
|
||||
// TransactionLog.shutdown()
|
||||
// LocalBookKeeperEnsemble.shutdown()
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -90,7 +90,7 @@ class RoundRobin1ReplicaMultiJvmNode2 extends WordSpec with MustMatchers {
|
|||
|
||||
Cluster.barrier("send-message-from-node2-to-node1", NrOfNodes) {
|
||||
hello must not equal (null)
|
||||
val reply = (hello !! "Hello").as[String].getOrElse(fail("Should have recieved reply from node1"))
|
||||
val reply = (hello ? "Hello").as[String].getOrElse(fail("Should have recieved reply from node1"))
|
||||
reply must equal("World from node [node1]")
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ import BKException._
|
|||
|
||||
import akka.cluster._
|
||||
import akka.actor._
|
||||
import Actor._
|
||||
import akka.actor.Actor._
|
||||
import akka.config.Config
|
||||
|
||||
object RoundRobin2ReplicasMultiJvmSpec {
|
||||
|
|
@ -102,14 +102,14 @@ class RoundRobin2ReplicasMultiJvmNode2 extends WordSpec with MustMatchers {
|
|||
else replies.put(reply, replies(reply) + 1)
|
||||
}
|
||||
|
||||
count((hello !! "Hello").as[String].getOrElse(fail("Should have recieved reply from node1")))
|
||||
count((hello !! "Hello").as[String].getOrElse(fail("Should have recieved reply from node3")))
|
||||
count((hello !! "Hello").as[String].getOrElse(fail("Should have recieved reply from node1")))
|
||||
count((hello !! "Hello").as[String].getOrElse(fail("Should have recieved reply from node3")))
|
||||
count((hello !! "Hello").as[String].getOrElse(fail("Should have recieved reply from node1")))
|
||||
count((hello !! "Hello").as[String].getOrElse(fail("Should have recieved reply from node3")))
|
||||
count((hello !! "Hello").as[String].getOrElse(fail("Should have recieved reply from node1")))
|
||||
count((hello !! "Hello").as[String].getOrElse(fail("Should have recieved reply from node3")))
|
||||
count((hello ? "Hello").as[String].getOrElse(fail("Should have recieved reply from node1")))
|
||||
count((hello ? "Hello").as[String].getOrElse(fail("Should have recieved reply from node3")))
|
||||
count((hello ? "Hello").as[String].getOrElse(fail("Should have recieved reply from node1")))
|
||||
count((hello ? "Hello").as[String].getOrElse(fail("Should have recieved reply from node3")))
|
||||
count((hello ? "Hello").as[String].getOrElse(fail("Should have recieved reply from node1")))
|
||||
count((hello ? "Hello").as[String].getOrElse(fail("Should have recieved reply from node3")))
|
||||
count((hello ? "Hello").as[String].getOrElse(fail("Should have recieved reply from node1")))
|
||||
count((hello ? "Hello").as[String].getOrElse(fail("Should have recieved reply from node3")))
|
||||
|
||||
replies("World from node [node1]") must equal(4)
|
||||
replies("World from node [node3]") must equal(4)
|
||||
|
|
|
|||
|
|
@ -18,8 +18,8 @@ in its mailbox.
|
|||
.. sidebar:: **IMPORTANT**
|
||||
|
||||
None of these mailboxes work with blocking message send, e.g. the message
|
||||
send operations that are relying on futures; ``!!``, ``!!!``,
|
||||
``sendRequestReply`` and ``sendRequestReplyFuture``. If the node has crashed
|
||||
send operations that are relying on futures; ``!!``, ``?``,
|
||||
``sendRequestReply`` and ``ask``. If the node has crashed
|
||||
and then restarted, the thread that was blocked waiting for the reply is gone
|
||||
and there is no way we can deliver the message.
|
||||
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ Here is the master actor:
|
|||
|
||||
A couple of things are worth explaining further.
|
||||
|
||||
First, we are passing in a ``java.util.concurrent.CountDownLatch`` to the ``Master`` actor. This latch is only used for plumbing (in this specific tutorial), to have a simple way of letting the outside world knowing when the master can deliver the result and shut down. In more idiomatic Akka code, as we will see in part two of this tutorial series, we would not use a latch but other abstractions and functions like ``Channel``, ``Future`` and ``!!!`` to achive the same thing in a non-blocking way. But for simplicity let's stick to a ``CountDownLatch`` for now.
|
||||
First, we are passing in a ``java.util.concurrent.CountDownLatch`` to the ``Master`` actor. This latch is only used for plumbing (in this specific tutorial), to have a simple way of letting the outside world knowing when the master can deliver the result and shut down. In more idiomatic Akka code, as we will see in part two of this tutorial series, we would not use a latch but other abstractions and functions like ``Channel``, ``Future`` and ``?`` to achive the same thing in a non-blocking way. But for simplicity let's stick to a ``CountDownLatch`` for now.
|
||||
|
||||
Second, we are adding a couple of life-cycle callback methods; ``preStart`` and ``postStop``. In the ``preStart`` callback we are recording the time when the actor is started and in the ``postStop`` callback we are printing out the result (the approximation of Pi) and the time it took to calculate it. In this call we also invoke ``latch.countDown`` to tell the outside world that we are done.
|
||||
|
||||
|
|
|
|||
|
|
@ -435,7 +435,7 @@ Here is the master actor::
|
|||
|
||||
A couple of things are worth explaining further.
|
||||
|
||||
First, we are passing in a ``java.util.concurrent.CountDownLatch`` to the ``Master`` actor. This latch is only used for plumbing (in this specific tutorial), to have a simple way of letting the outside world knowing when the master can deliver the result and shut down. In more idiomatic Akka code, as we will see in part two of this tutorial series, we would not use a latch but other abstractions and functions like ``Channel``, ``Future`` and ``!!!`` to achieve the same thing in a non-blocking way. But for simplicity let's stick to a ``CountDownLatch`` for now.
|
||||
First, we are passing in a ``java.util.concurrent.CountDownLatch`` to the ``Master`` actor. This latch is only used for plumbing (in this specific tutorial), to have a simple way of letting the outside world knowing when the master can deliver the result and shut down. In more idiomatic Akka code, as we will see in part two of this tutorial series, we would not use a latch but other abstractions and functions like ``Channel``, ``Future`` and ``?`` to achieve the same thing in a non-blocking way. But for simplicity let's stick to a ``CountDownLatch`` for now.
|
||||
|
||||
Second, we are adding a couple of life-cycle callback methods; ``preStart`` and ``postStop``. In the ``preStart`` callback we are recording the time when the actor is started and in the ``postStop`` callback we are printing out the result (the approximation of Pi) and the time it took to calculate it. In this call we also invoke ``latch.countDown()`` to tell the outside world that we are done.
|
||||
|
||||
|
|
|
|||
|
|
@ -335,7 +335,7 @@ Here is the master actor::
|
|||
|
||||
A couple of things are worth explaining further.
|
||||
|
||||
First, we are passing in a ``java.util.concurrent.CountDownLatch`` to the ``Master`` actor. This latch is only used for plumbing (in this specific tutorial), to have a simple way of letting the outside world knowing when the master can deliver the result and shut down. In more idiomatic Akka code, as we will see in part two of this tutorial series, we would not use a latch but other abstractions and functions like ``Channel``, ``Future`` and ``!!!`` to achieve the same thing in a non-blocking way. But for simplicity let's stick to a ``CountDownLatch`` for now.
|
||||
First, we are passing in a ``java.util.concurrent.CountDownLatch`` to the ``Master`` actor. This latch is only used for plumbing (in this specific tutorial), to have a simple way of letting the outside world knowing when the master can deliver the result and shut down. In more idiomatic Akka code, as we will see in part two of this tutorial series, we would not use a latch but other abstractions and functions like ``Channel``, ``Future`` and ``?`` to achieve the same thing in a non-blocking way. But for simplicity let's stick to a ``CountDownLatch`` for now.
|
||||
|
||||
Second, we are adding a couple of life-cycle callback methods; ``preStart`` and ``postStop``. In the ``preStart`` callback we are recording the time when the actor is started and in the ``postStop`` callback we are printing out the result (the approximation of Pi) and the time it took to calculate it. In this call we also invoke ``latch.countDown`` to tell the outside world that we are done.
|
||||
|
||||
|
|
|
|||
|
|
@ -329,7 +329,7 @@ Here is the master actor::
|
|||
|
||||
A couple of things are worth explaining further.
|
||||
|
||||
First, we are passing in a ``java.util.concurrent.CountDownLatch`` to the ``Master`` actor. This latch is only used for plumbing (in this specific tutorial), to have a simple way of letting the outside world knowing when the master can deliver the result and shut down. In more idiomatic Akka code, as we will see in part two of this tutorial series, we would not use a latch but other abstractions and functions like ``Channel``, ``Future`` and ``!!!`` to achieve the same thing in a non-blocking way. But for simplicity let's stick to a ``CountDownLatch`` for now.
|
||||
First, we are passing in a ``java.util.concurrent.CountDownLatch`` to the ``Master`` actor. This latch is only used for plumbing (in this specific tutorial), to have a simple way of letting the outside world knowing when the master can deliver the result and shut down. In more idiomatic Akka code, as we will see in part two of this tutorial series, we would not use a latch but other abstractions and functions like ``Channel``, ``Future`` and ``?`` to achieve the same thing in a non-blocking way. But for simplicity let's stick to a ``CountDownLatch`` for now.
|
||||
|
||||
Second, we are adding a couple of life-cycle callback methods; ``preStart`` and ``postStop``. In the ``preStart`` callback we are recording the time when the actor is started and in the ``postStop`` callback we are printing out the result (the approximation of Pi) and the time it took to calculate it. In this call we also invoke ``latch.countDown`` to tell the outside world that we are done.
|
||||
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ The Dispatcher is an important piece that allows you to configure the right sema
|
|||
|
||||
Akka supports dispatchers for both event-driven lightweight threads, allowing creation of millions threads on a single workstation, and thread-based Actors, where each dispatcher is bound to a dedicated OS thread.
|
||||
|
||||
The event-based Actors currently consume ~600 bytes per Actor which means that you can create more than 6.5 million Actors on 4 G RAM.
|
||||
The event-based Actors currently consume ~600 bytes per Actor which means that you can create more than 6.5 million Actors on 4 GB RAM.
|
||||
|
||||
Default dispatcher
|
||||
------------------
|
||||
|
|
@ -84,6 +84,7 @@ The 'Dispatcher' binds a set of Actors to a thread pool backed up by a 'Blocking
|
|||
The event-driven dispatchers **must be shared** between multiple Typed Actors and/or Actors. One best practice is to let each top-level Actor, e.g. the Actors you define in the declarative supervisor config, to get their own dispatcher but reuse the dispatcher for each new Actor that the top-level Actor creates. But you can also share dispatcher between multiple top-level Actors. This is very use-case specific and needs to be tried out on a case by case basis. The important thing is that Akka tries to provide you with the freedom you need to design and implement your system in the most efficient way in regards to performance, throughput and latency.
|
||||
|
||||
It comes with many different predefined BlockingQueue configurations:
|
||||
|
||||
* Bounded LinkedBlockingQueue
|
||||
* Unbounded LinkedBlockingQueue
|
||||
* Bounded ArrayBlockingQueue
|
||||
|
|
|
|||
|
|
@ -17,11 +17,11 @@ Use with Actors
|
|||
|
||||
There are generally two ways of getting a reply from an ``UntypedActor``: the first is by a sent message (``actorRef.sendOneWay(msg);``), which only works if the original sender was an ``UntypedActor``) and the second is through a ``Future``.
|
||||
|
||||
Using the ``ActorRef``\'s ``sendRequestReplyFuture`` method to send a message will return a Future. To wait for and retrieve the actual result the simplest method is:
|
||||
Using the ``ActorRef``\'s ``ask`` method to send a message will return a Future. To wait for and retrieve the actual result the simplest method is:
|
||||
|
||||
.. code-block:: java
|
||||
|
||||
Future[Object] future = actorRef.sendRequestReplyFuture[Object](msg);
|
||||
Future[Object] future = actorRef.ask[Object](msg);
|
||||
Object result = future.get(); //Block until result is available, usually bad practice
|
||||
|
||||
This will cause the current thread to block and wait for the ``UntypedActor`` to 'complete' the ``Future`` with it's reply. Due to the dynamic nature of Akka's ``UntypedActor``\s this result can be anything. The safest way to deal with this is to specify the result to an ``Object`` as is shown in the above example. You can also use the expected result type instead of ``Any``, but if an unexpected type were to be returned you will get a ``ClassCastException``. For more elegant ways to deal with this and to use the result without blocking, refer to `Functional Futures`_.
|
||||
|
|
|
|||
|
|
@ -115,6 +115,7 @@ Methods that return something (e.g. non-void methods) are turned into ‘send-an
|
|||
User user = service.getUser(username);
|
||||
|
||||
Generally it is preferred to use fire-forget messages as much as possible since they will never block, e.g. consume a resource by waiting. But sometimes they are neat to use since they:
|
||||
|
||||
# Simulates standard Java method dispatch, which is more intuitive for most Java developers
|
||||
# Are a neat to model request-reply
|
||||
# Are useful when you need to do things in a defined order
|
||||
|
|
|
|||
|
|
@ -109,7 +109,7 @@ Send messages
|
|||
Messages are sent to an Actor through one of the 'send' methods.
|
||||
* 'sendOneWay' means “fire-and-forget”, e.g. send a message asynchronously and return immediately.
|
||||
* 'sendRequestReply' means “send-and-reply-eventually”, e.g. send a message asynchronously and wait for a reply through a Future. Here you can specify a timeout. Using timeouts is very important. If no timeout is specified then the actor’s default timeout (set by the 'getContext().setTimeout(..)' method in the 'ActorRef') is used. This method throws an 'ActorTimeoutException' if the call timed out.
|
||||
* 'sendRequestReplyFuture' sends a message asynchronously and returns a 'Future'.
|
||||
* 'ask' sends a message asynchronously and returns a 'Future'.
|
||||
|
||||
In all these methods you have the option of passing along your 'ActorRef' context variable. Make it a practice of doing so because it will allow the receiver actors to be able to respond to your message, since the sender reference is sent along with the message.
|
||||
|
||||
|
|
@ -158,11 +158,11 @@ Here are some examples:
|
|||
Send-And-Receive-Future
|
||||
^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
Using 'sendRequestReplyFuture' will send a message to the receiving Actor asynchronously and will immediately return a 'Future'.
|
||||
Using 'ask' will send a message to the receiving Actor asynchronously and will immediately return a 'Future'.
|
||||
|
||||
.. code-block:: java
|
||||
|
||||
Future future = actorRef.sendRequestReplyFuture("Hello", getContext(), 1000);
|
||||
Future future = actorRef.ask("Hello", getContext(), 1000);
|
||||
|
||||
The 'Future' interface looks like this:
|
||||
|
||||
|
|
@ -182,7 +182,7 @@ So the normal way of working with futures is something like this:
|
|||
|
||||
.. code-block:: java
|
||||
|
||||
Future future = actorRef.sendRequestReplyFuture("Hello", getContext(), 1000);
|
||||
Future future = actorRef.ask("Hello", getContext(), 1000);
|
||||
future.await();
|
||||
if (future.isCompleted()) {
|
||||
Option resultOption = future.result();
|
||||
|
|
@ -305,7 +305,7 @@ On this 'Option' you can invoke 'boolean isDefined()' or 'boolean isEmpty()' to
|
|||
Reply using the sender future
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
If a message was sent with the 'sendRequestReply' or 'sendRequestReplyFuture' methods, which both implements request-reply semantics using Future's, then you either have the option of replying using the 'reply' method as above. This method will then resolve the Future. But you can also get a reference to the Future directly and resolve it yourself or if you would like to store it away to resolve it later, or pass it on to some other Actor to resolve it.
|
||||
If a message was sent with the 'sendRequestReply' or 'ask' methods, which both implements request-reply semantics using Future's, then you either have the option of replying using the 'reply' method as above. This method will then resolve the Future. But you can also get a reference to the Future directly and resolve it yourself or if you would like to store it away to resolve it later, or pass it on to some other Actor to resolve it.
|
||||
|
||||
The reference to the Future resides in the 'ActorRef' instance and can be retrieved using 'Option<Promise> getSenderFuture()'.
|
||||
|
||||
|
|
|
|||
|
|
@ -524,7 +524,7 @@ Release 0.6 - January 5th 2010
|
|||
- **ADD** - New and much improved docs (Jonas Bonér)
|
||||
- **ADD** - Enhanced trapping of failures: 'trapExit = List(classOf[..], classOf[..])' (Jonas Bonér)
|
||||
- **ADD** - Upgraded to Netty 3.2, Protobuf 2.2, ScalaTest 1.0, Jersey 1.1.3, Atmosphere 0.4.1, Cassandra 0.4.1, Configgy 1.4 (Jonas Bonér)
|
||||
- **FIX** - Lowered actor memory footprint; now an actor consumes ~600 bytes, which mean that you can create 6.5 million on 4 G RAM (Jonas Bonér)
|
||||
- **FIX** - Lowered actor memory footprint; now an actor consumes ~600 bytes, which mean that you can create 6.5 million on 4 GB RAM (Jonas Bonér)
|
||||
- **FIX** - Remote actors are now defined by their UUID (not class name) (Jonas Bonér)
|
||||
- **FIX** - Fixed dispatcher bugs (Jonas Bonér)
|
||||
- **FIX** - Cleaned up Maven scripts and distribution in general (Jonas Bonér)
|
||||
|
|
|
|||
|
|
@ -126,7 +126,7 @@ Messages are sent to an Actor through one of the “bang” methods.
|
|||
|
||||
* ! means “fire-and-forget”, e.g. send a message asynchronously and return immediately.
|
||||
* !! means “send-and-reply-eventually”, e.g. send a message asynchronously and wait for a reply through aFuture. Here you can specify a timeout. Using timeouts is very important. If no timeout is specified then the actor’s default timeout (set by the this.timeout variable in the actor) is used. This method returns an ``Option[Any]`` which will be either ``Some(result)`` if returning successfully or None if the call timed out.
|
||||
* !!! sends a message asynchronously and returns a ``Future``.
|
||||
* ? sends a message asynchronously and returns a ``Future``.
|
||||
|
||||
You can check if an Actor can handle a specific message by invoking the ``isDefinedAt`` method:
|
||||
|
||||
|
|
@ -180,11 +180,11 @@ Here are some examples:
|
|||
Send-And-Receive-Future
|
||||
^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
Using ``!!!`` will send a message to the receiving Actor asynchronously and will return a 'Future':
|
||||
Using ``?`` will send a message to the receiving Actor asynchronously and will return a 'Future':
|
||||
|
||||
.. code-block:: scala
|
||||
|
||||
val future = actor !!! "Hello"
|
||||
val future = actor ? "Hello"
|
||||
|
||||
See :ref:`futures-scala` for more information.
|
||||
|
||||
|
|
@ -329,7 +329,7 @@ The same pattern holds for using the ``senderFuture`` in the section below.
|
|||
Reply using the sender future
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
If a message was sent with the ``!!`` or ``!!!`` methods, which both implements request-reply semantics using Future's, then you either have the option of replying using the ``reply`` method as above. This method will then resolve the Future. But you can also get a reference to the Future directly and resolve it yourself or if you would like to store it away to resolve it later, or pass it on to some other Actor to resolve it.
|
||||
If a message was sent with the ``!!`` or ``?`` methods, which both implements request-reply semantics using Future's, then you either have the option of replying using the ``reply`` method as above. This method will then resolve the Future. But you can also get a reference to the Future directly and resolve it yourself or if you would like to store it away to resolve it later, or pass it on to some other Actor to resolve it.
|
||||
|
||||
The reference to the Future resides in the ``senderFuture: Option[Promise[_]]`` member field in the ``ActorRef`` class.
|
||||
|
||||
|
|
@ -427,7 +427,7 @@ PoisonPill
|
|||
|
||||
You can also send an actor the ``akka.actor.PoisonPill`` message, which will stop the actor when the message is processed.
|
||||
|
||||
If the sender is a ``Future`` (e.g. the message is sent with ``!!`` or ``!!!``), the ``Future`` will be completed with an ``akka.actor.ActorKilledException("PoisonPill")``.
|
||||
If the sender is a ``Future`` (e.g. the message is sent with ``!!`` or ``?``), the ``Future`` will be completed with an ``akka.actor.ActorKilledException("PoisonPill")``.
|
||||
|
||||
HotSwap
|
||||
-------
|
||||
|
|
@ -457,7 +457,7 @@ To hotswap the Actor using ``become``:
|
|||
.. code-block:: scala
|
||||
|
||||
def angry: Receive = {
|
||||
case "foo" => self reply "I am already angry!!!"
|
||||
case "foo" => self reply "I am already angry?"
|
||||
case "bar" => become(happy)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ The Dispatcher is an important piece that allows you to configure the right sema
|
|||
|
||||
Akka supports dispatchers for both event-driven lightweight threads, allowing creation of millions of threads on a single workstation, and thread-based Actors, where each dispatcher is bound to a dedicated OS thread.
|
||||
|
||||
The event-based Actors currently consume ~600 bytes per Actor which means that you can create more than 6.5 million Actors on 4 G RAM.
|
||||
The event-based Actors currently consume ~600 bytes per Actor which means that you can create more than 6.5 million Actors on 4 GB RAM.
|
||||
|
||||
Default dispatcher
|
||||
------------------
|
||||
|
|
|
|||
|
|
@ -17,11 +17,11 @@ Use with Actors
|
|||
|
||||
There are generally two ways of getting a reply from an ``Actor``: the first is by a sent message (``actor ! msg``), which only works if the original sender was an ``Actor``) and the second is through a ``Future``.
|
||||
|
||||
Using an ``Actor``\'s ``!!!`` method to send a message will return a Future. To wait for and retrieve the actual result the simplest method is:
|
||||
Using an ``Actor``\'s ``?`` method to send a message will return a Future. To wait for and retrieve the actual result the simplest method is:
|
||||
|
||||
.. code-block:: scala
|
||||
|
||||
val future = actor !!! msg
|
||||
val future = actor ? msg
|
||||
val result: Any = future.get()
|
||||
|
||||
This will cause the current thread to block and wait for the ``Actor`` to 'complete' the ``Future`` with it's reply. Due to the dynamic nature of Akka's ``Actor``\s this result will be untyped and will default to ``Nothing``. The safest way to deal with this is to cast the result to an ``Any`` as is shown in the above example. You can also use the expected result type instead of ``Any``, but if an unexpected type were to be returned you will get a ``ClassCastException``. For more elegant ways to deal with this and to use the result without blocking, refer to `Functional Futures`_.
|
||||
|
|
@ -141,13 +141,13 @@ The example for comprehension above is an example of composing ``Future``\s. A c
|
|||
|
||||
.. code-block:: scala
|
||||
|
||||
val f1 = actor1 !!! msg1
|
||||
val f2 = actor2 !!! msg2
|
||||
val f1 = actor1 ? msg1
|
||||
val f2 = actor2 ? msg2
|
||||
|
||||
val a: Int = f1.get()
|
||||
val b: Int = f2.get()
|
||||
|
||||
val f3 = actor3 !!! (a + b)
|
||||
val f3 = actor3 ? (a + b)
|
||||
|
||||
val result: String = f3.get()
|
||||
|
||||
|
|
@ -155,13 +155,13 @@ Here we wait for the results from the first 2 ``Actor``\s before sending that re
|
|||
|
||||
.. code-block:: scala
|
||||
|
||||
val f1 = actor1 !!! msg1
|
||||
val f2 = actor2 !!! msg2
|
||||
val f1 = actor1 ? msg1
|
||||
val f2 = actor2 ? msg2
|
||||
|
||||
val f3 = for {
|
||||
a: Int <- f1
|
||||
b: Int <- f2
|
||||
c: String <- actor3 !!! (a + b)
|
||||
c: String <- actor3 ? (a + b)
|
||||
} yield c
|
||||
|
||||
val result = f3.get()
|
||||
|
|
@ -173,7 +173,7 @@ This is fine when dealing with a known amount of Actors, but can grow unwieldy i
|
|||
.. code-block:: scala
|
||||
|
||||
// oddActor returns odd numbers sequentially from 1
|
||||
val listOfFutures: List[Future[Int]] = List.fill(100)(oddActor !!! GetNext)
|
||||
val listOfFutures: List[Future[Int]] = List.fill(100)(oddActor ? GetNext)
|
||||
|
||||
// now we have a Future[List[Int]]
|
||||
val futureList = Future.sequence(listOfFutures)
|
||||
|
|
@ -242,7 +242,7 @@ It is also possible to handle an ``Exception`` by returning a different result.
|
|||
|
||||
.. code-block:: scala
|
||||
|
||||
val future = actor !!! msg1 recover {
|
||||
val future = actor ? msg1 recover {
|
||||
case e: ArithmeticException => 0
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ The 'actorOf' factory method can be imported like this:
|
|||
|
||||
From now on we will assume that it is imported like this and can use it directly.
|
||||
|
||||
Akka Actors are extremely lightweight. Each Actor consume ~600 bytes, which means that you can create 6.5 million on 4 G RAM.
|
||||
Akka Actors are extremely lightweight. Each Actor consume ~600 bytes, which means that you can create 6.5 million on 4 GB RAM.
|
||||
|
||||
Messages are sent using the '!' operator:
|
||||
|
||||
|
|
|
|||
|
|
@ -323,7 +323,7 @@ public final class MailboxProtocol {
|
|||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
||||
private Builder(BuilderParent parent) {
|
||||
private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
|
||||
super(parent);
|
||||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
|
@ -925,7 +925,7 @@ public final class MailboxProtocol {
|
|||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
||||
private Builder(BuilderParent parent) {
|
||||
private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
|
||||
super(parent);
|
||||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -94,8 +94,8 @@ case class DurableDispatcher(
|
|||
override def createMailbox(actorRef: ActorRef): AnyRef = _storage.createFor(actorRef)
|
||||
|
||||
private[akka] override def dispatch(invocation: MessageInvocation): Unit = {
|
||||
if (invocation.senderFuture.isDefined)
|
||||
throw new IllegalArgumentException("Durable mailboxes do not support Future-based messages from !! and !!!")
|
||||
if (invocation.channel.isInstanceOf[ActorPromise])
|
||||
throw new IllegalArgumentException("Durable mailboxes do not support Future-based messages from ?")
|
||||
super.dispatch(invocation)
|
||||
}
|
||||
|
||||
|
|
@ -131,8 +131,8 @@ case class DurablePinnedDispatcher(
|
|||
override def createMailbox(actorRef: ActorRef): AnyRef = _storage.createFor(actorRef)
|
||||
|
||||
private[akka] override def dispatch(invocation: MessageInvocation): Unit = {
|
||||
if (invocation.senderFuture.isDefined)
|
||||
throw new IllegalArgumentException("Actor has a durable mailbox that does not support !! or !!!")
|
||||
if (invocation.channel.isInstanceOf[ActorPromise])
|
||||
throw new IllegalArgumentException("Actor has a durable mailbox that does not support ?")
|
||||
super.dispatch(invocation)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ package akka.actor.mailbox
|
|||
|
||||
import MailboxProtocol._
|
||||
|
||||
import akka.actor.{Actor, ActorRef}
|
||||
import akka.actor.{Actor, ActorRef, NullChannel}
|
||||
import akka.dispatch._
|
||||
import akka.event.EventHandler
|
||||
import akka.remote.MessageSerializer
|
||||
|
|
@ -48,7 +48,10 @@ abstract class DurableExecutableMailbox(owner: ActorRef) extends MessageQueue wi
|
|||
val builder = DurableMailboxMessageProtocol.newBuilder
|
||||
.setOwnerAddress(ownerAddress)
|
||||
.setMessage(message.toByteString)
|
||||
if (durableMessage.sender.isDefined) builder.setSenderAddress(durableMessage.sender.get.address)
|
||||
durableMessage.channel match {
|
||||
case a : ActorRef => builder.setSenderAddress(a.address)
|
||||
case _ =>
|
||||
}
|
||||
builder.build.toByteArray
|
||||
}
|
||||
|
||||
|
|
@ -62,10 +65,14 @@ abstract class DurableExecutableMailbox(owner: ActorRef) extends MessageQueue wi
|
|||
throw new DurableMailboxException("No actor could be found for address [" + ownerAddress + "], could not deserialize message."))
|
||||
|
||||
|
||||
val sender = if (durableMessage.hasSenderAddress) {
|
||||
val senderOption = if (durableMessage.hasSenderAddress) {
|
||||
Actor.registry.actorFor(durableMessage.getSenderAddress)
|
||||
} else None
|
||||
val sender = senderOption match {
|
||||
case Some(ref) => ref
|
||||
case None => NullChannel
|
||||
}
|
||||
|
||||
new MessageInvocation(owner, message, sender, None)
|
||||
new MessageInvocation(owner, message, sender)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -594,7 +594,7 @@ public final class RemoteProtocol {
|
|||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
||||
private Builder(BuilderParent parent) {
|
||||
private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
|
||||
super(parent);
|
||||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
|
@ -1388,7 +1388,7 @@ public final class RemoteProtocol {
|
|||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
||||
private Builder(BuilderParent parent) {
|
||||
private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
|
||||
super(parent);
|
||||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
|
@ -2760,7 +2760,7 @@ public final class RemoteProtocol {
|
|||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
||||
private Builder(BuilderParent parent) {
|
||||
private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
|
||||
super(parent);
|
||||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
|
@ -3235,7 +3235,7 @@ public final class RemoteProtocol {
|
|||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
||||
private Builder(BuilderParent parent) {
|
||||
private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
|
||||
super(parent);
|
||||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
|
@ -4062,7 +4062,7 @@ public final class RemoteProtocol {
|
|||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
||||
private Builder(BuilderParent parent) {
|
||||
private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
|
||||
super(parent);
|
||||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
|
@ -5428,7 +5428,7 @@ public final class RemoteProtocol {
|
|||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
||||
private Builder(BuilderParent parent) {
|
||||
private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
|
||||
super(parent);
|
||||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
|
@ -5936,7 +5936,7 @@ public final class RemoteProtocol {
|
|||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
||||
private Builder(BuilderParent parent) {
|
||||
private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
|
||||
super(parent);
|
||||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
|
@ -6401,7 +6401,7 @@ public final class RemoteProtocol {
|
|||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
||||
private Builder(BuilderParent parent) {
|
||||
private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
|
||||
super(parent);
|
||||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
|
@ -6948,7 +6948,7 @@ public final class RemoteProtocol {
|
|||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
||||
private Builder(BuilderParent parent) {
|
||||
private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
|
||||
super(parent);
|
||||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
|
@ -7381,7 +7381,7 @@ public final class RemoteProtocol {
|
|||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
||||
private Builder(BuilderParent parent) {
|
||||
private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
|
||||
super(parent);
|
||||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
|
@ -7784,7 +7784,7 @@ public final class RemoteProtocol {
|
|||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
||||
private Builder(BuilderParent parent) {
|
||||
private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
|
||||
super(parent);
|
||||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
|
@ -8187,7 +8187,7 @@ public final class RemoteProtocol {
|
|||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
||||
private Builder(BuilderParent parent) {
|
||||
private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
|
||||
super(parent);
|
||||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
|
@ -8657,7 +8657,7 @@ public final class RemoteProtocol {
|
|||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
||||
private Builder(BuilderParent parent) {
|
||||
private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
|
||||
super(parent);
|
||||
maybeForceBuilderInitialization();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
package akka.remote.netty
|
||||
|
||||
import akka.dispatch.{ DefaultPromise, Promise, Future }
|
||||
import akka.dispatch.{ ActorPromise, DefaultPromise, Promise, Future }
|
||||
import akka.remote.{ MessageSerializer, RemoteClientSettings, RemoteServerSettings }
|
||||
import akka.remote.protocol.RemoteProtocol._
|
||||
import akka.serialization.RemoteActorSerialization
|
||||
|
|
@ -917,8 +917,7 @@ class RemoteServerHandler(
|
|||
else actorRef.postMessageToMailboxAndCreateFutureResultWithTimeout(
|
||||
message,
|
||||
request.getActorInfo.getTimeout,
|
||||
None,
|
||||
Some(new DefaultPromise[Any](request.getActorInfo.getTimeout).
|
||||
new ActorPromise(request.getActorInfo.getTimeout).
|
||||
onComplete(_.value.get match {
|
||||
case l: Left[Throwable, Any] ⇒ write(channel, createErrorReplyMessage(l.a, request))
|
||||
case r: Right[Throwable, Any] ⇒
|
||||
|
|
@ -935,7 +934,7 @@ class RemoteServerHandler(
|
|||
if (request.hasSupervisorUuid) messageBuilder.setSupervisorUuid(request.getSupervisorUuid)
|
||||
|
||||
write(channel, RemoteEncoder.encode(messageBuilder.build))
|
||||
})))
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -3,8 +3,8 @@
|
|||
*/
|
||||
package sample.osgi
|
||||
|
||||
import akka.actor.{ Actor, ActorRegistry }
|
||||
import Actor._
|
||||
import akka.actor.Actor
|
||||
import akka.actor.Actor._
|
||||
|
||||
import org.osgi.framework.{ BundleActivator, BundleContext }
|
||||
|
||||
|
|
@ -13,7 +13,7 @@ class Activator extends BundleActivator {
|
|||
def start(context: BundleContext) {
|
||||
println("Starting the OSGi example ...")
|
||||
val echo = actorOf[EchoActor].start()
|
||||
val answer = (echo !! "OSGi example")
|
||||
val answer = (echo ? "OSGi example").as[String]
|
||||
println(answer getOrElse "No answer!")
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -25,8 +25,8 @@ akka {
|
|||
|
||||
actor {
|
||||
timeout = 2000 # Default timeout for Future based invocations
|
||||
# - Actor: !! && !!!
|
||||
# - UntypedActor: sendRequestReply && sendRequestReplyFuture
|
||||
# - Actor: !! && ?
|
||||
# - UntypedActor: sendRequestReply && ask
|
||||
# - TypedActor: methods with non-void return type
|
||||
serialize-messages = off # Does a deep clone of (non-primitive) messages to ensure immutability
|
||||
throughput = 5 # Default throughput for all ExecutorBasedEventDrivenDispatcher, set to 1 for complete fairness
|
||||
|
|
|
|||
|
|
@ -120,7 +120,7 @@ class Agent[T](initialValue: T) {
|
|||
* within the given timeout
|
||||
*/
|
||||
def alter(f: T ⇒ T)(timeout: Long): Future[T] = {
|
||||
def dispatch = updater.!!!(Update(f), timeout)
|
||||
def dispatch = updater.?(Update(f), timeout).asInstanceOf[Future[T]]
|
||||
if (Stm.activeTransaction) {
|
||||
val result = new DefaultPromise[T](timeout)
|
||||
get //Join xa
|
||||
|
|
@ -168,7 +168,7 @@ class Agent[T](initialValue: T) {
|
|||
send((value: T) ⇒ {
|
||||
suspend
|
||||
val threadBased = Actor.actorOf(new ThreadBasedAgentUpdater(this)).start()
|
||||
result completeWith threadBased.!!!(Update(f), timeout)
|
||||
result completeWith threadBased.?(Update(f), timeout).asInstanceOf[Future[T]]
|
||||
value
|
||||
})
|
||||
result
|
||||
|
|
@ -178,7 +178,7 @@ class Agent[T](initialValue: T) {
|
|||
* A future to the current value that will be completed after any currently
|
||||
* queued updates.
|
||||
*/
|
||||
def future(): Future[T] = (updater !!! Get).asInstanceOf[Future[T]]
|
||||
def future(): Future[T] = (updater ? Get).asInstanceOf[Future[T]]
|
||||
|
||||
/**
|
||||
* Gets this agent's value after all currently queued updates have completed.
|
||||
|
|
|
|||
|
|
@ -19,8 +19,8 @@ public class UntypedCoordinatedExample {
|
|||
|
||||
Thread.sleep(3000);
|
||||
|
||||
Future future1 = counter1.sendRequestReplyFuture("GetCount");
|
||||
Future future2 = counter2.sendRequestReplyFuture("GetCount");
|
||||
Future future1 = counter1.ask("GetCount");
|
||||
Future future2 = counter2.ask("GetCount");
|
||||
|
||||
future1.await();
|
||||
if (future1.isCompleted()) {
|
||||
|
|
|
|||
|
|
@ -18,8 +18,8 @@ public class UntypedTransactorExample {
|
|||
|
||||
Thread.sleep(3000);
|
||||
|
||||
Future future1 = counter1.sendRequestReplyFuture("GetCount");
|
||||
Future future2 = counter2.sendRequestReplyFuture("GetCount");
|
||||
Future future1 = counter1.ask("GetCount");
|
||||
Future future2 = counter2.ask("GetCount");
|
||||
|
||||
future1.await();
|
||||
if (future1.isCompleted()) {
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ public class UntypedCoordinatedIncrementTest {
|
|||
incrementLatch.await(timeout, TimeUnit.SECONDS);
|
||||
} catch (InterruptedException exception) {}
|
||||
for (ActorRef counter : counters) {
|
||||
Future future = counter.sendRequestReplyFuture("GetCount");
|
||||
Future future = counter.ask("GetCount");
|
||||
future.await();
|
||||
if (future.isCompleted()) {
|
||||
Option resultOption = future.result();
|
||||
|
|
@ -72,7 +72,7 @@ public class UntypedCoordinatedIncrementTest {
|
|||
incrementLatch.await(timeout, TimeUnit.SECONDS);
|
||||
} catch (InterruptedException exception) {}
|
||||
for (ActorRef counter : counters) {
|
||||
Future future = counter.sendRequestReplyFuture("GetCount");
|
||||
Future future = counter.ask("GetCount");
|
||||
future.await();
|
||||
if (future.isCompleted()) {
|
||||
Option resultOption = future.result();
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ public class UntypedTransactorTest {
|
|||
incrementLatch.await(timeout, TimeUnit.SECONDS);
|
||||
} catch (InterruptedException exception) {}
|
||||
for (ActorRef counter : counters) {
|
||||
Future future = counter.sendRequestReplyFuture("GetCount");
|
||||
Future future = counter.ask("GetCount");
|
||||
future.await();
|
||||
if (future.isCompleted()) {
|
||||
Option resultOption = future.result();
|
||||
|
|
@ -71,7 +71,7 @@ public class UntypedTransactorTest {
|
|||
incrementLatch.await(timeout, TimeUnit.SECONDS);
|
||||
} catch (InterruptedException exception) {}
|
||||
for (ActorRef counter : counters) {
|
||||
Future future = counter.sendRequestReplyFuture("GetCount");
|
||||
Future future = counter.ask("GetCount");
|
||||
future.await();
|
||||
if (future.isCompleted()) {
|
||||
Option resultOption = future.result();
|
||||
|
|
|
|||
|
|
@ -64,7 +64,7 @@ class CoordinatedIncrementSpec extends WordSpec with MustMatchers {
|
|||
counters(0) ! coordinated(Increment(counters.tail))
|
||||
coordinated.await
|
||||
for (counter ← counters) {
|
||||
(counter !! GetCount).get must be === 1
|
||||
(counter ? GetCount).as[Int].get must be === 1
|
||||
}
|
||||
counters foreach (_.stop())
|
||||
failer.stop()
|
||||
|
|
@ -76,7 +76,7 @@ class CoordinatedIncrementSpec extends WordSpec with MustMatchers {
|
|||
counters(0) ! Coordinated(Increment(counters.tail :+ failer))
|
||||
coordinated.await
|
||||
for (counter ← counters) {
|
||||
(counter !! GetCount).get must be === 0
|
||||
(counter ? GetCount).as[Int].get must be === 0
|
||||
}
|
||||
counters foreach (_.stop())
|
||||
failer.stop()
|
||||
|
|
|
|||
|
|
@ -109,9 +109,9 @@ class FickleFriendsSpec extends WordSpec with MustMatchers {
|
|||
val latch = new CountDownLatch(1)
|
||||
coordinator ! FriendlyIncrement(counters, latch)
|
||||
latch.await // this could take a while
|
||||
(coordinator !! GetCount).get must be === 1
|
||||
(coordinator ? GetCount).as[Int].get must be === 1
|
||||
for (counter ← counters) {
|
||||
(counter !! GetCount).get must be === 1
|
||||
(counter ? GetCount).as[Int].get must be === 1
|
||||
}
|
||||
counters foreach (_.stop())
|
||||
coordinator.stop()
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ class TransactorSpec extends WordSpec with MustMatchers {
|
|||
counters(0) ! Increment(counters.tail, incrementLatch)
|
||||
incrementLatch.await(timeout.length, timeout.unit)
|
||||
for (counter ← counters) {
|
||||
(counter !! GetCount).get must be === 1
|
||||
(counter ? GetCount).as[Int].get must be === 1
|
||||
}
|
||||
counters foreach (_.stop())
|
||||
failer.stop()
|
||||
|
|
@ -104,7 +104,7 @@ class TransactorSpec extends WordSpec with MustMatchers {
|
|||
counters(0) ! Increment(counters.tail :+ failer, failLatch)
|
||||
failLatch.await(timeout.length, timeout.unit)
|
||||
for (counter ← counters) {
|
||||
(counter !! GetCount).get must be === 0
|
||||
(counter ? GetCount).as[Int].get must be === 0
|
||||
}
|
||||
counters foreach (_.stop())
|
||||
failer.stop()
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ package akka.testkit
|
|||
|
||||
import akka.event.EventHandler
|
||||
import akka.actor.ActorRef
|
||||
import akka.dispatch.{ MessageDispatcher, MessageInvocation, FutureInvocation }
|
||||
import akka.dispatch.{ MessageDispatcher, MessageInvocation, FutureInvocation, Promise, ActorPromise }
|
||||
import java.util.concurrent.locks.ReentrantLock
|
||||
import java.util.LinkedList
|
||||
import java.util.concurrent.RejectedExecutionException
|
||||
|
|
@ -142,14 +142,14 @@ class CallingThreadDispatcher(val warnings: Boolean = true) extends MessageDispa
|
|||
val queue = mbox.queue
|
||||
val execute = mbox.suspended.ifElseYield {
|
||||
queue.push(handle)
|
||||
if (warnings && handle.senderFuture.isDefined) {
|
||||
if (warnings && handle.channel.isInstanceOf[Promise[_]]) {
|
||||
EventHandler.warning(this, "suspended, creating Future could deadlock; target: %s" format handle.receiver)
|
||||
}
|
||||
false
|
||||
} {
|
||||
queue.push(handle)
|
||||
if (queue.isActive) {
|
||||
if (warnings && handle.senderFuture.isDefined) {
|
||||
if (warnings && handle.channel.isInstanceOf[Promise[_]]) {
|
||||
EventHandler.warning(this, "blocked on this thread, creating Future could deadlock; target: %s" format handle.receiver)
|
||||
}
|
||||
false
|
||||
|
|
@ -188,14 +188,18 @@ class CallingThreadDispatcher(val warnings: Boolean = true) extends MessageDispa
|
|||
if (handle ne null) {
|
||||
try {
|
||||
handle.invoke
|
||||
val f = handle.senderFuture
|
||||
if (warnings && f.isDefined && !f.get.isCompleted) {
|
||||
EventHandler.warning(this, "calling %s with message %s did not reply as expected, might deadlock" format (handle.receiver, handle.message))
|
||||
if (warnings) handle.channel match {
|
||||
case f: ActorPromise if !f.isCompleted ⇒
|
||||
EventHandler.warning(this, "calling %s with message %s did not reply as expected, might deadlock" format (handle.receiver, handle.message))
|
||||
case _ ⇒
|
||||
}
|
||||
true
|
||||
} catch {
|
||||
case _ ⇒ queue.leave
|
||||
case e ⇒
|
||||
EventHandler.error(this, e)
|
||||
queue.leave
|
||||
false
|
||||
}
|
||||
true
|
||||
} else if (queue.isActive) {
|
||||
queue.leave
|
||||
false
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
*/
|
||||
package akka.testkit
|
||||
|
||||
import akka.actor.{ Actor, FSM }
|
||||
import akka.actor._
|
||||
import Actor._
|
||||
import akka.util.Duration
|
||||
import akka.util.duration._
|
||||
|
|
@ -17,9 +17,19 @@ object TestActor {
|
|||
|
||||
case class SetTimeout(d: Duration)
|
||||
case class SetIgnore(i: Ignore)
|
||||
|
||||
trait Message {
|
||||
def msg: AnyRef
|
||||
def channel: UntypedChannel
|
||||
}
|
||||
case class RealMessage(msg: AnyRef, channel: UntypedChannel) extends Message
|
||||
case object NullMessage extends Message {
|
||||
override def msg: AnyRef = throw new IllegalActorStateException("last receive did not dequeue a message")
|
||||
override def channel: UntypedChannel = throw new IllegalActorStateException("last receive did not dequeue a message")
|
||||
}
|
||||
}
|
||||
|
||||
class TestActor(queue: BlockingDeque[AnyRef]) extends Actor with FSM[Int, TestActor.Ignore] {
|
||||
class TestActor(queue: BlockingDeque[TestActor.Message]) extends Actor with FSM[Int, TestActor.Ignore] {
|
||||
import FSM._
|
||||
import TestActor._
|
||||
|
||||
|
|
@ -36,7 +46,7 @@ class TestActor(queue: BlockingDeque[AnyRef]) extends Actor with FSM[Int, TestAc
|
|||
case Event(x: AnyRef, ign) ⇒
|
||||
val ignore = ign map (z ⇒ if (z isDefinedAt x) z(x) else false) getOrElse false
|
||||
if (!ignore) {
|
||||
queue.offerLast(x)
|
||||
queue.offerLast(RealMessage(x, self.channel))
|
||||
}
|
||||
stay
|
||||
}
|
||||
|
|
@ -76,19 +86,23 @@ class TestActor(queue: BlockingDeque[AnyRef]) extends Actor with FSM[Int, TestAc
|
|||
*/
|
||||
trait TestKit {
|
||||
|
||||
private val queue = new LinkedBlockingDeque[AnyRef]()
|
||||
import TestActor.{ Message, RealMessage, NullMessage }
|
||||
|
||||
private val queue = new LinkedBlockingDeque[Message]()
|
||||
private[akka] var lastMessage: Message = NullMessage
|
||||
|
||||
/**
|
||||
* ActorRef of the test actor. Access is provided to enable e.g.
|
||||
* registration as message target.
|
||||
*/
|
||||
protected val testActor = actorOf(new TestActor(queue)).start()
|
||||
implicit val testActor = actorOf(new TestActor(queue)).start()
|
||||
|
||||
/**
|
||||
* Implicit sender reference so that replies are possible for messages sent
|
||||
* from the test class.
|
||||
*/
|
||||
protected implicit val senderOption = Some(testActor)
|
||||
@deprecated("will be removed after 1.2, replaced by implicit testActor", "1.2")
|
||||
val senderOption = Some(testActor)
|
||||
|
||||
private var end: Duration = Duration.Inf
|
||||
/*
|
||||
|
|
@ -183,6 +197,14 @@ trait TestKit {
|
|||
*/
|
||||
def within[T](max: Duration)(f: ⇒ T): T = within(0 seconds, max)(f)
|
||||
|
||||
/**
|
||||
* Send reply to the last dequeued message. Will throw
|
||||
* IllegalActorStateException if no message has been dequeued, yet. Dequeuing
|
||||
* means reception of the message as part of an expect... or receive... call,
|
||||
* not reception by the testActor.
|
||||
*/
|
||||
def reply(msg: AnyRef) { lastMessage.channel ! msg }
|
||||
|
||||
/**
|
||||
* Same as `expectMsg`, but takes the maximum wait time from the innermost
|
||||
* enclosing `within` block.
|
||||
|
|
@ -396,16 +418,21 @@ trait TestKit {
|
|||
*/
|
||||
def receiveWhile[T](max: Duration)(f: PartialFunction[AnyRef, T]): Seq[T] = {
|
||||
val stop = now + max
|
||||
var msg: Message = NullMessage
|
||||
|
||||
@tailrec
|
||||
def doit(acc: List[T]): List[T] = {
|
||||
receiveOne(stop - now) match {
|
||||
case null ⇒
|
||||
receiveOne(stop - now)
|
||||
lastMessage match {
|
||||
case NullMessage ⇒
|
||||
lastMessage = msg
|
||||
acc.reverse
|
||||
case o if (f isDefinedAt o) ⇒
|
||||
case RealMessage(o, _) if (f isDefinedAt o) ⇒
|
||||
msg = lastMessage
|
||||
doit(f(o) :: acc)
|
||||
case o ⇒
|
||||
queue.offerFirst(o)
|
||||
case RealMessage(o, _) ⇒
|
||||
queue.offerFirst(lastMessage)
|
||||
lastMessage = msg
|
||||
acc.reverse
|
||||
}
|
||||
}
|
||||
|
|
@ -415,7 +442,10 @@ trait TestKit {
|
|||
ret
|
||||
}
|
||||
|
||||
private def receiveN(n: Int, stop: Duration): Seq[AnyRef] = {
|
||||
/**
|
||||
* Receive N messages in a row before the given deadline.
|
||||
*/
|
||||
def receiveN(n: Int, stop: Duration): Seq[AnyRef] = {
|
||||
for { x ← 1 to n } yield {
|
||||
val timeout = stop - now
|
||||
val o = receiveOne(timeout)
|
||||
|
|
@ -424,17 +454,65 @@ trait TestKit {
|
|||
}
|
||||
}
|
||||
|
||||
private def receiveOne(max: Duration): AnyRef = {
|
||||
if (max == 0.seconds) {
|
||||
queue.pollFirst
|
||||
} else if (max.finite_?) {
|
||||
queue.pollFirst(max.length, max.unit)
|
||||
} else {
|
||||
queue.takeFirst
|
||||
/**
|
||||
* Receive one message from the internal queue of the TestActor. If the given
|
||||
* duration is zero, the queue is polled (non-blocking).
|
||||
*/
|
||||
def receiveOne(max: Duration): AnyRef = {
|
||||
val message =
|
||||
if (max == 0.seconds) {
|
||||
queue.pollFirst
|
||||
} else if (max.finite_?) {
|
||||
queue.pollFirst(max.length, max.unit)
|
||||
} else {
|
||||
queue.takeFirst
|
||||
}
|
||||
message match {
|
||||
case null ⇒
|
||||
lastMessage = NullMessage
|
||||
null
|
||||
case RealMessage(msg, _) ⇒
|
||||
lastMessage = message
|
||||
msg
|
||||
}
|
||||
}
|
||||
|
||||
private def format(u: TimeUnit, d: Duration) = "%.3f %s".format(d.toUnit(u), u.toString.toLowerCase)
|
||||
}
|
||||
|
||||
// vim: set ts=2 sw=2 et:
|
||||
/**
|
||||
* TestKit-based probe which allows sending, reception and reply.
|
||||
*/
|
||||
class TestProbe extends TestKit {
|
||||
|
||||
/**
|
||||
* Shorthand to get the testActor.
|
||||
*/
|
||||
def ref = testActor
|
||||
|
||||
/**
|
||||
* Send message to an actor while using the probe's TestActor as the sender.
|
||||
* Replies will be available for inspection with all of TestKit's assertion
|
||||
* methods.
|
||||
*/
|
||||
def send(actor: ActorRef, msg: AnyRef) = {
|
||||
actor ! msg
|
||||
}
|
||||
|
||||
/**
|
||||
* Forward this message as if in the TestActor's receive method with self.forward.
|
||||
*/
|
||||
def forward(actor: ActorRef, msg: AnyRef = lastMessage.msg) {
|
||||
actor.!(msg)(lastMessage.channel)
|
||||
}
|
||||
|
||||
/**
|
||||
* Get channel of last received message.
|
||||
*/
|
||||
def channel = lastMessage.channel
|
||||
|
||||
}
|
||||
|
||||
object TestProbe {
|
||||
def apply() = new TestProbe
|
||||
}
|
||||
|
|
|
|||
|
|
@ -114,7 +114,7 @@ class TestActorRefSpec extends WordSpec with MustMatchers with BeforeAndAfterEac
|
|||
def receive = { case _ ⇒ self reply nested }
|
||||
}).start()
|
||||
a must not be (null)
|
||||
val nested = (a !! "any").get.asInstanceOf[ActorRef]
|
||||
val nested = (a ? "any").as[ActorRef].get
|
||||
nested must not be (null)
|
||||
a must not be theSameInstanceAs(nested)
|
||||
}
|
||||
|
|
@ -125,7 +125,7 @@ class TestActorRefSpec extends WordSpec with MustMatchers with BeforeAndAfterEac
|
|||
def receive = { case _ ⇒ self reply nested }
|
||||
}).start()
|
||||
a must not be (null)
|
||||
val nested = (a !! "any").get.asInstanceOf[ActorRef]
|
||||
val nested = (a ? "any").as[ActorRef].get
|
||||
nested must not be (null)
|
||||
a must not be theSameInstanceAs(nested)
|
||||
}
|
||||
|
|
@ -160,7 +160,7 @@ class TestActorRefSpec extends WordSpec with MustMatchers with BeforeAndAfterEac
|
|||
"stop when sent a poison pill" in {
|
||||
val a = TestActorRef[WorkerActor].start()
|
||||
intercept[ActorKilledException] {
|
||||
a !! PoisonPill
|
||||
(a ? PoisonPill).get
|
||||
}
|
||||
a must not be ('running)
|
||||
a must be('shutdown)
|
||||
|
|
@ -190,7 +190,7 @@ class TestActorRefSpec extends WordSpec with MustMatchers with BeforeAndAfterEac
|
|||
|
||||
"support futures" in {
|
||||
val a = TestActorRef[WorkerActor].start()
|
||||
val f: Future[String] = a !!! "work"
|
||||
val f = a ? "work" mapTo manifest[String]
|
||||
f must be('completed)
|
||||
f.get must equal("workDone")
|
||||
}
|
||||
|
|
@ -239,9 +239,8 @@ class TestActorRefSpec extends WordSpec with MustMatchers with BeforeAndAfterEac
|
|||
intercept[IllegalActorStateException] { ref("work") }
|
||||
val ch = Promise.channel()
|
||||
ref ! ch
|
||||
val f = ch.promise
|
||||
f must be('completed)
|
||||
f.get must be("complexReply")
|
||||
ch must be('completed)
|
||||
ch.get must be("complexReply")
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
45
akka-testkit/src/test/scala/akka/testkit/TestProbeSpec.scala
Normal file
45
akka-testkit/src/test/scala/akka/testkit/TestProbeSpec.scala
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
package akka.testkit
|
||||
|
||||
import org.scalatest.WordSpec
|
||||
import org.scalatest.matchers.MustMatchers
|
||||
import org.scalatest.{ BeforeAndAfterEach, WordSpec }
|
||||
import akka.actor._
|
||||
import akka.config.Supervision.OneForOneStrategy
|
||||
import akka.event.EventHandler
|
||||
import akka.dispatch.Future
|
||||
import akka.util.duration._
|
||||
|
||||
class TestProbeSpec extends WordSpec with MustMatchers {
|
||||
|
||||
"A TestProbe" must {
|
||||
|
||||
"reply to futures" in {
|
||||
val tk = TestProbe()
|
||||
val future = tk.ref ? "hello"
|
||||
tk.expectMsg(0 millis, "hello") // TestActor runs on CallingThreadDispatcher
|
||||
tk.reply("world")
|
||||
future must be('completed)
|
||||
future.get must equal("world")
|
||||
}
|
||||
|
||||
"reply to messages" in {
|
||||
val tk1 = TestProbe()
|
||||
val tk2 = TestProbe()
|
||||
tk1.ref.!("hello")(tk2.ref)
|
||||
tk1.expectMsg(0 millis, "hello")
|
||||
tk1.reply("world")
|
||||
tk2.expectMsg(0 millis, "world")
|
||||
}
|
||||
|
||||
"properly send and reply to messages" in {
|
||||
val probe1 = TestProbe()
|
||||
val probe2 = TestProbe()
|
||||
probe1.send(probe2.ref, "hello")
|
||||
probe2.expectMsg(0 millis, "hello")
|
||||
probe2.reply("world")
|
||||
probe1.expectMsg(0 millis, "world")
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -184,10 +184,10 @@ public class Pi {
|
|||
|
||||
// send calculate message
|
||||
long timeout = 60000;
|
||||
Future<Double> replyFuture = master.sendRequestReplyFuture(new Calculate(), timeout, null);
|
||||
Option<Double> result = replyFuture.await().resultOrException();
|
||||
Future<Object> replyFuture = master.ask(new Calculate(), timeout, null);
|
||||
Option<Object> result = replyFuture.await().resultOrException();
|
||||
if (result.isDefined()) {
|
||||
double pi = result.get();
|
||||
double pi = (Double) result.get();
|
||||
// TODO java api for EventHandler?
|
||||
// EventHandler.info(this, String.format("\n\tPi estimate: \t\t%s\n\tCalculation time: \t%s millis", pi, (currentTimeMillis() - start)));
|
||||
System.out.println(String.format("\n\tPi estimate: \t\t%s\n\tCalculation time: \t%s millis", pi, (currentTimeMillis() - start)));
|
||||
|
|
|
|||
|
|
@ -104,7 +104,7 @@ object Pi extends App {
|
|||
val start = now
|
||||
|
||||
//send calculate message
|
||||
master.!!.
|
||||
master.?(Calculate, Actor.Timeout(60000)).
|
||||
await.resultOrException match {//wait for the result, with a 60 seconds timeout
|
||||
case Some(pi) =>
|
||||
EventHandler.info(this, "\n\tPi estimate: \t\t%s\n\tCalculation time: \t%s millis".format(pi, (now - start)))
|
||||
|
|
|
|||
|
|
@ -28,8 +28,8 @@ akka {
|
|||
|
||||
actor {
|
||||
timeout = 5 # Default timeout for Future based invocations
|
||||
# - Actor: !! && !!!
|
||||
# - UntypedActor: sendRequestReply && sendRequestReplyFuture
|
||||
# - Actor: !! && ?
|
||||
# - UntypedActor: sendRequestReply && ask
|
||||
# - TypedActor: methods with non-void return type
|
||||
serialize-messages = off # Does a deep clone of (non-primitive) messages to ensure immutability
|
||||
throughput = 5 # Default throughput for all Dispatcher, set to 1 for complete fairness
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue