Move content from akka-docs-new into akka-docs

Now the paradox documentation is no longer functional until we update akka-docs
to generate from paradox instead of sphinx

akka-docs/src/test/java/jdocs/tutorial_3/Device.java

@@ -0,0 +1,106 @@
+/**
+ * Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
+ */
+package jdocs.tutorial_3;
+
+//#device-with-register
+
+import akka.actor.AbstractActor;
+import akka.actor.Props;
+import akka.event.Logging;
+import akka.event.LoggingAdapter;
+
+import jdocs.tutorial_3.DeviceManager.DeviceRegistered;
+import jdocs.tutorial_3.DeviceManager.RequestTrackDevice;
+
+import java.util.Optional;
+
+public class Device extends AbstractActor {
+  private final LoggingAdapter log = Logging.getLogger(getContext().getSystem(), this);
+
+  final String groupId;
+
+  final String deviceId;
+
+  public Device(String groupId, String deviceId) {
+    this.groupId = groupId;
+    this.deviceId = deviceId;
+  }
+
+  public static Props props(String groupId, String deviceId) {
+    return Props.create(Device.class, groupId, deviceId);
+  }
+
+  public static final class RecordTemperature {
+    final long requestId;
+    final double value;
+
+    public RecordTemperature(long requestId, double value) {
+      this.requestId = requestId;
+      this.value = value;
+    }
+  }
+
+  public static final class TemperatureRecorded {
+    final long requestId;
+
+    public TemperatureRecorded(long requestId) {
+      this.requestId = requestId;
+    }
+  }
+
+  public static final class ReadTemperature {
+    final long requestId;
+
+    public ReadTemperature(long requestId) {
+      this.requestId = requestId;
+    }
+  }
+
+  public static final class RespondTemperature {
+    final long requestId;
+    final Optional<Double> value;
+
+    public RespondTemperature(long requestId, Optional<Double> value) {
+      this.requestId = requestId;
+      this.value = value;
+    }
+  }
+
+  Optional<Double> lastTemperatureReading = Optional.empty();
+
+  @Override
+  public void preStart() {
+    log.info("Device actor {}-{} started", groupId, deviceId);
+  }
+
+  @Override
+  public void postStop() {
+    log.info("Device actor {}-{} stopped", groupId, deviceId);
+  }
+
+  @Override
+  public Receive createReceive() {
+    return receiveBuilder()
+            .match(RequestTrackDevice.class, r -> {
+              if (this.groupId.equals(r.groupId) && this.deviceId.equals(r.deviceId)) {
+                getSender().tell(new DeviceRegistered(), getSelf());
+              } else {
+                log.warning(
+                        "Ignoring TrackDevice request for {}-{}.This actor is responsible for {}-{}.",
+                        r.groupId, r.deviceId, this.groupId, this.deviceId
+                );
+              }
+            })
+            .match(RecordTemperature.class, r -> {
+              log.info("Recorded temperature reading {} with {}", r.value, r.requestId);
+              lastTemperatureReading = Optional.of(r.value);
+              getSender().tell(new TemperatureRecorded(r.requestId), getSelf());
+            })
+            .match(ReadTemperature.class, r -> {
+              getSender().tell(new RespondTemperature(r.requestId, lastTemperatureReading), getSelf());
+            })
+            .build();
+  }
+}
+//#device-with-register

akka-docs/src/test/java/jdocs/tutorial_3/DeviceGroup.java

@@ -0,0 +1,119 @@
+/**
+ * Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
+ */
+package jdocs.tutorial_3;
+
+import java.util.Set;
+import java.util.Map;
+import java.util.HashMap;
+
+import akka.actor.AbstractActor;
+import akka.actor.ActorRef;
+import akka.actor.Props;
+import akka.actor.Terminated;
+import akka.event.Logging;
+import akka.event.LoggingAdapter;
+
+import jdocs.tutorial_3.Device;
+import jdocs.tutorial_3.DeviceManager;
+
+//#device-group-full
+public class DeviceGroup extends AbstractActor {
+  private final LoggingAdapter log = Logging.getLogger(getContext().getSystem(), this);
+
+  final String groupId;
+
+  public DeviceGroup(String groupId) {
+    this.groupId = groupId;
+  }
+
+  //#device-group-register
+  public static Props props(String groupId) {
+    return Props.create(DeviceGroup.class, groupId);
+  }
+  //#device-group-register
+
+  public static final class RequestDeviceList {
+    final long requestId;
+
+    public RequestDeviceList(long requestId) {
+      this.requestId = requestId;
+    }
+  }
+
+  public static final class ReplyDeviceList {
+    final long requestId;
+    final Set<String> ids;
+
+    public ReplyDeviceList(long requestId, Set<String> ids) {
+      this.requestId = requestId;
+      this.ids = ids;
+    }
+  }
+  //#device-group-register
+//#device-group-register
+//#device-group-register
+//#device-group-remove
+
+  final Map<String, ActorRef> deviceIdToActor = new HashMap<>();
+  //#device-group-register
+  final Map<ActorRef, String> actorToDeviceId = new HashMap<>();
+  //#device-group-register
+
+  @Override
+  public void preStart() {
+    log.info("DeviceGroup {} started", groupId);
+  }
+
+  @Override
+  public void postStop() {
+    log.info("DeviceGroup {} stopped", groupId);
+  }
+
+  private void onTrackDevice(DeviceManager.RequestTrackDevice trackMsg) {
+    if (this.groupId.equals(trackMsg.groupId)) {
+      ActorRef deviceActor = deviceIdToActor.get(trackMsg.deviceId);
+      if (deviceActor != null) {
+        deviceActor.forward(trackMsg, getContext());
+      } else {
+        log.info("Creating device actor for {}", trackMsg.deviceId);
+        deviceActor = getContext().actorOf(Device.props(groupId, trackMsg.deviceId), "device-" + trackMsg.deviceId);
+        //#device-group-register
+        getContext().watch(deviceActor);
+        actorToDeviceId.put(deviceActor, trackMsg.deviceId);
+        //#device-group-register
+        deviceIdToActor.put(trackMsg.deviceId, deviceActor);
+        deviceActor.forward(trackMsg, getContext());
+      }
+    } else {
+      log.warning(
+              "Ignoring TrackDevice request for {}. This actor is responsible for {}.",
+              groupId, this.groupId
+      );
+    }
+  }
+
+  private void onDeviceList(RequestDeviceList r) {
+    getSender().tell(new ReplyDeviceList(r.requestId, deviceIdToActor.keySet()), getSelf());
+  }
+
+  private void onTerminated(Terminated t) {
+    ActorRef deviceActor = t.getActor();
+    String deviceId = actorToDeviceId.get(deviceActor);
+    log.info("Device actor for {} has been terminated", deviceId);
+    actorToDeviceId.remove(deviceActor);
+    deviceIdToActor.remove(deviceId);
+  }
+
+  @Override
+  public Receive createReceive() {
+    return receiveBuilder()
+            .match(DeviceManager.RequestTrackDevice.class, this::onTrackDevice)
+            .match(RequestDeviceList.class, this::onDeviceList)
+            .match(Terminated.class, this::onTerminated)
+            .build();
+  }
+}
+//#device-group-remove
+//#device-group-register
+//#device-group-full

akka-docs/src/test/java/jdocs/tutorial_3/DeviceGroupTest.java

@@ -0,0 +1,131 @@
+/**
+ * Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
+ */
+package jdocs.tutorial_3;
+
+import java.util.stream.Stream;
+import java.util.stream.Collectors;
+
+import akka.actor.ActorRef;
+import akka.actor.ActorSystem;
+import akka.actor.PoisonPill;
+import akka.testkit.javadsl.TestKit;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+
+import org.scalatest.junit.JUnitSuite;
+
+public class DeviceGroupTest extends JUnitSuite {
+
+  static ActorSystem system;
+
+  @BeforeClass
+  public static void setup() {
+    system = ActorSystem.create();
+  }
+
+  @AfterClass
+  public static void teardown() {
+    TestKit.shutdownActorSystem(system);
+    system = null;
+  }
+
+  //#device-group-test-registration
+  @Test
+  public void testRegisterDeviceActor() {
+    TestKit probe = new TestKit(system);
+    ActorRef groupActor = system.actorOf(DeviceGroup.props("group"));
+
+    groupActor.tell(new DeviceManager.RequestTrackDevice("group", "device1"), probe.getRef());
+    probe.expectMsgClass(DeviceManager.DeviceRegistered.class);
+    ActorRef deviceActor1 = probe.getLastSender();
+
+    groupActor.tell(new DeviceManager.RequestTrackDevice("group", "device2"), probe.getRef());
+    probe.expectMsgClass(DeviceManager.DeviceRegistered.class);
+    ActorRef deviceActor2 = probe.getLastSender();
+    assertNotEquals(deviceActor1, deviceActor2);
+
+    // Check that the device actors are workingl
+    deviceActor1.tell(new Device.RecordTemperature(0L, 1.0), probe.getRef());
+    assertEquals(0L, probe.expectMsgClass(Device.TemperatureRecorded.class).requestId);
+    deviceActor2.tell(new Device.RecordTemperature(1L, 2.0), probe.getRef());
+    assertEquals(1L, probe.expectMsgClass(Device.TemperatureRecorded.class).requestId);
+  }
+
+  @Test
+  public void testIgnoreRequestsForWrongGroupId() {
+    TestKit probe = new TestKit(system);
+    ActorRef groupActor = system.actorOf(DeviceGroup.props("group"));
+
+    groupActor.tell(new DeviceManager.RequestTrackDevice("wrongGroup", "device1"), probe.getRef());
+    probe.expectNoMsg();
+  }
+  //#device-group-test-registration
+
+  //#device-group-test3
+  @Test
+  public void testReturnSameActorForSameDeviceId() {
+    TestKit probe = new TestKit(system);
+    ActorRef groupActor = system.actorOf(DeviceGroup.props("group"));
+
+    groupActor.tell(new DeviceManager.RequestTrackDevice("group", "device1"), probe.getRef());
+    probe.expectMsgClass(DeviceManager.DeviceRegistered.class);
+    ActorRef deviceActor1 = probe.getLastSender();
+
+    groupActor.tell(new DeviceManager.RequestTrackDevice("group", "device1"), probe.getRef());
+    probe.expectMsgClass(DeviceManager.DeviceRegistered.class);
+    ActorRef deviceActor2 = probe.getLastSender();
+    assertEquals(deviceActor1, deviceActor2);
+  }
+  //#device-group-test3
+
+  //#device-group-list-terminate-test
+  @Test
+  public void testListActiveDevices() {
+    TestKit probe = new TestKit(system);
+    ActorRef groupActor = system.actorOf(DeviceGroup.props("group"));
+
+    groupActor.tell(new DeviceManager.RequestTrackDevice("group", "device1"), probe.getRef());
+    probe.expectMsgClass(DeviceManager.DeviceRegistered.class);
+
+    groupActor.tell(new DeviceManager.RequestTrackDevice("group", "device2"), probe.getRef());
+    probe.expectMsgClass(DeviceManager.DeviceRegistered.class);
+
+    groupActor.tell(new DeviceGroup.RequestDeviceList(0L), probe.getRef());
+    DeviceGroup.ReplyDeviceList reply = probe.expectMsgClass(DeviceGroup.ReplyDeviceList.class);
+    assertEquals(0L, reply.requestId);
+    assertEquals(Stream.of("device1", "device2").collect(Collectors.toSet()), reply.ids);
+  }
+
+  @Test
+  public void teestListActiveDevicesAfterOneShutsDown() {
+    TestKit probe = new TestKit(system);
+    ActorRef groupActor = system.actorOf(DeviceGroup.props("group"));
+
+    groupActor.tell(new DeviceManager.RequestTrackDevice("group", "device1"), probe.getRef());
+    probe.expectMsgClass(DeviceManager.DeviceRegistered.class);
+    ActorRef toShutDown = probe.getLastSender();
+
+    groupActor.tell(new DeviceManager.RequestTrackDevice("group", "device2"), probe.getRef());
+    probe.expectMsgClass(DeviceManager.DeviceRegistered.class);
+
+    groupActor.tell(new DeviceGroup.RequestDeviceList(0L), probe.getRef());
+    DeviceGroup.ReplyDeviceList reply = probe.expectMsgClass(DeviceGroup.ReplyDeviceList.class);
+    assertEquals(0L, reply.requestId);
+    assertEquals(Stream.of("device1", "device2").collect(Collectors.toSet()), reply.ids);
+
+    probe.watch(toShutDown);
+    toShutDown.tell(PoisonPill.getInstance(), ActorRef.noSender());
+    probe.expectTerminated(toShutDown);
+
+    groupActor.tell(new DeviceGroup.RequestDeviceList(1L), probe.getRef());
+    reply = probe.expectMsgClass(DeviceGroup.ReplyDeviceList.class);
+    assertEquals(1L, reply.requestId);
+    assertEquals(Stream.of("device2").collect(Collectors.toSet()), reply.ids);
+  }
+  //#device-group-list-terminate-test
+}

akka-docs/src/test/java/jdocs/tutorial_3/DeviceManager.java

@@ -0,0 +1,84 @@
+/**
+ * Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
+ */
+
+package jdocs.tutorial_3;
+
+import java.util.Map;
+import java.util.HashMap;
+
+import akka.actor.AbstractActor;
+import akka.actor.ActorRef;
+import akka.actor.Props;
+import akka.actor.Terminated;
+import akka.event.Logging;
+import akka.event.LoggingAdapter;
+
+//#device-manager-full
+public class DeviceManager extends AbstractActor {
+  private final LoggingAdapter log = Logging.getLogger(getContext().getSystem(), this);
+
+  public static Props props() {
+    return Props.create(DeviceManager.class);
+  }
+
+  //#device-manager-msgs
+  public static final class RequestTrackDevice {
+    public final String groupId;
+    public final String deviceId;
+
+    public RequestTrackDevice(String groupId, String deviceId) {
+      this.groupId = groupId;
+      this.deviceId = deviceId;
+    }
+  }
+
+  public static final class DeviceRegistered {
+  }
+
+  //#device-manager-msgs
+  final Map<String, ActorRef> groupIdToActor = new HashMap<>();
+  final Map<ActorRef, String> actorToGroupId = new HashMap<>();
+
+  @Override
+  public void preStart() {
+    log.info("DeviceManager started");
+  }
+
+  @Override
+  public void postStop() {
+    log.info("DeviceManager stopped");
+  }
+
+  private void onTrackDevice(RequestTrackDevice trackMsg) {
+    String groupId = trackMsg.groupId;
+    ActorRef ref = groupIdToActor.get(groupId);
+    if (ref != null) {
+      ref.forward(trackMsg, getContext());
+    } else {
+      log.info("Creating device group actor for {}", groupId);
+      ActorRef groupActor = getContext().actorOf(DeviceGroup.props(groupId), "group-" + groupId);
+      getContext().watch(groupActor);
+      groupActor.forward(trackMsg, getContext());
+      groupIdToActor.put(groupId, groupActor);
+      actorToGroupId.put(groupActor, groupId);
+    }
+  }
+
+  private void onTerminated(Terminated t) {
+    ActorRef groupActor = t.getActor();
+    String groupId = actorToGroupId.get(groupActor);
+    log.info("Device group actor for {} has been terminated", groupId);
+    actorToGroupId.remove(groupActor);
+    groupIdToActor.remove(groupId);
+  }
+
+  public Receive createReceive() {
+    return receiveBuilder()
+            .match(RequestTrackDevice.class, this::onTrackDevice)
+            .match(Terminated.class, this::onTerminated)
+            .build();
+  }
+
+}
+//#device-manager-full

akka-docs/src/test/java/jdocs/tutorial_3/DeviceTest.java

@@ -0,0 +1,94 @@
+/**
+ * Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
+ */
+package jdocs.tutorial_3;
+
+import akka.actor.ActorRef;
+import akka.actor.ActorSystem;
+import akka.testkit.javadsl.TestKit;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+
+import org.scalatest.junit.JUnitSuite;
+
+import java.util.Optional;
+
+public class DeviceTest extends JUnitSuite {
+
+  static ActorSystem system;
+
+  @BeforeClass
+  public static void setup() {
+    system = ActorSystem.create();
+  }
+
+  @AfterClass
+  public static void teardown() {
+    TestKit.shutdownActorSystem(system);
+    system = null;
+  }
+
+  //#device-registration-tests
+  @Test
+  public void testReplyToRegistrationRequests() {
+    TestKit probe = new TestKit(system);
+    ActorRef deviceActor = system.actorOf(Device.props("group", "device"));
+
+    deviceActor.tell(new DeviceManager.RequestTrackDevice("group", "device"), probe.getRef());
+    probe.expectMsgClass(DeviceManager.DeviceRegistered.class);
+    assertEquals(deviceActor, probe.getLastSender());
+  }
+
+  @Test
+  public void testIgnoreWrongRegistrationRequests() {
+    TestKit probe = new TestKit(system);
+    ActorRef deviceActor = system.actorOf(Device.props("group", "device"));
+
+    deviceActor.tell(new DeviceManager.RequestTrackDevice("wrongGroup", "device"), probe.getRef());
+    probe.expectNoMsg();
+
+    deviceActor.tell(new DeviceManager.RequestTrackDevice("group", "wrongDevice"), probe.getRef());
+    probe.expectNoMsg();
+  }
+  //#device-registration-tests
+
+  //#device-read-test
+  @Test
+  public void testReplyWithEmptyReadingIfNoTemperatureIsKnown() {
+    TestKit probe = new TestKit(system);
+    ActorRef deviceActor = system.actorOf(Device.props("group", "device"));
+    deviceActor.tell(new Device.ReadTemperature(42L), probe.getRef());
+    Device.RespondTemperature response = probe.expectMsgClass(Device.RespondTemperature.class);
+    assertEquals(42L, response.requestId);
+    assertEquals(Optional.empty(), response.value);
+  }
+  //#device-read-test
+
+  //#device-write-read-test
+  @Test
+  public void testReplyWithLatestTemperatureReading() {
+    TestKit probe = new TestKit(system);
+    ActorRef deviceActor = system.actorOf(Device.props("group", "device"));
+
+    deviceActor.tell(new Device.RecordTemperature(1L, 24.0), probe.getRef());
+    assertEquals(1L, probe.expectMsgClass(Device.TemperatureRecorded.class).requestId);
+
+    deviceActor.tell(new Device.ReadTemperature(2L), probe.getRef());
+    Device.RespondTemperature response1 = probe.expectMsgClass(Device.RespondTemperature.class);
+    assertEquals(2L, response1.requestId);
+    assertEquals(Optional.of(24.0), response1.value);
+
+    deviceActor.tell(new Device.RecordTemperature(3L, 55.0), probe.getRef());
+    assertEquals(3L, probe.expectMsgClass(Device.TemperatureRecorded.class).requestId);
+
+    deviceActor.tell(new Device.ReadTemperature(4L), probe.getRef());
+    Device.RespondTemperature response2 = probe.expectMsgClass(Device.RespondTemperature.class);
+    assertEquals(4L, response2.requestId);
+    assertEquals(Optional.of(55.0), response2.value);
+  }
+  //#device-write-read-test
+
+}