Merge remote-tracking branch 'origin/master' into wip-1750-remove-ReflectiveAccess-∂π

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

@@ -37,6 +37,12 @@ case class Message(s: String)
 class FirstActor extends Actor {
   val myActor = context.actorOf(Props[MyActor], name = "myactor")
   //#context-actorOf
+  def receive = {
+    case x ⇒ sender ! x
+  }
+}
+
+class AnonymousActor extends Actor {
   //#anonymous-actor
   def receive = {
     case m: DoIt ⇒
@@ -48,9 +54,7 @@ class FirstActor extends Actor {
             context.stop(self)
         }
         def doSomeDangerousWork(msg: ImmutableMessage): String = { "done" }
-      })) ! m
-
-    case replyMsg: String ⇒ sender ! replyMsg
+      })) forward m
   }
   //#anonymous-actor
 }
@@ -241,7 +245,7 @@ class ActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
     import akka.util.duration._
     import akka.util.Timeout
     import akka.pattern.ask
-    implicit val timeout = Timeout(500 millis)
+    implicit val timeout = Timeout(5 seconds)
     val future = myActor ? "hello"
     //#using-implicit-timeout
     Await.result(future, timeout.duration) must be("hello")
@@ -253,9 +257,9 @@ class ActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
     //#using-explicit-timeout
     import akka.util.duration._
     import akka.pattern.ask
-    val future = myActor.ask("hello")(500 millis)
+    val future = myActor.ask("hello")(5 seconds)
     //#using-explicit-timeout
-    Await.result(future, 500 millis) must be("hello")
+    Await.result(future, 5 seconds) must be("hello")
   }
 
   "using receiveTimeout" in {

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

@@ -20,6 +20,27 @@ object DispatcherDocSpec {
   val config = """
     //#my-dispatcher-config
     my-dispatcher {
+      # Dispatcher is the name of the event-based dispatcher
+      type = Dispatcher
+      # What kind of ExecutionService to use
+      executor = "fork-join-executor"
+      # Configuration for the fork join pool
+      fork-join-executor {
+        # Min number of threads to cap factor-based parallelism number to
+        parallelism-min = 2
+        # Parallelism (threads) ... ceil(available processors * factor)
+        parallelism-factor = 2.0
+        # Max number of threads to cap factor-based parallelism number to
+        parallelism-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-thread-pool-dispatcher-config
+    my-thread-pool-dispatcher {
       # Dispatcher is the name of the event-based dispatcher
       type = Dispatcher
       # What kind of ExecutionService to use
@@ -37,7 +58,14 @@ object DispatcherDocSpec {
       # thread is returned to the pool. Set to 1 for as fair as possible.
       throughput = 100
     }
-    //#my-dispatcher-config
+    //#my-thread-pool-dispatcher-config
+
+    //#my-pinned-dispatcher-config
+    my-pinned-dispatcher {
+      executor = "thread-pool-executor"
+      type = PinnedDispatcher
+    }
+    //#my-pinned-dispatcher-config
 
     //#my-bounded-config
     my-dispatcher-bounded-queue {
@@ -66,13 +94,13 @@ object DispatcherDocSpec {
 
     //#prio-dispatcher-config
     prio-dispatcher {
-      mailboxType = "akka.docs.dispatcher.DispatcherDocSpec$PrioMailbox"
+      mailbox-type = "akka.docs.dispatcher.DispatcherDocSpec$PrioMailbox"
     }
     //#prio-dispatcher-config
 
     //#prio-dispatcher-config-java
     prio-dispatcher-java {
-      mailboxType = "akka.docs.dispatcher.DispatcherDocTestBase$PrioMailbox"
+      mailbox-type = "akka.docs.dispatcher.DispatcherDocTestBase$PrioMailbox"
     }
     //#prio-dispatcher-config-java
   """

akka-docs/scala/code/akka/docs/serialization/SerializationDocSpec.scala

@@ -44,6 +44,9 @@ class MyOwnSerializer extends Serializer {
 }
 //#my-own-serializer
 
+trait MyOwnSerializable
+case class Customer(name: String) extends MyOwnSerializable
+
 class SerializationDocSpec extends AkkaSpec {
   "demonstrate configuration of serialize messages" in {
     //#serialize-messages-config
@@ -81,8 +84,8 @@ class SerializationDocSpec extends AkkaSpec {
       akka {
         actor {
           serializers {
-            default = "akka.serialization.JavaSerializer"
-
+            java = "akka.serialization.JavaSerializer"
+            proto = "akka.serialization.ProtobufSerializer"
             myown = "akka.docs.serialization.MyOwnSerializer"
           }
         }
@@ -90,8 +93,6 @@ class SerializationDocSpec extends AkkaSpec {
     """)
     //#serialize-serializers-config
     val a = ActorSystem("system", config)
-    SerializationExtension(a).serializers("default").getClass.getName must equal("akka.serialization.JavaSerializer")
-    SerializationExtension(a).serializers("myown").getClass.getName must equal("akka.docs.serialization.MyOwnSerializer")
     a.shutdown()
   }
 
@@ -101,31 +102,26 @@ class SerializationDocSpec extends AkkaSpec {
       akka {
         actor {
           serializers {
-            default = "akka.serialization.JavaSerializer"
             java = "akka.serialization.JavaSerializer"
             proto = "akka.serialization.ProtobufSerializer"
             myown = "akka.docs.serialization.MyOwnSerializer"
           }
 
           serialization-bindings {
-           java = ["java.lang.String",
-                   "app.my.Customer"]
-           proto = ["com.google.protobuf.Message"]
-           myown = ["my.own.BusinessObject",
-                    "something.equally.Awesome",
-                    "akka.docs.serialization.MyOwnSerializable"
-                    "java.lang.Boolean"]
-         }
+            "java.lang.String" = java
+            "akka.docs.serialization.Customer" = java
+            "com.google.protobuf.Message" = proto
+            "akka.docs.serialization.MyOwnSerializable" = myown
+            "java.lang.Boolean" = myown
+          }
         }
       }
     """)
     //#serialization-bindings-config
     val a = ActorSystem("system", config)
-    SerializationExtension(a).serializers("default").getClass.getName must equal("akka.serialization.JavaSerializer")
-    SerializationExtension(a).serializers("java").getClass.getName must equal("akka.serialization.JavaSerializer")
-    SerializationExtension(a).serializers("myown").getClass.getName must equal("akka.docs.serialization.MyOwnSerializer")
-    SerializationExtension(a).serializerFor(classOf[String]).getClass.getName must equal("akka.serialization.JavaSerializer")
-    SerializationExtension(a).serializerFor(classOf[java.lang.Boolean]).getClass.getName must equal("akka.docs.serialization.MyOwnSerializer")
+    SerializationExtension(a).serializerFor(classOf[String]).getClass must equal(classOf[JavaSerializer])
+    SerializationExtension(a).serializerFor(classOf[Customer]).getClass must equal(classOf[JavaSerializer])
+    SerializationExtension(a).serializerFor(classOf[java.lang.Boolean]).getClass must equal(classOf[MyOwnSerializer])
     a.shutdown()
   }
 

akka-docs/scala/code/akka/docs/zeromq/ZeromqDocSpec.scala

@@ -0,0 +1,195 @@
+/**
+ * Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
+ */
+package akka.docs.zeromq
+
+import akka.actor.Actor
+import akka.actor.Props
+import akka.util.duration._
+import akka.testkit._
+import akka.zeromq.ZeroMQVersion
+import akka.zeromq.ZeroMQExtension
+import java.text.SimpleDateFormat
+import java.util.Date
+import akka.zeromq.SocketType
+import akka.zeromq.Bind
+
+object ZeromqDocSpec {
+
+  //#health
+  import akka.zeromq._
+  import akka.actor.Actor
+  import akka.actor.Props
+  import akka.actor.ActorLogging
+  import akka.serialization.SerializationExtension
+  import java.lang.management.ManagementFactory
+
+  case object Tick
+  case class Heap(timestamp: Long, used: Long, max: Long)
+  case class Load(timestamp: Long, loadAverage: Double)
+
+  class HealthProbe extends Actor {
+
+    val pubSocket = context.system.newSocket(SocketType.Pub, Bind("tcp://127.0.0.1:1235"))
+    val memory = ManagementFactory.getMemoryMXBean
+    val os = ManagementFactory.getOperatingSystemMXBean
+    val ser = SerializationExtension(context.system)
+
+    override def preStart() {
+      context.system.scheduler.schedule(1 second, 1 second, self, Tick)
+    }
+
+    override def postRestart(reason: Throwable) {
+      // don't call preStart, only schedule once
+    }
+
+    def receive: Receive = {
+      case Tick ⇒
+        val currentHeap = memory.getHeapMemoryUsage
+        val timestamp = System.currentTimeMillis
+
+        // use akka SerializationExtension to convert to bytes
+        val heapPayload = ser.serialize(Heap(timestamp, currentHeap.getUsed, currentHeap.getMax)).fold(throw _, identity)
+        // the first frame is the topic, second is the message
+        pubSocket ! ZMQMessage(Seq(Frame("health.heap"), Frame(heapPayload)))
+
+        // use akka SerializationExtension to convert to bytes
+        val loadPayload = ser.serialize(Load(timestamp, os.getSystemLoadAverage)).fold(throw _, identity)
+        // the first frame is the topic, second is the message
+        pubSocket ! ZMQMessage(Seq(Frame("health.load"), Frame(loadPayload)))
+    }
+  }
+  //#health
+
+  //#logger
+  class Logger extends Actor with ActorLogging {
+
+    context.system.newSocket(SocketType.Sub, Listener(self), Connect("tcp://127.0.0.1:1235"), Subscribe("health"))
+    val ser = SerializationExtension(context.system)
+    val timestampFormat = new SimpleDateFormat("HH:mm:ss.SSS")
+
+    def receive = {
+      // the first frame is the topic, second is the message
+      case m: ZMQMessage if m.firstFrameAsString == "health.heap" ⇒
+        ser.deserialize(m.payload(1), classOf[Heap], None) match {
+          case Right(Heap(timestamp, used, max)) ⇒
+            log.info("Used heap {} bytes, at {}", used, timestampFormat.format(new Date(timestamp)))
+          case Left(e) ⇒ throw e
+        }
+
+      case m: ZMQMessage if m.firstFrameAsString == "health.load" ⇒
+        ser.deserialize(m.payload(1), classOf[Load], None) match {
+          case Right(Load(timestamp, loadAverage)) ⇒
+            log.info("Load average {}, at {}", loadAverage, timestampFormat.format(new Date(timestamp)))
+          case Left(e) ⇒ throw e
+        }
+    }
+  }
+  //#logger
+
+  //#alerter
+  class HeapAlerter extends Actor with ActorLogging {
+
+    context.system.newSocket(SocketType.Sub, Listener(self), Connect("tcp://127.0.0.1:1235"), Subscribe("health.heap"))
+    val ser = SerializationExtension(context.system)
+    var count = 0
+
+    def receive = {
+      // the first frame is the topic, second is the message
+      case m: ZMQMessage if m.firstFrameAsString == "health.heap" ⇒
+        ser.deserialize(m.payload(1), classOf[Heap], None) match {
+          case Right(Heap(timestamp, used, max)) ⇒
+            if ((used.toDouble / max) > 0.9) count += 1
+            else count = 0
+            if (count > 10) log.warning("Need more memory, using {} %", (100.0 * used / max))
+          case Left(e) ⇒ throw e
+        }
+    }
+  }
+  //#alerter
+
+}
+
+class ZeromqDocSpec extends AkkaSpec("akka.loglevel=INFO") {
+  import ZeromqDocSpec._
+
+  "demonstrate how to create socket" in {
+    checkZeroMQInstallation()
+
+    //#pub-socket
+    import akka.zeromq.ZeroMQExtension
+    val pubSocket = ZeroMQExtension(system).newSocket(SocketType.Pub, Bind("tcp://127.0.0.1:1234"))
+    //#pub-socket
+
+    //#pub-socket2
+    import akka.zeromq._
+    val pubSocket2 = system.newSocket(SocketType.Pub, Bind("tcp://127.0.0.1:1234"))
+    //#pub-socket2
+
+    //#sub-socket
+    import akka.zeromq._
+    val listener = system.actorOf(Props(new Actor {
+      def receive: Receive = {
+        case Connecting    ⇒ //...
+        case m: ZMQMessage ⇒ //...
+        case _             ⇒ //...
+      }
+    }))
+    val subSocket = system.newSocket(SocketType.Sub, Listener(listener), Connect("tcp://127.0.0.1:1234"), SubscribeAll)
+    //#sub-socket
+
+    //#sub-topic-socket
+    val subTopicSocket = system.newSocket(SocketType.Sub, Listener(listener), Connect("tcp://127.0.0.1:1234"), Subscribe("foo.bar"))
+    //#sub-topic-socket
+
+    //#unsub-topic-socket
+    subTopicSocket ! Unsubscribe("foo.bar")
+    //#unsub-topic-socket
+
+    val payload = Array.empty[Byte]
+    //#pub-topic
+    pubSocket ! ZMQMessage(Seq(Frame("foo.bar"), Frame(payload)))
+    //#pub-topic
+
+    //#high-watermark
+    val highWatermarkSocket = system.newSocket(
+      SocketType.Router,
+      Listener(listener),
+      Bind("tcp://127.0.0.1:1234"),
+      HighWatermark(50000))
+    //#high-watermark
+  }
+
+  "demonstrate pub-sub" in {
+    checkZeroMQInstallation()
+
+    //#health
+
+    system.actorOf(Props[HealthProbe], name = "health")
+    //#health
+
+    //#logger
+
+    system.actorOf(Props[Logger], name = "logger")
+    //#logger
+
+    //#alerter
+
+    system.actorOf(Props[HeapAlerter], name = "alerter")
+    //#alerter
+
+    // Let it run for a while to see some output.
+    // Don't do like this in real tests, this is only doc demonstration.
+    3.seconds.sleep()
+
+  }
+
+  def checkZeroMQInstallation() = try {
+    ZeroMQExtension(system).version match {
+      case ZeroMQVersion(2, 1, _) ⇒ Unit
+      case version                ⇒ pending
+    }
+  } catch {
+    case e: LinkageError ⇒ pending
+  }
+}