diff --git a/akka-actor-tests/src/test/scala/akka/actor/dispatch/ActorModelSpec.scala b/akka-actor-tests/src/test/scala/akka/actor/dispatch/ActorModelSpec.scala
index 0afed9cb14..5d4a812e52 100644
--- a/akka-actor-tests/src/test/scala/akka/actor/dispatch/ActorModelSpec.scala
+++ b/akka-actor-tests/src/test/scala/akka/actor/dispatch/ActorModelSpec.scala
@@ -408,34 +408,38 @@ abstract class ActorModelSpec(config: String) extends AkkaSpec(config) with Defa
}
"continue to process messages when a thread gets interrupted and throws an exception" in {
- filterEvents(EventFilter[InterruptedException](), EventFilter[akka.event.Logging.LoggerException]()) {
- implicit val dispatcher = interceptedDispatcher()
- val a = newTestActor(dispatcher.id)
- val f1 = a ? Reply("foo")
- val f2 = a ? Reply("bar")
- val f3 = a ? Interrupt
- Thread.interrupted() // CallingThreadDispatcher may necessitate this
- val f4 = a ? Reply("foo2")
- val f5 = a ? Interrupt
- Thread.interrupted() // CallingThreadDispatcher may necessitate this
- val f6 = a ? Reply("bar2")
+ filterEvents(
+ EventFilter[InterruptedException](),
+ EventFilter[ActorInterruptedException](),
+ EventFilter[akka.event.Logging.LoggerException]()) {
+ implicit val dispatcher = interceptedDispatcher()
+ val a = newTestActor(dispatcher.id)
+ val f1 = a ? Reply("foo")
+ val f2 = a ? Reply("bar")
+ val f3 = a ? Interrupt
+ Thread.interrupted() // CallingThreadDispatcher may necessitate this
+ val f4 = a ? Reply("foo2")
+ val f5 = a ? Interrupt
+ Thread.interrupted() // CallingThreadDispatcher may necessitate this
+ val f6 = a ? Reply("bar2")
- val c = system.scheduler.scheduleOnce(2.seconds) {
- import collection.JavaConverters._
- Thread.getAllStackTraces().asScala foreach {
- case (thread, stack) ⇒
- println(s"$thread:")
- stack foreach (s ⇒ println(s"\t$s"))
+ val c = system.scheduler.scheduleOnce(2.seconds) {
+ import collection.JavaConverters._
+ Thread.getAllStackTraces().asScala foreach {
+ case (thread, stack) ⇒
+ println(s"$thread:")
+ stack foreach (s ⇒ println(s"\t$s"))
+ }
}
+ assert(Await.result(f1, remaining) === "foo")
+ assert(Await.result(f2, remaining) === "bar")
+ assert(Await.result(f4, remaining) === "foo2")
+ assert(intercept[ActorInterruptedException](Await.result(f3, remaining)).getCause.getMessage === "Ping!")
+ assert(Await.result(f6, remaining) === "bar2")
+ assert(intercept[ActorInterruptedException](Await.result(f5, remaining)).getCause.getMessage === "Ping!")
+ c.cancel()
+ Thread.sleep(300) // give the EventFilters a chance of catching all messages
}
- assert(Await.result(f1, remaining) === "foo")
- assert(Await.result(f2, remaining) === "bar")
- assert(Await.result(f4, remaining) === "foo2")
- assert(intercept[ActorInterruptedException](Await.result(f3, remaining)).getCause.getMessage === "Ping!")
- assert(Await.result(f6, remaining) === "bar2")
- assert(intercept[ActorInterruptedException](Await.result(f5, remaining)).getCause.getMessage === "Ping!")
- c.cancel()
- }
}
"continue to process messages without failure when a thread gets interrupted and doesn't throw an exception" in {
diff --git a/akka-actor/src/main/scala/akka/actor/Actor.scala b/akka-actor/src/main/scala/akka/actor/Actor.scala
index 01ae610a65..473ec814bb 100644
--- a/akka-actor/src/main/scala/akka/actor/Actor.scala
+++ b/akka-actor/src/main/scala/akka/actor/Actor.scala
@@ -338,8 +338,11 @@ object Actor {
/**
* Type alias representing a Receive-expression for Akka Actors.
*/
+ //#receive
type Receive = PartialFunction[Any, Unit]
+ //#receive
+
/**
* emptyBehavior is a Receive-expression that matches no messages at all, ever.
*/
@@ -463,7 +466,9 @@ trait Actor {
* This defines the initial actor behavior, it must return a partial function
* with the actor logic.
*/
- def receive: Receive
+ //#receive
+ def receive: Actor.Receive
+ //#receive
/**
* User overridable definition the strategy to use for supervising
@@ -478,8 +483,11 @@ trait Actor {
* Actors are automatically started asynchronously when created.
* Empty default implementation.
*/
- @throws(classOf[Exception])
- def preStart() {}
+ @throws(classOf[Exception]) // when changing this you MUST also change UntypedActorDocTestBase
+ //#lifecycle-hooks
+ def preStart(): Unit = ()
+
+ //#lifecycle-hooks
/**
* User overridable callback.
@@ -487,8 +495,11 @@ trait Actor {
* Is called asynchronously after 'actor.stop()' is invoked.
* Empty default implementation.
*/
- @throws(classOf[Exception])
- def postStop() {}
+ @throws(classOf[Exception]) // when changing this you MUST also change UntypedActorDocTestBase
+ //#lifecycle-hooks
+ def postStop(): Unit = ()
+
+ //#lifecycle-hooks
/**
* User overridable callback: '''By default it disposes of all children and then calls `postStop()`.'''
@@ -498,8 +509,9 @@ trait Actor {
* Is called on a crashed Actor right BEFORE it is restarted to allow clean
* up of resources before Actor is terminated.
*/
- @throws(classOf[Exception])
- def preRestart(reason: Throwable, message: Option[Any]) {
+ @throws(classOf[Exception]) // when changing this you MUST also change UntypedActorDocTestBase
+ //#lifecycle-hooks
+ def preRestart(reason: Throwable, message: Option[Any]): Unit = {
context.children foreach { child ⇒
context.unwatch(child)
context.stop(child)
@@ -507,14 +519,20 @@ trait Actor {
postStop()
}
+ //#lifecycle-hooks
+
/**
* User overridable callback: By default it calls `preStart()`.
* @param reason the Throwable that caused the restart to happen
*
* Is called right AFTER restart on the newly created Actor to allow reinitialization after an Actor crash.
*/
- @throws(classOf[Exception])
- def postRestart(reason: Throwable) { preStart() }
+ @throws(classOf[Exception]) // when changing this you MUST also change UntypedActorDocTestBase
+ //#lifecycle-hooks
+ def postRestart(reason: Throwable): Unit = {
+ preStart()
+ }
+ //#lifecycle-hooks
/**
* User overridable callback.
diff --git a/akka-actor/src/main/scala/akka/actor/ActorCell.scala b/akka-actor/src/main/scala/akka/actor/ActorCell.scala
index 242897ad30..61aa820d2d 100644
--- a/akka-actor/src/main/scala/akka/actor/ActorCell.scala
+++ b/akka-actor/src/main/scala/akka/actor/ActorCell.scala
@@ -31,18 +31,12 @@ import scala.util.control.NonFatal
* context.actorOf(props)
*
* // Scala
- * context.actorOf(Props[MyActor]("name")
- * context.actorOf(Props[MyActor]
- * context.actorOf(Props(new MyActor(...))
+ * context.actorOf(Props[MyActor])
+ * context.actorOf(Props(classOf[MyActor], arg1, arg2), "name")
*
* // Java
- * context.actorOf(classOf[MyActor]);
- * context.actorOf(Props(new Creator() {
- * public MyActor create() { ... }
- * });
- * context.actorOf(Props(new Creator() {
- * public MyActor create() { ... }
- * }, "name");
+ * getContext().actorOf(Props.create(MyActor.class));
+ * getContext().actorOf(Props.create(MyActor.class, arg1, arg2), "name");
* }}}
*
* Where no name is given explicitly, one will be automatically generated.
@@ -534,7 +528,7 @@ private[akka] class ActorCell(
contextStack.set(this :: contextStack.get)
try {
behaviorStack = emptyBehaviorStack
- val instance = props.creator.apply()
+ val instance = props.newActor()
if (instance eq null)
throw ActorInitializationException(self, "Actor instance passed to actorOf can't be 'null'")
diff --git a/akka-actor/src/main/scala/akka/actor/ActorRef.scala b/akka-actor/src/main/scala/akka/actor/ActorRef.scala
index 08a7e84421..3c48b3a861 100644
--- a/akka-actor/src/main/scala/akka/actor/ActorRef.scala
+++ b/akka-actor/src/main/scala/akka/actor/ActorRef.scala
@@ -46,7 +46,7 @@ import akka.event.LoggingAdapter
*
* public class ExampleActor Extends UntypedActor {
* // this child will be destroyed and re-created upon restart by default
- * final ActorRef other = getContext().actorOf(new Props(OtherActor.class), "childName");
+ * final ActorRef other = getContext().actorOf(Props.create(OtherActor.class), "childName");
*
* @Override
* public void onReceive(Object o) {
diff --git a/akka-actor/src/main/scala/akka/actor/ActorRefProvider.scala b/akka-actor/src/main/scala/akka/actor/ActorRefProvider.scala
index 18a3077e22..ef8ff80175 100644
--- a/akka-actor/src/main/scala/akka/actor/ActorRefProvider.scala
+++ b/akka-actor/src/main/scala/akka/actor/ActorRefProvider.scala
@@ -362,6 +362,73 @@ private[akka] object SystemGuardian {
case object TerminationHookDone
}
+private[akka] object LocalActorRefProvider {
+
+ /*
+ * Root and user guardian
+ */
+ private class Guardian(override val supervisorStrategy: SupervisorStrategy) extends Actor {
+
+ def receive = {
+ case Terminated(_) ⇒ context.stop(self)
+ case StopChild(child) ⇒ context.stop(child)
+ case m ⇒ context.system.deadLetters forward DeadLetter(m, sender, self)
+ }
+
+ // guardian MUST NOT lose its children during restart
+ override def preRestart(cause: Throwable, msg: Option[Any]) {}
+ }
+
+ /**
+ * System guardian
+ */
+ private class SystemGuardian(override val supervisorStrategy: SupervisorStrategy, val guardian: ActorRef) extends Actor {
+ import SystemGuardian._
+
+ var terminationHooks = Set.empty[ActorRef]
+
+ def receive = {
+ case Terminated(`guardian`) ⇒
+ // time for the systemGuardian to stop, but first notify all the
+ // termination hooks, they will reply with TerminationHookDone
+ // and when all are done the systemGuardian is stopped
+ context.become(terminating)
+ terminationHooks foreach { _ ! TerminationHook }
+ stopWhenAllTerminationHooksDone()
+ case Terminated(a) ⇒
+ // a registered, and watched termination hook terminated before
+ // termination process of guardian has started
+ terminationHooks -= a
+ case StopChild(child) ⇒ context.stop(child)
+ case RegisterTerminationHook if sender != context.system.deadLetters ⇒
+ terminationHooks += sender
+ context watch sender
+ case m ⇒ context.system.deadLetters forward DeadLetter(m, sender, self)
+ }
+
+ def terminating: Receive = {
+ case Terminated(a) ⇒ stopWhenAllTerminationHooksDone(a)
+ case TerminationHookDone ⇒ stopWhenAllTerminationHooksDone(sender)
+ case m ⇒ context.system.deadLetters forward DeadLetter(m, sender, self)
+ }
+
+ def stopWhenAllTerminationHooksDone(remove: ActorRef): Unit = {
+ terminationHooks -= remove
+ stopWhenAllTerminationHooksDone()
+ }
+
+ def stopWhenAllTerminationHooksDone(): Unit =
+ if (terminationHooks.isEmpty) {
+ context.system.eventStream.stopDefaultLoggers(context.system)
+ context.stop(self)
+ }
+
+ // guardian MUST NOT lose its children during restart
+ override def preRestart(cause: Throwable, msg: Option[Any]) {}
+ }
+
+}
+
/**
* Local ActorRef provider.
*
@@ -428,82 +495,22 @@ private[akka] class LocalActorRefProvider private[akka] (
override def !(message: Any)(implicit sender: ActorRef = Actor.noSender): Unit = stopped.ifOff(message match {
case null ⇒ throw new InvalidMessageException("Message is null")
case NullMessage ⇒ // do nothing
- case _ ⇒ log.error(this + " received unexpected message [" + message + "]")
+ case _ ⇒ log.error(s"$this received unexpected message [$message]")
})
override def sendSystemMessage(message: SystemMessage): Unit = stopped ifOff {
message match {
- case Failed(child, ex, _) ⇒ { causeOfTermination = Some(ex); child.asInstanceOf[InternalActorRef].stop() }
- case _: Supervise ⇒ // TODO register child in some map to keep track of it and enable shutdown after all dead
+ case Failed(child, ex, _) ⇒
+ log.error(ex, s"guardian $child failed, shutting down!")
+ causeOfTermination = Some(ex)
+ child.asInstanceOf[InternalActorRef].stop()
+ case Supervise(_, _) ⇒ // TODO register child in some map to keep track of it and enable shutdown after all dead
case _: DeathWatchNotification ⇒ stop()
- case _ ⇒ log.error(this + " received unexpected system message [" + message + "]")
+ case _ ⇒ log.error(s"$this received unexpected system message [$message]")
}
}
}
- /*
- * Root and user guardian
- */
- private class Guardian(override val supervisorStrategy: SupervisorStrategy) extends Actor {
-
- def receive = {
- case Terminated(_) ⇒ context.stop(self)
- case StopChild(child) ⇒ context.stop(child)
- case m ⇒ deadLetters forward DeadLetter(m, sender, self)
- }
-
- // guardian MUST NOT lose its children during restart
- override def preRestart(cause: Throwable, msg: Option[Any]) {}
- }
-
- /**
- * System guardian
- */
- private class SystemGuardian(override val supervisorStrategy: SupervisorStrategy) extends Actor {
- import SystemGuardian._
-
- var terminationHooks = Set.empty[ActorRef]
-
- def receive = {
- case Terminated(`guardian`) ⇒
- // time for the systemGuardian to stop, but first notify all the
- // termination hooks, they will reply with TerminationHookDone
- // and when all are done the systemGuardian is stopped
- context.become(terminating)
- terminationHooks foreach { _ ! TerminationHook }
- stopWhenAllTerminationHooksDone()
- case Terminated(a) ⇒
- // a registered, and watched termination hook terminated before
- // termination process of guardian has started
- terminationHooks -= a
- case StopChild(child) ⇒ context.stop(child)
- case RegisterTerminationHook if sender != context.system.deadLetters ⇒
- terminationHooks += sender
- context watch sender
- case m ⇒ deadLetters forward DeadLetter(m, sender, self)
- }
-
- def terminating: Receive = {
- case Terminated(a) ⇒ stopWhenAllTerminationHooksDone(a)
- case TerminationHookDone ⇒ stopWhenAllTerminationHooksDone(sender)
- case m ⇒ deadLetters forward DeadLetter(m, sender, self)
- }
-
- def stopWhenAllTerminationHooksDone(remove: ActorRef): Unit = {
- terminationHooks -= remove
- stopWhenAllTerminationHooksDone()
- }
-
- def stopWhenAllTerminationHooksDone(): Unit =
- if (terminationHooks.isEmpty) {
- eventStream.stopDefaultLoggers(system)
- context.stop(self)
- }
-
- // guardian MUST NOT lose its children during restart
- override def preRestart(cause: Throwable, msg: Option[Any]) {}
- }
-
/*
* The problem is that ActorRefs need a reference to the ActorSystem to
* provide their service. Hence they cannot be created while the
@@ -552,7 +559,11 @@ private[akka] class LocalActorRefProvider private[akka] (
protected def systemGuardianStrategy: SupervisorStrategy = SupervisorStrategy.defaultStrategy
override lazy val rootGuardian: LocalActorRef =
- new LocalActorRef(system, Props(new Guardian(rootGuardianStrategy)), theOneWhoWalksTheBubblesOfSpaceTime, rootPath) {
+ new LocalActorRef(
+ system,
+ Props(classOf[LocalActorRefProvider.Guardian], rootGuardianStrategy),
+ theOneWhoWalksTheBubblesOfSpaceTime,
+ rootPath) {
override def getParent: InternalActorRef = this
override def getSingleChild(name: String): InternalActorRef = name match {
case "temp" ⇒ tempContainer
@@ -568,7 +579,8 @@ private[akka] class LocalActorRefProvider private[akka] (
override lazy val guardian: LocalActorRef = {
val cell = rootGuardian.underlying
cell.reserveChild("user")
- val ref = new LocalActorRef(system, Props(new Guardian(guardianStrategy)), rootGuardian, rootPath / "user")
+ val ref = new LocalActorRef(system, Props(classOf[LocalActorRefProvider.Guardian], guardianStrategy),
+ rootGuardian, rootPath / "user")
cell.initChild(ref)
ref.start()
ref
@@ -577,7 +589,9 @@ private[akka] class LocalActorRefProvider private[akka] (
override lazy val systemGuardian: LocalActorRef = {
val cell = rootGuardian.underlying
cell.reserveChild("system")
- val ref = new LocalActorRef(system, Props(new SystemGuardian(systemGuardianStrategy)), rootGuardian, rootPath / "system")
+ val ref = new LocalActorRef(
+ system, Props(classOf[LocalActorRefProvider.SystemGuardian], systemGuardianStrategy, guardian),
+ rootGuardian, rootPath / "system")
cell.initChild(ref)
ref.start()
ref
@@ -669,7 +683,7 @@ private[akka] class LocalActorRefProvider private[akka] (
def actorOf(system: ActorSystemImpl, props: Props, supervisor: InternalActorRef, path: ActorPath,
systemService: Boolean, deploy: Option[Deploy], lookupDeploy: Boolean, async: Boolean): InternalActorRef = {
- props.routerConfig match {
+ props.deploy.routerConfig match {
case NoRouter ⇒
if (settings.DebugRouterMisconfiguration) {
deployer.lookup(path) foreach { d ⇒
diff --git a/akka-actor/src/main/scala/akka/actor/ActorSystem.scala b/akka-actor/src/main/scala/akka/actor/ActorSystem.scala
index 85d9f93310..8b9e1bb76e 100644
--- a/akka-actor/src/main/scala/akka/actor/ActorSystem.scala
+++ b/akka-actor/src/main/scala/akka/actor/ActorSystem.scala
@@ -217,17 +217,11 @@ object ActorSystem {
*
* // Scala
* system.actorOf(Props[MyActor], "name")
- * system.actorOf(Props[MyActor])
- * system.actorOf(Props(new MyActor(...)))
+ * system.actorOf(Props(classOf[MyActor], arg1, arg2), "name")
*
* // Java
- * system.actorOf(MyActor.class);
- * system.actorOf(Props(new Creator() {
- * public MyActor create() { ... }
- * });
- * system.actorOf(Props(new Creator() {
- * public MyActor create() { ... }
- * }, "name");
+ * system.actorOf(Props.create(MyActor.class), "name");
+ * system.actorOf(Props.create(MyActor.class, arg1, arg2), "name");
* }}}
*
* Where no name is given explicitly, one will be automatically generated.
diff --git a/akka-actor/src/main/scala/akka/actor/Deployer.scala b/akka-actor/src/main/scala/akka/actor/Deployer.scala
index a9a93c4a88..c3d728fc25 100644
--- a/akka-actor/src/main/scala/akka/actor/Deployer.scala
+++ b/akka-actor/src/main/scala/akka/actor/Deployer.scala
@@ -29,7 +29,7 @@ object Deploy {
* not needed when just doing deploy-as-you-go:
*
* {{{
- * context.actorOf(someProps, "someName", Deploy(scope = RemoteScope("someOtherNodeName")))
+ * val remoteProps = someProps.withDeploy(Deploy(scope = RemoteScope("someOtherNodeName")))
* }}}
*/
@SerialVersionUID(1L)
@@ -62,7 +62,12 @@ final case class Deploy(
*/
def withFallback(other: Deploy): Deploy = {
val disp = if (dispatcher == Deploy.NoDispatcherGiven) other.dispatcher else dispatcher
- Deploy(path, config.withFallback(other.config), routerConfig.withFallback(other.routerConfig), scope.withFallback(other.scope), disp)
+ Deploy(
+ path,
+ config.withFallback(other.config),
+ routerConfig.withFallback(other.routerConfig),
+ scope.withFallback(other.scope),
+ disp)
}
}
diff --git a/akka-actor/src/main/scala/akka/actor/FaultHandling.scala b/akka-actor/src/main/scala/akka/actor/FaultHandling.scala
index 93dc032440..a6e3febbff 100644
--- a/akka-actor/src/main/scala/akka/actor/FaultHandling.scala
+++ b/akka-actor/src/main/scala/akka/actor/FaultHandling.scala
@@ -115,7 +115,8 @@ object SupervisorStrategy extends SupervisorStrategyLowPriorityImplicits {
/**
* Escalates the failure to the supervisor of the supervisor,
- * by rethrowing the cause of the failure.
+ * by rethrowing the cause of the failure, i.e. the supervisor fails with
+ * the same exception as the child.
*/
case object Escalate extends Directive
@@ -132,14 +133,13 @@ object SupervisorStrategy extends SupervisorStrategyLowPriorityImplicits {
/**
* Java API: Returning this directive stops the Actor
- * Java API
*/
def stop = Stop
/**
* Java API: Returning this directive escalates the failure to the supervisor of the supervisor,
- * by rethrowing the cause of the failure.
- * Java API
+ * by rethrowing the cause of the failure, i.e. the supervisor fails with
+ * the same exception as the child.
*/
def escalate = Escalate
diff --git a/akka-actor/src/main/scala/akka/actor/Props.scala b/akka-actor/src/main/scala/akka/actor/Props.scala
index 07181c4f99..90aacdb7ff 100644
--- a/akka-actor/src/main/scala/akka/actor/Props.scala
+++ b/akka-actor/src/main/scala/akka/actor/Props.scala
@@ -9,13 +9,16 @@ import akka.japi.Creator
import scala.reflect.ClassTag
import akka.routing._
import akka.util.Reflect
+import scala.annotation.varargs
+import Deploy.NoDispatcherGiven
+import scala.collection.immutable
/**
* Factory for Props instances.
*
* Props is a ActorRef configuration object, that is immutable, so it is thread safe and fully sharable.
*
- * Used when creating new actors through; ActorSystem.actorOf and ActorContext.actorOf.
+ * Used when creating new actors through ActorSystem.actorOf and ActorContext.actorOf.
*/
object Props {
@@ -34,30 +37,32 @@ object Props {
*/
final val defaultDeploy = Deploy()
- /**
- * A Props instance whose creator will create an actor that doesn't respond to any message
- */
- final val empty = new Props(() ⇒ new Actor { def receive = Actor.emptyBehavior })
-
/**
* The default Props instance, uses the settings from the Props object starting with default*.
*/
final val default = new Props()
+ /**
+ * A Props instance whose creator will create an actor that doesn't respond to any message
+ */
+ final val empty = Props[EmptyActor]
+
+ /**
+ * INTERNAL API
+ *
+ * (Not because it is so immensely complicated, only because we might remove it if no longer needed internally)
+ */
+ private[akka] class EmptyActor extends Actor {
+ def receive = Actor.emptyBehavior
+ }
+
/**
* Returns a Props that has default values except for "creator" which will be a function that creates an instance
* of the supplied type using the default constructor.
*
* Scala API.
*/
- def apply[T <: Actor: ClassTag](): Props =
- default.withCreator(implicitly[ClassTag[T]].runtimeClass.asInstanceOf[Class[_ <: Actor]])
-
- /**
- * Returns a Props that has default values except for "creator" which will be a function that creates an instance
- * of the supplied class using the default constructor.
- */
- def apply(actorClass: Class[_ <: Actor]): Props = default.withCreator(actorClass)
+ def apply[T <: Actor: ClassTag](): Props = apply(implicitly[ClassTag[T]].runtimeClass)
/**
* Returns a Props that has default values except for "creator" which will be a function that creates an instance
@@ -65,116 +70,242 @@ object Props {
*
* Scala API.
*/
+ @deprecated("give class and arguments instead", "2.2")
def apply(creator: ⇒ Actor): Props = default.withCreator(creator)
/**
* Returns a Props that has default values except for "creator" which will be a function that creates an instance
* using the supplied thunk.
*/
+ @deprecated("give class and arguments instead", "2.2")
def apply(creator: Creator[_ <: Actor]): Props = default.withCreator(creator.create)
+
+ /**
+ * The deprecated legacy constructor.
+ */
+ @deprecated("give class and arguments instead", "2.2")
+ def apply(
+ creator: () ⇒ Actor = Props.defaultCreator,
+ dispatcher: String = Dispatchers.DefaultDispatcherId,
+ routerConfig: RouterConfig = Props.defaultRoutedProps,
+ deploy: Deploy = Props.defaultDeploy): Props = {
+
+ val d1 = if (dispatcher != Dispatchers.DefaultDispatcherId) deploy.copy(dispatcher = dispatcher) else deploy
+ val d2 = if (routerConfig != Props.defaultRoutedProps) d1.copy(routerConfig = routerConfig) else d1
+ val p = Props(classOf[CreatorFunctionConsumer], creator)
+ if (d2 != Props.defaultDeploy) p.withDeploy(d2) else p
+ }
+
+ /**
+ * Scala API: create a Props given a class and its constructor arguments.
+ */
+ def apply(clazz: Class[_], args: Any*): Props = apply(defaultDeploy, clazz, args.toVector)
+
+ /**
+ * Java API: create a Props given a class and its constructor arguments.
+ */
+ @varargs
+ def create(clazz: Class[_], args: AnyRef*): Props = apply(defaultDeploy, clazz, args.toVector)
}
/**
- * Props is a ActorRef configuration object, that is immutable, so it is thread safe and fully sharable.
- * Used when creating new actors through; ActorSystem.actorOf and ActorContext.actorOf.
- *
- * In case of providing code which creates the actual Actor instance, that must not return the same instance multiple times.
+ * Props is a configuration object using in creating an [[Actor]]; it is
+ * immutable, so it is thread-safe and fully shareable.
*
* Examples on Scala API:
* {{{
+ * val props = Props.empty
* val props = Props[MyActor]
- * val props = Props(new MyActor)
- * val props = Props(
- * creator = ..,
- * dispatcher = ..,
- * routerConfig = ..
- * )
- * val props = Props().withCreator(new MyActor)
- * val props = Props[MyActor].withRouter(RoundRobinRouter(..))
+ * val props = Props(classOf[MyActor], arg1, arg2)
+ *
+ * val otherProps = props.withDispatcher("dispatcher-id")
+ * val otherProps = props.withDeploy()
* }}}
*
* Examples on Java API:
* {{{
- * Props props = new Props();
- * Props props = new Props(MyActor.class);
- * Props props = new Props(new UntypedActorFactory() {
- * public UntypedActor create() {
- * return new MyActor();
- * }
- * });
- * Props props = new Props().withCreator(new UntypedActorFactory() { ... });
- * Props props = new Props(MyActor.class).withRouter(new RoundRobinRouter(..));
+ * final Props props = Props.empty();
+ * final Props props = Props.create(MyActor.class, arg1, arg2);
+ *
+ * final Props otherProps = props.withDispatcher("dispatcher-id");
+ * final Props otherProps = props.withDeploy();
* }}}
*/
-@SerialVersionUID(1L)
-case class Props(
- creator: () ⇒ Actor = Props.defaultCreator,
- dispatcher: String = Dispatchers.DefaultDispatcherId,
- routerConfig: RouterConfig = Props.defaultRoutedProps,
- deploy: Deploy = Props.defaultDeploy) {
+@SerialVersionUID(2L)
+case class Props(deploy: Deploy, clazz: Class[_], args: immutable.Seq[Any]) {
+
+ // validate constructor signature; throws IllegalArgumentException if invalid
+ Reflect.findConstructor(clazz, args)
/**
* No-args constructor that sets all the default values.
+ *
+ * @deprecated use `Props.create(clazz, args ...)` instead
*/
- def this() = this(
- creator = Props.defaultCreator,
- dispatcher = Dispatchers.DefaultDispatcherId)
+ @deprecated("use Props.create()", "2.2")
+ def this() = this(Props.defaultDeploy, classOf[CreatorFunctionConsumer], Vector(Props.defaultCreator))
/**
* Java API: create Props from an [[UntypedActorFactory]]
+ *
+ * @deprecated use `Props.create(clazz, args ...)` instead; this method has been
+ * deprecated because it encourages creating Props which contain
+ * non-serializable inner classes, making them also
+ * non-serializable
*/
- def this(factory: UntypedActorFactory) = this(
- creator = () ⇒ factory.create(),
- dispatcher = Dispatchers.DefaultDispatcherId)
+ @deprecated("use constructor which takes the actor class directly", "2.2")
+ def this(factory: UntypedActorFactory) = this(Props.defaultDeploy, classOf[UntypedActorFactoryConsumer], Vector(factory))
/**
* Java API: create Props from a given [[Class]]
+ *
+ * @deprecated use Props.create(clazz) instead; deprecated since it duplicates
+ * another API
*/
- def this(actorClass: Class[_ <: Actor]) = this(
- creator = FromClassCreator(actorClass),
- dispatcher = Dispatchers.DefaultDispatcherId,
- routerConfig = Props.defaultRoutedProps)
+ @deprecated("use Props.create()", "2.2")
+ def this(actorClass: Class[_ <: Actor]) = this(Props.defaultDeploy, actorClass, Vector.empty)
+
+ @deprecated("use newActor()", "2.2")
+ def creator: () ⇒ Actor = newActor
+
+ /**
+ * Convenience method for extracting the dispatcher information from the
+ * contained [[Deploy]] instance.
+ */
+ def dispatcher: String = deploy.dispatcher match {
+ case NoDispatcherGiven ⇒ Dispatchers.DefaultDispatcherId
+ case x ⇒ x
+ }
+
+ /**
+ * Convenience method for extracting the router configuration from the
+ * contained [[Deploy]] instance.
+ */
+ def routerConfig: RouterConfig = deploy.routerConfig
/**
* Scala API: Returns a new Props with the specified creator set.
*
* The creator must not return the same instance multiple times.
*/
- def withCreator(c: ⇒ Actor): Props = copy(creator = () ⇒ c)
+ @deprecated("move actor into named class and use withCreator(clazz)", "2.2")
+ def withCreator(c: ⇒ Actor): Props = copy(clazz = classOf[CreatorFunctionConsumer], args = Vector(() ⇒ c))
/**
* Java API: Returns a new Props with the specified creator set.
*
* The creator must not return the same instance multiple times.
+ *
+ * @deprecated use `Props.create(clazz, args ...)` instead; this method has been
+ * deprecated because it encourages creating Props which contain
+ * non-serializable inner classes, making them also
+ * non-serializable
*/
- def withCreator(c: Creator[Actor]): Props = copy(creator = () ⇒ c.create)
+ @deprecated("use Props.create(clazz, args ...) instead", "2.2")
+ def withCreator(c: Creator[Actor]): Props = copy(clazz = classOf[CreatorConsumer], args = Vector(c))
/**
- * Java API: Returns a new Props with the specified creator set.
+ * Returns a new Props with the specified creator set.
+ *
+ * @deprecated use Props.create(clazz) instead; deprecated since it duplicates
+ * another API
*/
- def withCreator(c: Class[_ <: Actor]): Props = copy(creator = FromClassCreator(c))
+ @deprecated("use Props(clazz, args).withDeploy(other.deploy)", "2.2")
+ def withCreator(c: Class[_ <: Actor]): Props = copy(clazz = c, args = Vector.empty)
/**
* Returns a new Props with the specified dispatcher set.
*/
- def withDispatcher(d: String): Props = copy(dispatcher = d)
+ def withDispatcher(d: String): Props = copy(deploy = deploy.copy(dispatcher = d))
/**
* Returns a new Props with the specified router config set.
*/
- def withRouter(r: RouterConfig): Props = copy(routerConfig = r)
+ def withRouter(r: RouterConfig): Props = copy(deploy = deploy.copy(routerConfig = r))
/**
* Returns a new Props with the specified deployment configuration.
*/
- def withDeploy(d: Deploy): Props = copy(deploy = d)
+ def withDeploy(d: Deploy): Props = copy(deploy = d withFallback deploy)
+ /**
+ * Create a new actor instance. This method is only useful when called during
+ * actor creation by the ActorSystem, i.e. for user-level code it can only be
+ * used within the implementation of [[IndirectActorProducer#produce]].
+ */
+ def newActor(): Actor = {
+ Reflect.instantiate(clazz, args) match {
+ case a: Actor ⇒ a
+ case i: IndirectActorProducer ⇒ i.produce()
+ case _ ⇒ throw new IllegalArgumentException(s"unknown actor creator [$clazz]")
+ }
+ }
+
+ /**
+ * Obtain an upper-bound approximation of the actor class which is going to
+ * be created by these Props. In other words, the [[#newActor]] method will
+ * produce an instance of this class or a subclass thereof. This is used by
+ * the actor system to select special dispatchers or mailboxes in case
+ * dependencies are encoded in the actor type.
+ */
+ def actorClass(): Class[_ <: Actor] = {
+ if (classOf[IndirectActorProducer].isAssignableFrom(clazz)) {
+ Reflect.instantiate(clazz, args).asInstanceOf[IndirectActorProducer].actorClass
+ } else if (classOf[Actor].isAssignableFrom(clazz)) {
+ clazz.asInstanceOf[Class[_ <: Actor]]
+ } else {
+ throw new IllegalArgumentException("unknown actor creator [$clazz]")
+ }
+ }
}
/**
- * Used when creating an Actor from a class. Special Function0 to be
- * able to optimize serialization.
+ * This interface defines a class of actor creation strategies deviating from
+ * the usual default of just reflectively instantiating the [[Actor]]
+ * subclass. It can be used to allow a dependency injection framework to
+ * determine the actual actor class and how it shall be instantiated.
*/
-private[akka] case class FromClassCreator(clazz: Class[_ <: Actor]) extends Function0[Actor] {
- def apply(): Actor = Reflect.instantiate(clazz)
+trait IndirectActorProducer {
+
+ /**
+ * This factory method must produce a fresh actor instance upon each
+ * invocation. It is not permitted to return the same instance more than
+ * once.
+ */
+ def produce(): Actor
+
+ /**
+ * This method is used by [[Props]] to determine the type of actor which will
+ * be created. This means that an instance of this `IndirectActorProducer`
+ * will be created in order to call this method during any call to
+ * [[Props#actorClass]]; it should be noted that such calls may
+ * performed during actor set-up before the actual actor’s instantiation, and
+ * that the instance created for calling `actorClass` is not necessarily reused
+ * later to produce the actor.
+ */
+ def actorClass: Class[_ <: Actor]
+}
+
+/**
+ * INTERNAL API
+ */
+private[akka] class UntypedActorFactoryConsumer(factory: UntypedActorFactory) extends IndirectActorProducer {
+ override def actorClass = classOf[Actor]
+ override def produce() = factory.create()
+}
+
+/**
+ * INTERNAL API
+ */
+private[akka] class CreatorFunctionConsumer(creator: () ⇒ Actor) extends IndirectActorProducer {
+ override def actorClass = classOf[Actor]
+ override def produce() = creator()
+}
+
+/**
+ * INTERNAL API
+ */
+private[akka] class CreatorConsumer(creator: Creator[Actor]) extends IndirectActorProducer {
+ override def actorClass = classOf[Actor]
+ override def produce() = creator.create()
}
diff --git a/akka-actor/src/main/scala/akka/actor/UntypedActor.scala b/akka-actor/src/main/scala/akka/actor/UntypedActor.scala
index 741d74feda..23fed1d819 100644
--- a/akka-actor/src/main/scala/akka/actor/UntypedActor.scala
+++ b/akka-actor/src/main/scala/akka/actor/UntypedActor.scala
@@ -71,11 +71,11 @@ import akka.japi.{ Creator }
*
* } else if (msg.equals("ErrorKernelWithDirectReply")) {
* // Send work to one-off child which will reply directly to original sender
- * getContext().actorOf(new Props(Worker.class)).tell("DoSomeDangerousWork", getSender());
+ * getContext().actorOf(Props.create(Worker.class)).tell("DoSomeDangerousWork", getSender());
*
* } else if (msg.equals("ErrorKernelWithReplyHere")) {
* // Send work to one-off child and collect the answer, reply handled further down
- * getContext().actorOf(new Props(Worker.class)).tell("DoWorkAndReplyToMe");
+ * getContext().actorOf(Props.create(Worker.class)).tell("DoWorkAndReplyToMe", getSelf());
*
* } else throw new IllegalArgumentException("Unknown message: " + message);
*
@@ -166,4 +166,5 @@ abstract class UntypedActor extends Actor {
/**
* Factory closure for an UntypedActor, to be used with 'Actors.actorOf(factory)'.
*/
+@deprecated("use Props.create(clazz, args) instead", "2.2")
trait UntypedActorFactory extends Creator[Actor] with Serializable
diff --git a/akka-actor/src/main/scala/akka/actor/dungeon/Children.scala b/akka-actor/src/main/scala/akka/actor/dungeon/Children.scala
index c419f1a14f..2281243b92 100644
--- a/akka-actor/src/main/scala/akka/actor/dungeon/Children.scala
+++ b/akka-actor/src/main/scala/akka/actor/dungeon/Children.scala
@@ -168,9 +168,11 @@ private[akka] trait Children { this: ActorCell ⇒
}
private def makeChild(cell: ActorCell, props: Props, name: String, async: Boolean, systemService: Boolean): ActorRef = {
- if (cell.system.settings.SerializeAllCreators && !props.creator.isInstanceOf[NoSerializationVerificationNeeded]) {
+ if (cell.system.settings.SerializeAllCreators) {
val ser = SerializationExtension(cell.system)
- ser.deserialize(ser.serialize(props.creator).get, props.creator.getClass).get
+ props.args forall (arg ⇒
+ arg.isInstanceOf[NoSerializationVerificationNeeded] ||
+ ser.deserialize(ser.serialize(arg.asInstanceOf[AnyRef]).get, arg.getClass).get != null)
}
/*
* in case we are currently terminating, fail external attachChild requests
diff --git a/akka-actor/src/main/scala/akka/routing/Routing.scala b/akka-actor/src/main/scala/akka/routing/Routing.scala
index 69f41fcbbf..9dc2088a0e 100644
--- a/akka-actor/src/main/scala/akka/routing/Routing.scala
+++ b/akka-actor/src/main/scala/akka/routing/Routing.scala
@@ -39,11 +39,20 @@ private[akka] class RoutedActorRef(_system: ActorSystemImpl, _props: Props, _sup
}
+private[akka] object RoutedActorCell {
+ class RouterCreator(routerConfig: RouterConfig) extends IndirectActorProducer {
+ override def actorClass = classOf[Router]
+ override def produce() = routerConfig.createActor()
+ }
+}
+
private[akka] class RoutedActorCell(_system: ActorSystemImpl, _ref: InternalActorRef, _props: Props, _supervisor: InternalActorRef)
extends ActorCell(
_system,
_ref,
- _props.copy(creator = () ⇒ _props.routerConfig.createActor(), dispatcher = _props.routerConfig.routerDispatcher),
+ _props.copy(
+ deploy = _props.deploy.copy(dispatcher = _props.routerConfig.routerDispatcher),
+ classOf[RoutedActorCell.RouterCreator], Vector(_props.routerConfig)),
_supervisor) {
private[akka] val routerConfig = _props.routerConfig
@@ -59,7 +68,7 @@ private[akka] class RoutedActorCell(_system: ActorSystemImpl, _ref: InternalActo
def routeeProvider = _routeeProvider
val route = {
- val routeeProps = _props.copy(routerConfig = NoRouter)
+ val routeeProps = _props.withRouter(NoRouter)
_routeeProvider = routerConfig.createRouteeProvider(this, routeeProps)
val r = routerConfig.createRoute(routeeProvider)
// initial resize, before message send
diff --git a/akka-actor/src/main/scala/akka/util/Reflect.scala b/akka-actor/src/main/scala/akka/util/Reflect.scala
index 5761fe5dd3..b3f67381ab 100644
--- a/akka-actor/src/main/scala/akka/util/Reflect.scala
+++ b/akka-actor/src/main/scala/akka/util/Reflect.scala
@@ -3,6 +3,8 @@
*/
package akka.util
import scala.util.control.NonFatal
+import java.lang.reflect.Constructor
+import scala.collection.immutable
/**
* Collection of internal reflection utilities which may or may not be
@@ -43,6 +45,42 @@ private[akka] object Reflect {
ctor.newInstance()
}
+ /**
+ * INTERNAL API
+ * Calls findConstructor and invokes it with the given arguments.
+ */
+ private[akka] def instantiate[T](clazz: Class[T], args: immutable.Seq[Any]): T = {
+ val constructor = findConstructor(clazz, args)
+ constructor.setAccessible(true)
+ try constructor.newInstance(args.asInstanceOf[Seq[AnyRef]]: _*)
+ catch {
+ case e: IllegalArgumentException ⇒
+ val argString = args map (_.getClass) mkString ("[", ", ", "]")
+ throw new IllegalArgumentException(s"constructor $constructor is incompatible with arguments $argString", e)
+ }
+ }
+
+ /**
+ * INTERNAL API
+ * Implements a primitive form of overload resolution a.k.a. finding the
+ * right constructor.
+ */
+ private[akka] def findConstructor[T](clazz: Class[T], args: immutable.Seq[Any]): Constructor[T] = {
+ def error(msg: String): Nothing = {
+ val argClasses = args map (_.getClass) mkString ", "
+ throw new IllegalArgumentException(s"$msg found on $clazz for arguments [$argClasses]")
+ }
+ val candidates =
+ clazz.getDeclaredConstructors filter (c ⇒
+ c.getParameterTypes.length == args.length &&
+ (c.getParameterTypes zip args forall {
+ case (found, required) ⇒ found.isInstance(required) || BoxedType(found).isInstance(required)
+ }))
+ if (candidates.size == 1) candidates.head.asInstanceOf[Constructor[T]]
+ else if (candidates.size > 1) error("multiple matching constructors")
+ else error("no matching constructor")
+ }
+
/**
* INTERNAL API
* @param clazz the class which to instantiate an instance of
diff --git a/akka-camel/src/test/scala/akka/camel/ConcurrentActivationTest.scala b/akka-camel/src/test/scala/akka/camel/ConcurrentActivationTest.scala
index 7d014f8a8c..9bf577a893 100644
--- a/akka-camel/src/test/scala/akka/camel/ConcurrentActivationTest.scala
+++ b/akka-camel/src/test/scala/akka/camel/ConcurrentActivationTest.scala
@@ -99,7 +99,7 @@ class ConsumerBroadcast(promise: Promise[(Future[List[List[ActorRef]]], Future[L
}
promise.success(Future.sequence(allActivationFutures) -> Future.sequence(allDeactivationFutures))
- broadcaster = Some(context.actorOf(Props[Registrar] withRouter (BroadcastRouter(routees)), "registrarRouter"))
+ broadcaster = Some(context.actorOf(Props.empty withRouter (BroadcastRouter(routees)), "registrarRouter"))
case reg: Any ⇒
broadcaster.foreach(_.forward(reg))
}
diff --git a/akka-contrib/src/main/scala/akka/contrib/pattern/ReliableProxy.scala b/akka-contrib/src/main/scala/akka/contrib/pattern/ReliableProxy.scala
index f34b73d589..f958ac0a80 100644
--- a/akka-contrib/src/main/scala/akka/contrib/pattern/ReliableProxy.scala
+++ b/akka-contrib/src/main/scala/akka/contrib/pattern/ReliableProxy.scala
@@ -74,16 +74,17 @@ import ReliableProxy._
* situations or other VM errors).
*
* You can create a reliable connection like this:
+ *
+ * In Scala:
+ *
* {{{
- * val proxy = context.actorOf(Props(new ReliableProxy(target)))
+ * val proxy = context.actorOf(Props(classOf[ReliableProxy], target))
* }}}
- * or in Java:
+ *
+ * In Java:
+ *
* {{{
- * final ActorRef proxy = getContext().actorOf(new Props(new UntypedActorFactory() {
- * public Actor create() {
- * return new ReliableProxy(target);
- * }
- * }));
+ * final ActorRef proxy = getContext().actorOf(Props.create(ReliableProxy.class target));
* }}}
*
* '''''Please note:''''' the tunnel is uni-directional, and original sender
diff --git a/akka-contrib/src/main/scala/akka/contrib/throttle/TimerBasedThrottler.scala b/akka-contrib/src/main/scala/akka/contrib/throttle/TimerBasedThrottler.scala
index 01003aff3d..709c1ee8cd 100644
--- a/akka-contrib/src/main/scala/akka/contrib/throttle/TimerBasedThrottler.scala
+++ b/akka-contrib/src/main/scala/akka/contrib/throttle/TimerBasedThrottler.scala
@@ -160,13 +160,17 @@ object TimerBasedThrottler {
* sending out further messages:
* {{{
* // A simple actor that prints whatever it receives
- * val printer = system.actorOf(Props(new Actor {
+ * class Printer extends Actor {
* def receive = {
* case x => println(x)
* }
- * }))
+ * }
+ *
+ * val printer = system.actorOf(Props[Printer], "printer")
+ *
* // The throttler for this example, setting the rate
- * val throttler = system.actorOf(Props(new TimerBasedThrottler(3 msgsPer (1.second))))
+ * val throttler = system.actorOf(Props(classOf[TimerBasedThrottler], 3 msgsPer 1.second))
+ *
* // Set the target
* throttler ! SetTarget(Some(printer))
* // These three messages will be sent to the printer immediately
diff --git a/akka-docs/rst/general/supervision.rst b/akka-docs/rst/general/supervision.rst
index 88097a5b88..3c65ae44d8 100644
--- a/akka-docs/rst/general/supervision.rst
+++ b/akka-docs/rst/general/supervision.rst
@@ -23,7 +23,7 @@ a choice of the following four options:
#. Resume the subordinate, keeping its accumulated internal state
#. Restart the subordinate, clearing out its accumulated internal state
#. Terminate the subordinate permanently
-#. Escalate the failure
+#. Escalate the failure, thereby failing itself
It is important to always view an actor as part of a supervision hierarchy,
which explains the existence of the fourth choice (as a supervisor also is
diff --git a/akka-docs/rst/java/code/docs/actor/FSMDocTestBase.java b/akka-docs/rst/java/code/docs/actor/FSMDocTestBase.java
index 91bd5af888..467e012010 100644
--- a/akka-docs/rst/java/code/docs/actor/FSMDocTestBase.java
+++ b/akka-docs/rst/java/code/docs/actor/FSMDocTestBase.java
@@ -186,7 +186,7 @@ public class FSMDocTestBase {
@org.junit.Test
public void mustBunch() {
- final ActorRef buncher = system.actorOf(new Props(MyFSM.class));
+ final ActorRef buncher = system.actorOf(Props.create(MyFSM.class));
final TestProbe probe = new TestProbe(system);
buncher.tell(new SetTarget(probe.ref()), null);
buncher.tell(new Queue(1), null);
diff --git a/akka-docs/rst/java/code/docs/actor/FaultHandlingTestBase.java b/akka-docs/rst/java/code/docs/actor/FaultHandlingTestBase.java
index 5de6a2eb31..b2ae8df06c 100644
--- a/akka-docs/rst/java/code/docs/actor/FaultHandlingTestBase.java
+++ b/akka-docs/rst/java/code/docs/actor/FaultHandlingTestBase.java
@@ -30,7 +30,6 @@ import static java.util.concurrent.TimeUnit.SECONDS;
import static akka.japi.Util.immutableSeq;
import akka.japi.Function;
import scala.Option;
-import scala.collection.JavaConverters;
import scala.collection.immutable.Seq;
import org.junit.Test;
@@ -171,10 +170,10 @@ public class FaultHandlingTestBase {
system.eventStream().publish(new TestEvent.Mute(ignoreExceptions));
//#create
- Props superprops = new Props(Supervisor.class);
+ Props superprops = Props.create(Supervisor.class);
ActorRef supervisor = system.actorOf(superprops, "supervisor");
ActorRef child = (ActorRef) Await.result(ask(supervisor,
- new Props(Child.class), 5000), timeout);
+ Props.create(Child.class), 5000), timeout);
//#create
//#resume
@@ -198,7 +197,7 @@ public class FaultHandlingTestBase {
//#escalate-kill
child = (ActorRef) Await.result(ask(supervisor,
- new Props(Child.class), 5000), timeout);
+ Props.create(Child.class), 5000), timeout);
probe.watch(child);
assert Await.result(ask(child, "get", 5000), timeout).equals(0);
child.tell(new Exception(), null);
@@ -206,10 +205,10 @@ public class FaultHandlingTestBase {
//#escalate-kill
//#escalate-restart
- superprops = new Props(Supervisor2.class);
+ superprops = Props.create(Supervisor2.class);
supervisor = system.actorOf(superprops);
child = (ActorRef) Await.result(ask(supervisor,
- new Props(Child.class), 5000), timeout);
+ Props.create(Child.class), 5000), timeout);
child.tell(23, null);
assert Await.result(ask(child, "get", 5000), timeout).equals(23);
child.tell(new Exception(), null);
@@ -219,6 +218,7 @@ public class FaultHandlingTestBase {
}
//#testkit
+ @SuppressWarnings("unchecked")
public Seq seq(A... args) {
return immutableSeq(args);
}
diff --git a/akka-docs/rst/java/code/docs/actor/FirstUntypedActor.java b/akka-docs/rst/java/code/docs/actor/FirstUntypedActor.java
index 3512449aaf..eefe49c5c9 100644
--- a/akka-docs/rst/java/code/docs/actor/FirstUntypedActor.java
+++ b/akka-docs/rst/java/code/docs/actor/FirstUntypedActor.java
@@ -10,7 +10,7 @@ import akka.actor.UntypedActor;
//#context-actorOf
public class FirstUntypedActor extends UntypedActor {
- ActorRef myActor = getContext().actorOf(new Props(MyActor.class), "myactor");
+ ActorRef myActor = getContext().actorOf(Props.create(MyActor.class), "myactor");
//#context-actorOf
diff --git a/akka-docs/rst/java/code/docs/actor/InitializationDocSpecJava.java b/akka-docs/rst/java/code/docs/actor/InitializationDocSpecJava.java
index fd9f7d3575..864a2b7848 100644
--- a/akka-docs/rst/java/code/docs/actor/InitializationDocSpecJava.java
+++ b/akka-docs/rst/java/code/docs/actor/InitializationDocSpecJava.java
@@ -78,7 +78,7 @@ public class InitializationDocSpecJava {
public void testIt() {
new JavaTestKit(system) {{
- ActorRef testactor = system.actorOf(new Props(MessageInitExample.class), "testactor");
+ ActorRef testactor = system.actorOf(Props.create(MessageInitExample.class), "testactor");
String probe = "U OK?";
testactor.tell(probe, getRef());
diff --git a/akka-docs/rst/java/code/docs/actor/MyReceivedTimeoutUntypedActor.java b/akka-docs/rst/java/code/docs/actor/MyReceiveTimeoutUntypedActor.java
similarity index 58%
rename from akka-docs/rst/java/code/docs/actor/MyReceivedTimeoutUntypedActor.java
rename to akka-docs/rst/java/code/docs/actor/MyReceiveTimeoutUntypedActor.java
index 1fcbe72036..a6e6db4daa 100644
--- a/akka-docs/rst/java/code/docs/actor/MyReceivedTimeoutUntypedActor.java
+++ b/akka-docs/rst/java/code/docs/actor/MyReceiveTimeoutUntypedActor.java
@@ -4,13 +4,16 @@
package docs.actor;
//#receive-timeout
+import akka.actor.ActorRef;
import akka.actor.ReceiveTimeout;
import akka.actor.UntypedActor;
import scala.concurrent.duration.Duration;
-public class MyReceivedTimeoutUntypedActor extends UntypedActor {
+public class MyReceiveTimeoutUntypedActor extends UntypedActor {
+
+ ActorRef target = getContext().system().deadLetters();
- public MyReceivedTimeoutUntypedActor() {
+ public MyReceiveTimeoutUntypedActor() {
// To set an initial delay
getContext().setReceiveTimeout(Duration.create("30 seconds"));
}
@@ -18,12 +21,13 @@ public class MyReceivedTimeoutUntypedActor extends UntypedActor {
public void onReceive(Object message) {
if (message.equals("Hello")) {
// To set in a response to a message
- getContext().setReceiveTimeout(Duration.create("10 seconds"));
- getSender().tell("Hello world", getSelf());
- } else if (message == ReceiveTimeout.getInstance()) {
+ getContext().setReceiveTimeout(Duration.create("1 second"));
+ target = getSender();
+ target.tell("Hello world", getSelf());
+ } else if (message instanceof ReceiveTimeout) {
// To turn it off
getContext().setReceiveTimeout(Duration.Undefined());
- throw new RuntimeException("received timeout");
+ target.tell("timeout", getSelf());
} else {
unhandled(message);
}
diff --git a/akka-docs/rst/java/code/docs/actor/MyUntypedActor.java b/akka-docs/rst/java/code/docs/actor/MyUntypedActor.java
index 0388913b9e..fc8f7ce68a 100644
--- a/akka-docs/rst/java/code/docs/actor/MyUntypedActor.java
+++ b/akka-docs/rst/java/code/docs/actor/MyUntypedActor.java
@@ -12,9 +12,10 @@ public class MyUntypedActor extends UntypedActor {
LoggingAdapter log = Logging.getLogger(getContext().system(), this);
public void onReceive(Object message) throws Exception {
- if (message instanceof String)
+ if (message instanceof String) {
log.info("Received String message: {}", message);
- else
+ getSender().tell(message, getSelf());
+ } else
unhandled(message);
}
}
diff --git a/akka-docs/rst/java/code/docs/actor/SchedulerDocTestBase.java b/akka-docs/rst/java/code/docs/actor/SchedulerDocTestBase.java
index cfbdec80b0..ac2e8c5f87 100644
--- a/akka-docs/rst/java/code/docs/actor/SchedulerDocTestBase.java
+++ b/akka-docs/rst/java/code/docs/actor/SchedulerDocTestBase.java
@@ -10,9 +10,7 @@ import java.util.concurrent.TimeUnit;
//#imports1
//#imports2
-import akka.actor.Actor;
import akka.actor.UntypedActor;
-import akka.actor.UntypedActorFactory;
import akka.actor.Cancellable;
//#imports2
@@ -32,7 +30,7 @@ public class SchedulerDocTestBase {
@Before
public void setUp() {
system = ActorSystem.create("MySystem", AkkaSpec.testConf());
- testActor = system.actorOf(new Props(MyUntypedActor.class));
+ testActor = system.actorOf(Props.create(MyUntypedActor.class));
}
@After
@@ -61,20 +59,18 @@ public class SchedulerDocTestBase {
@Test
public void scheduleRecurringTask() {
//#schedule-recurring
- ActorRef tickActor = system.actorOf(new Props().withCreator(
- new UntypedActorFactory() {
- public UntypedActor create() {
- return new UntypedActor() {
- public void onReceive(Object message) {
- if (message.equals("Tick")) {
- // Do someting
- } else {
- unhandled(message);
- }
- }
- };
+ class Ticker extends UntypedActor {
+ @Override
+ public void onReceive(Object message) {
+ if (message.equals("Tick")) {
+ // Do someting
+ } else {
+ unhandled(message);
}
- }));
+ }
+ }
+
+ ActorRef tickActor = system.actorOf(Props.create(Ticker.class, this));
//This will schedule to send the Tick-message
//to the tickActor after 0ms repeating every 50ms
diff --git a/akka-docs/rst/java/code/docs/actor/UntypedActorDocTestBase.java b/akka-docs/rst/java/code/docs/actor/UntypedActorDocTestBase.java
index 3e4c1da006..f58f1b82cf 100644
--- a/akka-docs/rst/java/code/docs/actor/UntypedActorDocTestBase.java
+++ b/akka-docs/rst/java/code/docs/actor/UntypedActorDocTestBase.java
@@ -3,74 +3,82 @@
*/
package docs.actor;
-//#imports
-import akka.actor.ActorRef;
-import akka.actor.ActorSystem;
-import akka.actor.Props;
-//#imports
-
-//#import-future
-import scala.concurrent.Future;
-import akka.dispatch.Futures;
-import akka.dispatch.Mapper;
-import scala.concurrent.Await;
-import scala.concurrent.duration.Duration;
-import akka.testkit.AkkaSpec;
-import akka.util.Timeout;
-//#import-future
-
-//#import-actors
-import akka.actor.PoisonPill;
-import akka.actor.Kill;
-//#import-actors
-
-//#import-procedure
-import akka.japi.Procedure;
-//#import-procedure
-
-//#import-watch
-import akka.actor.Terminated;
-//#import-watch
-
-//#import-identify
-import akka.actor.ActorSelection;
-import akka.actor.Identify;
-import akka.actor.ActorIdentity;
-//#import-identify
-
-//#import-gracefulStop
-import static akka.pattern.Patterns.gracefulStop;
-import scala.concurrent.Future;
-import scala.concurrent.Await;
-import scala.concurrent.duration.Duration;
-import akka.pattern.AskTimeoutException;
-//#import-gracefulStop
-
-//#import-askPipe
+//#import-ask
import static akka.pattern.Patterns.ask;
import static akka.pattern.Patterns.pipe;
-import scala.concurrent.Future;
-import akka.dispatch.Futures;
-import scala.concurrent.duration.Duration;
-import akka.util.Timeout;
-import java.util.concurrent.TimeUnit;
-import java.util.ArrayList;
-//#import-askPipe
+//#import-ask
+//#import-gracefulStop
+import static akka.pattern.Patterns.gracefulStop;
+//#import-gracefulStop
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+//#import-gracefulStop
+import scala.concurrent.Await;
+//#import-ask
+import scala.concurrent.Future;
+import scala.concurrent.duration.Duration;
+//#import-ask
+//#import-gracefulStop
+//#import-indirect
+import akka.actor.Actor;
+//#import-indirect
+//#import-identify
+import akka.actor.ActorIdentity;
+//#import-identify
+import akka.actor.ActorKilledException;
+//#import-identify
+import akka.actor.ActorSelection;
+//#import-identify
+//#import-actorRef
+import akka.actor.ActorRef;
+import akka.actor.ActorSystem;
+//#import-actorRef
+//#import-identify
+import akka.actor.Identify;
+//#import-identify
+//#import-indirect
+import akka.actor.IndirectActorProducer;
+//#import-indirect
+import akka.actor.OneForOneStrategy;
+//#import-props
+import akka.actor.Props;
+//#import-props
+import akka.actor.SupervisorStrategy;
+import akka.actor.SupervisorStrategy.Directive;
+//#import-terminated
+import akka.actor.Terminated;
+//#import-terminated
+//#import-untypedActor
+import akka.actor.UntypedActor;
+import akka.actor.UntypedActorFactory;
+//#import-untypedActor
//#import-stash
import akka.actor.UntypedActorWithStash;
//#import-stash
-
-import akka.actor.UntypedActor;
-import akka.actor.UntypedActorFactory;
-
-import org.junit.Test;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-import scala.Option;
-import java.lang.Object;
-import java.util.Iterator;
+//#import-ask
+import akka.dispatch.Futures;
+import akka.dispatch.Mapper;
+//#import-ask
+import akka.japi.Function;
+//#import-procedure
+import akka.japi.Procedure;
+//#import-procedure
+//#import-gracefulStop
+import akka.pattern.AskTimeoutException;
+//#import-gracefulStop
import akka.pattern.Patterns;
+import akka.testkit.AkkaSpec;
+import akka.testkit.JavaTestKit;
+//#import-ask
+import akka.util.Timeout;
+//#import-ask
public class UntypedActorDocTestBase {
@@ -87,71 +95,148 @@ public class UntypedActorDocTestBase {
system = null;
}
+ @SuppressWarnings("unused")
@Test
public void createProps() {
//#creating-props-config
- Props props1 = new Props();
- Props props2 = new Props(MyUntypedActor.class);
- Props props3 = new Props(new UntypedActorFactory() {
- public UntypedActor create() {
- return new MyUntypedActor();
- }
- });
- Props props4 = props1.withCreator(new UntypedActorFactory() {
- public UntypedActor create() {
- return new MyUntypedActor();
- }
- });
+ Props props1 = Props.create(MyUntypedActor.class);
+ Props props2 = Props.create(MyActor.class, "...");
//#creating-props-config
}
+ @SuppressWarnings("deprecation")
+ @Test
+ public void createPropsDeprecated() {
+ //#creating-props-deprecated
+ // DEPRECATED: encourages to close over enclosing class
+ final Props props1 = new Props(new UntypedActorFactory() {
+ private static final long serialVersionUID = 1L;
+ @Override
+ public UntypedActor create() throws Exception {
+ return new MyUntypedActor();
+ }
+ });
+
+ // DEPRECATED: encourages to close over enclosing class
+ final Props props2 = new Props().withCreator(new UntypedActorFactory() {
+ private static final long serialVersionUID = 1L;
+ @Override
+ public UntypedActor create() throws Exception {
+ return new MyUntypedActor();
+ }
+ });
+
+ // these are DEPRECATED due to duplicate functionality with Props.create()
+ final Props props3 = new Props(MyUntypedActor.class);
+ final Props props4 = new Props().withCreator(MyUntypedActor.class);
+ //#creating-props-deprecated
+ new JavaTestKit(system) {
+ {
+ for (Props props : new Props[] { props1, props2, props3, props4 }) {
+ final ActorRef a = system.actorOf(props);
+ a.tell("hello", getRef());
+ expectMsgEquals("hello");
+ }
+ }
+ };
+ }
+
@Test
public void systemActorOf() {
//#system-actorOf
- ActorSystem system = ActorSystem.create("MySystem");
- ActorRef myActor = system.actorOf(new Props(MyUntypedActor.class), "myactor");
+ // ActorSystem is a heavy object: create only one per application
+ final ActorSystem system = ActorSystem.create("MySystem");
+ final ActorRef myActor = system.actorOf(Props.create(MyUntypedActor.class), "myactor");
//#system-actorOf
- myActor.tell("test", null);
- system.shutdown();
+ try {
+ new JavaTestKit(system) {
+ {
+ myActor.tell("hello", getRef());
+ expectMsgEquals("hello");
+ }
+ };
+ } finally {
+ system.shutdown();
+ }
}
@Test
public void contextActorOf() {
- //#context-actorOf
- ActorRef myActor = system.actorOf(new Props(MyUntypedActor.class), "myactor2");
- //#context-actorOf
- myActor.tell("test", null);
- }
-
- @Test
- public void constructorActorOf() {
- //#creating-constructor
- // allows passing in arguments to the MyActor constructor
- ActorRef myActor = system.actorOf(new Props(new UntypedActorFactory() {
- public UntypedActor create() {
- return new MyActor("...");
+ new JavaTestKit(system) {
+ {
+ //#context-actorOf
+ class A extends UntypedActor {
+ final ActorRef child =
+ getContext().actorOf(Props.create(MyUntypedActor.class), "myChild");
+ //#plus-some-behavior
+ @Override
+ public void onReceive(Object msg) {
+ getSender().tell(child, getSelf());
+ }
+ //#plus-some-behavior
+ }
+ //#context-actorOf
+ final ActorRef top = system.actorOf(Props.create(A.class, this));
+ top.tell("hello", getRef());
+ final ActorRef child = expectMsgClass(ActorRef.class);
+ child.tell("hello", getRef());
+ expectMsgEquals("hello");
}
- }), "myactor3");
- //#creating-constructor
- myActor.tell("test", null);
+ };
+ }
+
+ // this is just to make the test below a tiny fraction nicer
+ private ActorSystem getContext() {
+ return system;
}
+ static
+ //#creating-indirectly
+ class DependencyInjector implements IndirectActorProducer {
+ final Object applicationContext;
+ final String beanName;
+
+ public DependencyInjector(Object applicationContext, String beanName) {
+ this.applicationContext = applicationContext;
+ this.beanName = beanName;
+ }
+
+ @Override
+ public Class actorClass() {
+ return MyActor.class;
+ }
+
+ @Override
+ public MyActor produce() {
+ MyActor result;
+ //#obtain-fresh-Actor-instance-from-DI-framework
+ result = new MyActor((String) applicationContext);
+ //#obtain-fresh-Actor-instance-from-DI-framework
+ return result;
+ }
+ }
+ //#creating-indirectly
+
@Test
- public void propsActorOf() {
- //#creating-props
- ActorRef myActor = system.actorOf(
- new Props(MyUntypedActor.class).withDispatcher("my-dispatcher"), "myactor4");
- //#creating-props
- myActor.tell("test", null);
+ public void indirectActorOf() {
+ final String applicationContext = "...";
+ //#creating-indirectly
+
+ final ActorRef myActor = getContext().actorOf(
+ Props.create(DependencyInjector.class, applicationContext, "MyActor"), "myactor3");
+ //#creating-indirectly
+ new JavaTestKit(system) {
+ {
+ myActor.tell("hello", getRef());
+ expectMsgEquals("...");
+ }
+ };
}
+ @SuppressWarnings("unused")
@Test
public void usingAsk() throws Exception {
- ActorRef myActor = system.actorOf(new Props(new UntypedActorFactory() {
- public UntypedActor create() {
- return new MyAskActor();
- }
- }), "myactor5");
+ ActorRef myActor = system.actorOf(Props.create(MyAskActor.class, this), "myactor5");
//#using-ask
Future