clears the program and past spawn information

counts all running spawns

creates a runner program

(create-program {:type :constant :id :hello :interval 10})

returns earliest created spawn

returns all running spawns

gets the program given runtime and program-id

(get-program |rt3| :test-program) => {}

gets the current props map for the runner

gets running spawn with id

gets the global state for the program-id

(get-state |rt3| :test-program) => {}

installs a program

checks if program is installed

(test-scaffold (fn runner _ (installed? runner :world))) => true

kills all the running tasks

(-> (doto |rt3| (kill-all :test-program)) (count-spawn :test-program)) => 0

stops a spawn and all jobs

(kill-spawn |rt3| :test-program “s1”) => spawn?

returns the latest active or past spawn

returns latest created spawn

returns the most recently stopped spawn

lists all running spawns

lists all stopped spawns

creates and starts a runner

(-> (runner {:id “runner”}) (h/comp:kill))

creates a runner

(runner:create {:id “runner”}) => runner?

returns health of runner

(runner:health |run|) => {:status :ok}

returns runner info

(h/with:component runner (runner:create {}) (runner:info runner)) => {:executors {:core {:threads 0, :active 0, :queued 0, :terminated false}, :scheduler {:threads 0, :active 0, :queued 0, :terminated false}}, :programs {}}

kills the runner

starts up the runner

(-> (runner:start |runner|) (runner:info)) => {:executors {:core {:threads 0, :active 0, :queued 0, :terminated false}, :scheduler {:threads 0, :active 0, :queued 0, :terminated false}}, :programs {}}

checks if runner is started

(runner:started? |run|) => true

stops the runner

checks if runner has stopped

(-> (doto |run| (runner:kill)) (runner:stopped?)) => true

checks if object is a runner

(runner? |run|) => true

manually overrides the interval for a spawn/program

spawns a runner that contains the program

stops all the running tasks

(-> (doto |rt3| (stop-all :test-program)) (count-spawn :test-program)) => 0

stop a spawn and waits for jobs to finish

triggers the program manually, without spawning

(test-scaffold (fn runner q (trigger runner :world) (trigger runner :world) (count q))) => 2

uninstalls a program

unspawns the running program