hara.function.procedure.middleware — hara/function.procedure 3.0.11

wrap-cached clj

(wrap-cached f)

adds a caching layer to the procedure

(-> ((wrap-cached (fn [inst args] (Thread/sleep 1000000))) {:result (promise) :cached true :cache (state/update (state/cache {}) assoc-in ["hello" :1 []] {:result (atom {:success true :value 42}) :runtime (atom {:ended 0})}) :name "hello" :id :1} []) deref) => {:success true, :value 42, :cached 0}

wrap-callback clj

(wrap-callback f)

enables a callback to be added to the procedure for side effects

((procedure {:name "callback" :id :2 :handler (fn [] :FAST) :callback (fn [x] (println x))} []))

wrap-id clj

(wrap-id f)

creates an id for the instance

((wrap-id (fn [inst args] (:id inst))) {:id-fn (constantly :hello)} []) => :hello

wrap-instance clj

(wrap-instance f)

enables the entire instance to be passed in

((wrap-instance (fn [_ args] (first args))) {:arglist [:instance]} [nil]) => {:arglist [:instance]}

((wrap-instance (fn [_ [inst]] (:params inst))) {:arglist [:instance] :params :b} [nil]) => :b

wrap-interrupt clj

(wrap-interrupt f)

interrupts the existing procedure

(do ((procedure {:name "hello" :id :1 :handler (fn [] (Thread/sleep 1000000000))} []))

(map :id (registry/list-instances
          registry/+default-registry
          "hello")))

=> '(:1)

(do ((procedure {:name "hello" :id :1 :interrupt true :handler (fn [] :FAST)} [])) (map :id (registry/list-instances registry/+default-registry "hello"))) => ()

wrap-mode clj

(wrap-mode f)

establishes how the computation is going to be run - :sync or :async

(def -a- ((wrap-mode (fn [inst args] inst)) {:mode :async :thread (volatile! nil)} []))

-a- => (contains {:mode :async, :result check/promise? :thread volatile?})

wrap-registry clj

(wrap-registry f)

updates the registry of the procedure

@((wrap-registry (fn [inst _] inst)) {:registry (state/cache {}) :name "hello" :id :1} []) => {}

wrap-timeout clj

(wrap-timeout f)

adds timeout to the procedure

@((procedure {:handler (fn [] (Thread/sleep 1000000)) :timeout 100} [])) => (throws java.lang.InterruptedException)

wrap-timing clj

(wrap-timing f)

adds timing to the instance (->> ((wrap-timing (fn [inst args] (Thread/sleep 100))) {:mode :async :runtime (atom {})} []) ((juxt #(-> % :ended :long) #(-> % :started :long))) (apply -)) => #(< 50 % 150)