Claus Ibsen (@davsclaus) riding the Apache Camel

Webinar on May 16th 2013 - Using Apache Camel connectors for external connectivity

2013-05-13T15:57:00.001+02:00

I have the pleasure of speaking at a webinar on thursday focusing on Apache Camel components.

Webinar about Apache Camel components

Any integration requires connectivity to applications, services, or databases. Connectivity could be a file drop via FTPor sFTP, a JDBC call to a database, or a webService call to an application. Apache Camel comes with 100+s Camel components or connectors that enable this functionality.

To archive that Apache Camel comes with 130+ components out of the box, ready for you to use. In this webinar we take a look at some of the popular components, as well how you can write your custom components.

The webinar is a mix between slides and live demonstration. The session is scheduled for one hour, where we leave about 10 minutes at the end for Q and A.

Register for this webinar and learn how:

Apache Camel speeds connectivity.
To use Apache Camel components to create faster integration solutions.
To build custom Camel components.

When
Thursday, May 16, 2013 at:

15:00 UTC
11:00 am (New York)
4:00 pm (Paris)
8:30 pm (Mumbai)

How to register
The webinar is free and you can register for the event from this link.

Video recordings (in Danish) from my latest getting started with Apache Camel presentation

2013-05-10T10:31:00.001+02:00

Last week I visited Århus, Denmark to give a presentation about Apache Camel. This event was organized by JavaGruppen, and OpenMinds was kind to host the event, in their beautiful office centrally located in Århus.

Thanks to Thomas Salling whom was so kind to pick me up at the train station, I arrived safely and in time for the event.

Claus presenting Apache Camel at Javagruppen meeting in Århus, Denmark - Photo by Søren Glasius

At the event we had a great turnup, of about 25 people. And we were almost out of free chairs, and space in the room, as you can see from the photos.

Attendees at the event - Photo by Søren Glasius

After the event we went for beers at Sct. Clements which is a brewery inside the restaurant.

Having beers at Sct Clemens after the event.

My presentation was 2 hours and with a mix of slides and live demonstrations. And as well taking in questions. We had a 10 minutes break at the one hour mark. Giving such a long presentation is of course a challenge. The response from the attendees was positive and they didn't get bored etc. And we had about 2/3 of the attendees whom didn't know about Apache Camel.

I also had the pleasure of meeting with two former colleagues whom I haven't seen in over 10 years. It was great to see you Michael and Simon.

Søren Berg Glasius, whom is known in the Groovy and Grails communities is head of organizing the GR8Conf conferences. The next GR8Conf takes place in a couple of weeks in Copenhagen, Denmark. So he is testing his video and presentation equipment, so we used this opportunity to video tape my entire presentation. Unfortunately there was some problems with the HDMI connection so we had to settle for VGA. But the end result is still very great. The video features both the slides and the camera feed in the same picture. This makes it very easy to follow the presentation.

Soren was so kind to invite me as a guest to the GR8Conf, so I will drop by in Copenhagen on the 23rd of March. Looking forward to see how far the Groovy and Grails have reached. We do see more and more people use Grails and Camel. Likewise the gradle build system seems to be cool as well.

The videos of the presentation is already online and you can find them here.
And the slides is also uploaded to slideshare here.

Thanks to Javagruppen and OpenMinds for hosting such a great event. I had a great time visiting Århus.

Apache Camel 2.11 released

2013-04-29T10:18:00.000+02:00

Last week Apache Camel 2.11 was released.

Apache Camel 2.11 has been released

This blog post is a summary of the most noticeable new features and improvements.
For a detailed description, see the Camel 2.11 release notes.

1) New components
As usual each new release contains a number of new components, contributed by our large user base. Thanks guys.

For example there is camel-cmis which allows to integrate with content management systems, such as Alfresco, or any of the systems supported by Apache Chemistry, which is what we use in camel-cmis.

We also got a new camel-couchdb for integrating with our fellow Apache CouchDB project.

Also very exiting is the new camel-elasticsearch component, to integrate with the excellent elastichsearch project.

In the hawt new project hawtio we are also working on some great new stuff with elastichsearch around log aggregation and analytics, with a shiny HTML5 graphical user interface using Kibana. If you haven't see hawtio yet, then make sure to check it out.

Then James Strachan created the new camel-rx component, for integrating Camel beautifully, as Eric Maijer said, with the fantastic Netflix port of Reative Extensions (RX) library. And when we got Java8 as well, this is going to rock.

Then I created the new camel-servletlistener component to allow bootstrapping Apache Camel applications in web applications with no other dependencies. Usually people would need to use Spring or other library to do this. To demonstrate this in example, we have a new servlet-tomcat-no-spring example. As well my blog entry - Camel web applications without Spring, earlier this year about this new functionality. For the upcoming Camel 2.12 we will work on an alternative example using the new blueprint-web module that allows Spring XML like configurations but with only two JARs as dependencies (blueprint-noosgi, blueprint-web). This works beautifully, and we already use it hawtio project to easily bootstrap hawtio web application from a blueprint XML file.

Scott Sullivan stepped up and created the new camel-sjms component for a light-weight JMS component which only depends on the JMS API. This component is expected to be further improved and hardened in the upcoming releases. The camel-sjms component is not a 1 to 1 replacement for the existing camel-jms component. They are two independent components. We want the freedom in camel-sjms to implement the functionality we think is best needed, and as well to avoid the many many options that Spring JMS exposes, and hence creeped into camel-jms as well.

We also have a new component for integration with Redis with the camel-spring-redis component.

And last year I created the camel-urlrewrite component, which allows people to do Camel routes for proxying HTTP services with URL rewrites. I have previously blogged about this as well.

We also created a new control bus component, which allows you to send messages to a control-bus endpoint to control routes. This may make it easier for people to start/stop their Camel routes. This component is expected to be improved in the future, so you for example can get performance statistics and other information as well.

2) SQL component can now consume as well
The SQL component has been improved, so you can now consume as well. This allows you to pickup new data from table(s) and route the data in Camel routes. This is best illustrated by the new camel-example-sql that we created. Oh and we also added support for using named parameters in the SQL queries.

3) Groovy DSL
The Groovy DSL in Camel has been totally overhauled, thanks to community contributions. The DSL is now fully up to date and uses the Groovy'sh style that makes it much more Groovy like. We also added a new Camel Maven Archetype to create a new Camel groovy project.

4) CDI improvements
In the earlier phase of development of Camel 2.11 we worked on improving the camel-cdi component.
We are not there yet but its a big step in the right direction. We are also waiting a bit for Apache DeltaSpike project to do new releases so we can finish the last pieces. So expect this to be improved in upcoming releases as well.

5) camel-netty scales better
We also worked on improving the camel-netty component to be faster. Most noticeable the netty producer that now pools channels for reuse.

6) JAXB controlling namespace prefixes
For people stuck in XML land and using JAXB, then we made it easier to control namespace prefixes, so you 100% can control the prefix names in use. This allows to conform the XML to a naming style, or if you must use a specific prefix name; usually if a legacy system expects prefix names to be hardcoded.

7) Guice 3.0
People who are fan of Guice, would be glad to hear we have upgraded camel-guice to use Guice 3.0 as is. The old guicyfruit dependency, which was needed when using Guice 1.x is now gone.

8) Backlog tracer
We introduced a new backlog tracer, which allows tooling to trace Camel messages at runtime, on-demand. There is new camel-backlog-tracer command(s) for Apache Karaf / ServiceMix, which allows you to trace messages on your running Camel applications at runtime. You can even enable a predicate filter, to only trace matched messages etc.

9) OSGi upgrades
Apache Camel 2.11 now requires OSGi 4.3 and Apache Aries 1.0 if you use the camel-blueprint component. This means that you should use Apache Karaf 2.3 or better as the container.

10) Miscellanies
We have improved the startup of Apache Camel a bit, as well the simple language is now faster when invoking OGNL like expressions. And we disabled the type converter utilization statistics as there is a slight performance impact under heavy load. And we managed to let the camel-jms component re-create temporary queues when doing request/reply over JMS with temporary queues, and the connection has been re-connected (eg automatic self-heal). The camel-cxfrs component has a simpler binding, making it easier to use.

And as usual we have a ton of bug fixes, minor improvements and new features. See the release notes for full details.

Apache Camel 2.11 is available for download from the Apache web site, and Maven users can get it from maven central.

The Camel team is now busy working on Apache Camel 2.12, where we have some exiting new work on improved documentations for Camel components.

Apache Camel web dashboard with hawtio

2013-04-19T11:11:00.000+02:00

I have been waiting patiently for James Strachan to write a blog to introduce us to his latest project - hawtio. This project surely has the potential to become as great or even greater than Apache Camel.

In a one liner, hawtio is:

hawtio is a lightweight and modular HTML5 web console for managing your Java stuff.

Today James is busy doing the release of the hawtio 1.1. This is a very hawt release, that has great functionality already, so we should start spread the word about this project. We have also talked about doing small videos, as recoding what you do in a web browser is easy.

Anyway this blog entry today of mine, is not to steal the thunder from James. I would let him do the introduction of hawtio, and his vision for creating this project.

So in hawtio we have a Camel plugin, that allows you to gain insight into your running Camel applications. So the screenshot below is from hawtio running as a plain web application deployed to JBoss AS 7.1.1. You can use any web container of choice, such as Tomcat, Jetty etc. Though I was tasked to give the JBoss AS a little test spin, and thus had the opportunity to take a screenshot. I have also deployed the Apache Camel example camel-example-servlet-tomcat in the container (its also just a WAR application).

Dashboard in hawtio, with a live Camel diagram and table, updating in real time.

hawtio allows you to create custom dashboards, where you can add any part of a view to the dashboard, and position the views as you please. So I created a Camel dashboard, which has a live diagram of the route from the camel-example-servlet-tomcat. As well a table with the running routes and their state and some key metrics. All the data on the dashboard updates in real time, which is very cool.

And the dashboards can be saved to a git repository, and you can share them with your team. And as its just a URL you can easily access the dashboard, by just copying the url from the browser address bar.

Anyway hawtio has a lot more cool stuff already. And we are having fun hacking on it. Its of course a 100% open source project, ASL licensed, and hosted at github. Everybody is welcome to contribute and hack on it.

Stay tuned, more blogs and videos should be coming in the future.

Slides from Apache Camel presentation in Copenhagen

2013-04-12T08:53:00.000+02:00

Yesterday I gave an Apache Camel presentation in Copenhagen, at the Javagruppen event.
As promised I have uploaded the slides to slideshare, which you can find here.

Next stop is a presentation in Gothenburg, Sweden on April 23, and followed by Århus, Denmark on May 7th. And a stop in Odense, Denmark is currently being planned.

Upcoming Apache Camel meetings in Copenhagen, and Gothenburg

2013-04-02T11:21:00.002+02:00

I previously blogged about upcoming Apache Camel events in Malmo and Copenhagen.
I had a great time at the Malmo JUG. And thanks to the beer sponsor TT (Three Towns) we had a great and cosy event. It was my first time giving a presentation with a beer in my hand.

My first talk with a beer in hand - Photo (c) FooCafe

I now have confirmation for the event in Copenhagen on April 11th is confirmed and will happen.
You can find details about this event, such as location and time, and how to register at JavaGruppens site at this link.

My presentation will be in English, and include some live demos as well, so at the end of the day, when you get back, you should be able to get started with Camel yourselves. Nineconsult has been so kind of hosting this event - thanks guys.

There is also time for Q and A, so power users of Camel is of course also welcome. We are very keen on hearing your feedback. And discuss the project, and what we can do better, and what lies down the roadmap etc.

Also we have time to check out the cool new web console project we are working on as well - hawtio. That is seriously cool stuff.

The JUG in Gothenburg have reach out to me, to discuss a Camel event on April 23rd. We are currently working out the details - I will post details when I know more about this event.

Upcoming Apache Camel presentations in Malmo and Copenhagen

2013-03-25T09:36:00.001+01:00

There is a couple of events coming up here in Malmo and Copenhagen which involves Apache Camel presentations.

Tomorrow I am presenting "Getting started with Apache Camel" at the Malmo JUG. The event opens at 17:00 pm, and my presentation starts at 17:35. Then we have a presentation about JavaScript and Android development, and followed on by talk on continues integration. Sounds like a great evening with a mix of great talks. And after that we go for beers. So its a great opportunity to learn and meet interesting people working in the industry.

The event is free, and there should be a few more seats available. You can register for the event and read more about the presentations here - http://www.javaforum.se/jf/?meeting=99

The event takes place at Foo Cafe which is not so far from the central station in Malmo.

JavaGruppen Denmark is planning an Apache Camel event on April 11th in Copenhagen. The planning is still in early stages and as I understand it's an after hour event where I will give a talk on Apache Camel, and then followed on by 1 or 2 talks from people who are using Apache Camel in their organization, and share their experience - both good and the bad.

I will be back when I have more details about the event in Copenhagen.

Today 6 years ago Apache Camel was created

2013-03-19T11:06:00.001+01:00

On Monday, March 19th 2007, James Strachan did the first commit what became Apache Camel. The commit log entry is here.

James Strachan founded the Apache Camel project with this first commit 6 years ago

Even in the first commit, todays users of the latest Apache Camel releases, can see the structure of the route builder, and the API with the component, endpoint, exchange, producer, consumer et all.

You can take a look in this unit test from the first commit.

Though here is a teaser with the RouteBuilder from the first commit

RouteBuilder builder = new RouteBuilder() {
public void configure() {
from("seda://a").to("seda://b");
}
};

And the content based router was already included. Though today the headerEquals predicate has been slightly changes to header("foo").isEqualTo("bar") instead.

RouteBuilder builder = new RouteBuilder() {
public void configure() {
from("seda://a").choice()
.when(headerEquals("foo", "bar")).to("seda://b")
.when(headerEquals("foo", "cheese")).to("seda://c")
.otherwise().to("seda://d");
}
};

In summer 2007 Apache Camel 1.0 was released, and that was a very impressive first release, which I previously have blogged about.

Today 6 years later, we have done 13677 commits on trunk (37 different committers), accordingly to the Apache Camel git commit log (git log --oneline | wc -l).

... and yeah we are closing in on the anticipated Apache Camel 2.11 release (likely being GA in next month).

CamelOne 2013 - Call For Paper

2013-02-28T15:01:00.001+01:00

CamelOne is happening this year as well, so its the 3rd consecutive conference all about open source integration and messaging, where Apache Camel is the star of the show.

CamelOne 2013 - We are calling for papers

The conference takes place yet again in the United States in Boston MA in june 2013.

If you have topics for talks then we are calling for papers. You can submit your proposals here.

If you are not familiar with CamelOne, then you can get a flavor of the conference, by viewing last years sessions here (registration required) and/or check out some photos from last year as well.

The conference website is online here.

Camel in Action - 2 years later

2013-01-12T11:59:00.000+01:00

Two years ago the Camel in Action book was done and published.

Camel in Action, published January 2011

So when we started the journey of the book we knew we had once shot of getting this right. So Jonathan and I went all in, and worked our socks off to deliver a quality book, that do justice to the fantastic project that Apache Camel is.

So with all the hard work Jonathan and I put into it, what did we get from this? Well it was not really about the money, as that can't cover cost of living. Though to treat myself good I purchased a coffee machine - which I still enjoy using ever day; the coffee tast really good.

The community liked the book and have gotten good reviews. Looking today at the Amazon site, we have 10 top-mark reviews. The last review is as late as December 26th 2012, so people are still finding this book useful.

Ten 5-star customer reviews of the Camel in Action book from Amazon

The book seems to go well over the years, for example the last quarterly sales figures I have (Q2 2012), the book sold 701 units.

As previous said, Jonathan and I, went all in with this book. So after the book was published, we have keep to our toes, and ensured that we keep the following up to date:

Sidenote: As a reader of other books, this is not always the case, where the authors have this devotion to their book. As a reader I fell disappointed to get started with a book, and the source code is outdated, and don't compile/work anymore. Or that mistakes in the book is not pointed out in an errata. And when I want to interact with the authors, they are not responsive on the official book forum.

When our readers find a mistake in the book, they report that to us on the book forum, or by sending private emails. We then take a look, and if there is a mistake, make sure to get the errata updated, and submit that to Manning; whom them publish the update on the book site. For example the last errata update is from July 2012.

Over the years since the book was published, we have released new versions of Apache Camel. So as a courtesy to new readers we are keeping the books source code in sync with the Camel releases. We only missed the Camel 2.6.0 release which was the 1st release after the book was published. So today we have 13 updates to the source code available for our readers.

Source code for the Camel in Action book, updated with the following Apache Camel releases.

The source code for the book has also been useful to the Camel team. So every time we are working on a new release, we run that release against the source code of the book, to test for any regressions etc. Over the time we have actually found a number of bugs, which we could fix before cutting the release.

So what's next? Well thats a story for another blog entry, if/when that story starts...

Camel 2.11 - Camel web applications without Spring

2013-01-04T15:34:00.000+01:00

So today we are in the year of 2013.

And as I write this we have just added a new component to the upcoming Apache Camel 2.11, that allow to run web applications with Camel without having to rely on Spring Framework to boostrap Camel. Or any other 3rd party frameworks for that matter.

A bit ashamed to say that in the year 2013 we are a bit late to the party to offer this out of the box in Apache Camel.

In modern web containers supporting Servlet 3.0 spec. you can programmatically bootstrap your code using the new @WebListener annotation. But even so there is still work to be done, as you would need to setup and configure Camel, and as well ensure resources is unregistered and stopped when stopping the web application.

I have not found a neat way of using @WebListener and allowing external configuration of your framework such as Apache Camel. I dont really want to hardcode my configuration, or have to invent my own way of loading external configuration and configure my application. Anyone know of a solution to this problem?

Anyway we also wanted a solution that works for old school Servlet 2.x based container. There is a ton of them out there running. And even so the old school configuration with a web.xml file works just as good in the newer Servlet 3.0 containers. So we wanted an out of the box solution that fit both worlds.

Example to showcase

We have a number of examples at Apache Camel, and one is a simple web application that is ready to be deployed as a .war file in Apache Tomcat, or any other web container.

This example is using the Spring Framework to boostrap a Spring XML file, where we have Camel embedded. So what we did was to redo this example without the need for Spring.

The two examples is documented at the Apache Camel site at:

CamelServletContextListener

In Camel 2.11 we have a new component named camel-servletlistener, which offers a new CamelServletContextListener class which you configure in the web.xml file. This will then boostrap a CamelContext, and use the context init parameters as its configuration.

This context listener has a lot of configuration, so you can easily configure Camel to your needs.
The options is listed in the Camel docs at: http://camel.apache.org/servletlistener-component.html

And in case you need to execute any custom logic when Camel is starting/stopping then we have an API for that, a CamelContextLifecycle interface. There is more details and examples at the Camel docs.

To see this in action, I suggest after reading this blog, check out the new example, as well the documentation for the camel-servletlistener component.

Dissecting the example

Having the two examples

We can take a peak at the difference between the two of them, when deploying to fresh installation of Apache Tomcat 7.0.30 using Java 1.6.

servlet-tomcat-example

size: 5.8 MB

jars: 19

classes loaded: 4507

current heap size: 10 MB

servlet-tomcat-no-spring-example

size: 2.9 MB

jars: 10

classes loaded: 3698

current heap size: 8 MB

I used jconsole to look at the number of loaded classes in the JVM with the Apache Tomcat and the deployed example. The heap size was measured as the lowest value I could get after performing GC.

So we cut 10 JARs and 3MB from the distribution. As well avoid loading in the shy of 1000 classes.

Remarks

I just want to emphasize that the goal of this new camel-servletlistener component is to allow people to easily bootstrap their Camel applications in any web container, without the need to be tied to any particular 3rd party framework such as Spring. The Apache Camel project aims to be neutral and agnostic; allowing people to run Camel in any way and container of choice.

Camel 2.11 - HTTP proxy routes with url rewriting functionality

2012-12-29T12:49:00.002+01:00

In the upcoming Apache Camel 2.11 release I have recently added support for plugging in custom url rewrite implementations to HTTP based routes (http, http4, jetty). This allows people to control the url mappings, when you use Camel to proxy/bridge HTTP routes.

For example suppose you need to proxy a legacy HTTP service and plugin a strategy for mapping the urls. This is now much easier with Camel 2.11. There is a new option urlRewrite added to the various HTTP components, to plugin a custom url rewriter.

For example having a http proxy route as shown, where we use the new urlRewrite option on the http producer endpoint.

from("jetty:http://localhost:{{port}}/myapp?matchOnUriPrefix=true")
.to("jetty:http://somewhere:{{port2}}/myapp2?bridgeEndpoint=true&throwExceptionOnFailure=false&urlRewrite=#myRewrite");

In a nutshell you can implement a custom strategy by implementing the UrlRewrite interface, as shown below. As this is from an unit test, we just replace yahoo to google in the url (yes its not a real-life applicable example).

public class GoogleUrlRewrite implements UrlRewrite {

@Override
public String rewrite(String url, String relativeUrl, Producer producer) {
return url.replaceAll("yahoo", "google");
}
}

In the rewrite method Camel provides you with the absolute url (eg including scheme:host:port/path?query) or a relative url which is the offset from the uri configured in the route (see further below).

However it all gives you the full power to control the url mappings, and even return a new absolute url. If you return null, then the default strategy is used, which is a 1:1 url mapping.

That is not all there is also a new component

Introducing the new camel-urlrewrite component

The new camel-urlrewrite component is a implementation of the new url rewrite plugin based on the UrlRewriteFilter project. This project has strong support for specifying your rewrite strategies as rules, and have its engine evaluate the rules.

For example we can have N+ rules in the url rewrite XML configuration file. In the example below we have a rule to rewrite urls to adapt to a legacy system which is using JSP.

<urlrewrite>

  <rule>
  <from>/products/([0-9]+)</from>
  <to>/products/index.jsp?product_id=$1</to>
  </rule>

</urlrewrite>

This project has even support for Apache mod_rewrite styles which allow you to define rules as you would do with the Apache HTTP server. Though if you are not familiar with the mod_rewrite style then its dense and takes some time to understand - but very powerful.

All this is documented at the camel-urlrewrite component page with examples. And if you want to look for more, then checking the unit tests source code is also a good way to learn more.

I encourage you to take a look at the new camel-urlrewrite page as it has full examples and more details, that what I have outlined in this short blog.

Happy new-year and see you in 2013.

Interview with me in Danish IT magazine

2012-11-28T14:07:00.001+01:00

A month ago I was interviewed for the Danish IT magazine Prosabladet. Today the magazine is online.

Image from Prosa magazine December 2012.

Though non Danish readers can enjoy the photo above which my wife Christina took. Its from my home office, with our dog Bambi on the lap. Bambi is my trusty companion at work every day in the office.

The article is online in Prosa December 2012 magazine at page 30.

I would like to thank Dan Mygind for the interview. It was a pleasure to talk with him for 1.5 - 2 hours, despite the target was 30 minutes. Yeah I guess I like to talk :)

As part of the interview I was asked to pick a comedy from xkcd, and among the many great ones, I chose this one - the license plate.

Camel is back in Akka 2.1

2012-11-27T15:44:00.001+01:00

When the Akka project was in its early days, Martin Krasser (@mrt1nz), developed what became the akka-camel module, to integrate these two marvelous projects.

Since then years has passed, and its great to see that the Akka community have stepped up and have more people leading the akka-camel module. So thanks to Raymond Roestenburg (co-author of Akka in Action) and Piotr Gabryanczyk (@piotrga) the akka-camel module is fully up to date, and top-notch ready for the Akka 2.1 release.

You can read more details from a recent blog post on let it crash.

Webinar - Building superior integrated applications with open source Apache Camel

2012-10-29T11:08:00.000+01:00

I am scheduled to host a free webinar on building integrated applications using Apache Camel.

Date: November 6th, 2012 (moved due Sandy hurricane)
Time: 3:00 PM (Central European Time) - 10:00 AM (EDT)
Duration: 1h15m

This webinar will show you how to build integrated applications with open source Apache Camel. Camel is one of the most frequently downloaded projects, and it is changing the way teams approach integration. The webinar will start with the basics, continue with examples and how to get started, and conclude with live demo. We will cover

Enterprise Integration Patterns
Domain Specific Languages
Maven and Eclipse tooling
Java, Spring, OSGi Blueprint, Scala and Groovy
Deployment options
Extending Camel by building custom Components
Q and A

Before we open for QA at the end of the session, we will share links where you can go and read and learn more about Camel. Don’t miss this informative session!

You can register for the webinar at this link.

Apache Camel 2.11 - Neo4j and more new components

2012-10-24T17:02:00.002+02:00

As usual the Camel community continues to be very active. For the upcoming Camel 2.11 release we have already five new components in the works

camel-neo4j - To integrate with the graph database neo4j
camel-couchdb - To integrate with the Apache CouchDB
camel-elastichsearch - To interface with an ElastichSearch Server
camel-cmis - To integrate with CMIS compliant content repository
camel-sjms - JMS component with pure JMS API (no 3rd party like spring-jms)

All five components started by members of the community, and not by people from the Camel team. For example the camel-neo4j, and camel-couchdb components is kindly donated to ASF by Stephen Samuel. Bilgin Ibryam contributed the camel-cmis component. And Cedric Vidal donated the camel-elastichsearch component. And lastly Scott Sullivan donated the camel-sjms component.

Since then Scott and Bilgin has been invited into the Camel team, and both are Camel committers today. Scott will continue improved and work on camel-sjms. At this time we are looking for people who wanna give the current code a test-spin. It does take some time to harden this component to become as stable and good as the current camel-jms component. We anticipate this is ongoing work over the next couple of Camel releases.

You can click on the links in the bulleted list to get to the Camel documentation for each of these components, which has some sample code as well.

Also expect much improved CDI support from Camel in 2.11.

The current in-progress release notes of changes in Camel 2.11 can be seen here.

Thanks a lot to the very active Camel community and for people taking up the time to write components that benefit all of us. Keep up the great work.

And in case you did not know, Apache Camel comes with a lot of components out of the box. The screenshot below is a directory listing from my laptop with the trunk code.

Camel Components Galore

PS: There is 133 components.

When did Apache Camel have retry?

2012-10-10T11:58:00.000+02:00

Ansgar Konermann asked me on twitter when Apache Camel had retry functionality (eg a common use-case is to retry in case of a failure).

@davsclaus since when/which version does Camel support retry processing? Spring Integration added it recently.

So I had a peak in the source code and the commits logs reveals the following

commit d0cba2ad2abda2a4e6a18b29a43f86405452f031
Author: James Strachan
Date: Wed Mar 21 09:56:11 2007 +0000
added an initial implementation of Dead Letter Channel

git-svn-id: https://svn.apache.org/repos/asf/activemq/camel/trunk@520823 13f79535-47bb-0310-9956-ffa450edef68

James added support for redelivery on the initial Dead Letter Channel in Camel 1.0. So the answer to this question is that Apache Camel came with this functionality out of the box from the very first release. This just makes the first release even more impressive, than I have previously blogged about.

In Camel 1.1 James improved the error handler to add support for exception clauses (eg the onException) so you have fine grained redelivery policies. For example to instruct IOException to have longer and more redelivery attempts, and have your MyBusinessException to not redeliver at all.

That came as early as Camel 1.1. Impressive.

We have since of course further improved error handling and retry/redeliver functionality in Camel. For example you can configure whether Camel should block or use non-blocking while waiting until next redelivery attempt is being triggered.

Another functionality that I remember we (the Camel team) have discussed for a long time how to implement and provide in Camel is graceful shutdown. It turns out its much easier to startup an application than it is to stop/shutdown the application in a reliable manner.

So I took a stab at implementing this and it was provided in the Camel 2.2 release. That is nearly 3 years ago.

Author: Claus Ibsen
Date: Sun Dec 20 12:27:04 2009 +0000
CAMEL-1483: Camel now uses graceful shutdown when shutting down.

git-svn-id: https://svn.apache.org/repos/asf/camel/trunk@892587 13f79535-47bb-0310-9956-ffa450edef68

Oh and if you want you can alter the redelivery settings at runtime using JMX. For example to adjust intervals etc. It can all be adjusted.

Apache ActiveMQ 5.7.0 Released

2012-10-08T16:22:00.000+02:00

Today the Apache ActiveMQ team announced the immediate release of Apache ActiveMQ 5.7.0.

In this release I had a more active role than I usually has. So its with great please to see a release come out.

Dejan has posted some highlights of the 5.7.0 release at his blog. Among others is the official support for Java 7, and inclusion of the latest Camel 2.10.x release.

I will continue to help work on ActiveMQ and take on some of the things we have learned over the years from Camel to ActiveMQ. For example I plan to work on enlisting all the threads pool that are in use in the JMX registry, so you can gain better runtime insights into the threading usages.
In the 5.7.0 release I helped improved the thread names to be consistent and start with ActiveMQ. This should help people to quicker identify threads by its name.

There is much more work planned for ActiveMQ 5.8.0, for example we would like to reduce the dependencies on activemq-core, and move code into new separate modules. This allows people to better slice and dice how they want their ActiveMQ deployments.

And I plan to take a look at the ActiveMQ JIRA tracker, there is some low-hanging fruits in there, as well some older tickets which needs a bit attention.

OSGi deployment made easy with FAB

2012-08-24T08:58:00.000+02:00

If I had a dollar each time people had a challenge with OSGi deployments ... I could solve the finance crisis in Europe. Okay I am of course exaggerating; but there is a grain of truth in there ;)

So if you are a developer who wants to be productive, and be able to go home on time, and drink beer with your friends, play sports, and generally have fun and be happy ... then read on.

So to understand what FAB is and why it can make your life easier, then I refer you to the following material.

A FAB (Fuse Bundles) is basically a new way of deploying applications into an OSGi container that can make your life a whole lot easier. This technology has been developed by my engineering colleagues at FuseSource and is open sourced at Github, (ASL 2.0 licensed)

Fintan Bolton and his video team have created 2 new excellent introduction videos about FAB.

To go along the videos we have documentation at the Fuse Fabric website. I encourage you to read the material, as its in the minds of James Strachan, who is a driving force behind FAB.

FAB comes out of the box in the new Fuse ESB Enterprise product, however as FAB is open source and freely available, you can use it in general purpose containers such as Apache ServiceMix or Apache Karaf.

At github there is a number of examples with full source code, that is also provided out of the box with the Fuse ESB Enterprise product.

Introduction to Fuse ESB Enterprise Video

2012-08-20T11:41:00.002+02:00

We at FuseSource have created a 5 minute video that shows a rundown of some of the highlights of the new Fuse ESB Enterprise release.

The video can be freely played from vimeo (no registration etc.) and last 5 minutes.

You can also find material about Fuse ESB Enterprise on the FuseSource website.

Link to video: http://vimeo.com/fusesource/review/47076337/76f8a99fbc

Olympics Image Loader powered by Apache Camel

2012-08-17T08:35:00.000+02:00

I have been on vacation for 3 weeks during the Olympics. So I missed most of it. Just got back in time for the finals of the football and basketball games on the last days. My vacation was really off the beaten track with no wifi or TVs. Just old fashioned relaxation and books.

In the mean time Bilgin Ibryam, from the Camel team, has been following the olympics. He created a little web application that displayed images related to the olympic games. He wrote a great blog post where he taks through how he did that. Its well worth a read.

Image from Bilgins blog, showing a preview of the website

The source code for the project is hosted on github. There is link and further explanations on Bilgins blog entry. So go there and read more.

Apache Camel 2.10 Released

2012-07-05T12:22:00.000+02:00

The Apache Camel 2.10 release is now available for download from Apache and for Maven users in central maven repo.

Apache Camel reaches impressive 2.10 release

The Camel 2.10 release marks a major milestone, not only, its the 10th release on the 2.x baseline, but this release officially supports Java 7. The Camel team have worked hard to ensure this release works well on both Java 6 and 7; which hasn't been a trivial task to ensure. Most noticeably is the fact that Java6 and 7 JRE ships with different versions of JAXB that were not immediately compatible.

Spring 3.1 is also official supported, and we have a dedicate test suite running on the Apache CI servers doing a full test run using Spring 3.1.

The Camel test kit have been improved by moving the Spring support into a new camel-test-spring component, which means camel-test is a pure Java based test kit (for non Spring users). There is great news for OSGi Blueprint users, as we have introduced a new camel-test-blueprint component for easy unit test with OSGi Blueprint. I have previously blogged about this.

We have also empowered the Camel test kit by making it easier to stub endpoints, or use the auto mock functionality, which now makes it even easier to skip sending to the target endpoint, using the new isMockEndpointsAndSkip method from CamelTestSupport.

The Camel Maven Archetypes got some love. We improved the blueprint archetype which now leverages the new camel-test-blueprint for unit testing. Likewise the camel:run plugin supports running Blueprint projects as well. The java archetype now creates a pure java project (without Spring). And for Scala enthusiasts we have new archetypes for creating new Scala based components and data formats. Also the archetypes now generates a sample unit test as well.

For managing Camel applications with JMX we have improved this to make it much easier to control and lock down the JMX namings of your Camel apps. I have previously blogged about this in detail. Likewise we have ensured that all the Camel EIPs is enlisted in JMX and offers utilization statistics. And we now have aggregate route statistics on the CamelContextMBean for all your routes.

For people using the file and/or ftp component, we now allow you to bridge exceptions happening when trying to pickup new files with the regular Camel error handler from your routes. This can now be done easily by enabling the consumer.bridgeErrorHandler option.

We also now allows you to configure a shared thread pool for your file/ftp routes (consumers), using the new scheduledExecutorService option. This can reduce the number of threads used in your JVM, if you have a lot of file based routes.

For people using Spring property placeholders, we can now bridge to that from Camel, using the new BridgePropertyPlaceholderConfigurer bean which means you do not have to explicit setup Camel property placeholder as well. The caveat is that you must define this as a Spring as Spring Framework is not flexible allowing 3rd parties to integrate more seamless with its property resolver.

So I have saved the best for the last. The Camel community continues to kick-ass, and for this release we have a record high of 18 new components. For example we now support dynamoDB in the AWS components. We also now supports the popular MongoDB database, and you can have fun with the new Twitter and websocket components. There is also a new component for integration with Spring Batch. And if you need CSV / flatfile support then BeanIO is worth a look as well.

And really existing is the new camel-cdi component which we will continue to expand.

The 2.10 release notes have more details whats included, as well a list of all the new components.

The Camel team will continue with Camel 2.11, and keep doing patch releases as well. However with 2.10 being released, then we will slowdown on the 2.8 release, to comply with our statement that we active support the last 2 minor release branches.

Happy Birthday Apache Camel - Camel turns five years today

2012-07-02T10:06:00.000+02:00

Happy 5 years birthday Apache Camel.

Apache Camel turns 5 years today

When does a software project have its birthday, is it the day of its

first commit
public announcement
any first 0.x release (pre 1.0)
or at the very first 1.0 release

Well today is July 2th 2012, and 5 years ago Apache Camel 1.0 was released and published to Maven Central.

Apache Camel 1.0 Release at Maven Central

So lets celebrate the birthday of Apache Camel today by marking its been 5 years since the very first 1.0 release hit the streets. The Camel team created a fantastic first release, which I blogged about previously.

Apache Camel 1.0 Release

Just to complete the bullets, so the first commit was done by one of the founders, James Strachan, on March 19th 2007. And its no wonder that it was James who made the first public announcement of Apache Camel on his blog on May 15th 2007. And 3 months later as we know it, Camel 1.0 was released on July 2th 2007.

Over the course of time the Camel team have released many Camel releases.

A total of 11 release of the Camel 1.x series.
And so far 23 releases (and 3 milestones, and 1 RC) of the Camel 2.x series.

The project has since grown tremendously and today is one of the most popular integration frameworks out there.

In January 2009 the project became a top level project at Apache.

Apache Camel has been presented at many conferences over the years, the first talk was at the Irish Java Tech Conference in November 2007 by James Strachan. Ever since a lot of people have spoken about Camel at conferences, JUGs, webinars and so forth. We have a link collection where you can find some of these presentations.

The popularity of the Camel project keep rising and at the beginning of 2011, the Camel in Action book went into print. Having a book published by the well respected Manning publication is a testimony of the popularity of the project.

Here today 5 years later the Camel project goes from strength to strengt, as the next couple of chars proves.

Quarterly visitis on the Apache Camel website

Yearly posts on Camel user mailing list

Number of commits on the project

Number of Camel components out of the box

And since the end of 2011 we have added two more committers, and the upcoming Camel 2.10 release adds a whopping of 18 new components. So the chars is continuing the growth.

Last year the first annual conference in its name - CamelOne - took place in Washington DC, and the event took place in Boston this year.

2nd annual CamelOne conference

All the sessions from 2012 was recorded, and you can find the videos to watch on your leisure. At CamelOne 2012 we had a sneak birthday celebration of Apache Camel, by having a Camel cake.

Camel Birthday Cake at CamelOne 2012

Today the Camel team is busy finalizing on the last bits for the upcoming Apache Camel 2.10 release.

I guess even James Strachan would not have anticipated what he and the fellow creates of Camel set out 5 years ago, would turn into such a successful project, that he gets a ride on a real Camel.

James Strachan riding a real Camel

Camel in Action book outdated?

2012-06-30T10:02:00.001+02:00

As you may know Jonathan and I got published about 1.5 years ago with the Camel in Action book.

And the book has been very well received within the community, and helped a lot of people getting onboard riding the Camel.

Jonathan and I have done our best to keep the material in the book as up to date to the lastest Camel release. In fact during the type setting period (that takes 4 months) we ensure that material was updated accordingly to new Apache Camel releases. So when the book went into production it was up to date with the Apache Camel 2.5.0 release from October 31st 2010.

Ever since the book was published we have been active on the Author Online forum to catch the minor mistakes and feedback you may have. The errata of the book is fully up to date. In fact the errata was updated as late of a couple of months ago.

Likewise the accompanying source code of the book has been kept up to date with the newer Camel releases, up till the lates official release 2.9.2 And this time we have prepared the source code for the upcoming Camel 2.10 release (currently expected to be GA next week).

Myself, as a reader of other books, this kind of service is rare. Most authors do not bother to even keep an errata, or make sure their source code actually works.

In fact we use the source code for the book as a test suite for the upcoming Apache Camel releases. In fact it was due to this source code we caught a regression in the 2.10 release, that we had to fix that and recut a new release candidate.

So with that in mind, its sad to see a reader post a bad review on Amazon (Click on image to read).

Our first 1-star review

For example the reader complains that he/she cannot find the Apache Camel 2.5.0 download. Well its due to Apache policy that older releases are not highlighted on the website, but available in the Apache Archives. If you click on the download link on the Camel website, we have a heading in the top saying "Older Releases". So its not hard to find.

You can download older Apache Camel releases

Riding the Camel with a new hat

2012-06-28T09:25:00.000+02:00

This morning I woke up to the news out in the public that Red Hat to Acquire FuseSource. You can read the Acquisition FAQ to learn more what has happened.

This is really great news for the FuseSource team, to find a new home that has truly Open Source in its DNA. Our new home is the JBoss Middleware Team, which are no strangers to what we do. JBoss loves our work we do in the Apache communities and they have been using the Apache products for many years. For example Apache Camel is part of the JBoss products.

For me personally this means I can continue to do what I love; with my devoted effort in the Camel communities and on the Apache Camel project itself.

My colleague Charles Moulliard, got creative this morning, and gave the Camel a new hat.

The Camel got a new hat. Photo by Charles Moulliard.

I guess its time for me to get a new hat as well.

Photo of Claus, not wearing a Red Hat (yet)

And I gathered a list of some blogs posted about this news from fellow employees