ANT path matcher

The Camel community is pushing in new requests. Lately Ramon Buckland from down under requested the need for ANT path styles. I couldn't agree more that this is truly a nice solution to express paths.

As Camel already leverage Spring in several of our components and other parts of Camel I wanted to create a solution using Spring only, to avoid bringing in a new dependency on ANT. As Spring already have nice AntPathMatcher support for it's resources I could quite easily add it to Camel as well.

So In Camel 2.0 you can use AntPathMatcherFileFilter as a java.io.FileFilter as the filter for which files to include when consuming files using the Camel File component.

As this is a Spring'ish solution it requires camel-spring.jar. You configure it using plain Spring bean, as a Spring Bean using properties for setting includes and exclude ANT paths.

I have provided a sample in the Camel File documentation - in the section "Filtering using ANT path matcher".

Yeah even during the holidays the Camel community and roadmap is moving - it's never standing still.


Camel Community is Rocking

The Apache Camel community is a vibrant community with many contributors.

As Gert Venthiensen blogged two new tutorials has been created. Charles Mouillard have created a great tutorial on how to use Apache Camel in various OSGi containers such as Apache ServiceMix and Spring DM. And this is just part 1, he will continue the tutorial.

Ramon Buckland contributed a totally new component to Camel for tidying up ugly HTML using TagSoup. Yeah we had a challenge with the name as TagSoup isn't so catch, so it's named tidyMark in the DSL.

The Camel riders thanks these great contributions. We love contributions and welcome your contributions in any form, on the forums, IRC char, blogs, JIRA issue tracker, improving the documentation and of course also code contributions.

And there are more contributions in the brew. Check out the camel user and dev forums for the discussions.


About Open Source Community

The Apache Camel community is very much alive and kicking. As my Camel rider journey started about 1 year ago I have seen a community with tremendous prospects. This is great news for Apache Camel that this community and it's contributors is around. In fact we are in talks to promote Apache Camel as a Apache Top Level Project (TLP).

I was wondering if anyone knows of some good stats aggregator for Open Source Communities? ohloh has potential but it only, to my knowledge, scans the source code commits. What I am looking for is metrics for activity in forums, irc channels, blogs on Camel, JIRA tickets analysis, talks about Camel on conventions, Authors write books about Camel, number of downloads, Companies offering training, support, etc. etc.

Anyone know of such metrics exists?


Camel and file sorting

The file component to be used for file connectivity in Camel is a key component in the kind of integration works I am hustling with a clients. We are still doing a lot of file and messaging based on IBM platforms from large mainframes and other older platforms. So I am not riding on the Camel with the yellow jersey in the "peloton" (hint: Tour de France).

So my Camel is up for a maintenance upgrade now that we are working on Camel 2.0. A part of this upgrade is being able to support ease of use for pluggable file filtering and sorting.

The sorting comes in two flavors:
- comparator
- textual expressions

Sorting by comparator
We leverage the java.util.Comparator to allow end users to configure their own implementation to use, or use what we have on the shelves out-of-the-box for the regular sorting by name, modified date, size etc provided in org.apache.camel.component.file.DefaultFileSorter.

We can configure the comparator in the file endpoint using the sorterRef option:

... where myFileSorter is lookup up in the registry, typically Spring application context defined as a spring bean:

<bean id="myFileSorter" class="com.mycompany.MyFileSorter"/>

Sorting by expressions
This is where we did go the extra mile and implemented textual configuration of sorting. You just add a sortBy option to the file endpoint URI configuration where you express what and how to sort.

A plain example would be:

We can specify reverse if we wanted to sort in reverse order

And the ignore case is also supported so you can process files regardless of the case

And on top of that we have grouped sorting so you can append a 2nd sort by, where the groups are separated with semi colon. So if we want to sort first by file extension and then by name we do:

As the expression is the file language you got its full power as well so if you want to sort by modified timestamp but it should only consider the date part, we can use the yyyyMMdd pattern and express this as:

Currently this is only implemented on the file component, but next up is to implement this for the FTP component as well.

Check out the file component and the file language to get an idea how this new sortBy option can be used.


Apache Camel Community helps drive the roadmap

We, the good Camel riders, get numerous times positive feedback from end users that they appreciate the great community that spins around Camel.

As a rider myself I enjoy all the great feedback we receive and it helps steer the Camel in the right direction.

Lately I have been in dialog with an end-user that had a bit more advanced use case for routing and handling certain custom exceptions. So after discussing and realizing that he needed an improvement in Camel I created the ticket for it.

The use case
The use case is that in case of a org.my.exception.FunctionalException is thrown and this exception is in a certain state then route the message to a certain bean handler. This can be expressed like this:

<redeliveryPolicy maximumRedeliveries="0"/>
<to uri="bean:myOwnErrorHandler"/>

The problem
The problem by its core is that Camel in case of an exception being thrown will look for (if any) onException that should handle it. And currently you can only state a list of exceptions and if the thrown exception is an instanceof on of these exceptions Camel will choice the first onException defined that matches. But the end-users needed to alter this choice to also express a predicate so the matching will only occur if the predicate is true as well.

The algorithm is: FunctionalException is thrown + hasSpecialEnumCode returns true

Camel is very flexible and the end user could actually implement this right out of the box, however he needed to provide his own ExceptionPolicyStrategty that contains the logic to select which onException to handle the given thrown exception. So he could have implemented the org.apache.camel.processor.exceptionpolicy.ExceptionPolicyStrategy interface and defined Camel to use this policy instead of the default. Yes Camel is flexible.
But as the author of this policy in the first place I picked up the glove to add this directly to Camel. Here is a short summary how this was done:

The solution
First of all I added the when predicate to the onException so you can add it (optional).

@XmlElement(name = "when", required = false)
private WhenType when;

Camel supports both Java DSL and spring DSL. As the Spring DSL XSD is auto generated we only add the JAXB binding annotations to control the XSD.

I then had to improve the DefaultExceptionPolicyStrategy to consider this new predicate (when).

Basically I had to add this piece of code, that in case if a when predicate is provided will match it, for onException without this predicate it returns true.

protected boolean matchesWhen(ExceptionType type, Exchange exchange) {
if (type.getWhen() == null || type.getWhen().getExpression() == null) {
// if no predicate then it's always a match
return true;
return type.getWhen().getExpression().matches(exchange);

Now we have a method to determine if there is a match or not, then I just had to skip non matching in the iteration while Camel finds the correct onException to use

// must match
if (!matchesWhen(type, exchange)) {
if (LOG.isDebugEnabled()) {
LOG.debug("The type did not match when: " + type);

That is basically it.

And the final route
Now we can add the onWhen predicate that will call a method on the bean mySpecialEnumChecker that will return either true or false. So the onException is only triggered when the exception FunctionalException is thrown + the predicate returns true.

The route is now:
<method bean="mySpecialEnumChecker" method="hasEnum"/>
<redeliveryPolicy maximumRedeliveries="0"/>
<to uri="bean:myOwnErrorHandler"/>

Apache Camel valuates its community and we strive to be there for the community and together steer Camel in the right direction.


Walks with Apache Camel

The getting started guide in Camel, if people find it, is a good 5 min. rundown of how Camel routing can be constructed using the fluent builders in Java (think Domain Specific Language).

What I wanted to demonstrate as well is that we also have a XML based DSL as well that many end users starts with.

So I created a little guide focusing on how to create routes using XML - "Walk through another example".

So if you have 5 minutes to surf on the web, then you could walk these two links:
- walk through an example (Java DSL based)
- walk through another example (XML DSL based)


Thanks JetBrains

License Certificate LC-XXXXX for IntelliJ IDEA

As an open source developer on the Apache Camel project I received a free license for Intellij IDEA 8.x today in my mail box. Thanks Jetbrains.

As a constant user of IDEA for the last 6+ years I am glad that IDEA 8.x has been focused on faster startup time. I am glad that you can install the plugins that you need and especially the ones you don't need. Oh and by they way they have bundled my plugin now.

The announcement of the release has hit the server side, so you can go there and enjoy the IDE wars that tend to get started when personal feelings is involved with your favorite tool.


Camel 1.5.0 Release

As my last post hinted it was only a matter of hours before Apache Camel 1.5.0 was released.

Bruce Snyder was so kind to blog this news. Always great when the community is there to help spread the word.

Apache Camel is really as Bruce write very much a community driven development ;) The Camel riders takes the community very seriously and we are active on the forums and as well on the IRC chat.

For me personally this is the 3rd consecutive released I have been involved with. Early Camel riders on the 1.2 or older much have noticed that we have picked up the pace and have released 3 major releases this year yet alone. Each release containing more than 200 issues addressed.

This release has widespread new features, improvements and bug fixes that it would take me quite some time to blog. So go read the release note that has detailed information about the changes.

This is again a marvelous work by both the Camel developers and the community behind it.


Camel 1.5 a nifty new feature - Delay Interceptor

It's just a matter of hours before the votes passes and Camel 1.5.0 is GA.

However this blog entry is about a new nifty feature we have added in Camel 1.5. The delay interceptor. The idea is basically to slow things down, or to be more precise to slow down the routing. Camel do this by delaying the passing of the message from node to node in the route graph.

During either development or testing you are often in a situation where you are debugging or testing an issue and you push in some messages to your ESB platform. Then they are processed but things happens so fast in modern computers that the logging out is hammering with zillions of log lines and you kinda lost the picture what happened.

So instead of having to add a lot of Thread.sleep() or .delay() (yes we also have a delayer DSL) in the route we have this light weight AOP interceptor that delays the routing for you.

To enable it in for instance the Spring DSL you set the delay attribute on the camelContext. As shown below we set a delay of 3 seconds (3000 millis).
<camelContext id="camel" delay="3000" xmlns="http://activemq.apache.org/camel/schema/spring">
This kind of interceptor has a sister so to speak, we have the Tracer that enables logging of the exchanges that are routed. Combining these two you have a powerful combination to easily help you at runtime to investigate what is happening.


File consumer gotchas with CAPS

In my day job I get the pleasure of working with $$$ ESB platforms from large vendors such as SUN and IBM. Mostly SUN but I get the deployer role from time to time on the IBM platform.

Well this time I had some trouble implementing a file based resend feature. The idea is to drop the backup file in a certain folder and then CAPS will pickup the file and resend it as if it was the original request (webservice).

While working on this one I got side tracked as CAPS once in a while would drop this error in the log:
kupFiles2CAPS|_ThreadID=149; ThreadName=Worker: 74;|[mammatus.rh.dk] [3180_10_BACKUPFILES2CAPS] [] [ERROR] [9] [] [3180_10_BACKUPFILES2CAPS] [CAPS]
[Batch Local File eWay error when doing file operation in [get()], message=[LocalFileClientImpl.get: Failed to get file to the payload.Nested exce
ption follows: ---
com.stc.eways.common.eway.standalone.streaming.StreamingException: LocalFileClientImpl.requestInputStream: Exception occurred.Nested exception foll
ows: ---
com.stc.eways.batchext.BatchException: Unable to find a file matching the Target Location configuration settings.Nested exception follows: ---
java.io.FileNotFoundException: Directory Name: /caps/projectdata/3180_EUP/resend/ File name: 8C803FD4-C7D8-A2BF-BA0B-5BF045012BA7.20081022-12145726
4-87-eup.xml--- End of nested exception.
--- End of nested exception.
--- End of nested exception.
].Nested exception follows: ---
After a while I realized it's the fact that CAPS will rename in progress files with a GUI prefix but keeping the original filename as postfix.

Original name: 20081022-121457264-87-eup.xml
In progress filename: 8C803FD4-C7D8-A2BF-BA0B-5BF045012BA7.20081022-12145726

So what is the problem here? Well the fact is that I have setup CAPS to monitor this folder and consume .xml files. So what CAPS will do is to also consume it's in progress file ;)

I haven't found a setting where I can change this to eg. let CAPS use a sub folder or a different file extension for in progress files.

Now I gotta change the regexp for matching the files to a avoid the CAPS in progress files.


File Language - A new feature in upcoming Camel 1.5.0

A favorite feature of mine in the next Apache Camel is a new feature to use file name patterns in the file component. What we have introduced is a new language, the file language, so you can leverage this feature anywhere in Camel where it uses Expressions, Languages etc. The file language currently support both the file and the FTP component as well.

As a lot of integrations is file based you need to be able to read (consume) or write (produce) files. Then you need to be able to specify file names. What's new in Camel 1.5.0 is that you can express this using patterns, for instance directly in the configuration of your endpoints. Prior you had to do this in Java code.

Simple example
Lets image you need to move consumed files into a backup folder after processing.

Now you can express this using the pattern: backup/${file:name}
Well then you need to use .bak as extension, and the pattern is: backup/${file:name}.bak

Okay next issue is that the backup folder should be grouped by dates using the yyyyMMdd pattern. Well the expression support the java.text.SimpleDateFormat patterns also.
The pattern is: backup/${date:now:yyyyMMdd}/${file:name}.bak where now means current date. You can substitute this with different commands such as file for using the timestamp on the file instead.

Advanced example
In this sample you need to produce files (save) and you need to save the file using a generate unique filename. We use the divide and conquer pattern for this so you create a POJO class that generates the unique filename, then you as the developer have the full power how to do this. And then its very easy to unit test as its plain POJO that can be tested very easily with JUnit. Next step is to express this as a file pattern. As your POJO is a bean we use the bean langauge to invoke your pojo.

So the pattern is: myfile-${bean:myguidgenerator.generateid}.txt
myguidgenerator is the bean id of your POJO and generateid is the method name. You can omit the method name if there is no ambiguity which method Camel should invoke.

Camel routes
This feature is configurable directly in camel routing on your endpoints. So what we can do now is:


The route will consume files and process the files in the processFile bean, that is a plain POJO class. After processing the files is moved (renamed) using the pattern in the expression. So the file is moved to the backup subfolder, for example: backup/20081014/report-october-2008.bak

More to come
Well there is a ton of new features and improvements in Camel 1.5.0. Check out the current release note.


Redelivery handling in CAPS

At my current client we are still developing integrations on the mighty SUN CAPS platform, former known as SeeBeyond ESB.

The current integration being developed needs redelivery handling controlled by CAPS itself. Frankly it has a nifty feature to setup variable interval using a sting pattern as: count;delay;count:delay;count;delay,.... This is quite nifty as you can use a shorter interval at start and then increase it a bit later. However CAPS doesn't state any upper bounds or the like when setting this pattern. Only at deployment time you get this error:

Not a friendly error message, but hey we do as it said and look into the server log and find the cause (and trust me this time we are in luck as we get a cause):

Caused by: java.lang.Exception: Could not parse [1:5000;10:10000; 100:move(queue:qu3180EUPError)]: error [java.lang.Exception: Delay of
[10000] exceeds maximum of 5000 ms] in element number 1: [10:10000]
at com.stc.jmsjca.core.RedeliveryHandler.parse(RedeliveryHandler.java:536)
at com.stc.jmsjca.core.Activation.activate(Activation.java:203)
at com.stc.jmsjca.core.RAJMSResourceAdapter.endpointActivation(RAJMSResourceAdapter.java:273)
... 107 more
Caused by: java.lang.Exception: Delay of [10000] exceeds maximum of 5000 ms
at com.stc.jmsjca.core.RedeliveryHandler$Delay.(RedeliveryHandler.java:253)
at com.stc.jmsjca.core.RedeliveryHandler.parse(RedeliveryHandler.java:483)
... 109 more

So basically you can only set a maximum delay of 5 seconds per interval. Well knowing how unreliable the network unfortunately can be, we can have outages lasting for 30+ minutes. or more.

Well at least CAPS supports setting a delay that somehow can be accepted with 5 seconds delay. I wish however I could use 10 seconds or even longer. No there is no exponential backoff setting and upper limit to be used for longer delays.

I am however pleased that we have such features in the Camel.

My next problem was that I wanted the current redelivery count when I was processing the message. However this count is not available to end-users but only to CAPS itself. I can only retrieve information that the current message is a redelivery or not.

Well my next problem is that when a message is then finally moved to the dead letter channel, after X failed attempts I need to alert this. And no the operations staff do not monitor CAPS manually, and any SNMP traps that CAPS could sent is not integrated into the existing surveillance (and I actually don't know if CAPS send a SNMP traps if a message is moved to the dead letter channel) so we are forced to alert by writing to log files ;)

Probably not what SeeBeyond envisioned their flagship product will be used, in such scenarios.

Well low-tech files is still used a lot for integrations and monitoring. So whatever fancy product is out there, don't underestimate supporting low-tech proven technology that regular staff know how to use.


Camel Tutorial - Using Axis with Camel

I have been cranking on some beginner tutorials on using Apache Camel. As of late I was asked how Camel integrates with existing applications using Apache Axis 1.4 as the webservice stack.

Well the question is valid as in my opinion its important for a framework to be versatile, flexible and appeal to the entire community. Apache Camel shouldn't be a high-level framework for geeks only.

So to demonstrate how you step by step can integrate a web application using Axis with Spring and Camel I have created a new tutorial "how to use good old Axis 1.4 with Camel" with an example application that will be distributed with the next release of Apache Camel.

Happy reading. And remember to check out the other tutorials as well.
If you have the time then the report incident tutorial is worth a read.

And if you fancy some more routing and what Camel can bring to the table in that regards, then I suggest you check out Eduard Hildebrandts award winning power point presentation, that is listed in the Articles section.


Tribute to Contributors

During my life span of developer I have contributed patches, suggestions etc. that it is the spirit of the open source community. The path to the source is available to me as a client. Once in a while you discover a few gems from the source thanking the contributors. That of course brings a smile to the contributor that his work is appreciated.

Today I discovered a little gem from the past. The excellent EHCache has had recent activity so I was circling their website again, pointed in their direction by all the news sites, feeds and blogs.

Well the EHCache team has taken the time to list a page of the team members and the contributors. Really nice. Thumbs up. Some years ago I was also told by my former colleagues from e-ma in China that they had found a snippet in iBatis where Clinton Begin thanks me.

Now that the committers have ohloh as a kind aggregation of your contributions I have been thinking that there should be a similar service for all the contributors as well. Many of these contributors are the real heroes. They are out there working at the clients, in knee deep wrestling with the problems and knows where the pain is.

Now that I am an Apache Committer on the Apache Camel project I take all our contributors seriously and know what it feels like when the team behind responds.

So if you haven't contributed, well you work is appreciated and its nice to have its name out in the opening. So dust of your patches from the open source frameworks you are using, create a JIRA account and submit your contributions. We need all the feedback and hard work from the end-users, the contributors, you, the real hero.


Camel - Tutorial - Part 4

I am writing a longer tutorial for Apache Camel where we start from the beginning and take baby steps. I have just completed part 4, that is the first part to introduce the routing concept in Camel so we are really serious about the baby steps.

The new part 4.
And if you haven't seen the tutorial before check out the introduction.


Camel now has HL7 support

I recently committed a new component camel-hl7 to Apache Camel to support HL7 in terms of:
- the HL7 MLLP (Minimal Link Layer Protocol) for HL7 services over the network
- a HL7 parser for the ER7 format (EDI based) with the HAPI library.

At my current client HL7 is a quite common data format for data interchange in the health care industry. And as the Capital Region of Denmark we of course also use HL7 for integrations. However not many of the Integration Platforms out there has some kind of HL7 support.

As the HAPI framework is quite well used we don't have any doubts not using it, and as the HL7 MLLP is just a "plugin" to Apache Mina we should be well covered with the network stuff.

The camel-hl7 component will be included as of Camel 1.5 that currently is in progress.

I have since received a few mails from people in same situation where they had to roll out the own solution. They are looking with interest that we have this feature out-of-the-box with Apache Camel.


Personal milestone - 500 commits

As I posted a blog today I saw that my ohloh banner had the major number 500:

Just wanted to post a quick blog with the breakdown:
- WebWork (58 commits)
- XWork (66 commits)
- Apache Camel (376 commits)

- 4 kudos received
- 2 kudos given

Will be fun to see if or when I reach 1000.

CWSIA0084E - What planet is WebSphere from!

At my current client we are evaluating different light weight ESB frameworks, that is to be hosted on the IBM WebSphere 6.1 platform.

We have chosen the web deployment model for our integrations so basically we are building a bunch of .war applications that we deploy. Within these .war application we have the light weight ESB embedded.

Today it's Mule's turn and I am building a proof of concept mirroring an existing integration we have on our old heavy weight platform. This integration uses two internal JMS queues to store intermediate messages in a route path.

I have setup a project using Mule 2.0.2 with its different transports and among them mule-transport-jms for the JMS part.

All is dandy when I run the application out-of-container with my unit tests where we use Jetty and ActiveMQ. No problem there.

I repackage my application without ActiveMQ and setup Mule to use WebSphere JMS connection factory instead.

Kaboom. I get a CWSIA0084E exception. Great there is an unique token to use for Google search (IBM got that part right), however I immediately got disappointed as even Google had a hard time to find any links - 6 hits.

At the end I found this IBM article from a IBM person:
Quoting from the article:
"So when you get this error, the problem isn't a bug in your code, it's your entire approach. In a nutshell, if you want to run a MessageListener in J2EE, don't implement a MessageListener, implement a (can you guess?) messsage-driven bean (the JMS kind, which implements MessageListener). And if you don't like using EJBs? Get used to it. MDBs work in J2EE; MessageListeners don't."

So I am just asking what planet are IBM WebSphere from? Please not always be so strict to the spec any other container I have worked with allowed you to work with JMS from any deployment model of choice.

Well that is -1 for Mule and -2 for WebSphere. Unfortunately WebSphere will prevail.


Generate toString() bundled in IDEA 8

Great news. Jetbrains is now bundling my plugin into the IDEA distribution.

I received this mail from Jetbrains:

Hello Claus,

A couple of days ago we saw a post on your blog complaining about the breakage in our OpenAPI. While in general this is indeed a big problem, in this particular case we can offer you a great solution: bundling your plugin in the IntelliJ IDEA distribution. In this case we'll update your plugin code ourselves while doing the API refactorings.

If you agree, we'll move the plugin to our Subversion repository. It will of course remain open-source, and you'll of course have commit access to the part of repository containing your plugin.

Are you interested in this?

Dmitry Jemerov
Development Lead
JetBrains, Inc.
"Develop with Pleasure!"
This is great news for the plugin. Jetbrains will ensure that it stays compatible with their future lines and the plugin was mostly feature complete anyway.

So after 6+ years of development of this plugin its nice to know that it have found a new home.

I want to thank Jetbrains for listening. Amazing they read my blog ;).
And of course all the people that have contributed to the plugin in any form, without you the plugin would have been so popular:

- Bas Leijdekkers for initial port of plugin to IDEA 7
- Mike Abney, Spencer Goh and Tom Gaigner for contributing templates that have been inspirations for improving the default templates
- Martin Schmid for submitting java code for field chooser dialog used in earlier versions
- Roman Porotnikov for improving templates
- Glen Schrader for showing how to add this plugin in the generate menu (alt + ins)
- Igor Levit for implementing the conflict resolution policy code and improving the settings UI
- Vince Mallet for upgrading the plugin to various Aurora versions
- Dave Griffith for inspiration how to use Inspection by sneaking his great InspectionGadget plugin source code
- Rick Maddy for explaining how the migration to the new plugin repository works (the since-build stuff)
- Mark Scott for the hint how to set Veloicty to log in IDEAs log files.
- Sascha Weinreuter (author of Smart Introduce plugin) for UI code to the quick template selection list
- Mark Scott for the hint how to fix the indent of toString() in the generate menu honoring icons


Apache Camel 1.4.0 Released

Just after 3½ months since release 1.3.0 of Apache Camel we have been very busy and have resolved 261 tickets.

Check out the release notes and go grab it from the download page.

If you are not familiar with Apache Camel then check out the FAQ or the Getting Started guide.

If you have more time and a fresh brew of coffee then I encourage you to read a somewhat different tutorial that focus on introducing Camel into an existing project step by step. The tutorial is work in progress, so check it out from time to time. The tutorial is based on a real life use-case.

If you have less time check out the regular tutorial that demonstrates how Camel easily work well together with Spring for message exchanges over JMS.

If you have questions about Camel then please check out the forums/mailinglists.

And then the answer to the mother of all questions about Camel.


SeeBeyond - The Beast

Rewinding my life back 2 years and I would be a happy person with an IT-job thinking one of the worst platforms I have been working with was IBM WebSphere. Happy unaware of a enterprise integration platform named SeeBeyond exists. SeeBeyond was later acquired by Sun, and the platform was then re branded as CAPS. My client was actually promised that CAPS was able to run on IBM WebSphere, but that is not true. That would have been a double nightmare!

My current client, unfortunately, uses this platform. During my 1½ working with this platform I must admit that I would never dare to run my business on this platform. Well the runtime platform is somewhat okay as its the Sun Application Server running the integrations, and its very stable. But the poor staff that has to monitor the server can't decode its strange logging errors from time to time, and its damm hard to make it shut up.

Where the platform really excels in lack of quality is its support and developer tools. You are forced to use these tools. The developer tools is a old fork of NetBeans that is so buggy and hard to use that its a nightmare to change an existing integration. For instance I have spent the last 5 hours to update and existing integration with a new webservice contract. My god does it toss out strange errors. The solution is always to create the damm integration from scratch. Have your fingers crosssed that it will compile and build the integration and you are able to deploy it.

As I am also having a foot in the lighter marked with Apache Camel I can't dare to think that I would have the job done in less than 1 hour with Camel. And I would not worry that I wont be able to compile and build my binaries just because I have to use a really poor tool that doesn't give me the control to run a build with javac, ANT or Maven that we all take for granted today.

At least my client has realized the platform is a no go for the future and we will in the future look for a new platform.


Apache Camel now with WebSphere 6.1 support

Lately I have been quite busy working on Apache Camel. We are about to finalize on a new release 1.4. I am happy to report that I managed to solve an issue in Camel related to WebSpheres dreadful classloading issues.

As Camel isn't a new pet in town and the community hasn't reported the issue before its a sign in the moon and wind that the fantastic open source community isn't riding on IBM's heavy elephant anymore - count yourself lucky for that!

Well as starting and stopping WebSphere isn't a fun activity to do in my spare time I had other issues to look and solve, such as many of the end-user request, patches and feature suggestions - keep 'em coming.

So finally I found some quite time and started tackle the beast. In the end it was all coming down to the fact that WebSphere classloader wasn't able to load a packagename from a URL resource. You must provide some kind of file resource such as a .class file. And as Camel is a clever framework that can auto register its type converters from just providing packagenames it should recursive scan the solutions wasn't to easy as end-users can also use this feature and provide their own packagenames to scan.

However at the end we have a workaround in Camel 1.4 to let it be able to run on the IBM elephant.


Generate toString() v4.0.6 released

As the author of the generate toString() plugin to IDEA I do have a job to maintain this plugin. I had a few user reports lying around for a while and this morning I thought I wanted to do some IDEA hacking instead of the Camel.

The release only contains 2 minor bugfixes, but importantly one of the bugs was reported by an end-user and we want to keep them happy ;)

The changelog for those interested:

v4.0.6 for IDEA 7.x (05-juli-2008)
- [BUG] ID17: Proper resource handling for loading template files
- [BUG] ID21: $member.typeName and $member.typeQualifiedName did not handle generic and primitve types


Riding the WebSphere Bus

At my current client that unfortunately is keen on IBM and thus we are on the AIX and IBM WebSphere 6.x servers.

We are in the process of evaluating some ESB platforms that must run in WebSphere 6.1, so in that perspective I had the fortune to ride the IBM WebSphere Bus today. Yes I didn't think it had a Bus but this is what its internal JMS provider more or less is re-branded as.

Eventually I had a ride with the bus, but as always it wasn't a joy ride. The goal is to use WebSphere 6.1 embedded JMS for messaging. So the task was to create a queue to store messages that the various ESB candidate platforms can use to publish messages to.

I have spent the most of the afternoon in the dreadful IBM console to setup the Bus and configure the JMS providers, connection factories, jndi bindings and whatnot. During trial and error with a candidate (Mule 2.0.1) it was quite a ride to decipher all these WebSphere exceptions. One good point worth mentioning is that WebSphere uses an token ide for the given exception that is easy to google. However its online documentation that you get when you click "Help" in the console wasn't to much use.

The morale of the story is that it wasn't a very easy task to setup and know we need to write multi pages word documentation with screenshot of every single step with red circles and precise instructions for the operations management when they get to the point where they are responsible for installation and configuration of the WebSphere Bus.

That's a pity we have to ride this Bus when there are more sexy transportation's out there!


Intellij IDEA plugin compablility

I discovered IDEA back in 2001 when there was no Eclipse and JBuilder was more or less the best choice at the time.

Its truly the best Java editor at the moment (however I would love it to be faster at startup). Well my story is that it had a plugin system from early days and plugin developers started producing add-on features both commerical and free. Over the time these features has also been embrased by JetBrains and included in the standard distribution.

Myself developer a generate toString() plugin that could at the time generate those boiler plate toString() implementations for your domain models that we used to crank in manually. I do think I got a first release of my plugin in late 2002 - can't remember the date exactly.

Over the course of time and new releases of IDEA plugins had breaked due changes in the plugin API. And I must admit that a few times I had started to fall behind and give up on it to refactor and dig into the strange errors why the plugin doesn't work the newer version. And yet again you do have the version issues. How do you support the older version of the plugin at the same time. Yes you can have a CVS/SVN repository and start have branches etc. But at the time most people did only have the source on their local computer and didn't share it in public.

Well the story is that in the next IDEA 8.0 I got an issue reported that my plugin doens't work.

With all these breaking API's during the course of IDEA I do think they have lost quite a few great plugins and plugin developers. Am I the next one? Only time will tell.



Its amazing how many new terms first spun on the internet that widespread with rapid pace and suddenly is what you hear from the young teenagers and later in an article in the free papers you read coming back from.

Now an avatar is used for the nice old fashioned passport photo as well, so when my blog needed a little nifty mugshot then I was looking for an avatar and stopped at Gravatar. Its actually quite cool as it integrates with my gmail account so I am able to switch the mugshot later on.
Gravator must be the next company that is acquired by one of the bigger fish - if not already.

When I needed to upload a photo they even had a simple and slick UI to crop the picture. It just works. And this is my point. I am in this part of my life now that I don't want to use 2-3 nights to figure out how it works - I just want it to work out-of-the-box. The days are over where I was reading magazines about new computer parts and using 1 week to assemble all the parts bought from several vendors to save costings.

So make software that "Just works".