Reggie is Sun's sample implementation of the core service in Jini, the
service registrar. We can be short about it, because its behavior is
fully described by the interface definitions in the Jini standard: it
registers services, removes registrations when leases expire, and performs
the multicast protocols so that it can be found.
Like the RMID, Reggie uses a log file (in the sense of a transaction log) that
keeps the state between invocations. If you start Reggie as an activatable
service (the default and documented way), you don't need to restart Reggie
anymore unless you remove either one of the RMID or Reggie log directories.
The transaction manager that Sun implemented is called Mahalo. It implements
the Jini TransactionManager interface but not the NestableTransactionManager
interface because it doesn't support nested transactions. It reuses the code
in Reggie to write transaction states to disk, so that transactions survive
crashes and subsequent restarts.
There is no hard evidence that Mahalo is a high-performance transaction
manager, and the Jini team certainly didn't make performance their primary
aim. However, there is anecdotical evidence that Mahalo holds up well in
transaction processing intensive environments, and as it seems a very stable
product there's nothing against starting projects with the relatively
light-weight Jini transaction specification.
Mahalo is an activatable service, so as long as you keep its log directory and
RMID's log directory in tact, you don't need to restart it.
Outrigger implements the JavaSpaces specification. There are two ways to start
it: either as a "transient" space or as a "persistent" space. Persistent
spaces are useful for mini-databases, but updating the storage slows it down
and as they run as activativatable services, they're a bit harder to start.
Transient spaces are useful if the results of a crash aren't devastating (the
contents of the spaces can be restored some other way) and performance is a