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

add-routes clj

(add-routes context & routes)

Adds route to the camel context

aggregate clj macro

(aggregate pd expression strategy opts & body)

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-from-batch-consumer true :eager-check-completion true :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
                      use-exponential-backoff]}])

debug-exchange clj

(debug-exchange & [pd])

debug-exchange-log clj

(debug-exchange-log ex)

delay clj macro

(delay pd delay-in-ms & body)

Delayer EIP: Creates a delayer allowing you to delay the delivery of messages to some destination.

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') ...

end clj

(end pd)

Ends the current block

end-choice clj

(end-choice cd)

Ends the current choice

endpoint clj

(endpoint exchange uri)

Resolves the given name to an Endpoint of the specified type. If the name has a singleton endpoint registered, then the singleton is returned. Otherwise, a new Endpoint is created and registered in the EndpointRegistry.

enrich clj

(enrich pd & [uri f])

Enrich an exchange with additional data obtained from a resourceUri 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-expression clj

(header-expression name)

header-filter-strategy clj

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

idempotent-consumer clj macro

(idempotent-consumer pd msg-id opts & body)

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.

log-error clj

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

Creates a log message to be logged at ERROR level.

log-warn clj

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

Creates a log message to be logged at WARN 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}') ...

multicast clj macro

(multicast pd opts & body)

Multicast EIP: Multicasts messages to all its child outputs; so that each processor and destination gets a copy of the original message to avoid the processors interfering with each other. Options: parallel-processing - if true exchanges processed in parallel timeout - a total timeout specified in millis, when using parallel processing

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

on-when clj

(on-when pd p)

Sets an additional predicate that should be true before the onCompletion is triggered. To be used for fine grained controlling whether a completion callback should be invoked or not

otherwise clj macro

(otherwise cd & body)

Related to choice

poll-enrich clj

(poll-enrich pd & [uri])

Enrich an exchange with additional data obtained from a resourceUri using a org.apache.camel.PollingConsumer to poll the endpoint. Read more http://camel.apache.org/content-enricher.html

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

receive-no-wait clj

(receive-no-wait consumer uri)

Receives from the endpoint, not waiting for a response if non exists.

recipient-list clj macro

(recipient-list pd expr opts & body)

Creates a dynamic recipient list allowing you to route messages to a number of dynamically specified recipients Params: expr – expression to decide the destinations Options: parallel-processing - if true exchanges processed in parallel agg-strategy - aggregation strategy to use delimiter – a custom delimiter to use ignore-invalid-endpoints - if true ignores the invalidate endpoint exception when try to create a producer with that endpoint Read more https://camel.apache.org/components/latest/eips/recipientList-eip.html

remove-headers clj

(remove-headers rd & [pattern])

Remove headers that match the specified pattern

remove-route clj

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

Removes route from camel context

request-body-and-headers clj

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

Sends an synchronous body to the given endpoint

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

set-in-body clj

(set-in-body ex body)

set-in-header clj

(set-in-header ex k value)

set-in-headers-from-wrapper clj

(set-in-headers-from-wrapper ex wrapped-headers)

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'})) ...

stop clj

(stop pd)

Stops continue routing the current Exchange and marks it as completed.

stringify-key clj

(stringify-key k)

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

to-d clj

(to-d rd & [uri])

Sends the exchange to the given dynamic endpoint

type-converter clj macro

(type-converter & body)

Creates a type converter

unmarshal clj

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

Unmarshals the in body using the specified DataFormat

when clj macro

(when cd pred & body)

Related to choice