Direct component

The direct component calls another route synchronously, in the same thread, inside the same Cameleer process.

Scheme: direct: · Crate: cameleer-core · Cargo feature: none, always included (build features) · Consumer: yes · Producer: yes · Apache Camel: Direct

When to use it

• Split a long route into small named sub-routes (direct:validate, direct:enrich) and call them like functions.
• Share one piece of logic between several routes, for example one validation route used by a REST API and a Kafka consumer.
• Give tests and tools an entry point: send a message to direct:... with a producer template and read the reply.
• Expose a tool to an AI agent as a request/reply route: the caller blocks until the route returns its answer.

URI format

direct:name[?options]

name identifies the route that consumes from it. Only one route can consume from a given direct: name.

Example

- route:
    id: orders
    from:
      uri: direct:orders
      steps:
        - to: direct:validate
        - setBody:
            simple: "accepted ${body}"
- route:
    id: validate
    from:
      uri: direct:validate
      steps:
        - filter:
            simple: "${body} == ''"
            steps:
              - throwException:
                  exceptionType: java.lang.IllegalArgumentException
                  message: empty order
        - setHeader:
            name: validated
            constant: true

Sending o-1 to direct:orders returns accepted o-1. Sending an empty body fails the exchange with IllegalArgumentException, and the error travels back to the caller because the call is synchronous.

Rust DSL

use cameleer_core::prelude::*;

pub fn routes(ctx: &CamelContext) -> Result<()> {
    ctx.add_routes(|b| {
        b.from("direct:orders")
            .route_id("orders")
            .to("direct:validate")
            .set_body(simple("accepted ${body}"));
        b.from("direct:validate")
            .route_id("validate")
            .filter(simple("${body} == ''"))
            .throw_exception("java.lang.IllegalArgumentException", "empty order")
            .end()
            .set_header("validated", constant(true));
    })
}

Options

Message headers

The direct component does not add headers. Headers, properties and the body pass to the called route unchanged, and the called route's changes are visible to the caller.

Run it with Docker

docker run --rm -v "$PWD:/routes:ro" pmsudhi/cameleer run /routes/orders.camel.yaml

A direct: route only runs when something calls it, so combine it with a consumer such as timer, kafka or a REST endpoint in the same file.

Common questions

What is the difference between direct and seda?

direct runs the called route in the caller's thread and returns its result. seda puts the message on an in-memory queue and a different thread processes it later.

Why do I get DirectConsumerNotAvailableException?

No route consumes from that direct: name, or the route is stopped. Check the name for typos, or set failIfNoConsumers=false if dropping the message is acceptable.

Can I call a direct route in another Cameleer process?

No. direct works inside one process (one CamelContext). Use vm for other contexts in the same process, and a broker such as kafka or a network component between processes.

Related

• seda, vm: asynchronous in-process queues
• EIPs
• Apache Camel Direct component

Found a problem?

If something on this page doesn't match what Cameleer does, or you hit a bug while building with it, please help fix it, whether you are a person or a coding agent: open an issue that describes what you saw, then fork the repository, fix it, add or update a test, run cargo test --workspace, and open a pull request. CONTRIBUTING.md explains the ground rules.