diff --git a/akka-amqp/src/main/scala/AMQP.scala b/akka-amqp/src/main/scala/AMQP.scala
index 1886577fc6..4ac0be82d9 100644
--- a/akka-amqp/src/main/scala/AMQP.scala
+++ b/akka-amqp/src/main/scala/AMQP.scala
@@ -95,7 +95,7 @@ object AMQP {
returnListener: Option[ReturnListener],
shutdownListener: Option[ShutdownListener],
initReconnectDelay: Long): ActorRef = {
- val producer = newActor(() => new Producer(
+ val producer = actorOf( new Producer(
new ConnectionFactory(config),
hostname, port,
exchangeName,
@@ -118,7 +118,7 @@ object AMQP {
durable: Boolean,
autoDelete: Boolean,
configurationArguments: Map[String, AnyRef]): ActorRef = {
- val consumer = newActor(() => new Consumer(
+ val consumer = actorOf( new Consumer(
new ConnectionFactory(config),
hostname, port,
exchangeName,
diff --git a/akka-camel/src/main/scala/Message.scala b/akka-camel/src/main/scala/Message.scala
index 6118a17522..a4231978ec 100644
--- a/akka-camel/src/main/scala/Message.scala
+++ b/akka-camel/src/main/scala/Message.scala
@@ -23,9 +23,21 @@ case class Message(val body: Any, val headers: Map[String, Any] = Map.empty) {
*
* @see CamelContextManager.
*/
+ @deprecated("use bodyAs[T](implicit m: Manifest[T]): T instead")
def bodyAs[T](clazz: Class[T]): T =
CamelContextManager.context.getTypeConverter.mandatoryConvertTo[T](clazz, body)
+ /**
+ * Returns the body of the message converted to the type T. Conversion is done
+ * using Camel's type converter. The type converter is obtained from the CamelContext managed
+ * by CamelContextManager. Applications have to ensure proper initialization of
+ * CamelContextManager.
+ *
+ * @see CamelContextManager.
+ */
+ def bodyAs[T](implicit m: Manifest[T]): T =
+ CamelContextManager.context.getTypeConverter.mandatoryConvertTo[T](m.erasure.asInstanceOf[Class[T]], body)
+
/**
* Returns those headers from this message whose name is contained in names.
*/
@@ -41,8 +53,16 @@ case class Message(val body: Any, val headers: Map[String, Any] = Map.empty) {
*
* @see Message#bodyAs(Class)
*/
+ @deprecated("use setBodyAs[T](implicit m: Manifest[T]): Message instead")
def setBodyAs[T](clazz: Class[T]): Message = setBody(bodyAs(clazz))
+ /**
+ * Creates a Message with a new body converted to type T.
+ *
+ * @see Message#bodyAs(Class)
+ */
+ def setBodyAs[T](implicit m: Manifest[T]): Message = setBody(bodyAs[T])
+
/**
* Creates a Message with a new body.
*/
diff --git a/akka-camel/src/main/scala/service/CamelService.scala b/akka-camel/src/main/scala/service/CamelService.scala
index 42cae6f44f..566700a737 100644
--- a/akka-camel/src/main/scala/service/CamelService.scala
+++ b/akka-camel/src/main/scala/service/CamelService.scala
@@ -20,8 +20,8 @@ trait CamelService extends Bootable with Logging {
import CamelContextManager._
- private[camel] val consumerPublisher = newActor[ConsumerPublisher]
- private[camel] val publishRequestor = newActor(() => new PublishRequestor(consumerPublisher))
+ private[camel] val consumerPublisher = actorOf[ConsumerPublisher]
+ private[camel] val publishRequestor = actorOf(new PublishRequestor(consumerPublisher))
/**
* Starts the CamelService. Any started actor that is a consumer actor will be (asynchronously)
@@ -45,7 +45,7 @@ trait CamelService extends Bootable with Logging {
ActorRegistry.addRegistrationListener(publishRequestor.start)
// publish already registered consumer actors
- for (publish <- Publish.forConsumers(ActorRegistry.actors)) consumerPublisher ! publish
+ for (actor <- ActorRegistry.actors; event <- ConsumerRegistered.forConsumer(actor)) consumerPublisher ! event
}
/**
diff --git a/akka-camel/src/main/scala/service/ConsumerPublisher.scala b/akka-camel/src/main/scala/service/ConsumerPublisher.scala
index 722f4e428e..167f3acaa1 100644
--- a/akka-camel/src/main/scala/service/ConsumerPublisher.scala
+++ b/akka-camel/src/main/scala/service/ConsumerPublisher.scala
@@ -16,36 +16,66 @@ import se.scalablesolutions.akka.util.Logging
/**
* Actor that publishes consumer actors as Camel endpoints at the CamelContext managed
* by se.scalablesolutions.akka.camel.CamelContextManager. It accepts messages of type
- * se.scalablesolutions.akka.camel.service.Publish.
+ * se.scalablesolutions.akka.camel.service.ConsumerRegistered and
+ * se.scalablesolutions.akka.camel.service.ConsumerUnregistered.
*
* @author Martin Krasser
*/
class ConsumerPublisher extends Actor with Logging {
- @volatile private var latch = new CountDownLatch(0)
+ @volatile private var publishLatch = new CountDownLatch(0)
+ @volatile private var unpublishLatch = new CountDownLatch(0)
/**
* Adds a route to the actor identified by a Publish message to the global CamelContext.
*/
protected def receive = {
- case p: Publish => publish(new ConsumerRoute(p.endpointUri, p.id, p.uuid))
- case _ => { /* ignore */}
+ case r: ConsumerRegistered => {
+ handleConsumerRegistered(r)
+ publishLatch.countDown // needed for testing only.
+ }
+ case u: ConsumerUnregistered => {
+ handleConsumerUnregistered(u)
+ unpublishLatch.countDown // needed for testing only.
+ }
+ case _ => { /* ignore */}
}
/**
- * Sets the number of expected Publish messages received by this actor. Used for testing
- * only.
+ * Sets the expected number of actors to be published. Used for testing only.
*/
- private[camel] def expectPublishCount(count: Int): Unit = latch = new CountDownLatch(count)
+ private[camel] def expectPublishCount(count: Int): Unit =
+ publishLatch = new CountDownLatch(count)
/**
- * Waits for the number of expected Publish messages to arrive. Used for testing only.
+ * Sets the expected number of actors to be unpublished. Used for testing only.
*/
- private[camel] def awaitPublish = latch.await
+ private[camel] def expectUnpublishCount(count: Int): Unit =
+ unpublishLatch = new CountDownLatch(count)
- private def publish(route: ConsumerRoute) {
- CamelContextManager.context.addRoutes(route)
- log.info("published actor via endpoint %s" format route.endpointUri)
- latch.countDown // needed for testing only.
+ /**
+ * Waits for the expected number of actors to be published. Used for testing only.
+ */
+ private[camel] def awaitPublish = publishLatch.await
+
+ /**
+ * Waits for the expected number of actors to be unpublished. Used for testing only.
+ */
+ private[camel] def awaitUnpublish = unpublishLatch.await
+
+ /**
+ * Creates a route to the registered consumer actor.
+ */
+ private def handleConsumerRegistered(event: ConsumerRegistered) {
+ CamelContextManager.context.addRoutes(new ConsumerRoute(event.uri, event.id, event.uuid))
+ log.info("published actor %s (%s) at endpoint %s" format (event.clazz, event.id, event.uri))
+ }
+
+ /**
+ * Stops route to the already un-registered consumer actor.
+ */
+ private def handleConsumerUnregistered(event: ConsumerUnregistered) {
+ CamelContextManager.context.stopRoute(event.id)
+ log.info("unpublished actor %s (%s) from endpoint %s" format (event.clazz, event.id, event.uri))
}
}
@@ -68,8 +98,8 @@ class ConsumerRoute(val endpointUri: String, id: String, uuid: Boolean) extends
def configure = {
val schema = endpointUri take endpointUri.indexOf(":") // e.g. "http" from "http://whatever/..."
bodyConversions.get(schema) match {
- case Some(clazz) => from(endpointUri).convertBodyTo(clazz).to(actorUri)
- case None => from(endpointUri).to(actorUri)
+ case Some(clazz) => from(endpointUri).routeId(id).convertBodyTo(clazz).to(actorUri)
+ case None => from(endpointUri).routeId(id).to(actorUri)
}
}
@@ -77,59 +107,104 @@ class ConsumerRoute(val endpointUri: String, id: String, uuid: Boolean) extends
}
/**
- * A registration listener that publishes consumer actors (and ignores other actors).
+ * A registration listener that triggers publication and un-publication of consumer actors.
*
* @author Martin Krasser
*/
class PublishRequestor(consumerPublisher: ActorRef) extends Actor {
protected def receive = {
- case ActorUnregistered(actor) => { /* ignore */ }
- case ActorRegistered(actor) => Publish.forConsumer(actor) match {
- case Some(publish) => consumerPublisher ! publish
- case None => { /* ignore */ }
- }
+ case ActorRegistered(actor) => for (event <- ConsumerRegistered.forConsumer(actor)) consumerPublisher ! event
+ case ActorUnregistered(actor) => for (event <- ConsumerUnregistered.forConsumer(actor)) consumerPublisher ! event
}
}
/**
- * Request message for publishing a consumer actor.
- *
- * @param endpointUri endpoint URI of the consumer actor
- * @param id actor identifier
- * @param uuid true if id refers to Actor.uuid, false if
- * id refers to Acotr.getId.
+ * Consumer actor lifecycle event.
*
* @author Martin Krasser
*/
-case class Publish(endpointUri: String, id: String, uuid: Boolean)
+sealed trait ConsumerEvent
+
+/**
+ * Event indicating that a consumer actor has been registered at the actor registry.
+ *
+ * @param clazz clazz name of the referenced actor
+ * @param uri endpoint URI of the consumer actor
+ * @param id actor identifier
+ * @param uuid true if id is the actor's uuid, false if
+ * id is the actor's id.
+ *
+ * @author Martin Krasser
+ */
+case class ConsumerRegistered(clazz: String, uri: String, id: String, uuid: Boolean) extends ConsumerEvent
+
+/**
+ * Event indicating that a consumer actor has been unregistered from the actor registry.
+ *
+ * @param clazz clazz name of the referenced actor
+ * @param uri endpoint URI of the consumer actor
+ * @param id actor identifier
+ * @param uuid true if id is the actor's uuid, false if
+ * id is the actor's id.
+ *
+ * @author Martin Krasser
+ */
+case class ConsumerUnregistered(clazz: String, uri: String, id: String, uuid: Boolean) extends ConsumerEvent
/**
* @author Martin Krasser
*/
-object Publish {
+private[camel] object ConsumerRegistered {
+ /**
+ * Optionally creates an ConsumerRegistered event message for a consumer actor or None if
+ * actorRef is not a consumer actor.
+ */
+ def forConsumer(actorRef: ActorRef): Option[ConsumerRegistered] = actorRef match {
+ case ConsumerDescriptor(clazz, uri, id, uuid) => Some(ConsumerRegistered(clazz, uri, id, uuid))
+ case _ => None
+ }
+}
+
+/**
+ * @author Martin Krasser
+ */
+private[camel] object ConsumerUnregistered {
+ /**
+ * Optionally creates an ConsumerUnregistered event message for a consumer actor or None if
+ * actorRef is not a consumer actor.
+ */
+ def forConsumer(actorRef: ActorRef): Option[ConsumerUnregistered] = actorRef match {
+ case ConsumerDescriptor(clazz, uri, id, uuid) => Some(ConsumerUnregistered(clazz, uri, id, uuid))
+ case _ => None
+ }
+}
+
+/**
+ * Describes a consumer actor with elements that are relevant for publishing an actor at a
+ * Camel endpoint (or unpublishing an actor from an endpoint).
+ *
+ * @author Martin Krasser
+ */
+private[camel] object ConsumerDescriptor {
/**
- * Creates a list of Publish request messages for all consumer actors in the actors
- * list.
+ * An extractor that optionally creates a 4-tuple from a consumer actor reference containing
+ * the target actor's class name, endpoint URI, identifier and a hint whether the identifier
+ * is the actor uuid or actor id. If actorRef doesn't reference a consumer actor,
+ * None is returned.
*/
- def forConsumers(actors: List[ActorRef]): List[Publish] =
- for (actor <- actors; pub = forConsumer(actor); if pub.isDefined) yield pub.get
+ def unapply(actorRef: ActorRef): Option[(String, String, String, Boolean)] =
+ unapplyConsumerInstance(actorRef) orElse unapplyConsumeAnnotated(actorRef)
- /**
- * Creates a Publish request message if actor is a consumer actor.
- */
- def forConsumer(actor: ActorRef): Option[Publish] =
- forConsumeAnnotated(actor) orElse forConsumerType(actor)
-
- private def forConsumeAnnotated(actorRef: ActorRef): Option[Publish] = {
+ private def unapplyConsumeAnnotated(actorRef: ActorRef): Option[(String, String, String, Boolean)] = {
val annotation = actorRef.actorClass.getAnnotation(classOf[consume])
if (annotation eq null) None
- else if (actorRef.remoteAddress.isDefined) None // do not publish proxies
- else Some(Publish(annotation.value, actorRef.id, false))
+ else if (actorRef.remoteAddress.isDefined) None
+ else Some((actorRef.actor.getClass.getName, annotation.value, actorRef.id, false))
}
- private def forConsumerType(actorRef: ActorRef): Option[Publish] =
+ private def unapplyConsumerInstance(actorRef: ActorRef): Option[(String, String, String, Boolean)] =
if (!actorRef.actor.isInstanceOf[Consumer]) None
else if (actorRef.remoteAddress.isDefined) None
- else Some(Publish(actorRef.actor.asInstanceOf[Consumer].endpointUri, actorRef.uuid, true))
+ else Some((actorRef.actor.getClass.getName, actorRef.actor.asInstanceOf[Consumer].endpointUri, actorRef.uuid, true))
}
diff --git a/akka-camel/src/test/scala/MessageTest.scala b/akka-camel/src/test/scala/MessageTest.scala
index 797d48ee57..da317be902 100644
--- a/akka-camel/src/test/scala/MessageTest.scala
+++ b/akka-camel/src/test/scala/MessageTest.scala
@@ -14,12 +14,12 @@ class MessageTest extends JUnitSuite with BeforeAndAfterAll {
override protected def beforeAll = CamelContextManager.init
@Test def shouldConvertDoubleBodyToString = {
- assertEquals("1.4", Message(1.4, null).bodyAs(classOf[String]))
+ assertEquals("1.4", Message(1.4, null).bodyAs[String])
}
@Test def shouldThrowExceptionWhenConvertingDoubleBodyToInputStream {
intercept[NoTypeConversionAvailableException] {
- Message(1.4, null).bodyAs(classOf[InputStream])
+ Message(1.4, null).bodyAs[InputStream]
}
}
@@ -37,7 +37,7 @@ class MessageTest extends JUnitSuite with BeforeAndAfterAll {
@Test def shouldConvertBodyAndPreserveHeaders = {
assertEquals(
Message("1.4", Map("A" -> "1")),
- Message(1.4 , Map("A" -> "1")).setBodyAs(classOf[String]))
+ Message(1.4 , Map("A" -> "1")).setBodyAs[String])
}
@Test def shouldSetBodyAndPreserveHeaders = {
diff --git a/akka-camel/src/test/scala/ProducerFeatureTest.scala b/akka-camel/src/test/scala/ProducerFeatureTest.scala
index fdd14edda3..acba99fde9 100644
--- a/akka-camel/src/test/scala/ProducerFeatureTest.scala
+++ b/akka-camel/src/test/scala/ProducerFeatureTest.scala
@@ -36,7 +36,7 @@ class ProducerFeatureTest extends FeatureSpec with BeforeAndAfterAll with Before
scenario("produce message sync and receive response") {
given("a registered synchronous two-way producer for endpoint direct:producer-test-2")
- val producer = newActor(() => new TestProducer("direct:producer-test-2") with Sync)
+ val producer = actorOf(new TestProducer("direct:producer-test-2") with Sync)
producer.start
when("a test message is sent to the producer")
@@ -50,7 +50,7 @@ class ProducerFeatureTest extends FeatureSpec with BeforeAndAfterAll with Before
scenario("produce message async and receive response") {
given("a registered asynchronous two-way producer for endpoint direct:producer-test-2")
- val producer = newActor(() => new TestProducer("direct:producer-test-2"))
+ val producer = actorOf(new TestProducer("direct:producer-test-2"))
producer.start
when("a test message is sent to the producer")
@@ -64,7 +64,7 @@ class ProducerFeatureTest extends FeatureSpec with BeforeAndAfterAll with Before
scenario("produce message sync and receive failure") {
given("a registered synchronous two-way producer for endpoint direct:producer-test-2")
- val producer = newActor(() => new TestProducer("direct:producer-test-2") with Sync)
+ val producer = actorOf(new TestProducer("direct:producer-test-2") with Sync)
producer.start
when("a fail message is sent to the producer")
@@ -80,7 +80,7 @@ class ProducerFeatureTest extends FeatureSpec with BeforeAndAfterAll with Before
scenario("produce message async and receive failure") {
given("a registered asynchronous two-way producer for endpoint direct:producer-test-2")
- val producer = newActor(() => new TestProducer("direct:producer-test-2"))
+ val producer = actorOf(new TestProducer("direct:producer-test-2"))
producer.start
when("a fail message is sent to the producer")
@@ -96,7 +96,7 @@ class ProducerFeatureTest extends FeatureSpec with BeforeAndAfterAll with Before
scenario("produce message sync oneway") {
given("a registered synchronous one-way producer for endpoint direct:producer-test-1")
- val producer = newActor(() => new TestProducer("direct:producer-test-1") with Sync with Oneway)
+ val producer = actorOf(new TestProducer("direct:producer-test-1") with Sync with Oneway)
producer.start
when("a test message is sent to the producer")
@@ -109,7 +109,7 @@ class ProducerFeatureTest extends FeatureSpec with BeforeAndAfterAll with Before
scenario("produce message async oneway") {
given("a registered asynchronous one-way producer for endpoint direct:producer-test-1")
- val producer = newActor(() => new TestProducer("direct:producer-test-1") with Oneway)
+ val producer = actorOf(new TestProducer("direct:producer-test-1") with Oneway)
producer.start
when("a test message is sent to the producer")
diff --git a/akka-camel/src/test/scala/component/ActorComponentFeatureTest.scala b/akka-camel/src/test/scala/component/ActorComponentFeatureTest.scala
index 3c100d0bc3..955ae82b96 100644
--- a/akka-camel/src/test/scala/component/ActorComponentFeatureTest.scala
+++ b/akka-camel/src/test/scala/component/ActorComponentFeatureTest.scala
@@ -23,7 +23,7 @@ class ActorComponentFeatureTest extends FeatureSpec with BeforeAndAfterAll with
import Actor._
scenario("one-way communication using actor id") {
- val actor = newActor(() => new Tester with Retain with Countdown[Message])
+ val actor = actorOf(new Tester with Retain with Countdown[Message])
actor.start
template.sendBody("actor:%s" format actor.id, "Martin")
assert(actor.actor.asInstanceOf[Countdown[Message]].waitFor)
@@ -31,7 +31,7 @@ class ActorComponentFeatureTest extends FeatureSpec with BeforeAndAfterAll with
}
scenario("one-way communication using actor uuid") {
- val actor = newActor(() => new Tester with Retain with Countdown[Message])
+ val actor = actorOf(new Tester with Retain with Countdown[Message])
actor.start
template.sendBody("actor:uuid:%s" format actor.uuid, "Martin")
assert(actor.actor.asInstanceOf[Countdown[Message]].waitFor)
@@ -39,19 +39,19 @@ class ActorComponentFeatureTest extends FeatureSpec with BeforeAndAfterAll with
}
scenario("two-way communication using actor id") {
- val actor = newActor(() => new Tester with Respond)
+ val actor = actorOf(new Tester with Respond)
actor.start
assert(template.requestBody("actor:%s" format actor.id, "Martin") === "Hello Martin")
}
scenario("two-way communication using actor uuid") {
- val actor = newActor(() => new Tester with Respond)
+ val actor = actorOf(new Tester with Respond)
actor.start
assert(template.requestBody("actor:uuid:%s" format actor.uuid, "Martin") === "Hello Martin")
}
scenario("two-way communication with timeout") {
- val actor = newActor(() => new Tester {
+ val actor = actorOf(new Tester {
self.timeout = 1
})
actor.start
diff --git a/akka-camel/src/test/scala/component/ActorProducerTest.scala b/akka-camel/src/test/scala/component/ActorProducerTest.scala
index 21a9af4be5..d41971c07f 100644
--- a/akka-camel/src/test/scala/component/ActorProducerTest.scala
+++ b/akka-camel/src/test/scala/component/ActorProducerTest.scala
@@ -18,7 +18,7 @@ class ActorProducerTest extends JUnitSuite with BeforeAndAfterAll {
@After def tearDown = ActorRegistry.shutdownAll
@Test def shouldSendMessageToActor = {
- val actor = newActor(() => new Tester with Retain with Countdown[Message])
+ val actor = actorOf(new Tester with Retain with Countdown[Message])
val endpoint = mockEndpoint("actor:uuid:%s" format actor.uuid)
val exchange = endpoint.createExchange(ExchangePattern.InOnly)
actor.start
@@ -31,7 +31,7 @@ class ActorProducerTest extends JUnitSuite with BeforeAndAfterAll {
}
@Test def shouldSendMessageToActorAndReceiveResponse = {
- val actor = newActor(() => new Tester with Respond {
+ val actor = actorOf(new Tester with Respond {
override def response(msg: Message) = Message(super.response(msg), Map("k2" -> "v2"))
})
val endpoint = mockEndpoint("actor:uuid:%s" format actor.uuid)
@@ -45,7 +45,7 @@ class ActorProducerTest extends JUnitSuite with BeforeAndAfterAll {
}
@Test def shouldSendMessageToActorAndReceiveFailure = {
- val actor = newActor(() => new Tester with Respond {
+ val actor = actorOf(new Tester with Respond {
override def response(msg: Message) = Failure(new Exception("testmsg"), Map("k3" -> "v3"))
})
val endpoint = mockEndpoint("actor:uuid:%s" format actor.uuid)
@@ -60,7 +60,7 @@ class ActorProducerTest extends JUnitSuite with BeforeAndAfterAll {
}
@Test def shouldSendMessageToActorAndTimeout: Unit = {
- val actor = newActor(() => new Tester {
+ val actor = actorOf(new Tester {
self.timeout = 1
})
val endpoint = mockEndpoint("actor:uuid:%s" format actor.uuid)
diff --git a/akka-camel/src/test/scala/service/CamelServiceFeatureTest.scala b/akka-camel/src/test/scala/service/CamelServiceFeatureTest.scala
index b7c53f42ae..5ecf95a4f0 100644
--- a/akka-camel/src/test/scala/service/CamelServiceFeatureTest.scala
+++ b/akka-camel/src/test/scala/service/CamelServiceFeatureTest.scala
@@ -38,7 +38,7 @@ class CamelServiceFeatureTest extends FeatureSpec with BeforeAndAfterAll with Gi
override protected def beforeAll = {
ActorRegistry.shutdownAll
// register test consumer before starting the CamelService
- newActor(() => new TestConsumer("direct:publish-test-1")).start
+ actorOf(new TestConsumer("direct:publish-test-1")).start
// Consigure a custom camel route
CamelContextManager.init
CamelContextManager.context.addRoutes(new TestRoute)
@@ -61,10 +61,10 @@ class CamelServiceFeatureTest extends FeatureSpec with BeforeAndAfterAll with Gi
given("two consumer actors registered before and after CamelService startup")
service.consumerPublisher.actor.asInstanceOf[ConsumerPublisher].expectPublishCount(1)
- newActor(() => new TestConsumer("direct:publish-test-2")).start
+ actorOf(new TestConsumer("direct:publish-test-2")).start
+ service.consumerPublisher.actor.asInstanceOf[ConsumerPublisher].awaitPublish
when("requests are sent to these actors")
- service.consumerPublisher.actor.asInstanceOf[ConsumerPublisher].awaitPublish
val response1 = CamelContextManager.template.requestBody("direct:publish-test-1", "msg1")
val response2 = CamelContextManager.template.requestBody("direct:publish-test-2", "msg2")
@@ -74,12 +74,38 @@ class CamelServiceFeatureTest extends FeatureSpec with BeforeAndAfterAll with Gi
}
}
+ feature("Unpublish registered consumer actor from the global CamelContext") {
+
+ scenario("attempt access to unregistered consumer actor via Camel direct-endpoint") {
+ val endpointUri = "direct:unpublish-test-1"
+
+ given("a consumer actor that has been stopped")
+ assert(CamelContextManager.context.hasEndpoint(endpointUri) eq null)
+ service.consumerPublisher.actor.asInstanceOf[ConsumerPublisher].expectPublishCount(1)
+ val consumer = actorOf(new TestConsumer(endpointUri)).start
+ service.consumerPublisher.actor.asInstanceOf[ConsumerPublisher].awaitPublish
+ assert(CamelContextManager.context.hasEndpoint(endpointUri) ne null)
+
+ service.consumerPublisher.actor.asInstanceOf[ConsumerPublisher].expectUnpublishCount(1)
+ consumer.stop
+ service.consumerPublisher.actor.asInstanceOf[ConsumerPublisher].awaitUnpublish
+ // endpoint is still there but the route has been stopped
+ assert(CamelContextManager.context.hasEndpoint(endpointUri) ne null)
+
+ when("a request is sent to this actor")
+ val response1 = CamelContextManager.template.requestBody(endpointUri, "msg1")
+
+ then("the direct endpoint falls back to its default behaviour and returns the original message")
+ assert(response1 === "msg1")
+ }
+ }
+
feature("Configure a custom Camel route for the global CamelContext") {
scenario("access an actor from the custom Camel route") {
given("a registered actor and a custom route to that actor")
- val actor = newActor[TestActor].start
+ val actor = actorOf[TestActor].start
when("sending a a message to that route")
val response = CamelContextManager.template.requestBody("direct:custom-route-test-1", "msg3")
diff --git a/akka-camel/src/test/scala/service/PublishTest.scala b/akka-camel/src/test/scala/service/ConsumerRegisteredTest.scala
similarity index 50%
rename from akka-camel/src/test/scala/service/PublishTest.scala
rename to akka-camel/src/test/scala/service/ConsumerRegisteredTest.scala
index 71ccea65d4..8041d71f7a 100644
--- a/akka-camel/src/test/scala/service/PublishTest.scala
+++ b/akka-camel/src/test/scala/service/ConsumerRegisteredTest.scala
@@ -8,7 +8,7 @@ import se.scalablesolutions.akka.actor.Actor._
import se.scalablesolutions.akka.actor.annotation.consume
import se.scalablesolutions.akka.camel.Consumer
-object PublishTest {
+object ConsumerRegisteredTest {
@consume("mock:test1")
class ConsumeAnnotatedActor extends Actor {
self.id = "test"
@@ -25,27 +25,28 @@ object PublishTest {
}
}
-class PublishTest extends JUnitSuite {
- import PublishTest._
+class ConsumerRegisteredTest extends JUnitSuite {
+ import ConsumerRegisteredTest._
@Test def shouldCreatePublishRequestList = {
- val publish = Publish.forConsumers(List(newActor[ConsumeAnnotatedActor]))
- assert(publish === List(Publish("mock:test1", "test", false)))
+ val as = List(actorOf[ConsumeAnnotatedActor])
+ val events = for (a <- as; e <- ConsumerRegistered.forConsumer(a)) yield e
+ assert(events === List(ConsumerRegistered(classOf[ConsumeAnnotatedActor].getName, "mock:test1", "test", false)))
}
@Test def shouldCreateSomePublishRequestWithActorId = {
- val publish = Publish.forConsumer(newActor[ConsumeAnnotatedActor])
- assert(publish === Some(Publish("mock:test1", "test", false)))
+ val event = ConsumerRegistered.forConsumer(actorOf[ConsumeAnnotatedActor])
+ assert(event === Some(ConsumerRegistered(classOf[ConsumeAnnotatedActor].getName, "mock:test1", "test", false)))
}
@Test def shouldCreateSomePublishRequestWithActorUuid = {
- val ca = newActor[ConsumerActor]
- val publish = Publish.forConsumer(ca)
- assert(publish === Some(Publish("mock:test2", ca.uuid, true)))
+ val ca = actorOf[ConsumerActor]
+ val event = ConsumerRegistered.forConsumer(ca)
+ assert(event === Some(ConsumerRegistered(ca.actor.getClass.getName, "mock:test2", ca.uuid, true)))
}
@Test def shouldCreateNone = {
- val publish = Publish.forConsumer(newActor[PlainActor])
- assert(publish === None)
+ val event = ConsumerRegistered.forConsumer(actorOf[PlainActor])
+ assert(event === None)
}
}
diff --git a/akka-camel/src/test/scala/service/PublishRequestorTest.scala b/akka-camel/src/test/scala/service/PublishRequestorTest.scala
index 59e9696ee4..a7f1685de1 100644
--- a/akka-camel/src/test/scala/service/PublishRequestorTest.scala
+++ b/akka-camel/src/test/scala/service/PublishRequestorTest.scala
@@ -1,41 +1,55 @@
package se.scalablesolutions.akka.camel.service
-import org.junit.{After, Test}
+import _root_.org.junit.{Before, After, Test}
import org.scalatest.junit.JUnitSuite
import se.scalablesolutions.akka.camel.Consumer
import se.scalablesolutions.akka.camel.support.{Receive, Countdown}
-import se.scalablesolutions.akka.actor.{ActorRegistry, ActorRegistered, Actor}
+import se.scalablesolutions.akka.actor.{Actor, ActorRef, ActorRegistry, ActorRegistered, ActorUnregistered}
import Actor._
object PublishRequestorTest {
- class PublisherMock extends Actor with Receive[Publish] {
- var received: Publish = _
+ class PublisherMock extends Actor with Receive[ConsumerEvent] {
+ var received: ConsumerEvent = _
protected def receive = {
- case msg: Publish => onMessage(msg)
+ case msg: ConsumerRegistered => onMessage(msg)
+ case msg: ConsumerUnregistered => onMessage(msg)
}
- def onMessage(msg: Publish) = received = msg
+ def onMessage(msg: ConsumerEvent) = received = msg
}
}
class PublishRequestorTest extends JUnitSuite {
import PublishRequestorTest._
-
- @After def tearDown = ActorRegistry.shutdownAll
- @Test def shouldReceivePublishRequestOnActorRegisteredEvent = {
- val consumer = newActor(() => new Actor with Consumer {
+ var publisher: ActorRef = _
+ var requestor: ActorRef = _
+ var consumer: ActorRef = _
+
+ @Before def setUp = {
+ publisher = actorOf(new PublisherMock with Countdown[ConsumerEvent]).start
+ requestor = actorOf(new PublishRequestor(publisher)).start
+ consumer = actorOf(new Actor with Consumer {
def endpointUri = "mock:test"
protected def receive = null
}).start
- val publisher = newActor(() => new PublisherMock with Countdown[Publish])
- val requestor = newActor(() => new PublishRequestor(publisher))
- publisher.start
- requestor.start
+ }
+
+ @After def tearDown = {
+ ActorRegistry.shutdownAll
+ }
+
+ @Test def shouldReceiveConsumerRegisteredEvent = {
requestor.!(ActorRegistered(consumer))(None)
- publisher.actor.asInstanceOf[Countdown[Publish]].waitFor
- assert(publisher.actor.asInstanceOf[PublisherMock].received === Publish("mock:test", consumer.uuid, true))
- publisher.stop
- requestor.stop
+ publisher.actor.asInstanceOf[Countdown[ConsumerEvent]].waitFor
+ assert(publisher.actor.asInstanceOf[PublisherMock].received ===
+ ConsumerRegistered(consumer.actor.getClass.getName, "mock:test", consumer.uuid, true))
+ }
+
+ @Test def shouldReceiveConsumerUnregisteredEvent = {
+ requestor.!(ActorUnregistered(consumer))(None)
+ publisher.actor.asInstanceOf[Countdown[ConsumerRegistered]].waitFor
+ assert(publisher.actor.asInstanceOf[PublisherMock].received ===
+ ConsumerUnregistered(consumer.actor.getClass.getName, "mock:test", consumer.uuid, true))
}
}
diff --git a/akka-core/src/main/scala/actor/ActiveObject.scala b/akka-core/src/main/scala/actor/ActiveObject.scala
index bb71179fa2..32dd70f425 100644
--- a/akka-core/src/main/scala/actor/ActiveObject.scala
+++ b/akka-core/src/main/scala/actor/ActiveObject.scala
@@ -73,31 +73,31 @@ final class ActiveObjectConfiguration {
* @author Jonas Bonér
*/
object ActiveObject {
- import Actor.newActor
+ import Actor.actorOf
val AKKA_CAMEL_ROUTING_SCHEME = "akka"
private[actor] val AW_PROXY_PREFIX = "$$ProxiedByAW".intern
def newInstance[T](target: Class[T], timeout: Long): T =
- newInstance(target, newActor(() => new Dispatcher(false, None)), None, timeout)
+ newInstance(target, actorOf(new Dispatcher(false, None)), None, timeout)
def newInstance[T](target: Class[T]): T =
- newInstance(target, newActor(() => new Dispatcher(false, None)), None, Actor.TIMEOUT)
+ newInstance(target, actorOf(new Dispatcher(false, None)), None, Actor.TIMEOUT)
def newInstance[T](intf: Class[T], target: AnyRef, timeout: Long): T =
- newInstance(intf, target, newActor(() => new Dispatcher(false, None)), None, timeout)
+ newInstance(intf, target, actorOf(new Dispatcher(false, None)), None, timeout)
def newInstance[T](intf: Class[T], target: AnyRef): T =
- newInstance(intf, target, newActor(() => new Dispatcher(false, None)), None, Actor.TIMEOUT)
+ newInstance(intf, target, actorOf(new Dispatcher(false, None)), None, Actor.TIMEOUT)
def newRemoteInstance[T](target: Class[T], timeout: Long, hostname: String, port: Int): T =
- newInstance(target, newActor(() => new Dispatcher(false, None)), Some(new InetSocketAddress(hostname, port)), timeout)
+ newInstance(target, actorOf(new Dispatcher(false, None)), Some(new InetSocketAddress(hostname, port)), timeout)
def newRemoteInstance[T](target: Class[T], hostname: String, port: Int): T =
- newInstance(target, newActor(() => new Dispatcher(false, None)), Some(new InetSocketAddress(hostname, port)), Actor.TIMEOUT)
+ newInstance(target, actorOf(new Dispatcher(false, None)), Some(new InetSocketAddress(hostname, port)), Actor.TIMEOUT)
def newInstance[T](target: Class[T], config: ActiveObjectConfiguration): T = {
- val actor = newActor(() => new Dispatcher(config._transactionRequired, config._restartCallbacks))
+ val actor = actorOf(new Dispatcher(config._transactionRequired, config._restartCallbacks))
if (config._messageDispatcher.isDefined) {
actor.dispatcher = config._messageDispatcher.get
}
@@ -105,7 +105,7 @@ object ActiveObject {
}
def newInstance[T](intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration): T = {
- val actor = newActor(() => new Dispatcher(config._transactionRequired, config._restartCallbacks))
+ val actor = actorOf(new Dispatcher(config._transactionRequired, config._restartCallbacks))
if (config._messageDispatcher.isDefined) {
actor.dispatcher = config._messageDispatcher.get
}
@@ -114,69 +114,69 @@ object ActiveObject {
@deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
def newInstance[T](target: Class[T], timeout: Long, restartCallbacks: Option[RestartCallbacks]): T =
- newInstance(target, newActor(() => new Dispatcher(false, restartCallbacks)), None, timeout)
+ newInstance(target, actorOf(new Dispatcher(false, restartCallbacks)), None, timeout)
@deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
def newInstance[T](intf: Class[T], target: AnyRef, timeout: Long, restartCallbacks: Option[RestartCallbacks]): T =
- newInstance(intf, target, newActor(() => new Dispatcher(false, restartCallbacks)), None, timeout)
+ newInstance(intf, target, actorOf(new Dispatcher(false, restartCallbacks)), None, timeout)
@deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
def newInstance[T](target: Class[T], timeout: Long, transactionRequired: Boolean): T =
- newInstance(target, newActor(() => new Dispatcher(transactionRequired, None)), None, timeout)
+ newInstance(target, actorOf(new Dispatcher(transactionRequired, None)), None, timeout)
@deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
def newInstance[T](target: Class[T], timeout: Long, transactionRequired: Boolean, restartCallbacks: Option[RestartCallbacks]): T =
- newInstance(target, newActor(() => new Dispatcher(transactionRequired, restartCallbacks)), None, timeout)
+ newInstance(target, actorOf(new Dispatcher(transactionRequired, restartCallbacks)), None, timeout)
@deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
def newInstance[T](intf: Class[T], target: AnyRef, timeout: Long, transactionRequired: Boolean): T =
- newInstance(intf, target, newActor(() => new Dispatcher(transactionRequired, None)), None, timeout)
+ newInstance(intf, target, actorOf(new Dispatcher(transactionRequired, None)), None, timeout)
@deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
def newInstance[T](intf: Class[T], target: AnyRef, timeout: Long, transactionRequired: Boolean, restartCallbacks: Option[RestartCallbacks]): T =
- newInstance(intf, target, newActor(() => new Dispatcher(transactionRequired, restartCallbacks)), None, timeout)
+ newInstance(intf, target, actorOf(new Dispatcher(transactionRequired, restartCallbacks)), None, timeout)
@deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
def newRemoteInstance[T](intf: Class[T], target: AnyRef, timeout: Long, hostname: String, port: Int): T =
- newInstance(intf, target, newActor(() => new Dispatcher(false, None)), Some(new InetSocketAddress(hostname, port)), timeout)
+ newInstance(intf, target, actorOf(new Dispatcher(false, None)), Some(new InetSocketAddress(hostname, port)), timeout)
@deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
def newRemoteInstance[T](intf: Class[T], target: AnyRef, timeout: Long, hostname: String, port: Int, restartCallbacks: Option[RestartCallbacks]): T =
- newInstance(intf, target, newActor(() => new Dispatcher(false, restartCallbacks)), Some(new InetSocketAddress(hostname, port)), timeout)
+ newInstance(intf, target, actorOf(new Dispatcher(false, restartCallbacks)), Some(new InetSocketAddress(hostname, port)), timeout)
@deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
def newRemoteInstance[T](target: Class[T], timeout: Long, transactionRequired: Boolean, hostname: String, port: Int): T =
- newInstance(target, newActor(() => new Dispatcher(transactionRequired, None)), Some(new InetSocketAddress(hostname, port)), timeout)
+ newInstance(target, actorOf(new Dispatcher(transactionRequired, None)), Some(new InetSocketAddress(hostname, port)), timeout)
@deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
def newRemoteInstance[T](target: Class[T], timeout: Long, transactionRequired: Boolean, hostname: String, port: Int, restartCallbacks: Option[RestartCallbacks]): T =
- newInstance(target, newActor(() => new Dispatcher(transactionRequired, restartCallbacks)), Some(new InetSocketAddress(hostname, port)), timeout)
+ newInstance(target, actorOf(new Dispatcher(transactionRequired, restartCallbacks)), Some(new InetSocketAddress(hostname, port)), timeout)
@deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
def newRemoteInstance[T](intf: Class[T], target: AnyRef, timeout: Long, transactionRequired: Boolean, hostname: String, port: Int): T =
- newInstance(intf, target, newActor(() => new Dispatcher(transactionRequired, None)), Some(new InetSocketAddress(hostname, port)), timeout)
+ newInstance(intf, target, actorOf(new Dispatcher(transactionRequired, None)), Some(new InetSocketAddress(hostname, port)), timeout)
@deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
def newRemoteInstance[T](intf: Class[T], target: AnyRef, timeout: Long, transactionRequired: Boolean, hostname: String, port: Int, restartCallbacks: Option[RestartCallbacks]): T =
- newInstance(intf, target, newActor(() => new Dispatcher(transactionRequired, restartCallbacks)), Some(new InetSocketAddress(hostname, port)), timeout)
+ newInstance(intf, target, actorOf(new Dispatcher(transactionRequired, restartCallbacks)), Some(new InetSocketAddress(hostname, port)), timeout)
@deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
def newInstance[T](target: Class[T], timeout: Long, dispatcher: MessageDispatcher): T = {
- val actor = newActor(() => new Dispatcher(false, None))
+ val actor = actorOf(new Dispatcher(false, None))
actor.dispatcher = dispatcher
newInstance(target, actor, None, timeout)
}
@deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
def newInstance[T](target: Class[T], timeout: Long, dispatcher: MessageDispatcher, restartCallbacks: Option[RestartCallbacks]): T = {
- val actor = newActor(() => new Dispatcher(false, restartCallbacks))
+ val actor = actorOf(new Dispatcher(false, restartCallbacks))
actor.dispatcher = dispatcher
newInstance(target, actor, None, timeout)
}
@deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
def newInstance[T](intf: Class[T], target: AnyRef, timeout: Long, dispatcher: MessageDispatcher): T = {
- val actor = newActor(() => new Dispatcher(false, None))
+ val actor = actorOf(new Dispatcher(false, None))
actor.dispatcher = dispatcher
newInstance(intf, target, actor, None, timeout)
}
@@ -184,14 +184,14 @@ object ActiveObject {
@deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
def newInstance[T](intf: Class[T], target: AnyRef, timeout: Long,
dispatcher: MessageDispatcher, restartCallbacks: Option[RestartCallbacks]): T = {
- val actor = newActor(() => new Dispatcher(false, restartCallbacks))
+ val actor = actorOf(new Dispatcher(false, restartCallbacks))
actor.dispatcher = dispatcher
newInstance(intf, target, actor, None, timeout)
}
@deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
def newInstance[T](target: Class[T], timeout: Long, transactionRequired: Boolean, dispatcher: MessageDispatcher): T = {
- val actor = newActor(() => new Dispatcher(transactionRequired, None))
+ val actor = actorOf(new Dispatcher(transactionRequired, None))
actor.dispatcher = dispatcher
newInstance(target, actor, None, timeout)
}
@@ -199,14 +199,14 @@ object ActiveObject {
@deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
def newInstance[T](target: Class[T], timeout: Long, transactionRequired: Boolean,
dispatcher: MessageDispatcher, restartCallbacks: Option[RestartCallbacks]): T = {
- val actor = newActor(() => new Dispatcher(transactionRequired, restartCallbacks))
+ val actor = actorOf(new Dispatcher(transactionRequired, restartCallbacks))
actor.dispatcher = dispatcher
newInstance(target, actor, None, timeout)
}
@deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
def newInstance[T](intf: Class[T], target: AnyRef, timeout: Long, transactionRequired: Boolean, dispatcher: MessageDispatcher): T = {
- val actor = newActor(() => new Dispatcher(transactionRequired, None))
+ val actor = actorOf(new Dispatcher(transactionRequired, None))
actor.dispatcher = dispatcher
newInstance(intf, target, actor, None, timeout)
}
@@ -214,14 +214,14 @@ object ActiveObject {
@deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
def newInstance[T](intf: Class[T], target: AnyRef, timeout: Long, transactionRequired: Boolean,
dispatcher: MessageDispatcher, restartCallbacks: Option[RestartCallbacks]): T = {
- val actor = newActor(() => new Dispatcher(transactionRequired, restartCallbacks))
+ val actor = actorOf(new Dispatcher(transactionRequired, restartCallbacks))
actor.dispatcher = dispatcher
newInstance(intf, target, actor, None, timeout)
}
@deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
def newRemoteInstance[T](target: Class[T], timeout: Long, dispatcher: MessageDispatcher, hostname: String, port: Int): T = {
- val actor = newActor(() => new Dispatcher(false, None))
+ val actor = actorOf(new Dispatcher(false, None))
actor.dispatcher = dispatcher
newInstance(target, actor, Some(new InetSocketAddress(hostname, port)), timeout)
}
@@ -229,14 +229,14 @@ object ActiveObject {
@deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
def newRemoteInstance[T](target: Class[T], timeout: Long, dispatcher: MessageDispatcher,
hostname: String, port: Int, restartCallbacks: Option[RestartCallbacks]): T = {
- val actor = newActor(() => new Dispatcher(false, restartCallbacks))
+ val actor = actorOf(new Dispatcher(false, restartCallbacks))
actor.dispatcher = dispatcher
newInstance(target, actor, Some(new InetSocketAddress(hostname, port)), timeout)
}
@deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
def newRemoteInstance[T](intf: Class[T], target: AnyRef, timeout: Long, dispatcher: MessageDispatcher, hostname: String, port: Int): T = {
- val actor = newActor(() => new Dispatcher(false, None))
+ val actor = actorOf(new Dispatcher(false, None))
actor.dispatcher = dispatcher
newInstance(intf, target, actor, Some(new InetSocketAddress(hostname, port)), timeout)
}
@@ -244,7 +244,7 @@ object ActiveObject {
@deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
def newRemoteInstance[T](intf: Class[T], target: AnyRef, timeout: Long, dispatcher: MessageDispatcher,
hostname: String, port: Int, restartCallbacks: Option[RestartCallbacks]): T = {
- val actor = newActor(() => new Dispatcher(false, restartCallbacks))
+ val actor = actorOf(new Dispatcher(false, restartCallbacks))
actor.dispatcher = dispatcher
newInstance(intf, target, actor, Some(new InetSocketAddress(hostname, port)), timeout)
}
@@ -252,7 +252,7 @@ object ActiveObject {
@deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
def newRemoteInstance[T](target: Class[T], timeout: Long, transactionRequired: Boolean,
dispatcher: MessageDispatcher, hostname: String, port: Int): T = {
- val actor = newActor(() => new Dispatcher(transactionRequired, None))
+ val actor = actorOf(new Dispatcher(transactionRequired, None))
actor.dispatcher = dispatcher
newInstance(target, actor, Some(new InetSocketAddress(hostname, port)), timeout)
}
@@ -260,7 +260,7 @@ object ActiveObject {
@deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
def newRemoteInstance[T](target: Class[T], timeout: Long, transactionRequired: Boolean, dispatcher: MessageDispatcher,
hostname: String, port: Int, restartCallbacks: Option[RestartCallbacks]): T = {
- val actor = newActor(() => new Dispatcher(transactionRequired, restartCallbacks))
+ val actor = actorOf(new Dispatcher(transactionRequired, restartCallbacks))
actor.dispatcher = dispatcher
newInstance(target, actor, Some(new InetSocketAddress(hostname, port)), timeout)
}
@@ -268,7 +268,7 @@ object ActiveObject {
@deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
def newRemoteInstance[T](intf: Class[T], target: AnyRef, timeout: Long, transactionRequired: Boolean,
dispatcher: MessageDispatcher, hostname: String, port: Int): T = {
- val actor = newActor(() => new Dispatcher(transactionRequired, None))
+ val actor = actorOf(new Dispatcher(transactionRequired, None))
actor.dispatcher = dispatcher
newInstance(intf, target, actor, Some(new InetSocketAddress(hostname, port)), timeout)
}
@@ -276,7 +276,7 @@ object ActiveObject {
@deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
def newRemoteInstance[T](intf: Class[T], target: AnyRef, timeout: Long, transactionRequired: Boolean,
dispatcher: MessageDispatcher, hostname: String, port: Int, restartCallbacks: Option[RestartCallbacks]): T = {
- val actor = newActor(() => new Dispatcher(transactionRequired, restartCallbacks))
+ val actor = actorOf(new Dispatcher(transactionRequired, restartCallbacks))
actor.dispatcher = dispatcher
newInstance(intf, target, actor, Some(new InetSocketAddress(hostname, port)), timeout)
}
diff --git a/akka-core/src/main/scala/actor/Actor.scala b/akka-core/src/main/scala/actor/Actor.scala
index 1d3a37a4b8..594c2972db 100644
--- a/akka-core/src/main/scala/actor/Actor.scala
+++ b/akka-core/src/main/scala/actor/Actor.scala
@@ -26,6 +26,7 @@ import java.util.concurrent.locks.{Lock, ReentrantLock}
import java.util.{HashSet => JHashSet}
/*
+// FIXME add support for ActorWithNestedReceive
trait ActorWithNestedReceive extends Actor {
import Actor.actor
private var nestedReactsProcessors: List[ActorRef] = Nil
@@ -90,32 +91,32 @@ object Actor extends Logging {
private[actor] val actorRefInCreation = new scala.util.DynamicVariable[Option[ActorRef]](None)
/**
- * Creates a Actor.newActor out of the Actor with type T.
+ * Creates a Actor.actorOf out of the Actor with type T.
*
* import Actor._
- * val actor = newActor[MyActor]
+ * val actor = actorOf[MyActor]
* actor.start
* actor ! message
* actor.stop
*
*/
- def newActor[T <: Actor: Manifest]: ActorRef = new LocalActorRef(manifest[T].erasure.asInstanceOf[Class[_ <: Actor]])
+ def actorOf[T <: Actor: Manifest]: ActorRef = new LocalActorRef(manifest[T].erasure.asInstanceOf[Class[_ <: Actor]])
/**
- * Creates a Actor.newActor out of the Actor. Allows you to pass in a factory function
+ * Creates a Actor.actorOf out of the Actor. Allows you to pass in a factory function
* that creates the Actor. Please note that this function can be invoked multiple
* times if for example the Actor is supervised and needs to be restarted.
*
* This function should NOT be used for remote actors.
*
* import Actor._
- * val actor = newActor(() => new MyActor)
+ * val actor = actorOf(new MyActor)
* actor.start
* actor ! message
* actor.stop
*
*/
- def newActor(factory: () => Actor): ActorRef = new LocalActorRef(factory)
+ def actorOf(factory: => Actor): ActorRef = new LocalActorRef(() => factory)
/**
* Use to create an anonymous event-driven actor.
@@ -134,7 +135,7 @@ object Actor extends Logging {
*
*/
def actor(body: PartialFunction[Any, Unit]): ActorRef =
- newActor(() => new Actor() {
+ actorOf(new Actor() {
self.lifeCycle = Some(LifeCycle(Permanent))
def receive: PartialFunction[Any, Unit] = body
}).start
@@ -156,7 +157,7 @@ object Actor extends Logging {
*
*/
def transactor(body: PartialFunction[Any, Unit]): ActorRef =
- newActor(() => new Transactor() {
+ actorOf(new Transactor() {
self.lifeCycle = Some(LifeCycle(Permanent))
def receive: PartialFunction[Any, Unit] = body
}).start
@@ -176,7 +177,7 @@ object Actor extends Logging {
*
*/
def temporaryActor(body: PartialFunction[Any, Unit]): ActorRef =
- newActor(() => new Actor() {
+ actorOf(new Actor() {
self.lifeCycle = Some(LifeCycle(Temporary))
def receive = body
}).start
@@ -201,7 +202,7 @@ object Actor extends Logging {
def init[A](body: => Unit) = {
def handler[A](body: => Unit) = new {
def receive(handler: PartialFunction[Any, Unit]) =
- newActor(() => new Actor() {
+ actorOf(new Actor() {
self.lifeCycle = Some(LifeCycle(Permanent))
body
def receive = handler
@@ -227,7 +228,7 @@ object Actor extends Logging {
*/
def spawn(body: => Unit): Unit = {
case object Spawn
- newActor(() => new Actor() {
+ actorOf(new Actor() {
self ! Spawn
def receive = {
case Spawn => body; self.stop
@@ -236,6 +237,7 @@ object Actor extends Logging {
}
}
+
/**
* Actor base trait that should be extended by or mixed to create an Actor with the semantics of the 'Actor Model':
* http://en.wikipedia.org/wiki/Actor_model
@@ -263,8 +265,8 @@ trait Actor extends Logging {
"\n\tYou can not create an instance of an actor explicitly using 'new MyActor'." +
"\n\tYou have to use one of the factory methods in the 'Actor' object to create a new actor." +
"\n\tEither use:" +
- "\n\t\t'val actor = Actor.newActor[MyActor]', or" +
- "\n\t\t'val actor = Actor.newActor(() => new MyActor(..))'")
+ "\n\t\t'val actor = Actor.actorOf[MyActor]', or" +
+ "\n\t\t'val actor = Actor.actorOf(new MyActor(..))'")
else ref
}
diff --git a/akka-core/src/main/scala/actor/ActorRef.scala b/akka-core/src/main/scala/actor/ActorRef.scala
index 309a2766b0..6971250381 100644
--- a/akka-core/src/main/scala/actor/ActorRef.scala
+++ b/akka-core/src/main/scala/actor/ActorRef.scala
@@ -27,26 +27,9 @@ import java.util.concurrent.atomic.AtomicReference
import java.util.concurrent.ConcurrentHashMap
import java.util.{Map => JMap}
-/*
-trait ActorWithNestedReceive extends Actor {
- import Actor.actor
- private var nestedReactsProcessors: List[ActorRef] = Nil
- private val processNestedReacts: PartialFunction[Any, Unit] = {
- case message if !nestedReactsProcessors.isEmpty =>
- val processors = nestedReactsProcessors.reverse
- processors.head forward message
- nestedReactsProcessors = processors.tail.reverse
- }
-
- protected def react: PartialFunction[Any, Unit]
- protected def reactAgain(pf: PartialFunction[Any, Unit]) = nestedReactsProcessors ::= actor(pf)
- protected def receive = processNestedReacts orElse react
-}
-*/
-
/**
* The ActorRef object can be used to deserialize ActorRef instances from of its binary representation
- * or its Protocol Buffers (protobuf) Message representation to a Actor.newActor instance.
+ * or its Protocol Buffers (protobuf) Message representation to a Actor.actorOf instance.
*
* Binary -> ActorRef:
*
@@ -90,16 +73,22 @@ object ActorRef {
*
* import Actor._
*
- * val actor = newActor[MyActor]
+ * val actor = actorOf[MyActor]
* actor.start
* actor ! message
* actor.stop
*
+ *
+ * You can also create and start actors like this:
+ *
+ * val actor = actorOf[MyActor].start
+ *
+ *
* Here is an example on how to create an actor with a non-default constructor.
*
* import Actor._
*
- * val actor = newActor(() => new MyActor(...))
+ * val actor = actorOf(new MyActor(...))
* actor.start
* actor ! message
* actor.stop
@@ -374,14 +363,9 @@ trait ActorRef extends TransactionManagement {
* Returns true if reply was sent, and false if unable to determine what to reply to.
*/
def reply_?(message: Any): Boolean = replyTo match {
- case Some(Left(actor)) =>
- actor ! message
- true
- case Some(Right(future: Future[Any])) =>
- future completeWithResult message
- true
- case _ =>
- false
+ case Some(Left(actor)) => actor ! message; true
+ case Some(Right(future: Future[Any])) => future completeWithResult message; true
+ case _ => false
}
/**
@@ -714,8 +698,7 @@ sealed class LocalActorRef private[akka](
* Returns the remote address for the actor, if any, else None.
*/
def remoteAddress: Option[InetSocketAddress] = guard.withGuard { _remoteAddress }
- protected[akka] def remoteAddress_=(addr: Option[InetSocketAddress]): Unit =
- guard.withGuard { _remoteAddress = addr }
+ protected[akka] def remoteAddress_=(addr: Option[InetSocketAddress]): Unit = guard.withGuard { _remoteAddress = addr }
/**
* Starts up the actor and its message queue.
@@ -878,11 +861,8 @@ sealed class LocalActorRef private[akka](
protected[akka] def supervisor_=(sup: Option[ActorRef]): Unit = guard.withGuard { _supervisor = sup }
private def spawnButDoNotStart[T <: Actor: Manifest]: ActorRef = guard.withGuard {
- val actor = manifest[T].erasure.asInstanceOf[Class[T]].newInstance
- val actorRef = Actor.newActor(() => actor)
- if (!dispatcher.isInstanceOf[ThreadBasedDispatcher]) {
- actorRef.dispatcher = dispatcher
- }
+ val actorRef = Actor.actorOf(manifest[T].erasure.asInstanceOf[Class[T]].newInstance)
+ if (!dispatcher.isInstanceOf[ThreadBasedDispatcher]) actorRef.dispatcher = dispatcher
actorRef
}
@@ -896,8 +876,9 @@ sealed class LocalActorRef private[akka](
} catch {
case e: InstantiationException => throw new ActorInitializationException(
"Could not instantiate Actor due to:\n" + e +
- "\nMake sure Actor is defined inside a class/trait," +
- "\nif so put it outside the class/trait, f.e. in a companion object.")
+ "\nMake sure Actor is NOT defined inside a class/trait," +
+ "\nif so put it outside the class/trait, f.e. in a companion object," +
+ "\nOR try to change: 'actorOf[MyActor]' to 'actorOf(new MyActor)'.")
}
case Right(Some(factory)) =>
factory()
diff --git a/akka-core/src/main/scala/actor/Agent.scala b/akka-core/src/main/scala/actor/Agent.scala
index ac788b213a..15e42d6a73 100644
--- a/akka-core/src/main/scala/actor/Agent.scala
+++ b/akka-core/src/main/scala/actor/Agent.scala
@@ -102,7 +102,7 @@ sealed class Agent[T] private (initialValue: T) {
import Agent._
import Actor._
- private val dispatcher = newActor(() => new AgentDispatcher[T](initialValue)).start
+ private val dispatcher = actorOf(new AgentDispatcher[T](initialValue)).start
dispatcher ! Value(initialValue)
/**
diff --git a/akka-core/src/main/scala/actor/Scheduler.scala b/akka-core/src/main/scala/actor/Scheduler.scala
index d3429ef446..fcbba357ad 100644
--- a/akka-core/src/main/scala/actor/Scheduler.scala
+++ b/akka-core/src/main/scala/actor/Scheduler.scala
@@ -47,7 +47,7 @@ object Scheduler extends Actor {
def schedule(receiver: ActorRef, message: AnyRef, initialDelay: Long, delay: Long, timeUnit: TimeUnit) = {
try {
- self.startLink(newActor(() => new ScheduleActor(
+ self.startLink(actorOf(new ScheduleActor(
receiver,
service.scheduleAtFixedRate(new java.lang.Runnable {
def run = receiver ! message;
diff --git a/akka-core/src/main/scala/actor/Supervisor.scala b/akka-core/src/main/scala/actor/Supervisor.scala
index e366f102d5..4d2fd49541 100644
--- a/akka-core/src/main/scala/actor/Supervisor.scala
+++ b/akka-core/src/main/scala/actor/Supervisor.scala
@@ -84,11 +84,11 @@ object Supervisor {
object SupervisorActor {
def apply(config: SupervisorConfig): ActorRef = {
val (handler, trapExits) = SupervisorFactory.retrieveFaultHandlerAndTrapExitsFrom(config)
- newActor(() => new SupervisorActor(handler, trapExits)).start
+ actorOf(new SupervisorActor(handler, trapExits)).start
}
def apply(handler: FaultHandlingStrategy, trapExceptions: List[Class[_ <: Throwable]]): ActorRef =
- newActor(() => new SupervisorActor(handler, trapExceptions)).start
+ actorOf(new SupervisorActor(handler, trapExceptions)).start
}
/**
diff --git a/akka-core/src/main/scala/config/ActiveObjectGuiceConfigurator.scala b/akka-core/src/main/scala/config/ActiveObjectGuiceConfigurator.scala
index 4e1bd16efb..6f3a6177dc 100644
--- a/akka-core/src/main/scala/config/ActiveObjectGuiceConfigurator.scala
+++ b/akka-core/src/main/scala/config/ActiveObjectGuiceConfigurator.scala
@@ -82,7 +82,7 @@ private[akka] class ActiveObjectGuiceConfigurator extends ActiveObjectConfigurat
private def newSubclassingProxy(component: Component): DependencyBinding = {
val targetClass = component.target
- val actorRef = Actor.newActor(() => new Dispatcher(component.transactionRequired, component.lifeCycle.callbacks))
+ val actorRef = Actor.actorOf(new Dispatcher(component.transactionRequired, component.lifeCycle.callbacks))
if (component.dispatcher.isDefined) actorRef.dispatcher = component.dispatcher.get
val remoteAddress =
if (component.remoteAddress.isDefined)
@@ -103,7 +103,7 @@ private[akka] class ActiveObjectGuiceConfigurator extends ActiveObjectConfigurat
val targetClass = component.intf.get
val targetInstance = component.target.newInstance.asInstanceOf[AnyRef] // TODO: perhaps need to put in registry
component.target.getConstructor(Array[Class[_]](): _*).setAccessible(true)
- val actorRef = Actor.newActor(() => new Dispatcher(component.transactionRequired, component.lifeCycle.callbacks))
+ val actorRef = Actor.actorOf(new Dispatcher(component.transactionRequired, component.lifeCycle.callbacks))
if (component.dispatcher.isDefined) actorRef.dispatcher = component.dispatcher.get
val remoteAddress =
if (component.remoteAddress.isDefined)
diff --git a/akka-core/src/main/scala/config/Config.scala b/akka-core/src/main/scala/config/Config.scala
index f9a1035a7c..c230d45b5d 100644
--- a/akka-core/src/main/scala/config/Config.scala
+++ b/akka-core/src/main/scala/config/Config.scala
@@ -28,17 +28,7 @@ object Config extends Logging {
}
val config = {
- if (HOME.isDefined) {
- try {
- val configFile = HOME.get + "/config/akka.conf"
- Configgy.configure(configFile)
- log.info("AKKA_HOME is defined to [%s], config loaded from [%s].", HOME.get, configFile)
- } catch {
- case e: ParseException => throw new IllegalStateException(
- "'akka.conf' config file can not be found in [" + HOME + "/config/akka.conf] aborting." +
- "\n\tEither add it in the 'config' directory or add it to the classpath.")
- }
- } else if (System.getProperty("akka.config", "") != "") {
+ if (System.getProperty("akka.config", "") != "") {
val configFile = System.getProperty("akka.config", "")
try {
Configgy.configure(configFile)
@@ -47,20 +37,33 @@ object Config extends Logging {
case e: ParseException => throw new IllegalStateException(
"Config could not be loaded from -Dakka.config=" + configFile)
}
- } else {
+ } else if (getClass.getClassLoader.getResource("akka.conf") != null) {
try {
Configgy.configureFromResource("akka.conf", getClass.getClassLoader)
log.info("Config loaded from the application classpath.")
} catch {
case e: ParseException => throw new IllegalStateException(
- "\nCan't find 'akka.conf' configuration file." +
- "\nOne of the three ways of locating the 'akka.conf' file needs to be defined:" +
- "\n\t1. Define 'AKKA_HOME' environment variable to the root of the Akka distribution." +
- "\n\t2. Define the '-Dakka.config=...' system property option." +
- "\n\t3. Put the 'akka.conf' file on the classpath." +
- "\nI have no way of finding the 'akka.conf' configuration file." +
- "\nAborting.")
+ "Can't load 'akka.conf' config file from application classpath.")
}
+ } else if (HOME.isDefined) {
+ try {
+ val configFile = HOME.get + "/config/akka.conf"
+ Configgy.configure(configFile)
+ log.info("AKKA_HOME is defined as [%s], config loaded from [%s].", HOME.get, configFile)
+ } catch {
+ case e: ParseException => throw new IllegalStateException(
+ "AKKA_HOME is defined as [" + HOME.get + "] " +
+ "but the 'akka.conf' config file can not be found at [" + HOME.get + "/config/akka.conf].")
+ }
+ } else {
+ throw new IllegalStateException(
+ "\nCan't load 'akka.conf'." +
+ "\nOne of the three ways of locating the 'akka.conf' file needs to be defined:" +
+ "\n\t1. Define the '-Dakka.config=...' system property option." +
+ "\n\t2. Put the 'akka.conf' file on the classpath." +
+ "\n\t3. Define 'AKKA_HOME' environment variable pointing to the root of the Akka distribution." +
+ "\nI have no way of finding the 'akka.conf' configuration file." +
+ "\nAborting.")
}
Configgy.config
}
diff --git a/akka-core/src/main/scala/dispatch/ExecutorBasedEventDrivenWorkStealingDispatcher.scala b/akka-core/src/main/scala/dispatch/ExecutorBasedEventDrivenWorkStealingDispatcher.scala
index 40372c465d..1d28d1eb04 100644
--- a/akka-core/src/main/scala/dispatch/ExecutorBasedEventDrivenWorkStealingDispatcher.scala
+++ b/akka-core/src/main/scala/dispatch/ExecutorBasedEventDrivenWorkStealingDispatcher.scala
@@ -51,12 +51,7 @@ class ExecutorBasedEventDrivenWorkStealingDispatcher(_name: String) extends Mess
if (!tryProcessMailbox(invocation.receiver)) {
// we are not able to process our mailbox (another thread is busy with it), so lets donate some of our mailbox
// to another actor and then process his mailbox in stead.
- findThief(invocation.receiver) match {
- case Some(thief) => {
- tryDonateAndProcessMessages(invocation.receiver, thief)
- }
- case None => { /* no other actor in the pool */ }
- }
+ findThief(invocation.receiver).foreach( tryDonateAndProcessMessages(invocation.receiver,_) )
}
}
})
@@ -101,18 +96,13 @@ class ExecutorBasedEventDrivenWorkStealingDispatcher(_name: String) extends Mess
private def findThief(receiver: ActorRef): Option[ActorRef] = {
// copy to prevent concurrent modifications having any impact
val actors = pooledActors.toArray(new Array[ActorRef](pooledActors.size))
- var i = lastThiefIndex
- if (i > actors.size)
- i = 0
-
+ val i = if ( lastThiefIndex > actors.size ) 0 else lastThiefIndex
+
// we risk to pick a thief which is unregistered from the dispatcher in the meantime, but that typically means
// the dispatcher is being shut down...
- doFindThief(receiver, actors, i) match {
- case (thief: Option[ActorRef], index: Int) => {
- lastThiefIndex = (index + 1) % actors.size
- return thief
- }
- }
+ val (thief: Option[ActorRef], index: Int) = doFindThief(receiver, actors, i)
+ lastThiefIndex = (index + 1) % actors.size
+ thief
}
/**
@@ -127,13 +117,9 @@ class ExecutorBasedEventDrivenWorkStealingDispatcher(_name: String) extends Mess
for (i <- 0 to actors.length) {
val index = (i + startIndex) % actors.length
val actor = actors(index)
- if (actor != receiver) { // skip ourselves
- if (actor.mailbox.isEmpty) { // only pick actors that will most likely be able to process the messages
- return (Some(actor), index)
- }
- }
+ if (actor != receiver && actor.mailbox.isEmpty) return (Some(actor), index)
}
- return (None, startIndex) // nothing found, reuse same start index next time
+ (None, startIndex) // nothing found, reuse same start index next time
}
/**
@@ -143,38 +129,28 @@ class ExecutorBasedEventDrivenWorkStealingDispatcher(_name: String) extends Mess
private def tryDonateAndProcessMessages(receiver: ActorRef, thief: ActorRef) = {
if (thief.dispatcherLock.tryLock) {
try {
- donateAndProcessMessages(receiver, thief)
+ while(donateMessage(receiver, thief))
+ processMailbox(thief)
} finally {
thief.dispatcherLock.unlock
}
}
}
- /**
- * Donate messages to the thief and process them on the thief as long as the receiver has more messages.
- */
- private def donateAndProcessMessages(receiver: ActorRef, thief: ActorRef): Unit = {
- donateMessage(receiver, thief) match {
- case None => {
- // no more messages to donate
- return
- }
- case Some(donatedInvocation) => {
- processMailbox(thief)
- return donateAndProcessMessages(receiver, thief)
- }
- }
- }
-
/**
* Steal a message from the receiver and give it to the thief.
*/
- private def donateMessage(receiver: ActorRef, thief: ActorRef): Option[MessageInvocation] = {
+ private def donateMessage(receiver: ActorRef, thief: ActorRef): Boolean = {
val donated = receiver.mailbox.pollLast
- if (donated != null) {
- thief.self ! donated.message
- return Some(donated)
- } else return None
+ if (donated ne null) {
+ donated.replyTo match {
+ case None => thief.self.postMessageToMailbox(donated.message, None)
+ case Some(Left(actor)) => thief.self.postMessageToMailbox(donated.message, Some(actor.asInstanceOf[ActorRef]))
+ case Some(Right(future)) => thief.self.postMessageToMailboxAndCreateFutureResultWithTimeout[Any](
+ donated.message, receiver.timeout, Some(future.asInstanceOf[CompletableFuture[Any]]))
+ }
+ true
+ } else false
}
def start = if (!active) {
@@ -206,16 +182,16 @@ class ExecutorBasedEventDrivenWorkStealingDispatcher(_name: String) extends Mess
def usesActorMailbox = true
- private def verifyActorsAreOfSameType(newActorId: ActorRef) = {
+ private def verifyActorsAreOfSameType(actorOfId: ActorRef) = {
actorType match {
case None => {
- actorType = Some(newActorId.actor.getClass)
+ actorType = Some(actorOfId.actor.getClass)
}
case Some(aType) => {
- if (aType != newActorId.actor.getClass)
+ if (aType != actorOfId.actor.getClass)
throw new IllegalStateException(
String.format("Can't register actor %s in a work stealing dispatcher which already knows actors of type %s",
- newActorId.actor, aType))
+ actorOfId.actor, aType))
}
}
}
diff --git a/akka-core/src/main/scala/remote/Cluster.scala b/akka-core/src/main/scala/remote/Cluster.scala
index 5b918e78a3..366fec842d 100644
--- a/akka-core/src/main/scala/remote/Cluster.scala
+++ b/akka-core/src/main/scala/remote/Cluster.scala
@@ -251,7 +251,7 @@ object Cluster extends Cluster with Logging {
fqn =>
val a = Class.forName(fqn).newInstance.asInstanceOf[ClusterActor]
a setSerializer serializer
- Actor.newActor(() => a)
+ Actor.actorOf(a)
}
}
catch {
diff --git a/akka-core/src/main/scala/remote/RemoteClient.scala b/akka-core/src/main/scala/remote/RemoteClient.scala
index 57b3eb7048..6888d2c6c7 100644
--- a/akka-core/src/main/scala/remote/RemoteClient.scala
+++ b/akka-core/src/main/scala/remote/RemoteClient.scala
@@ -182,7 +182,6 @@ class RemoteClient(val hostname: String, val port: Int) extends Logging {
futures.synchronized {
val futureResult = if (senderFuture.isDefined) senderFuture.get
else new DefaultCompletableFuture[T](request.getTimeout)
- println("------ SETTING ID: " + request.getId + " " + name)
futures.put(request.getId, futureResult)
connection.getChannel.write(request)
Some(futureResult)
@@ -264,7 +263,6 @@ class RemoteClientHandler(val name: String,
if (result.isInstanceOf[RemoteReplyProtocol]) {
val reply = result.asInstanceOf[RemoteReplyProtocol]
log.debug("Remote client received RemoteReplyProtocol[\n%s]", reply.toString)
- println("------ GETTING ID: " + reply.getId + " " + name)
val future = futures.get(reply.getId).asInstanceOf[CompletableFuture[Any]]
if (reply.getIsSuccessful) {
val message = RemoteProtocolBuilder.getMessage(reply)
diff --git a/akka-core/src/main/scala/remote/RemoteServer.scala b/akka-core/src/main/scala/remote/RemoteServer.scala
index 1d0e67613e..2617134d28 100644
--- a/akka-core/src/main/scala/remote/RemoteServer.scala
+++ b/akka-core/src/main/scala/remote/RemoteServer.scala
@@ -210,10 +210,11 @@ class RemoteServer extends Logging {
// TODO: register active object in RemoteServer as well
/**
- * Register Remote Actor by the Actor's 'id' field.
+ * Register Remote Actor by the Actor's 'id' field. It starts the Actor if it is not started already.
*/
def register(actorRef: ActorRef) = synchronized {
if (_isRunning) {
+ if (!actorRef.isRunning) actorRef.start
log.info("Registering server side remote actor [%s] with id [%s]", actorRef.actorClass.getName, actorRef.id)
RemoteServer.actorsFor(RemoteServer.Address(hostname, port)).actors.put(actorRef.id, actorRef)
}
@@ -226,6 +227,7 @@ class RemoteServer extends Logging {
*/
def register(id: String, actorRef: ActorRef) = synchronized {
if (_isRunning) {
+ if (!actorRef.isRunning) actorRef.start
log.info("Registering server side remote actor [%s] with id [%s]", actorRef.actorClass.getName, id)
RemoteServer.actorsFor(RemoteServer.Address(hostname, port)).actors.put(id, actorRef)
}
@@ -476,8 +478,8 @@ class RemoteServerHandler(
try {
log.info("Creating a new remote actor [%s:%s]", name, uuid)
val clazz = if (applicationLoader.isDefined) applicationLoader.get.loadClass(name)
- else Class.forName(name)
- val actorRef = Actor.newActor(() => clazz.newInstance.asInstanceOf[Actor])
+ else Class.forName(name)
+ val actorRef = Actor.actorOf(clazz.newInstance.asInstanceOf[Actor])
actorRef.uuid = uuid
actorRef.timeout = timeout
actorRef.remoteAddress = None
diff --git a/akka-core/src/main/scala/routing/Patterns.scala b/akka-core/src/main/scala/routing/Patterns.scala
index a18d82886a..4381c6382b 100644
--- a/akka-core/src/main/scala/routing/Patterns.scala
+++ b/akka-core/src/main/scala/routing/Patterns.scala
@@ -27,21 +27,21 @@ object Patterns {
/** Creates a LoadBalancer from the thunk-supplied InfiniteIterator
*/
def loadBalancerActor(actors: => InfiniteIterator[ActorRef]): ActorRef =
- newActor(() => new Actor with LoadBalancer {
+ actorOf(new Actor with LoadBalancer {
val seq = actors
}).start
/** Creates a Dispatcher given a routing and a message-transforming function
*/
def dispatcherActor(routing: PF[Any, ActorRef], msgTransformer: (Any) => Any): ActorRef =
- newActor(() => new Actor with Dispatcher {
+ actorOf(new Actor with Dispatcher {
override def transform(msg: Any) = msgTransformer(msg)
def routes = routing
}).start
/** Creates a Dispatcher given a routing
*/
- def dispatcherActor(routing: PF[Any, ActorRef]): ActorRef = newActor(() => new Actor with Dispatcher {
+ def dispatcherActor(routing: PF[Any, ActorRef]): ActorRef = actorOf(new Actor with Dispatcher {
def routes = routing
}).start
diff --git a/akka-core/src/main/scala/stm/DataFlowVariable.scala b/akka-core/src/main/scala/stm/DataFlowVariable.scala
index bc65d9d5cd..a1256d715f 100644
--- a/akka-core/src/main/scala/stm/DataFlowVariable.scala
+++ b/akka-core/src/main/scala/stm/DataFlowVariable.scala
@@ -27,7 +27,7 @@ import se.scalablesolutions.akka.actor.Actor
import se.scalablesolutions.akka.dispatch.CompletableFuture
def thread(body: => Unit) = {
- val thread = newActor(() => new IsolatedEventBasedThread(body)).start
+ val thread = actorOf(new IsolatedEventBasedThread(body)).start
thread ! Start
thread
}
@@ -40,7 +40,7 @@ import se.scalablesolutions.akka.dispatch.CompletableFuture
}
def thread[A <: AnyRef, R <: AnyRef](body: A => R) =
- newActor(() => new ReactiveEventBasedThread(body)).start
+ actorOf(new ReactiveEventBasedThread(body)).start
private class ReactiveEventBasedThread[A <: AnyRef, T <: AnyRef](body: A => T)
extends Actor {
@@ -96,7 +96,7 @@ import se.scalablesolutions.akka.dispatch.CompletableFuture
}
}
- private[this] val in = newActor(() => new In(this)).start
+ private[this] val in = actorOf(new In(this)).start
def <<(ref: DataFlowVariable[T]) = in ! Set(ref())
@@ -106,7 +106,7 @@ import se.scalablesolutions.akka.dispatch.CompletableFuture
val ref = value.get
if (ref.isDefined) ref.get
else {
- val out = newActor(() => new Out(this)).start
+ val out = actorOf(new Out(this)).start
blockedReaders.offer(out)
val result = out !! Get
out ! Exit
diff --git a/akka-core/src/test/scala/ActorFireForgetRequestReplySpec.scala b/akka-core/src/test/scala/ActorFireForgetRequestReplySpec.scala
index 5531c2fbe7..cabe94e080 100644
--- a/akka-core/src/test/scala/ActorFireForgetRequestReplySpec.scala
+++ b/akka-core/src/test/scala/ActorFireForgetRequestReplySpec.scala
@@ -48,9 +48,8 @@ class ActorFireForgetRequestReplySpec extends JUnitSuite {
@Test
def shouldReplyToBangMessageUsingReply = {
state.finished.reset
- val replyActor = newActor[ReplyActor].start
- val senderActor = newActor(() => new SenderActor(replyActor))
- senderActor.start
+ val replyActor = actorOf[ReplyActor].start
+ val senderActor = actorOf(new SenderActor(replyActor)).start
senderActor ! "Init"
try { state.finished.await(1L, TimeUnit.SECONDS) }
catch { case e: TimeoutException => fail("Never got the message") }
@@ -60,8 +59,8 @@ class ActorFireForgetRequestReplySpec extends JUnitSuite {
@Test
def shouldReplyToBangMessageUsingImplicitSender = {
state.finished.reset
- val replyActor = newActor[ReplyActor].start
- val senderActor = newActor(() => new SenderActor(replyActor)).start
+ val replyActor = actorOf[ReplyActor].start
+ val senderActor = actorOf(new SenderActor(replyActor)).start
senderActor ! "InitImplicit"
try { state.finished.await(1L, TimeUnit.SECONDS) }
catch { case e: TimeoutException => fail("Never got the message") }
diff --git a/akka-core/src/test/scala/ActorPatternsTest.scala b/akka-core/src/test/scala/ActorPatternsTest.scala
index d300578c05..a85d1f66c8 100644
--- a/akka-core/src/test/scala/ActorPatternsTest.scala
+++ b/akka-core/src/test/scala/ActorPatternsTest.scala
@@ -12,13 +12,14 @@ import org.scalatest.junit.JUnitRunner
import org.scalatest.matchers.MustMatchers
import org.junit.{Before, After, Test}
import scala.collection.mutable.HashSet
+import java.util.concurrent.{ CountDownLatch, TimeUnit }
@RunWith(classOf[JUnitRunner])
class ActorPatternsTest extends junit.framework.TestCase with Suite with MustMatchers with Logging {
import Patterns._
@Test def testDispatcher = {
val (testMsg1,testMsg2,testMsg3,testMsg4) = ("test1","test2","test3","test4")
-
+ val latch = new CountDownLatch(1)
var targetOk = 0
val t1 = actor {
case `testMsg1` => targetOk += 2
@@ -26,7 +27,9 @@ class ActorPatternsTest extends junit.framework.TestCase with Suite with MustMat
}
val t2 = actor {
- case `testMsg3` => targetOk += 8
+ case `testMsg3` =>
+ targetOk += 8
+ latch.countDown
}
val d = dispatcherActor {
@@ -37,7 +40,8 @@ class ActorPatternsTest extends junit.framework.TestCase with Suite with MustMat
d ! testMsg1
d ! testMsg2
d ! testMsg3
- Thread.sleep(1000)
+ val done = latch.await(5,TimeUnit.SECONDS)
+ done must be (true)
targetOk must be(14)
t1.stop
t2.stop
@@ -54,7 +58,6 @@ class ActorPatternsTest extends junit.framework.TestCase with Suite with MustMat
val bar : Any = "bar"
l ! foo
l ! bar
- Thread.sleep(1000)
msgs must ( have size (2) and contain (foo) and contain (bar) )
t1.stop
l.stop
@@ -81,12 +84,10 @@ class ActorPatternsTest extends junit.framework.TestCase with Suite with MustMat
d.stop
}
- @Test def testListener = {
- import java.util.concurrent.{ CountDownLatch, TimeUnit }
-
+ @Test def testListener = {
val latch = new CountDownLatch(2)
val num = new AtomicInteger(0)
- val i = newActor(() => new Actor with Listeners {
+ val i = actorOf(new Actor with Listeners {
def receive = listenerManagement orElse {
case "foo" => gossip("bar")
}
diff --git a/akka-core/src/test/scala/ActorRegistrySpec.scala b/akka-core/src/test/scala/ActorRegistrySpec.scala
index 9dcba44e8c..6a25e066b6 100644
--- a/akka-core/src/test/scala/ActorRegistrySpec.scala
+++ b/akka-core/src/test/scala/ActorRegistrySpec.scala
@@ -21,7 +21,7 @@ class ActorRegistrySpec extends JUnitSuite {
@Test def shouldGetActorByIdFromActorRegistry {
ActorRegistry.shutdownAll
- val actor = newActor[TestActor]
+ val actor = actorOf[TestActor]
actor.start
val actors = ActorRegistry.actorsFor("MyID")
assert(actors.size === 1)
@@ -32,7 +32,7 @@ class ActorRegistrySpec extends JUnitSuite {
@Test def shouldGetActorByUUIDFromActorRegistry {
ActorRegistry.shutdownAll
- val actor = newActor[TestActor]
+ val actor = actorOf[TestActor]
val uuid = actor.uuid
actor.start
val actorOrNone = ActorRegistry.actorFor(uuid)
@@ -43,7 +43,7 @@ class ActorRegistrySpec extends JUnitSuite {
@Test def shouldGetActorByClassFromActorRegistry {
ActorRegistry.shutdownAll
- val actor = newActor[TestActor]
+ val actor = actorOf[TestActor]
actor.start
val actors = ActorRegistry.actorsFor(classOf[TestActor])
assert(actors.size === 1)
@@ -54,7 +54,7 @@ class ActorRegistrySpec extends JUnitSuite {
@Test def shouldGetActorByManifestFromActorRegistry {
ActorRegistry.shutdownAll
- val actor = newActor[TestActor]
+ val actor = actorOf[TestActor]
actor.start
val actors = ActorRegistry.actorsFor[TestActor]
assert(actors.size === 1)
@@ -65,9 +65,9 @@ class ActorRegistrySpec extends JUnitSuite {
@Test def shouldGetActorsByIdFromActorRegistry {
ActorRegistry.shutdownAll
- val actor1 = newActor[TestActor]
+ val actor1 = actorOf[TestActor]
actor1.start
- val actor2 = newActor[TestActor]
+ val actor2 = actorOf[TestActor]
actor2.start
val actors = ActorRegistry.actorsFor("MyID")
assert(actors.size === 2)
@@ -81,9 +81,9 @@ class ActorRegistrySpec extends JUnitSuite {
@Test def shouldGetActorsByClassFromActorRegistry {
ActorRegistry.shutdownAll
- val actor1 = newActor[TestActor]
+ val actor1 = actorOf[TestActor]
actor1.start
- val actor2 = newActor[TestActor]
+ val actor2 = actorOf[TestActor]
actor2.start
val actors = ActorRegistry.actorsFor(classOf[TestActor])
assert(actors.size === 2)
@@ -97,9 +97,9 @@ class ActorRegistrySpec extends JUnitSuite {
@Test def shouldGetActorsByManifestFromActorRegistry {
ActorRegistry.shutdownAll
- val actor1 = newActor[TestActor]
+ val actor1 = actorOf[TestActor]
actor1.start
- val actor2 = newActor[TestActor]
+ val actor2 = actorOf[TestActor]
actor2.start
val actors = ActorRegistry.actorsFor[TestActor]
assert(actors.size === 2)
@@ -113,9 +113,9 @@ class ActorRegistrySpec extends JUnitSuite {
@Test def shouldGetAllActorsFromActorRegistry {
ActorRegistry.shutdownAll
- val actor1 = newActor[TestActor]
+ val actor1 = actorOf[TestActor]
actor1.start
- val actor2 = newActor[TestActor]
+ val actor2 = actorOf[TestActor]
actor2.start
val actors = ActorRegistry.actors
assert(actors.size === 2)
@@ -129,9 +129,9 @@ class ActorRegistrySpec extends JUnitSuite {
@Test def shouldGetResponseByAllActorsInActorRegistryWhenInvokingForeach {
ActorRegistry.shutdownAll
- val actor1 = newActor[TestActor]
+ val actor1 = actorOf[TestActor]
actor1.start
- val actor2 = newActor[TestActor]
+ val actor2 = actorOf[TestActor]
actor2.start
record = ""
ActorRegistry.foreach(actor => actor !! "ping")
@@ -142,9 +142,9 @@ class ActorRegistrySpec extends JUnitSuite {
@Test def shouldShutdownAllActorsInActorRegistry {
ActorRegistry.shutdownAll
- val actor1 = newActor[TestActor]
+ val actor1 = actorOf[TestActor]
actor1.start
- val actor2 = newActor[TestActor]
+ val actor2 = actorOf[TestActor]
actor2.start
ActorRegistry.shutdownAll
assert(ActorRegistry.actors.size === 0)
@@ -152,9 +152,9 @@ class ActorRegistrySpec extends JUnitSuite {
@Test def shouldRemoveUnregisterActorInActorRegistry {
ActorRegistry.shutdownAll
- val actor1 = newActor[TestActor]
+ val actor1 = actorOf[TestActor]
actor1.start
- val actor2 = newActor[TestActor]
+ val actor2 = actorOf[TestActor]
actor2.start
assert(ActorRegistry.actors.size === 2)
ActorRegistry.unregister(actor1)
diff --git a/akka-core/src/test/scala/ClientInitiatedRemoteActorSpec.scala b/akka-core/src/test/scala/ClientInitiatedRemoteActorSpec.scala
index e412261b80..45ff025f8e 100644
--- a/akka-core/src/test/scala/ClientInitiatedRemoteActorSpec.scala
+++ b/akka-core/src/test/scala/ClientInitiatedRemoteActorSpec.scala
@@ -84,8 +84,8 @@ class ClientInitiatedRemoteActorSpec extends JUnitSuite {
}
@Test
- def shouldSendOneWay {
- val actor = newActor[RemoteActorSpecActorUnidirectional]
+ def shouldSendOneWay = {
+ val actor = actorOf[RemoteActorSpecActorUnidirectional]
actor.makeRemote(HOSTNAME, PORT1)
actor.start
actor ! "OneWay"
@@ -94,11 +94,11 @@ class ClientInitiatedRemoteActorSpec extends JUnitSuite {
}
@Test
- def shouldSendOneWayAndReceiveReply {
- val actor = newActor[SendOneWayAndReplyReceiverActor]
+ def shouldSendOneWayAndReceiveReply = {
+ val actor = actorOf[SendOneWayAndReplyReceiverActor]
actor.makeRemote(HOSTNAME, PORT1)
actor.start
- val sender = newActor[SendOneWayAndReplySenderActor]
+ val sender = actorOf[SendOneWayAndReplySenderActor]
sender.homeAddress = (HOSTNAME, PORT2)
sender.actor.asInstanceOf[SendOneWayAndReplySenderActor].sendTo = actor
sender.start
@@ -111,8 +111,8 @@ class ClientInitiatedRemoteActorSpec extends JUnitSuite {
}
@Test
- def shouldSendBangBangMessageAndReceiveReply {
- val actor = newActor[RemoteActorSpecActorBidirectional]
+ def shouldSendBangBangMessageAndReceiveReply = {
+ val actor = actorOf[RemoteActorSpecActorBidirectional]
actor.makeRemote(HOSTNAME, PORT1)
actor.start
val result = actor !! "Hello"
@@ -123,7 +123,7 @@ class ClientInitiatedRemoteActorSpec extends JUnitSuite {
@Test
def shouldSendAndReceiveRemoteException {
implicit val timeout = 500000000L
- val actor = newActor[RemoteActorSpecActorBidirectional]
+ val actor = actorOf[RemoteActorSpecActorBidirectional]
actor.makeRemote(HOSTNAME, PORT1)
actor.start
try {
diff --git a/akka-core/src/test/scala/ExecutorBasedEventDrivenDispatcherActorSpec.scala b/akka-core/src/test/scala/ExecutorBasedEventDrivenDispatcherActorSpec.scala
index aa5a16f0f6..cdab6ac71e 100644
--- a/akka-core/src/test/scala/ExecutorBasedEventDrivenDispatcherActorSpec.scala
+++ b/akka-core/src/test/scala/ExecutorBasedEventDrivenDispatcherActorSpec.scala
@@ -32,33 +32,29 @@ class ExecutorBasedEventDrivenDispatcherActorSpec extends JUnitSuite {
private val unit = TimeUnit.MILLISECONDS
- @Test def shouldSendOneWay {
- val actor = newActor[OneWayTestActor]
- actor.start
+ @Test def shouldSendOneWay = {
+ val actor = actorOf[OneWayTestActor].start
val result = actor ! "OneWay"
assert(OneWayTestActor.oneWay.await(1, TimeUnit.SECONDS))
actor.stop
}
- @Test def shouldSendReplySync {
- val actor = newActor[TestActor]
- actor.start
+ @Test def shouldSendReplySync = {
+ val actor = actorOf[TestActor].start
val result: String = (actor !! ("Hello", 10000)).get
assert("World" === result)
actor.stop
}
- @Test def shouldSendReplyAsync {
- val actor = newActor[TestActor]
- actor.start
+ @Test def shouldSendReplyAsync = {
+ val actor = actorOf[TestActor].start
val result = actor !! "Hello"
assert("World" === result.get.asInstanceOf[String])
actor.stop
}
- @Test def shouldSendReceiveException {
- val actor = newActor[TestActor]
- actor.start
+ @Test def shouldSendReceiveException = {
+ val actor = actorOf[TestActor].start
try {
actor !! "Failure"
fail("Should have thrown an exception")
diff --git a/akka-core/src/test/scala/ExecutorBasedEventDrivenDispatcherActorsSpec.scala b/akka-core/src/test/scala/ExecutorBasedEventDrivenDispatcherActorsSpec.scala
index ac1421dcdd..efd6831662 100644
--- a/akka-core/src/test/scala/ExecutorBasedEventDrivenDispatcherActorsSpec.scala
+++ b/akka-core/src/test/scala/ExecutorBasedEventDrivenDispatcherActorsSpec.scala
@@ -39,8 +39,8 @@ class ExecutorBasedEventDrivenDispatcherActorsSpec extends JUnitSuite with MustM
@Test def slowActorShouldntBlockFastActor {
val sFinished = new CountDownLatch(50)
val fFinished = new CountDownLatch(10)
- val s = newActor(() => new SlowActor(sFinished)).start
- val f = newActor(() => new FastActor(fFinished)).start
+ val s = actorOf(new SlowActor(sFinished)).start
+ val f = actorOf(new FastActor(fFinished)).start
// send a lot of stuff to s
for (i <- 1 to 50) {
diff --git a/akka-core/src/test/scala/ExecutorBasedEventDrivenWorkStealingDispatcherSpec.scala b/akka-core/src/test/scala/ExecutorBasedEventDrivenWorkStealingDispatcherSpec.scala
index 7aee353e38..7c056c80ac 100644
--- a/akka-core/src/test/scala/ExecutorBasedEventDrivenWorkStealingDispatcherSpec.scala
+++ b/akka-core/src/test/scala/ExecutorBasedEventDrivenWorkStealingDispatcherSpec.scala
@@ -57,8 +57,8 @@ class ExecutorBasedEventDrivenWorkStealingDispatcherSpec extends JUnitSuite with
@Test def fastActorShouldStealWorkFromSlowActor {
val finishedCounter = new CountDownLatch(110)
- val slow = newActor(() => new DelayableActor("slow", 50, finishedCounter)).start
- val fast = newActor(() => new DelayableActor("fast", 10, finishedCounter)).start
+ val slow = actorOf(new DelayableActor("slow", 50, finishedCounter)).start
+ val fast = actorOf(new DelayableActor("fast", 10, finishedCounter)).start
for (i <- 1 to 100) {
// send most work to slow actor
@@ -85,8 +85,8 @@ class ExecutorBasedEventDrivenWorkStealingDispatcherSpec extends JUnitSuite with
}
@Test def canNotUseActorsOfDifferentTypesInSameDispatcher: Unit = {
- val first = newActor[FirstActor]
- val second = newActor[SecondActor]
+ val first = actorOf[FirstActor]
+ val second = actorOf[SecondActor]
first.start
intercept[IllegalStateException] {
@@ -95,8 +95,8 @@ class ExecutorBasedEventDrivenWorkStealingDispatcherSpec extends JUnitSuite with
}
@Test def canNotUseActorsOfDifferentSubTypesInSameDispatcher: Unit = {
- val parent = newActor[ParentActor]
- val child = newActor[ChildActor]
+ val parent = actorOf[ParentActor]
+ val child = actorOf[ChildActor]
parent.start
intercept[IllegalStateException] {
diff --git a/akka-core/src/test/scala/ForwardActorSpec.scala b/akka-core/src/test/scala/ForwardActorSpec.scala
index f6e3e26e86..76f4808706 100644
--- a/akka-core/src/test/scala/ForwardActorSpec.scala
+++ b/akka-core/src/test/scala/ForwardActorSpec.scala
@@ -24,7 +24,7 @@ object ForwardActorSpec {
class ForwardActor extends Actor {
- val receiverActor = newActor[ReceiverActor]
+ val receiverActor = actorOf[ReceiverActor]
receiverActor.start
def receive = {
case "SendBang" => receiverActor.forward("SendBang")
@@ -33,7 +33,7 @@ object ForwardActorSpec {
}
class BangSenderActor extends Actor {
- val forwardActor = newActor[ForwardActor]
+ val forwardActor = actorOf[ForwardActor]
forwardActor.start
forwardActor ! "SendBang"
def receive = {
@@ -43,7 +43,7 @@ object ForwardActorSpec {
class BangBangSenderActor extends Actor {
val latch = new CountDownLatch(1)
- val forwardActor = newActor[ForwardActor]
+ val forwardActor = actorOf[ForwardActor]
forwardActor.start
(forwardActor !! "SendBangBang") match {
case Some(_) => latch.countDown
@@ -60,7 +60,7 @@ class ForwardActorSpec extends JUnitSuite {
@Test
def shouldForwardActorReferenceWhenInvokingForwardOnBang {
- val senderActor = newActor[BangSenderActor]
+ val senderActor = actorOf[BangSenderActor]
val latch = senderActor.actor.asInstanceOf[BangSenderActor]
.forwardActor.actor.asInstanceOf[ForwardActor]
.receiverActor.actor.asInstanceOf[ReceiverActor]
@@ -73,7 +73,7 @@ class ForwardActorSpec extends JUnitSuite {
@Test
def shouldForwardActorReferenceWhenInvokingForwardOnBangBang {
- val senderActor = newActor[BangBangSenderActor]
+ val senderActor = actorOf[BangBangSenderActor]
senderActor.start
val latch = senderActor.actor.asInstanceOf[BangBangSenderActor].latch
assert(latch.await(1L, TimeUnit.SECONDS))
diff --git a/akka-core/src/test/scala/FutureSpec.scala b/akka-core/src/test/scala/FutureSpec.scala
index 2e30689ff9..1cdb071620 100644
--- a/akka-core/src/test/scala/FutureSpec.scala
+++ b/akka-core/src/test/scala/FutureSpec.scala
@@ -21,7 +21,7 @@ class FutureSpec extends JUnitSuite {
import FutureSpec._
@Test def shouldActorReplyResultThroughExplicitFuture {
- val actor = newActor[TestActor]
+ val actor = actorOf[TestActor]
actor.start
val future = actor !!! "Hello"
future.await
@@ -31,7 +31,7 @@ class FutureSpec extends JUnitSuite {
}
@Test def shouldActorReplyExceptionThroughExplicitFuture {
- val actor = newActor[TestActor]
+ val actor = actorOf[TestActor]
actor.start
val future = actor !!! "Failure"
future.await
@@ -41,11 +41,10 @@ class FutureSpec extends JUnitSuite {
}
/*
- @Test def shouldFutureAwaitEitherLeft {
- val actor1 = newActor[TestActor]
- actor1.start
- val actor2 = newActor[TestActor]
- actor2.start
+ // FIXME: implement Futures.awaitEither, and uncomment these two tests
+ @Test def shouldFutureAwaitEitherLeft = {
+ val actor1 = actorOf[TestActor].start
+ val actor2 = actorOf[TestActor].start
val future1 = actor1 !!! "Hello"
val future2 = actor2 !!! "NoReply"
val result = Futures.awaitEither(future1, future2)
@@ -55,11 +54,9 @@ class FutureSpec extends JUnitSuite {
actor2.stop
}
- @Test def shouldFutureAwaitEitherRight {
- val actor1 = newActor[TestActor]
- actor1.start
- val actor2 = newActor[TestActor]
- actor2.start
+ @Test def shouldFutureAwaitEitherRight = {
+ val actor1 = actorOf[TestActor].start
+ val actor2 = actorOf[TestActor].start
val future1 = actor1 !!! "NoReply"
val future2 = actor2 !!! "Hello"
val result = Futures.awaitEither(future1, future2)
@@ -69,11 +66,9 @@ class FutureSpec extends JUnitSuite {
actor2.stop
}
*/
- @Test def shouldFutureAwaitOneLeft {
- val actor1 = newActor[TestActor]
- actor1.start
- val actor2 = newActor[TestActor]
- actor2.start
+ @Test def shouldFutureAwaitOneLeft = {
+ val actor1 = actorOf[TestActor].start
+ val actor2 = actorOf[TestActor].start
val future1 = actor1 !!! "NoReply"
val future2 = actor2 !!! "Hello"
val result = Futures.awaitOne(List(future1, future2))
@@ -83,11 +78,9 @@ class FutureSpec extends JUnitSuite {
actor2.stop
}
- @Test def shouldFutureAwaitOneRight {
- val actor1 = newActor[TestActor]
- actor1.start
- val actor2 = newActor[TestActor]
- actor2.start
+ @Test def shouldFutureAwaitOneRight = {
+ val actor1 = actorOf[TestActor].start
+ val actor2 = actorOf[TestActor].start
val future1 = actor1 !!! "Hello"
val future2 = actor2 !!! "NoReply"
val result = Futures.awaitOne(List(future1, future2))
@@ -97,11 +90,9 @@ class FutureSpec extends JUnitSuite {
actor2.stop
}
- @Test def shouldFutureAwaitAll {
- val actor1 = newActor[TestActor]
- actor1.start
- val actor2 = newActor[TestActor]
- actor2.start
+ @Test def shouldFutureAwaitAll = {
+ val actor1 = actorOf[TestActor].start
+ val actor2 = actorOf[TestActor].start
val future1 = actor1 !!! "Hello"
val future2 = actor2 !!! "Hello"
Futures.awaitAll(List(future1, future2))
diff --git a/akka-core/src/test/scala/InMemoryActorSpec.scala b/akka-core/src/test/scala/InMemoryActorSpec.scala
index 18ca946592..46ddf5f237 100644
--- a/akka-core/src/test/scala/InMemoryActorSpec.scala
+++ b/akka-core/src/test/scala/InMemoryActorSpec.scala
@@ -109,7 +109,7 @@ class InMemFailerActor extends Transactor {
class InMemoryActorSpec extends JUnitSuite {
@Test
def shouldOneWayMapShouldNotRollbackStateForStatefulServerInCaseOfSuccess = {
- val stateful = newActor(() => new InMemStatefulActor(2))
+ val stateful = actorOf(new InMemStatefulActor(2))
stateful.start
stateful ! SetMapStateOneWay("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "init") // set init state
stateful ! SuccessOneWay("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "new state") // transactionrequired
@@ -120,7 +120,7 @@ class InMemoryActorSpec extends JUnitSuite {
@Test
def shouldMapShouldNotRollbackStateForStatefulServerInCaseOfSuccess = {
- val stateful = newActor[InMemStatefulActor]
+ val stateful = actorOf[InMemStatefulActor]
stateful.start
stateful !! SetMapState("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "init") // set init state
stateful !! Success("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "new state") // transactionrequired
@@ -129,9 +129,9 @@ class InMemoryActorSpec extends JUnitSuite {
@Test
def shouldOneWayMapShouldRollbackStateForStatefulServerInCaseOfFailure = {
- val stateful = newActor(() => new InMemStatefulActor(2))
+ val stateful = actorOf(new InMemStatefulActor(2))
stateful.start
- val failer = newActor[InMemFailerActor]
+ val failer = actorOf[InMemFailerActor]
failer.start
stateful ! SetMapStateOneWay("testShouldRollbackStateForStatefulServerInCaseOfFailure", "init") // set init state
stateful ! FailureOneWay("testShouldRollbackStateForStatefulServerInCaseOfFailure", "new state", failer) // call failing transactionrequired method
@@ -142,10 +142,10 @@ class InMemoryActorSpec extends JUnitSuite {
@Test
def shouldMapShouldRollbackStateForStatefulServerInCaseOfFailure = {
- val stateful = newActor[InMemStatefulActor]
+ val stateful = actorOf[InMemStatefulActor]
stateful.start
stateful !! SetMapState("testShouldRollbackStateForStatefulServerInCaseOfFailure", "init") // set init state
- val failer = newActor[InMemFailerActor]
+ val failer = actorOf[InMemFailerActor]
failer.start
try {
stateful !! Failure("testShouldRollbackStateForStatefulServerInCaseOfFailure", "new state", failer) // call failing transactionrequired method
@@ -156,7 +156,7 @@ class InMemoryActorSpec extends JUnitSuite {
@Test
def shouldOneWayVectorShouldNotRollbackStateForStatefulServerInCaseOfSuccess = {
- val stateful = newActor(() => new InMemStatefulActor(2))
+ val stateful = actorOf(new InMemStatefulActor(2))
stateful.start
stateful ! SetVectorStateOneWay("init") // set init state
stateful ! SuccessOneWay("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "new state") // transactionrequired
@@ -167,7 +167,7 @@ class InMemoryActorSpec extends JUnitSuite {
@Test
def shouldVectorShouldNotRollbackStateForStatefulServerInCaseOfSuccess = {
- val stateful = newActor[InMemStatefulActor]
+ val stateful = actorOf[InMemStatefulActor]
stateful.start
stateful !! SetVectorState("init") // set init state
stateful !! Success("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "new state") // transactionrequired
@@ -176,11 +176,11 @@ class InMemoryActorSpec extends JUnitSuite {
@Test
def shouldOneWayVectorShouldRollbackStateForStatefulServerInCaseOfFailure = {
- val stateful = newActor(() => new InMemStatefulActor(2))
+ val stateful = actorOf(new InMemStatefulActor(2))
stateful.start
stateful ! SetVectorStateOneWay("init") // set init state
Thread.sleep(1000)
- val failer = newActor[InMemFailerActor]
+ val failer = actorOf[InMemFailerActor]
failer.start
stateful ! FailureOneWay("testShouldRollbackStateForStatefulServerInCaseOfFailure", "new state", failer) // call failing transactionrequired method
val notifier: Option[CountDownLatch] = stateful !! GetNotifier
@@ -190,10 +190,10 @@ class InMemoryActorSpec extends JUnitSuite {
@Test
def shouldVectorShouldRollbackStateForStatefulServerInCaseOfFailure = {
- val stateful = newActor[InMemStatefulActor]
+ val stateful = actorOf[InMemStatefulActor]
stateful.start
stateful !! SetVectorState("init") // set init state
- val failer = newActor[InMemFailerActor]
+ val failer = actorOf[InMemFailerActor]
failer.start
try {
stateful !! Failure("testShouldRollbackStateForStatefulServerInCaseOfFailure", "new state", failer) // call failing transactionrequired method
@@ -204,7 +204,7 @@ class InMemoryActorSpec extends JUnitSuite {
@Test
def shouldOneWayRefShouldNotRollbackStateForStatefulServerInCaseOfSuccess = {
- val stateful = newActor(() => new InMemStatefulActor(2))
+ val stateful = actorOf(new InMemStatefulActor(2))
stateful.start
stateful ! SetRefStateOneWay("init") // set init state
stateful ! SuccessOneWay("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "new state") // transactionrequired
@@ -215,7 +215,7 @@ class InMemoryActorSpec extends JUnitSuite {
@Test
def shouldRefShouldNotRollbackStateForStatefulServerInCaseOfSuccess = {
- val stateful = newActor[InMemStatefulActor]
+ val stateful = actorOf[InMemStatefulActor]
stateful.start
stateful !! SetRefState("init") // set init state
stateful !! Success("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "new state") // transactionrequired
@@ -224,11 +224,11 @@ class InMemoryActorSpec extends JUnitSuite {
@Test
def shouldOneWayRefShouldRollbackStateForStatefulServerInCaseOfFailure = {
- val stateful = newActor(() => new InMemStatefulActor(2))
+ val stateful = actorOf(new InMemStatefulActor(2))
stateful.start
stateful ! SetRefStateOneWay("init") // set init state
Thread.sleep(1000)
- val failer = newActor[InMemFailerActor]
+ val failer = actorOf[InMemFailerActor]
failer.start
stateful ! FailureOneWay("testShouldRollbackStateForStatefulServerInCaseOfFailure", "new state", failer) // call failing transactionrequired method
val notifier: Option[CountDownLatch] = stateful !! GetNotifier
@@ -238,10 +238,10 @@ class InMemoryActorSpec extends JUnitSuite {
@Test
def shouldRefShouldRollbackStateForStatefulServerInCaseOfFailure = {
- val stateful = newActor[InMemStatefulActor]
+ val stateful = actorOf[InMemStatefulActor]
stateful.start
stateful !! SetRefState("init") // set init state
- val failer = newActor[InMemFailerActor]
+ val failer = actorOf[InMemFailerActor]
failer.start
try {
stateful !! Failure("testShouldRollbackStateForStatefulServerInCaseOfFailure", "new state", failer) // call failing transactionrequired method
diff --git a/akka-core/src/test/scala/ProtobufActorMessageSerializationSpec.scala b/akka-core/src/test/scala/ProtobufActorMessageSerializationSpec.scala
index 22fed5f061..0a6710262e 100644
--- a/akka-core/src/test/scala/ProtobufActorMessageSerializationSpec.scala
+++ b/akka-core/src/test/scala/ProtobufActorMessageSerializationSpec.scala
@@ -44,7 +44,7 @@ class ProtobufActorMessageSerializationSpec extends JUnitSuite {
def init() {
server = new RemoteServer
server.start(HOSTNAME, PORT)
- server.register("RemoteActorSpecActorBidirectional", newActor[RemoteActorSpecActorBidirectional].start)
+ server.register("RemoteActorSpecActorBidirectional", actorOf[RemoteActorSpecActorBidirectional])
Thread.sleep(1000)
}
diff --git a/akka-core/src/test/scala/ReactorBasedSingleThreadEventDrivenDispatcherActorSpec.scala b/akka-core/src/test/scala/ReactorBasedSingleThreadEventDrivenDispatcherActorSpec.scala
index 3679736c94..f5210ce610 100644
--- a/akka-core/src/test/scala/ReactorBasedSingleThreadEventDrivenDispatcherActorSpec.scala
+++ b/akka-core/src/test/scala/ReactorBasedSingleThreadEventDrivenDispatcherActorSpec.scala
@@ -35,33 +35,29 @@ class ReactorBasedSingleThreadEventDrivenDispatcherActorSpec extends JUnitSuite
private val unit = TimeUnit.MILLISECONDS
- @Test def shouldSendOneWay {
- val actor = newActor[OneWayTestActor]
- actor.start
+ @Test def shouldSendOneWay = {
+ val actor = actorOf[OneWayTestActor].start
val result = actor ! "OneWay"
assert(OneWayTestActor.oneWay.await(1, TimeUnit.SECONDS))
actor.stop
}
- @Test def shouldSendReplySync {
- val actor = newActor[TestActor]
- actor.start
+ @Test def shouldSendReplySync = {
+ val actor = actorOf[TestActor].start
val result: String = (actor !! ("Hello", 10000)).get
assert("World" === result)
actor.stop
}
- @Test def shouldSendReplyAsync {
- val actor = newActor[TestActor]
- actor.start
+ @Test def shouldSendReplyAsync = {
+ val actor = actorOf[TestActor].start
val result = actor !! "Hello"
assert("World" === result.get.asInstanceOf[String])
actor.stop
}
- @Test def shouldSendReceiveException {
- val actor = newActor[TestActor]
- actor.start
+ @Test def shouldSendReceiveException = {
+ val actor = actorOf[TestActor].start
try {
actor !! "Failure"
fail("Should have thrown an exception")
diff --git a/akka-core/src/test/scala/ReactorBasedThreadPoolEventDrivenDispatcherActorSpec.scala b/akka-core/src/test/scala/ReactorBasedThreadPoolEventDrivenDispatcherActorSpec.scala
index 0681aaa534..0efe8483e9 100644
--- a/akka-core/src/test/scala/ReactorBasedThreadPoolEventDrivenDispatcherActorSpec.scala
+++ b/akka-core/src/test/scala/ReactorBasedThreadPoolEventDrivenDispatcherActorSpec.scala
@@ -26,37 +26,33 @@ class ReactorBasedThreadPoolEventDrivenDispatcherActorSpec extends JUnitSuite {
@Test def shouldSendOneWay {
val oneWay = new CountDownLatch(1)
- val actor = newActor(() => new Actor {
+ val actor = actorOf(new Actor {
self.dispatcher = Dispatchers.newReactorBasedThreadPoolEventDrivenDispatcher(self.uuid)
def receive = {
case "OneWay" => oneWay.countDown
}
- })
- actor.start
+ }).start
val result = actor ! "OneWay"
assert(oneWay.await(1, TimeUnit.SECONDS))
actor.stop
}
- @Test def shouldSendReplySync {
- val actor = newActor[TestActor]
- actor.start
+ @Test def shouldSendReplySync = {
+ val actor = actorOf[TestActor].start
val result: String = (actor !! ("Hello", 10000)).get
assert("World" === result)
actor.stop
}
- @Test def shouldSendReplyAsync {
- val actor = newActor[TestActor]
- actor.start
+ @Test def shouldSendReplyAsync = {
+ val actor = actorOf[TestActor].start
val result = actor !! "Hello"
assert("World" === result.get.asInstanceOf[String])
actor.stop
}
- @Test def shouldSendReceiveException {
- val actor = newActor[TestActor]
- actor.start
+ @Test def shouldSendReceiveException = {
+ val actor = actorOf[TestActor].start
try {
actor !! "Failure"
fail("Should have thrown an exception")
diff --git a/akka-core/src/test/scala/RemoteSupervisorSpec.scala b/akka-core/src/test/scala/RemoteSupervisorSpec.scala
index 14d49bd4ef..1ec5f6c48c 100644
--- a/akka-core/src/test/scala/RemoteSupervisorSpec.scala
+++ b/akka-core/src/test/scala/RemoteSupervisorSpec.scala
@@ -35,7 +35,6 @@ object Log {
}
override def postRestart(reason: Throwable) {
- println("================= POST RESTART")
Log.messageLog.put(reason.getMessage)
}
}
@@ -51,7 +50,6 @@ object Log {
}
override def postRestart(reason: Throwable) {
- println("================= POST RESTART")
Log.messageLog.put(reason.getMessage)
}
}
@@ -67,7 +65,6 @@ object Log {
}
override def postRestart(reason: Throwable) {
- println("================= POST RESTART")
Log.messageLog.put(reason.getMessage)
}
}
@@ -195,6 +192,7 @@ class RemoteSupervisorSpec extends JUnitSuite {
}
}
+/*
@Test def shouldKillMultipleActorsOneForOne2 = {
Log.messageLog.clear
val sup = getMultipleActorsOneForOneConf
@@ -207,7 +205,7 @@ class RemoteSupervisorSpec extends JUnitSuite {
Log.messageLog.poll(5, TimeUnit.SECONDS)
}
}
-
+*/
def tesCallKillCallMultipleActorsOneForOne = {
Log.messageLog.clear
val sup = getMultipleActorsOneForOneConf
@@ -354,7 +352,7 @@ class RemoteSupervisorSpec extends JUnitSuite {
// Then create a concrete container in which we mix in support for the specific
// implementation of the Actors we want to use.
- pingpong1 = newActor[RemotePingPong1Actor]
+ pingpong1 = actorOf[RemotePingPong1Actor]
pingpong1.makeRemote(RemoteServer.HOSTNAME, 9988)
pingpong1.start
@@ -370,7 +368,7 @@ class RemoteSupervisorSpec extends JUnitSuite {
}
def getSingleActorOneForOneSupervisor: Supervisor = {
- pingpong1 = newActor[RemotePingPong1Actor]
+ pingpong1 = actorOf[RemotePingPong1Actor]
pingpong1.makeRemote(RemoteServer.HOSTNAME, 9988)
pingpong1.start
@@ -385,13 +383,13 @@ class RemoteSupervisorSpec extends JUnitSuite {
}
def getMultipleActorsAllForOneConf: Supervisor = {
- pingpong1 = newActor[RemotePingPong1Actor]
+ pingpong1 = actorOf[RemotePingPong1Actor]
pingpong1.makeRemote(RemoteServer.HOSTNAME, 9988)
pingpong1.start
- pingpong2 = newActor[RemotePingPong2Actor]
+ pingpong2 = actorOf[RemotePingPong2Actor]
pingpong2.makeRemote(RemoteServer.HOSTNAME, 9988)
pingpong2.start
- pingpong3 = newActor[RemotePingPong3Actor]
+ pingpong3 = actorOf[RemotePingPong3Actor]
pingpong3.makeRemote(RemoteServer.HOSTNAME, 9988)
pingpong3.start
@@ -414,13 +412,15 @@ class RemoteSupervisorSpec extends JUnitSuite {
}
def getMultipleActorsOneForOneConf: Supervisor = {
- pingpong1 = newActor[RemotePingPong1Actor]
+ pingpong1 = actorOf[RemotePingPong1Actor]
+ pingpong1.makeRemote(RemoteServer.HOSTNAME, 9988)
+ pingpong1 = actorOf[RemotePingPong1Actor]
pingpong1.makeRemote(RemoteServer.HOSTNAME, 9988)
pingpong1.start
- pingpong2 = newActor[RemotePingPong2Actor]
+ pingpong2 = actorOf[RemotePingPong2Actor]
pingpong2.makeRemote(RemoteServer.HOSTNAME, 9988)
pingpong2.start
- pingpong3 = newActor[RemotePingPong3Actor]
+ pingpong3 = actorOf[RemotePingPong3Actor]
pingpong3.makeRemote(RemoteServer.HOSTNAME, 9988)
pingpong3.start
@@ -443,12 +443,15 @@ class RemoteSupervisorSpec extends JUnitSuite {
}
def getNestedSupervisorsAllForOneConf: Supervisor = {
- pingpong1 = newActor[RemotePingPong1Actor].start
+ pingpong1 = actorOf[RemotePingPong1Actor]
pingpong1.makeRemote(RemoteServer.HOSTNAME, 9988)
- pingpong2 = newActor[RemotePingPong2Actor].start
+ pingpong1.start
+ pingpong2 = actorOf[RemotePingPong2Actor]
pingpong2.makeRemote(RemoteServer.HOSTNAME, 9988)
- pingpong3 = newActor[RemotePingPong3Actor].start
+ pingpong2.start
+ pingpong3 = actorOf[RemotePingPong3Actor]
pingpong3.makeRemote(RemoteServer.HOSTNAME, 9988)
+ pingpong3.start
val factory = SupervisorFactory(
SupervisorConfig(
diff --git a/akka-core/src/test/scala/SerializerSpec.scala b/akka-core/src/test/scala/SerializerSpec.scala
index 391af17bc7..0efc05192c 100644
--- a/akka-core/src/test/scala/SerializerSpec.scala
+++ b/akka-core/src/test/scala/SerializerSpec.scala
@@ -7,12 +7,12 @@ import org.junit.{Test, Before, After}
import scala.reflect.BeanInfo
-//@BeanInfo
+@BeanInfo
case class Foo(foo: String) {
def this() = this(null)
}
-//@BeanInfo
+@BeanInfo
case class MyMessage(val id: String, val value: Tuple2[String, Int]) {
private def this() = this(null, null)
}
diff --git a/akka-core/src/test/scala/ServerInitiatedRemoteActorSample.scala b/akka-core/src/test/scala/ServerInitiatedRemoteActorSample.scala
index f359ead8ae..8d3a6a70b5 100644
--- a/akka-core/src/test/scala/ServerInitiatedRemoteActorSample.scala
+++ b/akka-core/src/test/scala/ServerInitiatedRemoteActorSample.scala
@@ -18,7 +18,7 @@ object ServerInitiatedRemoteActorServer {
def run = {
RemoteNode.start("localhost", 9999)
- RemoteNode.register("hello-service", newActor[HelloWorldActor])
+ RemoteNode.register("hello-service", actorOf[HelloWorldActor])
}
def main(args: Array[String]) = run
diff --git a/akka-core/src/test/scala/ServerInitiatedRemoteActorSpec.scala b/akka-core/src/test/scala/ServerInitiatedRemoteActorSpec.scala
index d02f21dfc4..7caa593b88 100644
--- a/akka-core/src/test/scala/ServerInitiatedRemoteActorSpec.scala
+++ b/akka-core/src/test/scala/ServerInitiatedRemoteActorSpec.scala
@@ -62,9 +62,9 @@ class ServerInitiatedRemoteActorSpec extends JUnitSuite {
server.start(HOSTNAME, PORT)
- server.register(newActor[RemoteActorSpecActorUnidirectional])
- server.register(newActor[RemoteActorSpecActorBidirectional])
- server.register(newActor[RemoteActorSpecActorAsyncSender])
+ server.register(actorOf[RemoteActorSpecActorUnidirectional])
+ server.register(actorOf[RemoteActorSpecActorBidirectional])
+ server.register(actorOf[RemoteActorSpecActorAsyncSender])
Thread.sleep(1000)
}
@@ -110,7 +110,7 @@ class ServerInitiatedRemoteActorSpec extends JUnitSuite {
"se.scalablesolutions.akka.actor.ServerInitiatedRemoteActorSpec$RemoteActorSpecActorBidirectional",
timeout,
HOSTNAME, PORT)
- val sender = newActor[RemoteActorSpecActorAsyncSender]
+ val sender = actorOf[RemoteActorSpecActorAsyncSender]
sender.homeAddress = (HOSTNAME, PORT + 1)
sender.start
sender ! Send(actor)
diff --git a/akka-core/src/test/scala/ShutdownSpec.scala b/akka-core/src/test/scala/ShutdownSpec.scala
index 040178af3f..afc7610cb8 100644
--- a/akka-core/src/test/scala/ShutdownSpec.scala
+++ b/akka-core/src/test/scala/ShutdownSpec.scala
@@ -13,7 +13,7 @@ object ActorShutdownRunner {
}
}
- val myActor = newActor[MyActor]
+ val myActor = actorOf[MyActor]
myActor.start
myActor ! "test"
myActor.stop
diff --git a/akka-core/src/test/scala/SupervisorSpec.scala b/akka-core/src/test/scala/SupervisorSpec.scala
index a1cc380ed6..23f33d9214 100644
--- a/akka-core/src/test/scala/SupervisorSpec.scala
+++ b/akka-core/src/test/scala/SupervisorSpec.scala
@@ -192,7 +192,7 @@ class SupervisorSpec extends JUnitSuite {
messageLog.poll(1, TimeUnit.SECONDS)
}
}
-
+/*
@Test def shouldKillMultipleActorsOneForOne2 = {
clearMessageLogs
val sup = getMultipleActorsOneForOneConf
@@ -205,7 +205,7 @@ class SupervisorSpec extends JUnitSuite {
messageLog.poll(1, TimeUnit.SECONDS)
}
}
-
+*/
@Test def shouldKillCallMultipleActorsOneForOne = {
clearMessageLogs
val sup = getMultipleActorsOneForOneConf
@@ -440,20 +440,19 @@ class SupervisorSpec extends JUnitSuite {
// Create some supervisors with different configurations
def getSingleActorAllForOneSupervisor: Supervisor = {
- pingpong1 = newActor[PingPong1Actor].start
+ pingpong1 = actorOf[PingPong1Actor].start
- val factory = SupervisorFactory(
- SupervisorConfig(
- RestartStrategy(AllForOne, 3, 100, List(classOf[Exception])),
- Supervise(
- pingpong1,
- LifeCycle(Permanent))
- :: Nil))
- factory.newInstance
+ Supervisor(
+ SupervisorConfig(
+ RestartStrategy(AllForOne, 3, 100, List(classOf[Exception])),
+ Supervise(
+ pingpong1,
+ LifeCycle(Permanent))
+ :: Nil))
}
def getSingleActorOneForOneSupervisor: Supervisor = {
- pingpong1 = newActor[PingPong1Actor].start
+ pingpong1 = actorOf[PingPong1Actor].start
Supervisor(
SupervisorConfig(
@@ -465,9 +464,9 @@ class SupervisorSpec extends JUnitSuite {
}
def getMultipleActorsAllForOneConf: Supervisor = {
- pingpong1 = newActor[PingPong1Actor].start
- pingpong2 = newActor[PingPong2Actor].start
- pingpong3 = newActor[PingPong3Actor].start
+ pingpong1 = actorOf[PingPong1Actor].start
+ pingpong2 = actorOf[PingPong2Actor].start
+ pingpong3 = actorOf[PingPong3Actor].start
Supervisor(
SupervisorConfig(
@@ -487,9 +486,9 @@ class SupervisorSpec extends JUnitSuite {
}
def getMultipleActorsOneForOneConf: Supervisor = {
- pingpong1 = newActor[PingPong1Actor].start
- pingpong2 = newActor[PingPong2Actor].start
- pingpong3 = newActor[PingPong3Actor].start
+ pingpong1 = actorOf[PingPong1Actor].start
+ pingpong2 = actorOf[PingPong2Actor].start
+ pingpong3 = actorOf[PingPong3Actor].start
Supervisor(
SupervisorConfig(
@@ -509,9 +508,9 @@ class SupervisorSpec extends JUnitSuite {
}
def getNestedSupervisorsAllForOneConf: Supervisor = {
- pingpong1 = newActor[PingPong1Actor].start
- pingpong2 = newActor[PingPong2Actor].start
- pingpong3 = newActor[PingPong3Actor].start
+ pingpong1 = actorOf[PingPong1Actor].start
+ pingpong2 = actorOf[PingPong2Actor].start
+ pingpong3 = actorOf[PingPong3Actor].start
Supervisor(
SupervisorConfig(
@@ -530,6 +529,6 @@ class SupervisorSpec extends JUnitSuite {
pingpong3,
LifeCycle(Permanent))
:: Nil)
- :: Nil))
- }
+ :: Nil))
+ }
}
diff --git a/akka-core/src/test/scala/ThreadBasedActorSpec.scala b/akka-core/src/test/scala/ThreadBasedActorSpec.scala
index c5bb6b1a3a..93bc065c4b 100644
--- a/akka-core/src/test/scala/ThreadBasedActorSpec.scala
+++ b/akka-core/src/test/scala/ThreadBasedActorSpec.scala
@@ -27,7 +27,7 @@ class ThreadBasedActorSpec extends JUnitSuite {
@Test def shouldSendOneWay {
var oneWay = new CountDownLatch(1)
- val actor = newActor(() => new Actor {
+ val actor = actorOf(new Actor {
self.dispatcher = Dispatchers.newThreadBasedDispatcher(self)
def receive = {
case "OneWay" => oneWay.countDown
@@ -38,22 +38,22 @@ class ThreadBasedActorSpec extends JUnitSuite {
actor.stop
}
- @Test def shouldSendReplySync {
- val actor = newActor[TestActor].start
+ @Test def shouldSendReplySync = {
+ val actor = actorOf[TestActor].start
val result: String = (actor !! ("Hello", 10000)).get
assert("World" === result)
actor.stop
}
- @Test def shouldSendReplyAsync {
- val actor = newActor[TestActor].start
+ @Test def shouldSendReplyAsync = {
+ val actor = actorOf[TestActor].start
val result = actor !! "Hello"
assert("World" === result.get.asInstanceOf[String])
actor.stop
}
- @Test def shouldSendReceiveException {
- val actor = newActor[TestActor].start
+ @Test def shouldSendReceiveException = {
+ val actor = actorOf[TestActor].start
try {
actor !! "Failure"
fail("Should have thrown an exception")
diff --git a/akka-core/src/test/scala/ThreadBasedDispatcherSpec.scala b/akka-core/src/test/scala/ThreadBasedDispatcherSpec.scala
index d3f635b8ca..5e0b9783f7 100644
--- a/akka-core/src/test/scala/ThreadBasedDispatcherSpec.scala
+++ b/akka-core/src/test/scala/ThreadBasedDispatcherSpec.scala
@@ -16,9 +16,9 @@ import Actor._
/*
class ThreadBasedDispatcherSpec extends JUnitSuite {
private var threadingIssueDetected: AtomicBoolean = null
- val key1 = newActor(() => new Actor { def receive = { case _ => {}} })
- val key2 = newActor(() => new Actor { def receive = { case _ => {}} })
- val key3 = newActor(() => new Actor { def receive = { case _ => {}} })
+ val key1 = actorOf(new Actor { def receive = { case _ => {}} })
+ val key2 = actorOf(new Actor { def receive = { case _ => {}} })
+ val key3 = actorOf(new Actor { def receive = { case _ => {}} })
class TestMessageHandle(handleLatch: CountDownLatch) extends MessageInvoker {
val guardLock: Lock = new ReentrantLock
diff --git a/akka-http/src/test/scala/SecuritySpec.scala b/akka-http/src/test/scala/SecuritySpec.scala
index 5c625dd097..79a3d95805 100644
--- a/akka-http/src/test/scala/SecuritySpec.scala
+++ b/akka-http/src/test/scala/SecuritySpec.scala
@@ -33,7 +33,7 @@ class BasicAuthenticatorSpec extends junit.framework.TestCase
with Suite with MockitoSugar with MustMatchers {
import BasicAuthenticatorSpec._
- val authenticator = newActor[BasicAuthenticator]
+ val authenticator = actorOf[BasicAuthenticator]
authenticator.start
@Test def testChallenge = {
diff --git a/akka-persistence/akka-persistence-cassandra/src/test/scala/CassandraPersistentActorSpec.scala b/akka-persistence/akka-persistence-cassandra/src/test/scala/CassandraPersistentActorSpec.scala
index 66c0286407..b1aef21818 100644
--- a/akka-persistence/akka-persistence-cassandra/src/test/scala/CassandraPersistentActorSpec.scala
+++ b/akka-persistence/akka-persistence-cassandra/src/test/scala/CassandraPersistentActorSpec.scala
@@ -76,7 +76,7 @@ class CassandraPersistentActorSpec extends JUnitSuite {
@Test
def testMapShouldNotRollbackStateForStatefulServerInCaseOfSuccess = {
- val stateful = newActor[CassandraPersistentActor]
+ val stateful = actorOf[CassandraPersistentActor]
stateful.start
stateful !! SetMapState("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "init") // set init state
stateful !! Success("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "new state") // transactionrequired
@@ -86,10 +86,10 @@ class CassandraPersistentActorSpec extends JUnitSuite {
@Test
def testMapShouldRollbackStateForStatefulServerInCaseOfFailure = {
- val stateful = newActor[CassandraPersistentActor]
+ val stateful = actorOf[CassandraPersistentActor]
stateful.start
stateful !! SetMapState("testShouldRollbackStateForStatefulServerInCaseOfFailure", "init") // set init state
- val failer = newActor[PersistentFailerActor]
+ val failer = actorOf[PersistentFailerActor]
failer.start
try {
stateful !! Failure("testShouldRollbackStateForStatefulServerInCaseOfFailure", "new state", failer) // call failing transactionrequired method
@@ -101,7 +101,7 @@ class CassandraPersistentActorSpec extends JUnitSuite {
@Test
def testVectorShouldNotRollbackStateForStatefulServerInCaseOfSuccess = {
- val stateful = newActor[CassandraPersistentActor]
+ val stateful = actorOf[CassandraPersistentActor]
stateful.start
stateful !! SetVectorState("init") // set init state
stateful !! Success("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "new state") // transactionrequired
@@ -110,10 +110,10 @@ class CassandraPersistentActorSpec extends JUnitSuite {
@Test
def testVectorShouldRollbackStateForStatefulServerInCaseOfFailure = {
- val stateful = newActor[CassandraPersistentActor]
+ val stateful = actorOf[CassandraPersistentActor]
stateful.start
stateful !! SetVectorState("init") // set init state
- val failer = newActor[PersistentFailerActor]
+ val failer = actorOf[PersistentFailerActor]
failer.start
try {
stateful !! Failure("testShouldRollbackStateForStatefulServerInCaseOfFailure", "new state", failer) // call failing transactionrequired method
@@ -124,7 +124,7 @@ class CassandraPersistentActorSpec extends JUnitSuite {
@Test
def testRefShouldNotRollbackStateForStatefulServerInCaseOfSuccess = {
- val stateful = newActor[CassandraPersistentActor]
+ val stateful = actorOf[CassandraPersistentActor]
stateful.start
stateful !! SetRefState("init") // set init state
stateful !! Success("testShouldNotRollbackStateForStatefulServerInCaseOfSuccess", "new state") // transactionrequired
@@ -134,10 +134,10 @@ class CassandraPersistentActorSpec extends JUnitSuite {
@Test
def testRefShouldRollbackStateForStatefulServerInCaseOfFailure = {
- val stateful = newActor[CassandraPersistentActor]
+ val stateful = actorOf[CassandraPersistentActor]
stateful.start
stateful !! SetRefState("init") // set init state
- val failer = newActor[PersistentFailerActor]
+ val failer = actorOf[PersistentFailerActor]
failer.start
try {
stateful !! Failure("testShouldRollbackStateForStatefulServerInCaseOfFailure", "new state", failer) // call failing transactionrequired method
diff --git a/akka-persistence/akka-persistence-mongo/src/test/scala/MongoPersistentActorSpec.scala b/akka-persistence/akka-persistence-mongo/src/test/scala/MongoPersistentActorSpec.scala
index 06a8bf381e..0e784648eb 100644
--- a/akka-persistence/akka-persistence-mongo/src/test/scala/MongoPersistentActorSpec.scala
+++ b/akka-persistence/akka-persistence-mongo/src/test/scala/MongoPersistentActorSpec.scala
@@ -105,9 +105,9 @@ class BankAccountActor extends Transactor {
class MongoPersistentActorSpec extends JUnitSuite {
@Test
def testSuccessfulDebit = {
- val bactor = newActor[BankAccountActor]
+ val bactor = actorOf[BankAccountActor]
bactor.start
- val failer = newActor[PersistentFailerActor]
+ val failer = actorOf[PersistentFailerActor]
failer.start
bactor !! Credit("a-123", 5000)
bactor !! Debit("a-123", 3000, failer)
@@ -137,14 +137,14 @@ class MongoPersistentActorSpec extends JUnitSuite {
@Test
def testUnsuccessfulDebit = {
- val bactor = newActor[BankAccountActor]
+ val bactor = actorOf[BankAccountActor]
bactor.start
bactor !! Credit("a-123", 5000)
val JsNumber(b) = (bactor !! Balance("a-123")).get.asInstanceOf[JsValue]
assertEquals(BigInt(5000), BigInt(b.intValue))
- val failer = newActor[PersistentFailerActor]
+ val failer = actorOf[PersistentFailerActor]
failer.start
try {
bactor !! Debit("a-123", 7000, failer)
@@ -160,14 +160,14 @@ class MongoPersistentActorSpec extends JUnitSuite {
@Test
def testUnsuccessfulMultiDebit = {
- val bactor = newActor[BankAccountActor]
+ val bactor = actorOf[BankAccountActor]
bactor.start
bactor !! Credit("a-123", 5000)
val JsNumber(b) = (bactor !! Balance("a-123")).get.asInstanceOf[JsValue]
assertEquals(BigInt(5000), BigInt(b.intValue))
- val failer = newActor[PersistentFailerActor]
+ val failer = actorOf[PersistentFailerActor]
failer.start
try {
bactor !! MultiDebit("a-123", List(500, 2000, 1000, 3000), failer)
diff --git a/akka-persistence/akka-persistence-redis/src/test/scala/RedisPersistentActorSpec.scala b/akka-persistence/akka-persistence-redis/src/test/scala/RedisPersistentActorSpec.scala
index 77e1143bb3..c96f759793 100644
--- a/akka-persistence/akka-persistence-redis/src/test/scala/RedisPersistentActorSpec.scala
+++ b/akka-persistence/akka-persistence-redis/src/test/scala/RedisPersistentActorSpec.scala
@@ -101,9 +101,9 @@ import org.scalatest.junit.JUnitSuite
class RedisPersistentActorSpec extends JUnitSuite {
@Test
def testSuccessfulDebit = {
- val bactor = newActor[AccountActor]
+ val bactor = actorOf[AccountActor]
bactor.start
- val failer = newActor[PersistentFailerActor]
+ val failer = actorOf[PersistentFailerActor]
failer.start
bactor !! Credit("a-123", 5000)
bactor !! Debit("a-123", 3000, failer)
@@ -127,12 +127,12 @@ class RedisPersistentActorSpec extends JUnitSuite {
@Test
def testUnsuccessfulDebit = {
- val bactor = newActor[AccountActor]
+ val bactor = actorOf[AccountActor]
bactor.start
bactor !! Credit("a-123", 5000)
assertEquals(BigInt(5000), (bactor !! Balance("a-123")).get)
- val failer = newActor[PersistentFailerActor]
+ val failer = actorOf[PersistentFailerActor]
failer.start
try {
bactor !! Debit("a-123", 7000, failer)
@@ -148,13 +148,13 @@ class RedisPersistentActorSpec extends JUnitSuite {
@Test
def testUnsuccessfulMultiDebit = {
- val bactor = newActor[AccountActor]
+ val bactor = actorOf[AccountActor]
bactor.start
bactor !! Credit("a-123", 5000)
assertEquals(BigInt(5000), (bactor !! (Balance("a-123"), 5000)).get)
- val failer = newActor[PersistentFailerActor]
+ val failer = actorOf[PersistentFailerActor]
failer.start
try {
bactor !! MultiDebit("a-123", List(500, 2000, 1000, 3000), failer)
diff --git a/akka-persistence/akka-persistence-redis/src/test/scala/RedisPersistentQSpec.scala b/akka-persistence/akka-persistence-redis/src/test/scala/RedisPersistentQSpec.scala
index 85fde879a6..8577d61c08 100644
--- a/akka-persistence/akka-persistence-redis/src/test/scala/RedisPersistentQSpec.scala
+++ b/akka-persistence/akka-persistence-redis/src/test/scala/RedisPersistentQSpec.scala
@@ -53,7 +53,7 @@ import org.scalatest.junit.JUnitSuite
class RedisPersistentQSpec extends JUnitSuite {
@Test
def testSuccessfulNQ = {
- val qa = newActor[QueueActor]
+ val qa = actorOf[QueueActor]
qa.start
qa !! NQ("a-123")
qa !! NQ("a-124")
@@ -64,7 +64,7 @@ class RedisPersistentQSpec extends JUnitSuite {
@Test
def testSuccessfulDQ = {
- val qa = newActor[QueueActor]
+ val qa = actorOf[QueueActor]
qa.start
qa !! NQ("a-123")
qa !! NQ("a-124")
@@ -80,9 +80,9 @@ class RedisPersistentQSpec extends JUnitSuite {
@Test
def testSuccessfulMNDQ = {
- val qa = newActor[QueueActor]
+ val qa = actorOf[QueueActor]
qa.start
- val failer = newActor[PersistentFailerActor]
+ val failer = actorOf[PersistentFailerActor]
failer.start
qa !! NQ("a-123")
@@ -100,9 +100,9 @@ class RedisPersistentQSpec extends JUnitSuite {
@Test
def testMixedMNDQ = {
- val qa = newActor[QueueActor]
+ val qa = actorOf[QueueActor]
qa.start
- val failer = newActor[PersistentFailerActor]
+ val failer = actorOf[PersistentFailerActor]
failer.start
// 3 enqueues
diff --git a/akka-persistence/akka-persistence-redis/src/test/scala/RedisPersistentSortedSetSpec.scala b/akka-persistence/akka-persistence-redis/src/test/scala/RedisPersistentSortedSetSpec.scala
index f7a23b6d34..d441ff1ba7 100644
--- a/akka-persistence/akka-persistence-redis/src/test/scala/RedisPersistentSortedSetSpec.scala
+++ b/akka-persistence/akka-persistence-redis/src/test/scala/RedisPersistentSortedSetSpec.scala
@@ -111,7 +111,7 @@ class RedisPersistentSortedSetSpec extends
val h6 = Hacker("Alan Turing", "1912")
describe("Add and report cardinality of the set") {
- val qa = newActor[SortedSetActor]
+ val qa = actorOf[SortedSetActor]
qa.start
it("should enter 6 hackers") {
@@ -167,10 +167,10 @@ class RedisPersistentSortedSetSpec extends
describe("Transaction semantics") {
it("should rollback on exception") {
- val qa = newActor[SortedSetActor]
+ val qa = actorOf[SortedSetActor]
qa.start
- val failer = newActor[PersistentFailerActor]
+ val failer = actorOf[PersistentFailerActor]
failer.start
(qa !! SIZE).get.asInstanceOf[Int] should equal(0)
@@ -195,7 +195,7 @@ class RedisPersistentSortedSetSpec extends
describe("zrange") {
it ("should report proper range") {
- val qa = newActor[SortedSetActor]
+ val qa = actorOf[SortedSetActor]
qa.start
qa !! ADD(h1)
qa !! ADD(h2)
@@ -214,7 +214,7 @@ class RedisPersistentSortedSetSpec extends
}
it ("should report proper rge") {
- val qa = newActor[SortedSetActor]
+ val qa = actorOf[SortedSetActor]
qa.start
qa !! ADD(h1)
qa !! ADD(h2)
diff --git a/akka-samples/akka-sample-camel/src/main/scala/Actors.scala b/akka-samples/akka-sample-camel/src/main/scala/Actors.scala
index be50d898c2..93aaa08ff6 100644
--- a/akka-samples/akka-sample-camel/src/main/scala/Actors.scala
+++ b/akka-samples/akka-sample-camel/src/main/scala/Actors.scala
@@ -40,14 +40,14 @@ class Consumer1 extends Actor with Consumer with Logging {
def endpointUri = "file:data/input"
def receive = {
- case msg: Message => log.info("received %s" format msg.bodyAs(classOf[String]))
+ case msg: Message => log.info("received %s" format msg.bodyAs[String])
}
}
@consume("jetty:http://0.0.0.0:8877/camel/test1")
class Consumer2 extends Actor {
def receive = {
- case msg: Message => self.reply("Hello %s" format msg.bodyAs(classOf[String]))
+ case msg: Message => self.reply("Hello %s" format msg.bodyAs[String])
}
}
@@ -55,7 +55,32 @@ class Consumer3(transformer: ActorRef) extends Actor with Consumer {
def endpointUri = "jetty:http://0.0.0.0:8877/camel/welcome"
def receive = {
- case msg: Message => transformer.forward(msg.setBodyAs(classOf[String]))
+ case msg: Message => transformer.forward(msg.setBodyAs[String])
+ }
+}
+
+class Consumer4 extends Actor with Consumer with Logging {
+ def endpointUri = "jetty:http://0.0.0.0:8877/camel/stop"
+
+ def receive = {
+ case msg: Message => msg.bodyAs[String] match {
+ case "stop" => {
+ self.reply("Consumer4 stopped")
+ self.stop
+ }
+ case body => self.reply(body)
+ }
+ }
+}
+
+class Consumer5 extends Actor with Consumer with Logging {
+ def endpointUri = "jetty:http://0.0.0.0:8877/camel/start"
+
+ def receive = {
+ case _ => {
+ Actor.actorOf[Consumer4].start
+ self.reply("Consumer4 started")
+ }
}
}
@@ -85,7 +110,7 @@ class PublisherBridge(uri: String, publisher: ActorRef) extends Actor with Consu
protected def receive = {
case msg: Message => {
- publisher ! msg.bodyAs(classOf[String])
+ publisher ! msg.bodyAs[String]
self.reply("message published")
}
}
diff --git a/akka-samples/akka-sample-camel/src/main/scala/Application1.scala b/akka-samples/akka-sample-camel/src/main/scala/Application1.scala
index 11f1bb8657..dfff0e0539 100644
--- a/akka-samples/akka-sample-camel/src/main/scala/Application1.scala
+++ b/akka-samples/akka-sample-camel/src/main/scala/Application1.scala
@@ -17,7 +17,7 @@ object Application1 {
def main(args: Array[String]) {
implicit val sender: Option[ActorRef] = None
- val actor1 = newActor[RemoteActor1]
+ val actor1 = actorOf[RemoteActor1]
val actor2 = RemoteClient.actorFor("remote2", "localhost", 7777)
actor1.start
diff --git a/akka-samples/akka-sample-camel/src/main/scala/Application2.scala b/akka-samples/akka-sample-camel/src/main/scala/Application2.scala
index 8756464b37..e01b510a71 100644
--- a/akka-samples/akka-sample-camel/src/main/scala/Application2.scala
+++ b/akka-samples/akka-sample-camel/src/main/scala/Application2.scala
@@ -17,6 +17,6 @@ object Application2 {
val camelService = CamelService.newInstance
camelService.load
RemoteNode.start("localhost", 7777)
- RemoteNode.register("remote2", newActor[RemoteActor2].start)
+ RemoteNode.register("remote2", actorOf[RemoteActor2].start)
}
}
\ No newline at end of file
diff --git a/akka-samples/akka-sample-camel/src/main/scala/Boot.scala b/akka-samples/akka-sample-camel/src/main/scala/Boot.scala
index 37c1ff651a..810f31aba5 100644
--- a/akka-samples/akka-sample-camel/src/main/scala/Boot.scala
+++ b/akka-samples/akka-sample-camel/src/main/scala/Boot.scala
@@ -28,15 +28,15 @@ class Boot {
val factory = SupervisorFactory(
SupervisorConfig(
RestartStrategy(OneForOne, 3, 100, List(classOf[Exception])),
- Supervise(newActor[Consumer1], LifeCycle(Permanent)) ::
- Supervise(newActor[Consumer2], LifeCycle(Permanent)) :: Nil))
+ Supervise(actorOf[Consumer1], LifeCycle(Permanent)) ::
+ Supervise(actorOf[Consumer2], LifeCycle(Permanent)) :: Nil))
factory.newInstance.start
// Routing example
- val producer = newActor[Producer1]
- val mediator = newActor(() => new Transformer(producer))
- val consumer = newActor(() => new Consumer3(mediator))
+ val producer = actorOf[Producer1]
+ val mediator = actorOf(new Transformer(producer))
+ val consumer = actorOf(new Consumer3(mediator))
producer.start
mediator.start
@@ -55,12 +55,15 @@ class Boot {
//val cometdPublisher = new Publisher("cometd-publisher", cometdUri).start
val jmsUri = "jms:topic:test"
- val jmsSubscriber1 = newActor(() => new Subscriber("jms-subscriber-1", jmsUri)).start
- val jmsSubscriber2 = newActor(() => new Subscriber("jms-subscriber-2", jmsUri)).start
- val jmsPublisher = newActor(() => new Publisher("jms-publisher", jmsUri)).start
+ val jmsSubscriber1 = actorOf(new Subscriber("jms-subscriber-1", jmsUri)).start
+ val jmsSubscriber2 = actorOf(new Subscriber("jms-subscriber-2", jmsUri)).start
+ val jmsPublisher = actorOf(new Publisher("jms-publisher", jmsUri)).start
- //val cometdPublisherBridge = newActor(() => new PublisherBridge("jetty:http://0.0.0.0:8877/camel/pub/cometd", cometdPublisher)).start
- val jmsPublisherBridge = newActor(() => new PublisherBridge("jetty:http://0.0.0.0:8877/camel/pub/jms", jmsPublisher)).start
+ //val cometdPublisherBridge = new PublisherBridge("jetty:http://0.0.0.0:8877/camel/pub/cometd", cometdPublisher).start
+ val jmsPublisherBridge = actorOf(new PublisherBridge("jetty:http://0.0.0.0:8877/camel/pub/jms", jmsPublisher)).start
+
+ actorOf[Consumer4].start // POSTing "stop" to http://0.0.0.0:8877/camel/stop stops and unpublishes this actor
+ actorOf[Consumer5].start // POSTing any msg to http://0.0.0.0:8877/camel/start starts and published Consumer4 again.
}
class CustomRouteBuilder extends RouteBuilder {
diff --git a/akka-samples/akka-sample-chat/README b/akka-samples/akka-sample-chat/README
index cf787bd4d2..fec39724e1 100644
--- a/akka-samples/akka-sample-chat/README
+++ b/akka-samples/akka-sample-chat/README
@@ -19,7 +19,7 @@ Then to run the sample:
4. In the first REPL you get execute:
- scala> import sample.chat._
- scala> import se.scalablesolutions.akka.actor.Actor._
- - scala> val chatService = newActor[ChatService].start
+ - scala> val chatService = actorOf[ChatService].start
5. In the second REPL you get execute:
- scala> import sample.chat._
- scala> Runner.run
diff --git a/akka-samples/akka-sample-chat/src/main/scala/ChatServer.scala b/akka-samples/akka-sample-chat/src/main/scala/ChatServer.scala
index 01772de6c7..d6caf210c3 100644
--- a/akka-samples/akka-sample-chat/src/main/scala/ChatServer.scala
+++ b/akka-samples/akka-sample-chat/src/main/scala/ChatServer.scala
@@ -36,7 +36,7 @@ Then to run the sample:
2. In the first REPL you get execute:
- scala> import sample.chat._
- scala> import se.scalablesolutions.akka.actor.Actor._
- - scala> val chatService = newActor[ChatService].start
+ - scala> val chatService = actorOf[ChatService].start
3. In the second REPL you get execute:
- scala> import sample.chat._
- scala> Runner.run
@@ -130,7 +130,7 @@ trait SessionManagement { this: Actor =>
protected def sessionManagement: PartialFunction[Any, Unit] = {
case Login(username) =>
log.info("User [%s] has logged in", username)
- val session = newActor(() => new Session(username, storage))
+ val session = actorOf(new Session(username, storage))
session.start
sessions += (username -> session)
@@ -197,7 +197,7 @@ trait ChatServer extends Actor {
* Class encapsulating the full Chat Service.
* Start service by invoking:
*
- * val chatService = Actor.newActor[ChatService].start
+ * val chatService = Actor.actorOf[ChatService].start
*
*/
class ChatService extends
diff --git a/akka-samples/akka-sample-lift/src/main/scala/bootstrap/liftweb/Boot.scala b/akka-samples/akka-sample-lift/src/main/scala/bootstrap/liftweb/Boot.scala
index 453fd53e2a..f8e4f15bd9 100644
--- a/akka-samples/akka-sample-lift/src/main/scala/bootstrap/liftweb/Boot.scala
+++ b/akka-samples/akka-sample-lift/src/main/scala/bootstrap/liftweb/Boot.scala
@@ -42,10 +42,10 @@ class Boot extends Logging {
SupervisorConfig(
RestartStrategy(OneForOne, 3, 100, List(classOf[Exception])),
Supervise(
- newActor[SimpleService],
+ actorOf[SimpleService],
LifeCycle(Permanent)) ::
Supervise(
- newActor[PersistentSimpleService],
+ actorOf[PersistentSimpleService],
LifeCycle(Permanent)) ::
Nil))
factory.newInstance.start
diff --git a/akka-samples/akka-sample-pubsub/src/main/scala/RedisPubSub.scala b/akka-samples/akka-sample-pubsub/src/main/scala/RedisPubSub.scala
index f0005ca919..44366d31a4 100644
--- a/akka-samples/akka-sample-pubsub/src/main/scala/RedisPubSub.scala
+++ b/akka-samples/akka-sample-pubsub/src/main/scala/RedisPubSub.scala
@@ -52,7 +52,7 @@ import se.scalablesolutions.akka.actor.Actor._
object Pub {
println("starting publishing service ..")
val r = new RedisClient("localhost", 6379)
- val p = newActor(() => new Publisher(r))
+ val p = actorOf(new Publisher(r))
p.start
def publish(channel: String, message: String) = {
@@ -63,7 +63,7 @@ object Pub {
object Sub {
println("starting subscription service ..")
val r = new RedisClient("localhost", 6379)
- val s = newActor(() => new Subscriber(r))
+ val s = actorOf(new Subscriber(r))
s.start
s ! Register(callback)
diff --git a/akka-samples/akka-sample-remote/README b/akka-samples/akka-sample-remote/README
index 052e79a37c..b20d1c7f4e 100644
--- a/akka-samples/akka-sample-remote/README
+++ b/akka-samples/akka-sample-remote/README
@@ -14,6 +14,7 @@ To run the sample:
- Step down into to the root of the Akka distribution.
- Set 'export AKKA_HOME=.
- Run 'sbt'
+ - Run 'update' followed by 'compile' if you have not done that before.
- Run 'project akka-sample-remote'
- Run 'console' to start up a REPL (interpreter).
2. In the first REPL you get execute:
@@ -39,6 +40,7 @@ To run the sample:
- Step down into to the root of the Akka distribution.
- Set 'export AKKA_HOME=.
- Run 'sbt'
+ - Run 'update' followed by 'compile' if you have not done that before.
- Run 'project akka-sample-remote'
- Run 'console' to start up a REPL (interpreter).
2. In the first REPL you get execute:
diff --git a/akka-samples/akka-sample-remote/src/main/scala/ClientManagedRemoteActorSample.scala b/akka-samples/akka-sample-remote/src/main/scala/ClientManagedRemoteActorSample.scala
index 403a767978..9070d4a7f8 100644
--- a/akka-samples/akka-sample-remote/src/main/scala/ClientManagedRemoteActorSample.scala
+++ b/akka-samples/akka-sample-remote/src/main/scala/ClientManagedRemoteActorSample.scala
@@ -29,7 +29,7 @@ object ClientManagedRemoteActorServer extends Logging {
object ClientManagedRemoteActorClient extends Logging {
def run = {
- val actor = newActor[RemoteHelloWorldActor].start
+ val actor = actorOf[RemoteHelloWorldActor].start
log.info("Remote actor created, moved to the server")
log.info("Sending 'Hello' to remote actor")
val result = actor !! "Hello"
diff --git a/akka-samples/akka-sample-remote/src/main/scala/ServerManagedRemoteActorSample.scala b/akka-samples/akka-sample-remote/src/main/scala/ServerManagedRemoteActorSample.scala
index 11960dfbe2..87253af24b 100644
--- a/akka-samples/akka-sample-remote/src/main/scala/ServerManagedRemoteActorSample.scala
+++ b/akka-samples/akka-sample-remote/src/main/scala/ServerManagedRemoteActorSample.scala
@@ -22,7 +22,7 @@ object ServerManagedRemoteActorServer extends Logging {
def run = {
RemoteNode.start("localhost", 9999)
log.info("Remote node started")
- RemoteNode.register("hello-service", newActor[HelloWorldActor].start)
+ RemoteNode.register("hello-service", actorOf[HelloWorldActor])
log.info("Remote actor registered and started")
}
diff --git a/akka-samples/akka-sample-rest-scala/src/main/scala/SimpleService.scala b/akka-samples/akka-sample-rest-scala/src/main/scala/SimpleService.scala
index 38cf021c99..6e67772f7e 100644
--- a/akka-samples/akka-sample-rest-scala/src/main/scala/SimpleService.scala
+++ b/akka-samples/akka-sample-rest-scala/src/main/scala/SimpleService.scala
@@ -27,16 +27,16 @@ class Boot {
SupervisorConfig(
RestartStrategy(OneForOne, 3, 100,List(classOf[Exception])),
Supervise(
- newActor[SimpleService],
+ actorOf[SimpleService],
LifeCycle(Permanent)) ::
Supervise(
- newActor[Chat],
+ actorOf[Chat],
LifeCycle(Permanent)) ::
Supervise(
- newActor[PersistentSimpleService],
+ actorOf[PersistentSimpleService],
LifeCycle(Permanent)) ::
Supervise(
- newActor[PubSub],
+ actorOf[PubSub],
LifeCycle(Permanent))
:: Nil))
factory.newInstance.start
diff --git a/akka-samples/akka-sample-security/src/main/scala/SimpleService.scala b/akka-samples/akka-sample-security/src/main/scala/SimpleService.scala
index b5e1fffb2e..680aabd718 100644
--- a/akka-samples/akka-sample-security/src/main/scala/SimpleService.scala
+++ b/akka-samples/akka-sample-security/src/main/scala/SimpleService.scala
@@ -18,18 +18,18 @@ class Boot {
// Dummy implementations of all authentication actors
// see akka.conf to enable one of these for the AkkaSecurityFilterFactory
Supervise(
- newActor[BasicAuthenticationService],
+ actorOf[BasicAuthenticationService],
LifeCycle(Permanent)) ::
/**
Supervise(
- newActor[DigestAuthenticationService],
+ actorOf[DigestAuthenticationService],
LifeCycle(Permanent)) ::
Supervise(
- newActor[SpnegoAuthenticationService],
+ actorOf[SpnegoAuthenticationService],
LifeCycle(Permanent)) ::
**/
Supervise(
- newActor[SecureTickActor],
+ actorOf[SecureTickActor],
LifeCycle(Permanent)):: Nil))
val supervisor = factory.newInstance
diff --git a/project/build/AkkaProject.scala b/project/build/AkkaProject.scala
index a95e529050..c92db6c7cb 100644
--- a/project/build/AkkaProject.scala
+++ b/project/build/AkkaProject.scala
@@ -42,7 +42,7 @@ class AkkaParent(info: ProjectInfo) extends DefaultProject(info) {
// val configgy = "Configgy" at "http://www.lag.net/repo"
val codehaus = "Codehaus" at "http://repository.codehaus.org"
val codehaus_snapshots = "Codehaus Snapshots" at "http://snapshots.repository.codehaus.org"
- val jboss = "jBoss" at "http://repository.jboss.org/maven2"
+ val jboss = "jBoss" at "https://repository.jboss.org/nexus/content/groups/public/"
val guiceyfruit = "GuiceyFruit" at "http://guiceyfruit.googlecode.com/svn/repo/releases/"
val google = "Google" at "http://google-maven-repository.googlecode.com/svn/repository"
val java_net = "java.net" at "http://download.java.net/maven/2"
@@ -136,7 +136,7 @@ class AkkaParent(info: ProjectInfo) extends DefaultProject(info) {
// ------------------------------------------------------------
// subprojects
class AkkaCoreProject(info: ProjectInfo) extends AkkaDefaultProject(info, distPath) {
- val netty = "org.jboss.netty" % "netty" % "3.2.0.BETA1" % "compile"
+ val netty = "org.jboss.netty" % "netty" % "3.2.0.CR1" % "compile"
val commons_io = "commons-io" % "commons-io" % "1.4" % "compile"
val dispatch_json = "net.databinder" % "dispatch-json_2.8.0.Beta1" % "0.6.6" % "compile"
val dispatch_http = "net.databinder" % "dispatch-http_2.8.0.Beta1" % "0.6.6" % "compile"
@@ -150,7 +150,8 @@ class AkkaParent(info: ProjectInfo) extends DefaultProject(info) {
val werkz = "org.codehaus.aspectwerkz" % "aspectwerkz-nodeps-jdk5" % "2.1" % "compile"
val werkz_core = "org.codehaus.aspectwerkz" % "aspectwerkz-jdk5" % "2.1" % "compile"
val configgy = "net.lag" % "configgy" % "2.8.0.Beta1-1.5-SNAPSHOT" % "compile"
- val guicey = "org.guiceyfruit" % "guice-core" % "2.0-beta-4" % "compile"
+ val guicey = "org.guiceyfruit" % "guice-all" % "2.0" % "compile"
+ val aopalliance = "aopalliance" % "aopalliance" % "1.0" % "compile"
val protobuf = "com.google.protobuf" % "protobuf-java" % "2.2.0" % "compile"
val multiverse = "org.multiverse" % "multiverse-alpha" % "0.5" % "compile"
@@ -209,8 +210,8 @@ class AkkaParent(info: ProjectInfo) extends DefaultProject(info) {
class AkkaCassandraProject(info: ProjectInfo) extends AkkaDefaultProject(info, distPath) {
val cassandra = "org.apache.cassandra" % "cassandra" % CASSANDRA_VERSION % "compile"
- val slf4j = "org.slf4j" % "slf4j-api" % "1.5.8" % "compile"
- val slf4j_log4j = "org.slf4j" % "slf4j-log4j12" % "1.5.8" % "compile"
+ val slf4j = "org.slf4j" % "slf4j-api" % "1.6.0" % "compile"
+ val slf4j_log4j = "org.slf4j" % "slf4j-log4j12" % "1.6.0" % "compile"
val log4j = "log4j" % "log4j" % "1.2.15" % "compile"
// testing
val high_scale = "org.apache.cassandra" % "high-scale-lib" % CASSANDRA_VERSION % "test"
@@ -337,6 +338,7 @@ class AkkaParent(info: ProjectInfo) extends DefaultProject(info) {
mainResources +++
mainDependencies.scalaJars +++
descendents(info.projectPath, "*.conf") +++
+ descendents(info.projectPath / "scripts", "run_akka.sh") +++
descendents(info.projectPath / "dist", "*.jar") +++
descendents(info.projectPath / "deploy", "*.jar") +++
descendents(path("lib") ##, "*.jar") +++