keechma.pipelines.runtime — keechma/pipelines 0.1.1

*pipeline-depth* cljs

add-to-parent cljs

(add-to-parent state {:keys [ident]})

add-to-queue cljs

(add-to-queue state resumable)

as-error cljs

(as-error value)

can-start-immediately? cljs

(can-start-immediately? state resumable)

can-use-existing? cljs

(can-use-existing? resumable)

cleanup-parents cljs

(cleanup-parents {:keys [state*] :as runtime} instance)

default-opts cljs

default-transactor cljs

(default-transactor transaction)

deregister-instance cljs

(deregister-instance state resumable)

enqueue-resumable cljs

(enqueue-resumable {:keys [state*] :as runtime} resumable props)

error? cljs

(error? value)

execute cljs

(execute runtime context ident action value error get-interpreter-state)

finish-resumable cljs

(finish-resumable {:keys [state*] :as runtime}
                  {:keys [ident] :as resumable}
                  result)

fn->pipeline-step cljs

(fn->pipeline-step pipeline-fn)

get-cancel-root-ident cljs

(get-cancel-root-ident state ident)

get-existing cljs

(get-existing state resumable)

get-ident-and-descendant-idents cljs

(get-ident-and-descendant-idents state ident)

(get-ident-and-descendant-idents state ident descendants)

get-pipeline-instance cljs

(get-pipeline-instance state ident)

get-queue cljs

(get-queue state queue-name)

get-queue-config cljs

(get-queue-config state queue-name)

get-queue-queue cljs

(get-queue-queue state queue-name)

get-queued-idents-to-cancel cljs

(get-queued-idents-to-cancel state queue-name)

get-queued-idents-to-start cljs

(get-queued-idents-to-start state queue-name)

get-resumable-queue-name cljs

(get-resumable-queue-name resumable)

has-pipeline? cljs

(has-pipeline? {:keys [state*]} pipeline-name)

in-pipeline? cljs

(in-pipeline?)

interpreter-state->resumable cljs

(interpreter-state->resumable stack)

(interpreter-state->resumable stack use-fresh-idents)

invoke-resumable cljs

(invoke-resumable runtime
                  {:keys [ident args] :as resumable}
                  {:keys [parent] :as pipeline-opts})

IPipeline cljs protocol

->resumable cljs

(->resumable this pipeline-name value)

IPipelineInstance cljs protocol

get-args cljs

(get-args this)

get-ident cljs

(get-ident this)

IPipelineRuntime cljs protocol

on-cancel cljs

(on-cancel this promise deferred-result)

wait-all cljs

(wait-all this idents)

get-pipeline-instance* cljs

(get-pipeline-instance* this ident)

cancel-all cljs

(cancel-all this idents)

stop! cljs

(stop! this)

get-active cljs

(get-active this)

report-error cljs

(report-error this error)

transact cljs

(transact this transact-fn)

get-state* cljs

(get-state* this)

invoke cljs

(invoke this pipeline)

(invoke this pipeline args)

(invoke this pipeline args config)

wait cljs

(wait this ident)

cancel cljs

(cancel this ident)

IResumable cljs protocol

->pipeline cljs

(->pipeline this)

live-states cljs

make-ident cljs

(make-ident pipeline-id)

make-pipeline cljs

(make-pipeline id pipeline)

Pipeline cljs

pipeline-step? cljs

(pipeline-step? value)

pipeline? cljs

(pipeline? val)

PipelineRuntime cljs

process-pipeline cljs

(process-pipeline [pipeline-name pipeline])

process-resumable cljs

(process-resumable {:keys [state*] :as runtime} resumable props)

promise->chan cljs

(promise->chan promise)

queue-assoc-last cljs

(queue-assoc-last state resumable result)

queue-assoc-last-error cljs

(queue-assoc-last-error state resumable result)

queue-assoc-last-result cljs

(queue-assoc-last-result state resumable result)

real-value cljs

(real-value value prev-value)

register-instance cljs

(register-instance state resumable props)

(register-instance state resumable props instance-state)

remove-from-parent cljs

(remove-from-parent state {:keys [ident]})

remove-from-queue cljs

(remove-from-queue state resumable)

Resumable cljs

resumable-with-resumed-tail cljs

(resumable-with-resumed-tail runtime resumable)

resumable? cljs

(resumable? val)

run-sync-block cljs

(run-sync-block runtime context resumable props)

run-sync-block-until-no-resumable-state cljs

(run-sync-block-until-no-resumable-state runtime context resumable props)

running-states cljs

start! cljs

(start! context)

(start! context pipelines)

(start! context pipelines opts)

start-interpreter cljs

(start-interpreter runtime context resumable props)

start-next-in-queue cljs

(start-next-in-queue {:keys [state*] :as runtime} queue-name)

start-resumable cljs

(start-resumable {:keys [state* context] :as runtime}
                 {:keys [ident args] :as resumable})

throw-if-queues-not-matching cljs

(throw-if-queues-not-matching state resumable)

update-instance-state cljs

(update-instance-state state resumable instance-state)