std.scheduler.spawn — xyz.zcaudate/std.scheduler 4.0.1

*defaults* clj

*delay* clj

*group* clj

*interval* clj

*job* clj

*spawn* clj

*spawn-id* clj

*timing* clj

add-job clj

(add-job spawn job-id job)

adds job to the spawn

clear clj

(clear runtime program-id)

clears the program and past spawn information

count-jobs clj

(count-jobs spawn)

returns the number of jobs

count-spawn clj

(count-spawn runtime program-id)

counts all running spawns

create-handler clj

(create-handler {:keys [type] :as program} spawn)

creates a run handler

(create-handler (assoc defaults :type :basic) (create-spawn)) => fn?

create-handler-basic clj

(create-handler-basic program spawn)

creates a basic handler

create-handler-constant clj

(create-handler-constant {:keys [args-fn] :as program} spawn)

creates a constant handler

create-spawn clj

(create-spawn)

(create-spawn {:keys [create-fn continue-fn interval global full state]
               :as program}
              spawn-id)

creates a new spawn

(-> (create-spawn (merge defaults {:interval 1}) "spawn.1") (spawn-info)) => {:id "spawn.1", :status :created, :duration "0ms", :jobs {:submitted 0 :succeeded 0 :errored 0 :waiting 0}, :state nil}

earliest-spawn clj

(earliest-spawn runtime program-id)

returns earliest created spawn

get-all-spawn clj

(get-all-spawn runtime program-id)

returns all running spawns

get-job clj

(get-job spawn job-id)

(get-job spawn job-id ks)

retrieves a job given key

(-> (doto (create-spawn) (add-job "j.1" {:id "j.1"}))

(get-job "j.1"))

=> {:id "j.1"}

get-program clj

(get-program runtime program-id)

gets the program given runtime and program-id

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

get-props clj

(get-props spawn)

(get-props spawn k)

gets the spawn prop given key

(-> (create-spawn) (get-props :submitted)) => 0

get-spawn clj

(get-spawn runtime program-id spawn-id)

gets running spawn with id

get-state clj

(get-state runtime program-id)

gets the global state for the program-id

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

handler-run clj

(handler-run {:keys [args-fn main-fn merge-fn success-fn error-fn]}
             {:keys [state] :as spawn}
             {:keys [time return] job-id :id :as job})

handles the

(let [ret (h/incomplete) job {:id "j.0" :time 0 :return ret} spawn (doto (create-spawn) (add-job "j.0" job)) result {:task (handler-run defaults spawn job)}] (assoc result :return @ret :meta @(:output spawn))) => (contains-in {:task ["j.0" 0] :return nil :meta {:status :success, :data nil, :exception nil, :time 0, :start integer? :end integer?}})

kill-all clj

(kill-all runtime program-id)

kills all the running tasks

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

kill-spawn clj

(kill-spawn runtime program-id spawn-id)

stops a spawn and all jobs

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

latest clj

(latest runtime program-id)

returns the latest active or past spawn

latest-spawn clj

(latest-spawn runtime program-id)

returns latest created spawn

latest-stopped clj

(latest-stopped runtime program-id)

returns the most recently stopped spawn

list-job-ids clj

(list-job-ids spawn)

lists all job ids

list-jobs clj

(list-jobs spawn)

list all jobs

list-spawn clj

(list-spawn runner program-id)

(list-spawn runtime program-id order)

lists all running spawns

list-stopped clj

(list-stopped runtime program-id)

lists all stopped spawns

remove-job clj

(remove-job spawn job-id)

removes a job given key

run clj

(run runtime program-id)

(run runtime program-id opts spawn-id)

constructs and starts a spawn loop

schedule-timing clj

(schedule-timing type props last)

(schedule-timing type props last now)

calculates the timing for the next schedule

(schedule-timing :constant {:interval 1000} 500 635) => [1500 865]

send-result clj

(send-result {:keys [output] :as spawn} result)

sends the result to spawn output

set-props clj

(set-props spawn k v & more)

updates the spawn props

(-> (create-spawn) (set-props :submitted inc :errored 4 :started true) (select-keys [:submitted :errored :started])) => {:submitted 1, :errored 4, :started true}

spawn-info clj

(spawn-info {:keys [id board props output state exit] :as spawn})

returns the spawn info

spawn-loop clj

(spawn-loop runtime
            {:keys [time-fn continue-fn] :as program}
            {:keys [props exit board] :as spawn})

creates a spawn loop

spawn-save-past clj

(spawn-save-past runtime program-id {spawn-id :id :as spawn})

helper function to move spawn from :running to :past

spawn-status clj

(spawn-status {:keys [props exit] :as spawn})

returns the spawn status

spawn? clj

(spawn? obj)

checks that object is a spawn

stop-all clj

(stop-all runtime program-id)

stops all the running tasks

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

stop-spawn clj

(stop-spawn runtime program-id spawn-id)

stop a spawn and waits for jobs to finish

update-job clj

(update-job spawn job-id f & args)

updates a job given key

wrap-schedule clj

(wrap-schedule {:keys [type] :as program} {:keys [props] :as spawn} schedule-fn)

wrapper for the schedule function