Page History

Camel 3.0 Ideas

Camel is now almost 6 years old and its second revision camel-2.x is more than 4.5 years old already. Camel is extremely mature, used in production by a large number of organizations from small to large and even governments. We feel like we really hit the initial target of simplifying integration. Camel's middleware abstraction api and the eip based routing brought a lot of positive feedback from users.

...

JDK support

(+1: claus, cmueller, mattrpav)
(-1: hadrian)

We should drop support for JDK6, and require JDK7 as minimim version. eg build and compile the release with JDK7.
We should aim to be compatible with JDK8.
(hz) Why? Isn't OpenJDK 6 still supported by RedHat and very much in use? Even Oracle's Java 6 is still in use. Maybe some bundles would require JDK7+, buy why not keep things like the api for instance still supported with Java 6? A strong argument may sway my opinion, but for now, I fail to see the reason.

(mattrpav) Consider JDK8 as the base. By the time Camel 3 is stable and ready for wide-spread use, the transitive deps will have caught up. A number of suggestions below target JDK8 features, and all would require an "add-on" approach to maintain JDK7 backward compat. 

JDK8 Java DSL

It would be good to have a camel-java8-dsl component that offers a JDK8 DSL which uses all the nice new stuff from JDK8 with higher order functions, closures, et all.
Though this may comes later in Camel 3.x when JDK8 is GA.
At least stuff like Predicate, Expression, AggregationStrategy etc. are "functional interfaces" (containing only one method) and Java 8 applications can implement them using lambdas. That's only a start, but it doesn't require a specific DSL.

...

The proposal is to shift towards an iterative model, by redesigning the logic of Camel routing. The suggested model is defined by these pillars:

• A single class, or a limited set of them, contain the routing logic of Camel. Package name: org.apache.camel.core.routing. Central (abstract) class: RoutingCore. Concrete realisations could be: PipeliningRoutingCore, MulticastRoutingCore, depending on the fundamental routing pattern.
• The RoutingCore iteratively calls the routing steps, one after another. The routing steps return their result to the RoutingCore, who is in charge of calling the next element subsequently. OUT and IN are bridged if necessary (PipeliningRoutingCore).
• The Processor interface is crumbled up into its many specialisations, each of which represents a distinct concept of the Camel framework: RoutingDecider (EIPs should only take decisions about the routing, but not perform the routing itself, e.g. choice, filter, loop, throttle, etc.; see examples in subsection below.), Actions, ErrorHandler (already exists), Interceptor, etc.
• The RoutingCore is responsible of all the "magic" now disseminated across a number of processors. Assisted by Helper classes.

The goal of this idea isn't to zap off recursion altogether, just to consolidate the routing logic into a handful of cornerstone classes.

...

Converting some EIPs from "performers" to mere "deciders"

• choice() => evaluates the predicates and returns the List of Processors or Endpoints to invoke.
• filter() => same as choice(), but returning null if the filter doesn't match, to continue to the next routing step.
• loop() => evaluates whether the looping control predicate still stands. If yes, it returns the processors to invoke, where the last is itself (to trigger the looping logic again); else, it returns null to continue to the next routing step.
• throttle() => pauses accordingly and then returns the endpoint/processors to invoke.
• ...

Clearer Architecture of Camel Core

...

We should consider removing

• camel-bam
• camel-msv
• org.apache.camel.view from came-core

• dot maven generator

• ... (there could be other stuff to remove)

The BAM has not changed in 5 years, and very seldom used by end users. And neither has the functionality you need. There is much better solutions outside ASF Camel for a BAM solution.
The DOT generator is not up to date and maintained. Also it requires binary generator to generate a route diagram; we never managed to find a good java library for that.

...

We could consider adding DSL syntax sugar for scheduling routes. For example currently you have to use Quartz or a ScheduledPollingConsumer which has the delay option. We could add DSL which has something like:

schedule().every(5).minute().pollFrom("xxx").to("yyyy")

...

Unified statistics

-1: claus, mattrpav. We keep the JMX API and ppl can use jolokia for REST over JMX etc.

...

We already have REST support with CXFRS and Restlet but it can be better. We should make sure those components is dead easy to use and you can invoke REST services in one line of code etc. And we should make more examples and tidy up the CXFRS documentation.

More load tests (cmueller, +1 mattrpav)

More load tests for frequently used Camel components (jetty, jms ...) and camel-core. If we have an defined runtime environment which is in general accessable/available for all users (like a public image on Amazon EC2) and a data store for the performance numbers, than we could easily collect and share the numbers.

...

We should consider tighten up the onException DSL a bit, for example to make it more clear that if you have processing steps in there, they only occur after the message has been exhausted. So maybe we need to have a onExhausted to make this clear

onException(IOException.class).maximumRedeliveries(3)
  .onExhausted().handled(true).to("log:ignoreMe");

...

Also currently you can do this:

onException(IOException.class).maximumRedeliveries(3)
  .handled(true);

...

Note I'm not advocating XA here; I think the default for camel should be for Idempotent Consumer and simple approach to middleware

Add trace information to the Camel exceptions

If and exception occurs, it would be helpful if the exception contains trace information like the passed endpoints/processors and the current endpoint/processor. We may could also extend the error handler to log (or not) this information.
That make it much easier to dig into the problem when we encounter an exception.

Avoid throws Exception on end user API

Important: The org.apache.camel.Processor should stay as is. This API has been like this since the first commit, and we should let it be backwards compatible.

But there is a number of end user APIs such as Service, eg when you call start on a CamelContext. It would be better to have that not throws Exception but use runtime exceptions if failed to start etc.

An API which uses unchecked exceptions is the ProducerTemplate which end users uses. So its nice and easy to use.
Another example would be Main and MainSupport where the run method throws exception etc.
There is possible other end user APIs which we can make a bit more friendly.