Get the body of the msg, a Message.

See in and out for getting the Message out of an Exchange.

Type conversions. If clazz is provided use a type converter to cast it to clazz. Throws NoTypeConversionAvailableException if conversion fails because the type converter isn’t in the registry. Throws TypeConversionException if the conversion itself fails.

Uses the context of the exchange of msg. If msg has no exchange and context then the DefaultCamelcontext is used.

;; read from a direct exchange, get the in part of the exchange,
;; get the body, serialize to json using Cheshire, get :foo from the dict 
;; and print
(route (from "direct:hello")                   
       (process                                  
         (fn [x] (->> (in x)                   
                      body
                      cheshire.core/parse-string 
                      :foo                       
                      println))))                

Create an exchange on context on. Can set in as the In message. If third arg is truthy, set the exchange pattern as InOut. See message and reply.

on can be either a context, another exchange or an endpoint.

(body (in (exchange ctx (message "hi"))))
;; => "hi"

(out-capable? (exchange ctx (message "hi") :out))
;; => true

Fail the exchange because of reason. reason can be a string or exception/throwable.

Has the exchange failed (its exception is non-nil) or any of its messages faulted? See also fault?.

Fault the message.

Has the message faulted?

Get the headers of msg as a map.

Get the message id of msg.

With 1 arg, get the body of the In part of an InOut exchange x.

Create a Message, with body String as the body. Optionally with :headers (map) as the headers, and :id as the message id.

With 1 arg, get the body of the Out part of an InOut exchange x.

If the Exchange in x is an InOut exchange or not.

Reply successfully to an exchange with body. body can be a String message or a Message. If body is string it is converted into to a Message and the optional headers are inserted as the message headers and :id as the message ID. If body is already a Message its headers and id will be unaltered. See message and request-body.

Note. Reply works only on an InOut Exchange. Does nothing if exchange is InOnly.

(route 
   (from "vm:lol")
   (process (fn [x] (reply x "haha")))

(request-body ctx "vm:lol" "hi")
;; => "haha"

Synchronously send to endpoint and expect a reply, returns the reply.

Send body (String) to endpoint using the InOut pattern. Optionally send headers in headers.

(route (from "direct:foo")
       (process (fn [x] (reply x "Is it African or European?"))))

;; start the route, add to context, etc.

(request-body ctx "direct:foo" "How much weight can an unladen swallow carry?")
;; => "Is it African or European?"

Synchronously send body as message to endpoint.

Sends body (String) to endpoint. Optionally add headers in headers.

Set the body of msg to body.

Set the In part of an exchange to m.

Set the Out part of an exchange to m. No-op on InOnly exchanges.