=per #3915 Make become work during recovery for EventsourcedProcessor et.c.

akka-samples/akka-sample-persistence-java-lambda/src/main/java/doc/LambdaPersistenceDocTest.java

@@ -0,0 +1,389 @@
+/**
+ * Copyright (C) 2009-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package doc;
+
+import java.util.concurrent.TimeUnit;
+
+import akka.japi.pf.ReceiveBuilder;
+import scala.Option;
+import scala.PartialFunction;
+import scala.concurrent.duration.Duration;
+
+import akka.actor.*;
+import akka.persistence.*;
+import scala.runtime.BoxedUnit;
+
+import static java.util.Arrays.asList;
+
+public class LambdaPersistenceDocTest {
+
+  public interface ProcessorMethods {
+    //#processor-id
+    public String processorId();
+    //#processor-id
+    //#recovery-status
+    public boolean recoveryRunning();
+    public boolean recoveryFinished();
+    //#recovery-status
+    //#current-message
+    public Persistent getCurrentPersistentMessage();
+    //#current-message
+  }
+
+  static Object o1 = new Object() {
+    //#definition
+    class MyProcessor extends AbstractProcessor {
+      @Override public PartialFunction<Object, BoxedUnit> receive() {
+        return ReceiveBuilder.
+            match(Persistent.class, p -> {
+              // message successfully written to journal
+              Object payload = p.payload();
+              Long sequenceNr = p.sequenceNr();
+              // ...
+            }).
+            match(PersistenceFailure.class, failure -> {
+              // message failed to be written to journal
+              Object payload = failure.payload();
+              Long sequenceNr = failure.sequenceNr();
+              Throwable cause = failure.cause();
+              // ...
+            }).
+            matchAny(otherwise -> {
+              // message not written to journal
+            }).build();
+      }
+    }
+    //#definition
+
+    class MyActor extends AbstractActor {
+      ActorRef processor;
+
+      public MyActor() {
+        //#usage
+        processor = context().actorOf(Props.create(MyProcessor.class), "myProcessor");
+
+        processor.tell(Persistent.create("foo"), null);
+        processor.tell("bar", null);
+        //#usage
+      }
+
+      @Override public PartialFunction<Object, BoxedUnit> receive() {
+        return ReceiveBuilder.
+            match(Persistent.class, received -> {/* ... */}).build();
+      }
+
+      private void recover() {
+        //#recover-explicit
+        processor.tell(Recover.create(), null);
+        //#recover-explicit
+      }
+    }
+  };
+
+  static Object o2 = new Object() {
+    abstract class MyProcessor1 extends AbstractProcessor {
+      //#recover-on-start-disabled
+      @Override
+      public void preStart() {}
+      //#recover-on-start-disabled
+
+      //#recover-on-restart-disabled
+      @Override
+      public void preRestart(Throwable reason, Option<Object> message) {}
+      //#recover-on-restart-disabled
+    }
+
+    abstract class MyProcessor2 extends AbstractProcessor {
+      //#recover-on-start-custom
+      @Override
+      public void preStart() {
+        self().tell(Recover.create(457L), null);
+      }
+      //#recover-on-start-custom
+    }
+
+    abstract class MyProcessor3 extends AbstractProcessor {
+      //#deletion
+      @Override
+      public void preRestart(Throwable reason, Option<Object> message) {
+        if (message.isDefined() && message.get() instanceof Persistent) {
+          deleteMessage(((Persistent) message.get()).sequenceNr());
+        }
+        super.preRestart(reason, message);
+      }
+      //#deletion
+    }
+
+    class MyProcessor4 extends AbstractProcessor implements ProcessorMethods {
+      //#processor-id-override
+      @Override
+      public String processorId() {
+        return "my-stable-processor-id";
+      }
+
+      //#processor-id-override
+      @Override public PartialFunction<Object, BoxedUnit> receive() {
+        return ReceiveBuilder.
+            match(Persistent.class, received -> {/* ... */}).build();
+      }
+    }
+  };
+
+  static Object o3 = new Object() {
+    //#channel-example
+    class MyProcessor extends AbstractProcessor {
+      private final ActorRef destination;
+      private final ActorRef channel;
+
+      public MyProcessor() {
+        this.destination = context().actorOf(Props.create(MyDestination.class));
+        this.channel = context().actorOf(Channel.props(), "myChannel");
+      }
+
+      @Override public PartialFunction<Object, BoxedUnit> receive() {
+        return ReceiveBuilder.
+            match(Persistent.class, p -> {
+              Persistent out = p.withPayload("done " + p.payload());
+              channel.tell(Deliver.create(out, destination.path()), self());
+            }).build();
+      }
+    }
+
+    class MyDestination extends AbstractActor {
+      @Override public PartialFunction<Object, BoxedUnit> receive() {
+        return ReceiveBuilder.
+            match(ConfirmablePersistent.class, p -> {
+              Object payload = p.payload();
+              Long sequenceNr = p.sequenceNr();
+              int redeliveries = p.redeliveries();
+              // ...
+              p.confirm();
+            }).build();
+      }
+    }
+    //#channel-example
+
+    class MyProcessor2 extends AbstractProcessor {
+      private final ActorRef destination;
+      private final ActorRef channel;
+
+      public MyProcessor2(ActorRef destination) {
+        this.destination = context().actorOf(Props.create(MyDestination.class));
+        //#channel-id-override
+        this.channel = context().actorOf(Channel.props("my-stable-channel-id"));
+        //#channel-id-override
+
+        //#channel-custom-settings
+        context().actorOf(
+            Channel.props(ChannelSettings.create()
+                            .withRedeliverInterval(Duration.create(30, TimeUnit.SECONDS))
+                            .withRedeliverMax(15)));
+        //#channel-custom-settings
+
+        //#channel-custom-listener
+        class MyListener extends AbstractActor {
+          @Override public PartialFunction<Object, BoxedUnit> receive() {
+            return ReceiveBuilder.
+                match(RedeliverFailure.class, r -> {
+                  Iterable<ConfirmablePersistent> messages = r.getMessages();
+                  // ...
+                }).build();
+          }
+        }
+
+        final ActorRef myListener = context().actorOf(Props.create(MyListener.class));
+        context().actorOf(Channel.props(
+            ChannelSettings.create().withRedeliverFailureListener(null)));
+        //#channel-custom-listener
+
+      }
+
+      @Override public PartialFunction<Object, BoxedUnit> receive() {
+        return ReceiveBuilder.
+            match(Persistent.class, p -> {
+              Persistent out = p.withPayload("done " + p.payload());
+              channel.tell(Deliver.create(out, destination.path()), self());
+
+              //#channel-example-reply
+              channel.tell(Deliver.create(out, sender().path()), self());
+              //#channel-example-reply
+            }).build();
+      }
+    }
+  };
+
+  static Object o4 = new Object() {
+    //#save-snapshot
+    class MyProcessor extends AbstractProcessor {
+      private Object state;
+
+      @Override public PartialFunction<Object, BoxedUnit> receive() {
+        return ReceiveBuilder.
+            match(String.class, s -> s.equals("snap"),
+                  s -> saveSnapshot(state)).
+            match(SaveSnapshotSuccess.class, ss -> {
+              SnapshotMetadata metadata = ss.metadata();
+              // ...
+            }).
+            match(SaveSnapshotFailure.class, sf -> {
+              SnapshotMetadata metadata = sf.metadata();
+              // ...
+            }).build();
+      }
+    }
+    //#save-snapshot
+  };
+
+  static Object o5 = new Object() {
+    //#snapshot-offer
+    class MyProcessor extends AbstractProcessor {
+      private Object state;
+
+      @Override public PartialFunction<Object, BoxedUnit> receive() {
+        return ReceiveBuilder.
+            match(SnapshotOffer.class, s -> {
+              state = s.snapshot();
+              // ...
+            }).
+            match(Persistent.class, p -> {/* ...*/}).build();
+      }
+    }
+    //#snapshot-offer
+
+    class MyActor extends AbstractActor {
+      ActorRef processor;
+
+      public MyActor() {
+        processor = context().actorOf(Props.create(MyProcessor.class));
+      }
+
+      @Override public PartialFunction<Object, BoxedUnit> receive() {
+        return ReceiveBuilder.match(Object.class, o -> {/* ... */}).build();
+      }
+
+      private void recover() {
+        //#snapshot-criteria
+        processor.tell(Recover.create(
+            SnapshotSelectionCriteria
+                .create(457L, System.currentTimeMillis())), null);
+        //#snapshot-criteria
+      }
+    }
+  };
+
+  static Object o6 = new Object() {
+    //#batch-write
+    class MyProcessor extends AbstractProcessor {
+      @Override public PartialFunction<Object, BoxedUnit> receive() {
+        return ReceiveBuilder.
+            match(Persistent.class, p -> p.payload().equals("a"),
+                  p -> {/* ... */}).
+            match(Persistent.class, p -> p.payload().equals("b"),
+                  p -> {/* ... */}).build();
+      }
+    }
+
+    class Example {
+      final ActorSystem system    = ActorSystem.create("example");
+      final ActorRef    processor = system.actorOf(Props.create(MyProcessor.class));
+
+      public void batchWrite() {
+        processor.tell(PersistentBatch
+                  .create(asList(Persistent.create("a"),
+                                 Persistent.create("b"))), null);
+      }
+
+      // ...
+    }
+    //#batch-write
+  };
+
+  static Object o7 = new Object() {
+    abstract class MyProcessor extends AbstractProcessor {
+      ActorRef destination;
+
+      public void foo() {
+        //#persistent-channel-example
+        final ActorRef channel = context().actorOf(
+            PersistentChannel.props(
+                PersistentChannelSettings.create()
+                    .withRedeliverInterval(Duration.create(30, TimeUnit.SECONDS))
+                    .withRedeliverMax(15)),
+            "myPersistentChannel");
+
+        channel.tell(Deliver.create(Persistent.create("example"), destination.path()), self());
+        //#persistent-channel-example
+        //#persistent-channel-watermarks
+        PersistentChannelSettings.create()
+              .withPendingConfirmationsMax(10000)
+              .withPendingConfirmationsMin(2000);
+        //#persistent-channel-watermarks
+        //#persistent-channel-reply
+        PersistentChannelSettings.create().withReplyPersistent(true);
+        //#persistent-channel-reply
+      }
+    }
+  };
+
+  static Object o8 = new Object() {
+    //#reliable-event-delivery
+    class MyEventsourcedProcessor extends AbstractEventsourcedProcessor {
+      private ActorRef destination;
+      private ActorRef channel;
+
+      public MyEventsourcedProcessor(ActorRef destination) {
+        this.destination = destination;
+        this.channel = context().actorOf(Channel.props(), "channel");
+      }
+
+      private void handleEvent(String event) {
+        // update state
+        // ...
+        // reliably deliver events
+        channel.tell(Deliver.create(
+              Persistent.create(event, getCurrentPersistentMessage()),
+              destination.path()), self());
+      }
+
+      @Override public PartialFunction<Object, BoxedUnit> receiveRecover() {
+        return ReceiveBuilder.
+            match(String.class, this::handleEvent).build();
+      }
+
+      @Override public PartialFunction<Object, BoxedUnit> receiveCommand() {
+        return ReceiveBuilder.
+            match(String.class, s -> s.equals("cmd"),
+                  s -> persist("evt", this::handleEvent)).build();
+      }
+    }
+    //#reliable-event-delivery
+  };
+
+  static Object o9 = new Object() {
+    //#view
+    class MyView extends AbstractView {
+      @Override
+      public String processorId() {
+        return "some-processor-id";
+      }
+
+      @Override public PartialFunction<Object, BoxedUnit> receive() {
+        return ReceiveBuilder.
+            match(Persistent.class, peristent -> {
+              // ...
+            }).build();
+      }
+    }
+    //#view
+
+    public void usage() {
+      final ActorSystem system = ActorSystem.create("example");
+      //#view-update
+      final ActorRef view = system.actorOf(Props.create(MyView.class));
+      view.tell(Update.create(true), null);
+      //#view-update
+    }
+  };
+}

akka-samples/akka-sample-persistence-java-lambda/src/main/java/doc/LambdaPersistencePluginDocTest.java

@@ -0,0 +1,113 @@
+/**
+ * Copyright (C) 2009-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package doc;
+
+//#plugin-imports
+import akka.japi.pf.ReceiveBuilder;
+import scala.PartialFunction;
+import scala.concurrent.Future;
+import akka.japi.Option;
+import akka.japi.Procedure;
+import akka.persistence.*;
+import akka.persistence.journal.japi.*;
+import akka.persistence.snapshot.japi.*;
+//#plugin-imports
+import akka.actor.*;
+import akka.persistence.journal.leveldb.SharedLeveldbJournal;
+import akka.persistence.journal.leveldb.SharedLeveldbStore;
+import scala.runtime.BoxedUnit;
+
+public class LambdaPersistencePluginDocTest {
+
+
+  static Object o1 = new Object() {
+    final ActorSystem system = null;
+    //#shared-store-creation
+    final ActorRef store = system.actorOf(Props.create(SharedLeveldbStore.class), "store");
+    //#shared-store-creation
+
+    //#shared-store-usage
+    class SharedStorageUsage extends AbstractActor {
+      @Override
+      public void preStart() throws Exception {
+        String path = "akka.tcp://example@127.0.0.1:2552/user/store";
+        ActorSelection selection = context().actorSelection(path);
+        selection.tell(new Identify(1), self());
+      }
+
+      @Override public PartialFunction<Object, BoxedUnit> receive() {
+        return ReceiveBuilder.
+            match(ActorIdentity.class, ai -> {
+              if (ai.correlationId().equals(1)) {
+                ActorRef store = ai.getRef();
+                if (store != null) {
+                  SharedLeveldbJournal.setStore(store, context().system());
+                }
+              }
+            }).build();
+      }
+    }
+    //#shared-store-usage
+  };
+
+  class MySnapshotStore extends SnapshotStore {
+    @Override
+    public Future<Option<SelectedSnapshot>> doLoadAsync(String processorId, SnapshotSelectionCriteria criteria) {
+      return null;
+    }
+
+    @Override
+    public Future<Void> doSaveAsync(SnapshotMetadata metadata, Object snapshot) {
+      return null;
+    }
+
+    @Override
+    public void onSaved(SnapshotMetadata metadata) throws Exception {
+    }
+
+    @Override
+    public void doDelete(SnapshotMetadata metadata) throws Exception {
+    }
+
+    @Override
+    public void doDelete(String processorId, SnapshotSelectionCriteria criteria) throws Exception {
+    }
+  }
+
+  class MyAsyncJournal extends AsyncWriteJournal {
+    @Override
+    public Future<Void> doAsyncWriteMessages(Iterable<PersistentRepr> messages) {
+      return null;
+    }
+
+    @Override
+    public Future<Void> doAsyncWriteConfirmations(Iterable<PersistentConfirmation> confirmations) {
+      return null;
+    }
+
+    @Override
+    public Future<Void> doAsyncDeleteMessages(Iterable<PersistentId> messageIds, boolean permanent) {
+      return null;
+    }
+
+    @Override
+    public Future<Void> doAsyncDeleteMessagesTo(String processorId, long toSequenceNr, boolean permanent) {
+      return null;
+    }
+
+    @Override
+    public Future<Void> doAsyncReplayMessages(String processorId, long fromSequenceNr,
+                                              long toSequenceNr,
+                                              long max,
+                                              Procedure<PersistentRepr> replayCallback) {
+      return null;
+    }
+
+    @Override
+    public Future<Long> doAsyncReadHighestSequenceNr(String processorId, long fromSequenceNr) {
+      return null;
+    }
+  }
+}

akka-samples/akka-sample-persistence-java-lambda/src/main/java/sample/persistence/ConversationRecoveryExample.java

@@ -0,0 +1,74 @@
+/**
+ * Copyright (C) 2009-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package sample.persistence;
+
+import akka.actor.ActorRef;
+import akka.actor.ActorSystem;
+import akka.actor.Props;
+import akka.japi.pf.ReceiveBuilder;
+import akka.persistence.*;
+import scala.PartialFunction;
+import scala.runtime.BoxedUnit;
+
+public class ConversationRecoveryExample {
+    public static String PING = "PING";
+    public static String PONG = "PONG";
+
+    public static class Ping extends AbstractProcessor {
+        final ActorRef pongChannel = context().actorOf(Channel.props(), "pongChannel");
+        int counter = 0;
+
+        @Override public PartialFunction<Object, BoxedUnit> receive() {
+            return ReceiveBuilder.
+                match(ConfirmablePersistent.class, cp -> cp.payload().equals(PING), cp -> {
+                    counter += 1;
+                    System.out.println(String.format("received ping %d times", counter));
+                    cp.confirm();
+                    if (!recoveryRunning()) {
+                        try {
+                            Thread.sleep(1000);
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                    }
+                    pongChannel.tell(Deliver.create(cp.withPayload(PONG), sender().path()), self());
+                }).
+                match(String.class,
+                      s -> s.equals("init"),
+                      s -> pongChannel.tell(Deliver.create(Persistent.create(PONG), sender().path()), self())).build();
+        }
+    }
+
+    public static class Pong extends AbstractProcessor {
+        private final ActorRef pingChannel = context().actorOf(Channel.props(), "pingChannel");
+        private       int      counter     = 0;
+
+        @Override public PartialFunction<Object, BoxedUnit> receive() {
+            return ReceiveBuilder.
+                match(ConfirmablePersistent.class, cp -> cp.payload().equals(PONG), cp -> {
+                    counter += 1;
+                    System.out.println(String.format("received pong %d times", counter));
+                    cp.confirm();
+                    if (!recoveryRunning()) {
+                        try {
+                            Thread.sleep(1000);
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                    }
+                    pingChannel.tell(Deliver.create(cp.withPayload(PING), sender().path()), self());
+                }).build();
+        }
+    }
+
+    public static void main(String... args) throws Exception {
+        final ActorSystem system = ActorSystem.create("example");
+
+        final ActorRef ping = system.actorOf(Props.create(Ping.class), "ping");
+        final ActorRef pong = system.actorOf(Props.create(Pong.class), "pong");
+
+        ping.tell("init", pong);
+    }
+}

akka-samples/akka-sample-persistence-java-lambda/src/main/java/sample/persistence/EventsourcedExample.java

@@ -0,0 +1,121 @@
+/**
+ * Copyright (C) 2009-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package sample.persistence;
+
+//#eventsourced-example
+
+import akka.actor.ActorRef;
+import akka.actor.ActorSystem;
+import akka.actor.Props;
+import akka.japi.pf.ReceiveBuilder;
+import akka.persistence.AbstractEventsourcedProcessor;
+import akka.persistence.SnapshotOffer;
+import scala.PartialFunction;
+import scala.runtime.BoxedUnit;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+
+import static java.util.Arrays.asList;
+
+class Cmd implements Serializable {
+    private final String data;
+
+    public Cmd(String data) {
+        this.data = data;
+    }
+
+    public String getData() {
+        return data;
+    }
+}
+
+class Evt implements Serializable {
+    private final String data;
+
+    public Evt(String data) {
+        this.data = data;
+    }
+
+    public String getData() {
+        return data;
+    }
+}
+
+class ExampleState implements Serializable {
+    private final ArrayList<String> events;
+
+    public ExampleState() {
+        this(new ArrayList<String>());
+    }
+
+    public ExampleState(ArrayList<String> events) {
+        this.events = events;
+    }
+
+    public ExampleState copy() {
+        return new ExampleState(new ArrayList<String>(events));
+    }
+
+    public void update(Evt evt) {
+        events.add(evt.getData());
+    }
+
+    public int size() {
+        return events.size();
+    }
+
+    @Override
+    public String toString() {
+        return events.toString();
+    }
+}
+
+class ExampleProcessor extends AbstractEventsourcedProcessor {
+    private ExampleState state = new ExampleState();
+
+    public int getNumEvents() {
+        return state.size();
+    }
+
+    @Override public PartialFunction<Object, BoxedUnit> receiveRecover() {
+        return ReceiveBuilder.
+            match(Evt.class, state::update).
+            match(SnapshotOffer.class, ss -> state = (ExampleState) ss.snapshot()).build();
+    }
+
+    @Override public PartialFunction<Object, BoxedUnit> receiveCommand() {
+        return ReceiveBuilder.match(Cmd.class, c -> {
+            final String data = c.getData();
+            final Evt evt1 = new Evt(data + "-" + getNumEvents());
+            final Evt evt2 = new Evt(data + "-" + (getNumEvents() + 1));
+            persist(asList(evt1, evt2), (Evt evt) -> {
+                state.update(evt);
+                if (evt.equals(evt2)) {
+                    context().system().eventStream().publish(evt);
+                }
+            });
+        }).
+            match(String.class, s -> s.equals("snap"), s -> saveSnapshot(state.copy())).
+            match(String.class, s -> s.equals("print"), s -> System.out.println(state)).build();
+    }
+}
+//#eventsourced-example
+
+public class EventsourcedExample {
+    public static void main(String... args) throws Exception {
+        final ActorSystem system = ActorSystem.create("example");
+        final ActorRef processor = system.actorOf(Props.create(ExampleProcessor.class), "processor-4-java8");
+        processor.tell(new Cmd("foo"), null);
+        processor.tell(new Cmd("baz"), null);
+        processor.tell(new Cmd("bar"), null);
+        processor.tell("snap", null);
+        processor.tell(new Cmd("buzz"), null);
+        processor.tell("print", null);
+
+        Thread.sleep(1000);
+        system.shutdown();
+    }
+}

akka-samples/akka-sample-persistence-java-lambda/src/main/java/sample/persistence/ProcessorChannelExample.java

@@ -0,0 +1,58 @@
+/**
+ * Copyright (C) 2009-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package sample.persistence;
+
+import akka.actor.AbstractActor;
+import akka.actor.ActorRef;
+import akka.actor.ActorSystem;
+import akka.actor.Props;
+import akka.japi.pf.ReceiveBuilder;
+import akka.persistence.*;
+import scala.PartialFunction;
+import scala.runtime.BoxedUnit;
+
+public class ProcessorChannelExample {
+    public static class ExampleProcessor extends AbstractProcessor {
+        private ActorRef destination;
+        private ActorRef channel;
+
+        public ExampleProcessor(ActorRef destination) {
+            this.destination = destination;
+            this.channel = context().actorOf(Channel.props(), "channel");
+        }
+
+        @Override public PartialFunction<Object, BoxedUnit> receive() {
+            return ReceiveBuilder.
+                match(Persistent.class, p -> {
+                    System.out.println("processed " + p.payload());
+                    channel.tell(Deliver.create(p.withPayload("processed " + p.payload()), destination.path()), self());
+                }).
+                match(String.class, s -> System.out.println("reply = " + s)).build();
+        }
+    }
+
+    public static class ExampleDestination extends AbstractActor {
+        @Override public PartialFunction<Object, BoxedUnit> receive() {
+            return ReceiveBuilder.
+                match(ConfirmablePersistent.class, cp -> {
+                    System.out.println("received " + cp.payload());
+                    sender().tell(String.format("re: %s (%d)", cp.payload(), cp.sequenceNr()), null);
+                    cp.confirm();
+                }).build();
+        }
+    }
+
+    public static void main(String... args) throws Exception {
+        final ActorSystem system = ActorSystem.create("example");
+        final ActorRef destination = system.actorOf(Props.create(ExampleDestination.class));
+        final ActorRef processor = system.actorOf(Props.create(ExampleProcessor.class, destination), "processor-1");
+
+        processor.tell(Persistent.create("a"), null);
+        processor.tell(Persistent.create("b"), null);
+
+        Thread.sleep(1000);
+        system.shutdown();
+    }
+}

akka-samples/akka-sample-persistence-java-lambda/src/main/java/sample/persistence/ProcessorFailureExample.java

@@ -0,0 +1,72 @@
+/**
+ * Copyright (C) 2009-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package sample.persistence;
+
+import akka.actor.ActorRef;
+import akka.actor.ActorSystem;
+import akka.actor.Props;
+import akka.japi.pf.ReceiveBuilder;
+import akka.persistence.AbstractProcessor;
+import akka.persistence.Persistent;
+import scala.Option;
+import scala.PartialFunction;
+import scala.runtime.BoxedUnit;
+
+import java.util.ArrayList;
+
+public class ProcessorFailureExample {
+    public static class ExampleProcessor extends AbstractProcessor {
+        private ArrayList<Object> received = new ArrayList<Object>();
+
+        @Override public PartialFunction<Object, BoxedUnit> receive() {
+            return ReceiveBuilder.
+                match(Persistent.class, p -> p.payload().equals("boom"), p -> {throw new RuntimeException("boom");}).
+                match(Persistent.class, p -> !p.payload().equals("boom"), p -> received.add(p.payload())).
+                match(String.class, s -> s.equals("boom"), s -> {throw new RuntimeException("boom");}).
+                match(String.class, s -> s.equals("print"), s -> System.out.println("received " + received)).build();
+        }
+
+        @Override
+        public void preRestart(Throwable reason, Option<Object> message) {
+            if (message.isDefined() && message.get() instanceof Persistent) {
+                deleteMessage(((Persistent) message.get()).sequenceNr(), false);
+            }
+            super.preRestart(reason, message);
+        }
+    }
+
+    public static void main(String... args) throws Exception {
+        final ActorSystem system = ActorSystem.create("example");
+        final ActorRef processor = system.actorOf(Props.create(ExampleProcessor.class), "processor-2");
+
+        processor.tell(Persistent.create("a"), null);
+        processor.tell("print", null);
+        processor.tell("boom", null);
+        processor.tell("print", null);
+        processor.tell(Persistent.create("b"), null);
+        processor.tell("print", null);
+        processor.tell(Persistent.create("boom"), null);
+        processor.tell("print", null);
+        processor.tell(Persistent.create("c"), null);
+        processor.tell("print", null);
+
+        // Will print in a first run (i.e. with empty journal):
+
+        // received [a]
+        // received [a, b]
+        // received [a, b, c]
+
+        // Will print in a second run:
+
+        // received [a, b, c, a]
+        // received [a, b, c, a, b]
+        // received [a, b, c, a, b, c]
+
+        // etc ...
+
+        Thread.sleep(1000);
+        system.shutdown();
+    }
+}

akka-samples/akka-sample-persistence-java-lambda/src/main/java/sample/persistence/SnapshotExample.java

@@ -0,0 +1,79 @@
+/**
+ * Copyright (C) 2009-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package sample.persistence;
+
+import akka.actor.ActorRef;
+import akka.actor.ActorSystem;
+import akka.actor.Props;
+import akka.japi.pf.ReceiveBuilder;
+import akka.persistence.AbstractProcessor;
+import akka.persistence.Persistent;
+import akka.persistence.SnapshotOffer;
+import scala.PartialFunction;
+import scala.runtime.BoxedUnit;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+
+public class SnapshotExample {
+    public static class ExampleState implements Serializable {
+        private final ArrayList<String> received;
+
+        public ExampleState() {
+            this(new ArrayList<String>());
+        }
+
+        public ExampleState(ArrayList<String> received) {
+            this.received = received;
+        }
+
+        public ExampleState copy() {
+            return new ExampleState(new ArrayList<String>(received));
+        }
+
+        public void update(String s) {
+            received.add(s);
+        }
+
+        @Override
+        public String toString() {
+            return received.toString();
+        }
+    }
+
+    public static class ExampleProcessor extends AbstractProcessor {
+        private ExampleState state = new ExampleState();
+
+        @Override public PartialFunction<Object, BoxedUnit> receive() {
+            return ReceiveBuilder.
+                match(Persistent.class, p -> state.update(String.format("%s-%d", p.payload(), p.sequenceNr()))).
+                match(SnapshotOffer.class, s -> {
+                    ExampleState exState = (ExampleState) s.snapshot();
+                    System.out.println("offered state = " + exState);
+                    state = exState;
+                }).
+                match(String.class, s -> s.equals("print"), s -> System.out.println("current state = " + state)).
+                match(String.class, s -> s.equals("snap"), s ->
+                    // IMPORTANT: create a copy of snapshot
+                    // because ExampleState is mutable !!!
+                    saveSnapshot(state.copy())).build();
+        }
+    }
+
+    public static void main(String... args) throws Exception {
+        final ActorSystem system = ActorSystem.create("example");
+        final ActorRef processor = system.actorOf(Props.create(ExampleProcessor.class), "processor-3-java");
+
+        processor.tell(Persistent.create("a"), null);
+        processor.tell(Persistent.create("b"), null);
+        processor.tell("snap", null);
+        processor.tell(Persistent.create("c"), null);
+        processor.tell(Persistent.create("d"), null);
+        processor.tell("print", null);
+
+        Thread.sleep(1000);
+        system.shutdown();
+    }
+}

akka-samples/akka-sample-persistence-java-lambda/src/main/java/sample/persistence/ViewExample.java

@@ -0,0 +1,100 @@
+/**
+ * Copyright (C) 2009-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package sample.persistence;
+
+import akka.actor.AbstractActor;
+import akka.actor.ActorRef;
+import akka.actor.ActorSystem;
+import akka.actor.Props;
+import akka.japi.pf.ReceiveBuilder;
+import akka.persistence.*;
+import scala.PartialFunction;
+import scala.concurrent.duration.Duration;
+import scala.runtime.BoxedUnit;
+
+import java.util.concurrent.TimeUnit;
+
+public class ViewExample {
+    public static class ExampleProcessor extends AbstractProcessor {
+        @Override
+        public String processorId() {
+            return "processor-5";
+        }
+
+        @Override public PartialFunction<Object, BoxedUnit> receive() {
+            return ReceiveBuilder.
+                match(Persistent.class,
+                      p -> System.out.println(String.format("processor received %s (sequence nr = %d)",
+                                                            p.payload(),
+                                                            p.sequenceNr()))).build();
+        }
+    }
+
+    public static class ExampleView extends AbstractView {
+        private final ActorRef destination = context().actorOf(Props.create(ExampleDestination.class));
+        private final ActorRef channel     = context().actorOf(Channel.props("channel"));
+
+        private int numReplicated = 0;
+
+        @Override
+        public String viewId() {
+            return "view-5";
+        }
+
+        @Override
+        public String processorId() {
+            return "processor-5";
+        }
+
+        @Override public PartialFunction<Object, BoxedUnit> receive() {
+            return ReceiveBuilder.
+                match(Persistent.class, p -> {
+                    numReplicated += 1;
+                    System.out.println(String.format("view received %s (sequence nr = %d, num replicated = %d)",
+                                                     p.payload(),
+                                                     p.sequenceNr(),
+                                                     numReplicated));
+                    channel.tell(Deliver.create(p.withPayload("replicated-" + p.payload()), destination.path()),
+                                 self());
+                }).
+                match(SnapshotOffer.class, so -> {
+                    numReplicated = (Integer) so.snapshot();
+                    System.out.println(String.format("view received snapshot offer %s (metadata = %s)",
+                                                     numReplicated,
+                                                     so.metadata()));
+                }).
+                match(String.class, s -> s.equals("snap"), s -> saveSnapshot(numReplicated)).build();
+        }
+    }
+
+    public static class ExampleDestination extends AbstractActor {
+
+        @Override public PartialFunction<Object, BoxedUnit> receive() {
+            return ReceiveBuilder.
+                match(ConfirmablePersistent.class, cp -> {
+                    System.out.println(String.format("destination received %s (sequence nr = %s)",
+                                                     cp.payload(),
+                                                     cp.sequenceNr()));
+                    cp.confirm();
+                }).build();
+        }
+    }
+
+    public static void main(String... args) throws Exception {
+        final ActorSystem system = ActorSystem.create("example");
+        final ActorRef processor = system.actorOf(Props.create(ExampleProcessor.class));
+        final ActorRef view = system.actorOf(Props.create(ExampleView.class));
+
+        system.scheduler()
+            .schedule(Duration.Zero(),
+                      Duration.create(2, TimeUnit.SECONDS),
+                      processor,
+                      Persistent.create("scheduled"),
+                      system.dispatcher(),
+                      null);
+        system.scheduler()
+            .schedule(Duration.Zero(), Duration.create(5, TimeUnit.SECONDS), view, "snap", system.dispatcher(), null);
+    }
+}