test two separate list

Author: wangkexue

reactive-programming.org

@@ -1859,3 +1859,72 @@ trait Actor {
   }
 }
 #+end_src
+** Persistent Actor State
+Actors representing a stateful resource
+  - shall not lose important state due to (system) failure
+  - must persist state as needed
+  - must recover state at (re)start
+Two possibilities for persisting state:
+  - in-place updates
+  - persist changes in append-only fashion
+*** Changes vs. Current State
+*** Snapshots
+Immutable snapshots can be used to bound recovery time
+*** Persistence Primitive
+  - being persistent means "taking notes"
+#+begin_src scala
+persist(MyEvent(...)) { event =>
+  // now <event> is persisted
+  do SomethingWidth(event)
+}
+#+end_src
+*** Event Example
+#+begin_src scala
+case class NewPost(text: String, id: Long)
+case class BlogPosted(id: Long)
+case class BlogNotPosted(id: Long, reason: String)
+
+sealed trait Event
+case class PostCreated(text: String) extends Event
+case object QuotaReached extends Event
+
+case class State(posts: Vector[String], disabled: Boolean) {
+  def updated(e: Event): State = e match {
+    case PostCreated(text) => copy(posts = posts :+ text)
+    case QuotaReached      => copy(disabled = true)
+  }
+}
+
+class UserProcessor extends PersistentActor {
+  var state = State(Vector.empty, false)
+  def receiveCommand = {
+    case NewPost(text, id) =>
+      if (state.disabled) sender() ! BlogNotPosted(id, "quota reached")
+      else { persist(PostCreated（text)) { e =>
+                 updateState(e)
+                 sender() ! BlogPosted(id) }
+             persist(QuotaReached) (updateState) }
+ }
+  def updateState(e: Event) { state = state.updated(e) }
+  def receiveRecover = { case e: Event => updateState(e) }
+}  
+
+case NewPost(text, id) =>
+  if (!state.disabled) {
+    val created = PostCreated(text)
+    update(created)
+    update(QuotaReached)
+    persistAsync(created)(sender() ! BlogPosted(id))
+    persistAsync(QuotaReached)(_ => ())
+  } else sender() ! BlogNotPosted(id, "quota reached")
+#+end_src
+*** When to Apply the Events?
+- Applying after persisting leaves actor in stale state.
+*** At-Least-Once Delivery
+  - Guaranteeing delivery means retrying until successful
+  - Retries are the sender's responsibility
+  - The recipient needs to acknowledge receipt
+  - Lost receipts lead to duplicate deliveries => at-least-once
+  
+  - Retrying means taking note that the message needs to be sent
+  - Acknowledgement means taking note of the receipt of the confirmation