std.scheduler — xyz.zcaudate/std.scheduler 4.0.5

*no-limit* clj

clear clj

(clear runner)

(clear runner id)

clears the program and past spawn information

count-spawn clj

(count-spawn runner)

(count-spawn runner id)

counts all running spawns

create-program clj

(create-program program)

creates a runner program

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

earliest-spawn clj

(earliest-spawn runner)

(earliest-spawn runner id)

returns earliest created spawn

get-all-spawn clj

(get-all-spawn runner)

(get-all-spawn runner id)

returns all running spawns

get-program clj

(get-program runner)

(get-program runner id)

gets the program given runtime and program-id

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

get-props clj

(get-props {:keys [runtime] :as runner} program-id)

(get-props {:keys [runtime] :as runner} program-id spawn-id)

gets the current props map for the runner

get-spawn clj

(get-spawn runner program-id spawn-id)

gets running spawn with id

get-state clj

(get-state runner)

(get-state runner id)

gets the global state for the program-id

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

install clj

(install {:keys [runtime] :as runner} program)

installs a program

installed? clj

(installed? {:keys [runtime] :as runner} program-id)

checks if program is installed

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

kill-all-spawn clj

(kill-all-spawn runner)

(kill-all-spawn runner id)

kills all the running tasks

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

kill-spawn clj

(kill-spawn runner program-id spawn-id)

stops a spawn and all jobs

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

latest clj

(latest runner)

(latest runner id)

returns the latest active or past spawn

latest-spawn clj

(latest-spawn runner)

(latest-spawn runner id)

returns latest created spawn

latest-stopped clj

(latest-stopped runner)

(latest-stopped runner id)

returns the most recently stopped spawn

list-spawn clj

(list-spawn runner)

(list-spawn runner id)

lists all running spawns

list-stopped clj

(list-stopped runner)

(list-stopped runner id)

lists all stopped spawns

runner clj

(runner)

(runner m)

creates and starts a runner

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

runner:create clj

(runner:create)

(runner:create m)

creates a runner

(runner:create {:id "runner"}) => runner?

runner:health clj

(runner:health runner)

returns health of runner

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

runner:info clj

(runner:info {:keys [runtime] :as runner})

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 {}}

runner:kill clj

(runner:kill {:keys [runtime] :as runner})

kills the runner

runner:start clj

(runner:start {:keys [runtime] :as 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 {}}

runner:started? clj

(runner:started? {:keys [runtime] :as runner})

checks if runner is started

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

runner:stop clj

(runner:stop {:keys [runtime] :as runner})

stops the runner

runner:stopped? clj

(runner:stopped? {:keys [runtime] :as runner})

checks if runner has stopped

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

runner? clj

(runner? obj)

checks if object is a runner

(runner? |run|) => true

set-interval clj

(set-interval {:keys [runtime] :as runner} program-id interval)

(set-interval {:keys [runtime] :as runner} program-id spawn-id interval)

manually overrides the interval for a spawn/program

(h/bench-ms (test-scaffold (fn [runner q] (set-interval runner :world 10) (spawn runner :world) (doall (for [i (range 2)] (cc/take q)))))) => #(<= 15 % 50)

spawn clj

(spawn runner program-id)

(spawn {:keys [runtime] :as runner} program-id opts spawn-id)

spawns a runner that contains the program

stop-all-spawn clj

(stop-all-spawn runner)

(stop-all-spawn runner id)

stops all the running tasks

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

stop-spawn clj

(stop-spawn runner program-id spawn-id)

stop a spawn and waits for jobs to finish

trigger clj

(trigger runner program-id)

(trigger runner program-id t)

triggers the program manually, without spawning

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

uninstall clj

(uninstall {:keys [runtime] :as runner} program-id)

uninstalls a program

unspawn clj

(unspawn {:keys [runtime] :as runner} program-id)

unspawns the running program