clj-camel.core — takeoff/clj-camel 1.1.1

add-routes clj

(add-routes context & routes)

Adds route to the camel context

aggregate clj macro

(aggregate pd
           expression
           strategy
           &
           [{:keys [completion-size completion-timeout parallel-processing
                    completion-predicate]}])

The Aggregator from the EIP patterns allows you to combine a number of messages together into a single message. Read more https://camel.apache.org/components/latest/eips/aggregate-eip.html ... (c/set-body (c/constant 'test')) (c/aggregate (c/constant 1) c/grouped-body-strategy {:completion-size 1000 :completion-timeout 1000 :completion-predicate (c/predicate (fn [_] true))}) (c/to 'direct:result') ...

aggregator clj

(aggregator f)

Simple wrapper for aggregator strategy

async-request-body-and-headers clj

(async-request-body-and-headers producer-template endpoint-uri body headers)

Sends an asynchronous body to the given endpoint

body-expression clj

camel-context clj

(camel-context)

Creates the DefaultCamelContext.

choice clj macro

(choice pd & body)

The Content Based Router from the EIP patterns allows you to route messages to the correct destination based on the contents of the message exchanges. Read more https://camel.apache.org/components/latest/eips/choice-eip.html ... (c/choice (c/when (c/predicate (comp pos? :body)) (c/log 'when 1') (c/process some-processor)) (c/when (c/predicate (comp neg? :body)) (c/log 'when 2') (c/process some-processor)) (c/otherwise (c/log 'otherwise') (c/process some-processor))) (c/log 'after choice') ...

constant clj

(constant obj)

Creates constant expression eg. (c/set-body (c/constant 'x-token'))

convert-body-to clj

(convert-body-to rd & [clazz])

Converts the IN message body to the specified type

copy-body-to-header clj

(copy-body-to-header k)

Copies current body to header with specific key eg. (c/process (c/copy-body-to-header :body-data))

create-jdbc-idempotent-repository clj

(create-jdbc-idempotent-repository datasource processor-name)

Creates a new jdbc based repository

create-memory-idempotent-repository clj

(create-memory-idempotent-repository)

Creates a new memory based repository

dead-letter clj

(dead-letter r
             &
             [uri
              {:keys [add-exception-message-to-header maximum-redeliveries
                      redelivery-delay back-off-multiplier]}])

debug-exchange clj

(debug-exchange & [pd])

debug-exchange-log clj

(debug-exchange-log ex)

detect-error-type clj multimethod

do-catch clj macro

(do-catch try-def error & body)

Related to do-try macro

do-finally clj macro

(do-finally try-def & body)

Related to do-try macro

do-try clj macro

(do-try pd & body)

Try... Catch...Finally block Read more https://camel.apache.org/manual/latest/try-catch-finally.html ... (c/do-try (c/to 'http://test-http') (c/do-catch Exception (c/log 'handle exception') (c/log 'handle exception2')) (c/do-finally (c/log 'finally') (c/log 'finally2'))) (c/log 'after do-try') ...

enrich clj

(enrich pd & [uri f])

Enrich an exchange with additional data obtained from Read more http://camel.apache.org/content-enricher.html

filter clj macro

(filter pd predicate & body)

The Message Filter from the EIP patterns allows you to filter messages Read more https://camel.apache.org/components/latest/eips/filter-eip.html ... (c/route-builder (c/from 'direct:test') (c/route-id 'test-route') (c/to 'http://test-http') (c/filter (c/predicate (comp pos? :body)) (c/log 'Filtered ... ${body}') (c/to 'direct:result')) (c/process (fn [_] {:body 'after filter'}))) ...

filter-headers clj

(filter-headers headers header-name)

fn-name clj

(fn-name f)

Getting function name for processor id

from clj

(from r & [uri])

Creates a new route from the given URI input

get-endpoint-uri clj

(get-endpoint-uri ex)

Get endpoint URI

get-in-body clj

(get-in-body ex)

(get-in-body ex clazz)

get-in-header clj

(get-in-header ex k)

get-in-headers clj

(get-in-headers ex)

Useful for getting state inside processors

get-properties clj

(get-properties ex)

Useful for getting state inside processors

grouped-body-strategy clj

grouped-exchange-strategy clj

header-filter-strategy clj

(header-filter-strategy to-camel-headers to-external-headers)

idempotent-consumer clj

(idempotent-consumer pd msg-id & [repo])

The Idempotent Consumer from the EIP patterns is used to filter out duplicate messages. Read more https://camel.apache.org/components/latest/eips/idempotentConsumer-eip.html

json-path clj

(json-path obj)

Creates constant expression eg. (c/set-body (c/json-path '$.data'))

keyword->string clj

(keyword->string m)

Converting clojure keyword to string

• using dictionary
• as keyword string ':some-key' if not present in headers.clj

log clj

(log pd & [msg {:keys [id]}])

Creates a log message to be logged at INFO level.

marshal clj

(marshal pd & [data-format-definition])

Marshal the in body using the specified DataFormat

memoize clj macro

(memoize pd policy & body)

Create JCachePolicy interceptor around a route that caches the 'result of the route' Read more https://camel.apache.org/components/latest/jcache-component.html#_jcache_policy By default the message body at the beginning of the route is the cache key and the body at the end is the stored value.

... (c/set-body ${body.order-id}) (log 'order requested: ${body}') (c/memoize jcache-x-token-policy (log 'getting order with id: ${body}') (c/set-body (constant 'result-order'))) (log 'order found: ${body}') ...

on-completion clj macro

(on-completion pd & body)

Adds a hook that invoke this route as a callback when the Exchange has finished being processed.

on-prepare-failure-processor clj

otherwise clj macro

(otherwise cd & body)

Related to choice

predicate clj

(predicate f)

Evaluates a binary predicate on the message (headers, properties, body)

predicate-ex clj

(predicate-ex f)

Evaluates a binary predicate on the message exchange. Can be used for high load routes

process clj

(process pd & [f {:keys [id]}])

Adds the custom processor to this destination whichcould be a final destination, or could be a transformation in a pipeline

process-ex clj

(process-ex pd & [f {:keys [id]}])

Adds the custom processor to this destination which could be a final destination, or could be a transformation in a pipeline. Can be used for high load routes

processor clj

(processor f)

Simple wrapper of clojure function for applying Apache Camel processor interface for processing headers, properties, body

processor-ex clj

(processor-ex f)

Simple wrapper of clojure function for applying Apache Camel processor interface for processing Exchange

remove-route clj

(remove-route context & [route-id])

Removes route from camel context

route-builder clj macro

(route-builder & body)

Initialization single route

route-id clj

(route-id rd & [id])

Set the route id for this route

send-body-and-headers clj

(send-body-and-headers producer-template endpoint-uri body headers)

Sends the body to an endpoint with the specified headers and header values

set-body clj

(set-body processor-definition & [expr])

Adds a processor which sets the body on the IN message

set-header clj

(set-header pd & [name expr])

Adds a processor which sets the header on the IN message

simple clj

(simple text)

Creates simple expression eg. (c/idempotent-consumer (c/simple '${body}') (c/create-memory-idempotent-repository))

split clj macro

(split pd expr opts & body)

The Splitter from the EIP patterns allows you split a message into a number of pieces and process them individually. Read more https://camel.apache.org/components/latest/eips/split-eip.html ... (c/split (c/json-path '$.data.*') {:agg-strategy c/grouped-exchange-strategy :streaming true :parallel-processing true} (c/process (fn [] {}) {:id 'dummy-process-1'}) (c/to 'direct:result' {:id 'result'})) (c/process (fn [] {:body 'after'})) ...

sub-route clj

(sub-route named-node & [f])

Adds possibility to split big route to smallest part

throttle clj macro

(throttle pd
          requests-number
          &
          [{:keys [async-delayed reject-execution time-period-millis
                   executor-service-ref correlation-expression
                   caller-runs-when-rejected]}])

The Throttler Pattern allows you to ensure that a specific endpoint does not get overloaded, or that we don’t exceed an agreed SLA with some external service. Read more https://camel.apache.org/components/latest/eips/throttle-eip.html ... (c/set-body (c/constant 'test')) (c/throttle 20 {:async-delayed false :reject-execution false :time-period-millis 10000}) (c/to 'direct:result') ...

to clj

(to rd & [uri {:keys [id]}])

Sends the exchange to the given endpoint

type-converter clj macro

(type-converter & body)

Creates a type converter

unmarshall clj

(unmarshall pd & [data-format-definition])

Unmarshals the in body using the specified DataFormat

when clj macro

(when cd pred & body)

Related to choice