State of the Project

[Dain Sundstrom]

The first month of our project has seen a deluge of volunteers, email 
and code.  Indeed, for the first few days we had so many volunteers 
that it was almost impossible to keep up with the influx.  Many of the 
initial volunteers stuck around and are actively participating.  The 
email volume of the last month is shocking.  We have had over three 
thousand messages on the list, and for the first few days we were 
getting hundreds of emails a day.  The volume has settled down to a 
much more manageable level, and the discussions have improved as a 
result.  It has been amazing to see the small code seed we started with 
grow into a two and a half megabyte source bundle.  Even with this 
massive growth, the code base has remained stable (the build has only 
been broken a few times).

Given these signs, we declare the state of the project to be healthy 
and vibrant.

The momentum of the project is huge, and it appears we have reached the 
critical mass required for a success. However, we have some challenges 
to overcome.  One of these is the nature of discussions on the mailing 
list - we have had many bike shed type discussions thrashing minute 
details to death but choking out larger topics.  In some cases, this 
has resulted in contributors collaborating offline and major changes 
happening with little public discussion.  This issue is gradually 
working itself out, but we all need to be aware of this tendency and 
work to keep discussions on the list more focused.

Another challenge facing us is how to grow the committer base.  There 
is some perception of a cathedral clique of insiders, whereas in 
reality, many of the project management issues have arisen because the 
current committers are not used to working together and are new to the 
Apache Way.  With the initial startup phase behind us, we will be 
looking to expand the project rapidly over the next couple of months.


Geronimo is a complex project with many collaborating subsystems and 
significant progress has been made in many areas.

BUILD SYSTEM
Our build system came together surprisingly quickly.  We have support 
for multiple modules and an amazing auto-generated web site from maven. 
 Jason Dillon is currently working out the structure of our final 
build, and Dain Sundstrom and David Blevins will be setting up an 
integration testing system next week.

SPECIFICATION APIs
Some of the least exciting but most critical work has been the 
provision of unencumbered versions of the specification APIs. Credit 
goes to Maas van den Berg and Aaron Mulder for much of this work, with 
a special mention of Alex Blewitt for diligently building out the 
JavaMail API which contains substantial concrete implementation.

SERVICE FOUNDATION
Using JMX as a kernel technology has facilitated the manageability of 
the system.  A GeronimoMBean has been added, intended to be the basis 
for other services in Geronimo.  This MBean provides support for 
multiple managed objects and implements the managed object, state 
manageable and event provider interfaces from the J2EE Management 
specification.  Dain Sundstrom will be adding persistence capability, 
allowing the server configuration to be preserved between restarts.

CONSOLE
A console subsystem is in progress with web and command-line based 
interfaces under development by N. Alex Rupp and Matt Kurjanowicz.  
There are also plans for a GUI console once a common structure has been 
determined.

DEPLOYMENT
A common deployment architecture has been defined, supporting local and 
remote modules, dependencies between deployed components, and pluggable 
deployment strategies. Currently deployment is provided for service 
archives containing MBeans; support will be added soon for Web, EJB and 
Connector modules. Scanners have been implemented for both local and 
remote (WebDAV) filesystems.

REMOTING
Hiram Chirino has implemented a remoting framework for routing 
invocation requests both within and between VMs, freeing containers 
from the need to handle wire protocols and failover.  The current code 
supports both synchronous and asynchronous communication and is built 
on NIO.  Future work will add IIOP support using the simple RMI/IIOP 
ORB, allowing us to meet the requirements of the J2EE specification.

METADATA
We have defined a format for Geronimo-specific deployment descriptors 
and have added a basic object model for representing them in memory. A 
simple loader is in place based on Xerces and DOM, and investigation is 
proceeding into more effective XML binding based on the XMLBeans 
project. Aaron Mulder has been responsible for much of the initial 
implementation, and he is continuing work on J2EE Deployment (JSR 88) 
and Validation.

CLIENT CONTAINER
Jeremy Boynes has implemented an Application Client Container as a 
starting point for enterprise container functionality.  This includes a 
simple implementation of the java:comp Environment Naming Context with 
support for env-entry and ejb-ref elements.  Basic interoperability 
with external J2EE servers has been tested and full support will come 
with the introduction of IIOP remoting.

SECURITY
A start has been made on security by David Blevins and Alan Cabrera in 
the form of a JACC (JSR 115) implementation which, combined with JAAS, 
will provide a pluggable authentication and authorization framework.


With many of the basic services now in place, we expect to start work 
soon on the EJB containers and hopefully will have Session and BMP 
Entity support available within the next month.

In other areas, co-ordination has started with the OpenJMS and LDAPd 
projects to facilitate the integration of technology, and discussion 
has started with ObjectWeb to allow the sharing of technology between 
the two projects.

This has been a phenomenal first month in which huge progress has been 
made. Much of the technical groundwork has now been laid and we can 
look forward to the challenges of the EJB and Connector subsystems.

The Geronimo Project