clj-camel.core — com.dzer6/clj-camel 3.1.0

add-routes clj

(add-routes context & routes)

Adds route to the camel context

advice-with-route-builder clj macro

(advice-with-route-builder & body)

Creates an AdviceWithRouteBuilder

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-interval 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 body headers)

Sends an asynchronous body to the given endpoint

auto-startup clj

(auto-startup rd auto-startup)

Sets the auto startup property on this route

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

context-route-id-to-definition-map clj

(context-route-id-to-definition-map context)

Return route-id to route definition map.

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-jdbc-orphan-lock-aware-idempotent-repository clj

(create-jdbc-orphan-lock-aware-idempotent-repository
  datasource
  processor-name
  camel-context
  &
  [{:keys [lock-max-age-millis lock-keepalive-interval-millis]
    :or {lock-max-age-millis 30000 lock-keepalive-interval-millis 3000}}])

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

exchange-property clj

(exchange-property name)

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 :guard (partial instance? String)))

(from r (builder :guard (partial instance? EndpointConsumerBuilder)))

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

mock-endpoints clj

(mock-endpoints context route-id patterns & {:keys [skip] :or {skip false}})

Mock endpoints used in route-id in context by collection of patterns.

when skip passed as true, then exchanges found not be passed to endpoints consumers. when skip passed as false (default), then exchanges would reach the consumer.

mock-endpoints-and-skip clj

(mock-endpoints-and-skip context route-id patterns)

Mock endpoints matching the patterns collection and do not send exchanges to them.

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 opts & body)

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

on-exception clj macro

(on-exception pd exceptions & body)

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

route-non-initialized-error clj

(route-non-initialized-error route-id id->route-def)

route-policy clj

(route-policy rd & route-policies)

Configures route policies for the given 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)

set-property clj

(set-property pd & [name expr])

Adds a processor which sets the property 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'})) ...

stop clj

(stop pd)

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

stop-and-remove-route clj

(stop-and-remove-route camel-context route-id)

(stop-and-remove-route camel-context timeout time-unit route-id)

stop-route clj

(stop-route camel-context route-id)

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 :guard (partial instance? String)))

(to rd (builder :guard (partial instance? EndpointProducerBuilder)))

(to rd (uri :guard (partial instance? String)) (params :guard map?))

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

wire-tap clj

(wire-tap rd & [uri {:keys [id]}])

Sends a copy of the exchange to the given endpoint