Serverless JMS
An implementation using JGroups
Project Charter
Project Goal
The project's goal is to produce a JMS 1.1 compliant implementation,
based on the JGroups toolkit for reliable multicast communication. The
First Phase of the project is estimated to take approximately two
months,
time that should be sufficient to address the first three major
technical objectives, listed below (implementation of the JMS Common
Interfaces, Persistence
and Transactional Support). Depending on the actual schedule,
additional issues such as Message Selectors, JCA could be addressed.
The result of the First Phase is a standalone implementation of
JMS.
Should the benchmarks and performance evaluations applied to the First
Phase final release lead to the conclusion that the release is a good
candidate for production use, a Second Phase of the project will map a
plan towards total JMS 1.1 compliance and production quality code.
During the current stage of the project, however, the emphasis will be
placed not so much on the performance but on code clarity and
design pattern use. I plan on using liberal quantities of regression
tests, to insure that further refactoring and performance enhancements
preserve the compliance with the specifications.
Technical Objectives
1. Implementation of the JMS
1.1
Common Interfaces. The JMS domain-independent interfaces
support both Point-To-Point and Publish/Subscribe messaging domain.
JMS 1.1 specification recommends that clients should use with priority
the "Common Interfaces". These will be first to be supported. If the
need arises, the domain-specific interfaces will be supported in future
releases.
As part of the implementation of JMS Common Interfaces, an
way to declare JMS Administered Objects
(ConnectionFactories and Destinations) should be defined. The clients
must be able to look-up these objects via JNDI, according to JMS
specifications.
2. Implementation of Persistence
Support. JMS provides for persistence in two cases: persistent
subscribers and persistent message delivery mode. Gradual
support for persistence will be added in successive releases. The
simplest implementation won't support any kind of persistence, the
final release should support both persistent subscriptions and message
delivery mode.
3. Implementation of Transactional
Support. A session may optionally be specified as transacted.
Transaction support will be gradually added during the course of the
project. The simplest implementation
won't support transactions.
4. Investigation of various other JMS topics, such as message
selectors, authentication and integration with an application server
(JBoss) using JCA. At the moment of the writing, the knowledge on these
subjects is rather limited, but that will change as the project
progresses.
Proposed Schedule
1. Getting up to speed with JMS
Duration: 1 week, ends Jan 26th.
- Study JMS 1.1 Specifications and other available JMS
documentation.
- Download, install and experiment with the Sun Microsystems' JMS
reference implementation and current JBoss JMS implementation.
- Other prototyping work.
- Sketch the main design ideas.
- Setup the repository and check-in/check-out procedures, access
rights and the associated project logistics.
Deliverables: an operational project repository.
2. JMS Provider Design
Duration: 2 weeks, ends Feb. 9th.
At this stage I should be familiar
enough with the JMS details to be able
to produce the overall design. During the design phase, Bela's
involvement and support, as the JGroups expert, is essential. He will
actively take part to, and supervise, the design.
Some implementation tasks will start in parallel, but the formal design
phase
should take around two weeks.
After this phase, the overall design of the provider should be
reasonably well defined and a snapshot of it should be available in a
design document. I am thinking about a document no longer than several
pages. This is the only document that will be kept in sync, should
major
design changes occur in the next stages.
The advantage of having such a document is that provides the base for
future
user documentation.
Deliverables: A design document (no more than four-five pages of HTML
text and graphics)
3. Implementation of a simple
Publish/Subscribe provider
Duration: 2 weeks, ends Feb. 23rd.
- Implement the Common Interfaces to support the
Publish/Subscribe domain. This is the first choice since topics map
most
naturally over JGroups architecture.
- Provide Pub/Sub implementations for ConnectionFactory,
Connection, Destination, and Session.
- At this stage is not very clear yet if the code client code will
have to explicitely instantate ConnectionFactories and
Topics or they will be available through JNDI.
- Basic message delivery should be functional. The sessions are
non-transacted and support only NON_PERSISTENT delivery.
- The only available message acknowledgment mode will be
CLIENT_ACKNOWLEDGE.
- Provide support for all JMS Message types.
At the end of this stage, the
infrastructure should be mature enough to test most of
the design concepts and start applying performance tests.
Deliverables: release 0.1. It includes the features presented above
plus unit tests.
4. PTP Support, Persistent Subscribers
Duration: 1 week, ends Mar 1st.
- Add PTP support (implementation of a Queue).
- Add support for persistent topic subscribers. Different
persistence mechanisms should be investigated at this time, ranging
from the simplest, (flat file storage), to independent JDBC access.
Most likely the first release that supports persistence will do it so
by using a very simple mechanism (flat files).
Deliverables: release 0.2. It includes the features presented above
plus unit tests.
5. PERSISTENT Delivery Mode and
Transactional support
Duration: 2 weeks, ends Mar 15th.
- Add support for PERSISTENT delivery.
- Implement transacted sessions.
- Add support for the rest of the message acknowledgment modes.
Deliverables: release 0.3. It includes the features presented above
plus unit tests.
6. Release
1.0
Duration: 1 week, ends Mar
22nd.
- Wrap up the project.
- Run Benchmarks.
- Run stress tests.
- Re-plan Task 7 (if necessary).
Deliverable: The release that addresses the main Technical Objectives.
The
release includes unit tests.
7. Extra JMS topics; plan for the
future development
Duration: 1 week, ends Mar 29th.
- Investigation of topics such as Message Selectors, authentication
and JCA integration in JBoss.
- Preparation of the Second Phase (if it is the case).
Resources
Ovidiu Feodorov - part time availability, design and implementation.
The above schedule is still subject to actual availability.
Bela Ban - part time availability, design and JGroups expert support.
$Date: 2004/03/02 19:30:59 $
$Revision: 1.1.1.1 $
$Author: ovidiu $