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

2014-03-19 11:59:16 +01:00 · 2014-03-19 11:59:16 +01:00 · 26c493ea4a
commit 26c493ea4a
parent 82ee7e2ede
21 changed files with 136 additions and 86 deletions
--- a/akka-samples/akka-sample-persistence-java-lambda/src/main/java/sample/persistence/ConversationRecoveryExample.java
+++ b/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);
+    }
+}
--- a/akka-samples/akka-sample-persistence-java-lambda/src/main/java/sample/persistence/EventsourcedExample.java
+++ b/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();
+    }
+}
--- a/akka-samples/akka-sample-persistence-java-lambda/src/main/java/sample/persistence/ProcessorChannelExample.java
+++ b/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();
+    }
+}
--- a/akka-samples/akka-sample-persistence-java-lambda/src/main/java/sample/persistence/ProcessorFailureExample.java
+++ b/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();
+    }
+}
--- a/akka-samples/akka-sample-persistence-java-lambda/src/main/java/sample/persistence/SnapshotExample.java
+++ b/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();
+    }
+}
--- a/akka-samples/akka-sample-persistence-java-lambda/src/main/java/sample/persistence/ViewExample.java
+++ b/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);
+    }
+}