Merge with master

akka-docs/scala/code/StmDocSpec.scala

@@ -1,27 +0,0 @@
-package akka.docs.stm
-
-import org.scalatest.WordSpec
-import org.scalatest.matchers.MustMatchers
-
-class StmDocSpec extends WordSpec with MustMatchers {
-
-  "simple counter example" in {
-    //#simple
-    import akka.stm._
-
-    val ref = Ref(0)
-
-    def counter = atomic {
-      ref alter (_ + 1)
-    }
-
-    counter
-    // -> 1
-
-    counter
-    // -> 2
-    //#simple
-
-    ref.get must be === 2
-  }
-}

akka-docs/scala/code/akka/docs/actor/ActorDocSpec.scala

@@ -15,6 +15,7 @@ import akka.actor.ActorSystem
 import org.scalatest.{ BeforeAndAfterAll, WordSpec }
 import org.scalatest.matchers.MustMatchers
 import akka.testkit._
+import akka.util._
 import akka.util.duration._
 
 //#my-actor
@@ -187,6 +188,23 @@ class ActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
     system.stop(myActor)
   }
 
+  "creating a Props config" in {
+    val dispatcher = system.dispatcherFactory.lookup("my-dispatcher")
+    //#creating-props-config
+    import akka.actor.Props
+    val props1 = Props()
+    val props2 = Props[MyActor]
+    val props3 = Props(new MyActor)
+    val props4 = Props(
+      creator = { () ⇒ new MyActor },
+      dispatcher = dispatcher,
+      timeout = Timeout(100))
+    val props5 = props1.withCreator(new MyActor)
+    val props6 = props5.withDispatcher(dispatcher)
+    val props7 = props6.withTimeout(Timeout(100))
+    //#creating-props-config
+  }
+
   "creating actor with Props" in {
     //#creating-props
     import akka.actor.Props

akka-docs/scala/code/akka/docs/actor/SchedulerDocSpec.scala

@@ -0,0 +1,53 @@
+package akka.docs.actor
+
+//#imports1
+import akka.actor.Actor
+import akka.actor.Props
+import akka.util.duration._
+
+//#imports1
+
+import org.scalatest.{ BeforeAndAfterAll, WordSpec }
+import org.scalatest.matchers.MustMatchers
+import akka.testkit._
+
+class SchedulerDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
+  "schedule a one-off task" in {
+    //#schedule-one-off-message
+    //Schedules to send the "foo"-message to the testActor after 50ms
+    system.scheduler.scheduleOnce(50 milliseconds, testActor, "foo")
+    //#schedule-one-off-message
+
+    expectMsg(1 second, "foo")
+
+    //#schedule-one-off-thunk
+    //Schedules a function to be executed (send the current time) to the testActor after 50ms
+    system.scheduler.scheduleOnce(50 milliseconds) {
+      testActor ! System.currentTimeMillis
+    }
+    //#schedule-one-off-thunk
+
+  }
+
+  "schedule a recurring task" in {
+    //#schedule-recurring
+    val Tick = "tick"
+    val tickActor = system.actorOf(Props(new Actor {
+      def receive = {
+        case Tick ⇒ //Do something
+      }
+    }))
+    //This will schedule to send the Tick-message
+    //to the tickActor after 0ms repeating every 50ms
+    val cancellable =
+      system.scheduler.schedule(0 milliseconds,
+        50 milliseconds,
+        tickActor,
+        Tick)
+
+    //This cancels further Ticks to be sent
+    cancellable.cancel()
+    //#schedule-recurring
+    system.stop(tickActor)
+  }
+}

akka-docs/scala/code/akka/docs/dispatcher/DispatcherDocSpec.scala

@@ -16,27 +16,35 @@ object DispatcherDocSpec {
   val config = """
     //#my-dispatcher-config
     my-dispatcher {
-      type = Dispatcher             # Dispatcher is the name of the event-based dispatcher
-      daemonic = off                # Toggles whether the threads created by this dispatcher should be daemons or not
-      core-pool-size-min = 2        # minimum number of threads to cap factor-based core number to
-      core-pool-size-factor = 2.0   # No of core threads ... ceil(available processors * factor)
-      core-pool-size-max = 10       # maximum number of threads to cap factor-based number to
-      throughput = 100              # Throughput defines the number of messages that are processed in a batch before the
-                                    # thread is returned to the pool. Set to 1 for as fair as possible.
+      # Dispatcher is the name of the event-based dispatcher
+      type = Dispatcher
+      # Toggles whether the threads created by this dispatcher should be daemons or not
+      daemonic = off
+      # minimum number of threads to cap factor-based core number to
+      core-pool-size-min = 2
+      # No of core threads ... ceil(available processors * factor)
+      core-pool-size-factor = 2.0
+      # maximum number of threads to cap factor-based number to
+      core-pool-size-max = 10
+      # Throughput defines the number of messages that are processed in a batch before the
+      # thread is returned to the pool. Set to 1 for as fair as possible.
+      throughput = 100
     }
     //#my-dispatcher-config
-    
+
     //#my-bounded-config
     my-dispatcher-bounded-queue {
       type = Dispatcher
       core-pool-size-factor = 8.0
       max-pool-size-factor  = 16.0
-      task-queue-size = 100         # Specifies the bounded capacity of the task queue
-      task-queue-type = "array"     # Specifies which type of task queue will be used, can be "array" or "linked" (default)
+      # Specifies the bounded capacity of the task queue
+      task-queue-size = 100
+      # Specifies which type of task queue will be used, can be "array" or "linked" (default)
+      task-queue-type = "array"
       throughput = 3
     }
     //#my-bounded-config
-    
+
     //#my-balancing-config
     my-balancing-dispatcher {
       type = BalancingDispatcher

akka-docs/scala/code/akka/docs/extension/ExtensionDocSpec.scala

@@ -0,0 +1,74 @@
+package akka.docs.extension
+
+import org.scalatest.WordSpec
+import org.scalatest.matchers.MustMatchers
+
+//#imports
+import akka.actor._
+import java.util.concurrent.atomic.AtomicLong
+
+//#imports
+
+//#extension
+class CountExtensionImpl extends Extension {
+  //Since this Extension is a shared instance
+  // per ActorSystem we need to be threadsafe
+  private val counter = new AtomicLong(0)
+
+  //This is the operation this Extension provides
+  def increment() = counter.incrementAndGet()
+}
+//#extension
+
+//#extensionid
+object CountExtension
+  extends ExtensionId[CountExtensionImpl]
+  with ExtensionIdProvider {
+  //The lookup method is required by ExtensionIdProvider,
+  // so we return ourselves here, this allows us
+  // to configure our extension to be loaded when
+  // the ActorSystem starts up
+  override def lookup = CountExtension
+
+  //This method will be called by Akka
+  // to instantiate our Extension
+  override def createExtension(system: ActorSystemImpl) = new CountExtensionImpl
+}
+//#extensionid
+
+//#extension-usage-actor
+import akka.actor.Actor
+
+class MyActor extends Actor {
+  def receive = {
+    case someMessage ⇒
+      CountExtension(context.system).increment()
+  }
+}
+//#extension-usage-actor
+
+//#extension-usage-actor-trait
+import akka.actor.Actor
+
+trait Counting { self: Actor ⇒
+  def increment() = CountExtension(context.system).increment()
+}
+class MyCounterActor extends Actor with Counting {
+  def receive = {
+    case someMessage ⇒ increment()
+  }
+}
+//#extension-usage-actor-trait
+
+class ExtensionDocSpec extends WordSpec with MustMatchers {
+
+  "demonstrate how to create an extension in Scala" in {
+    val system: ActorSystem = null
+    intercept[Exception] {
+      //#extension-usage
+      CountExtension(system).increment
+      //#extension-usage
+    }
+  }
+
+}