Celtix 1.0: First Impression

Fri, 26 May 2006 17:15:07 GMT

This month's OCI Java lunch is a special one, because we are fortunate enough to have secured the appearance of Dr. Weiqi Gao, who will be talking about a new open source product called Celtix.

First person is Weiqi now.

I first encountered Celtix about a month ago, and have been playing with it a little bit. I wrote a very preliminary experience report 16 days ago, mostly about some trivial stuff.

What is an ESB

An ESB is a piece of IT infrastructure that shoots (XML) messages across a message-oriented middleware core (JMS).

The term ESB was popularized by a David Chappell book of the same name. Now that it is popular, many products out there start to use the ESB buzzword to spruce up their brochures. The definition has also been broadened to include other transport protocols.

What is Celtix

Celtix is an open source (dual licensed: LGPL and Eclipse EPL) project hosted on the ObjectWeb community. It was started by IONA to drive adoption non-server centric, distributed computing architectures.

What can Celtix do

If you read the Celtix page at ObjectWeb, you will find a laundry list of internal product features that were delivered on a per milestone bases:

Persistence support for Reliable Messaging based on Apache Derby
HTTPS based security support
Support for Javascript based webservices.
Support for changing configuration dynamically
Management support for additional Celtix components
Support for wsdlvalidator commandline tool
Routing support for all Celtix bindings and transports
Enhanced routing capabilities
WS-Addressing support for JMS based services
Interoperability with .NET.
Support for Maven 2.0.4
Support for running Celtix inside Apache Tuscany
Support for Webservice callbacks

Support for JAX-WS Dispatch APIs
Support for JAX-WS Provider APIs
Support for non-wrapper Doc/Literal style
Celtix based javatowsdl tool
Celtix based wsdltojava tool
First cut of transport APIs
Enhanced binding API for better pluggability
Support for Protocol Handlers

Support for Logical Handlers
Support for Contexts
SOAP 1.1 support for doc/rpc literal
Support for SOAP 1.1 faults
Support for SOAP 1.1 headers
Support for JAX-WS Sync APIs
Support for JAX-WS One-Way APIs
Support for inout and out variables

HTTP 1.1 transport
HTTP servlet transport
JMS transport based on Active MQ
Support for WS-Addressing
Support for JAX-WS async client APIs
Policy based configuration
Support for StreamHandler APIs
WS-RM based support for Webservices Reliability

Support for JMX based management
XML Binding
New commandline tools: xsd2wsdl, wsdl2xml, wsdl2soap, wsdl2service
Native integration into Apache Geronimo J2EE appserver
Support for validating application data against XMLSchema
Enhanced support for deploying celtix services into a servlet container based on feedback from Jonas J2EE appserver project

Some of these makes sense to the end developer (meaning the developer who's going to use it). Some doesn't (what do I care if it's Maven 1 or Maven 2.)

Luckily, Celtix comes with a set of sample applications that showcases its capabilities:

callback
common_build.xml
configuration
dispatch_provider
handlers
hello_world
hello_world_async
hello_world_https
hello_world_RPCLit
hello_world_xml_bare
hello_world_xml_wrapped
integration
integration/dotnet/celtix-server-dotnet-client
integration/dotnet/dotnet-server-celtix-client
j2ee
jms_pubsub
jms_queue
js_provider
management
routing
soap_header
streams
ws_addressing
ws_rm

How does Celtix do it

The same as CORBA, only different:

SOAP messages
QoS: Reliability, Security, Transaction, Routing, Transformation
Transport: HTTP, HTTPS, JMS, TCP
Stuff down below

No app servers. But can be integrated with one.
Relies on Jetty for HTTP, ActiveMQ for JMS, etc.
Provides JAX-WS, JAXB implementations.

The development process

Write WSDL (basically XMS Schema for data types, composed into messages, exchanges with operations)
Generate Java code (or class files) for types, service proxy, service interface, server mainline, client mainline, implementation object, and an Ant build file.
Add business logic and run.

What others are saying about ESB

That is a piece of SOA infrastructure, which is this huge thing that many vendors are so busy to build up products for.

What others are saying about SOA

Abstract interfaces through WSDL.

Bound to implementation code.

Loosely coupled.

Top down.

It's nothing new. (Only the WSDL and SOAP part is new.)

QoS's, a.k.a. WS-*, are going to save us.

WS-Angst, WS-DeathStar.

The only thing that's different this time is that all the big vendors are on board. When was the last time you saw Microsoft and IBM coorporate at this level?

Uh, that would be OS/2.

It's a waste of time. Everything you need is in HTTP.

I visited XYZ corporation and discovered that they have been doing SOA for 20 years. It's just that they don't know it by that name yet. They are sending bare data packets using UDP

Weiqi is done. First person is me now.

(In case you haven't noticed, I am Weiqi. Since it is quite hard to do a live blog of a talk while you yourself are talking, this live blog has been prepared ahead of time, which probably should disqualify it as a live blog. However I'll keep calling it live in the same spirit NBC Sports call its Olympic coverage live.)

Playing With Celtix 1.0---Pre-first Impressions

Wed, 10 May 2006 16:38:10 GMT

I'm doing some research into SOA now. And yesterday's release of Celtix 1.0 is just in time for me to have a hands on look at an ESB.

I have yet come to any conclusions about the topics at hand. However, I do want to praise the Celtix folks for the manner in which they packaged their product and the way in which they wrote the documentations.

I know this is all peripheral, however I have seen enough Java projects that are badly packaged and documented that seeing one Java project packaged right makes me want to write about it. I wish more Java open source projects are like this.

First of all, the download comes in a jar file, which, when run, extracts its content into a single directory named after the project.

The content of the directory has a sane structure that's familiar to many developers:

[weiqi@gao] $ ls celtix
3party-licenses.txt*  NOTICE*      bin/   etc/  resources/
LICENSE-EPL.txt*      README.txt*  docs/  lib/  samples/

The documentation matches the product. When it says to go to such-and-such directory and execute such-and-such command, the directory is there and the command executes fine mostly with expected results. I can't tell you how many times this is not the case with other open source products (makes me want to pull my hairs out).
The environment variable settings are spelled out and no guess work is required.
There is a prerequisite section in the installation guide that is actually accurate.
There are only two prerequisites: the JDK and optionally Ant.
The tools are provided in both command line versions and Ant tasks.
An abundance of many independent sample programs, each with a build.xml file with a few sensible targets. There is a README.txt in each sample program directory with no-nonsense instructions. For example
```
From the samples/hello_world directory, the ant build script
can be used to build and run the demo.

Using either UNIX or Windows:

  ant build
  ant server
  ant client
```
And most of the samples (all but the one that demonstrates .NET integration) work out of the box as one would expect. To top it off, the Ant scripts work under Cygwin, which is something that I can't say about the also recently released JBoss WS 1.0.0 GA, which I'm also looking at. (I usually don't make too big a noise if something doesn't work in Cygwin. I just open a Windows command shell and go on. The JBoss WS samples do compile fine there.)

Weiqi Gao's Observations - celtix tag