Back
error-handler (clj)
(source)function
(error-handler a)
Returns the error-handler of agent a, or nil if there is none.
See set-error-handler!
Examples
fulcrologic/fulcro
(ns fulcro-todomvc.server
(:require
[com.fulcrologic.fulcro.mutations :as m :refer [defmutation]]
[clojure.core.async :as async]
[com.wsscode.pathom.core :as p]
[com.wsscode.pathom.connect :as pc]
[taoensso.timbre :as log]))
;; setup for a given connect system
(def parser
(p/parallel-parser
{::p/env {::p/reader [p/map-reader
pc/parallel-reader
pc/open-ident-reader
p/env-placeholder-reader]}
::p/mutate pc/mutate-async
::p/plugins [(pc/connect-plugin {::pc/register my-resolvers})
(p/post-process-parser-plugin p/elide-not-found)
p/error-handler-plugin]}))
wilkerlucio/pathom
(ns com.wsscode.pathom.book.tracing.demo-parallel-reader
(:require [clojure.core.async :as async]
[com.wsscode.common.async-cljs :refer [go-catch <?]]
[com.wsscode.pathom.connect :as pc]
[com.wsscode.pathom.core :as p]))
(def parser
(p/parallel-parser
{::p/env {::p/reader [p/map-reader
pc/parallel-reader
pc/open-ident-reader
p/env-placeholder-reader]
::p/placeholder-prefixes #{">"}}
::p/mutate pc/mutate-async
::p/plugins [(pc/connect-plugin {::pc/register app-registry})
p/error-handler-plugin
p/trace-plugin]}))
mhuebert/maria
(ns cells.cell
(:refer-clojure :exclude [bound-fn get])
(:require [clojure.core :as core]
[cells.util :as util]
[applied-science.js-interop :as j]))
(defmacro bound-fn
"Returns an anonymous function which will evaluate in the context of the current cell
(useful for handling async-state)"
[& body]
`(let [cell# ~'cells.cell/*self*
error-handler# ~'cells.cell/*error-handler*]
(fn [& args#]
(binding [~'cells.cell/*self* cell#
~'cells.cell/*error-handler* error-handler#]
(try (apply (fn ~@body) args#)
(catch ~'js/Error e#
(~'cells.cell/error! cell# e#)))))))
typedclojure/typedclojure
(ns ^:no-doc typed.ann.clojure
"Type annotations for the base Clojure distribution."
#?(:cljs (:require-macros [typed.ann-macros.clojure :as macros]))
(:require [clojure.core :as cc]
[typed.clojure :as t]
#?(:clj [typed.ann-macros.clojure :as macros])
#?(:clj typed.ann.clojure.jvm) ;; jvm annotations
#?(:clj clojure.core.typed))
#?(:clj
(:import (clojure.lang PersistentHashSet PersistentList
APersistentMap #_IPersistentCollection
#_ITransientSet
IRef)
(java.util Comparator Collection))))
#?@(:cljs [] :default [
cc/get-thread-bindings [:-> (t/Map t/AnyVar t/Any)]
cc/bound-fn*
(t/All [r b :..]
[[b :.. b :-> r] :-> [b :.. b :-> r]])
cc/find-var
[t/Sym :-> (t/Nilable t/AnyVar)]
cc/agent
(t/All [x] [x & :optional {:validator (t/Nilable [x :-> t/Any]) :meta t/Any
:error-handler (t/Nilable [(t/Agent x) Throwable :-> t/Any])
:error-mode (t/U ':continue ':fail)}
:-> (t/Agent x)])
cc/set-agent-send-executor! [java.util.concurrent.ExecutorService :-> t/Any]
cc/set-agent-send-off-executor! [java.util.concurrent.ExecutorService :-> t/Any]
cc/send-via (t/All [x b :..] [(t/Agent x) [x b :.. b :-> x] b :.. b :-> (t/Agent x)])
cc/send (t/All [x b :..] [(t/Agent x) [x b :.. b :-> x] b :.. b :-> (t/Agent x)])
cc/send-off (t/All [x b :..] [(t/Agent x) [x b :.. b :-> x] b :.. b :-> (t/Agent x)])
cc/await [t/AnyAgent :* :-> nil]
cc/await-for [t/AnyInteger t/AnyAgent :* :-> t/Bool]
cc/await1 (t/All [[a :< t/AnyAgent]] [a :-> (t/Nilable a)])
cc/release-pending-sends [:-> t/AnyInteger]
])
#?@(:cljs [] :default [
cc/agent-error [t/AnyAgent :-> (t/Nilable Throwable)]
cc/restart-agent (t/All [x] [(t/Agent x) x & :optional {:clear-actions t/Any} :-> t/Any])
cc/set-error-handler! (t/All [x] [(t/Agent x) [(t/Agent x) Throwable :-> t/Any] :-> t/Any])
cc/error-handler (t/All [[a :< t/AnyAgent]] [a :-> (t/Nilable [a Throwable :-> t/Any])])
cc/set-error-mode! [t/AnyAgent (t/U ':fail ':continue) :-> t/Any]
cc/error-mode [t/AnyAgent :-> t/Any]
cc/agent-errors [t/AnyAgent :-> (t/Nilable (t/ASeq Throwable))]
cc/clear-agent-errors [t/AnyAgent :-> t/Any]
cc/shutdown-agents [:-> t/Any]
])
funcool/catacumba
(ns catacumba.tests.test-core
(:require [clojure.core.async :as a]
[clojure.test :refer :all]
[clojure.java.io :as io]
[clojure.pprint :refer [pprint]]
[beicon.core :as rx]
[clj-http.client :as client]
[promesa.core :as p]
[cuerdas.core :as str]
[manifold.stream :as ms]
[manifold.deferred :as md]
[catacumba.core :as ct]
[catacumba.http :as http]
[catacumba.testing :refer [with-server]]
[catacumba.tests.helpers :as th]
[catacumba.handlers.misc])
(:import ratpack.exec.Execution
ratpack.func.Action
ratpack.func.Block
ratpack.exec.ExecInterceptor
ratpack.exec.ExecInterceptor$ExecType
java.io.ByteArrayInputStream))
(testing "User defined error handler"
(let [error-handler (fn [ctx error] (http/ok "no error"))
handler (fn [ctx] (throw (Exception. "foobar")))
router (ct/routes [[:error error-handler]
[:any handler]])]
(with-server {:handler router}
(let [response (th/get "/")]
(is (= (:body response) "no error"))
(is (= (:status response) 200))))))
(testing "User defined error handler"
(let [error-handler1 (fn [ctx error] (http/ok "no error1"))
error-handler2 (fn [ctx error] (http/ok "no error2"))
handler (fn [ctx] (throw (Exception. "foobar")))
router (ct/routes [[:prefix "foo"
[:error error-handler1]
[:any handler]]
[:prefix "bar"
[:error error-handler2]
[:any handler]]])]
(with-server {:handler router}
(let [response1 (client/get (str base-url "/foo"))
response2 (client/get (str base-url "/bar"))]
(is (= (:body response1) "no error1"))
(is (= (:body response2) "no error2"))
(is (= (:status response1) 200))
(is (= (:status response2) 200))))))