Some great Hawtio videos by Robin Huiser

Recently Robin Huiser recorded three videos of demonstrating hawtio in action. I just wanted to help spread the word of his videos, as I enjoyed watching them.

hawtio videos by Robin Huiser

hawtio is a true agnostic web console that supports anything running in a Java JVM. Robin uses Talend ESB as his container for hosting Camel applications. You can of course run Camel anywhere as well, so you can also use Apache Karaf / ServiceMix / JBoss Fuse / Wildfly or any other platform of choice, and hawtio "just works".

The three videos is about 10 minutes give or take, so grab yourself a cup of coffee and sit back and enjoy.

Links to the videos on youtube.

• Part 1
• Part 2
• Part 3

Have a great new years even and see you in 2015 for a great year of Camel and hawtio. There is a ton of new stuff coming in Camel 2.15 that makes hawtio and Camel even more awesome.

Apache Camel please explain me what these endpoint options mean

In the upcoming Apache Camel 2.15, we have made Camel smarter. It is now able to act as a teacher and explain to you how its configured and what those options mean.

The first lesson Camel can do is to tell you how all the endpoints have been configured and what these option mean.

Lessons we are working on next is to let Camel explain the options for the EIPs are.

Okay a picture is worth a thousand words, so let me show a screenshot from Apache Karaf, where you can use the new endpoint-explain command to explain how the endpoints have been configured.

The screenshot from Apache is from the SQL example which I have installed in Karaf. This example uses a number of endpoints, and among those a timer to trigger every 5 seconds. As you can see from above, the command list the endpoint uri: timer://foo?period=5s and then explain the option(s) below. As the uri only has 1 option, there is only one listed. We can see that the option is named period. Its java type is a long. The json schema type is integer. We can see the value is 5s, and below the description which explains what the value does.

So why is there two types listed? The idea is that there is a type that is suitable for tooling etc, as it has a simpler category of types accordingly to the JSonSchema specification. The actual type in Java is listed as well.

The timer endpoint has many more options, so we can use the --verbose option to list all the options, as shown below:

The explain endpoint functionality is also available as JMX or as Java API on the CamelContext. For JMX each endpoint mbean has an explain operation that returns a tabular data with the data as above. This is illustrated in the screenshot below from jconsole:

In addition there is a generic explainEndpointJson operation on the CamelContext MBean, this allows to explain any arbitrary uri that is provided. So you can explain endpoints that are not in use by Camel.

So how does this works?

During the built of the Apache Camel release, for each component we generate a HTML and JSon schema where each endpoint option is documented with their name, type, and description. And for enums we list the possible values.

Here is an example of such a json schema for the camel-sql component:

Now for this to work, the component must support the uri options, which requires to annotation the endpoint with the @UriEndpoint. Though the Camel team has not migrated all the 160+ components in the Camel release yet. But we plan to migrate the components over time.

And certainly now where we have this new functionality, it encourages us to migrate all the components.

So where do we get the documentation? Well its just java code, so all you have to do is to have getter/setter for an endpoint option. Add the @UriParam annotation, and for the setter you just add javadoc. Yes we grab the javadoc as the documentation. So its just documented in one place and its in the source code, as standard javadoc.

I hope we in the future can auto generate the Camel website documentation for the components, so we do not have to maintain that separately in its wiki system. But that would take hard work to implement. But eventually we should get there, so every component is documented in the source code. For example we could have a readme.md for each component that has all the component documentation, and then the endpoint options is injected from the Camel built system into that readme.md file automatic. Having readme.md files also allow github users to browse the Camel component documentation nicely using github style ;o

So what is next?

The hawtio web console will integrate this as well, so users with Camel 2.15 onwards have that information in the web console out of the box.

And then its onwards to include documentation about the EIP in the XML schemas for Spring/Blueprint users. And improve the javadoc for the EIPs, as that then becomes the single source of documentation as well. This then allows tooling such as Eclipse / IDEA / Netbeans and whatnot to show the documentation when people develop their Camel routes in the XML editor, as the documentation is provided in the XSD as xsd:documentation tags.

We have captured some thoughts what else to do in the CAMEL-7999 ticket. If you have any ideas what else to improve or whatnot, then we love feedback from the community.

66th Apache Camel release is out - its the 2.14 release

Today Apache Camel 2.14.0 hit the streets. Its our 66th release (include all patch releases) since the project was created over 7 years ago.

There is a bunch of great stuff in this release, so let me try to distill a list of 10 highlights (in no particular order)


1) Java 8 support
The 2.14.x branch marks the 1st release where we officially support Java 8. We made sure the code compiles and all tests passes on Java 8 also. We also support Java 7.

Now you may ask about all the coolness from Java 8 about lambda's and whatnot. Yeah we are looking into that for the next release to provide examples and a first cut of a Java 8 based DSL.


2) Spring 4 support
The same goes here. We now support Spring 4.x also. There is one migration effort, as Spring 3.x and 4.x is not compatible when using spring testing. So we had to introduce a camel-test-spring3 module for Spring 3.x users, and camel-test-spring is for 4.x users. Also there is a known issue in camel-test-spring about Spring 4.1.x support which we will fix in the next patch release.


3) Rest DSL
This is likely one of the most exciting new features in this release. We now offer a REST styled DSL which can be used with Java or XML. The intention is to allow end users to define REST services using a REST style with verbs such as get, post, delete etc.

Here is a small taste of it in action:

rest("/customers/")     .get("/{id}").to("direct:customerDetail")     .get("/{id}/orders").to("direct:customerOrders")     .post("/neworder").to("direct:customerNewOrder");

The DSL can be used in both Java and XML. As this is the 1st release with the Rest DSL we will of course continue to improve on this, and certainly based on the feedback from the community.


4) Netty 4.x support
We now have support for both Netty 3.x and 4.x. As we take backwards compatibility seriously we decided to leave camel-netty as-is for Netty 3.x users, and port the code to a new camel-netty4 for Netty 4.x users. The same goes for the camel-netty-http and camel-netty-http4 modules.


5) API component
Dhiraj Bodke worked on a great new API component support in camel-core, that makes creating new Camel components for APIs much easier and faster. We use this to integrated with new components such as box, linkedin, google-drive, and salesforce and what else comes in the future. He wrote a great blog about this component and how to use it. So expect many more of these API components in upcoming releases.


6) More JMX MBeans
We now also enlist producers in JMX, and as well have a registry to capture runtime usage of endpoints, which allows you to "see" which endpoints are in use, and as well how endpoints may be shared across routes, e.g. sending to queue A in route 1 and consume from queue A in route 2. All based on dynamic usage such as dynamic patterns like the recipient list.

The aim is to provide better understand how your Camel routes are being used at runtime. We will continue to improve tooling in this area such as hawtio, and the Camel Karaf commands, etc.


7) Codahale metrics
And continued from #6 we also have a new camel-metrics component to integrate with the excellent codahale metrics library. On top of that we also allow to use this to capture Camel routing statistics using codehale. This can then be used with existing codahale tooling and also with hawtio. I wrote a blog about this earlier.

The screenshot below illustrates routing information captured by camel-metrics and displayed by hawtio in the new route metrics tab which supports codahale.

camel-metrics used to capture routing statics which can be displayed in hawtio using the new route metrics tab.

8) Circuit breaker EIP
We introduce a new EIP using the circuit breaker pattern.


9) Swagger integration
We have a new camel-swagger module that in combination with the Rest DSL allows to expose an API documentation of your REST services. This can then be used with existing swagger tooling and web consoles. For example hawtio has a swagger console out of the box, such as shown below

Camel example using the new Rest DSL which offers swagger API documentation, which can be viewed using a swagger console such as offered by hawtio

10) And the usual stuff
We added 15 new components, 1 new EIP, 1 new data format, and 1 new language. And as usual a bunch of bug fixes, improvements and hardening.  And we dropped support for Java 6.


If you want to see some of the new stuff in action, then you can try the new examples. We have the camel-example-servlet-rest-tomcat. This is a plain WAR file which you can run in Apache Tomcat, Jetty, Wildfly, fabric8 or any other web container. Then you can see both the new Rest DSL, Swagger and codehale metrics in action, all in the same application. And for hawtness then try deployed hawtio as well and see what it can do as well.

The same example is also available for Karaf users by the camel-example-servlet-rest-blueprint.



You can find more details about this release in the 2.14 release notes. And if you are upgrading from a previous release, then make sure to read about the changes that may effect you.

You can get this release from Maven Central and download from the Apache Camel website.

More metrics in Apache Camel 2.14

Apache Camel 2.14 is being released later this month. There is a slight holdup due some Apache infrastructure issue which is being worked on.

This blog post is to talk about one of the new functions we have added to this release. Thanks to Lauri Kimmel who donated a camel-metrics component, we integrated with the excellent codehale metrics library.

So I took this component one step further and integrated it with the Camel routes so we have additional metrics about the route performances using codehale metrics. This allows end users to seamless feed Camel routing information together with existing data they are gathering using codehale metrics.

Also take note we have a lot of existing metrics from camel-core which of course is still around.

What codehale brings to the table is that they have additional statistical data which we do not have in camel-core.

To use the codehale metics all you need to do is:

1. add camel-metrics component
2. enable route metrics in XML or Java code

To enable in XML you declare a as shown below:

  &;t;bean id="metricsRoutePolicyFactory"
        class="org.apache.camel.component.metrics.
               routepolicy.MetricsRoutePolicyFactory"/>

And doing so in Java code is easy as well by calling this method on your CamelContext

  context.addRoutePolicyFactory(new MetricsRoutePolicyFactory());

Now performance metrics is only useable if you have a way of displaying them, and for that you can use hawtio. Notice you can use any kind of monitoring tooling which can integrate with JMX, as the metrics is available over JMX. The actual data is 100% codehale json format, where a piece of the data is shown in the figure below.

Sample of the route metrics JSON data

The next release of hawtio supports Camel 2.14 and automatic detects if you have enabled route metrics and if so, then shows a sub, where the information can be seen in real time in a graphical charts.

hawtio have detected that we have route metrics enabled, and shows a sub tab where we can see the data in real time

The screenshot above is from the new camel-example-servlet-rest-tomcat which we ship out of the box. This example demonstrates another new functionality in Camel 2.14 which is the Rest DSL (I will do a blog about that later). This example enables the route metrics out of the box, so what I did was to deploy this example together with hawtio (the hawtio-default WAR) in Apache Tomcat 8.

With hawtio you can also build custom dashboards, so here at the end I have put together a dashboard with various screens from hawtio to have a custom view of a Camel application.

hawtio dashboard with Camel route and metrics as well control panel to control the route(s), and the logs in the bottom.

Apache Camel 2.14 on the way

This is just a little blog update to say that we are working on the final touches for the next release of Apache Camel which is version 2.14.

We have a discussion thread on the Apache Camel mailing list where you can provide feedback and follow the process.

There is a lot of great stuff in this release which I frankly need to blog about when I get a chance and spirt to write.

After getting some bug fixes into the Camel codebase today I plan to work on finishing the codehale metrics UI in hawtio. This allows Camel end users to easily add additional metrics about their route performances, using the metrics from codehale. We then use a metrics javascript ui, which we then integrate in hawtio, which makes it possible to render live charting which is shown in a screenshot below:

Camel routes using codehale metrics statistics, rendered in real time

Another great new functionality in Camel 2.14, is the new DSL for rest services, though that warrants a blog entry by itself. And we also integrated with Swagger, so these REST services can provide an API out of the box.

The Apache Camel 2.14 release is expected out in September 2014. We will try to see if we are ready next week to start cutting the release.

If you have anything you want included or fixed then its time now to speak up.

Developer Interview with me about Apache Camel

Today I had a nice talk with Markus Eisele whom run a series of developer interviews. I was lined up today.

The main topic was of course Apache Camel which is my primary area of interest and work for the last 6 years or so. But we do have a bit of time to talk a little about other cool projects such as hawtio, jolokia, vertx and whatnot. I also talked about my background and how I discovered and got involved with the Apache Camel project about 6,5 - 7 years ago.

As I talked a bit too much then the video is about 35 minutes, so it requires 2 cup of coffee to watch it end to end. But half way through I share my deskop and do some demoing. I have to talk Bilgin Ibryam for creating his lovely Camel Olympics demo, which I used as the 2nd demo.

You can find Markus blog here, to keep an eye on his developer interview series, and also find the past recordings.

Meet Fabric8 and video of fabric8 provisioning Apache Tomcat

Recently my fellow colleague Christian Posta wrote two great blog entries about fabric, which I want to share to you.

The new fabric8 logo

In his Meet Fabric8: An open-source integration platform based on Camel and ActiveMQ, Christian introduces us to fabric8, and talks about what fabric8 brings to the table from a DevOps perspective, and some of the other value-adds. Christian also talks about the history of the project.

In his 2nd blog DevOps with Apache Tomcat/TomEE and Fabric8, Christian talks and demonstrates some of the upcoming functionality in the next 1.1 beta7 release, where fabric8 adds support for provision and manage Apache Tomcat, and other containers. Christian recorded a video demonstrating this in action.

We are currently working hard on getting the last pieces into the 1.1 beta7 release which ought to be released this week. We have also worked on revamping the fabric8 website, and working on having the documentation in a nice bookish readable format, and as in PDF as well. The documentation is nicely readable now on handheld devices. I am also putting my touches on improving the quickstarts and examples to provide a lot more documentation and how-to. So expect the documentation, quickstarts, and other examples to have out attention, leading up to the 1.1 release.

We want to do a bunch of beta releases, as this makes it much easier for the community to try out fabric8, and help contribute to the project, before we reach 1.1 final release (ETA sometimes after the summer vacation).

Apache Camel, Groovy and hawtio at gr8conf

Today I presented Apache Camel at the gr8conf, which is a Groovy conference. So in my talk I presented what Camel can do with Groovy today.

Giving a talk about Apache Camel and Groovy at gr8conf 2014 in Copenhagen

The talk was recorded and will be later published by the gr8conf organizers. So keep an eye on their website when that happens.

Being here at the gr8conf is fun and a great event. I love how the groovy community and ecosystem has been able to establish this annual conference, running at its 6 year now. Also I take my hat off for the great people of the groovy team that do the great work on this language, that is now over 10 years old.

In my talk I also demonstrated hawtio which is a great web console, and a project that is fun to work on. So to prepare for gr8conf I developed a plugin example for hatwtio that is a Groovy Shell, so you can execute groovy scripts from the web console.

The source code for the example is in github at: https://github.com/hawtio/hawtio/tree/master/hawtio-plugin-examples/groovy-shell-plugin

And the plugin can easily be installed in Apache Tomcat, Karaf, JBoss Fuse, fabric8 etc.

Custom plugin installed in hawtio running on Apache Tomcat

If you are interested in learning how to build custom plugins for hawtio, then I think the groovy shell plugin is a good example, as it has a bit of backend service, and a simple web page to go with that.

So in my day time work I have great fun working with great technologies like Apache Camel, hawtio, and fabric8. And also a bit fun when I get a chance to work a bit with Groovy too. Anyway I just wanted to say that all these four awesome technologies has something in common. They are created/co-created by a great entrepreneur in our industry.

A slide with 4 great technologies that has something in common ...

Okay there is almost beer'o'clock here at gr8conf, as the organizers have brewed their own groovy beers we are going to taste soon in the scroll bar ;)

xPaaS in Action - Video from Red Hat JBoss Middleware keynote

At Red Hat Summit and Devnation the middleware keynote was presented, where Burr Suttor and his team accepted the following mission.

xPaaS mission for the keynote demo

They really did it on stage building a data center on stage using bare metal commodity hardware, and installing OpenStack and OpenShift as the cloud platform. And then JBoss Fuse 6.1 on top of that.

Red Hat also announced the availability of JBoss Fuse 6.1 at the summit, so Burr and his team is using the actual GA release for the demo.

You can watch the keynote as it has been published to youtube, and their mission starts at about 23 minutes into the video.

Link to video: https://www.youtube.com/watch?v=XPK2RTqlBxk

hawtio 1.3.0 released and a bit news about the 1st fabric8 community release

So today on april 1st we released hawtio 1.3.0. Well we are likely not making the same headlines as others news would do on this aprils fool day. But nevertheless it yet another sign of a great community and project where we release often.

It sure also helps that the release procedure is streamlined and much easier than some of the other projects we work on from time to time.

This release hasn't so many new features as the previous 1.2.3 release. But we upgraded to latest jolokia as well fixed a number of bugs, and prepared hawtio to support the upcoming fabric8 community release. You can find the changes for hawtio in the changelog page.

So we are working on making the codebase for fabric8 ready for the 1st community release. There is still some ongoing refactoring of naming such as fusesource -> fabric8 etc, to ensure the entire codebase is not using a company name or company brand - it is 100% an open source and free community project, using the ASL 2.0 license and source code hosted at github.

In the mean time we are also hacking on some great new stuff making into this 1st community release. For example the fabric will be poly container, meaning that support for Apache Tomcat, and JBoss WildFly is in the works, and other containers to follow.

James Strachan is currently hacking on the Tomcat, and he got the first piece working today, as he mentioned on the public fabric8 chat room today

[18:17:12] <+jstrachan> yay, got the hawtio console up in tomcat and the containers view shows a container (but it thinks its still updating ;)

Surely we are going to blog with more details about fabric8 when the 1st community release is around the corner. We likely will do a number of beta releases before the GA.

JBoss Fuse on OpenShift - How to connect to twitter

I recently recorded a video using JBoss Fuse on OpenShift to deploy a new container which runs a Camel based application that polls twitter feeds and logs them.

JBoss Fuse on OpenShift Video

I did the initial recording, and then the good OpenShift folks polished the video and did a voice over, so the video appears more professional with a great narrator.

The video and transcript is now online on the OpenShift website here.

You can try all this by yourself, by following this getting started guide first, and then you can install the twitter application afterwards, as shown in the video.

- Getting started with JBoss Fuse on OpenShift
- JBoss Fuse on OpenShift: How to Connect to Twitter

Apache Camel 2.13.0 released

We have just released Apache Camel 2.13.0 which you can download from Apache, as well from Maven Central. This release is about 6 months of work since Camel 2.12.0 was released.

In this release the community have contributed a number of new components such as integration with Splunk, Apache Hadoop 2.x, Infinispan, JGroups, and a few others. We also have a component to integrate with Apache Kafka, but currently the documentations is outstanding.

The Splunk component was developed and contributed by Preben Asmussen, whom wrote a blog post about it in action.

A number of open source projects has migrated to use the ASL2 license which allows us to provide the Infinispan and JGroups components out of the box - Yeah the ASL2 license rocks!

There is also a new language that leverages JSonPath which makes routing using JSon payloads.

We also improved support for Spring 4.x, so you should be able to use Spring with this release. However the release is built and tested against Spring 3.2.8. If you have any trouble let us know, but we intended to upgrade for Spring 4.x for the next release.

This release comes with the usual hardening, improvements and bug fixes we do for each release.

You can find more information in the release notes, and make sure to read the sections in the bottom of the page, when you upgrade.

hawtio 1.2.3 Released - Screenshots of some of the new hawt stuff

Today we released hawtio 1.2.3 - yay that is a beautify version number ;) 1-2-3 hawtio is ready for download and use.

The highlights of this new release from the changelog includes:

• New hawtio Chrome Extension for easier connection to remote JVMs from your browser without having to run a hawtio server or connect through a web proxy
• Upgraded to TypeScript 0.9.5 which is faster
• threads plugin to monitor JVM thread usage and status.
• Moved java code from hawtio-web into hawtio-system
• Clicking a line in the log plugin now shows a detail dialog with much more details.
• ActiveMQ plugin can now browse byte messages.
• Improved look and feel in the Camel route diagram.
• Breadcrumb navigation in Camel plugin to make it easier and faster to switch between CamelContext and routes in the selected view.
• Added Type Converter sub tab (requires Camel 2.13 onwards).
• Better support for older Internet Explorer browsers.
• Lots of polishing to work much better as the console for fabric8
• Fixes these 175 issues and enhancements

I will like to showcase the chrome extension a bit more.

hawtio as chrome extension

In the last 1.2.2 release we had a preview of the Google Chrome Extension which now has been improved and polished. So let's kick of this blog by installing and using hawtio 1.2.3 in your google web browser.

Just follow the instructions on the getting started page. And hawtio should be available from the web browser as shown below.

What we would do next is to connect to the remote JVM which we want to manage and gain insight what happens in the JVM. For example to connect to the upcoming Apache ActiveMQ 5.10 message broker, you connect using the details shown in the screenshot.

And when connected to the broker, you can access the server log, and as well manage the broker, such as browsing the queues and topics, and much more.

Browsing remote ActiveMQ server log using hawtio directly from your web browser.

You can also launch hawtio using the Chrome App Launcher from your operating system. For example from my OSX I can click the app launch icon which now includes hawtio.

Launch hawtio as a native application from your OS

Another highlight is the improved look and feel of the Camel plugin. Though we are not done yet, so we would like feedback on this, as finding the right colors that everybody
likes isn't so easy :)

Improved Camel Diagram look and feel

The Camel diagram which shows the routes visually now shows the various EIPs using different colors. For example the Apache Camel Servlet Tomcat example is shown below:

Camel diagram improved with more colors

Also we added a breadcrumb functionality which is known in IDEA which makes switching between routes and endpoints in the Camel plugin faster. To use that click that double arrow on the top right corner of the Camel Tree as shown below:

Double arrow accesses the breadcrumb functionality for fast switching between routes and endpoints.

And we are also ready for the upcoming Apache Camel 2.13 release, which allows hawtio to list all the registered type converters, and associated utilization statistics, as illustrated below:

Camel 2.13 can now list all the registered type converters and their utilization

Another functionality I want to highlight is the Maven plugins we included in last release.

Maven Plugin to bootup with hawtio

For example we can bootup the examples that comes out of box with Apache Camel. For example to run the management example with the hawtio web console, all we do is.

davsclaus:~/Downloads$ tar xf apache-camel-2.12.3.tar.gz
davsclaus:~/Downloads$ cd apache-camel-2.12.3
davsclaus:~/Downloads/apache-camel-2.12.3$ cd examples/
davsclaus:~/Downloads/apache-camel-2.12.3/examples$ cd camel-example-management/
davsclaus:~/Downloads/apache-camel-2.12.3/examples/camel-example-management$ mvn compile io.hawt:hawtio-maven-plugin:1.2.3:camel

And hawtio opens a web page with hawtio ready to use. With that I can gain insight into the Camel example and see real time data from the routes, and so forth.

hawtio plugin launched together with the Camel Management Example

You can find more details about the hawtio Maven plugins here.

Want to learn more

You can find more details about hawtio at the website. Its 100% open source, and licensed using the permissive Apache License. The source code is at gihub.

At the DevNation conference next month, Stan Lewis, James Strachan, and myself is demonstrating and talking more about hawtio. For example James will talk about open source integration in the cloud, where hawtio is the console for JBoss Fuse and fabric8. Stan Lewis gives two talks about hawtio, one focused how you can extend and write your custom plugins, and as well how to skin the look and feel, to create your own custom consoles.

Fuse at the DevNation conference (CamelOne 2014)

I have previously blogged about CamelOne 2014 conference is now hosted as part of the DevNation conference.

The agenda is now complete, and its great to say that the Fuse team will be there presenting the latest cool stuff happening around projects like fuse/fabric8 and hawtio, and about Apache ActiveMQ and Camel too.

Make sure to be there on sunday for the fuse track, where you will hear from James, Rob, Ioannis about all the latest greatness that are part of fabric8 and hawtio. And where it stands with OpenShift, Docker, and all the lovely cloudiness that changes how we roll out and host our applications, in hybrid environments.

Rob wrote a blog entry which details more about what the DevNation conference is about, and what to expect from it. I suggest to continue reading here.

Hope to see you next month in San Francisco. And yeah the Fuse team love beers too, so hopeful a chance to meet and chat over a beer too - and not only coffee.

Apache Camel and JBoss Fuse rolled out to UK hospital

Before I joined the Fuse team 5 years ago I worked as a consultant in the health-care industry.

So its great to hear that Apache Camel, ActiveMQ as part of JBoss Fuse is rolled out to King's College Hospital in the UK, to integrate hospital systems, to help the care of the patients.

There is a press release from Red Hat with more details here.

To ServiceMix or not to ServiceMix

This morning an interesting topic was posted to the Apache ServiceMix user forum, asking the question: To ServiceMix or not ServiceMix.

In my mind the short answer is: NO

Guillaume Nodet one of the key architects and long time committer on Apache ServiceMix already had his mind set 3 years ago when he wrong this blog post - Thoughts about ServiceMix.

What has happened on the ServiceMix project was that the ServiceMix kernel was pulled out of ServiceMix into its own project - Apache Karaf. That happened in spring 2009, which Guillaume also blogged about.

So is all that bad? No its IMHO all great. In fact having the kernel as a separate project, and Camel and CXF as the integration and WS/RS frameworks, would allow the ServiceMix team to focus on building the ESB that truly had value-add.

But that did not happen. ServiceMix did not create a cross product security model, web console, audit and trace tooling, clustering, governance, service registry, and much more that people were looking for in an ESB (or related to a SOA suite). There were only small pieces of it, but never really baked well into the project.

That said its not too late. I think the ServiceMix project is dying, but if a lot of people in the community step up, and contribute and work on these things, then it can bring value to some users. But I seriously doubt this will happen.

PS: 6 years ago I was working as a consultant and looked at the next integration platform for a major Danish organization, and we looked at ServiceMix back then and dismissed it due its JBI nature, and the new OSGi based architecture was only just started. And frankly it has taken a long long time to mature Apache Karaf / Felix / Aries and the other pieces in OSGi to what they are today to offer a stable and sound platform for users to build their integration applications. That was not the case 4-6 years ago.


Okay No to ServiceMix - what are my options then?
So what should use you instead of ServiceMix? Well in my mind you have at least these two options.

1)
Use Apache Karaf and add the pieces you need, such as Camel, CXF, ActiveMQ and build your own ESB. These individual projects have regular releases, and you can upgrade as you need.

The ServiceMix project only has the JBI components in additional, that you should NOT use. Only legacy users that got on the old ServiceMix 3.x wagon may need to use this in a graceful upgrade from JBI to Karaf based containers.


2)
Take a look at fabric8. IMHO fabric8 is all that value-add the ServiceMix project did not create, and a lot more.

James Strachan, just blogged today about some of his thoughts on fabric8, JBoss Fuse, and Karaf. I encourage you to take a read. For example he talks about how fabric becomes poly container, so you have a much wider choice of which containers/JVM to run your integration applications. OSGi is no longer a requirement. (IMHO that is very very existing and potentially a changer).

I encourage you to check out fabric8 web-site, and also read the overview and motivation sections of the documentation. And then check out some of the videos.

After the upcoming JBoss Fuse 6.1 release, the Fuse team at Red Hat will have more time and focus to bring the documentation at fabric8 up to date covering all the functionality we have (there is a lot more), and as well bring out a 1.0 community released using pure community releases. This gives end users a 100% free to use out of the box release. And users looking for a commercial release can then use JBoss Fuse. Best of both worlds.


Summary

Okay back to the question - to ServiceMix or not. Then NO.
Innovation happens outside ServiceMix, and also more and more outside Apache.

If you have thoughts then you can share those in comments to this blog, or better yet, get involved in the discussion forum at the ServiceMix user forum.


PPS: The thoughts on this blog is mine alone, and are not any official words from my employer.

hawtio connecting to remote ActiveMQ brokers

hawtio which is an awesome web console allows you to manage your Java stuff. hawtio has a plugin for managing ActiveMQ brokers.

hawtio allows to run in one JVM and connect remotely to other JVMs. This allow you to have dedicated boxes with the management console, and leave it out of your production boxes which runs your ActiveMQ brokers, and other server stuff.  It also makes it easier to mange the network topology as people who need web access to the management console only need access to the boxes where the management console is hosted, and not direct access to your production servers. Only the boxes where the management console is hosted needs network connection to the production servers.

Anyway what I wanted to talk about in this blog, is how to use the latest hawtio 1.2.2 as a standalone application to connect to remote ActiveMQ brokers.

For this we use
- hawtio 1.2.2
- activemq 5.8.0

And in ActiveMQ 5.9 hawtio is shipped out of the box.

Starting hawtio

To do this we download the executable hawtio 1.2.2 which you can find on that big button on the getting started page.

To start hawtio we simply run this command from the command line:

java -jar hawtio-app-1.2.2.jar

This starts hawtio on port 8080, though you can specify the port number to use with --port option. For more information see the hawtio getting started page.

Connecting to ActiveMQ 5.8.0

We have Apache ActiveMQ 5.8.0 running on a box. For demonstration purpose I run it on my local laptop, and start ActiveMQ as follows:

davsclaus:/opt/apache-activemq-5.8.0$ bin/activemq console

Then from hawtio we click the Connect tab, and enter the details as shown in the screenshot below:

Connecting from hawtio to a remote ActiveMQ 5.8 broker

The username and password is by default admin/admin. Though that can be changed on the ActiveMQ broker, so make sure to use correct login credentials. And I use localhost as hostname because I run everything from the same box. But you can of course enter a DNS or IP name for remote connection.

When you are connected then the navigation bar in hawtio changes to which plugins are currently available running in that remote JVM. As its ActiveMQ 5.8 broker, you should see the ActiveMQ plugin, and can see broker details, as shown in screenshot below:

Connected to remote ActiveMQ 5.8 broker

hawtio as desktop/browser application

In the upcoming hawtio 1.2.3 release James has been cooking some cool stuff to run hawtio as a desktop app and as a browser extension.

A little sneak peak is shown below where you can see hawtio as a app in the Chrome browser.

hawtio as an application in the Chrome browser

There is a few things to iron out to have hawtio fully working as a desktop app and as browser extension. 

Back from Barcelona

Last week I presented Apache Camel, and we had also a workshop in Barcelona, hosted by the BarcelonaJUG.

This morning I am back in my office, and thought I wanted to post a follow up blog, including some photos of the event.

On the first day I gave a long presentation about Apache Camel, in a 90 minutes session.

After the presentation some of us went out for dinner, in a nice Spanish tappas restaurant, where we enjoyed the local cuisine.

On the left (front to back): Ignacio, Esteve, Adela
On the right (front to back): Jonathan, Claus, Yeradis.

Thanks to the BarcelonaJUG organizers for hosting a great event, and taking good care of their speakers.

On saturday we had a 4 hour workshop, where people bring their own laptop, and then we start riding the Camel, and make sure everyone get onboard. I must say the workshop really pays off, and I think this is something to consider doing more often.

It was not only Camel we learned about in the workshop. We also installed hawtio in the Tomcat that we have been using as container. It was great to see that everybody could easily install hawtio by just dropping the .war into webapps. And that people could then have fun with hawtio and try out its other plugins as well.

There was much interest in hawtio and we may in the future have another event focusing more on hawtio and also how you can customize/skin it, and as well how to build custom plugins, and what not.

At the end of the workshop we had about 20 minutes, and the audience was given a choice between doing some more Camel coding, or seeing a live demonstration of fabric8. To learn more about fabric8 then I suggest to check out some of the videos James Strachan has done recently.

I have upload my slides from the presentation to slideshare here. The slides for the workshop will follow up soon - just need to polish a few pages, and prepare some of the source code.

Apache Camel presentation and workshop in Barcelona

The Barcelona Java User Group have invited me to spread the words about Apache Camel. This time we are doing this over two days.

Barcelona JUG

The event takes place on friday 24th and saturday 25th January 2014. On friday I will introduce and present Apache Camel. And on saturday we have a workshop where you bring your laptop, and get hands on experience with riding the Camel.

The presentation and workshop will be in English - All I can say in Spanish is - Dos grande cervezas por favor. Though we would need that phrase friday evening where we go out for food and drinks.

You can find much more information about the event at the Barcelona JUG web site, where you also can register for the event. There is limited number of seats, so hurry up and reserve your seat.

Apache Camel Developer's Cookbook

Today I received my reviewer copy of the new Apache Camel Developer's Cookbook book which was recently published, and authored by Scott Cranton and Jakub Korab who are long term Camel riders

Fantastic book with over 100 recipes how to do stuff with Apache Camel

The book has a great looking Camel on the cover; Though we cannot see if the Camel has one or two humphs. But more importantly the book has over 400 pages, and more than 100 recipes how to do stuff with Camel. So its packed with great information and ready to use examples provided as unit tests in the accompanying source code. It's certainly a cookbook worth purchasing to be a great Camel rider.

To learn more about this book and what it covers I encourage you to read from the mouth itself by reading the announcement from Jakub on his blog.

Congratulations to Scott and Jakub for being published. 

Remember to buy a round of beers from the money you receive from your first batch of royalties ;)

CamelOne 2014 Call for Paper

For the last 3 years FuseSource/Red Hat hosted the CamelOne conferences. From this year onwards the CamelOne conference is now part of the DevNation conference.

DevNation 2014

The conference takes place in San Francisco in the famous Moscone center, co-hosted with Red Hat Summit.

If you have desire to talk at DevNation, then the call for paper is open until January 15th 2014, so hurry up and submit your proposals.

Andrew Rubinger, one of the organizers have blogged about the creation of the DevNation conference, which you can read here.

Hope to see you there in the famous city of San Francisco.