You are viewing a plain text version of this content. The canonical link for it is here.

Posted to dev@karaf.apache.org by Guillaume Nodet <gn...@gmail.com> on 2013/01/25 12:08:35 UTC

Fwd: [ANN] hawtio: a new lightweight HTML5 console for Apache Camel, ActiveMQ, JMX, OSGi & Fuse Fabric

FYI, I'm really excited about finally being able to have a unified web
console for Karaf / ActiveMQ / Camel, especially the fact that the same web
console can be used in a non OSGi-environment, so we can really leverage
and work together on a single web console.
I'd encourage everyone to have a look at it and eventually look at what's
missing from a Karaf point of view so that we can discuss if/how we
integrate it.

---------- Forwarded message ----------
From: James Strachan <ja...@gmail.com>
Date: Fri, Jan 25, 2013 at 10:59 AM
Subject: [ANN] hawtio: a new lightweight HTML5 console for Apache Camel,
ActiveMQ, JMX, OSGi & Fuse Fabric
To: "users@camel.apache.org" <us...@camel.apache.org>


For the impatient just look here :) http://hawt.io/

Background
==========
We've had numerous consoles all over the place for some time in
various projects like Felix, Karaf, ActiveMQ, Camel, Tomcat, Fuse
Fabric to name but a few. Many of them quite heavy weight requiring a
custom web app to be deployed (which often is quite large); none
particularly working together.

We've been working on Fuse Fabric and its management console to
provide a more consolidated view of a cluster of Apache integration &
middleware technologies. Increasingly we're seeing our users and
customers using different combinations of technologies in different
containers (e.g. Tomcat + ActiveMQ or Karaf + Camel or Fuse Fabric +
Karaf + ActiveMQ + Camel or whatever).

So for a few months a few of us have been working on trying to make
the various web consoles for things like Apache Camel, ActiveMQ,
Felix/Karaf/OSGi & Fuse Fabric (long with more generic things like JMX
& OSGi) available as lightweight HTML5 plugins so they can be mixed
and matched together to suite any container and combination of
technologies that folks deploy in a JVM.


hawtio
=====
The result so far is hawtio: http://hawt.io/

You can deploy it as a WAR in any JVM (or feature in karaf) and it
provides a UI console for whatever it finds in the JVM. So it works
with Tomcat / Jetty / Karaf / JBoss / Fuse Fabric; and has plugins for
JMX, OSGi, ActiveMQ, Camel & Fuse Fabric so far with others on the
way.

The nice thing is its pretty small (about 1Mb WAR containing all the
server side code, HTML, JS, images, CSS etc). The only real server
side component is jolokia which is a small (about 300K) REST connector
for JMX (which is awesome BTW!) - the rest is static content (which
could be served from anywhere so doesn't need to be deployed in each
JVM).

Its based around a plugin architecture:
http://hawt.io/developers/plugins.html

so its easy to add new plugins for any kind of technology. A plugin is
pretty much anything that runs in a browser.

The nice thing is hawtio can discover UI plugins at runtime by
examining the contents of the JVM or querying REST endpoints; so the
UI can update in real time as you deploy new things into a JVM!


hawtio, the hawt camel rider
======================
A quick summary of the current features for camel folks:

* If you have any camel contexts running in a JVM when hawtio starts
up it adds an Integration tab which shows all the camel contexts
running.

* You can start/stop/suspend/resume the context and its routes; then
look at all the metrics for routes/endpoints/processors. The Charts
tab lets you visualise the real time metrics.

* You can create new endpoints; browse endpoints which are browsable &
send messages to endpoints (with syntax editing support for JSON / XML
/ YAML / properties)

* You can visualise all the camel routes or a specific camel route for
a context in the Diagram tab and see real time metrics of how many
messages are passing through each step on the diagram. e.g.
https://raw.github.com/hawtio/hawtio/master/website/src/images/screenshots/camelRoute.png

* Clicking on a Route allows you to Trace it; when tracing if you send
a message into a route then it captures a copy of the message at each
point through the route. So you can step through (scroll/click through
the table) a route and see the message contents and how the message
flows through the EIPs - highlighting where on the diagram each
message is. This is very handy for figuring out why your route doesn't
work :) Spot where the heading disappears! Or see why the CBR doesn't
go where you expected.

In general most of the runtime features of the open source Fuse IDE
eclipse tooling are now supported in the camel hawtio plugin; so
available in a web browser.


Summary
=======
So if you're vaguely interested in web consoles for Apache Camel I
urge you to give it a try. We love contributions and feedback!
http://hawt.io/contributing/index.html

or feel free to raise new issues for how to improve the camel plugin:
https://github.com/hawtio/hawtio/issues?labels=camel&page=1&sort=updated&state=open

or if you've an itch for a new kind of plugin please dive in! We
should be able to expose existing web apps/consoles as links inside
hawtio too BTW.

Feedback appreciated! Its hawt, but stay cool! ;)

--
James
-------
Red Hat

Email: jstracha@redhat.com
Web: http://fusesource.com
Twitter: jstrachan, fusenews
Blog: http://macstrac.blogspot.com/

Open Source Integration



-- 
------------------------
Guillaume Nodet
------------------------
Red Hat, Open Source Integration

Email: gnodet@redhat.com
Web: http://fusesource.com
Blog: http://gnodet.blogspot.com/

Re: Fwd: [ANN] hawtio: a new lightweight HTML5 console for Apache Camel, ActiveMQ, JMX, OSGi & Fuse Fabric

Posted by Jean-Baptiste Onofré <jb...@nanthrax.net>.

I would also like to see an update about a "merge" between HawtIO and 
Karaf WebConsole.
As reminder, Karaf WebConsole has been designed as a container hosting 
Karaf, ActiveMQ, Camel, etc, exactly the same purpose as HawtIO.
Of course HawtIO is not Apache or Karaf subproject now, but it could be 
interesting to see "overlap"/gaps and where the two projects have to 
move together (or not ;)).

Regards
JB

On 01/25/2013 12:08 PM, Guillaume Nodet wrote:
> FYI, I'm really excited about finally being able to have a unified web
> console for Karaf / ActiveMQ / Camel, especially the fact that the same web
> console can be used in a non OSGi-environment, so we can really leverage
> and work together on a single web console.
> I'd encourage everyone to have a look at it and eventually look at what's
> missing from a Karaf point of view so that we can discuss if/how we
> integrate it.
>
> ---------- Forwarded message ----------
> From: James Strachan <ja...@gmail.com>
> Date: Fri, Jan 25, 2013 at 10:59 AM
> Subject: [ANN] hawtio: a new lightweight HTML5 console for Apache Camel,
> ActiveMQ, JMX, OSGi & Fuse Fabric
> To: "users@camel.apache.org" <us...@camel.apache.org>
>
>
> For the impatient just look here :) http://hawt.io/
>
> Background
> ==========
> We've had numerous consoles all over the place for some time in
> various projects like Felix, Karaf, ActiveMQ, Camel, Tomcat, Fuse
> Fabric to name but a few. Many of them quite heavy weight requiring a
> custom web app to be deployed (which often is quite large); none
> particularly working together.
>
> We've been working on Fuse Fabric and its management console to
> provide a more consolidated view of a cluster of Apache integration &
> middleware technologies. Increasingly we're seeing our users and
> customers using different combinations of technologies in different
> containers (e.g. Tomcat + ActiveMQ or Karaf + Camel or Fuse Fabric +
> Karaf + ActiveMQ + Camel or whatever).
>
> So for a few months a few of us have been working on trying to make
> the various web consoles for things like Apache Camel, ActiveMQ,
> Felix/Karaf/OSGi & Fuse Fabric (long with more generic things like JMX
> & OSGi) available as lightweight HTML5 plugins so they can be mixed
> and matched together to suite any container and combination of
> technologies that folks deploy in a JVM.
>
>
> hawtio
> =====
> The result so far is hawtio: http://hawt.io/
>
> You can deploy it as a WAR in any JVM (or feature in karaf) and it
> provides a UI console for whatever it finds in the JVM. So it works
> with Tomcat / Jetty / Karaf / JBoss / Fuse Fabric; and has plugins for
> JMX, OSGi, ActiveMQ, Camel & Fuse Fabric so far with others on the
> way.
>
> The nice thing is its pretty small (about 1Mb WAR containing all the
> server side code, HTML, JS, images, CSS etc). The only real server
> side component is jolokia which is a small (about 300K) REST connector
> for JMX (which is awesome BTW!) - the rest is static content (which
> could be served from anywhere so doesn't need to be deployed in each
> JVM).
>
> Its based around a plugin architecture:
> http://hawt.io/developers/plugins.html
>
> so its easy to add new plugins for any kind of technology. A plugin is
> pretty much anything that runs in a browser.
>
> The nice thing is hawtio can discover UI plugins at runtime by
> examining the contents of the JVM or querying REST endpoints; so the
> UI can update in real time as you deploy new things into a JVM!
>
>
> hawtio, the hawt camel rider
> ======================
> A quick summary of the current features for camel folks:
>
> * If you have any camel contexts running in a JVM when hawtio starts
> up it adds an Integration tab which shows all the camel contexts
> running.
>
> * You can start/stop/suspend/resume the context and its routes; then
> look at all the metrics for routes/endpoints/processors. The Charts
> tab lets you visualise the real time metrics.
>
> * You can create new endpoints; browse endpoints which are browsable &
> send messages to endpoints (with syntax editing support for JSON / XML
> / YAML / properties)
>
> * You can visualise all the camel routes or a specific camel route for
> a context in the Diagram tab and see real time metrics of how many
> messages are passing through each step on the diagram. e.g.
> https://raw.github.com/hawtio/hawtio/master/website/src/images/screenshots/camelRoute.png
>
> * Clicking on a Route allows you to Trace it; when tracing if you send
> a message into a route then it captures a copy of the message at each
> point through the route. So you can step through (scroll/click through
> the table) a route and see the message contents and how the message
> flows through the EIPs - highlighting where on the diagram each
> message is. This is very handy for figuring out why your route doesn't
> work :) Spot where the heading disappears! Or see why the CBR doesn't
> go where you expected.
>
> In general most of the runtime features of the open source Fuse IDE
> eclipse tooling are now supported in the camel hawtio plugin; so
> available in a web browser.
>
>
> Summary
> =======
> So if you're vaguely interested in web consoles for Apache Camel I
> urge you to give it a try. We love contributions and feedback!
> http://hawt.io/contributing/index.html
>
> or feel free to raise new issues for how to improve the camel plugin:
> https://github.com/hawtio/hawtio/issues?labels=camel&page=1&sort=updated&state=open
>
> or if you've an itch for a new kind of plugin please dive in! We
> should be able to expose existing web apps/consoles as links inside
> hawtio too BTW.
>
> Feedback appreciated! Its hawt, but stay cool! ;)
>
> --
> James
> -------
> Red Hat
>
> Email: jstracha@redhat.com
> Web: http://fusesource.com
> Twitter: jstrachan, fusenews
> Blog: http://macstrac.blogspot.com/
>
> Open Source Integration
>
>
>

-- 
Jean-Baptiste Onofré
jbonofre@apache.org
http://blog.nanthrax.net
Talend - http://www.talend.com

Re: Fwd: [ANN] hawtio: a new lightweight HTML5 console for Apache Camel, ActiveMQ, JMX, OSGi & Fuse Fabric

Posted by James Strachan <ja...@gmail.com>.

On 25 January 2013 17:22, Christian Schneider <ch...@die-schneider.net> wrote:
> I have not looked into HawtIO in detail but the idea of having a general
> console with plugins for each technology sounds good to me.
> I also think it is good to start such a console separately in github as
> it allows for fast progress to show it works.

Agreed. github has great tools as well; plus its got the lowest
barrier to entry which encourages participation.

> For the long term I think that the generic part of such a console should
> move into an apache project. As it makes sense to keep the console
> independent of OSGi a separate project may make sense.
> So why should we do this in apache? The reason is that currently HawtIO
> is just another console. Only at a big community like apache we can hope
> for a project to get enough acceptance that a lot of projects participate.
>
> So if we succeed in creating an accepted generic foundation for
> management consoles then each of the technology plugins could be
> developed in the respective projects.
>
> What do you think about this?

It could move to Apache one day. I'm much more keen though to get
folks contributing and writing plugins - those plugins could live at
github, eclipse, inside their respective Apache projects or in a new
Apache UI project or whatever. Though actually having the UI console
in a separate project kinda helps (e.g. hawtio works with all versions
of Camel).

Everything's Apache licensed so any project can reuse / embed / extend
hawtio wherever folks wish; plus folks can create their own stand
alone consoles in any project - or just write and release their own
plugins from any project anywhere.

--
James
-------
Red Hat

Email: jstracha@redhat.com
Web: http://fusesource.com
Twitter: jstrachan, fusenews
Blog: http://macstrac.blogspot.com/

Open Source Integration

Re: [ANN] hawtio: a new lightweight HTML5 console for Apache Camel, ActiveMQ, JMX, OSGi & Fuse Fabric

Posted by James Strachan <ja...@gmail.com>.

On 27 January 2013 18:25, Christian Müller <ch...@gmail.com> wrote:
> ... and to make it precise. By writing "fighting for it" I mean:
> - add missing features to Karaf WebConsole
> - provide better documentation (for users and developers)
> - make it as easy as possible to install it
> -  and whatever you can do to improve Karaf WebConsole.

It doesn't have to be a fight :). There's no reason Karaf WebConsole
can't reuse any/all of hawtio's plugins (e.g. for Camel / ActiveMQ /
JMX) or for Karaf WebConsole to expose all its Karaf views as a plugin
to hawtio; so users get the best of both worlds.

--
James
-------
Red Hat

Email: jstracha@redhat.com
Web: http://fusesource.com
Twitter: jstrachan, fusenews
Blog: http://macstrac.blogspot.com/

Open Source Integration