          {:job-scheduler (:onyx.peer/job-scheduler peer-config)
           :messaging (select-keys peer-config [:onyx.messaging/impl])}))
 
+(defn playback-log [peer-config peer-log-reads]
+  (reduce #(onyx.extensions/apply-log-entry %2 %1)
+          (base-replica peer-config)
+          peer-log-reads))
+
+(defn pulses [conn peer-config]
+  (onyx.log.curator/children conn (onyx.log.zookeeper/pulse-path (:onyx/id peer-config))))
+
+;;; TODO, check whether the jobs were even submitted, if not, nothing should be read back
 (defrecord Checker [peer-config n-peers]
   checker/Checker
   (check [checker test model history]

                                                  (and (= (:f action) :read-peer-log)
                                                       (= (:type action) :ok)))
                                                history)))
          final-replica (reduce #(onyx.extensions/apply-log-entry %2 %1)
                                (base-replica peer-config)
                                peer-log-reads) 

          all-peers-up? (= (count (:peers final-replica))
                           (* 5 n-peers))

          results (map (fn [lr] 
                         (map :value (:results lr))) 
                       (:value ledger-reads))

          successfully-added (filter (fn [action]
                                       (and (= (:f action) :add)
                                            (= (:type action) :ok)))
                                     history)
          added-values (set (map :value successfully-added))
          read-values (set (reduce into [] results))
          diff-written-read (clojure.set/difference added-values read-values)
          all-written-read? (empty? diff-written-read)

          ;; Check that all values at the output went through the second task first
          all-stage-2 (set (mapcat (fn [lr] 

                                   (:value ledger-reads)))
          all-through-intermediate? (= all-stage-2 #{2})
          unacked-writes-read (clojure.set/difference read-values added-values)]
      (doto {:valid? (and all-written-read? all-peers-up? accepting-empty? prepared-empty? peers-match-pulses?)
             :peers-match-pulses? peers-match-pulses?
             :pulse-peers pulse-peers
             :peer-log peer-log-reads
             :accepted-empty? accepting-empty?
             :prepared-empty? prepared-empty?
             :final-replica final-replica
             :added added-values
             :job-exception-cause (some-> exception (.getCause))
             :job-exception-trace (some-> exception (.getStackTrace))
             :read-values read-values
             :diff-written-read diff-written-read
             :unacknowledged-writes-read unacked-writes-read
             :all-peers-up? all-peers-up?
             :all-written-read? all-written-read?}
        info))))
