The fabric8 guys goes to New York for full-day open developer event

In my youth a one-hit-wonder band emerged with the hit Frankie Goes to Hollywood.  And based on their popularly a poor computer game was done in their name.

c64 game of Frankie goes to Hollywood - yes it was a poor game

Now fast  forward 30 years and its no longer Frankie that is going, but some of us from the fabric8 team and we are stopping at the east coast in the big apple city.

And in 30 years the software has become much more awesome, and we can also play video games in our web browsers, where we can shoot angry pods.

Playing angry pods allows you to shoot the running pods. Here I am shooting at a Camel pods that runs the Camel CDI quickstart application.

goes to

the big apple city

Red Hat is hosting a all day event titled Microservices Developer Day on November 4th 2015, on west 39rd street on Manhattan, New York.

You can find the full agenda, location and how to register from the website.

I will be there to give a talk about developing microservices with Apache Camel, ready for the containers platforms with Docker, Kubernetes, OpenShift. and of course fabric8.

We are honored to have Tim Hockin from the Google Kubernetes team, to keynote about containers and Kubernetes. So its a great chance to hear from the Borg's how they see them taking over the worl... ehhhhh how awesome Kubernets is ;)

Earlier this year, in June, we hosted a similar event in London, which I previously blogged about. So you can take a look at the blog entry to read more about what kind of event this is. Since the London event we had 4-5 months more to hack on fabric8, so we have more awesome stuff in the toolbox to show and talk about.

And we are talking and demonstrating using the upstream community projects so you will see the bleeding edge from Apache Camel, apiman, and fabric8.

The apiman's will be there (hopefully in red tie, as the apiman logo wears red tie), to let you see how this awesome project can put in API management to your platform in a non invasive fashion.

Kurt and Marc from the apinman project in London presenting

Link to event: https://meeting-reg.com/redhat/new-york_november4/


hawtio v1 still going strong - New release with log plugin working on Karaf 3.x/4.x containers

The hawtio project is about to be 3 years old in next month, where the first commit was done by James on the end of november.

I blogged the first time about hawtio in april 2013, where the project has taken so much form that the Camel plugin was showing its promise, and we had the dashboard plugin that allowed to customize the ui with widgets you wanted.

About a year ago we started version 2 of hawtio that is taking the project more into a native web based frontend project, as opposed to v1 which has some ties to Java.

This blog is not about v2, but about v1 that is still going strong.

Today we released 1.4.56 (yes we love doing frequent releases) and in this release we managed to get the log plugin to work with Apache Karaf 3.x and 4.x containers (the Karaf team refactored a lot in 3.x that breaks stuff). To ensure this keeps working we ported over the log adapter from fabric8 v1 to hawtio v1 so we have the module natively in the hawtio project. This allows us to maintain the log adapter source code easier and ensure it continues to work with what changes the Karaf team may come up with.

In the screenshot below I installed hawtio in a vanilla Apache Karaf 4.0.2 release, and open the web console on localhost:8181/hawtio/ and login with karaf/karaf, and then the log plugin shows the log from Karaf. In the filter you can filter by keywords which gets highlighted in the log as well.

hawtio log plugin works in Karaf 3.x and 4.x containers

Unfortunately due the Karaf changes the log plugin does not work with Karaf 2.x containers.

This release also improves the Camel plugin which know shows endpoint / component documentation where we group the options in tabs. This helps with those endpoints that has a lot of options such as the file / JMS component.

hawtio now shows Camel endpoints properties grouped by tabs
You can find the latest release of hawtio at the website.


Cheers - Video recording of walk-through of the simple Java fat-jar fabric8 quickstart

Today we released a new version of fabric8 - version 2.2.51. Well in fact that is no so big news, as we do frequent releases.

But I am using this an an excuse to grab a beer and record a video. The video walks you through how to get started deploying and running your Java applications on fabric8, or to be more precise an OpenShift or Kubernetes Platform.

fabric8 - Walk through of the simple Java fat-jar quickstart

The video was recorded as a one take you get to see the few mistakes I do, and as such the videos is about 15 minutes long. The video is primary using the command shell as the interaction with OpenShift and Kubernetes. This is on purpose to show there is no hidden agenda, and that you can use any kind of tool, or is not locked into using heavy and complex tools.
Note the video is demonstrating a simple deployment strategy where we deploy straight to the platform. The fabric8 project has a much more sophisticated story for DevOps and CI/CD.  James Strachan and James Rawlings are working hard on this, and are currently recording a new set of videos to show the latest progress in that area. So expect me to point your in their directions where we have more to show. In fact a good source to keep up what happens on fabric8 is to follow fabric8 on medium.

Okay back to my videos, which is essential a video recording of our new beginner guide for the most simple quickstart we have with fabric8. And you may never expect to hear from my mouth, but this video is without Camel. There is sadly no Camel in this video. And the reason is that Camel has been a bad animal. I spent hours today chasing a problem with generating a new updated website for fabric8, which after hunt using git insect finally had to come to the reason, that for some reason a Camel upgrade causes a Scala scalate compiler to barf and spit out a 250+ lines long strack-trace that leads you astray. Yeah I guess I got a bit karma in my face for all the Camel users that may have looked at long Camel strack-traces in the earlier releases of 2.x, until we refactored the core and collapsed the strack frames tremendously. Ah okay well before this problem I would have started with the most simple quickstart anyway, which does not include Camel.

Stay tuned for more videos and documentation to come together in the near future where we will continue this trend, and look at how to build microservice applications using Camel on the world of docker and kubernetes.

Good weekend and cheers.


Apache Camel 2.16 Released - Top 10 highlights

Apache Camel 2.16 was released last friday.

This blog entry is my attempt to do a top-10 (+ 1 as bonus) highlights of this new release.

1. Dynamic To

Very likely the top FAQ question from Camel users, is how do I send a message to an endpoint which uri should use a dynamic value from my message such as a header.

Up until this release the answer would be the recipient list EIP.

But to make this easier we introduced a dynamic to in the DSL that uses the simple language for dynamic computed endpoint uri, and sends the message to that single endpoint. For more advanced use-cases the answer is still recipient list, as it can send to multiple endpoints, in parallel, and do aggregation and much more.

So the example from the FAQ


Where the solution with recipient list would be:


Can now easily be done using toD


In XML DSL you would use

We made to and toD separated on purpose. As the former allows Camel to optimize as it knows its a static endpoint, and the latter is dynamic.

The dynamic to is also supported in a few other EIPs such as WireTap, and in the rest-dsl.

2. Enrich and PollEnrich now supports dynamic endpoints.

Because of the new dynamic to, with toD, it made headway for being able to introduce this into the Content Enricher EIPs for enrich and pollEnrich. This has been on popular demand for a number of years, but was initially planned as a Camel 3.0 change. This works as toD does by supporting the simple language in the URI.

A little example:


Notice how we can refer to the header using ${header.orderId}.

3. All inclusive Component documentation

We have 199 components (some are variations such as ftp sftp etc) in this release. And for every single option you can configure on the component or the endpoint is now documented with javadoc.

That documentation is then extracted during the build process which makes it available at runtime, which you can access using Java API, JMX, or the Camel commands.

We have also started the process to label (think as a tag/badge) each option so you can see whether the option is for consumer, producer, security, advanced, and so on. This is an ongoing process, but we have done this for the components that has the most options.

This is a a continuation of the effort we started all way back in Camel 2.12. The previous Camel 2.15 release had a lot of documentation, which I have blogged about. With Camel 2.16 we now have 100% coverage of the documentation, and we have enabled a validation check during the build that will fail of options lack documentation.

With this functionality tooling such as hawtio can make beautify UI to present information about your Camel application such as shown below:

hawtio shown at runtime endpoint properties how its configured. The options is grouped in tabs.

4. More deep level JMX statistics

We have overhauled all the EIPs to offer more runtime statistics about the EIPs. For example the Content Based Router now allows to list all the predicates, and break-down which of these predicates have been used the most. The load balancer EIPs also exposes statistics such as their current state, which exception has been triggered the most, and so on. That goes around for all the various EIPs. In addition the configuration of the EIP is also exposed.

We also managed to make it possible to have your custom Camel components or Java Beans mixin their custom JMX attributes and operations together with the standard set of attributes/operations from Camel. Before that was not possible and it would be only yours that was available. I have blogged about this previously.

5. Incoming and Outgoing Endpoints

We now keep track of all the incoming and outgoing endpoints in the endpoint registry. The registry is accessible from Java, JMX, and the Camel commands. The registry also keep track of how often each endpoint is in use, so you can know which ones are the most in use.

I have previously blogged about this, and recorded a video to demonstrate this in action.

6. Swagger 2.0 in pure Java

The swagger component has been ported to Java as a new camel-swagger-java module, and upgraded to the swagger 2.0 spec. We also integrated the camel-swagger-java to the rest-dsl, and being able to use the selected HTTP component of choice. So if you use jetty with rest-dsl then the swagger module can reuse that for exposes the api docs over HTTP. The old module that is Scala based is deprecated and was only able to expose the api docs using a servlet.

I have previously blogged about this and recorded a video of this in action.

7. rest-dsl improvements

You can now configure documentation for the parameter mapping of the rest service, for query parameters, path, body, and so on.

You can find more details from a little example that is shipped in Apache Camel.

8. Script DSL

We introduced a dedicated script in the DSL, to allow executing a script during routing, which by default does not modify your message. We found a number of users wanting to do this, but had a bit pain to use the language component and remember to set transform=false. With the script DSL it stands out in the route.

A little example to run some groovy script

  <from uri="file://inbox"/>
    <groovy>// some groovy code goes here</groovy>
  <beanRef ref="myServiceBean" method="processLine"/>

9. Camel proxy easier to use with parameter binding enabled

If you use Camel proxy to hide middleware behind an interface, then when invoking the method(s) on the interface, now performs parameter binding up-front. We found out this is more intuitive and allows to map to these parameters from the message body/headers etc, just as you would do with the bean component.

See more detail at Camel proxy.

10. A few other great new stuff

The file consumer now supports a read lock mode using idempotent. This allows safely to have clustered file consumers compete a shared file system for the same files, to ensure exclusive read lock controlled by a idempotent repository of choice, for example using hazelcast.

We also provides Maven archetypes for creating microservice style using spring-boot and cdi.

The aggregator supports a pre completion mode that allows the incoming message to complete previous group and start a new group with itself as the first message.

11. More components

There is 12 new components, and 3 new data formats.

  • camel-paho - For MQTT messaging using Eclipse Paho client
  • camel-pdf - For creating PDF documents
  • camel-grape - allows you to fetch, load and manage additional jars when CamelContext is running.
  • camel-slack - allows you to connect to an instance of Slack and delivers a message contained in the message body via a pre established Slack incoming webhook.
  • camel-jolt - for JSON to JSON transformation
  • camel-aws-ec2 - Component providing support to Amazon Web Services EC2 
  • camel-undertow - To use Undertow as HTTP server or client.
  • camel-git - A generic Git component
  • camel-sjms - SJMS Batch is a specialized component for highly performant, transactional batch consumption from a JMS queue
  • camel-http-common - A common base component for reuse among all the various HTTP components we have.
  • camel-swagger-java - A pure Java based Swagger component.
  • camel-elsql - An extended SQL Component that uses ElSql for defining SQL queries
  • camel-jbpm - Sends messages through kie-remote-client API to jBPM. 

For example there is a generic git component, a pdf component to output PDF documents, and a new batching JMS component that allows to batch X number of JMS messages and aggregate them into a single message all within a transactional boundary.

For a detailed list of changes in this release, see the Camel 2.16 release notes. As always make sure to read the important changes to consider when upgrading section, when you are upgrading from an older Camel release.


Cheers - Two new releases today - hawtio and Apache Camel 2.16

Today we had dual releases of both hawtio and Apache Camel.

I recorded a little video where I show hawtio in action to demonstrate some of the new functionality that hawtio can do with Camel.

Video shows hawtio with Camel and the latest bells and whistles
I hope to get time next week to do a blog post on the impressive Apache Camel 2.16 release to highlight the great new stuff it comes with. But as some of you may know I have a lot of writing on my mind with also the Camel in Action 2nd edition in the works.

Cheers and have a great weekend.