onyx.peer.coordinator — org.onyxplatform/onyx 0.13.3-alpha1

barrier-period clj

(barrier-period job-config peer-config)

check-peer-timeout! clj

(check-peer-timeout! {:keys [messenger subscriber-liveness-timeout] :as state})

checkpoint-complete? clj

(checkpoint-complete? {:keys [initiated? epoch] :as checkpoint} status)

complete-job clj

(complete-job {:keys [tenancy-id log job-id messenger checkpoint group-ch
                      curr-replica]
               :as state})

completed-checkpoint clj

(completed-checkpoint
  {:keys [checkpoint messenger job-id tenancy-id log curr-replica] :as state})

Coordinator clj protocol

next-state clj

(next-state this old-replica new-replica)

start clj

(start this)

started? clj

(started? this)

stop clj

(stop this scheduler-event)

coordinator-backoff-ms clj

coordinator-iteration clj

(coordinator-iteration {:keys [messenger checkpoint last-heartbeat-time
                               allocation-ch shutdown-ch barrier job job-id
                               curr-replica subscriber-liveness-timeout]
                        :as state}
                       coordinator-max-sleep-ns
                       barrier-period-ns
                       heartbeat-ns)

emit-replica clj

(emit-replica {:keys [allocation-ch] :as coordinator} replica)

emit-seal-barrier clj

(emit-seal-barrier state)

evict-peer! clj

(evict-peer! {:keys [group-ch evicted curr-replica] :as state} peer-id)

initialise-state clj

(initialise-state {:keys [log messenger job-id tenancy-id curr-replica]
                   :as state})

input-publications clj

(input-publications {:keys [peer-sites message-short-ids] :as replica}
                    peer-config
                    peer-id
                    job-id)

make-task-data clj

(make-task-data replica job-id)

merged-statuses clj

(merged-statuses messenger)

new-peer-coordinator clj

(new-peer-coordinator workflow
                      resume-point
                      log
                      messenger-group
                      monitoring
                      peer-config
                      job-config
                      peer-id
                      job-id
                      group-ch)

next-replica clj

(next-replica {:keys [log job-id peer-id messenger curr-replica tenancy-id
                      peer-config]
               :as state}
              barrier-period-ns
              new-replica)

offer-barriers clj

(offer-barriers {:keys [messenger barrier] :as state})

offer-heartbeats clj

(offer-heartbeats {:keys [messenger] :as state})

periodic-barrier clj

(periodic-barrier {:keys [tenancy-id workflow-depth log curr-replica job-id
                          messenger barrier checkpoint]
                   :as state})

schedule-next-barrier clj

(schedule-next-barrier state barrier-period-ns)

shutdown clj

(shutdown {:keys [messenger peer-id] :as state})

start-coordinator! clj

(start-coordinator! {:keys [allocation-ch shutdown-ch peer-config job-config]
                     :as state})

start-messenger clj

(start-messenger messenger replica job-id)

stop-coordinator! clj

(stop-coordinator! {:keys [shutdown-ch allocation-ch peer-id]} scheduler-event)

write-coordinate clj

(write-coordinate curr-version log tenancy-id job-id coordinate)